summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.gitattributes2
-rw-r--r--.gitignore2
-rw-r--r--index.html12
-rw-r--r--main.js153
-rw-r--r--mathjs/mathjs-expression-parser.js13005
-rw-r--r--mathjs/mathjs-expression-parser.min.js1
-rw-r--r--mathjs/mathjs-expression-parser.min.js.map1
-rw-r--r--sounds/129655__perplessio__droplets-underwater.aiffbin0 -> 8929022 bytes
-rw-r--r--sounds/droplet.mp3bin0 -> 10608 bytes
9 files changed, 13176 insertions, 0 deletions
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..8ad74f7
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+# Normalize EOL for all files that Git considers text files.
+* text=auto eol=lf
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4709183
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+# Godot 4+ specific ignores
+.godot/
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..3b896ab
--- /dev/null
+++ b/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+ <head>
+ <meta charset="utf-8">
+ <title>robotic</title>
+ <script type="module" src="main.js"></script>
+ <script src="mathjs/mathjs-expression-parser.js"></script>
+ </head>
+ <body>
+ <div id="root"></div>
+ </body>
+</html>
diff --git a/main.js b/main.js
new file mode 100644
index 0000000..26741ea
--- /dev/null
+++ b/main.js
@@ -0,0 +1,153 @@
+const X_START = '8*cos(t)';
+const Y_START = '8*sin(t)';
+const equations = {
+ x: math.compile(X_START),
+ y: math.compile(Y_START),
+}
+
+window.onload = () => {
+ const root = document.getElementById('root');
+
+ const launchButton = document.createElement('input');
+ launchButton.type = 'button';
+ launchButton.value = 'Launch';
+ const xeq = document.createElement('input');
+ xeq.value = X_START;
+ xeq.onchange = (e) => {
+ equations.x = math.compile(e.target.value);
+ running = false;
+ path = computePath(equations, 0, 100, 0.1);
+ render(ctx, path, 0);
+ };
+ xeq.onkeydown = xeq.onchange;
+ xeq.onkeyup = xeq.onchange;
+ const yeq = document.createElement('input');
+ yeq.value = Y_START;
+ yeq.onchange = (e) => {
+ equations.y = math.compile(e.target.value);
+ running = false;
+ path = computePath(equations, 0, 100, 0.1);
+ render(ctx, path, 0);
+ };
+ yeq.onkeydown = yeq.onchange;
+ yeq.onkeyup = yeq.onchange;
+
+ root.appendChild(xeq);
+ root.appendChild(yeq);
+ root.appendChild(launchButton);
+
+ const canvas = document.createElement('canvas');
+ canvas.width = 600;
+ canvas.height = 600;
+ root.appendChild(canvas);
+
+ const ctx = canvas.getContext('2d');
+ ctx.translate(canvas.width/2, canvas.height/2)
+ ctx.scale(canvas.width/20, -canvas.height/20);
+ let path = computePath(equations, 0, 100, 0.1);
+
+ let running = false;
+ const step = (index) => {
+ render(ctx, path, index);
+ if (running && index < path.length-1) {
+ setTimeout(() => step(index+1), 10);
+ } else {
+ running = false;
+ render(ctx, path, 0);
+ }
+ }
+ launchButton.onclick = () => {
+ running = false;
+ setTimeout(() => { running=true; step(0); }, 20);
+ }
+ render(ctx, path, 0);
+}
+
+
+function render(ctx, path, index) {
+ const { width, height } = ctx.canvas;
+ ctx.fillStyle = 'black';
+ ctx.fillRect(-width, -height, 2*width, 2*height);
+ const [x0, y0] = path[index];
+ const [x1, y1] = path[index+1] || path[index];
+ const angle = Math.atan2(y1-y0, x1-x0);
+ drawGrid(ctx);
+ drawPath(ctx, path);
+ drawShip(ctx, [x0, y0], angle);
+}
+
+
+function drawShip(ctx, pos, angle) {
+ const transform = ctx.getTransform();
+ const { width, height } = ctx.canvas;
+ const [x, y] = pos;
+ ctx.translate(x, y);
+ ctx.rotate(angle);
+ ctx.fillStyle = 'white';
+ const STEP = 120/Math.min(width,height);
+ ctx.beginPath();
+ ctx.moveTo(0, 0);
+ ctx.lineTo(-STEP, -STEP);
+ ctx.lineTo(2*STEP, 0);
+ ctx.lineTo(-STEP, STEP);
+ ctx.lineTo(0, 0);
+ ctx.fill();
+ ctx.setTransform(transform);
+}
+
+
+function computePath(equations, start, end, step) {
+ const ts = [...Array(Math.floor((end-start)/step)).keys()].map(k => step * (start+k))
+ return ts.map(t => [ equations.x.eval({t}), equations.y.eval({t}) ]);
+}
+
+function drawGrid(ctx) {
+ ctx.scale(1, -1);
+ ctx.strokeStyle = 'white';
+ ctx.fillStyle = 'white';
+ const { width, height } = ctx.canvas;
+ ctx.font = `${200/Math.max(width, height)}px serif`;
+ ctx.lineWidth = 4 / Math.max(width, height);
+ const drawLine = (start, end) => {
+ ctx.beginPath();
+ ctx.moveTo(start[0], start[1]);
+ ctx.lineTo(end[0], end[1]);
+ ctx.stroke();
+ }
+ const drawXLabel = (x, y) => {
+ ctx.textAlign = 'right';
+ ctx.textBaseline = 'bottom';
+ ctx.fillText(`${x} `, x, y);
+ }
+
+ const drawYLabel = (x, y) => {
+ ctx.rotate(Math.PI/2);
+ ctx.textAlign = 'right';
+ ctx.textBaseline = 'bottom';
+ ctx.fillText(`${y} `, y, x);
+ ctx.rotate(-Math.PI/2);
+ }
+
+ const drawGrid = (start, end, step) => {
+ [...Array(1+Math.floor((end-start)/step)).keys()].forEach(z => {
+ z = (step*z)+start;
+ drawLine([z, start], [z, end]);
+ drawLine([start, z], [end, z]);
+ drawXLabel(z, end);
+ drawYLabel(end, z);
+ });
+ }
+ drawGrid(-10, 10, 2);
+ ctx.scale(1, -1);
+}
+
+function drawPath(ctx, path) {
+ const [ start, ...line ] = path;
+ const { width, height } = ctx.canvas;
+ ctx.strokeStyle = 'white';
+ ctx.lineWidth = 8 / Math.max(width, height);
+ ctx.beginPath();
+ ctx.moveTo(start[0], start[1]);
+ line.forEach(p => ctx.lineTo(p[0], p[1]));
+ ctx.stroke();
+}
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":"CAAA,SAAUA,GAAG,GAAoB,iBAAVC,SAAoC,oBAATC,OAAsBA,OAAOD,QAAQD,SAAS,GAAmB,mBAATG,QAAqBA,OAAOC,IAAKD,OAAO,GAAGH,OAAO,EAA0B,oBAATK,OAAwBA,OAA+B,oBAATC,OAAwBA,OAA6B,oBAAPC,KAAsBA,KAAYC,MAAOC,KAAOT,KAAzT,CAAgU,WAAqC,OAAmB,SAASU,EAAEC,EAAEC,EAAEC,GAAG,SAASC,EAAEC,EAAEf,GAAG,IAAIY,EAAEG,GAAG,CAAC,IAAIJ,EAAEI,GAAG,CAAC,IAAIC,EAAE,mBAAmBC,SAASA,QAAQ,IAAIjB,GAAGgB,EAAE,OAAOA,EAAED,GAAE,GAAI,GAAGG,EAAE,OAAOA,EAAEH,GAAE,GAAI,IAAII,EAAE,IAAIC,MAAM,uBAAuBL,EAAE,KAAK,MAAMI,EAAEE,KAAK,mBAAmBF,EAAE,IAAIG,EAAEV,EAAEG,GAAG,CAACd,QAAQ,IAAIU,EAAEI,GAAG,GAAGQ,KAAKD,EAAErB,QAAQ,SAASS,GAAoB,OAAOI,EAAlBH,EAAEI,GAAG,GAAGL,IAAeA,IAAIY,EAAEA,EAAErB,QAAQS,EAAEC,EAAEC,EAAEC,GAAG,OAAOD,EAAEG,GAAGd,QAAQ,IAAI,IAAIiB,EAAE,mBAAmBD,SAASA,QAAQF,EAAE,EAAEA,EAAEF,EAAEW,OAAOT,IAAID,EAAED,EAAEE,IAAI,OAAOD,EAA7b,CAA4c,CAACW,EAAE,CAAC,SAASR,EAAQf,EAAOD,GAEp1B,IAIIQ,EAJOQ,EAAQ,eAIHS,SAEhBjB,EAAKkB,OAAOV,EAAQ,yCACpBR,EAAKkB,OAAOV,EAAQ,2CACpBR,EAAKkB,OAAOV,EAAQ,wCAEpBR,EAAKkB,OAAOV,EAAQ,sCAGpBR,EAAKkB,OAAO,CAEVC,IAAY,SAAUT,EAAGU,GAAK,OAAOV,EAAIU,GACzCC,SAAY,SAAUX,EAAGU,GAAK,OAAOV,EAAIU,GACzCE,SAAY,SAAUZ,EAAGU,GAAK,OAAOV,EAAIU,GACzCG,OAAY,SAAUb,EAAGU,GAAK,OAAOV,EAAIU,GACzCI,IAAY,SAAUd,EAAGU,GAAK,OAAOV,EAAIU,GACzCK,UAAY,SAAUf,GAAK,OAAQA,GACnCgB,WAAY,SAAUhB,GAAK,OAAQA,GAGnCiB,MAAiB,SAAUjB,EAAGU,GAAK,OAAOV,EAAIU,GAC9CQ,OAAiB,SAAUlB,EAAGU,GAAK,OAAOV,EAAIU,GAC9CS,OAAiB,SAAUnB,EAAGU,GAAK,OAAOV,EAAIU,GAC9CU,OAAiB,SAAUpB,GAAK,OAAQA,GACxCqB,UAAiB,SAAUrB,EAAGU,GAAK,OAAOV,GAAKU,GAC/CY,gBAAiB,SAAUtB,EAAGU,GAAK,OAAOV,GAAKU,GAC/Ca,cAAiB,SAAUvB,EAAGU,GAAK,OAAOV,IAAMU,GAGhDc,GAAK,SAAUxB,EAAGU,GAAK,SAAUV,IAAKU,IACtCe,IAAK,SAAUzB,EAAGU,GAAK,QAASV,KAAQU,GACxCgB,IAAK,SAAU1B,EAAGU,GAAK,SAAUV,IAAKU,IACtCiB,IAAK,SAAU3B,GAAK,OAAQA,GAG5B4B,MAAW,SAAU5B,EAAGU,GAAK,OAAOV,GAAKU,GACzCmB,QAAW,SAAU7B,EAAGU,GAAK,OAAOV,GAAKU,GACzCoB,QAAW,SAAU9B,EAAGU,GAAK,OAAOV,EAAIU,GACxCqB,OAAW,SAAU/B,EAAGU,GAAK,OAAWA,EAAJV,GACpCgC,UAAW,SAAUhC,EAAGU,GAAK,OAAOV,GAAKU,GACzCuB,SAAW,SAAUjC,EAAGU,GAAK,OAAYA,GAALV,GAIpCkC,OAAQ,WACN,MAAM,IAAIjC,MAAM,2BAElBkC,MAAO,WAEL,MAAM,IAAIlC,MAAM,iCAIlBmC,GAAIC,KAAKC,GACT9C,EAAG6C,KAAKE,EACRC,MAAQ,EACRC,OAAS,EACTC,KAAQ,OAIV,IAAIC,EAAc,GAClBC,OAAOC,oBAAoBR,MAAMS,QAAQ,SAAUC,GAE5CH,OAAOI,UAAUC,eAAeF,KACnCJ,EAAYI,GAAQV,KAAKU,MAG7BzD,EAAKkB,OAAOmC,GAEZ5D,EAAOD,QAAUQ,GAEf,CAAC4D,cAAc,EAAEC,yCAAyC,GAAGC,sCAAsC,GAAGC,uCAAuC,GAAGC,oCAAoC,KAAKC,EAAE,CAAC,SAASzD,EAAQf,EAAOD,GACtN,aAKA,IAAI0E,EAAWZ,OAAOa,QAAU,SAAUC,GAAU,IAAK,IAAI9D,EAAI,EAAGA,EAAI+D,UAAUtD,OAAQT,IAAK,CAAE,IAAIgE,EAASD,UAAU/D,GAAI,IAAK,IAAIiE,KAAOD,EAAchB,OAAOI,UAAUC,eAAe7C,KAAKwD,EAAQC,KAAQH,EAAOG,GAAOD,EAAOC,IAAY,OAAOH,GAEnPI,EAAiB,CACnBC,IAAK,MACLC,IAAK,MACLC,KAAM,oBACNC,IAAK,MACLC,EAAG,MACHC,IAAK,MACLC,IAAK,MACLC,IAAK,sBACLC,EAAG,MACHC,IAAK,sBAEHC,EAAgB,CAClBC,IAAU,OACVC,IAAU,QACVC,IAAK,IACLC,KAAM,YACNC,OAAQ,cACRC,KAAM,eAGJC,EAAqB,SAA4BlB,EAAgBW,GACnE,OAAOjB,EAAS,GAAIM,EAAgBW,IAWtC1F,EAAOD,QAAU,SAAUmG,GAmCzB,IAlCA,IAAIC,EAA0B,EAAnBvB,UAAUtD,aAA+B8E,IAAjBxB,UAAU,GAAmBA,UAAU,GAAK,GAC3EyB,EAAwBF,EAAKG,mBAC7BA,OAA+CF,IAA1BC,GAA8CA,EACnEE,EAAmBJ,EAAKK,YACxBA,OAAmCJ,IAArBG,EAAiCN,EAAqBM,EAEpEE,EAAaC,OAAOR,GACpBS,EAAS,GAETC,EAAUJ,EAAY/B,EAAS,GAAIM,GAAiBuB,EAAqB7B,EAAS,GAAIiB,GAAiB,IACvGmB,EAAahD,OAAOiD,KAAKF,GAMzBG,EAAQ,WACV,IAAIC,GAAmB,EACvBH,EAAW9C,QAAQ,SAAUe,EAAK1B,GAC5B4D,GAGAP,EAAWnF,QAAUwD,EAAIxD,QAAUmF,EAAWQ,MAAM,EAAGnC,EAAIxD,UAAYwD,IACzE6B,GAAUC,EAAQC,EAAWzD,IAC7BqD,EAAaA,EAAWQ,MAAMnC,EAAIxD,OAAQmF,EAAWnF,QACrD0F,GAAmB,KAGlBA,IACHL,GAAUF,EAAWQ,MAAM,EAAG,GAC9BR,EAAaA,EAAWQ,MAAM,EAAGR,EAAWnF,UAIzCmF,GACLM,IAEF,OAAOJ,IAEP,IAAIO,EAAE,CAAC,SAASnG,EAAQf,EAAOD,GACjCC,EAAOD,QAAUgB,EAAQ,oBAEvB,CAACoG,kBAAkB,IAAIC,EAAE,CAAC,SAASrG,EAAQf,EAAOD,GACpD,aAEAgB,EAAQ,wBAER,IAAIsG,EAAYtG,EAAQ,qBAAqBsG,UAEzCC,EAAevG,EAAQ,WAEvBwG,EAAUxG,EAAQ,sBAElByG,EAAgBzG,EAAQ,qBAExB0G,EAAgB1G,EAAQ,qBAgC5BhB,EAAQyB,OAAS,SAAgBkG,GAE/B,GAA6B,mBAAlB7D,OAAOrC,OAChB,MAAM,IAAIN,MAAM,iHAIlB,IAAIyG,EAAY,GACZC,EAAY,GAEZrH,EAAOgH,EAAQM,MAAM,IACzBtH,EAAKuH,KAAO,GACZvH,EAAKwH,WAAa,CAChBC,UAAW,GACXC,kBAAmB,IAGrB1H,EAAK2H,MAAQZ,EAAa9F,OAAOjB,EAAKuH,MAEtC,IAAIK,EAAU,CAGZC,QAAS,MAETjF,OAAQ,SAERkF,OAAQ,SAERC,UAAW,GAKXC,aAAa,EAGbC,WAAY,MAWd,SAASC,EAAKC,GACZ,IAAKrB,EAAUqB,GACb,MAAM,IAAIxH,MAAM,yEAGlB,IACIyH,EADAvF,EAAQuE,EAAUiB,QAAQF,GAoB9B,OAjBe,IAAXtF,GAIAuF,GAFmB,IAAjBD,EAAQnI,KAECmI,EAAQA,QAAQnI,EAAKuH,KAAMK,EAASM,EAAMlI,EAAK2H,MAAO3H,GAEtDmI,EAAQA,QAAQnI,EAAKuH,KAAMK,EAASM,EAAMlI,EAAK2H,OAI5DP,EAAUkB,KAAKH,GACfd,EAAUiB,KAAKF,IAGfA,EAAWf,EAAUxE,GAGhBuF,EAYT,OARApI,EAAa,OAAIkI,EAAKjB,GACtBjH,EAAa,OAAIkI,EAAKhB,GACtBlH,EAAKwH,WAAWE,kBAA0B,OAAI1H,EAAa,OAEvDmH,GACFnH,EAAKuI,OAAOpB,GAGPnH,IAEP,CAACwI,qBAAqB,GAAGC,oBAAoB,GAAGC,uBAAuB,GAAGC,oBAAoB,EAAEC,oBAAoB,EAAEC,UAAU,IAAIC,EAAE,CAAC,SAAStI,EAAQf,EAAOD,GACjK,aAEA,IAAIuJ,EAASvI,EAAQ,sBAiGrB,SAASwI,EAAe7B,EAAS1D,EAAMwF,GACrC,QAAsBpD,IAAlBsB,EAAQ1D,KAzBIyF,EAyB6BD,EAzBtBE,EAyB8BhC,EAAQ1D,IAxB7B,IAAzByF,EAAMb,QAAQc,IAwBgD,CACnE,IAAItG,GAfWqG,EAeOD,EAfAE,EAeQhC,EAAQ1D,GAdjCyF,EAAME,IAAI,SAAU9I,GACzB,OAAOA,EAAE+I,gBACRhB,QAAQc,EAAKE,iBAcC,IAAXxG,GAGFyG,QAAQC,KAAK,mDAAqD9F,EAAO,iBAAmBwF,EAAOpG,GAAS,iBAAmBsE,EAAQ1D,GAAQ,MAC/I0D,EAAQ1D,GAAQwF,EAAOpG,IAGvByG,QAAQC,KAAK,2BAA6BpC,EAAQ1D,GAAQ,+BAAiCA,EAAO,yBAA2BwF,EAAOG,IAAII,KAAKC,WAAWC,KAAK,MAAQ,KAxB3K,IAAmBR,EAAOC,EAXRD,EAAOC,EAwCzB3J,EAAQiE,KAAO,SACfjE,EAAQQ,MAAO,EAEfR,EAAQ2I,QAlHR,SAAiBZ,EAAMgB,EAAQL,EAAMP,EAAO3H,GAC1C,IAAI2J,EAAS,CAAC,SAAU,SAEpBC,EAAS,CAAC,SAAU,YAAa,YAqCrC,SAAShC,EAAQT,GACf,GAAIA,EAAS,CACX,IAAI0C,EAAOd,EAAOK,IAAIb,EAAQQ,EAAOe,OAErCd,EAAe7B,EAAS,SAAUwC,GAClCX,EAAe7B,EAAS,SAAUyC,GAElCb,EAAOgB,WAAWxB,EAAQpB,GAC1B,IAAI6C,EAAOjB,EAAOK,IAAIb,EAAQQ,EAAOe,OACjCG,EAAUlB,EAAOK,IAAIjC,EAAS4B,EAAOe,OAGzC,OADA9J,EAAKkK,KAAK,SAAUF,EAAMH,EAAMI,GACzBD,EAEP,OAAOjB,EAAOK,IAAIb,EAAQQ,EAAOe,OAOrC,OAFAlC,EAAQ+B,OAASA,EACjB/B,EAAQgC,OAASA,EACVhC,IAsDP,CAACuC,qBAAqB,KAAKC,EAAE,CAAC,SAAS5J,EAAQf,EAAOD,GACxD,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAII,EAAOlK,EAAQ,sBAAsBkK,KAErC5D,EAAYtG,EAAQ,sBAAsBsG,UAE1C6D,EAAWnK,EAAQ,sBAAsBmK,SAEzCC,EAAiBpK,EAAQ,8BAkT7BhB,EAAQQ,MAAO,EAEfR,EAAQiE,KAAO,SACfjE,EAAQ2I,QAnTR,SAAiBZ,EAAMgB,EAAQL,EAAMP,EAAO3H,GAgG1C,SAAS6K,EAAQpH,EAAMqH,EAAO3D,GAO5B,GALIA,EAAQ4D,MAAyB,mBAAVD,IA4EvBE,EAAU,WAGZ,IAFA,IAAIC,EAAO,GAEF3K,EAAI,EAAG4K,EAAM7G,UAAUtD,OAAQT,EAAI4K,EAAK5K,IAAK,CACpD,IAAI6K,EAAM9G,UAAU/D,GACpB2K,EAAK3K,GAAK6K,GAAOA,EAAIC,UAGvB,OAAOC,EAAGC,MAAMtL,EAAMiL,KATXI,EAzEGP,GAqFTrD,YACLuD,EAAQvD,UAAY4D,EAAG5D,WAtFvBqD,EAyFKE,GAtFHO,EAAgBvL,EAAKyD,KAAU8H,EAAgBT,GAgBjD,OAbEA,EAFE3D,EAAQqE,SAEF7D,EAAMlE,EAAMqH,EAAMW,YAGlB9D,EAAM3H,EAAKyD,GAAOqH,GAK5BY,EAAiBjI,EAFjBzD,EAAKyD,GAAQqH,QAIb9K,EAAKkK,KAAK,SAAUzG,EAAM,WACxB,OAAOqH,IAwDb,IAAeO,EACTL,EApDJ,QAAmBnF,IAAf7F,EAAKyD,IAAuB0D,EAAQqE,SAQtC,OALAE,EAAiBjI,EAFjBzD,EAAKyD,GAAQqH,QAIb9K,EAAKkK,KAAK,SAAUzG,EAAM,WACxB,OAAOqH,IAKX,IAAK3D,EAAQwE,OACX,MAAM,IAAIhL,MAAM,kBAAoB8C,EAAO,qBAI/C,SAASiI,EAAiBjI,EAAMqH,GAC1BA,GAAoC,mBAApBA,EAAMrD,WACxBzH,EAAKwH,WAAWC,UAAUhE,GAAQqH,EAAMrD,UAEpCmE,EAAqBnI,KACvBzD,EAAKwH,WAAWE,kBAAkBjE,GAAQqH,EAAMrD,oBAI3CzH,EAAKwH,WAAWC,UAAUhE,GAE7BmI,EAAqBnI,KACvBzD,EAAKwH,WAAWE,kBAAkBjE,GAAQqH,IAKhD,SAASe,EAAiBpI,UACjBzD,EAAKwH,WAAWC,UAAUhE,GAE7BmI,EAAqBnI,GACvBzD,EAAKwH,WAAWE,kBAAkBjE,GAAQzD,EAAKyD,UAExCzD,EAAKwH,WAAWE,kBAAkBjE,GAsC7C,SAASqI,EAAe3D,EAAShB,GAC/B,GAA4B,iBAAjBgB,EAAQ1E,KAAmB,CACpC,IAAIA,EAAO0E,EAAQ1E,KACfsI,EAAoBtI,KAAQzD,EAAKwH,WAAWC,UAC5CuE,EAAY7D,EAAQ8D,KAAOtB,EAAS3K,EAAMmI,EAAQ8D,MAAQjM,EAC1DkM,EAAWF,EAAUrI,eAAeF,GAAQuI,EAAUvI,QAAQoC,EAE9DsG,EAAW,WACb,IAAI/D,EAAWF,EAAKC,GAEpB,GAAIC,GAA0C,mBAAvBA,EAASX,UAC9B,MAAM,IAAI9G,MAAM,yIAGlB,GAAI4K,EAAgBW,IAAaX,EAAgBnD,GAO/C,OANIjB,EAAQqE,WAGVpD,EAAWT,EAAMuE,EAAU9D,IAGtBA,EAGT,QAAiBvC,IAAbqG,GAA0B/E,EAAQqE,SACpC,OAAOpD,EAGT,IAAKjB,EAAQwE,OACX,MAAM,IAAIhL,MAAM,kBAAoB8C,EAAO,uBAI1B,IAAjB0E,EAAQuC,MACVA,EAAKsB,EAAWvI,EAAM0I,GAElBJ,EACFF,EAAiBpI,IAEI,yBAAjB0E,EAAQ8D,MAAmCG,EAA4BjE,KACzEuC,EAAK1K,EAAKwH,WAAWE,kBAAmBjE,EAAM0I,KAIlDH,EAAUvI,GAAQ0I,IAEdJ,EACFF,EAAiBpI,IAEI,yBAAjB0E,EAAQ8D,MAAmCG,EAA4BjE,MACzEnI,EAAKwH,WAAWE,kBAAkBjE,GAAQ0I,MAKhDnM,EAAKkK,KAAK,SAAUzG,EAAM0I,EAAUhE,EAAQ8D,WAI5C/D,EAAKC,GAqBT,SAASoD,EAAgBF,GACvB,MAAqB,mBAAPA,GAAgD,WAA3BhB,EAAQgB,EAAGI,YAGhD,SAASG,EAAqBnI,GAC5B,OAAQ4I,EAAO1I,eAAeF,GAGhC,SAAS2I,EAA4BjE,GACnC,YAAwBtC,IAAjBsC,EAAQ8D,OAAuBI,EAAO1I,eAAewE,EAAQ1E,MAItE,IAAI4I,EAAS,CACX7E,YAAc,EACdD,MAAQ,EACR+E,MAAQ,EACRC,OAAS,EACTC,MAAQ,EACRC,OAAS,GAGX,OA7PA,SAASC,EAAW3D,EAAQ5B,GAC1B,IA4NuB4B,EA5NnB4D,EAAMtI,UAAUtD,OAEpB,GAAY,IAAR4L,GAAqB,IAARA,EACf,MAAM,IAAI/B,EAAe,SAAU+B,EAAK,EAAG,GAQ7C,GALKxF,IACHA,EAAU,IAIRL,EAAUiC,GACZ+C,EAAe/C,EAAQ5B,QAClB,GAAIyF,MAAMC,QAAQ9D,GACvBA,EAAOvF,QAAQ,SAAUsJ,GACvBJ,EAAWI,EAAO3F,UAEf,GAAwB,WAApBkD,EAAQtB,IAEjB,IAAK,IAAItF,KAAQsF,EACf,GAAIA,EAAOpF,eAAeF,GAAO,CAC/B,IAAIqH,EAAQ/B,EAAOtF,GAwMA,mBADFsF,EArMG+B,IAsM+B,iBAAX/B,GAAyC,iBAAXA,GAAyC,kBAAXA,GAAmC,OAAXA,GAAmBA,GAAUxB,EAAKwF,OAAOhE,IAAWA,GAAUxB,EAAKyF,UAAUjE,IAAWA,GAAUxB,EAAK0F,YAAYlE,IAAWA,GAAUxB,EAAK2F,WAAWnE,IAAWA,GAAUxB,EAAK4F,SAASpE,IAAWA,GAAU6D,MAAMC,QAAQ9D,GArMxV8B,EAAQpH,EAAMqH,EAAO3D,GACZL,EAAUiC,GACnB+C,EAAe/C,EAAQ5B,GAEvBuF,EAAW5B,EAAO3D,SAKxB,IAAKA,EAAQwE,OACX,MAAM,IAAIyB,UAAU,wCAiO5B5N,EAAQkL,MAAO,GACb,CAAC2C,6BAA6B,EAAElD,qBAAqB,KAAKmD,EAAE,CAAC,SAAS9M,EAAQf,EAAOD,GACvF,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAIiD,EAAgB/M,EAAQ,kBAExBgN,EAAShN,EAAQ,qBAAqBgN,OAEtCP,EAAczM,EAAQ,oCAEtB2M,EAAW3M,EAAQ,kCAGnBiN,EAAe,WAIjB,OADAA,EAAeF,EAActM,OACtBsM,GAST/N,EAAQyB,OAAS,SAAgBsG,GAe/BA,EAAKmG,SAAW,SAAUC,GACxB,MAAoB,iBAANA,GAGhBpG,EAAKyF,UAAY,SAAUW,GACzB,OAAOpG,EAAKqG,SAAWD,aAAapG,EAAKqG,UAAW,GAGtDrG,EAAK0F,YAAcA,EAEnB1F,EAAK2F,WAAa,SAAUS,GAC1B,OAAOpG,EAAKsG,UAAYF,aAAapG,EAAKsG,WAAY,GAGxDtG,EAAKwF,OAAS,SAAUY,GACtB,OAAOA,GAAKA,EAAElD,YAAY/G,UAAUqJ,SAAU,GAGhDxF,EAAKuG,SAAW,SAAUH,GACxB,MAAoB,iBAANA,GAGhBpG,EAAKsF,QAAUD,MAAMC,QACrBtF,EAAK4F,SAAWA,EAEhB5F,EAAKwG,cAAgB,SAAUJ,GAC7B,OAAOA,GAAKA,EAAEI,eAAiBJ,EAAElD,YAAY/G,UAAUyJ,WAAY,GAGrE5F,EAAKyG,eAAiB,SAAUL,GAC9B,OAAOA,GAAKA,EAAEK,gBAAkBL,EAAElD,YAAY/G,UAAUyJ,WAAY,GAGtE5F,EAAK0G,QAAU,SAAUN,GACvB,OAAOA,GAAKA,EAAElD,YAAY/G,UAAUuK,UAAW,GAGjD1G,EAAK2G,QAAU,SAAUP,GACvB,OAAOA,GAAKA,EAAElD,YAAY/G,UAAUwK,UAAW,GAGjD3G,EAAK4G,UAAY,SAAUR,GACzB,MAAoB,kBAANA,GAGhBpG,EAAK6G,YAAc,SAAUT,GAC3B,OAAOA,GAAKA,EAAElD,YAAY/G,UAAU0K,cAAe,GAGrD7G,EAAK8G,OAAS,SAAUV,GACtB,OAAOA,GAAKA,EAAElD,YAAY/G,UAAU2K,SAAU,GAGhD9G,EAAK+G,WAAa,SAAUX,GAC1B,MAAoB,mBAANA,GAGhBpG,EAAKgH,OAAS,SAAUZ,GACtB,OAAOA,aAAaa,MAGtBjH,EAAKkH,SAAW,SAAUd,GACxB,OAAOA,aAAae,QAGtBnH,EAAKoH,SAAW,SAAUhB,GACxB,MAAsB,WAAftD,EAAQsD,IAAmBA,EAAElD,cAAgBnH,SAAWiE,EAAKyF,UAAUW,KAAOpG,EAAK2F,WAAWS,IAGvGpG,EAAKqH,OAAS,SAAUjB,GACtB,OAAa,OAANA,GAGTpG,EAAKsH,YAAc,SAAUlB,GAC3B,YAAa9H,IAAN8H,GAGTpG,EAAKuH,eAAiB,SAAUnB,GAC9B,OAAOA,GAAKA,EAAEmB,gBAAkBnB,EAAElD,YAAY/G,UAAUqL,SAAU,GAGpExH,EAAKyH,YAAc,SAAUrB,GAC3B,OAAOA,GAAKA,EAAEqB,aAAerB,EAAElD,YAAY/G,UAAUqL,SAAU,GAGjExH,EAAK0H,iBAAmB,SAAUtB,GAChC,OAAOA,GAAKA,EAAEsB,kBAAoBtB,EAAElD,YAAY/G,UAAUqL,SAAU,GAGtExH,EAAK2H,YAAc,SAAUvB,GAC3B,OAAOA,GAAKA,EAAEuB,aAAevB,EAAElD,YAAY/G,UAAUqL,SAAU,GAGjExH,EAAK4H,kBAAoB,SAAUxB,GACjC,OAAOA,GAAKA,EAAEwB,mBAAqBxB,EAAElD,YAAY/G,UAAUqL,SAAU,GAGvExH,EAAK6H,eAAiB,SAAUzB,GAC9B,OAAOA,GAAKA,EAAEyB,gBAAkBzB,EAAElD,YAAY/G,UAAUqL,SAAU,GAGpExH,EAAK8H,yBAA2B,SAAU1B,GACxC,OAAOA,GAAKA,EAAE0B,0BAA4B1B,EAAElD,YAAY/G,UAAUqL,SAAU,GAG9ExH,EAAK+H,eAAiB,SAAU3B,GAC9B,OAAOA,GAAKA,EAAE2B,gBAAkB3B,EAAElD,YAAY/G,UAAUqL,SAAU,GAGpExH,EAAKgI,YAAc,SAAU5B,GAC3B,OAAOA,GAAKA,EAAE4B,aAAe5B,EAAElD,YAAY/G,UAAUqL,SAAU,GAGjExH,EAAKwH,OAAS,SAAUpB,GACtB,OAAOA,GAAKA,EAAEoB,QAAUpB,EAAElD,YAAY/G,UAAUqL,SAAU,GAG5DxH,EAAKiI,aAAe,SAAU7B,GAC5B,OAAOA,GAAKA,EAAE6B,cAAgB7B,EAAElD,YAAY/G,UAAUqL,SAAU,GAGlExH,EAAKkI,eAAiB,SAAU9B,GAC9B,OAAOA,GAAKA,EAAE8B,gBAAkB9B,EAAElD,YAAY/G,UAAUqL,SAAU,GAGpExH,EAAKmI,kBAAoB,SAAU/B,GACjC,OAAOA,GAAKA,EAAE+B,mBAAqB/B,EAAElD,YAAY/G,UAAUqL,SAAU,GAGvExH,EAAKoI,YAAc,SAAUhC,GAC3B,OAAOA,GAAKA,EAAEgC,aAAehC,EAAElD,YAAY/G,UAAUqL,SAAU,GAGjExH,EAAKqI,aAAe,SAAUjC,GAC5B,OAAOA,GAAKA,EAAEiC,cAAgBjC,EAAElD,YAAY/G,UAAUqL,SAAU,GAGlExH,EAAKsI,QAAU,SAAUlC,GACvB,OAAOA,GAAKA,EAAElD,YAAY/G,UAAUmM,UAAW,GAIjD,IAAIlI,EAAQ8F,IAyPZ,OApPA9F,EAAMmI,MAAQ,CAAC,CACbrM,KAAM,SACNsM,KAAMxI,EAAKmG,UACV,CACDjK,KAAM,UACNsM,KAAMxI,EAAKyF,WACV,CACDvJ,KAAM,YACNsM,KAAMxI,EAAK0F,aACV,CACDxJ,KAAM,WACNsM,KAAMxI,EAAK2F,YACV,CACDzJ,KAAM,OACNsM,KAAMxI,EAAKwF,QACV,CACDtJ,KAAM,SACNsM,KAAMxI,EAAKuG,UACV,CACDrK,KAAM,QACNsM,KAAMxI,EAAKsF,SACV,CACDpJ,KAAM,SACNsM,KAAMxI,EAAK4F,UACV,CACD1J,KAAM,cACNsM,KAAMxI,EAAKwG,eACV,CACDtK,KAAM,eACNsM,KAAMxI,EAAKyG,gBACV,CACDvK,KAAM,QACNsM,KAAMxI,EAAK0G,SACV,CACDxK,KAAM,QACNsM,KAAMxI,EAAK2G,SACV,CACDzK,KAAM,UACNsM,KAAMxI,EAAK4G,WACV,CACD1K,KAAM,YACNsM,KAAMxI,EAAK6G,aACV,CACD3K,KAAM,OACNsM,KAAMxI,EAAK8G,QACV,CACD5K,KAAM,WACNsM,KAAMxI,EAAK+G,YACV,CACD7K,KAAM,OACNsM,KAAMxI,EAAKgH,QACV,CACD9K,KAAM,SACNsM,KAAMxI,EAAKkH,UACV,CACDhL,KAAM,OACNsM,KAAMxI,EAAKqH,QACV,CACDnL,KAAM,YACNsM,KAAMxI,EAAKsH,aACV,CACDpL,KAAM,eACNsM,KAAMxI,EAAKkI,gBACV,CACDhM,KAAM,eACNsM,KAAMxI,EAAK6H,gBACV,CACD3L,KAAM,aACNsM,KAAMxI,EAAKqI,cACV,CACDnM,KAAM,kBACNsM,KAAMxI,EAAKmI,mBACV,CACDjM,KAAM,eACNsM,KAAMxI,EAAK+H,gBACV,CACD7L,KAAM,yBACNsM,KAAMxI,EAAK8H,0BACV,CACD5L,KAAM,YACNsM,KAAMxI,EAAKyH,aACV,CACDvL,KAAM,iBACNsM,KAAMxI,EAAK0H,kBACV,CACDxL,KAAM,YACNsM,KAAMxI,EAAK2H,aACV,CACDzL,KAAM,kBACNsM,KAAMxI,EAAK4H,mBACV,CACD1L,KAAM,YACNsM,KAAMxI,EAAKgI,aACV,CACD9L,KAAM,YACNsM,KAAMxI,EAAKoI,aACV,CACDlM,KAAM,OACNsM,KAAMxI,EAAKwH,QACV,CACDtL,KAAM,SACNsM,KAAMxI,EAAKoH,WAIbhH,EAAMqI,YAAc,CAAC,CACnBC,KAAM,SACNC,GAAI,YACJC,QAAS,SAAiBxC,GAExB,GAAgB,GAAZH,EAAOG,GACT,MAAM,IAAIP,UAAU,uFAA8FO,EAAI,yDAGxH,OAAO,IAAIpG,EAAK6I,UAAUzC,KAE3B,CACDsC,KAAM,SACNC,GAAI,UACJC,QAAS,SAAiBxC,GACxB,OAAO,IAAIpG,EAAKqG,QAAQD,EAAG,KAE5B,CACDsC,KAAM,SACNC,GAAI,SACJC,QAAS,SAAiBxC,GACxB,OAAOA,EAAI,KAEZ,CACDsC,KAAM,YACNC,GAAI,UACJC,QAAS,SAAiBxC,GACxB,OAAO,IAAIpG,EAAKqG,QAAQD,EAAE0C,WAAY,KAEvC,CACDJ,KAAM,WACNC,GAAI,YACJC,QAAS,SAAiBxC,GACxB,MAAM,IAAIP,UAAU,+JAErB,CACD6C,KAAM,WACNC,GAAI,UACJC,QAAS,SAAiBxC,GACxB,OAAO,IAAIpG,EAAKqG,QAAQD,EAAEvC,UAAW,KAEtC,CACD6E,KAAM,SACNC,GAAI,WACJC,QAAS,SAAiBxC,GAGxB,GAFQ,IAAIpG,EAAKsG,SAASF,GAEpBvC,YAAcuC,EAClB,MAAM,IAAIP,UAAU,mGAA0GO,EAAI,uDAGpI,OAAO,IAAIpG,EAAKsG,SAASF,KAE1B,CAQDsC,KAAM,SACNC,GAAI,SACJC,QAAS,SAAiBxC,GACxB,IAAIxN,EAAImQ,OAAO3C,GAEf,GAAI4C,MAAMpQ,GACR,MAAM,IAAIQ,MAAM,mBAAqBgN,EAAI,iBAG3C,OAAOxN,IAER,CACD8P,KAAM,SACNC,GAAI,YACJC,QAAS,SAAiBxC,GACxB,IACE,OAAO,IAAIpG,EAAK6I,UAAUzC,GAC1B,MAAO6C,GACP,MAAM,IAAI7P,MAAM,mBAAqBgN,EAAI,qBAG5C,CACDsC,KAAM,SACNC,GAAI,WACJC,QAAS,SAAiBxC,GACxB,IACE,OAAO,IAAIpG,EAAKsG,SAASF,GACzB,MAAO6C,GACP,MAAM,IAAI7P,MAAM,mBAAqBgN,EAAI,oBAG5C,CACDsC,KAAM,SACNC,GAAI,UACJC,QAAS,SAAiBxC,GACxB,IACE,OAAO,IAAIpG,EAAKqG,QAAQD,GACxB,MAAO6C,GACP,MAAM,IAAI7P,MAAM,mBAAqBgN,EAAI,mBAG5C,CACDsC,KAAM,UACNC,GAAI,SACJC,QAAS,SAAiBxC,GACxB,OAAQA,IAET,CACDsC,KAAM,UACNC,GAAI,YACJC,QAAS,SAAiBxC,GACxB,OAAO,IAAIpG,EAAK6I,WAAWzC,KAE5B,CACDsC,KAAM,UACNC,GAAI,WACJC,QAAS,SAAiBxC,GACxB,OAAO,IAAIpG,EAAKsG,UAAUF,KAE3B,CACDsC,KAAM,UACNC,GAAI,SACJC,QAAS,SAAiBxC,GACxB,OAAQA,IAET,CACDsC,KAAM,QACNC,GAAI,SACJC,QAAS,SAAiBjH,GACxB,OAAO,IAAI3B,EAAKkJ,YAAYvH,KAE7B,CACD+G,KAAM,SACNC,GAAI,QACJC,QAAS,SAAiBvN,GACxB,OAAOA,EAAOwI,aAGXzD,IAEP,CAAC+I,mCAAmC,GAAGC,iCAAiC,GAAGC,oBAAoB,GAAGC,iBAAiB,KAAKC,EAAE,CAAC,SAAStQ,EAAQf,EAAOD,GACrJ,aAWA,SAASoL,EAAeS,EAAI0F,EAAOC,EAAKC,GACtC,KAAMlR,gBAAgB6K,GACpB,MAAM,IAAIsG,YAAY,oDAGxBnR,KAAKsL,GAAKA,EACVtL,KAAKgR,MAAQA,EACbhR,KAAKiR,IAAMA,EACXjR,KAAKkR,IAAMA,EACXlR,KAAKoR,QAAU,yCAA2C9F,EAAK,KAAO0F,EAAQ,cAAgBC,GAAOC,MAAAA,EAAoC,IAAMA,EAAM,IAAM,aAC3JlR,KAAKqR,OAAQ,IAAIzQ,OAAQyQ,OAG3BxG,EAAelH,UAAY,IAAI/C,OACN8J,YAAc9J,MACvCiK,EAAelH,UAAUD,KAAO,iBAChCmH,EAAelH,UAAU2N,kBAAmB,EAC5C5R,EAAOD,QAAUoL,GACf,IAAI0G,EAAE,CAAC,SAAS9Q,EAAQf,EAAOD,GACjC,aAWA,SAAS+R,EAAeC,EAAQC,EAAUC,GACxC,KAAM3R,gBAAgBwR,GACpB,MAAM,IAAIL,YAAY,oDAGxBnR,KAAKyR,OAASA,EACdzR,KAAK0R,SAAWA,EAChB1R,KAAK2R,SAAWA,EAChB3R,KAAKoR,QAAU,wBAA0BvE,MAAMC,QAAQ2E,GAAU,IAAMA,EAAO9H,KAAK,MAAQ,IAAM8H,GAAU,KAAOzR,KAAK2R,UAAY,MAAQ,KAAO9E,MAAMC,QAAQ4E,GAAY,IAAMA,EAAS/H,KAAK,MAAQ,IAAM+H,GAAY,IAC1N1R,KAAKqR,OAAQ,IAAIzQ,OAAQyQ,OAG3BG,EAAe7N,UAAY,IAAIiO,YACNlH,YAAckH,WACvCJ,EAAe7N,UAAUD,KAAO,iBAChC8N,EAAe7N,UAAUkO,kBAAmB,EAC5CnS,EAAOD,QAAU+R,GACf,IAAIM,GAAG,CAAC,SAASrR,EAAQf,EAAOD,GAClC,aAYA,SAASsS,EAAWjP,EAAOmO,EAAKC,GAC9B,KAAMlR,gBAAgB+R,GACpB,MAAM,IAAIZ,YAAY,oDAGxBnR,KAAK8C,MAAQA,EAETwB,UAAUtD,OAAS,GACrBhB,KAAKiR,IAAM,EACXjR,KAAKkR,IAAMD,IAEXjR,KAAKiR,IAAMA,EACXjR,KAAKkR,IAAMA,QAGIpL,IAAb9F,KAAKiR,KAAqBjR,KAAK8C,MAAQ9C,KAAKiR,IAC9CjR,KAAKoR,QAAU,uBAAyBpR,KAAK8C,MAAQ,MAAQ9C,KAAKiR,IAAM,SAClDnL,IAAb9F,KAAKkR,KAAqBlR,KAAK8C,OAAS9C,KAAKkR,IACtDlR,KAAKoR,QAAU,uBAAyBpR,KAAK8C,MAAQ,OAAS9C,KAAKkR,IAAM,GAAK,IAE9ElR,KAAKoR,QAAU,uBAAyBpR,KAAK8C,MAAQ,IAGvD9C,KAAKqR,OAAQ,IAAIzQ,OAAQyQ,OAG3BU,EAAWpO,UAAY,IAAIiO,YACNlH,YAAckH,WACnCG,EAAWpO,UAAUD,KAAO,aAC5BqO,EAAWpO,UAAUqO,cAAe,EACpCtS,EAAOD,QAAUsS,GACf,IAAIE,GAAG,CAAC,SAASxR,EAAQf,EAAOD,GAClC,aAEA,IAAIyS,EAAUzR,EAAQ,kCAmDtBhB,EAAQiE,KAAO,UACfjE,EAAQ2I,QAlDR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIuK,EAAQhK,EAAK1H,EAAQ,aAoCzB,OAAOmH,EAAM,UAAW,CACtBwK,OAAU,SAAgBC,GACxB,OAAOF,EAAME,GAAMC,WAErBC,iBAAkB,SAAqBF,GACrC,OAAOH,EAAQG,EAAM,SAAUtF,GAC7B,OAAOoF,EAAMpF,GAAOuF,iBAQ1B,CAACE,iCAAiC,GAAGC,WAAW,KAAKC,GAAG,CAAC,SAASjS,EAAQf,EAAOD,GACnF,aAEA,IAAIyS,EAAUzR,EAAQ,kCA2DtBhB,EAAQiE,KAAO,OACfjE,EAAQ2I,QA1DR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIuK,EAAQhK,EAAK1H,EAAQ,aAkCzB,OAAOmH,EAAM,UAAW,CACtBwK,OAAU,SAAgBC,GAExB,OAAOF,EAAME,GAAMC,UAAUK,KADjB,KAGdC,iBAAkB,SAAsBP,EAAMQ,GAC5C,OAAOV,EAAME,GAAMC,UAAUK,KAAKE,IAEpCN,iBAAkB,SAAqBF,GACrC,IAAIQ,EAAQ,GACZ,OAAOX,EAAQG,EAAM,SAAUtF,GAC7B,OAAOoF,EAAMpF,GAAOuF,UAAUK,KAAKE,MAGvCC,yBAA0B,SAA2BT,EAAMQ,GACzD,OAAOX,EAAQG,EAAM,SAAUtF,GAC7B,OAAOoF,EAAMpF,GAAOuF,UAAUK,KAAKE,UAQzC,CAACL,iCAAiC,GAAGC,WAAW,KAAKM,GAAG,CAAC,SAAStS,EAAQf,EAAOD,GACnF,aAkDAA,EAAQiE,KAAO,QACfjE,EAAQ2I,QAjDR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIuK,EAAQhK,EAAK1H,EAAQ,aAyCzB,OAAOmH,EAAM,QAAS,CACpBoL,0BAA2Bb,EAC3Bc,kCAAmCd,MAMrC,CAACM,WAAW,KAAKS,GAAG,CAAC,SAASzS,EAAQf,EAAOD,GAC/C,aAEAC,EAAOD,QAAU,CACf0T,KAAK,IAEL,IAAIC,GAAG,CAAC,SAAS3S,EAAQf,EAAOD,GAClC,aAEA,IAAI4T,EAAkB5S,EAAQ,uBAAuB4S,gBAsMrD5T,EAAQiE,KAAO,eACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QAtMR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WACpB8S,EAASpL,EAAK1H,EAAQ,mBAW1B,SAAS+S,EAAaxK,EAAQlG,GAC5B,KAAM9C,gBAAgBwT,GACpB,MAAM,IAAIrC,YAAY,oDAGxB,IAAK3J,EAAKwH,OAAOhG,GACf,MAAM,IAAIqE,UAAU,wCAGtB,IAAK7F,EAAKgI,YAAY1M,GACpB,MAAM,IAAIuK,UAAU,4CAGtBrN,KAAKgJ,OAASA,GAAU,KACxBhJ,KAAK8C,MAAQA,EAEbS,OAAOkQ,eAAezT,KAAM,OAAQ,CAClC0T,IAAK,WACH,OAAI1T,KAAK8C,MACA9C,KAAK8C,MAAM6Q,mBAAqB3T,KAAK8C,MAAM8Q,oBAAsB,GAEjE5T,KAAKgJ,OAAOtF,MAAQ,IAE7BmQ,KAAK7T,MACP8T,IAAK,WACH,MAAM,IAAIlT,MAAM,kDAsJtB,SAASmT,EAAgBC,GAEvB,QAASxM,EAAKuH,eAAeiF,IAASxM,EAAKyH,YAAY+E,IAASxM,EAAK6H,eAAe2E,IAASxM,EAAK+H,eAAeyE,IAASxM,EAAKiI,aAAauE,IAASxM,EAAKmI,kBAAkBqE,IAASxM,EAAKqI,aAAamE,IAGzM,OAtJAR,EAAa7P,UAAY,IAAI2P,GACN9L,KAAO,eAC9BgM,EAAa7P,UAAUoL,gBAAiB,EAexCyE,EAAa7P,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAChD,IAAIC,EAAanU,KAAKgJ,OAAOiL,SAAShU,EAAMiU,GAExCE,EAAYpU,KAAK8C,MAAMmR,SAAShU,EAAMiU,GAE1C,GAAIlU,KAAK8C,MAAM6Q,mBAAoB,CACjC,IAAIU,EAAOrU,KAAK8C,MAAM8Q,oBACtB,OAAO,SAA0Bf,EAAO3H,EAAMoJ,GAC5C,OAAOjB,EAAgBc,EAAWtB,EAAO3H,EAAMoJ,GAAUD,IAG3D,OAAO,SAA0BxB,EAAO3H,EAAMoJ,GAC5C,IAAItL,EAASmL,EAAWtB,EAAO3H,EAAMoJ,GACjCxR,EAAQsR,EAAUvB,EAAO3H,EAAMlC,GAEnC,OAAOuK,EAAOvK,EAAQlG,KAU5B0Q,EAAa7P,UAAUF,QAAU,SAAU8Q,GACzCA,EAASvU,KAAKgJ,OAAQ,SAAUhJ,MAChCuU,EAASvU,KAAK8C,MAAO,QAAS9C,OAUhCwT,EAAa7P,UAAU0F,IAAM,SAAUkL,GACrC,OAAO,IAAIf,EAAaxT,KAAKwU,QAAQD,EAASvU,KAAKgJ,OAAQ,SAAUhJ,OAAQA,KAAKwU,QAAQD,EAASvU,KAAK8C,MAAO,QAAS9C,SAQ1HwT,EAAa7P,UAAUoG,MAAQ,WAC7B,OAAO,IAAIyJ,EAAaxT,KAAKgJ,OAAQhJ,KAAK8C,QAS5C0Q,EAAa7P,UAAU8Q,UAAY,SAAUrN,GAC3C,IAAI4B,EAAShJ,KAAKgJ,OAAO0L,SAAStN,GAMlC,OAJI2M,EAAgB/T,KAAKgJ,UACvBA,EAAS,IAAMA,EAAS,KAGnBA,EAAShJ,KAAK8C,MAAM4R,SAAStN,IAStCoM,EAAa7P,UAAUgR,OAAS,SAAUvN,GACxC,IAAI4B,EAAShJ,KAAKgJ,OAAO2L,OAAOvN,GAMhC,OAJI2M,EAAgB/T,KAAKgJ,UACvBA,EAAS,iEAAmEA,EAAS,kEAGhFA,EAAShJ,KAAK8C,MAAM6R,OAAOvN,IASpCoM,EAAa7P,UAAUiR,OAAS,SAAUxN,GACxC,IAAI4B,EAAShJ,KAAKgJ,OAAO6L,MAAMzN,GAM/B,OAJI2M,EAAgB/T,KAAKgJ,UACvBA,EAAS,iCAGJA,EAAShJ,KAAK8C,MAAM+R,MAAMzN,IAQnCoM,EAAa7P,UAAUmR,OAAS,WAC9B,MAAO,CACLC,OAAQ,eACR/L,OAAQhJ,KAAKgJ,OACblG,MAAO9C,KAAK8C,QAYhB0Q,EAAawB,SAAW,SAAUvI,GAChC,OAAO,IAAI+G,EAAa/G,EAAKzD,OAAQyD,EAAK3J,QAarC0Q,IAMP,CAACyB,sBAAsB,GAAGC,SAAS,GAAGC,iBAAiB,KAAKC,GAAG,CAAC,SAAS3U,EAAQf,EAAOD,GAC1F,aAEA,IAAI4J,EAAM5I,EAAQ,qBAAqB4I,IA6LvC5J,EAAQiE,KAAO,YACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA7LR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WAQxB,SAAS4U,EAAUC,GACjB,KAAMtV,gBAAgBqV,GACpB,MAAM,IAAIlE,YAAY,oDAKxB,GAFAnR,KAAKsV,MAAQA,GAAS,IAEjBzI,MAAMC,QAAQ9M,KAAKsV,SAAWtV,KAAKsV,MAAMC,MAAM/N,EAAKwH,QACvD,MAAM,IAAI3B,UAAU,mCAItB,IAAImI,EAAa,WACf,MAAM,IAAI5U,MAAM,4EAGlB2C,OAAOkQ,eAAezT,KAAM,QAAS,CACnC0T,IAAK8B,EACL1B,IAAK0B,IA6JT,OAzJAH,EAAU1R,UAAY,IAAI2P,GACN9L,KAAO,YAC3B6N,EAAU1R,UAAUsL,aAAc,EAelCoG,EAAU1R,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAC7C,IAAIuB,EAAYpM,EAAIrJ,KAAKsV,MAAO,SAAUlM,GACxC,OAAOA,EAAK6K,SAAShU,EAAMiU,KAI7B,GAFwC,UAAzBjU,EAAKuI,SAAS3F,OAU3B,OAAO,SAAuBgQ,EAAO3H,EAAMoJ,GACzC,OAAOjL,EAAIoM,EAAW,SAAUC,GAC9B,OAAOA,EAAS7C,EAAO3H,EAAMoJ,MATjC,IAAIzR,EAAS5C,EAAK4C,OAClB,OAAO,SAAuBgQ,EAAO3H,EAAMoJ,GACzC,OAAOzR,EAAOwG,EAAIoM,EAAW,SAAUC,GACrC,OAAOA,EAAS7C,EAAO3H,EAAMoJ,QAiBrCe,EAAU1R,UAAUF,QAAU,SAAU8Q,GACtC,IAAK,IAAIhU,EAAI,EAAGA,EAAIP,KAAKsV,MAAMtU,OAAQT,IAErCgU,EADWvU,KAAKsV,MAAM/U,GACP,SAAWA,EAAI,IAAKP,OAWvCqV,EAAU1R,UAAU0F,IAAM,SAAUkL,GAGlC,IAFA,IAAIe,EAAQ,GAEH/U,EAAI,EAAGA,EAAIP,KAAKsV,MAAMtU,OAAQT,IACrC+U,EAAM/U,GAAKP,KAAKwU,QAAQD,EAASvU,KAAKsV,MAAM/U,GAAI,SAAWA,EAAI,IAAKP,OAGtE,OAAO,IAAIqV,EAAUC,IAQvBD,EAAU1R,UAAUoG,MAAQ,WAC1B,OAAO,IAAIsL,EAAUrV,KAAKsV,MAAM3O,MAAM,KAUxC0O,EAAU1R,UAAU8Q,UAAY,SAAUrN,GAIxC,MAAO,IAHKpH,KAAKsV,MAAMjM,IAAI,SAAU2K,GACnC,OAAOA,EAAKU,SAAStN,KAEJuC,KAAK,MAAQ,KAQlC0L,EAAU1R,UAAUmR,OAAS,WAC3B,MAAO,CACLC,OAAQ,YACRO,MAAOtV,KAAKsV,QAYhBD,EAAUL,SAAW,SAAUvI,GAC7B,OAAO,IAAI4I,EAAU5I,EAAK6I,QAU5BD,EAAU1R,UAAUgR,OAAS,SAAUvN,GAIrC,MAAO,kEAHKpH,KAAKsV,MAAMjM,IAAI,SAAU2K,GACnC,OAAOA,EAAKW,OAAOvN,KAE4DuC,KAAK,yCAA2C,mEASnI0L,EAAU1R,UAAUiR,OAAS,SAAUxN,GACrC,IAAIuO,EAAI,mBAcR,OAbA3V,KAAKsV,MAAM7R,QAAQ,SAAUuQ,GACvBA,EAAKsB,MACPK,GAAK3B,EAAKsB,MAAMjM,IAAI,SAAUuM,GAC5B,OAAOA,EAAUf,MAAMzN,KACtBuC,KAAK,KAERgM,GAAK3B,EAAKa,MAAMzN,GAIlBuO,GAAK,SAEPA,GAAK,kBAIAN,IAMP,CAACQ,oBAAoB,GAAGX,SAAS,KAAKY,GAAG,CAAC,SAASrV,EAAQf,EAAOD,GACpE,aAEA,IAAI4T,EAAkB5S,EAAQ,uBAAuB4S,gBAEjD0C,EAAkBtV,EAAQ,uBAAuBsV,gBAqTrDtW,EAAQiE,KAAO,iBACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QArTR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WACpB2D,EAAS+D,EAAK1H,EAAQ,mBACtB8S,EAASpL,EAAK1H,EAAQ,mBAEtBuV,EAAYvV,EAAQ,gBA6BxB,SAASwV,EAAejN,EAAQlG,EAAOiI,GACrC,KAAM/K,gBAAgBiW,GACpB,MAAM,IAAI9E,YAAY,oDAOxB,GAJAnR,KAAKgJ,OAASA,EACdhJ,KAAK8C,MAAQiI,EAAQjI,EAAQ,KAC7B9C,KAAK+K,MAAQA,GAASjI,GAEjB0E,EAAKqI,aAAa7G,KAAYxB,EAAKuH,eAAe/F,GACrD,MAAM,IAAIqE,UAAU,mDAGtB,GAAI7F,EAAKqI,aAAa7G,IAA2B,QAAhBA,EAAOtF,KACtC,MAAM,IAAI9C,MAAM,iCAGlB,GAAIZ,KAAK8C,QAAU0E,EAAKgI,YAAYxP,KAAK8C,OAEvC,MAAM,IAAIuK,UAAU,iCAGtB,IAAK7F,EAAKwH,OAAOhP,KAAK+K,OACpB,MAAM,IAAIsC,UAAU,4BAItB9J,OAAOkQ,eAAezT,KAAM,OAAQ,CAClC0T,IAAK,WACH,OAAI1T,KAAK8C,MACA9C,KAAK8C,MAAM6Q,mBAAqB3T,KAAK8C,MAAM8Q,oBAAsB,GAEjE5T,KAAKgJ,OAAOtF,MAAQ,IAE7BmQ,KAAK7T,MACP8T,IAAK,WACH,MAAM,IAAIlT,MAAM,kDAgJtB,SAASmT,EAAgBC,EAAMkC,GACxBA,IACHA,EAAc,QAGhB,IAAIC,EAAaH,EAAUI,cAAcpC,EAAMkC,GAC3CG,EAAiBL,EAAUI,cAAcpC,EAAKjJ,MAAOmL,GACzD,MAAuB,QAAhBA,GAA4C,OAAnBG,GAA2BA,GAAkBF,EAmF/E,OArOAF,EAAetS,UAAY,IAAI2P,GACN9L,KAAO,iBAChCyO,EAAetS,UAAUuL,kBAAmB,EAe5C+G,EAAetS,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAClD,IAAIC,EAAanU,KAAKgJ,OAAOiL,SAAShU,EAAMiU,GAExCE,EAAYpU,KAAK8C,MAAQ9C,KAAK8C,MAAMmR,SAAShU,EAAMiU,GAAY,KAE/DoC,EAAYtW,KAAK+K,MAAMkJ,SAAShU,EAAMiU,GAEtCxQ,EAAO1D,KAAKgJ,OAAOtF,KAEvB,GAAK1D,KAAK8C,MASH,CAAA,GAAI9C,KAAK8C,MAAM6Q,mBAAoB,CAExC,IAAIU,EAAOrU,KAAK8C,MAAM8Q,oBACtB,OAAO,SAA4Bf,EAAO3H,EAAMoJ,GAC9C,IAAItL,EAASmL,EAAWtB,EAAO3H,EAAMoJ,GACjCvJ,EAAQuL,EAAUzD,EAAO3H,EAAMoJ,GACnC,OAAOyB,EAAgB/M,EAAQqL,EAAMtJ,IAElC,GAAIvD,EAAKqI,aAAa7P,KAAKgJ,QAEhC,OAAO,SAA4B6J,EAAO3H,EAAMoJ,GAC9C,IAAIiC,EAAcpC,EAAWtB,EAAO3H,EAAMoJ,GACtCvJ,EAAQuL,EAAUzD,EAAO3H,EAAMoJ,GAC/BxR,EAAQsR,EAAUvB,EAAO3H,EAAMqL,GAGnC,OADAR,EAAgBlD,EAAOnP,EAAMU,EAAOmS,EAAazT,EAAOiI,IACjDA,GAQT,IAAIyL,EAAmBxW,KAAKgJ,OAAOA,OAAOiL,SAAShU,EAAMiU,GAEzD,GAAIlU,KAAKgJ,OAAOlG,MAAM6Q,mBAAoB,CACxC,IAAI8C,EAAazW,KAAKgJ,OAAOlG,MAAM8Q,oBACnC,OAAO,SAA4Bf,EAAO3H,EAAMoJ,GAC9C,IAAIoC,EAASF,EAAiB3D,EAAO3H,EAAMoJ,GACvCiC,EAAclD,EAAgBqD,EAAQD,GACtC3T,EAAQsR,EAAUvB,EAAO3H,EAAMqL,GAE/BxL,EAAQuL,EAAUzD,EAAO3H,EAAMoJ,GAEnC,OADAyB,EAAgBW,EAAQD,EAAYrS,EAAOmS,EAAazT,EAAOiI,IACxDA,GAIT,IAAI4L,EAAkB3W,KAAKgJ,OAAOlG,MAAMmR,SAAShU,EAAMiU,GAEvD,OAAO,SAA4BrB,EAAO3H,EAAMoJ,GAC9C,IAAIoC,EAASF,EAAiB3D,EAAO3H,EAAMoJ,GACvCsC,EAAcD,EAAgB9D,EAAO3H,EAAMwL,GAE3CH,EAAchD,EAAOmD,EAAQE,GAC7B9T,EAAQsR,EAAUvB,EAAO3H,EAAMqL,GAE/BxL,EAAQuL,EAAUzD,EAAO3H,EAAMoJ,GAEnC,OADAlQ,EAAOsS,EAAQE,EAAaxS,EAAOmS,EAAazT,EAAOiI,IAChDA,GAzDX,IAAKvD,EAAKqI,aAAa7P,KAAKgJ,QAC1B,MAAM,IAAIqE,UAAU,iCAGtB,OAAO,SAA4BwF,EAAO3H,EAAMoJ,GAC9C,OAAOyB,EAAgBlD,EAAOnP,EAAM4S,EAAUzD,EAAO3H,EAAMoJ,MA+DjE2B,EAAetS,UAAUF,QAAU,SAAU8Q,GAC3CA,EAASvU,KAAKgJ,OAAQ,SAAUhJ,MAE5BA,KAAK8C,OACPyR,EAASvU,KAAK8C,MAAO,QAAS9C,MAGhCuU,EAASvU,KAAK+K,MAAO,QAAS/K,OAUhCiW,EAAetS,UAAU0F,IAAM,SAAUkL,GAOvC,OAAO,IAAI0B,EANEjW,KAAKwU,QAAQD,EAASvU,KAAKgJ,OAAQ,SAAUhJ,OAE9CA,KAAK8C,MAAQ9C,KAAKwU,QAAQD,EAASvU,KAAK8C,MAAO,QAAS9C,OAAS,KAEjEA,KAAKwU,QAAQD,EAASvU,KAAK+K,MAAO,QAAS/K,SAUzDiW,EAAetS,UAAUoG,MAAQ,WAC/B,OAAO,IAAIkM,EAAejW,KAAKgJ,OAAQhJ,KAAK8C,MAAO9C,KAAK+K,QA0B1DkL,EAAetS,UAAU8Q,UAAY,SAAUrN,GAC7C,IAAI4B,EAAShJ,KAAKgJ,OAAO0L,SAAStN,GAC9BtE,EAAQ9C,KAAK8C,MAAQ9C,KAAK8C,MAAM4R,SAAStN,GAAW,GACpD2D,EAAQ/K,KAAK+K,MAAM2J,SAAStN,GAMhC,OAJI2M,EAAgB/T,KAAMoH,GAAWA,EAAQ8O,eAC3CnL,EAAQ,IAAMA,EAAQ,KAGjB/B,EAASlG,EAAQ,MAAQiI,GAQlCkL,EAAetS,UAAUmR,OAAS,WAChC,MAAO,CACLC,OAAQ,iBACR/L,OAAQhJ,KAAKgJ,OACblG,MAAO9C,KAAK8C,MACZiI,MAAO/K,KAAK+K,QAYhBkL,EAAejB,SAAW,SAAUvI,GAClC,OAAO,IAAIwJ,EAAexJ,EAAKzD,OAAQyD,EAAK3J,MAAO2J,EAAK1B,QAS1DkL,EAAetS,UAAUgR,OAAS,SAAUvN,GAC1C,IAAI4B,EAAShJ,KAAKgJ,OAAO2L,OAAOvN,GAC5BtE,EAAQ9C,KAAK8C,MAAQ9C,KAAK8C,MAAM6R,OAAOvN,GAAW,GAClD2D,EAAQ/K,KAAK+K,MAAM4J,OAAOvN,GAM9B,OAJI2M,EAAgB/T,KAAMoH,GAAWA,EAAQ8O,eAC3CnL,EAAQ,iEAAmEA,EAAQ,kEAG9E/B,EAASlG,EAAQ,uHAAyHiI,GASnJkL,EAAetS,UAAUiR,OAAS,SAAUxN,GAC1C,IAAI4B,EAAShJ,KAAKgJ,OAAO6L,MAAMzN,GAC3BtE,EAAQ9C,KAAK8C,MAAQ9C,KAAK8C,MAAM+R,MAAMzN,GAAW,GACjD2D,EAAQ/K,KAAK+K,MAAM8J,MAAMzN,GAM7B,OAJI2M,EAAgB/T,KAAMoH,GAAWA,EAAQ8O,eAC3CnL,EAAQ,UAAU8L,OAAO9L,EAAO,aAG3B/B,EAASlG,EAAQ,KAAOiI,GAG1BkL,IAMP,CAAChB,sBAAsB,GAAG6B,eAAe,GAAG5B,SAAS,GAAGC,iBAAiB,GAAG4B,iBAAiB,KAAKC,GAAG,CAAC,SAASvW,EAAQf,EAAOD,GAChI,aAEA,IAAIgE,EAAUhD,EAAQ,qBAAqBgD,QAEvC4F,EAAM5I,EAAQ,qBAAqB4I,IA0LvC5J,EAAQiE,KAAO,YACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA1LR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WACpBwW,EAAY9O,EAAK1H,EAAQ,mCAW7B,SAASyW,EAAUC,GACjB,KAAMnX,gBAAgBkX,GACpB,MAAM,IAAI/F,YAAY,oDAIxB,IAAKtE,MAAMC,QAAQqK,GAAS,MAAM,IAAIvW,MAAM,kBAC5CZ,KAAKmX,OAASA,EAAO9N,IAAI,SAAU+N,GACjC,IAAIpD,EAAOoD,GAASA,EAAMpD,KACtBqD,GAAUD,QAA2BtR,IAAlBsR,EAAMC,SAAwBD,EAAMC,QAC3D,IAAK7P,EAAKwH,OAAOgF,GAAO,MAAM,IAAI3G,UAAU,kCAC5C,GAAuB,kBAAZgK,EAAuB,MAAM,IAAIhK,UAAU,wCACtD,MAAO,CACL2G,KAAMA,EACNqD,QAASA,KA0Jf,OArJAH,EAAUvT,UAAY,IAAI2P,GACN9L,KAAO,YAC3B0P,EAAUvT,UAAUwL,aAAc,EAelC+H,EAAUvT,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAC7C,IAAIoD,EAAajO,EAAIrJ,KAAKmX,OAAQ,SAAUC,GAC1C,MAAO,CACLzE,KAAMyE,EAAMpD,KAAKC,SAAShU,EAAMiU,GAChCmD,QAASD,EAAMC,WAGnB,OAAO,SAAwBxE,EAAO3H,EAAMoJ,GAC1C,IAAIiD,EAAU,GAQd,OAPA9T,EAAQ6T,EAAY,SAAuBF,GACzC,IAAI/Q,EAAS+Q,EAAMzE,KAAKE,EAAO3H,EAAMoJ,GAEjC8C,EAAMC,SACRE,EAAQhP,KAAKlC,KAGV,IAAI4Q,EAAUM,KASzBL,EAAUvT,UAAUF,QAAU,SAAU8Q,GACtC,IAAK,IAAIhU,EAAI,EAAGA,EAAIP,KAAKmX,OAAOnW,OAAQT,IACtCgU,EAASvU,KAAKmX,OAAO5W,GAAGyT,KAAM,UAAYzT,EAAI,SAAUP,OAW5DkX,EAAUvT,UAAU0F,IAAM,SAAUkL,GAGlC,IAFA,IAAI4C,EAAS,GAEJ5W,EAAI,EAAGA,EAAIP,KAAKmX,OAAOnW,OAAQT,IAAK,CAC3C,IAAI6W,EAAQpX,KAAKmX,OAAO5W,GAEpByT,EAAOhU,KAAKwU,QAAQD,EAAS6C,EAAMpD,KAAM,UAAYzT,EAAI,SAAUP,OAEvEmX,EAAO5W,GAAK,CACVyT,KAAMA,EACNqD,QAASD,EAAMC,SAInB,OAAO,IAAIH,EAAUC,IAQvBD,EAAUvT,UAAUoG,MAAQ,WAO1B,OAAO,IAAImN,EANElX,KAAKmX,OAAO9N,IAAI,SAAU+N,GACrC,MAAO,CACLpD,KAAMoD,EAAMpD,KACZqD,QAASD,EAAMC,aAarBH,EAAUvT,UAAU8Q,UAAY,SAAUrN,GACxC,OAAOpH,KAAKmX,OAAO9N,IAAI,SAAUmO,GAC/B,OAAOA,EAAMxD,KAAKU,SAAStN,IAAYoQ,EAAMH,QAAU,GAAK,OAC3D1N,KAAK,OAQVuN,EAAUvT,UAAUmR,OAAS,WAC3B,MAAO,CACLC,OAAQ,YACRoC,OAAQnX,KAAKmX,SAYjBD,EAAUlC,SAAW,SAAUvI,GAC7B,OAAO,IAAIyK,EAAUzK,EAAK0K,SAU5BD,EAAUvT,UAAUgR,OAAS,SAAUvN,GACrC,OAAOpH,KAAKmX,OAAO9N,IAAI,SAAUmO,GAC/B,OAAOA,EAAMxD,KAAKW,OAAOvN,IAAYoQ,EAAMH,QAAU,GAAK,2CACzD1N,KAAK,+CASVuN,EAAUvT,UAAUiR,OAAS,SAAUxN,GACrC,OAAOpH,KAAKmX,OAAO9N,IAAI,SAAUmO,GAC/B,OAAOA,EAAMxD,KAAKa,MAAMzN,IAAYoQ,EAAMH,QAAU,GAAK,OACxD1N,KAAK,aAGHuN,IAMP,CAACO,iCAAiC,GAAG5B,oBAAoB,GAAGX,SAAS,KAAKwC,GAAG,CAAC,SAASjX,EAAQf,EAAOD,GACxG,aAEA,IAAIuW,EAAYvV,EAAQ,gBA0OxBhB,EAAQiE,KAAO,kBACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA1OR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WACpBkX,EAAaxP,EAAK1H,EAAQ,gCAY9B,SAASmX,EAAgBC,EAAWC,EAAUC,GAC5C,KAAM/X,gBAAgB4X,GACpB,MAAM,IAAIzG,YAAY,oDAGxB,IAAK3J,EAAKwH,OAAO6I,GAAY,MAAM,IAAIxK,UAAU,sCACjD,IAAK7F,EAAKwH,OAAO8I,GAAW,MAAM,IAAIzK,UAAU,qCAChD,IAAK7F,EAAKwH,OAAO+I,GAAY,MAAM,IAAI1K,UAAU,sCACjDrN,KAAK6X,UAAYA,EACjB7X,KAAK8X,SAAWA,EAChB9X,KAAK+X,UAAYA,EA6MnB,OA1MAH,EAAgBjU,UAAY,IAAI2P,GACN9L,KAAO,kBACjCoQ,EAAgBjU,UAAUyL,mBAAoB,EAe9CwI,EAAgBjU,UAAUsQ,SAAW,SAAUhU,EAAMiU,GACnD,IAAI8D,EAAgBhY,KAAK6X,UAAU5D,SAAShU,EAAMiU,GAE9C+D,EAAejY,KAAK8X,SAAS7D,SAAShU,EAAMiU,GAE5CgE,EAAgBlY,KAAK+X,UAAU9D,SAAShU,EAAMiU,GAElD,OAAO,SAA6BrB,EAAO3H,EAAMoJ,GAC/C,OAuJJ,SAAuBuD,GACrB,GAAyB,iBAAdA,GAA+C,kBAAdA,GAAgD,iBAAdA,EAC5E,QAASA,EAGX,GAAIA,EAAW,CACb,GAAIrQ,EAAK0F,YAAY2K,GACnB,OAAQA,EAAUM,SAGpB,GAAI3Q,EAAKyF,UAAU4K,GACjB,SAAUA,EAAUO,KAAMP,EAAUQ,IAGtC,GAAI7Q,EAAKwF,OAAO6K,GACd,QAASA,EAAU9M,MAIvB,GAAI8M,MAAAA,EAIJ,MAAM,IAAIxK,UAAU,kCAAoCsK,EAAWE,GAAa,KAH9E,OAAO,EA3KAS,CAAcN,EAAcnF,EAAO3H,EAAMoJ,IAAY2D,EAAapF,EAAO3H,EAAMoJ,GAAW4D,EAAcrF,EAAO3H,EAAMoJ,KAShIsD,EAAgBjU,UAAUF,QAAU,SAAU8Q,GAC5CA,EAASvU,KAAK6X,UAAW,YAAa7X,MACtCuU,EAASvU,KAAK8X,SAAU,WAAY9X,MACpCuU,EAASvU,KAAK+X,UAAW,YAAa/X,OAUxC4X,EAAgBjU,UAAU0F,IAAM,SAAUkL,GACxC,OAAO,IAAIqD,EAAgB5X,KAAKwU,QAAQD,EAASvU,KAAK6X,UAAW,YAAa7X,OAAQA,KAAKwU,QAAQD,EAASvU,KAAK8X,SAAU,WAAY9X,OAAQA,KAAKwU,QAAQD,EAASvU,KAAK+X,UAAW,YAAa/X,SAQpM4X,EAAgBjU,UAAUoG,MAAQ,WAChC,OAAO,IAAI6N,EAAgB5X,KAAK6X,UAAW7X,KAAK8X,SAAU9X,KAAK+X,YASjEH,EAAgBjU,UAAU8Q,UAAY,SAAUrN,GAC9C,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEC,EAAaH,EAAUI,cAAcpW,KAAMkW,GAK3C2B,EAAY7X,KAAK6X,UAAUnD,SAAStN,GACpCmR,EAAsBvC,EAAUI,cAAcpW,KAAK6X,UAAW3B,IAE9C,QAAhBA,GAAiD,iBAAxBlW,KAAK6X,UAAUrQ,MAAmD,OAAxB+Q,GAAgCA,GAAuBpC,KAC5H0B,EAAY,IAAMA,EAAY,KAGhC,IAAIC,EAAW9X,KAAK8X,SAASpD,SAAStN,GAClCoR,EAAiBxC,EAAUI,cAAcpW,KAAK8X,SAAU5B,IAExC,QAAhBA,GAAgD,iBAAvBlW,KAAK8X,SAAStQ,MAA8C,OAAnBgR,GAA2BA,GAAkBrC,KACjH2B,EAAW,IAAMA,EAAW,KAG9B,IAAIC,EAAY/X,KAAK+X,UAAUrD,SAAStN,GACpCqR,EAAkBzC,EAAUI,cAAcpW,KAAK+X,UAAW7B,GAM9D,OAJoB,QAAhBA,GAAiD,iBAAxBlW,KAAK+X,UAAUvQ,MAA+C,OAApBiR,GAA4BA,GAAmBtC,KACpH4B,EAAY,IAAMA,EAAY,KAGzBF,EAAY,MAAQC,EAAW,MAAQC,GAQhDH,EAAgBjU,UAAUmR,OAAS,WACjC,MAAO,CACLC,OAAQ,kBACR8C,UAAW7X,KAAK6X,UAChBC,SAAU9X,KAAK8X,SACfC,UAAW/X,KAAK+X,YAYpBH,EAAgB5C,SAAW,SAAUvI,GACnC,OAAO,IAAImL,EAAgBnL,EAAKoL,UAAWpL,EAAKqL,SAAUrL,EAAKsL,YASjEH,EAAgBjU,UAAUgR,OAAS,SAAUvN,GAC3C,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEC,EAAaH,EAAUI,cAAcpW,KAAMkW,GAK3C2B,EAAY7X,KAAK6X,UAAUlD,OAAOvN,GAClCmR,EAAsBvC,EAAUI,cAAcpW,KAAK6X,UAAW3B,IAE9C,QAAhBA,GAAiD,iBAAxBlW,KAAK6X,UAAUrQ,MAAmD,OAAxB+Q,GAAgCA,GAAuBpC,KAC5H0B,EAAY,iEAAmEA,EAAY,kEAG7F,IAAIC,EAAW9X,KAAK8X,SAASnD,OAAOvN,GAChCoR,EAAiBxC,EAAUI,cAAcpW,KAAK8X,SAAU5B,IAExC,QAAhBA,GAAgD,iBAAvBlW,KAAK8X,SAAStQ,MAA8C,OAAnBgR,GAA2BA,GAAkBrC,KACjH2B,EAAW,iEAAmEA,EAAW,kEAG3F,IAAIC,EAAY/X,KAAK+X,UAAUpD,OAAOvN,GAClCqR,EAAkBzC,EAAUI,cAAcpW,KAAK+X,UAAW7B,GAM9D,OAJoB,QAAhBA,GAAiD,iBAAxBlW,KAAK+X,UAAUvQ,MAA+C,OAApBiR,GAA4BA,GAAmBtC,KACpH4B,EAAY,iEAAmEA,EAAY,kEAGtFF,EAAY,iEAAmEC,EAAW,iEAAmEC,GAStKH,EAAgBjU,UAAUiR,OAAS,SAAUxN,GAC3C,MAAO,mBAAqBpH,KAAK8X,SAASjD,MAAMzN,GAAW,4BAA8BpH,KAAK6X,UAAUhD,MAAMzN,GAAW,SAAWpH,KAAK+X,UAAUlD,MAAMzN,GAAW,6CAmC/JwQ,IAMP,CAACc,8BAA8B,GAAG5B,eAAe,GAAG5B,SAAS,KAAKyD,GAAG,CAAC,SAASlY,EAAQf,EAAOD,GAChG,aAEA,IAAImZ,EAASnY,EAAQ,sBAAsBmY,OAEvCC,EAAcpY,EAAQ,qBAAqBqY,OAuL/CrZ,EAAQiE,KAAO,eACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QAvLR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WACpBsY,EAAU5Q,EAAK1H,EAAQ,gCAc3B,SAASuY,EAAajO,GACpB,KAAM/K,gBAAgBgZ,GACpB,MAAM,IAAI7H,YAAY,oDAGxB,GAAyB,IAArB7M,UAAUtD,OAEZ,MAAM,IAAImQ,YAAY,kKAGxBnR,KAAK+K,MAAQA,EAwJf,OArJAiO,EAAarV,UAAY,IAAI2P,GACN9L,KAAO,eAC9BwR,EAAarV,UAAU0L,gBAAiB,EAexC2J,EAAarV,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAChD,IAAInJ,EAAQ/K,KAAK+K,MACjB,OAAO,WACL,OAAOA,IASXiO,EAAarV,UAAUF,QAAU,SAAU8Q,KAU3CyE,EAAarV,UAAU0F,IAAM,SAAUkL,GACrC,OAAOvU,KAAK+J,SAQdiP,EAAarV,UAAUoG,MAAQ,WAC7B,OAAO,IAAIiP,EAAahZ,KAAK+K,QAS/BiO,EAAarV,UAAU8Q,UAAY,SAAUrN,GAC3C,OAAOwR,EAAO5Y,KAAK+K,MAAO3D,IAS5B4R,EAAarV,UAAUgR,OAAS,SAAUvN,GACxC,IAAI2D,EAAQ/K,KAAKyU,UAAUrN,GAE3B,OAAQ2R,EAAQ/Y,KAAK+K,QACnB,IAAK,SACL,IAAK,YACL,IAAK,WACH,MAAO,6BAA+BA,EAAQ,UAEhD,IAAK,SACH,MAAO,6BAA+BA,EAAQ,UAEhD,IAAK,UACH,MAAO,8BAAgCA,EAAQ,UAEjD,IAAK,OACH,MAAO,kCAAoCA,EAAQ,UAErD,IAAK,YACH,MAAO,gCAAkCA,EAAQ,UAEnD,QACE,MAAO,6BAA+BA,EAAQ,YASpDiO,EAAarV,UAAUmR,OAAS,WAC9B,MAAO,CACLC,OAAQ,eACRhK,MAAO/K,KAAK+K,QAYhBiO,EAAahE,SAAW,SAAUvI,GAChC,OAAO,IAAIuM,EAAavM,EAAK1B,QAS/BiO,EAAarV,UAAUiR,OAAS,SAAUxN,GACxC,IAAI2D,EAAQ/K,KAAKyU,UAAUrN,GAE3B,OAAQ2R,EAAQ/Y,KAAK+K,QACnB,IAAK,SACH,MAAO,YAAc8N,EAAY9N,GAAS,IAE5C,IAAK,SACL,IAAK,YACH,IAAIjI,EAAQiI,EAAMzB,cAAchB,QAAQ,KAExC,OAAe,IAAXxF,EACKiI,EAAMkO,UAAU,EAAGnW,GAAS,aAAeiI,EAAMkO,UAAUnW,EAAQ,GAAK,IAG1EiI,EAET,IAAK,WACH,OAAO/K,KAAK+K,MAAMmO,UAEpB,QACE,OAAOnO,IAINiO,IAMP,CAACN,8BAA8B,GAAGS,oBAAoB,GAAGC,qBAAqB,GAAGlE,SAAS,KAAKmE,GAAG,CAAC,SAAS5Y,EAAQf,EAAOD,GAC7H,aAEA,IAAI6Z,EAAW7Y,EAAQ,eAEnBqY,EAASrY,EAAQ,sBAAsBqY,OAEvCrV,EAAUhD,EAAQ,qBAAqBgD,QAEvCkG,EAAOlJ,EAAQ,qBAAqBkJ,KAEpC4P,EAAQ9Y,EAAQ,qBAEhBuV,EAAYvV,EAAQ,gBAEpBsV,EAAkBtV,EAAQ,uBAAuBsV,gBA8NrDtW,EAAQiE,KAAO,yBACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA9NR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WAcxB,SAAS+Y,EAAuB9V,EAAM+V,EAAQpH,GAC5C,KAAMrS,gBAAgBwZ,GACpB,MAAM,IAAIrI,YAAY,oDAIxB,GAAoB,iBAATzN,EAAmB,MAAM,IAAI2J,UAAU,wCAClD,IAAKR,MAAMC,QAAQ2M,GAAS,MAAM,IAAIpM,UAAU,uEAChD,IAAK7F,EAAKwH,OAAOqD,GAAO,MAAM,IAAIhF,UAAU,sCAC5C,GAAI3J,KAAQ4V,EAAU,MAAM,IAAI1Y,MAAM,2BAA6B8C,EAAO,2BAC1E1D,KAAK0D,KAAOA,EACZ1D,KAAKyZ,OAASA,EAAOpQ,IAAI,SAAUmO,GACjC,OAAOA,GAASA,EAAM9T,MAAQ8T,IAEhCxX,KAAK+P,MAAQ0J,EAAOpQ,IAAI,SAAUmO,GAChC,OAAOA,GAASA,EAAMhQ,MAAQ,QAEhCxH,KAAKqS,KAAOA,EA0Fd,SAAS0B,EAAgBC,EAAMkC,GAC7B,IAAIC,EAAaH,EAAUI,cAAcpC,EAAMkC,GAC3CG,EAAiBL,EAAUI,cAAcpC,EAAK3B,KAAM6D,GACxD,MAAuB,QAAhBA,GAA4C,OAAnBG,GAA2BA,GAAkBF,EA4F/E,OAtLAqD,EAAuB7V,UAAY,IAAI2P,GACN9L,KAAO,yBACxCgS,EAAuB7V,UAAU2L,0BAA2B,EAe5DkK,EAAuB7V,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAC1D,IAAIwF,EAAgBnW,OAAOrC,OAAOgT,GAClCzQ,EAAQzD,KAAKyZ,OAAQ,SAAUjC,GAC7BkC,EAAclC,IAAS,IAGzB,IAAImC,EAAW3Z,KAAKqS,KAAK4B,SAAShU,EAAMyZ,GAEpChW,EAAO1D,KAAK0D,KACZ+V,EAASzZ,KAAKyZ,OACdG,EAAYjQ,EAAK3J,KAAK+P,MAAO,KAC7B8J,EAASnW,EAAO,IAAMiG,EAAK3J,KAAKyZ,OAAQ,MAAQ,IACpD,OAAO,SAAoC5G,EAAO3H,EAAMoJ,GACtD,IAAI5I,EAAa,GAEjBA,EAAWkO,GAAa,WAGtB,IAFA,IAAIE,EAAYvW,OAAOrC,OAAOgK,GAErB3K,EAAI,EAAGA,EAAIkZ,EAAOzY,OAAQT,IACjCuZ,EAAUL,EAAOlZ,IAAM+D,UAAU/D,GAGnC,OAAOoZ,EAAS9G,EAAOiH,EAAWxF,IAGpC,IAAIhJ,EAAK1D,EAAMlE,EAAMgI,GAGrB,OAFAJ,EAAGuO,OAASA,EACZ9D,EAAgBlD,EAAOnP,EAAM4H,GACtBA,IASXkO,EAAuB7V,UAAUF,QAAU,SAAU8Q,GACnDA,EAASvU,KAAKqS,KAAM,OAAQrS,OAU9BwZ,EAAuB7V,UAAU0F,IAAM,SAAUkL,GAC/C,IAAIlC,EAAOrS,KAAKwU,QAAQD,EAASvU,KAAKqS,KAAM,OAAQrS,OAEpD,OAAO,IAAIwZ,EAAuBxZ,KAAK0D,KAAM1D,KAAKyZ,OAAO9S,MAAM,GAAI0L,IAQrEmH,EAAuB7V,UAAUoG,MAAQ,WACvC,OAAO,IAAIyP,EAAuBxZ,KAAK0D,KAAM1D,KAAKyZ,OAAO9S,MAAM,GAAI3G,KAAKqS,OAsB1EmH,EAAuB7V,UAAU8Q,UAAY,SAAUrN,GACrD,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrE7D,EAAOrS,KAAKqS,KAAKqC,SAAStN,GAM9B,OAJI2M,EAAgB/T,KAAMkW,KACxB7D,EAAO,IAAMA,EAAO,KAGfrS,KAAK0D,KAAO,IAAM1D,KAAKyZ,OAAO9P,KAAK,MAAQ,OAAS0I,GAQ7DmH,EAAuB7V,UAAUmR,OAAS,WACxC,IAAI/E,EAAQ/P,KAAK+P,MACjB,MAAO,CACLgF,OAAQ,yBACRrR,KAAM1D,KAAK0D,KACX+V,OAAQzZ,KAAKyZ,OAAOpQ,IAAI,SAAUmO,EAAO1U,GACvC,MAAO,CACLY,KAAM8T,EACNhQ,KAAMuI,EAAMjN,MAGhBuP,KAAMrS,KAAKqS,OAYfmH,EAAuBxE,SAAW,SAAUvI,GAC1C,OAAO,IAAI+M,EAAuB/M,EAAK/I,KAAM+I,EAAKgN,OAAQhN,EAAK4F,OASjEmH,EAAuB7V,UAAUgR,OAAS,SAAUvN,GAIlD,IAHA,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEuD,EAAS,GAEJlZ,EAAI,EAAGA,EAAIP,KAAKyZ,OAAOzY,OAAQT,IACtCkZ,EAAOlR,KAAK,4CAA8CuQ,EAAO9Y,KAAKyZ,OAAOlZ,IAAM,WAGrF,IAAI8R,EAAOrS,KAAKqS,KAAKsC,OAAOvN,GAM5B,OAJI2M,EAAgB/T,KAAMkW,KACxB7D,EAAO,iEAAmEA,EAAO,kEAG5E,+BAAiCyG,EAAO9Y,KAAK0D,MAAQ,wEAA+E+V,EAAO9P,KAAK,yCAA2C,qLAAuL0I,GAS3XmH,EAAuB7V,UAAUiR,OAAS,SAAUxN,GAClD,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrE7D,EAAOrS,KAAKqS,KAAKwC,MAAMzN,GAM3B,OAJI2M,EAAgB/T,KAAMkW,KACxB7D,EAAO,UAAUwE,OAAOxE,EAAM,aAGzB,YAAcrS,KAAK0D,KAAO,WAAa1D,KAAKyZ,OAAOpQ,IAAIkQ,EAAMQ,UAAUpQ,KAAK,KAAO,aAAe0I,GAGpGmH,IAMP,CAAC3D,oBAAoB,GAAGZ,sBAAsB,GAAGkE,oBAAoB,GAAGC,qBAAqB,GAAGY,cAAc,GAAGlD,eAAe,GAAG5B,SAAS,KAAK+E,GAAG,CAAC,SAASxZ,EAAQf,EAAOD,GAC/K,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,SAASpG,IAA2Q,OAA9PA,EAAWZ,OAAOa,QAAU,SAAUC,GAAU,IAAK,IAAI9D,EAAI,EAAGA,EAAI+D,UAAUtD,OAAQT,IAAK,CAAE,IAAIgE,EAASD,UAAU/D,GAAI,IAAK,IAAIiE,KAAOD,EAAchB,OAAOI,UAAUC,eAAe7C,KAAKwD,EAAQC,KAAQH,EAAOG,GAAOD,EAAOC,IAAY,OAAOH,IAA2BkH,MAAMvL,KAAMsE,WAEhT,IAAIiV,EAAQ9Y,EAAQ,qBAEhBqY,EAASrY,EAAQ,sBAAsBqY,OAEvClV,EAAiBnD,EAAQ,sBAAsBmD,eAE/CyF,EAAM5I,EAAQ,qBAAqB4I,IAEnC6Q,EAAqBzZ,EAAQ,uBAAuByZ,mBAEpD7G,EAAkB5S,EAAQ,uBAAuB4S,gBAgcrD5T,EAAQiE,KAAO,eACfjE,EAAQyM,KAAO,kBACfzM,EAAQQ,MAAO,EAEfR,EAAQ2I,QAlcR,SAAiBZ,EAAMgB,EAAQL,EAAMP,EAAO3H,GAC1C,IAAIqT,EAAOnL,EAAK1H,EAAQ,WACpB0Z,EAAahS,EAAK1H,EAAQ,iBAU9B,SAAS2Z,EAAa9O,EAAIJ,GACxB,KAAMlL,gBAAgBoa,GACpB,MAAM,IAAIjJ,YAAY,oDAQxB,GALkB,iBAAP7F,IACTA,EAAK,IAAI6O,EAAW7O,KAIjB9D,EAAKwH,OAAO1D,GAAK,MAAM,IAAI+B,UAAU,mCAE1C,IAAKR,MAAMC,QAAQ5B,KAAUA,EAAKqK,MAAM/N,EAAKwH,QAC3C,MAAM,IAAI3B,UAAU,wDAGtBrN,KAAKsL,GAAKA,EACVtL,KAAKkL,KAAOA,GAAQ,GAEpB3H,OAAOkQ,eAAezT,KAAM,OAAQ,CAClC0T,IAAK,WACH,OAAO1T,KAAKsL,GAAG5H,MAAQ,IACvBmQ,KAAK7T,MACP8T,IAAK,WACH,MAAM,IAAIlT,MAAM,kDAIpB,IAAI4U,EAAa,WACf,MAAM,IAAI5U,MAAM,gFAGlB2C,OAAOkQ,eAAezT,KAAM,SAAU,CACpC0T,IAAK8B,EACL1B,IAAK0B,KAIT4E,EAAazW,UAAY,IAAI2P,GACN9L,KAAO,eAC9B4S,EAAazW,UAAU4L,gBAAiB,EAexC6K,EAAazW,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAChD,KAAMlU,gBAAgBoa,GACpB,MAAM,IAAI/M,UAAU,yBAItB,IAAIgN,EAAWhR,EAAIrJ,KAAKkL,KAAM,SAAUE,GACtC,OAAOA,EAAI6I,SAAShU,EAAMiU,KAG5B,GAAI1M,EAAKqI,aAAa7P,KAAKsL,IAAK,CAE9B,IAAI5H,EAAO1D,KAAKsL,GAAG5H,KACf4H,EAAK5H,KAAQzD,EAAOoT,EAAgBpT,EAAMyD,QAAQoC,EAGtD,GAF0B,mBAAPwF,IAAoC,IAAfA,EAAGgP,QAEhC,CAGT,IAAIA,EAAUta,KAAKkL,KACnB,OAAO,SAA0B2H,EAAO3H,EAAMoJ,GAC5C,OAAQ5Q,KAAQmP,EAAQQ,EAAgBR,EAAOnP,GAAQ4H,GAAIgP,EAASra,EAAMkE,EAAS,GAAI0O,EAAO3H,KAIhG,GAAwB,IAApBmP,EAASrZ,OAAc,CACzB,IAAIuZ,EAAWF,EAAS,GACxB,OAAO,SAA0BxH,EAAO3H,EAAMoJ,GAC5C,OAAQ5Q,KAAQmP,EAAQQ,EAAgBR,EAAOnP,GAAQ4H,GAAIiP,EAAS1H,EAAO3H,EAAMoJ,KAE9E,GAAwB,IAApB+F,EAASrZ,OAOlB,OAAO,SAA0B6R,EAAO3H,EAAMoJ,GAC5C,OAAQ5Q,KAAQmP,EAAQQ,EAAgBR,EAAOnP,GAAQ4H,GAAIC,MAAM,KAAMlC,EAAIgR,EAAU,SAAUG,GAC7F,OAAOA,EAAQ3H,EAAO3H,EAAMoJ,OARhC,IAAImG,EAAWJ,EAAS,GACpBK,EAAWL,EAAS,GACxB,OAAO,SAA0BxH,EAAO3H,EAAMoJ,GAC5C,OAAQ5Q,KAAQmP,EAAQQ,EAAgBR,EAAOnP,GAAQ4H,GAAImP,EAAS5H,EAAO3H,EAAMoJ,GAAUoG,EAAS7H,EAAO3H,EAAMoJ,KAUlH,GAAI9M,EAAKuH,eAAe/O,KAAKsL,KAAO9D,EAAKgI,YAAYxP,KAAKsL,GAAGxI,QAAU9C,KAAKsL,GAAGxI,MAAM6Q,mBAAoB,CAE9G,IAAIQ,EAAanU,KAAKsL,GAAGtC,OAAOiL,SAAShU,EAAMiU,GAE3CG,EAAOrU,KAAKsL,GAAGxI,MAAM8Q,oBACrB+G,EAAW3a,KAAKkL,KACpB,OAAO,SAA0B2H,EAAO3H,EAAMoJ,GAC5C,IAAItL,EAASmL,EAAWtB,EAAO3H,EAAMoJ,GAGrC,OAFA4F,EAAmBlR,EAAQqL,GACfrL,EAAOqL,IAASrL,EAAOqL,GAAMiG,QAC1BtR,EAAOqL,GAAMsG,EAAU1a,EAAMkE,EAAS,GAAI0O,EAAO3H,IAC9DlC,EAAOqL,GAAM9I,MAAMvC,EAAQK,EAAIgR,EAAU,SAAUG,GAEnD,OAAOA,EAAQ3H,EAAO3H,EAAMoJ,OAMhC,IAAIsG,EAAS5a,KAAKsL,GAAG2I,SAAShU,EAAMiU,GAEhC2G,EAAY7a,KAAKkL,KACrB,OAAO,SAA0B2H,EAAO3H,EAAMoJ,GAC5C,IAAIhJ,EAAKsP,EAAO/H,EAAO3H,EAAMoJ,GAE7B,OADYhJ,GAAMA,EAAGgP,QACNhP,EAAGuP,EAAW5a,EAAMkE,EAAS,GAAI0O,EAAO3H,IACrDI,EAAGC,MAAMD,EAAIjC,EAAIgR,EAAU,SAAUG,GAErC,OAAOA,EAAQ3H,EAAO3H,EAAMoJ,QAWpC8F,EAAazW,UAAUF,QAAU,SAAU8Q,GACzC,IAAK,IAAIhU,EAAI,EAAGA,EAAIP,KAAKkL,KAAKlK,OAAQT,IACpCgU,EAASvU,KAAKkL,KAAK3K,GAAI,QAAUA,EAAI,IAAKP,OAW9Coa,EAAazW,UAAU0F,IAAM,SAAUkL,GAIrC,IAHA,IAAIjJ,EAAKtL,KAAKsL,GAAGjC,IAAIkL,GACjBrJ,EAAO,GAEF3K,EAAI,EAAGA,EAAIP,KAAKkL,KAAKlK,OAAQT,IACpC2K,EAAK3K,GAAKP,KAAKwU,QAAQD,EAASvU,KAAKkL,KAAK3K,GAAI,QAAUA,EAAI,IAAKP,OAGnE,OAAO,IAAIoa,EAAa9O,EAAIJ,IAQ9BkP,EAAazW,UAAUoG,MAAQ,WAC7B,OAAO,IAAIqQ,EAAapa,KAAKsL,GAAItL,KAAKkL,KAAKvE,MAAM,KAKnD,IAAImU,EAAeV,EAAazW,UAAU+Q,SA8F1C,SAASqG,EAAeC,EAAUhH,EAAM5M,GAStC,IARA,IAMI6T,EANA1B,EAAQ,GAGR2B,EAAQ,IAAIvM,OAAO,yDAA0D,MAC7EwM,EAAW,EAI2B,QAAlCF,EAAQC,EAAME,KAAKJ,KAMzB,GAHAzB,GAASyB,EAAS/B,UAAUkC,EAAUF,EAAMnY,OAC5CqY,EAAWF,EAAMnY,MAEA,OAAbmY,EAAM,GAER1B,GAAS,IACT4B,QACK,CAELA,GAAYF,EAAM,GAAGja,OACrB,IAAIqa,EAAWrH,EAAKiH,EAAM,IAE1B,IAAKI,EACH,MAAM,IAAIC,eAAe,sBAAwBL,EAAM,GAAK,oBAG9D,QAAiBnV,IAAbmV,EAAM,GAER,OAAQ3Q,EAAQ+Q,IACd,IAAK,SACH9B,GAAS8B,EACT,MAEF,IAAK,SACH,GAAI7T,EAAKwH,OAAOqM,GACd9B,GAAS8B,EAASxG,MAAMzN,OACnB,CAAA,IAAIyF,MAAMC,QAAQuO,GAUvB,MAAM,IAAIhO,UAAU,aAAe4N,EAAM,GAAK,+CAR9C1B,GAAS8B,EAAShS,IAAI,SAAU+B,EAAKtI,GACnC,GAAI0E,EAAKwH,OAAO5D,GACd,OAAOA,EAAIyJ,MAAMzN,GAGnB,MAAM,IAAIiG,UAAU,aAAe4N,EAAM,GAAK,IAAMnY,EAAQ,sBAC3D6G,KAAK,KAKV,MAEF,QACE,MAAM,IAAI0D,UAAU,aAAe4N,EAAM,GAAK,mDAE7C,CAEL,IAAIzT,EAAKwH,OAAOqM,EAASJ,EAAM,KAAOI,EAASJ,EAAM,KAGnD,MAAM,IAAI5N,UAAU,aAAe4N,EAAM,GAAK,IAAMA,EAAM,GAAK,oBAF/D1B,GAAS8B,EAASJ,EAAM,IAAIpG,MAAMzN,IAU1C,OAFAmS,GAASyB,EAASrU,MAAMwU,GAnJ1Bf,EAAazW,UAAU+Q,SAAW,SAAUtN,GAC1C,IAAImU,EACA7X,EAAO1D,KAAKsL,GAAGoJ,SAAStN,GAO5B,OALIA,GAAwC,WAA7BkD,EAAQlD,EAAQoU,UAAyB5X,EAAewD,EAAQoU,QAAS9X,KAEtF6X,EAAenU,EAAQoU,QAAQ9X,GAAM1D,KAAMoH,SAGjB,IAAjBmU,EACFA,EAIFT,EAAa/Z,KAAKf,KAAMoH,IASjCgT,EAAazW,UAAU8Q,UAAY,SAAUrN,GAC3C,IAAI8D,EAAOlL,KAAKkL,KAAK7B,IAAI,SAAU+B,GACjC,OAAOA,EAAIsJ,SAAStN,KAItB,OAFSI,EAAK8H,yBAAyBtP,KAAKsL,IAAM,IAAMtL,KAAKsL,GAAGoJ,SAAStN,GAAW,IAAMpH,KAAKsL,GAAGoJ,SAAStN,IAE/F,IAAM8D,EAAKvB,KAAK,MAAQ,KAQtCyQ,EAAazW,UAAUmR,OAAS,WAC9B,MAAO,CACLC,OAAQ,eACRzJ,GAAItL,KAAKsL,GACTJ,KAAMlL,KAAKkL,OAYfkP,EAAapF,SAAW,SAAUvI,GAChC,OAAO,IAAI2N,EAAa3N,EAAKnB,GAAImB,EAAKvB,OASxCkP,EAAazW,UAAUgR,OAAS,SAAUvN,GACxC,IAAI8D,EAAOlL,KAAKkL,KAAK7B,IAAI,SAAU+B,GACjC,OAAOA,EAAIuJ,OAAOvN,KAGpB,MAAO,+BAAiC0R,EAAO9Y,KAAKsL,IAAM,wEAA0EJ,EAAKvB,KAAK,yCAA2C,kEAsF3L,IAAI8R,EAAYrB,EAAazW,UAAUkR,MA0FvC,OA7EAuF,EAAazW,UAAUkR,MAAQ,SAAUzN,GACvC,IAAIsU,EAOJ,OALItU,GAAwC,WAA7BkD,EAAQlD,EAAQoU,UAAyB5X,EAAewD,EAAQoU,QAASxb,KAAK0D,QAE3FgY,EAAYtU,EAAQoU,QAAQxb,KAAK0D,MAAM1D,KAAMoH,SAGtB,IAAdsU,EACFA,EAIFD,EAAU1a,KAAKf,KAAMoH,IAS9BgT,EAAazW,UAAUiR,OAAS,SAAUxN,GACxC,IAIIuU,EAOAC,EAXA1Q,EAAOlL,KAAKkL,KAAK7B,IAAI,SAAU+B,GAEjC,OAAOA,EAAIyJ,MAAMzN,KAWnB,QAPInH,EAAKD,KAAK0D,OAA2C,mBAA1BzD,EAAKD,KAAK0D,MAAMmR,OAA2D,WAAnCvK,EAAQrK,EAAKD,KAAK0D,MAAMmR,QAAwD,iBAA1B5U,EAAKD,KAAK0D,MAAMmR,QAE3I8G,EAAiB1b,EAAKD,KAAK0D,MAAMmR,OAK3BvK,EAAQqR,IACd,IAAK,WAEHC,EAAcD,EAAe3b,KAAMoH,GACnC,MAEF,IAAK,SAEHwU,EAAcb,EAAeY,EAAgB3b,KAAMoH,GACnD,MAEF,IAAK,SAEH,OAAQkD,EAAQqR,EAAezQ,EAAKlK,UAClC,IAAK,WACH4a,EAAcD,EAAezQ,EAAKlK,QAAQhB,KAAMoH,GAChD,MAEF,IAAK,SACHwU,EAAcb,EAAeY,EAAezQ,EAAKlK,QAAShB,KAAMoH,IAMxE,YAA2B,IAAhBwU,EACFA,EAGFb,EAAexB,EAAMsC,gBAAiB7b,KAAMoH,IAQrDgT,EAAazW,UAAUmY,cAAgB,WACrC,OAAO9b,KAAKwH,KAAO,IAAMxH,KAAK0D,MAGzB0W,IAQP,CAACvE,oBAAoB,GAAGZ,sBAAsB,GAAGkE,oBAAoB,GAAG/O,qBAAqB,GAAGgP,qBAAqB,GAAGlE,SAAS,GAAG6G,eAAe,KAAKC,GAAG,CAAC,SAASvb,EAAQf,EAAOD,GACtL,aAEA,IAAI4J,EAAM5I,EAAQ,qBAAqB4I,IAEnCyP,EAASrY,EAAQ,sBAAsBqY,OA+Q3CrZ,EAAQiE,KAAO,YACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA/QR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WACpBwb,EAAQ9T,EAAK1H,EAAQ,4BACrBqM,EAAUD,MAAMC,QAiBpB,SAASoP,EAAUC,EAAYC,GAC7B,KAAMpc,gBAAgBkc,GACpB,MAAM,IAAI/K,YAAY,oDAMxB,GAHAnR,KAAKmc,WAAaA,EAClBnc,KAAKoc,YAAcA,IAAe,GAE7BtP,EAAQqP,KAAgBA,EAAW5G,MAAM/N,EAAKwH,QACjD,MAAM,IAAI3B,UAAU,8DAGtB,GAAIrN,KAAKoc,cAAgBpc,KAAK2T,mBAC5B,MAAM,IAAI/S,MAAM,qDAIlB,IAAI4U,EAAa,WACf,MAAM,IAAI5U,MAAM,0EAGlB2C,OAAOkQ,eAAezT,KAAM,SAAU,CACpC0T,IAAK8B,EACL1B,IAAK0B,IA2NT,SAAS6G,EAAYC,EAAOnJ,EAAKoJ,GAC/B,OAAO,IAAIN,EAAMzU,EAAK0F,YAAYoP,GAASA,EAAMhM,WAAagM,EAAO9U,EAAK0F,YAAYiG,GAAOA,EAAI7C,WAAa6C,EAAK3L,EAAK0F,YAAYqP,GAAQA,EAAKjM,WAAaiM,GAGhK,OA3NAL,EAAUvY,UAAY,IAAI2P,GACN9L,KAAO,YAC3B0U,EAAUvY,UAAU6L,aAAc,EAelC0M,EAAUvY,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAM7C,IAAIsI,EAAiBnT,EAAIrJ,KAAKmc,WAAY,SAAUM,EAAOlc,GACzD,GAAIiH,EAAKoI,YAAY6M,GAAQ,CAC3B,GAAIA,EAAMC,WAAY,CAEpB,IAAIhD,EAAgBnW,OAAOrC,OAAOgT,GAClCwF,EAAmB,KAAI,EAEvB,IAAIiD,EAAYF,EAAMH,MAAMrI,SAAShU,EAAMyZ,GAEvCkD,EAAUH,EAAMtJ,IAAIc,SAAShU,EAAMyZ,GAEnCmD,EAAWJ,EAAMF,KAAOE,EAAMF,KAAKtI,SAAShU,EAAMyZ,GAAiB,WACrE,OAAO,GAET,OAAO,SAAuB7G,EAAO3H,EAAMoJ,GACzC,IAAIwI,EAAO7c,EAAK6c,KAAKxI,GAASjJ,UAC1ByO,EAAYvW,OAAOrC,OAAOgK,GAE9B,OADA4O,EAAe,IAAIgD,EAAKvc,GACjB8b,EAAYM,EAAU9J,EAAOiH,EAAWxF,GAAUsI,EAAQ/J,EAAOiH,EAAWxF,GAAUuI,EAAShK,EAAOiH,EAAWxF,KAI1H,IAAIyI,EAAaN,EAAMH,MAAMrI,SAAShU,EAAMiU,GAExC8I,EAAWP,EAAMtJ,IAAIc,SAAShU,EAAMiU,GAEpC+I,EAAYR,EAAMF,KAAOE,EAAMF,KAAKtI,SAAShU,EAAMiU,GAAY,WACjE,OAAO,GAGT,OAAO,SAAuBrB,EAAO3H,EAAMoJ,GACzC,OAAO+H,EAAYU,EAAWlK,EAAO3H,EAAMoJ,GAAU0I,EAASnK,EAAO3H,EAAMoJ,GAAU2I,EAAUpK,EAAO3H,EAAMoJ,KAG3G,GAAI9M,EAAKqI,aAAa4M,IAAyB,QAAfA,EAAM/Y,KAAgB,CAE3D,IAAIwZ,EAAiB3Z,OAAOrC,OAAOgT,GAEnCgJ,EAAoB,KAAI,EAExB,IAAIC,EAAYV,EAAMxI,SAAShU,EAAMid,GAErC,OAAO,SAAuBrK,EAAO3H,EAAMoJ,GACzC,IAAIwI,EAAO7c,EAAK6c,KAAKxI,GAASjJ,UAC1ByO,EAAYvW,OAAOrC,OAAOgK,GAE9B,OADA4O,EAAe,IAAIgD,EAAKvc,GACjB4c,EAAUtK,EAAOiH,EAAWxF,IAIrC,IAAI8I,EAAaX,EAAMxI,SAAShU,EAAMiU,GAEtC,OAAO,SAAuBrB,EAAO3H,EAAMoJ,GACzC,OAAO8I,EAAWvK,EAAO3H,EAAMoJ,MAIrC,OAAO,SAAuBzB,EAAO3H,EAAMoJ,GACzC,IAAI6H,EAAa9S,EAAImT,EAAgB,SAAUa,GAC7C,OAAOA,EAAcxK,EAAO3H,EAAMoJ,KAEpC,OAAOrU,EAAK6C,MAAMyI,MAAMtL,EAAMkc,KASlCD,EAAUvY,UAAUF,QAAU,SAAU8Q,GACtC,IAAK,IAAIhU,EAAI,EAAGA,EAAIP,KAAKmc,WAAWnb,OAAQT,IAC1CgU,EAASvU,KAAKmc,WAAW5b,GAAI,cAAgBA,EAAI,IAAKP,OAW1Dkc,EAAUvY,UAAU0F,IAAM,SAAUkL,GAGlC,IAFA,IAAI4H,EAAa,GAER5b,EAAI,EAAGA,EAAIP,KAAKmc,WAAWnb,OAAQT,IAC1C4b,EAAW5b,GAAKP,KAAKwU,QAAQD,EAASvU,KAAKmc,WAAW5b,GAAI,cAAgBA,EAAI,IAAKP,OAGrF,OAAO,IAAIkc,EAAUC,IAQvBD,EAAUvY,UAAUoG,MAAQ,WAC1B,OAAO,IAAImS,EAAUlc,KAAKmc,WAAWxV,MAAM,KAQ7CuV,EAAUvY,UAAUgQ,iBAAmB,WACrC,OAAkC,IAA3B3T,KAAKmc,WAAWnb,QAAgBwG,EAAK6H,eAAerP,KAAKmc,WAAW,KAA2C,iBAA7Bnc,KAAKmc,WAAW,GAAGpR,OAS9GmR,EAAUvY,UAAUiQ,kBAAoB,WACtC,OAAO5T,KAAK2T,mBAAqB3T,KAAKmc,WAAW,GAAGpR,MAAQ,MAS9DmR,EAAUvY,UAAU8Q,UAAY,SAAUrN,GAExC,OAAOpH,KAAKoc,YAAc,IAAMpc,KAAK4T,oBAAsB,IAAM5T,KAAKmc,WAAWxS,KAAK,MAAQ,KAQhGuS,EAAUvY,UAAUmR,OAAS,WAC3B,MAAO,CACLC,OAAQ,YACRoH,WAAYnc,KAAKmc,WACjBC,YAAapc,KAAKoc,cAYtBF,EAAUlH,SAAW,SAAUvI,GAC7B,OAAO,IAAIyP,EAAUzP,EAAK0P,WAAY1P,EAAK2P,cAS7CF,EAAUvY,UAAUgR,OAAS,SAAUvN,GAIrC,IAFA,IAAI+U,EAAa,GAER5b,EAAI,EAAGA,EAAIP,KAAKmc,WAAWnb,OAAQT,IAC1C4b,EAAW5b,GAAKP,KAAKmc,WAAW5b,GAAGoU,SAGrC,OAAI3U,KAAKoc,YACA,sGAA6GtD,EAAO9Y,KAAK4T,qBAAuB,UAEhJ,kEAAoEuI,EAAWxS,KAAK,yCAA2C,mEAU1IuS,EAAUvY,UAAUiR,OAAS,SAAUxN,GACrC,IAAI+U,EAAanc,KAAKmc,WAAW9S,IAAI,SAAUoT,GAC7C,OAAOA,EAAM5H,MAAMzN,KAErB,OAAOpH,KAAKoc,YAAc,IAAMpc,KAAK4T,oBAA2B,KAAOuI,EAAWxS,KAAK,KAAO,KAQzFuS,IAMP,CAACoB,0BAA0B,GAAGzH,oBAAoB,GAAGuD,qBAAqB,GAAGlE,SAAS,KAAKqI,GAAG,CAAC,SAAS9c,EAAQf,EAAOD,GACzH,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAI+O,EAAW7Y,EAAQ,eAEnB+c,EAAY/c,EAAQ,sBAAsB+c,UAE1C5Z,EAAiBnD,EAAQ,sBAAsBmD,eA0anDnE,EAAQiE,KAAO,OACfjE,EAAQyM,KAAO,kBACfzM,EAAQQ,MAAO,EAEfR,EAAQ2I,QA5aR,SAAiBZ,EAAMgB,EAAQL,EAAMP,EAAO3H,GAI1C,SAASqT,IACP,KAAMtT,gBAAgBsT,GACpB,MAAM,IAAInC,YAAY,oDA+Z1B,OArZAmC,EAAK3P,UAAUgP,KAAO,SAAUE,GAC9B,OAAO7S,KAAKsS,UAAUK,KAAKE,IAG7BS,EAAK3P,UAAU6D,KAAO,OACtB8L,EAAK3P,UAAUqL,QAAS,EACxBsE,EAAK3P,UAAU8Z,QAAU,GASzBnK,EAAK3P,UAAU2O,QAAU,WACvB,IAAID,EAAOrS,KAAKiU,SAAShU,EAAKwH,WAAWE,kBAAmB,IAExDuD,EAAO,GAEX,MAAO,CACLyH,KAAM,SAAkBE,GACtB,IAAI8C,EAAI9C,GAAS,GAIjB,OAiXN,SAAwBA,GACtB,IAAK,IAAI6K,KAAU7K,EACjB,GAAIjP,EAAeiP,EAAO6K,IACpBA,KAAUpE,EACZ,MAAM,IAAI1Y,MAAM,sCAAwC8c,EAAS,2BAvXnEC,CAAehI,GAERtD,EAAKsD,EAAGzK,EAPL,SA0BhBoI,EAAK3P,UAAUsQ,SAAW,SAAUhU,EAAMiU,GACxC,MAAM,IAAItT,MAAM,iDAAmDZ,KAAKwH,OAQ1E8L,EAAK3P,UAAUF,QAAU,SAAU8Q,GAEjC,MAAM,IAAI3T,MAAM,2CAUlB0S,EAAK3P,UAAU0F,IAAM,SAAUkL,GAE7B,MAAM,IAAI3T,MAAM,uCAUlB0S,EAAK3P,UAAU6Q,QAAU,SAAUR,GACjC,IAAKxM,EAAKwH,OAAOgF,GACf,MAAM,IAAI3G,UAAU,wCAGtB,OAAO2G,GAUTV,EAAK3P,UAAUiH,SAAW,SAAU2J,GAElCA,EAASvU,KAAM,KAAM,MAGrB,SAAS4d,EAAU5J,EAAMO,GACvBP,EAAKvQ,QAAQ,SAAUoa,EAAO3R,EAAMwK,GAClCnC,EAASsJ,EAAO3R,EAAMwK,GAEtBkH,EAAUC,EAAOtJ,KAIrBqJ,CAAU5d,KAAMuU,IAyBlBjB,EAAK3P,UAAU+D,UAAY,SAAU6M,GAWnC,OATA,SAASuJ,EAAW9J,EAAMO,GACxB,OAAOP,EAAK3K,IAAI,SAAUwU,EAAO3R,EAAMwK,GAErC,OAAOoH,EADWvJ,EAASsJ,EAAO3R,EAAMwK,GACTnC,KAM5BuJ,CAFWvJ,EAASvU,KAAM,KAAM,MAERuU,IAkBjCjB,EAAK3P,UAAUoa,OAAS,SAAUxJ,GAChC,IAAIyJ,EAAQ,GAMZ,OALAhe,KAAK4K,SAAS,SAAUoJ,EAAM9H,EAAMwK,GAC9BnC,EAASP,EAAM9H,EAAMwK,IACvBsH,EAAMzV,KAAKyL,KAGRgK,GAIT1K,EAAK3P,UAAUsa,KAAO,WACpB,MAAM,IAAIrd,MAAM,+DAIlB0S,EAAK3P,UAAUsX,MAAQ,WACrB,MAAM,IAAIra,MAAM,iGAQlB0S,EAAK3P,UAAUoG,MAAQ,WAErB,MAAM,IAAInJ,MAAM,kCAQlB0S,EAAK3P,UAAUua,UAAY,WACzB,OAAOle,KAAKqJ,IAAI,SAAU2K,GACxB,OAAOA,EAAKkK,eAWhB5K,EAAK3P,UAAUwa,OAAS,SAAUC,GAChC,QAAOA,GAAQZ,EAAUxd,KAAMoe,IAmBjC9K,EAAK3P,UAAU+Q,SAAW,SAAUtN,GAClC,IAAImU,EAEJ,GAAInU,GAAgC,WAArBkD,EAAQlD,GACrB,OAAQkD,EAAQlD,EAAQoU,UACtB,IAAK,SACL,IAAK,YACH,MAEF,IAAK,WACHD,EAAenU,EAAQoU,QAAQxb,KAAMoH,GACrC,MAEF,QACE,MAAM,IAAIiG,UAAU,2CAI1B,YAA4B,IAAjBkO,EACFA,EAGFvb,KAAKyU,UAAUrN,IAUxBkM,EAAK3P,UAAUmR,OAAS,WACtB,MAAM,IAAIlU,MAAM,sDAAwDZ,KAAKwH,OAmB/E8L,EAAK3P,UAAUgR,OAAS,SAAUvN,GAChC,IAAImU,EAEJ,GAAInU,GAAgC,WAArBkD,EAAQlD,GACrB,OAAQkD,EAAQlD,EAAQoU,UACtB,IAAK,SACL,IAAK,YACH,MAEF,IAAK,WACHD,EAAenU,EAAQoU,QAAQxb,KAAMoH,GACrC,MAEF,QACE,MAAM,IAAIiG,UAAU,2CAI1B,YAA4B,IAAjBkO,EACFA,EAGFvb,KAAK2U,OAAOvN,IAUrBkM,EAAK3P,UAAU8Q,UAAY,WAEzB,MAAM,IAAI7T,MAAM,iCAAmCZ,KAAKwH,OAmB1D8L,EAAK3P,UAAUkR,MAAQ,SAAUzN,GAC/B,IAAIsU,EAEJ,GAAItU,GAAgC,WAArBkD,EAAQlD,GACrB,OAAQkD,EAAQlD,EAAQoU,UACtB,IAAK,SACL,IAAK,YACH,MAEF,IAAK,WACHE,EAAYtU,EAAQoU,QAAQxb,KAAMoH,GAClC,MAEF,QACE,MAAM,IAAIiG,UAAU,2CAI1B,YAAyB,IAAdqO,EACFA,EAGF1b,KAAK4U,OAAOxN,IAWrBkM,EAAK3P,UAAUiR,OAAS,SAAUxN,GAEhC,MAAM,IAAIxG,MAAM,8BAAgCZ,KAAKwH,OAQvD8L,EAAK3P,UAAUmY,cAAgB,WAC7B,OAAO9b,KAAKwH,MAQd8L,EAAK3P,UAAU0a,WAAa,WAC1B,OAAOre,MAmBFsT,IAQP,CAAClJ,qBAAqB,GAAG4P,cAAc,KAAKsE,GAAG,CAAC,SAAS7d,EAAQf,EAAOD,GAC1E,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAIb,EAAYjJ,EAAQ,sBAAsBiJ,UAE1CoP,EAASrY,EAAQ,sBAAsBqY,OAEvCyF,EAAiB9d,EAAQ,uBAAuB8d,eAEhD3a,EAAiBnD,EAAQ,sBAAsBmD,eA+MnDnE,EAAQiE,KAAO,aACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA/MR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WAQxB,SAAS+d,EAAWC,GAClB,KAAMze,gBAAgBwe,GACpB,MAAM,IAAIrN,YAAY,oDAKxB,GAFAnR,KAAKye,WAAaA,GAAc,GAE5BA,IAC4B,WAAxBnU,EAAQmU,KAA8Blb,OAAOiD,KAAKiY,GAAYlJ,MAAM,SAAU/Q,GAClF,OAAOgD,EAAKwH,OAAOyP,EAAWja,OAE9B,MAAM,IAAI6I,UAAU,oCAsL1B,OAjLAmR,EAAW7a,UAAY,IAAI2P,GACN9L,KAAO,aAC5BgX,EAAW7a,UAAU8L,cAAe,EAepC+O,EAAW7a,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAC9C,IAAIwK,EAAc,GAElB,IAAK,IAAIla,KAAOxE,KAAKye,WACnB,GAAI7a,EAAe5D,KAAKye,WAAYja,GAAM,CAGxC,IAAIma,EAAiBjV,EAAUlF,GAC3Boa,EAAYnV,KAAK0I,MAAMwM,GAE3B,IAAKJ,EAAeve,KAAKye,WAAYG,GACnC,MAAM,IAAIhe,MAAM,0BAA4Bge,EAAY,KAG1DF,EAAYE,GAAa5e,KAAKye,WAAWja,GAAKyP,SAAShU,EAAMiU,GAIjE,OAAO,SAAwBrB,EAAO3H,EAAMoJ,GAC1C,IAAI/J,EAAM,GAEV,IAAK,IAAIsU,KAAQH,EACX9a,EAAe8a,EAAaG,KAC9BtU,EAAIsU,GAAQH,EAAYG,GAAMhM,EAAO3H,EAAMoJ,IAI/C,OAAO/J,IASXiU,EAAW7a,UAAUF,QAAU,SAAU8Q,GACvC,IAAK,IAAI/P,KAAOxE,KAAKye,WACfze,KAAKye,WAAW7a,eAAeY,IACjC+P,EAASvU,KAAKye,WAAWja,GAAM,cAAgBkF,EAAUlF,GAAO,IAAKxE,OAY3Ewe,EAAW7a,UAAU0F,IAAM,SAAUkL,GACnC,IAAIkK,EAAa,GAEjB,IAAK,IAAIja,KAAOxE,KAAKye,WACfze,KAAKye,WAAW7a,eAAeY,KACjCia,EAAWja,GAAOxE,KAAKwU,QAAQD,EAASvU,KAAKye,WAAWja,GAAM,cAAgBkF,EAAUlF,GAAO,IAAKxE,QAIxG,OAAO,IAAIwe,EAAWC,IAQxBD,EAAW7a,UAAUoG,MAAQ,WAC3B,IAAI0U,EAAa,GAEjB,IAAK,IAAIja,KAAOxE,KAAKye,WACfze,KAAKye,WAAW7a,eAAeY,KACjCia,EAAWja,GAAOxE,KAAKye,WAAWja,IAItC,OAAO,IAAIga,EAAWC,IAUxBD,EAAW7a,UAAU8Q,UAAY,SAAUrN,GACzC,IAAI0X,EAAU,GAEd,IAAK,IAAIta,KAAOxE,KAAKye,WACfze,KAAKye,WAAW7a,eAAeY,IACjCsa,EAAQvW,KAAKmB,EAAUlF,GAAO,KAAOxE,KAAKye,WAAWja,GAAKkQ,SAAStN,IAIvE,MAAO,IAAM0X,EAAQnV,KAAK,MAAQ,KAQpC6U,EAAW7a,UAAUmR,OAAS,WAC5B,MAAO,CACLC,OAAQ,aACR0J,WAAYze,KAAKye,aAYrBD,EAAWxJ,SAAW,SAAUvI,GAC9B,OAAO,IAAI+R,EAAW/R,EAAKgS,aAU7BD,EAAW7a,UAAUgR,OAAS,SAAUvN,GACtC,IAAI0X,EAAU,GAEd,IAAK,IAAIta,KAAOxE,KAAKye,WACfze,KAAKye,WAAW7a,eAAeY,IACjCsa,EAAQvW,KAAK,2CAA6CuQ,EAAOtU,GAAO,8HAAqIxE,KAAKye,WAAWja,GAAKmQ,OAAOvN,IAI7O,MAAO,iEAAmE0X,EAAQnV,KAAK,yCAA2C,kEASpI6U,EAAW7a,UAAUiR,OAAS,SAAUxN,GACtC,IAAI0X,EAAU,GAEd,IAAK,IAAIta,KAAOxE,KAAKye,WACfze,KAAKye,WAAW7a,eAAeY,IACjCsa,EAAQvW,KAAK,YAAc/D,EAAM,QAAUxE,KAAKye,WAAWja,GAAKqQ,MAAMzN,GAAW,QAIrF,MAAO,8BAA8ByP,OAAOiI,EAAQnV,KAAK,MAAO,2BAG3D6U,IAMP,CAACvJ,sBAAsB,GAAG7K,qBAAqB,GAAGgP,qBAAqB,GAAGlE,SAAS,KAAK6J,GAAG,CAAC,SAASte,EAAQf,EAAOD,GACtH,aAEA,IAAI8Z,EAAQ9Y,EAAQ,qBAEhB4I,EAAM5I,EAAQ,qBAAqB4I,IAEnCyP,EAASrY,EAAQ,sBAAsBqY,OAEvCkG,EAAeve,EAAQ,uBAAuBue,aAE9C3L,EAAkB5S,EAAQ,uBAAuB4S,gBAEjD2C,EAAYvV,EAAQ,gBA+pBxBhB,EAAQiE,KAAO,eACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA/pBR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WAYxB,SAASwe,EAAaC,EAAI5T,EAAIJ,EAAMiU,GAClC,KAAMnf,gBAAgBif,GACpB,MAAM,IAAI9N,YAAY,oDAIxB,GAAkB,iBAAP+N,EACT,MAAM,IAAI7R,UAAU,sCAGtB,GAAkB,iBAAP/B,EACT,MAAM,IAAI+B,UAAU,sCAGtB,IAAKR,MAAMC,QAAQ5B,KAAUA,EAAKqK,MAAM/N,EAAKwH,QAC3C,MAAM,IAAI3B,UAAU,wDAGtBrN,KAAKmf,UAAwB,IAAbA,EAChBnf,KAAKkf,GAAKA,EACVlf,KAAKsL,GAAKA,EACVtL,KAAKkL,KAAOA,GAAQ,GA8HtB,SAASkU,EAA8BC,EAAMnJ,EAAaiJ,EAAUjU,EAAMqO,GAExE,IAoBIlT,EApBA8P,EAAaH,EAAUI,cAAciJ,EAAMnJ,GAC3CoJ,EAAgBtJ,EAAUuJ,iBAAiBF,EAAMnJ,GAErD,GAAoB,QAAhBA,GAAuC,EAAdhL,EAAKlK,QAAuC,qBAAzBqe,EAAKvD,iBAAmE,0BAAzBuD,EAAKvD,gBAclG,OAba5Q,EAAK7B,IAAI,SAAU+B,GAC9B,OAAQA,EAAIiT,aAAa7W,MAEvB,IAAK,YACL,IAAK,eACL,IAAK,aACL,IAAK,kBACH,OAAO,EAET,QACE,OAAO,KAQf,OAAQ0D,EAAKlK,QACX,KAAK,EACHqF,EAAS,GACT,MAEF,KAAK,EAGH,IAAImZ,EAAoBxJ,EAAUI,cAAclL,EAAK,GAAIgL,GAEzD,GAAIqD,GAA+B,OAAtBiG,EAA4B,CACvC,IAAIC,EACAC,EAWJ,GAPEA,EAFkB,SAAhBxJ,GACFuJ,EAAoBvU,EAAK,GAAG4Q,gBACXuD,EAAKvD,kBAGtB2D,EAAoBvU,EAAK,GAAGmT,aAAavC,gBACxBuD,EAAKhB,aAAavC,kBAGoC,IAArE9F,EAAUyI,WAAWtI,GAAYuJ,GAAgBC,gBAA2B,CAC9EtZ,EAAS,EAAC,GACV,MAGF,IAA+E,IAA3E2P,EAAUyI,WAAWe,GAAmBC,GAAmBG,YAAuB,CACpFvZ,EAAS,EAAC,GACV,OAIJ,GAA0B,OAAtBmZ,EAA4B,CAE9BnZ,EAAS,EAAC,GACV,MAGF,GAAImZ,GAAqBrJ,EAAY,CAEnC9P,EAAS,EAAC,GACV,MAIFA,EAAS,EAAC,GACV,MAEF,KAAK,EAEH,IAAIwZ,EAuBAC,EApBAC,EAAgB/J,EAAUI,cAAclL,EAAK,GAAIgL,GAEjD8J,EAAehK,EAAUiK,kBAAkBZ,EAAMnU,EAAK,GAAIgL,GAK5D2J,EAHoB,OAAlBE,IAIOA,IAAkB5J,GAAgC,UAAlBmJ,IAA8BU,GAM9DD,EAAgB5J,GAS3B,IAsBM+J,EAEAC,EACAC,EAzBFC,EAAgBrK,EAAUI,cAAclL,EAAK,GAAIgL,GAEjDoK,EAAetK,EAAUiK,kBAAkBZ,EAAMnU,EAAK,GAAIgL,GAK5D4J,EAHoB,OAAlBO,IAIOA,IAAkBlK,GAAgC,SAAlBmJ,IAA6BgB,GAM7DD,EAAgBlK,GAOvBoD,IASA6G,EAHkB,SAAhBlK,GACFgK,EAAkBb,EAAKvD,gBACvBqE,EAAgBd,EAAKnU,KAAK,GAAG4Q,gBACbuD,EAAKnU,KAAK,GAAG4Q,kBAG7BoE,EAAkBb,EAAKhB,aAAavC,gBACpCqE,EAAgBd,EAAKnU,KAAK,GAAGmT,aAAavC,gBAC1BuD,EAAKnU,KAAK,GAAGmT,aAAavC,iBAGtB,OAAlBiE,KACwE,IAAtE/J,EAAUyI,WAAWtI,GAAY+J,GAAiBP,kBACpDE,GAAY,IAGyD,IAAnE7J,EAAUyI,WAAWsB,GAAeI,GAAeP,cACrDC,GAAY,IAIM,OAAlBQ,KACyE,IAAvErK,EAAUyI,WAAWtI,GAAY+J,GAAiBK,mBACpDT,GAAY,IAGyD,IAAnE9J,EAAUyI,WAAW4B,GAAeD,GAAeR,cACrDE,GAAY,KAKlBzZ,EAAS,CAACwZ,EAAWC,GACrB,MAEF,QAC+B,qBAAzBT,EAAKvD,iBAAmE,0BAAzBuD,EAAKvD,kBACtDzV,EAAS6E,EAAK7B,IAAI,SAAU+B,GAC1B,IAAIoV,EAAgBxK,EAAUI,cAAchL,EAAK8K,GAC7CuK,EAAezK,EAAUiK,kBAAkBZ,EAAMjU,EAAK8K,GACtDwK,EAAmB1K,EAAUuJ,iBAAiBnU,EAAK8K,GAEvD,OAAsB,OAAlBsK,IAGOrK,IAAeqK,GAAiBlB,IAAkBoB,IAAqBD,GAEvED,EAAgBrK,MA2BnC,OAbmB,GAAfjL,EAAKlK,QAAwC,0BAAzBqe,EAAKvD,iBAA+CuD,EAAKF,UAA4B,SAAhBjJ,GAAuC,SAAbiJ,IACrH9Y,EAAS6E,EAAK7B,IAAI,SAAU+B,EAAKtI,GAC/B,IAAI6M,EAA4C,oBAAxBvE,EAAI0Q,gBAE5B,SAAIzV,EAAOvD,KAAU6M,MASlBtJ,EA+ST,OArnBA4Y,EAAatb,UAAY,IAAI2P,GACN9L,KAAO,eAC9ByX,EAAatb,UAAU+L,gBAAiB,EAexCuP,EAAatb,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAEhD,GAAuB,iBAAZlU,KAAKsL,KAAoB0T,EAAa/e,EAAMD,KAAKsL,IAC1D,MAAKrL,EAAKD,KAAKsL,IAGP,IAAI1K,MAAM,0BAA4BZ,KAAKsL,GAAK,KAFhD,IAAI1K,MAAM,YAAcZ,KAAKsL,GAAK,yCAM5C,IAAIA,EAAK+H,EAAgBpT,EAAMD,KAAKsL,IAChC+O,EAAWhR,EAAIrJ,KAAKkL,KAAM,SAAUE,GACtC,OAAOA,EAAI6I,SAAShU,EAAMiU,KAG5B,GAAwB,IAApBmG,EAASrZ,OAAc,CACzB,IAAIuZ,EAAWF,EAAS,GACxB,OAAO,SAA0BxH,EAAO3H,EAAMoJ,GAC5C,OAAOhJ,EAAGiP,EAAS1H,EAAO3H,EAAMoJ,KAE7B,GAAwB,IAApB+F,EAASrZ,OAOlB,OAAO,SAA0B6R,EAAO3H,EAAMoJ,GAC5C,OAAOhJ,EAAGC,MAAM,KAAMlC,EAAIgR,EAAU,SAAUG,GAC5C,OAAOA,EAAQ3H,EAAO3H,EAAMoJ,OARhC,IAAImG,EAAWJ,EAAS,GACpBK,EAAWL,EAAS,GACxB,OAAO,SAA0BxH,EAAO3H,EAAMoJ,GAC5C,OAAOhJ,EAAGmP,EAAS5H,EAAO3H,EAAMoJ,GAAUoG,EAAS7H,EAAO3H,EAAMoJ,MAgBtE2K,EAAatb,UAAUF,QAAU,SAAU8Q,GACzC,IAAK,IAAIhU,EAAI,EAAGA,EAAIP,KAAKkL,KAAKlK,OAAQT,IACpCgU,EAASvU,KAAKkL,KAAK3K,GAAI,QAAUA,EAAI,IAAKP,OAW9Cif,EAAatb,UAAU0F,IAAM,SAAUkL,GAGrC,IAFA,IAAIrJ,EAAO,GAEF3K,EAAI,EAAGA,EAAIP,KAAKkL,KAAKlK,OAAQT,IACpC2K,EAAK3K,GAAKP,KAAKwU,QAAQD,EAASvU,KAAKkL,KAAK3K,GAAI,QAAUA,EAAI,IAAKP,OAGnE,OAAO,IAAIif,EAAajf,KAAKkf,GAAIlf,KAAKsL,GAAIJ,EAAMlL,KAAKmf,WAQvDF,EAAatb,UAAUoG,MAAQ,WAC7B,OAAO,IAAIkV,EAAajf,KAAKkf,GAAIlf,KAAKsL,GAAItL,KAAKkL,KAAKvE,MAAM,GAAI3G,KAAKmf,WASrEF,EAAatb,UAAUgd,QAAU,WAC/B,OAA4B,IAArB3gB,KAAKkL,KAAKlK,QASnBie,EAAatb,UAAUid,SAAW,WAChC,OAA4B,IAArB5gB,KAAKkL,KAAKlK,QAqOnBie,EAAatb,UAAU8Q,UAAY,SAAUrN,GAC3C,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEiJ,EAAW/X,GAAWA,EAAQ+X,SAAW/X,EAAQ+X,SAAW,OAC5DjU,EAAOlL,KAAKkL,KACZ2V,EAASzB,EAA8Bpf,KAAMkW,EAAaiJ,EAAUjU,GAAM,GAE9E,GAAoB,IAAhBA,EAAKlK,OAAc,CAErB,IAAI8f,EAAQ9K,EAAUuJ,iBAAiBvf,KAAMkW,GACzC6K,EAAU7V,EAAK,GAAGwJ,SAAStN,GAM/B,OAJIyZ,EAAO,KACTE,EAAU,IAAMA,EAAU,KAGd,UAAVD,EAEK9gB,KAAKkf,GAAK6B,EAGVA,EAAU/gB,KAAKkf,GAKnB,GAAoB,IAAhBhU,EAAKlK,OAAc,CAC5B,IAAIggB,EAAM9V,EAAK,GAAGwJ,SAAStN,GAEvB6Z,EAAM/V,EAAK,GAAGwJ,SAAStN,GAY3B,OAVIyZ,EAAO,KAETG,EAAM,IAAMA,EAAM,KAGhBH,EAAO,KAETI,EAAM,IAAMA,EAAM,KAGhBjhB,KAAKmf,UAAqC,0BAAzBnf,KAAK8b,iBAA4D,SAAbqD,EAChE6B,EAAM,IAAMC,EAGdD,EAAM,IAAMhhB,KAAKkf,GAAK,IAAM+B,EAC9B,GAAkB,EAAd/V,EAAKlK,SAAwC,qBAAzBhB,KAAK8b,iBAAmE,0BAAzB9b,KAAK8b,iBAA8C,CAC/H,IAAIoF,EAAkBhW,EAAK7B,IAAI,SAAU+B,EAAKtI,GAQ5C,OAPAsI,EAAMA,EAAIsJ,SAAStN,GAEfyZ,EAAO/d,KAETsI,EAAM,IAAMA,EAAM,KAGbA,IAGT,OAAIpL,KAAKmf,UAAqC,0BAAzBnf,KAAK8b,iBAA4D,SAAbqD,EAChE+B,EAAgBvX,KAAK,KAGvBuX,EAAgBvX,KAAK,IAAM3J,KAAKkf,GAAK,KAG5C,OAAOlf,KAAKsL,GAAK,IAAMtL,KAAKkL,KAAKvB,KAAK,MAAQ,KASlDsV,EAAatb,UAAUmR,OAAS,WAC9B,MAAO,CACLC,OAAQ,eACRmK,GAAIlf,KAAKkf,GACT5T,GAAItL,KAAKsL,GACTJ,KAAMlL,KAAKkL,KACXiU,SAAUnf,KAAKmf,WAYnBF,EAAajK,SAAW,SAAUvI,GAChC,OAAO,IAAIwS,EAAaxS,EAAKyS,GAAIzS,EAAKnB,GAAImB,EAAKvB,KAAMuB,EAAK0S,WAS5DF,EAAatb,UAAUgR,OAAS,SAAUvN,GACxC,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEiJ,EAAW/X,GAAWA,EAAQ+X,SAAW/X,EAAQ+X,SAAW,OAC5DjU,EAAOlL,KAAKkL,KACZ2V,EAASzB,EAA8Bpf,KAAMkW,EAAaiJ,EAAUjU,GAAM,GAE9E,GAAoB,IAAhBA,EAAKlK,OAAc,CAErB,IAAI8f,EAAQ9K,EAAUuJ,iBAAiBvf,KAAMkW,GACzC6K,EAAU7V,EAAK,GAAGyJ,OAAOvN,GAM7B,OAJIyZ,EAAO,KACTE,EAAU,iEAAmEA,EAAU,kEAG3E,UAAVD,EAEK,gFAAkFhI,EAAO9Y,KAAKkf,IAAM,UAAY6B,EAGhH,iFAAmFjI,EAAO9Y,KAAKkf,IAAM,UAAY6B,EAKrH,GAAoB,IAAhB7V,EAAKlK,OAAc,CAE5B,IAAIggB,EAAM9V,EAAK,GAAGyJ,OAAOvN,GAErB6Z,EAAM/V,EAAK,GAAGyJ,OAAOvN,GAYzB,OAVIyZ,EAAO,KAETG,EAAM,iEAAmEA,EAAM,kEAG7EH,EAAO,KAETI,EAAM,iEAAmEA,EAAM,kEAG7EjhB,KAAKmf,UAAqC,0BAAzBnf,KAAK8b,iBAA4D,SAAbqD,EAChE6B,EAAM,yFAA2FC,EAGnGD,EAAM,kFAAoFlI,EAAO9Y,KAAKkf,IAAM,UAAY+B,EAE/H,IAAIC,EAAkBhW,EAAK7B,IAAI,SAAU+B,EAAKtI,GAQ5C,OAPAsI,EAAMA,EAAIuJ,OAAOvN,GAEbyZ,EAAO/d,KAETsI,EAAM,iEAAmEA,EAAM,kEAG1EA,IAGT,OAAkB,EAAdF,EAAKlK,SAAwC,qBAAzBhB,KAAK8b,iBAAmE,0BAAzB9b,KAAK8b,iBACtE9b,KAAKmf,UAAqC,0BAAzBnf,KAAK8b,iBAA4D,SAAbqD,EAChE+B,EAAgBvX,KAAK,0FAGvBuX,EAAgBvX,KAAK,kFAAoFmP,EAAO9Y,KAAKkf,IAAM,WAG3H,+BAAiCpG,EAAO9Y,KAAKsL,IAAM,wEAA0E4V,EAAgBvX,KAAK,yCAA2C,kEAW1MsV,EAAatb,UAAUiR,OAAS,SAAUxN,GACxC,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEiJ,EAAW/X,GAAWA,EAAQ+X,SAAW/X,EAAQ+X,SAAW,OAC5DjU,EAAOlL,KAAKkL,KACZ2V,EAASzB,EAA8Bpf,KAAMkW,EAAaiJ,EAAUjU,GAAM,GAC1EgU,EAAK3F,EAAMvD,UAAUhW,KAAKsL,IAG9B,GAFA4T,OAAmB,IAAPA,EAAqBlf,KAAKkf,GAAKA,EAEvB,IAAhBhU,EAAKlK,OAAc,CAErB,IAAI8f,EAAQ9K,EAAUuJ,iBAAiBvf,KAAMkW,GACzC6K,EAAU7V,EAAK,GAAG2J,MAAMzN,GAM5B,OAJIyZ,EAAO,KACTE,EAAU,UAAUlK,OAAOkK,EAAS,aAGxB,UAAVD,EAEK5B,EAAK6B,EAGLA,EAAU7B,EAKd,GAAoB,IAAhBhU,EAAKlK,OAAc,CAE5B,IAAIggB,EAAM9V,EAAK,GAEXiW,EAASH,EAAInM,MAAMzN,GAEnByZ,EAAO,KACTM,EAAS,UAAUtK,OAAOsK,EAAQ,aAGpC,IASIhB,EAPAiB,EAFMlW,EAAK,GAEE2J,MAAMzN,GAgBvB,OAdIyZ,EAAO,KACTO,EAAS,UAAUvK,OAAOuK,EAAQ,aAOlCjB,EADkB,SAAhBjK,EACc8K,EAAIlF,gBAGJkF,EAAI3C,aAAavC,gBAG3B9b,KAAK8b,iBACX,IAAK,sBAEH,OAAOoD,EAAK,IAAMiC,EAAS,KAAYC,EAAS,IAElD,IAAK,mBAIH,OAHAD,EAAS,IAAMA,EAAS,IACxBC,EAAS,IAAMA,EAAS,IAEhBjB,GACN,IAAK,kBAEL,IAAK,sBACHgB,EAAS,UAAUtK,OAAOsK,EAAQ,YAGtC,MAEF,IAAK,wBACH,GAAInhB,KAAKmf,UAAyB,SAAbA,EACnB,OAAOgC,EAAS,IAAMC,EAK5B,OAAOD,EAASjC,EAAKkC,EAChB,GAAkB,EAAdlW,EAAKlK,SAAwC,qBAAzBhB,KAAK8b,iBAAmE,0BAAzB9b,KAAK8b,iBAA8C,CAC/H,IAAIuF,EAAenW,EAAK7B,IAAI,SAAU+B,EAAKtI,GAOzC,OANAsI,EAAMA,EAAIyJ,MAAMzN,GAEZyZ,EAAO/d,KACTsI,EAAM,UAAUyL,OAAOzL,EAAK,aAGvBA,IAGT,MAA6B,0BAAzBpL,KAAK8b,iBAA+C9b,KAAKmf,SACpDkC,EAAa1X,KAAK,KAGpB0X,EAAa1X,KAAKuV,GAKzB,MAAO,YAAclf,KAAKsL,GAAK,WAAaJ,EAAK7B,IAAI,SAAU+B,GAC7D,OAAOA,EAAIyJ,MAAMzN,KAChBuC,KAAK,KAAO,YASnBsV,EAAatb,UAAUmY,cAAgB,WACrC,OAAO9b,KAAKwH,KAAO,IAAMxH,KAAKsL,IAGzB2T,IAMP,CAACpJ,oBAAoB,GAAGZ,sBAAsB,GAAGkE,oBAAoB,GAAGC,qBAAqB,GAAGtC,eAAe,GAAG5B,SAAS,KAAKoM,GAAG,CAAC,SAAS7gB,EAAQf,EAAOD,GAC9J,aA8JAA,EAAQiE,KAAO,kBACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QA9JR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WASxB,SAAS8gB,EAAgBC,GACvB,KAAMxhB,gBAAgBuhB,GACpB,MAAM,IAAIpQ,YAAY,oDAIxB,IAAK3J,EAAKwH,OAAOwS,GACf,MAAM,IAAInU,UAAU,yCAGtBrN,KAAKwhB,QAAUA,EAqIjB,OAlIAD,EAAgB5d,UAAY,IAAI2P,GACN9L,KAAO,kBACjC+Z,EAAgB5d,UAAUgM,mBAAoB,EAe9C4R,EAAgB5d,UAAUsQ,SAAW,SAAUhU,EAAMiU,GACnD,OAAOlU,KAAKwhB,QAAQvN,SAAShU,EAAMiU,IASrCqN,EAAgB5d,UAAU0a,WAAa,WACrC,OAAOre,KAAKwhB,QAAQnD,cAQtBkD,EAAgB5d,UAAUF,QAAU,SAAU8Q,GAC5CA,EAASvU,KAAKwhB,QAAS,UAAWxhB,OAUpCuhB,EAAgB5d,UAAU0F,IAAM,SAAUkL,GAExC,OAAO,IAAIgN,EADGhN,EAASvU,KAAKwhB,QAAS,UAAWxhB,QASlDuhB,EAAgB5d,UAAUoG,MAAQ,WAChC,OAAO,IAAIwX,EAAgBvhB,KAAKwhB,UAUlCD,EAAgB5d,UAAU8Q,UAAY,SAAUrN,GAC9C,OAAKA,GAAWA,IAAYA,EAAQ8O,aAAe9O,GAAmC,SAAxBA,EAAQ8O,YAC7D,IAAMlW,KAAKwhB,QAAQ9M,SAAStN,GAAW,IAGzCpH,KAAKwhB,QAAQ9M,SAAStN,IAQ/Bma,EAAgB5d,UAAUmR,OAAS,WACjC,MAAO,CACLC,OAAQ,kBACRyM,QAASxhB,KAAKwhB,UAYlBD,EAAgBvM,SAAW,SAAUvI,GACnC,OAAO,IAAI8U,EAAgB9U,EAAK+U,UAUlCD,EAAgB5d,UAAUgR,OAAS,SAAUvN,GAC3C,OAAKA,GAAWA,IAAYA,EAAQ8O,aAAe9O,GAAmC,SAAxBA,EAAQ8O,YAC7D,iEAAmElW,KAAKwhB,QAAQ7M,OAAOvN,GAAW,iEAGpGpH,KAAKwhB,QAAQ7M,OAAOvN,IAU7Bma,EAAgB5d,UAAUiR,OAAS,SAAUxN,GAC3C,OAAKA,GAAWA,IAAYA,EAAQ8O,aAAe9O,GAAmC,SAAxBA,EAAQ8O,YAC7D,UAAUW,OAAO7W,KAAKwhB,QAAQ3M,MAAMzN,GAAU,YAGhDpH,KAAKwhB,QAAQ3M,MAAMzN,IAGrBma,IAMP,CAACrM,SAAS,KAAKuM,GAAG,CAAC,SAAShhB,EAAQf,EAAOD,GAC7C,aAEA,IAAIuW,EAAYvV,EAAQ,gBAyRxBhB,EAAQiE,KAAO,YACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QAzRR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WAUxB,SAASihB,EAAUpF,EAAOnJ,EAAKoJ,GAC7B,KAAMvc,gBAAgB0hB,GACpB,MAAM,IAAIvQ,YAAY,oDAIxB,IAAK3J,EAAKwH,OAAOsN,GAAQ,MAAM,IAAIjP,UAAU,iBAC7C,IAAK7F,EAAKwH,OAAOmE,GAAM,MAAM,IAAI9F,UAAU,iBAC3C,GAAIkP,IAAS/U,EAAKwH,OAAOuN,GAAO,MAAM,IAAIlP,UAAU,iBACpD,GAAuB,EAAnB/I,UAAUtD,OAAY,MAAM,IAAIJ,MAAM,sBAC1CZ,KAAKsc,MAAQA,EAEbtc,KAAKmT,IAAMA,EAEXnT,KAAKuc,KAAOA,GAAQ,KAgGtB,SAAS6C,EAA8BpL,EAAMkC,GAC3C,IAAIC,EAAaH,EAAUI,cAAcpC,EAAMkC,GAC3C2K,EAAS,GACTc,EAAkB3L,EAAUI,cAAcpC,EAAKsI,MAAOpG,GAG1D,GAFA2K,EAAOvE,MAA4B,OAApBqF,GAA4BA,GAAmBxL,GAA8B,QAAhBD,EAExElC,EAAKuI,KAAM,CACb,IAAIqF,EAAiB5L,EAAUI,cAAcpC,EAAKuI,KAAMrG,GACxD2K,EAAOtE,KAA0B,OAAnBqF,GAA2BA,GAAkBzL,GAA8B,QAAhBD,EAG3E,IAAI2L,EAAgB7L,EAAUI,cAAcpC,EAAKb,IAAK+C,GAEtD,OADA2K,EAAO1N,IAAwB,OAAlB0O,GAA0BA,GAAiB1L,GAA8B,QAAhBD,EAC/D2K,EA8IT,OAxPAa,EAAU/d,UAAY,IAAI2P,GACN9L,KAAO,YAC3Bka,EAAU/d,UAAUiM,aAAc,EAOlC8R,EAAU/d,UAAU+Y,SAAW,WAK7B,OAA2B,EAHV1c,KAAK+d,OAAO,SAAU/J,GACrC,OAAOxM,EAAKqI,aAAamE,IAAuB,QAAdA,EAAKtQ,OAEvB1C,QAiBpB0gB,EAAU/d,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAC7C,IAAIuI,EAAQxc,EAAKwc,MAEbE,EAAY3c,KAAKsc,MAAMrI,SAAShU,EAAMiU,GAEtC0I,EAAU5c,KAAKmT,IAAIc,SAAShU,EAAMiU,GAEtC,GAAIlU,KAAKuc,KAAM,CACb,IAAIM,EAAW7c,KAAKuc,KAAKtI,SAAShU,EAAMiU,GAExC,OAAO,SAAuBrB,EAAO3H,EAAMoJ,GACzC,OAAOmI,EAAME,EAAU9J,EAAO3H,EAAMoJ,GAAUsI,EAAQ/J,EAAO3H,EAAMoJ,GAAUuI,EAAShK,EAAO3H,EAAMoJ,KAGrG,OAAO,SAAuBzB,EAAO3H,EAAMoJ,GACzC,OAAOmI,EAAME,EAAU9J,EAAO3H,EAAMoJ,GAAUsI,EAAQ/J,EAAO3H,EAAMoJ,MAUzEoN,EAAU/d,UAAUF,QAAU,SAAU8Q,GACtCA,EAASvU,KAAKsc,MAAO,QAAStc,MAC9BuU,EAASvU,KAAKmT,IAAK,MAAOnT,MAEtBA,KAAKuc,MACPhI,EAASvU,KAAKuc,KAAM,OAAQvc,OAWhC0hB,EAAU/d,UAAU0F,IAAM,SAAUkL,GAClC,OAAO,IAAImN,EAAU1hB,KAAKwU,QAAQD,EAASvU,KAAKsc,MAAO,QAAStc,OAAQA,KAAKwU,QAAQD,EAASvU,KAAKmT,IAAK,MAAOnT,OAAQA,KAAKuc,MAAQvc,KAAKwU,QAAQD,EAASvU,KAAKuc,KAAM,OAAQvc,SAQ/K0hB,EAAU/d,UAAUoG,MAAQ,WAC1B,OAAO,IAAI2X,EAAU1hB,KAAKsc,MAAOtc,KAAKmT,IAAKnT,KAAKuc,MAAQvc,KAAKuc,OAiC/DmF,EAAU/d,UAAU8Q,UAAY,SAAUrN,GACxC,IAGIxB,EAFAib,EAASzB,EAA8Bpf,KADzBoH,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,QAIrEoG,EAAQtc,KAAKsc,MAAM5H,SAAStN,GAQhC,GANIyZ,EAAOvE,QACTA,EAAQ,IAAMA,EAAQ,KAGxB1W,EAAM0W,EAEFtc,KAAKuc,KAAM,CACb,IAAIA,EAAOvc,KAAKuc,KAAK7H,SAAStN,GAE1ByZ,EAAOtE,OACTA,EAAO,IAAMA,EAAO,KAGtB3W,GAAO,IAAM2W,EAGf,IAAIpJ,EAAMnT,KAAKmT,IAAIuB,SAAStN,GAO5B,OALIyZ,EAAO1N,MACTA,EAAM,IAAMA,EAAM,KAGpBvN,GAAO,IAAMuN,GASfuO,EAAU/d,UAAUmR,OAAS,WAC3B,MAAO,CACLC,OAAQ,YACRuH,MAAOtc,KAAKsc,MACZnJ,IAAKnT,KAAKmT,IACVoJ,KAAMvc,KAAKuc,OAYfmF,EAAU1M,SAAW,SAAUvI,GAC7B,OAAO,IAAIiV,EAAUjV,EAAK6P,MAAO7P,EAAK0G,IAAK1G,EAAK8P,OASlDmF,EAAU/d,UAAUgR,OAAS,SAAUvN,GACrC,IAGIxB,EAFAib,EAASzB,EAA8Bpf,KADzBoH,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,QAIrEoG,EAAQtc,KAAKsc,MAAM3H,OAAOvN,GAQ9B,GANIyZ,EAAOvE,QACTA,EAAQ,iEAAmEA,EAAQ,kEAGrF1W,EAAM0W,EAEFtc,KAAKuc,KAAM,CACb,IAAIA,EAAOvc,KAAKuc,KAAK5H,OAAOvN,GAExByZ,EAAOtE,OACTA,EAAO,iEAAmEA,EAAO,kEAGnF3W,GAAO,2DAA6D2W,EAGtE,IAAIpJ,EAAMnT,KAAKmT,IAAIwB,OAAOvN,GAO1B,OALIyZ,EAAO1N,MACTA,EAAM,iEAAmEA,EAAM,kEAGjFvN,GAAO,2DAA6DuN,GAUtEuO,EAAU/d,UAAUiR,OAAS,SAAUxN,GACrC,IACIyZ,EAASzB,EAA8Bpf,KADzBoH,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,QAErEtQ,EAAM5F,KAAKsc,MAAMzH,MAAMzN,GAM3B,GAJIyZ,EAAOvE,QACT1W,EAAM,UAAUiR,OAAOjR,EAAK,aAG1B5F,KAAKuc,KAAM,CACb,IAAIA,EAAOvc,KAAKuc,KAAK1H,MAAMzN,GAEvByZ,EAAOtE,OACTA,EAAO,UAAU1F,OAAO0F,EAAM,aAGhC3W,GAAO,IAAM2W,EAGf,IAAIpJ,EAAMnT,KAAKmT,IAAI0B,MAAMzN,GAOzB,OALIyZ,EAAO1N,MACTA,EAAM,UAAU0D,OAAO1D,EAAK,aAG9BvN,GAAO,IAAMuN,GAIRuO,IAMP,CAAC5K,eAAe,GAAG5B,SAAS,KAAK4M,GAAG,CAAC,SAASrhB,EAAQf,EAAOD,GAC/D,aAEA,IAAIuW,EAAYvV,EAAQ,gBAEpB8Y,EAAQ9Y,EAAQ,qBAEhBqY,EAASrY,EAAQ,sBAAsBqY,OAwN3CrZ,EAAQiE,KAAO,iBACfjE,EAAQyM,KAAO,kBACfzM,EAAQ2I,QAxNR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI0L,EAAOnL,EAAK1H,EAAQ,WAEpB4S,EAAkB5S,EAAQ,uBAAuB4S,gBAYrD,SAAS0O,EAAeC,EAAcvI,GACpC,KAAMzZ,gBAAgB+hB,GACpB,MAAM,IAAI5Q,YAAY,oDAGxB,IAAKtE,MAAMC,QAAQkV,GAAe,MAAM,IAAI3U,UAAU,2CACtD,IAAKR,MAAMC,QAAQ2M,GAAS,MAAM,IAAIpM,UAAU,qCAChD,GAAI2U,EAAahhB,SAAWyY,EAAOzY,OAAS,EAAG,MAAM,IAAIqM,UAAU,sFACnErN,KAAKgiB,aAAeA,EACpBhiB,KAAKyZ,OAASA,EA2LhB,OAxLAsI,EAAepe,UAAY,IAAI2P,GACN9L,KAAO,iBAChCua,EAAepe,UAAUse,kBAAmB,EAe5CF,EAAepe,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAClD,IAAInU,EAAOC,KACPkiB,EAAWliB,KAAKyZ,OAAOpQ,IAAI,SAAUvI,GACvC,OAAOA,EAAEmT,SAAShU,EAAMiU,KAE1B,OAAO,SAA4BrB,EAAO3H,EAAMoJ,GAI9C,IAHA,IAAI6N,EACAC,EAAUF,EAAS,GAAGrP,EAAO3H,EAAMoJ,GAE9B/T,EAAI,EAAGA,EAAIR,EAAKiiB,aAAahhB,OAAQT,IAK5C,GAJA4hB,EAAUC,EACVA,EAAUF,EAAS3hB,EAAI,GAAGsS,EAAO3H,EAAMoJ,IAC1BjB,EAAgBpT,EAAMF,EAAKiiB,aAAazhB,GAEhD8hB,CAAOF,EAASC,GACnB,OAAO,EAIX,OAAO,IASXL,EAAepe,UAAUF,QAAU,SAAU8Q,GAC3C,IAAI+N,EAAQtiB,KAEZA,KAAKyZ,OAAOhW,QAAQ,SAAUrD,EAAGG,GAC/B,OAAOgU,EAASnU,EAAG,UAAYG,EAAI,IAAK+hB,IACvCtiB,OAUL+hB,EAAepe,UAAU0F,IAAM,SAAUkL,GACvC,IAAIgO,EAASviB,KAEb,OAAO,IAAI+hB,EAAe/hB,KAAKgiB,aAAarb,QAAS3G,KAAKyZ,OAAOpQ,IAAI,SAAUjJ,EAAGG,GAChF,OAAOgiB,EAAO/N,QAAQD,EAASnU,EAAG,UAAYG,EAAI,IAAKgiB,KACtDviB,QAQL+hB,EAAepe,UAAUoG,MAAQ,WAC/B,OAAO,IAAIgY,EAAe/hB,KAAKgiB,aAAchiB,KAAKyZ,SASpDsI,EAAepe,UAAU8Q,UAAY,SAAUrN,GAiB7C,IAhBA,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEC,EAAaH,EAAUI,cAAcpW,KAAMkW,GAC3CsM,EAAexiB,KAAKyZ,OAAOpQ,IAAI,SAAUvI,EAAGgC,GAC9C,IAAI2f,EAAkBzM,EAAUI,cAActV,EAAGoV,GACjD,MAAuB,QAAhBA,GAA6C,OAApBuM,GAA4BA,GAAmBtM,EAAa,IAAMrV,EAAE4T,SAAStN,GAAW,IAAMtG,EAAE4T,SAAStN,KAEvIsb,EAAc,CAChBngB,MAAS,KACTC,QAAW,KACXC,QAAW,IACXC,OAAU,IACVC,UAAa,KACbC,SAAY,MAEV+f,EAAMH,EAAa,GAEdjiB,EAAI,EAAGA,EAAIP,KAAKgiB,aAAahhB,OAAQT,IAC5CoiB,GAAO,IAAMD,EAAY1iB,KAAKgiB,aAAazhB,IAAM,IAAMiiB,EAAajiB,EAAI,GAG1E,OAAOoiB,GAQTZ,EAAepe,UAAUmR,OAAS,WAChC,MAAO,CACLC,OAAQ,iBACRiN,aAAchiB,KAAKgiB,aACnBvI,OAAQzZ,KAAKyZ,SAYjBsI,EAAe/M,SAAW,SAAUvI,GAClC,OAAO,IAAIsV,EAAetV,EAAKuV,aAAcvV,EAAKgN,SASpDsI,EAAepe,UAAUgR,OAAS,SAAUvN,GAiB1C,IAhBA,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEC,EAAaH,EAAUI,cAAcpW,KAAMkW,GAC3CsM,EAAexiB,KAAKyZ,OAAOpQ,IAAI,SAAUvI,EAAGgC,GAC9C,IAAI2f,EAAkBzM,EAAUI,cAActV,EAAGoV,GACjD,MAAuB,QAAhBA,GAA6C,OAApBuM,GAA4BA,GAAmBtM,EAAa,iEAAmErV,EAAE6T,OAAOvN,GAAW,iEAAmEtG,EAAE6T,OAAOvN,KAE7Psb,EAAc,CAChBngB,MAAS,KACTC,QAAW,KACXC,QAAW,IACXC,OAAU,IACVC,UAAa,KACbC,SAAY,MAEV+f,EAAMH,EAAa,GAEdjiB,EAAI,EAAGA,EAAIP,KAAKgiB,aAAahhB,OAAQT,IAC5CoiB,GAAO,kFAAoF7J,EAAO4J,EAAY1iB,KAAKgiB,aAAazhB,KAAO,UAAYiiB,EAAajiB,EAAI,GAGtK,OAAOoiB,GASTZ,EAAepe,UAAUiR,OAAS,SAAUxN,GAS1C,IARA,IAAI8O,EAAc9O,GAAWA,EAAQ8O,YAAc9O,EAAQ8O,YAAc,OACrEC,EAAaH,EAAUI,cAAcpW,KAAMkW,GAC3CsM,EAAexiB,KAAKyZ,OAAOpQ,IAAI,SAAUvI,EAAGgC,GAC9C,IAAI2f,EAAkBzM,EAAUI,cAActV,EAAGoV,GACjD,MAAuB,QAAhBA,GAA6C,OAApBuM,GAA4BA,GAAmBtM,EAAa,UAAYrV,EAAE4T,SAAStN,GAAW,UAAYtG,EAAE4T,SAAStN,KAEnJub,EAAMH,EAAa,GAEdjiB,EAAI,EAAGA,EAAIP,KAAKgiB,aAAahhB,OAAQT,IAC5CoiB,GAAOpJ,EAAMvD,UAAUhW,KAAKgiB,aAAazhB,IAAMiiB,EAAajiB,EAAI,GAGlE,OAAOoiB,GAGFZ,IAMP,CAAC9M,sBAAsB,GAAGkE,oBAAoB,GAAGC,qBAAqB,GAAGtC,eAAe,GAAG5B,SAAS,KAAK0N,GAAG,CAAC,SAASniB,EAAQf,EAAOD,GACvI,aAEA,IAAI8Z,EAAQ9Y,EAAQ,qBAEhBqY,EAASrY,EAAQ,sBAAsBqY,OAEvClV,EAAiBnD,EAAQ,sBAAsBmD,eAE/CyP,EAAkB5S,EAAQ,uBAAuB4S,gBAqMrD5T,EAAQiE,KAAO,aACfjE,EAAQyM,KAAO,kBACfzM,EAAQQ,MAAO,EAEfR,EAAQ2I,QAvMR,SAAiBZ,EAAMgB,EAAQL,EAAMP,EAAO3H,GAC1C,IAAIqT,EAAOnL,EAAK1H,EAAQ,WAOxB,SAASoiB,EAAgBnf,GACvB,QAAO8D,EAAKsb,MAAOtb,EAAKsb,KAAKD,gBAAgBnf,GAW/C,SAASyW,EAAWzW,GAClB,KAAM1D,gBAAgBma,GACpB,MAAM,IAAIhJ,YAAY,oDAIxB,GAAoB,iBAATzN,EAAmB,MAAM,IAAI2J,UAAU,wCAClDrN,KAAK0D,KAAOA,EAqKd,OAlKAyW,EAAWxW,UAAY,IAAI2P,GACN9L,KAAO,aAC5B2S,EAAWxW,UAAUkM,cAAe,EAepCsK,EAAWxW,UAAUsQ,SAAW,SAAUhU,EAAMiU,GAC9C,IAAIxQ,EAAO1D,KAAK0D,KAEhB,GAAIE,EAAesQ,EAAUxQ,GAG3B,OAAO,SAAUmP,EAAO3H,EAAMoJ,GAC5B,OAAOpJ,EAAKxH,IAET,GAAIA,KAAQzD,EACjB,OAAO,SAAU4S,EAAO3H,EAAMoJ,GAC5B,OAAuBjB,EAAhB3P,KAAQmP,EAAwBA,EAA+B5S,EAAxByD,IAGhD,IAAIsJ,EAAS6V,EAAgBnf,GAC7B,OAAO,SAAUmP,EAAO3H,EAAMoJ,GAC5B,OAAO5Q,KAAQmP,EAAQQ,EAAgBR,EAAOnP,GAAQsJ,EAAS,IAAIxF,EAAKsb,KAAK,KAAMpf,GA6BzF,SAAeA,GACb,MAAM,IAAI9C,MAAM,oBAAsB8C,GA9ByDqf,CAAMrf,KAUvGyW,EAAWxW,UAAUF,QAAU,SAAU8Q,KAUzC4F,EAAWxW,UAAU0F,IAAM,SAAUkL,GACnC,OAAOvU,KAAK+J,SAiBdoQ,EAAWxW,UAAUoG,MAAQ,WAC3B,OAAO,IAAIoQ,EAAWna,KAAK0D,OAU7ByW,EAAWxW,UAAU8Q,UAAY,SAAUrN,GACzC,OAAOpH,KAAK0D,MAUdyW,EAAWxW,UAAUgR,OAAS,SAAUvN,GACtC,IAAI1D,EAAOoV,EAAO9Y,KAAK0D,MAEvB,MAAa,SAATA,GAA4B,UAATA,EACd,0CAA4CA,EAAO,UACxC,MAATA,EACF,mDAAqDA,EAAO,UACjD,aAATA,EACF,kDAAoDA,EAAO,UAChD,QAATA,EACF,6CAA+CA,EAAO,UAC3C,SAATA,EACF,8CAAgDA,EAAO,UAC5C,cAATA,EACF,mDAAqDA,EAAO,UAG9D,6BAA+BA,EAAO,WAQ/CyW,EAAWxW,UAAUmR,OAAS,WAC5B,MAAO,CACLC,OAAQ,aACRrR,KAAM1D,KAAK0D,OAYfyW,EAAWnF,SAAW,SAAUvI,GAC9B,OAAO,IAAI0N,EAAW1N,EAAK/I,OAU7ByW,EAAWxW,UAAUiR,OAAS,SAAUxN,GACtC,IAAI4F,GAAS,OAEkB,IAApB/M,EAAKD,KAAK0D,OAAyBmf,EAAgB7iB,KAAK0D,QACjEsJ,GAAS,GAGX,IAAI0Q,EAASnE,EAAMQ,SAAS/Z,KAAK0D,KAAMsJ,GAEvC,MAAkB,OAAd0Q,EAAO,GAEFA,EAIF,IAAMA,GAGRvD,IAQP,CAAClF,sBAAsB,GAAGkE,oBAAoB,GAAG/O,qBAAqB,GAAGgP,qBAAqB,GAAGlE,SAAS,KAAK8N,GAAG,CAAC,SAASviB,EAAQf,EAAOD,GAC7I,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAI0Y,EAAiBxiB,EAAQ,mCAAmCiH,UAE5D2L,EAAkB5S,EAAQ,0BAA0B4S,gBAyCxD5T,EAAQ2I,QAvCR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIsb,EAAS/a,EAAK1H,EAAQ,oCAa1B,OAAO,SAAgBuI,EAAQlG,GAC7B,IACE,GAAI+J,MAAMC,QAAQ9D,GAChB,OAAOka,EAAOla,EAAQlG,GACjB,GAAIkG,GAAmC,mBAAlBA,EAAOka,OAEjC,OAAOla,EAAOka,OAAOpgB,GAChB,GAAsB,iBAAXkG,EAEhB,OAAOka,EAAOla,EAAQlG,GACjB,GAAwB,WAApBwH,EAAQtB,GAOjB,MAAM,IAAIqE,UAAU,kDANpB,IAAKvK,EAAM6Q,mBACT,MAAM,IAAItG,UAAU,mDAGtB,OAAOgG,EAAgBrK,EAAQlG,EAAM8Q,qBAIvC,MAAOnD,GACP,MAAMwS,EAAexS,OAMzB,CAAC0S,kCAAkC,GAAGC,yBAAyB,GAAGC,kCAAkC,KAAKC,GAAG,CAAC,SAAS7iB,EAAQf,EAAOD,GACvI,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAI0Y,EAAiBxiB,EAAQ,mCAAmCiH,UAE5DqO,EAAkBtV,EAAQ,0BAA0BsV,gBA8CxDtW,EAAQ2I,QA5CR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIsb,EAAS/a,EAAK1H,EAAQ,oCACtBoC,EAASsF,EAAK1H,EAAQ,yCAgB1B,OAAO,SAAgBuI,EAAQlG,EAAOiI,GACpC,IACE,GAAI8B,MAAMC,QAAQ9D,GAChB,OAAOnG,EAAOmG,GAAQka,OAAOpgB,EAAOiI,GAAOM,UACtC,GAAIrC,GAAmC,mBAAlBA,EAAOka,OAEjC,OAAOla,EAAOka,OAAOpgB,EAAOiI,GACvB,GAAsB,iBAAX/B,EAEhB,OAAOka,EAAOla,EAAQlG,EAAOiI,GACxB,GAAwB,WAApBT,EAAQtB,GAQjB,MAAM,IAAIqE,UAAU,kDAPpB,IAAKvK,EAAM6Q,mBACT,MAAMtG,UAAU,mDAIlB,OADA0I,EAAgB/M,EAAQlG,EAAM8Q,oBAAqB7I,GAC5C/B,EAIT,MAAOyH,GACP,MAAMwS,EAAexS,OAMzB,CAAC0S,kCAAkC,GAAGI,uCAAuC,GAAGH,yBAAyB,GAAGC,kCAAkC,KAAKG,GAAG,CAAC,SAAS/iB,EAAQf,EAAOD,GACjL,aAmBA,IAAIgf,EAAa,CAAC,CAEhBxI,eAAkB,GAClBuD,uBAA0B,IACzB,CAED5B,gBAAmB,CACjB+H,iBAAiB,EACjBY,kBAAkB,EAClBX,aAAa,IAId,CAED6D,kBAAmB,CACjBnE,cAAe,OACfoE,gBAAiB,KAElB,CAEDC,mBAAoB,CAClBrE,cAAe,OACfoE,gBAAiB,KAElB,CAEDE,mBAAoB,CAClBtE,cAAe,OACfoE,gBAAiB,KAElB,CAEDG,qBAAsB,CACpBvE,cAAe,OACfoE,gBAAiB,KAElB,CAEDI,sBAAuB,CACrBxE,cAAe,OACfoE,gBAAiB,KAElB,CAEDK,sBAAuB,CACrBzE,cAAe,OACfoE,gBAAiB,KAElB,CAEDM,qBAAsB,CACpB1E,cAAe,OACfoE,gBAAiB,IAEnBO,uBAAwB,CACtB3E,cAAe,OACfoE,gBAAiB,IAEnBQ,uBAAwB,CACtB5E,cAAe,OACfoE,gBAAiB,IAEnBS,sBAAuB,CACrB7E,cAAe,OACfoE,gBAAiB,IAEnBU,yBAA0B,CACxB9E,cAAe,OACfoE,gBAAiB,IAEnBW,wBAAyB,CACvB/E,cAAe,OACfoE,gBAAiB,IAEnB3B,eAAkB,CAChBzC,cAAe,OACfoE,gBAAiB,KAElB,CAEDY,yBAA0B,CACxBhF,cAAe,OACfoE,gBAAiB,IAEnBa,+BAAgC,CAC9BjF,cAAe,OACfoE,gBAAiB,IAEnBc,6BAA8B,CAC5BlF,cAAe,OACfoE,gBAAiB,KAElB,CAEDe,kBAAmB,CACjBnF,cAAe,OACfoE,gBAAiB,KAElB,CAEDhC,UAAa,IACZ,CAEDgD,mBAAoB,CAClBpF,cAAe,OACfoE,gBAAiB,CAAC,mBAAoB,0BAExCiB,wBAAyB,CACvBrF,cAAe,OACfoE,gBAAiB,KAElB,CAEDkB,wBAAyB,CACvBtF,cAAe,OACfoE,gBAAiB,CAAC,wBAAyB,sBAAuB,uBAAwB,uBAE5FmB,sBAAuB,CACrBvF,cAAe,OACfoE,gBAAiB,GACjB/D,iBAAiB,EACjBY,kBAAkB,EAClBX,aAAa,GAKfkF,2BAA4B,CAC1BxF,cAAe,OACfoE,gBAAiB,CAAC,wBAAyB,sBAAuB,2BAA4B,0BAEhGqB,yBAA0B,CACxBzF,cAAe,OACfoE,gBAAiB,IAEnBsB,mBAAoB,CAClB1F,cAAe,OACfoE,gBAAiB,KAElB,CAEDuB,yBAA0B,CACxB3F,cAAe,SAEjB4F,0BAA2B,CACzB5F,cAAe,SAEjB6F,sBAAuB,CACrB7F,cAAe,SAEjB8F,mBAAoB,CAClB9F,cAAe,UAEhB,CAED+F,mBAAoB,CAClB/F,cAAe,QACfoE,gBAAiB,GACjBnD,kBAAkB,GAKpB+E,sBAAuB,CACrBhG,cAAe,QACfoE,gBAAiB,KAElB,CAED6B,yBAA0B,CACxBjG,cAAe,SAEhB,CAEDkG,yBAA0B,CACxBlG,cAAe,UAanB,SAASlJ,EAAcqP,EAAOvP,GAC5B,IAAIlC,EAAOyR,EAES,SAAhBvP,IAEFlC,EAAOyR,EAAMpH,cAKf,IAFA,IAAIqH,EAAa1R,EAAK8H,gBAEbvb,EAAI,EAAGA,EAAIke,EAAWzd,OAAQT,IACrC,GAAImlB,KAAcjH,EAAWle,GAC3B,OAAOA,EAIX,OAAO,KAwFTb,EAAOD,QAAQgf,WAAaA,EAC5B/e,EAAOD,QAAQ2W,cAAgBA,EAC/B1W,EAAOD,QAAQ8f,iBA5Ef,SAA0BkG,EAAOvP,GAC/B,IAAIlC,EAAOyR,EAES,SAAhBvP,IAEFlC,EAAOyR,EAAMpH,cAGf,IAAIqH,EAAa1R,EAAK8H,gBAClBhZ,EAAQsT,EAAcpC,EAAMkC,GAEhC,GAAc,OAAVpT,EAEF,OAAO,KAGT,IAAIuY,EAAWoD,EAAW3b,GAAO4iB,GAEjC,GAAIrK,EAASzX,eAAe,iBAAkB,CAC5C,GAA+B,SAA3ByX,EAASiE,cACX,MAAO,OAGT,GAA+B,UAA3BjE,EAASiE,cACX,MAAO,QAIT,MAAM1e,MAAM,IAAO8kB,EAAa,oCAAwCrK,EAASiE,cAAgB,MAInG,OAAO,MA6CT5f,EAAOD,QAAQwgB,kBAhCf,SAA2B0F,EAAOC,EAAO1P,GAEvC,IAAIvV,EAAoB,SAAhBuV,EAAyByP,EAAMtH,aAAesH,EAClDtkB,EAAoB,SAAhB6U,EAAyByP,EAAMtH,aAAeuH,EAClDC,EAAcllB,EAAEmb,gBAChBgK,EAAczkB,EAAEya,gBAChBhZ,EAAQsT,EAAczV,EAAGuV,GAE7B,GAAc,OAAVpT,EAEF,OAAO,KAGT,IAAIuY,EAAWoD,EAAW3b,GAAO+iB,GAEjC,GAAIxK,EAASzX,eAAe,oBAAsByX,EAASqI,2BAA2B7W,MAAO,CAC3F,IAAK,IAAItM,EAAI,EAAGA,EAAI8a,EAASqI,gBAAgB1iB,OAAQT,IACnD,GAAI8a,EAASqI,gBAAgBnjB,KAAOulB,EAClC,OAAO,EAIX,OAAO,EAIT,OAAO,OAOP,IAAIC,GAAG,CAAC,SAAStlB,GAAQf,EAAOD,GAClC,aAEA,SAAS0E,KAA2Q,OAA9PA,GAAWZ,OAAOa,QAAU,SAAUC,GAAU,IAAK,IAAI9D,EAAI,EAAGA,EAAI+D,UAAUtD,OAAQT,IAAK,CAAE,IAAIgE,EAASD,UAAU/D,GAAI,IAAK,IAAIiE,KAAOD,EAAchB,OAAOI,UAAUC,eAAe7C,KAAKwD,EAAQC,KAAQH,EAAOG,GAAOD,EAAOC,IAAY,OAAOH,IAA2BkH,MAAMvL,KAAMsE,WAEhT,IAAIuG,GAAiBpK,GAAQ,2BAEzByR,GAAUzR,GAAQ,+BA+pDtBhB,EAAQiE,KAAO,QACfjE,EAAQyM,KAAO,aACfzM,EAAQ2I,QA/pDR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIoe,EAAU7d,EAAK1H,GAAQ,oBACvB+S,EAAerL,EAAK1H,GAAQ,wBAC5B4U,EAAYlN,EAAK1H,GAAQ,qBACzBwV,EAAiB9N,EAAK1H,GAAQ,0BAC9ByW,EAAY/O,EAAK1H,GAAQ,qBACzBmX,EAAkBzP,EAAK1H,GAAQ,2BAC/BuY,EAAe7Q,EAAK1H,GAAQ,wBAC5B+Y,EAAyBrR,EAAK1H,GAAQ,kCACtCyb,EAAY/T,EAAK1H,GAAQ,qBACzB+d,EAAarW,EAAK1H,GAAQ,sBAC1Bwe,EAAe9W,EAAK1H,GAAQ,wBAC5B8gB,EAAkBpZ,EAAK1H,GAAQ,2BAC/B2Z,EAAejS,EAAK1H,GAAQ,wBAC5BihB,EAAYvZ,EAAK1H,GAAQ,qBACzBshB,EAAiB5Z,EAAK1H,GAAQ,0BAC9B0Z,EAAahS,EAAK1H,GAAQ,sBAkC9B,SAAS0R,EAAME,EAAMjL,GACnB,GAAyB,IAArB9C,UAAUtD,QAAqC,IAArBsD,UAAUtD,OACtC,MAAM,IAAI6J,GAAe,QAASvG,UAAUtD,OAAQ,EAAG,GAIzD,IAAIilB,EAAa7e,GAAWA,EAAQ4W,MAAQ5W,EAAQ4W,MAAQ,GAE5D,GAAoB,iBAAT3L,EAET,OAAO6T,EAAW7T,EAAM4T,GACnB,GAAIpZ,MAAMC,QAAQuF,IAASA,aAAgB7K,EAAK2e,OAErD,OAAOjU,GAAQG,EAAM,SAAU+T,GAC7B,GAAoB,iBAATA,EAAmB,MAAM,IAAI/Y,UAAU,mBAClD,OAAO6Y,EAAWE,EAAMH,KAI1B,MAAM,IAAI5Y,UAAU,6BAKxB,IAAIgZ,EAAY,CACdC,KAAM,EACNC,UAAW,EACX1c,OAAQ,EACR2c,OAAQ,EACRC,QAAS,GAGPC,EAAa,CACfC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLriB,KAAK,EACLC,KAAK,EACLqiB,KAAK,EACLC,KAAM,EACNC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,MAAM,EACNC,KAAK,EACLC,MAAM,EACNziB,KAAK,EACLE,KAAK,EACLwiB,MAAM,EACNtiB,KAAK,EACLuiB,KAAK,EACL1iB,KAAK,EACL2iB,KAAK,EACLC,MAAM,EACNC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,KAAK,EACLC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,OAAO,GAGLC,EAAmB,CACrBhnB,KAAO,EACP0O,IAAM,EACNuY,IAAM,EACNrmB,KAAO,EACPD,KAAO,EACPD,IAAM,EACNG,KAAO,GAELqmB,EAAY,CACdxlB,MAAQ,EACRC,OAAS,EACTC,KAAQ,KACRyC,eAAaA,GAEX8iB,EAAoB,CAAC,MAAO,YAgChC,SAASC,EAAcC,EAAO9nB,GAC5B,OAAO8nB,EAAMrhB,WAAWshB,OAAOD,EAAMhmB,MAAO9B,GAW9C,SAASgoB,EAAiBF,GACxB,OAAOD,EAAcC,EAAO,GAU9B,SAASG,EAAKH,GACZA,EAAMhmB,QASR,SAASomB,EAAcJ,GACrB,OAAOA,EAAMrhB,WAAW0hB,OAAOL,EAAMhmB,MAAQ,GAS/C,SAASsmB,EAAcN,GACrB,OAAOA,EAAMrhB,WAAW0hB,OAAOL,EAAMhmB,MAAQ,GAS/C,SAASumB,EAASP,GAMhB,IALAA,EAAMQ,UAAYjD,EAAUC,KAC5BwC,EAAMS,MAAQ,GACdT,EAAMrL,QAAU,GAGTtL,EAAMqX,aAAaR,EAAiBF,GAAQA,EAAMW,eACvDR,EAAKH,GAIP,GAAgC,MAA5BE,EAAiBF,GACnB,KAAmC,OAA5BE,EAAiBF,IAA+C,KAA5BE,EAAiBF,IAC1DA,EAAMrL,SAAWuL,EAAiBF,GAClCG,EAAKH,GAKT,GAAgC,KAA5BE,EAAiBF,GAArB,CAOA,GAAgC,OAA5BE,EAAiBF,KAAoBA,EAAMW,aAI7C,OAHAX,EAAMQ,UAAYjD,EAAUE,UAC5BuC,EAAMS,MAAQP,EAAiBF,QAC/BG,EAAKH,GAIP,IAAIY,EAAKV,EAAiBF,GACtBa,EAAKd,EAAcC,EAAO,GAC1Bc,EAAKf,EAAcC,EAAO,GAE9B,GAAkB,IAAdc,EAAG5oB,QAAgB0lB,EAAWkD,GAMhC,OALAd,EAAMQ,UAAYjD,EAAUE,UAC5BuC,EAAMS,MAAQK,EACdX,EAAKH,GACLG,EAAKH,QACLG,EAAKH,GAKP,GAAkB,IAAda,EAAG3oB,QAAgB0lB,EAAWiD,GAKhC,OAJAb,EAAMQ,UAAYjD,EAAUE,UAC5BuC,EAAMS,MAAQI,EACdV,EAAKH,QACLG,EAAKH,GAKP,GAAIpC,EAAWgD,GAIb,OAHAZ,EAAMQ,UAAYjD,EAAUE,UAC5BuC,EAAMS,MAAQG,OACdT,EAAKH,GAKP,GAAI3W,EAAM0X,WAAWH,GAArB,CAGE,GAFAZ,EAAMQ,UAAYjD,EAAUxc,OAEI,MAA5Bmf,EAAiBF,GACnBA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAEA3W,EAAM2X,QAAQd,EAAiBF,MAElCA,EAAMQ,UAAYjD,EAAUE,eAEzB,CACL,KAAOpU,EAAM2X,QAAQd,EAAiBF,KACpCA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAGH3W,EAAM4X,cAAcf,EAAiBF,GAAQM,EAAcN,MAC7DA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,IAIT,KAAO3W,EAAM2X,QAAQd,EAAiBF,KACpCA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAIP,GAAgC,MAA5BE,EAAiBF,IAA8C,MAA5BE,EAAiBF,GACtD,GAAI3W,EAAM2X,QAAQV,EAAcN,KAAoC,MAAzBM,EAAcN,IAA2C,MAAzBM,EAAcN,GAAgB,CAUvG,GATAA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAE2B,MAA5BE,EAAiBF,IAA8C,MAA5BE,EAAiBF,KACtDA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,KAIF3W,EAAM2X,QAAQd,EAAiBF,IAClC,MAAMkB,GAAkBlB,EAAO,wBAA0BE,EAAiBF,GAAS,KAGrF,KAAO3W,EAAM2X,QAAQd,EAAiBF,KACpCA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAGP,GAAI3W,EAAM4X,cAAcf,EAAiBF,GAAQM,EAAcN,IAC7D,MAAMkB,GAAkBlB,EAAO,wBAA0BE,EAAiBF,GAAS,UAEhF,GAA6B,MAAzBM,EAAcN,GAEvB,MADAG,EAAKH,GACCkB,GAAkBlB,EAAO,wBAA0BE,EAAiBF,GAAS,SAtDzF,CA8DA,IAAI3W,EAAM8X,QAAQjB,EAAiBF,GAAQI,EAAcJ,GAAQM,EAAcN,IAA/E,CAkBA,IAFAA,EAAMQ,UAAYjD,EAAUI,QAEO,KAA5BuC,EAAiBF,IACtBA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAGP,MAAMkB,GAAkBlB,EAAO,yBAA2BA,EAAMS,MAAQ,KAtBtE,KAAOpX,EAAM8X,QAAQjB,EAAiBF,GAAQI,EAAcJ,GAAQM,EAAcN,KAAW3W,EAAM2X,QAAQd,EAAiBF,KAC1HA,EAAMS,OAASP,EAAiBF,GAChCG,EAAKH,GAGHL,EAAiB7kB,eAAeklB,EAAMS,OACxCT,EAAMQ,UAAYjD,EAAUE,UAE5BuC,EAAMQ,UAAYjD,EAAUG,aAlH9BsC,EAAMQ,UAAYjD,EAAUE,UAuIhC,SAAS2D,EAAoBpB,GAC3B,KACEO,EAASP,GACc,OAAhBA,EAAMS,SASjB,SAASY,EAAWrB,GAClBA,EAAMW,eAQR,SAASW,EAAYtB,GACnBA,EAAMW,eA0GR,SAASvD,EAAWze,EAAYwe,GAC9B,IAAI6C,EA/WG,CACL7C,WAAY,GAEZxe,WAAY,GAEZgW,QAAS,GAET3a,MAAO,EAEPymB,MAAO,GAEPD,UAAWjD,EAAUC,KAErBmD,aAAc,EAEdY,iBAAkB,MAkWpBlmB,GAAS2kB,EAAO,CACdrhB,WAAYA,EACZwe,WAAYA,IAGdoD,EAASP,GACT,IAAI9U,EAwBN,SAAoB8U,GAClB,IAAI9U,EAEAqD,EADAF,EAAS,GASb,IANoB,KAAhB2R,EAAMS,OAAgC,OAAhBT,EAAMS,OAAkC,MAAhBT,EAAMS,SACtDvV,EAAOsW,EAAgBxB,IAClBrL,QAAUqL,EAAMrL,SAIA,OAAhBqL,EAAMS,OAAkC,MAAhBT,EAAMS,OAEb,IAAlBpS,EAAOnW,QAAgBgT,IACzBqD,EAA0B,MAAhByR,EAAMS,MAChBpS,EAAO5O,KAAK,CACVyL,KAAMA,EACNqD,QAASA,KAIbgS,EAASP,GAEW,OAAhBA,EAAMS,OAAkC,MAAhBT,EAAMS,OAAiC,KAAhBT,EAAMS,SACvDvV,EAAOsW,EAAgBxB,IAClBrL,QAAUqL,EAAMrL,QACrBpG,EAA0B,MAAhByR,EAAMS,MAChBpS,EAAO5O,KAAK,CACVyL,KAAMA,EACNqD,QAASA,KAKf,OAAoB,EAAhBF,EAAOnW,OACF,IAAIkW,EAAUC,IAEhBnD,KACHA,EAAO,IAAIgF,OAAalT,IACnB2X,QAAUqL,EAAMrL,SAGhBzJ,GAlEEuW,CAAWzB,GAGtB,GAAoB,KAAhBA,EAAMS,MACR,MAAIT,EAAMQ,YAAcjD,EAAUE,UAG1BiE,GAAY1B,EAAO,uBAAyBA,EAAMS,OAElDS,GAAkBlB,EAAO,oBAAsBA,EAAMS,MAAQ,KAIvE,OAAOvV,EAkET,SAASsW,EAAgBxB,GACvB,IAAIplB,EAAMwH,EAAMH,EAAO0f,EACnBzW,EAmDN,SAA0B8U,GAGxB,IAFA,IAAI9U,EA8BN,SAAwB8U,GAGtB,IAFA,IAAI9U,EAAO0W,EAAgB5B,GAEJ,OAAhBA,EAAMS,OAEXW,EAAoBpB,GACpB9U,EAAO,IAAIiL,EAAa,KAAM,KAAM,CAACjL,EAAM0W,EAAgB5B,KAG7D,OAAO9U,EAvCI2W,CAAe7B,GAEH,MAAhBA,EAAMS,OAAe,CAI1B,IAAIzf,EAAOgf,EAAMuB,iBACjBvB,EAAMuB,iBAAmBvB,EAAMW,aAC/BS,EAAoBpB,GACpB,IAAIjR,EAAY7D,EACZ8D,EAAWwS,EAAgBxB,GAC/B,GAAoB,MAAhBA,EAAMS,MAAe,MAAMS,GAAkBlB,EAAO,iDACxDA,EAAMuB,iBAAmB,KACzBH,EAAoBpB,GACpB,IAAI/Q,EAAYuS,EAAgBxB,GAEhC9U,EAAO,IAAI4D,EAAgBC,EAAWC,EAAUC,GAEhD+Q,EAAMuB,iBAAmBvgB,EAG3B,OAAOkK,EAzEI4W,CAAiB9B,GAE5B,GAAoB,MAAhBA,EAAMS,MAmCV,OAAOvV,EAlCL,GAAIxM,EAAKqI,aAAamE,GAKpB,OAHAtQ,EAAOsQ,EAAKtQ,KACZwmB,EAAoBpB,GACpB/d,EAAQuf,EAAgBxB,GACjB,IAAI7S,EAAe,IAAIkE,EAAWzW,GAAOqH,GAC3C,GAAIvD,EAAKuH,eAAeiF,GAI7B,OAFAkW,EAAoBpB,GACpB/d,EAAQuf,EAAgBxB,GACjB,IAAI7S,EAAejC,EAAKhL,OAAQgL,EAAKlR,MAAOiI,GAC9C,GAAIvD,EAAK+H,eAAeyE,IAASxM,EAAKqI,aAAamE,EAAK1I,MAE7Dmf,GAAQ,EACRvf,EAAO,GACPxH,EAAOsQ,EAAKtQ,KACZsQ,EAAK9I,KAAKzH,QAAQ,SAAU2H,EAAKtI,GAC3B0E,EAAKqI,aAAazE,GACpBF,EAAKpI,GAASsI,EAAI1H,KAElB+mB,GAAQ,IAIRA,GAGF,OAFAP,EAAoBpB,GACpB/d,EAAQuf,EAAgBxB,GACjB,IAAItP,EAAuB9V,EAAMwH,EAAMH,GAIlD,MAAMif,GAAkBlB,EAAO,mDAkEnC,SAAS4B,EAAgB5B,GAGvB,IAFA,IAAI9U,EAAO6W,EAAgB/B,GAEJ,QAAhBA,EAAMS,OAEXW,EAAoBpB,GACpB9U,EAAO,IAAIiL,EAAa,MAAO,MAAO,CAACjL,EAAM6W,EAAgB/B,KAG/D,OAAO9U,EAST,SAAS6W,EAAgB/B,GAGvB,IAFA,IAAI9U,EAAO8W,EAAehC,GAEH,QAAhBA,EAAMS,OAEXW,EAAoBpB,GACpB9U,EAAO,IAAIiL,EAAa,MAAO,MAAO,CAACjL,EAAM8W,EAAehC,KAG9D,OAAO9U,EAST,SAAS8W,EAAehC,GAGtB,IAFA,IAAI9U,EAAO+W,EAAgBjC,GAEJ,MAAhBA,EAAMS,OAEXW,EAAoBpB,GACpB9U,EAAO,IAAIiL,EAAa,IAAK,QAAS,CAACjL,EAAM+W,EAAgBjC,KAG/D,OAAO9U,EAST,SAAS+W,EAAgBjC,GAGvB,IAFA,IAAI9U,EAAOgX,EAAgBlC,GAEJ,OAAhBA,EAAMS,OAEXW,EAAoBpB,GACpB9U,EAAO,IAAIiL,EAAa,KAAM,SAAU,CAACjL,EAAMgX,EAAgBlC,KAGjE,OAAO9U,EAST,SAASgX,EAAgBlC,GAGvB,IAFA,IAAI9U,EAAOiX,EAAgBnC,GAEJ,MAAhBA,EAAMS,OAEXW,EAAoBpB,GACpB9U,EAAO,IAAIiL,EAAa,IAAK,SAAU,CAACjL,EAAMiX,EAAgBnC,KAGhE,OAAO9U,EAQT,SAASiX,EAAgBnC,GAYvB,IAXA,IAAIrP,EAAS,CAACyR,EAAWpC,IACrB9G,EAAe,GACfhM,EAAY,CACdgS,KAAM,QACNC,KAAM,UACNC,IAAK,UACLC,IAAK,SACLC,KAAM,YACNC,KAAM,YAGDrS,EAAUpS,eAAeklB,EAAMS,QAAQ,CAE5C,IAAI4B,EAAO,CACTznB,KAAMolB,EAAMS,MACZje,GAAI0K,EAAU8S,EAAMS,QAEtBvH,EAAazZ,KAAK4iB,GAClBjB,EAAoBpB,GACpBrP,EAAOlR,KAAK2iB,EAAWpC,IAGzB,OAAsB,IAAlBrP,EAAOzY,OACFyY,EAAO,GACa,IAAlBA,EAAOzY,OACT,IAAIie,EAAa+C,EAAa,GAAGte,KAAMse,EAAa,GAAG1W,GAAImO,GAE3D,IAAIsI,EAAeC,EAAa3Y,IAAI,SAAU7I,GACnD,OAAOA,EAAE8K,KACPmO,GAUR,SAASyR,EAAWpC,GAClB,IAAI9U,EAAMgC,EAAWtS,EAAM4H,EAAImO,EAQ/B,IAPAzF,EAAOoX,EAAgBtC,GACvB9S,EAAY,CACVsS,KAAM,YACNC,KAAM,kBACNC,MAAO,iBAGFxS,EAAUpS,eAAeklB,EAAMS,QAEpCje,EAAK0K,EADLtS,EAAOolB,EAAMS,OAEbW,EAAoBpB,GACpBrP,EAAS,CAACzF,EAAMoX,EAAgBtC,IAChC9U,EAAO,IAAIiL,EAAavb,EAAM4H,EAAImO,GAGpC,OAAOzF,EAST,SAASoX,EAAgBtC,GACvB,IAAI9U,EAAMgC,EAAWtS,EAAM4H,EAAImO,EAQ/B,IAPAzF,EAAOqX,EAAWvC,GAClB9S,EAAY,CACV7F,GAAM,KACNuY,GAAM,MAID1S,EAAUpS,eAAeklB,EAAMS,QAEpCje,EAAK0K,EADLtS,EAAOolB,EAAMS,OAEbW,EAAoBpB,GAIlB9U,EAFW,OAATtQ,GAAiC,KAAhBolB,EAAMS,MAElB,IAAItK,EAAa,IAAK,WAAY,CAACjL,EAAM,IAAImG,EAAW,QAAQ,IAGvEV,EAAS,CAACzF,EAAMqX,EAAWvC,IACpB,IAAI7J,EAAavb,EAAM4H,EAAImO,IAItC,OAAOzF,EAST,SAASqX,EAAWvC,GAClB,IAAI9U,EACAyF,EAAS,GAUb,GANEzF,EAFkB,MAAhB8U,EAAMS,MAED,IAAIvQ,EAAa,GAGjBsS,EAAiBxC,GAGN,MAAhBA,EAAMS,OAAiBT,EAAMuB,mBAAqBvB,EAAMW,aAAc,CAIxE,IAFAhQ,EAAOlR,KAAKyL,GAEW,MAAhB8U,EAAMS,OAAiB9P,EAAOzY,OAAS,GAE5CkpB,EAAoBpB,GAEA,MAAhBA,EAAMS,OAAiC,MAAhBT,EAAMS,OAAiC,MAAhBT,EAAMS,OAAiC,KAAhBT,EAAMS,MAE7E9P,EAAOlR,KAAK,IAAI4R,EAAW,QAG3BV,EAAOlR,KAAK+iB,EAAiBxC,IAM/B9U,EAFoB,IAAlByF,EAAOzY,OAEF,IAAI0gB,EAAUjI,EAAO,GAAIA,EAAO,GAAIA,EAAO,IAI3C,IAAIiI,EAAUjI,EAAO,GAAIA,EAAO,IAI3C,OAAOzF,EAST,SAASsX,EAAiBxC,GACxB,IAAI9U,EAAMgC,EAAWtS,EAAM4H,EAAImO,EAO/B,IANAzF,EAAOuX,EAAoBzC,GAC3B9S,EAAY,CACVmR,IAAK,MACLC,IAAK,YAGApR,EAAUpS,eAAeklB,EAAMS,QAEpCje,EAAK0K,EADLtS,EAAOolB,EAAMS,OAEbW,EAAoBpB,GACpBrP,EAAS,CAACzF,EAAMuX,EAAoBzC,IACpC9U,EAAO,IAAIiL,EAAavb,EAAM4H,EAAImO,GAGpC,OAAOzF,EAST,SAASuX,EAAoBzC,GAC3B,IAAI9U,EAAMwX,EAAMxV,EAAWtS,EAAM4H,EAYjC,IAVAkgB,EADAxX,EAAOyX,EAA4B3C,GAEnC9S,EAAY,CACVqR,IAAK,WACLC,KAAM,cACNC,IAAK,SACLC,KAAM,YACNziB,IAAK,MACLtD,IAAO,OAIHuU,EAAUpS,eAAeklB,EAAMS,QAGjCje,EAAK0K,EADLtS,EAAOolB,EAAMS,OAEbW,EAAoBpB,GACpB0C,EAAOC,EAA4B3C,GACnC9U,EAAO,IAAIiL,EAAavb,EAAM4H,EAAI,CAAC0I,EAAMwX,IAM7C,OAAOxX,EAST,SAASyX,EAA4B3C,GACnC,IAAI9U,EAAMwX,EAIV,IAFAA,EADAxX,EAAO0X,EAAW5C,GAIZA,EAAMQ,YAAcjD,EAAUG,QAA0B,OAAhBsC,EAAMS,OAAkB/hB,EAAK6H,eAAe2E,MAAS8U,EAAMQ,YAAcjD,EAAUxc,QAAWrC,EAAK6H,eAAemc,IAAWhkB,EAAKkI,eAAe8b,IAAqB,MAAZA,EAAKtM,KAA+B,MAAhB4J,EAAMS,OAM9NiC,EAAOE,EAAW5C,GAClB9U,EAAO,IAAIiL,EAAa,IAAK,WAAY,CAACjL,EAAMwX,IAAO,GAQ3D,OAAOxX,EAWT,SAAS0X,EAAW5C,GAKlB,IAJA,IAAI9U,EAAO2X,EAAW7C,GAClB0C,EAAOxX,EACP4X,EAAc,GAII,MAAhB9C,EAAMS,OAAiB/hB,EAAK6H,eAAemc,IAFpC,CAOT,GAHAI,EAAYrjB,KAAKpE,GAAS,GAAI2kB,IAC9BoB,EAAoBpB,GAEhBA,EAAMQ,YAAcjD,EAAUxc,OAqB3B,CAEL1F,GAAS2kB,EAAO8C,EAAYC,OAE5B,MApBA,GAHAD,EAAYrjB,KAAKpE,GAAS,GAAI2kB,IAC9BoB,EAAoBpB,GAEhBA,EAAMQ,YAAcjD,EAAUG,QAA0B,MAAhBsC,EAAMS,MAQ3C,CAELqC,EAAYC,MAEZ1nB,GAAS2kB,EAAO8C,EAAYC,OAE5B,MAXA1nB,GAAS2kB,EAAO8C,EAAYC,OAE5BD,EAAYC,MACZL,EAAOG,EAAW7C,GAClB9U,EAAO,IAAIiL,EAAa,IAAK,SAAU,CAACjL,EAAMwX,IAoBtD,OAAOxX,EAST,SAAS2X,EAAW7C,GAClB,IAAIplB,EAAM+V,EAAQnO,EA0BFwd,EACZ9U,EAAMtQ,EAAM4H,EAAImO,EA1BhBzD,EAAY,CACdoR,IAAK,aACLD,IAAK,YACLhiB,IAAK,SACL7C,IAAO,OAGT,OAAI0T,EAAUpS,eAAeklB,EAAMS,QACjCje,EAAK0K,EAAU8S,EAAMS,OACrB7lB,EAAOolB,EAAMS,MACbW,EAAoBpB,GACpBrP,EAAS,CAACkS,EAAW7C,IACd,IAAI7J,EAAavb,EAAM4H,EAAImO,KAepCzF,EAoBF,SAAgC8U,GAC9B,IAAI9U,EAAMgC,EAAWtS,EAAM4H,EAO3B,IANA0I,EA+CF,SAA0B8U,GACxB,IA2CmBA,EACf9U,EAAMtQ,EAwHqBolB,EAC3B9U,EAAMpO,EAkDqBkjB,EAC3B9U,EAAMpO,EAxNN6T,EAAS,GAEb,GAAIqP,EAAMQ,YAAcjD,EAAUG,QAAUsC,EAAM7C,WAAWriB,eAAeklB,EAAMS,OAAQ,CACxF,IAAIuC,EAAahD,EAAM7C,WAAW6C,EAAMS,OAGxC,GAFAF,EAASP,GAEW,MAAhBA,EAAMS,MAAe,CAKvB,GAJA9P,EAAS,GACT0Q,EAAWrB,GACXO,EAASP,GAEW,MAAhBA,EAAMS,MAGR,IAFA9P,EAAOlR,KAAK+hB,EAAgBxB,IAEL,MAAhBA,EAAMS,OAEXF,EAASP,GACTrP,EAAOlR,KAAK+hB,EAAgBxB,IAIhC,GAAoB,MAAhBA,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,0BAGjCsB,EAAYtB,GACZO,EAASP,GAKX,OAAO,IAAIgD,EAAWrS,GAGxB,OASmBqP,EATAA,GAYTQ,YAAcjD,EAAUG,QAAUsC,EAAMQ,YAAcjD,EAAUE,WAAauC,EAAMS,SAASd,GACpG/kB,EAAOolB,EAAMS,MACbF,EAASP,GAIP9U,EAFE2U,EAAU/kB,eAAeF,GAEpB,IAAIsV,EAAa2P,EAAUjlB,KACY,IAArCklB,EAAkBtgB,QAAQ5E,GAE5B,IAAIsV,EAAagN,EAAQtiB,EAAM,WAE/B,IAAIyW,EAAWzW,GAIxBsQ,EAAO+X,EAAejD,EAAO9U,IA0GX,OAHW8U,EAnGAA,GAsGrBS,MAmDU,OAHWT,EAvCAA,GA0CrBS,MAgDZ,SAAqBT,GACnB,IAAI3f,EAAOsQ,EAAQuS,EAAMC,EAEzB,GAAoB,MAAhBnD,EAAMS,MAyDV,OA6BF,SAAqBT,GACnB,GAAoB,MAAhBA,EAAMS,MA2CV,OASmBT,EATAA,GAYTQ,YAAcjD,EAAUxc,OAgBpC,SAA0Bif,GACxB,IAAI9U,EAEJ,GAAoB,MAAhB8U,EAAMS,MAiBV,OASF,SAAkBT,GAChB,KAAoB,KAAhBA,EAAMS,MAEFS,GAAkBlB,EAAO,gCAEzBkB,GAAkBlB,EAAO,kBAd1BoD,CAASpD,GAXd,GAJAqB,EAAWrB,GACXO,EAASP,GACT9U,EAAOsW,EAAgBxB,GAEH,MAAhBA,EAAMS,MAQV,OAJAa,EAAYtB,GACZO,EAASP,GACT9U,EAAO,IAAIuN,EAAgBvN,GAC3BA,EAAO+X,EAAejD,EAAO9U,GAN3B,MAAMgW,GAAkBlB,EAAO,0BAnB5BqD,CAAiBrD,IALtBsD,EAAYtD,EAAMS,MAClBF,EAASP,GACF,IAAI9P,EAAagN,EAAQoG,EAAW5jB,EAAOT,UAPtD,IAAqB+gB,EACfsD,EApDE5nB,EACAia,EAAa,GAEjB,GAGE,GAFA4K,EAASP,GAEW,MAAhBA,EAAMS,MAAe,CAEvB,GAAoB,MAAhBT,EAAMS,MACR/kB,EAAM6nB,EAA6BvD,QAC9B,GAAoB,MAAhBA,EAAMS,MACf/kB,EAAM8nB,EAA6BxD,OAC9B,CAAA,GAAIA,EAAMQ,YAAcjD,EAAUG,OAIvC,MAAMwD,GAAkBlB,EAAO,2CAH/BtkB,EAAMskB,EAAMS,MACZF,EAASP,GAMX,GAAoB,MAAhBA,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,qCAGjCO,EAASP,GAETrK,EAAWja,GAAO8lB,EAAgBxB,UAEb,MAAhBA,EAAMS,OAGf,GAAoB,MAAhBT,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,oDAGjCO,EAASP,GACT,IAAI9U,EAAO,IAAIwK,EAAWC,GAG1B,OADAzK,EAAO+X,EAAejD,EAAO9U,GArExBuY,CAAYzD,GApDjB,GAHAqB,EAAWrB,GACXO,EAASP,GAEW,MAAhBA,EAAMS,MAAe,CAEvB,IAAIiD,EAAMC,GAAS3D,GAEnB,GAAoB,MAAhBA,EAAMS,MAAe,CAKvB,IAHAyC,EAAO,EACPvS,EAAS,CAAC+S,GAEa,MAAhB1D,EAAMS,OAEXF,EAASP,GACTrP,EAAOuS,GAAQS,GAAS3D,GACxBkD,IAGF,GAAoB,MAAhBlD,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,4BAGjCsB,EAAYtB,GACZO,EAASP,GAETmD,EAAOxS,EAAO,GAAGnE,MAAMtU,OAEvB,IAAK,IAAId,EAAI,EAAGA,EAAI8rB,EAAM9rB,IACxB,GAAIuZ,EAAOvZ,GAAGoV,MAAMtU,SAAWirB,EAC7B,MAAMzB,GAAY1B,EAAO,+BAAsCrP,EAAOvZ,GAAGoV,MAAMtU,OAAS,QAAUirB,EAAO,KAI7G9iB,EAAQ,IAAIkM,EAAUoE,OACjB,CAEL,GAAoB,MAAhBqP,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,4BAGjCsB,EAAYtB,GACZO,EAASP,GACT3f,EAAQqjB,QAIVpC,EAAYtB,GACZO,EAASP,GACT3f,EAAQ,IAAIkM,EAAU,IAGxB,OAAO0W,EAAejD,EAAO3f,GAhGxBujB,CAAY5D,IARjBljB,EAAM0mB,EAA6BxD,GAEnC9U,EAAO,IAAIgF,EAAapT,GAExBoO,EAAO+X,EAAejD,EAAO9U,KAvD7BpO,EAAMymB,EAA6BvD,GAEnC9U,EAAO,IAAIgF,EAAapT,GAExBoO,EAAO+X,EAAejD,EAAO9U,IA5NxB2Y,CAAiB7D,GACxB9S,EAAY,CACV0R,IAAK,YACLT,IAAM,cAGDjR,EAAUpS,eAAeklB,EAAMS,QACpC7lB,EAAOolB,EAAMS,MACbje,EAAK0K,EAAUtS,GACf2lB,EAASP,GAET9U,EAAO,IAAIiL,EAAavb,EAAM4H,EADrB,CAAC0I,IAEVA,EAAO+X,EAAejD,EAAO9U,GAG/B,OAAOA,EArCA4Y,CAFS9D,EAVAA,IAcI,MAAhBA,EAAMS,OAAiC,OAAhBT,EAAMS,SAC/B7lB,EAAOolB,EAAMS,MACbje,EAAc,MAAT5H,EAAe,MAAQ,SAC5BwmB,EAAoBpB,GACpBrP,EAAS,CAACzF,EAAM2X,EAAW7C,IAE3B9U,EAAO,IAAIiL,EAAavb,EAAM4H,EAAImO,IAG7BzF,GA6IT,SAAS+X,EAAejD,EAAO9U,EAAMjE,GAGnC,IAFA,IAAI0J,IAEoB,MAAhBqP,EAAMS,OAAiC,MAAhBT,EAAMS,OAAiC,MAAhBT,EAAMS,OAAoBxZ,IAAyC,IAAhCA,EAAMzH,QAAQwgB,EAAMS,SAI3G,GAFA9P,EAAS,GAEW,MAAhBqP,EAAMS,MAAe,CACvB,IAAI/hB,EAAKqI,aAAamE,KAASxM,EAAKuH,eAAeiF,GA0BjD,OAAOA,EArBP,GAHAmW,EAAWrB,GACXO,EAASP,GAEW,MAAhBA,EAAMS,MAGR,IAFA9P,EAAOlR,KAAK+hB,EAAgBxB,IAEL,MAAhBA,EAAMS,OAEXF,EAASP,GACTrP,EAAOlR,KAAK+hB,EAAgBxB,IAIhC,GAAoB,MAAhBA,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,0BAGjCsB,EAAYtB,GACZO,EAASP,GACT9U,EAAO,IAAIoG,EAAapG,EAAMyF,QAO3B,GAAoB,MAAhBqP,EAAMS,MAAe,CAK9B,GAHAY,EAAWrB,GACXO,EAASP,GAEW,MAAhBA,EAAMS,MAGR,IAFA9P,EAAOlR,KAAK+hB,EAAgBxB,IAEL,MAAhBA,EAAMS,OAEXF,EAASP,GACTrP,EAAOlR,KAAK+hB,EAAgBxB,IAIhC,GAAoB,MAAhBA,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,0BAGjCsB,EAAYtB,GACZO,EAASP,GACT9U,EAAO,IAAIR,EAAaQ,EAAM,IAAIkI,EAAUzC,QACvC,CAIL,GAFA4P,EAASP,GAELA,EAAMQ,YAAcjD,EAAUG,OAChC,MAAMwD,GAAkBlB,EAAO,oCAGjCrP,EAAOlR,KAAK,IAAIyQ,EAAa8P,EAAMS,QACnCF,EAASP,GAET9U,EAAO,IAAIR,EAAaQ,EAAM,IAAIkI,EAAUzC,GAD1B,IAKtB,OAAOzF,EA6BT,SAASqY,EAA6BvD,GAGpC,IAFA,IAAIljB,EAAM,GAEyB,KAA5BojB,EAAiBF,IAA6C,MAA5BE,EAAiBF,IACxB,OAA5BE,EAAiBF,KAGnBljB,GAAOojB,EAAiBF,GACxBG,EAAKH,IAGPljB,GAAOojB,EAAiBF,GACxBG,EAAKH,GAKP,GAFAO,EAASP,GAEW,MAAhBA,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,4BAIjC,OADAO,EAASP,GACFrf,KAAK0I,MAAM,IAAMvM,EAAM,KA6BhC,SAAS0mB,EAA6BxD,GAGpC,IAFA,IAAIljB,EAAM,GAEyB,KAA5BojB,EAAiBF,IAA6C,MAA5BE,EAAiBF,IACxB,OAA5BE,EAAiBF,KAGnBljB,GAAOojB,EAAiBF,GACxBG,EAAKH,IAGPljB,GAAOojB,EAAiBF,GACxBG,EAAKH,GAKP,GAFAO,EAASP,GAEW,MAAhBA,EAAMS,MACR,MAAMS,GAAkBlB,EAAO,4BAIjC,OADAO,EAASP,GACFrf,KAAK0I,MAAM,IAAMvM,EAAM,KA6EhC,SAAS6mB,GAAS3D,GAIhB,IAHA,IAAIrP,EAAS,CAAC6Q,EAAgBxB,IAC1B3d,EAAM,EAEa,MAAhB2d,EAAMS,OAEXF,EAASP,GAETrP,EAAOtO,GAAOmf,EAAgBxB,GAC9B3d,IAGF,OAAO,IAAIkK,EAAUoE,GAyIvB,SAASoT,GAAI/D,GACX,OAAOA,EAAMhmB,MAAQgmB,EAAMS,MAAMvoB,OAAS,EAU5C,SAASgpB,GAAkBlB,EAAO1X,GAChC,IAAI5Q,EAAIqsB,GAAI/D,GACRtc,EAAQ,IAAI2E,YAAYC,EAAU,UAAY5Q,EAAI,KAEtD,OADAgM,EAAY,KAAIhM,EACTgM,EAUT,SAASge,GAAY1B,EAAO1X,GAC1B,IAAI5Q,EAAIqsB,GAAI/D,GACRtc,EAAQ,IAAI2E,YAAYC,EAAU,UAAY5Q,EAAI,KAEtD,OADAgM,EAAY,KAAIhM,EACTgM,EAGT,OArvCA2F,EAAM8X,QAAU,SAAiBzpB,EAAGssB,EAAOC,GACzC,OAAO5a,EAAM6a,oBAAoBxsB,IAAM2R,EAAM8a,kBAAkBzsB,EAAGusB,IAAU5a,EAAM8a,kBAAkBH,EAAOtsB,IAS7G2R,EAAM6a,oBAAsB,SAA6BxsB,GACvD,MAAO,sDAAsDwP,KAAKxP,IAmBpE2R,EAAM8a,kBAAoB,SAA2BC,EAAMC,GACzD,MAAO,aAAand,KAAKkd,IAAS,oBAAoBld,KAAKmd,IAAQ,2KAA2Knd,KAAKmd,IAUrPhb,EAAMqX,aAAe,SAAsBhpB,EAAGipB,GAE5C,MAAa,MAANjpB,GAAmB,OAANA,GAAoB,OAANA,GAA6B,EAAfipB,GAWlDtX,EAAM4X,cAAgB,SAAuBvpB,EAAGusB,GAC9C,MAAa,MAANvsB,GAAuB,MAAVusB,GAA2B,MAAVA,GAA2B,MAAVA,GASxD5a,EAAM0X,WAAa,SAAoBrpB,GACrC,MAAY,KAALA,GAAYA,GAAK,KAAa,MAANA,GASjC2R,EAAM2X,QAAU,SAAiBtpB,GAC/B,MAAY,KAALA,GAAYA,GAAK,KA0qCnB2R,IAMP,CAACib,0BAA0B,EAAEC,kBAAkB,GAAGC,8BAA8B,GAAGC,sBAAsB,GAAGC,mBAAmB,GAAGC,wBAAwB,GAAGC,mBAAmB,GAAGC,yBAAyB,GAAGC,sBAAsB,GAAGC,gCAAgC,GAAGC,sBAAsB,GAAGC,mBAAmB,GAAGC,oBAAoB,GAAGC,sBAAsB,GAAGC,yBAAyB,GAAGC,mBAAmB,GAAGC,wBAAwB,GAAGC,oBAAoB,KAAKC,GAAG,CAAC,SAAS7tB,EAAQf,EAAOD,GAC9e,aAEA,IAAIsS,EAAatR,EAAQ,0BAQzBhB,EAAQiI,UAAY,SAAU+I,GAC5B,OAAIA,GAAOA,EAAIuB,aACN,IAAID,EAAWtB,EAAI3N,MAAQ,EAAG2N,EAAIQ,IAAM,OAAenL,IAAZ2K,EAAIS,IAAoBT,EAAIS,IAAM,OAAIpL,GAGnF2K,IAEP,CAAC8d,yBAAyB,KAAKC,GAAG,CAAC,SAAS/tB,EAAQf,EAAOD,GAC7D,aAEA,IAAIsK,EAAQtJ,EAAQ,sBAAsBsJ,MAEtC0kB,EAAgBhuB,EAAQ,qBAAqBguB,cAE7Cpb,EAAkB5S,EAAQ,uBAAuB4S,gBAEjD0C,EAAkBtV,EAAQ,uBAAuBsV,gBAEjDvE,EAAiB/Q,EAAQ,8BA6K7B,SAASiuB,EAAmB1lB,EAAQlG,GAClC,GAA4B,IAAxBA,EAAMga,OAAO9b,OACf,MAAM,IAAIwQ,EAAe1O,EAAMga,OAAQ,GAGzC,IAAItY,EAAM1B,EAAM6rB,UAAU,GAE1B,GAAmB,iBAARnqB,EACT,MAAM,IAAI6I,UAAU,2DAGtB,OAAOgG,EAAgBrK,EAAQxE,GAYjC,SAASoqB,EAAmB5lB,EAAQlG,EAAO+rB,GACzC,GAA4B,IAAxB/rB,EAAMga,OAAO9b,OACf,MAAM,IAAIwQ,EAAe1O,EAAMga,OAAQ,GAGzC,IAAItY,EAAM1B,EAAM6rB,UAAU,GAE1B,GAAmB,iBAARnqB,EACT,MAAM,IAAI6I,UAAU,2DAItB,IAAIyhB,EAAU/kB,EAAMf,GAEpB,OADA+M,EAAgB+Y,EAAStqB,EAAKqqB,GACvBC,EAGTrvB,EAAQiE,KAAO,SACfjE,EAAQ2I,QApNR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAI/E,EAASsF,EAAK1H,EAAQ,sCAoCtByiB,EAAStb,EAAM,SAAU,CAE3BmnB,eAAgB,SAAoBhkB,EAAOjI,GACzC,IACIogB,EADIrgB,EAAOkI,GACAmY,OAAOpgB,GAEtB,OAAOA,EAAMksB,WAAa9L,EAASA,EAAO7X,WAE5C4jB,gBAAiB,SAAqBlkB,EAAOjI,GAC3C,OAAOiI,EAAMmY,OAAOpgB,IAEtBosB,gBAAiBR,EACjBS,gBA6BF,SAAuBvpB,EAAK9C,GAC1B,IAAK0E,EAAK2G,QAAQrL,GAEhB,MAAM,IAAIuK,UAAU,kBAGtB,GAA4B,IAAxBvK,EAAMga,OAAO9b,OACf,MAAM,IAAIwQ,EAAe1O,EAAMga,OAAO9b,OAAQ,GAIhD,IAAIouB,EAASxpB,EAAI5E,OACjBytB,EAAc3rB,EAAMmO,MAAM,GAAIme,GAC9BX,EAAc3rB,EAAMoO,MAAM,GAAIke,GAC9B,IAAI3S,EAAQ3Z,EAAM6rB,UAAU,GACxB5F,EAAS,GAIb,OAHAtM,EAAMhZ,QAAQ,SAAU4rB,GACtBtG,GAAUnjB,EAAIujB,OAAOkG,KAEhBtG,GA9CPuG,oBAAqB,SAAuBvkB,EAAOjI,EAAO+rB,GACxD,OAAOhsB,EAAOkH,EAAMgB,IAAQmY,OAAOpgB,EAAO+rB,OAAa/oB,GAAWuF,WAEpEkkB,yBAA0B,SAA0BxkB,EAAOjI,EAAO+rB,EAAaW,GAC7E,OAAO3sB,EAAOkH,EAAMgB,IAAQmY,OAAOpgB,EAAO+rB,EAAaW,GAAcnkB,WAEvEokB,qBAAsB,SAAwB1kB,EAAOjI,EAAO+rB,GAC1D,OAAO9jB,EAAMhB,QAAQmZ,OAAOpgB,EAAO+rB,IAErCa,0BAA2B,SAA2B3kB,EAAOjI,EAAO+rB,EAAaW,GAC/E,OAAOzkB,EAAMhB,QAAQmZ,OAAOpgB,EAAO+rB,EAAaW,IAElDG,wBAAyBC,EACzBC,gCAAiCD,EACjCE,qBAAsBlB,IAIxB,OAFA1L,EAAOrO,WAAQ/O,EAERod,EA0CP,SAAS0M,EAAchqB,EAAK9C,EAAO+rB,EAAaW,GAC9C,IAAK1sB,IAA2B,IAAlBA,EAAMqL,QAElB,MAAM,IAAId,UAAU,kBAGtB,GAA4B,IAAxBvK,EAAMga,OAAO9b,OACf,MAAM,IAAIwQ,EAAe1O,EAAMga,OAAO9b,OAAQ,GAGhD,QAAqB8E,IAAjB0pB,GACF,GAA4B,iBAAjBA,GAAqD,IAAxBA,EAAaxuB,OACnD,MAAM,IAAIqM,UAAU,kDAGtBmiB,EAAe,IAGjB,IAAI/S,EAAQ3Z,EAAM6rB,UAAU,GAG5B,GAFUlS,EAAMK,OAAO,KAEX+R,EAAY7tB,OACtB,MAAM,IAAIwQ,EAAeiL,EAAMK,OAAO,GAAI+R,EAAY7tB,QAIxD,IAAIouB,EAASxpB,EAAI5E,OACjBytB,EAAc3rB,EAAMmO,MAAM,IAC1Bwd,EAAc3rB,EAAMoO,MAAM,IAI1B,IAFA,IAAI6e,EAAQ,GAEHxvB,EAAI,EAAGA,EAAI6uB,EAAQ7uB,IAC1BwvB,EAAMxvB,GAAKqF,EAAIujB,OAAO5oB,GAOxB,GAJAkc,EAAMhZ,QAAQ,SAAU4rB,EAAG9uB,GACzBwvB,EAAMV,GAAKR,EAAY1F,OAAO5oB,EAAE,MAG9BwvB,EAAM/uB,OAASouB,EACjB,IAAK,IAAIY,EAAKZ,EAAS,EAAGa,EAAOF,EAAM/uB,OAAQgvB,EAAKC,EAAMD,IACnDD,EAAMC,KACTD,EAAMC,GAAMR,GAKlB,OAAOO,EAAMpmB,KAAK,OAsDpB,CAACumB,6BAA6B,EAAEC,oCAAoC,GAAGta,oBAAoB,GAAGZ,sBAAsB,GAAG7K,qBAAqB,KAAKgmB,GAAG,CAAC,SAAS3vB,EAAQf,EAAOD,GAC/K,aAEA,IAAI2S,EAAS3R,EAAQ,sBAgHrBhB,EAAQiE,KAAO,SACfjE,EAAQ2I,QA/GR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GAqGnC,IAAIgR,EAAShR,EAAM,SAAU,CAC3ByoB,IAAOje,EAAOwG,OACd0X,kCAAmCle,EAAOwG,SAI5C,OAFAA,EAAO/D,WAAQ/O,EAER8S,IAKP,CAACQ,qBAAqB,KAAKmX,GAAG,CAAC,SAAS9vB,EAAQf,EAAOD,GACzD,aAEA,SAAS+wB,EAASjmB,GAA4T,OAA1OimB,EAArD,mBAAXhmB,QAAoD,iBAApBA,OAAOC,SAAoC,SAAkBF,GAAO,cAAcA,GAA4B,SAAkBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAA0BA,GAgG9V9K,EAAQiE,KAAO,SACfjE,EAAQ2I,QA/FR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GA2DnC,IAAI0C,EAAU1C,EAAM,UAAW,CAC7ByoB,IAAO,SAAaziB,GAClB,IAAIvN,EAAImwB,EAAS5iB,GAEjB,MAAU,WAANvN,EAEQ,OAANuN,EAAmB,OACnBf,MAAMC,QAAQc,GAAW,QACzBA,aAAaa,KAAa,OAC1Bb,aAAae,OAAe,SAE5BnH,EAAK0F,YAAYU,GAAW,YAC5BpG,EAAKyF,UAAUW,GAAW,UAC1BpG,EAAK2F,WAAWS,GAAW,WAC3BpG,EAAK4F,SAASQ,GAAW,SACzBpG,EAAKwF,OAAOY,GAAW,OACvBpG,EAAK2G,QAAQP,GAAW,QACxBpG,EAAK0G,QAAQN,GAAW,QACxBpG,EAAK6G,YAAYT,GAAW,YAC5BpG,EAAKwH,OAAOpB,GAAWA,EAAEpG,KACzBA,EAAKsI,QAAQlC,GAAW,QACxBpG,EAAK8G,OAAOV,GAAW,OACpB,SAGC,aAANvN,EAAyB,WACtBA,KAMX,OAFAiK,EAAQuK,WAAQ/O,EAETwE,IAKP,IAAImmB,GAAG,CAAC,SAAShwB,EAAQf,EAAOD,GAClC,aAEA,IAAIyS,EAAUzR,EAAQ,qCA4DtBhB,EAAQiE,KAAO,YACfjE,EAAQ2I,QA3DR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GA0BnC,IAAI8oB,EAAY9oB,EAAM,YAAa,CACjC+oB,GAAI,WACF,OAAO,IAAInpB,EAAK6I,UAAU,IAE5BtI,OAAU,SAAgB6F,GAExB,OAAO,IAAIpG,EAAK6I,UAAUzC,EAAI,KAEhCwE,OAAU,SAAgBxE,GACxB,OAAO,IAAIpG,EAAK6I,UAAUzC,IAE5ByC,UAAa,SAAmBzC,GAE9B,OAAOA,GAETE,SAAY,SAAkBF,GAC5B,OAAO,IAAIpG,EAAK6I,UAAUzC,EAAExN,GAAGwwB,IAAIhjB,EAAEijB,GAAGC,MAAMljB,EAAE+H,IAElDtS,KAAQ,SAAeuK,GACrB,OAAO,IAAIpG,EAAK6I,UAAU,IAE5BkC,iBAAkB,SAAqB3E,GACrC,OAAOsE,EAAQtE,EAAG8iB,MAOtB,OAJAA,EAAU7b,MAAQ,CAChBkc,EAAG,IACH9vB,EAAG,6BAEEyvB,IAKP,CAACM,oCAAoC,KAAKC,GAAG,CAAC,SAASxwB,EAAQf,EAAOD,GACxE,aAEA,IAAIyS,EAAUzR,EAAQ,qCA6DtBhB,EAAQiE,KAAO,WACfjE,EAAQ2I,QA5DR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GA0BnC,IAAIspB,EAAWtpB,EAAM,WAAY,CAC/BG,OAAU,SAAgB6F,GACxB,IAAKujB,SAASvjB,IAAM4C,MAAM5C,GACxB,MAAM,IAAIhN,MAAMgN,EAAI,wCAGtB,OAAO,IAAIpG,EAAKsG,SAASF,IAE3BwE,OAAU,SAAgBxE,GACxB,OAAO,IAAIpG,EAAKsG,SAASF,IAE3BwjB,iBAAkB,SAAsBC,EAAWC,GACjD,OAAO,IAAI9pB,EAAKsG,SAASujB,EAAWC,IAEtCjuB,KAAQ,SAAeuK,GACrB,OAAO,IAAIpG,EAAKsG,SAAS,IAE3BuC,UAAa,SAAmBzC,GAC9B,OAAO,IAAIpG,EAAKsG,SAASF,EAAE8G,aAE7B5G,SAAY,SAAkBF,GAC5B,OAAOA,GAETrK,OAAU,SAAgBqK,GACxB,OAAO,IAAIpG,EAAKsG,SAASF,IAE3B2E,iBAAkB,SAAqB3E,GACrC,OAAOsE,EAAQtE,EAAGsjB,MAGtB,OAAOA,IAKP,CAACF,oCAAoC,KAAKO,GAAG,CAAC,SAAS9wB,EAAQf,EAAOD,GACxE,aAEA,IAAIsI,EAAStH,EAAQ,sBA4UrBhB,EAAQiE,KAAO,QACfjE,EAAQyM,KAAO,OACfzM,EAAQ2I,QA5UR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GAgCnC,SAASqU,EAAMK,EAAOnJ,EAAKoJ,GACzB,KAAMvc,gBAAgBic,GACpB,MAAM,IAAI9K,YAAY,oDAGxB,IAAIqgB,EAAWlV,MAAAA,EACXmV,EAASte,MAAAA,EACTue,EAAUnV,MAAAA,EAEd,GAAIiV,EACF,GAAIhqB,EAAK0F,YAAYoP,GACnBA,EAAQA,EAAMhM,gBACT,GAAqB,iBAAVgM,EAChB,MAAM,IAAIjP,UAAU,oCAIxB,GAAIokB,EACF,GAAIjqB,EAAK0F,YAAYiG,GACnBA,EAAMA,EAAI7C,gBACL,GAAmB,iBAAR6C,EAChB,MAAM,IAAI9F,UAAU,kCAIxB,GAAIqkB,EACF,GAAIlqB,EAAK0F,YAAYqP,GACnBA,EAAOA,EAAKjM,gBACP,GAAoB,iBAATiM,EAChB,MAAM,IAAIlP,UAAU,mCAIxBrN,KAAKsc,MAAQkV,EAAWG,WAAWrV,GAAS,EAC5Ctc,KAAKmT,IAAMse,EAASE,WAAWxe,GAAO,EACtCnT,KAAKuc,KAAOmV,EAAUC,WAAWpV,GAAQ,EAoQ3C,OA7PAN,EAAMtY,UAAU6D,KAAO,QACvByU,EAAMtY,UAAUuK,SAAU,EAW1B+N,EAAM9J,MAAQ,SAAUvM,GACtB,GAAmB,iBAARA,EACT,OAAO,KAGT,IACIgsB,EADOhsB,EAAIisB,MAAM,KACLxoB,IAAI,SAAU+B,GAC5B,OAAOumB,WAAWvmB,KAMpB,GAJcwmB,EAAKE,KAAK,SAAUllB,GAChC,OAAO4D,MAAM5D,KAIb,OAAO,KAGT,OAAQglB,EAAK5wB,QACX,KAAK,EACH,OAAO,IAAIib,EAAM2V,EAAK,GAAIA,EAAK,IAEjC,KAAK,EACH,OAAO,IAAI3V,EAAM2V,EAAK,GAAIA,EAAK,GAAIA,EAAK,IAE1C,QACE,OAAO,OASb3V,EAAMtY,UAAUoG,MAAQ,WACtB,OAAO,IAAIkS,EAAMjc,KAAKsc,MAAOtc,KAAKmT,IAAKnT,KAAKuc,OAU9CN,EAAMtY,UAAUmZ,KAAO,WACrB,IAAI3R,EAAM,EACNmR,EAAQtc,KAAKsc,MACbC,EAAOvc,KAAKuc,KAEZwV,EADM/xB,KAAKmT,IACEmJ,EAYjB,OAVIvU,EAAOiqB,KAAKzV,KAAUxU,EAAOiqB,KAAKD,GACpC5mB,EAAMnI,KAAKivB,KAAKF,EAAOxV,GACL,IAATwV,IACT5mB,EAAM,GAGJqF,MAAMrF,KACRA,EAAM,GAGD,CAACA,IASV8Q,EAAMtY,UAAUsN,IAAM,WACpB,IAAI6L,EAAO9c,KAAK8c,OAAO,GAEvB,OAAW,EAAPA,EACc,EAAZ9c,KAAKuc,KAEAvc,KAAKsc,MAGLtc,KAAKsc,OAASQ,EAAO,GAAK9c,KAAKuc,UAGxC,GAUJN,EAAMtY,UAAUuN,IAAM,WACpB,IAAI4L,EAAO9c,KAAK8c,OAAO,GAEvB,OAAW,EAAPA,EACc,EAAZ9c,KAAKuc,KAEAvc,KAAKsc,OAASQ,EAAO,GAAK9c,KAAKuc,KAG/Bvc,KAAKsc,WAGd,GAYJL,EAAMtY,UAAUF,QAAU,SAAU8Q,GAClC,IAAI3G,EAAI5N,KAAKsc,MACTC,EAAOvc,KAAKuc,KACZpJ,EAAMnT,KAAKmT,IACX5S,EAAI,EAER,GAAW,EAAPgc,EACF,KAAO3O,EAAIuF,GACToB,EAAS3G,EAAG,CAACrN,GAAIP,MACjB4N,GAAK2O,EACLhc,SAEG,GAAIgc,EAAO,EAChB,KAAWpJ,EAAJvF,GACL2G,EAAS3G,EAAG,CAACrN,GAAIP,MACjB4N,GAAK2O,EACLhc,KAeN0b,EAAMtY,UAAU0F,IAAM,SAAUkL,GAC9B,IAAIpL,EAAQ,GAIZ,OAHAnJ,KAAKyD,QAAQ,SAAUsH,EAAOjI,EAAOyH,GACnCpB,EAAMrG,EAAM,IAAMyR,EAASxJ,EAAOjI,EAAOyH,KAEpCpB,GAST8S,EAAMtY,UAAUuuB,QAAU,WACxB,IAAI/oB,EAAQ,GAIZ,OAHAnJ,KAAKyD,QAAQ,SAAUsH,EAAOjI,GAC5BqG,EAAMrG,EAAM,IAAMiI,IAEb5B,GAST8S,EAAMtY,UAAU0H,QAAU,WAExB,OAAOrL,KAAKkyB,WAcdjW,EAAMtY,UAAUiV,OAAS,SAAUxR,GACjC,IAAIxB,EAAMmC,EAAO6Q,OAAO5Y,KAAKsc,MAAOlV,GAOpC,OALkB,IAAdpH,KAAKuc,OACP3W,GAAO,IAAMmC,EAAO6Q,OAAO5Y,KAAKuc,KAAMnV,IAGxCxB,GAAO,IAAMmC,EAAO6Q,OAAO5Y,KAAKmT,IAAK/L,IAUvC6U,EAAMtY,UAAU+Q,SAAW,WACzB,OAAO1U,KAAK4Y,UAUdqD,EAAMtY,UAAUmR,OAAS,WACvB,MAAO,CACLC,OAAQ,QACRuH,MAAOtc,KAAKsc,MACZnJ,IAAKnT,KAAKmT,IACVoJ,KAAMvc,KAAKuc,OAYfN,EAAMjH,SAAW,SAAUvI,GACzB,OAAO,IAAIwP,EAAMxP,EAAK6P,MAAO7P,EAAK0G,IAAK1G,EAAK8P,OAGvCN,IAMP,CAACkW,qBAAqB,KAAKC,GAAG,CAAC,SAAS3xB,EAAQf,EAAOD,GACzD,aA6EAA,EAAQiE,KAAO,SACfjE,EAAQ2I,QA5ER,SAAiBZ,EAAMgB,EAAQL,EAAMP,GAiCnC,IAAI/E,EAAS+E,EAAM,SAAU,CAC3B+oB,GAAI,WACF,OAAO0B,EAAQ,KAEjBjgB,OAAU,SAAgBwG,GACxB,OAAOyZ,EAAQ,GAAIzZ,IAErB0Z,iBAAkB,SAAsB1Z,EAAQ2Z,GAC9C,OAAOF,EAAQ,GAAIzZ,EAAQ2Z,IAE7B1lB,MAAS,SAAe2lB,GACtB,OAAOH,EAAQG,IAEjBrM,OAAU,SAAgBqM,GACxB,OAAOH,EAAQG,EAAMA,EAAKC,YAE5BC,yBAA0BL,EAC1BM,iCAAkCN,IAOpC,OALAxvB,EAAOgS,MAAQ,CACbkc,EAAG,iCACH9vB,EAAG,4BACHiD,EAAG,6BAEErB,EAUP,SAASwvB,EAAQG,EAAM5Z,EAAQ2Z,GAI7B,OAAO,IAFC/qB,EAAK2e,OAAOsM,QAAQ7Z,GAAU,WAE/B,CAAM4Z,EAAMD,MAMrB,IAAIK,GAAG,CAAC,SAASnyB,EAAQf,EAAOD,GAClC,aAEA,IAAIyS,EAAUzR,EAAQ,iCAwEtBhB,EAAQiE,KAAO,SACfjE,EAAQ2I,QAvER,SAAiBZ,EAAMgB,EAAQL,EAAMP,GA0BnC,IAAIG,EAASH,EAAM,SAAU,CAC3B+oB,GAAI,WACF,OAAO,GAET5oB,OAAU,SAAgB6F,GACxB,OAAOA,GAETwE,OAAU,SAAgBxE,GACxB,GAAU,QAANA,EAAa,OAAOilB,IACxB,IAAIjmB,EAAM2D,OAAO3C,GAEjB,GAAI4C,MAAM5D,GACR,MAAM,IAAIuE,YAAY,WAAavD,EAAI,wBAGzC,OAAOhB,GAETyD,UAAa,SAAmBzC,GAC9B,OAAOA,EAAE0C,YAEXxC,SAAY,SAAkBF,GAC5B,OAAOA,EAAEvC,WAEXyX,KAAQ,SAAclV,GACpB,MAAM,IAAIhN,MAAM,iDAElByC,KAAQ,SAAeuK,GACrB,OAAO,GAETklB,sBAAuB,SAAwBC,EAAMC,GACnD,OAAOD,EAAKziB,SAAS0iB,IAEvBzgB,iBAAkB,SAAqB3E,GACrC,OAAOsE,EAAQtE,EAAG7F,MAQtB,OALAA,EAAO8M,MAAQ,CACbkc,EAAG,IACH9vB,EAAG,4BACHiD,EAAG,sDAEE6D,IAKP,CAACkrB,gCAAgC,KAAKC,GAAG,CAAC,SAASzyB,EAAQf,EAAOD,GACpE,aAsDAA,EAAQyM,KAAO,OACfzM,EAAQiE,KAAO,WACfjE,EAAQ2I,QAtDR,SAAiBZ,EAAMgB,EAAQL,EAAMP,GACnC,IAAIurB,EAAYhrB,EAAK1H,EAAQ,6BACzB2yB,EAAkB,CACpBhhB,QAAU,EACVrK,QAAU,EACVsI,WAAa,EACbvC,UAAY,GAGVulB,EAAmB,CACrBtrB,OAAUI,EAAK1H,EAAQ,aACvB4P,UAAalI,EAAK1H,EAAQ,mCAC1BqN,SAAY3F,EAAK1H,EAAQ,kCAYvBulB,EAAU,SAAiBjb,EAAOuoB,GACpC,IAAIC,EAAYJ,EAAUpoB,GAE1B,KAAMwoB,KAAaH,GACjB,MAAM,IAAI/lB,UAAU,kBAAoBtC,EAAQ,aAAewoB,EAAY,4BAA8BhwB,OAAOiD,KAAK4sB,GAAiBzpB,KAAK,OAG7I,KAAM2pB,KAAcD,GAClB,MAAM,IAAIhmB,UAAU,kBAAoBtC,EAAQ,aAAeuoB,EAAa,6BAA+B/vB,OAAOiD,KAAK6sB,GAAkB1pB,KAAK,OAGhJ,OAAI2pB,IAAeC,EACVxoB,EAEAsoB,EAAiBC,GAAYvoB,IASxC,OALAib,EAAQnR,MAAQ,SAAUb,EAAM5M,GAE9B,OAAO4M,EAAK9I,KAAK,GAAG2J,SAGfmR,IAQP,CAACwN,2BAA2B,GAAGC,iCAAiC,GAAGC,+BAA+B,GAAGC,WAAW,KAAKC,GAAG,CAAC,SAASnzB,EAAQf,EAAOD,GACnJ,aAwEAA,EAAQiE,KAAO,YACfjE,EAAQyM,KAAO,OACfzM,EAAQ2I,QAxER,SAAiBZ,EAAMgB,EAAQL,EAAMP,GAOnC,SAASqP,EAAU6H,GACjB,KAAM9e,gBAAgBiX,GACpB,MAAM,IAAI9F,YAAY,oDAGxBnR,KAAK8e,QAAUA,GAAW,GAuD5B,OAhDA7H,EAAUtT,UAAU6D,KAAO,YAC3ByP,EAAUtT,UAAU0K,aAAc,EAOlC4I,EAAUtT,UAAU0H,QAAU,WAC5B,OAAOrL,KAAK8e,SASd7H,EAAUtT,UAAU+Q,SAAW,WAC7B,MAAO,IAAM1U,KAAK8e,QAAQnV,KAAK,MAAQ,KAUzCsN,EAAUtT,UAAUmR,OAAS,WAC3B,MAAO,CACLC,OAAQ,YACR+J,QAAS9e,KAAK8e,UAYlB7H,EAAUjC,SAAW,SAAUvI,GAC7B,OAAO,IAAIwK,EAAUxK,EAAKqS,UAGrB7H,IAMP,IAAI4c,GAAG,CAAC,SAASpzB,EAAQf,EAAOD,GAClC,aAEA8D,OAAOkQ,eAAehU,EAAS,aAAc,CAC3CsL,OAAO,IAETtL,EAAQqd,KAAOA,EACfrd,EAAQq0B,SA4FR,SAAkB3qB,EAAO2T,GAGvB,GAF+B,IAAhBA,EAAK9b,QAIlB,GAAI6L,MAAMC,QAAQ3D,GAChB,MAAM,IAAI4qB,EAAgBC,QAAQ7qB,EAAMnI,OAAQ,QA7CtD,SAASizB,EAAU9qB,EAAO2T,EAAMoX,GAC9B,IAAI3zB,EACJ,IAAI4K,EAAMhC,EAAMnI,OAEhB,GAAImK,IAAQ2R,EAAKoX,GACf,MAAM,IAAIH,EAAgBC,QAAQ7oB,EAAK2R,EAAKoX,IAG9C,GAAIA,EAAMpX,EAAK9b,OAAS,EAAG,CAEzB,IAAImzB,EAAUD,EAAM,EAEpB,IAAK3zB,EAAI,EAAGA,EAAI4K,EAAK5K,IAAK,CACxB,IAAIsd,EAAQ1U,EAAM5I,GAElB,IAAKsM,MAAMC,QAAQ+Q,GACjB,MAAM,IAAIkW,EAAgBC,QAAQlX,EAAK9b,OAAS,EAAG8b,EAAK9b,OAAQ,KAGlEizB,EAAU9qB,EAAM5I,GAAIuc,EAAMqX,SAI5B,IAAK5zB,EAAI,EAAGA,EAAI4K,EAAK5K,IACnB,GAAIsM,MAAMC,QAAQ3D,EAAM5I,IACtB,MAAM,IAAIwzB,EAAgBC,QAAQlX,EAAK9b,OAAS,EAAG8b,EAAK9b,OAAQ,KAwBpEizB,CAAU9qB,EAAO2T,EAAM,IArG3Brd,EAAQgvB,cAgHR,SAAuB3rB,EAAO9B,GAC5B,IAAKozB,EAAQJ,QAAQrmB,SAAS7K,KAAWsxB,EAAQJ,QAAQK,UAAUvxB,GACjE,MAAM,IAAIuK,UAAU,oCAAsCvK,EAAQ,KAGpE,GAAIA,EAAQ,GAAuB,iBAAX9B,GAAgCA,GAAT8B,EAC7C,MAAM,IAAIwxB,EAAYN,QAAQlxB,EAAO9B,IArHzCvB,EAAQ80B,OAoIR,SAAgBprB,EAAO2T,EAAM0S,GAG3B,IAAK3iB,MAAMC,QAAQ3D,KAAW0D,MAAMC,QAAQgQ,GAC1C,MAAM,IAAIzP,UAAU,kBAGtB,GAAoB,IAAhByP,EAAK9b,OACP,MAAM,IAAIJ,MAAM,uCAIlBkc,EAAKrZ,QAAQ,SAAUsH,GACrB,IAAKqpB,EAAQJ,QAAQrmB,SAAS5C,KAAWqpB,EAAQJ,QAAQK,UAAUtpB,IAAUA,EAAQ,EACnF,MAAM,IAAIsC,UAAU,uDAA8DmnB,EAAQR,QAAQpb,OAAOkE,GAAQ,OAIrH,IAAI2X,OAAiC3uB,IAAjB0pB,EAA6BA,EAAe,EAIhE,OAaF,SAASkF,EAAQvrB,EAAO2T,EAAMoX,EAAK1E,GACjC,IAAIjvB,EACA6lB,EACAuO,EAASxrB,EAAMnI,OACf4zB,EAAS9X,EAAKoX,GACdW,EAAS7xB,KAAKiO,IAAI0jB,EAAQC,GAI9B,GAFAzrB,EAAMnI,OAAS4zB,EAEXV,EAAMpX,EAAK9b,OAAS,EAAG,CAEzB,IAAImzB,EAAUD,EAAM,EAEpB,IAAK3zB,EAAI,EAAGA,EAAIs0B,EAAQt0B,IAEtB6lB,EAAOjd,EAAM5I,GAERsM,MAAMC,QAAQsZ,KACjBA,EAAO,CAACA,GAERjd,EAAM5I,GAAK6lB,GAGbsO,EAAQtO,EAAMtJ,EAAMqX,EAAS3E,GAI/B,IAAKjvB,EAAIs0B,EAAQt0B,EAAIq0B,EAAQr0B,IAE3B6lB,EAAO,GACPjd,EAAM5I,GAAK6lB,EAEXsO,EAAQtO,EAAMtJ,EAAMqX,EAAS3E,OAE1B,CAGL,IAAKjvB,EAAI,EAAGA,EAAIs0B,EAAQt0B,IACtB,KAAOsM,MAAMC,QAAQ3D,EAAM5I,KACzB4I,EAAM5I,GAAK4I,EAAM5I,GAAG,GAKxB,IAAKA,EAAIs0B,EAAQt0B,EAAIq0B,EAAQr0B,IAC3B4I,EAAM5I,GAAKivB,GA5DfkF,CAAQvrB,EAAO2T,EAAM,EAAG2X,GAEjBtrB,GAzJT1J,EAAQq1B,QAmOR,SAAiB3rB,EAAO4rB,GACtB,IACIC,EADAC,EAAYC,EAAQ/rB,GAGxB,SAASgsB,EAAQC,GACf,OAAOA,EAAIC,OAAO,SAAUvrB,EAAMG,GAChC,OAAOH,EAAOG,IAIlB,IAAK4C,MAAMC,QAAQ3D,KAAW0D,MAAMC,QAAQioB,GAC1C,MAAM,IAAI1nB,UAAU,kBAGtB,GAAqB,IAAjB0nB,EAAM/zB,OACR,MAAM,IAAI+yB,EAAgBC,QAAQ,EAAGmB,EAAQrY,EAAK3T,IAAS,MAK7D,IAFA,IAAImsB,EAAY,EAEPC,EAAY,EAAGA,EAAYR,EAAM/zB,OAAQu0B,IAChDD,GAAaP,EAAMQ,GAGrB,GAAIN,EAAUj0B,SAAWs0B,EACvB,MAAM,IAAIvB,EAAgBC,QAAQmB,EAAQJ,GAAQI,EAAQrY,EAAK3T,IAAS,MAG1E,IACE6rB,EAoBJ,SAAkB7rB,EAAO4rB,GAKvB,IAHA,IACIS,EADAC,EAAWtsB,EAGNosB,EAAYR,EAAM/zB,OAAS,EAAe,EAAZu0B,EAAeA,IAAa,CACjE,IAAIzY,EAAOiY,EAAMQ,GACjBC,EAAY,GAIZ,IAFA,IAAIx0B,EAASy0B,EAASz0B,OAAS8b,EAEtBvc,EAAI,EAAGA,EAAIS,EAAQT,IAC1Bi1B,EAAUjtB,KAAKktB,EAAS9uB,MAAMpG,EAAIuc,GAAOvc,EAAI,GAAKuc,IAIpD2Y,EAAWD,EAGb,OAAOC,EAvCMC,CAAST,EAAWF,GAC/B,MAAO50B,GACP,GAAIA,aAAa4zB,EAAgBC,QAC/B,MAAM,IAAID,EAAgBC,QAAQmB,EAAQJ,GAAQI,EAAQrY,EAAK3T,IAAS,MAG1E,MAAMhJ,EAGR,OAAO60B,GAxQTv1B,EAAQk2B,QAgTR,SAAiBxsB,EAAOysB,GACtB,IAAIjgB,EAAIigB,GAAa9Y,EAAK3T,GAE1B,KAAO0D,MAAMC,QAAQ3D,IAA2B,IAAjBA,EAAMnI,QACnCmI,EAAQA,EAAM,GACdwM,EAAEkgB,QAIJ,IAAIC,EAAOngB,EAAE3U,OAEb,KAAuB,IAAhB2U,EAAEmgB,EAAO,IACdA,IAIEA,EAAOngB,EAAE3U,SACXmI,EAgBJ,SAAS4sB,EAAS5sB,EAAO2sB,EAAM5B,GAC7B,IAAI3zB,EAAGy1B,EAEP,GAAI9B,EAAM4B,EAAM,CACd,IAAI7M,EAAOiL,EAAM,EAEjB,IAAK3zB,EAAI,EAAGy1B,EAAK7sB,EAAMnI,OAAQT,EAAIy1B,EAAIz1B,IACrC4I,EAAM5I,GAAKw1B,EAAS5sB,EAAM5I,GAAIu1B,EAAM7M,QAGtC,KAAOpc,MAAMC,QAAQ3D,IACnBA,EAAQA,EAAM,GAIlB,OAAOA,EA/BG4sB,CAAS5sB,EAAO2sB,EAAM,GAC9BngB,EAAE3U,OAAS80B,GAGb,OAAO3sB,GApUT1J,EAAQw2B,UA+WR,SAAmB9sB,EAAO2sB,EAAMI,EAAON,GACrC,IAAIjgB,EAAIigB,GAAa9Y,EAAK3T,GAE1B,GAAI+sB,EACF,IAAK,IAAI31B,EAAI,EAAGA,EAAI21B,EAAO31B,IACzB4I,EAAQ,CAACA,GACTwM,EAAEwgB,QAAQ,GAKdhtB,EAkBF,SAASitB,EAAWjtB,EAAO2sB,EAAM5B,GAC/B,IAAI3zB,EAAGy1B,EAEP,GAAInpB,MAAMC,QAAQ3D,GAAQ,CACxB,IAAI8f,EAAOiL,EAAM,EAEjB,IAAK3zB,EAAI,EAAGy1B,EAAK7sB,EAAMnI,OAAQT,EAAIy1B,EAAIz1B,IACrC4I,EAAM5I,GAAK61B,EAAWjtB,EAAM5I,GAAIu1B,EAAM7M,QAGxC,IAAK,IAAI4H,EAAIqD,EAAKrD,EAAIiF,EAAMjF,IAC1B1nB,EAAQ,CAACA,GAIb,OAAOA,EAjCCitB,CAAWjtB,EAAO2sB,EAAM,GAEhC,KAAOngB,EAAE3U,OAAS80B,GAChBngB,EAAEpN,KAAK,GAGT,OAAOY,GA/XT1J,EAAQy1B,QAAUA,EAClBz1B,EAAQ4J,IA0bR,SAAaF,EAAOoL,GAClB,OAAO1H,MAAMlJ,UAAU0F,IAAItI,KAAKoI,EAAOoL,IA1bzC9U,EAAQgE,QAmcR,SAAiB0F,EAAOoL,GACtB1H,MAAMlJ,UAAUF,QAAQ1C,KAAKoI,EAAOoL,IAnctC9U,EAAQse,OA4cR,SAAgB5U,EAAOoL,GACrB,GAA2B,IAAvBuI,EAAK3T,GAAOnI,OAIhB,OAAO6L,MAAMlJ,UAAUoa,OAAOhd,KAAKoI,EAAOoL,GAHxC,MAAM,IAAI3T,MAAM,4CA7cpBnB,EAAQ42B,aA2dR,SAAsBltB,EAAOmtB,GAC3B,GAA2B,IAAvBxZ,EAAK3T,GAAOnI,OAIhB,OAAO6L,MAAMlJ,UAAUoa,OAAOhd,KAAKoI,EAAO,SAAU4D,GAClD,OAAOupB,EAAOtmB,KAAKjD,KAJnB,MAAM,IAAInM,MAAM,4CA5dpBnB,EAAQkK,KA0eR,SAAcR,EAAOotB,GACnB,OAAO1pB,MAAMlJ,UAAUgG,KAAK5I,KAAKoI,EAAOotB,IA1e1C92B,EAAQ+2B,SAmfR,SAAkB71B,GAChB,IAAKkM,MAAMC,QAAQnM,GACjB,MAAM,IAAI0M,UAAU,wBAGtB,GAAiB,IAAb1M,EAAEK,OACJ,OAAOL,EAGT,IAAIU,EAAI,GACJ2P,EAAQ,EACZ3P,EAAE,GAAK,CACL0J,MAAOpK,EAAE,GACT+kB,WAAY,GAGd,IAAK,IAAInlB,EAAI,EAAGA,EAAII,EAAEK,OAAQT,IACxBI,EAAEJ,KAAOI,EAAEJ,EAAI,GACjByQ,IAEAA,EAAQ,EAGV3P,EAAEkH,KAAK,CACLwC,MAAOpK,EAAEJ,GACTmlB,WAAY1U,IAIhB,OAAO3P,GA/gBT5B,EAAQg3B,WAwhBR,SAAoB91B,GAClB,IAAKkM,MAAMC,QAAQnM,GACjB,MAAM,IAAI0M,UAAU,wBAGtB,GAAiB,IAAb1M,EAAEK,OACJ,OAAOL,EAKT,IAFA,IAAIU,EAAI,GAECd,EAAI,EAAGA,EAAII,EAAEK,OAAQT,IAC5Bc,EAAEkH,KAAK5H,EAAEJ,GAAGwK,OAGd,OAAO1J,GAriBT,IAAI+yB,EAAUsC,EAAuBj2B,EAAQ,aAEzC+zB,EAAUkC,EAAuBj2B,EAAQ,aAEzCszB,EAAkB2C,EAAuBj2B,EAAQ,4BAEjD6zB,EAAcoC,EAAuBj2B,EAAQ,wBAEjD,SAASi2B,EAAuBnsB,GAAO,OAAOA,GAAOA,EAAIosB,WAAapsB,EAAM,CAAEypB,QAASzpB,GASvF,SAASuS,EAAKlP,GAGZ,IAFA,IAAI+H,EAAI,GAED9I,MAAMC,QAAQc,IACnB+H,EAAEpN,KAAKqF,EAAE5M,QACT4M,EAAIA,EAAE,GAGR,OAAO+H,EAkYT,SAASuf,EAAQ/rB,GACf,IAAK0D,MAAMC,QAAQ3D,GAEjB,OAAOA,EAGT,IAAIytB,EAAO,GAQX,OAPAztB,EAAM1F,QAAQ,SAAS8Q,EAASxJ,GAC1B8B,MAAMC,QAAQ/B,GAChBA,EAAMtH,QAAQ8Q,GAEdqiB,EAAKruB,KAAKwC,KAGP6rB,IA8HP,CAACC,0BAA0B,EAAEC,sBAAsB,GAAGnD,WAAW,GAAGoD,WAAW,KAAKC,GAAG,CAAC,SAASv2B,EAAQf,EAAOD,GAClH,aAEA,IAAIw3B,EAAcx2B,EAAQ,aAsE1BhB,EAAQmZ,OAAS,SAAU7N,EAAO3D,GAChC,GAAuB,mBAAZA,EAET,OAAOA,EAAQ2D,GAIjB,IAAKA,EAAMomB,WACT,OAAOpmB,EAAMyF,QAAU,MAAQzF,EAAMmsB,GAAG,GAAK,WAAa,YAI5D,IACIlvB,EADAmvB,EAAW,OAkBf,YAfgBrxB,IAAZsB,IAEEA,EAAQ+vB,WACVA,EAAW/vB,EAAQ+vB,UAIE,iBAAZ/vB,EACTY,EAAYZ,EACHA,EAAQY,YACjBA,EAAYZ,EAAQY,YAKhBmvB,GACN,IAAK,QACH,OAAO13B,EAAQ23B,QAAQrsB,EAAO/C,GAEhC,IAAK,cACH,OAAOvI,EAAQ43B,cAActsB,EAAO/C,GAEtC,IAAK,OAGH,GAAIZ,GAAWA,EAAQkwB,mBAA8CxxB,IAA9BsB,EAAQkwB,YAAYC,YAAqDzxB,IAA9BsB,EAAQkwB,YAAYE,OAAsB,CAC1H,IAAIC,EAAeR,EAAY5tB,IAAIjC,EAAS,SAAUwG,GACpD,OAAOA,IAaT,OAXA6pB,EAAaH,iBAAcxxB,KAEvBsB,EAAQkwB,YAAYC,QACtBE,EAAaC,SAAW10B,KAAK20B,MAAM30B,KAAK40B,IAAIxwB,EAAQkwB,YAAYC,OAASv0B,KAAK60B,YAG9C/xB,IAA9BsB,EAAQkwB,YAAYE,QACtBC,EAAaK,SAAW90B,KAAK20B,MAAM30B,KAAK40B,IAAIxwB,EAAQkwB,YAAYE,OAASx0B,KAAK60B,OAGhFtuB,QAAQC,KAAK,2OAAiQC,KAAKC,UAAUtC,GAAW,SAAWqC,KAAKC,UAAU+tB,IAC3Th4B,EAAQmZ,OAAO7N,EAAO0sB,GAK/B,IAAIC,EAAWtwB,QAAgCtB,IAArBsB,EAAQswB,SAAyBtwB,EAAQswB,UAAY,EAC3EI,EAAW1wB,QAAgCtB,IAArBsB,EAAQ0wB,SAAyB1wB,EAAQ0wB,SAAW,EAE9E,GAAI/sB,EAAMoN,SAAU,MAAO,IAG3B,IAAI4f,EAAMhtB,EAAMitB,YAWhB,OATID,EAAIE,IAAIP,IAAaK,EAAIG,GAAGJ,GAExB/sB,EAAMotB,oBAAoBnwB,GAAWovB,UAGrC33B,EAAQ43B,cAActsB,EAAO/C,IAI1BowB,QAAQ,sBAAuB,WACxC,IAAI3qB,EAASnJ,UAAU,GACnBnE,EAAImE,UAAU,GAClB,MAAkB,MAAXmJ,EAAiBA,EAAStN,EAAIA,IAGzC,QACE,MAAM,IAAIS,MAAM,qBAAuBu2B,EAAW,kDAaxD13B,EAAQ43B,cAAgB,SAAUtsB,EAAO/C,GACvC,YAAkBlC,IAAdkC,EACK+C,EAAMssB,cAAcrvB,EAAY,GAEhC+C,EAAMssB,iBAWjB53B,EAAQ23B,QAAU,SAAUrsB,EAAO/C,GACjC,OAAO+C,EAAMqsB,QAAQpvB,KAErB,CAACqwB,YAAY,KAAKC,GAAG,CAAC,SAAS73B,EAAQf,EAAOD,GAChD,aAOAC,EAAOD,QAAU,SAAqBmO,GACpC,OAAOA,GAAKA,EAAElD,YAAY/G,UAAUuJ,cAAe,IAEnD,IAAIqrB,GAAG,CAAC,SAAS93B,EAAQf,EAAOD,GAClC,aAcAC,EAAOD,QAAU,SAASyS,EAAQ/I,EAAOoL,EAAUikB,GACjD,OAAIrvB,GAA8B,mBAAdA,EAAME,IAEjBF,EAAME,IAAI,SAAUuE,GACzB,OAAOsE,EAAQtE,EAAG2G,EAAUikB,KAGvBjkB,EAASpL,KAGlB,IAAIsvB,GAAG,CAAC,SAASh4B,EAAQf,EAAOD,GAClC,aAQAC,EAAOD,QAAU,SAAkBmO,GACjC,OAAOA,GAAKA,EAAElD,YAAY/G,UAAUyJ,WAAY,IAEhD,IAAIsrB,GAAG,CAAC,SAASj4B,EAAQf,EAAOD,GAClC,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAI3G,EAAiBnD,EAAQ,YAAYmD,eAoDzC,SAAS2a,EAAevV,EAAQqL,GAC9B,SAAKrL,GAA8B,WAApBsB,EAAQtB,QAMnBpF,EAAe+0B,EAAsBtkB,MAMrCA,KAAQ9Q,OAAOI,cASf0Q,KAAQukB,SAASj1B,YAgCvB,SAASqb,EAAahW,EAAQ6vB,GAC5B,SAAK7vB,GAAoC,mBAAnBA,EAAO6vB,QAOzBj1B,EAAeoF,EAAQ6vB,IAAWt1B,OAAOu1B,gBAAkBD,KAAUt1B,OAAOu1B,eAAe9vB,QAM3FpF,EAAem1B,EAAmBF,MAMlCA,KAAUt1B,OAAOI,cASjBk1B,KAAUD,SAASj1B,aAUzB,SAASq1B,EAAchwB,GACrB,MAA2B,WAApBsB,EAAQtB,IAAwBA,GAAUA,EAAO0B,cAAgBnH,OAG1E,IAAIo1B,EAAuB,CACzB33B,QAAQ,EACR0C,MAAM,GAEJq1B,EAAoB,CACtBrkB,UAAU,EACVrJ,SAAS,EACT4tB,gBAAgB,GAElBx5B,EAAQ4T,gBAnJR,SAAyBrK,EAAQqL,GAE/B,GAAI2kB,EAAchwB,IAAWuV,EAAevV,EAAQqL,GAClD,OAAOrL,EAAOqL,GAGhB,GAA4B,mBAAjBrL,EAAOqL,IAAwB2K,EAAahW,EAAQqL,GAC7D,MAAM,IAAIzT,MAAM,yBAA2ByT,EAAO,mBAGpD,MAAM,IAAIzT,MAAM,0BAA4ByT,EAAO,MA0IrD5U,EAAQsW,gBA5HR,SAAyB/M,EAAQqL,EAAMtJ,GAErC,GAAIiuB,EAAchwB,IAAWuV,EAAevV,EAAQqL,GAElD,OADArL,EAAOqL,GAAQtJ,EAIjB,MAAM,IAAInK,MAAM,0BAA4ByT,EAAO,MAsHrD5U,EAAQ8e,eAAiBA,EACzB9e,EAAQya,mBArER,SAA4BlR,EAAQ6vB,GAClC,IAAK7Z,EAAahW,EAAQ6vB,GACxB,MAAM,IAAIj4B,MAAM,wBAA0Bi4B,EAAS,MAoEvDp5B,EAAQuf,aAAeA,EACvBvf,EAAQu5B,cAAgBA,GACtB,CAACE,WAAW,KAAKC,GAAG,CAAC,SAAS14B,EAAQf,EAAOD,GAC/C,aAEA,IAAI25B,EAAU34B,EAAQ,gBAQtBhB,EAAQ8H,MAAQ,SAAUgD,GAExB,IAAItD,EAAU,IAAImyB,EAMlB,OAJA7uB,EAAI8uB,GAAKpyB,EAAQoyB,GAAGxlB,KAAK5M,GACzBsD,EAAI+uB,IAAMryB,EAAQqyB,IAAIzlB,KAAK5M,GAC3BsD,EAAIgvB,KAAOtyB,EAAQsyB,KAAK1lB,KAAK5M,GAC7BsD,EAAIJ,KAAOlD,EAAQkD,KAAK0J,KAAK5M,GACtBsD,IAEP,CAACivB,eAAe,KAAKC,GAAG,CAAC,SAASh5B,EAAQf,EAAOD,GACnD,aAEA,IAAIoZ,EAAcpY,EAAQ,gBAE1BhB,EAAQi6B,QAAU,CAEhBC,MAAO,IACPC,MAAO,UACPC,KAAM,IACNC,KAAM,SACNC,MAAO,UACPC,MAAO,UACPC,MAAO,UACPC,MAAO,UACPC,QAAS,IACTryB,QAAS,YACTsyB,WAAY,eACZC,KAAM,IACNC,KAAM,SACNC,IAAK,IACLC,IAAK,QACLC,MAAO,UACPC,MAAO,UACPC,SAAU,aACVC,KAAM,IACNC,KAAM,SACNC,MAAO,IACPC,MAAO,UACPC,SAAU,aACVC,OAAQ,WACRC,OAAQ,WACRC,GAAI,IACJC,GAAI,OACJC,GAAI,IACJC,GAAI,OACJC,GAAI,OACJC,GAAI,OACJC,QAAS,IACTC,QAAS,IACTC,GAAI,OACJ54B,GAAI,OACJ64B,MAAO,UACPC,IAAK,IACLC,IAAK,QACLC,OAAQ,WACRC,MAAO,UACPC,MAAO,UACPC,SAAU,aACVC,IAAK,IACLC,IAAK,QACLC,QAAS,YACTC,QAAS,YACTC,IAAK,QACLC,IAAK,QACLC,OAAQ,WACRC,IAAK,IACLC,IAAK,QACLC,IAAK,QACLC,IAAK,QACLC,MAAO,UACPC,MAAO,UAEP55B,KAAQ,iBACRC,MAAS,kBAET7C,EAAG,IAEHy8B,IAAK,UACLC,IAAK,UACLC,SAAU,UACVC,SAAU,UACVC,GAAI,UACJC,IAAK,QACLv3B,UAAa,eAEfrG,EAAQuW,UAAY,CAClBsnB,UAAa,SACbC,WAAc,KACdC,UAAa,IACbC,IAAO,IACPC,OAAU,YAEVh8B,UAAa,IACbC,WAAc,IACdI,OAAU,MAEVO,IAAO,QACPf,SAAY,SACZC,OAAU,SAEVm8B,YAAe,UAEfC,UAAa,KAEbn8B,IAAO,QACPL,IAAO,IACPE,SAAY,IACZ6O,GAAM,eACNnO,UAAa,KACbC,gBAAmB,KACnBC,cAAiB,MACjBK,MAAS,IACTC,QAAW,QACXC,QAAW,IACXC,OAAU,IACVC,UAAa,QACbC,SAAY,QACZd,OAAU,MACVD,OAAU,iBACVD,MAAS,IACTS,IAAO,UACPD,IAAO,WACPD,GAAM,SAER1C,EAAQoc,gBAAkB,0CAC1B,IAAIgiB,EAAQ,CACVC,IAAK,WAGPr+B,EAAQqZ,OAAS,SAAU1G,GACzB,OAAOyG,EAAYzG,EAAQ,CACzBpM,oBAAsB,KAM1BvG,EAAQsa,SAAW,SAAUrW,EAAMsJ,GAGjC,OAFAA,OAA2B,IAAXA,GAAiCA,GAG3C6wB,EAAMj6B,eAAeF,GAChBm6B,EAAMn6B,GAGR,YAAcjE,EAAQqZ,OAAOpV,GAAQ,IAG1CjE,EAAQi6B,QAAQ91B,eAAeF,GAC1BjE,EAAQi6B,QAAQh2B,GAGlBjE,EAAQqZ,OAAOpV,KAEtB,CAACq6B,eAAe,IAAIC,GAAG,CAAC,SAASv9B,EAAQf,EAAOD,GAClD,aAEA,IAAIw3B,EAAcx2B,EAAQ,YAgc1B,SAASw9B,EAAMj9B,GAGb,IAFA,IAAIo0B,EAAM,GAED70B,EAAI,EAAGA,EAAIS,EAAQT,IAC1B60B,EAAI7sB,KAAK,GAGX,OAAO6sB,EA3bT31B,EAAQkO,SAAW,SAAU5C,GAC3B,MAAwB,iBAAVA,GAShBtL,EAAQ40B,UAAY,SAAUtpB,GAC5B,MAAqB,kBAAVA,KAIJomB,SAASpmB,IAASA,IAAU/H,KAAK20B,MAAM5sB,IAShDtL,EAAQuyB,KAAOhvB,KAAKgvB,MAAQ,SAAUpkB,GACpC,OAAQ,EAAJA,EACK,EACEA,EAAI,GACL,EAED,GA2EXnO,EAAQmZ,OAAS,SAAU7N,EAAO3D,GAChC,GAAuB,mBAAZA,EAET,OAAOA,EAAQ2D,GAIjB,GAAIA,IAAUoyB,EAAAA,EACZ,MAAO,WACF,GAAIpyB,KAAWoyB,EAAAA,EACpB,MAAO,YACF,GAAI3sB,MAAMzF,GACf,MAAO,MAIT,IACI/C,EADAmvB,EAAW,OAkBf,OAfI/vB,IAEEA,EAAQ+vB,WACVA,EAAW/vB,EAAQ+vB,UAIjB13B,EAAQkO,SAASvG,GACnBY,EAAYZ,EACHA,EAAQY,YACjBA,EAAYZ,EAAQY,YAKhBmvB,GACN,IAAK,QACH,OAAO13B,EAAQ23B,QAAQrsB,EAAO/C,GAEhC,IAAK,cACH,OAAOvI,EAAQ43B,cAActsB,EAAO/C,GAEtC,IAAK,cACH,OAAOvI,EAAQy+B,cAAcnzB,EAAO/C,GAEtC,IAAK,OAGH,IAAIZ,IAAWA,EAAQkwB,kBAA8CxxB,IAA9BsB,EAAQkwB,YAAYC,YAAqDzxB,IAA9BsB,EAAQkwB,YAAYE,MAkBtG,OAAO/3B,EAAQ0+B,YAAYpzB,EAAO/C,EAAWZ,GAAWA,GACvDgxB,QAAQ,sBAAuB,WAC9B,IAAI3qB,EAASnJ,UAAU,GACnBnE,EAAImE,UAAU,GAClB,MAAkB,MAAXmJ,EAAiBA,EAAStN,EAAIA,IArBrC,IAAIs3B,EAAeR,EAAY5tB,IAAIjC,EAAS,SAAUwG,GACpD,OAAOA,IAaT,OAXA6pB,EAAaH,iBAAcxxB,KAEvBsB,EAAQkwB,YAAYC,QACtBE,EAAaC,SAAW10B,KAAK20B,MAAM30B,KAAK40B,IAAIxwB,EAAQkwB,YAAYC,OAASv0B,KAAK60B,YAG9C/xB,IAA9BsB,EAAQkwB,YAAYE,QACtBC,EAAaK,SAAW90B,KAAK20B,MAAM30B,KAAK40B,IAAIxwB,EAAQkwB,YAAYE,OAASx0B,KAAK60B,OAGhFtuB,QAAQC,KAAK,2OAAiQC,KAAKC,UAAUtC,GAAW,SAAWqC,KAAKC,UAAU+tB,IAC3Th4B,EAAQ0+B,YAAYpzB,EAAO/C,EAAWyvB,GAUjD,QACE,MAAM,IAAI72B,MAAM,qBAAuBu2B,EAAW,kDAWxD13B,EAAQ2+B,YAAc,SAAUrzB,GAE9B,IAAIkQ,EAAQ7U,OAAO2E,GAAOzB,cAAc2R,MAAM,sCAE9C,IAAKA,EACH,MAAM,IAAI9J,YAAY,kBAAoBpG,GAG5C,IAAIinB,EAAO/W,EAAM,GACbxN,EAASwN,EAAM,GACfojB,EAAW1M,WAAW1W,EAAM,IAAM,KAClCqjB,EAAM7wB,EAAOnF,QAAQ,KACzB+1B,IAAqB,IAATC,EAAaA,EAAM,EAAI7wB,EAAOzM,OAAS,EACnD,IAAIu9B,EAAe9wB,EAAO2qB,QAAQ,IAAK,IACtCA,QAAQ,MAAO,SAAU6F,GAGxB,OADAI,GAAYJ,EAAMj9B,OACX,KACNo3B,QAAQ,MAAO,IACjBvG,MAAM,IAAIxoB,IAAI,SAAUwnB,GACvB,OAAO2N,SAAS3N,KAQlB,OAL4B,IAAxB0N,EAAav9B,SACfu9B,EAAah2B,KAAK,GAClB81B,KAGK,CACLrM,KAAMA,EACNuM,aAAcA,EACdF,SAAUA,IAUd5+B,EAAQy+B,cAAgB,SAAUnzB,EAAO/C,GACvC,GAAIwI,MAAMzF,KAAWomB,SAASpmB,GAC5B,OAAO3E,OAAO2E,GAGhB,IAAI0zB,EAAUh/B,EAAQi/B,YAAYj/B,EAAQ2+B,YAAYrzB,GAAQ/C,GAC1D7H,EAAIs+B,EAAQJ,SACZ79B,EAAIi+B,EAAQF,aAEZI,EAASx+B,EAAI,GAAM,EAAIA,EAAIA,EAAI,EAAIA,EAAI,EAAIA,EAAI,EAAIA,EAAIA,EAAI,EAE/D,GAAIV,EAAQkO,SAAS3F,GAEfA,EAAYxH,EAAEQ,SAAQR,EAAIA,EAAEqW,OAAOonB,EAAMj2B,EAAYxH,EAAEQ,cACtD,CAEL,IAAI49B,EAAwB,GAALz+B,EAASA,EAAI6C,KAAK67B,IAAIF,GAEzCn+B,EAAEQ,OAAS,EAAI49B,IAAkBp+B,EAAIA,EAAEqW,OAAOonB,EAAMW,GAAoBp+B,EAAEQ,OAAS,MAOzF,IAHA,IAAI89B,EAAU97B,KAAK67B,IAAI1+B,EAAIw+B,GACvBI,EAAa,EAEG,KAAXD,GACPC,IAKF,IAAIC,EAAWx+B,EAAEmG,MAAMo4B,GAAYp1B,KAAK,IACpCs1B,EAAax/B,EAAQkO,SAAS3F,IAAcg3B,EAASh+B,QAAUg+B,EAAS/jB,MAAM,SAAW,IAAM+jB,EAAW,GAC1Gp5B,EAAMpF,EAAEmG,MAAM,EAAGo4B,GAAYp1B,KAAK,IAAMs1B,EAAa,KAAY,GAAL9+B,EAAS,IAAM,IAAMw+B,EAAOjqB,WAC5F,OAAO+pB,EAAQzM,KAAOpsB,GAUxBnG,EAAQ23B,QAAU,SAAUrsB,EAAO/C,GACjC,GAAIwI,MAAMzF,KAAWomB,SAASpmB,GAC5B,OAAO3E,OAAO2E,GAGhB,IAAIm0B,EAAaz/B,EAAQ2+B,YAAYrzB,GACjC0zB,EAA+B,iBAAdz2B,EAAyBvI,EAAQi/B,YAAYQ,EAAYA,EAAWb,SAAW,EAAIr2B,GAAak3B,EACjH1+B,EAAIi+B,EAAQF,aACZz9B,EAAI29B,EAAQJ,SAAW,EAGvBc,EAAKr+B,GAAKkH,GAAa,GAiB3B,OAfIxH,EAAEQ,OAASm+B,IACb3+B,EAAIA,EAAEqW,OAAOonB,EAAMkB,EAAK3+B,EAAEQ,UAIxBF,EAAI,IACNN,EAAIy9B,EAAW,EAAJn9B,GAAO+V,OAAOrW,GACzBM,EAAI,GAIFA,EAAIN,EAAEQ,QACRR,EAAE4+B,OAAOt+B,EAAG,EAAS,IAANA,EAAU,KAAO,KAG3B29B,EAAQzM,KAAOxxB,EAAEmJ,KAAK,KAW/BlK,EAAQ43B,cAAgB,SAAUtsB,EAAO/C,GACvC,GAAIwI,MAAMzF,KAAWomB,SAASpmB,GAC5B,OAAO3E,OAAO2E,GAIhB,IAAI8mB,EAAQpyB,EAAQ2+B,YAAYrzB,GAC5B0zB,EAAUz2B,EAAYvI,EAAQi/B,YAAY7M,EAAO7pB,GAAa6pB,EAC9DrxB,EAAIi+B,EAAQF,aACZp+B,EAAIs+B,EAAQJ,SAEZ79B,EAAEQ,OAASgH,IACbxH,EAAIA,EAAEqW,OAAOonB,EAAMj2B,EAAYxH,EAAEQ,UAInC,IAAIq+B,EAAQ7+B,EAAEq1B,QACd,OAAO4I,EAAQzM,KAAOqN,GAAoB,EAAX7+B,EAAEQ,OAAa,IAAMR,EAAEmJ,KAAK,IAAM,IAAM,KAAY,GAALxJ,EAAS,IAAM,IAAMA,GAcrGV,EAAQ0+B,YAAc,SAAUpzB,EAAO/C,EAAWZ,GAChD,GAAIoJ,MAAMzF,KAAWomB,SAASpmB,GAC5B,OAAO3E,OAAO2E,GAIhB,IAAI2sB,EAAWtwB,QAAgCtB,IAArBsB,EAAQswB,SAAyBtwB,EAAQswB,UAAY,EAC3EI,EAAW1wB,QAAgCtB,IAArBsB,EAAQ0wB,SAAyB1wB,EAAQ0wB,SAAW,EAC1EjG,EAAQpyB,EAAQ2+B,YAAYrzB,GAEhC,GAAI8mB,EAAMwM,SAAW3G,GAAY7F,EAAMwM,UAAYvG,EAEjD,OAAOr4B,EAAQ43B,cAActsB,EAAO/C,GAEpC,IAAIy2B,EAAUz2B,EAAYvI,EAAQi/B,YAAY7M,EAAO7pB,GAAa6pB,EAC9DrxB,EAAIi+B,EAAQF,aACZp+B,EAAIs+B,EAAQJ,SAEZ79B,EAAEQ,OAASgH,IACbxH,EAAIA,EAAEqW,OAAOonB,EAAMj2B,EAAYxH,EAAEQ,UAKnCR,EAAIA,EAAEqW,OAAOonB,EAAM99B,EAAIK,EAAEQ,OAAS,GAAKR,EAAEQ,OAASgH,EAAYA,EAAYxH,EAAEQ,OAAS,KAGrF,IAAIs9B,EAAU,EAAJn+B,EAAQA,EAAI,EAMtB,OAJIm+B,GAHJ99B,EAAIy9B,GAAO99B,GAAG0W,OAAOrW,IAGTQ,OAAS,GACnBR,EAAE4+B,OAAOd,EAAM,EAAG,EAAG,KAGhBG,EAAQzM,KAAOxxB,EAAEmJ,KAAK,KAajClK,EAAQi/B,YAAc,SAAU7M,EAAO7pB,GASrC,IAPA,IAAIy2B,EAAU,CACZzM,KAAMH,EAAMG,KACZuM,aAAc1M,EAAM0M,aACpBF,SAAUxM,EAAMwM,UAEd79B,EAAIi+B,EAAQF,aAETv2B,GAAa,GAClBxH,EAAE21B,QAAQ,GACVsI,EAAQJ,WACRr2B,IAGF,GAAIxH,EAAEQ,OAASgH,GAGK,GAFJxH,EAAE4+B,OAAOp3B,EAAWxH,EAAEQ,OAASgH,GAEjC,GAAS,CACnB,IAAIzH,EAAIyH,EAAY,EAGpB,IAFAxH,EAAED,KAEc,KAATC,EAAED,IACPC,EAAEqrB,MAEQ,IAANtrB,IACFC,EAAE21B,QAAQ,GACVsI,EAAQJ,WACR99B,KAIFC,IADAD,KAMN,OAAOk+B,GA+BTh/B,EAAQgO,OAAS,SAAU1C,GACzB,OAAOA,EAAMssB,gBAAgBe,QAAQ,OAAQ,IAC5CA,QAAQ,aAAc,IACtBp3B,QAOHvB,EAAQ6/B,YAAc/uB,OAAOgvB,SAAW,qBAWxC9/B,EAAQ+/B,YAAc,SAAU5xB,EAAG6xB,EAAG33B,GAEpC,GAAIA,MAAAA,EACF,OAAO8F,IAAM6xB,EAGf,GAAI7xB,IAAM6xB,EACR,OAAO,EAIT,GAAIjvB,MAAM5C,IAAM4C,MAAMivB,GACpB,OAAO,EAIT,GAAItO,SAASvjB,IAAMujB,SAASsO,GAAI,CAE9B,IAAI1N,EAAO/uB,KAAK67B,IAAIjxB,EAAI6xB,GAExB,OAAI1N,EAAOtyB,EAAQ6/B,aAIVvN,GAAQ/uB,KAAKkO,IAAIlO,KAAK67B,IAAIjxB,GAAI5K,KAAK67B,IAAIY,IAAM33B,EAKxD,OAAO,IAEP,CAACoxB,WAAW,KAAKwG,GAAG,CAAC,SAASj/B,EAAQf,EAAOD,GAC/C,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAI2C,EAAczM,EAAQ,2BAc1BhB,EAAQsK,MAAQ,SAASA,EAAM6D,GAC7B,IAAIpG,EAAO8C,EAAQsD,GAGnB,GAAa,WAATpG,GAA8B,WAATA,GAA8B,YAATA,GAA1CA,MAAgEoG,EAClE,OAAOA,EAIT,GAAuB,mBAAZA,EAAE7D,MACX,OAAO6D,EAAE7D,QAIX,GAAI8C,MAAMC,QAAQc,GAChB,OAAOA,EAAEvE,IAAI,SAAU0B,GACrB,OAAOhB,EAAMgB,KAIjB,GAAI6C,aAAaa,KAAM,OAAO,IAAIA,KAAKb,EAAEvC,WACzC,GAAI6B,EAAYU,GAAI,OAAOA,EAE3B,GAAIA,aAAae,OAAQ,MAAM,IAAItB,UAAU,gBAAkBO,GAG/D,OAAOnO,EAAQ4J,IAAIuE,EAAG7D,IAUxBtK,EAAQ4J,IAAM,SAAUL,EAAQuL,GAC9B,IAAIxK,EAAQ,GAEZ,IAAK,IAAIvF,KAAOwE,EACVvJ,EAAQmE,eAAeoF,EAAQxE,KACjCuF,EAAMvF,GAAO+P,EAASvL,EAAOxE,KAIjC,OAAOuF,GAUTtK,EAAQkgC,OAAS,SAAUh/B,EAAGU,GAC5B,IAAK,IAAIgT,KAAQhT,EACX5B,EAAQmE,eAAevC,EAAGgT,KAC5B1T,EAAE0T,GAAQhT,EAAEgT,IAIhB,OAAO1T,GAUTlB,EAAQuK,WAAa,SAASA,EAAWrJ,EAAGU,GAE1C,GAAIwL,MAAMC,QAAQzL,GAChB,MAAM,IAAIgM,UAAU,0CAGtB,IAAK,IAAIgH,KAAQhT,EACf,GAAI5B,EAAQmE,eAAevC,EAAGgT,GAC5B,GAAIhT,EAAEgT,IAAShT,EAAEgT,GAAM3J,cAAgBnH,YACrBuC,IAAZnF,EAAE0T,KACJ1T,EAAE0T,GAAQ,IAGR1T,EAAE0T,GAAM3J,cAAgBnH,OAC1ByG,EAAWrJ,EAAE0T,GAAOhT,EAAEgT,IAEtB1T,EAAE0T,GAAQhT,EAAEgT,OAET,CAAA,GAAIxH,MAAMC,QAAQzL,EAAEgT,IACzB,MAAM,IAAIhH,UAAU,0CAEpB1M,EAAE0T,GAAQhT,EAAEgT,GAKlB,OAAO1T,GAUTlB,EAAQ+d,UAAY,SAAmB7c,EAAGU,GACxC,IAAIgT,EAAM9T,EAAG4K,EAEb,GAAI0B,MAAMC,QAAQnM,GAAI,CACpB,IAAKkM,MAAMC,QAAQzL,GACjB,OAAO,EAGT,GAAIV,EAAEK,SAAWK,EAAEL,OACjB,OAAO,EAGT,IAAKT,EAAI,EAAG4K,EAAMxK,EAAEK,OAAQT,EAAI4K,EAAK5K,IACnC,IAAKd,EAAQ+d,UAAU7c,EAAEJ,GAAIc,EAAEd,IAC7B,OAAO,EAIX,OAAO,EACF,GAAII,aAAa4C,OAAQ,CAC9B,GAAIsJ,MAAMC,QAAQzL,MAAQA,aAAakC,QACrC,OAAO,EAGT,IAAK8Q,KAAQ1T,EAEX,IAAKlB,EAAQ+d,UAAU7c,EAAE0T,GAAOhT,EAAEgT,IAChC,OAAO,EAIX,IAAKA,KAAQhT,EAEX,IAAK5B,EAAQ+d,UAAU7c,EAAE0T,GAAOhT,EAAEgT,IAChC,OAAO,EAIX,OAAO,EAEP,OAAO1T,IAAMU,GASjB5B,EAAQmgC,kBAAoB,WAE1B,IACE,GAAIr8B,OAAOkQ,eAIT,OAHAlQ,OAAOkQ,eAAe,GAAI,IAAK,CAC7BC,IAAK,gBAEA,EAET,MAAOvT,IAET,OAAO,GAcTV,EAAQkL,KAAO,SAAU3B,EAAQqL,EAAM/I,GACrC,GAAI7L,EAAQmgC,oBAAqB,CAC/B,IAEIC,EAFAC,GAAiB,EAIrBv8B,OAAOkQ,eAAezK,EAAQqL,EAAM,CAClCX,IAAK,WAMH,OALIosB,IACFD,EAASv0B,IACTw0B,GAAiB,GAGZD,GAET/rB,IAAK,SAAa/I,GAChB80B,EAAS90B,EACT+0B,GAAiB,GAEnBC,cAAc,EACdC,YAAY,SAIdh3B,EAAOqL,GAAQ/I,KAYnB7L,EAAQmL,SAAW,SAAU5B,EAAQkD,GACnC,IAAI3B,EAAMvB,EAEV,GAAIkD,EAGF,IAFA,IAAI+zB,EAAQ/zB,EAAK2lB,MAAM,KAEdtxB,EAAI,EAAGA,EAAI0/B,EAAMj/B,OAAQT,IAAK,CACrC,IAAImD,EAAOu8B,EAAM1/B,GAEXmD,KAAQ6G,IACZA,EAAI7G,GAAQ,IAGd6G,EAAMA,EAAI7G,GAId,OAAO6G,GAST9K,EAAQmE,eAAiB,SAAUoF,EAAQqS,GACzC,OAAOrS,GAAUzF,OAAOK,eAAe7C,KAAKiI,EAAQqS,IAgBtD5b,EAAQsH,UAAY,SAAUiC,GAC5B,OAAOA,GAAoC,mBAAnBA,EAAOZ,UAE/B,CAAC83B,0BAA0B,KAAKC,GAAG,CAAC,SAAS1/B,EAAQf,EAAOD,GAC9D,aAKA8Q,OAAO4gB,SAAW5gB,OAAO4gB,UAAY,SAAUpmB,GAC7C,MAAwB,iBAAVA,GAAsBomB,SAASpmB,IAK/CwF,OAAOC,MAAQD,OAAOC,OAAS,SAAUzF,GACvC,OAAOA,GAAUA,IAEjB,IAAIq1B,GAAG,CAAC,SAAS3/B,EAAQf,EAAOD,GAClC,aAEA,SAAS6K,EAAQC,GAAwT,OAAtOD,EAArD,mBAAXE,QAAoD,iBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAO7G,UAAY,gBAAkB4G,IAAyBA,GAExV,IAAI81B,EAAe5/B,EAAQ,YAAYmY,OAEnC0nB,EAAkB7/B,EAAQ,yBAAyBmY,OAEnD1L,EAAczM,EAAQ,2BAQ1BhB,EAAQsO,SAAW,SAAUhD,GAC3B,MAAwB,iBAAVA,GAShBtL,EAAQ8gC,SAAW,SAAUC,EAAMC,GACjC,IAAInkB,EAAQkkB,EAAKx/B,OAASy/B,EAAOz/B,OAC7BmS,EAAMqtB,EAAKx/B,OACf,OAAOw/B,EAAKvnB,UAAUqD,EAAOnJ,KAASstB,GAuCxChhC,EAAQmZ,OAAS,SAAU7N,EAAO3D,GAChC,GAAqB,iBAAV2D,EACT,OAAOs1B,EAAat1B,EAAO3D,GAG7B,GAAI8F,EAAYnC,GACd,OAAOu1B,EAAgBv1B,EAAO3D,GAKhC,IAkIyB2D,EAlIHA,IAmIa,WAAnBT,EAAQS,IAA0C,iBAAZA,EAAM4K,GAAqC,iBAAZ5K,EAAM3K,GAAqC,iBAAZ2K,EAAM8lB,EAlIxH,OAAKzpB,GAAgC,YAArBA,EAAQ8pB,SAKfnmB,EAAM2J,WAHN3J,EAAM4K,EAAI5K,EAAM3K,EAAI,IAAM2K,EAAM8lB,EA+H7C,IAA2B9lB,EAxHzB,GAAI8B,MAAMC,QAAQ/B,GAChB,OA6FJ,SAAS21B,EAAYv3B,EAAO/B,GAC1B,CAAA,GAAIyF,MAAMC,QAAQ3D,GAAQ,CAIxB,IAHA,IAAIvD,EAAM,IACNuF,EAAMhC,EAAMnI,OAEPT,EAAI,EAAGA,EAAI4K,EAAK5K,IACb,IAANA,IACFqF,GAAO,MAGTA,GAAO86B,EAAYv3B,EAAM5I,GAAI6G,GAI/B,OADAxB,GAAO,IAGP,OAAOnG,EAAQmZ,OAAOzP,EAAO/B,IA7GtBs5B,CAAY31B,EAAO3D,GAG5B,GAAI3H,EAAQsO,SAAShD,GACnB,MAAO,IAAMA,EAAQ,IAGvB,GAAqB,mBAAVA,EACT,OAAOA,EAAM8O,OAASzT,OAAO2E,EAAM8O,QAAU,WAG/C,GAAI9O,GAA4B,WAAnBT,EAAQS,GAAqB,CACxC,GAA4B,mBAAjBA,EAAM6N,OACf,OAAO7N,EAAM6N,OAAOxR,GACf,GAAI2D,GAASA,EAAM2J,aAAe,GAAGA,WAE1C,OAAO3J,EAAM2J,WAEb,IAAIoK,EAAU,GAEd,IAAK,IAAIta,KAAOuG,EACVA,EAAMnH,eAAeY,IACvBsa,EAAQvW,KAAK,IAAM/D,EAAM,MAAQ/E,EAAQmZ,OAAO7N,EAAMvG,GAAM4C,IAIhE,MAAO,IAAM0X,EAAQnV,KAAK,MAAQ,IAItC,OAAOvD,OAAO2E,IAUhBtL,EAAQiK,UAAY,SAAUqB,GAK5B,IAJA,IAAIy1B,EAAOp6B,OAAO2E,GACd41B,EAAU,GACVpgC,EAAI,EAEDA,EAAIigC,EAAKx/B,QAAQ,CACtB,IAAIR,EAAIggC,EAAKrX,OAAO5oB,GAEV,OAANC,GACFmgC,GAAWngC,EACXD,IAGU,MAFVC,EAAIggC,EAAKrX,OAAO5oB,MAE6B,IAA7B,aAAa+H,QAAQ9H,KACnCmgC,GAAW,MAGbA,GAAWngC,GAEXmgC,GADe,MAANngC,EACE,MAEAA,EAGbD,IAGF,MAAO,IAAMogC,EAAU,KASzBlhC,EAAQqZ,OAAS,SAAU/N,GACzB,IAAIy1B,EAAOp6B,OAAO2E,GAElB,OADAy1B,EAAOA,EAAKpI,QAAQ,KAAM,SAASA,QAAQ,KAAM,UAAUA,QAAQ,KAAM,SAASA,QAAQ,KAAM,QAAQA,QAAQ,KAAM,UA4CtH,CAACwI,wBAAwB,GAAGV,0BAA0B,GAAGvM,WAAW,KAAKkN,GAAG,CAAC,SAASpgC,EAAQf,EAAOD,GACvG,SAASyD,KAKTA,EAAES,UAAY,CACZ01B,GAAI,SAAU31B,EAAM6Q,EAAUusB,GAC5B,IAAI3gC,EAAIH,KAAKG,IAAMH,KAAKG,EAAI,IAO5B,OALCA,EAAEuD,KAAUvD,EAAEuD,GAAQ,KAAK6E,KAAK,CAC/B+C,GAAIiJ,EACJusB,IAAKA,IAGA9gC,MAGTu5B,KAAM,SAAU71B,EAAM6Q,EAAUusB,GAC9B,IAAI/gC,EAAOC,KACX,SAAS+gC,IACPhhC,EAAKu5B,IAAI51B,EAAMq9B,GACfxsB,EAAShJ,MAAMu1B,EAAKx8B,WAItB,OADAy8B,EAAS77B,EAAIqP,EACNvU,KAAKq5B,GAAG31B,EAAMq9B,EAAUD,IAGjC32B,KAAM,SAAUzG,GAMd,IALA,IAAI8uB,EAAO,GAAG7rB,MAAM5F,KAAKuD,UAAW,GAChC08B,IAAWhhC,KAAKG,IAAMH,KAAKG,EAAI,KAAKuD,IAAS,IAAIiD,QACjDpG,EAAI,EACJ4K,EAAM61B,EAAOhgC,OAETT,EAAI4K,EAAK5K,IACfygC,EAAOzgC,GAAG+K,GAAGC,MAAMy1B,EAAOzgC,GAAGugC,IAAKtO,GAGpC,OAAOxyB,MAGTs5B,IAAK,SAAU51B,EAAM6Q,GACnB,IAAIpU,EAAIH,KAAKG,IAAMH,KAAKG,EAAI,IACxB8gC,EAAO9gC,EAAEuD,GACTw9B,EAAa,GAEjB,GAAID,GAAQ1sB,EACV,IAAK,IAAIhU,EAAI,EAAG4K,EAAM81B,EAAKjgC,OAAQT,EAAI4K,EAAK5K,IACtC0gC,EAAK1gC,GAAG+K,KAAOiJ,GAAY0sB,EAAK1gC,GAAG+K,GAAGpG,IAAMqP,GAC9C2sB,EAAW34B,KAAK04B,EAAK1gC,IAY3B,OAJC2gC,EAAiB,OACd/gC,EAAEuD,GAAQw9B,SACH/gC,EAAEuD,GAEN1D,OAIXN,EAAOD,QAAUyD,GAEf,IAAIi+B,GAAG,CAAC,SAAS1gC,EAAQf,EAAOD,GAQlC,aAEC,IAAU4f,EAAMjX,EAANiX,EAaTrf,KAbeoI,EAaT,WAEN,SAASg5B,IACP,OAAO,EAGT,SAASC,KACP,OAAO,EAGT,SAASte,MA60CT,OAzyCA,SAAS7hB,IAEP,IAAIogC,EAAS,CACX,CAAE59B,KAAM,SAAasM,KAAM,SAAUpC,GAAK,MAAoB,iBAANA,IACxD,CAAElK,KAAM,SAAasM,KAAM,SAAUpC,GAAK,MAAoB,iBAANA,IACxD,CAAElK,KAAM,UAAasM,KAAM,SAAUpC,GAAK,MAAoB,kBAANA,IACxD,CAAElK,KAAM,WAAasM,KAAM,SAAUpC,GAAK,MAAoB,mBAANA,IACxD,CAAElK,KAAM,QAAasM,KAAMnD,MAAMC,SACjC,CAAEpJ,KAAM,OAAasM,KAAM,SAAUpC,GAAK,OAAOA,aAAaa,OAC9D,CAAE/K,KAAM,SAAasM,KAAM,SAAUpC,GAAK,OAAOA,aAAae,SAC9D,CAAEjL,KAAM,SAAasM,KAAM,SAAUpC,GACnC,MAAoB,iBAANA,GAAkBA,EAAElD,cAAgBnH,SAEpD,CAAEG,KAAM,OAAasM,KAAM,SAAUpC,GAAK,OAAa,OAANA,IACjD,CAAElK,KAAM,YAAasM,KAAM,SAAUpC,GAAK,YAAa9H,IAAN8H,KAG/C2zB,EAAU,CACZ79B,KAAM,MACNsM,KAAMoxB,GAIJI,EAAU,GAGVC,EAAe,GAGf75B,EAAQ,CACVmI,MAAOuxB,EACPrxB,YAAawxB,EACbC,OAAQF,GASV,SAASG,EAAgBC,GACvB,IAAI70B,EAAQ80B,GAAYj6B,EAAMmI,MAAO,SAAUhD,GAC7C,OAAOA,EAAMrJ,OAASk+B,IAGxB,GAAI70B,EACF,OAAOA,EAGT,GAAiB,QAAb60B,EACF,OAAOL,EAGT,IAAIO,EAAOD,GAAYj6B,EAAMmI,MAAO,SAAUhD,GAC5C,OAAOA,EAAMrJ,KAAK4F,gBAAkBs4B,EAASt4B,gBAG/C,MAAM,IAAI+D,UAAU,iBAAmBu0B,EAAW,KAC7CE,EAAQ,mBAAqBA,EAAKp+B,KAAO,KAAQ,KAQxD,SAASq+B,EAAcv6B,GACrB,OAAIA,IAAS+5B,EACJ,IAGF35B,EAAMmI,MAAMzH,QAAQd,GAS7B,SAASw6B,EAAaj3B,GACpB,IAAIgC,EAAQ80B,GAAYj6B,EAAMmI,MAAO,SAAUhD,GAC7C,OAAOA,EAAMiD,KAAKjF,KAGpB,GAAIgC,EACF,OAAOA,EAAMrJ,KAGf,MAAM,IAAI2J,UAAU,kCAAoCtC,GA+E1D,SAASk3B,EAAiBxoB,GACxB,OAAOA,EACFpQ,IAAI,SAAUmO,GACb,IAAI0qB,EAAY1qB,EAAMzH,MAAM1G,IAAI84B,GAEhC,OAAQ3qB,EAAM4qB,UAAY,MAAQ,IAAMF,EAAUv4B,KAAK,OAExDA,KAAK,KASZ,SAAS04B,EAAY7qB,EAAOvH,GAC1B,IA0dsCiyB,EAClCI,EA3dAF,EAAqC,IAAzB5qB,EAAMlP,QAAQ,OAO1B45B,GANUE,EAEQ,EAAf5qB,EAAMxW,OACHwW,EAAM7Q,MAAM,GACZ,MAHJ6Q,GAKgBqa,MAAM,KAAKxoB,IAAIk5B,IAChCxkB,OAAOykB,GACPzkB,OAAO0kB,GAERC,GA+ckCR,EA/cmBA,EAgdrDI,EAAU,GAhd8BryB,EAkdhCxM,QAAQ,SAAUk/B,IACgB,IAAxCT,EAAU55B,QAAQq6B,EAAWzyB,QACS,IAAtCgyB,EAAU55B,QAAQq6B,EAAWxyB,KAC5BmyB,EAAQK,EAAWzyB,QACtBoyB,EAAQK,EAAWzyB,MAAQyyB,KAIxBp/B,OAAOiD,KAAK87B,GAASj5B,IAAI,SAAU6G,GACxC,OAAOoyB,EAAQpyB,MAzdb0yB,EAAaV,EAAU74B,IAAI,SAAUu4B,GACvC,IAAIp6B,EAAOm6B,EAAeC,GAE1B,MAAO,CACLl+B,KAAMk+B,EACNiB,UAAWd,EAAcv6B,GACzBwI,KAAMxI,EAAKwI,KACX2yB,WAAY,KACZG,iBAAkB,KAIlBC,EAAmBL,EAAoBr5B,IAAI,SAAUs5B,GACvD,IAAIn7B,EAAOm6B,EAAegB,EAAWzyB,MAErC,MAAO,CACLxM,KAAMi/B,EAAWzyB,KACjB2yB,UAAWd,EAAcv6B,GACzBwI,KAAMxI,EAAKwI,KACX2yB,WAAYA,EACZG,gBAAiB7yB,EAAY3H,QAAQq6B,MAIzC,MAAO,CACL5yB,MAAO6yB,EAAW/rB,OAAOksB,GACzBX,UAAWA,GAgDf,SAASY,EAAavpB,GACpB,IAAIjC,EAAQgU,EAAK/R,GACjB,QAAOjC,GAAQA,EAAM4qB,UASvB,SAASa,EAAezrB,GACtB,OAAOA,EAAMzH,MAAM+hB,KAAK,SAAUtqB,GAChC,OAA0B,MAAnBA,EAAKm7B,aAUhB,SAASO,EAAY1rB,GACnB,GAAKA,GAAgC,IAAvBA,EAAMzH,MAAM/O,OAIrB,CAAA,GAA2B,IAAvBwW,EAAMzH,MAAM/O,OACnB,OAAO2gC,EAAenqB,EAAMzH,MAAM,GAAGrM,MAAMsM,KAExC,GAA2B,IAAvBwH,EAAMzH,MAAM/O,OAAc,CACjC,IAAImiC,EAAQxB,EAAenqB,EAAMzH,MAAM,GAAGrM,MAAMsM,KAC5CozB,EAAQzB,EAAenqB,EAAMzH,MAAM,GAAGrM,MAAMsM,KAChD,OAAO,SAAYpC,GACjB,OAAOu1B,EAAMv1B,IAAMw1B,EAAMx1B,IAI3B,IAAIy1B,EAAQ7rB,EAAMzH,MAAM1G,IAAI,SAAU7B,GACpC,OAAOm6B,EAAen6B,EAAK9D,MAAMsM,OAEnC,OAAO,SAAYpC,GACjB,IAAK,IAAIrN,EAAI,EAAGA,EAAI8iC,EAAMriC,OAAQT,IAChC,GAAI8iC,EAAM9iC,GAAGqN,GACX,OAAO,EAGX,OAAO,GAtBT,OAAOwzB,EAgCX,SAASkC,EAAa7pB,GACpB,IAAI4pB,EAAOF,EAAOC,EAwvBHhO,EAtvBf,GAAI4N,EAAavpB,GAAS,CAGxB,IAAI8pB,GADJF,GAovBajO,EApvBG3b,EAqvBX2b,EAAIzuB,MAAM,EAAGyuB,EAAIp0B,OAAS,IArvBPqI,IAAI65B,IACPliC,OACjBwiC,EAAWN,EAAY1X,EAAK/R,IAUhC,OAAO,SAAkBvO,GACvB,IAAK,IAAI3K,EAAI,EAAGA,EAAI8iC,EAAMriC,OAAQT,IAChC,IAAK8iC,EAAM9iC,GAAG2K,EAAK3K,IACjB,OAAO,EAGX,OAfkB,SAAU2K,GAC5B,IAAK,IAAI3K,EAAIgjC,EAAUhjC,EAAI2K,EAAKlK,OAAQT,IACtC,IAAKijC,EAASt4B,EAAK3K,IACjB,OAAO,EAGX,OAAO,EASAkjC,CAAcv4B,IAAUA,EAAKlK,QAAUuiC,EAAW,GAK3D,OAAsB,IAAlB9pB,EAAOzY,OACF,SAAkBkK,GACvB,OAAuB,IAAhBA,EAAKlK,QAGW,IAAlByY,EAAOzY,QACdmiC,EAAQD,EAAYzpB,EAAO,IACpB,SAAkBvO,GACvB,OAAOi4B,EAAMj4B,EAAK,KAAuB,IAAhBA,EAAKlK,SAGP,IAAlByY,EAAOzY,QACdmiC,EAAQD,EAAYzpB,EAAO,IAC3B2pB,EAAQF,EAAYzpB,EAAO,IACpB,SAAkBvO,GACvB,OAAOi4B,EAAMj4B,EAAK,KAAOk4B,EAAMl4B,EAAK,KAAuB,IAAhBA,EAAKlK,UAIlDqiC,EAAQ5pB,EAAOpQ,IAAI65B,GACZ,SAAkBh4B,GACvB,IAAK,IAAI3K,EAAI,EAAGA,EAAI8iC,EAAMriC,OAAQT,IAChC,IAAK8iC,EAAM9iC,GAAG2K,EAAK3K,IACjB,OAAO,EAGX,OAAO2K,EAAKlK,SAAWqiC,EAAMriC,SAcrC,SAAS0iC,EAAgB9pB,EAAW9W,GAClC,OAAOA,EAAQ8W,EAAUH,OAAOzY,OAC1B4Y,EAAUH,OAAO3W,GACjBkgC,EAAappB,EAAUH,QACnB+R,EAAK5R,EAAUH,QACf,KAUZ,SAASkqB,EAAsB/pB,EAAW9W,EAAO8gC,GAC/C,IAAIpsB,EAAQksB,EAAgB9pB,EAAW9W,GAOvC,OANY0U,EACNosB,EACQpsB,EAAMzH,MAAMgO,OAAO8lB,GACnBrsB,EAAMzH,MACd,IAEO1G,IAAI84B,GAQnB,SAASA,EAAY36B,GACnB,OAAOA,EAAK9D,KAQd,SAASmgC,EAAYr8B,GACnB,OAA2B,OAApBA,EAAKm7B,iBAA2C78B,IAApB0B,EAAKm7B,WAU1C,SAASmB,EAAoBp4B,EAAY5I,GACvC,IAAIo/B,EAwsBN,SAAc9M,GAEZ,IADA,IAAItW,EAAU,GACLve,EAAI,EAAGA,EAAI60B,EAAIp0B,OAAQT,IAC9Bue,EAAQsW,EAAI70B,KAAM,EAEpB,OAAOgD,OAAOiD,KAAKsY,GA7sBHilB,CAAKC,GAAQt4B,EAAY,SAAUkO,GACjD,OAAO+pB,EAAqB/pB,EAAW9W,GAAO,MAGhD,OAAsC,IAA9Bo/B,EAAU55B,QAAQ,OAAiB,CAAC,OAAS45B,EA+FvD,SAAS+B,EAAoBzsB,GAG3B,IAFA,IAAIvG,EAAM,IAED1Q,EAAI,EAAGA,EAAIiX,EAAMzH,MAAM/O,OAAQT,IAClCsjC,EAAYrsB,EAAMzH,MAAMxP,MAC1B0Q,EAAMjO,KAAKiO,IAAIA,EAAKuG,EAAMzH,MAAMxP,GAAGsiC,YAIvC,OAAO5xB,EAST,SAASizB,EAA0B1sB,GAGjC,IAFA,IAAIvG,EAAM,IAED1Q,EAAI,EAAGA,EAAIiX,EAAMzH,MAAM/O,OAAQT,IACjCsjC,EAAYrsB,EAAMzH,MAAMxP,MAC3B0Q,EAAMjO,KAAKiO,IAAIA,EAAKuG,EAAMzH,MAAMxP,GAAGuiC,kBAIvC,OAAO7xB,EA4CT,SAASkzB,EAAmBC,EAAYC,GACtC,IACI9jC,EACAC,EApCkB8jC,EAAQC,EAC1B/jC,EAiCA2K,EAAMnI,KAAKiO,IAAImzB,EAAW3qB,OAAOzY,OAAQqjC,EAAW5qB,OAAOzY,QAM/D,GAAU,IADVR,EAAI4jC,EAAW3qB,OAAOqY,KAAKmR,GAAkBoB,EAAW5qB,OAAOqY,KAAKmR,IAElE,OAAOziC,EAIT,IAAKD,EAAI,EAAGA,EAAI4K,EAAK5K,IAEnB,GAAU,IADVC,EAAIyiC,EAAemB,EAAW3qB,OAAOlZ,IAAM0iC,EAAeoB,EAAW5qB,OAAOlZ,KAE1E,OAAOC,EAKX,IAAKD,EAAI,EAAGA,EAAI4K,EAAK5K,IAEnB,GAvDoB+jC,EAsDFF,EAAW3qB,OAAOlZ,GAtDRgkC,EAsDYF,EAAW5qB,OAAOlZ,GArDxDC,OAAAA,EAsDQ,KADVA,EAjDQ,IADVA,EAAI8jC,EAAOlC,UAAYmC,EAAOnC,WAErB5hC,EAKC,IADVA,EAAIyiC,EAAeqB,GAAUrB,EAAesB,IAEnC/jC,EAKC,IADVA,EAAIyjC,EAAmBK,GAAUL,EAAmBM,IAE3C/jC,EAIF0jC,EAAyBI,GAAUJ,EAAyBK,IAkC/D,OAAO/jC,EAKX,OAAO4jC,EAAW3qB,OAAOzY,OAASqjC,EAAW5qB,OAAOzY,OA6EtD,SAASwjC,GAAqBhtB,GAC5B,IAAI2rB,EAAOC,EAAOqB,EAAaC,EAC3BrB,EAAQ,GACRpzB,EAAc,GAUlB,OARAuH,EAAMzH,MAAMtM,QAAQ,SAAU+D,GACxBA,EAAKm7B,aACPU,EAAM96B,KAAKo5B,EAAen6B,EAAKm7B,WAAWzyB,MAAMF,MAChDC,EAAY1H,KAAKf,EAAKm7B,WAAWvyB,YAK7BH,EAAYjP,QAClB,KAAK,EACH,OAAO,SAAoBoK,GACzB,OAAOA,GAGX,KAAK,EAGH,OAFA+3B,EAAQE,EAAM,GACdoB,EAAcx0B,EAAY,GACnB,SAAoB7E,GACzB,OAAI+3B,EAAM/3B,GACDq5B,EAAYr5B,GAEdA,GAGX,KAAK,EAKH,OAJA+3B,EAAQE,EAAM,GACdD,EAAQC,EAAM,GACdoB,EAAcx0B,EAAY,GAC1By0B,EAAcz0B,EAAY,GACnB,SAAoB7E,GACzB,OAAI+3B,EAAM/3B,GACDq5B,EAAYr5B,GAEjBg4B,EAAMh4B,GACDs5B,EAAYt5B,GAEdA,GAGX,QACE,OAAO,SAAoBA,GACzB,IAAK,IAAI7K,EAAI,EAAGA,EAAI0P,EAAYjP,OAAQT,IACtC,GAAI8iC,EAAM9iC,GAAG6K,GACX,OAAO6E,EAAY1P,GAAG6K,GAG1B,OAAOA,IA+Cf,SAASu5B,GAAYlrB,EAAQmrB,GA4C3B,OA3CA,SAASC,EAAaprB,EAAQ3W,EAAOiN,GACnC,GAAIjN,EAAQ2W,EAAOzY,OAAQ,CACzB,IAII8jC,EAJAttB,EAAQiC,EAAO3W,GACfiiC,EAAgBH,EACdptB,EAAMzH,MAAMgO,OAAO8lB,GACnBrsB,EAAMzH,MAGZ,GAAIyH,EAAM4qB,UAAW,CAGnB,IAAIQ,EAAamC,EAAchnB,OAAO8lB,GACtCiB,EAAalC,EAAW5hC,OAAS+jC,EAAc/jC,OACzC,CAAC4hC,EAAYmC,GACb,CAACA,QAKPD,EAAaC,EAAc17B,IAAI,SAAU7B,GACvC,MAAO,CAACA,KAKZ,OAAOw8B,GAAQc,EAAY,SAAUE,GACnC,OAAOH,EAAaprB,EAAQ3W,EAAQ,EAAGiN,EAAM8G,OAAO,CAACmuB,OAavD,MAAO,CAPcj1B,EAAM1G,IAAI,SAAU7B,EAAMq7B,GAC7C,MAAO,CACL9yB,MAAOvI,EACP46B,UAAYS,IAAcppB,EAAOzY,OAAS,GAAMgiC,EAAavpB,OAQ9DorB,CAAaprB,EAAQ,EAAG,IAyCjC,SAASwrB,EAAoBvhC,EAAMwhC,GACjC,GAA0C,IAAtC3hC,OAAOiD,KAAK0+B,GAAelkC,OAC7B,MAAM,IAAImQ,YAAY,0BAIxB,IAAIg0B,EAAmB,GACvB5hC,OAAOiD,KAAK0+B,GACP77B,IAAI,SAAUuQ,GACb,OAzqB4BtO,EAyqBK45B,EAzqBhBtrB,EAyqBKA,GAzqBU3J,EAyqB2BrI,EAAMqI,YAxqBnEwJ,EAAS,GAEY,KAArBG,EAAU2oB,SACZ9oB,EAASG,EACJiY,MAAM,KACNxoB,IAAIk5B,IACJl5B,IAAI,SAAUmO,EAAO1U,EAAOqG,GAC3B,IAAIi8B,EAAc/C,EAAW7qB,EAAOvH,GAEpC,GAAIm1B,EAAYhD,WAAct/B,IAAUqG,EAAMnI,OAAS,EACrD,MAAM,IAAImQ,YAAY,8BAAgCqG,EAAQ,0CAIhE,OAAO4tB,KAIX3rB,EAAOqY,KAAKuT,IAGP,KAGF,CACL5rB,OAAQA,EACRnO,GAAIA,GA3BR,IAAyBsO,EAAWtO,EAAI2E,EAClCwJ,IA0qBCsE,OAAOunB,IACP7hC,QAAQ,SAAU8hC,GAEjB,IAAIC,EAAuB3D,GAAYsD,EAAkB,SAAUxvB,GACjE,OA/CV,SAA8ByuB,EAAYC,GAGxC,IAFA,IAAIrO,EAAKhzB,KAAKkO,IAAIkzB,EAAW3qB,OAAOzY,OAAQqjC,EAAW5qB,OAAOzY,QAErDT,EAAI,EAAGA,EAAIy1B,EAAIz1B,IAItB,IAAKklC,GAHa9B,EAAqBS,EAAY7jC,GAAG,GACpCojC,EAAqBU,EAAY9jC,GAAG,IAGpD,OAAO,EAIX,IAAImlC,EAAOtB,EAAW3qB,OAAOzY,OACzB2kC,EAAOtB,EAAW5qB,OAAOzY,OACzB4kC,EAAa5C,EAAaoB,EAAW3qB,QACrCosB,EAAa7C,EAAaqB,EAAW5qB,QAEzC,OAAOmsB,EACDC,EAAcH,IAASC,EAAiBD,GAARC,EAChCE,EAAsBF,GAARD,EAAkBA,IAASC,EA4BhCG,CAAqBnwB,EAAG4vB,KAEjC,GAAIC,EACF,MAAM,IAAIn4B,UAAU,2BAChB40B,EAAgBuD,EAAqB/rB,QAAU,UAC/CwoB,EAAgBsD,EAAgB9rB,QAAU,MAGhD0rB,EAAiB58B,KAAKg9B,KAI5B,IAAI75B,EAAas4B,GAAQmB,EAAkB,SAAUI,GAGnD,OAFaA,EAAkBZ,GAAYY,EAAgB9rB,QAAQ,GAAS,IAE9DpQ,IAAI,SAAUoQ,GAC1B,MAAO,CACLA,OAAQA,EACRnO,GAAIi6B,EAAgBj6B,QAGvByS,OAAOunB,IAEV55B,EAAWq6B,KAAK5B,GAGhB,IA5JIe,EA4JAc,EAAMt6B,EAAW,IAAMA,EAAW,GAAG+N,OAAOzY,QAAU,IAAMgiC,EAAat3B,EAAW,GAAG+N,QACvFwsB,EAAMv6B,EAAW,IAAMA,EAAW,GAAG+N,OAAOzY,QAAU,IAAMgiC,EAAat3B,EAAW,GAAG+N,QACvFysB,EAAMx6B,EAAW,IAAMA,EAAW,GAAG+N,OAAOzY,QAAU,IAAMgiC,EAAat3B,EAAW,GAAG+N,QACvF0sB,EAAMz6B,EAAW,IAAMA,EAAW,GAAG+N,OAAOzY,QAAU,IAAMgiC,EAAat3B,EAAW,GAAG+N,QACvF2sB,EAAM16B,EAAW,IAAMA,EAAW,GAAG+N,OAAOzY,QAAU,IAAMgiC,EAAat3B,EAAW,GAAG+N,QACvF4sB,EAAM36B,EAAW,IAAMA,EAAW,GAAG+N,OAAOzY,QAAU,IAAMgiC,EAAat3B,EAAW,GAAG+N,QACvF6sB,EAAQN,GAAOC,GAAOC,GAAOC,GAAOC,GAAOC,EAG3ChD,EAAQ33B,EAAWrC,IAAI,SAAUuQ,GACnC,OAAO0pB,EAAa1pB,EAAUH,UAG5B8sB,EAASP,EAAM9C,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtDmF,EAASP,EAAM/C,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtDoF,EAASP,EAAMhD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtDqF,EAASP,EAAMjD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtDsF,EAASP,EAAMlD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtDuF,EAASP,EAAMnD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GAEtDwF,EAASb,EAAM9C,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtDyF,EAASb,EAAM/C,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtD0F,EAASb,EAAMhD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtD2F,EAASb,EAAMjD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtD4F,EAASb,EAAMlD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GACtD6F,EAASb,EAAMnD,EAAYx3B,EAAW,GAAG+N,OAAO,IAAM4nB,GAGtD8F,EAAMz7B,EAAWrC,IAAI,SAASuQ,GAChC,OAvSJ,SAAkCH,EAAQnO,GACxC,IAAI87B,EAAY97B,EAIhB,GAAImO,EAAOqY,KAAKmR,GAAiB,CAC/B,IAAIb,EAAYY,EAAavpB,GACzB4tB,EAAsB5tB,EAAOpQ,IAAIm7B,IAErC4C,EAAY,WAGV,IAFA,IAAIl8B,EAAO,GACPsgB,EAAO4W,EAAY99B,UAAUtD,OAAS,EAAIsD,UAAUtD,OAC/CT,EAAI,EAAGA,EAAIirB,EAAMjrB,IACxB2K,EAAK3K,GAAK8mC,EAAoB9mC,GAAG+D,UAAU/D,IAM7C,OAJI6hC,IACFl3B,EAAKsgB,GAAQlnB,UAAUknB,GAAMniB,IAAIg+B,EAAoB7b,KAGhDlgB,EAAGC,MAAM,KAAML,IAI1B,IAAIo8B,EAAeF,EACnB,GAAIpE,EAAavpB,GAAS,CACxB,IAAI8tB,EAAS9tB,EAAOzY,OAAS,EAE7BsmC,EAAe,WACb,OAAOF,EAAU77B,MAAM,KACnB5E,GAAMrC,UAAW,EAAGijC,GAAQ1wB,OAAO,CAAClQ,GAAMrC,UAAWijC,OAI7D,OAAOD,EAsQEE,CAAyB5tB,EAAUH,OAAQG,EAAUtO,MAG1Dm8B,EAAMzB,EAAMmB,EAAI,GAAKpkB,GACrB2kB,EAAMzB,EAAMkB,EAAI,GAAKpkB,GACrB4kB,EAAMzB,EAAMiB,EAAI,GAAKpkB,GACrB6kB,EAAMzB,EAAMgB,EAAI,GAAKpkB,GACrB8kB,EAAMzB,EAAMe,EAAI,GAAKpkB,GACrB+kB,EAAMzB,EAAMc,EAAI,GAAKpkB,GAErBglB,EAAO/B,EAAMt6B,EAAW,GAAG+N,OAAOzY,QAAU,EAC5C0kC,EAAOO,EAAMv6B,EAAW,GAAG+N,OAAOzY,QAAU,EAC5C2kC,EAAOO,EAAMx6B,EAAW,GAAG+N,OAAOzY,QAAU,EAC5CgnC,EAAO7B,EAAMz6B,EAAW,GAAG+N,OAAOzY,QAAU,EAC5CinC,EAAO7B,EAAM16B,EAAW,GAAG+N,OAAOzY,QAAU,EAC5CknC,EAAO7B,EAAM36B,EAAW,GAAG+N,OAAOzY,QAAU,EAG5CmnC,EAAS7B,EAAQ,EAAI,EACrB8B,EAAO18B,EAAW1K,OAClBqnC,EAAU,WAGZ,IAAK,IAAI9nC,EAAI4nC,EAAQ5nC,EAAI6nC,EAAM7nC,IAC7B,GAAI8iC,EAAM9iC,GAAG+D,WACX,OAAO6iC,EAAI5mC,GAAGgL,MAAM,KAAMjH,WAI9B,MA9hBJ,SAAqBZ,EAAMwH,EAAMQ,GAC/B,IAAI+E,EAAKiB,EAKL5O,EAJAwlC,EAAQ5kC,GAAQ,UAGhB6kC,EAAqB78B,EAEzB,IAAK5I,EAAQ,EAAGA,EAAQoI,EAAKlK,OAAQ8B,IAAS,CAC5C,IAAI0lC,EAAmBD,EAAmBxqB,OAAO,SAAUnE,GACzD,IAAI5J,EAAOkzB,EAAYQ,EAAgB9pB,EAAW9W,IAClD,OAAQA,EAAQ8W,EAAUH,OAAOzY,QAAUgiC,EAAappB,EAAUH,UAC9DzJ,EAAK9E,EAAKpI,MAGhB,GAAgC,IAA5B0lC,EAAiBxnC,QAGnB,GAAsB,GADtB0Q,EAAWoyB,EAAoByE,EAAoBzlC,IACtC9B,OAAY,CACvB,IAAIynC,EAAazG,EAAa92B,EAAKpI,IAYnC,OAVA2N,EAAM,IAAIpD,UAAU,2CAA6Ci7B,EAC7D,eAAiB52B,EAAS/H,KAAK,QAC/B,aAAe8+B,EAAa,YAAc3lC,EAAQ,MAClD0vB,KAAO,CACTkW,SAAU,YACVp9B,GAAIg9B,EACJxlC,MAAOA,EACP2O,OAAQg3B,EACR/2B,SAAUA,GAELjB,QAIT83B,EAAqBC,EAKzB,IAAIG,EAAUJ,EAAmBl/B,IAAI,SAAUuQ,GAC7C,OAAOopB,EAAappB,EAAUH,QAAU0jB,EAAAA,EAAWvjB,EAAUH,OAAOzY,SAEtE,GAAIkK,EAAKlK,OAASgC,KAAKiO,IAAI1F,MAAM,KAAMo9B,GAWrC,OAVAj3B,EAAWoyB,EAAoByE,EAAoBzlC,IACnD2N,EAAM,IAAIpD,UAAU,iCAAmCi7B,EACnD,eAAiB52B,EAAS/H,KAAK,QAC/B,YAAcuB,EAAKlK,OAAS,MAC5BwxB,KAAO,CACTkW,SAAU,aACVp9B,GAAIg9B,EACJxlC,MAAOoI,EAAKlK,OACZ0Q,SAAUA,GAELjB,EAIT,IAAIm4B,EAAY5lC,KAAKkO,IAAI3F,MAAM,KAAMo9B,GACrC,OAAIz9B,EAAKlK,OAAS4nC,GAChBn4B,EAAM,IAAIpD,UAAU,kCAAoCi7B,EACpD,eAAiBM,EAAY,aAAe19B,EAAKlK,OAAS,MAC1DwxB,KAAO,CACTkW,SAAU,cACVp9B,GAAIg9B,EACJxlC,MAAOoI,EAAKlK,OACZ6nC,eAAgBD,IAKpBn4B,EAAM,IAAIpD,UAAU,sBAAwBnC,EAAKvB,KAAK,MAClD,4DAA8D2+B,EAAQ,MACtE9V,KAAO,CACTkW,SAAU,WACVj3B,OAAQvG,EAAK7B,IAAI24B,IAPVvxB,EA2dD+Z,CAAY9mB,EAAMY,UAAWoH,IAKjCJ,EAAK,SAAYw9B,EAAMC,GAGzB,OAAIzkC,UAAUtD,SAAW+mC,GAAQxB,EAAOuC,IAASjC,EAAOkC,GAAgBtB,EAAIl8B,MAAM,KAAMjH,WACpFA,UAAUtD,SAAW0kC,GAAQc,EAAOsC,IAAShC,EAAOiC,GAAgBrB,EAAIn8B,MAAM,KAAMjH,WACpFA,UAAUtD,SAAW2kC,GAAQc,EAAOqC,IAAS/B,EAAOgC,GAAgBpB,EAAIp8B,MAAM,KAAMjH,WACpFA,UAAUtD,SAAWgnC,GAAQtB,EAAOoC,IAAS9B,EAAO+B,GAAgBnB,EAAIr8B,MAAM,KAAMjH,WACpFA,UAAUtD,SAAWinC,GAAQtB,EAAOmC,IAAS7B,EAAO8B,GAAgBlB,EAAIt8B,MAAM,KAAMjH,WACpFA,UAAUtD,SAAWknC,GAAQtB,EAAOkC,IAAS5B,EAAO6B,GAAgBjB,EAAIv8B,MAAM,KAAMjH,WAEjF+jC,EAAQ98B,MAAM,KAAMjH,YAI7B,IACEf,OAAOkQ,eAAenI,EAAI,OAAQ,CAACP,MAAOrH,IAE5C,MAAO+M,IASP,OAFAnF,EAAGI,YAnPCw5B,EAAgB,GAmPgBx5B,EAlPzBjI,QAAQ,SAAUmW,GACtBA,EAAUH,OAAOqY,KAAKmR,IACzB0B,GAAY/qB,EAAUH,QAAQ,GAAMhW,QAAQ,SAAUgW,GACpDyrB,EAAcjD,EAAgBxoB,IAAWG,EAAUtO,OAKlD45B,GA4OA55B,EAQT,SAASm3B,EAAUb,GACjB,OAA2C,IAApCh6B,EAAM85B,OAAOp5B,QAAQs5B,GAQ9B,SAASW,GAAK38B,GACZ,OAAOA,EAAI28B,OAQb,SAASC,EAAS58B,GAChB,QAASA,EAQX,SAAS0/B,GAAQv6B,GACf,OAAiB,OAAVA,EAQT,SAASs6B,GAAgB7tB,GACvB,OAA8B,IAAvBA,EAAMzH,MAAM/O,OAiBrB,SAASwqB,EAAK4J,GACZ,OAAOA,EAAIA,EAAIp0B,OAAS,GAU1B,SAAS2F,GAAMyuB,EAAK9Y,EAAOnJ,GACzB,OAAOtG,MAAMlJ,UAAUgD,MAAM5F,KAAKq0B,EAAK9Y,EAAOnJ,GAmBhD,SAASsyB,GAAWuD,EAAQC,GAC1B,IAAK,IAAI1oC,EAAI,EAAGA,EAAIyoC,EAAOhoC,OAAQT,IACjC,GAZc4I,EAYD8/B,EAZQ7/B,EAYA4/B,EAAOzoC,IAXE,IAAzB4I,EAAMb,QAAQc,GAYjB,OAAO,EAbb,IAAkBD,EAAOC,EAiBvB,OAAO,EAUT,SAASy4B,GAAYzM,EAAKplB,GACxB,IAAK,IAAIzP,EAAI,EAAGA,EAAI60B,EAAIp0B,OAAQT,IAC9B,GAAIyP,EAAKolB,EAAI70B,IACX,OAAO60B,EAAI70B,GA0BjB,SAASyjC,GAAQ5O,EAAK7gB,GACpB,OAAO1H,MAAMlJ,UAAUkT,OAAOtL,MAAM,GAAI6pB,EAAI/rB,IAAIkL,IAQlD,SAAS20B,EAAS/B,GAGhB,IAFA,IAAIzjC,EAAO,GAEFnD,EAAI,EAAGA,EAAI4mC,EAAInmC,OAAQT,IAAK,CACnC,IAAI+K,EAAK67B,EAAI5mC,GAGb,IAA8B,iBAAlB+K,EAAGI,YAAmD,iBAAjBJ,EAAGsO,YAAuC,KAAZtO,EAAG5H,KAChF,GAAa,KAATA,EACFA,EAAO4H,EAAG5H,UAEP,GAAIA,IAAS4H,EAAG5H,KAAM,CACzB,IAAI+M,EAAM,IAAI7P,MAAM,0CAA4C8C,EAAO,aAAe4H,EAAG5H,KAAO,KAKhG,MAJA+M,EAAI+hB,KAAO,CACT/gB,OAAQnG,EAAG5H,KACXgO,SAAUhO,GAEN+M,GAKZ,OAAO/M,EAIT,SAASylC,EAAkBhC,GACzB,IAAI12B,EACAy0B,EAAgB,GAEpB,SAASkE,EAAeC,EAAYC,GAClC,GAAIpE,EAActhC,eAAeylC,IAAeC,IAAQpE,EAAcmE,GAGpE,MAFA54B,EAAM,IAAI7P,MAAM,cAAgByoC,EAAa,uBACzC7W,KAAO,CAAC5Y,UAAWyvB,GACjB54B,EAKV,IAAK,IAAIlQ,EAAI,EAAGA,EAAI4mC,EAAInmC,OAAQT,IAAK,CACnC,IAAI+K,EAAK67B,EAAI5mC,GAGb,GAA6B,iBAAlB+K,EAAGI,WAEZ,IAAK,IAAIkO,KAAatO,EAAGI,WACnBJ,EAAGI,WAAW9H,eAAegW,KAC/BwvB,EAAexvB,EAAWtO,EAAGI,WAAWkO,IACxCsrB,EAActrB,GAAatO,EAAGI,WAAWkO,QAI1C,CAAA,GAA4B,iBAAjBtO,EAAGsO,UAOjB,MAFAnJ,EAAM,IAAIpD,UAAU,yCAA2C9M,EAAI,MAC/DiyB,KAAO,CAAC1vB,MAAOvC,GACbkQ,EANN24B,EAAe99B,EAAGsO,UAAWtO,GAC7B45B,EAAc55B,EAAGsO,WAAatO,GASlC,OAAO45B,EAoET,OAjEAt9B,EAAQq9B,EAAoB,QAAS,CACnCryB,iBAAkBqyB,EAClB1hC,OAAU,SAAU2hC,GAElB,IAAIiC,EAAM,GACV,IAAK,IAAIvtB,KAAasrB,EAChBA,EAActhC,eAAegW,IAC/ButB,EAAI5+B,KAAK28B,EAActrB,IAI3B,OAAOqrB,EADIiE,EAAQ/B,GACcjC,IAEnCqE,cAAe,SAAUpC,GACvB,OAAOlC,EAAoBiE,EAAQ/B,GAAMgC,EAAkBhC,KAE7DqC,sBAAuB,SAAU9lC,EAAMyjC,GACrC,OAAOlC,EAAoBvhC,EAAMylC,EAAkBhC,QAIjDjmC,OAASA,EACf0G,EAAMmI,MAAQuxB,EACd15B,EAAMqI,YAAcwxB,EACpB75B,EAAM85B,OAASF,EACf55B,EAAMwI,QA5mCN,SAAkBrF,EAAOvD,GACvB,IAAI0I,EAAO8xB,EAAaj3B,GAGxB,GAAIvD,IAAS0I,EACX,OAAOnF,EAGT,IAAK,IAAIxK,EAAI,EAAGA,EAAIqH,EAAMqI,YAAYjP,OAAQT,IAAK,CACjD,IAAIoiC,EAAa/6B,EAAMqI,YAAY1P,GACnC,GAAIoiC,EAAWzyB,OAASA,GAAQyyB,EAAWxyB,KAAO3I,EAChD,OAAOm7B,EAAWvyB,QAAQrF,GAI9B,MAAM,IAAInK,MAAM,uBAAyBsP,EAAO,OAAS1I,IA8lC3DI,EAAMqW,KAnpCN,SAAe3S,EAAIsO,GACjB,IAAKtO,EAAGI,WACN,MAAM,IAAI2B,UAAU,iCAItB,IAAI+nB,EACJ,GAAyB,iBAAdxb,EAAwB,CACjCwb,EAAMxb,EAAUiY,MAAM,KACtB,IAAK,IAAItxB,EAAI,EAAGA,EAAI60B,EAAIp0B,OAAQT,IAC9B60B,EAAI70B,GAAK60B,EAAI70B,GAAGgiC,WAGf,CAAA,IAAI11B,MAAMC,QAAQ8M,GAIrB,MAAM,IAAIvM,UAAU,qDAHpB+nB,EAAMxb,EAMR,IAAIhU,EAAMwvB,EAAIzrB,KAAK,KAGfsR,EAAQ3P,EAAGI,WAAW9F,GAC1B,GAAIqV,EACF,OAAOA,EAKT,MAAM,IAAI5N,UAAU,oCAAsC/B,EAAG5H,MAAQ,WAAa,IAAM0xB,EAAIzrB,KAAK,MAAQ,OA+nC3G/B,EAAM6hC,QAAU,SAAUjiC,EAAMkiC,GAC9B,IAAKliC,GAA6B,iBAAdA,EAAK9D,MAA0C,mBAAd8D,EAAKwI,KACxD,MAAM,IAAI3C,UAAU,kEAGtB,IAAyB,IAArBq8B,EACF,IAAK,IAAInpC,EAAI,EAAGA,EAAIqH,EAAMmI,MAAM/O,OAAQT,IACtC,GAA4B,WAAxBqH,EAAMmI,MAAMxP,GAAGmD,KAEjB,YADAkE,EAAMmI,MAAMqvB,OAAO7+B,EAAG,EAAGiH,GAM/BI,EAAMmI,MAAMxH,KAAKf,IAInBI,EAAM+hC,cAAgB,SAAUhH,GAC9B,IAAKA,GAC6B,iBAApBA,EAAWzyB,MACO,iBAAlByyB,EAAWxyB,IACY,mBAAvBwyB,EAAWvyB,QACvB,MAAM,IAAI/C,UAAU,iFAGtBzF,EAAMqI,YAAY1H,KAAKo6B,IAGlB/6B,EAGF1G,IAh2CuB,iBAAZzB,EAIhBC,EAAOD,QAAU2I,IAGjBiX,EAAKzX,MAAQQ,KA21Cf,KAAK,GAAG,CAAC,GA3sZiW,CA2sZ7V"} \ No newline at end of file
diff --git a/sounds/129655__perplessio__droplets-underwater.aiff b/sounds/129655__perplessio__droplets-underwater.aiff
new file mode 100644
index 0000000..f08b7ed
--- /dev/null
+++ b/sounds/129655__perplessio__droplets-underwater.aiff
Binary files differ
diff --git a/sounds/droplet.mp3 b/sounds/droplet.mp3
new file mode 100644
index 0000000..1852466
--- /dev/null
+++ b/sounds/droplet.mp3
Binary files differ
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-22 01:54:05 +0000