feat:node-modules

node_modules/mathjs/lib/browser/math.js.LICENSE.txt

@@ -0,0 +1,42 @@
+/*!
+ *  decimal.js v10.4.3
+ *  An arbitrary-precision Decimal type for JavaScript.
+ *  https://github.com/MikeMcl/decimal.js
+ *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
+ *  MIT Licence
+ */
+
+/**
+ * @license Fraction.js v4.3.7 31/08/2023
+ * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+ *
+ * Copyright (c) 2023, Robert Eisele (robert@raw.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/
+
+/**
+ * math.js
+ * https://github.com/josdejong/mathjs
+ *
+ * Math.js is an extensive math library for JavaScript and Node.js,
+ * It features real and complex numbers, units, matrices, a large set of
+ * mathematical functions, and a flexible expression parser.
+ *
+ * @version 13.2.3
+ * @date    2024-11-20
+ *
+ * @license
+ * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */

node_modules/mathjs/lib/browser/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

node_modules/mathjs/lib/cjs/constants.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createVersion = exports.createUppercasePi = exports.createUppercaseE = exports.createTrue = exports.createTau = exports.createSQRT2 = exports.createSQRT1_2 = exports.createPi = exports.createPhi = exports.createNull = exports.createNaN = exports.createLOG2E = exports.createLOG10E = exports.createLN2 = exports.createLN10 = exports.createInfinity = exports.createI = exports.createFalse = exports.createE = void 0;
+var _factory = require("./utils/factory.js");
+var _version = require("./version.js");
+var _constants = require("./utils/bignumber/constants.js");
+var _index = require("./plain/number/index.js");
+const createTrue = exports.createTrue = /* #__PURE__ */(0, _factory.factory)('true', [], () => true);
+const createFalse = exports.createFalse = /* #__PURE__ */(0, _factory.factory)('false', [], () => false);
+const createNull = exports.createNull = /* #__PURE__ */(0, _factory.factory)('null', [], () => null);
+const createInfinity = exports.createInfinity = /* #__PURE__ */recreateFactory('Infinity', ['config', '?BigNumber'], _ref => {
+  let {
+    config,
+    BigNumber
+  } = _ref;
+  return config.number === 'BigNumber' ? new BigNumber(Infinity) : Infinity;
+});
+const createNaN = exports.createNaN = /* #__PURE__ */recreateFactory('NaN', ['config', '?BigNumber'], _ref2 => {
+  let {
+    config,
+    BigNumber
+  } = _ref2;
+  return config.number === 'BigNumber' ? new BigNumber(NaN) : NaN;
+});
+const createPi = exports.createPi = /* #__PURE__ */recreateFactory('pi', ['config', '?BigNumber'], _ref3 => {
+  let {
+    config,
+    BigNumber
+  } = _ref3;
+  return config.number === 'BigNumber' ? (0, _constants.createBigNumberPi)(BigNumber) : _index.pi;
+});
+const createTau = exports.createTau = /* #__PURE__ */recreateFactory('tau', ['config', '?BigNumber'], _ref4 => {
+  let {
+    config,
+    BigNumber
+  } = _ref4;
+  return config.number === 'BigNumber' ? (0, _constants.createBigNumberTau)(BigNumber) : _index.tau;
+});
+const createE = exports.createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'], _ref5 => {
+  let {
+    config,
+    BigNumber
+  } = _ref5;
+  return config.number === 'BigNumber' ? (0, _constants.createBigNumberE)(BigNumber) : _index.e;
+});
+
+// golden ratio, (1+sqrt(5))/2
+const createPhi = exports.createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], _ref6 => {
+  let {
+    config,
+    BigNumber
+  } = _ref6;
+  return config.number === 'BigNumber' ? (0, _constants.createBigNumberPhi)(BigNumber) : _index.phi;
+});
+const createLN2 = exports.createLN2 = /* #__PURE__ */recreateFactory('LN2', ['config', '?BigNumber'], _ref7 => {
+  let {
+    config,
+    BigNumber
+  } = _ref7;
+  return config.number === 'BigNumber' ? new BigNumber(2).ln() : Math.LN2;
+});
+const createLN10 = exports.createLN10 = /* #__PURE__ */recreateFactory('LN10', ['config', '?BigNumber'], _ref8 => {
+  let {
+    config,
+    BigNumber
+  } = _ref8;
+  return config.number === 'BigNumber' ? new BigNumber(10).ln() : Math.LN10;
+});
+const createLOG2E = exports.createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?BigNumber'], _ref9 => {
+  let {
+    config,
+    BigNumber
+  } = _ref9;
+  return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(2).ln()) : Math.LOG2E;
+});
+const createLOG10E = exports.createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref10 => {
+  let {
+    config,
+    BigNumber
+  } = _ref10;
+  return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
+});
+const createSQRT1_2 = exports.createSQRT1_2 = /* #__PURE__ */recreateFactory(
+// eslint-disable-line camelcase
+'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
+  let {
+    config,
+    BigNumber
+  } = _ref11;
+  return config.number === 'BigNumber' ? new BigNumber('0.5').sqrt() : Math.SQRT1_2;
+});
+const createSQRT2 = exports.createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref12 => {
+  let {
+    config,
+    BigNumber
+  } = _ref12;
+  return config.number === 'BigNumber' ? new BigNumber(2).sqrt() : Math.SQRT2;
+});
+const createI = exports.createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 => {
+  let {
+    Complex
+  } = _ref13;
+  return Complex.I;
+});
+
+// for backward compatibility with v5
+const createUppercasePi = exports.createUppercasePi = /* #__PURE__ */(0, _factory.factory)('PI', ['pi'], _ref14 => {
+  let {
+    pi
+  } = _ref14;
+  return pi;
+});
+const createUppercaseE = exports.createUppercaseE = /* #__PURE__ */(0, _factory.factory)('E', ['e'], _ref15 => {
+  let {
+    e
+  } = _ref15;
+  return e;
+});
+const createVersion = exports.createVersion = /* #__PURE__ */(0, _factory.factory)('version', [], () => _version.version);
+
+// helper function to create a factory with a flag recreateOnConfigChange
+// idea: allow passing optional properties to be attached to the factory function as 4th argument?
+function recreateFactory(name, dependencies, create) {
+  return (0, _factory.factory)(name, dependencies, create, {
+    recreateOnConfigChange: true
+  });
+}

node_modules/mathjs/lib/cjs/core/config.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_CONFIG = void 0;
+const DEFAULT_CONFIG = exports.DEFAULT_CONFIG = {
+  // minimum relative difference between two compared values,
+  // used by all comparison functions
+  relTol: 1e-12,
+  // minimum absolute difference between two compared values,
+  // used by all comparison functions
+  absTol: 1e-15,
+  // type of default matrix output. Choose 'matrix' (default) or 'array'
+  matrix: 'Matrix',
+  // type of default number output. Choose 'number' (default) 'BigNumber', 'bigint', or 'Fraction'
+  number: 'number',
+  // type of fallback used for config { number: 'bigint' } when a value cannot be represented
+  // in the configured numeric type. Choose 'number' (default) or 'BigNumber'.
+  numberFallback: 'number',
+  // number of significant digits in BigNumbers
+  precision: 64,
+  // predictable output type of functions. When true, output type depends only
+  // on the input types. When false (default), output type can vary depending
+  // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
+  // predictable is false, and returns `NaN` when true.
+  predictable: false,
+  // random seed for seeded pseudo random number generation
+  // null = randomly seed
+  randomSeed: null
+};

node_modules/mathjs/lib/cjs/core/create.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.create = create;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _typedFunction = _interopRequireDefault(require("typed-function"));
+var _ArgumentsError = require("../error/ArgumentsError.js");
+var _DimensionError = require("../error/DimensionError.js");
+var _IndexError = require("../error/IndexError.js");
+var _factory = require("../utils/factory.js");
+var _is = require("../utils/is.js");
+var _object = require("../utils/object.js");
+var emitter = _interopRequireWildcard(require("./../utils/emitter.js"));
+var _config = require("./config.js");
+var _config2 = require("./function/config.js");
+var _import = require("./function/import.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Create a mathjs instance from given factory functions and optionally config
+ *
+ * Usage:
+ *
+ *     const mathjs1 = create({ createAdd, createMultiply, ...})
+ *     const config = { number: 'BigNumber' }
+ *     const mathjs2 = create(all, config)
+ *
+ * @param {Object} [factories] An object with factory functions
+ *                             The object can contain nested objects,
+ *                             all nested objects will be flattened.
+ * @param {Object} [config]    Available options:
+ *                            {number} relTol
+ *                              Minimum relative difference between two
+ *                              compared values, used by all comparison functions.
+ *                            {number} absTol
+ *                              Minimum absolute difference between two
+ *                              compared values, used by all comparison functions.
+ *                            {string} matrix
+ *                              A string 'Matrix' (default) or 'Array'.
+ *                            {string} number
+ *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+ *                            {number} precision
+ *                              The number of significant digits for BigNumbers.
+ *                              Not applicable for Numbers.
+ *                            {boolean} predictable
+ *                              Predictable output type of functions. When true,
+ *                              output type depends only on the input types. When
+ *                              false (default), output type can vary depending
+ *                              on input values. For example `math.sqrt(-4)`
+ *                              returns `complex('2i')` when predictable is false, and
+ *                              returns `NaN` when true.
+ *                            {string} randomSeed
+ *                              Random seed for seeded pseudo random number generator.
+ *                              Set to null to randomly seed.
+ * @returns {Object} Returns a bare-bone math.js instance containing
+ *                   functions:
+ *                   - `import` to add new functions
+ *                   - `config` to change configuration
+ *                   - `on`, `off`, `once`, `emit` for events
+ */
+function create(factories, config) {
+  const configInternal = (0, _extends2.default)({}, _config.DEFAULT_CONFIG, config);
+
+  // simple test for ES5 support
+  if (typeof Object.create !== 'function') {
+    throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.');
+  }
+
+  // create the mathjs instance
+  const math = emitter.mixin({
+    // only here for backward compatibility for legacy factory functions
+    isNumber: _is.isNumber,
+    isComplex: _is.isComplex,
+    isBigNumber: _is.isBigNumber,
+    isBigInt: _is.isBigInt,
+    isFraction: _is.isFraction,
+    isUnit: _is.isUnit,
+    isString: _is.isString,
+    isArray: _is.isArray,
+    isMatrix: _is.isMatrix,
+    isCollection: _is.isCollection,
+    isDenseMatrix: _is.isDenseMatrix,
+    isSparseMatrix: _is.isSparseMatrix,
+    isRange: _is.isRange,
+    isIndex: _is.isIndex,
+    isBoolean: _is.isBoolean,
+    isResultSet: _is.isResultSet,
+    isHelp: _is.isHelp,
+    isFunction: _is.isFunction,
+    isDate: _is.isDate,
+    isRegExp: _is.isRegExp,
+    isObject: _is.isObject,
+    isMap: _is.isMap,
+    isPartitionedMap: _is.isPartitionedMap,
+    isObjectWrappingMap: _is.isObjectWrappingMap,
+    isNull: _is.isNull,
+    isUndefined: _is.isUndefined,
+    isAccessorNode: _is.isAccessorNode,
+    isArrayNode: _is.isArrayNode,
+    isAssignmentNode: _is.isAssignmentNode,
+    isBlockNode: _is.isBlockNode,
+    isConditionalNode: _is.isConditionalNode,
+    isConstantNode: _is.isConstantNode,
+    isFunctionAssignmentNode: _is.isFunctionAssignmentNode,
+    isFunctionNode: _is.isFunctionNode,
+    isIndexNode: _is.isIndexNode,
+    isNode: _is.isNode,
+    isObjectNode: _is.isObjectNode,
+    isOperatorNode: _is.isOperatorNode,
+    isParenthesisNode: _is.isParenthesisNode,
+    isRangeNode: _is.isRangeNode,
+    isRelationalNode: _is.isRelationalNode,
+    isSymbolNode: _is.isSymbolNode,
+    isChain: _is.isChain
+  });
+
+  // load config function and apply provided config
+  math.config = (0, _config2.configFactory)(configInternal, math.emit);
+  math.expression = {
+    transform: {},
+    mathWithTransform: {
+      config: math.config
+    }
+  };
+
+  // cached factories and instances used by function load
+  const legacyFactories = [];
+  const legacyInstances = [];
+
+  /**
+   * Load a function or data type from a factory.
+   * If the function or data type already exists, the existing instance is
+   * returned.
+   * @param {Function} factory
+   * @returns {*}
+   */
+  function load(factory) {
+    if ((0, _factory.isFactory)(factory)) {
+      return factory(math);
+    }
+    const firstProperty = factory[Object.keys(factory)[0]];
+    if ((0, _factory.isFactory)(firstProperty)) {
+      return firstProperty(math);
+    }
+    if (!(0, _object.isLegacyFactory)(factory)) {
+      console.warn('Factory object with properties `type`, `name`, and `factory` expected', factory);
+      throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
+    }
+    const index = legacyFactories.indexOf(factory);
+    let instance;
+    if (index === -1) {
+      // doesn't yet exist
+      if (factory.math === true) {
+        // pass with math namespace
+        instance = factory.factory(math.type, configInternal, load, math.typed, math);
+      } else {
+        instance = factory.factory(math.type, configInternal, load, math.typed);
+      }
+
+      // append to the cache
+      legacyFactories.push(factory);
+      legacyInstances.push(instance);
+    } else {
+      // already existing function, return the cached instance
+      instance = legacyInstances[index];
+    }
+    return instance;
+  }
+  const importedFactories = {};
+
+  // load the import function
+  function lazyTyped() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return math.typed.apply(math.typed, args);
+  }
+  lazyTyped.isTypedFunction = _typedFunction.default.isTypedFunction;
+  const internalImport = (0, _import.importFactory)(lazyTyped, load, math, importedFactories);
+  math.import = internalImport;
+
+  // listen for changes in config, import all functions again when changed
+  // TODO: move this listener into the import function?
+  math.on('config', () => {
+    Object.values(importedFactories).forEach(factory => {
+      if (factory && factory.meta && factory.meta.recreateOnConfigChange) {
+        // FIXME: only re-create when the current instance is the same as was initially created
+        // FIXME: delete the functions/constants before importing them again?
+        internalImport(factory, {
+          override: true
+        });
+      }
+    });
+  });
+
+  // the create function exposed on the mathjs instance is bound to
+  // the factory functions passed before
+  math.create = create.bind(null, factories);
+
+  // export factory function
+  math.factory = _factory.factory;
+
+  // import the factory functions like createAdd as an array instead of object,
+  // else they will get a different naming (`createAdd` instead of `add`).
+  math.import(Object.values((0, _object.deepFlatten)(factories)));
+  math.ArgumentsError = _ArgumentsError.ArgumentsError;
+  math.DimensionError = _DimensionError.DimensionError;
+  math.IndexError = _IndexError.IndexError;
+  return math;
+}

node_modules/mathjs/lib/cjs/core/function/config.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NUMBER_OPTIONS = exports.MATRIX_OPTIONS = void 0;
+exports.configFactory = configFactory;
+var _object = require("../../utils/object.js");
+var _config2 = require("../config.js");
+const MATRIX_OPTIONS = exports.MATRIX_OPTIONS = ['Matrix', 'Array']; // valid values for option matrix
+const NUMBER_OPTIONS = exports.NUMBER_OPTIONS = ['number', 'BigNumber', 'Fraction']; // valid values for option number
+
+function configFactory(config, emit) {
+  /**
+   * Set configuration options for math.js, and get current options.
+   * Will emit a 'config' event, with arguments (curr, prev, changes).
+   *
+   * This function is only available on a mathjs instance created using `create`.
+   *
+   * Syntax:
+   *
+   *     math.config(config: Object): Object
+   *
+   * Examples:
+   *
+   *
+   *     import { create, all } from 'mathjs'
+   *
+   *     // create a mathjs instance
+   *     const math = create(all)
+   *
+   *     math.config().number                // outputs 'number'
+   *     math.evaluate('0.4')                // outputs number 0.4
+   *     math.config({number: 'Fraction'})
+   *     math.evaluate('0.4')                // outputs Fraction 2/5
+   *
+   * @param {Object} [options] Available options:
+   *                            {number} relTol
+   *                              Minimum relative difference between two
+   *                              compared values, used by all comparison functions.
+   *                            {number} absTol
+   *                              Minimum absolute difference between two
+   *                              compared values, used by all comparison functions.
+   *                            {string} matrix
+   *                              A string 'Matrix' (default) or 'Array'.
+   *                            {string} number
+   *                              A string 'number' (default), 'BigNumber', 'bigint', or 'Fraction'
+   *                            {number} precision
+   *                              The number of significant digits for BigNumbers.
+   *                              Not applicable for Numbers.
+   *                            {string} parenthesis
+   *                              How to display parentheses in LaTeX and string
+   *                              output.
+   *                            {string} randomSeed
+   *                              Random seed for seeded pseudo random number generator.
+   *                              Set to null to randomly seed.
+   * @return {Object} Returns the current configuration
+   */
+  function _config(options) {
+    if (options) {
+      if (options.epsilon !== undefined) {
+        // this if is only for backwards compatibility, it can be removed in the future.
+        console.warn('Warning: The configuration option "epsilon" is deprecated. Use "relTol" and "absTol" instead.');
+        const optionsFix = (0, _object.clone)(options);
+        optionsFix.relTol = options.epsilon;
+        optionsFix.absTol = options.epsilon * 1e-3;
+        delete optionsFix.epsilon;
+        return _config(optionsFix);
+      }
+      const prev = (0, _object.clone)(config);
+
+      // validate some of the options
+      validateOption(options, 'matrix', MATRIX_OPTIONS);
+      validateOption(options, 'number', NUMBER_OPTIONS);
+
+      // merge options
+      (0, _object.deepExtend)(config, options);
+      const curr = (0, _object.clone)(config);
+      const changes = (0, _object.clone)(options);
+
+      // emit 'config' event
+      emit('config', curr, prev, changes);
+      return curr;
+    } else {
+      return (0, _object.clone)(config);
+    }
+  }
+
+  // attach the valid options to the function so they can be extended
+  _config.MATRIX_OPTIONS = MATRIX_OPTIONS;
+  _config.NUMBER_OPTIONS = NUMBER_OPTIONS;
+
+  // attach the config properties as readonly properties to the config function
+  Object.keys(_config2.DEFAULT_CONFIG).forEach(key => {
+    Object.defineProperty(_config, key, {
+      get: () => config[key],
+      enumerable: true,
+      configurable: true
+    });
+  });
+  return _config;
+}
+
+/**
+ * Validate an option
+ * @param {Object} options         Object with options
+ * @param {string} name            Name of the option to validate
+ * @param {Array.<string>} values  Array with valid values for this option
+ */
+function validateOption(options, name, values) {
+  if (options[name] !== undefined && !values.includes(options[name])) {
+    // unknown value
+    console.warn('Warning: Unknown value "' + options[name] + '" for configuration option "' + name + '". ' + 'Available options: ' + values.map(value => JSON.stringify(value)).join(', ') + '.');
+  }
+}

node_modules/mathjs/lib/cjs/core/function/import.js

@@ -0,0 +1,331 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.importFactory = importFactory;
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var _object = require("../../utils/object.js");
+var _ArgumentsError = require("../../error/ArgumentsError.js");
+function importFactory(typed, load, math, importedFactories) {
+  /**
+   * Import functions from an object or a module.
+   *
+   * This function is only available on a mathjs instance created using `create`.
+   *
+   * Syntax:
+   *
+   *    math.import(functions)
+   *    math.import(functions, options)
+   *
+   * Where:
+   *
+   * - `functions: Object`
+   *   An object with functions or factories to be imported.
+   * - `options: Object` An object with import options. Available options:
+   *   - `override: boolean`
+   *     If true, existing functions will be overwritten. False by default.
+   *   - `silent: boolean`
+   *     If true, the function will not throw errors on duplicates or invalid
+   *     types. False by default.
+   *   - `wrap: boolean`
+   *     If true, the functions will be wrapped in a wrapper function
+   *     which converts data types like Matrix to primitive data types like Array.
+   *     The wrapper is needed when extending math.js with libraries which do not
+   *     support these data type. False by default.
+   *
+   * Examples:
+   *
+   *    import { create, all } from 'mathjs'
+   *    import * as numbers from 'numbers'
+   *
+   *    // create a mathjs instance
+   *    const math = create(all)
+   *
+   *    // define new functions and variables
+   *    math.import({
+   *      myvalue: 42,
+   *      hello: function (name) {
+   *        return 'hello, ' + name + '!'
+   *      }
+   *    })
+   *
+   *    // use the imported function and variable
+   *    math.myvalue * 2               // 84
+   *    math.hello('user')             // 'hello, user!'
+   *
+   *    // import the npm module 'numbers'
+   *    // (must be installed first with `npm install numbers`)
+   *    math.import(numbers, {wrap: true})
+   *
+   *    math.fibonacci(7) // returns 13
+   *
+   * @param {Object | Array} functions  Object with functions to be imported.
+   * @param {Object} [options]          Import options.
+   */
+  function mathImport(functions, options) {
+    const num = arguments.length;
+    if (num !== 1 && num !== 2) {
+      throw new _ArgumentsError.ArgumentsError('import', num, 1, 2);
+    }
+    if (!options) {
+      options = {};
+    }
+    function flattenImports(flatValues, value, name) {
+      if (Array.isArray(value)) {
+        value.forEach(item => flattenImports(flatValues, item));
+      } else if (typeof value === 'object') {
+        for (const name in value) {
+          if ((0, _object.hasOwnProperty)(value, name)) {
+            flattenImports(flatValues, value[name], name);
+          }
+        }
+      } else if ((0, _factory.isFactory)(value) || name !== undefined) {
+        const flatName = (0, _factory.isFactory)(value) ? isTransformFunctionFactory(value) ? value.fn + '.transform' // TODO: this is ugly
+        : value.fn : name;
+
+        // we allow importing the same function twice if it points to the same implementation
+        if ((0, _object.hasOwnProperty)(flatValues, flatName) && flatValues[flatName] !== value && !options.silent) {
+          throw new Error('Cannot import "' + flatName + '" twice');
+        }
+        flatValues[flatName] = value;
+      } else {
+        if (!options.silent) {
+          throw new TypeError('Factory, Object, or Array expected');
+        }
+      }
+    }
+    const flatValues = {};
+    flattenImports(flatValues, functions);
+    for (const name in flatValues) {
+      if ((0, _object.hasOwnProperty)(flatValues, name)) {
+        // console.log('import', name)
+        const value = flatValues[name];
+        if ((0, _factory.isFactory)(value)) {
+          // we ignore name here and enforce the name of the factory
+          // maybe at some point we do want to allow overriding it
+          // in that case we can implement an option overrideFactoryNames: true
+          _importFactory(value, options);
+        } else if (isSupportedType(value)) {
+          _import(name, value, options);
+        } else {
+          if (!options.silent) {
+            throw new TypeError('Factory, Object, or Array expected');
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Add a property to the math namespace
+   * @param {string} name
+   * @param {*} value
+   * @param {Object} options  See import for a description of the options
+   * @private
+   */
+  function _import(name, value, options) {
+    // TODO: refactor this function, it's to complicated and contains duplicate code
+    if (options.wrap && typeof value === 'function') {
+      // create a wrapper around the function
+      value = _wrap(value);
+    }
+
+    // turn a plain function with a typed-function signature into a typed-function
+    if (hasTypedFunctionSignature(value)) {
+      value = typed(name, {
+        [value.signature]: value
+      });
+    }
+    if (typed.isTypedFunction(math[name]) && typed.isTypedFunction(value)) {
+      if (options.override) {
+        // give the typed function the right name
+        value = typed(name, value.signatures);
+      } else {
+        // merge the existing and typed function
+        value = typed(math[name], value);
+      }
+      math[name] = value;
+      delete importedFactories[name];
+      _importTransform(name, value);
+      math.emit('import', name, function resolver() {
+        return value;
+      });
+      return;
+    }
+    if (math[name] === undefined || options.override) {
+      math[name] = value;
+      delete importedFactories[name];
+      _importTransform(name, value);
+      math.emit('import', name, function resolver() {
+        return value;
+      });
+      return;
+    }
+    if (!options.silent) {
+      throw new Error('Cannot import "' + name + '": already exists');
+    }
+  }
+  function _importTransform(name, value) {
+    if (value && typeof value.transform === 'function') {
+      math.expression.transform[name] = value.transform;
+      if (allowedInExpressions(name)) {
+        math.expression.mathWithTransform[name] = value.transform;
+      }
+    } else {
+      // remove existing transform
+      delete math.expression.transform[name];
+      if (allowedInExpressions(name)) {
+        math.expression.mathWithTransform[name] = value;
+      }
+    }
+  }
+  function _deleteTransform(name) {
+    delete math.expression.transform[name];
+    if (allowedInExpressions(name)) {
+      math.expression.mathWithTransform[name] = math[name];
+    } else {
+      delete math.expression.mathWithTransform[name];
+    }
+  }
+
+  /**
+   * Create a wrapper a round an function which converts the arguments
+   * to their primitive values (like convert a Matrix to Array)
+   * @param {Function} fn
+   * @return {Function} Returns the wrapped function
+   * @private
+   */
+  function _wrap(fn) {
+    const wrapper = function wrapper() {
+      const args = [];
+      for (let i = 0, len = arguments.length; i < len; i++) {
+        const arg = arguments[i];
+        args[i] = arg && arg.valueOf();
+      }
+      return fn.apply(math, args);
+    };
+    if (fn.transform) {
+      wrapper.transform = fn.transform;
+    }
+    return wrapper;
+  }
+
+  /**
+   * Import an instance of a factory into math.js
+   * @param {function(scope: object)} factory
+   * @param {Object} options  See import for a description of the options
+   * @param {string} [name=factory.name] Optional custom name
+   * @private
+   */
+  function _importFactory(factory, options) {
+    let name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : factory.fn;
+    if (name.includes('.')) {
+      throw new Error('Factory name should not contain a nested path. ' + 'Name: ' + JSON.stringify(name));
+    }
+    const namespace = isTransformFunctionFactory(factory) ? math.expression.transform : math;
+    const existingTransform = name in math.expression.transform;
+    const existing = (0, _object.hasOwnProperty)(namespace, name) ? namespace[name] : undefined;
+    const resolver = function () {
+      // collect all dependencies, handle finding both functions and classes and other special cases
+      const dependencies = {};
+      factory.dependencies.map(_factory.stripOptionalNotation).forEach(dependency => {
+        if (dependency.includes('.')) {
+          throw new Error('Factory dependency should not contain a nested path. ' + 'Name: ' + JSON.stringify(dependency));
+        }
+        if (dependency === 'math') {
+          dependencies.math = math;
+        } else if (dependency === 'mathWithTransform') {
+          dependencies.mathWithTransform = math.expression.mathWithTransform;
+        } else if (dependency === 'classes') {
+          // special case for json reviver
+          dependencies.classes = math;
+        } else {
+          dependencies[dependency] = math[dependency];
+        }
+      });
+      const instance = /* #__PURE__ */factory(dependencies);
+      if (instance && typeof instance.transform === 'function') {
+        throw new Error('Transforms cannot be attached to factory functions. ' + 'Please create a separate function for it with export const path = "expression.transform"');
+      }
+      if (existing === undefined || options.override) {
+        return instance;
+      }
+      if (typed.isTypedFunction(existing) && typed.isTypedFunction(instance)) {
+        // merge the existing and new typed function
+        return typed(existing, instance);
+      }
+      if (options.silent) {
+        // keep existing, ignore imported function
+        return existing;
+      } else {
+        throw new Error('Cannot import "' + name + '": already exists');
+      }
+    };
+
+    // TODO: add unit test with non-lazy factory
+    if (!factory.meta || factory.meta.lazy !== false) {
+      (0, _object.lazy)(namespace, name, resolver);
+
+      // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
+      if (existing && existingTransform) {
+        _deleteTransform(name);
+      } else {
+        if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
+          (0, _object.lazy)(math.expression.mathWithTransform, name, () => namespace[name]);
+        }
+      }
+    } else {
+      namespace[name] = resolver();
+
+      // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
+      if (existing && existingTransform) {
+        _deleteTransform(name);
+      } else {
+        if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
+          (0, _object.lazy)(math.expression.mathWithTransform, name, () => namespace[name]);
+        }
+      }
+    }
+
+    // TODO: improve factories, store a list with imports instead which can be re-played
+    importedFactories[name] = factory;
+    math.emit('import', name, resolver);
+  }
+
+  /**
+   * Check whether given object is a type which can be imported
+   * @param {Function | number | string | boolean | null | Unit | Complex} object
+   * @return {boolean}
+   * @private
+   */
+  function isSupportedType(object) {
+    return typeof object === 'function' || typeof object === 'number' || typeof object === 'string' || typeof object === 'boolean' || object === null || (0, _is.isUnit)(object) || (0, _is.isComplex)(object) || (0, _is.isBigNumber)(object) || (0, _is.isFraction)(object) || (0, _is.isMatrix)(object) || Array.isArray(object);
+  }
+  function hasTypedFunctionSignature(fn) {
+    return typeof fn === 'function' && typeof fn.signature === 'string';
+  }
+  function allowedInExpressions(name) {
+    return !(0, _object.hasOwnProperty)(unsafe, name);
+  }
+  function factoryAllowedInExpressions(factory) {
+    return !factory.fn.includes('.') &&
+    // FIXME: make checking on path redundant, check on meta data instead
+    !(0, _object.hasOwnProperty)(unsafe, factory.fn) && (!factory.meta || !factory.meta.isClass);
+  }
+  function isTransformFunctionFactory(factory) {
+    return factory !== undefined && factory.meta !== undefined && factory.meta.isTransformFunction === true || false;
+  }
+
+  // namespaces and functions not available in the parser for safety reasons
+  const unsafe = {
+    expression: true,
+    type: true,
+    docs: true,
+    error: true,
+    json: true,
+    chain: true // chain method not supported. Note that there is a unit chain too.
+  };
+  return mathImport;
+}

node_modules/mathjs/lib/cjs/defaultInstance.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var all = _interopRequireWildcard(require("./factoriesAny.js"));
+var _create = require("./core/create.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = (0, _create.create)(all);

node_modules/mathjs/lib/cjs/entry/allFactoriesAny.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.all = void 0;
+var allFactories = _interopRequireWildcard(require("../factoriesAny.js"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// creating all factories here in a separate file is needed to get tree-shaking working
+
+const all = exports.all = allFactories;

node_modules/mathjs/lib/cjs/entry/allFactoriesNumber.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.all = void 0;
+var allFactories = _interopRequireWildcard(require("../factoriesNumber.js"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// creating all factories here in a separate file is needed to get tree-shaking working
+
+const all = exports.all = allFactories;

node_modules/mathjs/lib/cjs/entry/configReadonly.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.config = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _config = require("../core/config.js");
+var _config2 = require("../core/function/config.js");
+// create a read-only version of config
+const config = function (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(_config.DEFAULT_CONFIG);
+};
+exports.config = config;
+(0, _extends2.default)(config, _config.DEFAULT_CONFIG, {
+  MATRIX_OPTIONS: _config2.MATRIX_OPTIONS,
+  NUMBER_OPTIONS: _config2.NUMBER_OPTIONS
+});

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAbs.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.absDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const absDependencies = exports.absDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAbs: _factoriesAny.createAbs
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAccessorNode.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccessorNodeDependencies = void 0;
+var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
+var _dependenciesSubsetGenerated = require("./dependenciesSubset.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const AccessorNodeDependencies = exports.AccessorNodeDependencies = {
+  NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
+  subsetDependencies: _dependenciesSubsetGenerated.subsetDependencies,
+  createAccessorNode: _factoriesAny.createAccessorNode
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcos.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acosDependencies = void 0;
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const acosDependencies = exports.acosDependencies = {
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAcos: _factoriesAny.createAcos
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcosh.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acoshDependencies = void 0;
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const acoshDependencies = exports.acoshDependencies = {
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAcosh: _factoriesAny.createAcosh
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcot.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acotDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const acotDependencies = exports.acotDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAcot: _factoriesAny.createAcot
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcoth.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acothDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const acothDependencies = exports.acothDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAcoth: _factoriesAny.createAcoth
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcsc.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acscDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const acscDependencies = exports.acscDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAcsc: _factoriesAny.createAcsc
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcsch.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acschDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const acschDependencies = exports.acschDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAcsch: _factoriesAny.createAcsch
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAdd.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDependencies = void 0;
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesSparseMatrixClassGenerated = require("./dependenciesSparseMatrixClass.generated.js");
+var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const addDependencies = exports.addDependencies = {
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  SparseMatrixDependencies: _dependenciesSparseMatrixClassGenerated.SparseMatrixDependencies,
+  addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAdd: _factoriesAny.createAdd
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAddScalar.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addScalarDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const addScalarDependencies = exports.addScalarDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAddScalar: _factoriesAny.createAddScalar
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAnd.generated.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.andDependencies = void 0;
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesNotGenerated = require("./dependenciesNot.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const andDependencies = exports.andDependencies = {
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  notDependencies: _dependenciesNotGenerated.notDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
+  createAnd: _factoriesAny.createAnd
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAndTransform.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.andTransformDependencies = void 0;
+var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesNotGenerated = require("./dependenciesNot.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const andTransformDependencies = exports.andTransformDependencies = {
+  addDependencies: _dependenciesAddGenerated.addDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  notDependencies: _dependenciesNotGenerated.notDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
+  createAndTransform: _factoriesAny.createAndTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesApply.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyDependencies = void 0;
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const applyDependencies = exports.applyDependencies = {
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createApply: _factoriesAny.createApply
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesApplyTransform.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyTransformDependencies = void 0;
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const applyTransformDependencies = exports.applyTransformDependencies = {
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createApplyTransform: _factoriesAny.createApplyTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesArg.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.argDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const argDependencies = exports.argDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createArg: _factoriesAny.createArg
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesArrayNode.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayNodeDependencies = void 0;
+var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ArrayNodeDependencies = exports.ArrayNodeDependencies = {
+  NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
+  createArrayNode: _factoriesAny.createArrayNode
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsec.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asecDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const asecDependencies = exports.asecDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAsec: _factoriesAny.createAsec
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsech.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asechDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const asechDependencies = exports.asechDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAsech: _factoriesAny.createAsech
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsin.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asinDependencies = void 0;
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const asinDependencies = exports.asinDependencies = {
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAsin: _factoriesAny.createAsin
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsinh.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asinhDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const asinhDependencies = exports.asinhDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAsinh: _factoriesAny.createAsinh
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAssignmentNode.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssignmentNodeDependencies = void 0;
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
+var _dependenciesSubsetGenerated = require("./dependenciesSubset.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const AssignmentNodeDependencies = exports.AssignmentNodeDependencies = {
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
+  subsetDependencies: _dependenciesSubsetGenerated.subsetDependencies,
+  createAssignmentNode: _factoriesAny.createAssignmentNode
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtan.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.atanDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const atanDependencies = exports.atanDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAtan: _factoriesAny.createAtan
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtan2.generated.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.atan2Dependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const atan2Dependencies = exports.atan2Dependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAtan2: _factoriesAny.createAtan2
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtanh.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.atanhDependencies = void 0;
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const atanhDependencies = exports.atanhDependencies = {
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createAtanh: _factoriesAny.createAtanh
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtomicMass.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.atomicMassDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const atomicMassDependencies = exports.atomicMassDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createAtomicMass: _factoriesAny.createAtomicMass
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAvogadro.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.avogadroDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const avogadroDependencies = exports.avogadroDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createAvogadro: _factoriesAny.createAvogadro
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBellNumbers.generated.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bellNumbersDependencies = void 0;
+var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
+var _dependenciesStirlingS2Generated = require("./dependenciesStirlingS2.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bellNumbersDependencies = exports.bellNumbersDependencies = {
+  addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
+  stirlingS2Dependencies: _dependenciesStirlingS2Generated.stirlingS2Dependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBellNumbers: _factoriesAny.createBellNumbers
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBigNumberClass.generated.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BigNumberDependencies = void 0;
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const BigNumberDependencies = exports.BigNumberDependencies = {
+  createBigNumberClass: _factoriesAny.createBigNumberClass
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBigint.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bigintDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bigintDependencies = exports.bigintDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBigint: _factoriesAny.createBigint
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBignumber.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bignumberDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bignumberDependencies = exports.bignumberDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBignumber: _factoriesAny.createBignumber
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBin.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.binDependencies = void 0;
+var _dependenciesFormatGenerated = require("./dependenciesFormat.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const binDependencies = exports.binDependencies = {
+  formatDependencies: _dependenciesFormatGenerated.formatDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBin: _factoriesAny.createBin
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitAnd.generated.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitAndDependencies = void 0;
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bitAndDependencies = exports.bitAndDependencies = {
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBitAnd: _factoriesAny.createBitAnd
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitAndTransform.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitAndTransformDependencies = void 0;
+var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesNotGenerated = require("./dependenciesNot.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bitAndTransformDependencies = exports.bitAndTransformDependencies = {
+  addDependencies: _dependenciesAddGenerated.addDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  notDependencies: _dependenciesNotGenerated.notDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
+  createBitAndTransform: _factoriesAny.createBitAndTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitNot.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitNotDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bitNotDependencies = exports.bitNotDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBitNot: _factoriesAny.createBitNot
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitOr.generated.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitOrDependencies = void 0;
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bitOrDependencies = exports.bitOrDependencies = {
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBitOr: _factoriesAny.createBitOr
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitOrTransform.generated.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitOrTransformDependencies = void 0;
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bitOrTransformDependencies = exports.bitOrTransformDependencies = {
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBitOrTransform: _factoriesAny.createBitOrTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitXor.generated.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitXorDependencies = void 0;
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bitXorDependencies = exports.bitXorDependencies = {
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBitXor: _factoriesAny.createBitXor
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBlockNode.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockNodeDependencies = void 0;
+var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
+var _dependenciesResultSetGenerated = require("./dependenciesResultSet.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const BlockNodeDependencies = exports.BlockNodeDependencies = {
+  NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
+  ResultSetDependencies: _dependenciesResultSetGenerated.ResultSetDependencies,
+  createBlockNode: _factoriesAny.createBlockNode
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBohrMagneton.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bohrMagnetonDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bohrMagnetonDependencies = exports.bohrMagnetonDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createBohrMagneton: _factoriesAny.createBohrMagneton
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBohrRadius.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bohrRadiusDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const bohrRadiusDependencies = exports.bohrRadiusDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createBohrRadius: _factoriesAny.createBohrRadius
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBoltzmann.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.boltzmannDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const boltzmannDependencies = exports.boltzmannDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createBoltzmann: _factoriesAny.createBoltzmann
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBoolean.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.booleanDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const booleanDependencies = exports.booleanDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createBoolean: _factoriesAny.createBoolean
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCatalan.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.catalanDependencies = void 0;
+var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
+var _dependenciesCombinationsGenerated = require("./dependenciesCombinations.generated.js");
+var _dependenciesDivideScalarGenerated = require("./dependenciesDivideScalar.generated.js");
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
+var _dependenciesMultiplyScalarGenerated = require("./dependenciesMultiplyScalar.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const catalanDependencies = exports.catalanDependencies = {
+  addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
+  combinationsDependencies: _dependenciesCombinationsGenerated.combinationsDependencies,
+  divideScalarDependencies: _dependenciesDivideScalarGenerated.divideScalarDependencies,
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
+  multiplyScalarDependencies: _dependenciesMultiplyScalarGenerated.multiplyScalarDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCatalan: _factoriesAny.createCatalan
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCbrt.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cbrtDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesFractionClassGenerated = require("./dependenciesFractionClass.generated.js");
+var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesUnaryMinusGenerated = require("./dependenciesUnaryMinus.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cbrtDependencies = exports.cbrtDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  FractionDependencies: _dependenciesFractionClassGenerated.FractionDependencies,
+  isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  unaryMinusDependencies: _dependenciesUnaryMinusGenerated.unaryMinusDependencies,
+  createCbrt: _factoriesAny.createCbrt
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCeil.generated.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ceilDependencies = void 0;
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesRoundGenerated = require("./dependenciesRound.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ceilDependencies = exports.ceilDependencies = {
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  roundDependencies: _dependenciesRoundGenerated.roundDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
+  createCeil: _factoriesAny.createCeil
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesChain.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chainDependencies = void 0;
+var _dependenciesChainClassGenerated = require("./dependenciesChainClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const chainDependencies = exports.chainDependencies = {
+  ChainDependencies: _dependenciesChainClassGenerated.ChainDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createChain: _factoriesAny.createChain
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesChainClass.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChainDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ChainDependencies = exports.ChainDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createChainClass: _factoriesAny.createChainClass
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesClassicalElectronRadius.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.classicalElectronRadiusDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const classicalElectronRadiusDependencies = exports.classicalElectronRadiusDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createClassicalElectronRadius: _factoriesAny.createClassicalElectronRadius
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesClone.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloneDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cloneDependencies = exports.cloneDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createClone: _factoriesAny.createClone
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesColumn.generated.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.columnDependencies = void 0;
+var _dependenciesIndexClassGenerated = require("./dependenciesIndexClass.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesRangeGenerated = require("./dependenciesRange.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const columnDependencies = exports.columnDependencies = {
+  IndexDependencies: _dependenciesIndexClassGenerated.IndexDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  rangeDependencies: _dependenciesRangeGenerated.rangeDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createColumn: _factoriesAny.createColumn
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesColumnTransform.generated.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.columnTransformDependencies = void 0;
+var _dependenciesIndexClassGenerated = require("./dependenciesIndexClass.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesRangeGenerated = require("./dependenciesRange.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const columnTransformDependencies = exports.columnTransformDependencies = {
+  IndexDependencies: _dependenciesIndexClassGenerated.IndexDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  rangeDependencies: _dependenciesRangeGenerated.rangeDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createColumnTransform: _factoriesAny.createColumnTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCombinations.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combinationsDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const combinationsDependencies = exports.combinationsDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCombinations: _factoriesAny.createCombinations
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCombinationsWithRep.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combinationsWithRepDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const combinationsWithRepDependencies = exports.combinationsWithRepDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCombinationsWithRep: _factoriesAny.createCombinationsWithRep
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompare.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
+var _dependenciesFractionClassGenerated = require("./dependenciesFractionClass.generated.js");
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const compareDependencies = exports.compareDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
+  FractionDependencies: _dependenciesFractionClassGenerated.FractionDependencies,
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCompare: _factoriesAny.createCompare
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompareNatural.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareNaturalDependencies = void 0;
+var _dependenciesCompareGenerated = require("./dependenciesCompare.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const compareNaturalDependencies = exports.compareNaturalDependencies = {
+  compareDependencies: _dependenciesCompareGenerated.compareDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCompareNatural: _factoriesAny.createCompareNatural
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompareText.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareTextDependencies = void 0;
+var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const compareTextDependencies = exports.compareTextDependencies = {
+  concatDependencies: _dependenciesConcatGenerated.concatDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCompareText: _factoriesAny.createCompareText
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompile.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compileDependencies = void 0;
+var _dependenciesParseGenerated = require("./dependenciesParse.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const compileDependencies = exports.compileDependencies = {
+  parseDependencies: _dependenciesParseGenerated.parseDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCompile: _factoriesAny.createCompile
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesComplex.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.complexDependencies = void 0;
+var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const complexDependencies = exports.complexDependencies = {
+  ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createComplex: _factoriesAny.createComplex
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesComplexClass.generated.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ComplexDependencies = void 0;
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ComplexDependencies = exports.ComplexDependencies = {
+  createComplexClass: _factoriesAny.createComplexClass
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesComposition.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compositionDependencies = void 0;
+var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
+var _dependenciesCombinationsGenerated = require("./dependenciesCombinations.generated.js");
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
+var _dependenciesIsPositiveGenerated = require("./dependenciesIsPositive.generated.js");
+var _dependenciesLargerGenerated = require("./dependenciesLarger.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const compositionDependencies = exports.compositionDependencies = {
+  addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
+  combinationsDependencies: _dependenciesCombinationsGenerated.combinationsDependencies,
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
+  isPositiveDependencies: _dependenciesIsPositiveGenerated.isPositiveDependencies,
+  largerDependencies: _dependenciesLargerGenerated.largerDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createComposition: _factoriesAny.createComposition
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConcat.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.concatDependencies = void 0;
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const concatDependencies = exports.concatDependencies = {
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createConcat: _factoriesAny.createConcat
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConcatTransform.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.concatTransformDependencies = void 0;
+var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const concatTransformDependencies = exports.concatTransformDependencies = {
+  isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createConcatTransform: _factoriesAny.createConcatTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConditionalNode.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConditionalNodeDependencies = void 0;
+var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ConditionalNodeDependencies = exports.ConditionalNodeDependencies = {
+  NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
+  createConditionalNode: _factoriesAny.createConditionalNode
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConductanceQuantum.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conductanceQuantumDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const conductanceQuantumDependencies = exports.conductanceQuantumDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createConductanceQuantum: _factoriesAny.createConductanceQuantum
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConj.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conjDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const conjDependencies = exports.conjDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createConj: _factoriesAny.createConj
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConstantNode.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConstantNodeDependencies = void 0;
+var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ConstantNodeDependencies = exports.ConstantNodeDependencies = {
+  NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
+  createConstantNode: _factoriesAny.createConstantNode
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCorr.generated.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.corrDependencies = void 0;
+var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
+var _dependenciesDivideGenerated = require("./dependenciesDivide.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesMeanGenerated = require("./dependenciesMean.generated.js");
+var _dependenciesMultiplyGenerated = require("./dependenciesMultiply.generated.js");
+var _dependenciesPowGenerated = require("./dependenciesPow.generated.js");
+var _dependenciesSqrtGenerated = require("./dependenciesSqrt.generated.js");
+var _dependenciesSubtractGenerated = require("./dependenciesSubtract.generated.js");
+var _dependenciesSumGenerated = require("./dependenciesSum.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const corrDependencies = exports.corrDependencies = {
+  addDependencies: _dependenciesAddGenerated.addDependencies,
+  divideDependencies: _dependenciesDivideGenerated.divideDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  meanDependencies: _dependenciesMeanGenerated.meanDependencies,
+  multiplyDependencies: _dependenciesMultiplyGenerated.multiplyDependencies,
+  powDependencies: _dependenciesPowGenerated.powDependencies,
+  sqrtDependencies: _dependenciesSqrtGenerated.sqrtDependencies,
+  subtractDependencies: _dependenciesSubtractGenerated.subtractDependencies,
+  sumDependencies: _dependenciesSumGenerated.sumDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCorr: _factoriesAny.createCorr
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCos.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cosDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cosDependencies = exports.cosDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCos: _factoriesAny.createCos
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCosh.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.coshDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const coshDependencies = exports.coshDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCosh: _factoriesAny.createCosh
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCot.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cotDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cotDependencies = exports.cotDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCot: _factoriesAny.createCot
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCoth.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cothDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cothDependencies = exports.cothDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCoth: _factoriesAny.createCoth
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCoulomb.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.coulombDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const coulombDependencies = exports.coulombDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  createCoulomb: _factoriesAny.createCoulomb
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCount.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.countDependencies = void 0;
+var _dependenciesProdGenerated = require("./dependenciesProd.generated.js");
+var _dependenciesSizeGenerated = require("./dependenciesSize.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const countDependencies = exports.countDependencies = {
+  prodDependencies: _dependenciesProdGenerated.prodDependencies,
+  sizeDependencies: _dependenciesSizeGenerated.sizeDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCount: _factoriesAny.createCount
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCreateUnit.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUnitDependencies = void 0;
+var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const createUnitDependencies = exports.createUnitDependencies = {
+  UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCreateUnit: _factoriesAny.createCreateUnit
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCross.generated.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.crossDependencies = void 0;
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesMultiplyGenerated = require("./dependenciesMultiply.generated.js");
+var _dependenciesSubtractGenerated = require("./dependenciesSubtract.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const crossDependencies = exports.crossDependencies = {
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  multiplyDependencies: _dependenciesMultiplyGenerated.multiplyDependencies,
+  subtractDependencies: _dependenciesSubtractGenerated.subtractDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCross: _factoriesAny.createCross
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCsc.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cscDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cscDependencies = exports.cscDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCsc: _factoriesAny.createCsc
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCsch.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cschDependencies = void 0;
+var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cschDependencies = exports.cschDependencies = {
+  BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCsch: _factoriesAny.createCsch
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCtranspose.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ctransposeDependencies = void 0;
+var _dependenciesConjGenerated = require("./dependenciesConj.generated.js");
+var _dependenciesTransposeGenerated = require("./dependenciesTranspose.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const ctransposeDependencies = exports.ctransposeDependencies = {
+  conjDependencies: _dependenciesConjGenerated.conjDependencies,
+  transposeDependencies: _dependenciesTransposeGenerated.transposeDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCtranspose: _factoriesAny.createCtranspose
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCube.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cubeDependencies = void 0;
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cubeDependencies = exports.cubeDependencies = {
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createCube: _factoriesAny.createCube
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCumSum.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cumsumDependencies = void 0;
+var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesUnaryPlusGenerated = require("./dependenciesUnaryPlus.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cumsumDependencies = exports.cumsumDependencies = {
+  addDependencies: _dependenciesAddGenerated.addDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  unaryPlusDependencies: _dependenciesUnaryPlusGenerated.unaryPlusDependencies,
+  createCumSum: _factoriesAny.createCumSum
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCumSumTransform.generated.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cumsumTransformDependencies = void 0;
+var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesUnaryPlusGenerated = require("./dependenciesUnaryPlus.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const cumsumTransformDependencies = exports.cumsumTransformDependencies = {
+  addDependencies: _dependenciesAddGenerated.addDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  unaryPlusDependencies: _dependenciesUnaryPlusGenerated.unaryPlusDependencies,
+  createCumSumTransform: _factoriesAny.createCumSumTransform
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesDeepEqual.generated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepEqualDependencies = void 0;
+var _dependenciesEqualGenerated = require("./dependenciesEqual.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const deepEqualDependencies = exports.deepEqualDependencies = {
+  equalDependencies: _dependenciesEqualGenerated.equalDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createDeepEqual: _factoriesAny.createDeepEqual
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesDenseMatrixClass.generated.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DenseMatrixDependencies = void 0;
+var _dependenciesMatrixClassGenerated = require("./dependenciesMatrixClass.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const DenseMatrixDependencies = exports.DenseMatrixDependencies = {
+  MatrixDependencies: _dependenciesMatrixClassGenerated.MatrixDependencies,
+  createDenseMatrixClass: _factoriesAny.createDenseMatrixClass
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesDerivative.generated.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.derivativeDependencies = void 0;
+var _dependenciesConstantNodeGenerated = require("./dependenciesConstantNode.generated.js");
+var _dependenciesFunctionNodeGenerated = require("./dependenciesFunctionNode.generated.js");
+var _dependenciesOperatorNodeGenerated = require("./dependenciesOperatorNode.generated.js");
+var _dependenciesParenthesisNodeGenerated = require("./dependenciesParenthesisNode.generated.js");
+var _dependenciesSymbolNodeGenerated = require("./dependenciesSymbolNode.generated.js");
+var _dependenciesEqualGenerated = require("./dependenciesEqual.generated.js");
+var _dependenciesIsZeroGenerated = require("./dependenciesIsZero.generated.js");
+var _dependenciesNumericGenerated = require("./dependenciesNumeric.generated.js");
+var _dependenciesParseGenerated = require("./dependenciesParse.generated.js");
+var _dependenciesSimplifyGenerated = require("./dependenciesSimplify.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const derivativeDependencies = exports.derivativeDependencies = {
+  ConstantNodeDependencies: _dependenciesConstantNodeGenerated.ConstantNodeDependencies,
+  FunctionNodeDependencies: _dependenciesFunctionNodeGenerated.FunctionNodeDependencies,
+  OperatorNodeDependencies: _dependenciesOperatorNodeGenerated.OperatorNodeDependencies,
+  ParenthesisNodeDependencies: _dependenciesParenthesisNodeGenerated.ParenthesisNodeDependencies,
+  SymbolNodeDependencies: _dependenciesSymbolNodeGenerated.SymbolNodeDependencies,
+  equalDependencies: _dependenciesEqualGenerated.equalDependencies,
+  isZeroDependencies: _dependenciesIsZeroGenerated.isZeroDependencies,
+  numericDependencies: _dependenciesNumericGenerated.numericDependencies,
+  parseDependencies: _dependenciesParseGenerated.parseDependencies,
+  simplifyDependencies: _dependenciesSimplifyGenerated.simplifyDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  createDerivative: _factoriesAny.createDerivative
+};

node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesDet.generated.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detDependencies = void 0;
+var _dependenciesDivideScalarGenerated = require("./dependenciesDivideScalar.generated.js");
+var _dependenciesIsZeroGenerated = require("./dependenciesIsZero.generated.js");
+var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
+var _dependenciesMultiplyGenerated = require("./dependenciesMultiply.generated.js");
+var _dependenciesSubtractScalarGenerated = require("./dependenciesSubtractScalar.generated.js");
+var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
+var _dependenciesUnaryMinusGenerated = require("./dependenciesUnaryMinus.generated.js");
+var _factoriesAny = require("../../factoriesAny.js");
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+const detDependencies = exports.detDependencies = {
+  divideScalarDependencies: _dependenciesDivideScalarGenerated.divideScalarDependencies,
+  isZeroDependencies: _dependenciesIsZeroGenerated.isZeroDependencies,
+  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
+  multiplyDependencies: _dependenciesMultiplyGenerated.multiplyDependencies,
+  subtractScalarDependencies: _dependenciesSubtractScalarGenerated.subtractScalarDependencies,
+  typedDependencies: _dependenciesTypedGenerated.typedDependencies,
+  unaryMinusDependencies: _dependenciesUnaryMinusGenerated.unaryMinusDependencies,
+  createDet: _factoriesAny.createDet
+};