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