mathjs 10.6.4 → 11.1.0

package/lib/esm/type/matrix/utils/matrixAlgorithmSuite.js

@@ -0,0 +1,168 @@
+import { factory } from '../../../utils/factory.js';
+import { extend } from '../../../utils/object.js';
+import { createMatAlgo13xDD } from './matAlgo13xDD.js';
+import { createMatAlgo14xDs } from './matAlgo14xDs.js';
+var name = 'matrixAlgorithmSuite';
+var dependencies = ['typed', 'matrix'];
+export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix
+  } = _ref;
+  var matAlgo13xDD = createMatAlgo13xDD({
+    typed
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  /**
+   * Return a signatures object with the usual boilerplate of
+   * matrix algorithms, based on a plain options object with the
+   * following properties:
+   *   elop: function -- the elementwise operation to use, defaults to self
+   *   SS: function -- the algorithm to apply for two sparse matrices
+   *   DS: function -- the algorithm to apply for a dense and a sparse matrix
+   *   SD: function -- algo for a sparse and a dense; defaults to SD flipped
+   *   Ss: function -- the algorithm to apply for a sparse matrix and scalar
+   *   sS: function -- algo for scalar and sparse; defaults to Ss flipped
+   *   scalar: string -- typed-function type for scalars, defaults to 'any'
+   *
+   * If Ss is not specified, no matrix-scalar signatures are generated.
+   *
+   * @param {object} options
+   * @return {Object<string, function>} signatures
+   */
+
+  return function matrixAlgorithmSuite(options) {
+    var elop = options.elop;
+    var SD = options.SD || options.DS;
+    var matrixSignatures;
+
+    if (elop) {
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': (x, y) => matAlgo13xDD(x, y, elop),
+        'Array, Array': (x, y) => matAlgo13xDD(matrix(x), matrix(y), elop).valueOf(),
+        'Array, DenseMatrix': (x, y) => matAlgo13xDD(matrix(x), y, elop),
+        'DenseMatrix, Array': (x, y) => matAlgo13xDD(x, matrix(y), elop)
+      }; // Now incorporate sparse matrices
+
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(x, y, elop, false);
+      }
+
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = (x, y) => options.DS(x, y, elop, false);
+
+        matrixSignatures['Array, SparseMatrix'] = (x, y) => options.DS(matrix(x), y, elop, false);
+      }
+
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(y, x, elop, true);
+
+        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(matrix(y), x, elop, true);
+      }
+    } else {
+      // No elop, use this
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(x, y, self);
+        }),
+        'Array, Array': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(matrix(x), matrix(y), self).valueOf();
+        }),
+        'Array, DenseMatrix': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(matrix(x), y, self);
+        }),
+        'DenseMatrix, Array': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(x, matrix(y), self);
+        })
+      }; // Now incorporate sparse matrices
+
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.SS(x, y, self, false);
+        });
+      }
+
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.DS(x, y, self, false);
+        });
+        matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.DS(matrix(x), y, self, false);
+        });
+      }
+
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return SD(y, x, self, true);
+        });
+        matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(self => (x, y) => {
+          return SD(matrix(y), x, self, true);
+        });
+      }
+    } // Now add the scalars
+
+
+    var scalar = options.scalar || 'any';
+    var Ds = options.Ds || options.Ss;
+
+    if (Ds) {
+      if (elop) {
+        matrixSignatures['DenseMatrix,' + scalar] = (x, y) => matAlgo14xDs(x, y, elop, false);
+
+        matrixSignatures[scalar + ', DenseMatrix'] = (x, y) => matAlgo14xDs(y, x, elop, true);
+
+        matrixSignatures['Array,' + scalar] = (x, y) => matAlgo14xDs(matrix(x), y, elop, false).valueOf();
+
+        matrixSignatures[scalar + ', Array'] = (x, y) => matAlgo14xDs(matrix(y), x, elop, true).valueOf();
+      } else {
+        matrixSignatures['DenseMatrix,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(x, y, self, false);
+        });
+        matrixSignatures[scalar + ', DenseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(y, x, self, true);
+        });
+        matrixSignatures['Array,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+        });
+        matrixSignatures[scalar + ', Array'] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+        });
+      }
+    }
+
+    var sS = options.sS !== undefined ? options.sS : options.Ss;
+
+    if (elop) {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = (x, y) => options.Ss(x, y, elop, false);
+      }
+
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = (x, y) => sS(y, x, elop, true);
+      }
+    } else {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return options.Ss(x, y, self, false);
+        });
+      }
+
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return sS(y, x, self, true);
+        });
+      }
+    } // Also pull in the scalar signatures if the operator is a typed function
+
+
+    if (elop && elop.signatures) {
+      extend(matrixSignatures, elop.signatures);
+    }
+
+    return matrixSignatures;
+  };
+});

package/lib/esm/type/number.js

@@ -146,9 +146,7 @@ export var createNumber = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
       return unit.toNumber(valuelessUnit);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   }); // reviver function to parse a JSON object like:
   //
   //     {"mathjs":"number","value":"2.3"}

package/lib/esm/type/string.js

@@ -47,9 +47,7 @@ export var createString = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(x) {
       return x;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self)),
     any: function any(x) {
       return String(x);
     }

package/lib/esm/type/unit/Unit.js

@@ -1,5 +1,5 @@
-import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _extends from "@babel/runtime/helpers/extends";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -37,8 +37,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
   /**
    * A unit can be constructed in the following ways:
    *
-   *     const a = new Unit(value, name)
-   *     const b = new Unit(null, name)
+   *     const a = new Unit(value, valuelessUnit)
+   *     const b = new Unit(null, valuelessUnit)
    *     const c = Unit.parse(str)
    *
    * Example usage:
@@ -51,10 +51,10 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @class Unit
    * @constructor Unit
    * @param {number | BigNumber | Fraction | Complex | boolean} [value]  A value like 5.2
-   * @param {string} [name]   A unit name like "cm" or "inch", or a derived unit of the form: "u1[^ex1] [u2[^ex2] ...] [/ u3[^ex3] [u4[^ex4]]]", such as "kg m^2/s^2", where each unit appearing after the forward slash is taken to be in the denominator. "kg m^2 s^-2" is a synonym and is also acceptable. Any of the units can include a prefix.
+   * @param {string | Unit} valuelessUnit   A unit without value. Can have prefix, like "cm"
    */
 
-  function Unit(value, name) {
+  function Unit(value, valuelessUnit) {
     if (!(this instanceof Unit)) {
       throw new Error('Constructor must be called with the new operator');
     }
@@ -63,42 +63,42 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       throw new TypeError('First parameter in Unit constructor must be number, BigNumber, Fraction, Complex, or undefined');
     }
 
-    if (name !== undefined && (typeof name !== 'string' || name === '')) {
-      throw new TypeError('Second parameter in Unit constructor must be a string');
-    }
-
-    if (name !== undefined) {
-      var u = Unit.parse(name);
-      this.units = u.units;
-      this.dimensions = u.dimensions;
-    } else {
-      this.units = [{
-        unit: UNIT_NONE,
-        prefix: PREFIXES.NONE,
-        // link to a list with supported prefixes
-        power: 0
-      }];
-      this.dimensions = [];
-
-      for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
-        this.dimensions[i] = 0;
-      }
-    }
-
-    this.value = value !== undefined && value !== null ? this._normalize(value) : null;
     this.fixPrefix = false; // if true, function format will not search for the
     // best prefix but leave it as initially provided.
     // fixPrefix is set true by the method Unit.to
     // The justification behind this is that if the constructor is explicitly called,
-    // the caller wishes the units to be returned exactly as he supplied.
+    // the caller wishes the units to be returned exactly as supplied.
 
     this.skipAutomaticSimplification = true;
+
+    if (valuelessUnit === undefined) {
+      this.units = [];
+      this.dimensions = BASE_DIMENSIONS.map(x => 0);
+    } else if (typeof valuelessUnit === 'string') {
+      var u = Unit.parse(valuelessUnit);
+      this.units = u.units;
+      this.dimensions = u.dimensions;
+    } else if (isUnit(valuelessUnit) && valuelessUnit.value === null) {
+      // clone from valuelessUnit
+      this.fixPrefix = valuelessUnit.fixPrefix;
+      this.skipAutomaticSimplification = valuelessUnit.skipAutomaticSimplification;
+      this.dimensions = valuelessUnit.dimensions.slice(0);
+      this.units = valuelessUnit.units.map(u => _extends({}, u));
+    } else {
+      throw new TypeError('Second parameter in Unit constructor must be a string or valueless Unit');
+    }
+
+    this.value = this._normalize(value);
   }
   /**
    * Attach type information
    */
 
 
+  Object.defineProperty(Unit, 'name', {
+    value: 'Unit'
+  });
+  Unit.prototype.constructor = Unit;
   Unit.prototype.type = 'Unit';
   Unit.prototype.isUnit = true; // private variables and functions for the Unit parser
 
@@ -461,6 +461,17 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
     return unit;
   };
+  /**
+   * Return the type of the value of this unit
+   *
+   * @memberof Unit
+   * @ return {string} type of the value of the unit
+   */
+
+
+  Unit.prototype.valueType = function () {
+    return typeOf(this.value);
+  };
   /**
    * Return whether the unit is derived (such as m/s, or cm^2, but not N)
    * @memberof Unit
@@ -648,15 +659,16 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     return this.equalBase(other) && equal(this.value, other.value);
   };
   /**
-   * Multiply this unit with another one
+   * Multiply this unit with another one or with a scalar
    * @memberof Unit
    * @param {Unit} other
    * @return {Unit} product of this unit and the other unit
    */
 
 
-  Unit.prototype.multiply = function (other) {
+  Unit.prototype.multiply = function (_other) {
     var res = this.clone();
+    var other = isUnit(_other) ? _other : new Unit(_other);
 
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
@@ -680,19 +692,35 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       res.value = null;
     }
 
-    res.skipAutomaticSimplification = false;
+    if (isUnit(_other)) {
+      res.skipAutomaticSimplification = false;
+    }
+
     return getNumericIfUnitless(res);
   };
+  /**
+   * Divide a number by this unit
+   *
+   * @memberof Unit
+   * @param {numeric} numerator
+   * @param {unit} result of dividing numerator by this unit
+   */
+
+
+  Unit.prototype.divideInto = function (numerator) {
+    return new Unit(numerator).divide(this);
+  };
   /**
    * Divide this unit by another one
    * @memberof Unit
-   * @param {Unit} other
+   * @param {Unit | numeric} other
    * @return {Unit} result of dividing this unit by the other unit
    */
 
 
-  Unit.prototype.divide = function (other) {
+  Unit.prototype.divide = function (_other) {
     var res = this.clone();
+    var other = isUnit(_other) ? _other : new Unit(_other);
 
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
@@ -718,7 +746,10 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       res.value = null;
     }
 
-    res.skipAutomaticSimplification = false;
+    if (isUnit(_other)) {
+      res.skipAutomaticSimplification = false;
+    }
+
     return getNumericIfUnitless(res);
   };
   /**
@@ -787,7 +818,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
         // To give the correct, but unexpected, results for units with an offset.
         // For example, abs(-283.15 degC) = -263.15 degC !!!
         // We must take the offset into consideration here
-        var convert = Unit._getNumberConverter(typeOf(ret.value)); // convert to Fraction or BigNumber if needed
+        var convert = ret._numberConverter(); // convert to Fraction or BigNumber if needed
 
 
         var unitValue = convert(ret.units[0].unit.value);
@@ -3627,6 +3658,23 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       return x;
     }
   };
+  /**
+   * Retrieve the right converter function corresponding with this unit's
+   * value
+   *
+   * @memberof Unit
+   * @return {Function}
+   */
+
+  Unit.prototype._numberConverter = function () {
+    var convert = Unit.typeConverters[this.valueType()];
+
+    if (convert) {
+      return convert;
+    }
+
+    throw new TypeError('Unsupported Unit value type "' + this.valueType() + '"');
+  };
   /**
    * Retrieve the right convertor function corresponding with the type
    * of provided exampleValue.
@@ -3636,6 +3684,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {Function}
    */
 
+
   Unit._getNumberConverter = function (type) {
     if (!Unit.typeConverters[type]) {
       throw new TypeError('Unsupported type "' + type + '"');

package/lib/esm/type/unit/function/createUnit.js

@@ -34,9 +34,10 @@ export var createCreateUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
    *     math.createUnit('foo')
    *     math.createUnit('knot', {definition: '0.514444444 m/s', aliases: ['knots', 'kt', 'kts']})
    *     math.createUnit('mph', '1 mile/hour')
+   *     math.createUnit('km', math.unit(1000, 'm'))
    *
    * @param {string} name      The name of the new unit. Must be unique. Example: 'knot'
-   * @param {string, Unit} definition      Definition of the unit in terms of existing units. For example, '0.514444444 m / s'.
+   * @param {string, UnitDefinition, Unit} definition      Definition of the unit in terms of existing units. For example, '0.514444444 m / s'.
    * @param {Object} options   (optional) An object containing any of the following properties:
    *     - `prefixes {string}` "none", "short", "long", "binary_short", or "binary_long". The default is "none".
    *     - `aliases {Array}` Array of strings. Example: ['knots', 'kt', 'kts']

package/lib/esm/type/unit/function/unit.js

@@ -17,10 +17,13 @@ export var createUnitFunction = /* #__PURE__ */factory(name, dependencies, _ref
    * Syntax:
    *
    *     math.unit(unit : string)
-   *     math.unit(value : number, unit : string)
+   *     math.unit(value : number, valuelessUnit : Unit)
+   *     math.unit(value : number, valuelessUnit : string)
    *
    * Examples:
    *
+   *    const kph = math.unit('km/h')   // returns Unit km/h (valueless)
+   *    const v = math.unit(25, kph)    // returns Unit 25 km/h
    *    const a = math.unit(5, 'cm')    // returns Unit 50 mm
    *    const b = math.unit('23 kg')    // returns Unit 23 kg
    *    a.to('m')                       // returns Unit 0.05 m
@@ -45,11 +48,13 @@ export var createUnitFunction = /* #__PURE__ */factory(name, dependencies, _ref
         allowNoUnits: true
       }); // a unit with value, like '5cm'
     },
-    'number | BigNumber | Fraction | Complex, string': function numberBigNumberFractionComplexString(value, unit) {
+    'number | BigNumber | Fraction | Complex, string | Unit': function numberBigNumberFractionComplexStringUnit(value, unit) {
       return new Unit(value, unit);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'number | BigNumber | Fraction': function numberBigNumberFraction(value) {
+      // dimensionless
+      return new Unit(value);
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/utils/is.js

@@ -111,6 +111,20 @@ export function isConditionalNode(x) {
 export function isConstantNode(x) {
   return x && x.isConstantNode === true && x.constructor.prototype.isNode === true || false;
 }
+/* Very specialized: returns true for those nodes which in the numerator of
+   a fraction means that the division in that fraction has precedence over implicit
+   multiplication, e.g. -2/3 x parses as (-2/3) x and 3/4 x parses as (3/4) x but
+   6!/8 x parses as 6! / (8x). It is located here because it is shared between
+   parse.js and OperatorNode.js (for parsing and printing, respectively).
+
+   This should *not* be exported from mathjs, unlike most of the tests here.
+   Its name does not start with 'is' to prevent utils/snapshot.js from thinking
+   it should be exported.
+*/
+
+export function rule2Node(node) {
+  return isConstantNode(node) || isOperatorNode(node) && node.args.length === 1 && isConstantNode(node.args[0]) && '-+~'.includes(node.op);
+}
 export function isFunctionAssignmentNode(x) {
   return x && x.isFunctionAssignmentNode === true && x.constructor.prototype.isNode === true || false;
 }
@@ -145,26 +159,12 @@ export function typeOf(x) {
   var t = typeof x;
 
   if (t === 'object') {
-    // JavaScript types
     if (x === null) return 'null';
-    if (Array.isArray(x)) return 'Array';
-    if (x instanceof Date) return 'Date';
-    if (x instanceof RegExp) return 'RegExp'; // math.js types
+    if (isBigNumber(x)) return 'BigNumber'; // Special: weird mashup with Decimal
 
-    if (isBigNumber(x)) return 'BigNumber';
-    if (isComplex(x)) return 'Complex';
-    if (isFraction(x)) return 'Fraction';
-    if (isMatrix(x)) return 'Matrix';
-    if (isUnit(x)) return 'Unit';
-    if (isIndex(x)) return 'Index';
-    if (isRange(x)) return 'Range';
-    if (isResultSet(x)) return 'ResultSet';
-    if (isNode(x)) return x.type;
-    if (isChain(x)) return 'Chain';
-    if (isHelp(x)) return 'Help';
-    return 'Object';
+    if (x.constructor && x.constructor.name) return x.constructor.name;
+    return 'Object'; // just in case
   }
 
-  if (t === 'function') return 'Function';
-  return t; // can be 'string', 'number', 'boolean', ...
+  return t; // can be 'string', 'number', 'boolean', 'function', 'bigint', ...
 }

package/lib/esm/utils/snapshot.js

@@ -16,6 +16,7 @@ import assert from 'assert';
 import * as allIsFunctions from './is.js';
 import { create } from '../core/create.js';
 import { endsWith } from './string.js';
+export var validateTypeOf = allIsFunctions.typeOf;
 export function validateBundle(expectedBundleStructure, bundle) {
   var originalWarn = console.warn;
 
@@ -110,21 +111,21 @@ export function createSnapshotFromFactories(factories) {
     var factory = factories[factoryName];
     var name = factory.fn;
     var isTransformFunction = factory.meta && factory.meta.isTransformFunction;
-    var isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'Function';
+    var isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'function';
     var dependenciesName = factory.fn + (isTransformFunction ? 'Transform' : '') + 'Dependencies';
-    allFactoryFunctions[factoryName] = 'Function';
+    allFactoryFunctions[factoryName] = 'function';
     allFunctionsConstantsClasses[name] = validateTypeOf(math[name]);
     allDependencyCollections[dependenciesName] = 'Object';
 
     if (isTransformFunction) {
-      allTransformFunctions[name] = 'Function';
+      allTransformFunctions[name] = 'function';
     }
 
     if (isClass) {
       if (endsWith(name, 'Node')) {
-        allNodeClasses[name] = 'Function';
+        allNodeClasses[name] = 'function';
       } else {
-        allClasses[name] = 'Function';
+        allClasses[name] = 'function';
       }
     } else {
       allFunctionsConstants[name] = validateTypeOf(math[name]);
@@ -144,37 +145,37 @@ export function createSnapshotFromFactories(factories) {
   var allTypeChecks = {};
   Object.keys(allIsFunctions).forEach(name => {
     if (name.indexOf('is') === 0) {
-      allTypeChecks[name] = 'Function';
+      allTypeChecks[name] = 'function';
     }
   });
   var allErrorClasses = {
-    ArgumentsError: 'Function',
-    DimensionError: 'Function',
-    IndexError: 'Function'
+    ArgumentsError: 'function',
+    DimensionError: 'function',
+    IndexError: 'function'
   };
 
   var expectedInstanceStructure = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, allFunctionsConstantsClasses), {}, {
-    on: 'Function',
-    off: 'Function',
-    once: 'Function',
-    emit: 'Function',
-    import: 'Function',
-    config: 'Function',
-    create: 'Function',
-    factory: 'Function'
+    on: 'function',
+    off: 'function',
+    once: 'function',
+    emit: 'function',
+    import: 'function',
+    config: 'function',
+    create: 'function',
+    factory: 'function'
   }, allTypeChecks), allErrorClasses), {}, {
     expression: {
       transform: _objectSpread({}, allTransformFunctions),
       mathWithTransform: _objectSpread(_objectSpread({}, exclude(allFunctionsConstants, ['chain'])), {}, {
-        config: 'Function'
+        config: 'function'
       })
     }
   });
 
   var expectedES6Structure = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, exclude(allFunctionsConstantsClasses, ['E', 'false', 'Infinity', 'NaN', 'null', 'PI', 'true'])), {}, {
-    create: 'Function',
-    config: 'Function',
-    factory: 'Function',
+    create: 'function',
+    config: 'function',
+    factory: 'function',
     _true: 'boolean',
     _false: 'boolean',
     _null: 'null',
@@ -189,33 +190,6 @@ export function createSnapshotFromFactories(factories) {
     expectedES6Structure
   };
 }
-export function validateTypeOf(x) {
-  if (x && x.type === 'Unit') {
-    return 'Unit';
-  }
-
-  if (x && x.type === 'Complex') {
-    return 'Complex';
-  }
-
-  if (Array.isArray(x)) {
-    return 'Array';
-  }
-
-  if (x === null) {
-    return 'null';
-  }
-
-  if (typeof x === 'function') {
-    return 'Function';
-  }
-
-  if (typeof x === 'object') {
-    return 'Object';
-  }
-
-  return typeof x;
-}
 
 function traverse(obj) {
   var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (value, path) => {};

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '10.6.4'; // Note: This file is automatically generated when building math.js.
+export var version = '11.1.0'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.