mathjs 10.6.3 → 11.0.1

package/lib/cjs/function/trigonometry/sinh.js

@@ -7,8 +7,6 @@ exports.createSinh = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _collection = require("../../utils/collection.js");
-
 var _index = require("../../plain/number/index.js");
 
 var name = 'sinh';
@@ -20,7 +18,8 @@ var createSinh = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * Calculate the hyperbolic sine of a value,
    * defined as `sinh(x) = 1/2 * (exp(x) - exp(-x))`.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix hyperbolic sine, this function does
+   * not apply to matrices.
    *
    * Syntax:
    *
@@ -34,27 +33,13 @@ var createSinh = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    *
    *    cosh, tanh
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
-   * @return {number | BigNumber | Complex | Array | Matrix} Hyperbolic sine of x
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic sine of x
    */
   return typed(name, {
     number: _index.sinhNumber,
-    Complex: function Complex(x) {
-      return x.sinh();
-    },
-    BigNumber: function BigNumber(x) {
+    'Complex | BigNumber': function ComplexBigNumber(x) {
       return x.sinh();
-    },
-    Unit: function Unit(x) {
-      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
-        throw new TypeError('Unit in function sinh is no angle');
-      }
-
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since sinh(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
     }
   });
 });

package/lib/cjs/function/trigonometry/tan.js

@@ -7,17 +7,20 @@ exports.createTan = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _collection = require("../../utils/collection.js");
+var _trigUnit = require("./trigUnit.js");
 
 var name = 'tan';
 var dependencies = ['typed'];
 var createTan = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
-
+  var trigUnit = (0, _trigUnit.createTrigUnit)({
+    typed: typed
+  });
   /**
    * Calculate the tangent of a value. `tan(x)` is equal to `sin(x) / cos(x)`.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix tangent, this function does not apply
+   * to matrices.
    *
    * Syntax:
    *
@@ -34,28 +37,15 @@ var createTan = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *
    *    atan, sin, cos
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
-   * @return {number | BigNumber | Complex | Array | Matrix} Tangent of x
+   * @param {number | BigNumber | Complex | Unit} x  Function input
+   * @return {number | BigNumber | Complex} Tangent of x
    */
+
   return typed(name, {
     number: Math.tan,
-    Complex: function Complex(x) {
+    'Complex | BigNumber': function ComplexBigNumber(x) {
       return x.tan();
-    },
-    BigNumber: function BigNumber(x) {
-      return x.tan();
-    },
-    Unit: function Unit(x) {
-      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
-        throw new TypeError('Unit in function tan is no angle');
-      }
-
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since tan(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
     }
-  });
+  }, trigUnit);
 });
 exports.createTan = createTan;

package/lib/cjs/function/trigonometry/tanh.js

@@ -7,8 +7,6 @@ exports.createTanh = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _collection = require("../../utils/collection.js");
-
 var _number = require("../../utils/number.js");
 
 var name = 'tanh';
@@ -20,7 +18,8 @@ var createTanh = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * Calculate the hyperbolic tangent of a value,
    * defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with matrix hyperbolic tangent, this function does
+   * not apply to matrices.
    *
    * Syntax:
    *
@@ -37,27 +36,13 @@ var createTanh = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    *
    *    sinh, cosh, coth
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
-   * @return {number | BigNumber | Complex | Array | Matrix} Hyperbolic tangent of x
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic tangent of x
    */
   return typed('tanh', {
     number: _number.tanh,
-    Complex: function Complex(x) {
-      return x.tanh();
-    },
-    BigNumber: function BigNumber(x) {
+    'Complex | BigNumber': function ComplexBigNumber(x) {
       return x.tanh();
-    },
-    Unit: function Unit(x) {
-      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
-        throw new TypeError('Unit in function tanh is no angle');
-      }
-
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since tanh(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
     }
   });
 });

package/lib/cjs/function/trigonometry/trigUnit.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTrigUnit = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var createTrigUnit = /* #__PURE__ */(0, _factory.factory)('trigUnit', ['typed'], function (_ref) {
+  var typed = _ref.typed;
+  return {
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+          throw new TypeError('Unit in function cot is no angle');
+        }
+
+        return typed.find(self, x.valueType())(x.value);
+      };
+    })
+  };
+});
+exports.createTrigUnit = createTrigUnit;

package/lib/cjs/function/unit/to.js

@@ -7,20 +7,16 @@ exports.createTo = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _algorithm = require("../../type/matrix/utils/algorithm13.js");
-
-var _algorithm2 = require("../../type/matrix/utils/algorithm14.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 
 var name = 'to';
 var dependencies = ['typed', 'matrix'];
 var createTo = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       matrix = _ref.matrix;
-  var algorithm13 = (0, _algorithm.createAlgorithm13)({
-    typed: typed
-  });
-  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
-    typed: typed
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix
   });
   /**
    * Change the unit of a value.
@@ -50,39 +46,9 @@ var createTo = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function
   return typed(name, {
     'Unit, Unit | string': function UnitUnitString(x, unit) {
       return x.to(unit);
-    },
-    'Matrix, Matrix': function MatrixMatrix(x, y) {
-      // SparseMatrix does not support Units
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'Matrix, any': function MatrixAny(x, y) {
-      // SparseMatrix does not support Units
-      return algorithm14(x, y, this, false);
-    },
-    'any, Matrix': function anyMatrix(x, y) {
-      // SparseMatrix does not support Units
-      return algorithm14(y, x, this, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
     }
-  });
+  }, matrixAlgorithmSuite({
+    Ds: true
+  }));
 });
 exports.createTo = createTo;

package/lib/cjs/function/utils/clone.js

@@ -24,7 +24,7 @@ var createClone = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    * Examples:
    *
    *    math.clone(3.5)                   // returns number 3.5
-   *    math.clone(math.complex('2-4i') // returns Complex 2 - 4i
+   *    math.clone(math.complex('2-4i'))  // returns Complex 2 - 4i
    *    math.clone(math.unit(45, 'deg'))  // returns Unit 45 deg
    *    math.clone([[1, 2], [3, 4]])      // returns Array [[1, 2], [3, 4]]
    *    math.clone("hello world")         // returns string "hello world"

package/lib/cjs/function/utils/hasNumericValue.js

@@ -30,7 +30,8 @@ var createHasNumericValue = /* #__PURE__ */(0, _factory.factory)(name, dependenc
    *    math.hasNumericValue(0)                     // returns true
    *    math.hasNumericValue(math.bignumber(500))   // returns true
    *    math.hasNumericValue(math.fraction(4))      // returns true
-   *    math.hasNumericValue(math.complex('2-4i')   // returns false
+   *    math.hasNumericValue(math.complex('2-4i'))  // returns false
+   *    math.hasNumericValue(false)                 // returns true
    *    math.hasNumericValue([2.3, 'foo', false])   // returns [true, false, true]
    *
    * See also:
@@ -43,6 +44,9 @@ var createHasNumericValue = /* #__PURE__ */(0, _factory.factory)(name, dependenc
    *                    Throws an error in case of unknown types.
    */
   return typed(name, {
+    "boolean": function boolean() {
+      return true;
+    },
     string: function string(x) {
       return x.trim().length > 0 && !isNaN(Number(x));
     },

package/lib/cjs/function/utils/isInteger.js

@@ -35,7 +35,7 @@ var createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    *    math.isInteger(math.fraction(4))      // returns true
    *    math.isInteger('3')                   // returns true
    *    math.isInteger([3, 0.5, -2])          // returns [true, false, true]
-   *    math.isInteger(math.complex('2-4i')   // throws an error
+   *    math.isInteger(math.complex('2-4i'))  // throws an error
    *
    * See also:
    *
@@ -54,9 +54,11 @@ var createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     Fraction: function Fraction(x) {
       return x.d === 1 && isFinite(x.n);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsInteger = createIsInteger;

package/lib/cjs/function/utils/isNaN.js

@@ -35,7 +35,7 @@ var createIsNaN = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    *    math.isNaN(math.bignumber(0))     // returns false
    *    math.isNaN(math.fraction(-2, 5))  // returns false
    *    math.isNaN('-2')                  // returns false
-   *    math.isNaN([2, 0, -3, NaN]')      // returns [false, false, false, true]
+   *    math.isNaN([2, 0, -3, NaN])       // returns [false, false, false, true]
    *
    * See also:
    *

package/lib/cjs/function/utils/isNegative.js

@@ -35,7 +35,7 @@ var createIsNegative = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    *    math.isNegative(math.bignumber(2))     // returns false
    *    math.isNegative(math.fraction(-2, 5))  // returns true
    *    math.isNegative('-2')                  // returns true
-   *    math.isNegative([2, 0, -3]')           // returns [false, false, true]
+   *    math.isNegative([2, 0, -3])            // returns [false, false, true]
    *
    * See also:
    *
@@ -53,12 +53,16 @@ var createIsNegative = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     Fraction: function Fraction(x) {
       return x.s < 0; // It's enough to decide on the sign
     },
-    Unit: function Unit(x) {
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsNegative = createIsNegative;

package/lib/cjs/function/utils/isNumeric.js

@@ -31,7 +31,7 @@ var createIsNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    *    math.isNumeric(0)                     // returns true
    *    math.isNumeric(math.bignumber(500))   // returns true
    *    math.isNumeric(math.fraction(4))      // returns true
-   *    math.isNumeric(math.complex('2-4i')   // returns false
+   *    math.isNumeric(math.complex('2-4i'))  // returns false
    *    math.isNumeric([2.3, 'foo', false])   // returns [true, false, true]
    *
    * See also:
@@ -50,9 +50,11 @@ var createIsNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     'Complex | Unit | string | null | undefined | Node': function ComplexUnitStringNullUndefinedNode() {
       return false;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsNumeric = createIsNumeric;

package/lib/cjs/function/utils/isPositive.js

@@ -35,7 +35,7 @@ var createIsPositive = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    *    math.isPositive(0.5)                   // returns true
    *    math.isPositive(math.bignumber(2))     // returns true
    *    math.isPositive(math.fraction(-2, 5))  // returns false
-   *    math.isPositive(math.fraction(1,3))    // returns false
+   *    math.isPositive(math.fraction(1, 3))   // returns true
    *    math.isPositive('2')                   // returns true
    *    math.isPositive([2, 0, -3])            // returns [true, false, false]
    *
@@ -55,12 +55,16 @@ var createIsPositive = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     Fraction: function Fraction(x) {
       return x.s > 0 && x.n > 0;
     },
-    Unit: function Unit(x) {
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsPositive = createIsPositive;

package/lib/cjs/function/utils/isPrime.js

@@ -144,9 +144,11 @@ var createIsPrime = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
 
       return true;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsPrime = createIsPrime;

package/lib/cjs/function/utils/isZero.js

@@ -29,17 +29,17 @@ var createIsZero = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    * Examples:
    *
-   *    math.isZero(0)                     // returns true
-   *    math.isZero(2)                     // returns false
-   *    math.isZero(0.5)                   // returns false
-   *    math.isZero(math.bignumber(0))     // returns true
-   *    math.isZero(math.fraction(0))      // returns true
-   *    math.isZero(math.fraction(1,3))    // returns false
-   *    math.isZero(math.complex('2 - 4i') // returns false
-   *    math.isZero(math.complex('0i')     // returns true
-   *    math.isZero('0')                   // returns true
-   *    math.isZero('2')                   // returns false
-   *    math.isZero([2, 0, -3]')           // returns [false, true, false]
+   *    math.isZero(0)                      // returns true
+   *    math.isZero(2)                      // returns false
+   *    math.isZero(0.5)                    // returns false
+   *    math.isZero(math.bignumber(0))      // returns true
+   *    math.isZero(math.fraction(0))       // returns true
+   *    math.isZero(math.fraction(1,3))     // returns false
+   *    math.isZero(math.complex('2 - 4i')) // returns false
+   *    math.isZero(math.complex('0i'))     // returns true
+   *    math.isZero('0')                    // returns true
+   *    math.isZero('2')                    // returns false
+   *    math.isZero([2, 0, -3])             // returns [false, true, false]
    *
    * See also:
    *
@@ -60,12 +60,16 @@ var createIsZero = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     Fraction: function Fraction(x) {
       return x.d === 1 && x.n === 0;
     },
-    Unit: function Unit(x) {
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsZero = createIsZero;

package/lib/cjs/function/utils/numeric.js

@@ -44,12 +44,12 @@ var createNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *
    * Examples:
    *
-   *    math.numeric('4')                           // returns number 4
-   *    math.numeric('4', 'number')                 // returns number 4
+   *    math.numeric('4')                           // returns 4
+   *    math.numeric('4', 'number')                 // returns 4
    *    math.numeric('4', 'BigNumber')              // returns BigNumber 4
    *    math.numeric('4', 'Fraction')               // returns Fraction 4
    *    math.numeric(4, 'Fraction')                 // returns Fraction 4
-   *    math.numeric(math.fraction(2, 5), 'number') // returns number 0.4
+   *    math.numeric(math.fraction(2, 5), 'number') // returns 0.4
    *
    * See also:
    *
@@ -64,7 +64,14 @@ var createNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *              Returns an instance of the numeric in the requested type
    */
 
-  return function numeric(value, outputType) {
+  return function numeric(value) {
+    var outputType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'number';
+    var check = arguments.length > 2 ? arguments[2] : undefined;
+
+    if (check !== undefined) {
+      throw new SyntaxError('numeric() takes one or two arguments');
+    }
+
     var inputType = (0, _is.typeOf)(value);
 
     if (!(inputType in validInputTypes)) {

package/lib/cjs/function/utils/typeOf.js

@@ -15,46 +15,7 @@ var createTypeOf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
   var typed = _ref.typed;
 
   /**
-   * Determine the type of a variable.
-   *
-   * Function `typeOf` recognizes the following types of objects:
-   *
-   * Object                 | Returns       | Example
-   * ---------------------- | ------------- | ------------------------------------------
-   * null                   | `'null'`      | `math.typeOf(null)`
-   * number                 | `'number'`    | `math.typeOf(3.5)`
-   * boolean                | `'boolean'`   | `math.typeOf(true)`
-   * string                 | `'string'`    | `math.typeOf('hello world')`
-   * Array                  | `'Array'`     | `math.typeOf([1, 2, 3])`
-   * Date                   | `'Date'`      | `math.typeOf(new Date())`
-   * Function               | `'Function'`  | `math.typeOf(function () {})`
-   * Object                 | `'Object'`    | `math.typeOf({a: 2, b: 3})`
-   * RegExp                 | `'RegExp'`    | `math.typeOf(/a regexp/)`
-   * undefined              | `'undefined'` | `math.typeOf(undefined)`
-   * math.BigNumber         | `'BigNumber'` | `math.typeOf(math.bignumber('2.3e500'))`
-   * math.Chain             | `'Chain'`     | `math.typeOf(math.chain(2))`
-   * math.Complex           | `'Complex'`   | `math.typeOf(math.complex(2, 3))`
-   * math.Fraction          | `'Fraction'`  | `math.typeOf(math.fraction(1, 3))`
-   * math.Help              | `'Help'`      | `math.typeOf(math.help('sqrt'))`
-   * math.Help              | `'Help'`      | `math.typeOf(math.help('sqrt'))`
-   * math.Index             | `'Index'`     | `math.typeOf(math.index(1, 3))`
-   * math.Matrix            | `'Matrix'`    | `math.typeOf(math.matrix([[1,2], [3, 4]]))`
-   * math.Range             | `'Range'`     | `math.typeOf(math.range(0, 10))`
-   * math.ResultSet         | `'ResultSet'` | `math.typeOf(math.evaluate('a=2\nb=3'))`
-   * math.Unit              | `'Unit'`      | `math.typeOf(math.unit('45 deg'))`
-   * math.AccessorNode            | `'AccessorNode'`            | `math.typeOf(math.parse('A[2]'))`
-   * math.ArrayNode               | `'ArrayNode'`               | `math.typeOf(math.parse('[1,2,3]'))`
-   * math.AssignmentNode          | `'AssignmentNode'`          | `math.typeOf(math.parse('x=2'))`
-   * math.BlockNode               | `'BlockNode'`               | `math.typeOf(math.parse('a=2; b=3'))`
-   * math.ConditionalNode         | `'ConditionalNode'`         | `math.typeOf(math.parse('x<0 ? -x : x'))`
-   * math.ConstantNode            | `'ConstantNode'`            | `math.typeOf(math.parse('2.3'))`
-   * math.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeOf(math.parse('f(x)=x^2'))`
-   * math.FunctionNode            | `'FunctionNode'`            | `math.typeOf(math.parse('sqrt(4)'))`
-   * math.IndexNode               | `'IndexNode'`               | `math.typeOf(math.parse('A[2]').index)`
-   * math.ObjectNode              | `'ObjectNode'`              | `math.typeOf(math.parse('{a:2}'))`
-   * math.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeOf(math.parse('(2+3)'))`
-   * math.RangeNode               | `'RangeNode'`               | `math.typeOf(math.parse('1:10'))`
-   * math.SymbolNode              | `'SymbolNode'`              | `math.typeOf(math.parse('x'))`
+   * Determine the type of an entity.
    *
    * Syntax:
    *
@@ -62,10 +23,43 @@ var createTypeOf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    * Examples:
    *
-   *    math.typeOf(3.5)                     // returns 'number'
-   *    math.typeOf(math.complex('2-4i'))    // returns 'Complex'
-   *    math.typeOf(math.unit('45 deg'))     // returns 'Unit'
-   *    math.typeOf('hello world')           // returns 'string'
+   *    // This list is intended to include all relevant types, for testing
+   *    // purposes:
+   *    math.typeOf(3.5)                      // returns 'number'
+   *    math.typeOf(math.complex('2-4i'))     // returns 'Complex'
+   *    math.typeOf(math.unit('45 deg'))      // returns 'Unit'
+   *    math.typeOf('hello world')            // returns 'string'
+   *    math.typeOf(null)                     // returns 'null'
+   *    math.typeOf(true)                     // returns 'boolean'
+   *    math.typeOf([1, 2, 3])                // returns 'Array'
+   *    math.typeOf(new Date())               // returns 'Date'
+   *    math.typeOf(function () {})           // returns 'function'
+   *    math.typeOf({a: 2, b: 3})             // returns 'Object'
+   *    math.typeOf(/a regexp/)               // returns 'RegExp'
+   *    math.typeOf(undefined)                // returns 'undefined'
+   *    math.typeOf(math.bignumber('23e99'))  // returns 'BigNumber'
+   *    math.typeOf(math.chain(2))            // returns 'Chain'
+   *    math.typeOf(math.fraction(1, 3))      // returns 'Fraction'
+   *    math.typeOf(math.help('sqrt'))        // returns 'Help'
+   *    math.typeOf(math.index(1, 3))         // returns 'Index'
+   *    math.typeOf(math.matrix([[1],[3]]))   // returns 'DenseMatrix'
+   *    math.typeOf(math.matrix([],'sparse')) // returns 'SparseMatrix'
+   *    math.typeOf(new math.Range(0, 10))    // returns 'Range'
+   *    math.typeOf(math.evaluate('a=2\na'))  // returns 'ResultSet'
+   *    math.typeOf(math.parse('A[2]'))       // returns 'AccessorNode'
+   *    math.typeOf(math.parse('[1,2,3]'))    // returns 'ArrayNode'
+   *    math.typeOf(math.parse('x=2'))        // returns 'AssignmentNode'
+   *    math.typeOf(math.parse('a=2; b=3'))   // returns 'BlockNode'
+   *    math.typeOf(math.parse('x<0?-1:1'))   // returns 'ConditionalNode'
+   *    math.typeOf(math.parse('2.3'))        // returns 'ConstantNode'
+   *    math.typeOf(math.parse('f(x)=x^2'))   // returns 'FunctionAssignmentNode'
+   *    math.typeOf(math.parse('sqrt(4)'))    // returns 'FunctionNode'
+   *    math.typeOf(math.parse('A[2]').index) // returns 'IndexNode'
+   *    math.typeOf(math.parse('{a:2}'))      // returns 'ObjectNode'
+   *    math.typeOf(math.parse('(2+3)'))      // returns 'ParenthesisNode'
+   *    math.typeOf(math.parse('1:10'))       // returns 'RangeNode'
+   *    math.typeOf(math.parse('a<b<c'))      // returns 'RelationalNode'
+   *    math.typeOf(math.parse('x'))          // returns 'SymbolNode'
    *
    * @param {*} x     The variable for which to test the type.
    * @return {string} Returns the name of the type. Primitive types are lower case,

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 10.6.3
- * @date    2022-06-24
+ * @version 11.0.1
+ * @date    2022-07-25
  *
  * @license
  * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/plain/bignumber/index.js

@@ -27,7 +27,7 @@ Object.keys(_arithmetic).forEach(function (key) {
 });
 
 // TODO: this is ugly. Instead, be able to pass your own isBigNumber function to typed?
-var BigNumber = _decimal.default.clone();
+var BigNumber = _decimal["default"].clone();
 
 BigNumber.prototype.isBigNumber = true;
 

package/lib/cjs/type/bignumber/BigNumber.js

@@ -17,9 +17,9 @@ var createBigNumberClass = /* #__PURE__ */(0, _factory.factory)(name, dependenci
   var on = _ref.on,
       config = _ref.config;
 
-  var BigNumber = _decimal.default.clone({
+  var BigNumber = _decimal["default"].clone({
     precision: config.precision,
-    modulo: _decimal.default.EUCLID
+    modulo: _decimal["default"].EUCLID
   });
 
   BigNumber.prototype = Object.create(BigNumber.prototype);