mathjs 12.4.3 → 13.0.1

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createClone = void 0;
 var _object = require("../../utils/object.js");
 var _factory = require("../../utils/factory.js");
-var name = 'clone';
-var dependencies = ['typed'];
-var createClone = exports.createClone = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'clone';
+const dependencies = ['typed'];
+const createClone = exports.createClone = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Clone an object. Will make a deep copy of the data.
    *

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

@@ -5,11 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createHasNumericValue = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'hasNumericValue';
-var dependencies = ['typed', 'isNumeric'];
-var createHasNumericValue = exports.createHasNumericValue = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    isNumeric = _ref.isNumeric;
+const name = 'hasNumericValue';
+const dependencies = ['typed', 'isNumeric'];
+const createHasNumericValue = exports.createHasNumericValue = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isNumeric
+  } = _ref;
   /**
    * Test whether a value is an numeric value.
    *
@@ -25,7 +27,9 @@ var createHasNumericValue = exports.createHasNumericValue = /* #__PURE__ */(0, _
    *    math.hasNumericValue('2')                   // returns true
    *    math.isNumeric('2')                         // returns false
    *    math.hasNumericValue(0)                     // returns true
-   *    math.hasNumericValue(math.bignumber(500))   // returns true
+   *    math.hasNumericValue(math.bignumber('500')) // returns true
+   *    math.hasNumericValue(math.bigint('42'))     // returns true
+   *    math.hasNumericValue(42n)                   // returns true
    *    math.hasNumericValue(math.fraction(4))      // returns true
    *    math.hasNumericValue(math.complex('2-4i'))  // returns false
    *    math.hasNumericValue(false)                 // returns true
@@ -41,13 +45,11 @@ var createHasNumericValue = exports.createHasNumericValue = /* #__PURE__ */(0, _
    *                    Throws an error in case of unknown types.
    */
   return typed(name, {
-    "boolean": function boolean() {
-      return true;
-    },
-    string: function string(x) {
+    boolean: () => true,
+    string: function (x) {
       return x.trim().length > 0 && !isNaN(Number(x));
     },
-    any: function any(x) {
+    any: function (x) {
       return isNumeric(x);
     }
   });

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

@@ -7,10 +7,12 @@ exports.createIsInteger = void 0;
 var _collection = require("../../utils/collection.js");
 var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
-var name = 'isInteger';
-var dependencies = ['typed'];
-var createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'isInteger';
+const dependencies = ['typed'];
+const createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Test whether a value is an integer number.
    * The function supports `number`, `BigNumber`, and `Fraction`.
@@ -36,7 +38,7 @@ var createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.fact
    *
    *    isNumeric, isPositive, isNegative, isZero
    *
-   * @param {number | BigNumber | Fraction | Array | Matrix} x   Value to be tested
+   * @param {number | BigNumber | bigint | Fraction | Array | Matrix} x   Value to be tested
    * @return {boolean}  Returns true when `x` contains a numeric, integer value.
    *                    Throws an error in case of an unknown data type.
    */
@@ -44,16 +46,15 @@ var createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.fact
     number: _number.isInteger,
     // TODO: what to do with isInteger(add(0.1, 0.2))  ?
 
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       return x.isInt();
     },
-    Fraction: function Fraction(x) {
+    bigint: function (x) {
+      return true;
+    },
+    Fraction: function (x) {
       return x.d === 1 && isFinite(x.n);
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -7,10 +7,12 @@ exports.createIsNaN = void 0;
 var _collection = require("../../utils/collection.js");
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
-var name = 'isNaN';
-var dependencies = ['typed'];
-var createIsNaN = exports.createIsNaN = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'isNaN';
+const dependencies = ['typed'];
+const createIsNaN = exports.createIsNaN = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Test whether a value is NaN (not a number).
    * The function supports types `number`, `BigNumber`, `Fraction`, `Unit` and `Complex`.
@@ -36,28 +38,27 @@ var createIsNaN = exports.createIsNaN = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    isNumeric, isNegative, isPositive, isZero, isInteger
    *
-   * @param {number | BigNumber | Fraction | Unit | Array | Matrix} x  Value to be tested
+   * @param {number | BigNumber | bigint | Fraction | Unit | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is NaN.
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
     number: _index.isNaNNumber,
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       return x.isNaN();
     },
-    Fraction: function Fraction(x) {
+    bigint: function (x) {
       return false;
     },
-    Complex: function Complex(x) {
+    Fraction: function (x) {
+      return false;
+    },
+    Complex: function (x) {
       return x.isNaN();
     },
-    Unit: function Unit(x) {
+    Unit: function (x) {
       return Number.isNaN(x.value);
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -7,10 +7,15 @@ exports.createIsNegative = void 0;
 var _collection = require("../../utils/collection.js");
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
-var name = 'isNegative';
-var dependencies = ['typed'];
-var createIsNegative = exports.createIsNegative = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
+var _number = require("../../utils/number.js");
+const name = 'isNegative';
+const dependencies = ['typed', 'config'];
+const createIsNegative = exports.createIsNegative = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config
+  } = _ref;
   /**
    * Test whether a value is negative: smaller than zero.
    * The function supports types `number`, `BigNumber`, `Fraction`, and `Unit`.
@@ -36,27 +41,18 @@ var createIsNegative = exports.createIsNegative = /* #__PURE__ */(0, _factory.fa
    *
    *    isNumeric, isPositive, isZero, isInteger
    *
-   * @param {number | BigNumber | Fraction | Unit | Array | Matrix} x  Value to be tested
+   * @param {number | BigNumber | bigint | Fraction | Unit | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is larger than zero.
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: _index.isNegativeNumber,
-    BigNumber: function BigNumber(x) {
-      return x.isNeg() && !x.isZero() && !x.isNaN();
-    },
-    Fraction: function Fraction(x) {
-      return x.s < 0; // It's enough to decide on the sign
-    },
-    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);
-      };
-    })
+    number: x => (0, _number.nearlyEqual)(x, 0, config.relTol, config.absTol) ? false : (0, _index.isNegativeNumber)(x),
+    BigNumber: x => (0, _nearlyEqual.nearlyEqual)(x, new x.constructor(0), config.relTol, config.absTol) ? false : x.isNeg() && !x.isZero() && !x.isNaN(),
+    bigint: x => x < 0n,
+    Fraction: x => x.s < 0,
+    // It's enough to decide on the sign
+
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createIsNumeric = void 0;
 var _collection = require("../../utils/collection.js");
 var _factory = require("../../utils/factory.js");
-var name = 'isNumeric';
-var dependencies = ['typed'];
-var createIsNumeric = exports.createIsNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'isNumeric';
+const dependencies = ['typed'];
+const createIsNumeric = exports.createIsNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Test whether a value is an numeric value.
    *
@@ -25,7 +27,8 @@ var createIsNumeric = exports.createIsNumeric = /* #__PURE__ */(0, _factory.fact
    *    math.isNumeric('2')                   // returns false
    *    math.hasNumericValue('2')             // returns true
    *    math.isNumeric(0)                     // returns true
-   *    math.isNumeric(math.bignumber(500))   // returns true
+   *    math.isNumeric(math.bignumber('42'))  // returns true
+   *    math.isNumeric(math.bigint('42'))     // returns true
    *    math.isNumeric(math.fraction(4))      // returns true
    *    math.isNumeric(math.complex('2-4i'))  // returns false
    *    math.isNumeric([2.3, 'foo', false])   // returns [true, false, true]
@@ -40,16 +43,8 @@ var createIsNumeric = exports.createIsNumeric = /* #__PURE__ */(0, _factory.fact
    *                    Throws an error in case of unknown types.
    */
   return typed(name, {
-    'number | BigNumber | Fraction | boolean': function numberBigNumberFractionBoolean() {
-      return true;
-    },
-    'Complex | Unit | string | null | undefined | Node': function ComplexUnitStringNullUndefinedNode() {
-      return false;
-    },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'number | BigNumber | bigint | Fraction | boolean': () => true,
+    'Complex | Unit | string | null | undefined | Node': () => false,
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -7,10 +7,15 @@ exports.createIsPositive = void 0;
 var _collection = require("../../utils/collection.js");
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
-var name = 'isPositive';
-var dependencies = ['typed'];
-var createIsPositive = exports.createIsPositive = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
+var _number = require("../../utils/number.js");
+const name = 'isPositive';
+const dependencies = ['typed', 'config'];
+const createIsPositive = exports.createIsPositive = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config
+  } = _ref;
   /**
    * Test whether a value is positive: larger than zero.
    * The function supports types `number`, `BigNumber`, `Fraction`, and `Unit`.
@@ -38,27 +43,16 @@ var createIsPositive = exports.createIsPositive = /* #__PURE__ */(0, _factory.fa
    *
    *    isNumeric, isZero, isNegative, isInteger
    *
-   * @param {number | BigNumber | Fraction | Unit | Array | Matrix} x  Value to be tested
+   * @param {number | BigNumber | bigint | Fraction | Unit | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is larger than zero.
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: _index.isPositiveNumber,
-    BigNumber: function BigNumber(x) {
-      return !x.isNeg() && !x.isZero() && !x.isNaN();
-    },
-    Fraction: function Fraction(x) {
-      return x.s > 0 && x.n > 0;
-    },
-    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);
-      };
-    })
+    number: x => (0, _number.nearlyEqual)(x, 0, config.relTol, config.absTol) ? false : (0, _index.isPositiveNumber)(x),
+    BigNumber: x => (0, _nearlyEqual.nearlyEqual)(x, new x.constructor(0), config.relTol, config.absTol) ? false : !x.isNeg() && !x.isZero() && !x.isNaN(),
+    bigint: x => x > 0n,
+    Fraction: x => x.s > 0 && x.n > 0,
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createIsPrime = void 0;
 var _collection = require("../../utils/collection.js");
 var _factory = require("../../utils/factory.js");
-var name = 'isPrime';
-var dependencies = ['typed'];
-var createIsPrime = exports.createIsPrime = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'isPrime';
+const dependencies = ['typed'];
+const createIsPrime = exports.createIsPrime = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Test whether a value is prime: has no divisors other than itself and one.
    * The function supports type `number`, `bignumber`.
@@ -34,37 +36,45 @@ var createIsPrime = exports.createIsPrime = /* #__PURE__ */(0, _factory.factory)
    *
    *    isNumeric, isZero, isNegative, isInteger
    *
-   * @param {number | BigNumber | Array | Matrix} x  Value to be tested
+   * @param {number | BigNumber | bigint | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is larger than zero.
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: function number(x) {
-      if (x * 0 !== 0) {
-        return false;
-      }
+    number: function (x) {
       if (x <= 3) {
         return x > 1;
       }
       if (x % 2 === 0 || x % 3 === 0) {
         return false;
       }
-      for (var i = 5; i * i <= x; i += 6) {
+      for (let i = 5; i * i <= x; i += 6) {
         if (x % i === 0 || x % (i + 2) === 0) {
           return false;
         }
       }
       return true;
     },
-    BigNumber: function BigNumber(n) {
-      if (n.toNumber() * 0 !== 0) {
+    bigint: function (x) {
+      if (x <= 3n) {
+        return x > 1n;
+      }
+      if (x % 2n === 0n || x % 3n === 0n) {
         return false;
       }
+      for (let i = 5n; i * i <= x; i += 6n) {
+        if (x % i === 0n || x % (i + 2n) === 0n) {
+          return false;
+        }
+      }
+      return true;
+    },
+    BigNumber: function (n) {
       if (n.lte(3)) return n.gt(1);
       if (n.mod(2).eq(0) || n.mod(3).eq(0)) return false;
       if (n.lt(Math.pow(2, 32))) {
-        var x = n.toNumber();
-        for (var i = 5; i * i <= x; i += 6) {
+        const x = n.toNumber();
+        for (let i = 5; i * i <= x; i += 6) {
           if (x % i === 0 || x % (i + 2) === 0) {
             return false;
           }
@@ -73,7 +83,7 @@ var createIsPrime = exports.createIsPrime = /* #__PURE__ */(0, _factory.factory)
       }
       function modPow(base, exponent, modulus) {
         // exponent can be huge, use non-recursive variant
-        var accumulator = 1;
+        let accumulator = 1;
         while (!exponent.eq(0)) {
           if (exponent.mod(2).eq(0)) {
             exponent = exponent.div(2);
@@ -87,35 +97,33 @@ var createIsPrime = exports.createIsPrime = /* #__PURE__ */(0, _factory.factory)
       }
 
       // https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test#Deterministic_variants
-      var Decimal = n.constructor.clone({
+      const Decimal = n.constructor.clone({
         precision: n.toFixed(0).length * 2
       });
       n = new Decimal(n);
-      var r = 0;
-      var d = n.sub(1);
+      let r = 0;
+      let d = n.sub(1);
       while (d.mod(2).eq(0)) {
         d = d.div(2);
         r += 1;
       }
-      var bases = null;
+      let bases = null;
       // https://en.wikipedia.org/wiki/Miller–Rabin_primality_test#Testing_against_small_sets_of_bases
       if (n.lt('3317044064679887385961981')) {
-        bases = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41].filter(function (x) {
-          return x < n;
-        });
+        bases = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41].filter(x => x < n);
       } else {
-        var max = Math.min(n.toNumber() - 2, Math.floor(2 * Math.pow(n.toFixed(0).length * Math.log(10), 2)));
+        const max = Math.min(n.toNumber() - 2, Math.floor(2 * Math.pow(n.toFixed(0).length * Math.log(10), 2)));
         bases = [];
-        for (var _i = 2; _i <= max; _i += 1) {
+        for (let i = 2; i <= max; i += 1) {
           bases.push(max);
         }
       }
-      for (var _i2 = 0; _i2 < bases.length; _i2 += 1) {
-        var a = bases[_i2];
-        var adn = modPow(n.sub(n).add(a), d, n);
+      for (let i = 0; i < bases.length; i += 1) {
+        const a = bases[i];
+        const adn = modPow(n.sub(n).add(a), d, n);
         if (!adn.eq(1)) {
-          for (var _i3 = 0, _x = adn; !_x.eq(n.sub(1)); _i3 += 1, _x = _x.mul(_x).mod(n)) {
-            if (_i3 === r - 1) {
+          for (let i = 0, x = adn; !x.eq(n.sub(1)); i += 1, x = x.mul(x).mod(n)) {
+            if (i === r - 1) {
               return false;
             }
           }
@@ -123,10 +131,6 @@ var createIsPrime = exports.createIsPrime = /* #__PURE__ */(0, _factory.factory)
       }
       return true;
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createIsZero = void 0;
 var _collection = require("../../utils/collection.js");
 var _factory = require("../../utils/factory.js");
-var _index = require("../../plain/number/index.js");
-var name = 'isZero';
-var dependencies = ['typed'];
-var createIsZero = exports.createIsZero = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'isZero';
+const dependencies = ['typed', 'equalScalar'];
+const createIsZero = exports.createIsZero = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    equalScalar
+  } = _ref;
   /**
    * Test whether a value is zero.
    * The function can check for zero for types `number`, `BigNumber`, `Fraction`,
@@ -40,30 +42,14 @@ var createIsZero = exports.createIsZero = /* #__PURE__ */(0, _factory.factory)(n
    *
    *    isNumeric, isPositive, isNegative, isInteger
    *
-   * @param {number | BigNumber | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
    * @return {boolean}  Returns true when `x` is zero.
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: _index.isZeroNumber,
-    BigNumber: function BigNumber(x) {
-      return x.isZero();
-    },
-    Complex: function Complex(x) {
-      return x.re === 0 && x.im === 0;
-    },
-    Fraction: function Fraction(x) {
-      return x.d === 1 && x.n === 0;
-    },
-    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);
-      };
-    })
+    'number | BigNumber | Complex | Fraction': x => equalScalar(x, 0),
+    bigint: x => x === 0n,
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -7,13 +7,15 @@ exports.createNumeric = void 0;
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
 var _noop = require("../../utils/noop.js");
-var name = 'numeric';
-var dependencies = ['number', '?bignumber', '?fraction'];
-var createNumeric = exports.createNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var _number = _ref.number,
-    bignumber = _ref.bignumber,
-    fraction = _ref.fraction;
-  var validInputTypes = {
+const name = 'numeric';
+const dependencies = ['number', '?bignumber', '?fraction'];
+const createNumeric = exports.createNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    number,
+    bignumber,
+    fraction
+  } = _ref;
+  const validInputTypes = {
     string: true,
     number: true,
     BigNumber: true,
@@ -21,20 +23,15 @@ var createNumeric = exports.createNumeric = /* #__PURE__ */(0, _factory.factory)
   };
 
   // Load the conversion functions for each output type
-  var validOutputTypes = {
-    number: function number(x) {
-      return _number(x);
-    },
-    BigNumber: bignumber ? function (x) {
-      return bignumber(x);
-    } : _noop.noBignumber,
-    Fraction: fraction ? function (x) {
-      return fraction(x);
-    } : _noop.noFraction
+  const validOutputTypes = {
+    number: x => number(x),
+    BigNumber: bignumber ? x => bignumber(x) : _noop.noBignumber,
+    bigint: x => BigInt(x),
+    Fraction: fraction ? x => fraction(x) : _noop.noFraction
   };
 
   /**
-   * Convert a numeric input to a specific numeric type: number, BigNumber, or Fraction.
+   * Convert a numeric input to a specific numeric type: number, BigNumber, bigint, or Fraction.
    *
    * Syntax:
    *
@@ -44,6 +41,7 @@ var createNumeric = exports.createNumeric = /* #__PURE__ */(0, _factory.factory)
    *
    *    math.numeric('4')                           // returns 4
    *    math.numeric('4', 'number')                 // returns 4
+   *    math.numeric('4', 'bigint')                 // returns 4n
    *    math.numeric('4', 'BigNumber')              // returns BigNumber 4
    *    math.numeric('4', 'Fraction')               // returns Fraction 4
    *    math.numeric(4, 'Fraction')                 // returns Fraction 4
@@ -51,23 +49,23 @@ var createNumeric = exports.createNumeric = /* #__PURE__ */(0, _factory.factory)
    *
    * See also:
    *
-   *    number, fraction, bignumber, string, format
+   *    number, fraction, bignumber, bigint, string, format
    *
-   * @param {string | number | BigNumber | Fraction } value
+   * @param {string | number | BigNumber | bigint | Fraction } value
    *              A numeric value or a string containing a numeric value
    * @param {string} outputType
    *              Desired numeric output type.
    *              Available values: 'number', 'BigNumber', or 'Fraction'
-   * @return {number | BigNumber | Fraction}
+   * @return {number | BigNumber | bigint | Fraction}
    *              Returns an instance of the numeric in the requested type
    */
   return function numeric(value) {
-    var outputType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'number';
-    var check = arguments.length > 2 ? arguments[2] : undefined;
+    let outputType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'number';
+    let 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);
+    const inputType = (0, _is.typeOf)(value);
     if (!(inputType in validInputTypes)) {
       throw new TypeError('Cannot convert ' + value + ' of type "' + inputType + '"; valid input types are ' + Object.keys(validInputTypes).join(', '));
     }

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createTypeOf = void 0;
 var _factory = require("../../utils/factory.js");
 var _is = require("../../utils/is.js");
-var name = 'typeOf';
-var dependencies = ['typed'];
-var createTypeOf = exports.createTypeOf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'typeOf';
+const dependencies = ['typed'];
+const createTypeOf = exports.createTypeOf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Determine the type of an entity.
    *
@@ -22,6 +24,7 @@ var createTypeOf = exports.createTypeOf = /* #__PURE__ */(0, _factory.factory)(n
    *    // This list is intended to include all relevant types, for testing
    *    // purposes:
    *    math.typeOf(3.5)                      // returns 'number'
+   *    math.typeOf(42n)                      // returns 'bigint'
    *    math.typeOf(math.complex('2-4i'))     // returns 'Complex'
    *    math.typeOf(math.unit('45 deg'))      // returns 'Unit'
    *    math.typeOf('hello world')            // returns 'string'

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 12.4.3
- * @date    2024-05-31
+ * @version 13.0.1
+ * @date    2024-06-28
  *
  * @license
  * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>