basic trajectory plotting

3 files changed, 13007 insertions, 0 deletions

diff --git a/mathjs/mathjs-expression-parser.js b/mathjs/mathjs-expression-parser.js
new file mode 100644
index 0000000..4d521b9
--- /dev/null
+++ b/mathjs/mathjs-expression-parser.js
@@ -0,0 +1,13005 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.math = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+// Load the math.js core
+var core = require('mathjs/core');
+
+// Create a new, empty math.js instance
+// It will only contain methods `import` and `config`
+var math = core.create();
+
+math.import(require('mathjs/lib/expression/function/parse'));
+math.import(require('mathjs/lib/expression/function/compile'));
+math.import(require('mathjs/lib/expression/function/eval'));
+
+math.import(require('mathjs/lib/function/string/format'));
+
+// create simple functions for all operators
+math.import({
+  // arithmetic
+  add:        function (a, b) { return a + b },
+  subtract:   function (a, b) { return a - b },
+  multiply:   function (a, b) { return a * b },
+  divide:     function (a, b) { return a / b },
+  mod:        function (a, b) { return a % b },
+  unaryPlus:  function (a) { return  a },
+  unaryMinus: function (a) { return -a },
+
+  // bitwise
+  bitOr:           function (a, b) { return a | b },
+  bitXor:          function (a, b) { return a ^ b },
+  bitAnd:          function (a, b) { return a & b },
+  bitNot:          function (a) { return ~a },
+  leftShift:       function (a, b) { return a << b },
+  rightArithShift: function (a, b) { return a >> b },
+  rightLogShift:   function (a, b) { return a >>> b },
+
+  // logical
+  or:  function (a, b) { return !!(a || b) },
+  xor: function (a, b) { return !!a !== !!b },
+  and: function (a, b) { return !!(a && b) },
+  not: function (a) { return !a },
+
+  // relational
+  equal:     function (a, b) { return a == b },
+  unequal:   function (a, b) { return a != b },
+  smaller:   function (a, b) { return a < b },
+  larger:    function (a, b) { return a > b },
+  smallerEq: function (a, b) { return a <= b },
+  largerEq:  function (a, b) { return a >= b },
+
+  // matrix
+  // matrix: function (a) { return a },
+  matrix: function () { 
+    throw new Error('Matrices not supported')
+  },
+  index: function () {
+    // TODO: create a simple index function
+    throw new Error('Matrix indexes not supported')
+  },
+
+  // add pi and e as lowercase
+  pi: Math.PI,
+  e: Math.E,
+  'true': true,
+  'false': false,
+  'null': null
+})
+
+// import everything from Math (like trigonometric functions)
+var allFromMath = {};
+Object.getOwnPropertyNames(Math).forEach(function (name) {
+  // filter out stuff like Firefox's "toSource" method.
+  if (!Object.prototype.hasOwnProperty(name)) {
+    allFromMath[name] = Math[name];
+  }
+});
+math.import(allFromMath);
+
+module.exports = math;
+
+},{"mathjs/core":3,"mathjs/lib/expression/function/compile":11,"mathjs/lib/expression/function/eval":12,"mathjs/lib/expression/function/parse":13,"mathjs/lib/function/string/format":37}],2:[function(require,module,exports){
+"use strict";
+
+// Map the characters to escape to their escaped values. The list is derived
+// from http://www.cespedes.org/blog/85/how-to-escape-latex-special-characters
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var defaultEscapes = {
+  "{": "\\{",
+  "}": "\\}",
+  "\\": "\\textbackslash{}",
+  "#": "\\#",
+  $: "\\$",
+  "%": "\\%",
+  "&": "\\&",
+  "^": "\\textasciicircum{}",
+  _: "\\_",
+  "~": "\\textasciitilde{}"
+};
+var formatEscapes = {
+  "\u2013": "\\--",
+  "\u2014": "\\---",
+  " ": "~",
+  "\t": "\\qquad{}",
+  "\r\n": "\\newline{}",
+  "\n": "\\newline{}"
+};
+
+var defaultEscapeMapFn = function defaultEscapeMapFn(defaultEscapes, formatEscapes) {
+  return _extends({}, defaultEscapes, formatEscapes);
+};
+
+/**
+ * Escape a string to be used in LaTeX documents.
+ * @param {string} str the string to be escaped.
+ * @param {boolean} params.preserveFormatting whether formatting escapes should
+ *  be performed (default: false).
+ * @param {function} params.escapeMapFn the function to modify the escape maps.
+ * @return {string} the escaped string, ready to be used in LaTeX.
+ */
+module.exports = function (str) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      _ref$preserveFormatti = _ref.preserveFormatting,
+      preserveFormatting = _ref$preserveFormatti === undefined ? false : _ref$preserveFormatti,
+      _ref$escapeMapFn = _ref.escapeMapFn,
+      escapeMapFn = _ref$escapeMapFn === undefined ? defaultEscapeMapFn : _ref$escapeMapFn;
+
+  var runningStr = String(str);
+  var result = "";
+
+  var escapes = escapeMapFn(_extends({}, defaultEscapes), preserveFormatting ? _extends({}, formatEscapes) : {});
+  var escapeKeys = Object.keys(escapes); // as it is reused later on
+
+  // Algorithm: Go through the string character by character, if it matches
+  // with one of the special characters then we'll replace it with the escaped
+  // version.
+
+  var _loop = function _loop() {
+    var specialCharFound = false;
+    escapeKeys.forEach(function (key, index) {
+      if (specialCharFound) {
+        return;
+      }
+      if (runningStr.length >= key.length && runningStr.slice(0, key.length) === key) {
+        result += escapes[escapeKeys[index]];
+        runningStr = runningStr.slice(key.length, runningStr.length);
+        specialCharFound = true;
+      }
+    });
+    if (!specialCharFound) {
+      result += runningStr.slice(0, 1);
+      runningStr = runningStr.slice(1, runningStr.length);
+    }
+  };
+
+  while (runningStr) {
+    _loop();
+  }
+  return result;
+};
+},{}],3:[function(require,module,exports){
+module.exports = require('./lib/core/core')
+
+},{"./lib/core/core":4}],4:[function(require,module,exports){
+'use strict';
+
+require('./../utils/polyfills');
+
+var isFactory = require('./../utils/object').isFactory;
+
+var typedFactory = require('./typed');
+
+var emitter = require('./../utils/emitter');
+
+var importFactory = require('./function/import');
+
+var configFactory = require('./function/config');
+/**
+ * Math.js core. Creates a new, empty math.js instance
+ * @param {Object} [options] Available options:
+ *                            {number} epsilon
+ *                              Minimum relative difference between two
+ *                              compared values, used by all comparison functions.
+ *                            {string} matrix
+ *                              A string 'Matrix' (default) or 'Array'.
+ *                            {string} number
+ *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+ *                            {number} precision
+ *                              The number of significant digits for BigNumbers.
+ *                              Not applicable for Numbers.
+ *                            {boolean} predictable
+ *                              Predictable output type of functions. When true,
+ *                              output type depends only on the input types. When
+ *                              false (default), output type can vary depending
+ *                              on input values. For example `math.sqrt(-4)`
+ *                              returns `complex('2i')` when predictable is false, and
+ *                              returns `NaN` when true.
+ *                            {string} randomSeed
+ *                              Random seed for seeded pseudo random number generator.
+ *                              Set to null to randomly seed.
+ * @returns {Object} Returns a bare-bone math.js instance containing
+ *                   functions:
+ *                   - `import` to add new functions
+ *                   - `config` to change configuration
+ *                   - `on`, `off`, `once`, `emit` for events
+ */
+
+
+exports.create = function create(options) {
+  // simple test for ES5 support
+  if (typeof Object.create !== 'function') {
+    throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.');
+  } // cached factories and instances
+
+
+  var factories = [];
+  var instances = []; // create a namespace for the mathjs instance, and attach emitter functions
+
+  var math = emitter.mixin({});
+  math.type = {};
+  math.expression = {
+    transform: {},
+    mathWithTransform: {} // create a new typed instance
+
+  };
+  math.typed = typedFactory.create(math.type); // create configuration options. These are private
+
+  var _config = {
+    // minimum relative difference between two compared values,
+    // used by all comparison functions
+    epsilon: 1e-12,
+    // type of default matrix output. Choose 'matrix' (default) or 'array'
+    matrix: 'Matrix',
+    // type of default number output. Choose 'number' (default) 'BigNumber', or 'Fraction
+    number: 'number',
+    // number of significant digits in BigNumbers
+    precision: 64,
+    // predictable output type of functions. When true, output type depends only
+    // on the input types. When false (default), output type can vary depending
+    // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
+    // predictable is false, and returns `NaN` when true.
+    predictable: false,
+    // random seed for seeded pseudo random number generation
+    // null = randomly seed
+    randomSeed: null
+    /**
+     * Load a function or data type from a factory.
+     * If the function or data type already exists, the existing instance is
+     * returned.
+     * @param {{type: string, name: string, factory: Function}} factory
+     * @returns {*}
+     */
+
+  };
+
+  function load(factory) {
+    if (!isFactory(factory)) {
+      throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
+    }
+
+    var index = factories.indexOf(factory);
+    var instance;
+
+    if (index === -1) {
+      // doesn't yet exist
+      if (factory.math === true) {
+        // pass with math namespace
+        instance = factory.factory(math.type, _config, load, math.typed, math);
+      } else {
+        instance = factory.factory(math.type, _config, load, math.typed);
+      } // append to the cache
+
+
+      factories.push(factory);
+      instances.push(instance);
+    } else {
+      // already existing function, return the cached instance
+      instance = instances[index];
+    }
+
+    return instance;
+  } // load the import and config functions
+
+
+  math['import'] = load(importFactory);
+  math['config'] = load(configFactory);
+  math.expression.mathWithTransform['config'] = math['config']; // apply options
+
+  if (options) {
+    math.config(options);
+  }
+
+  return math;
+};
+},{"./../utils/emitter":52,"./../utils/object":55,"./../utils/polyfills":56,"./function/config":5,"./function/import":6,"./typed":7}],5:[function(require,module,exports){
+'use strict';
+
+var object = require('../../utils/object');
+
+function factory(type, config, load, typed, math) {
+  var MATRIX = ['Matrix', 'Array']; // valid values for option matrix
+
+  var NUMBER = ['number', 'BigNumber', 'Fraction']; // valid values for option number
+
+  /**
+   * Set configuration options for math.js, and get current options.
+   * Will emit a 'config' event, with arguments (curr, prev, changes).
+   *
+   * Syntax:
+   *
+   *     math.config(config: Object): Object
+   *
+   * Examples:
+   *
+   *     math.config().number                // outputs 'number'
+   *     math.eval('0.4')                    // outputs number 0.4
+   *     math.config({number: 'Fraction'})
+   *     math.eval('0.4')                    // outputs Fraction 2/5
+   *
+   * @param {Object} [options] Available options:
+   *                            {number} epsilon
+   *                              Minimum relative difference between two
+   *                              compared values, used by all comparison functions.
+   *                            {string} matrix
+   *                              A string 'Matrix' (default) or 'Array'.
+   *                            {string} number
+   *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+   *                            {number} precision
+   *                              The number of significant digits for BigNumbers.
+   *                              Not applicable for Numbers.
+   *                            {string} parenthesis
+   *                              How to display parentheses in LaTeX and string
+   *                              output.
+   *                            {string} randomSeed
+   *                              Random seed for seeded pseudo random number generator.
+   *                              Set to null to randomly seed.
+   * @return {Object} Returns the current configuration
+   */
+
+  function _config(options) {
+    if (options) {
+      var prev = object.map(config, object.clone); // validate some of the options
+
+      validateOption(options, 'matrix', MATRIX);
+      validateOption(options, 'number', NUMBER); // merge options
+
+      object.deepExtend(config, options);
+      var curr = object.map(config, object.clone);
+      var changes = object.map(options, object.clone); // emit 'config' event
+
+      math.emit('config', curr, prev, changes);
+      return curr;
+    } else {
+      return object.map(config, object.clone);
+    }
+  } // attach the valid options to the function so they can be extended
+
+
+  _config.MATRIX = MATRIX;
+  _config.NUMBER = NUMBER;
+  return _config;
+}
+/**
+ * Test whether an Array contains a specific item.
+ * @param {Array.<string>} array
+ * @param {string} item
+ * @return {boolean}
+ */
+
+
+function contains(array, item) {
+  return array.indexOf(item) !== -1;
+}
+/**
+ * Find a string in an array. Case insensitive search
+ * @param {Array.<string>} array
+ * @param {string} item
+ * @return {number} Returns the index when found. Returns -1 when not found
+ */
+
+
+function findIndex(array, item) {
+  return array.map(function (i) {
+    return i.toLowerCase();
+  }).indexOf(item.toLowerCase());
+}
+/**
+ * Validate an option
+ * @param {Object} options         Object with options
+ * @param {string} name            Name of the option to validate
+ * @param {Array.<string>} values  Array with valid values for this option
+ */
+
+
+function validateOption(options, name, values) {
+  if (options[name] !== undefined && !contains(values, options[name])) {
+    var index = findIndex(values, options[name]);
+
+    if (index !== -1) {
+      // right value, wrong casing
+      // TODO: lower case values are deprecated since v3, remove this warning some day.
+      console.warn('Warning: Wrong casing for configuration option "' + name + '", should be "' + values[index] + '" instead of "' + options[name] + '".');
+      options[name] = values[index]; // change the option to the right casing
+    } else {
+      // unknown value
+      console.warn('Warning: Unknown value "' + options[name] + '" for configuration option "' + name + '". Available options: ' + values.map(JSON.stringify).join(', ') + '.');
+    }
+  }
+}
+
+exports.name = 'config';
+exports.math = true; // request the math namespace as fifth argument
+
+exports.factory = factory;
+},{"../../utils/object":55}],6:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var lazy = require('../../utils/object').lazy;
+
+var isFactory = require('../../utils/object').isFactory;
+
+var traverse = require('../../utils/object').traverse;
+
+var ArgumentsError = require('../../error/ArgumentsError');
+
+function factory(type, config, load, typed, math) {
+  /**
+   * Import functions from an object or a module
+   *
+   * Syntax:
+   *
+   *    math.import(object)
+   *    math.import(object, options)
+   *
+   * Where:
+   *
+   * - `object: Object`
+   *   An object with functions to be imported.
+   * - `options: Object` An object with import options. Available options:
+   *   - `override: boolean`
+   *     If true, existing functions will be overwritten. False by default.
+   *   - `silent: boolean`
+   *     If true, the function will not throw errors on duplicates or invalid
+   *     types. False by default.
+   *   - `wrap: boolean`
+   *     If true, the functions will be wrapped in a wrapper function
+   *     which converts data types like Matrix to primitive data types like Array.
+   *     The wrapper is needed when extending math.js with libraries which do not
+   *     support these data type. False by default.
+   *
+   * Examples:
+   *
+   *    // define new functions and variables
+   *    math.import({
+   *      myvalue: 42,
+   *      hello: function (name) {
+   *        return 'hello, ' + name + '!'
+   *      }
+   *    })
+   *
+   *    // use the imported function and variable
+   *    math.myvalue * 2               // 84
+   *    math.hello('user')             // 'hello, user!'
+   *
+   *    // import the npm module 'numbers'
+   *    // (must be installed first with `npm install numbers`)
+   *    math.import(require('numbers'), {wrap: true})
+   *
+   *    math.fibonacci(7) // returns 13
+   *
+   * @param {Object | Array} object   Object with functions to be imported.
+   * @param {Object} [options]        Import options.
+   */
+  function mathImport(object, options) {
+    var num = arguments.length;
+
+    if (num !== 1 && num !== 2) {
+      throw new ArgumentsError('import', num, 1, 2);
+    }
+
+    if (!options) {
+      options = {};
+    } // TODO: allow a typed-function with name too
+
+
+    if (isFactory(object)) {
+      _importFactory(object, options);
+    } else if (Array.isArray(object)) {
+      object.forEach(function (entry) {
+        mathImport(entry, options);
+      });
+    } else if (_typeof(object) === 'object') {
+      // a map with functions
+      for (var name in object) {
+        if (object.hasOwnProperty(name)) {
+          var value = object[name];
+
+          if (isSupportedType(value)) {
+            _import(name, value, options);
+          } else if (isFactory(object)) {
+            _importFactory(object, options);
+          } else {
+            mathImport(value, options);
+          }
+        }
+      }
+    } else {
+      if (!options.silent) {
+        throw new TypeError('Factory, Object, or Array expected');
+      }
+    }
+  }
+  /**
+   * Add a property to the math namespace and create a chain proxy for it.
+   * @param {string} name
+   * @param {*} value
+   * @param {Object} options  See import for a description of the options
+   * @private
+   */
+
+
+  function _import(name, value, options) {
+    // TODO: refactor this function, it's to complicated and contains duplicate code
+    if (options.wrap && typeof value === 'function') {
+      // create a wrapper around the function
+      value = _wrap(value);
+    }
+
+    if (isTypedFunction(math[name]) && isTypedFunction(value)) {
+      if (options.override) {
+        // give the typed function the right name
+        value = typed(name, value.signatures);
+      } else {
+        // merge the existing and typed function
+        value = typed(math[name], value);
+      }
+
+      math[name] = value;
+
+      _importTransform(name, value);
+
+      math.emit('import', name, function resolver() {
+        return value;
+      });
+      return;
+    }
+
+    if (math[name] === undefined || options.override) {
+      math[name] = value;
+
+      _importTransform(name, value);
+
+      math.emit('import', name, function resolver() {
+        return value;
+      });
+      return;
+    }
+
+    if (!options.silent) {
+      throw new Error('Cannot import "' + name + '": already exists');
+    }
+  }
+
+  function _importTransform(name, value) {
+    if (value && typeof value.transform === 'function') {
+      math.expression.transform[name] = value.transform;
+
+      if (allowedInExpressions(name)) {
+        math.expression.mathWithTransform[name] = value.transform;
+      }
+    } else {
+      // remove existing transform
+      delete math.expression.transform[name];
+
+      if (allowedInExpressions(name)) {
+        math.expression.mathWithTransform[name] = value;
+      }
+    }
+  }
+
+  function _deleteTransform(name) {
+    delete math.expression.transform[name];
+
+    if (allowedInExpressions(name)) {
+      math.expression.mathWithTransform[name] = math[name];
+    } else {
+      delete math.expression.mathWithTransform[name];
+    }
+  }
+  /**
+   * Create a wrapper a round an function which converts the arguments
+   * to their primitive values (like convert a Matrix to Array)
+   * @param {Function} fn
+   * @return {Function} Returns the wrapped function
+   * @private
+   */
+
+
+  function _wrap(fn) {
+    var wrapper = function wrapper() {
+      var args = [];
+
+      for (var i = 0, len = arguments.length; i < len; i++) {
+        var arg = arguments[i];
+        args[i] = arg && arg.valueOf();
+      }
+
+      return fn.apply(math, args);
+    };
+
+    if (fn.transform) {
+      wrapper.transform = fn.transform;
+    }
+
+    return wrapper;
+  }
+  /**
+   * Import an instance of a factory into math.js
+   * @param {{factory: Function, name: string, path: string, math: boolean}} factory
+   * @param {Object} options  See import for a description of the options
+   * @private
+   */
+
+
+  function _importFactory(factory, options) {
+    if (typeof factory.name === 'string') {
+      var name = factory.name;
+      var existingTransform = name in math.expression.transform;
+      var namespace = factory.path ? traverse(math, factory.path) : math;
+      var existing = namespace.hasOwnProperty(name) ? namespace[name] : undefined;
+
+      var resolver = function resolver() {
+        var instance = load(factory);
+
+        if (instance && typeof instance.transform === 'function') {
+          throw new Error('Transforms cannot be attached to factory functions. ' + 'Please create a separate function for it with exports.path="expression.transform"');
+        }
+
+        if (isTypedFunction(existing) && isTypedFunction(instance)) {
+          if (options.override) {// replace the existing typed function (nothing to do)
+          } else {
+            // merge the existing and new typed function
+            instance = typed(existing, instance);
+          }
+
+          return instance;
+        }
+
+        if (existing === undefined || options.override) {
+          return instance;
+        }
+
+        if (!options.silent) {
+          throw new Error('Cannot import "' + name + '": already exists');
+        }
+      };
+
+      if (factory.lazy !== false) {
+        lazy(namespace, name, resolver);
+
+        if (existingTransform) {
+          _deleteTransform(name);
+        } else {
+          if (factory.path === 'expression.transform' || factoryAllowedInExpressions(factory)) {
+            lazy(math.expression.mathWithTransform, name, resolver);
+          }
+        }
+      } else {
+        namespace[name] = resolver();
+
+        if (existingTransform) {
+          _deleteTransform(name);
+        } else {
+          if (factory.path === 'expression.transform' || factoryAllowedInExpressions(factory)) {
+            math.expression.mathWithTransform[name] = resolver();
+          }
+        }
+      }
+
+      math.emit('import', name, resolver, factory.path);
+    } else {
+      // unnamed factory.
+      // no lazy loading
+      load(factory);
+    }
+  }
+  /**
+   * Check whether given object is a type which can be imported
+   * @param {Function | number | string | boolean | null | Unit | Complex} object
+   * @return {boolean}
+   * @private
+   */
+
+
+  function isSupportedType(object) {
+    return typeof object === 'function' || typeof object === 'number' || typeof object === 'string' || typeof object === 'boolean' || object === null || object && type.isUnit(object) || object && type.isComplex(object) || object && type.isBigNumber(object) || object && type.isFraction(object) || object && type.isMatrix(object) || object && Array.isArray(object);
+  }
+  /**
+   * Test whether a given thing is a typed-function
+   * @param {*} fn
+   * @return {boolean} Returns true when `fn` is a typed-function
+   */
+
+
+  function isTypedFunction(fn) {
+    return typeof fn === 'function' && _typeof(fn.signatures) === 'object';
+  }
+
+  function allowedInExpressions(name) {
+    return !unsafe.hasOwnProperty(name);
+  }
+
+  function factoryAllowedInExpressions(factory) {
+    return factory.path === undefined && !unsafe.hasOwnProperty(factory.name);
+  } // namespaces and functions not available in the parser for safety reasons
+
+
+  var unsafe = {
+    'expression': true,
+    'type': true,
+    'docs': true,
+    'error': true,
+    'json': true,
+    'chain': true // chain method not supported. Note that there is a unit chain too.
+
+  };
+  return mathImport;
+}
+
+exports.math = true; // request access to the math namespace as 5th argument of the factory function
+
+exports.name = 'import';
+exports.factory = factory;
+exports.lazy = true;
+},{"../../error/ArgumentsError":8,"../../utils/object":55}],7:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var typedFunction = require('typed-function');
+
+var digits = require('./../utils/number').digits;
+
+var isBigNumber = require('./../utils/bignumber/isBigNumber');
+
+var isMatrix = require('./../utils/collection/isMatrix'); // returns a new instance of typed-function
+
+
+var _createTyped = function createTyped() {
+  // initially, return the original instance of typed-function
+  // consecutively, return a new instance from typed.create.
+  _createTyped = typedFunction.create;
+  return typedFunction;
+};
+/**
+ * Factory function for creating a new typed instance
+ * @param {Object} type   Object with data types like Complex and BigNumber
+ * @returns {Function}
+ */
+
+
+exports.create = function create(type) {
+  // TODO: typed-function must be able to silently ignore signatures with unknown data types
+  // type checks for all known types
+  //
+  // note that:
+  //
+  // - check by duck-typing on a property like `isUnit`, instead of checking instanceof.
+  //   instanceof cannot be used because that would not allow to pass data from
+  //   one instance of math.js to another since each has it's own instance of Unit.
+  // - check the `isUnit` property via the constructor, so there will be no
+  //   matches for "fake" instances like plain objects with a property `isUnit`.
+  //   That is important for security reasons.
+  // - It must not be possible to override the type checks used internally,
+  //   for security reasons, so these functions are not exposed in the expression
+  //   parser.
+  type.isNumber = function (x) {
+    return typeof x === 'number';
+  };
+
+  type.isComplex = function (x) {
+    return type.Complex && x instanceof type.Complex || false;
+  };
+
+  type.isBigNumber = isBigNumber;
+
+  type.isFraction = function (x) {
+    return type.Fraction && x instanceof type.Fraction || false;
+  };
+
+  type.isUnit = function (x) {
+    return x && x.constructor.prototype.isUnit || false;
+  };
+
+  type.isString = function (x) {
+    return typeof x === 'string';
+  };
+
+  type.isArray = Array.isArray;
+  type.isMatrix = isMatrix;
+
+  type.isDenseMatrix = function (x) {
+    return x && x.isDenseMatrix && x.constructor.prototype.isMatrix || false;
+  };
+
+  type.isSparseMatrix = function (x) {
+    return x && x.isSparseMatrix && x.constructor.prototype.isMatrix || false;
+  };
+
+  type.isRange = function (x) {
+    return x && x.constructor.prototype.isRange || false;
+  };
+
+  type.isIndex = function (x) {
+    return x && x.constructor.prototype.isIndex || false;
+  };
+
+  type.isBoolean = function (x) {
+    return typeof x === 'boolean';
+  };
+
+  type.isResultSet = function (x) {
+    return x && x.constructor.prototype.isResultSet || false;
+  };
+
+  type.isHelp = function (x) {
+    return x && x.constructor.prototype.isHelp || false;
+  };
+
+  type.isFunction = function (x) {
+    return typeof x === 'function';
+  };
+
+  type.isDate = function (x) {
+    return x instanceof Date;
+  };
+
+  type.isRegExp = function (x) {
+    return x instanceof RegExp;
+  };
+
+  type.isObject = function (x) {
+    return _typeof(x) === 'object' && x.constructor === Object && !type.isComplex(x) && !type.isFraction(x);
+  };
+
+  type.isNull = function (x) {
+    return x === null;
+  };
+
+  type.isUndefined = function (x) {
+    return x === undefined;
+  };
+
+  type.isAccessorNode = function (x) {
+    return x && x.isAccessorNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isArrayNode = function (x) {
+    return x && x.isArrayNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isAssignmentNode = function (x) {
+    return x && x.isAssignmentNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isBlockNode = function (x) {
+    return x && x.isBlockNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isConditionalNode = function (x) {
+    return x && x.isConditionalNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isConstantNode = function (x) {
+    return x && x.isConstantNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isFunctionAssignmentNode = function (x) {
+    return x && x.isFunctionAssignmentNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isFunctionNode = function (x) {
+    return x && x.isFunctionNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isIndexNode = function (x) {
+    return x && x.isIndexNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isNode = function (x) {
+    return x && x.isNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isObjectNode = function (x) {
+    return x && x.isObjectNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isOperatorNode = function (x) {
+    return x && x.isOperatorNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isParenthesisNode = function (x) {
+    return x && x.isParenthesisNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isRangeNode = function (x) {
+    return x && x.isRangeNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isSymbolNode = function (x) {
+    return x && x.isSymbolNode && x.constructor.prototype.isNode || false;
+  };
+
+  type.isChain = function (x) {
+    return x && x.constructor.prototype.isChain || false;
+  }; // get a new instance of typed-function
+
+
+  var typed = _createTyped(); // define all types. The order of the types determines in which order function
+  // arguments are type-checked (so for performance it's important to put the
+  // most used types first).
+
+
+  typed.types = [{
+    name: 'number',
+    test: type.isNumber
+  }, {
+    name: 'Complex',
+    test: type.isComplex
+  }, {
+    name: 'BigNumber',
+    test: type.isBigNumber
+  }, {
+    name: 'Fraction',
+    test: type.isFraction
+  }, {
+    name: 'Unit',
+    test: type.isUnit
+  }, {
+    name: 'string',
+    test: type.isString
+  }, {
+    name: 'Array',
+    test: type.isArray
+  }, {
+    name: 'Matrix',
+    test: type.isMatrix
+  }, {
+    name: 'DenseMatrix',
+    test: type.isDenseMatrix
+  }, {
+    name: 'SparseMatrix',
+    test: type.isSparseMatrix
+  }, {
+    name: 'Range',
+    test: type.isRange
+  }, {
+    name: 'Index',
+    test: type.isIndex
+  }, {
+    name: 'boolean',
+    test: type.isBoolean
+  }, {
+    name: 'ResultSet',
+    test: type.isResultSet
+  }, {
+    name: 'Help',
+    test: type.isHelp
+  }, {
+    name: 'function',
+    test: type.isFunction
+  }, {
+    name: 'Date',
+    test: type.isDate
+  }, {
+    name: 'RegExp',
+    test: type.isRegExp
+  }, {
+    name: 'null',
+    test: type.isNull
+  }, {
+    name: 'undefined',
+    test: type.isUndefined
+  }, {
+    name: 'OperatorNode',
+    test: type.isOperatorNode
+  }, {
+    name: 'ConstantNode',
+    test: type.isConstantNode
+  }, {
+    name: 'SymbolNode',
+    test: type.isSymbolNode
+  }, {
+    name: 'ParenthesisNode',
+    test: type.isParenthesisNode
+  }, {
+    name: 'FunctionNode',
+    test: type.isFunctionNode
+  }, {
+    name: 'FunctionAssignmentNode',
+    test: type.isFunctionAssignmentNode
+  }, {
+    name: 'ArrayNode',
+    test: type.isArrayNode
+  }, {
+    name: 'AssignmentNode',
+    test: type.isAssignmentNode
+  }, {
+    name: 'BlockNode',
+    test: type.isBlockNode
+  }, {
+    name: 'ConditionalNode',
+    test: type.isConditionalNode
+  }, {
+    name: 'IndexNode',
+    test: type.isIndexNode
+  }, {
+    name: 'RangeNode',
+    test: type.isRangeNode
+  }, {
+    name: 'Node',
+    test: type.isNode
+  }, {
+    name: 'Object',
+    test: type.isObject // order 'Object' last, it matches on other classes too
+
+  }]; // TODO: add conversion from BigNumber to number?
+
+  typed.conversions = [{
+    from: 'number',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      // note: conversion from number to BigNumber can fail if x has >15 digits
+      if (digits(x) > 15) {
+        throw new TypeError('Cannot implicitly convert a number with >15 significant digits to BigNumber ' + '(value: ' + x + '). ' + 'Use function bignumber(x) to convert to BigNumber.');
+      }
+
+      return new type.BigNumber(x);
+    }
+  }, {
+    from: 'number',
+    to: 'Complex',
+    convert: function convert(x) {
+      return new type.Complex(x, 0);
+    }
+  }, {
+    from: 'number',
+    to: 'string',
+    convert: function convert(x) {
+      return x + '';
+    }
+  }, {
+    from: 'BigNumber',
+    to: 'Complex',
+    convert: function convert(x) {
+      return new type.Complex(x.toNumber(), 0);
+    }
+  }, {
+    from: 'Fraction',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      throw new TypeError('Cannot implicitly convert a Fraction to BigNumber or vice versa. ' + 'Use function bignumber(x) to convert to BigNumber or fraction(x) to convert to Fraction.');
+    }
+  }, {
+    from: 'Fraction',
+    to: 'Complex',
+    convert: function convert(x) {
+      return new type.Complex(x.valueOf(), 0);
+    }
+  }, {
+    from: 'number',
+    to: 'Fraction',
+    convert: function convert(x) {
+      var f = new type.Fraction(x);
+
+      if (f.valueOf() !== x) {
+        throw new TypeError('Cannot implicitly convert a number to a Fraction when there will be a loss of precision ' + '(value: ' + x + '). ' + 'Use function fraction(x) to convert to Fraction.');
+      }
+
+      return new type.Fraction(x);
+    }
+  }, {
+    // FIXME: add conversion from Fraction to number, for example for `sqrt(fraction(1,3))`
+    //  from: 'Fraction',
+    //  to: 'number',
+    //  convert: function (x) {
+    //    return x.valueOf()
+    //  }
+    // }, {
+    from: 'string',
+    to: 'number',
+    convert: function convert(x) {
+      var n = Number(x);
+
+      if (isNaN(n)) {
+        throw new Error('Cannot convert "' + x + '" to a number');
+      }
+
+      return n;
+    }
+  }, {
+    from: 'string',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      try {
+        return new type.BigNumber(x);
+      } catch (err) {
+        throw new Error('Cannot convert "' + x + '" to BigNumber');
+      }
+    }
+  }, {
+    from: 'string',
+    to: 'Fraction',
+    convert: function convert(x) {
+      try {
+        return new type.Fraction(x);
+      } catch (err) {
+        throw new Error('Cannot convert "' + x + '" to Fraction');
+      }
+    }
+  }, {
+    from: 'string',
+    to: 'Complex',
+    convert: function convert(x) {
+      try {
+        return new type.Complex(x);
+      } catch (err) {
+        throw new Error('Cannot convert "' + x + '" to Complex');
+      }
+    }
+  }, {
+    from: 'boolean',
+    to: 'number',
+    convert: function convert(x) {
+      return +x;
+    }
+  }, {
+    from: 'boolean',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      return new type.BigNumber(+x);
+    }
+  }, {
+    from: 'boolean',
+    to: 'Fraction',
+    convert: function convert(x) {
+      return new type.Fraction(+x);
+    }
+  }, {
+    from: 'boolean',
+    to: 'string',
+    convert: function convert(x) {
+      return +x;
+    }
+  }, {
+    from: 'Array',
+    to: 'Matrix',
+    convert: function convert(array) {
+      return new type.DenseMatrix(array);
+    }
+  }, {
+    from: 'Matrix',
+    to: 'Array',
+    convert: function convert(matrix) {
+      return matrix.valueOf();
+    }
+  }];
+  return typed;
+};
+},{"./../utils/bignumber/isBigNumber":48,"./../utils/collection/isMatrix":50,"./../utils/number":54,"typed-function":59}],8:[function(require,module,exports){
+'use strict';
+/**
+ * Create a syntax error with the message:
+ *     'Wrong number of arguments in function <fn> (<count> provided, <min>-<max> expected)'
+ * @param {string} fn     Function name
+ * @param {number} count  Actual argument count
+ * @param {number} min    Minimum required argument count
+ * @param {number} [max]  Maximum required argument count
+ * @extends Error
+ */
+
+function ArgumentsError(fn, count, min, max) {
+  if (!(this instanceof ArgumentsError)) {
+    throw new SyntaxError('Constructor must be called with the new operator');
+  }
+
+  this.fn = fn;
+  this.count = count;
+  this.min = min;
+  this.max = max;
+  this.message = 'Wrong number of arguments in function ' + fn + ' (' + count + ' provided, ' + min + (max !== undefined && max !== null ? '-' + max : '') + ' expected)';
+  this.stack = new Error().stack;
+}
+
+ArgumentsError.prototype = new Error();
+ArgumentsError.prototype.constructor = Error;
+ArgumentsError.prototype.name = 'ArgumentsError';
+ArgumentsError.prototype.isArgumentsError = true;
+module.exports = ArgumentsError;
+},{}],9:[function(require,module,exports){
+'use strict';
+/**
+ * Create a range error with the message:
+ *     'Dimension mismatch (<actual size> != <expected size>)'
+ * @param {number | number[]} actual        The actual size
+ * @param {number | number[]} expected      The expected size
+ * @param {string} [relation='!=']          Optional relation between actual
+ *                                          and expected size: '!=', '<', etc.
+ * @extends RangeError
+ */
+
+function DimensionError(actual, expected, relation) {
+  if (!(this instanceof DimensionError)) {
+    throw new SyntaxError('Constructor must be called with the new operator');
+  }
+
+  this.actual = actual;
+  this.expected = expected;
+  this.relation = relation;
+  this.message = 'Dimension mismatch (' + (Array.isArray(actual) ? '[' + actual.join(', ') + ']' : actual) + ' ' + (this.relation || '!=') + ' ' + (Array.isArray(expected) ? '[' + expected.join(', ') + ']' : expected) + ')';
+  this.stack = new Error().stack;
+}
+
+DimensionError.prototype = new RangeError();
+DimensionError.prototype.constructor = RangeError;
+DimensionError.prototype.name = 'DimensionError';
+DimensionError.prototype.isDimensionError = true;
+module.exports = DimensionError;
+},{}],10:[function(require,module,exports){
+'use strict';
+/**
+ * Create a range error with the message:
+ *     'Index out of range (index < min)'
+ *     'Index out of range (index < max)'
+ *
+ * @param {number} index     The actual index
+ * @param {number} [min=0]   Minimum index (included)
+ * @param {number} [max]     Maximum index (excluded)
+ * @extends RangeError
+ */
+
+function IndexError(index, min, max) {
+  if (!(this instanceof IndexError)) {
+    throw new SyntaxError('Constructor must be called with the new operator');
+  }
+
+  this.index = index;
+
+  if (arguments.length < 3) {
+    this.min = 0;
+    this.max = min;
+  } else {
+    this.min = min;
+    this.max = max;
+  }
+
+  if (this.min !== undefined && this.index < this.min) {
+    this.message = 'Index out of range (' + this.index + ' < ' + this.min + ')';
+  } else if (this.max !== undefined && this.index >= this.max) {
+    this.message = 'Index out of range (' + this.index + ' > ' + (this.max - 1) + ')';
+  } else {
+    this.message = 'Index out of range (' + this.index + ')';
+  }
+
+  this.stack = new Error().stack;
+}
+
+IndexError.prototype = new RangeError();
+IndexError.prototype.constructor = RangeError;
+IndexError.prototype.name = 'IndexError';
+IndexError.prototype.isIndexError = true;
+module.exports = IndexError;
+},{}],11:[function(require,module,exports){
+'use strict';
+
+var deepMap = require('../../utils/collection/deepMap');
+
+function factory(type, config, load, typed) {
+  var parse = load(require('../parse'));
+  /**
+   * Parse and compile an expression.
+   * Returns a an object with a function `eval([scope])` to evaluate the
+   * compiled expression.
+   *
+   * Syntax:
+   *
+   *     math.compile(expr)                       // returns one node
+   *     math.compile([expr1, expr2, expr3, ...]) // returns an array with nodes
+   *
+   * Examples:
+   *
+   *     const code1 = math.compile('sqrt(3^2 + 4^2)')
+   *     code1.eval() // 5
+   *
+   *     let scope = {a: 3, b: 4}
+   *     const code2 = math.compile('a * b') // 12
+   *     code2.eval(scope) // 12
+   *     scope.a = 5
+   *     code2.eval(scope) // 20
+   *
+   *     const nodes = math.compile(['a = 3', 'b = 4', 'a * b'])
+   *     nodes[2].eval() // 12
+   *
+   * See also:
+   *
+   *    parse, eval
+   *
+   * @param {string | string[] | Array | Matrix} expr
+   *            The expression to be compiled
+   * @return {{eval: Function} | Array.<{eval: Function}>} code
+   *            An object with the compiled expression
+   * @throws {Error}
+   */
+
+  return typed('compile', {
+    'string': function string(expr) {
+      return parse(expr).compile();
+    },
+    'Array | Matrix': function ArrayMatrix(expr) {
+      return deepMap(expr, function (entry) {
+        return parse(entry).compile();
+      });
+    }
+  });
+}
+
+exports.name = 'compile';
+exports.factory = factory;
+},{"../../utils/collection/deepMap":49,"../parse":34}],12:[function(require,module,exports){
+'use strict';
+
+var deepMap = require('../../utils/collection/deepMap');
+
+function factory(type, config, load, typed) {
+  var parse = load(require('../parse'));
+  /**
+   * Evaluate an expression.
+   *
+   * Note the evaluating arbitrary expressions may involve security risks,
+   * see [http://mathjs.org/docs/expressions/security.html](http://mathjs.org/docs/expressions/security.html) for more information.
+   *
+   * Syntax:
+   *
+   *     math.eval(expr)
+   *     math.eval(expr, scope)
+   *     math.eval([expr1, expr2, expr3, ...])
+   *     math.eval([expr1, expr2, expr3, ...], scope)
+   *
+   * Example:
+   *
+   *     math.eval('(2+3)/4')                // 1.25
+   *     math.eval('sqrt(3^2 + 4^2)')        // 5
+   *     math.eval('sqrt(-4)')               // 2i
+   *     math.eval(['a=3', 'b=4', 'a*b'])    // [3, 4, 12]
+   *
+   *     let scope = {a:3, b:4}
+   *     math.eval('a * b', scope)           // 12
+   *
+   * See also:
+   *
+   *    parse, compile
+   *
+   * @param {string | string[] | Matrix} expr   The expression to be evaluated
+   * @param {Object} [scope]                    Scope to read/write variables
+   * @return {*} The result of the expression
+   * @throws {Error}
+   */
+
+  return typed('compile', {
+    'string': function string(expr) {
+      var scope = {};
+      return parse(expr).compile().eval(scope);
+    },
+    'string, Object': function stringObject(expr, scope) {
+      return parse(expr).compile().eval(scope);
+    },
+    'Array | Matrix': function ArrayMatrix(expr) {
+      var scope = {};
+      return deepMap(expr, function (entry) {
+        return parse(entry).compile().eval(scope);
+      });
+    },
+    'Array | Matrix, Object': function ArrayMatrixObject(expr, scope) {
+      return deepMap(expr, function (entry) {
+        return parse(entry).compile().eval(scope);
+      });
+    }
+  });
+}
+
+exports.name = 'eval';
+exports.factory = factory;
+},{"../../utils/collection/deepMap":49,"../parse":34}],13:[function(require,module,exports){
+'use strict';
+
+function factory(type, config, load, typed) {
+  var parse = load(require('../parse'));
+  /**
+   * Parse an expression. Returns a node tree, which can be evaluated by
+   * invoking node.eval().
+   *
+   * Note the evaluating arbitrary expressions may involve security risks,
+   * see [http://mathjs.org/docs/expressions/security.html](http://mathjs.org/docs/expressions/security.html) for more information.
+   *
+   * Syntax:
+   *
+   *     math.parse(expr)
+   *     math.parse(expr, options)
+   *     math.parse([expr1, expr2, expr3, ...])
+   *     math.parse([expr1, expr2, expr3, ...], options)
+   *
+   * Example:
+   *
+   *     const node1 = math.parse('sqrt(3^2 + 4^2)')
+   *     node1.compile().eval() // 5
+   *
+   *     let scope = {a:3, b:4}
+   *     const node2 = math.parse('a * b') // 12
+   *     const code2 = node2.compile()
+   *     code2.eval(scope) // 12
+   *     scope.a = 5
+   *     code2.eval(scope) // 20
+   *
+   *     const nodes = math.parse(['a = 3', 'b = 4', 'a * b'])
+   *     nodes[2].compile().eval() // 12
+   *
+   * See also:
+   *
+   *     eval, compile
+   *
+   * @param {string | string[] | Matrix} expr          Expression to be parsed
+   * @param {{nodes: Object<string, Node>}} [options]  Available options:
+   *                                                   - `nodes` a set of custom nodes
+   * @return {Node | Node[]} node
+   * @throws {Error}
+   */
+
+  return typed('parse', {
+    'string | Array | Matrix': parse,
+    'string | Array | Matrix, Object': parse
+  });
+}
+
+exports.name = 'parse';
+exports.factory = factory;
+},{"../parse":34}],14:[function(require,module,exports){
+'use strict'; // Reserved keywords not allowed to use in the parser
+
+module.exports = {
+  end: true
+};
+},{}],15:[function(require,module,exports){
+'use strict';
+
+var getSafeProperty = require('../../utils/customs').getSafeProperty;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  var access = load(require('./utils/access'));
+  /**
+   * @constructor AccessorNode
+   * @extends {Node}
+   * Access an object property or get a matrix subset
+   *
+   * @param {Node} object                 The object from which to retrieve
+   *                                      a property or subset.
+   * @param {IndexNode} index             IndexNode containing ranges
+   */
+
+  function AccessorNode(object, index) {
+    if (!(this instanceof AccessorNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    if (!type.isNode(object)) {
+      throw new TypeError('Node expected for parameter "object"');
+    }
+
+    if (!type.isIndexNode(index)) {
+      throw new TypeError('IndexNode expected for parameter "index"');
+    }
+
+    this.object = object || null;
+    this.index = index; // readonly property name
+
+    Object.defineProperty(this, 'name', {
+      get: function () {
+        if (this.index) {
+          return this.index.isObjectProperty() ? this.index.getObjectProperty() : '';
+        } else {
+          return this.object.name || '';
+        }
+      }.bind(this),
+      set: function set() {
+        throw new Error('Cannot assign a new name, name is read-only');
+      }
+    });
+  }
+
+  AccessorNode.prototype = new Node();
+  AccessorNode.prototype.type = 'AccessorNode';
+  AccessorNode.prototype.isAccessorNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  AccessorNode.prototype._compile = function (math, argNames) {
+    var evalObject = this.object._compile(math, argNames);
+
+    var evalIndex = this.index._compile(math, argNames);
+
+    if (this.index.isObjectProperty()) {
+      var prop = this.index.getObjectProperty();
+      return function evalAccessorNode(scope, args, context) {
+        return getSafeProperty(evalObject(scope, args, context), prop);
+      };
+    } else {
+      return function evalAccessorNode(scope, args, context) {
+        var object = evalObject(scope, args, context);
+        var index = evalIndex(scope, args, object); // we pass object here instead of context
+
+        return access(object, index);
+      };
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  AccessorNode.prototype.forEach = function (callback) {
+    callback(this.object, 'object', this);
+    callback(this.index, 'index', this);
+  };
+  /**
+   * Create a new AccessorNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {AccessorNode} Returns a transformed copy of the node
+   */
+
+
+  AccessorNode.prototype.map = function (callback) {
+    return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)));
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {AccessorNode}
+   */
+
+
+  AccessorNode.prototype.clone = function () {
+    return new AccessorNode(this.object, this.index);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string}
+   */
+
+
+  AccessorNode.prototype._toString = function (options) {
+    var object = this.object.toString(options);
+
+    if (needParenthesis(this.object)) {
+      object = '(' + object + ')';
+    }
+
+    return object + this.index.toString(options);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string}
+   */
+
+
+  AccessorNode.prototype.toHTML = function (options) {
+    var object = this.object.toHTML(options);
+
+    if (needParenthesis(this.object)) {
+      object = '<span class="math-parenthesis math-round-parenthesis">(</span>' + object + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    return object + this.index.toHTML(options);
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string}
+   */
+
+
+  AccessorNode.prototype._toTex = function (options) {
+    var object = this.object.toTex(options);
+
+    if (needParenthesis(this.object)) {
+      object = "\\left(' + object + '\\right)";
+    }
+
+    return object + this.index.toTex(options);
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  AccessorNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'AccessorNode',
+      object: this.object,
+      index: this.index
+    };
+  };
+  /**
+   * Instantiate an AccessorNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "AccessorNode", object: ..., index: ...}`,
+   *                       where mathjs is optional
+   * @returns {AccessorNode}
+   */
+
+
+  AccessorNode.fromJSON = function (json) {
+    return new AccessorNode(json.object, json.index);
+  };
+  /**
+   * Are parenthesis needed?
+   * @private
+   */
+
+
+  function needParenthesis(node) {
+    // TODO: maybe make a method on the nodes which tells whether they need parenthesis?
+    return !(type.isAccessorNode(node) || type.isArrayNode(node) || type.isConstantNode(node) || type.isFunctionNode(node) || type.isObjectNode(node) || type.isParenthesisNode(node) || type.isSymbolNode(node));
+  }
+
+  return AccessorNode;
+}
+
+exports.name = 'AccessorNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/customs":51,"./Node":24,"./utils/access":31}],16:[function(require,module,exports){
+'use strict';
+
+var map = require('../../utils/array').map;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  /**
+   * @constructor ArrayNode
+   * @extends {Node}
+   * Holds an 1-dimensional array with items
+   * @param {Node[]} [items]   1 dimensional array with items
+   */
+
+  function ArrayNode(items) {
+    if (!(this instanceof ArrayNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    this.items = items || []; // validate input
+
+    if (!Array.isArray(this.items) || !this.items.every(type.isNode)) {
+      throw new TypeError('Array containing Nodes expected');
+    } // TODO: deprecated since v3, remove some day
+
+
+    var deprecated = function deprecated() {
+      throw new Error('Property `ArrayNode.nodes` is deprecated, use `ArrayNode.items` instead');
+    };
+
+    Object.defineProperty(this, 'nodes', {
+      get: deprecated,
+      set: deprecated
+    });
+  }
+
+  ArrayNode.prototype = new Node();
+  ArrayNode.prototype.type = 'ArrayNode';
+  ArrayNode.prototype.isArrayNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  ArrayNode.prototype._compile = function (math, argNames) {
+    var evalItems = map(this.items, function (item) {
+      return item._compile(math, argNames);
+    });
+    var asMatrix = math.config().matrix !== 'Array';
+
+    if (asMatrix) {
+      var matrix = math.matrix;
+      return function evalArrayNode(scope, args, context) {
+        return matrix(map(evalItems, function (evalItem) {
+          return evalItem(scope, args, context);
+        }));
+      };
+    } else {
+      return function evalArrayNode(scope, args, context) {
+        return map(evalItems, function (evalItem) {
+          return evalItem(scope, args, context);
+        });
+      };
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  ArrayNode.prototype.forEach = function (callback) {
+    for (var i = 0; i < this.items.length; i++) {
+      var node = this.items[i];
+      callback(node, 'items[' + i + ']', this);
+    }
+  };
+  /**
+   * Create a new ArrayNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {ArrayNode} Returns a transformed copy of the node
+   */
+
+
+  ArrayNode.prototype.map = function (callback) {
+    var items = [];
+
+    for (var i = 0; i < this.items.length; i++) {
+      items[i] = this._ifNode(callback(this.items[i], 'items[' + i + ']', this));
+    }
+
+    return new ArrayNode(items);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {ArrayNode}
+   */
+
+
+  ArrayNode.prototype.clone = function () {
+    return new ArrayNode(this.items.slice(0));
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ArrayNode.prototype._toString = function (options) {
+    var items = this.items.map(function (node) {
+      return node.toString(options);
+    });
+    return '[' + items.join(', ') + ']';
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  ArrayNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'ArrayNode',
+      items: this.items
+    };
+  };
+  /**
+   * Instantiate an ArrayNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "ArrayNode", items: [...]}`,
+   *                       where mathjs is optional
+   * @returns {ArrayNode}
+   */
+
+
+  ArrayNode.fromJSON = function (json) {
+    return new ArrayNode(json.items);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ArrayNode.prototype.toHTML = function (options) {
+    var items = this.items.map(function (node) {
+      return node.toHTML(options);
+    });
+    return '<span class="math-parenthesis math-square-parenthesis">[</span>' + items.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-square-parenthesis">]</span>';
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ArrayNode.prototype._toTex = function (options) {
+    var s = '\\begin{bmatrix}';
+    this.items.forEach(function (node) {
+      if (node.items) {
+        s += node.items.map(function (childNode) {
+          return childNode.toTex(options);
+        }).join('&');
+      } else {
+        s += node.toTex(options);
+      } // new line
+
+
+      s += '\\\\';
+    });
+    s += '\\end{bmatrix}';
+    return s;
+  };
+
+  return ArrayNode;
+}
+
+exports.name = 'ArrayNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/array":46,"./Node":24}],17:[function(require,module,exports){
+'use strict';
+
+var getSafeProperty = require('../../utils/customs').getSafeProperty;
+
+var setSafeProperty = require('../../utils/customs').setSafeProperty;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  var assign = load(require('./utils/assign'));
+  var access = load(require('./utils/access'));
+
+  var operators = require('../operators');
+  /**
+   * @constructor AssignmentNode
+   * @extends {Node}
+   *
+   * Define a symbol, like `a=3.2`, update a property like `a.b=3.2`, or
+   * replace a subset of a matrix like `A[2,2]=42`.
+   *
+   * Syntax:
+   *
+   *     new AssignmentNode(symbol, value)
+   *     new AssignmentNode(object, index, value)
+   *
+   * Usage:
+   *
+   *    new AssignmentNode(new SymbolNode('a'), new ConstantNode(2))                       // a=2
+   *    new AssignmentNode(new SymbolNode('a'), new IndexNode('b'), new ConstantNode(2))   // a.b=2
+   *    new AssignmentNode(new SymbolNode('a'), new IndexNode(1, 2), new ConstantNode(3))  // a[1,2]=3
+   *
+   * @param {SymbolNode | AccessorNode} object  Object on which to assign a value
+   * @param {IndexNode} [index=null]            Index, property name or matrix
+   *                                            index. Optional. If not provided
+   *                                            and `object` is a SymbolNode,
+   *                                            the property is assigned to the
+   *                                            global scope.
+   * @param {Node} value                        The value to be assigned
+   */
+
+
+  function AssignmentNode(object, index, value) {
+    if (!(this instanceof AssignmentNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    this.object = object;
+    this.index = value ? index : null;
+    this.value = value || index; // validate input
+
+    if (!type.isSymbolNode(object) && !type.isAccessorNode(object)) {
+      throw new TypeError('SymbolNode or AccessorNode expected as "object"');
+    }
+
+    if (type.isSymbolNode(object) && object.name === 'end') {
+      throw new Error('Cannot assign to symbol "end"');
+    }
+
+    if (this.index && !type.isIndexNode(this.index)) {
+      // index is optional
+      throw new TypeError('IndexNode expected as "index"');
+    }
+
+    if (!type.isNode(this.value)) {
+      throw new TypeError('Node expected as "value"');
+    } // readonly property name
+
+
+    Object.defineProperty(this, 'name', {
+      get: function () {
+        if (this.index) {
+          return this.index.isObjectProperty() ? this.index.getObjectProperty() : '';
+        } else {
+          return this.object.name || '';
+        }
+      }.bind(this),
+      set: function set() {
+        throw new Error('Cannot assign a new name, name is read-only');
+      }
+    });
+  }
+
+  AssignmentNode.prototype = new Node();
+  AssignmentNode.prototype.type = 'AssignmentNode';
+  AssignmentNode.prototype.isAssignmentNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  AssignmentNode.prototype._compile = function (math, argNames) {
+    var evalObject = this.object._compile(math, argNames);
+
+    var evalIndex = this.index ? this.index._compile(math, argNames) : null;
+
+    var evalValue = this.value._compile(math, argNames);
+
+    var name = this.object.name;
+
+    if (!this.index) {
+      // apply a variable to the scope, for example `a=2`
+      if (!type.isSymbolNode(this.object)) {
+        throw new TypeError('SymbolNode expected as object');
+      }
+
+      return function evalAssignmentNode(scope, args, context) {
+        return setSafeProperty(scope, name, evalValue(scope, args, context));
+      };
+    } else if (this.index.isObjectProperty()) {
+      // apply an object property for example `a.b=2`
+      var prop = this.index.getObjectProperty();
+      return function evalAssignmentNode(scope, args, context) {
+        var object = evalObject(scope, args, context);
+        var value = evalValue(scope, args, context);
+        return setSafeProperty(object, prop, value);
+      };
+    } else if (type.isSymbolNode(this.object)) {
+      // update a matrix subset, for example `a[2]=3`
+      return function evalAssignmentNode(scope, args, context) {
+        var childObject = evalObject(scope, args, context);
+        var value = evalValue(scope, args, context);
+        var index = evalIndex(scope, args, childObject); // Important:  we pass childObject instead of context
+
+        setSafeProperty(scope, name, assign(childObject, index, value));
+        return value;
+      };
+    } else {
+      // type.isAccessorNode(node.object) === true
+      // update a matrix subset, for example `a.b[2]=3`
+      // we will not use the compile function of the AccessorNode, but compile it
+      // ourselves here as we need the parent object of the AccessorNode:
+      // wee need to apply the updated object to parent object
+      var evalParentObject = this.object.object._compile(math, argNames);
+
+      if (this.object.index.isObjectProperty()) {
+        var parentProp = this.object.index.getObjectProperty();
+        return function evalAssignmentNode(scope, args, context) {
+          var parent = evalParentObject(scope, args, context);
+          var childObject = getSafeProperty(parent, parentProp);
+          var index = evalIndex(scope, args, childObject); // Important: we pass childObject instead of context
+
+          var value = evalValue(scope, args, context);
+          setSafeProperty(parent, parentProp, assign(childObject, index, value));
+          return value;
+        };
+      } else {
+        // if some parameters use the 'end' parameter, we need to calculate the size
+        var evalParentIndex = this.object.index._compile(math, argNames);
+
+        return function evalAssignmentNode(scope, args, context) {
+          var parent = evalParentObject(scope, args, context);
+          var parentIndex = evalParentIndex(scope, args, parent); // Important: we pass parent instead of context
+
+          var childObject = access(parent, parentIndex);
+          var index = evalIndex(scope, args, childObject); // Important:  we pass childObject instead of context
+
+          var value = evalValue(scope, args, context);
+          assign(parent, parentIndex, assign(childObject, index, value));
+          return value;
+        };
+      }
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  AssignmentNode.prototype.forEach = function (callback) {
+    callback(this.object, 'object', this);
+
+    if (this.index) {
+      callback(this.index, 'index', this);
+    }
+
+    callback(this.value, 'value', this);
+  };
+  /**
+   * Create a new AssignmentNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {AssignmentNode} Returns a transformed copy of the node
+   */
+
+
+  AssignmentNode.prototype.map = function (callback) {
+    var object = this._ifNode(callback(this.object, 'object', this));
+
+    var index = this.index ? this._ifNode(callback(this.index, 'index', this)) : null;
+
+    var value = this._ifNode(callback(this.value, 'value', this));
+
+    return new AssignmentNode(object, index, value);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {AssignmentNode}
+   */
+
+
+  AssignmentNode.prototype.clone = function () {
+    return new AssignmentNode(this.object, this.index, this.value);
+  };
+  /*
+   * Is parenthesis needed?
+   * @param {node} node
+   * @param {string} [parenthesis='keep']
+   * @private
+   */
+
+
+  function needParenthesis(node, parenthesis) {
+    if (!parenthesis) {
+      parenthesis = 'keep';
+    }
+
+    var precedence = operators.getPrecedence(node, parenthesis);
+    var exprPrecedence = operators.getPrecedence(node.value, parenthesis);
+    return parenthesis === 'all' || exprPrecedence !== null && exprPrecedence <= precedence;
+  }
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string}
+   */
+
+
+  AssignmentNode.prototype._toString = function (options) {
+    var object = this.object.toString(options);
+    var index = this.index ? this.index.toString(options) : '';
+    var value = this.value.toString(options);
+
+    if (needParenthesis(this, options && options.parenthesis)) {
+      value = '(' + value + ')';
+    }
+
+    return object + index + ' = ' + value;
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  AssignmentNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'AssignmentNode',
+      object: this.object,
+      index: this.index,
+      value: this.value
+    };
+  };
+  /**
+   * Instantiate an AssignmentNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "AssignmentNode", object: ..., index: ..., value: ...}`,
+   *                       where mathjs is optional
+   * @returns {AssignmentNode}
+   */
+
+
+  AssignmentNode.fromJSON = function (json) {
+    return new AssignmentNode(json.object, json.index, json.value);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string}
+   */
+
+
+  AssignmentNode.prototype.toHTML = function (options) {
+    var object = this.object.toHTML(options);
+    var index = this.index ? this.index.toHTML(options) : '';
+    var value = this.value.toHTML(options);
+
+    if (needParenthesis(this, options && options.parenthesis)) {
+      value = '<span class="math-paranthesis math-round-parenthesis">(</span>' + value + '<span class="math-paranthesis math-round-parenthesis">)</span>';
+    }
+
+    return object + index + '<span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>' + value;
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string}
+   */
+
+
+  AssignmentNode.prototype._toTex = function (options) {
+    var object = this.object.toTex(options);
+    var index = this.index ? this.index.toTex(options) : '';
+    var value = this.value.toTex(options);
+
+    if (needParenthesis(this, options && options.parenthesis)) {
+      value = "\\left(".concat(value, "\\right)");
+    }
+
+    return object + index + ':=' + value;
+  };
+
+  return AssignmentNode;
+}
+
+exports.name = 'AssignmentNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/customs":51,"../operators":33,"./Node":24,"./utils/access":31,"./utils/assign":32}],18:[function(require,module,exports){
+'use strict';
+
+var forEach = require('../../utils/array').forEach;
+
+var map = require('../../utils/array').map;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  var ResultSet = load(require('../../type/resultset/ResultSet'));
+  /**
+   * @constructor BlockNode
+   * @extends {Node}
+   * Holds a set with blocks
+   * @param {Array.<{node: Node} | {node: Node, visible: boolean}>} blocks
+   *            An array with blocks, where a block is constructed as an Object
+   *            with properties block, which is a Node, and visible, which is
+   *            a boolean. The property visible is optional and is true by default
+   */
+
+  function BlockNode(blocks) {
+    if (!(this instanceof BlockNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    } // validate input, copy blocks
+
+
+    if (!Array.isArray(blocks)) throw new Error('Array expected');
+    this.blocks = blocks.map(function (block) {
+      var node = block && block.node;
+      var visible = block && block.visible !== undefined ? block.visible : true;
+      if (!type.isNode(node)) throw new TypeError('Property "node" must be a Node');
+      if (typeof visible !== 'boolean') throw new TypeError('Property "visible" must be a boolean');
+      return {
+        node: node,
+        visible: visible
+      };
+    });
+  }
+
+  BlockNode.prototype = new Node();
+  BlockNode.prototype.type = 'BlockNode';
+  BlockNode.prototype.isBlockNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  BlockNode.prototype._compile = function (math, argNames) {
+    var evalBlocks = map(this.blocks, function (block) {
+      return {
+        eval: block.node._compile(math, argNames),
+        visible: block.visible
+      };
+    });
+    return function evalBlockNodes(scope, args, context) {
+      var results = [];
+      forEach(evalBlocks, function evalBlockNode(block) {
+        var result = block.eval(scope, args, context);
+
+        if (block.visible) {
+          results.push(result);
+        }
+      });
+      return new ResultSet(results);
+    };
+  };
+  /**
+   * Execute a callback for each of the child blocks of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  BlockNode.prototype.forEach = function (callback) {
+    for (var i = 0; i < this.blocks.length; i++) {
+      callback(this.blocks[i].node, 'blocks[' + i + '].node', this);
+    }
+  };
+  /**
+   * Create a new BlockNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {BlockNode} Returns a transformed copy of the node
+   */
+
+
+  BlockNode.prototype.map = function (callback) {
+    var blocks = [];
+
+    for (var i = 0; i < this.blocks.length; i++) {
+      var block = this.blocks[i];
+
+      var node = this._ifNode(callback(block.node, 'blocks[' + i + '].node', this));
+
+      blocks[i] = {
+        node: node,
+        visible: block.visible
+      };
+    }
+
+    return new BlockNode(blocks);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {BlockNode}
+   */
+
+
+  BlockNode.prototype.clone = function () {
+    var blocks = this.blocks.map(function (block) {
+      return {
+        node: block.node,
+        visible: block.visible
+      };
+    });
+    return new BlockNode(blocks);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  BlockNode.prototype._toString = function (options) {
+    return this.blocks.map(function (param) {
+      return param.node.toString(options) + (param.visible ? '' : ';');
+    }).join('\n');
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  BlockNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'BlockNode',
+      blocks: this.blocks
+    };
+  };
+  /**
+   * Instantiate an BlockNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "BlockNode", blocks: [{node: ..., visible: false}, ...]}`,
+   *                       where mathjs is optional
+   * @returns {BlockNode}
+   */
+
+
+  BlockNode.fromJSON = function (json) {
+    return new BlockNode(json.blocks);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  BlockNode.prototype.toHTML = function (options) {
+    return this.blocks.map(function (param) {
+      return param.node.toHTML(options) + (param.visible ? '' : '<span class="math-separator">;</span>');
+    }).join('<span class="math-separator"><br /></span>');
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  BlockNode.prototype._toTex = function (options) {
+    return this.blocks.map(function (param) {
+      return param.node.toTex(options) + (param.visible ? '' : ';');
+    }).join('\\;\\;\n');
+  };
+
+  return BlockNode;
+}
+
+exports.name = 'BlockNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../type/resultset/ResultSet":45,"../../utils/array":46,"./Node":24}],19:[function(require,module,exports){
+'use strict';
+
+var operators = require('../operators');
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  var mathTypeOf = load(require('../../function/utils/typeof'));
+  /**
+   * A lazy evaluating conditional operator: 'condition ? trueExpr : falseExpr'
+   *
+   * @param {Node} condition   Condition, must result in a boolean
+   * @param {Node} trueExpr    Expression evaluated when condition is true
+   * @param {Node} falseExpr   Expression evaluated when condition is true
+   *
+   * @constructor ConditionalNode
+   * @extends {Node}
+   */
+
+  function ConditionalNode(condition, trueExpr, falseExpr) {
+    if (!(this instanceof ConditionalNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    if (!type.isNode(condition)) throw new TypeError('Parameter condition must be a Node');
+    if (!type.isNode(trueExpr)) throw new TypeError('Parameter trueExpr must be a Node');
+    if (!type.isNode(falseExpr)) throw new TypeError('Parameter falseExpr must be a Node');
+    this.condition = condition;
+    this.trueExpr = trueExpr;
+    this.falseExpr = falseExpr;
+  }
+
+  ConditionalNode.prototype = new Node();
+  ConditionalNode.prototype.type = 'ConditionalNode';
+  ConditionalNode.prototype.isConditionalNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  ConditionalNode.prototype._compile = function (math, argNames) {
+    var evalCondition = this.condition._compile(math, argNames);
+
+    var evalTrueExpr = this.trueExpr._compile(math, argNames);
+
+    var evalFalseExpr = this.falseExpr._compile(math, argNames);
+
+    return function evalConditionalNode(scope, args, context) {
+      return testCondition(evalCondition(scope, args, context)) ? evalTrueExpr(scope, args, context) : evalFalseExpr(scope, args, context);
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  ConditionalNode.prototype.forEach = function (callback) {
+    callback(this.condition, 'condition', this);
+    callback(this.trueExpr, 'trueExpr', this);
+    callback(this.falseExpr, 'falseExpr', this);
+  };
+  /**
+   * Create a new ConditionalNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {ConditionalNode} Returns a transformed copy of the node
+   */
+
+
+  ConditionalNode.prototype.map = function (callback) {
+    return new ConditionalNode(this._ifNode(callback(this.condition, 'condition', this)), this._ifNode(callback(this.trueExpr, 'trueExpr', this)), this._ifNode(callback(this.falseExpr, 'falseExpr', this)));
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {ConditionalNode}
+   */
+
+
+  ConditionalNode.prototype.clone = function () {
+    return new ConditionalNode(this.condition, this.trueExpr, this.falseExpr);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ConditionalNode.prototype._toString = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var precedence = operators.getPrecedence(this, parenthesis); // Enclose Arguments in parentheses if they are an OperatorNode
+    // or have lower or equal precedence
+    // NOTE: enclosing all OperatorNodes in parentheses is a decision
+    // purely based on aesthetics and readability
+
+    var condition = this.condition.toString(options);
+    var conditionPrecedence = operators.getPrecedence(this.condition, parenthesis);
+
+    if (parenthesis === 'all' || this.condition.type === 'OperatorNode' || conditionPrecedence !== null && conditionPrecedence <= precedence) {
+      condition = '(' + condition + ')';
+    }
+
+    var trueExpr = this.trueExpr.toString(options);
+    var truePrecedence = operators.getPrecedence(this.trueExpr, parenthesis);
+
+    if (parenthesis === 'all' || this.trueExpr.type === 'OperatorNode' || truePrecedence !== null && truePrecedence <= precedence) {
+      trueExpr = '(' + trueExpr + ')';
+    }
+
+    var falseExpr = this.falseExpr.toString(options);
+    var falsePrecedence = operators.getPrecedence(this.falseExpr, parenthesis);
+
+    if (parenthesis === 'all' || this.falseExpr.type === 'OperatorNode' || falsePrecedence !== null && falsePrecedence <= precedence) {
+      falseExpr = '(' + falseExpr + ')';
+    }
+
+    return condition + ' ? ' + trueExpr + ' : ' + falseExpr;
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  ConditionalNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'ConditionalNode',
+      condition: this.condition,
+      trueExpr: this.trueExpr,
+      falseExpr: this.falseExpr
+    };
+  };
+  /**
+   * Instantiate an ConditionalNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "ConditionalNode", "condition": ..., "trueExpr": ..., "falseExpr": ...}`,
+   *                       where mathjs is optional
+   * @returns {ConditionalNode}
+   */
+
+
+  ConditionalNode.fromJSON = function (json) {
+    return new ConditionalNode(json.condition, json.trueExpr, json.falseExpr);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ConditionalNode.prototype.toHTML = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var precedence = operators.getPrecedence(this, parenthesis); // Enclose Arguments in parentheses if they are an OperatorNode
+    // or have lower or equal precedence
+    // NOTE: enclosing all OperatorNodes in parentheses is a decision
+    // purely based on aesthetics and readability
+
+    var condition = this.condition.toHTML(options);
+    var conditionPrecedence = operators.getPrecedence(this.condition, parenthesis);
+
+    if (parenthesis === 'all' || this.condition.type === 'OperatorNode' || conditionPrecedence !== null && conditionPrecedence <= precedence) {
+      condition = '<span class="math-parenthesis math-round-parenthesis">(</span>' + condition + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    var trueExpr = this.trueExpr.toHTML(options);
+    var truePrecedence = operators.getPrecedence(this.trueExpr, parenthesis);
+
+    if (parenthesis === 'all' || this.trueExpr.type === 'OperatorNode' || truePrecedence !== null && truePrecedence <= precedence) {
+      trueExpr = '<span class="math-parenthesis math-round-parenthesis">(</span>' + trueExpr + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    var falseExpr = this.falseExpr.toHTML(options);
+    var falsePrecedence = operators.getPrecedence(this.falseExpr, parenthesis);
+
+    if (parenthesis === 'all' || this.falseExpr.type === 'OperatorNode' || falsePrecedence !== null && falsePrecedence <= precedence) {
+      falseExpr = '<span class="math-parenthesis math-round-parenthesis">(</span>' + falseExpr + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    return condition + '<span class="math-operator math-conditional-operator">?</span>' + trueExpr + '<span class="math-operator math-conditional-operator">:</span>' + falseExpr;
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ConditionalNode.prototype._toTex = function (options) {
+    return '\\begin{cases} {' + this.trueExpr.toTex(options) + '}, &\\quad{\\text{if }\\;' + this.condition.toTex(options) + '}\\\\{' + this.falseExpr.toTex(options) + '}, &\\quad{\\text{otherwise}}\\end{cases}';
+  };
+  /**
+   * Test whether a condition is met
+   * @param {*} condition
+   * @returns {boolean} true if condition is true or non-zero, else false
+   */
+
+
+  function testCondition(condition) {
+    if (typeof condition === 'number' || typeof condition === 'boolean' || typeof condition === 'string') {
+      return !!condition;
+    }
+
+    if (condition) {
+      if (type.isBigNumber(condition)) {
+        return !condition.isZero();
+      }
+
+      if (type.isComplex(condition)) {
+        return !!(condition.re || condition.im);
+      }
+
+      if (type.isUnit(condition)) {
+        return !!condition.value;
+      }
+    }
+
+    if (condition === null || condition === undefined) {
+      return false;
+    }
+
+    throw new TypeError('Unsupported type of condition "' + mathTypeOf(condition) + '"');
+  }
+
+  return ConditionalNode;
+}
+
+exports.name = 'ConditionalNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../function/utils/typeof":38,"../operators":33,"./Node":24}],20:[function(require,module,exports){
+'use strict';
+
+var format = require('../../utils/string').format;
+
+var escapeLatex = require('../../utils/latex').escape;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  var getType = load(require('../../function/utils/typeof'));
+  /**
+   * A ConstantNode holds a constant value like a number or string.
+   *
+   * Usage:
+   *
+   *     new ConstantNode(2.3)
+   *     new ConstantNode('hello')
+   *
+   * @param {*} value    Value can be any type (number, BigNumber, string, ...)
+   * @constructor ConstantNode
+   * @extends {Node}
+   */
+
+  function ConstantNode(value) {
+    if (!(this instanceof ConstantNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    if (arguments.length === 2) {
+      // TODO: remove deprecation error some day (created 2018-01-23)
+      throw new SyntaxError('new ConstantNode(valueStr, valueType) is not supported anymore since math v4.0.0. Use new ConstantNode(value) instead, where value is a non-stringified value.');
+    }
+
+    this.value = value;
+  }
+
+  ConstantNode.prototype = new Node();
+  ConstantNode.prototype.type = 'ConstantNode';
+  ConstantNode.prototype.isConstantNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  ConstantNode.prototype._compile = function (math, argNames) {
+    var value = this.value;
+    return function evalConstantNode() {
+      return value;
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  ConstantNode.prototype.forEach = function (callback) {} // nothing to do, we don't have childs
+
+  /**
+   * Create a new ConstantNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node) : Node} callback
+   * @returns {ConstantNode} Returns a clone of the node
+   */
+  ;
+
+  ConstantNode.prototype.map = function (callback) {
+    return this.clone();
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {ConstantNode}
+   */
+
+
+  ConstantNode.prototype.clone = function () {
+    return new ConstantNode(this.value);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ConstantNode.prototype._toString = function (options) {
+    return format(this.value, options);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ConstantNode.prototype.toHTML = function (options) {
+    var value = this._toString(options);
+
+    switch (getType(this.value)) {
+      case 'number':
+      case 'BigNumber':
+      case 'Fraction':
+        return '<span class="math-number">' + value + '</span>';
+
+      case 'string':
+        return '<span class="math-string">' + value + '</span>';
+
+      case 'boolean':
+        return '<span class="math-boolean">' + value + '</span>';
+
+      case 'null':
+        return '<span class="math-null-symbol">' + value + '</span>';
+
+      case 'undefined':
+        return '<span class="math-undefined">' + value + '</span>';
+
+      default:
+        return '<span class="math-symbol">' + value + '</span>';
+    }
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  ConstantNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'ConstantNode',
+      value: this.value
+    };
+  };
+  /**
+   * Instantiate a ConstantNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "SymbolNode", value: 2.3}`,
+   *                       where mathjs is optional
+   * @returns {ConstantNode}
+   */
+
+
+  ConstantNode.fromJSON = function (json) {
+    return new ConstantNode(json.value);
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ConstantNode.prototype._toTex = function (options) {
+    var value = this._toString(options);
+
+    switch (getType(this.value)) {
+      case 'string':
+        return '\\mathtt{' + escapeLatex(value) + '}';
+
+      case 'number':
+      case 'BigNumber':
+        var index = value.toLowerCase().indexOf('e');
+
+        if (index !== -1) {
+          return value.substring(0, index) + '\\cdot10^{' + value.substring(index + 1) + '}';
+        }
+
+        return value;
+
+      case 'Fraction':
+        return this.value.toLatex();
+
+      default:
+        return value;
+    }
+  };
+
+  return ConstantNode;
+}
+
+exports.name = 'ConstantNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../function/utils/typeof":38,"../../utils/latex":53,"../../utils/string":57,"./Node":24}],21:[function(require,module,exports){
+'use strict';
+
+var keywords = require('../keywords');
+
+var escape = require('../../utils/string').escape;
+
+var forEach = require('../../utils/array').forEach;
+
+var join = require('../../utils/array').join;
+
+var latex = require('../../utils/latex');
+
+var operators = require('../operators');
+
+var setSafeProperty = require('../../utils/customs').setSafeProperty;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  /**
+   * @constructor FunctionAssignmentNode
+   * @extends {Node}
+   * Function assignment
+   *
+   * @param {string} name           Function name
+   * @param {string[] | Array.<{name: string, type: string}>} params
+   *                                Array with function parameter names, or an
+   *                                array with objects containing the name
+   *                                and type of the parameter
+   * @param {Node} expr             The function expression
+   */
+
+  function FunctionAssignmentNode(name, params, expr) {
+    if (!(this instanceof FunctionAssignmentNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    } // validate input
+
+
+    if (typeof name !== 'string') throw new TypeError('String expected for parameter "name"');
+    if (!Array.isArray(params)) throw new TypeError('Array containing strings or objects expected for parameter "params"');
+    if (!type.isNode(expr)) throw new TypeError('Node expected for parameter "expr"');
+    if (name in keywords) throw new Error('Illegal function name, "' + name + '" is a reserved keyword');
+    this.name = name;
+    this.params = params.map(function (param) {
+      return param && param.name || param;
+    });
+    this.types = params.map(function (param) {
+      return param && param.type || 'any';
+    });
+    this.expr = expr;
+  }
+
+  FunctionAssignmentNode.prototype = new Node();
+  FunctionAssignmentNode.prototype.type = 'FunctionAssignmentNode';
+  FunctionAssignmentNode.prototype.isFunctionAssignmentNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  FunctionAssignmentNode.prototype._compile = function (math, argNames) {
+    var childArgNames = Object.create(argNames);
+    forEach(this.params, function (param) {
+      childArgNames[param] = true;
+    }); // compile the function expression with the child args
+
+    var evalExpr = this.expr._compile(math, childArgNames);
+
+    var name = this.name;
+    var params = this.params;
+    var signature = join(this.types, ',');
+    var syntax = name + '(' + join(this.params, ', ') + ')';
+    return function evalFunctionAssignmentNode(scope, args, context) {
+      var signatures = {};
+
+      signatures[signature] = function () {
+        var childArgs = Object.create(args);
+
+        for (var i = 0; i < params.length; i++) {
+          childArgs[params[i]] = arguments[i];
+        }
+
+        return evalExpr(scope, childArgs, context);
+      };
+
+      var fn = typed(name, signatures);
+      fn.syntax = syntax;
+      setSafeProperty(scope, name, fn);
+      return fn;
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  FunctionAssignmentNode.prototype.forEach = function (callback) {
+    callback(this.expr, 'expr', this);
+  };
+  /**
+   * Create a new FunctionAssignmentNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {FunctionAssignmentNode} Returns a transformed copy of the node
+   */
+
+
+  FunctionAssignmentNode.prototype.map = function (callback) {
+    var expr = this._ifNode(callback(this.expr, 'expr', this));
+
+    return new FunctionAssignmentNode(this.name, this.params.slice(0), expr);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {FunctionAssignmentNode}
+   */
+
+
+  FunctionAssignmentNode.prototype.clone = function () {
+    return new FunctionAssignmentNode(this.name, this.params.slice(0), this.expr);
+  };
+  /**
+   * Is parenthesis needed?
+   * @param {Node} node
+   * @param {Object} parenthesis
+   * @private
+   */
+
+
+  function needParenthesis(node, parenthesis) {
+    var precedence = operators.getPrecedence(node, parenthesis);
+    var exprPrecedence = operators.getPrecedence(node.expr, parenthesis);
+    return parenthesis === 'all' || exprPrecedence !== null && exprPrecedence <= precedence;
+  }
+  /**
+   * get string representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  FunctionAssignmentNode.prototype._toString = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var expr = this.expr.toString(options);
+
+    if (needParenthesis(this, parenthesis)) {
+      expr = '(' + expr + ')';
+    }
+
+    return this.name + '(' + this.params.join(', ') + ') = ' + expr;
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  FunctionAssignmentNode.prototype.toJSON = function () {
+    var types = this.types;
+    return {
+      mathjs: 'FunctionAssignmentNode',
+      name: this.name,
+      params: this.params.map(function (param, index) {
+        return {
+          name: param,
+          type: types[index]
+        };
+      }),
+      expr: this.expr
+    };
+  };
+  /**
+   * Instantiate an FunctionAssignmentNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "FunctionAssignmentNode", name: ..., params: ..., expr: ...}`,
+   *                       where mathjs is optional
+   * @returns {FunctionAssignmentNode}
+   */
+
+
+  FunctionAssignmentNode.fromJSON = function (json) {
+    return new FunctionAssignmentNode(json.name, json.params, json.expr);
+  };
+  /**
+   * get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  FunctionAssignmentNode.prototype.toHTML = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var params = [];
+
+    for (var i = 0; i < this.params.length; i++) {
+      params.push('<span class="math-symbol math-parameter">' + escape(this.params[i]) + '</span>');
+    }
+
+    var expr = this.expr.toHTML(options);
+
+    if (needParenthesis(this, parenthesis)) {
+      expr = '<span class="math-parenthesis math-round-parenthesis">(</span>' + expr + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    return '<span class="math-function">' + escape(this.name) + '</span>' + '<span class="math-parenthesis math-round-parenthesis">(</span>' + params.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-round-parenthesis">)</span><span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>' + expr;
+  };
+  /**
+   * get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  FunctionAssignmentNode.prototype._toTex = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var expr = this.expr.toTex(options);
+
+    if (needParenthesis(this, parenthesis)) {
+      expr = "\\left(".concat(expr, "\\right)");
+    }
+
+    return '\\mathrm{' + this.name + '}\\left(' + this.params.map(latex.toSymbol).join(',') + '\\right):=' + expr;
+  };
+
+  return FunctionAssignmentNode;
+}
+
+exports.name = 'FunctionAssignmentNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../keywords":14,"../operators":33,"./Node":24}],22:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var latex = require('../../utils/latex');
+
+var escape = require('../../utils/string').escape;
+
+var hasOwnProperty = require('../../utils/object').hasOwnProperty;
+
+var map = require('../../utils/array').map;
+
+var validateSafeMethod = require('../../utils/customs').validateSafeMethod;
+
+var getSafeProperty = require('../../utils/customs').getSafeProperty;
+
+function factory(type, config, load, typed, math) {
+  var Node = load(require('./Node'));
+  var SymbolNode = load(require('./SymbolNode'));
+  /**
+   * @constructor FunctionNode
+   * @extends {./Node}
+   * invoke a list with arguments on a node
+   * @param {./Node | string} fn Node resolving with a function on which to invoke
+   *                             the arguments, typically a SymboNode or AccessorNode
+   * @param {./Node[]} args
+   */
+
+  function FunctionNode(fn, args) {
+    if (!(this instanceof FunctionNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    if (typeof fn === 'string') {
+      fn = new SymbolNode(fn);
+    } // validate input
+
+
+    if (!type.isNode(fn)) throw new TypeError('Node expected as parameter "fn"');
+
+    if (!Array.isArray(args) || !args.every(type.isNode)) {
+      throw new TypeError('Array containing Nodes expected for parameter "args"');
+    }
+
+    this.fn = fn;
+    this.args = args || []; // readonly property name
+
+    Object.defineProperty(this, 'name', {
+      get: function () {
+        return this.fn.name || '';
+      }.bind(this),
+      set: function set() {
+        throw new Error('Cannot assign a new name, name is read-only');
+      }
+    }); // TODO: deprecated since v3, remove some day
+
+    var deprecated = function deprecated() {
+      throw new Error('Property `FunctionNode.object` is deprecated, use `FunctionNode.fn` instead');
+    };
+
+    Object.defineProperty(this, 'object', {
+      get: deprecated,
+      set: deprecated
+    });
+  }
+
+  FunctionNode.prototype = new Node();
+  FunctionNode.prototype.type = 'FunctionNode';
+  FunctionNode.prototype.isFunctionNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  FunctionNode.prototype._compile = function (math, argNames) {
+    if (!(this instanceof FunctionNode)) {
+      throw new TypeError('No valid FunctionNode');
+    } // compile arguments
+
+
+    var evalArgs = map(this.args, function (arg) {
+      return arg._compile(math, argNames);
+    });
+
+    if (type.isSymbolNode(this.fn)) {
+      // we can statically determine whether the function has an rawArgs property
+      var name = this.fn.name;
+      var fn = name in math ? getSafeProperty(math, name) : undefined;
+      var isRaw = typeof fn === 'function' && fn.rawArgs === true;
+
+      if (isRaw) {
+        // pass unevaluated parameters (nodes) to the function
+        // "raw" evaluation
+        var rawArgs = this.args;
+        return function evalFunctionNode(scope, args, context) {
+          return (name in scope ? getSafeProperty(scope, name) : fn)(rawArgs, math, _extends({}, scope, args));
+        };
+      } else {
+        // "regular" evaluation
+        if (evalArgs.length === 1) {
+          var evalArg0 = evalArgs[0];
+          return function evalFunctionNode(scope, args, context) {
+            return (name in scope ? getSafeProperty(scope, name) : fn)(evalArg0(scope, args, context));
+          };
+        } else if (evalArgs.length === 2) {
+          var _evalArg = evalArgs[0];
+          var evalArg1 = evalArgs[1];
+          return function evalFunctionNode(scope, args, context) {
+            return (name in scope ? getSafeProperty(scope, name) : fn)(_evalArg(scope, args, context), evalArg1(scope, args, context));
+          };
+        } else {
+          return function evalFunctionNode(scope, args, context) {
+            return (name in scope ? getSafeProperty(scope, name) : fn).apply(null, map(evalArgs, function (evalArg) {
+              return evalArg(scope, args, context);
+            }));
+          };
+        }
+      }
+    } else if (type.isAccessorNode(this.fn) && type.isIndexNode(this.fn.index) && this.fn.index.isObjectProperty()) {
+      // execute the function with the right context: the object of the AccessorNode
+      var evalObject = this.fn.object._compile(math, argNames);
+
+      var prop = this.fn.index.getObjectProperty();
+      var _rawArgs = this.args;
+      return function evalFunctionNode(scope, args, context) {
+        var object = evalObject(scope, args, context);
+        validateSafeMethod(object, prop);
+        var isRaw = object[prop] && object[prop].rawArgs;
+        return isRaw ? object[prop](_rawArgs, math, _extends({}, scope, args)) // "raw" evaluation
+        : object[prop].apply(object, map(evalArgs, function (evalArg) {
+          // "regular" evaluation
+          return evalArg(scope, args, context);
+        }));
+      };
+    } else {
+      // node.fn.isAccessorNode && !node.fn.index.isObjectProperty()
+      // we have to dynamically determine whether the function has a rawArgs property
+      var evalFn = this.fn._compile(math, argNames);
+
+      var _rawArgs2 = this.args;
+      return function evalFunctionNode(scope, args, context) {
+        var fn = evalFn(scope, args, context);
+        var isRaw = fn && fn.rawArgs;
+        return isRaw ? fn(_rawArgs2, math, _extends({}, scope, args)) // "raw" evaluation
+        : fn.apply(fn, map(evalArgs, function (evalArg) {
+          // "regular" evaluation
+          return evalArg(scope, args, context);
+        }));
+      };
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  FunctionNode.prototype.forEach = function (callback) {
+    for (var i = 0; i < this.args.length; i++) {
+      callback(this.args[i], 'args[' + i + ']', this);
+    }
+  };
+  /**
+   * Create a new FunctionNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {FunctionNode} Returns a transformed copy of the node
+   */
+
+
+  FunctionNode.prototype.map = function (callback) {
+    var fn = this.fn.map(callback);
+    var args = [];
+
+    for (var i = 0; i < this.args.length; i++) {
+      args[i] = this._ifNode(callback(this.args[i], 'args[' + i + ']', this));
+    }
+
+    return new FunctionNode(fn, args);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {FunctionNode}
+   */
+
+
+  FunctionNode.prototype.clone = function () {
+    return new FunctionNode(this.fn, this.args.slice(0));
+  }; // backup Node's toString function
+  // @private
+
+
+  var nodeToString = FunctionNode.prototype.toString;
+  /**
+   * Get string representation. (wrapper function)
+   * This overrides parts of Node's toString function.
+   * If callback is an object containing callbacks, it
+   * calls the correct callback for the current node,
+   * otherwise it falls back to calling Node's toString
+   * function.
+   *
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+  FunctionNode.prototype.toString = function (options) {
+    var customString;
+    var name = this.fn.toString(options);
+
+    if (options && _typeof(options.handler) === 'object' && hasOwnProperty(options.handler, name)) {
+      // callback is a map of callback functions
+      customString = options.handler[name](this, options);
+    }
+
+    if (typeof customString !== 'undefined') {
+      return customString;
+    } // fall back to Node's toString
+
+
+    return nodeToString.call(this, options);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  FunctionNode.prototype._toString = function (options) {
+    var args = this.args.map(function (arg) {
+      return arg.toString(options);
+    });
+    var fn = type.isFunctionAssignmentNode(this.fn) ? '(' + this.fn.toString(options) + ')' : this.fn.toString(options); // format the arguments like "add(2, 4.2)"
+
+    return fn + '(' + args.join(', ') + ')';
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  FunctionNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'FunctionNode',
+      fn: this.fn,
+      args: this.args
+    };
+  };
+  /**
+   * Instantiate an AssignmentNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "FunctionNode", fn: ..., args: ...}`,
+   *                       where mathjs is optional
+   * @returns {FunctionNode}
+   */
+
+
+  FunctionNode.fromJSON = function (json) {
+    return new FunctionNode(json.fn, json.args);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  FunctionNode.prototype.toHTML = function (options) {
+    var args = this.args.map(function (arg) {
+      return arg.toHTML(options);
+    }); // format the arguments like "add(2, 4.2)"
+
+    return '<span class="math-function">' + escape(this.fn) + '</span><span class="math-paranthesis math-round-parenthesis">(</span>' + args.join('<span class="math-separator">,</span>') + '<span class="math-paranthesis math-round-parenthesis">)</span>';
+  };
+  /*
+   * Expand a LaTeX template
+   *
+   * @param {string} template
+   * @param {Node} node
+   * @param {Object} options
+   * @private
+   **/
+
+
+  function expandTemplate(template, node, options) {
+    var latex = ''; // Match everything of the form ${identifier} or ${identifier[2]} or $$
+    // while submatching identifier and 2 (in the second case)
+
+    var regex = new RegExp('\\$(?:\\{([a-z_][a-z_0-9]*)(?:\\[([0-9]+)\\])?\\}|\\$)', 'ig');
+    var inputPos = 0; // position in the input string
+
+    var match;
+
+    while ((match = regex.exec(template)) !== null) {
+      // go through all matches
+      // add everything in front of the match to the LaTeX string
+      latex += template.substring(inputPos, match.index);
+      inputPos = match.index;
+
+      if (match[0] === '$$') {
+        // escaped dollar sign
+        latex += '$';
+        inputPos++;
+      } else {
+        // template parameter
+        inputPos += match[0].length;
+        var property = node[match[1]];
+
+        if (!property) {
+          throw new ReferenceError('Template: Property ' + match[1] + ' does not exist.');
+        }
+
+        if (match[2] === undefined) {
+          // no square brackets
+          switch (_typeof(property)) {
+            case 'string':
+              latex += property;
+              break;
+
+            case 'object':
+              if (type.isNode(property)) {
+                latex += property.toTex(options);
+              } else if (Array.isArray(property)) {
+                // make array of Nodes into comma separated list
+                latex += property.map(function (arg, index) {
+                  if (type.isNode(arg)) {
+                    return arg.toTex(options);
+                  }
+
+                  throw new TypeError('Template: ' + match[1] + '[' + index + '] is not a Node.');
+                }).join(',');
+              } else {
+                throw new TypeError('Template: ' + match[1] + ' has to be a Node, String or array of Nodes');
+              }
+
+              break;
+
+            default:
+              throw new TypeError('Template: ' + match[1] + ' has to be a Node, String or array of Nodes');
+          }
+        } else {
+          // with square brackets
+          if (type.isNode(property[match[2]] && property[match[2]])) {
+            latex += property[match[2]].toTex(options);
+          } else {
+            throw new TypeError('Template: ' + match[1] + '[' + match[2] + '] is not a Node.');
+          }
+        }
+      }
+    }
+
+    latex += template.slice(inputPos); // append rest of the template
+
+    return latex;
+  } // backup Node's toTex function
+  // @private
+
+
+  var nodeToTex = FunctionNode.prototype.toTex;
+  /**
+   * Get LaTeX representation. (wrapper function)
+   * This overrides parts of Node's toTex function.
+   * If callback is an object containing callbacks, it
+   * calls the correct callback for the current node,
+   * otherwise it falls back to calling Node's toTex
+   * function.
+   *
+   * @param {Object} options
+   * @return {string}
+   */
+
+  FunctionNode.prototype.toTex = function (options) {
+    var customTex;
+
+    if (options && _typeof(options.handler) === 'object' && hasOwnProperty(options.handler, this.name)) {
+      // callback is a map of callback functions
+      customTex = options.handler[this.name](this, options);
+    }
+
+    if (typeof customTex !== 'undefined') {
+      return customTex;
+    } // fall back to Node's toTex
+
+
+    return nodeToTex.call(this, options);
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  FunctionNode.prototype._toTex = function (options) {
+    var args = this.args.map(function (arg) {
+      // get LaTeX of the arguments
+      return arg.toTex(options);
+    });
+    var latexConverter;
+
+    if (math[this.name] && (typeof math[this.name].toTex === 'function' || _typeof(math[this.name].toTex) === 'object' || typeof math[this.name].toTex === 'string')) {
+      // .toTex is a callback function
+      latexConverter = math[this.name].toTex;
+    }
+
+    var customToTex;
+
+    switch (_typeof(latexConverter)) {
+      case 'function':
+        // a callback function
+        customToTex = latexConverter(this, options);
+        break;
+
+      case 'string':
+        // a template string
+        customToTex = expandTemplate(latexConverter, this, options);
+        break;
+
+      case 'object':
+        // an object with different "converters" for different numbers of arguments
+        switch (_typeof(latexConverter[args.length])) {
+          case 'function':
+            customToTex = latexConverter[args.length](this, options);
+            break;
+
+          case 'string':
+            customToTex = expandTemplate(latexConverter[args.length], this, options);
+            break;
+        }
+
+    }
+
+    if (typeof customToTex !== 'undefined') {
+      return customToTex;
+    }
+
+    return expandTemplate(latex.defaultTemplate, this, options);
+  };
+  /**
+   * Get identifier.
+   * @return {string}
+   */
+
+
+  FunctionNode.prototype.getIdentifier = function () {
+    return this.type + ':' + this.name;
+  };
+
+  return FunctionNode;
+}
+
+exports.name = 'FunctionNode';
+exports.path = 'expression.node';
+exports.math = true; // request access to the math namespace as 5th argument of the factory function
+
+exports.factory = factory;
+},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/object":55,"../../utils/string":57,"./Node":24,"./SymbolNode":30}],23:[function(require,module,exports){
+'use strict';
+
+var map = require('../../utils/array').map;
+
+var escape = require('../../utils/string').escape;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  var Range = load(require('../../type/matrix/Range'));
+  var isArray = Array.isArray;
+  /**
+   * @constructor IndexNode
+   * @extends Node
+   *
+   * Describes a subset of a matrix or an object property.
+   * Cannot be used on its own, needs to be used within an AccessorNode or
+   * AssignmentNode.
+   *
+   * @param {Node[]} dimensions
+   * @param {boolean} [dotNotation=false]  Optional property describing whether
+   *                                       this index was written using dot
+   *                                       notation like `a.b`, or using bracket
+   *                                       notation like `a["b"]` (default).
+   *                                       Used to stringify an IndexNode.
+   */
+
+  function IndexNode(dimensions, dotNotation) {
+    if (!(this instanceof IndexNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    this.dimensions = dimensions;
+    this.dotNotation = dotNotation || false; // validate input
+
+    if (!isArray(dimensions) || !dimensions.every(type.isNode)) {
+      throw new TypeError('Array containing Nodes expected for parameter "dimensions"');
+    }
+
+    if (this.dotNotation && !this.isObjectProperty()) {
+      throw new Error('dotNotation only applicable for object properties');
+    } // TODO: deprecated since v3, remove some day
+
+
+    var deprecated = function deprecated() {
+      throw new Error('Property `IndexNode.object` is deprecated, use `IndexNode.fn` instead');
+    };
+
+    Object.defineProperty(this, 'object', {
+      get: deprecated,
+      set: deprecated
+    });
+  }
+
+  IndexNode.prototype = new Node();
+  IndexNode.prototype.type = 'IndexNode';
+  IndexNode.prototype.isIndexNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  IndexNode.prototype._compile = function (math, argNames) {
+    // TODO: implement support for bignumber (currently bignumbers are silently
+    //       reduced to numbers when changing the value to zero-based)
+    // TODO: Optimization: when the range values are ConstantNodes,
+    //       we can beforehand resolve the zero-based value
+    // optimization for a simple object property
+    var evalDimensions = map(this.dimensions, function (range, i) {
+      if (type.isRangeNode(range)) {
+        if (range.needsEnd()) {
+          // create a range containing end (like '4:end')
+          var childArgNames = Object.create(argNames);
+          childArgNames['end'] = true;
+
+          var evalStart = range.start._compile(math, childArgNames);
+
+          var evalEnd = range.end._compile(math, childArgNames);
+
+          var evalStep = range.step ? range.step._compile(math, childArgNames) : function () {
+            return 1;
+          };
+          return function evalDimension(scope, args, context) {
+            var size = math.size(context).valueOf();
+            var childArgs = Object.create(args);
+            childArgs['end'] = size[i];
+            return createRange(evalStart(scope, childArgs, context), evalEnd(scope, childArgs, context), evalStep(scope, childArgs, context));
+          };
+        } else {
+          // create range
+          var _evalStart = range.start._compile(math, argNames);
+
+          var _evalEnd = range.end._compile(math, argNames);
+
+          var _evalStep = range.step ? range.step._compile(math, argNames) : function () {
+            return 1;
+          };
+
+          return function evalDimension(scope, args, context) {
+            return createRange(_evalStart(scope, args, context), _evalEnd(scope, args, context), _evalStep(scope, args, context));
+          };
+        }
+      } else if (type.isSymbolNode(range) && range.name === 'end') {
+        // SymbolNode 'end'
+        var _childArgNames = Object.create(argNames);
+
+        _childArgNames['end'] = true;
+
+        var evalRange = range._compile(math, _childArgNames);
+
+        return function evalDimension(scope, args, context) {
+          var size = math.size(context).valueOf();
+          var childArgs = Object.create(args);
+          childArgs['end'] = size[i];
+          return evalRange(scope, childArgs, context);
+        };
+      } else {
+        // ConstantNode
+        var _evalRange = range._compile(math, argNames);
+
+        return function evalDimension(scope, args, context) {
+          return _evalRange(scope, args, context);
+        };
+      }
+    });
+    return function evalIndexNode(scope, args, context) {
+      var dimensions = map(evalDimensions, function (evalDimension) {
+        return evalDimension(scope, args, context);
+      });
+      return math.index.apply(math, dimensions);
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  IndexNode.prototype.forEach = function (callback) {
+    for (var i = 0; i < this.dimensions.length; i++) {
+      callback(this.dimensions[i], 'dimensions[' + i + ']', this);
+    }
+  };
+  /**
+   * Create a new IndexNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {IndexNode} Returns a transformed copy of the node
+   */
+
+
+  IndexNode.prototype.map = function (callback) {
+    var dimensions = [];
+
+    for (var i = 0; i < this.dimensions.length; i++) {
+      dimensions[i] = this._ifNode(callback(this.dimensions[i], 'dimensions[' + i + ']', this));
+    }
+
+    return new IndexNode(dimensions);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {IndexNode}
+   */
+
+
+  IndexNode.prototype.clone = function () {
+    return new IndexNode(this.dimensions.slice(0));
+  };
+  /**
+   * Test whether this IndexNode contains a single property name
+   * @return {boolean}
+   */
+
+
+  IndexNode.prototype.isObjectProperty = function () {
+    return this.dimensions.length === 1 && type.isConstantNode(this.dimensions[0]) && typeof this.dimensions[0].value === 'string';
+  };
+  /**
+   * Returns the property name if IndexNode contains a property.
+   * If not, returns null.
+   * @return {string | null}
+   */
+
+
+  IndexNode.prototype.getObjectProperty = function () {
+    return this.isObjectProperty() ? this.dimensions[0].value : null;
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  IndexNode.prototype._toString = function (options) {
+    // format the parameters like "[1, 0:5]"
+    return this.dotNotation ? '.' + this.getObjectProperty() : '[' + this.dimensions.join(', ') + ']';
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  IndexNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'IndexNode',
+      dimensions: this.dimensions,
+      dotNotation: this.dotNotation
+    };
+  };
+  /**
+   * Instantiate an IndexNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "IndexNode", dimensions: [...], dotNotation: false}`,
+   *                       where mathjs is optional
+   * @returns {IndexNode}
+   */
+
+
+  IndexNode.fromJSON = function (json) {
+    return new IndexNode(json.dimensions, json.dotNotation);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  IndexNode.prototype.toHTML = function (options) {
+    // format the parameters like "[1, 0:5]"
+    var dimensions = [];
+
+    for (var i = 0; i < this.dimensions.length; i++) {
+      dimensions[i] = this.dimensions[i].toHTML();
+    }
+
+    if (this.dotNotation) {
+      return '<span class="math-operator math-accessor-operator">.</span>' + '<span class="math-symbol math-property">' + escape(this.getObjectProperty()) + '</span>';
+    } else {
+      return '<span class="math-parenthesis math-square-parenthesis">[</span>' + dimensions.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-square-parenthesis">]</span>';
+    }
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  IndexNode.prototype._toTex = function (options) {
+    var dimensions = this.dimensions.map(function (range) {
+      return range.toTex(options);
+    });
+    return this.dotNotation ? '.' + this.getObjectProperty() + '' : '_{' + dimensions.join(',') + '}';
+  }; // helper function to create a Range from start, step and end
+
+
+  function createRange(start, end, step) {
+    return new Range(type.isBigNumber(start) ? start.toNumber() : start, type.isBigNumber(end) ? end.toNumber() : end, type.isBigNumber(step) ? step.toNumber() : step);
+  }
+
+  return IndexNode;
+}
+
+exports.name = 'IndexNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../type/matrix/Range":41,"../../utils/array":46,"../../utils/string":57,"./Node":24}],24:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var keywords = require('../keywords');
+
+var deepEqual = require('../../utils/object').deepEqual;
+
+var hasOwnProperty = require('../../utils/object').hasOwnProperty;
+
+function factory(type, config, load, typed, math) {
+  /**
+   * Node
+   */
+  function Node() {
+    if (!(this instanceof Node)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+  }
+  /**
+   * Evaluate the node
+   * @param {Object} [scope]  Scope to read/write variables
+   * @return {*}              Returns the result
+   */
+
+
+  Node.prototype.eval = function (scope) {
+    return this.compile().eval(scope);
+  };
+
+  Node.prototype.type = 'Node';
+  Node.prototype.isNode = true;
+  Node.prototype.comment = '';
+  /**
+   * Compile the node into an optimized, evauatable JavaScript function
+   * @return {{eval: function([Object])}} expr  Returns an object with a function 'eval',
+   *                                  which can be invoked as expr.eval([scope: Object]),
+   *                                  where scope is an optional object with
+   *                                  variables.
+   */
+
+  Node.prototype.compile = function () {
+    var expr = this._compile(math.expression.mathWithTransform, {});
+
+    var args = {};
+    var context = null;
+    return {
+      eval: function evalNode(scope) {
+        var s = scope || {};
+
+        _validateScope(s);
+
+        return expr(s, args, context);
+      }
+    };
+  };
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+
+  Node.prototype._compile = function (math, argNames) {
+    throw new Error('Method _compile should be implemented by type ' + this.type);
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  Node.prototype.forEach = function (callback) {
+    // must be implemented by each of the Node implementations
+    throw new Error('Cannot run forEach on a Node interface');
+  };
+  /**
+   * Create a new Node having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {OperatorNode} Returns a transformed copy of the node
+   */
+
+
+  Node.prototype.map = function (callback) {
+    // must be implemented by each of the Node implementations
+    throw new Error('Cannot run map on a Node interface');
+  };
+  /**
+   * Validate whether an object is a Node, for use with map
+   * @param {Node} node
+   * @returns {Node} Returns the input if it's a node, else throws an Error
+   * @protected
+   */
+
+
+  Node.prototype._ifNode = function (node) {
+    if (!type.isNode(node)) {
+      throw new TypeError('Callback function must return a Node');
+    }
+
+    return node;
+  };
+  /**
+   * Recursively traverse all nodes in a node tree. Executes given callback for
+   * this node and each of its child nodes.
+   * @param {function(node: Node, path: string, parent: Node)} callback
+   *          A callback called for every node in the node tree.
+   */
+
+
+  Node.prototype.traverse = function (callback) {
+    // execute callback for itself
+    callback(this, null, null); // eslint-disable-line standard/no-callback-literal
+    // recursively traverse over all childs of a node
+
+    function _traverse(node, callback) {
+      node.forEach(function (child, path, parent) {
+        callback(child, path, parent);
+
+        _traverse(child, callback);
+      });
+    }
+
+    _traverse(this, callback);
+  };
+  /**
+   * Recursively transform a node tree via a transform function.
+   *
+   * For example, to replace all nodes of type SymbolNode having name 'x' with a
+   * ConstantNode with value 2:
+   *
+   *     const res = Node.transform(function (node, path, parent) {
+   *       if (node && node.isSymbolNode) && (node.name === 'x')) {
+   *         return new ConstantNode(2)
+   *       }
+   *       else {
+   *         return node
+   *       }
+   *     })
+   *
+   * @param {function(node: Node, path: string, parent: Node) : Node} callback
+   *          A mapping function accepting a node, and returning
+   *          a replacement for the node or the original node.
+   *          Signature: callback(node: Node, index: string, parent: Node) : Node
+   * @return {Node} Returns the original node or its replacement
+   */
+
+
+  Node.prototype.transform = function (callback) {
+    // traverse over all childs
+    function _transform(node, callback) {
+      return node.map(function (child, path, parent) {
+        var replacement = callback(child, path, parent);
+        return _transform(replacement, callback);
+      });
+    }
+
+    var replacement = callback(this, null, null); // eslint-disable-line standard/no-callback-literal
+
+    return _transform(replacement, callback);
+  };
+  /**
+   * Find any node in the node tree matching given filter function. For example, to
+   * find all nodes of type SymbolNode having name 'x':
+   *
+   *     const results = Node.filter(function (node) {
+   *       return (node && node.isSymbolNode) && (node.name === 'x')
+   *     })
+   *
+   * @param {function(node: Node, path: string, parent: Node) : Node} callback
+   *            A test function returning true when a node matches, and false
+   *            otherwise. Function signature:
+   *            callback(node: Node, index: string, parent: Node) : boolean
+   * @return {Node[]} nodes       An array with nodes matching given filter criteria
+   */
+
+
+  Node.prototype.filter = function (callback) {
+    var nodes = [];
+    this.traverse(function (node, path, parent) {
+      if (callback(node, path, parent)) {
+        nodes.push(node);
+      }
+    });
+    return nodes;
+  }; // TODO: deprecated since version 1.1.0, remove this some day
+
+
+  Node.prototype.find = function () {
+    throw new Error('Function Node.find is deprecated. Use Node.filter instead.');
+  }; // TODO: deprecated since version 1.1.0, remove this some day
+
+
+  Node.prototype.match = function () {
+    throw new Error('Function Node.match is deprecated. See functions Node.filter, Node.transform, Node.traverse.');
+  };
+  /**
+   * Create a shallow clone of this node
+   * @return {Node}
+   */
+
+
+  Node.prototype.clone = function () {
+    // must be implemented by each of the Node implementations
+    throw new Error('Cannot clone a Node interface');
+  };
+  /**
+   * Create a deep clone of this node
+   * @return {Node}
+   */
+
+
+  Node.prototype.cloneDeep = function () {
+    return this.map(function (node) {
+      return node.cloneDeep();
+    });
+  };
+  /**
+   * Deep compare this node with another node.
+   * @param {Node} other
+   * @return {boolean} Returns true when both nodes are of the same type and
+   *                   contain the same values (as do their childs)
+   */
+
+
+  Node.prototype.equals = function (other) {
+    return other ? deepEqual(this, other) : false;
+  };
+  /**
+   * Get string representation. (wrapper function)
+   *
+   * This function can get an object of the following form:
+   * {
+   *    handler: //This can be a callback function of the form
+   *             // "function callback(node, options)"or
+   *             // a map that maps function names (used in FunctionNodes)
+   *             // to callbacks
+   *    parenthesis: "keep" //the parenthesis option (This is optional)
+   * }
+   *
+   * @param {Object} [options]
+   * @return {string}
+   */
+
+
+  Node.prototype.toString = function (options) {
+    var customString;
+
+    if (options && _typeof(options) === 'object') {
+      switch (_typeof(options.handler)) {
+        case 'object':
+        case 'undefined':
+          break;
+
+        case 'function':
+          customString = options.handler(this, options);
+          break;
+
+        default:
+          throw new TypeError('Object or function expected as callback');
+      }
+    }
+
+    if (typeof customString !== 'undefined') {
+      return customString;
+    }
+
+    return this._toString(options);
+  };
+  /**
+   * Get a JSON representation of the node
+   * Both .toJSON() and the static .fromJSON(json) should be implemented by all
+   * implementations of Node
+   * @returns {Object}
+   */
+
+
+  Node.prototype.toJSON = function () {
+    throw new Error('Cannot serialize object: toJSON not implemented by ' + this.type);
+  };
+  /**
+   * Get HTML representation. (wrapper function)
+   *
+   * This function can get an object of the following form:
+   * {
+   *    handler: //This can be a callback function of the form
+   *             // "function callback(node, options)" or
+   *             // a map that maps function names (used in FunctionNodes)
+   *             // to callbacks
+   *    parenthesis: "keep" //the parenthesis option (This is optional)
+   * }
+   *
+   * @param {Object} [options]
+   * @return {string}
+   */
+
+
+  Node.prototype.toHTML = function (options) {
+    var customString;
+
+    if (options && _typeof(options) === 'object') {
+      switch (_typeof(options.handler)) {
+        case 'object':
+        case 'undefined':
+          break;
+
+        case 'function':
+          customString = options.handler(this, options);
+          break;
+
+        default:
+          throw new TypeError('Object or function expected as callback');
+      }
+    }
+
+    if (typeof customString !== 'undefined') {
+      return customString;
+    }
+
+    return this.toHTML(options);
+  };
+  /**
+   * Internal function to generate the string output.
+   * This has to be implemented by every Node
+   *
+   * @throws {Error}
+   */
+
+
+  Node.prototype._toString = function () {
+    // must be implemented by each of the Node implementations
+    throw new Error('_toString not implemented for ' + this.type);
+  };
+  /**
+   * Get LaTeX representation. (wrapper function)
+   *
+   * This function can get an object of the following form:
+   * {
+   *    handler: //This can be a callback function of the form
+   *             // "function callback(node, options)"or
+   *             // a map that maps function names (used in FunctionNodes)
+   *             // to callbacks
+   *    parenthesis: "keep" //the parenthesis option (This is optional)
+   * }
+   *
+   * @param {Object} [options]
+   * @return {string}
+   */
+
+
+  Node.prototype.toTex = function (options) {
+    var customTex;
+
+    if (options && _typeof(options) === 'object') {
+      switch (_typeof(options.handler)) {
+        case 'object':
+        case 'undefined':
+          break;
+
+        case 'function':
+          customTex = options.handler(this, options);
+          break;
+
+        default:
+          throw new TypeError('Object or function expected as callback');
+      }
+    }
+
+    if (typeof customTex !== 'undefined') {
+      return customTex;
+    }
+
+    return this._toTex(options);
+  };
+  /**
+   * Internal function to generate the LaTeX output.
+   * This has to be implemented by every Node
+   *
+   * @param {Object} [options]
+   * @throws {Error}
+   */
+
+
+  Node.prototype._toTex = function (options) {
+    // must be implemented by each of the Node implementations
+    throw new Error('_toTex not implemented for ' + this.type);
+  };
+  /**
+   * Get identifier.
+   * @return {string}
+   */
+
+
+  Node.prototype.getIdentifier = function () {
+    return this.type;
+  };
+  /**
+   * Get the content of the current Node.
+   * @return {Node} node
+   **/
+
+
+  Node.prototype.getContent = function () {
+    return this;
+  };
+  /**
+   * Validate the symbol names of a scope.
+   * Throws an error when the scope contains an illegal symbol.
+   * @param {Object} scope
+   */
+
+
+  function _validateScope(scope) {
+    for (var symbol in scope) {
+      if (hasOwnProperty(scope, symbol)) {
+        if (symbol in keywords) {
+          throw new Error('Scope contains an illegal symbol, "' + symbol + '" is a reserved keyword');
+        }
+      }
+    }
+  }
+
+  return Node;
+}
+
+exports.name = 'Node';
+exports.path = 'expression.node';
+exports.math = true; // request access to the math namespace as 5th argument of the factory function
+
+exports.factory = factory;
+},{"../../utils/object":55,"../keywords":14}],25:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var stringify = require('../../utils/string').stringify;
+
+var escape = require('../../utils/string').escape;
+
+var isSafeProperty = require('../../utils/customs').isSafeProperty;
+
+var hasOwnProperty = require('../../utils/object').hasOwnProperty;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  /**
+   * @constructor ObjectNode
+   * @extends {Node}
+   * Holds an object with keys/values
+   * @param {Object.<string, Node>} [properties]   object with key/value pairs
+   */
+
+  function ObjectNode(properties) {
+    if (!(this instanceof ObjectNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    this.properties = properties || {}; // validate input
+
+    if (properties) {
+      if (!(_typeof(properties) === 'object') || !Object.keys(properties).every(function (key) {
+        return type.isNode(properties[key]);
+      })) {
+        throw new TypeError('Object containing Nodes expected');
+      }
+    }
+  }
+
+  ObjectNode.prototype = new Node();
+  ObjectNode.prototype.type = 'ObjectNode';
+  ObjectNode.prototype.isObjectNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  ObjectNode.prototype._compile = function (math, argNames) {
+    var evalEntries = {};
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        // we stringify/parse the key here to resolve unicode characters,
+        // so you cannot create a key like {"co\\u006Estructor": null}
+        var stringifiedKey = stringify(key);
+        var parsedKey = JSON.parse(stringifiedKey);
+
+        if (!isSafeProperty(this.properties, parsedKey)) {
+          throw new Error('No access to property "' + parsedKey + '"');
+        }
+
+        evalEntries[parsedKey] = this.properties[key]._compile(math, argNames);
+      }
+    }
+
+    return function evalObjectNode(scope, args, context) {
+      var obj = {};
+
+      for (var _key in evalEntries) {
+        if (hasOwnProperty(evalEntries, _key)) {
+          obj[_key] = evalEntries[_key](scope, args, context);
+        }
+      }
+
+      return obj;
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  ObjectNode.prototype.forEach = function (callback) {
+    for (var key in this.properties) {
+      if (this.properties.hasOwnProperty(key)) {
+        callback(this.properties[key], 'properties[' + stringify(key) + ']', this);
+      }
+    }
+  };
+  /**
+   * Create a new ObjectNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {ObjectNode} Returns a transformed copy of the node
+   */
+
+
+  ObjectNode.prototype.map = function (callback) {
+    var properties = {};
+
+    for (var key in this.properties) {
+      if (this.properties.hasOwnProperty(key)) {
+        properties[key] = this._ifNode(callback(this.properties[key], 'properties[' + stringify(key) + ']', this));
+      }
+    }
+
+    return new ObjectNode(properties);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {ObjectNode}
+   */
+
+
+  ObjectNode.prototype.clone = function () {
+    var properties = {};
+
+    for (var key in this.properties) {
+      if (this.properties.hasOwnProperty(key)) {
+        properties[key] = this.properties[key];
+      }
+    }
+
+    return new ObjectNode(properties);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ObjectNode.prototype._toString = function (options) {
+    var entries = [];
+
+    for (var key in this.properties) {
+      if (this.properties.hasOwnProperty(key)) {
+        entries.push(stringify(key) + ': ' + this.properties[key].toString(options));
+      }
+    }
+
+    return '{' + entries.join(', ') + '}';
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  ObjectNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'ObjectNode',
+      properties: this.properties
+    };
+  };
+  /**
+   * Instantiate an OperatorNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "ObjectNode", "properties": {...}}`,
+   *                       where mathjs is optional
+   * @returns {ObjectNode}
+   */
+
+
+  ObjectNode.fromJSON = function (json) {
+    return new ObjectNode(json.properties);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ObjectNode.prototype.toHTML = function (options) {
+    var entries = [];
+
+    for (var key in this.properties) {
+      if (this.properties.hasOwnProperty(key)) {
+        entries.push('<span class="math-symbol math-property">' + escape(key) + '</span>' + '<span class="math-operator math-assignment-operator math-property-assignment-operator math-binary-operator">:</span>' + this.properties[key].toHTML(options));
+      }
+    }
+
+    return '<span class="math-parenthesis math-curly-parenthesis">{</span>' + entries.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-curly-parenthesis">}</span>';
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ObjectNode.prototype._toTex = function (options) {
+    var entries = [];
+
+    for (var key in this.properties) {
+      if (this.properties.hasOwnProperty(key)) {
+        entries.push('\\mathbf{' + key + ':} & ' + this.properties[key].toTex(options) + '\\\\');
+      }
+    }
+
+    return "\\left\\{\\begin{array}{ll}".concat(entries.join('\n'), "\\end{array}\\right\\}");
+  };
+
+  return ObjectNode;
+}
+
+exports.name = 'ObjectNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/customs":51,"../../utils/object":55,"../../utils/string":57,"./Node":24}],26:[function(require,module,exports){
+'use strict';
+
+var latex = require('../../utils/latex');
+
+var map = require('../../utils/array').map;
+
+var escape = require('../../utils/string').escape;
+
+var isSafeMethod = require('../../utils/customs').isSafeMethod;
+
+var getSafeProperty = require('../../utils/customs').getSafeProperty;
+
+var operators = require('../operators');
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  /**
+   * @constructor OperatorNode
+   * @extends {Node}
+   * An operator with two arguments, like 2+3
+   *
+   * @param {string} op           Operator name, for example '+'
+   * @param {string} fn           Function name, for example 'add'
+   * @param {Node[]} args         Operator arguments
+   * @param {boolean} [implicit]  Is this an implicit multiplication?
+   */
+
+  function OperatorNode(op, fn, args, implicit) {
+    if (!(this instanceof OperatorNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    } // validate input
+
+
+    if (typeof op !== 'string') {
+      throw new TypeError('string expected for parameter "op"');
+    }
+
+    if (typeof fn !== 'string') {
+      throw new TypeError('string expected for parameter "fn"');
+    }
+
+    if (!Array.isArray(args) || !args.every(type.isNode)) {
+      throw new TypeError('Array containing Nodes expected for parameter "args"');
+    }
+
+    this.implicit = implicit === true;
+    this.op = op;
+    this.fn = fn;
+    this.args = args || [];
+  }
+
+  OperatorNode.prototype = new Node();
+  OperatorNode.prototype.type = 'OperatorNode';
+  OperatorNode.prototype.isOperatorNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  OperatorNode.prototype._compile = function (math, argNames) {
+    // validate fn
+    if (typeof this.fn !== 'string' || !isSafeMethod(math, this.fn)) {
+      if (!math[this.fn]) {
+        throw new Error('Function ' + this.fn + ' missing in provided namespace "math"');
+      } else {
+        throw new Error('No access to function "' + this.fn + '"');
+      }
+    }
+
+    var fn = getSafeProperty(math, this.fn);
+    var evalArgs = map(this.args, function (arg) {
+      return arg._compile(math, argNames);
+    });
+
+    if (evalArgs.length === 1) {
+      var evalArg0 = evalArgs[0];
+      return function evalOperatorNode(scope, args, context) {
+        return fn(evalArg0(scope, args, context));
+      };
+    } else if (evalArgs.length === 2) {
+      var _evalArg = evalArgs[0];
+      var evalArg1 = evalArgs[1];
+      return function evalOperatorNode(scope, args, context) {
+        return fn(_evalArg(scope, args, context), evalArg1(scope, args, context));
+      };
+    } else {
+      return function evalOperatorNode(scope, args, context) {
+        return fn.apply(null, map(evalArgs, function (evalArg) {
+          return evalArg(scope, args, context);
+        }));
+      };
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  OperatorNode.prototype.forEach = function (callback) {
+    for (var i = 0; i < this.args.length; i++) {
+      callback(this.args[i], 'args[' + i + ']', this);
+    }
+  };
+  /**
+   * Create a new OperatorNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {OperatorNode} Returns a transformed copy of the node
+   */
+
+
+  OperatorNode.prototype.map = function (callback) {
+    var args = [];
+
+    for (var i = 0; i < this.args.length; i++) {
+      args[i] = this._ifNode(callback(this.args[i], 'args[' + i + ']', this));
+    }
+
+    return new OperatorNode(this.op, this.fn, args, this.implicit);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {OperatorNode}
+   */
+
+
+  OperatorNode.prototype.clone = function () {
+    return new OperatorNode(this.op, this.fn, this.args.slice(0), this.implicit);
+  };
+  /**
+   * Check whether this is an unary OperatorNode:
+   * has exactly one argument, like `-a`.
+   * @return {boolean} Returns true when an unary operator node, false otherwise.
+   */
+
+
+  OperatorNode.prototype.isUnary = function () {
+    return this.args.length === 1;
+  };
+  /**
+   * Check whether this is a binary OperatorNode:
+   * has exactly two arguments, like `a + b`.
+   * @return {boolean} Returns true when a binary operator node, false otherwise.
+   */
+
+
+  OperatorNode.prototype.isBinary = function () {
+    return this.args.length === 2;
+  };
+  /**
+   * Calculate which parentheses are necessary. Gets an OperatorNode
+   * (which is the root of the tree) and an Array of Nodes
+   * (this.args) and returns an array where 'true' means that an argument
+   * has to be enclosed in parentheses whereas 'false' means the opposite.
+   *
+   * @param {OperatorNode} root
+   * @param {string} parenthesis
+   * @param {Node[]} args
+   * @param {boolean} latex
+   * @return {boolean[]}
+   * @private
+   */
+
+
+  function calculateNecessaryParentheses(root, parenthesis, implicit, args, latex) {
+    // precedence of the root OperatorNode
+    var precedence = operators.getPrecedence(root, parenthesis);
+    var associativity = operators.getAssociativity(root, parenthesis);
+
+    if (parenthesis === 'all' || args.length > 2 && root.getIdentifier() !== 'OperatorNode:add' && root.getIdentifier() !== 'OperatorNode:multiply') {
+      var parens = args.map(function (arg) {
+        switch (arg.getContent().type) {
+          // Nodes that don't need extra parentheses
+          case 'ArrayNode':
+          case 'ConstantNode':
+          case 'SymbolNode':
+          case 'ParenthesisNode':
+            return false;
+
+          default:
+            return true;
+        }
+      });
+      return parens;
+    }
+
+    var result;
+
+    switch (args.length) {
+      case 0:
+        result = [];
+        break;
+
+      case 1:
+        // unary operators
+        // precedence of the operand
+        var operandPrecedence = operators.getPrecedence(args[0], parenthesis); // handle special cases for LaTeX, where some of the parentheses aren't needed
+
+        if (latex && operandPrecedence !== null) {
+          var operandIdentifier;
+          var rootIdentifier;
+
+          if (parenthesis === 'keep') {
+            operandIdentifier = args[0].getIdentifier();
+            rootIdentifier = root.getIdentifier();
+          } else {
+            // Ignore Parenthesis Nodes when not in 'keep' mode
+            operandIdentifier = args[0].getContent().getIdentifier();
+            rootIdentifier = root.getContent().getIdentifier();
+          }
+
+          if (operators.properties[precedence][rootIdentifier].latexLeftParens === false) {
+            result = [false];
+            break;
+          }
+
+          if (operators.properties[operandPrecedence][operandIdentifier].latexParens === false) {
+            result = [false];
+            break;
+          }
+        }
+
+        if (operandPrecedence === null) {
+          // if the operand has no defined precedence, no parens are needed
+          result = [false];
+          break;
+        }
+
+        if (operandPrecedence <= precedence) {
+          // if the operands precedence is lower, parens are needed
+          result = [true];
+          break;
+        } // otherwise, no parens needed
+
+
+        result = [false];
+        break;
+
+      case 2:
+        // binary operators
+        var lhsParens; // left hand side needs parenthesis?
+        // precedence of the left hand side
+
+        var lhsPrecedence = operators.getPrecedence(args[0], parenthesis); // is the root node associative with the left hand side
+
+        var assocWithLhs = operators.isAssociativeWith(root, args[0], parenthesis);
+
+        if (lhsPrecedence === null) {
+          // if the left hand side has no defined precedence, no parens are needed
+          // FunctionNode for example
+          lhsParens = false;
+        } else if (lhsPrecedence === precedence && associativity === 'right' && !assocWithLhs) {
+          // In case of equal precedence, if the root node is left associative
+          // parens are **never** necessary for the left hand side.
+          // If it is right associative however, parens are necessary
+          // if the root node isn't associative with the left hand side
+          lhsParens = true;
+        } else if (lhsPrecedence < precedence) {
+          lhsParens = true;
+        } else {
+          lhsParens = false;
+        }
+
+        var rhsParens; // right hand side needs parenthesis?
+        // precedence of the right hand side
+
+        var rhsPrecedence = operators.getPrecedence(args[1], parenthesis); // is the root node associative with the right hand side?
+
+        var assocWithRhs = operators.isAssociativeWith(root, args[1], parenthesis);
+
+        if (rhsPrecedence === null) {
+          // if the right hand side has no defined precedence, no parens are needed
+          // FunctionNode for example
+          rhsParens = false;
+        } else if (rhsPrecedence === precedence && associativity === 'left' && !assocWithRhs) {
+          // In case of equal precedence, if the root node is right associative
+          // parens are **never** necessary for the right hand side.
+          // If it is left associative however, parens are necessary
+          // if the root node isn't associative with the right hand side
+          rhsParens = true;
+        } else if (rhsPrecedence < precedence) {
+          rhsParens = true;
+        } else {
+          rhsParens = false;
+        } // handle special cases for LaTeX, where some of the parentheses aren't needed
+
+
+        if (latex) {
+          var _rootIdentifier;
+
+          var lhsIdentifier;
+          var rhsIdentifier;
+
+          if (parenthesis === 'keep') {
+            _rootIdentifier = root.getIdentifier();
+            lhsIdentifier = root.args[0].getIdentifier();
+            rhsIdentifier = root.args[1].getIdentifier();
+          } else {
+            // Ignore ParenthesisNodes when not in 'keep' mode
+            _rootIdentifier = root.getContent().getIdentifier();
+            lhsIdentifier = root.args[0].getContent().getIdentifier();
+            rhsIdentifier = root.args[1].getContent().getIdentifier();
+          }
+
+          if (lhsPrecedence !== null) {
+            if (operators.properties[precedence][_rootIdentifier].latexLeftParens === false) {
+              lhsParens = false;
+            }
+
+            if (operators.properties[lhsPrecedence][lhsIdentifier].latexParens === false) {
+              lhsParens = false;
+            }
+          }
+
+          if (rhsPrecedence !== null) {
+            if (operators.properties[precedence][_rootIdentifier].latexRightParens === false) {
+              rhsParens = false;
+            }
+
+            if (operators.properties[rhsPrecedence][rhsIdentifier].latexParens === false) {
+              rhsParens = false;
+            }
+          }
+        }
+
+        result = [lhsParens, rhsParens];
+        break;
+
+      default:
+        if (root.getIdentifier() === 'OperatorNode:add' || root.getIdentifier() === 'OperatorNode:multiply') {
+          result = args.map(function (arg) {
+            var argPrecedence = operators.getPrecedence(arg, parenthesis);
+            var assocWithArg = operators.isAssociativeWith(root, arg, parenthesis);
+            var argAssociativity = operators.getAssociativity(arg, parenthesis);
+
+            if (argPrecedence === null) {
+              // if the argument has no defined precedence, no parens are needed
+              return false;
+            } else if (precedence === argPrecedence && associativity === argAssociativity && !assocWithArg) {
+              return true;
+            } else if (argPrecedence < precedence) {
+              return true;
+            }
+
+            return false;
+          });
+        }
+
+        break;
+    } // handles an edge case of 'auto' parentheses with implicit multiplication of ConstantNode
+    // In that case print parentheses for ParenthesisNodes even though they normally wouldn't be
+    // printed.
+
+
+    if (args.length >= 2 && root.getIdentifier() === 'OperatorNode:multiply' && root.implicit && parenthesis === 'auto' && implicit === 'hide') {
+      result = args.map(function (arg, index) {
+        var isParenthesisNode = arg.getIdentifier() === 'ParenthesisNode';
+
+        if (result[index] || isParenthesisNode) {
+          // put in parenthesis?
+          return true;
+        }
+
+        return false;
+      });
+    }
+
+    return result;
+  }
+  /**
+   * Get string representation.
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  OperatorNode.prototype._toString = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var implicit = options && options.implicit ? options.implicit : 'hide';
+    var args = this.args;
+    var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false);
+
+    if (args.length === 1) {
+      // unary operators
+      var assoc = operators.getAssociativity(this, parenthesis);
+      var operand = args[0].toString(options);
+
+      if (parens[0]) {
+        operand = '(' + operand + ')';
+      }
+
+      if (assoc === 'right') {
+        // prefix operator
+        return this.op + operand;
+      } else if (assoc === 'left') {
+        // postfix
+        return operand + this.op;
+      } // fall back to postfix
+
+
+      return operand + this.op;
+    } else if (args.length === 2) {
+      var lhs = args[0].toString(options); // left hand side
+
+      var rhs = args[1].toString(options); // right hand side
+
+      if (parens[0]) {
+        // left hand side in parenthesis?
+        lhs = '(' + lhs + ')';
+      }
+
+      if (parens[1]) {
+        // right hand side in parenthesis?
+        rhs = '(' + rhs + ')';
+      }
+
+      if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+        return lhs + ' ' + rhs;
+      }
+
+      return lhs + ' ' + this.op + ' ' + rhs;
+    } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
+      var stringifiedArgs = args.map(function (arg, index) {
+        arg = arg.toString(options);
+
+        if (parens[index]) {
+          // put in parenthesis?
+          arg = '(' + arg + ')';
+        }
+
+        return arg;
+      });
+
+      if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+        return stringifiedArgs.join(' ');
+      }
+
+      return stringifiedArgs.join(' ' + this.op + ' ');
+    } else {
+      // fallback to formatting as a function call
+      return this.fn + '(' + this.args.join(', ') + ')';
+    }
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  OperatorNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'OperatorNode',
+      op: this.op,
+      fn: this.fn,
+      args: this.args,
+      implicit: this.implicit
+    };
+  };
+  /**
+   * Instantiate an OperatorNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [...], "implicit": false}`,
+   *                       where mathjs is optional
+   * @returns {OperatorNode}
+   */
+
+
+  OperatorNode.fromJSON = function (json) {
+    return new OperatorNode(json.op, json.fn, json.args, json.implicit);
+  };
+  /**
+   * Get HTML representation.
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  OperatorNode.prototype.toHTML = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var implicit = options && options.implicit ? options.implicit : 'hide';
+    var args = this.args;
+    var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false);
+
+    if (args.length === 1) {
+      // unary operators
+      var assoc = operators.getAssociativity(this, parenthesis);
+      var operand = args[0].toHTML(options);
+
+      if (parens[0]) {
+        operand = '<span class="math-parenthesis math-round-parenthesis">(</span>' + operand + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      }
+
+      if (assoc === 'right') {
+        // prefix operator
+        return '<span class="math-operator math-unary-operator math-lefthand-unary-operator">' + escape(this.op) + '</span>' + operand;
+      } else if (assoc === 'left') {
+        // postfix
+        return '<span class="math-operator math-unary-operator math-righthand-unary-operator">' + escape(this.op) + '</span>' + operand;
+      } // fall back to postfix
+
+
+      return '<span class="math-operator math-unary-operator math-righthand-unary-operator">' + escape(this.op) + '</span>' + operand;
+    } else if (args.length === 2) {
+      // binary operatoes
+      var lhs = args[0].toHTML(options); // left hand side
+
+      var rhs = args[1].toHTML(options); // right hand side
+
+      if (parens[0]) {
+        // left hand side in parenthesis?
+        lhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + lhs + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      }
+
+      if (parens[1]) {
+        // right hand side in parenthesis?
+        rhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + rhs + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      }
+
+      if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+        return lhs + '<span class="math-operator math-binary-operator math-implicit-binary-operator"></span>' + rhs;
+      }
+
+      return lhs + '<span class="math-operator math-binary-operator math-explicit-binary-operator">' + escape(this.op) + '</span>' + rhs;
+    } else {
+      var stringifiedArgs = args.map(function (arg, index) {
+        arg = arg.toHTML(options);
+
+        if (parens[index]) {
+          // put in parenthesis?
+          arg = '<span class="math-parenthesis math-round-parenthesis">(</span>' + arg + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+        }
+
+        return arg;
+      });
+
+      if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
+        if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+          return stringifiedArgs.join('<span class="math-operator math-binary-operator math-implicit-binary-operator"></span>');
+        }
+
+        return stringifiedArgs.join('<span class="math-operator math-binary-operator math-explicit-binary-operator">' + escape(this.op) + '</span>');
+      } else {
+        // fallback to formatting as a function call
+        return '<span class="math-function">' + escape(this.fn) + '</span><span class="math-paranthesis math-round-parenthesis">(</span>' + stringifiedArgs.join('<span class="math-separator">,</span>') + '<span class="math-paranthesis math-round-parenthesis">)</span>';
+      }
+    }
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  OperatorNode.prototype._toTex = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var implicit = options && options.implicit ? options.implicit : 'hide';
+    var args = this.args;
+    var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, true);
+    var op = latex.operators[this.fn];
+    op = typeof op === 'undefined' ? this.op : op; // fall back to using this.op
+
+    if (args.length === 1) {
+      // unary operators
+      var assoc = operators.getAssociativity(this, parenthesis);
+      var operand = args[0].toTex(options);
+
+      if (parens[0]) {
+        operand = "\\left(".concat(operand, "\\right)");
+      }
+
+      if (assoc === 'right') {
+        // prefix operator
+        return op + operand;
+      } else if (assoc === 'left') {
+        // postfix operator
+        return operand + op;
+      } // fall back to postfix
+
+
+      return operand + op;
+    } else if (args.length === 2) {
+      // binary operators
+      var lhs = args[0]; // left hand side
+
+      var lhsTex = lhs.toTex(options);
+
+      if (parens[0]) {
+        lhsTex = "\\left(".concat(lhsTex, "\\right)");
+      }
+
+      var rhs = args[1]; // right hand side
+
+      var rhsTex = rhs.toTex(options);
+
+      if (parens[1]) {
+        rhsTex = "\\left(".concat(rhsTex, "\\right)");
+      } // handle some exceptions (due to the way LaTeX works)
+
+
+      var lhsIdentifier;
+
+      if (parenthesis === 'keep') {
+        lhsIdentifier = lhs.getIdentifier();
+      } else {
+        // Ignore ParenthesisNodes if in 'keep' mode
+        lhsIdentifier = lhs.getContent().getIdentifier();
+      }
+
+      switch (this.getIdentifier()) {
+        case 'OperatorNode:divide':
+          // op contains '\\frac' at this point
+          return op + '{' + lhsTex + '}' + '{' + rhsTex + '}';
+
+        case 'OperatorNode:pow':
+          lhsTex = '{' + lhsTex + '}';
+          rhsTex = '{' + rhsTex + '}';
+
+          switch (lhsIdentifier) {
+            case 'ConditionalNode': //
+
+            case 'OperatorNode:divide':
+              lhsTex = "\\left(".concat(lhsTex, "\\right)");
+          }
+
+          break;
+
+        case 'OperatorNode:multiply':
+          if (this.implicit && implicit === 'hide') {
+            return lhsTex + '~' + rhsTex;
+          }
+
+      }
+
+      return lhsTex + op + rhsTex;
+    } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
+      var texifiedArgs = args.map(function (arg, index) {
+        arg = arg.toTex(options);
+
+        if (parens[index]) {
+          arg = "\\left(".concat(arg, "\\right)");
+        }
+
+        return arg;
+      });
+
+      if (this.getIdentifier() === 'OperatorNode:multiply' && this.implicit) {
+        return texifiedArgs.join('~');
+      }
+
+      return texifiedArgs.join(op);
+    } else {
+      // fall back to formatting as a function call
+      // as this is a fallback, it doesn't use
+      // fancy function names
+      return '\\mathrm{' + this.fn + '}\\left(' + args.map(function (arg) {
+        return arg.toTex(options);
+      }).join(',') + '\\right)';
+    }
+  };
+  /**
+   * Get identifier.
+   * @return {string}
+   */
+
+
+  OperatorNode.prototype.getIdentifier = function () {
+    return this.type + ':' + this.fn;
+  };
+
+  return OperatorNode;
+}
+
+exports.name = 'OperatorNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../operators":33,"./Node":24}],27:[function(require,module,exports){
+'use strict';
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  /**
+   * @constructor ParenthesisNode
+   * @extends {Node}
+   * A parenthesis node describes manual parenthesis from the user input
+   * @param {Node} content
+   * @extends {Node}
+   */
+
+  function ParenthesisNode(content) {
+    if (!(this instanceof ParenthesisNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    } // validate input
+
+
+    if (!type.isNode(content)) {
+      throw new TypeError('Node expected for parameter "content"');
+    }
+
+    this.content = content;
+  }
+
+  ParenthesisNode.prototype = new Node();
+  ParenthesisNode.prototype.type = 'ParenthesisNode';
+  ParenthesisNode.prototype.isParenthesisNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  ParenthesisNode.prototype._compile = function (math, argNames) {
+    return this.content._compile(math, argNames);
+  };
+  /**
+   * Get the content of the current Node.
+   * @return {Node} content
+   * @override
+   **/
+
+
+  ParenthesisNode.prototype.getContent = function () {
+    return this.content.getContent();
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  ParenthesisNode.prototype.forEach = function (callback) {
+    callback(this.content, 'content', this);
+  };
+  /**
+   * Create a new ParenthesisNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node) : Node} callback
+   * @returns {ParenthesisNode} Returns a clone of the node
+   */
+
+
+  ParenthesisNode.prototype.map = function (callback) {
+    var content = callback(this.content, 'content', this);
+    return new ParenthesisNode(content);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {ParenthesisNode}
+   */
+
+
+  ParenthesisNode.prototype.clone = function () {
+    return new ParenthesisNode(this.content);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ParenthesisNode.prototype._toString = function (options) {
+    if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') {
+      return '(' + this.content.toString(options) + ')';
+    }
+
+    return this.content.toString(options);
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  ParenthesisNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'ParenthesisNode',
+      content: this.content
+    };
+  };
+  /**
+   * Instantiate an ParenthesisNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "ParenthesisNode", "content": ...}`,
+   *                       where mathjs is optional
+   * @returns {ParenthesisNode}
+   */
+
+
+  ParenthesisNode.fromJSON = function (json) {
+    return new ParenthesisNode(json.content);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ParenthesisNode.prototype.toHTML = function (options) {
+    if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') {
+      return '<span class="math-parenthesis math-round-parenthesis">(</span>' + this.content.toHTML(options) + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    return this.content.toHTML(options);
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ParenthesisNode.prototype._toTex = function (options) {
+    if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') {
+      return "\\left(".concat(this.content.toTex(options), "\\right)");
+    }
+
+    return this.content.toTex(options);
+  };
+
+  return ParenthesisNode;
+}
+
+exports.name = 'ParenthesisNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"./Node":24}],28:[function(require,module,exports){
+'use strict';
+
+var operators = require('../operators');
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+  /**
+   * @constructor RangeNode
+   * @extends {Node}
+   * create a range
+   * @param {Node} start  included lower-bound
+   * @param {Node} end    included upper-bound
+   * @param {Node} [step] optional step
+   */
+
+  function RangeNode(start, end, step) {
+    if (!(this instanceof RangeNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    } // validate inputs
+
+
+    if (!type.isNode(start)) throw new TypeError('Node expected');
+    if (!type.isNode(end)) throw new TypeError('Node expected');
+    if (step && !type.isNode(step)) throw new TypeError('Node expected');
+    if (arguments.length > 3) throw new Error('Too many arguments');
+    this.start = start; // included lower-bound
+
+    this.end = end; // included upper-bound
+
+    this.step = step || null; // optional step
+  }
+
+  RangeNode.prototype = new Node();
+  RangeNode.prototype.type = 'RangeNode';
+  RangeNode.prototype.isRangeNode = true;
+  /**
+   * Check whether the RangeNode needs the `end` symbol to be defined.
+   * This end is the size of the Matrix in current dimension.
+   * @return {boolean}
+   */
+
+  RangeNode.prototype.needsEnd = function () {
+    // find all `end` symbols in this RangeNode
+    var endSymbols = this.filter(function (node) {
+      return type.isSymbolNode(node) && node.name === 'end';
+    });
+    return endSymbols.length > 0;
+  };
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+
+  RangeNode.prototype._compile = function (math, argNames) {
+    var range = math.range;
+
+    var evalStart = this.start._compile(math, argNames);
+
+    var evalEnd = this.end._compile(math, argNames);
+
+    if (this.step) {
+      var evalStep = this.step._compile(math, argNames);
+
+      return function evalRangeNode(scope, args, context) {
+        return range(evalStart(scope, args, context), evalEnd(scope, args, context), evalStep(scope, args, context));
+      };
+    } else {
+      return function evalRangeNode(scope, args, context) {
+        return range(evalStart(scope, args, context), evalEnd(scope, args, context));
+      };
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  RangeNode.prototype.forEach = function (callback) {
+    callback(this.start, 'start', this);
+    callback(this.end, 'end', this);
+
+    if (this.step) {
+      callback(this.step, 'step', this);
+    }
+  };
+  /**
+   * Create a new RangeNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {RangeNode} Returns a transformed copy of the node
+   */
+
+
+  RangeNode.prototype.map = function (callback) {
+    return new RangeNode(this._ifNode(callback(this.start, 'start', this)), this._ifNode(callback(this.end, 'end', this)), this.step && this._ifNode(callback(this.step, 'step', this)));
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {RangeNode}
+   */
+
+
+  RangeNode.prototype.clone = function () {
+    return new RangeNode(this.start, this.end, this.step && this.step);
+  };
+  /**
+   * Calculate the necessary parentheses
+   * @param {Node} node
+   * @param {string} parenthesis
+   * @return {Object} parentheses
+   * @private
+   */
+
+
+  function calculateNecessaryParentheses(node, parenthesis) {
+    var precedence = operators.getPrecedence(node, parenthesis);
+    var parens = {};
+    var startPrecedence = operators.getPrecedence(node.start, parenthesis);
+    parens.start = startPrecedence !== null && startPrecedence <= precedence || parenthesis === 'all';
+
+    if (node.step) {
+      var stepPrecedence = operators.getPrecedence(node.step, parenthesis);
+      parens.step = stepPrecedence !== null && stepPrecedence <= precedence || parenthesis === 'all';
+    }
+
+    var endPrecedence = operators.getPrecedence(node.end, parenthesis);
+    parens.end = endPrecedence !== null && endPrecedence <= precedence || parenthesis === 'all';
+    return parens;
+  }
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  RangeNode.prototype._toString = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var parens = calculateNecessaryParentheses(this, parenthesis); // format string as start:step:stop
+
+    var str;
+    var start = this.start.toString(options);
+
+    if (parens.start) {
+      start = '(' + start + ')';
+    }
+
+    str = start;
+
+    if (this.step) {
+      var step = this.step.toString(options);
+
+      if (parens.step) {
+        step = '(' + step + ')';
+      }
+
+      str += ':' + step;
+    }
+
+    var end = this.end.toString(options);
+
+    if (parens.end) {
+      end = '(' + end + ')';
+    }
+
+    str += ':' + end;
+    return str;
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  RangeNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'RangeNode',
+      start: this.start,
+      end: this.end,
+      step: this.step
+    };
+  };
+  /**
+   * Instantiate an RangeNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "RangeNode", "start": ..., "end": ..., "step": ...}`,
+   *                       where mathjs is optional
+   * @returns {RangeNode}
+   */
+
+
+  RangeNode.fromJSON = function (json) {
+    return new RangeNode(json.start, json.end, json.step);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  RangeNode.prototype.toHTML = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var parens = calculateNecessaryParentheses(this, parenthesis); // format string as start:step:stop
+
+    var str;
+    var start = this.start.toHTML(options);
+
+    if (parens.start) {
+      start = '<span class="math-parenthesis math-round-parenthesis">(</span>' + start + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    str = start;
+
+    if (this.step) {
+      var step = this.step.toHTML(options);
+
+      if (parens.step) {
+        step = '<span class="math-parenthesis math-round-parenthesis">(</span>' + step + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      }
+
+      str += '<span class="math-operator math-range-operator">:</span>' + step;
+    }
+
+    var end = this.end.toHTML(options);
+
+    if (parens.end) {
+      end = '<span class="math-parenthesis math-round-parenthesis">(</span>' + end + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    }
+
+    str += '<span class="math-operator math-range-operator">:</span>' + end;
+    return str;
+  };
+  /**
+   * Get LaTeX representation
+   * @params {Object} options
+   * @return {string} str
+   */
+
+
+  RangeNode.prototype._toTex = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var parens = calculateNecessaryParentheses(this, parenthesis);
+    var str = this.start.toTex(options);
+
+    if (parens.start) {
+      str = "\\left(".concat(str, "\\right)");
+    }
+
+    if (this.step) {
+      var step = this.step.toTex(options);
+
+      if (parens.step) {
+        step = "\\left(".concat(step, "\\right)");
+      }
+
+      str += ':' + step;
+    }
+
+    var end = this.end.toTex(options);
+
+    if (parens.end) {
+      end = "\\left(".concat(end, "\\right)");
+    }
+
+    str += ':' + end;
+    return str;
+  };
+
+  return RangeNode;
+}
+
+exports.name = 'RangeNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../operators":33,"./Node":24}],29:[function(require,module,exports){
+'use strict';
+
+var operators = require('../operators');
+
+var latex = require('../../utils/latex');
+
+var escape = require('../../utils/string').escape;
+
+function factory(type, config, load, typed) {
+  var Node = load(require('./Node'));
+
+  var getSafeProperty = require('../../utils/customs').getSafeProperty;
+  /**
+   * A node representing a chained conditional expression, such as 'x > y > z'
+   *
+   * @param {String[]} conditionals   An array of conditional operators used to compare the parameters
+   * @param {Node[]} params   The parameters that will be compared
+   *
+   * @constructor RelationalNode
+   * @extends {Node}
+   */
+
+
+  function RelationalNode(conditionals, params) {
+    if (!(this instanceof RelationalNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    if (!Array.isArray(conditionals)) throw new TypeError('Parameter conditionals must be an array');
+    if (!Array.isArray(params)) throw new TypeError('Parameter params must be an array');
+    if (conditionals.length !== params.length - 1) throw new TypeError('Parameter params must contain exactly one more element than parameter conditionals');
+    this.conditionals = conditionals;
+    this.params = params;
+  }
+
+  RelationalNode.prototype = new Node();
+  RelationalNode.prototype.type = 'RelationalNode';
+  RelationalNode.prototype.isRelationalNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  RelationalNode.prototype._compile = function (math, argNames) {
+    var self = this;
+    var compiled = this.params.map(function (p) {
+      return p._compile(math, argNames);
+    });
+    return function evalRelationalNode(scope, args, context) {
+      var evalLhs;
+      var evalRhs = compiled[0](scope, args, context);
+
+      for (var i = 0; i < self.conditionals.length; i++) {
+        evalLhs = evalRhs;
+        evalRhs = compiled[i + 1](scope, args, context);
+        var condFn = getSafeProperty(math, self.conditionals[i]);
+
+        if (!condFn(evalLhs, evalRhs)) {
+          return false;
+        }
+      }
+
+      return true;
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  RelationalNode.prototype.forEach = function (callback) {
+    var _this = this;
+
+    this.params.forEach(function (n, i) {
+      return callback(n, 'params[' + i + ']', _this);
+    }, this);
+  };
+  /**
+   * Create a new RelationalNode having its childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node): Node} callback
+   * @returns {RelationalNode} Returns a transformed copy of the node
+   */
+
+
+  RelationalNode.prototype.map = function (callback) {
+    var _this2 = this;
+
+    return new RelationalNode(this.conditionals.slice(), this.params.map(function (n, i) {
+      return _this2._ifNode(callback(n, 'params[' + i + ']', _this2));
+    }, this));
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {RelationalNode}
+   */
+
+
+  RelationalNode.prototype.clone = function () {
+    return new RelationalNode(this.conditionals, this.params);
+  };
+  /**
+   * Get string representation.
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  RelationalNode.prototype._toString = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var precedence = operators.getPrecedence(this, parenthesis);
+    var paramStrings = this.params.map(function (p, index) {
+      var paramPrecedence = operators.getPrecedence(p, parenthesis);
+      return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '(' + p.toString(options) + ')' : p.toString(options);
+    });
+    var operatorMap = {
+      'equal': '==',
+      'unequal': '!=',
+      'smaller': '<',
+      'larger': '>',
+      'smallerEq': '<=',
+      'largerEq': '>='
+    };
+    var ret = paramStrings[0];
+
+    for (var i = 0; i < this.conditionals.length; i++) {
+      ret += ' ' + operatorMap[this.conditionals[i]] + ' ' + paramStrings[i + 1];
+    }
+
+    return ret;
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  RelationalNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'RelationalNode',
+      conditionals: this.conditionals,
+      params: this.params
+    };
+  };
+  /**
+   * Instantiate a RelationalNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "RelationalNode", "condition": ..., "trueExpr": ..., "falseExpr": ...}`,
+   *                       where mathjs is optional
+   * @returns {RelationalNode}
+   */
+
+
+  RelationalNode.fromJSON = function (json) {
+    return new RelationalNode(json.conditionals, json.params);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  RelationalNode.prototype.toHTML = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var precedence = operators.getPrecedence(this, parenthesis);
+    var paramStrings = this.params.map(function (p, index) {
+      var paramPrecedence = operators.getPrecedence(p, parenthesis);
+      return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '<span class="math-parenthesis math-round-parenthesis">(</span>' + p.toHTML(options) + '<span class="math-parenthesis math-round-parenthesis">)</span>' : p.toHTML(options);
+    });
+    var operatorMap = {
+      'equal': '==',
+      'unequal': '!=',
+      'smaller': '<',
+      'larger': '>',
+      'smallerEq': '<=',
+      'largerEq': '>='
+    };
+    var ret = paramStrings[0];
+
+    for (var i = 0; i < this.conditionals.length; i++) {
+      ret += '<span class="math-operator math-binary-operator math-explicit-binary-operator">' + escape(operatorMap[this.conditionals[i]]) + '</span>' + paramStrings[i + 1];
+    }
+
+    return ret;
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  RelationalNode.prototype._toTex = function (options) {
+    var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+    var precedence = operators.getPrecedence(this, parenthesis);
+    var paramStrings = this.params.map(function (p, index) {
+      var paramPrecedence = operators.getPrecedence(p, parenthesis);
+      return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '\\left(' + p.toString(options) + '\right)' : p.toString(options);
+    });
+    var ret = paramStrings[0];
+
+    for (var i = 0; i < this.conditionals.length; i++) {
+      ret += latex.operators[this.conditionals[i]] + paramStrings[i + 1];
+    }
+
+    return ret;
+  };
+
+  return RelationalNode;
+}
+
+exports.name = 'RelationalNode';
+exports.path = 'expression.node';
+exports.factory = factory;
+},{"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../operators":33,"./Node":24}],30:[function(require,module,exports){
+'use strict';
+
+var latex = require('../../utils/latex');
+
+var escape = require('../../utils/string').escape;
+
+var hasOwnProperty = require('../../utils/object').hasOwnProperty;
+
+var getSafeProperty = require('../../utils/customs').getSafeProperty;
+
+function factory(type, config, load, typed, math) {
+  var Node = load(require('./Node'));
+  /**
+   * Check whether some name is a valueless unit like "inch".
+   * @param {string} name
+   * @return {boolean}
+   */
+
+  function isValuelessUnit(name) {
+    return type.Unit ? type.Unit.isValuelessUnit(name) : false;
+  }
+  /**
+   * @constructor SymbolNode
+   * @extends {Node}
+   * A symbol node can hold and resolve a symbol
+   * @param {string} name
+   * @extends {Node}
+   */
+
+
+  function SymbolNode(name) {
+    if (!(this instanceof SymbolNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    } // validate input
+
+
+    if (typeof name !== 'string') throw new TypeError('String expected for parameter "name"');
+    this.name = name;
+  }
+
+  SymbolNode.prototype = new Node();
+  SymbolNode.prototype.type = 'SymbolNode';
+  SymbolNode.prototype.isSymbolNode = true;
+  /**
+   * Compile a node into a JavaScript function.
+   * This basically pre-calculates as much as possible and only leaves open
+   * calculations which depend on a dynamic scope with variables.
+   * @param {Object} math     Math.js namespace with functions and constants.
+   * @param {Object} argNames An object with argument names as key and `true`
+   *                          as value. Used in the SymbolNode to optimize
+   *                          for arguments from user assigned functions
+   *                          (see FunctionAssignmentNode) or special symbols
+   *                          like `end` (see IndexNode).
+   * @return {function} Returns a function which can be called like:
+   *                        evalNode(scope: Object, args: Object, context: *)
+   */
+
+  SymbolNode.prototype._compile = function (math, argNames) {
+    var name = this.name;
+
+    if (hasOwnProperty(argNames, name)) {
+      // this is a FunctionAssignment argument
+      // (like an x when inside the expression of a function assignment `f(x) = ...`)
+      return function (scope, args, context) {
+        return args[name];
+      };
+    } else if (name in math) {
+      return function (scope, args, context) {
+        return name in scope ? getSafeProperty(scope, name) : getSafeProperty(math, name);
+      };
+    } else {
+      var isUnit = isValuelessUnit(name);
+      return function (scope, args, context) {
+        return name in scope ? getSafeProperty(scope, name) : isUnit ? new type.Unit(null, name) : undef(name);
+      };
+    }
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  SymbolNode.prototype.forEach = function (callback) {} // nothing to do, we don't have childs
+
+  /**
+   * Create a new SymbolNode having it's childs be the results of calling
+   * the provided callback function for each of the childs of the original node.
+   * @param {function(child: Node, path: string, parent: Node) : Node} callback
+   * @returns {SymbolNode} Returns a clone of the node
+   */
+  ;
+
+  SymbolNode.prototype.map = function (callback) {
+    return this.clone();
+  };
+  /**
+   * Throws an error 'Undefined symbol {name}'
+   * @param {string} name
+   */
+
+
+  function undef(name) {
+    throw new Error('Undefined symbol ' + name);
+  }
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {SymbolNode}
+   */
+
+
+  SymbolNode.prototype.clone = function () {
+    return new SymbolNode(this.name);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  SymbolNode.prototype._toString = function (options) {
+    return this.name;
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  SymbolNode.prototype.toHTML = function (options) {
+    var name = escape(this.name);
+
+    if (name === 'true' || name === 'false') {
+      return '<span class="math-symbol math-boolean">' + name + '</span>';
+    } else if (name === 'i') {
+      return '<span class="math-symbol math-imaginary-symbol">' + name + '</span>';
+    } else if (name === 'Infinity') {
+      return '<span class="math-symbol math-infinity-symbol">' + name + '</span>';
+    } else if (name === 'NaN') {
+      return '<span class="math-symbol math-nan-symbol">' + name + '</span>';
+    } else if (name === 'null') {
+      return '<span class="math-symbol math-null-symbol">' + name + '</span>';
+    } else if (name === 'undefined') {
+      return '<span class="math-symbol math-undefined-symbol">' + name + '</span>';
+    }
+
+    return '<span class="math-symbol">' + name + '</span>';
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  SymbolNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'SymbolNode',
+      name: this.name
+    };
+  };
+  /**
+   * Instantiate a SymbolNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "SymbolNode", name: "x"}`,
+   *                       where mathjs is optional
+   * @returns {SymbolNode}
+   */
+
+
+  SymbolNode.fromJSON = function (json) {
+    return new SymbolNode(json.name);
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  SymbolNode.prototype._toTex = function (options) {
+    var isUnit = false;
+
+    if (typeof math[this.name] === 'undefined' && isValuelessUnit(this.name)) {
+      isUnit = true;
+    }
+
+    var symbol = latex.toSymbol(this.name, isUnit);
+
+    if (symbol[0] === '\\') {
+      // no space needed if the symbol starts with '\'
+      return symbol;
+    } // the space prevents symbols from breaking stuff like '\cdot' if it's written right before the symbol
+
+
+    return ' ' + symbol;
+  };
+
+  return SymbolNode;
+}
+
+exports.name = 'SymbolNode';
+exports.path = 'expression.node';
+exports.math = true; // request access to the math namespace as 5th argument of the factory function
+
+exports.factory = factory;
+},{"../../utils/customs":51,"../../utils/latex":53,"../../utils/object":55,"../../utils/string":57,"./Node":24}],31:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var errorTransform = require('../../transform/error.transform').transform;
+
+var getSafeProperty = require('../../../utils/customs').getSafeProperty;
+
+function factory(type, config, load, typed) {
+  var subset = load(require('../../../function/matrix/subset'));
+  /**
+   * Retrieve part of an object:
+   *
+   * - Retrieve a property from an object
+   * - Retrieve a part of a string
+   * - Retrieve a matrix subset
+   *
+   * @param {Object | Array | Matrix | string} object
+   * @param {Index} index
+   * @return {Object | Array | Matrix | string} Returns the subset
+   */
+
+  return function access(object, index) {
+    try {
+      if (Array.isArray(object)) {
+        return subset(object, index);
+      } else if (object && typeof object.subset === 'function') {
+        // Matrix
+        return object.subset(index);
+      } else if (typeof object === 'string') {
+        // TODO: move getStringSubset into a separate util file, use that
+        return subset(object, index);
+      } else if (_typeof(object) === 'object') {
+        if (!index.isObjectProperty()) {
+          throw new TypeError('Cannot apply a numeric index as object property');
+        }
+
+        return getSafeProperty(object, index.getObjectProperty());
+      } else {
+        throw new TypeError('Cannot apply index: unsupported type of object');
+      }
+    } catch (err) {
+      throw errorTransform(err);
+    }
+  };
+}
+
+exports.factory = factory;
+},{"../../../function/matrix/subset":36,"../../../utils/customs":51,"../../transform/error.transform":35}],32:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var errorTransform = require('../../transform/error.transform').transform;
+
+var setSafeProperty = require('../../../utils/customs').setSafeProperty;
+
+function factory(type, config, load, typed) {
+  var subset = load(require('../../../function/matrix/subset'));
+  var matrix = load(require('../../../type/matrix/function/matrix'));
+  /**
+   * Replace part of an object:
+   *
+   * - Assign a property to an object
+   * - Replace a part of a string
+   * - Replace a matrix subset
+   *
+   * @param {Object | Array | Matrix | string} object
+   * @param {Index} index
+   * @param {*} value
+   * @return {Object | Array | Matrix | string} Returns the original object
+   *                                            except in case of a string
+   */
+  // TODO: change assign to return the value instead of the object
+
+  return function assign(object, index, value) {
+    try {
+      if (Array.isArray(object)) {
+        return matrix(object).subset(index, value).valueOf();
+      } else if (object && typeof object.subset === 'function') {
+        // Matrix
+        return object.subset(index, value);
+      } else if (typeof object === 'string') {
+        // TODO: move setStringSubset into a separate util file, use that
+        return subset(object, index, value);
+      } else if (_typeof(object) === 'object') {
+        if (!index.isObjectProperty()) {
+          throw TypeError('Cannot apply a numeric index as object property');
+        }
+
+        setSafeProperty(object, index.getObjectProperty(), value);
+        return object;
+      } else {
+        throw new TypeError('Cannot apply index: unsupported type of object');
+      }
+    } catch (err) {
+      throw errorTransform(err);
+    }
+  };
+}
+
+exports.factory = factory;
+},{"../../../function/matrix/subset":36,"../../../type/matrix/function/matrix":42,"../../../utils/customs":51,"../../transform/error.transform":35}],33:[function(require,module,exports){
+'use strict'; // list of identifiers of nodes in order of their precedence
+// also contains information about left/right associativity
+// and which other operator the operator is associative with
+// Example:
+// addition is associative with addition and subtraction, because:
+// (a+b)+c=a+(b+c)
+// (a+b)-c=a+(b-c)
+//
+// postfix operators are left associative, prefix operators
+// are right associative
+//
+// It's also possible to set the following properties:
+// latexParens: if set to false, this node doesn't need to be enclosed
+//              in parentheses when using LaTeX
+// latexLeftParens: if set to false, this !OperatorNode's!
+//                  left argument doesn't need to be enclosed
+//                  in parentheses
+// latexRightParens: the same for the right argument
+
+var properties = [{
+  // assignment
+  'AssignmentNode': {},
+  'FunctionAssignmentNode': {}
+}, {
+  // conditional expression
+  'ConditionalNode': {
+    latexLeftParens: false,
+    latexRightParens: false,
+    latexParens: false // conditionals don't need parentheses in LaTeX because
+    // they are 2 dimensional
+
+  }
+}, {
+  // logical or
+  'OperatorNode:or': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // logical xor
+  'OperatorNode:xor': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // logical and
+  'OperatorNode:and': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // bitwise or
+  'OperatorNode:bitOr': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // bitwise xor
+  'OperatorNode:bitXor': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // bitwise and
+  'OperatorNode:bitAnd': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // relational operators
+  'OperatorNode:equal': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:unequal': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:smaller': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:larger': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:smallerEq': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:largerEq': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'RelationalNode': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // bitshift operators
+  'OperatorNode:leftShift': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:rightArithShift': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:rightLogShift': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // unit conversion
+  'OperatorNode:to': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // range
+  'RangeNode': {}
+}, {
+  // addition, subtraction
+  'OperatorNode:add': {
+    associativity: 'left',
+    associativeWith: ['OperatorNode:add', 'OperatorNode:subtract']
+  },
+  'OperatorNode:subtract': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // multiply, divide, modulus
+  'OperatorNode:multiply': {
+    associativity: 'left',
+    associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'Operator:dotMultiply', 'Operator:dotDivide']
+  },
+  'OperatorNode:divide': {
+    associativity: 'left',
+    associativeWith: [],
+    latexLeftParens: false,
+    latexRightParens: false,
+    latexParens: false // fractions don't require parentheses because
+    // they're 2 dimensional, so parens aren't needed
+    // in LaTeX
+
+  },
+  'OperatorNode:dotMultiply': {
+    associativity: 'left',
+    associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'OperatorNode:dotMultiply', 'OperatorNode:doDivide']
+  },
+  'OperatorNode:dotDivide': {
+    associativity: 'left',
+    associativeWith: []
+  },
+  'OperatorNode:mod': {
+    associativity: 'left',
+    associativeWith: []
+  }
+}, {
+  // unary prefix operators
+  'OperatorNode:unaryPlus': {
+    associativity: 'right'
+  },
+  'OperatorNode:unaryMinus': {
+    associativity: 'right'
+  },
+  'OperatorNode:bitNot': {
+    associativity: 'right'
+  },
+  'OperatorNode:not': {
+    associativity: 'right'
+  }
+}, {
+  // exponentiation
+  'OperatorNode:pow': {
+    associativity: 'right',
+    associativeWith: [],
+    latexRightParens: false // the exponent doesn't need parentheses in
+    // LaTeX because it's 2 dimensional
+    // (it's on top)
+
+  },
+  'OperatorNode:dotPow': {
+    associativity: 'right',
+    associativeWith: []
+  }
+}, {
+  // factorial
+  'OperatorNode:factorial': {
+    associativity: 'left'
+  }
+}, {
+  // matrix transpose
+  'OperatorNode:transpose': {
+    associativity: 'left'
+  }
+}];
+/**
+ * Get the precedence of a Node.
+ * Higher number for higher precedence, starting with 0.
+ * Returns null if the precedence is undefined.
+ *
+ * @param {Node}
+ * @param {string} parenthesis
+ * @return {number|null}
+ */
+
+function getPrecedence(_node, parenthesis) {
+  var node = _node;
+
+  if (parenthesis !== 'keep') {
+    // ParenthesisNodes are only ignored when not in 'keep' mode
+    node = _node.getContent();
+  }
+
+  var identifier = node.getIdentifier();
+
+  for (var i = 0; i < properties.length; i++) {
+    if (identifier in properties[i]) {
+      return i;
+    }
+  }
+
+  return null;
+}
+/**
+ * Get the associativity of an operator (left or right).
+ * Returns a string containing 'left' or 'right' or null if
+ * the associativity is not defined.
+ *
+ * @param {Node}
+ * @param {string} parenthesis
+ * @return {string|null}
+ * @throws {Error}
+ */
+
+
+function getAssociativity(_node, parenthesis) {
+  var node = _node;
+
+  if (parenthesis !== 'keep') {
+    // ParenthesisNodes are only ignored when not in 'keep' mode
+    node = _node.getContent();
+  }
+
+  var identifier = node.getIdentifier();
+  var index = getPrecedence(node, parenthesis);
+
+  if (index === null) {
+    // node isn't in the list
+    return null;
+  }
+
+  var property = properties[index][identifier];
+
+  if (property.hasOwnProperty('associativity')) {
+    if (property.associativity === 'left') {
+      return 'left';
+    }
+
+    if (property.associativity === 'right') {
+      return 'right';
+    } // associativity is invalid
+
+
+    throw Error('\'' + identifier + '\' has the invalid associativity \'' + property.associativity + '\'.');
+  } // associativity is undefined
+
+
+  return null;
+}
+/**
+ * Check if an operator is associative with another operator.
+ * Returns either true or false or null if not defined.
+ *
+ * @param {Node} nodeA
+ * @param {Node} nodeB
+ * @param {string} parenthesis
+ * @return {bool|null}
+ */
+
+
+function isAssociativeWith(nodeA, nodeB, parenthesis) {
+  // ParenthesisNodes are only ignored when not in 'keep' mode
+  var a = parenthesis !== 'keep' ? nodeA.getContent() : nodeA;
+  var b = parenthesis !== 'keep' ? nodeA.getContent() : nodeB;
+  var identifierA = a.getIdentifier();
+  var identifierB = b.getIdentifier();
+  var index = getPrecedence(a, parenthesis);
+
+  if (index === null) {
+    // node isn't in the list
+    return null;
+  }
+
+  var property = properties[index][identifierA];
+
+  if (property.hasOwnProperty('associativeWith') && property.associativeWith instanceof Array) {
+    for (var i = 0; i < property.associativeWith.length; i++) {
+      if (property.associativeWith[i] === identifierB) {
+        return true;
+      }
+    }
+
+    return false;
+  } // associativeWith is not defined
+
+
+  return null;
+}
+
+module.exports.properties = properties;
+module.exports.getPrecedence = getPrecedence;
+module.exports.getAssociativity = getAssociativity;
+module.exports.isAssociativeWith = isAssociativeWith;
+},{}],34:[function(require,module,exports){
+'use strict';
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var ArgumentsError = require('../error/ArgumentsError');
+
+var deepMap = require('../utils/collection/deepMap');
+
+function factory(type, config, load, typed) {
+  var numeric = load(require('../type/numeric'));
+  var AccessorNode = load(require('./node/AccessorNode'));
+  var ArrayNode = load(require('./node/ArrayNode'));
+  var AssignmentNode = load(require('./node/AssignmentNode'));
+  var BlockNode = load(require('./node/BlockNode'));
+  var ConditionalNode = load(require('./node/ConditionalNode'));
+  var ConstantNode = load(require('./node/ConstantNode'));
+  var FunctionAssignmentNode = load(require('./node/FunctionAssignmentNode'));
+  var IndexNode = load(require('./node/IndexNode'));
+  var ObjectNode = load(require('./node/ObjectNode'));
+  var OperatorNode = load(require('./node/OperatorNode'));
+  var ParenthesisNode = load(require('./node/ParenthesisNode'));
+  var FunctionNode = load(require('./node/FunctionNode'));
+  var RangeNode = load(require('./node/RangeNode'));
+  var RelationalNode = load(require('./node/RelationalNode'));
+  var SymbolNode = load(require('./node/SymbolNode'));
+  /**
+   * Parse an expression. Returns a node tree, which can be evaluated by
+   * invoking node.eval().
+   *
+   * Syntax:
+   *
+   *     parse(expr)
+   *     parse(expr, options)
+   *     parse([expr1, expr2, expr3, ...])
+   *     parse([expr1, expr2, expr3, ...], options)
+   *
+   * Example:
+   *
+   *     const node = parse('sqrt(3^2 + 4^2)')
+   *     node.compile(math).eval() // 5
+   *
+   *     let scope = {a:3, b:4}
+   *     const node = parse('a * b') // 12
+   *     const code = node.compile(math)
+   *     code.eval(scope) // 12
+   *     scope.a = 5
+   *     code.eval(scope) // 20
+   *
+   *     const nodes = math.parse(['a = 3', 'b = 4', 'a * b'])
+   *     nodes[2].compile(math).eval() // 12
+   *
+   * @param {string | string[] | Matrix} expr
+   * @param {{nodes: Object<string, Node>}} [options]  Available options:
+   *                                                   - `nodes` a set of custom nodes
+   * @return {Node | Node[]} node
+   * @throws {Error}
+   */
+
+  function parse(expr, options) {
+    if (arguments.length !== 1 && arguments.length !== 2) {
+      throw new ArgumentsError('parse', arguments.length, 1, 2);
+    } // pass extra nodes
+
+
+    var extraNodes = options && options.nodes ? options.nodes : {};
+
+    if (typeof expr === 'string') {
+      // parse a single expression
+      return parseStart(expr, extraNodes);
+    } else if (Array.isArray(expr) || expr instanceof type.Matrix) {
+      // parse an array or matrix with expressions
+      return deepMap(expr, function (elem) {
+        if (typeof elem !== 'string') throw new TypeError('String expected');
+        return parseStart(elem, extraNodes);
+      });
+    } else {
+      // oops
+      throw new TypeError('String or matrix expected');
+    }
+  } // token types enumeration
+
+
+  var TOKENTYPE = {
+    NULL: 0,
+    DELIMITER: 1,
+    NUMBER: 2,
+    SYMBOL: 3,
+    UNKNOWN: 4 // map with all delimiters
+
+  };
+  var DELIMITERS = {
+    ',': true,
+    '(': true,
+    ')': true,
+    '[': true,
+    ']': true,
+    '{': true,
+    '}': true,
+    '"': true,
+    '\'': true,
+    ';': true,
+    '+': true,
+    '-': true,
+    '*': true,
+    '.*': true,
+    '/': true,
+    './': true,
+    '%': true,
+    '^': true,
+    '.^': true,
+    '~': true,
+    '!': true,
+    '&': true,
+    '|': true,
+    '^|': true,
+    '=': true,
+    ':': true,
+    '?': true,
+    '==': true,
+    '!=': true,
+    '<': true,
+    '>': true,
+    '<=': true,
+    '>=': true,
+    '<<': true,
+    '>>': true,
+    '>>>': true // map with all named delimiters
+
+  };
+  var NAMED_DELIMITERS = {
+    'mod': true,
+    'to': true,
+    'in': true,
+    'and': true,
+    'xor': true,
+    'or': true,
+    'not': true
+  };
+  var CONSTANTS = {
+    'true': true,
+    'false': false,
+    'null': null,
+    'undefined': undefined
+  };
+  var NUMERIC_CONSTANTS = ['NaN', 'Infinity'];
+
+  function initialState() {
+    return {
+      extraNodes: {},
+      // current extra nodes, must be careful not to mutate
+      expression: '',
+      // current expression
+      comment: '',
+      // last parsed comment
+      index: 0,
+      // current index in expr
+      token: '',
+      // current token
+      tokenType: TOKENTYPE.NULL,
+      // type of the token
+      nestingLevel: 0,
+      // level of nesting inside parameters, used to ignore newline characters
+      conditionalLevel: null // when a conditional is being parsed, the level of the conditional is stored here
+
+    };
+  }
+  /**
+   * View upto `length` characters of the expression starting at the current character.
+   *
+   * @param {State} state
+   * @param {number} [length=1] Number of characters to view
+   * @returns {string}
+   * @private
+   */
+
+
+  function currentString(state, length) {
+    return state.expression.substr(state.index, length);
+  }
+  /**
+   * View the current character. Returns '' if end of expression is reached.
+   *
+   * @param {State} state
+   * @returns {string}
+   * @private
+   */
+
+
+  function currentCharacter(state) {
+    return currentString(state, 1);
+  }
+  /**
+   * Get the next character from the expression.
+   * The character is stored into the char c. If the end of the expression is
+   * reached, the function puts an empty string in c.
+   * @private
+   */
+
+
+  function next(state) {
+    state.index++;
+  }
+  /**
+   * Preview the previous character from the expression.
+   * @return {string} cNext
+   * @private
+   */
+
+
+  function prevCharacter(state) {
+    return state.expression.charAt(state.index - 1);
+  }
+  /**
+   * Preview the next character from the expression.
+   * @return {string} cNext
+   * @private
+   */
+
+
+  function nextCharacter(state) {
+    return state.expression.charAt(state.index + 1);
+  }
+  /**
+   * Get next token in the current string expr.
+   * The token and token type are available as token and tokenType
+   * @private
+   */
+
+
+  function getToken(state) {
+    state.tokenType = TOKENTYPE.NULL;
+    state.token = '';
+    state.comment = ''; // skip over whitespaces
+    // space, tab, and newline when inside parameters
+
+    while (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) {
+      next(state);
+    } // skip comment
+
+
+    if (currentCharacter(state) === '#') {
+      while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') {
+        state.comment += currentCharacter(state);
+        next(state);
+      }
+    } // check for end of expression
+
+
+    if (currentCharacter(state) === '') {
+      // token is still empty
+      state.tokenType = TOKENTYPE.DELIMITER;
+      return;
+    } // check for new line character
+
+
+    if (currentCharacter(state) === '\n' && !state.nestingLevel) {
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = currentCharacter(state);
+      next(state);
+      return;
+    }
+
+    var c1 = currentCharacter(state);
+    var c2 = currentString(state, 2);
+    var c3 = currentString(state, 3);
+
+    if (c3.length === 3 && DELIMITERS[c3]) {
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = c3;
+      next(state);
+      next(state);
+      next(state);
+      return;
+    } // check for delimiters consisting of 2 characters
+
+
+    if (c2.length === 2 && DELIMITERS[c2]) {
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = c2;
+      next(state);
+      next(state);
+      return;
+    } // check for delimiters consisting of 1 character
+
+
+    if (DELIMITERS[c1]) {
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = c1;
+      next(state);
+      return;
+    } // check for a number
+
+
+    if (parse.isDigitDot(c1)) {
+      state.tokenType = TOKENTYPE.NUMBER; // get number, can have a single dot
+
+      if (currentCharacter(state) === '.') {
+        state.token += currentCharacter(state);
+        next(state);
+
+        if (!parse.isDigit(currentCharacter(state))) {
+          // this is no number, it is just a dot (can be dot notation)
+          state.tokenType = TOKENTYPE.DELIMITER;
+        }
+      } else {
+        while (parse.isDigit(currentCharacter(state))) {
+          state.token += currentCharacter(state);
+          next(state);
+        }
+
+        if (parse.isDecimalMark(currentCharacter(state), nextCharacter(state))) {
+          state.token += currentCharacter(state);
+          next(state);
+        }
+      }
+
+      while (parse.isDigit(currentCharacter(state))) {
+        state.token += currentCharacter(state);
+        next(state);
+      } // check for exponential notation like "2.3e-4", "1.23e50" or "2e+4"
+
+
+      if (currentCharacter(state) === 'E' || currentCharacter(state) === 'e') {
+        if (parse.isDigit(nextCharacter(state)) || nextCharacter(state) === '-' || nextCharacter(state) === '+') {
+          state.token += currentCharacter(state);
+          next(state);
+
+          if (currentCharacter(state) === '+' || currentCharacter(state) === '-') {
+            state.token += currentCharacter(state);
+            next(state);
+          } // Scientific notation MUST be followed by an exponent
+
+
+          if (!parse.isDigit(currentCharacter(state))) {
+            throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"');
+          }
+
+          while (parse.isDigit(currentCharacter(state))) {
+            state.token += currentCharacter(state);
+            next(state);
+          }
+
+          if (parse.isDecimalMark(currentCharacter(state), nextCharacter(state))) {
+            throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"');
+          }
+        } else if (nextCharacter(state) === '.') {
+          next(state);
+          throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"');
+        }
+      }
+
+      return;
+    } // check for variables, functions, named operators
+
+
+    if (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state))) {
+      while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
+        state.token += currentCharacter(state);
+        next(state);
+      }
+
+      if (NAMED_DELIMITERS.hasOwnProperty(state.token)) {
+        state.tokenType = TOKENTYPE.DELIMITER;
+      } else {
+        state.tokenType = TOKENTYPE.SYMBOL;
+      }
+
+      return;
+    } // something unknown is found, wrong characters -> a syntax error
+
+
+    state.tokenType = TOKENTYPE.UNKNOWN;
+
+    while (currentCharacter(state) !== '') {
+      state.token += currentCharacter(state);
+      next(state);
+    }
+
+    throw createSyntaxError(state, 'Syntax error in part "' + state.token + '"');
+  }
+  /**
+   * Get next token and skip newline tokens
+   */
+
+
+  function getTokenSkipNewline(state) {
+    do {
+      getToken(state);
+    } while (state.token === '\n'); // eslint-disable-line no-unmodified-loop-condition
+
+  }
+  /**
+   * Open parameters.
+   * New line characters will be ignored until closeParams(state) is called
+   */
+
+
+  function openParams(state) {
+    state.nestingLevel++;
+  }
+  /**
+   * Close parameters.
+   * New line characters will no longer be ignored
+   */
+
+
+  function closeParams(state) {
+    state.nestingLevel--;
+  }
+  /**
+   * Checks whether the current character `c` is a valid alpha character:
+   *
+   * - A latin letter (upper or lower case) Ascii: a-z, A-Z
+   * - An underscore                        Ascii: _
+   * - A dollar sign                        Ascii: $
+   * - A latin letter with accents          Unicode: \u00C0 - \u02AF
+   * - A greek letter                       Unicode: \u0370 - \u03FF
+   * - A mathematical alphanumeric symbol   Unicode: \u{1D400} - \u{1D7FF} excluding invalid code points
+   *
+   * The previous and next characters are needed to determine whether
+   * this character is part of a unicode surrogate pair.
+   *
+   * @param {string} c      Current character in the expression
+   * @param {string} cPrev  Previous character
+   * @param {string} cNext  Next character
+   * @return {boolean}
+   */
+
+
+  parse.isAlpha = function isAlpha(c, cPrev, cNext) {
+    return parse.isValidLatinOrGreek(c) || parse.isValidMathSymbol(c, cNext) || parse.isValidMathSymbol(cPrev, c);
+  };
+  /**
+   * Test whether a character is a valid latin, greek, or letter-like character
+   * @param {string} c
+   * @return {boolean}
+   */
+
+
+  parse.isValidLatinOrGreek = function isValidLatinOrGreek(c) {
+    return /^[a-zA-Z_$\u00C0-\u02AF\u0370-\u03FF\u2100-\u214F]$/.test(c);
+  };
+  /**
+   * Test whether two given 16 bit characters form a surrogate pair of a
+   * unicode math symbol.
+   *
+   * http://unicode-table.com/en/
+   * http://www.wikiwand.com/en/Mathematical_operators_and_symbols_in_Unicode
+   *
+   * Note: In ES6 will be unicode aware:
+   * http://stackoverflow.com/questions/280712/javascript-unicode-regexes
+   * https://mathiasbynens.be/notes/es6-unicode-regex
+   *
+   * @param {string} high
+   * @param {string} low
+   * @return {boolean}
+   */
+
+
+  parse.isValidMathSymbol = function isValidMathSymbol(high, low) {
+    return /^[\uD835]$/.test(high) && /^[\uDC00-\uDFFF]$/.test(low) && /^[^\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]$/.test(low);
+  };
+  /**
+   * Check whether given character c is a white space character: space, tab, or enter
+   * @param {string} c
+   * @param {number} nestingLevel
+   * @return {boolean}
+   */
+
+
+  parse.isWhitespace = function isWhitespace(c, nestingLevel) {
+    // TODO: also take '\r' carriage return as newline? Or does that give problems on mac?
+    return c === ' ' || c === '\t' || c === '\n' && nestingLevel > 0;
+  };
+  /**
+   * Test whether the character c is a decimal mark (dot).
+   * This is the case when it's not the start of a delimiter '.*', './', or '.^'
+   * @param {string} c
+   * @param {string} cNext
+   * @return {boolean}
+   */
+
+
+  parse.isDecimalMark = function isDecimalMark(c, cNext) {
+    return c === '.' && cNext !== '/' && cNext !== '*' && cNext !== '^';
+  };
+  /**
+   * checks if the given char c is a digit or dot
+   * @param {string} c   a string with one character
+   * @return {boolean}
+   */
+
+
+  parse.isDigitDot = function isDigitDot(c) {
+    return c >= '0' && c <= '9' || c === '.';
+  };
+  /**
+   * checks if the given char c is a digit
+   * @param {string} c   a string with one character
+   * @return {boolean}
+   */
+
+
+  parse.isDigit = function isDigit(c) {
+    return c >= '0' && c <= '9';
+  };
+  /**
+   * Start of the parse levels below, in order of precedence
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseStart(expression, extraNodes) {
+    var state = initialState();
+
+    _extends(state, {
+      expression: expression,
+      extraNodes: extraNodes
+    });
+
+    getToken(state);
+    var node = parseBlock(state); // check for garbage at the end of the expression
+    // an expression ends with a empty character '' and tokenType DELIMITER
+
+    if (state.token !== '') {
+      if (state.tokenType === TOKENTYPE.DELIMITER) {
+        // user entered a not existing operator like "//"
+        // TODO: give hints for aliases, for example with "<>" give as hint " did you mean !== ?"
+        throw createError(state, 'Unexpected operator ' + state.token);
+      } else {
+        throw createSyntaxError(state, 'Unexpected part "' + state.token + '"');
+      }
+    }
+
+    return node;
+  }
+  /**
+   * Parse a block with expressions. Expressions can be separated by a newline
+   * character '\n', or by a semicolon ';'. In case of a semicolon, no output
+   * of the preceding line is returned.
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseBlock(state) {
+    var node;
+    var blocks = [];
+    var visible;
+
+    if (state.token !== '' && state.token !== '\n' && state.token !== ';') {
+      node = parseAssignment(state);
+      node.comment = state.comment;
+    } // TODO: simplify this loop
+
+
+    while (state.token === '\n' || state.token === ';') {
+      // eslint-disable-line no-unmodified-loop-condition
+      if (blocks.length === 0 && node) {
+        visible = state.token !== ';';
+        blocks.push({
+          node: node,
+          visible: visible
+        });
+      }
+
+      getToken(state);
+
+      if (state.token !== '\n' && state.token !== ';' && state.token !== '') {
+        node = parseAssignment(state);
+        node.comment = state.comment;
+        visible = state.token !== ';';
+        blocks.push({
+          node: node,
+          visible: visible
+        });
+      }
+    }
+
+    if (blocks.length > 0) {
+      return new BlockNode(blocks);
+    } else {
+      if (!node) {
+        node = new ConstantNode(undefined);
+        node.comment = state.comment;
+      }
+
+      return node;
+    }
+  }
+  /**
+   * Assignment of a function or variable,
+   * - can be a variable like 'a=2.3'
+   * - or a updating an existing variable like 'matrix(2,3:5)=[6,7,8]'
+   * - defining a function like 'f(x) = x^2'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseAssignment(state) {
+    var name, args, value, valid;
+    var node = parseConditional(state);
+
+    if (state.token === '=') {
+      if (type.isSymbolNode(node)) {
+        // parse a variable assignment like 'a = 2/3'
+        name = node.name;
+        getTokenSkipNewline(state);
+        value = parseAssignment(state);
+        return new AssignmentNode(new SymbolNode(name), value);
+      } else if (type.isAccessorNode(node)) {
+        // parse a matrix subset assignment like 'A[1,2] = 4'
+        getTokenSkipNewline(state);
+        value = parseAssignment(state);
+        return new AssignmentNode(node.object, node.index, value);
+      } else if (type.isFunctionNode(node) && type.isSymbolNode(node.fn)) {
+        // parse function assignment like 'f(x) = x^2'
+        valid = true;
+        args = [];
+        name = node.name;
+        node.args.forEach(function (arg, index) {
+          if (type.isSymbolNode(arg)) {
+            args[index] = arg.name;
+          } else {
+            valid = false;
+          }
+        });
+
+        if (valid) {
+          getTokenSkipNewline(state);
+          value = parseAssignment(state);
+          return new FunctionAssignmentNode(name, args, value);
+        }
+      }
+
+      throw createSyntaxError(state, 'Invalid left hand side of assignment operator =');
+    }
+
+    return node;
+  }
+  /**
+   * conditional operation
+   *
+   *     condition ? truePart : falsePart
+   *
+   * Note: conditional operator is right-associative
+   *
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseConditional(state) {
+    var node = parseLogicalOr(state);
+
+    while (state.token === '?') {
+      // eslint-disable-line no-unmodified-loop-condition
+      // set a conditional level, the range operator will be ignored as long
+      // as conditionalLevel === state.nestingLevel.
+      var prev = state.conditionalLevel;
+      state.conditionalLevel = state.nestingLevel;
+      getTokenSkipNewline(state);
+      var condition = node;
+      var trueExpr = parseAssignment(state);
+      if (state.token !== ':') throw createSyntaxError(state, 'False part of conditional expression expected');
+      state.conditionalLevel = null;
+      getTokenSkipNewline(state);
+      var falseExpr = parseAssignment(state); // Note: check for conditional operator again, right associativity
+
+      node = new ConditionalNode(condition, trueExpr, falseExpr); // restore the previous conditional level
+
+      state.conditionalLevel = prev;
+    }
+
+    return node;
+  }
+  /**
+   * logical or, 'x or y'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseLogicalOr(state) {
+    var node = parseLogicalXor(state);
+
+    while (state.token === 'or') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('or', 'or', [node, parseLogicalXor(state)]);
+    }
+
+    return node;
+  }
+  /**
+   * logical exclusive or, 'x xor y'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseLogicalXor(state) {
+    var node = parseLogicalAnd(state);
+
+    while (state.token === 'xor') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('xor', 'xor', [node, parseLogicalAnd(state)]);
+    }
+
+    return node;
+  }
+  /**
+   * logical and, 'x and y'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseLogicalAnd(state) {
+    var node = parseBitwiseOr(state);
+
+    while (state.token === 'and') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('and', 'and', [node, parseBitwiseOr(state)]);
+    }
+
+    return node;
+  }
+  /**
+   * bitwise or, 'x | y'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseBitwiseOr(state) {
+    var node = parseBitwiseXor(state);
+
+    while (state.token === '|') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('|', 'bitOr', [node, parseBitwiseXor(state)]);
+    }
+
+    return node;
+  }
+  /**
+   * bitwise exclusive or (xor), 'x ^| y'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseBitwiseXor(state) {
+    var node = parseBitwiseAnd(state);
+
+    while (state.token === '^|') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('^|', 'bitXor', [node, parseBitwiseAnd(state)]);
+    }
+
+    return node;
+  }
+  /**
+   * bitwise and, 'x & y'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseBitwiseAnd(state) {
+    var node = parseRelational(state);
+
+    while (state.token === '&') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('&', 'bitAnd', [node, parseRelational(state)]);
+    }
+
+    return node;
+  }
+  /**
+   * Parse a chained conditional, like 'a > b >= c'
+   * @return {Node} node
+   */
+
+
+  function parseRelational(state) {
+    var params = [parseShift(state)];
+    var conditionals = [];
+    var operators = {
+      '==': 'equal',
+      '!=': 'unequal',
+      '<': 'smaller',
+      '>': 'larger',
+      '<=': 'smallerEq',
+      '>=': 'largerEq'
+    };
+
+    while (operators.hasOwnProperty(state.token)) {
+      // eslint-disable-line no-unmodified-loop-condition
+      var cond = {
+        name: state.token,
+        fn: operators[state.token]
+      };
+      conditionals.push(cond);
+      getTokenSkipNewline(state);
+      params.push(parseShift(state));
+    }
+
+    if (params.length === 1) {
+      return params[0];
+    } else if (params.length === 2) {
+      return new OperatorNode(conditionals[0].name, conditionals[0].fn, params);
+    } else {
+      return new RelationalNode(conditionals.map(function (c) {
+        return c.fn;
+      }), params);
+    }
+  }
+  /**
+   * Bitwise left shift, bitwise right arithmetic shift, bitwise right logical shift
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseShift(state) {
+    var node, operators, name, fn, params;
+    node = parseConversion(state);
+    operators = {
+      '<<': 'leftShift',
+      '>>': 'rightArithShift',
+      '>>>': 'rightLogShift'
+    };
+
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
+      fn = operators[name];
+      getTokenSkipNewline(state);
+      params = [node, parseConversion(state)];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+  /**
+   * conversion operators 'to' and 'in'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseConversion(state) {
+    var node, operators, name, fn, params;
+    node = parseRange(state);
+    operators = {
+      'to': 'to',
+      'in': 'to' // alias of 'to'
+
+    };
+
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
+      fn = operators[name];
+      getTokenSkipNewline(state);
+
+      if (name === 'in' && state.token === '') {
+        // end of expression -> this is the unit 'in' ('inch')
+        node = new OperatorNode('*', 'multiply', [node, new SymbolNode('in')], true);
+      } else {
+        // operator 'a to b' or 'a in b'
+        params = [node, parseRange(state)];
+        node = new OperatorNode(name, fn, params);
+      }
+    }
+
+    return node;
+  }
+  /**
+   * parse range, "start:end", "start:step:end", ":", "start:", ":end", etc
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseRange(state) {
+    var node;
+    var params = [];
+
+    if (state.token === ':') {
+      // implicit start=1 (one-based)
+      node = new ConstantNode(1);
+    } else {
+      // explicit start
+      node = parseAddSubtract(state);
+    }
+
+    if (state.token === ':' && state.conditionalLevel !== state.nestingLevel) {
+      // we ignore the range operator when a conditional operator is being processed on the same level
+      params.push(node); // parse step and end
+
+      while (state.token === ':' && params.length < 3) {
+        // eslint-disable-line no-unmodified-loop-condition
+        getTokenSkipNewline(state);
+
+        if (state.token === ')' || state.token === ']' || state.token === ',' || state.token === '') {
+          // implicit end
+          params.push(new SymbolNode('end'));
+        } else {
+          // explicit end
+          params.push(parseAddSubtract(state));
+        }
+      }
+
+      if (params.length === 3) {
+        // params = [start, step, end]
+        node = new RangeNode(params[0], params[2], params[1]); // start, end, step
+      } else {
+        // length === 2
+        // params = [start, end]
+        node = new RangeNode(params[0], params[1]); // start, end
+      }
+    }
+
+    return node;
+  }
+  /**
+   * add or subtract
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseAddSubtract(state) {
+    var node, operators, name, fn, params;
+    node = parseMultiplyDivide(state);
+    operators = {
+      '+': 'add',
+      '-': 'subtract'
+    };
+
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
+      fn = operators[name];
+      getTokenSkipNewline(state);
+      params = [node, parseMultiplyDivide(state)];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+  /**
+   * multiply, divide, modulus
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseMultiplyDivide(state) {
+    var node, last, operators, name, fn;
+    node = parseImplicitMultiplication(state);
+    last = node;
+    operators = {
+      '*': 'multiply',
+      '.*': 'dotMultiply',
+      '/': 'divide',
+      './': 'dotDivide',
+      '%': 'mod',
+      'mod': 'mod'
+    };
+
+    while (true) {
+      if (operators.hasOwnProperty(state.token)) {
+        // explicit operators
+        name = state.token;
+        fn = operators[name];
+        getTokenSkipNewline(state);
+        last = parseImplicitMultiplication(state);
+        node = new OperatorNode(name, fn, [node, last]);
+      } else {
+        break;
+      }
+    }
+
+    return node;
+  }
+  /**
+   * implicit multiplication
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseImplicitMultiplication(state) {
+    var node, last;
+    node = parseRule2(state);
+    last = node;
+
+    while (true) {
+      if (state.tokenType === TOKENTYPE.SYMBOL || state.token === 'in' && type.isConstantNode(node) || state.tokenType === TOKENTYPE.NUMBER && !type.isConstantNode(last) && (!type.isOperatorNode(last) || last.op === '!') || state.token === '(') {
+        // parse implicit multiplication
+        //
+        // symbol:      implicit multiplication like '2a', '(2+3)a', 'a b'
+        // number:      implicit multiplication like '(2+3)2'
+        // parenthesis: implicit multiplication like '2(3+4)', '(3+4)(1+2)'
+        last = parseRule2(state);
+        node = new OperatorNode('*', 'multiply', [node, last], true
+        /* implicit */
+        );
+      } else {
+        break;
+      }
+    }
+
+    return node;
+  }
+  /**
+   * Infamous "rule 2" as described in https://github.com/josdejong/mathjs/issues/792#issuecomment-361065370
+   * Explicit division gets higher precedence than implicit multiplication
+   * when the division matches this pattern: [number] / [number] [symbol]
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseRule2(state) {
+    var node = parseUnary(state);
+    var last = node;
+    var tokenStates = [];
+
+    while (true) {
+      // Match the "number /" part of the pattern "number / number symbol"
+      if (state.token === '/' && type.isConstantNode(last)) {
+        // Look ahead to see if the next token is a number
+        tokenStates.push(_extends({}, state));
+        getTokenSkipNewline(state); // Match the "number / number" part of the pattern
+
+        if (state.tokenType === TOKENTYPE.NUMBER) {
+          // Look ahead again
+          tokenStates.push(_extends({}, state));
+          getTokenSkipNewline(state); // Match the "symbol" part of the pattern, or a left parenthesis
+
+          if (state.tokenType === TOKENTYPE.SYMBOL || state.token === '(') {
+            // We've matched the pattern "number / number symbol".
+            // Rewind once and build the "number / number" node; the symbol will be consumed later
+            _extends(state, tokenStates.pop());
+
+            tokenStates.pop();
+            last = parseUnary(state);
+            node = new OperatorNode('/', 'divide', [node, last]);
+          } else {
+            // Not a match, so rewind
+            tokenStates.pop();
+
+            _extends(state, tokenStates.pop());
+
+            break;
+          }
+        } else {
+          // Not a match, so rewind
+          _extends(state, tokenStates.pop());
+
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+
+    return node;
+  }
+  /**
+   * Unary plus and minus, and logical and bitwise not
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseUnary(state) {
+    var name, params, fn;
+    var operators = {
+      '-': 'unaryMinus',
+      '+': 'unaryPlus',
+      '~': 'bitNot',
+      'not': 'not'
+    };
+
+    if (operators.hasOwnProperty(state.token)) {
+      fn = operators[state.token];
+      name = state.token;
+      getTokenSkipNewline(state);
+      params = [parseUnary(state)];
+      return new OperatorNode(name, fn, params);
+    }
+
+    return parsePow(state);
+  }
+  /**
+   * power
+   * Note: power operator is right associative
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parsePow(state) {
+    var node, name, fn, params;
+    node = parseLeftHandOperators(state);
+
+    if (state.token === '^' || state.token === '.^') {
+      name = state.token;
+      fn = name === '^' ? 'pow' : 'dotPow';
+      getTokenSkipNewline(state);
+      params = [node, parseUnary(state)]; // Go back to unary, we can have '2^-3'
+
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+  /**
+   * Left hand operators: factorial x!, ctranspose x'
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseLeftHandOperators(state) {
+    var node, operators, name, fn, params;
+    node = parseCustomNodes(state);
+    operators = {
+      '!': 'factorial',
+      '\'': 'ctranspose'
+    };
+
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
+      fn = operators[name];
+      getToken(state);
+      params = [node];
+      node = new OperatorNode(name, fn, params);
+      node = parseAccessors(state, node);
+    }
+
+    return node;
+  }
+  /**
+   * Parse a custom node handler. A node handler can be used to process
+   * nodes in a custom way, for example for handling a plot.
+   *
+   * A handler must be passed as second argument of the parse function.
+   * - must extend math.expression.node.Node
+   * - must contain a function _compile(defs: Object) : string
+   * - must contain a function find(filter: Object) : Node[]
+   * - must contain a function toString() : string
+   * - the constructor is called with a single argument containing all parameters
+   *
+   * For example:
+   *
+   *     nodes = {
+   *       'plot': PlotHandler
+   *     }
+   *
+   * The constructor of the handler is called as:
+   *
+   *     node = new PlotHandler(params)
+   *
+   * The handler will be invoked when evaluating an expression like:
+   *
+   *     node = math.parse('plot(sin(x), x)', nodes)
+   *
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseCustomNodes(state) {
+    var params = [];
+
+    if (state.tokenType === TOKENTYPE.SYMBOL && state.extraNodes.hasOwnProperty(state.token)) {
+      var CustomNode = state.extraNodes[state.token];
+      getToken(state); // parse parameters
+
+      if (state.token === '(') {
+        params = [];
+        openParams(state);
+        getToken(state);
+
+        if (state.token !== ')') {
+          params.push(parseAssignment(state)); // parse a list with parameters
+
+          while (state.token === ',') {
+            // eslint-disable-line no-unmodified-loop-condition
+            getToken(state);
+            params.push(parseAssignment(state));
+          }
+        }
+
+        if (state.token !== ')') {
+          throw createSyntaxError(state, 'Parenthesis ) expected');
+        }
+
+        closeParams(state);
+        getToken(state);
+      } // create a new custom node
+      // noinspection JSValidateTypes
+
+
+      return new CustomNode(params);
+    }
+
+    return parseSymbol(state);
+  }
+  /**
+   * parse symbols: functions, variables, constants, units
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseSymbol(state) {
+    var node, name;
+
+    if (state.tokenType === TOKENTYPE.SYMBOL || state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS) {
+      name = state.token;
+      getToken(state);
+
+      if (CONSTANTS.hasOwnProperty(name)) {
+        // true, false, null, ...
+        node = new ConstantNode(CONSTANTS[name]);
+      } else if (NUMERIC_CONSTANTS.indexOf(name) !== -1) {
+        // NaN, Infinity
+        node = new ConstantNode(numeric(name, 'number'));
+      } else {
+        node = new SymbolNode(name);
+      } // parse function parameters and matrix index
+
+
+      node = parseAccessors(state, node);
+      return node;
+    }
+
+    return parseDoubleQuotesString(state);
+  }
+  /**
+   * parse accessors:
+   * - function invocation in round brackets (...), for example sqrt(2)
+   * - index enclosed in square brackets [...], for example A[2,3]
+   * - dot notation for properties, like foo.bar
+   * @param {Node} node    Node on which to apply the parameters. If there
+   *                       are no parameters in the expression, the node
+   *                       itself is returned
+   * @param {string[]} [types]  Filter the types of notations
+   *                            can be ['(', '[', '.']
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseAccessors(state, node, types) {
+    var params;
+
+    while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.indexOf(state.token) !== -1)) {
+      // eslint-disable-line no-unmodified-loop-condition
+      params = [];
+
+      if (state.token === '(') {
+        if (type.isSymbolNode(node) || type.isAccessorNode(node)) {
+          // function invocation like fn(2, 3) or obj.fn(2, 3)
+          openParams(state);
+          getToken(state);
+
+          if (state.token !== ')') {
+            params.push(parseAssignment(state)); // parse a list with parameters
+
+            while (state.token === ',') {
+              // eslint-disable-line no-unmodified-loop-condition
+              getToken(state);
+              params.push(parseAssignment(state));
+            }
+          }
+
+          if (state.token !== ')') {
+            throw createSyntaxError(state, 'Parenthesis ) expected');
+          }
+
+          closeParams(state);
+          getToken(state);
+          node = new FunctionNode(node, params);
+        } else {
+          // implicit multiplication like (2+3)(4+5) or sqrt(2)(1+2)
+          // don't parse it here but let it be handled by parseImplicitMultiplication
+          // with correct precedence
+          return node;
+        }
+      } else if (state.token === '[') {
+        // index notation like variable[2, 3]
+        openParams(state);
+        getToken(state);
+
+        if (state.token !== ']') {
+          params.push(parseAssignment(state)); // parse a list with parameters
+
+          while (state.token === ',') {
+            // eslint-disable-line no-unmodified-loop-condition
+            getToken(state);
+            params.push(parseAssignment(state));
+          }
+        }
+
+        if (state.token !== ']') {
+          throw createSyntaxError(state, 'Parenthesis ] expected');
+        }
+
+        closeParams(state);
+        getToken(state);
+        node = new AccessorNode(node, new IndexNode(params));
+      } else {
+        // dot notation like variable.prop
+        getToken(state);
+
+        if (state.tokenType !== TOKENTYPE.SYMBOL) {
+          throw createSyntaxError(state, 'Property name expected after dot');
+        }
+
+        params.push(new ConstantNode(state.token));
+        getToken(state);
+        var dotNotation = true;
+        node = new AccessorNode(node, new IndexNode(params, dotNotation));
+      }
+    }
+
+    return node;
+  }
+  /**
+   * Parse a double quotes string.
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseDoubleQuotesString(state) {
+    var node, str;
+
+    if (state.token === '"') {
+      str = parseDoubleQuotesStringToken(state); // create constant
+
+      node = new ConstantNode(str); // parse index parameters
+
+      node = parseAccessors(state, node);
+      return node;
+    }
+
+    return parseSingleQuotesString(state);
+  }
+  /**
+   * Parse a string surrounded by double quotes "..."
+   * @return {string}
+   */
+
+
+  function parseDoubleQuotesStringToken(state) {
+    var str = '';
+
+    while (currentCharacter(state) !== '' && currentCharacter(state) !== '"') {
+      if (currentCharacter(state) === '\\') {
+        // escape character, immediately process the next
+        // character to prevent stopping at a next '\"'
+        str += currentCharacter(state);
+        next(state);
+      }
+
+      str += currentCharacter(state);
+      next(state);
+    }
+
+    getToken(state);
+
+    if (state.token !== '"') {
+      throw createSyntaxError(state, 'End of string " expected');
+    }
+
+    getToken(state);
+    return JSON.parse('"' + str + '"'); // unescape escaped characters
+  }
+  /**
+   * Parse a single quotes string.
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseSingleQuotesString(state) {
+    var node, str;
+
+    if (state.token === '\'') {
+      str = parseSingleQuotesStringToken(state); // create constant
+
+      node = new ConstantNode(str); // parse index parameters
+
+      node = parseAccessors(state, node);
+      return node;
+    }
+
+    return parseMatrix(state);
+  }
+  /**
+   * Parse a string surrounded by single quotes '...'
+   * @return {string}
+   */
+
+
+  function parseSingleQuotesStringToken(state) {
+    var str = '';
+
+    while (currentCharacter(state) !== '' && currentCharacter(state) !== '\'') {
+      if (currentCharacter(state) === '\\') {
+        // escape character, immediately process the next
+        // character to prevent stopping at a next '\''
+        str += currentCharacter(state);
+        next(state);
+      }
+
+      str += currentCharacter(state);
+      next(state);
+    }
+
+    getToken(state);
+
+    if (state.token !== '\'') {
+      throw createSyntaxError(state, 'End of string \' expected');
+    }
+
+    getToken(state);
+    return JSON.parse('"' + str + '"'); // unescape escaped characters
+  }
+  /**
+   * parse the matrix
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseMatrix(state) {
+    var array, params, rows, cols;
+
+    if (state.token === '[') {
+      // matrix [...]
+      openParams(state);
+      getToken(state);
+
+      if (state.token !== ']') {
+        // this is a non-empty matrix
+        var row = parseRow(state);
+
+        if (state.token === ';') {
+          // 2 dimensional array
+          rows = 1;
+          params = [row]; // the rows of the matrix are separated by dot-comma's
+
+          while (state.token === ';') {
+            // eslint-disable-line no-unmodified-loop-condition
+            getToken(state);
+            params[rows] = parseRow(state);
+            rows++;
+          }
+
+          if (state.token !== ']') {
+            throw createSyntaxError(state, 'End of matrix ] expected');
+          }
+
+          closeParams(state);
+          getToken(state); // check if the number of columns matches in all rows
+
+          cols = params[0].items.length;
+
+          for (var r = 1; r < rows; r++) {
+            if (params[r].items.length !== cols) {
+              throw createError(state, 'Column dimensions mismatch ' + '(' + params[r].items.length + ' !== ' + cols + ')');
+            }
+          }
+
+          array = new ArrayNode(params);
+        } else {
+          // 1 dimensional vector
+          if (state.token !== ']') {
+            throw createSyntaxError(state, 'End of matrix ] expected');
+          }
+
+          closeParams(state);
+          getToken(state);
+          array = row;
+        }
+      } else {
+        // this is an empty matrix "[ ]"
+        closeParams(state);
+        getToken(state);
+        array = new ArrayNode([]);
+      }
+
+      return parseAccessors(state, array);
+    }
+
+    return parseObject(state);
+  }
+  /**
+   * Parse a single comma-separated row from a matrix, like 'a, b, c'
+   * @return {ArrayNode} node
+   */
+
+
+  function parseRow(state) {
+    var params = [parseAssignment(state)];
+    var len = 1;
+
+    while (state.token === ',') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getToken(state); // parse expression
+
+      params[len] = parseAssignment(state);
+      len++;
+    }
+
+    return new ArrayNode(params);
+  }
+  /**
+   * parse an object, enclosed in angle brackets{...}, for example {value: 2}
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseObject(state) {
+    if (state.token === '{') {
+      var key;
+      var properties = {};
+
+      do {
+        getToken(state);
+
+        if (state.token !== '}') {
+          // parse key
+          if (state.token === '"') {
+            key = parseDoubleQuotesStringToken(state);
+          } else if (state.token === '\'') {
+            key = parseSingleQuotesStringToken(state);
+          } else if (state.tokenType === TOKENTYPE.SYMBOL) {
+            key = state.token;
+            getToken(state);
+          } else {
+            throw createSyntaxError(state, 'Symbol or string expected as object key');
+          } // parse key/value separator
+
+
+          if (state.token !== ':') {
+            throw createSyntaxError(state, 'Colon : expected after object key');
+          }
+
+          getToken(state); // parse key
+
+          properties[key] = parseAssignment(state);
+        }
+      } while (state.token === ','); // eslint-disable-line no-unmodified-loop-condition
+
+
+      if (state.token !== '}') {
+        throw createSyntaxError(state, 'Comma , or bracket } expected after object value');
+      }
+
+      getToken(state);
+      var node = new ObjectNode(properties); // parse index parameters
+
+      node = parseAccessors(state, node);
+      return node;
+    }
+
+    return parseNumber(state);
+  }
+  /**
+   * parse a number
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseNumber(state) {
+    var numberStr;
+
+    if (state.tokenType === TOKENTYPE.NUMBER) {
+      // this is a number
+      numberStr = state.token;
+      getToken(state);
+      return new ConstantNode(numeric(numberStr, config.number));
+    }
+
+    return parseParentheses(state);
+  }
+  /**
+   * parentheses
+   * @return {Node} node
+   * @private
+   */
+
+
+  function parseParentheses(state) {
+    var node; // check if it is a parenthesized expression
+
+    if (state.token === '(') {
+      // parentheses (...)
+      openParams(state);
+      getToken(state);
+      node = parseAssignment(state); // start again
+
+      if (state.token !== ')') {
+        throw createSyntaxError(state, 'Parenthesis ) expected');
+      }
+
+      closeParams(state);
+      getToken(state);
+      node = new ParenthesisNode(node);
+      node = parseAccessors(state, node);
+      return node;
+    }
+
+    return parseEnd(state);
+  }
+  /**
+   * Evaluated when the expression is not yet ended but expected to end
+   * @return {Node} res
+   * @private
+   */
+
+
+  function parseEnd(state) {
+    if (state.token === '') {
+      // syntax error or unexpected end of expression
+      throw createSyntaxError(state, 'Unexpected end of expression');
+    } else {
+      throw createSyntaxError(state, 'Value expected');
+    }
+  }
+  /**
+   * Shortcut for getting the current row value (one based)
+   * Returns the line of the currently handled expression
+   * @private
+   */
+
+  /* TODO: implement keeping track on the row number
+  function row () {
+    return null
+  }
+  */
+
+  /**
+   * Shortcut for getting the current col value (one based)
+   * Returns the column (position) where the last state.token starts
+   * @private
+   */
+
+
+  function col(state) {
+    return state.index - state.token.length + 1;
+  }
+  /**
+   * Create an error
+   * @param {string} message
+   * @return {SyntaxError} instantiated error
+   * @private
+   */
+
+
+  function createSyntaxError(state, message) {
+    var c = col(state);
+    var error = new SyntaxError(message + ' (char ' + c + ')');
+    error['char'] = c;
+    return error;
+  }
+  /**
+   * Create an error
+   * @param {string} message
+   * @return {Error} instantiated error
+   * @private
+   */
+
+
+  function createError(state, message) {
+    var c = col(state);
+    var error = new SyntaxError(message + ' (char ' + c + ')');
+    error['char'] = c;
+    return error;
+  }
+
+  return parse;
+}
+
+exports.name = 'parse';
+exports.path = 'expression';
+exports.factory = factory;
+},{"../error/ArgumentsError":8,"../type/numeric":44,"../utils/collection/deepMap":49,"./node/AccessorNode":15,"./node/ArrayNode":16,"./node/AssignmentNode":17,"./node/BlockNode":18,"./node/ConditionalNode":19,"./node/ConstantNode":20,"./node/FunctionAssignmentNode":21,"./node/FunctionNode":22,"./node/IndexNode":23,"./node/ObjectNode":25,"./node/OperatorNode":26,"./node/ParenthesisNode":27,"./node/RangeNode":28,"./node/RelationalNode":29,"./node/SymbolNode":30}],35:[function(require,module,exports){
+'use strict';
+
+var IndexError = require('../../error/IndexError');
+/**
+ * Transform zero-based indices to one-based indices in errors
+ * @param {Error} err
+ * @returns {Error} Returns the transformed error
+ */
+
+
+exports.transform = function (err) {
+  if (err && err.isIndexError) {
+    return new IndexError(err.index + 1, err.min + 1, err.max !== undefined ? err.max + 1 : undefined);
+  }
+
+  return err;
+};
+},{"../../error/IndexError":10}],36:[function(require,module,exports){
+'use strict';
+
+var clone = require('../../utils/object').clone;
+
+var validateIndex = require('../../utils/array').validateIndex;
+
+var getSafeProperty = require('../../utils/customs').getSafeProperty;
+
+var setSafeProperty = require('../../utils/customs').setSafeProperty;
+
+var DimensionError = require('../../error/DimensionError');
+
+function factory(type, config, load, typed) {
+  var matrix = load(require('../../type/matrix/function/matrix'));
+  /**
+   * Get or set a subset of a matrix or string.
+   *
+   * Syntax:
+   *     math.subset(value, index)                                // retrieve a subset
+   *     math.subset(value, index, replacement [, defaultValue])  // replace a subset
+   *
+   * Examples:
+   *
+   *     // get a subset
+   *     const d = [[1, 2], [3, 4]]
+   *     math.subset(d, math.index(1, 0))        // returns 3
+   *     math.subset(d, math.index([0, 1], 1))   // returns [[2], [4]]
+   *
+   *     // replace a subset
+   *     const e = []
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
+   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
+   *
+   * See also:
+   *
+   *     size, resize, squeeze, index
+   *
+   * @param {Array | Matrix | string} matrix  An array, matrix, or string
+   * @param {Index} index                     An index containing ranges for each
+   *                                          dimension
+   * @param {*} [replacement]                 An array, matrix, or scalar.
+   *                                          If provided, the subset is replaced with replacement.
+   *                                          If not provided, the subset is returned
+   * @param {*} [defaultValue=undefined]      Default value, filled in on new entries when
+   *                                          the matrix is resized. If not provided,
+   *                                          math.matrix elements will be left undefined.
+   * @return {Array | Matrix | string} Either the retrieved subset or the updated matrix.
+   */
+
+  var subset = typed('subset', {
+    // get subset
+    'Array, Index': function ArrayIndex(value, index) {
+      var m = matrix(value);
+      var subset = m.subset(index); // returns a Matrix
+
+      return index.isScalar() ? subset : subset.valueOf(); // return an Array (like the input)
+    },
+    'Matrix, Index': function MatrixIndex(value, index) {
+      return value.subset(index);
+    },
+    'Object, Index': _getObjectProperty,
+    'string, Index': _getSubstring,
+    // set subset
+    'Array, Index, any': function ArrayIndexAny(value, index, replacement) {
+      return matrix(clone(value)).subset(index, replacement, undefined).valueOf();
+    },
+    'Array, Index, any, any': function ArrayIndexAnyAny(value, index, replacement, defaultValue) {
+      return matrix(clone(value)).subset(index, replacement, defaultValue).valueOf();
+    },
+    'Matrix, Index, any': function MatrixIndexAny(value, index, replacement) {
+      return value.clone().subset(index, replacement);
+    },
+    'Matrix, Index, any, any': function MatrixIndexAnyAny(value, index, replacement, defaultValue) {
+      return value.clone().subset(index, replacement, defaultValue);
+    },
+    'string, Index, string': _setSubstring,
+    'string, Index, string, string': _setSubstring,
+    'Object, Index, any': _setObjectProperty
+  });
+  subset.toTex = undefined; // use default template
+
+  return subset;
+  /**
+   * Retrieve a subset of a string
+   * @param {string} str            string from which to get a substring
+   * @param {Index} index           An index containing ranges for each dimension
+   * @returns {string} substring
+   * @private
+   */
+
+  function _getSubstring(str, index) {
+    if (!type.isIndex(index)) {
+      // TODO: better error message
+      throw new TypeError('Index expected');
+    }
+
+    if (index.size().length !== 1) {
+      throw new DimensionError(index.size().length, 1);
+    } // validate whether the range is out of range
+
+
+    var strLen = str.length;
+    validateIndex(index.min()[0], strLen);
+    validateIndex(index.max()[0], strLen);
+    var range = index.dimension(0);
+    var substr = '';
+    range.forEach(function (v) {
+      substr += str.charAt(v);
+    });
+    return substr;
+  }
+  /**
+   * Replace a substring in a string
+   * @param {string} str            string to be replaced
+   * @param {Index} index           An index containing ranges for each dimension
+   * @param {string} replacement    Replacement string
+   * @param {string} [defaultValue] Default value to be uses when resizing
+   *                                the string. is ' ' by default
+   * @returns {string} result
+   * @private
+   */
+
+
+  function _setSubstring(str, index, replacement, defaultValue) {
+    if (!index || index.isIndex !== true) {
+      // TODO: better error message
+      throw new TypeError('Index expected');
+    }
+
+    if (index.size().length !== 1) {
+      throw new DimensionError(index.size().length, 1);
+    }
+
+    if (defaultValue !== undefined) {
+      if (typeof defaultValue !== 'string' || defaultValue.length !== 1) {
+        throw new TypeError('Single character expected as defaultValue');
+      }
+    } else {
+      defaultValue = ' ';
+    }
+
+    var range = index.dimension(0);
+    var len = range.size()[0];
+
+    if (len !== replacement.length) {
+      throw new DimensionError(range.size()[0], replacement.length);
+    } // validate whether the range is out of range
+
+
+    var strLen = str.length;
+    validateIndex(index.min()[0]);
+    validateIndex(index.max()[0]); // copy the string into an array with characters
+
+    var chars = [];
+
+    for (var i = 0; i < strLen; i++) {
+      chars[i] = str.charAt(i);
+    }
+
+    range.forEach(function (v, i) {
+      chars[v] = replacement.charAt(i[0]);
+    }); // initialize undefined characters with a space
+
+    if (chars.length > strLen) {
+      for (var _i = strLen - 1, _len = chars.length; _i < _len; _i++) {
+        if (!chars[_i]) {
+          chars[_i] = defaultValue;
+        }
+      }
+    }
+
+    return chars.join('');
+  }
+}
+/**
+ * Retrieve a property from an object
+ * @param {Object} object
+ * @param {Index} index
+ * @return {*} Returns the value of the property
+ * @private
+ */
+
+
+function _getObjectProperty(object, index) {
+  if (index.size().length !== 1) {
+    throw new DimensionError(index.size(), 1);
+  }
+
+  var key = index.dimension(0);
+
+  if (typeof key !== 'string') {
+    throw new TypeError('String expected as index to retrieve an object property');
+  }
+
+  return getSafeProperty(object, key);
+}
+/**
+ * Set a property on an object
+ * @param {Object} object
+ * @param {Index} index
+ * @param {*} replacement
+ * @return {*} Returns the updated object
+ * @private
+ */
+
+
+function _setObjectProperty(object, index, replacement) {
+  if (index.size().length !== 1) {
+    throw new DimensionError(index.size(), 1);
+  }
+
+  var key = index.dimension(0);
+
+  if (typeof key !== 'string') {
+    throw new TypeError('String expected as index to retrieve an object property');
+  } // clone the object, and apply the property to the clone
+
+
+  var updated = clone(object);
+  setSafeProperty(updated, key, replacement);
+  return updated;
+}
+
+exports.name = 'subset';
+exports.factory = factory;
+},{"../../error/DimensionError":9,"../../type/matrix/function/matrix":42,"../../utils/array":46,"../../utils/customs":51,"../../utils/object":55}],37:[function(require,module,exports){
+'use strict';
+
+var string = require('../../utils/string');
+
+function factory(type, config, load, typed) {
+  /**
+   * Format a value of any type into a string.
+   *
+   * Syntax:
+   *
+   *    math.format(value)
+   *    math.format(value, options)
+   *    math.format(value, precision)
+   *    math.format(value, callback)
+   *
+   * Where:
+   *
+   *  - `value: *`
+   *    The value to be formatted
+   *  - `options: Object`
+   *    An object with formatting options. Available options:
+   *    - `notation: string`
+   *      Number notation. Choose from:
+   *      - 'fixed'
+   *        Always use regular number notation.
+   *        For example '123.40' and '14000000'
+   *      - 'exponential'
+   *        Always use exponential notation.
+   *        For example '1.234e+2' and '1.4e+7'
+   *      - 'engineering'
+   *        Always use engineering notation.
+   *        For example '123.4e+0' and '14.0e+6'
+   *      - 'auto' (default)
+   *        Regular number notation for numbers having an absolute value between
+   *        `lower` and `upper` bounds, and uses exponential notation elsewhere.
+   *        Lower bound is included, upper bound is excluded.
+   *        For example '123.4' and '1.4e7'.
+   *    - `precision: number`
+   *      A number between 0 and 16 to round the digits of the number. In case
+   *      of notations 'exponential', 'engineering', and 'auto', `precision`
+   *      defines the total number of significant digits returned.
+   *      In case of notation 'fixed', `precision` defines the number of
+   *      significant digits after the decimal point.
+   *      `precision` is undefined by default.
+   *    - `lowerExp: number`
+   *      Exponent determining the lower boundary for formatting a value with
+   *      an exponent when `notation='auto`. Default value is `-3`.
+   *    - `upperExp: number`
+   *      Exponent determining the upper boundary for formatting a value with
+   *      an exponent when `notation='auto`. Default value is `5`.
+   *    - `fraction: string`. Available values: 'ratio' (default) or 'decimal'.
+   *      For example `format(fraction(1, 3))` will output '1/3' when 'ratio' is
+   *      configured, and will output `0.(3)` when 'decimal' is configured.
+   * - `callback: function`
+   *   A custom formatting function, invoked for all numeric elements in `value`,
+   *   for example all elements of a matrix, or the real and imaginary
+   *   parts of a complex number. This callback can be used to override the
+   *   built-in numeric notation with any type of formatting. Function `callback`
+   *   is called with `value` as parameter and must return a string.
+   *
+   * When `value` is an Object:
+   *
+   * - When the object contains a property `format` being a function, this function
+   *   is invoked as `value.format(options)` and the result is returned.
+   * - When the object has its own `toString` method, this method is invoked
+   *   and the result is returned.
+   * - In other cases the function will loop over all object properties and
+   *   return JSON object notation like '{"a": 2, "b": 3}'.
+   *
+   * When value is a function:
+   *
+   * - When the function has a property `syntax`, it returns this
+   *   syntax description.
+   * - In other cases, a string `'function'` is returned.
+   *
+   * Examples:
+   *
+   *    math.format(6.4)                                        // returns '6.4'
+   *    math.format(1240000)                                    // returns '1.24e6'
+   *    math.format(1/3)                                        // returns '0.3333333333333333'
+   *    math.format(1/3, 3)                                     // returns '0.333'
+   *    math.format(21385, 2)                                   // returns '21000'
+   *    math.format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+   *    math.format(2.3,  {notation: 'fixed', precision: 4})    // returns '2.3000'
+   *    math.format(52.8, {notation: 'exponential'})            // returns '5.28e+1'
+   *    math.format(12400,{notation: 'engineering'})            // returns '12.400e+3'
+   *    math.format(2000, {lowerExp: -2, upperExp: 2})          // returns '2e+3'
+   *
+   *    function formatCurrency(value) {
+   *      // return currency notation with two digits:
+   *      return '$' + value.toFixed(2)
+   *
+   *      // you could also use math.format inside the callback:
+   *      // return '$' + math.format(value, {notation: 'fixed', precision: 2})
+   *    }
+   *    math.format([2.1, 3, 0.016], formatCurrency}            // returns '[$2.10, $3.00, $0.02]'
+   *
+   * See also:
+   *
+   *    print
+   *
+   * @param {*} value                               Value to be stringified
+   * @param {Object | Function | number} [options]  Formatting options
+   * @return {string} The formatted value
+   */
+  var format = typed('format', {
+    'any': string.format,
+    'any, Object | function | number': string.format
+  });
+  format.toTex = undefined; // use default template
+
+  return format;
+}
+
+exports.name = 'format';
+exports.factory = factory;
+},{"../../utils/string":57}],38:[function(require,module,exports){
+'use strict';
+
+function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
+
+function factory(type, config, load, typed) {
+  /**
+   * Determine the type of a variable.
+   *
+   * Function `typeof` recognizes the following types of objects:
+   *
+   * Object                 | Returns       | Example
+   * ---------------------- | ------------- | ------------------------------------------
+   * null                   | `'null'`      | `math.typeof(null)`
+   * number                 | `'number'`    | `math.typeof(3.5)`
+   * boolean                | `'boolean'`   | `math.typeof(true)`
+   * string                 | `'string'`    | `math.typeof('hello world')`
+   * Array                  | `'Array'`     | `math.typeof([1, 2, 3])`
+   * Date                   | `'Date'`      | `math.typeof(new Date())`
+   * Function               | `'Function'`  | `math.typeof(function () {})`
+   * Object                 | `'Object'`    | `math.typeof({a: 2, b: 3})`
+   * RegExp                 | `'RegExp'`    | `math.typeof(/a regexp/)`
+   * undefined              | `'undefined'` | `math.typeof(undefined)`
+   * math.type.BigNumber    | `'BigNumber'` | `math.typeof(math.bignumber('2.3e500'))`
+   * math.type.Chain        | `'Chain'`     | `math.typeof(math.chain(2))`
+   * math.type.Complex      | `'Complex'`   | `math.typeof(math.complex(2, 3))`
+   * math.type.Fraction     | `'Fraction'`  | `math.typeof(math.fraction(1, 3))`
+   * math.type.Help         | `'Help'`      | `math.typeof(math.help('sqrt'))`
+   * math.type.Help         | `'Help'`      | `math.typeof(math.help('sqrt'))`
+   * math.type.Index        | `'Index'`     | `math.typeof(math.index(1, 3))`
+   * math.type.Matrix       | `'Matrix'`    | `math.typeof(math.matrix([[1,2], [3, 4]]))`
+   * math.type.Range        | `'Range'`     | `math.typeof(math.range(0, 10))`
+   * math.type.ResultSet    | `'ResultSet'` | `math.typeof(math.eval('a=2\nb=3'))`
+   * math.type.Unit         | `'Unit'`      | `math.typeof(math.unit('45 deg'))`
+   * math.expression.node&#8203;.AccessorNode            | `'AccessorNode'`            | `math.typeof(math.parse('A[2]'))`
+   * math.expression.node&#8203;.ArrayNode               | `'ArrayNode'`               | `math.typeof(math.parse('[1,2,3]'))`
+   * math.expression.node&#8203;.AssignmentNode          | `'AssignmentNode'`          | `math.typeof(math.parse('x=2'))`
+   * math.expression.node&#8203;.BlockNode               | `'BlockNode'`               | `math.typeof(math.parse('a=2; b=3'))`
+   * math.expression.node&#8203;.ConditionalNode         | `'ConditionalNode'`         | `math.typeof(math.parse('x<0 ? -x : x'))`
+   * math.expression.node&#8203;.ConstantNode            | `'ConstantNode'`            | `math.typeof(math.parse('2.3'))`
+   * math.expression.node&#8203;.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeof(math.parse('f(x)=x^2'))`
+   * math.expression.node&#8203;.FunctionNode            | `'FunctionNode'`            | `math.typeof(math.parse('sqrt(4)'))`
+   * math.expression.node&#8203;.IndexNode               | `'IndexNode'`               | `math.typeof(math.parse('A[2]').index)`
+   * math.expression.node&#8203;.ObjectNode              | `'ObjectNode'`              | `math.typeof(math.parse('{a:2}'))`
+   * math.expression.node&#8203;.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeof(math.parse('(2+3)'))`
+   * math.expression.node&#8203;.RangeNode               | `'RangeNode'`               | `math.typeof(math.parse('1:10'))`
+   * math.expression.node&#8203;.SymbolNode              | `'SymbolNode'`              | `math.typeof(math.parse('x'))`
+   *
+   * Syntax:
+   *
+   *    math.typeof(x)
+   *
+   * Examples:
+   *
+   *    math.typeof(3.5)                     // returns 'number'
+   *    math.typeof(math.complex('2-4i'))    // returns 'Complex'
+   *    math.typeof(math.unit('45 deg'))     // returns 'Unit'
+   *    math.typeof('hello world')           // returns 'string'
+   *
+   * @param {*} x     The variable for which to test the type.
+   * @return {string} Returns the name of the type. Primitive types are lower case,
+   *                  non-primitive types are upper-camel-case.
+   *                  For example 'number', 'string', 'Array', 'Date'.
+   */
+  var _typeof = typed('_typeof', {
+    'any': function any(x) {
+      var t = _typeof2(x);
+
+      if (t === 'object') {
+        // JavaScript types
+        if (x === null) return 'null';
+        if (Array.isArray(x)) return 'Array';
+        if (x instanceof Date) return 'Date';
+        if (x instanceof RegExp) return 'RegExp'; // math.js types
+
+        if (type.isBigNumber(x)) return 'BigNumber';
+        if (type.isComplex(x)) return 'Complex';
+        if (type.isFraction(x)) return 'Fraction';
+        if (type.isMatrix(x)) return 'Matrix';
+        if (type.isUnit(x)) return 'Unit';
+        if (type.isIndex(x)) return 'Index';
+        if (type.isRange(x)) return 'Range';
+        if (type.isResultSet(x)) return 'ResultSet';
+        if (type.isNode(x)) return x.type;
+        if (type.isChain(x)) return 'Chain';
+        if (type.isHelp(x)) return 'Help';
+        return 'Object';
+      }
+
+      if (t === 'function') return 'Function';
+      return t; // can be 'string', 'number', 'boolean', ...
+    }
+  });
+
+  _typeof.toTex = undefined; // use default template
+
+  return _typeof;
+}
+
+exports.name = 'typeof';
+exports.factory = factory;
+},{}],39:[function(require,module,exports){
+'use strict';
+
+var deepMap = require('../../../utils/collection/deepMap');
+
+function factory(type, config, load, typed) {
+  /**
+   * Create a BigNumber, which can store numbers with arbitrary precision.
+   * When a matrix is provided, all elements will be converted to BigNumber.
+   *
+   * Syntax:
+   *
+   *    math.bignumber(x)
+   *
+   * Examples:
+   *
+   *    0.1 + 0.2                                  // returns number 0.30000000000000004
+   *    math.bignumber(0.1) + math.bignumber(0.2)  // returns BigNumber 0.3
+   *
+   *
+   *    7.2e500                                    // returns number Infinity
+   *    math.bignumber('7.2e500')                  // returns BigNumber 7.2e500
+   *
+   * See also:
+   *
+   *    boolean, complex, index, matrix, string, unit
+   *
+   * @param {number | string | Fraction | BigNumber | Array | Matrix | boolean | null} [value]  Value for the big number,
+   *                                                    0 by default.
+   * @returns {BigNumber} The created bignumber
+   */
+  var bignumber = typed('bignumber', {
+    '': function _() {
+      return new type.BigNumber(0);
+    },
+    'number': function number(x) {
+      // convert to string to prevent errors in case of >15 digits
+      return new type.BigNumber(x + '');
+    },
+    'string': function string(x) {
+      return new type.BigNumber(x);
+    },
+    'BigNumber': function BigNumber(x) {
+      // we assume a BigNumber is immutable
+      return x;
+    },
+    'Fraction': function Fraction(x) {
+      return new type.BigNumber(x.n).div(x.d).times(x.s);
+    },
+    'null': function _null(x) {
+      return new type.BigNumber(0);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return deepMap(x, bignumber);
+    }
+  });
+  bignumber.toTex = {
+    0: '0',
+    1: "\\left(${args[0]}\\right)"
+  };
+  return bignumber;
+}
+
+exports.name = 'bignumber';
+exports.factory = factory;
+},{"../../../utils/collection/deepMap":49}],40:[function(require,module,exports){
+'use strict';
+
+var deepMap = require('../../../utils/collection/deepMap');
+
+function factory(type, config, load, typed) {
+  /**
+   * Create a fraction convert a value to a fraction.
+   *
+   * Syntax:
+   *     math.fraction(numerator, denominator)
+   *     math.fraction({n: numerator, d: denominator})
+   *     math.fraction(matrix: Array | Matrix)         Turn all matrix entries
+   *                                                   into fractions
+   *
+   * Examples:
+   *
+   *     math.fraction(1, 3)
+   *     math.fraction('2/3')
+   *     math.fraction({n: 2, d: 3})
+   *     math.fraction([0.2, 0.25, 1.25])
+   *
+   * See also:
+   *
+   *    bignumber, number, string, unit
+   *
+   * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
+   *            Arguments specifying the numerator and denominator of
+   *            the fraction
+   * @return {Fraction | Array | Matrix} Returns a fraction
+   */
+  var fraction = typed('fraction', {
+    'number': function number(x) {
+      if (!isFinite(x) || isNaN(x)) {
+        throw new Error(x + ' cannot be represented as a fraction');
+      }
+
+      return new type.Fraction(x);
+    },
+    'string': function string(x) {
+      return new type.Fraction(x);
+    },
+    'number, number': function numberNumber(numerator, denominator) {
+      return new type.Fraction(numerator, denominator);
+    },
+    'null': function _null(x) {
+      return new type.Fraction(0);
+    },
+    'BigNumber': function BigNumber(x) {
+      return new type.Fraction(x.toString());
+    },
+    'Fraction': function Fraction(x) {
+      return x; // fractions are immutable
+    },
+    'Object': function Object(x) {
+      return new type.Fraction(x);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return deepMap(x, fraction);
+    }
+  });
+  return fraction;
+}
+
+exports.name = 'fraction';
+exports.factory = factory;
+},{"../../../utils/collection/deepMap":49}],41:[function(require,module,exports){
+'use strict';
+
+var number = require('../../utils/number');
+
+function factory(type, config, load, typed) {
+  /**
+   * Create a range. A range has a start, step, and end, and contains functions
+   * to iterate over the range.
+   *
+   * A range can be constructed as:
+   *
+   *     const range = new Range(start, end)
+   *     const range = new Range(start, end, step)
+   *
+   * To get the result of the range:
+   *     range.forEach(function (x) {
+   *         console.log(x)
+   *     })
+   *     range.map(function (x) {
+   *         return math.sin(x)
+   *     })
+   *     range.toArray()
+   *
+   * Example usage:
+   *
+   *     const c = new Range(2, 6)       // 2:1:5
+   *     c.toArray()                     // [2, 3, 4, 5]
+   *     const d = new Range(2, -3, -1)  // 2:-1:-2
+   *     d.toArray()                     // [2, 1, 0, -1, -2]
+   *
+   * @class Range
+   * @constructor Range
+   * @param {number} start  included lower bound
+   * @param {number} end    excluded upper bound
+   * @param {number} [step] step size, default value is 1
+   */
+  function Range(start, end, step) {
+    if (!(this instanceof Range)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    var hasStart = start !== null && start !== undefined;
+    var hasEnd = end !== null && end !== undefined;
+    var hasStep = step !== null && step !== undefined;
+
+    if (hasStart) {
+      if (type.isBigNumber(start)) {
+        start = start.toNumber();
+      } else if (typeof start !== 'number') {
+        throw new TypeError('Parameter start must be a number');
+      }
+    }
+
+    if (hasEnd) {
+      if (type.isBigNumber(end)) {
+        end = end.toNumber();
+      } else if (typeof end !== 'number') {
+        throw new TypeError('Parameter end must be a number');
+      }
+    }
+
+    if (hasStep) {
+      if (type.isBigNumber(step)) {
+        step = step.toNumber();
+      } else if (typeof step !== 'number') {
+        throw new TypeError('Parameter step must be a number');
+      }
+    }
+
+    this.start = hasStart ? parseFloat(start) : 0;
+    this.end = hasEnd ? parseFloat(end) : 0;
+    this.step = hasStep ? parseFloat(step) : 1;
+  }
+  /**
+   * Attach type information
+   */
+
+
+  Range.prototype.type = 'Range';
+  Range.prototype.isRange = true;
+  /**
+   * Parse a string into a range,
+   * The string contains the start, optional step, and end, separated by a colon.
+   * If the string does not contain a valid range, null is returned.
+   * For example str='0:2:11'.
+   * @memberof Range
+   * @param {string} str
+   * @return {Range | null} range
+   */
+
+  Range.parse = function (str) {
+    if (typeof str !== 'string') {
+      return null;
+    }
+
+    var args = str.split(':');
+    var nums = args.map(function (arg) {
+      return parseFloat(arg);
+    });
+    var invalid = nums.some(function (num) {
+      return isNaN(num);
+    });
+
+    if (invalid) {
+      return null;
+    }
+
+    switch (nums.length) {
+      case 2:
+        return new Range(nums[0], nums[1]);
+
+      case 3:
+        return new Range(nums[0], nums[2], nums[1]);
+
+      default:
+        return null;
+    }
+  };
+  /**
+   * Create a clone of the range
+   * @return {Range} clone
+   */
+
+
+  Range.prototype.clone = function () {
+    return new Range(this.start, this.end, this.step);
+  };
+  /**
+   * Retrieve the size of the range.
+   * Returns an array containing one number, the number of elements in the range.
+   * @memberof Range
+   * @returns {number[]} size
+   */
+
+
+  Range.prototype.size = function () {
+    var len = 0;
+    var start = this.start;
+    var step = this.step;
+    var end = this.end;
+    var diff = end - start;
+
+    if (number.sign(step) === number.sign(diff)) {
+      len = Math.ceil(diff / step);
+    } else if (diff === 0) {
+      len = 0;
+    }
+
+    if (isNaN(len)) {
+      len = 0;
+    }
+
+    return [len];
+  };
+  /**
+   * Calculate the minimum value in the range
+   * @memberof Range
+   * @return {number | undefined} min
+   */
+
+
+  Range.prototype.min = function () {
+    var size = this.size()[0];
+
+    if (size > 0) {
+      if (this.step > 0) {
+        // positive step
+        return this.start;
+      } else {
+        // negative step
+        return this.start + (size - 1) * this.step;
+      }
+    } else {
+      return undefined;
+    }
+  };
+  /**
+   * Calculate the maximum value in the range
+   * @memberof Range
+   * @return {number | undefined} max
+   */
+
+
+  Range.prototype.max = function () {
+    var size = this.size()[0];
+
+    if (size > 0) {
+      if (this.step > 0) {
+        // positive step
+        return this.start + (size - 1) * this.step;
+      } else {
+        // negative step
+        return this.start;
+      }
+    } else {
+      return undefined;
+    }
+  };
+  /**
+   * Execute a callback function for each value in the range.
+   * @memberof Range
+   * @param {function} callback   The callback method is invoked with three
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Range being traversed.
+   */
+
+
+  Range.prototype.forEach = function (callback) {
+    var x = this.start;
+    var step = this.step;
+    var end = this.end;
+    var i = 0;
+
+    if (step > 0) {
+      while (x < end) {
+        callback(x, [i], this);
+        x += step;
+        i++;
+      }
+    } else if (step < 0) {
+      while (x > end) {
+        callback(x, [i], this);
+        x += step;
+        i++;
+      }
+    }
+  };
+  /**
+   * Execute a callback function for each value in the Range, and return the
+   * results as an array
+   * @memberof Range
+   * @param {function} callback   The callback method is invoked with three
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Matrix being traversed.
+   * @returns {Array} array
+   */
+
+
+  Range.prototype.map = function (callback) {
+    var array = [];
+    this.forEach(function (value, index, obj) {
+      array[index[0]] = callback(value, index, obj);
+    });
+    return array;
+  };
+  /**
+   * Create an Array with a copy of the Ranges data
+   * @memberof Range
+   * @returns {Array} array
+   */
+
+
+  Range.prototype.toArray = function () {
+    var array = [];
+    this.forEach(function (value, index) {
+      array[index[0]] = value;
+    });
+    return array;
+  };
+  /**
+   * Get the primitive value of the Range, a one dimensional array
+   * @memberof Range
+   * @returns {Array} array
+   */
+
+
+  Range.prototype.valueOf = function () {
+    // TODO: implement a caching mechanism for range.valueOf()
+    return this.toArray();
+  };
+  /**
+   * Get a string representation of the range, with optional formatting options.
+   * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+   * @memberof Range
+   * @param {Object | number | function} [options]  Formatting options. See
+   *                                                lib/utils/number:format for a
+   *                                                description of the available
+   *                                                options.
+   * @returns {string} str
+   */
+
+
+  Range.prototype.format = function (options) {
+    var str = number.format(this.start, options);
+
+    if (this.step !== 1) {
+      str += ':' + number.format(this.step, options);
+    }
+
+    str += ':' + number.format(this.end, options);
+    return str;
+  };
+  /**
+   * Get a string representation of the range.
+   * @memberof Range
+   * @returns {string}
+   */
+
+
+  Range.prototype.toString = function () {
+    return this.format();
+  };
+  /**
+   * Get a JSON representation of the range
+   * @memberof Range
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+   */
+
+
+  Range.prototype.toJSON = function () {
+    return {
+      mathjs: 'Range',
+      start: this.start,
+      end: this.end,
+      step: this.step
+    };
+  };
+  /**
+   * Instantiate a Range from a JSON object
+   * @memberof Range
+   * @param {Object} json A JSON object structured as:
+   *                      `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+   * @return {Range}
+   */
+
+
+  Range.fromJSON = function (json) {
+    return new Range(json.start, json.end, json.step);
+  };
+
+  return Range;
+}
+
+exports.name = 'Range';
+exports.path = 'type';
+exports.factory = factory;
+},{"../../utils/number":54}],42:[function(require,module,exports){
+'use strict';
+
+function factory(type, config, load, typed) {
+  /**
+   * Create a Matrix. The function creates a new `math.type.Matrix` object from
+   * an `Array`. A Matrix has utility functions to manipulate the data in the
+   * matrix, like getting the size and getting or setting values in the matrix.
+   * Supported storage formats are 'dense' and 'sparse'.
+   *
+   * Syntax:
+   *
+   *    math.matrix()                         // creates an empty matrix using default storage format (dense).
+   *    math.matrix(data)                     // creates a matrix with initial data using default storage format (dense).
+   *    math.matrix('dense')                  // creates an empty matrix using the given storage format.
+   *    math.matrix(data, 'dense')            // creates a matrix with initial data using the given storage format.
+   *    math.matrix(data, 'sparse')           // creates a sparse matrix with initial data.
+   *    math.matrix(data, 'sparse', 'number') // creates a sparse matrix with initial data, number data type.
+   *
+   * Examples:
+   *
+   *    let m = math.matrix([[1, 2], [3, 4]])
+   *    m.size()                        // Array [2, 2]
+   *    m.resize([3, 2], 5)
+   *    m.valueOf()                     // Array [[1, 2], [3, 4], [5, 5]]
+   *    m.get([1, 0])                    // number 3
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, index, number, string, unit, sparse
+   *
+   * @param {Array | Matrix} [data]    A multi dimensional array
+   * @param {string} [format]          The Matrix storage format
+   *
+   * @return {Matrix} The created matrix
+   */
+  var matrix = typed('matrix', {
+    '': function _() {
+      return _create([]);
+    },
+    'string': function string(format) {
+      return _create([], format);
+    },
+    'string, string': function stringString(format, datatype) {
+      return _create([], format, datatype);
+    },
+    'Array': function Array(data) {
+      return _create(data);
+    },
+    'Matrix': function Matrix(data) {
+      return _create(data, data.storage());
+    },
+    'Array | Matrix, string': _create,
+    'Array | Matrix, string, string': _create
+  });
+  matrix.toTex = {
+    0: '\\begin{bmatrix}\\end{bmatrix}',
+    1: "\\left(${args[0]}\\right)",
+    2: "\\left(${args[0]}\\right)"
+  };
+  return matrix;
+  /**
+   * Create a new Matrix with given storage format
+   * @param {Array} data
+   * @param {string} [format]
+   * @param {string} [datatype]
+   * @returns {Matrix} Returns a new Matrix
+   * @private
+   */
+
+  function _create(data, format, datatype) {
+    // get storage format constructor
+    var M = type.Matrix.storage(format || 'default'); // create instance
+
+    return new M(data, datatype);
+  }
+}
+
+exports.name = 'matrix';
+exports.factory = factory;
+},{}],43:[function(require,module,exports){
+'use strict';
+
+var deepMap = require('./../utils/collection/deepMap');
+
+function factory(type, config, load, typed) {
+  /**
+   * Create a number or convert a string, boolean, or unit to a number.
+   * When value is a matrix, all elements will be converted to number.
+   *
+   * Syntax:
+   *
+   *    math.number(value)
+   *    math.number(unit, valuelessUnit)
+   *
+   * Examples:
+   *
+   *    math.number(2)                         // returns number 2
+   *    math.number('7.2')                     // returns number 7.2
+   *    math.number(true)                      // returns number 1
+   *    math.number([true, false, true, true]) // returns [1, 0, 1, 1]
+   *    math.number(math.unit('52cm'), 'm')    // returns 0.52
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, index, matrix, string, unit
+   *
+   * @param {string | number | BigNumber | Fraction | boolean | Array | Matrix | Unit | null} [value]  Value to be converted
+   * @param {Unit | string} [valuelessUnit] A valueless unit, used to convert a unit to a number
+   * @return {number | Array | Matrix} The created number
+   */
+  var number = typed('number', {
+    '': function _() {
+      return 0;
+    },
+    'number': function number(x) {
+      return x;
+    },
+    'string': function string(x) {
+      if (x === 'NaN') return NaN;
+      var num = Number(x);
+
+      if (isNaN(num)) {
+        throw new SyntaxError('String "' + x + '" is no valid number');
+      }
+
+      return num;
+    },
+    'BigNumber': function BigNumber(x) {
+      return x.toNumber();
+    },
+    'Fraction': function Fraction(x) {
+      return x.valueOf();
+    },
+    'Unit': function Unit(x) {
+      throw new Error('Second argument with valueless unit expected');
+    },
+    'null': function _null(x) {
+      return 0;
+    },
+    'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
+      return unit.toNumber(valuelessUnit);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return deepMap(x, number);
+    }
+  });
+  number.toTex = {
+    0: "0",
+    1: "\\left(${args[0]}\\right)",
+    2: "\\left(\\left(${args[0]}\\right)${args[1]}\\right)"
+  };
+  return number;
+}
+
+exports.name = 'number';
+exports.factory = factory;
+},{"./../utils/collection/deepMap":49}],44:[function(require,module,exports){
+'use strict';
+
+function factory(type, config, load, typed) {
+  var getTypeOf = load(require('../function/utils/typeof'));
+  var validInputTypes = {
+    'string': true,
+    'number': true,
+    'BigNumber': true,
+    'Fraction': true // Load the conversion functions for each output type
+
+  };
+  var validOutputTypes = {
+    'number': load(require('./number')),
+    'BigNumber': load(require('./bignumber/function/bignumber')),
+    'Fraction': load(require('./fraction/function/fraction'))
+    /**
+     * Convert a numeric value to a specific type: number, BigNumber, or Fraction
+     *
+     * @param {string | number | BigNumber | Fraction } value
+     * @param {'number' | 'BigNumber' | 'Fraction'} outputType
+     * @return {number | BigNumber | Fraction} Returns an instance of the
+     *                                         numeric in the requested type
+     */
+
+  };
+
+  var numeric = function numeric(value, outputType) {
+    var inputType = getTypeOf(value);
+
+    if (!(inputType in validInputTypes)) {
+      throw new TypeError('Cannot convert ' + value + ' of type "' + inputType + '"; valid input types are ' + Object.keys(validInputTypes).join(', '));
+    }
+
+    if (!(outputType in validOutputTypes)) {
+      throw new TypeError('Cannot convert ' + value + ' to type "' + outputType + '"; valid output types are ' + Object.keys(validOutputTypes).join(', '));
+    }
+
+    if (outputType === inputType) {
+      return value;
+    } else {
+      return validOutputTypes[outputType](value);
+    }
+  };
+
+  numeric.toTex = function (node, options) {
+    // Not sure if this is strictly right but should work correctly for the vast majority of use cases.
+    return node.args[0].toTex();
+  };
+
+  return numeric;
+} // FIXME: expose numeric in the math namespace after we've decided on a name and have written proper docs for this function. See https://github.com/josdejong/mathjs/pull/1270
+// exports.name = 'type._numeric'
+
+
+exports.path = 'type';
+exports.name = '_numeric';
+exports.factory = factory;
+},{"../function/utils/typeof":38,"./bignumber/function/bignumber":39,"./fraction/function/fraction":40,"./number":43}],45:[function(require,module,exports){
+'use strict';
+
+function factory(type, config, load, typed) {
+  /**
+   * A ResultSet contains a list or results
+   * @class ResultSet
+   * @param {Array} entries
+   * @constructor ResultSet
+   */
+  function ResultSet(entries) {
+    if (!(this instanceof ResultSet)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    this.entries = entries || [];
+  }
+  /**
+   * Attach type information
+   */
+
+
+  ResultSet.prototype.type = 'ResultSet';
+  ResultSet.prototype.isResultSet = true;
+  /**
+   * Returns the array with results hold by this ResultSet
+   * @memberof ResultSet
+   * @returns {Array} entries
+   */
+
+  ResultSet.prototype.valueOf = function () {
+    return this.entries;
+  };
+  /**
+   * Returns the stringified results of the ResultSet
+   * @memberof ResultSet
+   * @returns {string} string
+   */
+
+
+  ResultSet.prototype.toString = function () {
+    return '[' + this.entries.join(', ') + ']';
+  };
+  /**
+   * Get a JSON representation of the ResultSet
+   * @memberof ResultSet
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "ResultSet", "entries": [...]}`
+   */
+
+
+  ResultSet.prototype.toJSON = function () {
+    return {
+      mathjs: 'ResultSet',
+      entries: this.entries
+    };
+  };
+  /**
+   * Instantiate a ResultSet from a JSON object
+   * @memberof ResultSet
+   * @param {Object} json  A JSON object structured as:
+   *                       `{"mathjs": "ResultSet", "entries": [...]}`
+   * @return {ResultSet}
+   */
+
+
+  ResultSet.fromJSON = function (json) {
+    return new ResultSet(json.entries);
+  };
+
+  return ResultSet;
+}
+
+exports.name = 'ResultSet';
+exports.path = 'type';
+exports.factory = factory;
+},{}],46:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.size = size;
+exports.validate = validate;
+exports.validateIndex = validateIndex;
+exports.resize = resize;
+exports.reshape = reshape;
+exports.squeeze = squeeze;
+exports.unsqueeze = unsqueeze;
+exports.flatten = flatten;
+exports.map = map;
+exports.forEach = forEach;
+exports.filter = filter;
+exports.filterRegExp = filterRegExp;
+exports.join = join;
+exports.identify = identify;
+exports.generalize = generalize;
+
+var _number = _interopRequireDefault(require("./number"));
+
+var _string = _interopRequireDefault(require("./string"));
+
+var _DimensionError = _interopRequireDefault(require("../error/DimensionError"));
+
+var _IndexError = _interopRequireDefault(require("../error/IndexError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Calculate the size of a multi dimensional array.
+ * This function checks the size of the first entry, it does not validate
+ * whether all dimensions match. (use function `validate` for that)
+ * @param {Array} x
+ * @Return {Number[]} size
+ */
+function size(x) {
+  var s = [];
+
+  while (Array.isArray(x)) {
+    s.push(x.length);
+    x = x[0];
+  }
+
+  return s;
+}
+/**
+ * Recursively validate whether each element in a multi dimensional array
+ * has a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @param {number} dim   Current dimension
+ * @throws DimensionError
+ * @private
+ */
+
+
+function _validate(array, size, dim) {
+  var i;
+  var len = array.length;
+
+  if (len !== size[dim]) {
+    throw new _DimensionError.default(len, size[dim]);
+  }
+
+  if (dim < size.length - 1) {
+    // recursively validate each child array
+    var dimNext = dim + 1;
+
+    for (i = 0; i < len; i++) {
+      var child = array[i];
+
+      if (!Array.isArray(child)) {
+        throw new _DimensionError.default(size.length - 1, size.length, '<');
+      }
+
+      _validate(array[i], size, dimNext);
+    }
+  } else {
+    // last dimension. none of the childs may be an array
+    for (i = 0; i < len; i++) {
+      if (Array.isArray(array[i])) {
+        throw new _DimensionError.default(size.length + 1, size.length, '>');
+      }
+    }
+  }
+}
+/**
+ * Validate whether each element in a multi dimensional array has
+ * a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @throws DimensionError
+ */
+
+
+function validate(array, size) {
+  var isScalar = size.length === 0;
+
+  if (isScalar) {
+    // scalar
+    if (Array.isArray(array)) {
+      throw new _DimensionError.default(array.length, 0);
+    }
+  } else {
+    // array
+    _validate(array, size, 0);
+  }
+}
+/**
+ * Test whether index is an integer number with index >= 0 and index < length
+ * when length is provided
+ * @param {number} index    Zero-based index
+ * @param {number} [length] Length of the array
+ */
+
+
+function validateIndex(index, length) {
+  if (!_number.default.isNumber(index) || !_number.default.isInteger(index)) {
+    throw new TypeError('Index must be an integer (value: ' + index + ')');
+  }
+
+  if (index < 0 || typeof length === 'number' && index >= length) {
+    throw new _IndexError.default(index, length);
+  }
+}
+/**
+ * Resize a multi dimensional array. The resized array is returned.
+ * @param {Array} array         Array to be resized
+ * @param {Array.<number>} size Array with the size of each dimension
+ * @param {*} [defaultValue=0]  Value to be filled in in new entries,
+ *                              zero by default. Specify for example `null`,
+ *                              to clearly see entries that are not explicitly
+ *                              set.
+ * @return {Array} array         The resized array
+ */
+
+
+function resize(array, size, defaultValue) {
+  // TODO: add support for scalars, having size=[] ?
+  // check the type of the arguments
+  if (!Array.isArray(array) || !Array.isArray(size)) {
+    throw new TypeError('Array expected');
+  }
+
+  if (size.length === 0) {
+    throw new Error('Resizing to scalar is not supported');
+  } // check whether size contains positive integers
+
+
+  size.forEach(function (value) {
+    if (!_number.default.isNumber(value) || !_number.default.isInteger(value) || value < 0) {
+      throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + _string.default.format(size) + ')');
+    }
+  }); // recursively resize the array
+
+  var _defaultValue = defaultValue !== undefined ? defaultValue : 0;
+
+  _resize(array, size, 0, _defaultValue);
+
+  return array;
+}
+/**
+ * Recursively resize a multi dimensional array
+ * @param {Array} array         Array to be resized
+ * @param {number[]} size       Array with the size of each dimension
+ * @param {number} dim          Current dimension
+ * @param {*} [defaultValue]    Value to be filled in in new entries,
+ *                              undefined by default.
+ * @private
+ */
+
+
+function _resize(array, size, dim, defaultValue) {
+  var i;
+  var elem;
+  var oldLen = array.length;
+  var newLen = size[dim];
+  var minLen = Math.min(oldLen, newLen); // apply new length
+
+  array.length = newLen;
+
+  if (dim < size.length - 1) {
+    // non-last dimension
+    var dimNext = dim + 1; // resize existing child arrays
+
+    for (i = 0; i < minLen; i++) {
+      // resize child array
+      elem = array[i];
+
+      if (!Array.isArray(elem)) {
+        elem = [elem]; // add a dimension
+
+        array[i] = elem;
+      }
+
+      _resize(elem, size, dimNext, defaultValue);
+    } // create new child arrays
+
+
+    for (i = minLen; i < newLen; i++) {
+      // get child array
+      elem = [];
+      array[i] = elem; // resize new child array
+
+      _resize(elem, size, dimNext, defaultValue);
+    }
+  } else {
+    // last dimension
+    // remove dimensions of existing values
+    for (i = 0; i < minLen; i++) {
+      while (Array.isArray(array[i])) {
+        array[i] = array[i][0];
+      }
+    } // fill new elements with the default value
+
+
+    for (i = minLen; i < newLen; i++) {
+      array[i] = defaultValue;
+    }
+  }
+}
+/**
+ * Re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ *
+ * @throws {DimensionError}       If the product of the new dimension sizes does
+ *                                not equal that of the old ones
+ */
+
+
+function reshape(array, sizes) {
+  var flatArray = flatten(array);
+  var newArray;
+
+  function product(arr) {
+    return arr.reduce(function (prev, curr) {
+      return prev * curr;
+    });
+  }
+
+  if (!Array.isArray(array) || !Array.isArray(sizes)) {
+    throw new TypeError('Array expected');
+  }
+
+  if (sizes.length === 0) {
+    throw new _DimensionError.default(0, product(size(array)), '!=');
+  }
+
+  var totalSize = 1;
+
+  for (var sizeIndex = 0; sizeIndex < sizes.length; sizeIndex++) {
+    totalSize *= sizes[sizeIndex];
+  }
+
+  if (flatArray.length !== totalSize) {
+    throw new _DimensionError.default(product(sizes), product(size(array)), '!=');
+  }
+
+  try {
+    newArray = _reshape(flatArray, sizes);
+  } catch (e) {
+    if (e instanceof _DimensionError.default) {
+      throw new _DimensionError.default(product(sizes), product(size(array)), '!=');
+    }
+
+    throw e;
+  }
+
+  return newArray;
+}
+/**
+ * Iteratively re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ */
+
+
+function _reshape(array, sizes) {
+  // testing if there are enough elements for the requested shape
+  var tmpArray = array;
+  var tmpArray2; // for each dimensions starting by the last one and ignoring the first one
+
+  for (var sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
+    var size = sizes[sizeIndex];
+    tmpArray2 = []; // aggregate the elements of the current tmpArray in elements of the requested size
+
+    var length = tmpArray.length / size;
+
+    for (var i = 0; i < length; i++) {
+      tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size));
+    } // set it as the new tmpArray for the next loop turn or for return
+
+
+    tmpArray = tmpArray2;
+  }
+
+  return tmpArray;
+}
+/**
+ * Squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {Array} [arraySize]
+ * @returns {Array} returns the array itself
+ */
+
+
+function squeeze(array, arraySize) {
+  var s = arraySize || size(array); // squeeze outer dimensions
+
+  while (Array.isArray(array) && array.length === 1) {
+    array = array[0];
+    s.shift();
+  } // find the first dimension to be squeezed
+
+
+  var dims = s.length;
+
+  while (s[dims - 1] === 1) {
+    dims--;
+  } // squeeze inner dimensions
+
+
+  if (dims < s.length) {
+    array = _squeeze(array, dims, 0);
+    s.length = dims;
+  }
+
+  return array;
+}
+/**
+ * Recursively squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {number} dims Required number of dimensions
+ * @param {number} dim  Current dimension
+ * @returns {Array | *} Returns the squeezed array
+ * @private
+ */
+
+
+function _squeeze(array, dims, dim) {
+  var i, ii;
+
+  if (dim < dims) {
+    var next = dim + 1;
+
+    for (i = 0, ii = array.length; i < ii; i++) {
+      array[i] = _squeeze(array[i], dims, next);
+    }
+  } else {
+    while (Array.isArray(array)) {
+      array = array[0];
+    }
+  }
+
+  return array;
+}
+/**
+ * Unsqueeze a multi dimensional array: add dimensions when missing
+ *
+ * Paramter `size` will be mutated to match the new, unqueezed matrix size.
+ *
+ * @param {Array} array
+ * @param {number} dims       Desired number of dimensions of the array
+ * @param {number} [outer]    Number of outer dimensions to be added
+ * @param {Array} [arraySize] Current size of array.
+ * @returns {Array} returns the array itself
+ * @private
+ */
+
+
+function unsqueeze(array, dims, outer, arraySize) {
+  var s = arraySize || size(array); // unsqueeze outer dimensions
+
+  if (outer) {
+    for (var i = 0; i < outer; i++) {
+      array = [array];
+      s.unshift(1);
+    }
+  } // unsqueeze inner dimensions
+
+
+  array = _unsqueeze(array, dims, 0);
+
+  while (s.length < dims) {
+    s.push(1);
+  }
+
+  return array;
+}
+/**
+ * Recursively unsqueeze a multi dimensional array
+ * @param {Array} array
+ * @param {number} dims Required number of dimensions
+ * @param {number} dim  Current dimension
+ * @returns {Array | *} Returns the squeezed array
+ * @private
+ */
+
+
+function _unsqueeze(array, dims, dim) {
+  var i, ii;
+
+  if (Array.isArray(array)) {
+    var next = dim + 1;
+
+    for (i = 0, ii = array.length; i < ii; i++) {
+      array[i] = _unsqueeze(array[i], dims, next);
+    }
+  } else {
+    for (var d = dim; d < dims; d++) {
+      array = [array];
+    }
+  }
+
+  return array;
+}
+/**
+ * Flatten a multi dimensional array, put all elements in a one dimensional
+ * array
+ * @param {Array} array   A multi dimensional array
+ * @return {Array}        The flattened array (1 dimensional)
+ */
+
+
+function flatten(array) {
+  if (!Array.isArray(array)) {
+    // if not an array, return as is
+    return array;
+  }
+
+  var flat = [];
+  array.forEach(function callback(value) {
+    if (Array.isArray(value)) {
+      value.forEach(callback); // traverse through sub-arrays recursively
+    } else {
+      flat.push(value);
+    }
+  });
+  return flat;
+}
+/**
+ * A safe map
+ * @param {Array} array
+ * @param {function} callback
+ */
+
+
+function map(array, callback) {
+  return Array.prototype.map.call(array, callback);
+}
+/**
+ * A safe forEach
+ * @param {Array} array
+ * @param {function} callback
+ */
+
+
+function forEach(array, callback) {
+  Array.prototype.forEach.call(array, callback);
+}
+/**
+ * A safe filter
+ * @param {Array} array
+ * @param {function} callback
+ */
+
+
+function filter(array, callback) {
+  if (size(array).length !== 1) {
+    throw new Error('Only one dimensional matrices supported');
+  }
+
+  return Array.prototype.filter.call(array, callback);
+}
+/**
+ * Filter values in a callback given a regular expression
+ * @param {Array} array
+ * @param {RegExp} regexp
+ * @return {Array} Returns the filtered array
+ * @private
+ */
+
+
+function filterRegExp(array, regexp) {
+  if (size(array).length !== 1) {
+    throw new Error('Only one dimensional matrices supported');
+  }
+
+  return Array.prototype.filter.call(array, function (entry) {
+    return regexp.test(entry);
+  });
+}
+/**
+ * A safe join
+ * @param {Array} array
+ * @param {string} separator
+ */
+
+
+function join(array, separator) {
+  return Array.prototype.join.call(array, separator);
+}
+/**
+ * Assign a numeric identifier to every element of a sorted array
+ * @param {Array} a  An array
+ * @return {Array} An array of objects containing the original value and its identifier
+ */
+
+
+function identify(a) {
+  if (!Array.isArray(a)) {
+    throw new TypeError('Array input expected');
+  }
+
+  if (a.length === 0) {
+    return a;
+  }
+
+  var b = [];
+  var count = 0;
+  b[0] = {
+    value: a[0],
+    identifier: 0
+  };
+
+  for (var i = 1; i < a.length; i++) {
+    if (a[i] === a[i - 1]) {
+      count++;
+    } else {
+      count = 0;
+    }
+
+    b.push({
+      value: a[i],
+      identifier: count
+    });
+  }
+
+  return b;
+}
+/**
+ * Remove the numeric identifier from the elements
+ * @param {array} a  An array
+ * @return {array} An array of values without identifiers
+ */
+
+
+function generalize(a) {
+  if (!Array.isArray(a)) {
+    throw new TypeError('Array input expected');
+  }
+
+  if (a.length === 0) {
+    return a;
+  }
+
+  var b = [];
+
+  for (var i = 0; i < a.length; i++) {
+    b.push(a[i].value);
+  }
+
+  return b;
+}
+},{"../error/DimensionError":9,"../error/IndexError":10,"./number":54,"./string":57}],47:[function(require,module,exports){
+'use strict';
+
+var objectUtils = require('../object');
+/**
+ * Convert a BigNumber to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lower` and `upper` bounds, and uses
+ *                                          exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+ *    format(2.3,    {notation: 'fixed', precision: 4})  // returns '2.3000'
+ *    format(52.8,   {notation: 'exponential'})          // returns '5.28e+1'
+ *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
+ *
+ * @param {BigNumber} value
+ * @param {Object | Function | number} [options]
+ * @return {string} str The formatted value
+ */
+
+
+exports.format = function (value, options) {
+  if (typeof options === 'function') {
+    // handle format(value, fn)
+    return options(value);
+  } // handle special cases
+
+
+  if (!value.isFinite()) {
+    return value.isNaN() ? 'NaN' : value.gt(0) ? 'Infinity' : '-Infinity';
+  } // default values for options
+
+
+  var notation = 'auto';
+  var precision;
+
+  if (options !== undefined) {
+    // determine notation from options
+    if (options.notation) {
+      notation = options.notation;
+    } // determine precision from options
+
+
+    if (typeof options === 'number') {
+      precision = options;
+    } else if (options.precision) {
+      precision = options.precision;
+    }
+  } // handle the various notations
+
+
+  switch (notation) {
+    case 'fixed':
+      return exports.toFixed(value, precision);
+
+    case 'exponential':
+      return exports.toExponential(value, precision);
+
+    case 'auto':
+      // TODO: clean up some day. Deprecated since: 2018-01-24
+      // @deprecated upper and lower are replaced with upperExp and lowerExp since v4.0.0
+      if (options && options.exponential && (options.exponential.lower !== undefined || options.exponential.upper !== undefined)) {
+        var fixedOptions = objectUtils.map(options, function (x) {
+          return x;
+        });
+        fixedOptions.exponential = undefined;
+
+        if (options.exponential.lower !== undefined) {
+          fixedOptions.lowerExp = Math.round(Math.log(options.exponential.lower) / Math.LN10);
+        }
+
+        if (options.exponential.upper !== undefined) {
+          fixedOptions.upperExp = Math.round(Math.log(options.exponential.upper) / Math.LN10);
+        }
+
+        console.warn('Deprecation warning: Formatting options exponential.lower and exponential.upper ' + '(minimum and maximum value) ' + 'are replaced with exponential.lowerExp and exponential.upperExp ' + '(minimum and maximum exponent) since version 4.0.0. ' + 'Replace ' + JSON.stringify(options) + ' with ' + JSON.stringify(fixedOptions));
+        return exports.format(value, fixedOptions);
+      } // determine lower and upper bound for exponential notation.
+      // TODO: implement support for upper and lower to be BigNumbers themselves
+
+
+      var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3;
+      var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5; // handle special case zero
+
+      if (value.isZero()) return '0'; // determine whether or not to output exponential notation
+
+      var str;
+      var exp = value.logarithm();
+
+      if (exp.gte(lowerExp) && exp.lt(upperExp)) {
+        // normal number notation
+        str = value.toSignificantDigits(precision).toFixed();
+      } else {
+        // exponential notation
+        str = exports.toExponential(value, precision);
+      } // remove trailing zeros after the decimal point
+
+
+      return str.replace(/((\.\d*?)(0+))($|e)/, function () {
+        var digits = arguments[2];
+        var e = arguments[4];
+        return digits !== '.' ? digits + e : e;
+      });
+
+    default:
+      throw new Error('Unknown notation "' + notation + '". ' + 'Choose "auto", "exponential", or "fixed".');
+  }
+};
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]  Number of digits in formatted output.
+ *                              If not provided, the maximum available digits
+ *                              is used.
+ * @returns {string} str
+ */
+
+
+exports.toExponential = function (value, precision) {
+  if (precision !== undefined) {
+    return value.toExponential(precision - 1); // Note the offset of one
+  } else {
+    return value.toExponential();
+  }
+};
+/**
+ * Format a number with fixed notation.
+ * @param {BigNumber} value
+ * @param {number} [precision=undefined] Optional number of decimals after the
+ *                                       decimal point. Undefined by default.
+ */
+
+
+exports.toFixed = function (value, precision) {
+  return value.toFixed(precision);
+};
+},{"../object":55}],48:[function(require,module,exports){
+'use strict';
+/**
+ * Test whether a value is a BigNumber
+ * @param {*} x
+ * @return {boolean}
+ */
+
+module.exports = function isBigNumber(x) {
+  return x && x.constructor.prototype.isBigNumber || false;
+};
+},{}],49:[function(require,module,exports){
+'use strict';
+/**
+ * Execute the callback function element wise for each element in array and any
+ * nested array
+ * Returns an array with the results
+ * @param {Array | Matrix} array
+ * @param {Function} callback   The callback is called with two parameters:
+ *                              value1 and value2, which contain the current
+ *                              element of both arrays.
+ * @param {boolean} [skipZeros] Invoke callback function for non-zero values only.
+ *
+ * @return {Array | Matrix} res
+ */
+
+module.exports = function deepMap(array, callback, skipZeros) {
+  if (array && typeof array.map === 'function') {
+    // TODO: replace array.map with a for loop to improve performance
+    return array.map(function (x) {
+      return deepMap(x, callback, skipZeros);
+    });
+  } else {
+    return callback(array);
+  }
+};
+},{}],50:[function(require,module,exports){
+'use strict';
+/**
+ * Test whether a value is a Matrix
+ * @param {*} x
+ * @returns {boolean} returns true with input is a Matrix
+ *                    (like a DenseMatrix or SparseMatrix)
+ */
+
+module.exports = function isMatrix(x) {
+  return x && x.constructor.prototype.isMatrix || false;
+};
+},{}],51:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var hasOwnProperty = require('./object').hasOwnProperty;
+/**
+ * Get a property of a plain object
+ * Throws an error in case the object is not a plain object or the
+ * property is not defined on the object itself
+ * @param {Object} object
+ * @param {string} prop
+ * @return {*} Returns the property value when safe
+ */
+
+
+function getSafeProperty(object, prop) {
+  // only allow getting safe properties of a plain object
+  if (isPlainObject(object) && isSafeProperty(object, prop)) {
+    return object[prop];
+  }
+
+  if (typeof object[prop] === 'function' && isSafeMethod(object, prop)) {
+    throw new Error('Cannot access method "' + prop + '" as a property');
+  }
+
+  throw new Error('No access to property "' + prop + '"');
+}
+/**
+ * Set a property on a plain object.
+ * Throws an error in case the object is not a plain object or the
+ * property would override an inherited property like .constructor or .toString
+ * @param {Object} object
+ * @param {string} prop
+ * @param {*} value
+ * @return {*} Returns the value
+ */
+// TODO: merge this function into access.js?
+
+
+function setSafeProperty(object, prop, value) {
+  // only allow setting safe properties of a plain object
+  if (isPlainObject(object) && isSafeProperty(object, prop)) {
+    object[prop] = value;
+    return value;
+  }
+
+  throw new Error('No access to property "' + prop + '"');
+}
+/**
+ * Test whether a property is safe to use for an object.
+ * For example .toString and .constructor are not safe
+ * @param {string} prop
+ * @return {boolean} Returns true when safe
+ */
+
+
+function isSafeProperty(object, prop) {
+  if (!object || _typeof(object) !== 'object') {
+    return false;
+  } // SAFE: whitelisted
+  // e.g length
+
+
+  if (hasOwnProperty(safeNativeProperties, prop)) {
+    return true;
+  } // UNSAFE: inherited from Object prototype
+  // e.g constructor
+
+
+  if (prop in Object.prototype) {
+    // 'in' is used instead of hasOwnProperty for nodejs v0.10
+    // which is inconsistent on root prototypes. It is safe
+    // here because Object.prototype is a root object
+    return false;
+  } // UNSAFE: inherited from Function prototype
+  // e.g call, apply
+
+
+  if (prop in Function.prototype) {
+    // 'in' is used instead of hasOwnProperty for nodejs v0.10
+    // which is inconsistent on root prototypes. It is safe
+    // here because Function.prototype is a root object
+    return false;
+  }
+
+  return true;
+}
+/**
+ * Validate whether a method is safe.
+ * Throws an error when that's not the case.
+ * @param {Object} object
+ * @param {string} method
+ */
+// TODO: merge this function into assign.js?
+
+
+function validateSafeMethod(object, method) {
+  if (!isSafeMethod(object, method)) {
+    throw new Error('No access to method "' + method + '"');
+  }
+}
+/**
+ * Check whether a method is safe.
+ * Throws an error when that's not the case (for example for `constructor`).
+ * @param {Object} object
+ * @param {string} method
+ * @return {boolean} Returns true when safe, false otherwise
+ */
+
+
+function isSafeMethod(object, method) {
+  if (!object || typeof object[method] !== 'function') {
+    return false;
+  } // UNSAFE: ghosted
+  // e.g overridden toString
+  // Note that IE10 doesn't support __proto__ and we can't do this check there.
+
+
+  if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
+    return false;
+  } // SAFE: whitelisted
+  // e.g toString
+
+
+  if (hasOwnProperty(safeNativeMethods, method)) {
+    return true;
+  } // UNSAFE: inherited from Object prototype
+  // e.g constructor
+
+
+  if (method in Object.prototype) {
+    // 'in' is used instead of hasOwnProperty for nodejs v0.10
+    // which is inconsistent on root prototypes. It is safe
+    // here because Object.prototype is a root object
+    return false;
+  } // UNSAFE: inherited from Function prototype
+  // e.g call, apply
+
+
+  if (method in Function.prototype) {
+    // 'in' is used instead of hasOwnProperty for nodejs v0.10
+    // which is inconsistent on root prototypes. It is safe
+    // here because Function.prototype is a root object
+    return false;
+  }
+
+  return true;
+}
+
+function isPlainObject(object) {
+  return _typeof(object) === 'object' && object && object.constructor === Object;
+}
+
+var safeNativeProperties = {
+  length: true,
+  name: true
+};
+var safeNativeMethods = {
+  toString: true,
+  valueOf: true,
+  toLocaleString: true
+};
+exports.getSafeProperty = getSafeProperty;
+exports.setSafeProperty = setSafeProperty;
+exports.isSafeProperty = isSafeProperty;
+exports.validateSafeMethod = validateSafeMethod;
+exports.isSafeMethod = isSafeMethod;
+exports.isPlainObject = isPlainObject;
+},{"./object":55}],52:[function(require,module,exports){
+'use strict';
+
+var Emitter = require('tiny-emitter');
+/**
+ * Extend given object with emitter functions `on`, `off`, `once`, `emit`
+ * @param {Object} obj
+ * @return {Object} obj
+ */
+
+
+exports.mixin = function (obj) {
+  // create event emitter
+  var emitter = new Emitter(); // bind methods to obj (we don't want to expose the emitter.e Array...)
+
+  obj.on = emitter.on.bind(emitter);
+  obj.off = emitter.off.bind(emitter);
+  obj.once = emitter.once.bind(emitter);
+  obj.emit = emitter.emit.bind(emitter);
+  return obj;
+};
+},{"tiny-emitter":58}],53:[function(require,module,exports){
+'use strict';
+
+var escapeLatex = require('escape-latex');
+
+exports.symbols = {
+  // GREEK LETTERS
+  Alpha: 'A',
+  alpha: '\\alpha',
+  Beta: 'B',
+  beta: '\\beta',
+  Gamma: '\\Gamma',
+  gamma: '\\gamma',
+  Delta: '\\Delta',
+  delta: '\\delta',
+  Epsilon: 'E',
+  epsilon: '\\epsilon',
+  varepsilon: '\\varepsilon',
+  Zeta: 'Z',
+  zeta: '\\zeta',
+  Eta: 'H',
+  eta: '\\eta',
+  Theta: '\\Theta',
+  theta: '\\theta',
+  vartheta: '\\vartheta',
+  Iota: 'I',
+  iota: '\\iota',
+  Kappa: 'K',
+  kappa: '\\kappa',
+  varkappa: '\\varkappa',
+  Lambda: '\\Lambda',
+  lambda: '\\lambda',
+  Mu: 'M',
+  mu: '\\mu',
+  Nu: 'N',
+  nu: '\\nu',
+  Xi: '\\Xi',
+  xi: '\\xi',
+  Omicron: 'O',
+  omicron: 'o',
+  Pi: '\\Pi',
+  pi: '\\pi',
+  varpi: '\\varpi',
+  Rho: 'P',
+  rho: '\\rho',
+  varrho: '\\varrho',
+  Sigma: '\\Sigma',
+  sigma: '\\sigma',
+  varsigma: '\\varsigma',
+  Tau: 'T',
+  tau: '\\tau',
+  Upsilon: "\\Upsilon",
+  upsilon: "\\upsilon",
+  Phi: '\\Phi',
+  phi: '\\phi',
+  varphi: '\\varphi',
+  Chi: 'X',
+  chi: '\\chi',
+  Psi: '\\Psi',
+  psi: '\\psi',
+  Omega: '\\Omega',
+  omega: '\\omega',
+  // logic
+  'true': '\\mathrm{True}',
+  'false': '\\mathrm{False}',
+  // other
+  i: 'i',
+  // TODO use \i ??
+  inf: '\\infty',
+  Inf: '\\infty',
+  infinity: '\\infty',
+  Infinity: '\\infty',
+  oo: '\\infty',
+  lim: '\\lim',
+  'undefined': '\\mathbf{?}'
+};
+exports.operators = {
+  'transpose': '^\\top',
+  'ctranspose': '^H',
+  'factorial': '!',
+  'pow': '^',
+  'dotPow': '.^\\wedge',
+  // TODO find ideal solution
+  'unaryPlus': '+',
+  'unaryMinus': '-',
+  'bitNot': '\\~',
+  // TODO find ideal solution
+  'not': '\\neg',
+  'multiply': '\\cdot',
+  'divide': '\\frac',
+  // TODO how to handle that properly?
+  'dotMultiply': '.\\cdot',
+  // TODO find ideal solution
+  'dotDivide': '.:',
+  // TODO find ideal solution
+  'mod': '\\mod',
+  'add': '+',
+  'subtract': '-',
+  'to': '\\rightarrow',
+  'leftShift': '<<',
+  'rightArithShift': '>>',
+  'rightLogShift': '>>>',
+  'equal': '=',
+  'unequal': '\\neq',
+  'smaller': '<',
+  'larger': '>',
+  'smallerEq': '\\leq',
+  'largerEq': '\\geq',
+  'bitAnd': '\\&',
+  'bitXor': "\\underline{|}",
+  'bitOr': '|',
+  'and': '\\wedge',
+  'xor': '\\veebar',
+  'or': '\\vee'
+};
+exports.defaultTemplate = "\\mathrm{${name}}\\left(${args}\\right)";
+var units = {
+  deg: '^\\circ'
+};
+
+exports.escape = function (string) {
+  return escapeLatex(string, {
+    'preserveFormatting': true
+  });
+}; // @param {string} name
+// @param {boolean} isUnit
+
+
+exports.toSymbol = function (name, isUnit) {
+  isUnit = typeof isUnit === 'undefined' ? false : isUnit;
+
+  if (isUnit) {
+    if (units.hasOwnProperty(name)) {
+      return units[name];
+    }
+
+    return '\\mathrm{' + exports.escape(name) + '}';
+  }
+
+  if (exports.symbols.hasOwnProperty(name)) {
+    return exports.symbols[name];
+  }
+
+  return exports.escape(name);
+};
+},{"escape-latex":2}],54:[function(require,module,exports){
+'use strict';
+
+var objectUtils = require('./object');
+/**
+ * @typedef {{sign: '+' | '-' | '', coefficients: number[], exponent: number}} SplitValue
+ */
+
+/**
+ * Test whether value is a number
+ * @param {*} value
+ * @return {boolean} isNumber
+ */
+
+
+exports.isNumber = function (value) {
+  return typeof value === 'number';
+};
+/**
+ * Check if a number is integer
+ * @param {number | boolean} value
+ * @return {boolean} isInteger
+ */
+
+
+exports.isInteger = function (value) {
+  if (typeof value === 'boolean') {
+    return true;
+  }
+
+  return isFinite(value) ? value === Math.round(value) : false; // Note: we use ==, not ===, as we can have Booleans as well
+};
+/**
+ * Calculate the sign of a number
+ * @param {number} x
+ * @returns {*}
+ */
+
+
+exports.sign = Math.sign || function (x) {
+  if (x > 0) {
+    return 1;
+  } else if (x < 0) {
+    return -1;
+  } else {
+    return 0;
+  }
+};
+/**
+ * Convert a number to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'engineering'    Always use engineering notation.
+ *                                          For example '123.4e+0' and '14.0e+6'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lowerExp` and `upperExp` bounds, and
+ *                                          uses exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default,
+ *                                          not rounding any digits.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12.071, {notation: 'fixed'})                // '12'
+ *    format(2.3,    {notation: 'fixed', precision: 2})  // '2.30'
+ *    format(52.8,   {notation: 'exponential'})          // '5.28e+1'
+ *    format(12345678, {notation: 'engineering'})        // '12.345678e+6'
+ *
+ * @param {number} value
+ * @param {Object | Function | number} [options]
+ * @return {string} str The formatted value
+ */
+
+
+exports.format = function (value, options) {
+  if (typeof options === 'function') {
+    // handle format(value, fn)
+    return options(value);
+  } // handle special cases
+
+
+  if (value === Infinity) {
+    return 'Infinity';
+  } else if (value === -Infinity) {
+    return '-Infinity';
+  } else if (isNaN(value)) {
+    return 'NaN';
+  } // default values for options
+
+
+  var notation = 'auto';
+  var precision;
+
+  if (options) {
+    // determine notation from options
+    if (options.notation) {
+      notation = options.notation;
+    } // determine precision from options
+
+
+    if (exports.isNumber(options)) {
+      precision = options;
+    } else if (options.precision) {
+      precision = options.precision;
+    }
+  } // handle the various notations
+
+
+  switch (notation) {
+    case 'fixed':
+      return exports.toFixed(value, precision);
+
+    case 'exponential':
+      return exports.toExponential(value, precision);
+
+    case 'engineering':
+      return exports.toEngineering(value, precision);
+
+    case 'auto':
+      // TODO: clean up some day. Deprecated since: 2018-01-24
+      // @deprecated upper and lower are replaced with upperExp and lowerExp since v4.0.0
+      if (options && options.exponential && (options.exponential.lower !== undefined || options.exponential.upper !== undefined)) {
+        var fixedOptions = objectUtils.map(options, function (x) {
+          return x;
+        });
+        fixedOptions.exponential = undefined;
+
+        if (options.exponential.lower !== undefined) {
+          fixedOptions.lowerExp = Math.round(Math.log(options.exponential.lower) / Math.LN10);
+        }
+
+        if (options.exponential.upper !== undefined) {
+          fixedOptions.upperExp = Math.round(Math.log(options.exponential.upper) / Math.LN10);
+        }
+
+        console.warn('Deprecation warning: Formatting options exponential.lower and exponential.upper ' + '(minimum and maximum value) ' + 'are replaced with exponential.lowerExp and exponential.upperExp ' + '(minimum and maximum exponent) since version 4.0.0. ' + 'Replace ' + JSON.stringify(options) + ' with ' + JSON.stringify(fixedOptions));
+        return exports.toPrecision(value, precision, fixedOptions);
+      }
+
+      return exports.toPrecision(value, precision, options && options) // remove trailing zeros after the decimal point
+      .replace(/((\.\d*?)(0+))($|e)/, function () {
+        var digits = arguments[2];
+        var e = arguments[4];
+        return digits !== '.' ? digits + e : e;
+      });
+
+    default:
+      throw new Error('Unknown notation "' + notation + '". ' + 'Choose "auto", "exponential", or "fixed".');
+  }
+};
+/**
+ * Split a number into sign, coefficients, and exponent
+ * @param {number | string} value
+ * @return {SplitValue}
+ *              Returns an object containing sign, coefficients, and exponent
+ */
+
+
+exports.splitNumber = function (value) {
+  // parse the input value
+  var match = String(value).toLowerCase().match(/^0*?(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
+
+  if (!match) {
+    throw new SyntaxError('Invalid number ' + value);
+  }
+
+  var sign = match[1];
+  var digits = match[2];
+  var exponent = parseFloat(match[4] || '0');
+  var dot = digits.indexOf('.');
+  exponent += dot !== -1 ? dot - 1 : digits.length - 1;
+  var coefficients = digits.replace('.', '') // remove the dot (must be removed before removing leading zeros)
+  .replace(/^0*/, function (zeros) {
+    // remove leading zeros, add their count to the exponent
+    exponent -= zeros.length;
+    return '';
+  }).replace(/0*$/, '') // remove trailing zeros
+  .split('').map(function (d) {
+    return parseInt(d);
+  });
+
+  if (coefficients.length === 0) {
+    coefficients.push(0);
+    exponent++;
+  }
+
+  return {
+    sign: sign,
+    coefficients: coefficients,
+    exponent: exponent
+  };
+};
+/**
+ * Format a number in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param {number | string} value
+ * @param {number} [precision]        Optional number of significant figures to return.
+ */
+
+
+exports.toEngineering = function (value, precision) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
+  }
+
+  var rounded = exports.roundDigits(exports.splitNumber(value), precision);
+  var e = rounded.exponent;
+  var c = rounded.coefficients; // find nearest lower multiple of 3 for exponent
+
+  var newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
+
+  if (exports.isNumber(precision)) {
+    // add zeroes to give correct sig figs
+    if (precision > c.length) c = c.concat(zeros(precision - c.length));
+  } else {
+    // concatenate coefficients with necessary zeros
+    var significandsDiff = e >= 0 ? e : Math.abs(newExp); // add zeros if necessary (for ex: 1e+8)
+
+    if (c.length - 1 < significandsDiff) c = c.concat(zeros(significandsDiff - (c.length - 1)));
+  } // find difference in exponents
+
+
+  var expDiff = Math.abs(e - newExp);
+  var decimalIdx = 1; // push decimal index over by expDiff times
+
+  while (--expDiff >= 0) {
+    decimalIdx++;
+  } // if all coefficient values are zero after the decimal point and precision is unset, don't add a decimal value.
+  // otherwise concat with the rest of the coefficients
+
+
+  var decimals = c.slice(decimalIdx).join('');
+  var decimalVal = exports.isNumber(precision) && decimals.length || decimals.match(/[1-9]/) ? '.' + decimals : '';
+  var str = c.slice(0, decimalIdx).join('') + decimalVal + 'e' + (e >= 0 ? '+' : '') + newExp.toString();
+  return rounded.sign + str;
+};
+/**
+ * Format a number with fixed notation.
+ * @param {number | string} value
+ * @param {number} [precision=undefined]  Optional number of decimals after the
+ *                                        decimal point. null by default.
+ */
+
+
+exports.toFixed = function (value, precision) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
+  }
+
+  var splitValue = exports.splitNumber(value);
+  var rounded = typeof precision === 'number' ? exports.roundDigits(splitValue, splitValue.exponent + 1 + precision) : splitValue;
+  var c = rounded.coefficients;
+  var p = rounded.exponent + 1; // exponent may have changed
+  // append zeros if needed
+
+  var pp = p + (precision || 0);
+
+  if (c.length < pp) {
+    c = c.concat(zeros(pp - c.length));
+  } // prepend zeros if needed
+
+
+  if (p < 0) {
+    c = zeros(-p + 1).concat(c);
+    p = 1;
+  } // insert a dot if needed
+
+
+  if (p < c.length) {
+    c.splice(p, 0, p === 0 ? '0.' : '.');
+  }
+
+  return rounded.sign + c.join('');
+};
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {number | string} value
+ * @param {number} [precision]  Number of digits in formatted output.
+ *                              If not provided, the maximum available digits
+ *                              is used.
+ */
+
+
+exports.toExponential = function (value, precision) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
+  } // round if needed, else create a clone
+
+
+  var split = exports.splitNumber(value);
+  var rounded = precision ? exports.roundDigits(split, precision) : split;
+  var c = rounded.coefficients;
+  var e = rounded.exponent; // append zeros if needed
+
+  if (c.length < precision) {
+    c = c.concat(zeros(precision - c.length));
+  } // format as `C.CCCe+EEE` or `C.CCCe-EEE`
+
+
+  var first = c.shift();
+  return rounded.sign + first + (c.length > 0 ? '.' + c.join('') : '') + 'e' + (e >= 0 ? '+' : '') + e;
+};
+/**
+ * Format a number with a certain precision
+ * @param {number | string} value
+ * @param {number} [precision=undefined] Optional number of digits.
+ * @param {{lowerExp: number | undefined, upperExp: number | undefined}} [options]
+ *                                       By default:
+ *                                         lowerExp = -3 (incl)
+ *                                         upper = +5 (excl)
+ * @return {string}
+ */
+
+
+exports.toPrecision = function (value, precision, options) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
+  } // determine lower and upper bound for exponential notation.
+
+
+  var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3;
+  var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5;
+  var split = exports.splitNumber(value);
+
+  if (split.exponent < lowerExp || split.exponent >= upperExp) {
+    // exponential notation
+    return exports.toExponential(value, precision);
+  } else {
+    var rounded = precision ? exports.roundDigits(split, precision) : split;
+    var c = rounded.coefficients;
+    var e = rounded.exponent; // append trailing zeros
+
+    if (c.length < precision) {
+      c = c.concat(zeros(precision - c.length));
+    } // append trailing zeros
+    // TODO: simplify the next statement
+
+
+    c = c.concat(zeros(e - c.length + 1 + (c.length < precision ? precision - c.length : 0))); // prepend zeros
+
+    c = zeros(-e).concat(c);
+    var dot = e > 0 ? e : 0;
+
+    if (dot < c.length - 1) {
+      c.splice(dot + 1, 0, '.');
+    }
+
+    return rounded.sign + c.join('');
+  }
+};
+/**
+ * Round the number of digits of a number *
+ * @param {SplitValue} split       A value split with .splitNumber(value)
+ * @param {number} precision  A positive integer
+ * @return {SplitValue}
+ *              Returns an object containing sign, coefficients, and exponent
+ *              with rounded digits
+ */
+
+
+exports.roundDigits = function (split, precision) {
+  // create a clone
+  var rounded = {
+    sign: split.sign,
+    coefficients: split.coefficients,
+    exponent: split.exponent
+  };
+  var c = rounded.coefficients; // prepend zeros if needed
+
+  while (precision <= 0) {
+    c.unshift(0);
+    rounded.exponent++;
+    precision++;
+  }
+
+  if (c.length > precision) {
+    var removed = c.splice(precision, c.length - precision);
+
+    if (removed[0] >= 5) {
+      var i = precision - 1;
+      c[i]++;
+
+      while (c[i] === 10) {
+        c.pop();
+
+        if (i === 0) {
+          c.unshift(0);
+          rounded.exponent++;
+          i++;
+        }
+
+        i--;
+        c[i]++;
+      }
+    }
+  }
+
+  return rounded;
+};
+/**
+ * Create an array filled with zeros.
+ * @param {number} length
+ * @return {Array}
+ */
+
+
+function zeros(length) {
+  var arr = [];
+
+  for (var i = 0; i < length; i++) {
+    arr.push(0);
+  }
+
+  return arr;
+}
+/**
+ * Count the number of significant digits of a number.
+ *
+ * For example:
+ *   2.34 returns 3
+ *   0.0034 returns 2
+ *   120.5e+30 returns 4
+ *
+ * @param {number} value
+ * @return {number} digits   Number of significant digits
+ */
+
+
+exports.digits = function (value) {
+  return value.toExponential().replace(/e.*$/, '') // remove exponential notation
+  .replace(/^0\.?0*|\./, '') // remove decimal point and leading zeros
+  .length;
+};
+/**
+ * Minimum number added to one that makes the result different than one
+ */
+
+
+exports.DBL_EPSILON = Number.EPSILON || 2.2204460492503130808472633361816E-16;
+/**
+ * Compares two floating point numbers.
+ * @param {number} x          First value to compare
+ * @param {number} y          Second value to compare
+ * @param {number} [epsilon]  The maximum relative difference between x and y
+ *                            If epsilon is undefined or null, the function will
+ *                            test whether x and y are exactly equal.
+ * @return {boolean} whether the two numbers are nearly equal
+*/
+
+exports.nearlyEqual = function (x, y, epsilon) {
+  // if epsilon is null or undefined, test whether x and y are exactly equal
+  if (epsilon === null || epsilon === undefined) {
+    return x === y;
+  }
+
+  if (x === y) {
+    return true;
+  } // NaN
+
+
+  if (isNaN(x) || isNaN(y)) {
+    return false;
+  } // at this point x and y should be finite
+
+
+  if (isFinite(x) && isFinite(y)) {
+    // check numbers are very close, needed when comparing numbers near zero
+    var diff = Math.abs(x - y);
+
+    if (diff < exports.DBL_EPSILON) {
+      return true;
+    } else {
+      // use relative error
+      return diff <= Math.max(Math.abs(x), Math.abs(y)) * epsilon;
+    }
+  } // Infinite and Number or negative Infinite and positive Infinite cases
+
+
+  return false;
+};
+},{"./object":55}],55:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var isBigNumber = require('./bignumber/isBigNumber');
+/**
+ * Clone an object
+ *
+ *     clone(x)
+ *
+ * Can clone any primitive type, array, and object.
+ * If x has a function clone, this function will be invoked to clone the object.
+ *
+ * @param {*} x
+ * @return {*} clone
+ */
+
+
+exports.clone = function clone(x) {
+  var type = _typeof(x); // immutable primitive types
+
+
+  if (type === 'number' || type === 'string' || type === 'boolean' || x === null || x === undefined) {
+    return x;
+  } // use clone function of the object when available
+
+
+  if (typeof x.clone === 'function') {
+    return x.clone();
+  } // array
+
+
+  if (Array.isArray(x)) {
+    return x.map(function (value) {
+      return clone(value);
+    });
+  }
+
+  if (x instanceof Date) return new Date(x.valueOf());
+  if (isBigNumber(x)) return x; // bignumbers are immutable
+
+  if (x instanceof RegExp) throw new TypeError('Cannot clone ' + x); // TODO: clone a RegExp
+  // object
+
+  return exports.map(x, clone);
+};
+/**
+ * Apply map to all properties of an object
+ * @param {Object} object
+ * @param {function} callback
+ * @return {Object} Returns a copy of the object with mapped properties
+ */
+
+
+exports.map = function (object, callback) {
+  var clone = {};
+
+  for (var key in object) {
+    if (exports.hasOwnProperty(object, key)) {
+      clone[key] = callback(object[key]);
+    }
+  }
+
+  return clone;
+};
+/**
+ * Extend object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ */
+
+
+exports.extend = function (a, b) {
+  for (var prop in b) {
+    if (exports.hasOwnProperty(b, prop)) {
+      a[prop] = b[prop];
+    }
+  }
+
+  return a;
+};
+/**
+ * Deep extend an object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @returns {Object}
+ */
+
+
+exports.deepExtend = function deepExtend(a, b) {
+  // TODO: add support for Arrays to deepExtend
+  if (Array.isArray(b)) {
+    throw new TypeError('Arrays are not supported by deepExtend');
+  }
+
+  for (var prop in b) {
+    if (exports.hasOwnProperty(b, prop)) {
+      if (b[prop] && b[prop].constructor === Object) {
+        if (a[prop] === undefined) {
+          a[prop] = {};
+        }
+
+        if (a[prop].constructor === Object) {
+          deepExtend(a[prop], b[prop]);
+        } else {
+          a[prop] = b[prop];
+        }
+      } else if (Array.isArray(b[prop])) {
+        throw new TypeError('Arrays are not supported by deepExtend');
+      } else {
+        a[prop] = b[prop];
+      }
+    }
+  }
+
+  return a;
+};
+/**
+ * Deep test equality of all fields in two pairs of arrays or objects.
+ * @param {Array | Object} a
+ * @param {Array | Object} b
+ * @returns {boolean}
+ */
+
+
+exports.deepEqual = function deepEqual(a, b) {
+  var prop, i, len;
+
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
+    }
+
+    if (a.length !== b.length) {
+      return false;
+    }
+
+    for (i = 0, len = a.length; i < len; i++) {
+      if (!exports.deepEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  } else if (a instanceof Object) {
+    if (Array.isArray(b) || !(b instanceof Object)) {
+      return false;
+    }
+
+    for (prop in a) {
+      // noinspection JSUnfilteredForInLoop
+      if (!exports.deepEqual(a[prop], b[prop])) {
+        return false;
+      }
+    }
+
+    for (prop in b) {
+      // noinspection JSUnfilteredForInLoop
+      if (!exports.deepEqual(a[prop], b[prop])) {
+        return false;
+      }
+    }
+
+    return true;
+  } else {
+    return a === b;
+  }
+};
+/**
+ * Test whether the current JavaScript engine supports Object.defineProperty
+ * @returns {boolean} returns true if supported
+ */
+
+
+exports.canDefineProperty = function () {
+  // test needed for broken IE8 implementation
+  try {
+    if (Object.defineProperty) {
+      Object.defineProperty({}, 'x', {
+        get: function get() {}
+      });
+      return true;
+    }
+  } catch (e) {}
+
+  return false;
+};
+/**
+ * Attach a lazy loading property to a constant.
+ * The given function `fn` is called once when the property is first requested.
+ * On older browsers (<IE8), the function will fall back to direct evaluation
+ * of the properties value.
+ * @param {Object} object   Object where to add the property
+ * @param {string} prop     Property name
+ * @param {Function} fn     Function returning the property value. Called
+ *                          without arguments.
+ */
+
+
+exports.lazy = function (object, prop, fn) {
+  if (exports.canDefineProperty()) {
+    var _uninitialized = true;
+
+    var _value;
+
+    Object.defineProperty(object, prop, {
+      get: function get() {
+        if (_uninitialized) {
+          _value = fn();
+          _uninitialized = false;
+        }
+
+        return _value;
+      },
+      set: function set(value) {
+        _value = value;
+        _uninitialized = false;
+      },
+      configurable: true,
+      enumerable: true
+    });
+  } else {
+    // fall back to immediate evaluation
+    object[prop] = fn();
+  }
+};
+/**
+ * Traverse a path into an object.
+ * When a namespace is missing, it will be created
+ * @param {Object} object
+ * @param {string} path   A dot separated string like 'name.space'
+ * @return {Object} Returns the object at the end of the path
+ */
+
+
+exports.traverse = function (object, path) {
+  var obj = object;
+
+  if (path) {
+    var names = path.split('.');
+
+    for (var i = 0; i < names.length; i++) {
+      var name = names[i];
+
+      if (!(name in obj)) {
+        obj[name] = {};
+      }
+
+      obj = obj[name];
+    }
+  }
+
+  return obj;
+};
+/**
+ * A safe hasOwnProperty
+ * @param {Object} object
+ * @param {string} property
+ */
+
+
+exports.hasOwnProperty = function (object, property) {
+  return object && Object.hasOwnProperty.call(object, property);
+};
+/**
+ * Test whether an object is a factory. a factory has fields:
+ *
+ * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object])   (required)
+ * - name: string (optional)
+ * - path: string    A dot separated path (optional)
+ * - math: boolean   If true (false by default), the math namespace is passed
+ *                   as fifth argument of the factory function
+ *
+ * @param {*} object
+ * @returns {boolean}
+ */
+
+
+exports.isFactory = function (object) {
+  return object && typeof object.factory === 'function';
+};
+},{"./bignumber/isBigNumber":48}],56:[function(require,module,exports){
+"use strict";
+
+// TODO: remove these polyfills as soon as we have a build process that transpiles the code to ES5
+// Polyfill for IE 11 (Number.isFinite is used in `complex.js`)
+// source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite
+Number.isFinite = Number.isFinite || function (value) {
+  return typeof value === 'number' && isFinite(value);
+}; // Polyfill for IE 11
+// source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+
+
+Number.isNaN = Number.isNaN || function (value) {
+  return value !== value; // eslint-disable-line no-self-compare
+};
+},{}],57:[function(require,module,exports){
+'use strict';
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var formatNumber = require('./number').format;
+
+var formatBigNumber = require('./bignumber/formatter').format;
+
+var isBigNumber = require('./bignumber/isBigNumber');
+/**
+ * Test whether value is a string
+ * @param {*} value
+ * @return {boolean} isString
+ */
+
+
+exports.isString = function (value) {
+  return typeof value === 'string';
+};
+/**
+ * Check if a text ends with a certain string.
+ * @param {string} text
+ * @param {string} search
+ */
+
+
+exports.endsWith = function (text, search) {
+  var start = text.length - search.length;
+  var end = text.length;
+  return text.substring(start, end) === search;
+};
+/**
+ * Format a value of any type into a string.
+ *
+ * Usage:
+ *     math.format(value)
+ *     math.format(value, precision)
+ *
+ * When value is a function:
+ *
+ * - When the function has a property `syntax`, it returns this
+ *   syntax description.
+ * - In other cases, a string `'function'` is returned.
+ *
+ * When `value` is an Object:
+ *
+ * - When the object contains a property `format` being a function, this
+ *   function is invoked as `value.format(options)` and the result is returned.
+ * - When the object has its own `toString` method, this method is invoked
+ *   and the result is returned.
+ * - In other cases the function will loop over all object properties and
+ *   return JSON object notation like '{"a": 2, "b": 3}'.
+ *
+ * Example usage:
+ *     math.format(2/7)                // '0.2857142857142857'
+ *     math.format(math.pi, 3)         // '3.14'
+ *     math.format(new Complex(2, 3))  // '2 + 3i'
+ *     math.format('hello')            // '"hello"'
+ *
+ * @param {*} value             Value to be stringified
+ * @param {Object | number | Function} [options]  Formatting options. See
+ *                                                lib/utils/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @return {string} str
+ */
+
+
+exports.format = function (value, options) {
+  if (typeof value === 'number') {
+    return formatNumber(value, options);
+  }
+
+  if (isBigNumber(value)) {
+    return formatBigNumber(value, options);
+  } // note: we use unsafe duck-typing here to check for Fractions, this is
+  // ok here since we're only invoking toString or concatenating its values
+
+
+  if (looksLikeFraction(value)) {
+    if (!options || options.fraction !== 'decimal') {
+      // output as ratio, like '1/3'
+      return value.s * value.n + '/' + value.d;
+    } else {
+      // output as decimal, like '0.(3)'
+      return value.toString();
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return formatArray(value, options);
+  }
+
+  if (exports.isString(value)) {
+    return '"' + value + '"';
+  }
+
+  if (typeof value === 'function') {
+    return value.syntax ? String(value.syntax) : 'function';
+  }
+
+  if (value && _typeof(value) === 'object') {
+    if (typeof value.format === 'function') {
+      return value.format(options);
+    } else if (value && value.toString() !== {}.toString()) {
+      // this object has a non-native toString method, use that one
+      return value.toString();
+    } else {
+      var entries = [];
+
+      for (var key in value) {
+        if (value.hasOwnProperty(key)) {
+          entries.push('"' + key + '": ' + exports.format(value[key], options));
+        }
+      }
+
+      return '{' + entries.join(', ') + '}';
+    }
+  }
+
+  return String(value);
+};
+/**
+ * Stringify a value into a string enclosed in double quotes.
+ * Unescaped double quotes and backslashes inside the value are escaped.
+ * @param {*} value
+ * @return {string}
+ */
+
+
+exports.stringify = function (value) {
+  var text = String(value);
+  var escaped = '';
+  var i = 0;
+
+  while (i < text.length) {
+    var c = text.charAt(i);
+
+    if (c === '\\') {
+      escaped += c;
+      i++;
+      c = text.charAt(i);
+
+      if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) {
+        escaped += '\\'; // no valid escape character -> escape it
+      }
+
+      escaped += c;
+    } else if (c === '"') {
+      escaped += '\\"';
+    } else {
+      escaped += c;
+    }
+
+    i++;
+  }
+
+  return '"' + escaped + '"';
+};
+/**
+ * Escape special HTML characters
+ * @param {*} value
+ * @return {string}
+ */
+
+
+exports.escape = function (value) {
+  var text = String(value);
+  text = text.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return text;
+};
+/**
+ * Recursively format an n-dimensional matrix
+ * Example output: "[[1, 2], [3, 4]]"
+ * @param {Array} array
+ * @param {Object | number | Function} [options]  Formatting options. See
+ *                                                lib/utils/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @returns {string} str
+ */
+
+
+function formatArray(array, options) {
+  if (Array.isArray(array)) {
+    var str = '[';
+    var len = array.length;
+
+    for (var i = 0; i < len; i++) {
+      if (i !== 0) {
+        str += ', ';
+      }
+
+      str += formatArray(array[i], options);
+    }
+
+    str += ']';
+    return str;
+  } else {
+    return exports.format(array, options);
+  }
+}
+/**
+ * Check whether a value looks like a Fraction (unsafe duck-type check)
+ * @param {*} value
+ * @return {boolean}
+ */
+
+
+function looksLikeFraction(value) {
+  return value && _typeof(value) === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
+}
+},{"./bignumber/formatter":47,"./bignumber/isBigNumber":48,"./number":54}],58:[function(require,module,exports){
+function E () {
+  // Keep this empty so it's easier to inherit from
+  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+}
+
+E.prototype = {
+  on: function (name, callback, ctx) {
+    var e = this.e || (this.e = {});
+
+    (e[name] || (e[name] = [])).push({
+      fn: callback,
+      ctx: ctx
+    });
+
+    return this;
+  },
+
+  once: function (name, callback, ctx) {
+    var self = this;
+    function listener () {
+      self.off(name, listener);
+      callback.apply(ctx, arguments);
+    };
+
+    listener._ = callback
+    return this.on(name, listener, ctx);
+  },
+
+  emit: function (name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
+
+    return this;
+  },
+
+  off: function (name, callback) {
+    var e = this.e || (this.e = {});
+    var evts = e[name];
+    var liveEvents = [];
+
+    if (evts && callback) {
+      for (var i = 0, len = evts.length; i < len; i++) {
+        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+          liveEvents.push(evts[i]);
+      }
+    }
+
+    // Remove event from queue to prevent memory leak
+    // Suggested by https://github.com/lazd
+    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+
+    (liveEvents.length)
+      ? e[name] = liveEvents
+      : delete e[name];
+
+    return this;
+  }
+};
+
+module.exports = E;
+
+},{}],59:[function(require,module,exports){
+/**
+ * typed-function
+ *
+ * Type checking for JavaScript functions
+ *
+ * https://github.com/josdejong/typed-function
+ */
+'use strict';
+
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define([], factory);
+  } else if (typeof exports === 'object') {
+    // OldNode. Does not work with strict CommonJS, but
+    // only CommonJS-like environments that support module.exports,
+    // like OldNode.
+    module.exports = factory();
+  } else {
+    // Browser globals (root is window)
+    root.typed = factory();
+  }
+}(this, function () {
+
+  function ok () {
+    return true;
+  }
+
+  function notOk () {
+    return false;
+  }
+
+  function undef () {
+    return undefined;
+  }
+
+  /**
+   * @typedef {{
+   *   params: Param[],
+   *   fn: function
+   * }} Signature
+   *
+   * @typedef {{
+   *   types: Type[],
+   *   restParam: boolean
+   * }} Param
+   *
+   * @typedef {{
+   *   name: string,
+   *   typeIndex: number,
+   *   test: function,
+   *   conversion?: ConversionDef,
+   *   conversionIndex: number,
+   * }} Type
+   *
+   * @typedef {{
+   *   from: string,
+   *   to: string,
+   *   convert: function (*) : *
+   * }} ConversionDef
+   *
+   * @typedef {{
+   *   name: string,
+   *   test: function(*) : boolean
+   * }} TypeDef
+   */
+
+  // create a new instance of typed-function
+  function create () {
+    // data type tests
+    var _types = [
+      { name: 'number',    test: function (x) { return typeof x === 'number' } },
+      { name: 'string',    test: function (x) { return typeof x === 'string' } },
+      { name: 'boolean',   test: function (x) { return typeof x === 'boolean' } },
+      { name: 'Function',  test: function (x) { return typeof x === 'function'} },
+      { name: 'Array',     test: Array.isArray },
+      { name: 'Date',      test: function (x) { return x instanceof Date } },
+      { name: 'RegExp',    test: function (x) { return x instanceof RegExp } },
+      { name: 'Object',    test: function (x) {
+        return typeof x === 'object' && x.constructor === Object
+      }},
+      { name: 'null',      test: function (x) { return x === null } },
+      { name: 'undefined', test: function (x) { return x === undefined } }
+    ];
+
+    var anyType = {
+      name: 'any',
+      test: ok
+    }
+
+    // types which need to be ignored
+    var _ignore = [];
+
+    // type conversions
+    var _conversions = [];
+
+    // This is a temporary object, will be replaced with a typed function at the end
+    var typed = {
+      types: _types,
+      conversions: _conversions,
+      ignore: _ignore
+    };
+
+    /**
+     * Find the test function for a type
+     * @param {String} typeName
+     * @return {TypeDef} Returns the type definition when found,
+     *                    Throws a TypeError otherwise
+     */
+    function findTypeByName (typeName) {
+      var entry = findInArray(typed.types, function (entry) {
+        return entry.name === typeName;
+      });
+
+      if (entry) {
+        return entry;
+      }
+
+      if (typeName === 'any') { // special baked-in case 'any'
+        return anyType;
+      }
+
+      var hint = findInArray(typed.types, function (entry) {
+        return entry.name.toLowerCase() === typeName.toLowerCase();
+      });
+
+      throw new TypeError('Unknown type "' + typeName + '"' +
+          (hint ? ('. Did you mean "' + hint.name + '"?') : ''));
+    }
+
+    /**
+     * Find the index of a type definition. Handles special case 'any'
+     * @param {TypeDef} type
+     * @return {number}
+     */
+    function findTypeIndex(type) {
+      if (type === anyType) {
+        return 999;
+      }
+
+      return typed.types.indexOf(type);
+    }
+
+    /**
+     * Find a type that matches a value.
+     * @param {*} value
+     * @return {string} Returns the name of the first type for which
+     *                  the type test matches the value.
+     */
+    function findTypeName(value) {
+      var entry = findInArray(typed.types, function (entry) {
+        return entry.test(value);
+      });
+
+      if (entry) {
+        return entry.name;
+      }
+
+      throw new TypeError('Value has unknown type. Value: ' + value);
+    }
+
+    /**
+     * Find a specific signature from a (composed) typed function, for example:
+     *
+     *   typed.find(fn, ['number', 'string'])
+     *   typed.find(fn, 'number, string')
+     *
+     * Function find only only works for exact matches.
+     *
+     * @param {Function} fn                   A typed-function
+     * @param {string | string[]} signature   Signature to be found, can be
+     *                                        an array or a comma separated string.
+     * @return {Function}                     Returns the matching signature, or
+     *                                        throws an error when no signature
+     *                                        is found.
+     */
+    function find (fn, signature) {
+      if (!fn.signatures) {
+        throw new TypeError('Function is no typed-function');
+      }
+
+      // normalize input
+      var arr;
+      if (typeof signature === 'string') {
+        arr = signature.split(',');
+        for (var i = 0; i < arr.length; i++) {
+          arr[i] = arr[i].trim();
+        }
+      }
+      else if (Array.isArray(signature)) {
+        arr = signature;
+      }
+      else {
+        throw new TypeError('String array or a comma separated string expected');
+      }
+
+      var str = arr.join(',');
+
+      // find an exact match
+      var match = fn.signatures[str];
+      if (match) {
+        return match;
+      }
+
+      // TODO: extend find to match non-exact signatures
+
+      throw new TypeError('Signature not found (signature: ' + (fn.name || 'unnamed') + '(' + arr.join(', ') + '))');
+    }
+
+    /**
+     * Convert a given value to another data type.
+     * @param {*} value
+     * @param {string} type
+     */
+    function convert (value, type) {
+      var from = findTypeName(value);
+
+      // check conversion is needed
+      if (type === from) {
+        return value;
+      }
+
+      for (var i = 0; i < typed.conversions.length; i++) {
+        var conversion = typed.conversions[i];
+        if (conversion.from === from && conversion.to === type) {
+          return conversion.convert(value);
+        }
+      }
+
+      throw new Error('Cannot convert from ' + from + ' to ' + type);
+    }
+    
+    /**
+     * Stringify parameters in a normalized way
+     * @param {Param[]} params
+     * @return {string}
+     */
+    function stringifyParams (params) {
+      return params
+          .map(function (param) {
+            var typeNames = param.types.map(getTypeName);
+
+            return (param.restParam ? '...' : '') + typeNames.join('|');
+          })
+          .join(',');
+    }
+
+    /**
+     * Parse a parameter, like "...number | boolean"
+     * @param {string} param
+     * @param {ConversionDef[]} conversions
+     * @return {Param} param
+     */
+    function parseParam (param, conversions) {
+      var restParam = param.indexOf('...') === 0;
+      var types = (!restParam)
+          ? param
+          : (param.length > 3)
+              ? param.slice(3)
+              : 'any';
+
+      var typeNames = types.split('|').map(trim)
+          .filter(notEmpty)
+          .filter(notIgnore);
+
+      var matchingConversions = filterConversions(conversions, typeNames);
+
+      var exactTypes = typeNames.map(function (typeName) {
+        var type = findTypeByName(typeName);
+
+        return {
+          name: typeName,
+          typeIndex: findTypeIndex(type),
+          test: type.test,
+          conversion: null,
+          conversionIndex: -1
+        };
+      });
+
+      var convertibleTypes = matchingConversions.map(function (conversion) {
+        var type = findTypeByName(conversion.from);
+
+        return {
+          name: conversion.from,
+          typeIndex: findTypeIndex(type),
+          test: type.test,
+          conversion: conversion,
+          conversionIndex: conversions.indexOf(conversion)
+        };
+      });
+
+      return {
+        types: exactTypes.concat(convertibleTypes),
+        restParam: restParam
+      };
+    }
+
+    /**
+     * Parse a signature with comma separated parameters,
+     * like "number | boolean, ...string"
+     * @param {string} signature
+     * @param {function} fn
+     * @param {ConversionDef[]} conversions
+     * @return {Signature | null} signature
+     */
+    function parseSignature (signature, fn, conversions) {
+      var params = [];
+
+      if (signature.trim() !== '') {
+        params = signature
+            .split(',')
+            .map(trim)
+            .map(function (param, index, array) {
+              var parsedParam = parseParam(param, conversions);
+
+              if (parsedParam.restParam && (index !== array.length - 1)) {
+                throw new SyntaxError('Unexpected rest parameter "' + param + '": ' +
+                    'only allowed for the last parameter');
+              }
+
+              return parsedParam;
+          });
+      }
+
+      if (params.some(isInvalidParam)) {
+        // invalid signature: at least one parameter has no types
+        // (they may have been filtered)
+        return null;
+      }
+
+      return {
+        params: params,
+        fn: fn
+      };
+    }
+
+    /**
+     * Test whether a set of params contains a restParam
+     * @param {Param[]} params
+     * @return {boolean} Returns true when the last parameter is a restParam
+     */
+    function hasRestParam(params) {
+      var param = last(params)
+      return param ? param.restParam : false;
+    }
+
+    /**
+     * Test whether a parameter contains conversions
+     * @param {Param} param
+     * @return {boolean} Returns true when at least one of the parameters
+     *                   contains a conversion.
+     */
+    function hasConversions(param) {
+      return param.types.some(function (type) {
+        return type.conversion != null;
+      });
+    }
+
+    /**
+     * Create a type test for a single parameter, which can have one or multiple
+     * types.
+     * @param {Param} param
+     * @return {function(x: *) : boolean} Returns a test function
+     */
+    function compileTest(param) {
+      if (!param || param.types.length === 0) {
+        // nothing to do
+        return ok;
+      }
+      else if (param.types.length === 1) {
+        return findTypeByName(param.types[0].name).test;
+      }
+      else if (param.types.length === 2) {
+        var test0 = findTypeByName(param.types[0].name).test;
+        var test1 = findTypeByName(param.types[1].name).test;
+        return function or(x) {
+          return test0(x) || test1(x);
+        }
+      }
+      else { // param.types.length > 2
+        var tests = param.types.map(function (type) {
+          return findTypeByName(type.name).test;
+        })
+        return function or(x) {
+          for (var i = 0; i < tests.length; i++) {
+            if (tests[i](x)) {
+              return true;
+            }
+          }
+          return false;
+        }
+      }
+    }
+
+    /**
+     * Create a test for all parameters of a signature
+     * @param {Param[]} params
+     * @return {function(args: Array<*>) : boolean}
+     */
+    function compileTests(params) {
+      var tests, test0, test1;
+
+      if (hasRestParam(params)) {
+        // variable arguments like '...number'
+        tests = initial(params).map(compileTest);
+        var varIndex = tests.length;
+        var lastTest = compileTest(last(params));
+        var testRestParam = function (args) {
+          for (var i = varIndex; i < args.length; i++) {
+            if (!lastTest(args[i])) {
+              return false;
+            }
+          }
+          return true;
+        }
+
+        return function testArgs(args) {
+          for (var i = 0; i < tests.length; i++) {
+            if (!tests[i](args[i])) {
+              return false;
+            }
+          }
+          return testRestParam(args) && (args.length >= varIndex + 1);
+        };
+      }
+      else {
+        // no variable arguments
+        if (params.length === 0) {
+          return function testArgs(args) {
+            return args.length === 0;
+          };
+        }
+        else if (params.length === 1) {
+          test0 = compileTest(params[0]);
+          return function testArgs(args) {
+            return test0(args[0]) && args.length === 1;
+          };
+        }
+        else if (params.length === 2) {
+          test0 = compileTest(params[0]);
+          test1 = compileTest(params[1]);
+          return function testArgs(args) {
+            return test0(args[0]) && test1(args[1]) && args.length === 2;
+          };
+        }
+        else { // arguments.length > 2
+          tests = params.map(compileTest);
+          return function testArgs(args) {
+            for (var i = 0; i < tests.length; i++) {
+              if (!tests[i](args[i])) {
+                return false;
+              }
+            }
+            return args.length === tests.length;
+          };
+        }
+      }
+    }
+
+    /**
+     * Find the parameter at a specific index of a signature.
+     * Handles rest parameters.
+     * @param {Signature} signature
+     * @param {number} index
+     * @return {Param | null} Returns the matching parameter when found,
+     *                        null otherwise.
+     */
+    function getParamAtIndex(signature, index) {
+      return index < signature.params.length
+          ? signature.params[index]
+          : hasRestParam(signature.params)
+              ? last(signature.params)
+              : null
+    }
+
+    /**
+     * Get all type names of a parameter
+     * @param {Signature} signature
+     * @param {number} index
+     * @param {boolean} excludeConversions
+     * @return {string[]} Returns an array with type names
+     */
+    function getExpectedTypeNames (signature, index, excludeConversions) {
+      var param = getParamAtIndex(signature, index);
+      var types = param
+          ? excludeConversions
+                  ? param.types.filter(isExactType)
+                  : param.types
+          : [];
+
+      return types.map(getTypeName);
+    }
+
+    /**
+     * Returns the name of a type
+     * @param {Type} type
+     * @return {string} Returns the type name
+     */
+    function getTypeName(type) {
+      return type.name;
+    }
+
+    /**
+     * Test whether a type is an exact type or conversion
+     * @param {Type} type
+     * @return {boolean} Returns true when
+     */
+    function isExactType(type) {
+      return type.conversion === null || type.conversion === undefined;
+    }
+
+    /**
+     * Helper function for creating error messages: create an array with
+     * all available types on a specific argument index.
+     * @param {Signature[]} signatures
+     * @param {number} index
+     * @return {string[]} Returns an array with available types
+     */
+    function mergeExpectedParams(signatures, index) {
+      var typeNames = uniq(flatMap(signatures, function (signature) {
+        return getExpectedTypeNames(signature, index, false);
+      }));
+
+      return (typeNames.indexOf('any') !== -1) ? ['any'] : typeNames;
+    }
+
+    /**
+     * Create
+     * @param {string} name             The name of the function
+     * @param {array.<*>} args          The actual arguments passed to the function
+     * @param {Signature[]} signatures  A list with available signatures
+     * @return {TypeError} Returns a type error with additional data
+     *                     attached to it in the property `data`
+     */
+    function createError(name, args, signatures) {
+      var err, expected;
+      var _name = name || 'unnamed';
+
+      // test for wrong type at some index
+      var matchingSignatures = signatures;
+      var index;
+      for (index = 0; index < args.length; index++) {
+        var nextMatchingDefs = matchingSignatures.filter(function (signature) {
+          var test = compileTest(getParamAtIndex(signature, index));
+          return (index < signature.params.length || hasRestParam(signature.params)) &&
+              test(args[index]);
+        });
+
+        if (nextMatchingDefs.length === 0) {
+          // no matching signatures anymore, throw error "wrong type"
+          expected = mergeExpectedParams(matchingSignatures, index);
+          if (expected.length > 0) {
+            var actualType = findTypeName(args[index]);
+
+            err = new TypeError('Unexpected type of argument in function ' + _name +
+                ' (expected: ' + expected.join(' or ') +
+                ', actual: ' + actualType + ', index: ' + index + ')');
+            err.data = {
+              category: 'wrongType',
+              fn: _name,
+              index: index,
+              actual: actualType,
+              expected: expected
+            }
+            return err;
+          }
+        }
+        else {
+          matchingSignatures = nextMatchingDefs;
+        }
+      }
+
+      // test for too few arguments
+      var lengths = matchingSignatures.map(function (signature) {
+        return hasRestParam(signature.params) ? Infinity : signature.params.length;
+      });
+      if (args.length < Math.min.apply(null, lengths)) {
+        expected = mergeExpectedParams(matchingSignatures, index);
+        err = new TypeError('Too few arguments in function ' + _name +
+            ' (expected: ' + expected.join(' or ') +
+            ', index: ' + args.length + ')');
+        err.data = {
+          category: 'tooFewArgs',
+          fn: _name,
+          index: args.length,
+          expected: expected
+        }
+        return err;
+      }
+
+      // test for too many arguments
+      var maxLength = Math.max.apply(null, lengths);
+      if (args.length > maxLength) {
+        err = new TypeError('Too many arguments in function ' + _name +
+            ' (expected: ' + maxLength + ', actual: ' + args.length + ')');
+        err.data = {
+          category: 'tooManyArgs',
+          fn: _name,
+          index: args.length,
+          expectedLength: maxLength
+        }
+        return err;
+      }
+
+      err = new TypeError('Arguments of type "' + args.join(', ') +
+          '" do not match any of the defined signatures of function ' + _name + '.');
+      err.data = {
+        category: 'mismatch',
+        actual: args.map(findTypeName)
+      }
+      return err;
+    }
+
+    /**
+     * Find the lowest index of all exact types of a parameter (no conversions)
+     * @param {Param} param
+     * @return {number} Returns the index of the lowest type in typed.types
+     */
+    function getLowestTypeIndex (param) {
+      var min = 999;
+
+      for (var i = 0; i < param.types.length; i++) {
+        if (isExactType(param.types[i])) {
+          min = Math.min(min, param.types[i].typeIndex);
+        }
+      }
+
+      return min;
+    }
+
+    /**
+     * Find the lowest index of the conversion of all types of the parameter
+     * having a conversion
+     * @param {Param} param
+     * @return {number} Returns the lowest index of the conversions of this type
+     */
+    function getLowestConversionIndex (param) {
+      var min = 999;
+
+      for (var i = 0; i < param.types.length; i++) {
+        if (!isExactType(param.types[i])) {
+          min = Math.min(min, param.types[i].conversionIndex);
+        }
+      }
+
+      return min;
+    }
+
+    /**
+     * Compare two params
+     * @param {Param} param1
+     * @param {Param} param2
+     * @return {number} returns a negative number when param1 must get a lower
+     *                  index than param2, a positive number when the opposite,
+     *                  or zero when both are equal
+     */
+    function compareParams (param1, param2) {
+      var c;
+
+      // compare having a rest parameter or not
+      c = param1.restParam - param2.restParam;
+      if (c !== 0) {
+        return c;
+      }
+
+      // compare having conversions or not
+      c = hasConversions(param1) - hasConversions(param2);
+      if (c !== 0) {
+        return c;
+      }
+
+      // compare the index of the types
+      c = getLowestTypeIndex(param1) - getLowestTypeIndex(param2);
+      if (c !== 0) {
+        return c;
+      }
+
+      // compare the index of any conversion
+      return getLowestConversionIndex(param1) - getLowestConversionIndex(param2);
+    }
+
+    /**
+     * Compare two signatures
+     * @param {Signature} signature1
+     * @param {Signature} signature2
+     * @return {number} returns a negative number when param1 must get a lower
+     *                  index than param2, a positive number when the opposite,
+     *                  or zero when both are equal
+     */
+    function compareSignatures (signature1, signature2) {
+      var len = Math.min(signature1.params.length, signature2.params.length);
+      var i;
+      var c;
+
+      // compare whether the params have conversions at all or not
+      c = signature1.params.some(hasConversions) - signature2.params.some(hasConversions)
+      if (c !== 0) {
+        return c;
+      }
+
+      // next compare whether the params have conversions one by one
+      for (i = 0; i < len; i++) {
+        c = hasConversions(signature1.params[i]) - hasConversions(signature2.params[i]);
+        if (c !== 0) {
+          return c;
+        }
+      }
+
+      // compare the types of the params one by one
+      for (i = 0; i < len; i++) {
+        c = compareParams(signature1.params[i], signature2.params[i]);
+        if (c !== 0) {
+          return c;
+        }
+      }
+
+      // compare the number of params
+      return signature1.params.length - signature2.params.length;
+    }
+
+    /**
+     * Get params containing all types that can be converted to the defined types.
+     *
+     * @param {ConversionDef[]} conversions
+     * @param {string[]} typeNames
+     * @return {ConversionDef[]} Returns the conversions that are available
+     *                        for every type (if any)
+     */
+    function filterConversions(conversions, typeNames) {
+      var matches = {};
+
+      conversions.forEach(function (conversion) {
+        if (typeNames.indexOf(conversion.from) === -1 &&
+            typeNames.indexOf(conversion.to) !== -1 &&
+            !matches[conversion.from]) {
+          matches[conversion.from] = conversion;
+        }
+      });
+
+      return Object.keys(matches).map(function (from) {
+        return matches[from];
+      });
+    }
+
+    /**
+     * Preprocess arguments before calling the original function:
+     * - if needed convert the parameters
+     * - in case of rest parameters, move the rest parameters into an Array
+     * @param {Param[]} params
+     * @param {function} fn
+     * @return {function} Returns a wrapped function
+     */
+    function compileArgsPreprocessing(params, fn) {
+      var fnConvert = fn;
+
+      // TODO: can we make this wrapper function smarter/simpler?
+
+      if (params.some(hasConversions)) {
+        var restParam = hasRestParam(params);
+        var compiledConversions = params.map(compileArgConversion)
+
+        fnConvert = function convertArgs() {
+          var args = [];
+          var last = restParam ? arguments.length - 1 : arguments.length;
+          for (var i = 0; i < last; i++) {
+            args[i] = compiledConversions[i](arguments[i]);
+          }
+          if (restParam) {
+            args[last] = arguments[last].map(compiledConversions[last]);
+          }
+
+          return fn.apply(null, args);
+        }
+      }
+
+      var fnPreprocess = fnConvert;
+      if (hasRestParam(params)) {
+        var offset = params.length - 1;
+
+        fnPreprocess = function preprocessRestParams () {
+          return fnConvert.apply(null,
+              slice(arguments, 0, offset).concat([slice(arguments, offset)]));
+        }
+      }
+
+      return fnPreprocess;
+    }
+
+    /**
+     * Compile conversion for a parameter to the right type
+     * @param {Param} param
+     * @return {function} Returns the wrapped function that will convert arguments
+     *
+     */
+    function compileArgConversion(param) {
+      var test0, test1, conversion0, conversion1;
+      var tests = [];
+      var conversions = [];
+
+      param.types.forEach(function (type) {
+        if (type.conversion) {
+          tests.push(findTypeByName(type.conversion.from).test);
+          conversions.push(type.conversion.convert);
+        }
+      });
+
+      // create optimized conversion functions depending on the number of conversions
+      switch (conversions.length) {
+        case 0:
+          return function convertArg(arg) {
+            return arg;
+          }
+
+        case 1:
+          test0 = tests[0]
+          conversion0 = conversions[0];
+          return function convertArg(arg) {
+            if (test0(arg)) {
+              return conversion0(arg)
+            }
+            return arg;
+          }
+
+        case 2:
+          test0 = tests[0]
+          test1 = tests[1]
+          conversion0 = conversions[0];
+          conversion1 = conversions[1];
+          return function convertArg(arg) {
+            if (test0(arg)) {
+              return conversion0(arg)
+            }
+            if (test1(arg)) {
+              return conversion1(arg)
+            }
+            return arg;
+          }
+
+        default:
+          return function convertArg(arg) {
+            for (var i = 0; i < conversions.length; i++) {
+              if (tests[i](arg)) {
+                return conversions[i](arg);
+              }
+            }
+            return arg;
+          }
+      }
+    }
+
+    /**
+     * Convert an array with signatures into a map with signatures,
+     * where signatures with union types are split into separate signatures
+     *
+     * Throws an error when there are conflicting types
+     *
+     * @param {Signature[]} signatures
+     * @return {Object.<string, function>}  Returns a map with signatures
+     *                                      as key and the original function
+     *                                      of this signature as value.
+     */
+    function createSignaturesMap(signatures) {
+      var signaturesMap = {};
+      signatures.forEach(function (signature) {
+        if (!signature.params.some(hasConversions)) {
+          splitParams(signature.params, true).forEach(function (params) {
+            signaturesMap[stringifyParams(params)] = signature.fn;
+          });
+        }
+      });
+
+      return signaturesMap;
+    }
+
+    /**
+     * Split params with union types in to separate params.
+     *
+     * For example:
+     *
+     *     splitParams([['Array', 'Object'], ['string', 'RegExp'])
+     *     // returns:
+     *     // [
+     *     //   ['Array', 'string'],
+     *     //   ['Array', 'RegExp'],
+     *     //   ['Object', 'string'],
+     *     //   ['Object', 'RegExp']
+     *     // ]
+     *
+     * @param {Param[]} params
+     * @param {boolean} ignoreConversionTypes
+     * @return {Param[]}
+     */
+    function splitParams(params, ignoreConversionTypes) {
+      function _splitParams(params, index, types) {
+        if (index < params.length) {
+          var param = params[index]
+          var filteredTypes = ignoreConversionTypes
+              ? param.types.filter(isExactType)
+              : param.types;
+          var typeGroups
+
+          if (param.restParam) {
+            // split the types of a rest parameter in two:
+            // one with only exact types, and one with exact types and conversions
+            var exactTypes = filteredTypes.filter(isExactType)
+            typeGroups = exactTypes.length < filteredTypes.length
+                ? [exactTypes, filteredTypes]
+                : [filteredTypes]
+
+          }
+          else {
+            // split all the types of a regular parameter into one type per group
+            typeGroups = filteredTypes.map(function (type) {
+              return [type]
+            })
+          }
+
+          // recurse over the groups with types
+          return flatMap(typeGroups, function (typeGroup) {
+            return _splitParams(params, index + 1, types.concat([typeGroup]));
+          });
+
+        }
+        else {
+          // we've reached the end of the parameters. Now build a new Param
+          var splittedParams = types.map(function (type, typeIndex) {
+            return {
+              types: type,
+              restParam: (typeIndex === params.length - 1) && hasRestParam(params)
+            }
+          });
+
+          return [splittedParams];
+        }
+      }
+
+      return _splitParams(params, 0, []);
+    }
+
+    /**
+     * Test whether two signatures have a conflicting signature
+     * @param {Signature} signature1
+     * @param {Signature} signature2
+     * @return {boolean} Returns true when the signatures conflict, false otherwise.
+     */
+    function hasConflictingParams(signature1, signature2) {
+      var ii = Math.max(signature1.params.length, signature2.params.length);
+
+      for (var i = 0; i < ii; i++) {
+        var typesNames1 = getExpectedTypeNames(signature1, i, true);
+        var typesNames2 = getExpectedTypeNames(signature2, i, true);
+
+        if (!hasOverlap(typesNames1, typesNames2)) {
+          return false;
+        }
+      }
+
+      var len1 = signature1.params.length;
+      var len2 = signature2.params.length;
+      var restParam1 = hasRestParam(signature1.params);
+      var restParam2 = hasRestParam(signature2.params);
+
+      return restParam1
+          ? restParam2 ? (len1 === len2) : (len2 >= len1)
+          : restParam2 ? (len1 >= len2)  : (len1 === len2)
+    }
+
+    /**
+     * Create a typed function
+     * @param {String} name               The name for the typed function
+     * @param {Object.<string, function>} signaturesMap
+     *                                    An object with one or
+     *                                    multiple signatures as key, and the
+     *                                    function corresponding to the
+     *                                    signature as value.
+     * @return {function}  Returns the created typed function.
+     */
+    function createTypedFunction(name, signaturesMap) {
+      if (Object.keys(signaturesMap).length === 0) {
+        throw new SyntaxError('No signatures provided');
+      }
+
+      // parse the signatures, and check for conflicts
+      var parsedSignatures = [];
+      Object.keys(signaturesMap)
+          .map(function (signature) {
+            return parseSignature(signature, signaturesMap[signature], typed.conversions);
+          })
+          .filter(notNull)
+          .forEach(function (parsedSignature) {
+            // check whether this parameter conflicts with already parsed signatures
+            var conflictingSignature = findInArray(parsedSignatures, function (s) {
+              return hasConflictingParams(s, parsedSignature)
+            });
+            if (conflictingSignature) {
+              throw new TypeError('Conflicting signatures "' +
+                  stringifyParams(conflictingSignature.params) + '" and "' +
+                  stringifyParams(parsedSignature.params) + '".');
+            }
+
+            parsedSignatures.push(parsedSignature);
+          });
+
+      // split and filter the types of the signatures, and then order them
+      var signatures = flatMap(parsedSignatures, function (parsedSignature) {
+        var params = parsedSignature ? splitParams(parsedSignature.params, false) : []
+
+        return params.map(function (params) {
+          return {
+            params: params,
+            fn: parsedSignature.fn
+          };
+        });
+      }).filter(notNull);
+
+      signatures.sort(compareSignatures);
+
+      // we create a highly optimized checks for the first couple of signatures with max 2 arguments
+      var ok0 = signatures[0] && signatures[0].params.length <= 2 && !hasRestParam(signatures[0].params);
+      var ok1 = signatures[1] && signatures[1].params.length <= 2 && !hasRestParam(signatures[1].params);
+      var ok2 = signatures[2] && signatures[2].params.length <= 2 && !hasRestParam(signatures[2].params);
+      var ok3 = signatures[3] && signatures[3].params.length <= 2 && !hasRestParam(signatures[3].params);
+      var ok4 = signatures[4] && signatures[4].params.length <= 2 && !hasRestParam(signatures[4].params);
+      var ok5 = signatures[5] && signatures[5].params.length <= 2 && !hasRestParam(signatures[5].params);
+      var allOk = ok0 && ok1 && ok2 && ok3 && ok4 && ok5;
+
+      // compile the tests
+      var tests = signatures.map(function (signature) {
+        return compileTests(signature.params);
+      });
+
+      var test00 = ok0 ? compileTest(signatures[0].params[0]) : notOk;
+      var test10 = ok1 ? compileTest(signatures[1].params[0]) : notOk;
+      var test20 = ok2 ? compileTest(signatures[2].params[0]) : notOk;
+      var test30 = ok3 ? compileTest(signatures[3].params[0]) : notOk;
+      var test40 = ok4 ? compileTest(signatures[4].params[0]) : notOk;
+      var test50 = ok5 ? compileTest(signatures[5].params[0]) : notOk;
+
+      var test01 = ok0 ? compileTest(signatures[0].params[1]) : notOk;
+      var test11 = ok1 ? compileTest(signatures[1].params[1]) : notOk;
+      var test21 = ok2 ? compileTest(signatures[2].params[1]) : notOk;
+      var test31 = ok3 ? compileTest(signatures[3].params[1]) : notOk;
+      var test41 = ok4 ? compileTest(signatures[4].params[1]) : notOk;
+      var test51 = ok5 ? compileTest(signatures[5].params[1]) : notOk;
+
+      // compile the functions
+      var fns = signatures.map(function(signature) {
+        return compileArgsPreprocessing(signature.params, signature.fn)
+      });
+
+      var fn0 = ok0 ? fns[0] : undef;
+      var fn1 = ok1 ? fns[1] : undef;
+      var fn2 = ok2 ? fns[2] : undef;
+      var fn3 = ok3 ? fns[3] : undef;
+      var fn4 = ok4 ? fns[4] : undef;
+      var fn5 = ok5 ? fns[5] : undef;
+
+      var len0 = ok0 ? signatures[0].params.length : -1;
+      var len1 = ok1 ? signatures[1].params.length : -1;
+      var len2 = ok2 ? signatures[2].params.length : -1;
+      var len3 = ok3 ? signatures[3].params.length : -1;
+      var len4 = ok4 ? signatures[4].params.length : -1;
+      var len5 = ok5 ? signatures[5].params.length : -1;
+
+      // simple and generic, but also slow
+      var iStart = allOk ? 6 : 0;
+      var iEnd = signatures.length;
+      var generic = function generic() {
+        'use strict';
+
+        for (var i = iStart; i < iEnd; i++) {
+          if (tests[i](arguments)) {
+            return fns[i].apply(null, arguments);
+          }
+        }
+
+        throw createError(name, arguments, signatures);
+      }
+
+      // create the typed function
+      // fast, specialized version. Falls back to the slower, generic one if needed
+      var fn = function fn(arg0, arg1) {
+        'use strict';
+
+        if (arguments.length === len0 && test00(arg0) && test01(arg1)) { return fn0.apply(null, arguments); }
+        if (arguments.length === len1 && test10(arg0) && test11(arg1)) { return fn1.apply(null, arguments); }
+        if (arguments.length === len2 && test20(arg0) && test21(arg1)) { return fn2.apply(null, arguments); }
+        if (arguments.length === len3 && test30(arg0) && test31(arg1)) { return fn3.apply(null, arguments); }
+        if (arguments.length === len4 && test40(arg0) && test41(arg1)) { return fn4.apply(null, arguments); }
+        if (arguments.length === len5 && test50(arg0) && test51(arg1)) { return fn5.apply(null, arguments); }
+
+        return generic.apply(null, arguments);
+      }
+
+      // attach name the typed function
+      try {
+        Object.defineProperty(fn, 'name', {value: name});
+      }
+      catch (err) {
+        // old browsers do not support Object.defineProperty and some don't support setting the name property
+        // the function name is not essential for the functioning, it's mostly useful for debugging,
+        // so it's fine to have unnamed functions.
+      }
+
+      // attach signatures to the function
+      fn.signatures = createSignaturesMap(signatures);
+
+      return fn;
+    }
+
+    /**
+     * Test whether a type should be NOT be ignored
+     * @param {string} typeName
+     * @return {boolean}
+     */
+    function notIgnore(typeName) {
+      return typed.ignore.indexOf(typeName) === -1;
+    }
+
+    /**
+     * trim a string
+     * @param {string} str
+     * @return {string}
+     */
+    function trim(str) {
+      return str.trim();
+    }
+
+    /**
+     * Test whether a string is not empty
+     * @param {string} str
+     * @return {boolean}
+     */
+    function notEmpty(str) {
+      return !!str;
+    }
+
+    /**
+     * test whether a value is not strict equal to null
+     * @param {*} value
+     * @return {boolean}
+     */
+    function notNull(value) {
+      return value !== null;
+    }
+
+    /**
+     * Test whether a parameter has no types defined
+     * @param {Param} param
+     * @return {boolean}
+     */
+    function isInvalidParam (param) {
+      return param.types.length === 0;
+    }
+
+    /**
+     * Return all but the last items of an array
+     * @param {Array} arr
+     * @return {Array}
+     */
+    function initial(arr) {
+      return arr.slice(0, arr.length - 1);
+    }
+
+    /**
+     * return the last item of an array
+     * @param {Array} arr
+     * @return {*}
+     */
+    function last(arr) {
+      return arr[arr.length - 1];
+    }
+
+    /**
+     * Slice an array or function Arguments
+     * @param {Array | Arguments | IArguments} arr
+     * @param {number} start
+     * @param {number} [end]
+     * @return {Array}
+     */
+    function slice(arr, start, end) {
+      return Array.prototype.slice.call(arr, start, end);
+    }
+
+    /**
+     * Test whether an array contains some item
+     * @param {Array} array
+     * @param {*} item
+     * @return {boolean} Returns true if array contains item, false if not.
+     */
+    function contains(array, item) {
+      return array.indexOf(item) !== -1;
+    }
+
+    /**
+     * Test whether two arrays have overlapping items
+     * @param {Array} array1
+     * @param {Array} array2
+     * @return {boolean} Returns true when at least one item exists in both arrays
+     */
+    function hasOverlap(array1, array2) {
+      for (var i = 0; i < array1.length; i++) {
+        if (contains(array2, array1[i])) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Return the first item from an array for which test(arr[i]) returns true
+     * @param {Array} arr
+     * @param {function} test
+     * @return {* | undefined} Returns the first matching item
+     *                         or undefined when there is no match
+     */
+    function findInArray(arr, test) {
+      for (var i = 0; i < arr.length; i++) {
+        if (test(arr[i])) {
+          return arr[i];
+        }
+      }
+      return undefined;
+    }
+
+    /**
+     * Filter unique items of an array with strings
+     * @param {string[]} arr
+     * @return {string[]}
+     */
+    function uniq(arr) {
+      var entries = {}
+      for (var i = 0; i < arr.length; i++) {
+        entries[arr[i]] = true;
+      }
+      return Object.keys(entries);
+    }
+
+    /**
+     * Flat map the result invoking a callback for every item in an array.
+     * https://gist.github.com/samgiles/762ee337dff48623e729
+     * @param {Array} arr
+     * @param {function} callback
+     * @return {Array}
+     */
+    function flatMap(arr, callback) {
+      return Array.prototype.concat.apply([], arr.map(callback));
+    }
+
+    /**
+     * Retrieve the function name from a set of typed functions,
+     * and check whether the name of all functions match (if given)
+     * @param {function[]} fns
+     */
+    function getName (fns) {
+      var name = '';
+
+      for (var i = 0; i < fns.length; i++) {
+        var fn = fns[i];
+
+        // check whether the names are the same when defined
+        if ((typeof fn.signatures === 'object' || typeof fn.signature === 'string') && fn.name !== '') {
+          if (name === '') {
+            name = fn.name;
+          }
+          else if (name !== fn.name) {
+            var err = new Error('Function names do not match (expected: ' + name + ', actual: ' + fn.name + ')');
+            err.data = {
+              actual: fn.name,
+              expected: name
+            };
+            throw err;
+          }
+        }
+      }
+
+      return name;
+    }
+
+    // extract and merge all signatures of a list with typed functions
+    function extractSignatures(fns) {
+      var err;
+      var signaturesMap = {};
+
+      function validateUnique(_signature, _fn) {
+        if (signaturesMap.hasOwnProperty(_signature) && _fn !== signaturesMap[_signature]) {
+          err = new Error('Signature "' + _signature + '" is defined twice');
+          err.data = {signature: _signature};
+          throw err;
+          // else: both signatures point to the same function, that's fine
+        }
+      }
+
+      for (var i = 0; i < fns.length; i++) {
+        var fn = fns[i];
+
+        // test whether this is a typed-function
+        if (typeof fn.signatures === 'object') {
+          // merge the signatures
+          for (var signature in fn.signatures) {
+            if (fn.signatures.hasOwnProperty(signature)) {
+              validateUnique(signature, fn.signatures[signature]);
+              signaturesMap[signature] = fn.signatures[signature];
+            }
+          }
+        }
+        else if (typeof fn.signature === 'string') {
+          validateUnique(fn.signature, fn);
+          signaturesMap[fn.signature] = fn;
+        }
+        else {
+          err = new TypeError('Function is no typed-function (index: ' + i + ')');
+          err.data = {index: i};
+          throw err;
+        }
+      }
+
+      return signaturesMap;
+    }
+
+    typed = createTypedFunction('typed', {
+      'string, Object': createTypedFunction,
+      'Object': function (signaturesMap) {
+        // find existing name
+        var fns = [];
+        for (var signature in signaturesMap) {
+          if (signaturesMap.hasOwnProperty(signature)) {
+            fns.push(signaturesMap[signature]);
+          }
+        }
+        var name = getName(fns);
+        return createTypedFunction(name, signaturesMap);
+      },
+      '...Function': function (fns) {
+        return createTypedFunction(getName(fns), extractSignatures(fns));
+      },
+      'string, ...Function': function (name, fns) {
+        return createTypedFunction(name, extractSignatures(fns));
+      }
+    });
+
+    typed.create = create;
+    typed.types = _types;
+    typed.conversions = _conversions;
+    typed.ignore = _ignore;
+    typed.convert = convert;
+    typed.find = find;
+
+    /**
+     * add a type
+     * @param {{name: string, test: function}} type
+     * @param {boolean} [beforeObjectTest=true]
+     *                          If true, the new test will be inserted before
+     *                          the test with name 'Object' (if any), since
+     *                          tests for Object match Array and classes too.
+     */
+    typed.addType = function (type, beforeObjectTest) {
+      if (!type || typeof type.name !== 'string' || typeof type.test !== 'function') {
+        throw new TypeError('Object with properties {name: string, test: function} expected');
+      }
+
+      if (beforeObjectTest !== false) {
+        for (var i = 0; i < typed.types.length; i++) {
+          if (typed.types[i].name === 'Object') {
+            typed.types.splice(i, 0, type);
+            return
+          }
+        }
+      }
+
+      typed.types.push(type);
+    };
+
+    // add a conversion
+    typed.addConversion = function (conversion) {
+      if (!conversion
+          || typeof conversion.from !== 'string'
+          || typeof conversion.to !== 'string'
+          || typeof conversion.convert !== 'function') {
+        throw new TypeError('Object with properties {from: string, to: string, convert: function} expected');
+      }
+
+      typed.conversions.push(conversion);
+    };
+
+    return typed;
+  }
+
+  return create();
+}));
+},{}]},{},[1])(1)
+});
diff --git a/mathjs/mathjs-expression-parser.min.js b/mathjs/mathjs-expression-parser.min.js
new file mode 100644
index 0000000..675afce
--- /dev/null
+++ b/mathjs/mathjs-expression-parser.min.js
@@ -0,0 +1 @@
+!function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).math=t()}}(function(){return function i(a,s,u){function p(e,t){if(!s[e]){if(!a[e]){var n="function"==typeof require&&require;if(!t&&n)return n(e,!0);if(c)return c(e,!0);var r=new Error("Cannot find module '"+e+"'");throw r.code="MODULE_NOT_FOUND",r}var o=s[e]={exports:{}};a[e][0].call(o.exports,function(t){return p(a[e][1][t]||t)},o,o.exports,i,a,s,u)}return s[e].exports}for(var c="function"==typeof require&&require,t=0;t<u.length;t++)p(u[t]);return p}({1:[function(t,e,n){var r=t("mathjs/core").create();r.import(t("mathjs/lib/expression/function/parse")),r.import(t("mathjs/lib/expression/function/compile")),r.import(t("mathjs/lib/expression/function/eval")),r.import(t("mathjs/lib/function/string/format")),r.import({add:function(t,e){return t+e},subtract:function(t,e){return t-e},multiply:function(t,e){return t*e},divide:function(t,e){return t/e},mod:function(t,e){return t%e},unaryPlus:function(t){return t},unaryMinus:function(t){return-t},bitOr:function(t,e){return t|e},bitXor:function(t,e){return t^e},bitAnd:function(t,e){return t&e},bitNot:function(t){return~t},leftShift:function(t,e){return t<<e},rightArithShift:function(t,e){return t>>e},rightLogShift:function(t,e){return t>>>e},or:function(t,e){return!(!t&&!e)},xor:function(t,e){return!!t!=!!e},and:function(t,e){return!(!t||!e)},not:function(t){return!t},equal:function(t,e){return t==e},unequal:function(t,e){return t!=e},smaller:function(t,e){return t<e},larger:function(t,e){return e<t},smallerEq:function(t,e){return t<=e},largerEq:function(t,e){return e<=t},matrix:function(){throw new Error("Matrices not supported")},index:function(){throw new Error("Matrix indexes not supported")},pi:Math.PI,e:Math.E,true:!0,false:!1,null:null});var o={};Object.getOwnPropertyNames(Math).forEach(function(t){Object.prototype.hasOwnProperty(t)||(o[t]=Math[t])}),r.import(o),e.exports=r},{"mathjs/core":3,"mathjs/lib/expression/function/compile":11,"mathjs/lib/expression/function/eval":12,"mathjs/lib/expression/function/parse":13,"mathjs/lib/function/string/format":37}],2:[function(t,e,n){"use strict";var f=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(t[r]=n[r])}return t},h={"{":"\\{","}":"\\}","\\":"\\textbackslash{}","#":"\\#",$:"\\$","%":"\\%","&":"\\&","^":"\\textasciicircum{}",_:"\\_","~":"\\textasciitilde{}"},l={"–":"\\--","—":"\\---"," ":"~","\t":"\\qquad{}","\r\n":"\\newline{}","\n":"\\newline{}"},m=function(t,e){return f({},t,e)};e.exports=function(t){for(var e=1<arguments.length&&void 0!==arguments[1]?arguments[1]:{},n=e.preserveFormatting,r=void 0!==n&&n,o=e.escapeMapFn,i=void 0===o?m:o,a=String(t),s="",u=i(f({},h),r?f({},l):{}),p=Object.keys(u),c=function(){var n=!1;p.forEach(function(t,e){n||a.length>=t.length&&a.slice(0,t.length)===t&&(s+=u[p[e]],a=a.slice(t.length,a.length),n=!0)}),n||(s+=a.slice(0,1),a=a.slice(1,a.length))};a;)c();return s}},{}],3:[function(t,e,n){e.exports=t("./lib/core/core")},{"./lib/core/core":4}],4:[function(t,e,n){"use strict";t("./../utils/polyfills");var u=t("./../utils/object").isFactory,p=t("./typed"),c=t("./../utils/emitter"),f=t("./function/import"),h=t("./function/config");n.create=function(t){if("function"!=typeof Object.create)throw new Error("ES5 not supported by this JavaScript engine. Please load the es5-shim and es5-sham library for compatibility.");var r=[],o=[],i=c.mixin({});i.type={},i.expression={transform:{},mathWithTransform:{}},i.typed=p.create(i.type);var a={epsilon:1e-12,matrix:"Matrix",number:"number",precision:64,predictable:!1,randomSeed:null};function s(t){if(!u(t))throw new Error("Factory object with properties `type`, `name`, and `factory` expected");var e,n=r.indexOf(t);return-1===n?(e=!0===t.math?t.factory(i.type,a,s,i.typed,i):t.factory(i.type,a,s,i.typed),r.push(t),o.push(e)):e=o[n],e}return i.import=s(f),i.config=s(h),i.expression.mathWithTransform.config=i.config,t&&i.config(t),i}},{"./../utils/emitter":52,"./../utils/object":55,"./../utils/polyfills":56,"./function/config":5,"./function/import":6,"./typed":7}],5:[function(t,e,n){"use strict";var u=t("../../utils/object");function p(t,e,n){if(void 0!==t[e]&&(a=n,s=t[e],-1===a.indexOf(s))){var r=(o=n,i=t[e],o.map(function(t){return t.toLowerCase()}).indexOf(i.toLowerCase()));-1!==r?(console.warn('Warning: Wrong casing for configuration option "'+e+'", should be "'+n[r]+'" instead of "'+t[e]+'".'),t[e]=n[r]):console.warn('Warning: Unknown value "'+t[e]+'" for configuration option "'+e+'". Available options: '+n.map(JSON.stringify).join(", ")+".")}var o,i,a,s}n.name="config",n.math=!0,n.factory=function(t,o,e,n,i){var a=["Matrix","Array"],s=["number","BigNumber","Fraction"];function r(t){if(t){var e=u.map(o,u.clone);p(t,"matrix",a),p(t,"number",s),u.deepExtend(o,t);var n=u.map(o,u.clone),r=u.map(t,u.clone);return i.emit("config",n,e,r),n}return u.map(o,u.clone)}return r.MATRIX=a,r.NUMBER=s,r}},{"../../utils/object":55}],6:[function(t,e,n){"use strict";function y(t){return(y="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var g=t("../../utils/object").lazy,v=t("../../utils/object").isFactory,b=t("../../utils/object").traverse,x=t("../../error/ArgumentsError");n.math=!0,n.name="import",n.factory=function(s,t,u,p,c){function f(t,e,n){if(n.wrap&&"function"==typeof e&&(r=function(){for(var t=[],e=0,n=arguments.length;e<n;e++){var r=arguments[e];t[e]=r&&r.valueOf()}return o.apply(c,t)},(o=e).transform&&(r.transform=o.transform),e=r),m(c[t])&&m(e))return e=n.override?p(t,e.signatures):p(c[t],e),i(t,c[t]=e),void c.emit("import",t,function(){return e});var o,r;if(void 0===c[t]||n.override)return i(t,c[t]=e),void c.emit("import",t,function(){return e});if(!n.silent)throw new Error('Cannot import "'+t+'": already exists')}function i(t,e){e&&"function"==typeof e.transform?(c.expression.transform[t]=e.transform,n(t)&&(c.expression.mathWithTransform[t]=e.transform)):(delete c.expression.transform[t],n(t)&&(c.expression.mathWithTransform[t]=e))}function h(t){delete c.expression.transform[t],n(t)?c.expression.mathWithTransform[t]=c[t]:delete c.expression.mathWithTransform[t]}function l(e,n){if("string"==typeof e.name){var r=e.name,t=r in c.expression.transform,o=e.path?b(c,e.path):c,i=o.hasOwnProperty(r)?o[r]:void 0,a=function(){var t=u(e);if(t&&"function"==typeof t.transform)throw new Error('Transforms cannot be attached to factory functions. Please create a separate function for it with exports.path="expression.transform"');if(m(i)&&m(t))return n.override||(t=p(i,t)),t;if(void 0===i||n.override)return t;if(!n.silent)throw new Error('Cannot import "'+r+'": already exists')};!1!==e.lazy?(g(o,r,a),t?h(r):("expression.transform"===e.path||d(e))&&g(c.expression.mathWithTransform,r,a)):(o[r]=a(),t?h(r):("expression.transform"===e.path||d(e))&&(c.expression.mathWithTransform[r]=a())),c.emit("import",r,a,e.path)}else u(e)}function m(t){return"function"==typeof t&&"object"===y(t.signatures)}function n(t){return!e.hasOwnProperty(t)}function d(t){return void 0===t.path&&!e.hasOwnProperty(t.name)}var e={expression:!0,type:!0,docs:!0,error:!0,json:!0,chain:!0};return function e(t,n){var r,o=arguments.length;if(1!==o&&2!==o)throw new x("import",o,1,2);if(n||(n={}),v(t))l(t,n);else if(Array.isArray(t))t.forEach(function(t){e(t,n)});else if("object"===y(t)){for(var i in t)if(t.hasOwnProperty(i)){var a=t[i];"function"==typeof(r=a)||"number"==typeof r||"string"==typeof r||"boolean"==typeof r||null===r||r&&s.isUnit(r)||r&&s.isComplex(r)||r&&s.isBigNumber(r)||r&&s.isFraction(r)||r&&s.isMatrix(r)||r&&Array.isArray(r)?f(i,a,n):v(t)?l(t,n):e(a,n)}}else if(!n.silent)throw new TypeError("Factory, Object, or Array expected")}},n.lazy=!0},{"../../error/ArgumentsError":8,"../../utils/object":55}],7:[function(t,e,n){"use strict";function r(t){return(r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var o=t("typed-function"),i=t("./../utils/number").digits,a=t("./../utils/bignumber/isBigNumber"),s=t("./../utils/collection/isMatrix"),u=function(){return u=o.create,o};n.create=function(n){n.isNumber=function(t){return"number"==typeof t},n.isComplex=function(t){return n.Complex&&t instanceof n.Complex||!1},n.isBigNumber=a,n.isFraction=function(t){return n.Fraction&&t instanceof n.Fraction||!1},n.isUnit=function(t){return t&&t.constructor.prototype.isUnit||!1},n.isString=function(t){return"string"==typeof t},n.isArray=Array.isArray,n.isMatrix=s,n.isDenseMatrix=function(t){return t&&t.isDenseMatrix&&t.constructor.prototype.isMatrix||!1},n.isSparseMatrix=function(t){return t&&t.isSparseMatrix&&t.constructor.prototype.isMatrix||!1},n.isRange=function(t){return t&&t.constructor.prototype.isRange||!1},n.isIndex=function(t){return t&&t.constructor.prototype.isIndex||!1},n.isBoolean=function(t){return"boolean"==typeof t},n.isResultSet=function(t){return t&&t.constructor.prototype.isResultSet||!1},n.isHelp=function(t){return t&&t.constructor.prototype.isHelp||!1},n.isFunction=function(t){return"function"==typeof t},n.isDate=function(t){return t instanceof Date},n.isRegExp=function(t){return t instanceof RegExp},n.isObject=function(t){return"object"===r(t)&&t.constructor===Object&&!n.isComplex(t)&&!n.isFraction(t)},n.isNull=function(t){return null===t},n.isUndefined=function(t){return void 0===t},n.isAccessorNode=function(t){return t&&t.isAccessorNode&&t.constructor.prototype.isNode||!1},n.isArrayNode=function(t){return t&&t.isArrayNode&&t.constructor.prototype.isNode||!1},n.isAssignmentNode=function(t){return t&&t.isAssignmentNode&&t.constructor.prototype.isNode||!1},n.isBlockNode=function(t){return t&&t.isBlockNode&&t.constructor.prototype.isNode||!1},n.isConditionalNode=function(t){return t&&t.isConditionalNode&&t.constructor.prototype.isNode||!1},n.isConstantNode=function(t){return t&&t.isConstantNode&&t.constructor.prototype.isNode||!1},n.isFunctionAssignmentNode=function(t){return t&&t.isFunctionAssignmentNode&&t.constructor.prototype.isNode||!1},n.isFunctionNode=function(t){return t&&t.isFunctionNode&&t.constructor.prototype.isNode||!1},n.isIndexNode=function(t){return t&&t.isIndexNode&&t.constructor.prototype.isNode||!1},n.isNode=function(t){return t&&t.isNode&&t.constructor.prototype.isNode||!1},n.isObjectNode=function(t){return t&&t.isObjectNode&&t.constructor.prototype.isNode||!1},n.isOperatorNode=function(t){return t&&t.isOperatorNode&&t.constructor.prototype.isNode||!1},n.isParenthesisNode=function(t){return t&&t.isParenthesisNode&&t.constructor.prototype.isNode||!1},n.isRangeNode=function(t){return t&&t.isRangeNode&&t.constructor.prototype.isNode||!1},n.isSymbolNode=function(t){return t&&t.isSymbolNode&&t.constructor.prototype.isNode||!1},n.isChain=function(t){return t&&t.constructor.prototype.isChain||!1};var t=u();return t.types=[{name:"number",test:n.isNumber},{name:"Complex",test:n.isComplex},{name:"BigNumber",test:n.isBigNumber},{name:"Fraction",test:n.isFraction},{name:"Unit",test:n.isUnit},{name:"string",test:n.isString},{name:"Array",test:n.isArray},{name:"Matrix",test:n.isMatrix},{name:"DenseMatrix",test:n.isDenseMatrix},{name:"SparseMatrix",test:n.isSparseMatrix},{name:"Range",test:n.isRange},{name:"Index",test:n.isIndex},{name:"boolean",test:n.isBoolean},{name:"ResultSet",test:n.isResultSet},{name:"Help",test:n.isHelp},{name:"function",test:n.isFunction},{name:"Date",test:n.isDate},{name:"RegExp",test:n.isRegExp},{name:"null",test:n.isNull},{name:"undefined",test:n.isUndefined},{name:"OperatorNode",test:n.isOperatorNode},{name:"ConstantNode",test:n.isConstantNode},{name:"SymbolNode",test:n.isSymbolNode},{name:"ParenthesisNode",test:n.isParenthesisNode},{name:"FunctionNode",test:n.isFunctionNode},{name:"FunctionAssignmentNode",test:n.isFunctionAssignmentNode},{name:"ArrayNode",test:n.isArrayNode},{name:"AssignmentNode",test:n.isAssignmentNode},{name:"BlockNode",test:n.isBlockNode},{name:"ConditionalNode",test:n.isConditionalNode},{name:"IndexNode",test:n.isIndexNode},{name:"RangeNode",test:n.isRangeNode},{name:"Node",test:n.isNode},{name:"Object",test:n.isObject}],t.conversions=[{from:"number",to:"BigNumber",convert:function(t){if(15<i(t))throw new TypeError("Cannot implicitly convert a number with >15 significant digits to BigNumber (value: "+t+"). Use function bignumber(x) to convert to BigNumber.");return new n.BigNumber(t)}},{from:"number",to:"Complex",convert:function(t){return new n.Complex(t,0)}},{from:"number",to:"string",convert:function(t){return t+""}},{from:"BigNumber",to:"Complex",convert:function(t){return new n.Complex(t.toNumber(),0)}},{from:"Fraction",to:"BigNumber",convert:function(t){throw new TypeError("Cannot implicitly convert a Fraction to BigNumber or vice versa. Use function bignumber(x) to convert to BigNumber or fraction(x) to convert to Fraction.")}},{from:"Fraction",to:"Complex",convert:function(t){return new n.Complex(t.valueOf(),0)}},{from:"number",to:"Fraction",convert:function(t){if(new n.Fraction(t).valueOf()!==t)throw new TypeError("Cannot implicitly convert a number to a Fraction when there will be a loss of precision (value: "+t+"). Use function fraction(x) to convert to Fraction.");return new n.Fraction(t)}},{from:"string",to:"number",convert:function(t){var e=Number(t);if(isNaN(e))throw new Error('Cannot convert "'+t+'" to a number');return e}},{from:"string",to:"BigNumber",convert:function(e){try{return new n.BigNumber(e)}catch(t){throw new Error('Cannot convert "'+e+'" to BigNumber')}}},{from:"string",to:"Fraction",convert:function(e){try{return new n.Fraction(e)}catch(t){throw new Error('Cannot convert "'+e+'" to Fraction')}}},{from:"string",to:"Complex",convert:function(e){try{return new n.Complex(e)}catch(t){throw new Error('Cannot convert "'+e+'" to Complex')}}},{from:"boolean",to:"number",convert:function(t){return+t}},{from:"boolean",to:"BigNumber",convert:function(t){return new n.BigNumber(+t)}},{from:"boolean",to:"Fraction",convert:function(t){return new n.Fraction(+t)}},{from:"boolean",to:"string",convert:function(t){return+t}},{from:"Array",to:"Matrix",convert:function(t){return new n.DenseMatrix(t)}},{from:"Matrix",to:"Array",convert:function(t){return t.valueOf()}}],t}},{"./../utils/bignumber/isBigNumber":48,"./../utils/collection/isMatrix":50,"./../utils/number":54,"typed-function":59}],8:[function(t,e,n){"use strict";function o(t,e,n,r){if(!(this instanceof o))throw new SyntaxError("Constructor must be called with the new operator");this.fn=t,this.count=e,this.min=n,this.max=r,this.message="Wrong number of arguments in function "+t+" ("+e+" provided, "+n+(null!=r?"-"+r:"")+" expected)",this.stack=(new Error).stack}(o.prototype=new Error).constructor=Error,o.prototype.name="ArgumentsError",o.prototype.isArgumentsError=!0,e.exports=o},{}],9:[function(t,e,n){"use strict";function r(t,e,n){if(!(this instanceof r))throw new SyntaxError("Constructor must be called with the new operator");this.actual=t,this.expected=e,this.relation=n,this.message="Dimension mismatch ("+(Array.isArray(t)?"["+t.join(", ")+"]":t)+" "+(this.relation||"!=")+" "+(Array.isArray(e)?"["+e.join(", ")+"]":e)+")",this.stack=(new Error).stack}(r.prototype=new RangeError).constructor=RangeError,r.prototype.name="DimensionError",r.prototype.isDimensionError=!0,e.exports=r},{}],10:[function(t,e,n){"use strict";function r(t,e,n){if(!(this instanceof r))throw new SyntaxError("Constructor must be called with the new operator");this.index=t,arguments.length<3?(this.min=0,this.max=e):(this.min=e,this.max=n),void 0!==this.min&&this.index<this.min?this.message="Index out of range ("+this.index+" < "+this.min+")":void 0!==this.max&&this.index>=this.max?this.message="Index out of range ("+this.index+" > "+(this.max-1)+")":this.message="Index out of range ("+this.index+")",this.stack=(new Error).stack}(r.prototype=new RangeError).constructor=RangeError,r.prototype.name="IndexError",r.prototype.isIndexError=!0,e.exports=r},{}],11:[function(i,t,e){"use strict";var a=i("../../utils/collection/deepMap");e.name="compile",e.factory=function(t,e,n,r){var o=n(i("../parse"));return r("compile",{string:function(t){return o(t).compile()},"Array | Matrix":function(t){return a(t,function(t){return o(t).compile()})}})}},{"../../utils/collection/deepMap":49,"../parse":34}],12:[function(i,t,e){"use strict";var a=i("../../utils/collection/deepMap");e.name="eval",e.factory=function(t,e,n,r){var o=n(i("../parse"));return r("compile",{string:function(t){return o(t).compile().eval({})},"string, Object":function(t,e){return o(t).compile().eval(e)},"Array | Matrix":function(t){var e={};return a(t,function(t){return o(t).compile().eval(e)})},"Array | Matrix, Object":function(t,e){return a(t,function(t){return o(t).compile().eval(e)})}})}},{"../../utils/collection/deepMap":49,"../parse":34}],13:[function(i,t,e){"use strict";e.name="parse",e.factory=function(t,e,n,r){var o=n(i("../parse"));return r("parse",{"string | Array | Matrix":o,"string | Array | Matrix, Object":o})}},{"../parse":34}],14:[function(t,e,n){"use strict";e.exports={end:!0}},{}],15:[function(u,t,e){"use strict";var p=u("../../utils/customs").getSafeProperty;e.name="AccessorNode",e.path="expression.node",e.factory=function(n,t,e,r){var o=e(u("./Node")),s=e(u("./utils/access"));function i(t,e){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(!n.isNode(t))throw new TypeError('Node expected for parameter "object"');if(!n.isIndexNode(e))throw new TypeError('IndexNode expected for parameter "index"');this.object=t||null,this.index=e,Object.defineProperty(this,"name",{get:function(){return this.index?this.index.isObjectProperty()?this.index.getObjectProperty():"":this.object.name||""}.bind(this),set:function(){throw new Error("Cannot assign a new name, name is read-only")}})}function a(t){return!(n.isAccessorNode(t)||n.isArrayNode(t)||n.isConstantNode(t)||n.isFunctionNode(t)||n.isObjectNode(t)||n.isParenthesisNode(t)||n.isSymbolNode(t))}return(i.prototype=new o).type="AccessorNode",i.prototype.isAccessorNode=!0,i.prototype._compile=function(t,e){var i=this.object._compile(t,e),a=this.index._compile(t,e);if(this.index.isObjectProperty()){var r=this.index.getObjectProperty();return function(t,e,n){return p(i(t,e,n),r)}}return function(t,e,n){var r=i(t,e,n),o=a(t,e,r);return s(r,o)}},i.prototype.forEach=function(t){t(this.object,"object",this),t(this.index,"index",this)},i.prototype.map=function(t){return new i(this._ifNode(t(this.object,"object",this)),this._ifNode(t(this.index,"index",this)))},i.prototype.clone=function(){return new i(this.object,this.index)},i.prototype._toString=function(t){var e=this.object.toString(t);return a(this.object)&&(e="("+e+")"),e+this.index.toString(t)},i.prototype.toHTML=function(t){var e=this.object.toHTML(t);return a(this.object)&&(e='<span class="math-parenthesis math-round-parenthesis">(</span>'+e+'<span class="math-parenthesis math-round-parenthesis">)</span>'),e+this.index.toHTML(t)},i.prototype._toTex=function(t){var e=this.object.toTex(t);return a(this.object)&&(e="\\left(' + object + '\\right)"),e+this.index.toTex(t)},i.prototype.toJSON=function(){return{mathjs:"AccessorNode",object:this.object,index:this.index}},i.fromJSON=function(t){return new i(t.object,t.index)},i}},{"../../utils/customs":51,"./Node":24,"./utils/access":31}],16:[function(a,t,e){"use strict";var s=a("../../utils/array").map;e.name="ArrayNode",e.path="expression.node",e.factory=function(n,t,e,r){var o=e(a("./Node"));function i(t){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(this.items=t||[],!Array.isArray(this.items)||!this.items.every(n.isNode))throw new TypeError("Array containing Nodes expected");var e=function(){throw new Error("Property `ArrayNode.nodes` is deprecated, use `ArrayNode.items` instead")};Object.defineProperty(this,"nodes",{get:e,set:e})}return(i.prototype=new o).type="ArrayNode",i.prototype.isArrayNode=!0,i.prototype._compile=function(e,n){var t=s(this.items,function(t){return t._compile(e,n)});if("Array"===e.config().matrix)return function(e,n,r){return s(t,function(t){return t(e,n,r)})};var o=e.matrix;return function(e,n,r){return o(s(t,function(t){return t(e,n,r)}))}},i.prototype.forEach=function(t){for(var e=0;e<this.items.length;e++)t(this.items[e],"items["+e+"]",this)},i.prototype.map=function(t){for(var e=[],n=0;n<this.items.length;n++)e[n]=this._ifNode(t(this.items[n],"items["+n+"]",this));return new i(e)},i.prototype.clone=function(){return new i(this.items.slice(0))},i.prototype._toString=function(e){return"["+this.items.map(function(t){return t.toString(e)}).join(", ")+"]"},i.prototype.toJSON=function(){return{mathjs:"ArrayNode",items:this.items}},i.fromJSON=function(t){return new i(t.items)},i.prototype.toHTML=function(e){return'<span class="math-parenthesis math-square-parenthesis">[</span>'+this.items.map(function(t){return t.toHTML(e)}).join('<span class="math-separator">,</span>')+'<span class="math-parenthesis math-square-parenthesis">]</span>'},i.prototype._toTex=function(e){var n="\\begin{bmatrix}";return this.items.forEach(function(t){t.items?n+=t.items.map(function(t){return t.toTex(e)}).join("&"):n+=t.toTex(e),n+="\\\\"}),n+="\\end{bmatrix}"},i}},{"../../utils/array":46,"./Node":24}],17:[function(u,t,e){"use strict";var d=u("../../utils/customs").getSafeProperty,y=u("../../utils/customs").setSafeProperty;e.name="AssignmentNode",e.path="expression.node",e.factory=function(r,t,e,n){var o=e(u("./Node")),l=e(u("./utils/assign")),m=e(u("./utils/access")),i=u("../operators");function a(t,e,n){if(!(this instanceof a))throw new SyntaxError("Constructor must be called with the new operator");if(this.object=t,this.index=n?e:null,this.value=n||e,!r.isSymbolNode(t)&&!r.isAccessorNode(t))throw new TypeError('SymbolNode or AccessorNode expected as "object"');if(r.isSymbolNode(t)&&"end"===t.name)throw new Error('Cannot assign to symbol "end"');if(this.index&&!r.isIndexNode(this.index))throw new TypeError('IndexNode expected as "index"');if(!r.isNode(this.value))throw new TypeError('Node expected as "value"');Object.defineProperty(this,"name",{get:function(){return this.index?this.index.isObjectProperty()?this.index.getObjectProperty():"":this.object.name||""}.bind(this),set:function(){throw new Error("Cannot assign a new name, name is read-only")}})}function s(t,e){e||(e="keep");var n=i.getPrecedence(t,e),r=i.getPrecedence(t.value,e);return"all"===e||null!==r&&r<=n}return(a.prototype=new o).type="AssignmentNode",a.prototype.isAssignmentNode=!0,a.prototype._compile=function(t,e){var a=this.object._compile(t,e),u=this.index?this.index._compile(t,e):null,p=this.value._compile(t,e),s=this.object.name;if(this.index){if(this.index.isObjectProperty()){var i=this.index.getObjectProperty();return function(t,e,n){var r=a(t,e,n),o=p(t,e,n);return y(r,i,o)}}if(r.isSymbolNode(this.object))return function(t,e,n){var r=a(t,e,n),o=p(t,e,n),i=u(t,e,r);return y(t,s,l(r,i,o)),o};var c=this.object.object._compile(t,e);if(this.object.index.isObjectProperty()){var f=this.object.index.getObjectProperty();return function(t,e,n){var r=c(t,e,n),o=d(r,f),i=u(t,e,o),a=p(t,e,n);return y(r,f,l(o,i,a)),a}}var h=this.object.index._compile(t,e);return function(t,e,n){var r=c(t,e,n),o=h(t,e,r),i=m(r,o),a=u(t,e,i),s=p(t,e,n);return l(r,o,l(i,a,s)),s}}if(!r.isSymbolNode(this.object))throw new TypeError("SymbolNode expected as object");return function(t,e,n){return y(t,s,p(t,e,n))}},a.prototype.forEach=function(t){t(this.object,"object",this),this.index&&t(this.index,"index",this),t(this.value,"value",this)},a.prototype.map=function(t){return new a(this._ifNode(t(this.object,"object",this)),this.index?this._ifNode(t(this.index,"index",this)):null,this._ifNode(t(this.value,"value",this)))},a.prototype.clone=function(){return new a(this.object,this.index,this.value)},a.prototype._toString=function(t){var e=this.object.toString(t),n=this.index?this.index.toString(t):"",r=this.value.toString(t);return s(this,t&&t.parenthesis)&&(r="("+r+")"),e+n+" = "+r},a.prototype.toJSON=function(){return{mathjs:"AssignmentNode",object:this.object,index:this.index,value:this.value}},a.fromJSON=function(t){return new a(t.object,t.index,t.value)},a.prototype.toHTML=function(t){var e=this.object.toHTML(t),n=this.index?this.index.toHTML(t):"",r=this.value.toHTML(t);return s(this,t&&t.parenthesis)&&(r='<span class="math-paranthesis math-round-parenthesis">(</span>'+r+'<span class="math-paranthesis math-round-parenthesis">)</span>'),e+n+'<span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>'+r},a.prototype._toTex=function(t){var e=this.object.toTex(t),n=this.index?this.index.toTex(t):"",r=this.value.toTex(t);return s(this,t&&t.parenthesis)&&(r="\\left(".concat(r,"\\right)")),e+n+":="+r},a}},{"../../utils/customs":51,"../operators":33,"./Node":24,"./utils/access":31,"./utils/assign":32}],18:[function(s,t,e){"use strict";var u=s("../../utils/array").forEach,p=s("../../utils/array").map;e.name="BlockNode",e.path="expression.node",e.factory=function(r,t,e,n){var o=e(s("./Node")),a=e(s("../../type/resultset/ResultSet"));function i(t){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(!Array.isArray(t))throw new Error("Array expected");this.blocks=t.map(function(t){var e=t&&t.node,n=!t||void 0===t.visible||t.visible;if(!r.isNode(e))throw new TypeError('Property "node" must be a Node');if("boolean"!=typeof n)throw new TypeError('Property "visible" must be a boolean');return{node:e,visible:n}})}return(i.prototype=new o).type="BlockNode",i.prototype.isBlockNode=!0,i.prototype._compile=function(e,n){var t=p(this.blocks,function(t){return{eval:t.node._compile(e,n),visible:t.visible}});return function(n,r,o){var i=[];return u(t,function(t){var e=t.eval(n,r,o);t.visible&&i.push(e)}),new a(i)}},i.prototype.forEach=function(t){for(var e=0;e<this.blocks.length;e++)t(this.blocks[e].node,"blocks["+e+"].node",this)},i.prototype.map=function(t){for(var e=[],n=0;n<this.blocks.length;n++){var r=this.blocks[n],o=this._ifNode(t(r.node,"blocks["+n+"].node",this));e[n]={node:o,visible:r.visible}}return new i(e)},i.prototype.clone=function(){return new i(this.blocks.map(function(t){return{node:t.node,visible:t.visible}}))},i.prototype._toString=function(e){return this.blocks.map(function(t){return t.node.toString(e)+(t.visible?"":";")}).join("\n")},i.prototype.toJSON=function(){return{mathjs:"BlockNode",blocks:this.blocks}},i.fromJSON=function(t){return new i(t.blocks)},i.prototype.toHTML=function(e){return this.blocks.map(function(t){return t.node.toHTML(e)+(t.visible?"":'<span class="math-separator">;</span>')}).join('<span class="math-separator"><br /></span>')},i.prototype._toTex=function(e){return this.blocks.map(function(t){return t.node.toTex(e)+(t.visible?"":";")}).join("\\;\\;\n")},i}},{"../../type/resultset/ResultSet":45,"../../utils/array":46,"./Node":24}],19:[function(i,t,e){"use strict";var p=i("../operators");e.name="ConditionalNode",e.path="expression.node",e.factory=function(a,t,e,n){var r=e(i("./Node")),s=e(i("../../function/utils/typeof"));function o(t,e,n){if(!(this instanceof o))throw new SyntaxError("Constructor must be called with the new operator");if(!a.isNode(t))throw new TypeError("Parameter condition must be a Node");if(!a.isNode(e))throw new TypeError("Parameter trueExpr must be a Node");if(!a.isNode(n))throw new TypeError("Parameter falseExpr must be a Node");this.condition=t,this.trueExpr=e,this.falseExpr=n}return(o.prototype=new r).type="ConditionalNode",o.prototype.isConditionalNode=!0,o.prototype._compile=function(t,e){var r=this.condition._compile(t,e),o=this.trueExpr._compile(t,e),i=this.falseExpr._compile(t,e);return function(t,e,n){return function(t){if("number"==typeof t||"boolean"==typeof t||"string"==typeof t)return!!t;if(t){if(a.isBigNumber(t))return!t.isZero();if(a.isComplex(t))return!(!t.re&&!t.im);if(a.isUnit(t))return!!t.value}if(null!=t)throw new TypeError('Unsupported type of condition "'+s(t)+'"');return!1}(r(t,e,n))?o(t,e,n):i(t,e,n)}},o.prototype.forEach=function(t){t(this.condition,"condition",this),t(this.trueExpr,"trueExpr",this),t(this.falseExpr,"falseExpr",this)},o.prototype.map=function(t){return new o(this._ifNode(t(this.condition,"condition",this)),this._ifNode(t(this.trueExpr,"trueExpr",this)),this._ifNode(t(this.falseExpr,"falseExpr",this)))},o.prototype.clone=function(){return new o(this.condition,this.trueExpr,this.falseExpr)},o.prototype._toString=function(t){var e=t&&t.parenthesis?t.parenthesis:"keep",n=p.getPrecedence(this,e),r=this.condition.toString(t),o=p.getPrecedence(this.condition,e);("all"===e||"OperatorNode"===this.condition.type||null!==o&&o<=n)&&(r="("+r+")");var i=this.trueExpr.toString(t),a=p.getPrecedence(this.trueExpr,e);("all"===e||"OperatorNode"===this.trueExpr.type||null!==a&&a<=n)&&(i="("+i+")");var s=this.falseExpr.toString(t),u=p.getPrecedence(this.falseExpr,e);return("all"===e||"OperatorNode"===this.falseExpr.type||null!==u&&u<=n)&&(s="("+s+")"),r+" ? "+i+" : "+s},o.prototype.toJSON=function(){return{mathjs:"ConditionalNode",condition:this.condition,trueExpr:this.trueExpr,falseExpr:this.falseExpr}},o.fromJSON=function(t){return new o(t.condition,t.trueExpr,t.falseExpr)},o.prototype.toHTML=function(t){var e=t&&t.parenthesis?t.parenthesis:"keep",n=p.getPrecedence(this,e),r=this.condition.toHTML(t),o=p.getPrecedence(this.condition,e);("all"===e||"OperatorNode"===this.condition.type||null!==o&&o<=n)&&(r='<span class="math-parenthesis math-round-parenthesis">(</span>'+r+'<span class="math-parenthesis math-round-parenthesis">)</span>');var i=this.trueExpr.toHTML(t),a=p.getPrecedence(this.trueExpr,e);("all"===e||"OperatorNode"===this.trueExpr.type||null!==a&&a<=n)&&(i='<span class="math-parenthesis math-round-parenthesis">(</span>'+i+'<span class="math-parenthesis math-round-parenthesis">)</span>');var s=this.falseExpr.toHTML(t),u=p.getPrecedence(this.falseExpr,e);return("all"===e||"OperatorNode"===this.falseExpr.type||null!==u&&u<=n)&&(s='<span class="math-parenthesis math-round-parenthesis">(</span>'+s+'<span class="math-parenthesis math-round-parenthesis">)</span>'),r+'<span class="math-operator math-conditional-operator">?</span>'+i+'<span class="math-operator math-conditional-operator">:</span>'+s},o.prototype._toTex=function(t){return"\\begin{cases} {"+this.trueExpr.toTex(t)+"}, &\\quad{\\text{if }\\;"+this.condition.toTex(t)+"}\\\\{"+this.falseExpr.toTex(t)+"}, &\\quad{\\text{otherwise}}\\end{cases}"},o}},{"../../function/utils/typeof":38,"../operators":33,"./Node":24}],20:[function(s,t,e){"use strict";var u=s("../../utils/string").format,p=s("../../utils/latex").escape;e.name="ConstantNode",e.path="expression.node",e.factory=function(t,e,n,r){var o=n(s("./Node")),i=n(s("../../function/utils/typeof"));function a(t){if(!(this instanceof a))throw new SyntaxError("Constructor must be called with the new operator");if(2===arguments.length)throw new SyntaxError("new ConstantNode(valueStr, valueType) is not supported anymore since math v4.0.0. Use new ConstantNode(value) instead, where value is a non-stringified value.");this.value=t}return(a.prototype=new o).type="ConstantNode",a.prototype.isConstantNode=!0,a.prototype._compile=function(t,e){var n=this.value;return function(){return n}},a.prototype.forEach=function(t){},a.prototype.map=function(t){return this.clone()},a.prototype.clone=function(){return new a(this.value)},a.prototype._toString=function(t){return u(this.value,t)},a.prototype.toHTML=function(t){var e=this._toString(t);switch(i(this.value)){case"number":case"BigNumber":case"Fraction":return'<span class="math-number">'+e+"</span>";case"string":return'<span class="math-string">'+e+"</span>";case"boolean":return'<span class="math-boolean">'+e+"</span>";case"null":return'<span class="math-null-symbol">'+e+"</span>";case"undefined":return'<span class="math-undefined">'+e+"</span>";default:return'<span class="math-symbol">'+e+"</span>"}},a.prototype.toJSON=function(){return{mathjs:"ConstantNode",value:this.value}},a.fromJSON=function(t){return new a(t.value)},a.prototype._toTex=function(t){var e=this._toString(t);switch(i(this.value)){case"string":return"\\mathtt{"+p(e)+"}";case"number":case"BigNumber":var n=e.toLowerCase().indexOf("e");return-1!==n?e.substring(0,n)+"\\cdot10^{"+e.substring(n+1)+"}":e;case"Fraction":return this.value.toLatex();default:return e}},a}},{"../../function/utils/typeof":38,"../../utils/latex":53,"../../utils/string":57,"./Node":24}],21:[function(a,t,e){"use strict";var s=a("../keywords"),u=a("../../utils/string").escape,f=a("../../utils/array").forEach,h=a("../../utils/array").join,p=a("../../utils/latex"),l=a("../operators"),m=a("../../utils/customs").setSafeProperty;e.name="FunctionAssignmentNode",e.path="expression.node",e.factory=function(r,t,e,c){var n=e(a("./Node"));function o(t,e,n){if(!(this instanceof o))throw new SyntaxError("Constructor must be called with the new operator");if("string"!=typeof t)throw new TypeError('String expected for parameter "name"');if(!Array.isArray(e))throw new TypeError('Array containing strings or objects expected for parameter "params"');if(!r.isNode(n))throw new TypeError('Node expected for parameter "expr"');if(t in s)throw new Error('Illegal function name, "'+t+'" is a reserved keyword');this.name=t,this.params=e.map(function(t){return t&&t.name||t}),this.types=e.map(function(t){return t&&t.type||"any"}),this.expr=n}function i(t,e){var n=l.getPrecedence(t,e),r=l.getPrecedence(t.expr,e);return"all"===e||null!==r&&r<=n}return(o.prototype=new n).type="FunctionAssignmentNode",o.prototype.isFunctionAssignmentNode=!0,o.prototype._compile=function(t,e){var n=Object.create(e);f(this.params,function(t){n[t]=!0});var i=this.expr._compile(t,n),a=this.name,s=this.params,u=h(this.types,","),p=a+"("+h(this.params,", ")+")";return function(n,r,o){var t={};t[u]=function(){for(var t=Object.create(r),e=0;e<s.length;e++)t[s[e]]=arguments[e];return i(n,t,o)};var e=c(a,t);return e.syntax=p,m(n,a,e),e}},o.prototype.forEach=function(t){t(this.expr,"expr",this)},o.prototype.map=function(t){var e=this._ifNode(t(this.expr,"expr",this));return new o(this.name,this.params.slice(0),e)},o.prototype.clone=function(){return new o(this.name,this.params.slice(0),this.expr)},o.prototype._toString=function(t){var e=t&&t.parenthesis?t.parenthesis:"keep",n=this.expr.toString(t);return i(this,e)&&(n="("+n+")"),this.name+"("+this.params.join(", ")+") = "+n},o.prototype.toJSON=function(){var n=this.types;return{mathjs:"FunctionAssignmentNode",name:this.name,params:this.params.map(function(t,e){return{name:t,type:n[e]}}),expr:this.expr}},o.fromJSON=function(t){return new o(t.name,t.params,t.expr)},o.prototype.toHTML=function(t){for(var e=t&&t.parenthesis?t.parenthesis:"keep",n=[],r=0;r<this.params.length;r++)n.push('<span class="math-symbol math-parameter">'+u(this.params[r])+"</span>");var o=this.expr.toHTML(t);return i(this,e)&&(o='<span class="math-parenthesis math-round-parenthesis">(</span>'+o+'<span class="math-parenthesis math-round-parenthesis">)</span>'),'<span class="math-function">'+u(this.name)+'</span><span class="math-parenthesis math-round-parenthesis">(</span>'+n.join('<span class="math-separator">,</span>')+'<span class="math-parenthesis math-round-parenthesis">)</span><span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>'+o},o.prototype._toTex=function(t){var e=t&&t.parenthesis?t.parenthesis:"keep",n=this.expr.toTex(t);return i(this,e)&&(n="\\left(".concat(n,"\\right)")),"\\mathrm{"+this.name+"}\\left("+this.params.map(p.toSymbol).join(",")+"\\right):="+n},o}},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../keywords":14,"../operators":33,"./Node":24}],22:[function(p,t,e){"use strict";function c(t){return(c="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function v(){return(v=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(t[r]=n[r])}return t}).apply(this,arguments)}var f=p("../../utils/latex"),h=p("../../utils/string").escape,l=p("../../utils/object").hasOwnProperty,b=p("../../utils/array").map,x=p("../../utils/customs").validateSafeMethod,w=p("../../utils/customs").getSafeProperty;e.name="FunctionNode",e.path="expression.node",e.math=!0,e.factory=function(y,t,e,n,o){var r=e(p("./Node")),i=e(p("./SymbolNode"));function g(t,e){if(!(this instanceof g))throw new SyntaxError("Constructor must be called with the new operator");if("string"==typeof t&&(t=new i(t)),!y.isNode(t))throw new TypeError('Node expected as parameter "fn"');if(!Array.isArray(e)||!e.every(y.isNode))throw new TypeError('Array containing Nodes expected for parameter "args"');this.fn=t,this.args=e||[],Object.defineProperty(this,"name",{get:function(){return this.fn.name||""}.bind(this),set:function(){throw new Error("Cannot assign a new name, name is read-only")}});var n=function(){throw new Error("Property `FunctionNode.object` is deprecated, use `FunctionNode.fn` instead")};Object.defineProperty(this,"object",{get:n,set:n})}(g.prototype=new r).type="FunctionNode",g.prototype.isFunctionNode=!0,g.prototype._compile=function(o,e){if(!(this instanceof g))throw new TypeError("No valid FunctionNode");var i=b(this.args,function(t){return t._compile(o,e)});if(y.isSymbolNode(this.fn)){var a=this.fn.name,s=a in o?w(o,a):void 0;if("function"==typeof s&&!0===s.rawArgs){var r=this.args;return function(t,e,n){return(a in t?w(t,a):s)(r,o,v({},t,e))}}if(1===i.length){var u=i[0];return function(t,e,n){return(a in t?w(t,a):s)(u(t,e,n))}}if(2!==i.length)return function(e,n,r){return(a in e?w(e,a):s).apply(null,b(i,function(t){return t(e,n,r)}))};var p=i[0],c=i[1];return function(t,e,n){return(a in t?w(t,a):s)(p(t,e,n),c(t,e,n))}}if(y.isAccessorNode(this.fn)&&y.isIndexNode(this.fn.index)&&this.fn.index.isObjectProperty()){var f=this.fn.object._compile(o,e),h=this.fn.index.getObjectProperty(),l=this.args;return function(e,n,r){var t=f(e,n,r);return x(t,h),t[h]&&t[h].rawArgs?t[h](l,o,v({},e,n)):t[h].apply(t,b(i,function(t){return t(e,n,r)}))}}var m=this.fn._compile(o,e),d=this.args;return function(e,n,r){var t=m(e,n,r);return t&&t.rawArgs?t(d,o,v({},e,n)):t.apply(t,b(i,function(t){return t(e,n,r)}))}},g.prototype.forEach=function(t){for(var e=0;e<this.args.length;e++)t(this.args[e],"args["+e+"]",this)},g.prototype.map=function(t){for(var e=this.fn.map(t),n=[],r=0;r<this.args.length;r++)n[r]=this._ifNode(t(this.args[r],"args["+r+"]",this));return new g(e,n)},g.prototype.clone=function(){return new g(this.fn,this.args.slice(0))};var a=g.prototype.toString;function s(t,e,n){for(var r,o="",i=new RegExp("\\$(?:\\{([a-z_][a-z_0-9]*)(?:\\[([0-9]+)\\])?\\}|\\$)","ig"),a=0;null!==(r=i.exec(t));)if(o+=t.substring(a,r.index),a=r.index,"$$"===r[0])o+="$",a++;else{a+=r[0].length;var s=e[r[1]];if(!s)throw new ReferenceError("Template: Property "+r[1]+" does not exist.");if(void 0===r[2])switch(c(s)){case"string":o+=s;break;case"object":if(y.isNode(s))o+=s.toTex(n);else{if(!Array.isArray(s))throw new TypeError("Template: "+r[1]+" has to be a Node, String or array of Nodes");o+=s.map(function(t,e){if(y.isNode(t))return t.toTex(n);throw new TypeError("Template: "+r[1]+"["+e+"] is not a Node.")}).join(",")}break;default:throw new TypeError("Template: "+r[1]+" has to be a Node, String or array of Nodes")}else{if(!y.isNode(s[r[2]]&&s[r[2]]))throw new TypeError("Template: "+r[1]+"["+r[2]+"] is not a Node.");o+=s[r[2]].toTex(n)}}return o+=t.slice(a)}g.prototype.toString=function(t){var e,n=this.fn.toString(t);return t&&"object"===c(t.handler)&&l(t.handler,n)&&(e=t.handler[n](this,t)),void 0!==e?e:a.call(this,t)},g.prototype._toString=function(e){var t=this.args.map(function(t){return t.toString(e)});return(y.isFunctionAssignmentNode(this.fn)?"("+this.fn.toString(e)+")":this.fn.toString(e))+"("+t.join(", ")+")"},g.prototype.toJSON=function(){return{mathjs:"FunctionNode",fn:this.fn,args:this.args}},g.fromJSON=function(t){return new g(t.fn,t.args)},g.prototype.toHTML=function(e){var t=this.args.map(function(t){return t.toHTML(e)});return'<span class="math-function">'+h(this.fn)+'</span><span class="math-paranthesis math-round-parenthesis">(</span>'+t.join('<span class="math-separator">,</span>')+'<span class="math-paranthesis math-round-parenthesis">)</span>'};var u=g.prototype.toTex;return g.prototype.toTex=function(t){var e;return t&&"object"===c(t.handler)&&l(t.handler,this.name)&&(e=t.handler[this.name](this,t)),void 0!==e?e:u.call(this,t)},g.prototype._toTex=function(e){var t,n,r=this.args.map(function(t){return t.toTex(e)});switch(!o[this.name]||"function"!=typeof o[this.name].toTex&&"object"!==c(o[this.name].toTex)&&"string"!=typeof o[this.name].toTex||(t=o[this.name].toTex),c(t)){case"function":n=t(this,e);break;case"string":n=s(t,this,e);break;case"object":switch(c(t[r.length])){case"function":n=t[r.length](this,e);break;case"string":n=s(t[r.length],this,e)}}return void 0!==n?n:s(f.defaultTemplate,this,e)},g.prototype.getIdentifier=function(){return this.type+":"+this.name},g}},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/object":55,"../../utils/string":57,"./Node":24,"./SymbolNode":30}],23:[function(s,t,e){"use strict";var u=s("../../utils/array").map,p=s("../../utils/string").escape;e.name="IndexNode",e.path="expression.node",e.factory=function(m,t,e,n){var r=e(s("./Node")),o=e(s("../../type/matrix/Range")),i=Array.isArray;function a(t,e){if(!(this instanceof a))throw new SyntaxError("Constructor must be called with the new operator");if(this.dimensions=t,this.dotNotation=e||!1,!i(t)||!t.every(m.isNode))throw new TypeError('Array containing Nodes expected for parameter "dimensions"');if(this.dotNotation&&!this.isObjectProperty())throw new Error("dotNotation only applicable for object properties");var n=function(){throw new Error("Property `IndexNode.object` is deprecated, use `IndexNode.fn` instead")};Object.defineProperty(this,"object",{get:n,set:n})}function d(t,e,n){return new o(m.isBigNumber(t)?t.toNumber():t,m.isBigNumber(e)?e.toNumber():e,m.isBigNumber(n)?n.toNumber():n)}return(a.prototype=new r).type="IndexNode",a.prototype.isIndexNode=!0,a.prototype._compile=function(h,l){var o=u(this.dimensions,function(t,i){if(m.isRangeNode(t)){if(t.needsEnd()){var e=Object.create(l);e.end=!0;var a=t.start._compile(h,e),s=t.end._compile(h,e),u=t.step?t.step._compile(h,e):function(){return 1};return function(t,e,n){var r=h.size(n).valueOf(),o=Object.create(e);return o.end=r[i],d(a(t,o,n),s(t,o,n),u(t,o,n))}}var r=t.start._compile(h,l),o=t.end._compile(h,l),p=t.step?t.step._compile(h,l):function(){return 1};return function(t,e,n){return d(r(t,e,n),o(t,e,n),p(t,e,n))}}if(m.isSymbolNode(t)&&"end"===t.name){var n=Object.create(l);n.end=!0;var c=t._compile(h,n);return function(t,e,n){var r=h.size(n).valueOf(),o=Object.create(e);return o.end=r[i],c(t,o,n)}}var f=t._compile(h,l);return function(t,e,n){return f(t,e,n)}});return function(e,n,r){var t=u(o,function(t){return t(e,n,r)});return h.index.apply(h,t)}},a.prototype.forEach=function(t){for(var e=0;e<this.dimensions.length;e++)t(this.dimensions[e],"dimensions["+e+"]",this)},a.prototype.map=function(t){for(var e=[],n=0;n<this.dimensions.length;n++)e[n]=this._ifNode(t(this.dimensions[n],"dimensions["+n+"]",this));return new a(e)},a.prototype.clone=function(){return new a(this.dimensions.slice(0))},a.prototype.isObjectProperty=function(){return 1===this.dimensions.length&&m.isConstantNode(this.dimensions[0])&&"string"==typeof this.dimensions[0].value},a.prototype.getObjectProperty=function(){return this.isObjectProperty()?this.dimensions[0].value:null},a.prototype._toString=function(t){return this.dotNotation?"."+this.getObjectProperty():"["+this.dimensions.join(", ")+"]"},a.prototype.toJSON=function(){return{mathjs:"IndexNode",dimensions:this.dimensions,dotNotation:this.dotNotation}},a.fromJSON=function(t){return new a(t.dimensions,t.dotNotation)},a.prototype.toHTML=function(t){for(var e=[],n=0;n<this.dimensions.length;n++)e[n]=this.dimensions[n].toHTML();return this.dotNotation?'<span class="math-operator math-accessor-operator">.</span><span class="math-symbol math-property">'+p(this.getObjectProperty())+"</span>":'<span class="math-parenthesis math-square-parenthesis">[</span>'+e.join('<span class="math-separator">,</span>')+'<span class="math-parenthesis math-square-parenthesis">]</span>'},a.prototype._toTex=function(e){var t=this.dimensions.map(function(t){return t.toTex(e)});return this.dotNotation?"."+this.getObjectProperty():"_{"+t.join(",")+"}"},a}},{"../../type/matrix/Range":41,"../../utils/array":46,"../../utils/string":57,"./Node":24}],24:[function(t,e,n){"use strict";function a(t){return(a="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var s=t("../keywords"),u=t("../../utils/object").deepEqual,p=t("../../utils/object").hasOwnProperty;n.name="Node",n.path="expression.node",n.math=!0,n.factory=function(e,t,n,r,o){function i(){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator")}return i.prototype.eval=function(t){return this.compile().eval(t)},i.prototype.type="Node",i.prototype.isNode=!0,i.prototype.comment="",i.prototype.compile=function(){var n=this._compile(o.expression.mathWithTransform,{}),r={};return{eval:function(t){var e=t||{};return function(t){for(var e in t)if(p(t,e)&&e in s)throw new Error('Scope contains an illegal symbol, "'+e+'" is a reserved keyword')}(e),n(e,r,null)}}},i.prototype._compile=function(t,e){throw new Error("Method _compile should be implemented by type "+this.type)},i.prototype.forEach=function(t){throw new Error("Cannot run forEach on a Node interface")},i.prototype.map=function(t){throw new Error("Cannot run map on a Node interface")},i.prototype._ifNode=function(t){if(!e.isNode(t))throw new TypeError("Callback function must return a Node");return t},i.prototype.traverse=function(t){t(this,null,null),function r(t,o){t.forEach(function(t,e,n){o(t,e,n),r(t,o)})}(this,t)},i.prototype.transform=function(t){return function r(t,o){return t.map(function(t,e,n){return r(o(t,e,n),o)})}(t(this,null,null),t)},i.prototype.filter=function(r){var o=[];return this.traverse(function(t,e,n){r(t,e,n)&&o.push(t)}),o},i.prototype.find=function(){throw new Error("Function Node.find is deprecated. Use Node.filter instead.")},i.prototype.match=function(){throw new Error("Function Node.match is deprecated. See functions Node.filter, Node.transform, Node.traverse.")},i.prototype.clone=function(){throw new Error("Cannot clone a Node interface")},i.prototype.cloneDeep=function(){return this.map(function(t){return t.cloneDeep()})},i.prototype.equals=function(t){return!!t&&u(this,t)},i.prototype.toString=function(t){var e;if(t&&"object"===a(t))switch(a(t.handler)){case"object":case"undefined":break;case"function":e=t.handler(this,t);break;default:throw new TypeError("Object or function expected as callback")}return void 0!==e?e:this._toString(t)},i.prototype.toJSON=function(){throw new Error("Cannot serialize object: toJSON not implemented by "+this.type)},i.prototype.toHTML=function(t){var e;if(t&&"object"===a(t))switch(a(t.handler)){case"object":case"undefined":break;case"function":e=t.handler(this,t);break;default:throw new TypeError("Object or function expected as callback")}return void 0!==e?e:this.toHTML(t)},i.prototype._toString=function(){throw new Error("_toString not implemented for "+this.type)},i.prototype.toTex=function(t){var e;if(t&&"object"===a(t))switch(a(t.handler)){case"object":case"undefined":break;case"function":e=t.handler(this,t);break;default:throw new TypeError("Object or function expected as callback")}return void 0!==e?e:this._toTex(t)},i.prototype._toTex=function(t){throw new Error("_toTex not implemented for "+this.type)},i.prototype.getIdentifier=function(){return this.type},i.prototype.getContent=function(){return this},i}},{"../../utils/object":55,"../keywords":14}],25:[function(a,t,e){"use strict";function s(t){return(s="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var u=a("../../utils/string").stringify,p=a("../../utils/string").escape,c=a("../../utils/customs").isSafeProperty,f=a("../../utils/object").hasOwnProperty;e.name="ObjectNode",e.path="expression.node",e.factory=function(n,t,e,r){var o=e(a("./Node"));function i(e){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(this.properties=e||{},e&&("object"!==s(e)||!Object.keys(e).every(function(t){return n.isNode(e[t])})))throw new TypeError("Object containing Nodes expected")}return(i.prototype=new o).type="ObjectNode",i.prototype.isObjectNode=!0,i.prototype._compile=function(t,e){var i={};for(var n in this.properties)if(f(this.properties,n)){var r=u(n),o=JSON.parse(r);if(!c(this.properties,o))throw new Error('No access to property "'+o+'"');i[o]=this.properties[n]._compile(t,e)}return function(t,e,n){var r={};for(var o in i)f(i,o)&&(r[o]=i[o](t,e,n));return r}},i.prototype.forEach=function(t){for(var e in this.properties)this.properties.hasOwnProperty(e)&&t(this.properties[e],"properties["+u(e)+"]",this)},i.prototype.map=function(t){var e={};for(var n in this.properties)this.properties.hasOwnProperty(n)&&(e[n]=this._ifNode(t(this.properties[n],"properties["+u(n)+"]",this)));return new i(e)},i.prototype.clone=function(){var t={};for(var e in this.properties)this.properties.hasOwnProperty(e)&&(t[e]=this.properties[e]);return new i(t)},i.prototype._toString=function(t){var e=[];for(var n in this.properties)this.properties.hasOwnProperty(n)&&e.push(u(n)+": "+this.properties[n].toString(t));return"{"+e.join(", ")+"}"},i.prototype.toJSON=function(){return{mathjs:"ObjectNode",properties:this.properties}},i.fromJSON=function(t){return new i(t.properties)},i.prototype.toHTML=function(t){var e=[];for(var n in this.properties)this.properties.hasOwnProperty(n)&&e.push('<span class="math-symbol math-property">'+p(n)+'</span><span class="math-operator math-assignment-operator math-property-assignment-operator math-binary-operator">:</span>'+this.properties[n].toHTML(t));return'<span class="math-parenthesis math-curly-parenthesis">{</span>'+e.join('<span class="math-separator">,</span>')+'<span class="math-parenthesis math-curly-parenthesis">}</span>'},i.prototype._toTex=function(t){var e=[];for(var n in this.properties)this.properties.hasOwnProperty(n)&&e.push("\\mathbf{"+n+":} & "+this.properties[n].toTex(t)+"\\\\");return"\\left\\{\\begin{array}{ll}".concat(e.join("\n"),"\\end{array}\\right\\}")},i}},{"../../utils/customs":51,"../../utils/object":55,"../../utils/string":57,"./Node":24}],26:[function(a,t,e){"use strict";var m=a("../../utils/latex"),s=a("../../utils/array").map,c=a("../../utils/string").escape,u=a("../../utils/customs").isSafeMethod,p=a("../../utils/customs").getSafeProperty,x=a("../operators");e.name="OperatorNode",e.path="expression.node",e.factory=function(o,t,e,n){var r=e(a("./Node"));function i(t,e,n,r){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if("string"!=typeof t)throw new TypeError('string expected for parameter "op"');if("string"!=typeof e)throw new TypeError('string expected for parameter "fn"');if(!Array.isArray(n)||!n.every(o.isNode))throw new TypeError('Array containing Nodes expected for parameter "args"');this.implicit=!0===r,this.op=t,this.fn=e,this.args=n||[]}function l(o,i,t,e,n){var r,a=x.getPrecedence(o,i),s=x.getAssociativity(o,i);if("all"===i||2<e.length&&"OperatorNode:add"!==o.getIdentifier()&&"OperatorNode:multiply"!==o.getIdentifier())return e.map(function(t){switch(t.getContent().type){case"ArrayNode":case"ConstantNode":case"SymbolNode":case"ParenthesisNode":return!1;default:return!0}});switch(e.length){case 0:r=[];break;case 1:var u=x.getPrecedence(e[0],i);if(n&&null!==u){var p,c;if(c="keep"===i?(p=e[0].getIdentifier(),o.getIdentifier()):(p=e[0].getContent().getIdentifier(),o.getContent().getIdentifier()),!1===x.properties[a][c].latexLeftParens){r=[!1];break}if(!1===x.properties[u][p].latexParens){r=[!1];break}}if(null===u){r=[!1];break}if(u<=a){r=[!0];break}r=[!1];break;case 2:var f,h,l=x.getPrecedence(e[0],i),m=x.isAssociativeWith(o,e[0],i);f=null!==l&&(l===a&&"right"===s&&!m||l<a);var d,y,g,v=x.getPrecedence(e[1],i),b=x.isAssociativeWith(o,e[1],i);h=null!==v&&(v===a&&"left"===s&&!b||v<a),n&&(g="keep"===i?(d=o.getIdentifier(),y=o.args[0].getIdentifier(),o.args[1].getIdentifier()):(d=o.getContent().getIdentifier(),y=o.args[0].getContent().getIdentifier(),o.args[1].getContent().getIdentifier()),null!==l&&(!1===x.properties[a][d].latexLeftParens&&(f=!1),!1===x.properties[l][y].latexParens&&(f=!1)),null!==v&&(!1===x.properties[a][d].latexRightParens&&(h=!1),!1===x.properties[v][g].latexParens&&(h=!1))),r=[f,h];break;default:"OperatorNode:add"!==o.getIdentifier()&&"OperatorNode:multiply"!==o.getIdentifier()||(r=e.map(function(t){var e=x.getPrecedence(t,i),n=x.isAssociativeWith(o,t,i),r=x.getAssociativity(t,i);return null!==e&&(a===e&&s===r&&!n||e<a)}))}return 2<=e.length&&"OperatorNode:multiply"===o.getIdentifier()&&o.implicit&&"auto"===i&&"hide"===t&&(r=e.map(function(t,e){var n="ParenthesisNode"===t.getIdentifier();return!(!r[e]&&!n)})),r}return(i.prototype=new r).type="OperatorNode",i.prototype.isOperatorNode=!0,i.prototype._compile=function(e,n){if("string"!=typeof this.fn||!u(e,this.fn))throw e[this.fn]?new Error('No access to function "'+this.fn+'"'):new Error("Function "+this.fn+' missing in provided namespace "math"');var o=p(e,this.fn),t=s(this.args,function(t){return t._compile(e,n)});if(1===t.length){var r=t[0];return function(t,e,n){return o(r(t,e,n))}}if(2!==t.length)return function(e,n,r){return o.apply(null,s(t,function(t){return t(e,n,r)}))};var i=t[0],a=t[1];return function(t,e,n){return o(i(t,e,n),a(t,e,n))}},i.prototype.forEach=function(t){for(var e=0;e<this.args.length;e++)t(this.args[e],"args["+e+"]",this)},i.prototype.map=function(t){for(var e=[],n=0;n<this.args.length;n++)e[n]=this._ifNode(t(this.args[n],"args["+n+"]",this));return new i(this.op,this.fn,e,this.implicit)},i.prototype.clone=function(){return new i(this.op,this.fn,this.args.slice(0),this.implicit)},i.prototype.isUnary=function(){return 1===this.args.length},i.prototype.isBinary=function(){return 2===this.args.length},i.prototype._toString=function(n){var t=n&&n.parenthesis?n.parenthesis:"keep",e=n&&n.implicit?n.implicit:"hide",r=this.args,o=l(this,t,e,r,!1);if(1===r.length){var i=x.getAssociativity(this,t),a=r[0].toString(n);return o[0]&&(a="("+a+")"),"right"===i?this.op+a:a+this.op}if(2===r.length){var s=r[0].toString(n),u=r[1].toString(n);return o[0]&&(s="("+s+")"),o[1]&&(u="("+u+")"),this.implicit&&"OperatorNode:multiply"===this.getIdentifier()&&"hide"===e?s+" "+u:s+" "+this.op+" "+u}if(2<r.length&&("OperatorNode:add"===this.getIdentifier()||"OperatorNode:multiply"===this.getIdentifier())){var p=r.map(function(t,e){return t=t.toString(n),o[e]&&(t="("+t+")"),t});return this.implicit&&"OperatorNode:multiply"===this.getIdentifier()&&"hide"===e?p.join(" "):p.join(" "+this.op+" ")}return this.fn+"("+this.args.join(", ")+")"},i.prototype.toJSON=function(){return{mathjs:"OperatorNode",op:this.op,fn:this.fn,args:this.args,implicit:this.implicit}},i.fromJSON=function(t){return new i(t.op,t.fn,t.args,t.implicit)},i.prototype.toHTML=function(n){var t=n&&n.parenthesis?n.parenthesis:"keep",e=n&&n.implicit?n.implicit:"hide",r=this.args,o=l(this,t,e,r,!1);if(1===r.length){var i=x.getAssociativity(this,t),a=r[0].toHTML(n);return o[0]&&(a='<span class="math-parenthesis math-round-parenthesis">(</span>'+a+'<span class="math-parenthesis math-round-parenthesis">)</span>'),"right"===i?'<span class="math-operator math-unary-operator math-lefthand-unary-operator">'+c(this.op)+"</span>"+a:'<span class="math-operator math-unary-operator math-righthand-unary-operator">'+c(this.op)+"</span>"+a}if(2===r.length){var s=r[0].toHTML(n),u=r[1].toHTML(n);return o[0]&&(s='<span class="math-parenthesis math-round-parenthesis">(</span>'+s+'<span class="math-parenthesis math-round-parenthesis">)</span>'),o[1]&&(u='<span class="math-parenthesis math-round-parenthesis">(</span>'+u+'<span class="math-parenthesis math-round-parenthesis">)</span>'),this.implicit&&"OperatorNode:multiply"===this.getIdentifier()&&"hide"===e?s+'<span class="math-operator math-binary-operator math-implicit-binary-operator"></span>'+u:s+'<span class="math-operator math-binary-operator math-explicit-binary-operator">'+c(this.op)+"</span>"+u}var p=r.map(function(t,e){return t=t.toHTML(n),o[e]&&(t='<span class="math-parenthesis math-round-parenthesis">(</span>'+t+'<span class="math-parenthesis math-round-parenthesis">)</span>'),t});return 2<r.length&&("OperatorNode:add"===this.getIdentifier()||"OperatorNode:multiply"===this.getIdentifier())?this.implicit&&"OperatorNode:multiply"===this.getIdentifier()&&"hide"===e?p.join('<span class="math-operator math-binary-operator math-implicit-binary-operator"></span>'):p.join('<span class="math-operator math-binary-operator math-explicit-binary-operator">'+c(this.op)+"</span>"):'<span class="math-function">'+c(this.fn)+'</span><span class="math-paranthesis math-round-parenthesis">(</span>'+p.join('<span class="math-separator">,</span>')+'<span class="math-paranthesis math-round-parenthesis">)</span>'},i.prototype._toTex=function(n){var t=n&&n.parenthesis?n.parenthesis:"keep",e=n&&n.implicit?n.implicit:"hide",r=this.args,o=l(this,t,e,r,!0),i=m.operators[this.fn];if(i=void 0===i?this.op:i,1===r.length){var a=x.getAssociativity(this,t),s=r[0].toTex(n);return o[0]&&(s="\\left(".concat(s,"\\right)")),"right"===a?i+s:s+i}if(2===r.length){var u=r[0],p=u.toTex(n);o[0]&&(p="\\left(".concat(p,"\\right)"));var c,f=r[1].toTex(n);switch(o[1]&&(f="\\left(".concat(f,"\\right)")),c="keep"===t?u.getIdentifier():u.getContent().getIdentifier(),this.getIdentifier()){case"OperatorNode:divide":return i+"{"+p+"}{"+f+"}";case"OperatorNode:pow":switch(p="{"+p+"}",f="{"+f+"}",c){case"ConditionalNode":case"OperatorNode:divide":p="\\left(".concat(p,"\\right)")}break;case"OperatorNode:multiply":if(this.implicit&&"hide"===e)return p+"~"+f}return p+i+f}if(2<r.length&&("OperatorNode:add"===this.getIdentifier()||"OperatorNode:multiply"===this.getIdentifier())){var h=r.map(function(t,e){return t=t.toTex(n),o[e]&&(t="\\left(".concat(t,"\\right)")),t});return"OperatorNode:multiply"===this.getIdentifier()&&this.implicit?h.join("~"):h.join(i)}return"\\mathrm{"+this.fn+"}\\left("+r.map(function(t){return t.toTex(n)}).join(",")+"\\right)"},i.prototype.getIdentifier=function(){return this.type+":"+this.fn},i}},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../operators":33,"./Node":24}],27:[function(a,t,e){"use strict";e.name="ParenthesisNode",e.path="expression.node",e.factory=function(e,t,n,r){var o=n(a("./Node"));function i(t){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(!e.isNode(t))throw new TypeError('Node expected for parameter "content"');this.content=t}return(i.prototype=new o).type="ParenthesisNode",i.prototype.isParenthesisNode=!0,i.prototype._compile=function(t,e){return this.content._compile(t,e)},i.prototype.getContent=function(){return this.content.getContent()},i.prototype.forEach=function(t){t(this.content,"content",this)},i.prototype.map=function(t){return new i(t(this.content,"content",this))},i.prototype.clone=function(){return new i(this.content)},i.prototype._toString=function(t){return!t||t&&!t.parenthesis||t&&"keep"===t.parenthesis?"("+this.content.toString(t)+")":this.content.toString(t)},i.prototype.toJSON=function(){return{mathjs:"ParenthesisNode",content:this.content}},i.fromJSON=function(t){return new i(t.content)},i.prototype.toHTML=function(t){return!t||t&&!t.parenthesis||t&&"keep"===t.parenthesis?'<span class="math-parenthesis math-round-parenthesis">(</span>'+this.content.toHTML(t)+'<span class="math-parenthesis math-round-parenthesis">)</span>':this.content.toHTML(t)},i.prototype._toTex=function(t){return!t||t&&!t.parenthesis||t&&"keep"===t.parenthesis?"\\left(".concat(this.content.toTex(t),"\\right)"):this.content.toTex(t)},i}},{"./Node":24}],28:[function(s,t,e){"use strict";var u=s("../operators");e.name="RangeNode",e.path="expression.node",e.factory=function(r,t,e,n){var o=e(s("./Node"));function i(t,e,n){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(!r.isNode(t))throw new TypeError("Node expected");if(!r.isNode(e))throw new TypeError("Node expected");if(n&&!r.isNode(n))throw new TypeError("Node expected");if(3<arguments.length)throw new Error("Too many arguments");this.start=t,this.end=e,this.step=n||null}function a(t,e){var n=u.getPrecedence(t,e),r={},o=u.getPrecedence(t.start,e);if(r.start=null!==o&&o<=n||"all"===e,t.step){var i=u.getPrecedence(t.step,e);r.step=null!==i&&i<=n||"all"===e}var a=u.getPrecedence(t.end,e);return r.end=null!==a&&a<=n||"all"===e,r}return(i.prototype=new o).type="RangeNode",i.prototype.isRangeNode=!0,i.prototype.needsEnd=function(){return 0<this.filter(function(t){return r.isSymbolNode(t)&&"end"===t.name}).length},i.prototype._compile=function(t,e){var r=t.range,o=this.start._compile(t,e),i=this.end._compile(t,e);if(this.step){var a=this.step._compile(t,e);return function(t,e,n){return r(o(t,e,n),i(t,e,n),a(t,e,n))}}return function(t,e,n){return r(o(t,e,n),i(t,e,n))}},i.prototype.forEach=function(t){t(this.start,"start",this),t(this.end,"end",this),this.step&&t(this.step,"step",this)},i.prototype.map=function(t){return new i(this._ifNode(t(this.start,"start",this)),this._ifNode(t(this.end,"end",this)),this.step&&this._ifNode(t(this.step,"step",this)))},i.prototype.clone=function(){return new i(this.start,this.end,this.step&&this.step)},i.prototype._toString=function(t){var e,n=a(this,t&&t.parenthesis?t.parenthesis:"keep"),r=this.start.toString(t);if(n.start&&(r="("+r+")"),e=r,this.step){var o=this.step.toString(t);n.step&&(o="("+o+")"),e+=":"+o}var i=this.end.toString(t);return n.end&&(i="("+i+")"),e+=":"+i},i.prototype.toJSON=function(){return{mathjs:"RangeNode",start:this.start,end:this.end,step:this.step}},i.fromJSON=function(t){return new i(t.start,t.end,t.step)},i.prototype.toHTML=function(t){var e,n=a(this,t&&t.parenthesis?t.parenthesis:"keep"),r=this.start.toHTML(t);if(n.start&&(r='<span class="math-parenthesis math-round-parenthesis">(</span>'+r+'<span class="math-parenthesis math-round-parenthesis">)</span>'),e=r,this.step){var o=this.step.toHTML(t);n.step&&(o='<span class="math-parenthesis math-round-parenthesis">(</span>'+o+'<span class="math-parenthesis math-round-parenthesis">)</span>'),e+='<span class="math-operator math-range-operator">:</span>'+o}var i=this.end.toHTML(t);return n.end&&(i='<span class="math-parenthesis math-round-parenthesis">(</span>'+i+'<span class="math-parenthesis math-round-parenthesis">)</span>'),e+='<span class="math-operator math-range-operator">:</span>'+i},i.prototype._toTex=function(t){var e=a(this,t&&t.parenthesis?t.parenthesis:"keep"),n=this.start.toTex(t);if(e.start&&(n="\\left(".concat(n,"\\right)")),this.step){var r=this.step.toTex(t);e.step&&(r="\\left(".concat(r,"\\right)")),n+=":"+r}var o=this.end.toTex(t);return e.end&&(o="\\left(".concat(o,"\\right)")),n+=":"+o},i}},{"../operators":33,"./Node":24}],29:[function(a,t,e){"use strict";var s=a("../operators"),u=a("../../utils/latex"),c=a("../../utils/string").escape;e.name="RelationalNode",e.path="expression.node",e.factory=function(t,e,n,r){var o=n(a("./Node")),p=a("../../utils/customs").getSafeProperty;function i(t,e){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if(!Array.isArray(t))throw new TypeError("Parameter conditionals must be an array");if(!Array.isArray(e))throw new TypeError("Parameter params must be an array");if(t.length!==e.length-1)throw new TypeError("Parameter params must contain exactly one more element than parameter conditionals");this.conditionals=t,this.params=e}return(i.prototype=new o).type="RelationalNode",i.prototype.isRelationalNode=!0,i.prototype._compile=function(a,e){var s=this,u=this.params.map(function(t){return t._compile(a,e)});return function(t,e,n){for(var r,o=u[0](t,e,n),i=0;i<s.conditionals.length;i++)if(r=o,o=u[i+1](t,e,n),!p(a,s.conditionals[i])(r,o))return!1;return!0}},i.prototype.forEach=function(n){var r=this;this.params.forEach(function(t,e){return n(t,"params["+e+"]",r)},this)},i.prototype.map=function(n){var r=this;return new i(this.conditionals.slice(),this.params.map(function(t,e){return r._ifNode(n(t,"params["+e+"]",r))},this))},i.prototype.clone=function(){return new i(this.conditionals,this.params)},i.prototype._toString=function(r){for(var o=r&&r.parenthesis?r.parenthesis:"keep",i=s.getPrecedence(this,o),t=this.params.map(function(t,e){var n=s.getPrecedence(t,o);return"all"===o||null!==n&&n<=i?"("+t.toString(r)+")":t.toString(r)}),e={equal:"==",unequal:"!=",smaller:"<",larger:">",smallerEq:"<=",largerEq:">="},n=t[0],a=0;a<this.conditionals.length;a++)n+=" "+e[this.conditionals[a]]+" "+t[a+1];return n},i.prototype.toJSON=function(){return{mathjs:"RelationalNode",conditionals:this.conditionals,params:this.params}},i.fromJSON=function(t){return new i(t.conditionals,t.params)},i.prototype.toHTML=function(r){for(var o=r&&r.parenthesis?r.parenthesis:"keep",i=s.getPrecedence(this,o),t=this.params.map(function(t,e){var n=s.getPrecedence(t,o);return"all"===o||null!==n&&n<=i?'<span class="math-parenthesis math-round-parenthesis">(</span>'+t.toHTML(r)+'<span class="math-parenthesis math-round-parenthesis">)</span>':t.toHTML(r)}),e={equal:"==",unequal:"!=",smaller:"<",larger:">",smallerEq:"<=",largerEq:">="},n=t[0],a=0;a<this.conditionals.length;a++)n+='<span class="math-operator math-binary-operator math-explicit-binary-operator">'+c(e[this.conditionals[a]])+"</span>"+t[a+1];return n},i.prototype._toTex=function(r){for(var o=r&&r.parenthesis?r.parenthesis:"keep",i=s.getPrecedence(this,o),t=this.params.map(function(t,e){var n=s.getPrecedence(t,o);return"all"===o||null!==n&&n<=i?"\\left("+t.toString(r)+"\right)":t.toString(r)}),e=t[0],n=0;n<this.conditionals.length;n++)e+=u.operators[this.conditionals[n]]+t[n+1];return e},i}},{"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../operators":33,"./Node":24}],30:[function(u,t,e){"use strict";var p=u("../../utils/latex"),c=u("../../utils/string").escape,f=u("../../utils/object").hasOwnProperty,h=u("../../utils/customs").getSafeProperty;e.name="SymbolNode",e.path="expression.node",e.math=!0,e.factory=function(a,t,e,n,r){var o=e(u("./Node"));function s(t){return!!a.Unit&&a.Unit.isValuelessUnit(t)}function i(t){if(!(this instanceof i))throw new SyntaxError("Constructor must be called with the new operator");if("string"!=typeof t)throw new TypeError('String expected for parameter "name"');this.name=t}return(i.prototype=new o).type="SymbolNode",i.prototype.isSymbolNode=!0,i.prototype._compile=function(r,t){var o=this.name;if(f(t,o))return function(t,e,n){return e[o]};if(o in r)return function(t,e,n){return h(o in t?t:r,o)};var i=s(o);return function(t,e,n){return o in t?h(t,o):i?new a.Unit(null,o):function(t){throw new Error("Undefined symbol "+t)}(o)}},i.prototype.forEach=function(t){},i.prototype.map=function(t){return this.clone()},i.prototype.clone=function(){return new i(this.name)},i.prototype._toString=function(t){return this.name},i.prototype.toHTML=function(t){var e=c(this.name);return"true"===e||"false"===e?'<span class="math-symbol math-boolean">'+e+"</span>":"i"===e?'<span class="math-symbol math-imaginary-symbol">'+e+"</span>":"Infinity"===e?'<span class="math-symbol math-infinity-symbol">'+e+"</span>":"NaN"===e?'<span class="math-symbol math-nan-symbol">'+e+"</span>":"null"===e?'<span class="math-symbol math-null-symbol">'+e+"</span>":"undefined"===e?'<span class="math-symbol math-undefined-symbol">'+e+"</span>":'<span class="math-symbol">'+e+"</span>"},i.prototype.toJSON=function(){return{mathjs:"SymbolNode",name:this.name}},i.fromJSON=function(t){return new i(t.name)},i.prototype._toTex=function(t){var e=!1;void 0===r[this.name]&&s(this.name)&&(e=!0);var n=p.toSymbol(this.name,e);return"\\"===n[0]?n:" "+n},i}},{"../../utils/customs":51,"../../utils/latex":53,"../../utils/object":55,"../../utils/string":57,"./Node":24}],31:[function(i,t,e){"use strict";function a(t){return(a="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var s=i("../../transform/error.transform").transform,u=i("../../../utils/customs").getSafeProperty;e.factory=function(t,e,n,r){var o=n(i("../../../function/matrix/subset"));return function(t,e){try{if(Array.isArray(t))return o(t,e);if(t&&"function"==typeof t.subset)return t.subset(e);if("string"==typeof t)return o(t,e);if("object"!==a(t))throw new TypeError("Cannot apply index: unsupported type of object");if(!e.isObjectProperty())throw new TypeError("Cannot apply a numeric index as object property");return u(t,e.getObjectProperty())}catch(t){throw s(t)}}}},{"../../../function/matrix/subset":36,"../../../utils/customs":51,"../../transform/error.transform":35}],32:[function(a,t,e){"use strict";function s(t){return(s="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var u=a("../../transform/error.transform").transform,p=a("../../../utils/customs").setSafeProperty;e.factory=function(t,e,n,r){var o=n(a("../../../function/matrix/subset")),i=n(a("../../../type/matrix/function/matrix"));return function(t,e,n){try{if(Array.isArray(t))return i(t).subset(e,n).valueOf();if(t&&"function"==typeof t.subset)return t.subset(e,n);if("string"==typeof t)return o(t,e,n);if("object"!==s(t))throw new TypeError("Cannot apply index: unsupported type of object");if(!e.isObjectProperty())throw TypeError("Cannot apply a numeric index as object property");return p(t,e.getObjectProperty(),n),t}catch(t){throw u(t)}}}},{"../../../function/matrix/subset":36,"../../../type/matrix/function/matrix":42,"../../../utils/customs":51,"../../transform/error.transform":35}],33:[function(t,e,n){"use strict";var c=[{AssignmentNode:{},FunctionAssignmentNode:{}},{ConditionalNode:{latexLeftParens:!1,latexRightParens:!1,latexParens:!1}},{"OperatorNode:or":{associativity:"left",associativeWith:[]}},{"OperatorNode:xor":{associativity:"left",associativeWith:[]}},{"OperatorNode:and":{associativity:"left",associativeWith:[]}},{"OperatorNode:bitOr":{associativity:"left",associativeWith:[]}},{"OperatorNode:bitXor":{associativity:"left",associativeWith:[]}},{"OperatorNode:bitAnd":{associativity:"left",associativeWith:[]}},{"OperatorNode:equal":{associativity:"left",associativeWith:[]},"OperatorNode:unequal":{associativity:"left",associativeWith:[]},"OperatorNode:smaller":{associativity:"left",associativeWith:[]},"OperatorNode:larger":{associativity:"left",associativeWith:[]},"OperatorNode:smallerEq":{associativity:"left",associativeWith:[]},"OperatorNode:largerEq":{associativity:"left",associativeWith:[]},RelationalNode:{associativity:"left",associativeWith:[]}},{"OperatorNode:leftShift":{associativity:"left",associativeWith:[]},"OperatorNode:rightArithShift":{associativity:"left",associativeWith:[]},"OperatorNode:rightLogShift":{associativity:"left",associativeWith:[]}},{"OperatorNode:to":{associativity:"left",associativeWith:[]}},{RangeNode:{}},{"OperatorNode:add":{associativity:"left",associativeWith:["OperatorNode:add","OperatorNode:subtract"]},"OperatorNode:subtract":{associativity:"left",associativeWith:[]}},{"OperatorNode:multiply":{associativity:"left",associativeWith:["OperatorNode:multiply","OperatorNode:divide","Operator:dotMultiply","Operator:dotDivide"]},"OperatorNode:divide":{associativity:"left",associativeWith:[],latexLeftParens:!1,latexRightParens:!1,latexParens:!1},"OperatorNode:dotMultiply":{associativity:"left",associativeWith:["OperatorNode:multiply","OperatorNode:divide","OperatorNode:dotMultiply","OperatorNode:doDivide"]},"OperatorNode:dotDivide":{associativity:"left",associativeWith:[]},"OperatorNode:mod":{associativity:"left",associativeWith:[]}},{"OperatorNode:unaryPlus":{associativity:"right"},"OperatorNode:unaryMinus":{associativity:"right"},"OperatorNode:bitNot":{associativity:"right"},"OperatorNode:not":{associativity:"right"}},{"OperatorNode:pow":{associativity:"right",associativeWith:[],latexRightParens:!1},"OperatorNode:dotPow":{associativity:"right",associativeWith:[]}},{"OperatorNode:factorial":{associativity:"left"}},{"OperatorNode:transpose":{associativity:"left"}}];function f(t,e){var n=t;"keep"!==e&&(n=t.getContent());for(var r=n.getIdentifier(),o=0;o<c.length;o++)if(r in c[o])return o;return null}e.exports.properties=c,e.exports.getPrecedence=f,e.exports.getAssociativity=function(t,e){var n=t;"keep"!==e&&(n=t.getContent());var r=n.getIdentifier(),o=f(n,e);if(null===o)return null;var i=c[o][r];if(i.hasOwnProperty("associativity")){if("left"===i.associativity)return"left";if("right"===i.associativity)return"right";throw Error("'"+r+"' has the invalid associativity '"+i.associativity+"'.")}return null},e.exports.isAssociativeWith=function(t,e,n){var r="keep"!==n?t.getContent():t,o="keep"!==n?t.getContent():e,i=r.getIdentifier(),a=o.getIdentifier(),s=f(r,n);if(null===s)return null;var u=c[s][i];if(u.hasOwnProperty("associativeWith")&&u.associativeWith instanceof Array){for(var p=0;p<u.associativeWith.length;p++)if(u.associativeWith[p]===a)return!0;return!1}return null}},{}],34:[function(ot,t,e){"use strict";function it(){return(it=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(t[r]=n[r])}return t}).apply(this,arguments)}var at=ot("../error/ArgumentsError"),st=ot("../utils/collection/deepMap");e.name="parse",e.path="expression",e.factory=function(a,h,t,e){var l=t(ot("../type/numeric")),o=t(ot("./node/AccessorNode")),m=t(ot("./node/ArrayNode")),s=t(ot("./node/AssignmentNode")),i=t(ot("./node/BlockNode")),u=t(ot("./node/ConditionalNode")),d=t(ot("./node/ConstantNode")),p=t(ot("./node/FunctionAssignmentNode")),c=t(ot("./node/IndexNode")),y=t(ot("./node/ObjectNode")),f=t(ot("./node/OperatorNode")),g=t(ot("./node/ParenthesisNode")),v=t(ot("./node/FunctionNode")),r=t(ot("./node/RangeNode")),b=t(ot("./node/RelationalNode")),x=t(ot("./node/SymbolNode"));function w(t,e){if(1!==arguments.length&&2!==arguments.length)throw new at("parse",arguments.length,1,2);var n=e&&e.nodes?e.nodes:{};if("string"==typeof t)return D(t,n);if(Array.isArray(t)||t instanceof a.Matrix)return st(t,function(t){if("string"!=typeof t)throw new TypeError("String expected");return D(t,n)});throw new TypeError("String or matrix expected")}var N={NULL:0,DELIMITER:1,NUMBER:2,SYMBOL:3,UNKNOWN:4},E={",":!0,"(":!0,")":!0,"[":!0,"]":!0,"{":!0,"}":!0,'"':!0,"'":!0,";":!0,"+":!0,"-":!0,"*":!0,".*":!0,"/":!0,"./":!0,"%":!0,"^":!0,".^":!0,"~":!0,"!":!0,"&":!0,"|":!0,"^|":!0,"=":!0,":":!0,"?":!0,"==":!0,"!=":!0,"<":!0,">":!0,"<=":!0,">=":!0,"<<":!0,">>":!0,">>>":!0},O={mod:!0,to:!0,in:!0,and:!0,xor:!0,or:!0,not:!0},S={true:!0,false:!1,null:null,undefined:void 0},j=["NaN","Infinity"];function k(t,e){return t.expression.substr(t.index,e)}function T(t){return k(t,1)}function A(t){t.index++}function P(t){return t.expression.charAt(t.index-1)}function M(t){return t.expression.charAt(t.index+1)}function C(t){for(t.tokenType=N.NULL,t.token="",t.comment="";w.isWhitespace(T(t),t.nestingLevel);)A(t);if("#"===T(t))for(;"\n"!==T(t)&&""!==T(t);)t.comment+=T(t),A(t);if(""!==T(t)){if("\n"===T(t)&&!t.nestingLevel)return t.tokenType=N.DELIMITER,t.token=T(t),void A(t);var e=T(t),n=k(t,2),r=k(t,3);if(3===r.length&&E[r])return t.tokenType=N.DELIMITER,t.token=r,A(t),A(t),void A(t);if(2===n.length&&E[n])return t.tokenType=N.DELIMITER,t.token=n,A(t),void A(t);if(E[e])return t.tokenType=N.DELIMITER,t.token=e,void A(t);if(w.isDigitDot(e)){if(t.tokenType=N.NUMBER,"."===T(t))t.token+=T(t),A(t),w.isDigit(T(t))||(t.tokenType=N.DELIMITER);else{for(;w.isDigit(T(t));)t.token+=T(t),A(t);w.isDecimalMark(T(t),M(t))&&(t.token+=T(t),A(t))}for(;w.isDigit(T(t));)t.token+=T(t),A(t);if("E"===T(t)||"e"===T(t))if(w.isDigit(M(t))||"-"===M(t)||"+"===M(t)){if(t.token+=T(t),A(t),"+"!==T(t)&&"-"!==T(t)||(t.token+=T(t),A(t)),!w.isDigit(T(t)))throw nt(t,'Digit expected, got "'+T(t)+'"');for(;w.isDigit(T(t));)t.token+=T(t),A(t);if(w.isDecimalMark(T(t),M(t)))throw nt(t,'Digit expected, got "'+T(t)+'"')}else if("."===M(t))throw A(t),nt(t,'Digit expected, got "'+T(t)+'"')}else{if(!w.isAlpha(T(t),P(t),M(t))){for(t.tokenType=N.UNKNOWN;""!==T(t);)t.token+=T(t),A(t);throw nt(t,'Syntax error in part "'+t.token+'"')}for(;w.isAlpha(T(t),P(t),M(t))||w.isDigit(T(t));)t.token+=T(t),A(t);O.hasOwnProperty(t.token)?t.tokenType=N.DELIMITER:t.tokenType=N.SYMBOL}}else t.tokenType=N.DELIMITER}function I(t){for(;C(t),"\n"===t.token;);}function F(t){t.nestingLevel++}function _(t){t.nestingLevel--}function D(t,e){var n={extraNodes:{},expression:"",comment:"",index:0,token:"",tokenType:N.NULL,nestingLevel:0,conditionalLevel:null};it(n,{expression:t,extraNodes:e}),C(n);var r=function(t){var e,n,r=[];for(""!==t.token&&"\n"!==t.token&&";"!==t.token&&((e=L(t)).comment=t.comment);"\n"===t.token||";"===t.token;)0===r.length&&e&&(n=";"!==t.token,r.push({node:e,visible:n})),C(t),"\n"!==t.token&&";"!==t.token&&""!==t.token&&((e=L(t)).comment=t.comment,n=";"!==t.token,r.push({node:e,visible:n}));return 0<r.length?new i(r):(e||((e=new d(void 0)).comment=t.comment),e)}(n);if(""!==n.token)throw n.tokenType===N.DELIMITER?rt(n,"Unexpected operator "+n.token):nt(n,'Unexpected part "'+n.token+'"');return r}function L(t){var e,n,r,o,i=function(t){for(var e=function(t){for(var e=R(t);"or"===t.token;)I(t),e=new f("or","or",[e,R(t)]);return e}(t);"?"===t.token;){var n=t.conditionalLevel;t.conditionalLevel=t.nestingLevel,I(t);var r=e,o=L(t);if(":"!==t.token)throw nt(t,"False part of conditional expression expected");t.conditionalLevel=null,I(t);var i=L(t);e=new u(r,o,i),t.conditionalLevel=n}return e}(t);if("="!==t.token)return i;if(a.isSymbolNode(i))return e=i.name,I(t),r=L(t),new s(new x(e),r);if(a.isAccessorNode(i))return I(t),r=L(t),new s(i.object,i.index,r);if(a.isFunctionNode(i)&&a.isSymbolNode(i.fn)&&(o=!0,n=[],e=i.name,i.args.forEach(function(t,e){a.isSymbolNode(t)?n[e]=t.name:o=!1}),o))return I(t),r=L(t),new p(e,n,r);throw nt(t,"Invalid left hand side of assignment operator =")}function R(t){for(var e=n(t);"xor"===t.token;)I(t),e=new f("xor","xor",[e,n(t)]);return e}function n(t){for(var e=B(t);"and"===t.token;)I(t),e=new f("and","and",[e,B(t)]);return e}function B(t){for(var e=W(t);"|"===t.token;)I(t),e=new f("|","bitOr",[e,W(t)]);return e}function W(t){for(var e=H(t);"^|"===t.token;)I(t),e=new f("^|","bitXor",[e,H(t)]);return e}function H(t){for(var e=q(t);"&"===t.token;)I(t),e=new f("&","bitAnd",[e,q(t)]);return e}function q(t){for(var e=[U(t)],n=[],r={"==":"equal","!=":"unequal","<":"smaller",">":"larger","<=":"smallerEq",">=":"largerEq"};r.hasOwnProperty(t.token);){var o={name:t.token,fn:r[t.token]};n.push(o),I(t),e.push(U(t))}return 1===e.length?e[0]:2===e.length?new f(n[0].name,n[0].fn,e):new b(n.map(function(t){return t.fn}),e)}function U(t){var e,n,r,o,i;for(e=J(t),n={"<<":"leftShift",">>":"rightArithShift",">>>":"rightLogShift"};n.hasOwnProperty(t.token);)o=n[r=t.token],I(t),i=[e,J(t)],e=new f(r,o,i);return e}function J(t){var e,n,r,o,i;for(e=z(t),n={to:"to",in:"to"};n.hasOwnProperty(t.token);)o=n[r=t.token],I(t),e="in"===r&&""===t.token?new f("*","multiply",[e,new x("in")],!0):(i=[e,z(t)],new f(r,o,i));return e}function z(t){var e,n=[];if(e=":"===t.token?new d(1):$(t),":"===t.token&&t.conditionalLevel!==t.nestingLevel){for(n.push(e);":"===t.token&&n.length<3;)I(t),")"===t.token||"]"===t.token||","===t.token||""===t.token?n.push(new x("end")):n.push($(t));e=3===n.length?new r(n[0],n[2],n[1]):new r(n[0],n[1])}return e}function $(t){var e,n,r,o,i;for(e=V(t),n={"+":"add","-":"subtract"};n.hasOwnProperty(t.token);)o=n[r=t.token],I(t),i=[e,V(t)],e=new f(r,o,i);return e}function V(t){var e,n,r,o,i;for(n=e=X(t),r={"*":"multiply",".*":"dotMultiply","/":"divide","./":"dotDivide","%":"mod",mod:"mod"};r.hasOwnProperty(t.token);)i=r[o=t.token],I(t),n=X(t),e=new f(o,i,[e,n]);return e}function X(t){var e,n;for(n=e=Y(t);t.tokenType===N.SYMBOL||"in"===t.token&&a.isConstantNode(e)||!(t.tokenType!==N.NUMBER||a.isConstantNode(n)||a.isOperatorNode(n)&&"!"!==n.op)||"("===t.token;)n=Y(t),e=new f("*","multiply",[e,n],!0);return e}function Y(t){for(var e=Z(t),n=e,r=[];"/"===t.token&&a.isConstantNode(n);){if(r.push(it({},t)),I(t),t.tokenType!==N.NUMBER){it(t,r.pop());break}if(r.push(it({},t)),I(t),t.tokenType!==N.SYMBOL&&"("!==t.token){r.pop(),it(t,r.pop());break}it(t,r.pop()),r.pop(),n=Z(t),e=new f("/","divide",[e,n])}return e}function Z(t){var e,n,r,o,i,a,s,u,p={"-":"unaryMinus","+":"unaryPlus","~":"bitNot",not:"not"};return p.hasOwnProperty(t.token)?(r=p[t.token],e=t.token,I(t),n=[Z(t)],new f(e,r,n)):(i=function(t){var e,n,r,o;for(e=function(t){var e,n,r,o,i,a,s,u,p,c=[];if(t.tokenType===N.SYMBOL&&t.extraNodes.hasOwnProperty(t.token)){var f=t.extraNodes[t.token];if(C(t),"("===t.token){if(c=[],F(t),C(t),")"!==t.token)for(c.push(L(t));","===t.token;)C(t),c.push(L(t));if(")"!==t.token)throw nt(t,"Parenthesis ) expected");_(t),C(t)}return new f(c)}return(e=t).tokenType===N.SYMBOL||e.tokenType===N.DELIMITER&&e.token in O?(r=e.token,C(e),n=S.hasOwnProperty(r)?new d(S[r]):-1!==j.indexOf(r)?new d(l(r,"number")):new x(r),n=G(e,n)):'"'!==(o=e).token?"'"!==(s=o).token?function(t){var e,n,r,o;if("["!==t.token)return function(t){if("{"!==t.token)return(e=t).tokenType!==N.NUMBER?function(t){var e;if("("!==t.token)return function(t){throw""===t.token?nt(t,"Unexpected end of expression"):nt(t,"Value expected")}(t);if(F(t),C(t),e=L(t),")"===t.token)return _(t),C(t),e=new g(e),e=G(t,e);throw nt(t,"Parenthesis ) expected")}(e):(n=e.token,C(e),new d(l(n,h.number)));var e,n,r,o={};do{if(C(t),"}"!==t.token){if('"'===t.token)r=K(t);else if("'"===t.token)r=Q(t);else{if(t.tokenType!==N.SYMBOL)throw nt(t,"Symbol or string expected as object key");r=t.token,C(t)}if(":"!==t.token)throw nt(t,"Colon : expected after object key");C(t),o[r]=L(t)}}while(","===t.token);if("}"!==t.token)throw nt(t,"Comma , or bracket } expected after object value");C(t);var i=new y(o);return i=G(t,i)}(t);if(F(t),C(t),"]"!==t.token){var i=tt(t);if(";"===t.token){for(r=1,n=[i];";"===t.token;)C(t),n[r]=tt(t),r++;if("]"!==t.token)throw nt(t,"End of matrix ] expected");_(t),C(t),o=n[0].items.length;for(var a=1;a<r;a++)if(n[a].items.length!==o)throw rt(t,"Column dimensions mismatch ("+n[a].items.length+" !== "+o+")");e=new m(n)}else{if("]"!==t.token)throw nt(t,"End of matrix ] expected");_(t),C(t),e=i}}else _(t),C(t),e=new m([]);return G(t,e)}(s):(p=Q(s),u=new d(p),u=G(s,u)):(a=K(o),i=new d(a),i=G(o,i))}(t),n={"!":"factorial","'":"ctranspose"};n.hasOwnProperty(t.token);)r=t.token,o=n[r],C(t),e=new f(r,o,[e]),e=G(t,e);return e}(o=t),("^"===o.token||".^"===o.token)&&(a=o.token,s="^"===a?"pow":"dotPow",I(o),u=[i,Z(o)],i=new f(a,s,u)),i)}function G(t,e,n){for(var r;!("("!==t.token&&"["!==t.token&&"."!==t.token||n&&-1===n.indexOf(t.token));)if(r=[],"("===t.token){if(!a.isSymbolNode(e)&&!a.isAccessorNode(e))return e;if(F(t),C(t),")"!==t.token)for(r.push(L(t));","===t.token;)C(t),r.push(L(t));if(")"!==t.token)throw nt(t,"Parenthesis ) expected");_(t),C(t),e=new v(e,r)}else if("["===t.token){if(F(t),C(t),"]"!==t.token)for(r.push(L(t));","===t.token;)C(t),r.push(L(t));if("]"!==t.token)throw nt(t,"Parenthesis ] expected");_(t),C(t),e=new o(e,new c(r))}else{if(C(t),t.tokenType!==N.SYMBOL)throw nt(t,"Property name expected after dot");r.push(new d(t.token)),C(t),e=new o(e,new c(r,!0))}return e}function K(t){for(var e="";""!==T(t)&&'"'!==T(t);)"\\"===T(t)&&(e+=T(t),A(t)),e+=T(t),A(t);if(C(t),'"'!==t.token)throw nt(t,'End of string " expected');return C(t),JSON.parse('"'+e+'"')}function Q(t){for(var e="";""!==T(t)&&"'"!==T(t);)"\\"===T(t)&&(e+=T(t),A(t)),e+=T(t),A(t);if(C(t),"'"!==t.token)throw nt(t,"End of string ' expected");return C(t),JSON.parse('"'+e+'"')}function tt(t){for(var e=[L(t)],n=1;","===t.token;)C(t),e[n]=L(t),n++;return new m(e)}function et(t){return t.index-t.token.length+1}function nt(t,e){var n=et(t),r=new SyntaxError(e+" (char "+n+")");return r.char=n,r}function rt(t,e){var n=et(t),r=new SyntaxError(e+" (char "+n+")");return r.char=n,r}return w.isAlpha=function(t,e,n){return w.isValidLatinOrGreek(t)||w.isValidMathSymbol(t,n)||w.isValidMathSymbol(e,t)},w.isValidLatinOrGreek=function(t){return/^[a-zA-Z_$\u00C0-\u02AF\u0370-\u03FF\u2100-\u214F]$/.test(t)},w.isValidMathSymbol=function(t,e){return/^[\uD835]$/.test(t)&&/^[\uDC00-\uDFFF]$/.test(e)&&/^[^\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]$/.test(e)},w.isWhitespace=function(t,e){return" "===t||"\t"===t||"\n"===t&&0<e},w.isDecimalMark=function(t,e){return"."===t&&"/"!==e&&"*"!==e&&"^"!==e},w.isDigitDot=function(t){return"0"<=t&&t<="9"||"."===t},w.isDigit=function(t){return"0"<=t&&t<="9"},w}},{"../error/ArgumentsError":8,"../type/numeric":44,"../utils/collection/deepMap":49,"./node/AccessorNode":15,"./node/ArrayNode":16,"./node/AssignmentNode":17,"./node/BlockNode":18,"./node/ConditionalNode":19,"./node/ConstantNode":20,"./node/FunctionAssignmentNode":21,"./node/FunctionNode":22,"./node/IndexNode":23,"./node/ObjectNode":25,"./node/OperatorNode":26,"./node/ParenthesisNode":27,"./node/RangeNode":28,"./node/RelationalNode":29,"./node/SymbolNode":30}],35:[function(t,e,n){"use strict";var r=t("../../error/IndexError");n.transform=function(t){return t&&t.isIndexError?new r(t.index+1,t.min+1,void 0!==t.max?t.max+1:void 0):t}},{"../../error/IndexError":10}],36:[function(s,t,e){"use strict";var u=s("../../utils/object").clone,c=s("../../utils/array").validateIndex,r=s("../../utils/customs").getSafeProperty,i=s("../../utils/customs").setSafeProperty,f=s("../../error/DimensionError");function p(t,e){if(1!==e.size().length)throw new f(e.size(),1);var n=e.dimension(0);if("string"!=typeof n)throw new TypeError("String expected as index to retrieve an object property");return r(t,n)}function h(t,e,n){if(1!==e.size().length)throw new f(e.size(),1);var r=e.dimension(0);if("string"!=typeof r)throw new TypeError("String expected as index to retrieve an object property");var o=u(t);return i(o,r,n),o}e.name="subset",e.factory=function(i,t,e,n){var o=e(s("../../type/matrix/function/matrix")),r=n("subset",{"Array, Index":function(t,e){var n=o(t).subset(e);return e.isScalar()?n:n.valueOf()},"Matrix, Index":function(t,e){return t.subset(e)},"Object, Index":p,"string, Index":function(e,t){if(!i.isIndex(t))throw new TypeError("Index expected");if(1!==t.size().length)throw new f(t.size().length,1);var n=e.length;c(t.min()[0],n),c(t.max()[0],n);var r=t.dimension(0),o="";return r.forEach(function(t){o+=e.charAt(t)}),o},"Array, Index, any":function(t,e,n){return o(u(t)).subset(e,n,void 0).valueOf()},"Array, Index, any, any":function(t,e,n,r){return o(u(t)).subset(e,n,r).valueOf()},"Matrix, Index, any":function(t,e,n){return t.clone().subset(e,n)},"Matrix, Index, any, any":function(t,e,n,r){return t.clone().subset(e,n,r)},"string, Index, string":a,"string, Index, string, string":a,"Object, Index, any":h});return r.toTex=void 0,r;function a(t,e,n,r){if(!e||!0!==e.isIndex)throw new TypeError("Index expected");if(1!==e.size().length)throw new f(e.size().length,1);if(void 0!==r){if("string"!=typeof r||1!==r.length)throw new TypeError("Single character expected as defaultValue")}else r=" ";var o=e.dimension(0);if(o.size()[0]!==n.length)throw new f(o.size()[0],n.length);var i=t.length;c(e.min()[0]),c(e.max()[0]);for(var a=[],s=0;s<i;s++)a[s]=t.charAt(s);if(o.forEach(function(t,e){a[t]=n.charAt(e[0])}),a.length>i)for(var u=i-1,p=a.length;u<p;u++)a[u]||(a[u]=r);return a.join("")}}},{"../../error/DimensionError":9,"../../type/matrix/function/matrix":42,"../../utils/array":46,"../../utils/customs":51,"../../utils/object":55}],37:[function(t,e,n){"use strict";var i=t("../../utils/string");n.name="format",n.factory=function(t,e,n,r){var o=r("format",{any:i.format,"any, Object | function | number":i.format});return o.toTex=void 0,o}},{"../../utils/string":57}],38:[function(t,e,n){"use strict";function i(t){return(i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}n.name="typeof",n.factory=function(n,t,e,r){var o=r("_typeof",{any:function(t){var e=i(t);return"object"===e?null===t?"null":Array.isArray(t)?"Array":t instanceof Date?"Date":t instanceof RegExp?"RegExp":n.isBigNumber(t)?"BigNumber":n.isComplex(t)?"Complex":n.isFraction(t)?"Fraction":n.isMatrix(t)?"Matrix":n.isUnit(t)?"Unit":n.isIndex(t)?"Index":n.isRange(t)?"Range":n.isResultSet(t)?"ResultSet":n.isNode(t)?t.type:n.isChain(t)?"Chain":n.isHelp(t)?"Help":"Object":"function"===e?"Function":e}});return o.toTex=void 0,o}},{}],39:[function(t,e,n){"use strict";var i=t("../../../utils/collection/deepMap");n.name="bignumber",n.factory=function(e,t,n,r){var o=r("bignumber",{"":function(){return new e.BigNumber(0)},number:function(t){return new e.BigNumber(t+"")},string:function(t){return new e.BigNumber(t)},BigNumber:function(t){return t},Fraction:function(t){return new e.BigNumber(t.n).div(t.d).times(t.s)},null:function(t){return new e.BigNumber(0)},"Array | Matrix":function(t){return i(t,o)}});return o.toTex={0:"0",1:"\\left(${args[0]}\\right)"},o}},{"../../../utils/collection/deepMap":49}],40:[function(t,e,n){"use strict";var i=t("../../../utils/collection/deepMap");n.name="fraction",n.factory=function(n,t,e,r){var o=r("fraction",{number:function(t){if(!isFinite(t)||isNaN(t))throw new Error(t+" cannot be represented as a fraction");return new n.Fraction(t)},string:function(t){return new n.Fraction(t)},"number, number":function(t,e){return new n.Fraction(t,e)},null:function(t){return new n.Fraction(0)},BigNumber:function(t){return new n.Fraction(t.toString())},Fraction:function(t){return t},Object:function(t){return new n.Fraction(t)},"Array | Matrix":function(t){return i(t,o)}});return o}},{"../../../utils/collection/deepMap":49}],41:[function(t,e,n){"use strict";var o=t("../../utils/number");n.name="Range",n.path="type",n.factory=function(a,t,e,n){function s(t,e,n){if(!(this instanceof s))throw new SyntaxError("Constructor must be called with the new operator");var r=null!=t,o=null!=e,i=null!=n;if(r)if(a.isBigNumber(t))t=t.toNumber();else if("number"!=typeof t)throw new TypeError("Parameter start must be a number");if(o)if(a.isBigNumber(e))e=e.toNumber();else if("number"!=typeof e)throw new TypeError("Parameter end must be a number");if(i)if(a.isBigNumber(n))n=n.toNumber();else if("number"!=typeof n)throw new TypeError("Parameter step must be a number");this.start=r?parseFloat(t):0,this.end=o?parseFloat(e):0,this.step=i?parseFloat(n):1}return s.prototype.type="Range",s.prototype.isRange=!0,s.parse=function(t){if("string"!=typeof t)return null;var e=t.split(":").map(function(t){return parseFloat(t)});if(e.some(function(t){return isNaN(t)}))return null;switch(e.length){case 2:return new s(e[0],e[1]);case 3:return new s(e[0],e[2],e[1]);default:return null}},s.prototype.clone=function(){return new s(this.start,this.end,this.step)},s.prototype.size=function(){var t=0,e=this.start,n=this.step,r=this.end-e;return o.sign(n)===o.sign(r)?t=Math.ceil(r/n):0===r&&(t=0),isNaN(t)&&(t=0),[t]},s.prototype.min=function(){var t=this.size()[0];return 0<t?0<this.step?this.start:this.start+(t-1)*this.step:void 0},s.prototype.max=function(){var t=this.size()[0];return 0<t?0<this.step?this.start+(t-1)*this.step:this.start:void 0},s.prototype.forEach=function(t){var e=this.start,n=this.step,r=this.end,o=0;if(0<n)for(;e<r;)t(e,[o],this),e+=n,o++;else if(n<0)for(;r<e;)t(e,[o],this),e+=n,o++},s.prototype.map=function(r){var o=[];return this.forEach(function(t,e,n){o[e[0]]=r(t,e,n)}),o},s.prototype.toArray=function(){var n=[];return this.forEach(function(t,e){n[e[0]]=t}),n},s.prototype.valueOf=function(){return this.toArray()},s.prototype.format=function(t){var e=o.format(this.start,t);return 1!==this.step&&(e+=":"+o.format(this.step,t)),e+=":"+o.format(this.end,t)},s.prototype.toString=function(){return this.format()},s.prototype.toJSON=function(){return{mathjs:"Range",start:this.start,end:this.end,step:this.step}},s.fromJSON=function(t){return new s(t.start,t.end,t.step)},s}},{"../../utils/number":54}],42:[function(t,e,n){"use strict";n.name="matrix",n.factory=function(r,t,e,n){var o=n("matrix",{"":function(){return i([])},string:function(t){return i([],t)},"string, string":function(t,e){return i([],t,e)},Array:function(t){return i(t)},Matrix:function(t){return i(t,t.storage())},"Array | Matrix, string":i,"Array | Matrix, string, string":i});return o.toTex={0:"\\begin{bmatrix}\\end{bmatrix}",1:"\\left(${args[0]}\\right)",2:"\\left(${args[0]}\\right)"},o;function i(t,e,n){return new(r.Matrix.storage(e||"default"))(t,n)}}},{}],43:[function(t,e,n){"use strict";var i=t("./../utils/collection/deepMap");n.name="number",n.factory=function(t,e,n,r){var o=r("number",{"":function(){return 0},number:function(t){return t},string:function(t){if("NaN"===t)return NaN;var e=Number(t);if(isNaN(e))throw new SyntaxError('String "'+t+'" is no valid number');return e},BigNumber:function(t){return t.toNumber()},Fraction:function(t){return t.valueOf()},Unit:function(t){throw new Error("Second argument with valueless unit expected")},null:function(t){return 0},"Unit, string | Unit":function(t,e){return t.toNumber(e)},"Array | Matrix":function(t){return i(t,o)}});return o.toTex={0:"0",1:"\\left(${args[0]}\\right)",2:"\\left(\\left(${args[0]}\\right)${args[1]}\\right)"},o}},{"./../utils/collection/deepMap":49}],44:[function(u,t,e){"use strict";e.path="type",e.name="_numeric",e.factory=function(t,e,n,r){var o=n(u("../function/utils/typeof")),i={string:!0,number:!0,BigNumber:!0,Fraction:!0},a={number:n(u("./number")),BigNumber:n(u("./bignumber/function/bignumber")),Fraction:n(u("./fraction/function/fraction"))},s=function(t,e){var n=o(t);if(!(n in i))throw new TypeError("Cannot convert "+t+' of type "'+n+'"; valid input types are '+Object.keys(i).join(", "));if(!(e in a))throw new TypeError("Cannot convert "+t+' to type "'+e+'"; valid output types are '+Object.keys(a).join(", "));return e===n?t:a[e](t)};return s.toTex=function(t,e){return t.args[0].toTex()},s}},{"../function/utils/typeof":38,"./bignumber/function/bignumber":39,"./fraction/function/fraction":40,"./number":43}],45:[function(t,e,n){"use strict";n.name="ResultSet",n.path="type",n.factory=function(t,e,n,r){function o(t){if(!(this instanceof o))throw new SyntaxError("Constructor must be called with the new operator");this.entries=t||[]}return o.prototype.type="ResultSet",o.prototype.isResultSet=!0,o.prototype.valueOf=function(){return this.entries},o.prototype.toString=function(){return"["+this.entries.join(", ")+"]"},o.prototype.toJSON=function(){return{mathjs:"ResultSet",entries:this.entries}},o.fromJSON=function(t){return new o(t.entries)},o}},{}],46:[function(t,e,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.size=s,n.validate=function(t,e){if(0===e.length){if(Array.isArray(t))throw new u.default(t.length,0)}else!function t(e,n,r){var o;var i=e.length;if(i!==n[r])throw new u.default(i,n[r]);if(r<n.length-1){var a=r+1;for(o=0;o<i;o++){var s=e[o];if(!Array.isArray(s))throw new u.default(n.length-1,n.length,"<");t(e[o],n,a)}}else for(o=0;o<i;o++)if(Array.isArray(e[o]))throw new u.default(n.length+1,n.length,">")}(t,e,0)},n.validateIndex=function(t,e){if(!o.default.isNumber(t)||!o.default.isInteger(t))throw new TypeError("Index must be an integer (value: "+t+")");if(t<0||"number"==typeof e&&e<=t)throw new r.default(t,e)},n.resize=function(t,e,n){if(!Array.isArray(t)||!Array.isArray(e))throw new TypeError("Array expected");if(0===e.length)throw new Error("Resizing to scalar is not supported");e.forEach(function(t){if(!o.default.isNumber(t)||!o.default.isInteger(t)||t<0)throw new TypeError("Invalid size, must contain positive integers (size: "+i.default.format(e)+")")});var r=void 0!==n?n:0;return function t(e,n,r,o){var i,a,s=e.length,u=n[r],p=Math.min(s,u);if(e.length=u,r<n.length-1){var c=r+1;for(i=0;i<p;i++)a=e[i],Array.isArray(a)||(a=[a],e[i]=a),t(a,n,c,o);for(i=p;i<u;i++)a=[],e[i]=a,t(a,n,c,o)}else{for(i=0;i<p;i++)for(;Array.isArray(e[i]);)e[i]=e[i][0];for(i=p;i<u;i++)e[i]=o}}(t,e,0,r),t},n.reshape=function(e,n){var t,r=p(e);function o(t){return t.reduce(function(t,e){return t*e})}if(!Array.isArray(e)||!Array.isArray(n))throw new TypeError("Array expected");if(0===n.length)throw new u.default(0,o(s(e)),"!=");for(var i=1,a=0;a<n.length;a++)i*=n[a];if(r.length!==i)throw new u.default(o(n),o(s(e)),"!=");try{t=function(t,e){for(var n,r=t,o=e.length-1;0<o;o--){var i=e[o];n=[];for(var a=r.length/i,s=0;s<a;s++)n.push(r.slice(s*i,(s+1)*i));r=n}return r}(r,n)}catch(t){if(t instanceof u.default)throw new u.default(o(n),o(s(e)),"!=");throw t}return t},n.squeeze=function(t,e){var n=e||s(t);for(;Array.isArray(t)&&1===t.length;)t=t[0],n.shift();var r=n.length;for(;1===n[r-1];)r--;r<n.length&&(t=function t(e,n,r){var o,i;if(r<n){var a=r+1;for(o=0,i=e.length;o<i;o++)e[o]=t(e[o],n,a)}else for(;Array.isArray(e);)e=e[0];return e}(t,r,0),n.length=r);return t},n.unsqueeze=function(t,e,n,r){var o=r||s(t);if(n)for(var i=0;i<n;i++)t=[t],o.unshift(1);t=function t(e,n,r){var o,i;if(Array.isArray(e)){var a=r+1;for(o=0,i=e.length;o<i;o++)e[o]=t(e[o],n,a)}else for(var s=r;s<n;s++)e=[e];return e}(t,e,0);for(;o.length<e;)o.push(1);return t},n.flatten=p,n.map=function(t,e){return Array.prototype.map.call(t,e)},n.forEach=function(t,e){Array.prototype.forEach.call(t,e)},n.filter=function(t,e){if(1===s(t).length)return Array.prototype.filter.call(t,e);throw new Error("Only one dimensional matrices supported")},n.filterRegExp=function(t,e){if(1===s(t).length)return Array.prototype.filter.call(t,function(t){return e.test(t)});throw new Error("Only one dimensional matrices supported")},n.join=function(t,e){return Array.prototype.join.call(t,e)},n.identify=function(t){if(!Array.isArray(t))throw new TypeError("Array input expected");if(0===t.length)return t;var e=[],n=0;e[0]={value:t[0],identifier:0};for(var r=1;r<t.length;r++)t[r]===t[r-1]?n++:n=0,e.push({value:t[r],identifier:n});return e},n.generalize=function(t){if(!Array.isArray(t))throw new TypeError("Array input expected");if(0===t.length)return t;for(var e=[],n=0;n<t.length;n++)e.push(t[n].value);return e};var o=a(t("./number")),i=a(t("./string")),u=a(t("../error/DimensionError")),r=a(t("../error/IndexError"));function a(t){return t&&t.__esModule?t:{default:t}}function s(t){for(var e=[];Array.isArray(t);)e.push(t.length),t=t[0];return e}function p(t){if(!Array.isArray(t))return t;var n=[];return t.forEach(function t(e){Array.isArray(e)?e.forEach(t):n.push(e)}),n}},{"../error/DimensionError":9,"../error/IndexError":10,"./number":54,"./string":57}],47:[function(t,e,u){"use strict";var p=t("../object");u.format=function(t,e){if("function"==typeof e)return e(t);if(!t.isFinite())return t.isNaN()?"NaN":t.gt(0)?"Infinity":"-Infinity";var n,r="auto";switch(void 0!==e&&(e.notation&&(r=e.notation),"number"==typeof e?n=e:e.precision&&(n=e.precision)),r){case"fixed":return u.toFixed(t,n);case"exponential":return u.toExponential(t,n);case"auto":if(e&&e.exponential&&(void 0!==e.exponential.lower||void 0!==e.exponential.upper)){var o=p.map(e,function(t){return t});return(o.exponential=void 0)!==e.exponential.lower&&(o.lowerExp=Math.round(Math.log(e.exponential.lower)/Math.LN10)),void 0!==e.exponential.upper&&(o.upperExp=Math.round(Math.log(e.exponential.upper)/Math.LN10)),console.warn("Deprecation warning: Formatting options exponential.lower and exponential.upper (minimum and maximum value) are replaced with exponential.lowerExp and exponential.upperExp (minimum and maximum exponent) since version 4.0.0. Replace "+JSON.stringify(e)+" with "+JSON.stringify(o)),u.format(t,o)}var i=e&&void 0!==e.lowerExp?e.lowerExp:-3,a=e&&void 0!==e.upperExp?e.upperExp:5;if(t.isZero())return"0";var s=t.logarithm();return(s.gte(i)&&s.lt(a)?t.toSignificantDigits(n).toFixed():u.toExponential(t,n)).replace(/((\.\d*?)(0+))($|e)/,function(){var t=arguments[2],e=arguments[4];return"."!==t?t+e:e});default:throw new Error('Unknown notation "'+r+'". Choose "auto", "exponential", or "fixed".')}},u.toExponential=function(t,e){return void 0!==e?t.toExponential(e-1):t.toExponential()},u.toFixed=function(t,e){return t.toFixed(e)}},{"../object":55}],48:[function(t,e,n){"use strict";e.exports=function(t){return t&&t.constructor.prototype.isBigNumber||!1}},{}],49:[function(t,e,n){"use strict";e.exports=function e(t,n,r){return t&&"function"==typeof t.map?t.map(function(t){return e(t,n,r)}):n(t)}},{}],50:[function(t,e,n){"use strict";e.exports=function(t){return t&&t.constructor.prototype.isMatrix||!1}},{}],51:[function(t,e,n){"use strict";function r(t){return(r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var o=t("./object").hasOwnProperty;function i(t,e){return!(!t||"object"!==r(t))&&(!!o(u,e)||!(e in Object.prototype)&&!(e in Function.prototype))}function a(t,e){return!(!t||"function"!=typeof t[e])&&(!(o(t,e)&&Object.getPrototypeOf&&e in Object.getPrototypeOf(t))&&(!!o(p,e)||!(e in Object.prototype)&&!(e in Function.prototype)))}function s(t){return"object"===r(t)&&t&&t.constructor===Object}var u={length:!0,name:!0},p={toString:!0,valueOf:!0,toLocaleString:!0};n.getSafeProperty=function(t,e){if(s(t)&&i(t,e))return t[e];if("function"==typeof t[e]&&a(t,e))throw new Error('Cannot access method "'+e+'" as a property');throw new Error('No access to property "'+e+'"')},n.setSafeProperty=function(t,e,n){if(s(t)&&i(t,e))return t[e]=n;throw new Error('No access to property "'+e+'"')},n.isSafeProperty=i,n.validateSafeMethod=function(t,e){if(!a(t,e))throw new Error('No access to method "'+e+'"')},n.isSafeMethod=a,n.isPlainObject=s},{"./object":55}],52:[function(t,e,n){"use strict";var r=t("tiny-emitter");n.mixin=function(t){var e=new r;return t.on=e.on.bind(e),t.off=e.off.bind(e),t.once=e.once.bind(e),t.emit=e.emit.bind(e),t}},{"tiny-emitter":58}],53:[function(t,e,n){"use strict";var r=t("escape-latex");n.symbols={Alpha:"A",alpha:"\\alpha",Beta:"B",beta:"\\beta",Gamma:"\\Gamma",gamma:"\\gamma",Delta:"\\Delta",delta:"\\delta",Epsilon:"E",epsilon:"\\epsilon",varepsilon:"\\varepsilon",Zeta:"Z",zeta:"\\zeta",Eta:"H",eta:"\\eta",Theta:"\\Theta",theta:"\\theta",vartheta:"\\vartheta",Iota:"I",iota:"\\iota",Kappa:"K",kappa:"\\kappa",varkappa:"\\varkappa",Lambda:"\\Lambda",lambda:"\\lambda",Mu:"M",mu:"\\mu",Nu:"N",nu:"\\nu",Xi:"\\Xi",xi:"\\xi",Omicron:"O",omicron:"o",Pi:"\\Pi",pi:"\\pi",varpi:"\\varpi",Rho:"P",rho:"\\rho",varrho:"\\varrho",Sigma:"\\Sigma",sigma:"\\sigma",varsigma:"\\varsigma",Tau:"T",tau:"\\tau",Upsilon:"\\Upsilon",upsilon:"\\upsilon",Phi:"\\Phi",phi:"\\phi",varphi:"\\varphi",Chi:"X",chi:"\\chi",Psi:"\\Psi",psi:"\\psi",Omega:"\\Omega",omega:"\\omega",true:"\\mathrm{True}",false:"\\mathrm{False}",i:"i",inf:"\\infty",Inf:"\\infty",infinity:"\\infty",Infinity:"\\infty",oo:"\\infty",lim:"\\lim",undefined:"\\mathbf{?}"},n.operators={transpose:"^\\top",ctranspose:"^H",factorial:"!",pow:"^",dotPow:".^\\wedge",unaryPlus:"+",unaryMinus:"-",bitNot:"\\~",not:"\\neg",multiply:"\\cdot",divide:"\\frac",dotMultiply:".\\cdot",dotDivide:".:",mod:"\\mod",add:"+",subtract:"-",to:"\\rightarrow",leftShift:"<<",rightArithShift:">>",rightLogShift:">>>",equal:"=",unequal:"\\neq",smaller:"<",larger:">",smallerEq:"\\leq",largerEq:"\\geq",bitAnd:"\\&",bitXor:"\\underline{|}",bitOr:"|",and:"\\wedge",xor:"\\veebar",or:"\\vee"},n.defaultTemplate="\\mathrm{${name}}\\left(${args}\\right)";var o={deg:"^\\circ"};n.escape=function(t){return r(t,{preserveFormatting:!0})},n.toSymbol=function(t,e){return(e=void 0!==e&&e)?o.hasOwnProperty(t)?o[t]:"\\mathrm{"+n.escape(t)+"}":n.symbols.hasOwnProperty(t)?n.symbols[t]:n.escape(t)}},{"escape-latex":2}],54:[function(t,e,h){"use strict";var i=t("./object");function l(t){for(var e=[],n=0;n<t;n++)e.push(0);return e}h.isNumber=function(t){return"number"==typeof t},h.isInteger=function(t){return"boolean"==typeof t||!!isFinite(t)&&t===Math.round(t)},h.sign=Math.sign||function(t){return 0<t?1:t<0?-1:0},h.format=function(t,e){if("function"==typeof e)return e(t);if(t===1/0)return"Infinity";if(t===-1/0)return"-Infinity";if(isNaN(t))return"NaN";var n,r="auto";switch(e&&(e.notation&&(r=e.notation),h.isNumber(e)?n=e:e.precision&&(n=e.precision)),r){case"fixed":return h.toFixed(t,n);case"exponential":return h.toExponential(t,n);case"engineering":return h.toEngineering(t,n);case"auto":if(!e||!e.exponential||void 0===e.exponential.lower&&void 0===e.exponential.upper)return h.toPrecision(t,n,e&&e).replace(/((\.\d*?)(0+))($|e)/,function(){var t=arguments[2],e=arguments[4];return"."!==t?t+e:e});var o=i.map(e,function(t){return t});return(o.exponential=void 0)!==e.exponential.lower&&(o.lowerExp=Math.round(Math.log(e.exponential.lower)/Math.LN10)),void 0!==e.exponential.upper&&(o.upperExp=Math.round(Math.log(e.exponential.upper)/Math.LN10)),console.warn("Deprecation warning: Formatting options exponential.lower and exponential.upper (minimum and maximum value) are replaced with exponential.lowerExp and exponential.upperExp (minimum and maximum exponent) since version 4.0.0. Replace "+JSON.stringify(e)+" with "+JSON.stringify(o)),h.toPrecision(t,n,o);default:throw new Error('Unknown notation "'+r+'". Choose "auto", "exponential", or "fixed".')}},h.splitNumber=function(t){var e=String(t).toLowerCase().match(/^0*?(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);if(!e)throw new SyntaxError("Invalid number "+t);var n=e[1],r=e[2],o=parseFloat(e[4]||"0"),i=r.indexOf(".");o+=-1!==i?i-1:r.length-1;var a=r.replace(".","").replace(/^0*/,function(t){return o-=t.length,""}).replace(/0*$/,"").split("").map(function(t){return parseInt(t)});return 0===a.length&&(a.push(0),o++),{sign:n,coefficients:a,exponent:o}},h.toEngineering=function(t,e){if(isNaN(t)||!isFinite(t))return String(t);var n=h.roundDigits(h.splitNumber(t),e),r=n.exponent,o=n.coefficients,i=r%3==0?r:r<0?r-3-r%3:r-r%3;if(h.isNumber(e))e>o.length&&(o=o.concat(l(e-o.length)));else{var a=0<=r?r:Math.abs(i);o.length-1<a&&(o=o.concat(l(a-(o.length-1))))}for(var s=Math.abs(r-i),u=1;0<=--s;)u++;var p=o.slice(u).join(""),c=h.isNumber(e)&&p.length||p.match(/[1-9]/)?"."+p:"",f=o.slice(0,u).join("")+c+"e"+(0<=r?"+":"")+i.toString();return n.sign+f},h.toFixed=function(t,e){if(isNaN(t)||!isFinite(t))return String(t);var n=h.splitNumber(t),r="number"==typeof e?h.roundDigits(n,n.exponent+1+e):n,o=r.coefficients,i=r.exponent+1,a=i+(e||0);return o.length<a&&(o=o.concat(l(a-o.length))),i<0&&(o=l(1-i).concat(o),i=1),i<o.length&&o.splice(i,0,0===i?"0.":"."),r.sign+o.join("")},h.toExponential=function(t,e){if(isNaN(t)||!isFinite(t))return String(t);var n=h.splitNumber(t),r=e?h.roundDigits(n,e):n,o=r.coefficients,i=r.exponent;o.length<e&&(o=o.concat(l(e-o.length)));var a=o.shift();return r.sign+a+(0<o.length?"."+o.join(""):"")+"e"+(0<=i?"+":"")+i},h.toPrecision=function(t,e,n){if(isNaN(t)||!isFinite(t))return String(t);var r=n&&void 0!==n.lowerExp?n.lowerExp:-3,o=n&&void 0!==n.upperExp?n.upperExp:5,i=h.splitNumber(t);if(i.exponent<r||i.exponent>=o)return h.toExponential(t,e);var a=e?h.roundDigits(i,e):i,s=a.coefficients,u=a.exponent;s.length<e&&(s=s.concat(l(e-s.length))),s=s.concat(l(u-s.length+1+(s.length<e?e-s.length:0)));var p=0<u?u:0;return p<(s=l(-u).concat(s)).length-1&&s.splice(p+1,0,"."),a.sign+s.join("")},h.roundDigits=function(t,e){for(var n={sign:t.sign,coefficients:t.coefficients,exponent:t.exponent},r=n.coefficients;e<=0;)r.unshift(0),n.exponent++,e++;if(r.length>e&&5<=r.splice(e,r.length-e)[0]){var o=e-1;for(r[o]++;10===r[o];)r.pop(),0===o&&(r.unshift(0),n.exponent++,o++),r[--o]++}return n},h.digits=function(t){return t.toExponential().replace(/e.*$/,"").replace(/^0\.?0*|\./,"").length},h.DBL_EPSILON=Number.EPSILON||2220446049250313e-31,h.nearlyEqual=function(t,e,n){if(null==n)return t===e;if(t===e)return!0;if(isNaN(t)||isNaN(e))return!1;if(isFinite(t)&&isFinite(e)){var r=Math.abs(t-e);return r<h.DBL_EPSILON||r<=Math.max(Math.abs(t),Math.abs(e))*n}return!1}},{"./object":55}],55:[function(t,e,i){"use strict";function r(t){return(r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var o=t("./bignumber/isBigNumber");i.clone=function e(t){var n=r(t);if("number"===n||"string"===n||"boolean"===n||null==t)return t;if("function"==typeof t.clone)return t.clone();if(Array.isArray(t))return t.map(function(t){return e(t)});if(t instanceof Date)return new Date(t.valueOf());if(o(t))return t;if(t instanceof RegExp)throw new TypeError("Cannot clone "+t);return i.map(t,e)},i.map=function(t,e){var n={};for(var r in t)i.hasOwnProperty(t,r)&&(n[r]=e(t[r]));return n},i.extend=function(t,e){for(var n in e)i.hasOwnProperty(e,n)&&(t[n]=e[n]);return t},i.deepExtend=function t(e,n){if(Array.isArray(n))throw new TypeError("Arrays are not supported by deepExtend");for(var r in n)if(i.hasOwnProperty(n,r))if(n[r]&&n[r].constructor===Object)void 0===e[r]&&(e[r]={}),e[r].constructor===Object?t(e[r],n[r]):e[r]=n[r];else{if(Array.isArray(n[r]))throw new TypeError("Arrays are not supported by deepExtend");e[r]=n[r]}return e},i.deepEqual=function(t,e){var n,r,o;if(Array.isArray(t)){if(!Array.isArray(e))return!1;if(t.length!==e.length)return!1;for(r=0,o=t.length;r<o;r++)if(!i.deepEqual(t[r],e[r]))return!1;return!0}if(t instanceof Object){if(Array.isArray(e)||!(e instanceof Object))return!1;for(n in t)if(!i.deepEqual(t[n],e[n]))return!1;for(n in e)if(!i.deepEqual(t[n],e[n]))return!1;return!0}return t===e},i.canDefineProperty=function(){try{if(Object.defineProperty)return Object.defineProperty({},"x",{get:function(){}}),!0}catch(t){}return!1},i.lazy=function(t,e,n){if(i.canDefineProperty()){var r,o=!0;Object.defineProperty(t,e,{get:function(){return o&&(r=n(),o=!1),r},set:function(t){r=t,o=!1},configurable:!0,enumerable:!0})}else t[e]=n()},i.traverse=function(t,e){var n=t;if(e)for(var r=e.split("."),o=0;o<r.length;o++){var i=r[o];i in n||(n[i]={}),n=n[i]}return n},i.hasOwnProperty=function(t,e){return t&&Object.hasOwnProperty.call(t,e)},i.isFactory=function(t){return t&&"function"==typeof t.factory}},{"./bignumber/isBigNumber":48}],56:[function(t,e,n){"use strict";Number.isFinite=Number.isFinite||function(t){return"number"==typeof t&&isFinite(t)},Number.isNaN=Number.isNaN||function(t){return t!=t}},{}],57:[function(t,e,a){"use strict";function i(t){return(i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var s=t("./number").format,u=t("./bignumber/formatter").format,p=t("./bignumber/isBigNumber");a.isString=function(t){return"string"==typeof t},a.endsWith=function(t,e){var n=t.length-e.length,r=t.length;return t.substring(n,r)===e},a.format=function(t,e){if("number"==typeof t)return s(t,e);if(p(t))return u(t,e);if((n=t)&&"object"===i(n)&&"number"==typeof n.s&&"number"==typeof n.n&&"number"==typeof n.d)return e&&"decimal"===e.fraction?t.toString():t.s*t.n+"/"+t.d;var n;if(Array.isArray(t))return function t(e,n){{if(Array.isArray(e)){for(var r="[",o=e.length,i=0;i<o;i++)0!==i&&(r+=", "),r+=t(e[i],n);return r+="]"}return a.format(e,n)}}(t,e);if(a.isString(t))return'"'+t+'"';if("function"==typeof t)return t.syntax?String(t.syntax):"function";if(t&&"object"===i(t)){if("function"==typeof t.format)return t.format(e);if(t&&t.toString()!=={}.toString())return t.toString();var r=[];for(var o in t)t.hasOwnProperty(o)&&r.push('"'+o+'": '+a.format(t[o],e));return"{"+r.join(", ")+"}"}return String(t)},a.stringify=function(t){for(var e=String(t),n="",r=0;r<e.length;){var o=e.charAt(r);"\\"===o?(n+=o,r++,""!==(o=e.charAt(r))&&-1!=='"\\/bfnrtu'.indexOf(o)||(n+="\\"),n+=o):n+='"'===o?'\\"':o,r++}return'"'+n+'"'},a.escape=function(t){var e=String(t);return e=e.replace(/&/g,"&amp;").replace(/"/g,"&quot;").replace(/'/g,"&#39;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}},{"./bignumber/formatter":47,"./bignumber/isBigNumber":48,"./number":54}],58:[function(t,e,n){function r(){}r.prototype={on:function(t,e,n){var r=this.e||(this.e={});return(r[t]||(r[t]=[])).push({fn:e,ctx:n}),this},once:function(t,e,n){var r=this;function o(){r.off(t,o),e.apply(n,arguments)}return o._=e,this.on(t,o,n)},emit:function(t){for(var e=[].slice.call(arguments,1),n=((this.e||(this.e={}))[t]||[]).slice(),r=0,o=n.length;r<o;r++)n[r].fn.apply(n[r].ctx,e);return this},off:function(t,e){var n=this.e||(this.e={}),r=n[t],o=[];if(r&&e)for(var i=0,a=r.length;i<a;i++)r[i].fn!==e&&r[i].fn._!==e&&o.push(r[i]);return o.length?n[t]=o:delete n[t],this}},e.exports=r},{}],59:[function(t,e,n){"use strict";var r,o;r=this,o=function(){function g(){return!0}function pt(){return!1}function ct(){}return function t(){var e=[{name:"number",test:function(t){return"number"==typeof t}},{name:"string",test:function(t){return"string"==typeof t}},{name:"boolean",test:function(t){return"boolean"==typeof t}},{name:"Function",test:function(t){return"function"==typeof t}},{name:"Array",test:Array.isArray},{name:"Date",test:function(t){return t instanceof Date}},{name:"RegExp",test:function(t){return t instanceof RegExp}},{name:"Object",test:function(t){return"object"==typeof t&&t.constructor===Object}},{name:"null",test:function(t){return null===t}},{name:"undefined",test:function(t){return void 0===t}}],r={name:"any",test:g},n=[],o=[],q={types:e,conversions:o,ignore:n};function p(e){var t=st(q.types,function(t){return t.name===e});if(t)return t;if("any"===e)return r;var n=st(q.types,function(t){return t.name.toLowerCase()===e.toLowerCase()});throw new TypeError('Unknown type "'+e+'"'+(n?'. Did you mean "'+n.name+'"?':""))}function c(t){return t===r?999:q.types.indexOf(t)}function U(e){var t=st(q.types,function(t){return t.test(e)});if(t)return t.name;throw new TypeError("Value has unknown type. Value: "+e)}function J(t){return t.map(function(t){var e=t.types.map(i);return(t.restParam?"...":"")+e.join("|")}).join(",")}function z(t,n){var e,r,o=0===t.indexOf("..."),i=(o?3<t.length?t.slice(3):"any":t).split("|").map(nt).filter(m).filter(l),a=(e=i,r={},n.forEach(function(t){-1!==e.indexOf(t.from)||-1===e.indexOf(t.to)||r[t.from]||(r[t.from]=t)}),Object.keys(r).map(function(t){return r[t]})),s=i.map(function(t){var e=p(t);return{name:t,typeIndex:c(e),test:e.test,conversion:null,conversionIndex:-1}}),u=a.map(function(t){var e=p(t.from);return{name:t.from,typeIndex:c(e),test:e.test,conversion:t,conversionIndex:n.indexOf(t)}});return{types:s.concat(u),restParam:o}}function $(t){var e=s(t);return!!e&&e.restParam}function V(t){return t.types.some(function(t){return null!=t.conversion})}function X(t){if(t&&0!==t.types.length){if(1===t.types.length)return p(t.types[0].name).test;if(2===t.types.length){var e=p(t.types[0].name).test,n=p(t.types[1].name).test;return function(t){return e(t)||n(t)}}var r=t.types.map(function(t){return p(t.name).test});return function(t){for(var e=0;e<r.length;e++)if(r[e](t))return!0;return!1}}return g}function Y(t){var n,e,r,o;if($(t)){var i=(n=(o=t,o.slice(0,o.length-1)).map(X)).length,a=X(s(t));return function(t){for(var e=0;e<n.length;e++)if(!n[e](t[e]))return!1;return function(t){for(var e=i;e<t.length;e++)if(!a(t[e]))return!1;return!0}(t)&&t.length>=i+1}}return 0===t.length?function(t){return 0===t.length}:1===t.length?(e=X(t[0]),function(t){return e(t[0])&&1===t.length}):2===t.length?(e=X(t[0]),r=X(t[1]),function(t){return e(t[0])&&r(t[1])&&2===t.length}):(n=t.map(X),function(t){for(var e=0;e<n.length;e++)if(!n[e](t[e]))return!1;return t.length===n.length})}function Z(t,e){return e<t.params.length?t.params[e]:$(t.params)?s(t.params):null}function G(t,e,n){var r=Z(t,e);return(r?n?r.types.filter(f):r.types:[]).map(i)}function i(t){return t.name}function f(t){return null===t.conversion||void 0===t.conversion}function K(t,e){var n=function(t){for(var e={},n=0;n<t.length;n++)e[t[n]]=!0;return Object.keys(e)}(ut(t,function(t){return G(t,e,!1)}));return-1!==n.indexOf("any")?["any"]:n}function u(t){for(var e=999,n=0;n<t.types.length;n++)f(t.types[n])&&(e=Math.min(e,t.types[n].typeIndex));return e}function h(t){for(var e=999,n=0;n<t.types.length;n++)f(t.types[n])||(e=Math.min(e,t.types[n].conversionIndex));return e}function Q(t,e){var n,r,o,i,a,s=Math.min(t.params.length,e.params.length);if(0!=(r=t.params.some(V)-e.params.some(V)))return r;for(n=0;n<s;n++)if(0!=(r=V(t.params[n])-V(e.params[n])))return r;for(n=0;n<s;n++)if(o=t.params[n],i=e.params[n],a=void 0,0!==(r=0!=(a=o.restParam-i.restParam)?a:0!=(a=V(o)-V(i))?a:0!=(a=u(o)-u(i))?a:h(o)-h(i)))return r;return t.params.length-e.params.length}function tt(t){var e,n,r,o,i=[],a=[];switch(t.types.forEach(function(t){t.conversion&&(i.push(p(t.conversion.from).test),a.push(t.conversion.convert))}),a.length){case 0:return function(t){return t};case 1:return e=i[0],r=a[0],function(t){return e(t)?r(t):t};case 2:return e=i[0],n=i[1],r=a[0],o=a[1],function(t){return e(t)?r(t):n(t)?o(t):t};default:return function(t){for(var e=0;e<a.length;e++)if(i[e](t))return a[e](t);return t}}}function et(t,u){return function e(n,r,o){if(r<n.length){var t,i=n[r],a=u?i.types.filter(f):i.types;if(i.restParam){var s=a.filter(f);t=s.length<a.length?[s,a]:[a]}else t=a.map(function(t){return[t]});return ut(t,function(t){return e(n,r+1,o.concat([t]))})}return[o.map(function(t,e){return{types:t,restParam:e===n.length-1&&$(n)}})]}(t,0,[])}function a(e,i){if(0===Object.keys(i).length)throw new SyntaxError("No signatures provided");var n=[];Object.keys(i).map(function(t){return n=i[e=t],o=q.conversions,r=[],""!==e.trim()&&(r=e.split(",").map(nt).map(function(t,e,n){var r=z(t,o);if(r.restParam&&e!==n.length-1)throw new SyntaxError('Unexpected rest parameter "'+t+'": only allowed for the last parameter');return r})),r.some(ot)?null:{params:r,fn:n};var e,n,o,r}).filter(rt).forEach(function(e){var t=st(n,function(t){return function(t,e){for(var n=Math.max(t.params.length,e.params.length),r=0;r<n;r++)if(!at(G(t,r,!0),G(e,r,!0)))return!1;var o=t.params.length,i=e.params.length,a=$(t.params),s=$(e.params);return a?s?o===i:o<=i:s?i<=o:o===i}(t,e)});if(t)throw new TypeError('Conflicting signatures "'+J(t.params)+'" and "'+J(e.params)+'".');n.push(e)});var r=ut(n,function(e){return(e?et(e.params,!1):[]).map(function(t){return{params:t,fn:e.fn}})}).filter(rt);r.sort(Q);var o,t=r[0]&&r[0].params.length<=2&&!$(r[0].params),a=r[1]&&r[1].params.length<=2&&!$(r[1].params),s=r[2]&&r[2].params.length<=2&&!$(r[2].params),u=r[3]&&r[3].params.length<=2&&!$(r[3].params),p=r[4]&&r[4].params.length<=2&&!$(r[4].params),c=r[5]&&r[5].params.length<=2&&!$(r[5].params),f=t&&a&&s&&u&&p&&c,h=r.map(function(t){return Y(t.params)}),l=t?X(r[0].params[0]):pt,m=a?X(r[1].params[0]):pt,d=s?X(r[2].params[0]):pt,y=u?X(r[3].params[0]):pt,g=p?X(r[4].params[0]):pt,v=c?X(r[5].params[0]):pt,b=t?X(r[0].params[1]):pt,x=a?X(r[1].params[1]):pt,w=s?X(r[2].params[1]):pt,N=u?X(r[3].params[1]):pt,E=p?X(r[4].params[1]):pt,O=c?X(r[5].params[1]):pt,S=r.map(function(t){return function(t,r){var e=r;if(t.some(V)){var o=$(t),i=t.map(tt);e=function(){for(var t=[],e=o?arguments.length-1:arguments.length,n=0;n<e;n++)t[n]=i[n](arguments[n]);return o&&(t[e]=arguments[e].map(i[e])),r.apply(null,t)}}var n=e;if($(t)){var a=t.length-1;n=function(){return e.apply(null,it(arguments,0,a).concat([it(arguments,a)]))}}return n}(t.params,t.fn)}),j=t?S[0]:ct,k=a?S[1]:ct,T=s?S[2]:ct,A=u?S[3]:ct,P=p?S[4]:ct,M=c?S[5]:ct,C=t?r[0].params.length:-1,I=a?r[1].params.length:-1,F=s?r[2].params.length:-1,_=u?r[3].params.length:-1,D=p?r[4].params.length:-1,L=c?r[5].params.length:-1,R=f?6:0,B=r.length,W=function(){for(var t=R;t<B;t++)if(h[t](arguments))return S[t].apply(null,arguments);throw function(t,n,e){var r,o,i,a=t||"unnamed",s=e;for(i=0;i<n.length;i++){var u=s.filter(function(t){var e=X(Z(t,i));return(i<t.params.length||$(t.params))&&e(n[i])});if(0===u.length){if(0<(o=K(s,i)).length){var p=U(n[i]);return(r=new TypeError("Unexpected type of argument in function "+a+" (expected: "+o.join(" or ")+", actual: "+p+", index: "+i+")")).data={category:"wrongType",fn:a,index:i,actual:p,expected:o},r}}else s=u}var c=s.map(function(t){return $(t.params)?1/0:t.params.length});if(n.length<Math.min.apply(null,c))return o=K(s,i),(r=new TypeError("Too few arguments in function "+a+" (expected: "+o.join(" or ")+", index: "+n.length+")")).data={category:"tooFewArgs",fn:a,index:n.length,expected:o},r;var f=Math.max.apply(null,c);return n.length>f?(r=new TypeError("Too many arguments in function "+a+" (expected: "+f+", actual: "+n.length+")")).data={category:"tooManyArgs",fn:a,index:n.length,expectedLength:f}:(r=new TypeError('Arguments of type "'+n.join(", ")+'" do not match any of the defined signatures of function '+a+".")).data={category:"mismatch",actual:n.map(U)},r}(e,arguments,r)},H=function(t,e){return arguments.length===C&&l(t)&&b(e)?j.apply(null,arguments):arguments.length===I&&m(t)&&x(e)?k.apply(null,arguments):arguments.length===F&&d(t)&&w(e)?T.apply(null,arguments):arguments.length===_&&y(t)&&N(e)?A.apply(null,arguments):arguments.length===D&&g(t)&&E(e)?P.apply(null,arguments):arguments.length===L&&v(t)&&O(e)?M.apply(null,arguments):W.apply(null,arguments)};try{Object.defineProperty(H,"name",{value:e})}catch(t){}return H.signatures=(o={},r.forEach(function(e){e.params.some(V)||et(e.params,!0).forEach(function(t){o[J(t)]=e.fn})}),o),H}function l(t){return-1===q.ignore.indexOf(t)}function nt(t){return t.trim()}function m(t){return!!t}function rt(t){return null!==t}function ot(t){return 0===t.types.length}function s(t){return t[t.length-1]}function it(t,e,n){return Array.prototype.slice.call(t,e,n)}function at(t,e){for(var n=0;n<t.length;n++)if(r=e,o=t[n],-1!==r.indexOf(o))return!0;var r,o;return!1}function st(t,e){for(var n=0;n<t.length;n++)if(e(t[n]))return t[n]}function ut(t,e){return Array.prototype.concat.apply([],t.map(e))}function d(t){for(var e="",n=0;n<t.length;n++){var r=t[n];if(("object"==typeof r.signatures||"string"==typeof r.signature)&&""!==r.name)if(""===e)e=r.name;else if(e!==r.name){var o=new Error("Function names do not match (expected: "+e+", actual: "+r.name+")");throw o.data={actual:r.name,expected:e},o}}return e}function y(t){var n,r={};function e(t,e){if(r.hasOwnProperty(t)&&e!==r[t])throw(n=new Error('Signature "'+t+'" is defined twice')).data={signature:t},n}for(var o=0;o<t.length;o++){var i=t[o];if("object"==typeof i.signatures)for(var a in i.signatures)i.signatures.hasOwnProperty(a)&&(e(a,i.signatures[a]),r[a]=i.signatures[a]);else{if("string"!=typeof i.signature)throw(n=new TypeError("Function is no typed-function (index: "+o+")")).data={index:o},n;e(i.signature,i),r[i.signature]=i}}return r}return(q=a("typed",{"string, Object":a,Object:function(t){var e=[];for(var n in t)t.hasOwnProperty(n)&&e.push(t[n]);return a(d(e),t)},"...Function":function(t){return a(d(t),y(t))},"string, ...Function":function(t,e){return a(t,y(e))}})).create=t,q.types=e,q.conversions=o,q.ignore=n,q.convert=function(t,e){var n=U(t);if(e===n)return t;for(var r=0;r<q.conversions.length;r++){var o=q.conversions[r];if(o.from===n&&o.to===e)return o.convert(t)}throw new Error("Cannot convert from "+n+" to "+e)},q.find=function(t,e){if(!t.signatures)throw new TypeError("Function is no typed-function");var n;if("string"==typeof e){n=e.split(",");for(var r=0;r<n.length;r++)n[r]=n[r].trim()}else{if(!Array.isArray(e))throw new TypeError("String array or a comma separated string expected");n=e}var o=n.join(","),i=t.signatures[o];if(i)return i;throw new TypeError("Signature not found (signature: "+(t.name||"unnamed")+"("+n.join(", ")+"))")},q.addType=function(t,e){if(!t||"string"!=typeof t.name||"function"!=typeof t.test)throw new TypeError("Object with properties {name: string, test: function} expected");if(!1!==e)for(var n=0;n<q.types.length;n++)if("Object"===q.types[n].name)return void q.types.splice(n,0,t);q.types.push(t)},q.addConversion=function(t){if(!t||"string"!=typeof t.from||"string"!=typeof t.to||"function"!=typeof t.convert)throw new TypeError("Object with properties {from: string, to: string, convert: function} expected");q.conversions.push(t)},q}()},"object"==typeof n?e.exports=o():r.typed=o()},{}]},{},[1])(1)});
\ No newline at end of file
diff --git a/mathjs/mathjs-expression-parser.min.js.map b/mathjs/mathjs-expression-parser.min.js.map
new file mode 100644
index 0000000..9e9622b
--- /dev/null
+++ b/mathjs/mathjs-expression-parser.min.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["dist/mathjs-expression-parser.js"],"names":["f","exports","module","define","amd","window","global","self","this","math","r","e","n","t","o","i","c","require","u","a","Error","code","p","call","length","1","create","import","add","b","subtract","multiply","divide","mod","unaryPlus","unaryMinus","bitOr","bitXor","bitAnd","bitNot","leftShift","rightArithShift","rightLogShift","or","xor","and","not","equal","unequal","smaller","larger","smallerEq","largerEq","matrix","index","pi","Math","PI","E","true","false","null","allFromMath","Object","getOwnPropertyNames","forEach","name","prototype","hasOwnProperty","mathjs/core","mathjs/lib/expression/function/compile","mathjs/lib/expression/function/eval","mathjs/lib/expression/function/parse","mathjs/lib/function/string/format","2","_extends","assign","target","arguments","source","key","defaultEscapes","{","}","\\","#","$","%","&","^","_","~","formatEscapes","–","—"," ","\t","\r\n","\n","defaultEscapeMapFn","str","_ref","undefined","_ref$preserveFormatti","preserveFormatting","_ref$escapeMapFn","escapeMapFn","runningStr","String","result","escapes","escapeKeys","keys","_loop","specialCharFound","slice","3","./lib/core/core","4","isFactory","typedFactory","emitter","importFactory","configFactory","options","factories","instances","mixin","type","expression","transform","mathWithTransform","typed","_config","epsilon","number","precision","predictable","randomSeed","load","factory","instance","indexOf","push","config","./../utils/emitter","./../utils/object","./../utils/polyfills","./function/config","./function/import","./typed","5","object","validateOption","values","array","item","map","toLowerCase","console","warn","JSON","stringify","join","MATRIX","NUMBER","prev","clone","deepExtend","curr","changes","emit","../../utils/object","6","_typeof","obj","Symbol","iterator","constructor","lazy","traverse","ArgumentsError","_import","value","wrap","wrapper","args","len","arg","valueOf","fn","apply","isTypedFunction","override","signatures","_importTransform","silent","allowedInExpressions","_deleteTransform","_importFactory","existingTransform","namespace","path","existing","resolver","factoryAllowedInExpressions","unsafe","docs","error","json","chain","mathImport","num","Array","isArray","entry","isUnit","isComplex","isBigNumber","isFraction","isMatrix","TypeError","../../error/ArgumentsError","7","typedFunction","digits","_createTyped","isNumber","x","Complex","Fraction","isString","isDenseMatrix","isSparseMatrix","isRange","isIndex","isBoolean","isResultSet","isHelp","isFunction","isDate","Date","isRegExp","RegExp","isObject","isNull","isUndefined","isAccessorNode","isNode","isArrayNode","isAssignmentNode","isBlockNode","isConditionalNode","isConstantNode","isFunctionAssignmentNode","isFunctionNode","isIndexNode","isObjectNode","isOperatorNode","isParenthesisNode","isRangeNode","isSymbolNode","isChain","types","test","conversions","from","to","convert","BigNumber","toNumber","Number","isNaN","err","DenseMatrix","./../utils/bignumber/isBigNumber","./../utils/collection/isMatrix","./../utils/number","typed-function","8","count","min","max","SyntaxError","message","stack","isArgumentsError","9","DimensionError","actual","expected","relation","RangeError","isDimensionError","10","IndexError","isIndexError","11","deepMap","parse","string","expr","compile","Array | Matrix","../../utils/collection/deepMap","../parse","12","eval","string, Object","scope","Array | Matrix, Object","13","string | Array | Matrix","string | Array | Matrix, Object","14","end","15","getSafeProperty","Node","access","AccessorNode","defineProperty","get","isObjectProperty","getObjectProperty","bind","set","needParenthesis","node","_compile","argNames","evalObject","evalIndex","prop","context","callback","_ifNode","_toString","toString","toHTML","_toTex","toTex","toJSON","mathjs","fromJSON","../../utils/customs","./Node","./utils/access","16","ArrayNode","items","every","deprecated","evalItems","evalItem","s","childNode","../../utils/array","17","setSafeProperty","operators","AssignmentNode","parenthesis","precedence","getPrecedence","exprPrecedence","evalValue","childObject","evalParentObject","parentProp","parent","evalParentIndex","parentIndex","concat","../operators","./utils/assign","18","ResultSet","BlockNode","blocks","block","visible","evalBlocks","results","param","../../type/resultset/ResultSet","19","mathTypeOf","ConditionalNode","condition","trueExpr","falseExpr","evalCondition","evalTrueExpr","evalFalseExpr","isZero","re","im","testCondition","conditionPrecedence","truePrecedence","falsePrecedence","../../function/utils/typeof","20","format","escapeLatex","escape","getType","ConstantNode","substring","toLatex","../../utils/latex","../../utils/string","21","keywords","latex","FunctionAssignmentNode","params","childArgNames","evalExpr","signature","syntax","childArgs","toSymbol","../keywords","22","validateSafeMethod","SymbolNode","FunctionNode","evalArgs","rawArgs","evalArg0","evalArg","_evalArg","evalArg1","_rawArgs","evalFn","_rawArgs2","nodeToString","expandTemplate","template","match","regex","inputPos","exec","property","ReferenceError","customString","handler","nodeToTex","customTex","latexConverter","customToTex","defaultTemplate","getIdentifier","./SymbolNode","23","Range","IndexNode","dimensions","dotNotation","createRange","start","step","evalDimensions","range","needsEnd","evalStart","evalEnd","evalStep","size","_evalStart","_evalEnd","_evalStep","_childArgNames","evalRange","_evalRange","evalDimension","../../type/matrix/Range","24","deepEqual","comment","symbol","_validateScope","_traverse","child","_transform","filter","nodes","find","cloneDeep","equals","other","getContent","25","isSafeProperty","ObjectNode","properties","evalEntries","stringifiedKey","parsedKey","_key","entries","26","isSafeMethod","OperatorNode","op","implicit","calculateNecessaryParentheses","root","associativity","getAssociativity","operandPrecedence","operandIdentifier","rootIdentifier","latexLeftParens","latexParens","lhsParens","rhsParens","lhsPrecedence","assocWithLhs","isAssociativeWith","_rootIdentifier","lhsIdentifier","rhsIdentifier","rhsPrecedence","assocWithRhs","latexRightParens","argPrecedence","assocWithArg","argAssociativity","isUnary","isBinary","parens","assoc","operand","lhs","rhs","stringifiedArgs","lhsTex","rhsTex","texifiedArgs","27","ParenthesisNode","content","28","RangeNode","startPrecedence","stepPrecedence","endPrecedence","29","RelationalNode","conditionals","isRelationalNode","compiled","evalLhs","evalRhs","condFn","_this","_this2","paramStrings","paramPrecedence","operatorMap","ret","30","isValuelessUnit","Unit","undef","31","errorTransform","subset","../../../function/matrix/subset","../../../utils/customs","../../transform/error.transform","32","../../../type/matrix/function/matrix","33","OperatorNode:or","associativeWith","OperatorNode:xor","OperatorNode:and","OperatorNode:bitOr","OperatorNode:bitXor","OperatorNode:bitAnd","OperatorNode:equal","OperatorNode:unequal","OperatorNode:smaller","OperatorNode:larger","OperatorNode:smallerEq","OperatorNode:largerEq","OperatorNode:leftShift","OperatorNode:rightArithShift","OperatorNode:rightLogShift","OperatorNode:to","OperatorNode:add","OperatorNode:subtract","OperatorNode:multiply","OperatorNode:divide","OperatorNode:dotMultiply","OperatorNode:dotDivide","OperatorNode:mod","OperatorNode:unaryPlus","OperatorNode:unaryMinus","OperatorNode:bitNot","OperatorNode:not","OperatorNode:pow","OperatorNode:dotPow","OperatorNode:factorial","OperatorNode:transpose","_node","identifier","nodeA","nodeB","identifierA","identifierB","34","numeric","extraNodes","parseStart","Matrix","elem","TOKENTYPE","NULL","DELIMITER","SYMBOL","UNKNOWN","DELIMITERS",",","(",")","[","]","\"","'",";","+","-","*",".*","/","./",".^","!","|","^|","=",":","?","==","!=","<",">","<=",">=","<<",">>",">>>","NAMED_DELIMITERS","in","CONSTANTS","NUMERIC_CONSTANTS","currentString","state","substr","currentCharacter","next","prevCharacter","charAt","nextCharacter","getToken","tokenType","token","isWhitespace","nestingLevel","c1","c2","c3","isDigitDot","isDigit","isDecimalMark","createSyntaxError","isAlpha","getTokenSkipNewline","openParams","closeParams","conditionalLevel","parseAssignment","parseBlock","createError","valid","parseLogicalXor","parseLogicalOr","parseConditional","parseLogicalAnd","parseBitwiseOr","parseBitwiseXor","parseBitwiseAnd","parseRelational","parseShift","cond","parseConversion","parseRange","parseAddSubtract","parseMultiplyDivide","last","parseImplicitMultiplication","parseRule2","parseUnary","tokenStates","pop","CustomNode","parseAccessors","rows","cols","parseEnd","parseParentheses","numberStr","parseDoubleQuotesStringToken","parseSingleQuotesStringToken","parseObject","row","parseRow","parseMatrix","parseCustomNodes","parseLeftHandOperators","col","cPrev","cNext","isValidLatinOrGreek","isValidMathSymbol","high","low","../error/ArgumentsError","../type/numeric","../utils/collection/deepMap","./node/AccessorNode","./node/ArrayNode","./node/AssignmentNode","./node/BlockNode","./node/ConditionalNode","./node/ConstantNode","./node/FunctionAssignmentNode","./node/FunctionNode","./node/IndexNode","./node/ObjectNode","./node/OperatorNode","./node/ParenthesisNode","./node/RangeNode","./node/RelationalNode","./node/SymbolNode","35","../../error/IndexError","36","validateIndex","_getObjectProperty","dimension","_setObjectProperty","replacement","updated","Array, Index","isScalar","Matrix, Index","Object, Index","string, Index","strLen","v","Array, Index, any","Array, Index, any, any","defaultValue","Matrix, Index, any","Matrix, Index, any, any","string, Index, string","_setSubstring","string, Index, string, string","Object, Index, any","chars","_i","_len","../../error/DimensionError","../../type/matrix/function/matrix","37","any","any, Object | function | number","38","_typeof2","39","bignumber","","div","d","times","0","../../../utils/collection/deepMap","40","fraction","isFinite","number, number","numerator","denominator","41","hasStart","hasEnd","hasStep","parseFloat","nums","split","some","diff","sign","ceil","toArray","../../utils/number","42","_create","string, string","datatype","data","storage","Array | Matrix, string","Array | Matrix, string, string","43","NaN","Unit, string | Unit","unit","valuelessUnit","./../utils/collection/deepMap","44","getTypeOf","validInputTypes","validOutputTypes","outputType","inputType","../function/utils/typeof","./bignumber/function/bignumber","./fraction/function/fraction","./number","45","46","validate","_DimensionError","default","_validate","dim","dimNext","_number","isInteger","_IndexError","resize","_string","_defaultValue","_resize","oldLen","newLen","minLen","reshape","sizes","newArray","flatArray","flatten","product","arr","reduce","totalSize","sizeIndex","tmpArray2","tmpArray","_reshape","squeeze","arraySize","shift","dims","_squeeze","ii","unsqueeze","outer","unshift","_unsqueeze","filterRegExp","regexp","separator","identify","generalize","_interopRequireDefault","__esModule","flat","../error/DimensionError","../error/IndexError","./string","47","objectUtils","gt","notation","toFixed","toExponential","exponential","lower","upper","fixedOptions","lowerExp","round","log","LN10","upperExp","exp","logarithm","gte","lt","toSignificantDigits","replace","../object","48","49","skipZeros","50","51","safeNativeProperties","Function","method","getPrototypeOf","safeNativeMethods","isPlainObject","toLocaleString","./object","52","Emitter","on","off","once","tiny-emitter","53","symbols","Alpha","alpha","Beta","beta","Gamma","gamma","Delta","delta","Epsilon","varepsilon","Zeta","zeta","Eta","eta","Theta","theta","vartheta","Iota","iota","Kappa","kappa","varkappa","Lambda","lambda","Mu","mu","Nu","nu","Xi","xi","Omicron","omicron","Pi","varpi","Rho","rho","varrho","Sigma","sigma","varsigma","Tau","tau","Upsilon","upsilon","Phi","phi","varphi","Chi","chi","Psi","psi","Omega","omega","inf","Inf","infinity","Infinity","oo","lim","transpose","ctranspose","factorial","pow","dotPow","dotMultiply","dotDivide","units","deg","escape-latex","54","zeros","toEngineering","toPrecision","splitNumber","exponent","dot","coefficients","parseInt","rounded","roundDigits","newExp","significandsDiff","abs","expDiff","decimalIdx","decimals","decimalVal","splitValue","pp","splice","first","DBL_EPSILON","EPSILON","nearlyEqual","y","55","extend","canDefineProperty","_value","_uninitialized","configurable","enumerable","names","./bignumber/isBigNumber","56","57","formatNumber","formatBigNumber","endsWith","text","search","formatArray","escaped","./bignumber/formatter","58","ctx","listener","evtArr","evts","liveEvents","59","ok","notOk","_types","anyType","_ignore","_conversions","ignore","findTypeByName","typeName","findInArray","hint","findTypeIndex","findTypeName","stringifyParams","typeNames","getTypeName","restParam","parseParam","matches","trim","notEmpty","notIgnore","matchingConversions","conversion","exactTypes","typeIndex","conversionIndex","convertibleTypes","hasRestParam","hasConversions","compileTest","test0","test1","tests","compileTests","varIndex","lastTest","testRestParam","getParamAtIndex","getExpectedTypeNames","excludeConversions","isExactType","mergeExpectedParams","uniq","flatMap","getLowestTypeIndex","getLowestConversionIndex","compareSignatures","signature1","signature2","param1","param2","compileArgConversion","conversion0","conversion1","splitParams","ignoreConversionTypes","_splitParams","typeGroups","filteredTypes","typeGroup","createTypedFunction","signaturesMap","parsedSignatures","parsedParam","isInvalidParam","notNull","parsedSignature","conflictingSignature","hasOverlap","len1","len2","restParam1","restParam2","hasConflictingParams","sort","ok0","ok1","ok2","ok3","ok4","ok5","allOk","test00","test10","test20","test30","test40","test50","test01","test11","test21","test31","test41","test51","fns","fnConvert","compiledConversions","fnPreprocess","offset","compileArgsPreprocessing","fn0","fn1","fn2","fn3","fn4","fn5","len0","len3","len4","len5","iStart","iEnd","generic","_name","matchingSignatures","nextMatchingDefs","actualType","category","lengths","maxLength","expectedLength","arg0","arg1","array1","array2","getName","extractSignatures","validateUnique","_signature","_fn","...Function","string, ...Function","addType","beforeObjectTest","addConversion"],"mappings":"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"}
\ No newline at end of file