feat:node-modules

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