feat:node-modules

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

@@ -0,0 +1,30 @@
+import { isSymbolNode } from '../../../utils/is.js';
+import { PartitionedMap } from '../../../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
+ */
+export function compileInlineExpression(expression, math, scope) {
+  // find an undefined symbol
+  var symbol = expression.filter(function (node) {
+    return 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
+  var name = symbol.name; // variable name
+  var argsScope = new Map();
+  var subScope = new PartitionedMap(scope, argsScope, new Set([name]));
+  var eq = expression.compile();
+  return function inlineExpression(x) {
+    argsScope.set(name, x);
+    return eq.evaluate(subScope);
+  };
+}

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

@@ -0,0 +1,16 @@
+import { isNumber, isBigNumber } from '../../../utils/is.js';
+/**
+ * Change last argument dim from one-based to zero-based.
+ */
+export function dimToZeroBase(dim) {
+  if (isNumber(dim)) {
+    return dim - 1;
+  } else if (isBigNumber(dim)) {
+    return dim.minus(1);
+  } else {
+    return dim;
+  }
+}
+export function isNumberOrBigNumber(n) {
+  return isNumber(n) || isBigNumber(n);
+}

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

@@ -0,0 +1,13 @@
+import { IndexError } from '../../../error/IndexError.js';
+
+/**
+ * Transform zero-based indices to one-based indices in errors
+ * @param {Error} err
+ * @returns {Error | IndexError} Returns the transformed error
+ */
+export function errorTransform(err) {
+  if (err && err.isIndexError) {
+    return new IndexError(err.index + 1, err.min + 1, err.max !== undefined ? err.max + 1 : undefined);
+  }
+  return err;
+}

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

@@ -0,0 +1,15 @@
+import { isCollection } from '../../../utils/is.js';
+import { dimToZeroBase, isNumberOrBigNumber } from './dimToZeroBase.js';
+/**
+ * Change last argument dim from one-based to zero-based.
+ */
+export function lastDimToZeroBase(args) {
+  if (args.length === 2 && isCollection(args[0])) {
+    args = args.slice();
+    var dim = args[1];
+    if (isNumberOrBigNumber(dim)) {
+      args[1] = dimToZeroBase(dim);
+    }
+  }
+  return args;
+}

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

@@ -0,0 +1,95 @@
+import { factory } from '../../../utils/factory.js';
+var name = 'transformCallback';
+var dependencies = ['typed'];
+export var createTransformCallback = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    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) {
+    var signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      var [signature, callbackFunction] = _ref2;
+      var 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];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var 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];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var idx = _transformDims(args[numberOfArrays]);
+      var 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);
+}