@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/function/algebra/resolve.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createResolve = void 0;
+
+var _map = require("../../utils/map.js");
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'resolve';
+var dependencies = ['parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse,
+      ConstantNode = _ref.ConstantNode,
+      FunctionNode = _ref.FunctionNode,
+      OperatorNode = _ref.OperatorNode,
+      ParenthesisNode = _ref.ParenthesisNode;
+
+  /**
+   * resolve(expr, scope) replaces variable nodes with their scoped values
+   *
+   * Syntax:
+   *
+   *     resolve(expr, scope)
+   *
+   * Examples:
+   *
+   *     math.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
+   *     math.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
+   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
+   *
+   * See also:
+   *
+   *     simplify, evaluate
+   *
+   * @param {Node | Node[]} node
+   *     The expression tree (or trees) to be simplified
+   * @param {Object} scope
+   *     Scope specifying variables to be resolved
+   * @return {Node | Node[]} Returns `node` with variables recursively substituted.
+   * @throws {ReferenceError}
+   *     If there is a cyclic dependency among the variables in `scope`,
+   *     resolution is impossible and a ReferenceError is thrown.
+   */
+  function resolve(node, scope) {
+    var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+
+    // note `within`:
+    // `within` is not documented, since it is for internal cycle
+    // detection only
+    if (!scope) {
+      return node;
+    }
+
+    if (!(0, _map.isMap)(scope)) {
+      scope = (0, _map.createMap)(scope);
+    }
+
+    if ((0, _is.isSymbolNode)(node)) {
+      if (within.has(node.name)) {
+        var variables = Array.from(within).join(', ');
+        throw new ReferenceError("recursive loop of variable definitions among {".concat(variables, "}"));
+      }
+
+      var value = scope.get(node.name);
+
+      if ((0, _is.isNode)(value)) {
+        var nextWithin = new Set(within);
+        nextWithin.add(node.name);
+        return resolve(value, scope, nextWithin);
+      } else if (typeof value === 'number') {
+        return parse(String(value));
+      } else if (value !== undefined) {
+        return new ConstantNode(value);
+      } else {
+        return node;
+      }
+    } else if ((0, _is.isOperatorNode)(node)) {
+      var args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+      return new OperatorNode(node.op, node.fn, args, node.implicit);
+    } else if ((0, _is.isParenthesisNode)(node)) {
+      return new ParenthesisNode(resolve(node.content, scope, within));
+    } else if ((0, _is.isFunctionNode)(node)) {
+      var _args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+
+      return new FunctionNode(node.name, _args);
+    } // Otherwise just recursively resolve any children (might also work
+    // for some of the above special cases)
+
+
+    return node.map(function (child) {
+      return resolve(child, scope, within);
+    });
+  }
+
+  return resolve;
+});
+exports.createResolve = createResolve;

package/dist/node_modules/mathjs/lib/cjs/function/algebra/simplify/simplifyConstant.js

@@ -0,0 +1,526 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSimplifyConstant = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _is = require("../../../utils/is.js");
+
+var _factory = require("../../../utils/factory.js");
+
+var _util = require("./util.js");
+
+var _noop = require("../../../utils/noop.js");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var name = 'simplifyConstant';
+var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
+var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      config = _ref.config,
+      mathWithTransform = _ref.mathWithTransform,
+      matrix = _ref.matrix,
+      fraction = _ref.fraction,
+      bignumber = _ref.bignumber,
+      AccessorNode = _ref.AccessorNode,
+      ArrayNode = _ref.ArrayNode,
+      ConstantNode = _ref.ConstantNode,
+      FunctionNode = _ref.FunctionNode,
+      IndexNode = _ref.IndexNode,
+      ObjectNode = _ref.ObjectNode,
+      OperatorNode = _ref.OperatorNode,
+      SymbolNode = _ref.SymbolNode;
+
+  var _createUtil = (0, _util.createUtil)({
+    FunctionNode: FunctionNode,
+    OperatorNode: OperatorNode,
+    SymbolNode: SymbolNode
+  }),
+      isCommutative = _createUtil.isCommutative,
+      isAssociative = _createUtil.isAssociative,
+      allChildren = _createUtil.allChildren,
+      createMakeNodeFunction = _createUtil.createMakeNodeFunction;
+
+  function simplifyConstant(expr, options) {
+    return _ensureNode(foldFraction(expr, options));
+  }
+
+  function _removeFractions(thing) {
+    if ((0, _is.isFraction)(thing)) {
+      return thing.valueOf();
+    }
+
+    if (thing instanceof Array) {
+      return thing.map(_removeFractions);
+    }
+
+    if ((0, _is.isMatrix)(thing)) {
+      return matrix(_removeFractions(thing.valueOf()));
+    }
+
+    return thing;
+  }
+
+  function _eval(fnname, args, options) {
+    try {
+      return mathWithTransform[fnname].apply(null, args);
+    } catch (ignore) {
+      // sometimes the implicit type conversion causes the evaluation to fail, so we'll try again after removing Fractions
+      args = args.map(_removeFractions);
+      return _toNumber(mathWithTransform[fnname].apply(null, args), options);
+    }
+  }
+
+  var _toNode = typed({
+    Fraction: _fractionToNode,
+    number: function number(n) {
+      if (n < 0) {
+        return unaryMinusNode(new ConstantNode(-n));
+      }
+
+      return new ConstantNode(n);
+    },
+    BigNumber: function BigNumber(n) {
+      if (n < 0) {
+        return unaryMinusNode(new ConstantNode(-n));
+      }
+
+      return new ConstantNode(n); // old parameters: (n.toString(), 'number')
+    },
+    Complex: function Complex(s) {
+      throw new Error('Cannot convert Complex number to Node');
+    },
+    string: function string(s) {
+      return new ConstantNode(s);
+    },
+    Matrix: function Matrix(m) {
+      return new ArrayNode(m.valueOf().map(function (e) {
+        return _toNode(e);
+      }));
+    }
+  });
+
+  function _ensureNode(thing) {
+    if ((0, _is.isNode)(thing)) {
+      return thing;
+    }
+
+    return _toNode(thing);
+  } // convert a number to a fraction only if it can be expressed exactly,
+  // and when both numerator and denominator are small enough
+
+
+  function _exactFraction(n, options) {
+    var exactFractions = options && options.exactFractions !== false;
+
+    if (exactFractions && isFinite(n) && fraction) {
+      var f = fraction(n);
+      var fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
+
+      if (f.valueOf() === n && f.n < fractionsLimit && f.d < fractionsLimit) {
+        return f;
+      }
+    }
+
+    return n;
+  } // Convert numbers to a preferred number type in preference order: Fraction, number, Complex
+  // BigNumbers are left alone
+
+
+  var _toNumber = typed({
+    'string, Object': function stringObject(s, options) {
+      if (config.number === 'BigNumber') {
+        if (bignumber === undefined) {
+          (0, _noop.noBignumber)();
+        }
+
+        return bignumber(s);
+      } else if (config.number === 'Fraction') {
+        if (fraction === undefined) {
+          (0, _noop.noFraction)();
+        }
+
+        return fraction(s);
+      } else {
+        var n = parseFloat(s);
+        return _exactFraction(n, options);
+      }
+    },
+    'Fraction, Object': function FractionObject(s, options) {
+      return s;
+    },
+    // we don't need options here
+    'BigNumber, Object': function BigNumberObject(s, options) {
+      return s;
+    },
+    // we don't need options here
+    'number, Object': function numberObject(s, options) {
+      return _exactFraction(s, options);
+    },
+    'Complex, Object': function ComplexObject(s, options) {
+      if (s.im !== 0) {
+        return s;
+      }
+
+      return _exactFraction(s.re, options);
+    },
+    'Matrix, Object': function MatrixObject(s, options) {
+      return matrix(_exactFraction(s.valueOf()));
+    },
+    'Array, Object': function ArrayObject(s, options) {
+      return s.map(_exactFraction);
+    }
+  });
+
+  function unaryMinusNode(n) {
+    return new OperatorNode('-', 'unaryMinus', [n]);
+  }
+
+  function _fractionToNode(f) {
+    var n;
+    var vn = f.s * f.n;
+
+    if (vn < 0) {
+      n = new OperatorNode('-', 'unaryMinus', [new ConstantNode(-vn)]);
+    } else {
+      n = new ConstantNode(vn);
+    }
+
+    if (f.d === 1) {
+      return n;
+    }
+
+    return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
+  }
+  /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */
+
+
+  function _foldAccessor(obj, index, options) {
+    if (!(0, _is.isIndexNode)(index)) {
+      // don't know what to do with that...
+      return new AccessorNode(_ensureNode(obj), _ensureNode(index));
+    }
+
+    if ((0, _is.isArrayNode)(obj) || (0, _is.isMatrix)(obj)) {
+      var remainingDims = Array.from(index.dimensions);
+      /* We will resolve constant indices one at a time, looking
+       * just in the first or second dimensions because (a) arrays
+       * of more than two dimensions are likely rare, and (b) pulling
+       * out the third or higher dimension would be pretty intricate.
+       * The price is that we miss simplifying [..3d array][x,y,1]
+       */
+
+      while (remainingDims.length > 0) {
+        if ((0, _is.isConstantNode)(remainingDims[0]) && typeof remainingDims[0].value !== 'string') {
+          var first = _toNumber(remainingDims.shift().value, options);
+
+          if ((0, _is.isArrayNode)(obj)) {
+            obj = obj.items[first - 1];
+          } else {
+            // matrix
+            obj = obj.valueOf()[first - 1];
+
+            if (obj instanceof Array) {
+              obj = matrix(obj);
+            }
+          }
+        } else if (remainingDims.length > 1 && (0, _is.isConstantNode)(remainingDims[1]) && typeof remainingDims[1].value !== 'string') {
+          var second = _toNumber(remainingDims[1].value, options);
+
+          var tryItems = [];
+          var fromItems = (0, _is.isArrayNode)(obj) ? obj.items : obj.valueOf();
+
+          var _iterator = _createForOfIteratorHelper(fromItems),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var item = _step.value;
+
+              if ((0, _is.isArrayNode)(item)) {
+                tryItems.push(item.items[second - 1]);
+              } else if ((0, _is.isMatrix)(obj)) {
+                tryItems.push(item[second - 1]);
+              } else {
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+
+          if (tryItems.length === fromItems.length) {
+            if ((0, _is.isArrayNode)(obj)) {
+              obj = new ArrayNode(tryItems);
+            } else {
+              // matrix
+              obj = matrix(tryItems);
+            }
+
+            remainingDims.splice(1, 1);
+          } else {
+            // extracting slice along 2nd dimension failed, give up
+            break;
+          }
+        } else {
+          // neither 1st or 2nd dimension is constant, give up
+          break;
+        }
+      }
+
+      if (remainingDims.length === index.dimensions.length) {
+        /* No successful constant indexing */
+        return new AccessorNode(_ensureNode(obj), index);
+      }
+
+      if (remainingDims.length > 0) {
+        /* Indexed some but not all dimensions */
+        index = new IndexNode(remainingDims);
+        return new AccessorNode(_ensureNode(obj), index);
+      }
+      /* All dimensions were constant, access completely resolved */
+
+
+      return obj;
+    }
+
+    if ((0, _is.isObjectNode)(obj) && index.dimensions.length === 1 && (0, _is.isConstantNode)(index.dimensions[0])) {
+      var key = index.dimensions[0].value;
+
+      if (key in obj.properties) {
+        return obj.properties[key];
+      }
+
+      return new ConstantNode(); // undefined
+    }
+    /* Don't know how to index this sort of obj, at least not with this index */
+
+
+    return new AccessorNode(_ensureNode(obj), index);
+  }
+  /*
+   * Create a binary tree from a list of Fractions and Nodes.
+   * Tries to fold Fractions by evaluating them until the first Node in the list is hit, so
+   * `args` should be sorted to have the Fractions at the start (if the operator is commutative).
+   * @param args - list of Fractions and Nodes
+   * @param fn - evaluator for the binary operation evaluator that accepts two Fractions
+   * @param makeNode - creates a binary OperatorNode/FunctionNode from a list of child Nodes
+   * if args.length is 1, returns args[0]
+   * @return - Either a Node representing a binary expression or Fraction
+   */
+
+
+  function foldOp(fn, args, makeNode, options) {
+    return args.reduce(function (a, b) {
+      if (!(0, _is.isNode)(a) && !(0, _is.isNode)(b)) {
+        try {
+          return _eval(fn, [a, b], options);
+        } catch (ignoreandcontinue) {}
+
+        a = _toNode(a);
+        b = _toNode(b);
+      } else if (!(0, _is.isNode)(a)) {
+        a = _toNode(a);
+      } else if (!(0, _is.isNode)(b)) {
+        b = _toNode(b);
+      }
+
+      return makeNode([a, b]);
+    });
+  } // destroys the original node and returns a folded one
+
+
+  function foldFraction(node, options) {
+    switch (node.type) {
+      case 'SymbolNode':
+        return node;
+
+      case 'ConstantNode':
+        switch ((0, _typeof2.default)(node.value)) {
+          case 'number':
+            return _toNumber(node.value, options);
+
+          case 'string':
+            return node.value;
+
+          default:
+            if (!isNaN(node.value)) return _toNumber(node.value, options);
+        }
+
+        return node;
+
+      case 'FunctionNode':
+        if (mathWithTransform[node.name] && mathWithTransform[node.name].rawArgs) {
+          return node;
+        }
+
+        {
+          // Process operators as OperatorNode
+          var operatorFunctions = ['add', 'multiply'];
+
+          if (operatorFunctions.indexOf(node.name) === -1) {
+            var args = node.args.map(function (arg) {
+              return foldFraction(arg, options);
+            }); // If all args are numbers
+
+            if (!args.some(_is.isNode)) {
+              try {
+                return _eval(node.name, args, options);
+              } catch (ignoreandcontinue) {}
+            } // Size of a matrix does not depend on entries
+
+
+            if (node.name === 'size' && args.length === 1 && (0, _is.isArrayNode)(args[0])) {
+              var sz = [];
+              var section = args[0];
+
+              while ((0, _is.isArrayNode)(section)) {
+                sz.push(section.items.length);
+                section = section.items[0];
+              }
+
+              return matrix(sz);
+            } // Convert all args to nodes and construct a symbolic function call
+
+
+            return new FunctionNode(node.name, args.map(_ensureNode));
+          } else {// treat as operator
+          }
+        }
+
+      /* falls through */
+
+      case 'OperatorNode':
+        {
+          var fn = node.fn.toString();
+
+          var _args;
+
+          var res;
+          var makeNode = createMakeNodeFunction(node);
+
+          if ((0, _is.isOperatorNode)(node) && node.isUnary()) {
+            _args = [foldFraction(node.args[0], options)];
+
+            if (!(0, _is.isNode)(_args[0])) {
+              res = _eval(fn, _args, options);
+            } else {
+              res = makeNode(_args);
+            }
+          } else if (isAssociative(node, options.context)) {
+            _args = allChildren(node, options.context);
+            _args = _args.map(function (arg) {
+              return foldFraction(arg, options);
+            });
+
+            if (isCommutative(fn, options.context)) {
+              // commutative binary operator
+              var consts = [];
+              var vars = [];
+
+              for (var i = 0; i < _args.length; i++) {
+                if (!(0, _is.isNode)(_args[i])) {
+                  consts.push(_args[i]);
+                } else {
+                  vars.push(_args[i]);
+                }
+              }
+
+              if (consts.length > 1) {
+                res = foldOp(fn, consts, makeNode, options);
+                vars.unshift(res);
+                res = foldOp(fn, vars, makeNode, options);
+              } else {
+                // we won't change the children order since it's not neccessary
+                res = foldOp(fn, _args, makeNode, options);
+              }
+            } else {
+              // non-commutative binary operator
+              res = foldOp(fn, _args, makeNode, options);
+            }
+          } else {
+            // non-associative binary operator
+            _args = node.args.map(function (arg) {
+              return foldFraction(arg, options);
+            });
+            res = foldOp(fn, _args, makeNode, options);
+          }
+
+          return res;
+        }
+
+      case 'ParenthesisNode':
+        // remove the uneccessary parenthesis
+        return foldFraction(node.content, options);
+
+      case 'AccessorNode':
+        return _foldAccessor(foldFraction(node.object, options), foldFraction(node.index, options), options);
+
+      case 'ArrayNode':
+        {
+          var foldItems = node.items.map(function (item) {
+            return foldFraction(item, options);
+          });
+
+          if (foldItems.some(_is.isNode)) {
+            return new ArrayNode(foldItems.map(_ensureNode));
+          }
+          /* All literals -- return a Matrix so we can operate on it */
+
+
+          return matrix(foldItems);
+        }
+
+      case 'IndexNode':
+        {
+          return new IndexNode(node.dimensions.map(function (n) {
+            return simplifyConstant(n, options);
+          }));
+        }
+
+      case 'ObjectNode':
+        {
+          var foldProps = {};
+
+          for (var prop in node.properties) {
+            foldProps[prop] = simplifyConstant(node.properties[prop], options);
+          }
+
+          return new ObjectNode(foldProps);
+        }
+
+      case 'AssignmentNode':
+      /* falls through */
+
+      case 'BlockNode':
+      /* falls through */
+
+      case 'FunctionAssignmentNode':
+      /* falls through */
+
+      case 'RangeNode':
+      /* falls through */
+
+      case 'ConditionalNode':
+      /* falls through */
+
+      default:
+        throw new Error("Unimplemented node type in simplifyConstant: ".concat(node.type));
+    }
+  }
+
+  return simplifyConstant;
+});
+exports.createSimplifyConstant = createSimplifyConstant;