@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/core/function/typed.js

@@ -0,0 +1,389 @@
+/**
+ * Create a typed-function which checks the types of the arguments and
+ * can match them against multiple provided signatures. The typed-function
+ * automatically converts inputs in order to find a matching signature.
+ * Typed functions throw informative errors in case of wrong input arguments.
+ *
+ * See the library [typed-function](https://github.com/josdejong/typed-function)
+ * for detailed documentation.
+ *
+ * Syntax:
+ *
+ *     math.typed(name, signatures) : function
+ *     math.typed(signatures) : function
+ *
+ * Examples:
+ *
+ *     // create a typed function with multiple types per argument (type union)
+ *     const fn2 = typed({
+ *       'number | boolean': function (b) {
+ *         return 'b is a number or boolean'
+ *       },
+ *       'string, number | boolean': function (a, b) {
+ *         return 'a is a string, b is a number or boolean'
+ *       }
+ *     })
+ *
+ *     // create a typed function with an any type argument
+ *     const log = typed({
+ *       'string, any': function (event, data) {
+ *         console.log('event: ' + event + ', data: ' + JSON.stringify(data))
+ *       }
+ *     })
+ *
+ * @param {string} [name]                          Optional name for the typed-function
+ * @param {Object<string, function>} signatures   Object with one or multiple function signatures
+ * @returns {function} The created typed-function.
+ */
+import { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRegExp, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit } from '../../utils/is.js';
+import typedFunction from 'typed-function';
+import { digits } from '../../utils/number.js';
+import { factory } from '../../utils/factory.js';
+import { isMap } from '../../utils/map.js'; // returns a new instance of typed-function
+
+var _createTyped2 = function _createTyped() {
+  // initially, return the original instance of typed-function
+  // consecutively, return a new instance from typed.create.
+  _createTyped2 = typedFunction.create;
+  return typedFunction;
+};
+
+var dependencies = ['?BigNumber', '?Complex', '?DenseMatrix', '?Fraction'];
+/**
+ * Factory function for creating a new typed instance
+ * @param {Object} dependencies   Object with data types like Complex and BigNumber
+ * @returns {Function}
+ */
+
+export var createTyped = /* #__PURE__ */factory('typed', dependencies, function createTyped(_ref) {
+  var {
+    BigNumber,
+    Complex,
+    DenseMatrix,
+    Fraction
+  } = _ref;
+
+  // TODO: typed-function must be able to silently ignore signatures with unknown data types
+  // get a new instance of typed-function
+  var typed = _createTyped2(); // define all types. The order of the types determines in which order function
+  // arguments are type-checked (so for performance it's important to put the
+  // most used types first).
+
+
+  typed.types = [{
+    name: 'number',
+    test: isNumber
+  }, {
+    name: 'Complex',
+    test: isComplex
+  }, {
+    name: 'BigNumber',
+    test: isBigNumber
+  }, {
+    name: 'Fraction',
+    test: isFraction
+  }, {
+    name: 'Unit',
+    test: isUnit
+  }, {
+    name: 'string',
+    test: isString
+  }, {
+    name: 'Chain',
+    test: isChain
+  }, {
+    name: 'Array',
+    test: isArray
+  }, {
+    name: 'Matrix',
+    test: isMatrix
+  }, {
+    name: 'DenseMatrix',
+    test: isDenseMatrix
+  }, {
+    name: 'SparseMatrix',
+    test: isSparseMatrix
+  }, {
+    name: 'Range',
+    test: isRange
+  }, {
+    name: 'Index',
+    test: isIndex
+  }, {
+    name: 'boolean',
+    test: isBoolean
+  }, {
+    name: 'ResultSet',
+    test: isResultSet
+  }, {
+    name: 'Help',
+    test: isHelp
+  }, {
+    name: 'function',
+    test: isFunction
+  }, {
+    name: 'Date',
+    test: isDate
+  }, {
+    name: 'RegExp',
+    test: isRegExp
+  }, {
+    name: 'null',
+    test: isNull
+  }, {
+    name: 'undefined',
+    test: isUndefined
+  }, {
+    name: 'AccessorNode',
+    test: isAccessorNode
+  }, {
+    name: 'ArrayNode',
+    test: isArrayNode
+  }, {
+    name: 'AssignmentNode',
+    test: isAssignmentNode
+  }, {
+    name: 'BlockNode',
+    test: isBlockNode
+  }, {
+    name: 'ConditionalNode',
+    test: isConditionalNode
+  }, {
+    name: 'ConstantNode',
+    test: isConstantNode
+  }, {
+    name: 'FunctionNode',
+    test: isFunctionNode
+  }, {
+    name: 'FunctionAssignmentNode',
+    test: isFunctionAssignmentNode
+  }, {
+    name: 'IndexNode',
+    test: isIndexNode
+  }, {
+    name: 'Node',
+    test: isNode
+  }, {
+    name: 'ObjectNode',
+    test: isObjectNode
+  }, {
+    name: 'OperatorNode',
+    test: isOperatorNode
+  }, {
+    name: 'ParenthesisNode',
+    test: isParenthesisNode
+  }, {
+    name: 'RangeNode',
+    test: isRangeNode
+  }, {
+    name: 'SymbolNode',
+    test: isSymbolNode
+  }, {
+    name: 'Map',
+    test: isMap
+  }, {
+    name: 'Object',
+    test: isObject
+  } // order 'Object' last, it matches on other classes too
+  ];
+  typed.conversions = [{
+    from: 'number',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      if (!BigNumber) {
+        throwNoBignumber(x);
+      } // note: conversion from number to BigNumber can fail if x has >15 digits
+
+
+      if (digits(x) > 15) {
+        throw new TypeError('Cannot implicitly convert a number with >15 significant digits to BigNumber ' + '(value: ' + x + '). ' + 'Use function bignumber(x) to convert to BigNumber.');
+      }
+
+      return new BigNumber(x);
+    }
+  }, {
+    from: 'number',
+    to: 'Complex',
+    convert: function convert(x) {
+      if (!Complex) {
+        throwNoComplex(x);
+      }
+
+      return new Complex(x, 0);
+    }
+  }, {
+    from: 'number',
+    to: 'string',
+    convert: function convert(x) {
+      return x + '';
+    }
+  }, {
+    from: 'BigNumber',
+    to: 'Complex',
+    convert: function convert(x) {
+      if (!Complex) {
+        throwNoComplex(x);
+      }
+
+      return new Complex(x.toNumber(), 0);
+    }
+  }, {
+    from: 'Fraction',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      throw new TypeError('Cannot implicitly convert a Fraction to BigNumber or vice versa. ' + 'Use function bignumber(x) to convert to BigNumber or fraction(x) to convert to Fraction.');
+    }
+  }, {
+    from: 'Fraction',
+    to: 'Complex',
+    convert: function convert(x) {
+      if (!Complex) {
+        throwNoComplex(x);
+      }
+
+      return new Complex(x.valueOf(), 0);
+    }
+  }, {
+    from: 'number',
+    to: 'Fraction',
+    convert: function convert(x) {
+      if (!Fraction) {
+        throwNoFraction(x);
+      }
+
+      var f = new Fraction(x);
+
+      if (f.valueOf() !== x) {
+        throw new TypeError('Cannot implicitly convert a number to a Fraction when there will be a loss of precision ' + '(value: ' + x + '). ' + 'Use function fraction(x) to convert to Fraction.');
+      }
+
+      return f;
+    }
+  }, {
+    // FIXME: add conversion from Fraction to number, for example for `sqrt(fraction(1,3))`
+    //  from: 'Fraction',
+    //  to: 'number',
+    //  convert: function (x) {
+    //    return x.valueOf()
+    //  }
+    // }, {
+    from: 'string',
+    to: 'number',
+    convert: function convert(x) {
+      var n = Number(x);
+
+      if (isNaN(n)) {
+        throw new Error('Cannot convert "' + x + '" to a number');
+      }
+
+      return n;
+    }
+  }, {
+    from: 'string',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      if (!BigNumber) {
+        throwNoBignumber(x);
+      }
+
+      try {
+        return new BigNumber(x);
+      } catch (err) {
+        throw new Error('Cannot convert "' + x + '" to BigNumber');
+      }
+    }
+  }, {
+    from: 'string',
+    to: 'Fraction',
+    convert: function convert(x) {
+      if (!Fraction) {
+        throwNoFraction(x);
+      }
+
+      try {
+        return new Fraction(x);
+      } catch (err) {
+        throw new Error('Cannot convert "' + x + '" to Fraction');
+      }
+    }
+  }, {
+    from: 'string',
+    to: 'Complex',
+    convert: function convert(x) {
+      if (!Complex) {
+        throwNoComplex(x);
+      }
+
+      try {
+        return new Complex(x);
+      } catch (err) {
+        throw new Error('Cannot convert "' + x + '" to Complex');
+      }
+    }
+  }, {
+    from: 'boolean',
+    to: 'number',
+    convert: function convert(x) {
+      return +x;
+    }
+  }, {
+    from: 'boolean',
+    to: 'BigNumber',
+    convert: function convert(x) {
+      if (!BigNumber) {
+        throwNoBignumber(x);
+      }
+
+      return new BigNumber(+x);
+    }
+  }, {
+    from: 'boolean',
+    to: 'Fraction',
+    convert: function convert(x) {
+      if (!Fraction) {
+        throwNoFraction(x);
+      }
+
+      return new Fraction(+x);
+    }
+  }, {
+    from: 'boolean',
+    to: 'string',
+    convert: function convert(x) {
+      return String(x);
+    }
+  }, {
+    from: 'Array',
+    to: 'Matrix',
+    convert: function convert(array) {
+      if (!DenseMatrix) {
+        throwNoMatrix();
+      }
+
+      return new DenseMatrix(array);
+    }
+  }, {
+    from: 'Matrix',
+    to: 'Array',
+    convert: function convert(matrix) {
+      return matrix.valueOf();
+    }
+  }];
+  return typed;
+});
+
+function throwNoBignumber(x) {
+  throw new Error("Cannot convert value ".concat(x, " into a BigNumber: no class 'BigNumber' provided"));
+}
+
+function throwNoComplex(x) {
+  throw new Error("Cannot convert value ".concat(x, " into a Complex number: no class 'Complex' provided"));
+}
+
+function throwNoMatrix() {
+  throw new Error('Cannot convert array into a Matrix: no class \'DenseMatrix\' provided');
+}
+
+function throwNoFraction(x) {
+  throw new Error("Cannot convert value ".concat(x, " into a Fraction, no class 'Fraction' provided."));
+}

package/dist/node_modules/mathjs/lib/esm/defaultInstance.js

@@ -0,0 +1,3 @@
+import * as all from './factoriesAny.js';
+import { create } from './core/create.js';
+export default create(all);

package/dist/node_modules/mathjs/lib/esm/entry/allFactoriesAny.js

@@ -0,0 +1,3 @@
+// creating all factories here in a separate file is needed to get tree-shaking working
+import * as allFactories from '../factoriesAny.js';
+export var all = allFactories;

package/dist/node_modules/mathjs/lib/esm/entry/allFactoriesNumber.js

@@ -0,0 +1,3 @@
+// creating all factories here in a separate file is needed to get tree-shaking working
+import * as allFactories from '../factoriesNumber.js';
+export var all = allFactories;

package/dist/node_modules/mathjs/lib/esm/entry/configReadonly.js

@@ -0,0 +1,16 @@
+import _extends from "@babel/runtime/helpers/extends";
+import { DEFAULT_CONFIG } from '../core/config.js';
+import { MATRIX_OPTIONS, NUMBER_OPTIONS } from '../core/function/config.js'; // create a read-only version of config
+
+export var config = /* #__PURE__ */function config(options) {
+  if (options) {
+    throw new Error('The global config is readonly. \n' + 'Please create a mathjs instance if you want to change the default configuration. \n' + 'Example:\n' + '\n' + '  import { create, all } from \'mathjs\';\n' + '  const mathjs = create(all);\n' + '  mathjs.config({ number: \'BigNumber\' });\n');
+  }
+
+  return Object.freeze(DEFAULT_CONFIG);
+};
+
+_extends(config, DEFAULT_CONFIG, {
+  MATRIX_OPTIONS,
+  NUMBER_OPTIONS
+});

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAbs.generated.js

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAbs } from '../../factoriesAny.js';
+export var absDependencies = {
+  typedDependencies,
+  createAbs
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAccessorNode.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { NodeDependencies } from './dependenciesNode.generated.js';
+import { subsetDependencies } from './dependenciesSubset.generated.js';
+import { createAccessorNode } from '../../factoriesAny.js';
+export var AccessorNodeDependencies = {
+  NodeDependencies,
+  subsetDependencies,
+  createAccessorNode
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAcos.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAcos } from '../../factoriesAny.js';
+export var acosDependencies = {
+  ComplexDependencies,
+  typedDependencies,
+  createAcos
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAcosh.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAcosh } from '../../factoriesAny.js';
+export var acoshDependencies = {
+  ComplexDependencies,
+  typedDependencies,
+  createAcosh
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAcot.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAcot } from '../../factoriesAny.js';
+export var acotDependencies = {
+  BigNumberDependencies,
+  typedDependencies,
+  createAcot
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAcoth.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAcoth } from '../../factoriesAny.js';
+export var acothDependencies = {
+  BigNumberDependencies,
+  ComplexDependencies,
+  typedDependencies,
+  createAcoth
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAcsc.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAcsc } from '../../factoriesAny.js';
+export var acscDependencies = {
+  BigNumberDependencies,
+  ComplexDependencies,
+  typedDependencies,
+  createAcsc
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAcsch.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAcsch } from '../../factoriesAny.js';
+export var acschDependencies = {
+  BigNumberDependencies,
+  typedDependencies,
+  createAcsch
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAdd.generated.js

@@ -0,0 +1,20 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { SparseMatrixDependencies } from './dependenciesSparseMatrixClass.generated.js';
+import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAdd } from '../../factoriesAny.js';
+export var addDependencies = {
+  DenseMatrixDependencies,
+  SparseMatrixDependencies,
+  addScalarDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createAdd
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAddScalar.generated.js

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAddScalar } from '../../factoriesAny.js';
+export var addScalarDependencies = {
+  typedDependencies,
+  createAddScalar
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAnd.generated.js

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { notDependencies } from './dependenciesNot.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { zerosDependencies } from './dependenciesZeros.generated.js';
+import { createAnd } from '../../factoriesAny.js';
+export var andDependencies = {
+  equalScalarDependencies,
+  matrixDependencies,
+  notDependencies,
+  typedDependencies,
+  zerosDependencies,
+  createAnd
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesApply.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createApply } from '../../factoriesAny.js';
+export var applyDependencies = {
+  isIntegerDependencies,
+  typedDependencies,
+  createApply
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesApplyTransform.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createApplyTransform } from '../../factoriesAny.js';
+export var applyTransformDependencies = {
+  isIntegerDependencies,
+  typedDependencies,
+  createApplyTransform
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesArg.generated.js

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createArg } from '../../factoriesAny.js';
+export var argDependencies = {
+  typedDependencies,
+  createArg
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesArrayNode.generated.js

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { NodeDependencies } from './dependenciesNode.generated.js';
+import { createArrayNode } from '../../factoriesAny.js';
+export var ArrayNodeDependencies = {
+  NodeDependencies,
+  createArrayNode
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAsec.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAsec } from '../../factoriesAny.js';
+export var asecDependencies = {
+  BigNumberDependencies,
+  ComplexDependencies,
+  typedDependencies,
+  createAsec
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAsech.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAsech } from '../../factoriesAny.js';
+export var asechDependencies = {
+  BigNumberDependencies,
+  ComplexDependencies,
+  typedDependencies,
+  createAsech
+};

package/dist/node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesAsin.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAsin } from '../../factoriesAny.js';
+export var asinDependencies = {
+  ComplexDependencies,
+  typedDependencies,
+  createAsin
+};