mathjs 12.4.3 → 13.0.0

package/lib/cjs/utils/bignumber/constants.js

@@ -10,10 +10,10 @@ var _function = require("../function.js");
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns e
  */
-var createBigNumberE = exports.createBigNumberE = (0, _function.memoize)(function (BigNumber) {
+const createBigNumberE = exports.createBigNumberE = (0, _function.memoize)(function (BigNumber) {
   return new BigNumber(1).exp();
 }, {
-  hasher: hasher
+  hasher
 });
 
 /**
@@ -21,10 +21,10 @@ var createBigNumberE = exports.createBigNumberE = (0, _function.memoize)(functio
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns phi
  */
-var createBigNumberPhi = exports.createBigNumberPhi = (0, _function.memoize)(function (BigNumber) {
+const createBigNumberPhi = exports.createBigNumberPhi = (0, _function.memoize)(function (BigNumber) {
   return new BigNumber(1).plus(new BigNumber(5).sqrt()).div(2);
 }, {
-  hasher: hasher
+  hasher
 });
 
 /**
@@ -32,10 +32,10 @@ var createBigNumberPhi = exports.createBigNumberPhi = (0, _function.memoize)(fun
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns pi
  */
-var createBigNumberPi = exports.createBigNumberPi = (0, _function.memoize)(function (BigNumber) {
+const createBigNumberPi = exports.createBigNumberPi = (0, _function.memoize)(function (BigNumber) {
   return BigNumber.acos(-1);
 }, {
-  hasher: hasher
+  hasher
 });
 
 /**
@@ -43,10 +43,10 @@ var createBigNumberPi = exports.createBigNumberPi = (0, _function.memoize)(funct
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns tau
  */
-var createBigNumberTau = exports.createBigNumberTau = (0, _function.memoize)(function (BigNumber) {
+const createBigNumberTau = exports.createBigNumberTau = (0, _function.memoize)(function (BigNumber) {
   return createBigNumberPi(BigNumber).times(2);
 }, {
-  hasher: hasher
+  hasher
 });
 
 /**

package/lib/cjs/utils/bignumber/formatter.js

@@ -17,9 +17,9 @@ var _number = require("../number.js");
  * @returns {string}
  */
 function formatBigNumberToBase(n, base, size) {
-  var BigNumberCtor = n.constructor;
-  var big2 = new BigNumberCtor(2);
-  var suffix = '';
+  const BigNumberCtor = n.constructor;
+  const big2 = new BigNumberCtor(2);
+  let suffix = '';
   if (size) {
     if (size < 1) {
       throw new Error('size must be in greater than 0');
@@ -28,7 +28,7 @@ function formatBigNumberToBase(n, base, size) {
       throw new Error('size must be an integer');
     }
     if (n.greaterThan(big2.pow(size - 1).sub(1)) || n.lessThan(big2.pow(size - 1).mul(-1))) {
-      throw new Error("Value must be in range [-2^".concat(size - 1, ", 2^").concat(size - 1, "-1]"));
+      throw new Error(`Value must be in range [-2^${size - 1}, 2^${size - 1}-1]`);
     }
     if (!n.isInteger()) {
       throw new Error('Value must be an integer');
@@ -36,17 +36,17 @@ function formatBigNumberToBase(n, base, size) {
     if (n.lessThan(0)) {
       n = n.add(big2.pow(size));
     }
-    suffix = "i".concat(size);
+    suffix = `i${size}`;
   }
   switch (base) {
     case 2:
-      return "".concat(n.toBinary()).concat(suffix);
+      return `${n.toBinary()}${suffix}`;
     case 8:
-      return "".concat(n.toOctal()).concat(suffix);
+      return `${n.toOctal()}${suffix}`;
     case 16:
-      return "".concat(n.toHexadecimal()).concat(suffix);
+      return `${n.toHexadecimal()}${suffix}`;
     default:
-      throw new Error("Base ".concat(base, " not supported "));
+      throw new Error(`Base ${base} not supported `);
   }
 }
 
@@ -141,10 +141,11 @@ function format(value, options) {
   if (!value.isFinite()) {
     return value.isNaN() ? 'NaN' : value.gt(0) ? 'Infinity' : '-Infinity';
   }
-  var _normalizeFormatOptio = (0, _number.normalizeFormatOptions)(options),
-    notation = _normalizeFormatOptio.notation,
-    precision = _normalizeFormatOptio.precision,
-    wordSize = _normalizeFormatOptio.wordSize;
+  const {
+    notation,
+    precision,
+    wordSize
+  } = (0, _number.normalizeFormatOptions)(options);
 
   // handle the various notations
   switch (notation) {
@@ -164,16 +165,16 @@ function format(value, options) {
       {
         // determine lower and upper bound for exponential notation.
         // TODO: implement support for upper and lower to be BigNumbers themselves
-        var lowerExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.lowerExp, -3);
-        var upperExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.upperExp, 5);
+        const lowerExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.lowerExp, -3);
+        const upperExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.upperExp, 5);
 
         // handle special case zero
         if (value.isZero()) return '0';
 
         // determine whether or not to output exponential notation
-        var str;
-        var rounded = value.toSignificantDigits(precision);
-        var exp = rounded.e;
+        let str;
+        const rounded = value.toSignificantDigits(precision);
+        const exp = rounded.e;
         if (exp >= lowerExp && exp < upperExp) {
           // normal number notation
           str = rounded.toFixed();
@@ -184,8 +185,8 @@ function format(value, options) {
 
         // remove trailing zeros after the decimal point
         return str.replace(/((\.\d*?)(0+))($|e)/, function () {
-          var digits = arguments[2];
-          var e = arguments[4];
+          const digits = arguments[2];
+          const e = arguments[4];
           return digits !== '.' ? digits + e : e;
         });
       }
@@ -201,14 +202,14 @@ function format(value, options) {
  */
 function toEngineering(value, precision) {
   // find nearest lower multiple of 3 for exponent
-  var e = value.e;
-  var newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
+  const e = value.e;
+  const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
 
   // find difference in exponents, and calculate the value without exponent
-  var valueWithoutExp = value.mul(Math.pow(10, -newExp));
-  var valueStr = valueWithoutExp.toPrecision(precision);
+  const valueWithoutExp = value.mul(Math.pow(10, -newExp));
+  let valueStr = valueWithoutExp.toPrecision(precision);
   if (valueStr.includes('e')) {
-    var BigNumber = value.constructor;
+    const BigNumber = value.constructor;
     valueStr = new BigNumber(valueStr).toFixed();
   }
   return valueStr + 'e' + (e >= 0 ? '+' : '') + newExp.toString();

package/lib/cjs/utils/bignumber/nearlyEqual.js

@@ -6,42 +6,40 @@ Object.defineProperty(exports, "__esModule", {
 exports.nearlyEqual = nearlyEqual;
 /**
  * Compares two BigNumbers.
- * @param {BigNumber} x       First value to compare
- * @param {BigNumber} y       Second value to compare
- * @param {number} [epsilon]  The maximum relative difference between x and y
- *                            If epsilon is undefined or null, the function will
- *                            test whether x and y are exactly equal.
- * @return {boolean} whether the two numbers are nearly equal
+ * @param {BigNumber} a - First value to compare
+ * @param {BigNumber} b - Second value to compare
+ * @param {number} [relTol=1e-09] - The relative tolerance, indicating the maximum allowed difference relative to the larger absolute value. Must be greater than 0.
+ * @param {number} [absTol=0] - The minimum absolute tolerance, useful for comparisons near zero. Must be at least 0.
+ * @returns {boolean} whether the two numbers are nearly equal
+ * @throws {Error} If `relTol` is less than or equal to 0.
+ * @throws {Error} If `absTol` is less than 0.
+ *
+ * @example
+ * nearlyEqual(1.000000001, 1.0, 1e-9);            // true
+ * nearlyEqual(1.000000002, 1.0, 0);            // false
+ * nearlyEqual(1.0, 1.009, undefined, 0.02);       // true
+ * nearlyEqual(0.000000001, 0.0, undefined, 1e-8); // true
  */
-function nearlyEqual(x, y, epsilon) {
-  // if epsilon is null or undefined, test whether x and y are exactly equal
-  if (epsilon === null || epsilon === undefined) {
-    return x.eq(y);
+function nearlyEqual(a, b) {
+  let relTol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1e-9;
+  let absTol = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  if (relTol <= 0) {
+    throw new Error('Relative tolerance must be greater than 0');
   }
-
-  // use "==" operator, handles infinities
-  if (x.eq(y)) {
-    return true;
+  if (absTol < 0) {
+    throw new Error('Absolute tolerance must be at least 0');
   }
-
   // NaN
-  if (x.isNaN() || y.isNaN()) {
+  if (a.isNaN() || b.isNaN()) {
     return false;
   }
-
-  // at this point x and y should be finite
-  if (x.isFinite() && y.isFinite()) {
-    // check numbers are very close, needed when comparing numbers near zero
-    var diff = x.minus(y).abs();
-    if (diff.isZero()) {
-      return true;
-    } else {
-      // use relative error
-      var max = x.constructor.max(x.abs(), y.abs());
-      return diff.lte(max.times(epsilon));
-    }
+  if (!a.isFinite() || !b.isFinite()) {
+    return a.eq(b);
   }
-
-  // Infinite and Number or negative Infinite and positive Infinite cases
-  return false;
+  // use "==" operator, handles infinities
+  if (a.eq(b)) {
+    return true;
+  }
+  // abs(a-b) <= max(relTol * max(abs(a), abs(b)), absTol)
+  return a.minus(b).abs().lte(a.constructor.max(a.constructor.max(a.abs(), b.abs()).mul(relTol), absTol));
 }

package/lib/cjs/utils/collection.js

@@ -19,7 +19,7 @@ var _switch2 = require("./switch.js");
  *                    collections (Arrays or Matrices). Returns false otherwise.
  */
 function containsCollections(array) {
-  for (var i = 0; i < array.length; i++) {
+  for (let i = 0; i < array.length; i++) {
     if ((0, _is.isCollection)(array[i])) {
       return true;
     }
@@ -38,8 +38,8 @@ function deepForEach(array, callback) {
   if ((0, _is.isMatrix)(array)) {
     array = array.valueOf();
   }
-  for (var i = 0, ii = array.length; i < ii; i++) {
-    var value = array[i];
+  for (let i = 0, ii = array.length; i < ii; i++) {
+    const value = array[i];
     if (Array.isArray(value)) {
       deepForEach(value, callback);
     } else {
@@ -81,7 +81,7 @@ function deepMap(array, callback, skipZeros) {
  * @return {Array | Matrix} res
  */
 function reduce(mat, dim, callback) {
-  var size = Array.isArray(mat) ? (0, _array.arraySize)(mat) : mat.size();
+  const size = Array.isArray(mat) ? (0, _array.arraySize)(mat) : mat.size();
   if (dim < 0 || dim >= size.length) {
     // TODO: would be more clear when throwing a DimensionError here
     throw new _IndexError.IndexError(dim, size.length);
@@ -102,7 +102,7 @@ function reduce(mat, dim, callback) {
  * @private
  */
 function _reduce(mat, dim, callback) {
-  var i, ret, val, tran;
+  let i, ret, val, tran;
   if (dim <= 0) {
     if (!Array.isArray(mat[0])) {
       val = mat[0];
@@ -130,12 +130,12 @@ function _reduce(mat, dim, callback) {
 // TODO: document function scatter
 function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
   // a arrays
-  var avalues = a._values;
-  var aindex = a._index;
-  var aptr = a._ptr;
+  const avalues = a._values;
+  const aindex = a._index;
+  const aptr = a._ptr;
 
   // vars
-  var k, k0, k1, i;
+  let k, k0, k1, i;
 
   // check we need to process values (pattern matrix)
   if (x) {

package/lib/cjs/utils/complex.js

@@ -6,13 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.complexEquals = complexEquals;
 var _number = require("./number.js");
 /**
- * Test whether two complex values are equal provided a given epsilon.
+ * Test whether two complex values are equal provided a given relTol and absTol.
  * Does not use or change the global Complex.EPSILON setting
- * @param {Complex} x
- * @param {Complex} y
- * @param {number} epsilon
- * @returns {boolean}
+ * @param {Complex} x - The first complex number for comparison.
+ * @param {Complex} y - The second complex number for comparison.
+ * @param {number} relTol - The relative tolerance for comparison.
+ * @param {number} absTol - The absolute tolerance for comparison.
+ * @returns {boolean} - Returns true if the two complex numbers are equal within the given tolerances, otherwise returns false.
  */
-function complexEquals(x, y, epsilon) {
-  return (0, _number.nearlyEqual)(x.re, y.re, epsilon) && (0, _number.nearlyEqual)(x.im, y.im, epsilon);
+function complexEquals(x, y, relTol, absTol) {
+  return (0, _number.nearlyEqual)(x.re, y.re, relTol, absTol) && (0, _number.nearlyEqual)(x.im, y.im, relTol, absTol);
 }

package/lib/cjs/utils/customs.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -12,7 +11,6 @@ exports.isPlainObject = isPlainObject;
 exports.isSafeMethod = isSafeMethod;
 exports.isSafeProperty = isSafeProperty;
 exports.setSafeProperty = setSafeProperty;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _object = require("./object.js");
 /**
  * Get a property of a plain object
@@ -52,9 +50,7 @@ function setSafeProperty(object, prop, value) {
   throw new Error('No access to property "' + prop + '"');
 }
 function getSafeProperties(object) {
-  return Object.keys(object).filter(function (prop) {
-    return (0, _object.hasOwnProperty)(object, prop);
-  });
+  return Object.keys(object).filter(prop => (0, _object.hasOwnProperty)(object, prop));
 }
 function hasSafeProperty(object, prop) {
   return prop in object;
@@ -67,7 +63,7 @@ function hasSafeProperty(object, prop) {
  * @return {boolean} Returns true when safe
  */
 function isSafeProperty(object, prop) {
-  if (!object || (0, _typeof2["default"])(object) !== 'object') {
+  if (!object || typeof object !== 'object') {
     return false;
   }
   // SAFE: whitelisted
@@ -149,13 +145,13 @@ function isSafeMethod(object, method) {
   return true;
 }
 function isPlainObject(object) {
-  return (0, _typeof2["default"])(object) === 'object' && object && object.constructor === Object;
+  return typeof object === 'object' && object && object.constructor === Object;
 }
-var safeNativeProperties = {
+const safeNativeProperties = {
   length: true,
   name: true
 };
-var safeNativeMethods = {
+const safeNativeMethods = {
   toString: true,
   valueOf: true,
   toLocaleString: true

package/lib/cjs/utils/emitter.js

@@ -13,7 +13,7 @@ var _tinyEmitter = _interopRequireDefault(require("tiny-emitter"));
  */
 function mixin(obj) {
   // create event emitter
-  var emitter = new _tinyEmitter["default"]();
+  const emitter = new _tinyEmitter.default();
 
   // bind methods to obj (we don't want to expose the emitter.e Array...)
   obj.on = emitter.on.bind(emitter);

package/lib/cjs/utils/factory.js

@@ -40,7 +40,7 @@ function factory(name, dependencies, create, meta) {
     // we only pass the requested dependencies to the factory function
     // to prevent functions to rely on dependencies that are not explicitly
     // requested.
-    var deps = (0, _object.pickShallow)(scope, dependencies.map(stripOptionalNotation));
+    const deps = (0, _object.pickShallow)(scope, dependencies.map(stripOptionalNotation));
     assertDependencies(name, dependencies, scope);
     return create(deps);
   }
@@ -60,8 +60,8 @@ function factory(name, dependencies, create, meta) {
  * @returns {Array} Returns a new array with the sorted factories.
  */
 function sortFactories(factories) {
-  var factoriesByName = {};
-  factories.forEach(function (factory) {
+  const factoriesByName = {};
+  factories.forEach(factory => {
     factoriesByName[factory.fn] = factory;
   });
   function containsDependency(factory, dependency) {
@@ -70,17 +70,15 @@ function sortFactories(factories) {
       if (factory.dependencies.includes(dependency.fn || dependency.name)) {
         return true;
       }
-      if (factory.dependencies.some(function (d) {
-        return containsDependency(factoriesByName[d], dependency);
-      })) {
+      if (factory.dependencies.some(d => containsDependency(factoriesByName[d], dependency))) {
         return true;
       }
     }
     return false;
   }
-  var sorted = [];
+  const sorted = [];
   function addFactory(factory) {
-    var index = 0;
+    let index = 0;
     while (index < sorted.length && !containsDependency(sorted[index], factory)) {
       index++;
     }
@@ -91,18 +89,14 @@ function sortFactories(factories) {
   factories.filter(isFactory).forEach(addFactory);
 
   // sort legacy factory functions AFTER the regular factory functions
-  factories.filter(function (factory) {
-    return !isFactory(factory);
-  }).forEach(addFactory);
+  factories.filter(factory => !isFactory(factory)).forEach(addFactory);
   return sorted;
 }
 
 // TODO: comment or cleanup if unused in the end
 function create(factories) {
-  var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  sortFactories(factories).forEach(function (factory) {
-    return factory(scope);
-  });
+  let scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  sortFactories(factories).forEach(factory => factory(scope));
   return scope;
 }
 
@@ -126,21 +120,13 @@ function isFactory(obj) {
  * @param {Object} scope
  */
 function assertDependencies(name, dependencies, scope) {
-  var allDefined = dependencies.filter(function (dependency) {
-    return !isOptionalDependency(dependency);
-  }) // filter optionals
-  .every(function (dependency) {
-    return scope[dependency] !== undefined;
-  });
+  const allDefined = dependencies.filter(dependency => !isOptionalDependency(dependency)) // filter optionals
+  .every(dependency => scope[dependency] !== undefined);
   if (!allDefined) {
-    var missingDependencies = dependencies.filter(function (dependency) {
-      return scope[dependency] === undefined;
-    });
+    const missingDependencies = dependencies.filter(dependency => scope[dependency] === undefined);
 
     // TODO: create a custom error class for this, a MathjsError or something like that
-    throw new Error("Cannot create function \"".concat(name, "\", ") + "some dependencies are missing: ".concat(missingDependencies.map(function (d) {
-      return "\"".concat(d, "\"");
-    }).join(', '), "."));
+    throw new Error(`Cannot create function "${name}", ` + `some dependencies are missing: ${missingDependencies.map(d => `"${d}"`).join(', ')}.`);
   }
 }
 function isOptionalDependency(dependency) {

package/lib/cjs/utils/function.js

@@ -1,13 +1,11 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.maxArgumentCount = maxArgumentCount;
 exports.memoize = memoize;
 exports.memoizeCompare = memoizeCompare;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _lruQueue = require("./lruQueue.js");
 // function utils
 
@@ -27,30 +25,31 @@ var _lruQueue = require("./lruQueue.js");
  * @return {function}                       Returns the memoized function
  */
 function memoize(fn) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    hasher = _ref.hasher,
-    limit = _ref.limit;
+  let {
+    hasher,
+    limit
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   limit = limit == null ? Number.POSITIVE_INFINITY : limit;
   hasher = hasher == null ? JSON.stringify : hasher;
   return function memoize() {
-    if ((0, _typeof2["default"])(memoize.cache) !== 'object') {
+    if (typeof memoize.cache !== 'object') {
       memoize.cache = {
         values: new Map(),
         lru: (0, _lruQueue.lruQueue)(limit || Number.POSITIVE_INFINITY)
       };
     }
-    var args = [];
-    for (var i = 0; i < arguments.length; i++) {
+    const args = [];
+    for (let i = 0; i < arguments.length; i++) {
       args[i] = arguments[i];
     }
-    var hash = hasher(args);
+    const hash = hasher(args);
     if (memoize.cache.values.has(hash)) {
       memoize.cache.lru.hit(hash);
       return memoize.cache.values.get(hash);
     }
-    var newVal = fn.apply(fn, args);
+    const newVal = fn.apply(fn, args);
     memoize.cache.values.set(hash, newVal);
-    memoize.cache.values["delete"](memoize.cache.lru.hit(hash));
+    memoize.cache.values.delete(memoize.cache.lru.hit(hash));
     return newVal;
   };
 }
@@ -70,22 +69,22 @@ function memoize(fn) {
  * @returns {function}
  */
 function memoizeCompare(fn, isEqual) {
-  var memoize = function memoize() {
-    var args = [];
-    for (var i = 0; i < arguments.length; i++) {
+  const memoize = function memoize() {
+    const args = [];
+    for (let i = 0; i < arguments.length; i++) {
       args[i] = arguments[i];
     }
-    for (var c = 0; c < memoize.cache.length; c++) {
-      var cached = memoize.cache[c];
+    for (let c = 0; c < memoize.cache.length; c++) {
+      const cached = memoize.cache[c];
       if (isEqual(args, cached.args)) {
         // TODO: move this cache entry to the top so recently used entries move up?
         return cached.res;
       }
     }
-    var res = fn.apply(fn, args);
+    const res = fn.apply(fn, args);
     memoize.cache.unshift({
-      args: args,
-      res: res
+      args,
+      res
     });
     return res;
   };
@@ -101,7 +100,7 @@ function memoizeCompare(fn, isEqual) {
  */
 function maxArgumentCount(fn) {
   return Object.keys(fn.signatures || {}).reduce(function (args, signature) {
-    var count = (signature.match(/,/g) || []).length + 1;
+    const count = (signature.match(/,/g) || []).length + 1;
     return Math.max(args, count);
   }, -1);
 }

package/lib/cjs/utils/is.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -8,6 +7,7 @@ exports.isAccessorNode = isAccessorNode;
 exports.isArray = void 0;
 exports.isArrayNode = isArrayNode;
 exports.isAssignmentNode = isAssignmentNode;
+exports.isBigInt = isBigInt;
 exports.isBigNumber = isBigNumber;
 exports.isBlockNode = isBlockNode;
 exports.isBoolean = isBoolean;
@@ -45,7 +45,6 @@ exports.isUndefined = isUndefined;
 exports.isUnit = isUnit;
 exports.rule2Node = rule2Node;
 exports.typeOf = typeOf;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 // type checks for all known types
 //
 // note that:
@@ -64,10 +63,10 @@ function isNumber(x) {
   return typeof x === 'number';
 }
 function isBigNumber(x) {
-  if (!x || (0, _typeof2["default"])(x) !== 'object' || typeof x.constructor !== 'function') {
+  if (!x || typeof x !== 'object' || typeof x.constructor !== 'function') {
     return false;
   }
-  if (x.isBigNumber === true && (0, _typeof2["default"])(x.constructor.prototype) === 'object' && x.constructor.prototype.isBigNumber === true) {
+  if (x.isBigNumber === true && typeof x.constructor.prototype === 'object' && x.constructor.prototype.isBigNumber === true) {
     return true;
   }
   if (typeof x.constructor.isDecimal === 'function' && x.constructor.isDecimal(x) === true) {
@@ -75,11 +74,14 @@ function isBigNumber(x) {
   }
   return false;
 }
+function isBigInt(x) {
+  return typeof x === 'bigint';
+}
 function isComplex(x) {
-  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
+  return x && typeof x === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
 }
 function isFraction(x) {
-  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
+  return x && typeof x === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
 }
 function isUnit(x) {
   return x && x.constructor.prototype.isUnit === true || false;
@@ -87,7 +89,7 @@ function isUnit(x) {
 function isString(x) {
   return typeof x === 'string';
 }
-var isArray = exports.isArray = Array.isArray;
+const isArray = exports.isArray = Array.isArray;
 function isMatrix(x) {
   return x && x.constructor.prototype.isMatrix === true || false;
 }
@@ -131,7 +133,7 @@ function isRegExp(x) {
   return x instanceof RegExp;
 }
 function isObject(x) {
-  return !!(x && (0, _typeof2["default"])(x) === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
+  return !!(x && typeof x === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
 }
 function isNull(x) {
   return x === null;
@@ -205,7 +207,7 @@ function isChain(x) {
   return x && x.constructor.prototype.isChain === true || false;
 }
 function typeOf(x) {
-  var t = (0, _typeof2["default"])(x);
+  const t = typeof x;
   if (t === 'object') {
     if (x === null) return 'null';
     if (isBigNumber(x)) return 'BigNumber'; // Special: weird mashup with Decimal