feat:node-modules

node_modules/mathjs/lib/esm/constants.js

@@ -0,0 +1,124 @@
+import { factory } from './utils/factory.js';
+import { version } from './version.js';
+import { createBigNumberE, createBigNumberPhi, createBigNumberPi, createBigNumberTau } from './utils/bignumber/constants.js';
+import { pi, tau, e, phi } from './plain/number/index.js';
+export var createTrue = /* #__PURE__ */factory('true', [], () => true);
+export var createFalse = /* #__PURE__ */factory('false', [], () => false);
+export var createNull = /* #__PURE__ */factory('null', [], () => null);
+export var createInfinity = /* #__PURE__ */recreateFactory('Infinity', ['config', '?BigNumber'], _ref => {
+  var {
+    config,
+    BigNumber
+  } = _ref;
+  return config.number === 'BigNumber' ? new BigNumber(Infinity) : Infinity;
+});
+export var createNaN = /* #__PURE__ */recreateFactory('NaN', ['config', '?BigNumber'], _ref2 => {
+  var {
+    config,
+    BigNumber
+  } = _ref2;
+  return config.number === 'BigNumber' ? new BigNumber(NaN) : NaN;
+});
+export var createPi = /* #__PURE__ */recreateFactory('pi', ['config', '?BigNumber'], _ref3 => {
+  var {
+    config,
+    BigNumber
+  } = _ref3;
+  return config.number === 'BigNumber' ? createBigNumberPi(BigNumber) : pi;
+});
+export var createTau = /* #__PURE__ */recreateFactory('tau', ['config', '?BigNumber'], _ref4 => {
+  var {
+    config,
+    BigNumber
+  } = _ref4;
+  return config.number === 'BigNumber' ? createBigNumberTau(BigNumber) : tau;
+});
+export var createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'], _ref5 => {
+  var {
+    config,
+    BigNumber
+  } = _ref5;
+  return config.number === 'BigNumber' ? createBigNumberE(BigNumber) : e;
+});
+
+// golden ratio, (1+sqrt(5))/2
+export var createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], _ref6 => {
+  var {
+    config,
+    BigNumber
+  } = _ref6;
+  return config.number === 'BigNumber' ? createBigNumberPhi(BigNumber) : phi;
+});
+export var createLN2 = /* #__PURE__ */recreateFactory('LN2', ['config', '?BigNumber'], _ref7 => {
+  var {
+    config,
+    BigNumber
+  } = _ref7;
+  return config.number === 'BigNumber' ? new BigNumber(2).ln() : Math.LN2;
+});
+export var createLN10 = /* #__PURE__ */recreateFactory('LN10', ['config', '?BigNumber'], _ref8 => {
+  var {
+    config,
+    BigNumber
+  } = _ref8;
+  return config.number === 'BigNumber' ? new BigNumber(10).ln() : Math.LN10;
+});
+export var createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?BigNumber'], _ref9 => {
+  var {
+    config,
+    BigNumber
+  } = _ref9;
+  return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(2).ln()) : Math.LOG2E;
+});
+export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref10 => {
+  var {
+    config,
+    BigNumber
+  } = _ref10;
+  return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
+});
+export var createSQRT1_2 = /* #__PURE__ */recreateFactory(
+// eslint-disable-line camelcase
+'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
+  var {
+    config,
+    BigNumber
+  } = _ref11;
+  return config.number === 'BigNumber' ? new BigNumber('0.5').sqrt() : Math.SQRT1_2;
+});
+export var createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref12 => {
+  var {
+    config,
+    BigNumber
+  } = _ref12;
+  return config.number === 'BigNumber' ? new BigNumber(2).sqrt() : Math.SQRT2;
+});
+export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 => {
+  var {
+    Complex
+  } = _ref13;
+  return Complex.I;
+});
+
+// for backward compatibility with v5
+export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], _ref14 => {
+  var {
+    pi
+  } = _ref14;
+  return pi;
+});
+export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], _ref15 => {
+  var {
+    e
+  } = _ref15;
+  return e;
+});
+export var createVersion = /* #__PURE__ */factory('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 factory(name, dependencies, create, {
+    recreateOnConfigChange: true
+  });
+}

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

@@ -0,0 +1,25 @@
+export var 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/esm/core/create.js

@@ -0,0 +1,205 @@
+import _extends from "@babel/runtime/helpers/extends";
+import typedFunction from 'typed-function';
+import { ArgumentsError } from '../error/ArgumentsError.js';
+import { DimensionError } from '../error/DimensionError.js';
+import { IndexError } from '../error/IndexError.js';
+import { factory, isFactory } from '../utils/factory.js';
+import { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigInt, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMap, isMatrix, isNode, isNull, isNumber, isObject, isObjectNode, isObjectWrappingMap, isOperatorNode, isParenthesisNode, isPartitionedMap, isRange, isRangeNode, isRegExp, isRelationalNode, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit } from '../utils/is.js';
+import { deepFlatten, isLegacyFactory } from '../utils/object.js';
+import * as emitter from './../utils/emitter.js';
+import { DEFAULT_CONFIG } from './config.js';
+import { configFactory } from './function/config.js';
+import { importFactory } from './function/import.js';
+
+/**
+ * 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
+ */
+export function create(factories, config) {
+  var configInternal = _extends({}, 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
+  var math = emitter.mixin({
+    // only here for backward compatibility for legacy factory functions
+    isNumber,
+    isComplex,
+    isBigNumber,
+    isBigInt,
+    isFraction,
+    isUnit,
+    isString,
+    isArray,
+    isMatrix,
+    isCollection,
+    isDenseMatrix,
+    isSparseMatrix,
+    isRange,
+    isIndex,
+    isBoolean,
+    isResultSet,
+    isHelp,
+    isFunction,
+    isDate,
+    isRegExp,
+    isObject,
+    isMap,
+    isPartitionedMap,
+    isObjectWrappingMap,
+    isNull,
+    isUndefined,
+    isAccessorNode,
+    isArrayNode,
+    isAssignmentNode,
+    isBlockNode,
+    isConditionalNode,
+    isConstantNode,
+    isFunctionAssignmentNode,
+    isFunctionNode,
+    isIndexNode,
+    isNode,
+    isObjectNode,
+    isOperatorNode,
+    isParenthesisNode,
+    isRangeNode,
+    isRelationalNode,
+    isSymbolNode,
+    isChain
+  });
+
+  // load config function and apply provided config
+  math.config = configFactory(configInternal, math.emit);
+  math.expression = {
+    transform: {},
+    mathWithTransform: {
+      config: math.config
+    }
+  };
+
+  // cached factories and instances used by function load
+  var legacyFactories = [];
+  var 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 (isFactory(factory)) {
+      return factory(math);
+    }
+    var firstProperty = factory[Object.keys(factory)[0]];
+    if (isFactory(firstProperty)) {
+      return firstProperty(math);
+    }
+    if (!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');
+    }
+    var index = legacyFactories.indexOf(factory);
+    var 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;
+  }
+  var 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.isTypedFunction;
+  var internalImport = 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;
+
+  // 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(deepFlatten(factories)));
+  math.ArgumentsError = ArgumentsError;
+  math.DimensionError = DimensionError;
+  math.IndexError = IndexError;
+  return math;
+}

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

@@ -0,0 +1,108 @@
+import { clone, deepExtend } from '../../utils/object.js';
+import { DEFAULT_CONFIG } from '../config.js';
+export var MATRIX_OPTIONS = ['Matrix', 'Array']; // valid values for option matrix
+export var NUMBER_OPTIONS = ['number', 'BigNumber', 'Fraction']; // valid values for option number
+
+export 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.');
+        var optionsFix = clone(options);
+        optionsFix.relTol = options.epsilon;
+        optionsFix.absTol = options.epsilon * 1e-3;
+        delete optionsFix.epsilon;
+        return _config(optionsFix);
+      }
+      var prev = clone(config);
+
+      // validate some of the options
+      validateOption(options, 'matrix', MATRIX_OPTIONS);
+      validateOption(options, 'number', NUMBER_OPTIONS);
+
+      // merge options
+      deepExtend(config, options);
+      var curr = clone(config);
+      var changes = clone(options);
+
+      // emit 'config' event
+      emit('config', curr, prev, changes);
+      return curr;
+    } else {
+      return 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(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/esm/core/function/import.js

@@ -0,0 +1,325 @@
+import { isBigNumber, isComplex, isFraction, isMatrix, isUnit } from '../../utils/is.js';
+import { isFactory, stripOptionalNotation } from '../../utils/factory.js';
+import { hasOwnProperty, lazy } from '../../utils/object.js';
+import { ArgumentsError } from '../../error/ArgumentsError.js';
+export 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) {
+    var num = arguments.length;
+    if (num !== 1 && num !== 2) {
+      throw new 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 (var _name in value) {
+          if (hasOwnProperty(value, _name)) {
+            flattenImports(flatValues, value[_name], _name);
+          }
+        }
+      } else if (isFactory(value) || name !== undefined) {
+        var flatName = 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 (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');
+        }
+      }
+    }
+    var flatValues = {};
+    flattenImports(flatValues, functions);
+    for (var name in flatValues) {
+      if (hasOwnProperty(flatValues, name)) {
+        // console.log('import', name)
+        var value = flatValues[name];
+        if (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) {
+    var wrapper = function wrapper() {
+      var args = [];
+      for (var i = 0, len = arguments.length; i < len; i++) {
+        var 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) {
+    var 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));
+    }
+    var namespace = isTransformFunctionFactory(factory) ? math.expression.transform : math;
+    var existingTransform = name in math.expression.transform;
+    var existing = hasOwnProperty(namespace, name) ? namespace[name] : undefined;
+    var resolver = function resolver() {
+      // collect all dependencies, handle finding both functions and classes and other special cases
+      var dependencies = {};
+      factory.dependencies.map(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];
+        }
+      });
+      var 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) {
+      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)) {
+          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)) {
+          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 || isUnit(object) || isComplex(object) || isBigNumber(object) || isFraction(object) || isMatrix(object) || Array.isArray(object);
+  }
+  function hasTypedFunctionSignature(fn) {
+    return typeof fn === 'function' && typeof fn.signature === 'string';
+  }
+  function allowedInExpressions(name) {
+    return !hasOwnProperty(unsafe, name);
+  }
+  function factoryAllowedInExpressions(factory) {
+    return !factory.fn.includes('.') &&
+    // FIXME: make checking on path redundant, check on meta data instead
+    !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
+  var 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/esm/defaultInstance.js

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

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

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

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

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

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

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

node_modules/mathjs/lib/esm/entry/dependenciesAny.generated.js

@@ -0,0 +1,367 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+export { absDependencies } from './dependenciesAny/dependenciesAbs.generated.js';
+export { AccessorNodeDependencies } from './dependenciesAny/dependenciesAccessorNode.generated.js';
+export { acosDependencies } from './dependenciesAny/dependenciesAcos.generated.js';
+export { acoshDependencies } from './dependenciesAny/dependenciesAcosh.generated.js';
+export { acotDependencies } from './dependenciesAny/dependenciesAcot.generated.js';
+export { acothDependencies } from './dependenciesAny/dependenciesAcoth.generated.js';
+export { acscDependencies } from './dependenciesAny/dependenciesAcsc.generated.js';
+export { acschDependencies } from './dependenciesAny/dependenciesAcsch.generated.js';
+export { addDependencies } from './dependenciesAny/dependenciesAdd.generated.js';
+export { addScalarDependencies } from './dependenciesAny/dependenciesAddScalar.generated.js';
+export { andDependencies } from './dependenciesAny/dependenciesAnd.generated.js';
+export { andTransformDependencies } from './dependenciesAny/dependenciesAndTransform.generated.js';
+export { applyDependencies } from './dependenciesAny/dependenciesApply.generated.js';
+export { applyTransformDependencies } from './dependenciesAny/dependenciesApplyTransform.generated.js';
+export { argDependencies } from './dependenciesAny/dependenciesArg.generated.js';
+export { ArrayNodeDependencies } from './dependenciesAny/dependenciesArrayNode.generated.js';
+export { asecDependencies } from './dependenciesAny/dependenciesAsec.generated.js';
+export { asechDependencies } from './dependenciesAny/dependenciesAsech.generated.js';
+export { asinDependencies } from './dependenciesAny/dependenciesAsin.generated.js';
+export { asinhDependencies } from './dependenciesAny/dependenciesAsinh.generated.js';
+export { AssignmentNodeDependencies } from './dependenciesAny/dependenciesAssignmentNode.generated.js';
+export { atanDependencies } from './dependenciesAny/dependenciesAtan.generated.js';
+export { atan2Dependencies } from './dependenciesAny/dependenciesAtan2.generated.js';
+export { atanhDependencies } from './dependenciesAny/dependenciesAtanh.generated.js';
+export { atomicMassDependencies } from './dependenciesAny/dependenciesAtomicMass.generated.js';
+export { avogadroDependencies } from './dependenciesAny/dependenciesAvogadro.generated.js';
+export { bellNumbersDependencies } from './dependenciesAny/dependenciesBellNumbers.generated.js';
+export { BigNumberDependencies } from './dependenciesAny/dependenciesBigNumberClass.generated.js';
+export { bigintDependencies } from './dependenciesAny/dependenciesBigint.generated.js';
+export { bignumberDependencies } from './dependenciesAny/dependenciesBignumber.generated.js';
+export { binDependencies } from './dependenciesAny/dependenciesBin.generated.js';
+export { bitAndDependencies } from './dependenciesAny/dependenciesBitAnd.generated.js';
+export { bitAndTransformDependencies } from './dependenciesAny/dependenciesBitAndTransform.generated.js';
+export { bitNotDependencies } from './dependenciesAny/dependenciesBitNot.generated.js';
+export { bitOrDependencies } from './dependenciesAny/dependenciesBitOr.generated.js';
+export { bitOrTransformDependencies } from './dependenciesAny/dependenciesBitOrTransform.generated.js';
+export { bitXorDependencies } from './dependenciesAny/dependenciesBitXor.generated.js';
+export { BlockNodeDependencies } from './dependenciesAny/dependenciesBlockNode.generated.js';
+export { bohrMagnetonDependencies } from './dependenciesAny/dependenciesBohrMagneton.generated.js';
+export { bohrRadiusDependencies } from './dependenciesAny/dependenciesBohrRadius.generated.js';
+export { boltzmannDependencies } from './dependenciesAny/dependenciesBoltzmann.generated.js';
+export { booleanDependencies } from './dependenciesAny/dependenciesBoolean.generated.js';
+export { catalanDependencies } from './dependenciesAny/dependenciesCatalan.generated.js';
+export { cbrtDependencies } from './dependenciesAny/dependenciesCbrt.generated.js';
+export { ceilDependencies } from './dependenciesAny/dependenciesCeil.generated.js';
+export { chainDependencies } from './dependenciesAny/dependenciesChain.generated.js';
+export { ChainDependencies } from './dependenciesAny/dependenciesChainClass.generated.js';
+export { classicalElectronRadiusDependencies } from './dependenciesAny/dependenciesClassicalElectronRadius.generated.js';
+export { cloneDependencies } from './dependenciesAny/dependenciesClone.generated.js';
+export { columnDependencies } from './dependenciesAny/dependenciesColumn.generated.js';
+export { columnTransformDependencies } from './dependenciesAny/dependenciesColumnTransform.generated.js';
+export { combinationsDependencies } from './dependenciesAny/dependenciesCombinations.generated.js';
+export { combinationsWithRepDependencies } from './dependenciesAny/dependenciesCombinationsWithRep.generated.js';
+export { compareDependencies } from './dependenciesAny/dependenciesCompare.generated.js';
+export { compareNaturalDependencies } from './dependenciesAny/dependenciesCompareNatural.generated.js';
+export { compareTextDependencies } from './dependenciesAny/dependenciesCompareText.generated.js';
+export { compileDependencies } from './dependenciesAny/dependenciesCompile.generated.js';
+export { complexDependencies } from './dependenciesAny/dependenciesComplex.generated.js';
+export { ComplexDependencies } from './dependenciesAny/dependenciesComplexClass.generated.js';
+export { compositionDependencies } from './dependenciesAny/dependenciesComposition.generated.js';
+export { concatDependencies } from './dependenciesAny/dependenciesConcat.generated.js';
+export { concatTransformDependencies } from './dependenciesAny/dependenciesConcatTransform.generated.js';
+export { ConditionalNodeDependencies } from './dependenciesAny/dependenciesConditionalNode.generated.js';
+export { conductanceQuantumDependencies } from './dependenciesAny/dependenciesConductanceQuantum.generated.js';
+export { conjDependencies } from './dependenciesAny/dependenciesConj.generated.js';
+export { ConstantNodeDependencies } from './dependenciesAny/dependenciesConstantNode.generated.js';
+export { corrDependencies } from './dependenciesAny/dependenciesCorr.generated.js';
+export { cosDependencies } from './dependenciesAny/dependenciesCos.generated.js';
+export { coshDependencies } from './dependenciesAny/dependenciesCosh.generated.js';
+export { cotDependencies } from './dependenciesAny/dependenciesCot.generated.js';
+export { cothDependencies } from './dependenciesAny/dependenciesCoth.generated.js';
+export { coulombDependencies } from './dependenciesAny/dependenciesCoulomb.generated.js';
+export { countDependencies } from './dependenciesAny/dependenciesCount.generated.js';
+export { createUnitDependencies } from './dependenciesAny/dependenciesCreateUnit.generated.js';
+export { crossDependencies } from './dependenciesAny/dependenciesCross.generated.js';
+export { cscDependencies } from './dependenciesAny/dependenciesCsc.generated.js';
+export { cschDependencies } from './dependenciesAny/dependenciesCsch.generated.js';
+export { ctransposeDependencies } from './dependenciesAny/dependenciesCtranspose.generated.js';
+export { cubeDependencies } from './dependenciesAny/dependenciesCube.generated.js';
+export { cumsumDependencies } from './dependenciesAny/dependenciesCumSum.generated.js';
+export { cumsumTransformDependencies } from './dependenciesAny/dependenciesCumSumTransform.generated.js';
+export { deepEqualDependencies } from './dependenciesAny/dependenciesDeepEqual.generated.js';
+export { DenseMatrixDependencies } from './dependenciesAny/dependenciesDenseMatrixClass.generated.js';
+export { derivativeDependencies } from './dependenciesAny/dependenciesDerivative.generated.js';
+export { detDependencies } from './dependenciesAny/dependenciesDet.generated.js';
+export { deuteronMassDependencies } from './dependenciesAny/dependenciesDeuteronMass.generated.js';
+export { diagDependencies } from './dependenciesAny/dependenciesDiag.generated.js';
+export { diffDependencies } from './dependenciesAny/dependenciesDiff.generated.js';
+export { diffTransformDependencies } from './dependenciesAny/dependenciesDiffTransform.generated.js';
+export { distanceDependencies } from './dependenciesAny/dependenciesDistance.generated.js';
+export { divideDependencies } from './dependenciesAny/dependenciesDivide.generated.js';
+export { divideScalarDependencies } from './dependenciesAny/dependenciesDivideScalar.generated.js';
+export { dotDependencies } from './dependenciesAny/dependenciesDot.generated.js';
+export { dotDivideDependencies } from './dependenciesAny/dependenciesDotDivide.generated.js';
+export { dotMultiplyDependencies } from './dependenciesAny/dependenciesDotMultiply.generated.js';
+export { dotPowDependencies } from './dependenciesAny/dependenciesDotPow.generated.js';
+export { eDependencies } from './dependenciesAny/dependenciesE.generated.js';
+export { efimovFactorDependencies } from './dependenciesAny/dependenciesEfimovFactor.generated.js';
+export { eigsDependencies } from './dependenciesAny/dependenciesEigs.generated.js';
+export { electricConstantDependencies } from './dependenciesAny/dependenciesElectricConstant.generated.js';
+export { electronMassDependencies } from './dependenciesAny/dependenciesElectronMass.generated.js';
+export { elementaryChargeDependencies } from './dependenciesAny/dependenciesElementaryCharge.generated.js';
+export { equalDependencies } from './dependenciesAny/dependenciesEqual.generated.js';
+export { equalScalarDependencies } from './dependenciesAny/dependenciesEqualScalar.generated.js';
+export { equalTextDependencies } from './dependenciesAny/dependenciesEqualText.generated.js';
+export { erfDependencies } from './dependenciesAny/dependenciesErf.generated.js';
+export { evaluateDependencies } from './dependenciesAny/dependenciesEvaluate.generated.js';
+export { expDependencies } from './dependenciesAny/dependenciesExp.generated.js';
+export { expmDependencies } from './dependenciesAny/dependenciesExpm.generated.js';
+export { expm1Dependencies } from './dependenciesAny/dependenciesExpm1.generated.js';
+export { factorialDependencies } from './dependenciesAny/dependenciesFactorial.generated.js';
+export { falseDependencies } from './dependenciesAny/dependenciesFalse.generated.js';
+export { faradayDependencies } from './dependenciesAny/dependenciesFaraday.generated.js';
+export { fermiCouplingDependencies } from './dependenciesAny/dependenciesFermiCoupling.generated.js';
+export { fftDependencies } from './dependenciesAny/dependenciesFft.generated.js';
+export { FibonacciHeapDependencies } from './dependenciesAny/dependenciesFibonacciHeapClass.generated.js';
+export { filterDependencies } from './dependenciesAny/dependenciesFilter.generated.js';
+export { filterTransformDependencies } from './dependenciesAny/dependenciesFilterTransform.generated.js';
+export { fineStructureDependencies } from './dependenciesAny/dependenciesFineStructure.generated.js';
+export { firstRadiationDependencies } from './dependenciesAny/dependenciesFirstRadiation.generated.js';
+export { fixDependencies } from './dependenciesAny/dependenciesFix.generated.js';
+export { flattenDependencies } from './dependenciesAny/dependenciesFlatten.generated.js';
+export { floorDependencies } from './dependenciesAny/dependenciesFloor.generated.js';
+export { forEachDependencies } from './dependenciesAny/dependenciesForEach.generated.js';
+export { forEachTransformDependencies } from './dependenciesAny/dependenciesForEachTransform.generated.js';
+export { formatDependencies } from './dependenciesAny/dependenciesFormat.generated.js';
+export { fractionDependencies } from './dependenciesAny/dependenciesFraction.generated.js';
+export { FractionDependencies } from './dependenciesAny/dependenciesFractionClass.generated.js';
+export { freqzDependencies } from './dependenciesAny/dependenciesFreqz.generated.js';
+export { FunctionAssignmentNodeDependencies } from './dependenciesAny/dependenciesFunctionAssignmentNode.generated.js';
+export { FunctionNodeDependencies } from './dependenciesAny/dependenciesFunctionNode.generated.js';
+export { gammaDependencies } from './dependenciesAny/dependenciesGamma.generated.js';
+export { gasConstantDependencies } from './dependenciesAny/dependenciesGasConstant.generated.js';
+export { gcdDependencies } from './dependenciesAny/dependenciesGcd.generated.js';
+export { getMatrixDataTypeDependencies } from './dependenciesAny/dependenciesGetMatrixDataType.generated.js';
+export { gravitationConstantDependencies } from './dependenciesAny/dependenciesGravitationConstant.generated.js';
+export { gravityDependencies } from './dependenciesAny/dependenciesGravity.generated.js';
+export { hartreeEnergyDependencies } from './dependenciesAny/dependenciesHartreeEnergy.generated.js';
+export { hasNumericValueDependencies } from './dependenciesAny/dependenciesHasNumericValue.generated.js';
+export { helpDependencies } from './dependenciesAny/dependenciesHelp.generated.js';
+export { HelpDependencies } from './dependenciesAny/dependenciesHelpClass.generated.js';
+export { hexDependencies } from './dependenciesAny/dependenciesHex.generated.js';
+export { hypotDependencies } from './dependenciesAny/dependenciesHypot.generated.js';
+export { iDependencies } from './dependenciesAny/dependenciesI.generated.js';
+export { identityDependencies } from './dependenciesAny/dependenciesIdentity.generated.js';
+export { ifftDependencies } from './dependenciesAny/dependenciesIfft.generated.js';
+export { imDependencies } from './dependenciesAny/dependenciesIm.generated.js';
+export { ImmutableDenseMatrixDependencies } from './dependenciesAny/dependenciesImmutableDenseMatrixClass.generated.js';
+export { indexDependencies } from './dependenciesAny/dependenciesIndex.generated.js';
+export { IndexDependencies } from './dependenciesAny/dependenciesIndexClass.generated.js';
+export { IndexNodeDependencies } from './dependenciesAny/dependenciesIndexNode.generated.js';
+export { indexTransformDependencies } from './dependenciesAny/dependenciesIndexTransform.generated.js';
+export { InfinityDependencies } from './dependenciesAny/dependenciesInfinity.generated.js';
+export { intersectDependencies } from './dependenciesAny/dependenciesIntersect.generated.js';
+export { invDependencies } from './dependenciesAny/dependenciesInv.generated.js';
+export { inverseConductanceQuantumDependencies } from './dependenciesAny/dependenciesInverseConductanceQuantum.generated.js';
+export { invmodDependencies } from './dependenciesAny/dependenciesInvmod.generated.js';
+export { isIntegerDependencies } from './dependenciesAny/dependenciesIsInteger.generated.js';
+export { isNaNDependencies } from './dependenciesAny/dependenciesIsNaN.generated.js';
+export { isNegativeDependencies } from './dependenciesAny/dependenciesIsNegative.generated.js';
+export { isNumericDependencies } from './dependenciesAny/dependenciesIsNumeric.generated.js';
+export { isPositiveDependencies } from './dependenciesAny/dependenciesIsPositive.generated.js';
+export { isPrimeDependencies } from './dependenciesAny/dependenciesIsPrime.generated.js';
+export { isZeroDependencies } from './dependenciesAny/dependenciesIsZero.generated.js';
+export { kldivergenceDependencies } from './dependenciesAny/dependenciesKldivergence.generated.js';
+export { klitzingDependencies } from './dependenciesAny/dependenciesKlitzing.generated.js';
+export { kronDependencies } from './dependenciesAny/dependenciesKron.generated.js';
+export { LN10Dependencies } from './dependenciesAny/dependenciesLN10.generated.js';
+export { LN2Dependencies } from './dependenciesAny/dependenciesLN2.generated.js';
+export { LOG10EDependencies } from './dependenciesAny/dependenciesLOG10E.generated.js';
+export { LOG2EDependencies } from './dependenciesAny/dependenciesLOG2E.generated.js';
+export { largerDependencies } from './dependenciesAny/dependenciesLarger.generated.js';
+export { largerEqDependencies } from './dependenciesAny/dependenciesLargerEq.generated.js';
+export { lcmDependencies } from './dependenciesAny/dependenciesLcm.generated.js';
+export { leafCountDependencies } from './dependenciesAny/dependenciesLeafCount.generated.js';
+export { leftShiftDependencies } from './dependenciesAny/dependenciesLeftShift.generated.js';
+export { lgammaDependencies } from './dependenciesAny/dependenciesLgamma.generated.js';
+export { logDependencies } from './dependenciesAny/dependenciesLog.generated.js';
+export { log10Dependencies } from './dependenciesAny/dependenciesLog10.generated.js';
+export { log1pDependencies } from './dependenciesAny/dependenciesLog1p.generated.js';
+export { log2Dependencies } from './dependenciesAny/dependenciesLog2.generated.js';
+export { loschmidtDependencies } from './dependenciesAny/dependenciesLoschmidt.generated.js';
+export { lsolveDependencies } from './dependenciesAny/dependenciesLsolve.generated.js';
+export { lsolveAllDependencies } from './dependenciesAny/dependenciesLsolveAll.generated.js';
+export { lupDependencies } from './dependenciesAny/dependenciesLup.generated.js';
+export { lusolveDependencies } from './dependenciesAny/dependenciesLusolve.generated.js';
+export { lyapDependencies } from './dependenciesAny/dependenciesLyap.generated.js';
+export { madDependencies } from './dependenciesAny/dependenciesMad.generated.js';
+export { magneticConstantDependencies } from './dependenciesAny/dependenciesMagneticConstant.generated.js';
+export { magneticFluxQuantumDependencies } from './dependenciesAny/dependenciesMagneticFluxQuantum.generated.js';
+export { mapDependencies } from './dependenciesAny/dependenciesMap.generated.js';
+export { mapTransformDependencies } from './dependenciesAny/dependenciesMapTransform.generated.js';
+export { matrixDependencies } from './dependenciesAny/dependenciesMatrix.generated.js';
+export { MatrixDependencies } from './dependenciesAny/dependenciesMatrixClass.generated.js';
+export { matrixFromColumnsDependencies } from './dependenciesAny/dependenciesMatrixFromColumns.generated.js';
+export { matrixFromFunctionDependencies } from './dependenciesAny/dependenciesMatrixFromFunction.generated.js';
+export { matrixFromRowsDependencies } from './dependenciesAny/dependenciesMatrixFromRows.generated.js';
+export { maxDependencies } from './dependenciesAny/dependenciesMax.generated.js';
+export { maxTransformDependencies } from './dependenciesAny/dependenciesMaxTransform.generated.js';
+export { meanDependencies } from './dependenciesAny/dependenciesMean.generated.js';
+export { meanTransformDependencies } from './dependenciesAny/dependenciesMeanTransform.generated.js';
+export { medianDependencies } from './dependenciesAny/dependenciesMedian.generated.js';
+export { minDependencies } from './dependenciesAny/dependenciesMin.generated.js';
+export { minTransformDependencies } from './dependenciesAny/dependenciesMinTransform.generated.js';
+export { modDependencies } from './dependenciesAny/dependenciesMod.generated.js';
+export { modeDependencies } from './dependenciesAny/dependenciesMode.generated.js';
+export { molarMassDependencies } from './dependenciesAny/dependenciesMolarMass.generated.js';
+export { molarMassC12Dependencies } from './dependenciesAny/dependenciesMolarMassC12.generated.js';
+export { molarPlanckConstantDependencies } from './dependenciesAny/dependenciesMolarPlanckConstant.generated.js';
+export { molarVolumeDependencies } from './dependenciesAny/dependenciesMolarVolume.generated.js';
+export { multinomialDependencies } from './dependenciesAny/dependenciesMultinomial.generated.js';
+export { multiplyDependencies } from './dependenciesAny/dependenciesMultiply.generated.js';
+export { multiplyScalarDependencies } from './dependenciesAny/dependenciesMultiplyScalar.generated.js';
+export { NaNDependencies } from './dependenciesAny/dependenciesNaN.generated.js';
+export { neutronMassDependencies } from './dependenciesAny/dependenciesNeutronMass.generated.js';
+export { NodeDependencies } from './dependenciesAny/dependenciesNode.generated.js';
+export { normDependencies } from './dependenciesAny/dependenciesNorm.generated.js';
+export { notDependencies } from './dependenciesAny/dependenciesNot.generated.js';
+export { nthRootDependencies } from './dependenciesAny/dependenciesNthRoot.generated.js';
+export { nthRootsDependencies } from './dependenciesAny/dependenciesNthRoots.generated.js';
+export { nuclearMagnetonDependencies } from './dependenciesAny/dependenciesNuclearMagneton.generated.js';
+export { nullDependencies } from './dependenciesAny/dependenciesNull.generated.js';
+export { numberDependencies } from './dependenciesAny/dependenciesNumber.generated.js';
+export { numericDependencies } from './dependenciesAny/dependenciesNumeric.generated.js';
+export { ObjectNodeDependencies } from './dependenciesAny/dependenciesObjectNode.generated.js';
+export { octDependencies } from './dependenciesAny/dependenciesOct.generated.js';
+export { onesDependencies } from './dependenciesAny/dependenciesOnes.generated.js';
+export { OperatorNodeDependencies } from './dependenciesAny/dependenciesOperatorNode.generated.js';
+export { orDependencies } from './dependenciesAny/dependenciesOr.generated.js';
+export { orTransformDependencies } from './dependenciesAny/dependenciesOrTransform.generated.js';
+export { ParenthesisNodeDependencies } from './dependenciesAny/dependenciesParenthesisNode.generated.js';
+export { parseDependencies } from './dependenciesAny/dependenciesParse.generated.js';
+export { parserDependencies } from './dependenciesAny/dependenciesParser.generated.js';
+export { ParserDependencies } from './dependenciesAny/dependenciesParserClass.generated.js';
+export { partitionSelectDependencies } from './dependenciesAny/dependenciesPartitionSelect.generated.js';
+export { permutationsDependencies } from './dependenciesAny/dependenciesPermutations.generated.js';
+export { phiDependencies } from './dependenciesAny/dependenciesPhi.generated.js';
+export { piDependencies } from './dependenciesAny/dependenciesPi.generated.js';
+export { pickRandomDependencies } from './dependenciesAny/dependenciesPickRandom.generated.js';
+export { pinvDependencies } from './dependenciesAny/dependenciesPinv.generated.js';
+export { planckChargeDependencies } from './dependenciesAny/dependenciesPlanckCharge.generated.js';
+export { planckConstantDependencies } from './dependenciesAny/dependenciesPlanckConstant.generated.js';
+export { planckLengthDependencies } from './dependenciesAny/dependenciesPlanckLength.generated.js';
+export { planckMassDependencies } from './dependenciesAny/dependenciesPlanckMass.generated.js';
+export { planckTemperatureDependencies } from './dependenciesAny/dependenciesPlanckTemperature.generated.js';
+export { planckTimeDependencies } from './dependenciesAny/dependenciesPlanckTime.generated.js';
+export { polynomialRootDependencies } from './dependenciesAny/dependenciesPolynomialRoot.generated.js';
+export { powDependencies } from './dependenciesAny/dependenciesPow.generated.js';
+export { printDependencies } from './dependenciesAny/dependenciesPrint.generated.js';
+export { printTransformDependencies } from './dependenciesAny/dependenciesPrintTransform.generated.js';
+export { prodDependencies } from './dependenciesAny/dependenciesProd.generated.js';
+export { protonMassDependencies } from './dependenciesAny/dependenciesProtonMass.generated.js';
+export { qrDependencies } from './dependenciesAny/dependenciesQr.generated.js';
+export { quantileSeqDependencies } from './dependenciesAny/dependenciesQuantileSeq.generated.js';
+export { quantileSeqTransformDependencies } from './dependenciesAny/dependenciesQuantileSeqTransform.generated.js';
+export { quantumOfCirculationDependencies } from './dependenciesAny/dependenciesQuantumOfCirculation.generated.js';
+export { randomDependencies } from './dependenciesAny/dependenciesRandom.generated.js';
+export { randomIntDependencies } from './dependenciesAny/dependenciesRandomInt.generated.js';
+export { rangeDependencies } from './dependenciesAny/dependenciesRange.generated.js';
+export { RangeDependencies } from './dependenciesAny/dependenciesRangeClass.generated.js';
+export { RangeNodeDependencies } from './dependenciesAny/dependenciesRangeNode.generated.js';
+export { rangeTransformDependencies } from './dependenciesAny/dependenciesRangeTransform.generated.js';
+export { rationalizeDependencies } from './dependenciesAny/dependenciesRationalize.generated.js';
+export { reDependencies } from './dependenciesAny/dependenciesRe.generated.js';
+export { reducedPlanckConstantDependencies } from './dependenciesAny/dependenciesReducedPlanckConstant.generated.js';
+export { RelationalNodeDependencies } from './dependenciesAny/dependenciesRelationalNode.generated.js';
+export { replacerDependencies } from './dependenciesAny/dependenciesReplacer.generated.js';
+export { reshapeDependencies } from './dependenciesAny/dependenciesReshape.generated.js';
+export { resizeDependencies } from './dependenciesAny/dependenciesResize.generated.js';
+export { resolveDependencies } from './dependenciesAny/dependenciesResolve.generated.js';
+export { ResultSetDependencies } from './dependenciesAny/dependenciesResultSet.generated.js';
+export { reviverDependencies } from './dependenciesAny/dependenciesReviver.generated.js';
+export { rightArithShiftDependencies } from './dependenciesAny/dependenciesRightArithShift.generated.js';
+export { rightLogShiftDependencies } from './dependenciesAny/dependenciesRightLogShift.generated.js';
+export { rotateDependencies } from './dependenciesAny/dependenciesRotate.generated.js';
+export { rotationMatrixDependencies } from './dependenciesAny/dependenciesRotationMatrix.generated.js';
+export { roundDependencies } from './dependenciesAny/dependenciesRound.generated.js';
+export { rowDependencies } from './dependenciesAny/dependenciesRow.generated.js';
+export { rowTransformDependencies } from './dependenciesAny/dependenciesRowTransform.generated.js';
+export { rydbergDependencies } from './dependenciesAny/dependenciesRydberg.generated.js';
+export { SQRT1_2Dependencies } from './dependenciesAny/dependenciesSQRT1_2.generated.js'; // eslint-disable-line camelcase
+export { SQRT2Dependencies } from './dependenciesAny/dependenciesSQRT2.generated.js';
+export { sackurTetrodeDependencies } from './dependenciesAny/dependenciesSackurTetrode.generated.js';
+export { schurDependencies } from './dependenciesAny/dependenciesSchur.generated.js';
+export { secDependencies } from './dependenciesAny/dependenciesSec.generated.js';
+export { sechDependencies } from './dependenciesAny/dependenciesSech.generated.js';
+export { secondRadiationDependencies } from './dependenciesAny/dependenciesSecondRadiation.generated.js';
+export { setCartesianDependencies } from './dependenciesAny/dependenciesSetCartesian.generated.js';
+export { setDifferenceDependencies } from './dependenciesAny/dependenciesSetDifference.generated.js';
+export { setDistinctDependencies } from './dependenciesAny/dependenciesSetDistinct.generated.js';
+export { setIntersectDependencies } from './dependenciesAny/dependenciesSetIntersect.generated.js';
+export { setIsSubsetDependencies } from './dependenciesAny/dependenciesSetIsSubset.generated.js';
+export { setMultiplicityDependencies } from './dependenciesAny/dependenciesSetMultiplicity.generated.js';
+export { setPowersetDependencies } from './dependenciesAny/dependenciesSetPowerset.generated.js';
+export { setSizeDependencies } from './dependenciesAny/dependenciesSetSize.generated.js';
+export { setSymDifferenceDependencies } from './dependenciesAny/dependenciesSetSymDifference.generated.js';
+export { setUnionDependencies } from './dependenciesAny/dependenciesSetUnion.generated.js';
+export { signDependencies } from './dependenciesAny/dependenciesSign.generated.js';
+export { simplifyDependencies } from './dependenciesAny/dependenciesSimplify.generated.js';
+export { simplifyConstantDependencies } from './dependenciesAny/dependenciesSimplifyConstant.generated.js';
+export { simplifyCoreDependencies } from './dependenciesAny/dependenciesSimplifyCore.generated.js';
+export { sinDependencies } from './dependenciesAny/dependenciesSin.generated.js';
+export { sinhDependencies } from './dependenciesAny/dependenciesSinh.generated.js';
+export { sizeDependencies } from './dependenciesAny/dependenciesSize.generated.js';
+export { sluDependencies } from './dependenciesAny/dependenciesSlu.generated.js';
+export { smallerDependencies } from './dependenciesAny/dependenciesSmaller.generated.js';
+export { smallerEqDependencies } from './dependenciesAny/dependenciesSmallerEq.generated.js';
+export { solveODEDependencies } from './dependenciesAny/dependenciesSolveODE.generated.js';
+export { sortDependencies } from './dependenciesAny/dependenciesSort.generated.js';
+export { SpaDependencies } from './dependenciesAny/dependenciesSpaClass.generated.js';
+export { sparseDependencies } from './dependenciesAny/dependenciesSparse.generated.js';
+export { SparseMatrixDependencies } from './dependenciesAny/dependenciesSparseMatrixClass.generated.js';
+export { speedOfLightDependencies } from './dependenciesAny/dependenciesSpeedOfLight.generated.js';
+export { splitUnitDependencies } from './dependenciesAny/dependenciesSplitUnit.generated.js';
+export { sqrtDependencies } from './dependenciesAny/dependenciesSqrt.generated.js';
+export { sqrtmDependencies } from './dependenciesAny/dependenciesSqrtm.generated.js';
+export { squareDependencies } from './dependenciesAny/dependenciesSquare.generated.js';
+export { squeezeDependencies } from './dependenciesAny/dependenciesSqueeze.generated.js';
+export { stdDependencies } from './dependenciesAny/dependenciesStd.generated.js';
+export { stdTransformDependencies } from './dependenciesAny/dependenciesStdTransform.generated.js';
+export { stefanBoltzmannDependencies } from './dependenciesAny/dependenciesStefanBoltzmann.generated.js';
+export { stirlingS2Dependencies } from './dependenciesAny/dependenciesStirlingS2.generated.js';
+export { stringDependencies } from './dependenciesAny/dependenciesString.generated.js';
+export { subsetDependencies } from './dependenciesAny/dependenciesSubset.generated.js';
+export { subsetTransformDependencies } from './dependenciesAny/dependenciesSubsetTransform.generated.js';
+export { subtractDependencies } from './dependenciesAny/dependenciesSubtract.generated.js';
+export { subtractScalarDependencies } from './dependenciesAny/dependenciesSubtractScalar.generated.js';
+export { sumDependencies } from './dependenciesAny/dependenciesSum.generated.js';
+export { sumTransformDependencies } from './dependenciesAny/dependenciesSumTransform.generated.js';
+export { sylvesterDependencies } from './dependenciesAny/dependenciesSylvester.generated.js';
+export { SymbolNodeDependencies } from './dependenciesAny/dependenciesSymbolNode.generated.js';
+export { symbolicEqualDependencies } from './dependenciesAny/dependenciesSymbolicEqual.generated.js';
+export { tanDependencies } from './dependenciesAny/dependenciesTan.generated.js';
+export { tanhDependencies } from './dependenciesAny/dependenciesTanh.generated.js';
+export { tauDependencies } from './dependenciesAny/dependenciesTau.generated.js';
+export { thomsonCrossSectionDependencies } from './dependenciesAny/dependenciesThomsonCrossSection.generated.js';
+export { toDependencies } from './dependenciesAny/dependenciesTo.generated.js';
+export { traceDependencies } from './dependenciesAny/dependenciesTrace.generated.js';
+export { transposeDependencies } from './dependenciesAny/dependenciesTranspose.generated.js';
+export { trueDependencies } from './dependenciesAny/dependenciesTrue.generated.js';
+export { typeOfDependencies } from './dependenciesAny/dependenciesTypeOf.generated.js';
+export { typedDependencies } from './dependenciesAny/dependenciesTyped.generated.js';
+export { unaryMinusDependencies } from './dependenciesAny/dependenciesUnaryMinus.generated.js';
+export { unaryPlusDependencies } from './dependenciesAny/dependenciesUnaryPlus.generated.js';
+export { unequalDependencies } from './dependenciesAny/dependenciesUnequal.generated.js';
+export { UnitDependencies } from './dependenciesAny/dependenciesUnitClass.generated.js';
+export { unitDependencies } from './dependenciesAny/dependenciesUnitFunction.generated.js';
+export { EDependencies } from './dependenciesAny/dependenciesUppercaseE.generated.js';
+export { PIDependencies } from './dependenciesAny/dependenciesUppercasePi.generated.js';
+export { usolveDependencies } from './dependenciesAny/dependenciesUsolve.generated.js';
+export { usolveAllDependencies } from './dependenciesAny/dependenciesUsolveAll.generated.js';
+export { vacuumImpedanceDependencies } from './dependenciesAny/dependenciesVacuumImpedance.generated.js';
+export { varianceDependencies } from './dependenciesAny/dependenciesVariance.generated.js';
+export { varianceTransformDependencies } from './dependenciesAny/dependenciesVarianceTransform.generated.js';
+export { versionDependencies } from './dependenciesAny/dependenciesVersion.generated.js';
+export { weakMixingAngleDependencies } from './dependenciesAny/dependenciesWeakMixingAngle.generated.js';
+export { wienDisplacementDependencies } from './dependenciesAny/dependenciesWienDisplacement.generated.js';
+export { xgcdDependencies } from './dependenciesAny/dependenciesXgcd.generated.js';
+export { xorDependencies } from './dependenciesAny/dependenciesXor.generated.js';
+export { zerosDependencies } from './dependenciesAny/dependenciesZeros.generated.js';
+export { zetaDependencies } from './dependenciesAny/dependenciesZeta.generated.js';
+export { zpk2tfDependencies } from './dependenciesAny/dependenciesZpk2tf.generated.js';
+export { all } from './allFactoriesAny.js';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createAtan2 } from '../../factoriesAny.js';
+export var atan2Dependencies = {
+  BigNumberDependencies,
+  DenseMatrixDependencies,
+  concatDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createAtan2
+};

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { isNegativeDependencies } from './dependenciesIsNegative.generated.js';
+import { stirlingS2Dependencies } from './dependenciesStirlingS2.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBellNumbers } from '../../factoriesAny.js';
+export var bellNumbersDependencies = {
+  addScalarDependencies,
+  isIntegerDependencies,
+  isNegativeDependencies,
+  stirlingS2Dependencies,
+  typedDependencies,
+  createBellNumbers
+};

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

@@ -0,0 +1,8 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { createBigNumberClass } from '../../factoriesAny.js';
+export var BigNumberDependencies = {
+  createBigNumberClass
+};

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBitAnd } from '../../factoriesAny.js';
+export var bitAndDependencies = {
+  concatDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createBitAnd
+};

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

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

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBitOr } from '../../factoriesAny.js';
+export var bitOrDependencies = {
+  DenseMatrixDependencies,
+  concatDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createBitOr
+};

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

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBitOrTransform } from '../../factoriesAny.js';
+export var bitOrTransformDependencies = {
+  DenseMatrixDependencies,
+  concatDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createBitOrTransform
+};

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

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBitXor } from '../../factoriesAny.js';
+export var bitXorDependencies = {
+  DenseMatrixDependencies,
+  concatDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createBitXor
+};

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
+import { combinationsDependencies } from './dependenciesCombinations.generated.js';
+import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { isNegativeDependencies } from './dependenciesIsNegative.generated.js';
+import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCatalan } from '../../factoriesAny.js';
+export var catalanDependencies = {
+  addScalarDependencies,
+  combinationsDependencies,
+  divideScalarDependencies,
+  isIntegerDependencies,
+  isNegativeDependencies,
+  multiplyScalarDependencies,
+  typedDependencies,
+  createCatalan
+};

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

@@ -0,0 +1,22 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { FractionDependencies } from './dependenciesFractionClass.generated.js';
+import { isNegativeDependencies } from './dependenciesIsNegative.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { unaryMinusDependencies } from './dependenciesUnaryMinus.generated.js';
+import { createCbrt } from '../../factoriesAny.js';
+export var cbrtDependencies = {
+  BigNumberDependencies,
+  ComplexDependencies,
+  FractionDependencies,
+  isNegativeDependencies,
+  matrixDependencies,
+  typedDependencies,
+  unaryMinusDependencies,
+  createCbrt
+};

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

@@ -0,0 +1,20 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { roundDependencies } from './dependenciesRound.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { zerosDependencies } from './dependenciesZeros.generated.js';
+import { createCeil } from '../../factoriesAny.js';
+export var ceilDependencies = {
+  DenseMatrixDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  roundDependencies,
+  typedDependencies,
+  zerosDependencies,
+  createCeil
+};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { IndexDependencies } from './dependenciesIndexClass.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { rangeDependencies } from './dependenciesRange.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createColumn } from '../../factoriesAny.js';
+export var columnDependencies = {
+  IndexDependencies,
+  matrixDependencies,
+  rangeDependencies,
+  typedDependencies,
+  createColumn
+};

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

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { IndexDependencies } from './dependenciesIndexClass.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { rangeDependencies } from './dependenciesRange.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createColumnTransform } from '../../factoriesAny.js';
+export var columnTransformDependencies = {
+  IndexDependencies,
+  matrixDependencies,
+  rangeDependencies,
+  typedDependencies,
+  createColumnTransform
+};

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

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

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

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

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

@@ -0,0 +1,22 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { FractionDependencies } from './dependenciesFractionClass.generated.js';
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCompare } from '../../factoriesAny.js';
+export var compareDependencies = {
+  BigNumberDependencies,
+  DenseMatrixDependencies,
+  FractionDependencies,
+  concatDependencies,
+  equalScalarDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createCompare
+};

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { concatDependencies } from './dependenciesConcat.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCompareText } from '../../factoriesAny.js';
+export var compareTextDependencies = {
+  concatDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createCompareText
+};

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

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

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { createComplexClass } from '../../factoriesAny.js';
+export var ComplexDependencies = {
+  createComplexClass
+};

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

@@ -0,0 +1,22 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
+import { combinationsDependencies } from './dependenciesCombinations.generated.js';
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { isNegativeDependencies } from './dependenciesIsNegative.generated.js';
+import { isPositiveDependencies } from './dependenciesIsPositive.generated.js';
+import { largerDependencies } from './dependenciesLarger.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createComposition } from '../../factoriesAny.js';
+export var compositionDependencies = {
+  addScalarDependencies,
+  combinationsDependencies,
+  isIntegerDependencies,
+  isNegativeDependencies,
+  isPositiveDependencies,
+  largerDependencies,
+  typedDependencies,
+  createComposition
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { divideDependencies } from './dependenciesDivide.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { meanDependencies } from './dependenciesMean.generated.js';
+import { multiplyDependencies } from './dependenciesMultiply.generated.js';
+import { powDependencies } from './dependenciesPow.generated.js';
+import { sqrtDependencies } from './dependenciesSqrt.generated.js';
+import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { sumDependencies } from './dependenciesSum.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCorr } from '../../factoriesAny.js';
+export var corrDependencies = {
+  addDependencies,
+  divideDependencies,
+  matrixDependencies,
+  meanDependencies,
+  multiplyDependencies,
+  powDependencies,
+  sqrtDependencies,
+  subtractDependencies,
+  sumDependencies,
+  typedDependencies,
+  createCorr
+};

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { prodDependencies } from './dependenciesProd.generated.js';
+import { sizeDependencies } from './dependenciesSize.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCount } from '../../factoriesAny.js';
+export var countDependencies = {
+  prodDependencies,
+  sizeDependencies,
+  typedDependencies,
+  createCount
+};

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { multiplyDependencies } from './dependenciesMultiply.generated.js';
+import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCross } from '../../factoriesAny.js';
+export var crossDependencies = {
+  matrixDependencies,
+  multiplyDependencies,
+  subtractDependencies,
+  typedDependencies,
+  createCross
+};

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

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

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { conjDependencies } from './dependenciesConj.generated.js';
+import { transposeDependencies } from './dependenciesTranspose.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createCtranspose } from '../../factoriesAny.js';
+export var ctransposeDependencies = {
+  conjDependencies,
+  transposeDependencies,
+  typedDependencies,
+  createCtranspose
+};

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { unaryPlusDependencies } from './dependenciesUnaryPlus.generated.js';
+import { createCumSum } from '../../factoriesAny.js';
+export var cumsumDependencies = {
+  addDependencies,
+  typedDependencies,
+  unaryPlusDependencies,
+  createCumSum
+};

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

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { unaryPlusDependencies } from './dependenciesUnaryPlus.generated.js';
+import { createCumSumTransform } from '../../factoriesAny.js';
+export var cumsumTransformDependencies = {
+  addDependencies,
+  typedDependencies,
+  unaryPlusDependencies,
+  createCumSumTransform
+};

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

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

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

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

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

@@ -0,0 +1,30 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ConstantNodeDependencies } from './dependenciesConstantNode.generated.js';
+import { FunctionNodeDependencies } from './dependenciesFunctionNode.generated.js';
+import { OperatorNodeDependencies } from './dependenciesOperatorNode.generated.js';
+import { ParenthesisNodeDependencies } from './dependenciesParenthesisNode.generated.js';
+import { SymbolNodeDependencies } from './dependenciesSymbolNode.generated.js';
+import { equalDependencies } from './dependenciesEqual.generated.js';
+import { isZeroDependencies } from './dependenciesIsZero.generated.js';
+import { numericDependencies } from './dependenciesNumeric.generated.js';
+import { parseDependencies } from './dependenciesParse.generated.js';
+import { simplifyDependencies } from './dependenciesSimplify.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createDerivative } from '../../factoriesAny.js';
+export var derivativeDependencies = {
+  ConstantNodeDependencies,
+  FunctionNodeDependencies,
+  OperatorNodeDependencies,
+  ParenthesisNodeDependencies,
+  SymbolNodeDependencies,
+  equalDependencies,
+  isZeroDependencies,
+  numericDependencies,
+  parseDependencies,
+  simplifyDependencies,
+  typedDependencies,
+  createDerivative
+};

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

@@ -0,0 +1,22 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
+import { isZeroDependencies } from './dependenciesIsZero.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { multiplyDependencies } from './dependenciesMultiply.generated.js';
+import { subtractScalarDependencies } from './dependenciesSubtractScalar.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { unaryMinusDependencies } from './dependenciesUnaryMinus.generated.js';
+import { createDet } from '../../factoriesAny.js';
+export var detDependencies = {
+  divideScalarDependencies,
+  isZeroDependencies,
+  matrixDependencies,
+  multiplyDependencies,
+  subtractScalarDependencies,
+  typedDependencies,
+  unaryMinusDependencies,
+  createDet
+};

node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesDeuteronMass.generated.js

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

node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesDiag.generated.js

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
+import { SparseMatrixDependencies } from './dependenciesSparseMatrixClass.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createDiag } from '../../factoriesAny.js';
+export var diagDependencies = {
+  DenseMatrixDependencies,
+  SparseMatrixDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createDiag
+};

node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesDiff.generated.js

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
+import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createDiff } from '../../factoriesAny.js';
+export var diffDependencies = {
+  matrixDependencies,
+  numberDependencies,
+  subtractDependencies,
+  typedDependencies,
+  createDiff
+};

node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesDiffTransform.generated.js

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { bignumberDependencies } from './dependenciesBignumber.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
+import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createDiffTransform } from '../../factoriesAny.js';
+export var diffTransformDependencies = {
+  bignumberDependencies,
+  matrixDependencies,
+  numberDependencies,
+  subtractDependencies,
+  typedDependencies,
+  createDiffTransform
+};