feat:node-modules

node_modules/mathjs/lib/cjs/expression/transform/utils/compileInlineExpression.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compileInlineExpression = compileInlineExpression;
+var _is = require("../../../utils/is.js");
+var _map = require("../../../utils/map.js");
+/**
+ * Compile an inline expression like "x > 0"
+ * @param {Node} expression
+ * @param {Object} math
+ * @param {Map} scope
+ * @return {function} Returns a function with one argument which fills in the
+ *                    undefined variable (like "x") and evaluates the expression
+ */
+function compileInlineExpression(expression, math, scope) {
+  // find an undefined symbol
+  const symbol = expression.filter(function (node) {
+    return (0, _is.isSymbolNode)(node) && !(node.name in math) && !scope.has(node.name);
+  })[0];
+  if (!symbol) {
+    throw new Error('No undefined variable found in inline expression "' + expression + '"');
+  }
+
+  // create a test function for this equation
+  const name = symbol.name; // variable name
+  const argsScope = new Map();
+  const subScope = new _map.PartitionedMap(scope, argsScope, new Set([name]));
+  const eq = expression.compile();
+  return function inlineExpression(x) {
+    argsScope.set(name, x);
+    return eq.evaluate(subScope);
+  };
+}

node_modules/mathjs/lib/cjs/expression/transform/utils/dimToZeroBase.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimToZeroBase = dimToZeroBase;
+exports.isNumberOrBigNumber = isNumberOrBigNumber;
+var _is = require("../../../utils/is.js");
+/**
+ * Change last argument dim from one-based to zero-based.
+ */
+function dimToZeroBase(dim) {
+  if ((0, _is.isNumber)(dim)) {
+    return dim - 1;
+  } else if ((0, _is.isBigNumber)(dim)) {
+    return dim.minus(1);
+  } else {
+    return dim;
+  }
+}
+function isNumberOrBigNumber(n) {
+  return (0, _is.isNumber)(n) || (0, _is.isBigNumber)(n);
+}

node_modules/mathjs/lib/cjs/expression/transform/utils/errorTransform.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorTransform = errorTransform;
+var _IndexError = require("../../../error/IndexError.js");
+/**
+ * Transform zero-based indices to one-based indices in errors
+ * @param {Error} err
+ * @returns {Error | IndexError} Returns the transformed error
+ */
+function errorTransform(err) {
+  if (err && err.isIndexError) {
+    return new _IndexError.IndexError(err.index + 1, err.min + 1, err.max !== undefined ? err.max + 1 : undefined);
+  }
+  return err;
+}

node_modules/mathjs/lib/cjs/expression/transform/utils/lastDimToZeroBase.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lastDimToZeroBase = lastDimToZeroBase;
+var _is = require("../../../utils/is.js");
+var _dimToZeroBase = require("./dimToZeroBase.js");
+/**
+ * Change last argument dim from one-based to zero-based.
+ */
+function lastDimToZeroBase(args) {
+  if (args.length === 2 && (0, _is.isCollection)(args[0])) {
+    args = args.slice();
+    const dim = args[1];
+    if ((0, _dimToZeroBase.isNumberOrBigNumber)(dim)) {
+      args[1] = (0, _dimToZeroBase.dimToZeroBase)(dim);
+    }
+  }
+  return args;
+}