feat:node-modules

node_modules/mathjs/lib/cjs/expression/transform/and.transform.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAndTransform = void 0;
+var _and = require("../../function/logical/and.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+const name = 'and';
+const dependencies = ['typed', 'matrix', 'zeros', 'add', 'equalScalar', 'not', 'concat'];
+const createAndTransform = exports.createAndTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    equalScalar,
+    zeros,
+    not,
+    concat
+  } = _ref;
+  const and = (0, _and.createAnd)({
+    typed,
+    matrix,
+    equalScalar,
+    zeros,
+    not,
+    concat
+  });
+  function andTransform(args, math, scope) {
+    const condition1 = args[0].compile().evaluate(scope);
+    if (!(0, _is.isCollection)(condition1) && !and(condition1, true)) {
+      return false;
+    }
+    const condition2 = args[1].compile().evaluate(scope);
+    return and(condition1, condition2);
+  }
+  andTransform.rawArgs = true;
+  return andTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/apply.transform.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createApplyTransform = void 0;
+var _errorTransform = require("./utils/errorTransform.js");
+var _factory = require("../../utils/factory.js");
+var _apply = require("../../function/matrix/apply.js");
+var _is = require("../../utils/is.js");
+const name = 'apply';
+const dependencies = ['typed', 'isInteger'];
+
+/**
+ * Attach a transform function to math.apply
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function apply
+ * from one-based to zero based
+ */
+const createApplyTransform = exports.createApplyTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isInteger
+  } = _ref;
+  const apply = (0, _apply.createApply)({
+    typed,
+    isInteger
+  });
+
+  // @see: comment of concat itself
+  return typed('apply', {
+    '...any': function (args) {
+      // change dim from one-based to zero-based
+      const dim = args[1];
+      if ((0, _is.isNumber)(dim)) {
+        args[1] = dim - 1;
+      } else if ((0, _is.isBigNumber)(dim)) {
+        args[1] = dim.minus(1);
+      }
+      try {
+        return apply.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/bitAnd.transform.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBitAndTransform = void 0;
+var _bitAnd = require("../../function/bitwise/bitAnd.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+const name = 'bitAnd';
+const dependencies = ['typed', 'matrix', 'zeros', 'add', 'equalScalar', 'not', 'concat'];
+const createBitAndTransform = exports.createBitAndTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    equalScalar,
+    zeros,
+    not,
+    concat
+  } = _ref;
+  const bitAnd = (0, _bitAnd.createBitAnd)({
+    typed,
+    matrix,
+    equalScalar,
+    zeros,
+    not,
+    concat
+  });
+  function bitAndTransform(args, math, scope) {
+    const condition1 = args[0].compile().evaluate(scope);
+    if (!(0, _is.isCollection)(condition1)) {
+      if (isNaN(condition1)) {
+        return NaN;
+      }
+      if (condition1 === 0 || condition1 === false) {
+        return 0;
+      }
+    }
+    const condition2 = args[1].compile().evaluate(scope);
+    return bitAnd(condition1, condition2);
+  }
+  bitAndTransform.rawArgs = true;
+  return bitAndTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/bitOr.transform.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBitOrTransform = void 0;
+var _bitOr = require("../../function/bitwise/bitOr.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+const name = 'bitOr';
+const dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat'];
+const createBitOrTransform = exports.createBitOrTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    equalScalar,
+    DenseMatrix,
+    concat
+  } = _ref;
+  const bitOr = (0, _bitOr.createBitOr)({
+    typed,
+    matrix,
+    equalScalar,
+    DenseMatrix,
+    concat
+  });
+  function bitOrTransform(args, math, scope) {
+    const condition1 = args[0].compile().evaluate(scope);
+    if (!(0, _is.isCollection)(condition1)) {
+      if (isNaN(condition1)) {
+        return NaN;
+      }
+      if (condition1 === -1) {
+        return -1;
+      }
+      if (condition1 === true) {
+        return 1;
+      }
+    }
+    const condition2 = args[1].compile().evaluate(scope);
+    return bitOr(condition1, condition2);
+  }
+  bitOrTransform.rawArgs = true;
+  return bitOrTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/column.transform.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createColumnTransform = void 0;
+var _errorTransform = require("./utils/errorTransform.js");
+var _factory = require("../../utils/factory.js");
+var _column = require("../../function/matrix/column.js");
+var _is = require("../../utils/is.js");
+const name = 'column';
+const dependencies = ['typed', 'Index', 'matrix', 'range'];
+
+/**
+ * Attach a transform function to matrix.column
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `index` parameter of function column
+ * from zero-based to one-based
+ */
+const createColumnTransform = exports.createColumnTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    Index,
+    matrix,
+    range
+  } = _ref;
+  const column = (0, _column.createColumn)({
+    typed,
+    Index,
+    matrix,
+    range
+  });
+
+  // @see: comment of column itself
+  return typed('column', {
+    '...any': function (args) {
+      // change last argument from zero-based to one-based
+      const lastIndex = args.length - 1;
+      const last = args[lastIndex];
+      if ((0, _is.isNumber)(last)) {
+        args[lastIndex] = last - 1;
+      }
+      try {
+        return column.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/concat.transform.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConcatTransform = void 0;
+var _is = require("../../utils/is.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _factory = require("../../utils/factory.js");
+var _concat = require("../../function/matrix/concat.js");
+const name = 'concat';
+const dependencies = ['typed', 'matrix', 'isInteger'];
+const createConcatTransform = exports.createConcatTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    isInteger
+  } = _ref;
+  const concat = (0, _concat.createConcat)({
+    typed,
+    matrix,
+    isInteger
+  });
+
+  /**
+   * Attach a transform function to math.range
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function concat
+   * from one-based to zero based
+   */
+  return typed('concat', {
+    '...any': function (args) {
+      // change last argument from one-based to zero-based
+      const lastIndex = args.length - 1;
+      const last = args[lastIndex];
+      if ((0, _is.isNumber)(last)) {
+        args[lastIndex] = last - 1;
+      } else if ((0, _is.isBigNumber)(last)) {
+        args[lastIndex] = last.minus(1);
+      }
+      try {
+        return concat.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/cumsum.transform.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCumSumTransform = void 0;
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _cumsum = require("../../function/statistics/cumsum.js");
+/**
+ * Attach a transform function to math.sum
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function sum
+ * from one-based to zero based
+ */
+const name = 'cumsum';
+const dependencies = ['typed', 'add', 'unaryPlus'];
+const createCumSumTransform = exports.createCumSumTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    add,
+    unaryPlus
+  } = _ref;
+  const cumsum = (0, _cumsum.createCumSum)({
+    typed,
+    add,
+    unaryPlus
+  });
+  return typed(name, {
+    '...any': function (args) {
+      // change last argument dim from one-based to zero-based
+      if (args.length === 2 && (0, _is.isCollection)(args[0])) {
+        const dim = args[1];
+        if ((0, _is.isNumber)(dim)) {
+          args[1] = dim - 1;
+        } else if ((0, _is.isBigNumber)(dim)) {
+          args[1] = dim.minus(1);
+        }
+      }
+      try {
+        return cumsum.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/diff.transform.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDiffTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _diff = require("../../function/matrix/diff.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'diff';
+const dependencies = ['typed', 'matrix', 'subtract', 'number', 'bignumber'];
+const createDiffTransform = exports.createDiffTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    subtract,
+    number,
+    bignumber
+  } = _ref;
+  const diff = (0, _diff.createDiff)({
+    typed,
+    matrix,
+    subtract,
+    number,
+    bignumber
+  });
+
+  /**
+   * Attach a transform function to math.diff
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a range which includes the end value
+   */
+  return typed(name, {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return diff.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/filter.transform.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFilterTransform = void 0;
+var _filter = require("../../function/matrix/filter.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var _compileInlineExpression = require("./utils/compileInlineExpression.js");
+var _transformCallback = require("./utils/transformCallback.js");
+const name = 'filter';
+const dependencies = ['typed'];
+const createFilterTransform = exports.createFilterTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+   * Attach a transform function to math.filter
+   * Adds a property transform containing the transform function.
+   *
+   * This transform adds support for equations as test function for math.filter,
+   * so you can do something like 'filter([3, -2, 5], x > 0)'.
+   */
+  function filterTransform(args, math, scope) {
+    const filter = (0, _filter.createFilter)({
+      typed
+    });
+    const transformCallback = (0, _transformCallback.createTransformCallback)({
+      typed
+    });
+    if (args.length === 0) {
+      return filter();
+    }
+    let x = args[0];
+    if (args.length === 1) {
+      return filter(x);
+    }
+    const N = args.length - 1;
+    let callback = args[N];
+    if (x) {
+      x = _compileAndEvaluate(x, scope);
+    }
+    if (callback) {
+      if ((0, _is.isSymbolNode)(callback) || (0, _is.isFunctionAssignmentNode)(callback)) {
+        // a function pointer, like filter([3, -2, 5], myTestFunction)
+        callback = _compileAndEvaluate(callback, scope);
+      } else {
+        // an expression like filter([3, -2, 5], x > 0)
+        callback = (0, _compileInlineExpression.compileInlineExpression)(callback, math, scope);
+      }
+    }
+    return filter(x, transformCallback(callback, N));
+  }
+  filterTransform.rawArgs = true;
+  function _compileAndEvaluate(arg, scope) {
+    return arg.compile().evaluate(scope);
+  }
+  return filterTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/forEach.transform.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createForEachTransform = void 0;
+var _forEach = require("../../function/matrix/forEach.js");
+var _transformCallback = require("./utils/transformCallback.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var _compileInlineExpression = require("./utils/compileInlineExpression.js");
+const name = 'forEach';
+const dependencies = ['typed'];
+const createForEachTransform = exports.createForEachTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+   * Attach a transform function to math.forEach
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a one-based index instead of a zero-based index
+   */
+  const forEach = (0, _forEach.createForEach)({
+    typed
+  });
+  const transformCallback = (0, _transformCallback.createTransformCallback)({
+    typed
+  });
+  function forEachTransform(args, math, scope) {
+    if (args.length === 0) {
+      return forEach();
+    }
+    let x = args[0];
+    if (args.length === 1) {
+      return forEach(x);
+    }
+    const N = args.length - 1;
+    let callback = args[N];
+    if (x) {
+      x = _compileAndEvaluate(x, scope);
+    }
+    if (callback) {
+      if ((0, _is.isSymbolNode)(callback) || (0, _is.isFunctionAssignmentNode)(callback)) {
+        // a function pointer, like filter([3, -2, 5], myTestFunction)
+        callback = _compileAndEvaluate(callback, scope);
+      } else {
+        // an expression like filter([3, -2, 5], x > 0)
+        callback = (0, _compileInlineExpression.compileInlineExpression)(callback, math, scope);
+      }
+    }
+    return forEach(x, transformCallback(callback, N));
+  }
+  forEachTransform.rawArgs = true;
+  function _compileAndEvaluate(arg, scope) {
+    return arg.compile().evaluate(scope);
+  }
+  return forEachTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/index.transform.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIndexTransform = void 0;
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+const name = 'index';
+const dependencies = ['Index', 'getMatrixDataType'];
+const createIndexTransform = exports.createIndexTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    Index,
+    getMatrixDataType
+  } = _ref;
+  /**
+   * Attach a transform function to math.index
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a one-based index instead of a zero-based index
+   */
+  return function indexTransform() {
+    const args = [];
+    for (let i = 0, ii = arguments.length; i < ii; i++) {
+      let arg = arguments[i];
+
+      // change from one-based to zero based, convert BigNumber to number and leave Array of Booleans as is
+      if ((0, _is.isRange)(arg)) {
+        arg.start--;
+        arg.end -= arg.step > 0 ? 0 : 2;
+      } else if (arg && arg.isSet === true) {
+        arg = arg.map(function (v) {
+          return v - 1;
+        });
+      } else if ((0, _is.isArray)(arg) || (0, _is.isMatrix)(arg)) {
+        if (getMatrixDataType(arg) !== 'boolean') {
+          arg = arg.map(function (v) {
+            return v - 1;
+          });
+        }
+      } else if ((0, _is.isNumber)(arg)) {
+        arg--;
+      } else if ((0, _is.isBigNumber)(arg)) {
+        arg = arg.toNumber() - 1;
+      } else if (typeof arg === 'string') {
+        // leave as is
+      } else {
+        throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
+      }
+      args[i] = arg;
+    }
+    const res = new Index();
+    Index.apply(res, args);
+    return res;
+  };
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/map.transform.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMapTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var _map = require("../../function/matrix/map.js");
+var _compileInlineExpression = require("./utils/compileInlineExpression.js");
+var _transformCallback = require("./utils/transformCallback.js");
+const name = 'map';
+const dependencies = ['typed'];
+const createMapTransform = exports.createMapTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+   * Attach a transform function to math.map
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a one-based index instead of a zero-based index
+   */
+  const map = (0, _map.createMap)({
+    typed
+  });
+  const transformCallback = (0, _transformCallback.createTransformCallback)({
+    typed
+  });
+  function mapTransform(args, math, scope) {
+    if (args.length === 0) {
+      return map();
+    }
+    if (args.length === 1) {
+      return map(args[0]);
+    }
+    const N = args.length - 1;
+    let X = args.slice(0, N);
+    let callback = args[N];
+    X = X.map(arg => _compileAndEvaluate(arg, scope));
+    if (callback) {
+      if ((0, _is.isSymbolNode)(callback) || (0, _is.isFunctionAssignmentNode)(callback)) {
+        // a function pointer, like filter([3, -2, 5], myTestFunction)
+        callback = _compileAndEvaluate(callback, scope);
+      } else {
+        // an expression like filter([3, -2, 5], x > 0)
+        callback = (0, _compileInlineExpression.compileInlineExpression)(callback, math, scope);
+      }
+    }
+    return map(...X, transformCallback(callback, N));
+    function _compileAndEvaluate(arg, scope) {
+      return arg.compile().evaluate(scope);
+    }
+  }
+  mapTransform.rawArgs = true;
+  return mapTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/max.transform.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMaxTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _max = require("../../function/statistics/max.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'max';
+const dependencies = ['typed', 'config', 'numeric', 'larger'];
+const createMaxTransform = exports.createMaxTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    numeric,
+    larger
+  } = _ref;
+  const max = (0, _max.createMax)({
+    typed,
+    config,
+    numeric,
+    larger
+  });
+
+  /**
+   * Attach a transform function to math.max
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function max
+   * from one-based to zero based
+   */
+  return typed('max', {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return max.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/mean.transform.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMeanTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _mean = require("../../function/statistics/mean.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'mean';
+const dependencies = ['typed', 'add', 'divide'];
+const createMeanTransform = exports.createMeanTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    add,
+    divide
+  } = _ref;
+  const mean = (0, _mean.createMean)({
+    typed,
+    add,
+    divide
+  });
+
+  /**
+   * Attach a transform function to math.mean
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function mean
+   * from one-based to zero based
+   */
+  return typed('mean', {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return mean.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/min.transform.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMinTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _min = require("../../function/statistics/min.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'min';
+const dependencies = ['typed', 'config', 'numeric', 'smaller'];
+const createMinTransform = exports.createMinTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    numeric,
+    smaller
+  } = _ref;
+  const min = (0, _min.createMin)({
+    typed,
+    config,
+    numeric,
+    smaller
+  });
+
+  /**
+   * Attach a transform function to math.min
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function min
+   * from one-based to zero based
+   */
+  return typed('min', {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return min.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/or.transform.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOrTransform = void 0;
+var _or = require("../../function/logical/or.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+const name = 'or';
+const dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat'];
+const createOrTransform = exports.createOrTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    equalScalar,
+    DenseMatrix,
+    concat
+  } = _ref;
+  const or = (0, _or.createOr)({
+    typed,
+    matrix,
+    equalScalar,
+    DenseMatrix,
+    concat
+  });
+  function orTransform(args, math, scope) {
+    const condition1 = args[0].compile().evaluate(scope);
+    if (!(0, _is.isCollection)(condition1) && or(condition1, false)) {
+      return true;
+    }
+    const condition2 = args[1].compile().evaluate(scope);
+    return or(condition1, condition2);
+  }
+  orTransform.rawArgs = true;
+  return orTransform;
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/print.transform.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPrintTransform = void 0;
+var _print = require("../../function/string/print.js");
+var _factory = require("../../utils/factory.js");
+var _print2 = require("../../utils/print.js");
+const name = 'print';
+const dependencies = ['typed', 'matrix', 'zeros', 'add'];
+const createPrintTransform = exports.createPrintTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    zeros,
+    add
+  } = _ref;
+  const print = (0, _print.createPrint)({
+    typed,
+    matrix,
+    zeros,
+    add
+  });
+  return typed(name, {
+    'string, Object | Array': function (template, values) {
+      return print(_convertTemplateToZeroBasedIndex(template), values);
+    },
+    'string, Object | Array, number | Object': function (template, values, options) {
+      return print(_convertTemplateToZeroBasedIndex(template), values, options);
+    }
+  });
+  function _convertTemplateToZeroBasedIndex(template) {
+    return template.replace(_print2.printTemplate, x => {
+      const parts = x.slice(1).split('.');
+      const result = parts.map(function (part) {
+        if (!isNaN(part) && part.length > 0) {
+          return parseInt(part) - 1;
+        } else {
+          return part;
+        }
+      });
+      return '$' + result.join('.');
+    });
+  }
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/quantileSeq.transform.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createQuantileSeqTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _quantileSeq = require("../../function/statistics/quantileSeq.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'quantileSeq';
+const dependencies = ['typed', 'bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+
+/**
+ * Attach a transform function to math.quantileSeq
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the `dim` parameter of function std
+ * from one-based to zero based
+ */
+const createQuantileSeqTransform = exports.createQuantileSeqTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    bignumber,
+    add,
+    subtract,
+    divide,
+    multiply,
+    partitionSelect,
+    compare,
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
+  } = _ref;
+  const quantileSeq = (0, _quantileSeq.createQuantileSeq)({
+    typed,
+    bignumber,
+    add,
+    subtract,
+    divide,
+    multiply,
+    partitionSelect,
+    compare,
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
+  });
+  return typed('quantileSeq', {
+    'Array | Matrix, number | BigNumber': quantileSeq,
+    'Array | Matrix, number | BigNumber, number': (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase(dim)),
+    'Array | Matrix, number | BigNumber, boolean': quantileSeq,
+    'Array | Matrix, number | BigNumber, boolean, number': (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase(dim)),
+    'Array | Matrix, Array | Matrix': quantileSeq,
+    'Array | Matrix, Array | Matrix, number': (data, prob, dim) => quantileSeq(data, prob, dimToZeroBase(dim)),
+    'Array | Matrix, Array | Matrix, boolean': quantileSeq,
+    'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => quantileSeq(data, prob, sorted, dimToZeroBase(dim))
+  });
+  function dimToZeroBase(dim) {
+    // TODO: find a better way, maybe lastDimToZeroBase could apply to more cases.
+    return (0, _lastDimToZeroBase.lastDimToZeroBase)([[], dim])[1];
+  }
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/range.transform.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRangeTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _range = require("../../function/matrix/range.js");
+const name = 'range';
+const dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
+const createRangeTransform = exports.createRangeTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    matrix,
+    bignumber,
+    smaller,
+    smallerEq,
+    larger,
+    largerEq,
+    add,
+    isPositive
+  } = _ref;
+  const range = (0, _range.createRange)({
+    typed,
+    config,
+    matrix,
+    bignumber,
+    smaller,
+    smallerEq,
+    larger,
+    largerEq,
+    add,
+    isPositive
+  });
+
+  /**
+   * Attach a transform function to math.range
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a range which includes the end value
+   */
+  return typed('range', {
+    '...any': function (args) {
+      const lastIndex = args.length - 1;
+      const last = args[lastIndex];
+      if (typeof last !== 'boolean') {
+        // append a parameter includeEnd=true
+        args.push(true);
+      }
+      return range.apply(null, args);
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/row.transform.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRowTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _row = require("../../function/matrix/row.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _is = require("../../utils/is.js");
+const name = 'row';
+const dependencies = ['typed', 'Index', 'matrix', 'range'];
+
+/**
+ * Attach a transform function to matrix.column
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `index` parameter of function column
+ * from zero-based to one-based
+ */
+const createRowTransform = exports.createRowTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    Index,
+    matrix,
+    range
+  } = _ref;
+  const row = (0, _row.createRow)({
+    typed,
+    Index,
+    matrix,
+    range
+  });
+
+  // @see: comment of row itself
+  return typed('row', {
+    '...any': function (args) {
+      // change last argument from zero-based to one-based
+      const lastIndex = args.length - 1;
+      const last = args[lastIndex];
+      if ((0, _is.isNumber)(last)) {
+        args[lastIndex] = last - 1;
+      }
+      try {
+        return row.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/std.transform.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStdTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _std = require("../../function/statistics/std.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'std';
+const dependencies = ['typed', 'map', 'sqrt', 'variance'];
+
+/**
+ * Attach a transform function to math.std
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the `dim` parameter of function std
+ * from one-based to zero based
+ */
+const createStdTransform = exports.createStdTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    map,
+    sqrt,
+    variance
+  } = _ref;
+  const std = (0, _std.createStd)({
+    typed,
+    map,
+    sqrt,
+    variance
+  });
+  return typed('std', {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return std.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/subset.transform.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubsetTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _subset = require("../../function/matrix/subset.js");
+const name = 'subset';
+const dependencies = ['typed', 'matrix', 'zeros', 'add'];
+const createSubsetTransform = exports.createSubsetTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    zeros,
+    add
+  } = _ref;
+  const subset = (0, _subset.createSubset)({
+    typed,
+    matrix,
+    zeros,
+    add
+  });
+
+  /**
+   * Attach a transform function to math.subset
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a range which includes the end value
+   */
+  return typed('subset', {
+    '...any': function (args) {
+      try {
+        return subset.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

node_modules/mathjs/lib/cjs/expression/transform/sum.transform.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSumTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _sum = require("../../function/statistics/sum.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+/**
+ * Attach a transform function to math.sum
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function sum
+ * from one-based to zero based
+ */
+const name = 'sum';
+const dependencies = ['typed', 'config', 'add', 'numeric'];
+const createSumTransform = exports.createSumTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    add,
+    numeric
+  } = _ref;
+  const sum = (0, _sum.createSum)({
+    typed,
+    config,
+    add,
+    numeric
+  });
+  return typed(name, {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return sum.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

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

node_modules/mathjs/lib/cjs/expression/transform/variance.transform.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createVarianceTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _variance = require("../../function/statistics/variance.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+const name = 'variance';
+const dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
+
+/**
+ * Attach a transform function to math.var
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the `dim` parameter of function var
+ * from one-based to zero based
+ */
+const createVarianceTransform = exports.createVarianceTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    add,
+    subtract,
+    multiply,
+    divide,
+    apply,
+    isNaN
+  } = _ref;
+  const variance = (0, _variance.createVariance)({
+    typed,
+    add,
+    subtract,
+    multiply,
+    divide,
+    apply,
+    isNaN
+  });
+  return typed(name, {
+    '...any': function (args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return variance.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});