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;
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTransformCallback = void 0;
+var _factory = require("../../../utils/factory.js");
+const name = 'transformCallback';
+const dependencies = ['typed'];
+const createTransformCallback = exports.createTransformCallback = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+         * Transforms the given callback function based on its type and number of arrays.
+         *
+         * @param {Function} callback - The callback function to transform.
+         * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+         * @returns {*} - The transformed callback function.
+         */
+  return function (callback, numberOfArrays) {
+    if (typed.isTypedFunction(callback)) {
+      return _transformTypedCallbackFunction(callback, numberOfArrays);
+    } else {
+      return _transformCallbackFunction(callback, callback.length, numberOfArrays);
+    }
+  };
+
+  /**
+       * Transforms the given typed callback function based on the number of arrays.
+       *
+       * @param {Function} typedFunction - The typed callback function to transform.
+       * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+       * @returns {*} - The transformed callback function.
+       */
+  function _transformTypedCallbackFunction(typedFunction, numberOfArrays) {
+    const signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      let [signature, callbackFunction] = _ref2;
+      const numberOfCallbackInputs = signature.split(',').length;
+      if (typed.isTypedFunction(callbackFunction)) {
+        return [signature, _transformTypedCallbackFunction(callbackFunction, numberOfArrays)];
+      } else {
+        return [signature, _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays)];
+      }
+    }));
+    if (typeof typedFunction.name === 'string') {
+      return typed(typedFunction.name, signatures);
+    } else {
+      return typed(signatures);
+    }
+  }
+});
+
+/**
+     * Transforms the callback function based on the number of callback inputs and arrays.
+     * There are three cases:
+     * 1. The callback function has N arguments.
+     * 2. The callback function has N+1 arguments.
+     * 3. The callback function has 2N+1 arguments.
+     *
+     * @param {Function} callbackFunction - The callback function to transform.
+     * @param {number} numberOfCallbackInputs - The number of callback inputs.
+     * @param {number} numberOfArrays - The number of arrays.
+     * @returns {Function} The transformed callback function.
+     */
+function _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays) {
+  if (numberOfCallbackInputs === numberOfArrays) {
+    return callbackFunction;
+  } else if (numberOfCallbackInputs === numberOfArrays + 1) {
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      return callbackFunction(...vals, idx);
+    };
+  } else if (numberOfCallbackInputs > numberOfArrays + 1) {
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      const rest = args.slice(numberOfArrays + 1);
+      return callbackFunction(...vals, idx, ...rest);
+    };
+  } else {
+    return callbackFunction;
+  }
+}
+
+/**
+   * Transforms the dimensions by adding 1 to each dimension.
+   *
+   * @param {Array} dims - The dimensions to transform.
+   * @returns {Array} The transformed dimensions.
+   */
+function _transformDims(dims) {
+  return dims.map(dim => dim + 1);
+}