mathjs 15.0.0 → 15.1.0

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

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsBounded = void 0;
+var _factory = require("../../utils/factory.js");
+const name = 'isBounded';
+const dependencies = ['typed'];
+const createIsBounded = exports.createIsBounded = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is bounded. For scalars, this test is equivalent
+   * to the isFinite finiteness test. On the other hand, a Matrix or Array
+   * is defined to be bounded if every entry is finite.
+   *
+   * Syntax:
+   *
+   *     math.isBounded(x)
+   *
+   * Examples:
+   *
+   *    math.isBounded(0)                        // returns true
+   *    math.isBounded(NaN)                      // returns false
+   *    math.isBounded(math.bignumber(Infinity)) // returns false
+   *    math.isBounded(math.fraction(1,3))       // returns true
+   *    math.isBounded(math.complex('2 - 4i'))   // returns true
+   *    math.isBounded(-10000000000000000n)      // returns true
+   *    math.isBounded(undefined)                // returns false
+   *    math.isBounded(null)                     // returns false
+   *    math.isBounded([0.001, -3n, 0])          // returns true
+   *    math.isBounded([2, -Infinity, -3])       // returns false
+   *
+   * See also:
+   *
+   *    isFinite, isNumeric, isPositive, isNegative, isNaN
+   *
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean}  Returns true when `x` is bounded.
+   */
+  return typed(name, {
+    number: n => Number.isFinite(n),
+    'BigNumber | Complex': x => x.isFinite(),
+    'bigint | Fraction': () => true,
+    'null | undefined': () => false,
+    Unit: typed.referToSelf(self => x => self(x.value)),
+    'Array | Matrix': typed.referToSelf(self => A => {
+      if (!Array.isArray(A)) A = A.valueOf();
+      return A.every(entry => self(entry));
+    })
+  });
+});

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsFinite = void 0;
+var _factory = require("../../utils/factory.js");
+const name = 'isFinite';
+const dependencies = ['typed', 'isBounded', 'map'];
+const createIsFinite = exports.createIsFinite = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isBounded,
+    map
+  } = _ref;
+  /**
+   * Test whether a value is finite.
+   *
+   * Operates elementwise on Array and Matrix values. To test if all entries
+   * of an Array or Matrix are finite, use isBounded.
+   *
+   * Syntax:
+   *
+   *     math.isFinite(x)
+   *
+   * Examples:
+   *
+   *    math.isFinite(0)                        // returns true
+   *    math.isFinite(NaN)                      // returns false
+   *    math.isFinite(math.bignumber(Infinity)) // returns false
+   *    math.isFinite(math.fraction(1,3))       // returns true
+   *    math.isFinite(math.complex('2 - 4i'))   // returns true
+   *    math.isFinite(-10000000000000000n)      // returns true
+   *    math.isFinite(undefined)                // returns false
+   *    math.isFinite(null)                     // returns false
+   *    math.isFinite([0.001, -3n, 0])          // Array [true, true, true]
+   *    math.isFinite([2, -Infinity, -3])       // Array [true, false, true]
+   *
+   * See also:
+   *
+   *    isBounded isNumeric, isPositive, isNegative, isNaN
+   *
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean | Array | Matrix}
+   */
+  return typed(name, {
+    'Array | Matrix': A => map(A, isBounded),
+    any: x => isBounded(x)
+  });
+});

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

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createIsInteger = void 0;
 var _collection = require("../../utils/collection.js");
-var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
 const name = 'isInteger';
-const dependencies = ['typed'];
+const dependencies = ['typed', 'equal'];
 const createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    typed
+    typed,
+    equal
   } = _ref;
   /**
    * Test whether a value is an integer number.
@@ -43,18 +43,10 @@ const createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.fa
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: _number.isInteger,
-    // TODO: what to do with isInteger(add(0.1, 0.2))  ?
-
-    BigNumber: function (x) {
-      return x.isInt();
-    },
-    bigint: function (x) {
-      return true;
-    },
-    Fraction: function (x) {
-      return x.d === 1n;
-    },
+    number: n => Number.isFinite(n) ? equal(n, Math.round(n)) : false,
+    BigNumber: b => b.isFinite() ? equal(b.round(), b) : false,
+    bigint: b => true,
+    Fraction: r => r.d === 1n,
     'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -36,7 +36,7 @@ const createIsNaN = exports.createIsNaN = /* #__PURE__ */(0, _factory.factory)(n
    *
    * See also:
    *
-   *    isNumeric, isNegative, isPositive, isZero, isInteger
+   *    isNumeric, isNegative, isPositive, isZero, isInteger, isFinite, isBounded
    *
    * @param {number | BigNumber | bigint | Fraction | Unit | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is NaN.

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

@@ -35,7 +35,7 @@ const createIsNumeric = exports.createIsNumeric = /* #__PURE__ */(0, _factory.fa
    *
    * See also:
    *
-   *    isZero, isPositive, isNegative, isInteger, hasNumericValue
+   *    isZero, isPositive, isNegative, isInteger, hasNumericValue, isFinite, isBounded
    *
    * @param {*} x       Value to be tested
    * @return {boolean}  Returns true when `x` is a `number`, `BigNumber`,

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 15.0.0
- * @date    2025-10-10
+ * @version 15.1.0
+ * @date    2025-11-05
  *
  * @license
  * Copyright (C) 2013-2025 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/json/replacer.js

@@ -22,7 +22,7 @@ const createReplacer = exports.createReplacer = /* #__PURE__ */(0, _factory.fact
    */
   return function replacer(key, value) {
     // the numeric values Infinitiy, -Infinity, and NaN cannot be serialized to JSON
-    if (typeof value === 'number' && (!isFinite(value) || isNaN(value))) {
+    if (typeof value === 'number' && (!Number.isFinite(value) || isNaN(value))) {
       return {
         mathjs: 'number',
         value: String(value)

package/lib/cjs/plain/number/probability.js

@@ -16,7 +16,7 @@ function gammaNumber(n) {
   let x;
   if ((0, _number.isInteger)(n)) {
     if (n <= 0) {
-      return isFinite(n) ? Infinity : NaN;
+      return Number.isFinite(n) ? Infinity : NaN;
     }
     if (n > 171) {
       return Infinity; // Will overflow
@@ -63,7 +63,7 @@ const lgammaSeries = exports.lgammaSeries = [1.000000000190015, 76.1800917294714
 function lgammaNumber(n) {
   if (n < 0) return NaN;
   if (n === 0) return Infinity;
-  if (!isFinite(n)) return n;
+  if (!Number.isFinite(n)) return n;
   if (n < 0.5) {
     // Use Euler's reflection formula:
     // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))

package/lib/cjs/plain/number/trigonometry.js

@@ -44,7 +44,7 @@ function acotNumber(x) {
 }
 acotNumber.signature = n1;
 function acothNumber(x) {
-  return isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
+  return Number.isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
 }
 acothNumber.signature = n1;
 function acscNumber(x) {

package/lib/cjs/type/fraction/function/fraction.js

@@ -52,7 +52,7 @@ const createFraction = exports.createFraction = /* #__PURE__ */(0, _factory.fact
    */
   return typed('fraction', {
     number: function (x) {
-      if (!isFinite(x) || isNaN(x)) {
+      if (!Number.isFinite(x) || isNaN(x)) {
         throw new Error(x + ' cannot be represented as a fraction');
       }
       return new Fraction(x);

package/lib/cjs/type/matrix/SparseMatrix.js

@@ -21,9 +21,27 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     Matrix
   } = _ref;
   /**
-   * Sparse Matrix implementation. This type implements
-   * a [Compressed Column Storage](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS))
-   * format for two-dimensional sparse matrices.
+   * Sparse Matrix implementation. This type (currently) implements 2D
+   * matrices only via the format known as
+   * [Compressed Column Storage](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS)).
+   *
+   * The structure/invariants of the internal data should be:
+   * 1. _values is an array of the nonzero values in order from top to bottom
+   *    (of each column), left to right.
+   * 2. _index is an array of row numbers, of the same length as and
+   *    corresponding positionally to _values.
+   * 3. _ptr is an array of length one more than the number of columns. For j
+   *    less than the number of columns, the "half-open" span of indices
+   *    _ptr[j] to _ptr[j+1] (i.e. including _ptr[j] if it is less than
+   *    _ptr[j+1], but never including _ptr[j+1]) are the indices in _values
+   *    of the nonzero elements in column j. Note there are no nonzero elements
+   *    in column j exactly when _ptr[j] === _ptr[j+1], and that the final
+   *    entry in _ptr is always exactly the number of nonzero entries in the
+   *    matrix.
+   * 4. _size is a length-2 array consisting of the number of rows followed by
+   *    the number of columns.
+   * 5. _datatype, if set, is the mathjs typeOf value of all entries of the
+   *    SparseMatrix.
    * @class SparseMatrix
    */
   function SparseMatrix(data, datatype) {
@@ -141,7 +159,9 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
       } while (j < columns);
     }
     // store number of values in ptr
-    matrix._ptr.push(matrix._index.length);
+    while (matrix._ptr.length <= columns) {
+      matrix._ptr.push(matrix._index.length);
+    }
     // size
     matrix._size = [rows, columns];
   }

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

@@ -13,7 +13,7 @@ var _string = require("../../utils/string.js");
 var _object = require("../../utils/object.js");
 var _constants = require("../../utils/bignumber/constants.js");
 const name = 'Unit';
-const dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'toBest', 'number', 'Complex', 'BigNumber', 'Fraction'];
+const dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
 const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     on,
@@ -29,13 +29,15 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
     equal,
     isNumeric,
     format,
-    toBest,
     number,
     Complex,
     BigNumber,
     Fraction
   } = _ref;
   const toNumber = number;
+  const fixPrefixDefault = false;
+  const skipAutomaticSimplificationDefault = true;
+
   /**
    * A unit can be constructed in the following ways:
    *
@@ -62,13 +64,13 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
     if (!(value === null || value === undefined || isNumeric(value) || (0, _is.isComplex)(value))) {
       throw new TypeError('First parameter in Unit constructor must be number, BigNumber, Fraction, Complex, or undefined');
     }
-    this.fixPrefix = false; // if true, function format will not search for the
+    this.fixPrefix = fixPrefixDefault; // 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 supplied.
-    this.skipAutomaticSimplification = true;
+    this.skipAutomaticSimplification = skipAutomaticSimplificationDefault;
     if (valuelessUnit === undefined) {
       this.units = [];
       this.dimensions = BASE_DIMENSIONS.map(x => 0);
@@ -862,14 +864,15 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
    * Get a JSON representation of the unit
    * @memberof Unit
    * @returns {Object} Returns a JSON object structured as:
-   *                   `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
+   *                   `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false, "skipSimp": true}`
    */
   Unit.prototype.toJSON = function () {
     return {
       mathjs: 'Unit',
       value: this._denormalize(this.value),
       unit: this.units.length > 0 ? this.formatUnits() : null,
-      fixPrefix: this.fixPrefix
+      fixPrefix: this.fixPrefix,
+      skipSimp: this.skipAutomaticSimplification
     };
   };
 
@@ -881,9 +884,10 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
    * @return {Unit}
    */
   Unit.fromJSON = function (json) {
-    var _json$unit;
+    var _json$unit, _json$fixPrefix, _json$skipSimp;
     const unit = new Unit(json.value, (_json$unit = json.unit) !== null && _json$unit !== void 0 ? _json$unit : undefined);
-    unit.fixPrefix = json.fixPrefix || false;
+    unit.fixPrefix = (_json$fixPrefix = json.fixPrefix) !== null && _json$fixPrefix !== void 0 ? _json$fixPrefix : fixPrefixDefault;
+    unit.skipAutomaticSimplification = (_json$skipSimp = json.skipSimp) !== null && _json$skipSimp !== void 0 ? _json$skipSimp : skipAutomaticSimplificationDefault;
     return unit;
   };
 

package/lib/cjs/utils/number.js

@@ -36,7 +36,7 @@ function isInteger(value) {
   if (typeof value === 'boolean') {
     return true;
   }
-  return isFinite(value) ? value === Math.round(value) : false;
+  return Number.isFinite(value) ? value === Math.round(value) : false;
 }
 
 /**
@@ -128,7 +128,7 @@ const cbrt = exports.cbrt = Math.cbrt || function cbrt(x) {
   if (negate) {
     x = -x;
   }
-  if (isFinite(x)) {
+  if (Number.isFinite(x)) {
     result = Math.exp(Math.log(x) / 3);
     // from https://en.wikipedia.org/wiki/Cube_root#Numerical_methods
     result = (x / (result * result) + 2 * result) / 3;
@@ -404,7 +404,7 @@ function splitNumber(value) {
  * @param {number} [precision]        Optional number of significant figures to return.
  */
 function toEngineering(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(value)) {
     return String(value);
   }
   const split = splitNumber(value);
@@ -453,7 +453,7 @@ function toEngineering(value, precision) {
  *                                        decimal point. null by default.
  */
 function toFixed(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(value)) {
     return String(value);
   }
   const splitValue = splitNumber(value);
@@ -488,7 +488,7 @@ function toFixed(value, precision) {
  *                              is used.
  */
 function toExponential(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(Number(value))) {
     return String(value);
   }
 
@@ -519,7 +519,7 @@ function toExponential(value, precision) {
  * @return {string}
  */
 function toPrecision(value, precision, options) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(value)) {
     return String(value);
   }
 
@@ -658,7 +658,7 @@ function nearlyEqual(a, b) {
   if (isNaN(a) || isNaN(b)) {
     return false;
   }
-  if (!isFinite(a) || !isFinite(b)) {
+  if (!Number.isFinite(a) || !Number.isFinite(b)) {
     return a === b;
   }
   if (a === b) {

package/lib/cjs/utils/optimizeCallback.js

@@ -23,7 +23,19 @@ function optimizeCallback(callback, array, name, isUnary) {
     if (isUnary) {
       numberOfArguments = 1;
     } else {
-      const firstIndex = (array.isMatrix ? array.size() : (0, _array.arraySize)(array)).map(() => 0);
+      const size = array.isMatrix ? array.size() : (0, _array.arraySize)(array);
+
+      // Check the size of the last dimension to see if the array/matrix is empty
+      const isEmpty = size.length ? size[size.length - 1] === 0 : true;
+      if (isEmpty) {
+        // don't optimize callbacks for empty arrays/matrix, as they will never be called
+        // and in fact will throw an exception when we try to access the first element below
+        return {
+          isUnary,
+          fn: callback
+        };
+      }
+      const firstIndex = size.map(() => 0);
       const firstValue = array.isMatrix ? array.get(firstIndex) : (0, _array.get)(array, firstIndex);
       numberOfArguments = _findNumberOfArgumentsTyped(callback, firstValue, firstIndex, array);
     }

package/lib/cjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-const version = exports.version = '15.0.0';
+const version = exports.version = '15.1.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/lib/esm/entry/dependenciesAny/dependenciesBernoulli.generated.js

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { FractionDependencies } from './dependenciesFractionClass.generated.js';
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBernoulli } from '../../factoriesAny.js';
+export var bernoulliDependencies = {
+  BigNumberDependencies,
+  FractionDependencies,
+  isIntegerDependencies,
+  numberDependencies,
+  typedDependencies,
+  createBernoulli
+};

package/lib/esm/entry/dependenciesAny/dependenciesConstantNode.generated.js

@@ -3,8 +3,10 @@
  * DON'T MAKE CHANGES HERE
  */
 import { NodeDependencies } from './dependenciesNode.generated.js';
+import { isBoundedDependencies } from './dependenciesIsBounded.generated.js';
 import { createConstantNode } from '../../factoriesAny.js';
 export var ConstantNodeDependencies = {
   NodeDependencies,
+  isBoundedDependencies,
   createConstantNode
 };

package/lib/esm/entry/dependenciesAny/dependenciesEqual.generated.js

@@ -4,7 +4,6 @@
  */
 import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
 import { SparseMatrixDependencies } from './dependenciesSparseMatrixClass.generated.js';
-import { concatDependencies } from './dependenciesConcat.generated.js';
 import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
@@ -12,7 +11,6 @@ import { createEqual } from '../../factoriesAny.js';
 export var equalDependencies = {
   DenseMatrixDependencies,
   SparseMatrixDependencies,
-  concatDependencies,
   equalScalarDependencies,
   matrixDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesAny/dependenciesIsBounded.generated.js

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createIsBounded } from '../../factoriesAny.js';
+export var isBoundedDependencies = {
+  typedDependencies,
+  createIsBounded
+};

package/lib/esm/entry/dependenciesAny/dependenciesIsFinite.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { isBoundedDependencies } from './dependenciesIsBounded.generated.js';
+import { mapDependencies } from './dependenciesMap.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createIsFinite } from '../../factoriesAny.js';
+export var isFiniteDependencies = {
+  isBoundedDependencies,
+  mapDependencies,
+  typedDependencies,
+  createIsFinite
+};

package/lib/esm/entry/dependenciesAny/dependenciesIsInteger.generated.js

@@ -2,9 +2,11 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { equalDependencies } from './dependenciesEqual.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createIsInteger } from '../../factoriesAny.js';
 export var isIntegerDependencies = {
+  equalDependencies,
   typedDependencies,
   createIsInteger
 };

package/lib/esm/entry/dependenciesAny/dependenciesSimplifyConstant.generated.js

@@ -12,6 +12,7 @@ import { IndexNodeDependencies } from './dependenciesIndexNode.generated.js';
 import { ObjectNodeDependencies } from './dependenciesObjectNode.generated.js';
 import { OperatorNodeDependencies } from './dependenciesOperatorNode.generated.js';
 import { SymbolNodeDependencies } from './dependenciesSymbolNode.generated.js';
+import { isBoundedDependencies } from './dependenciesIsBounded.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createSimplifyConstant } from '../../factoriesAny.js';
@@ -26,6 +27,7 @@ export var simplifyConstantDependencies = {
   ObjectNodeDependencies,
   OperatorNodeDependencies,
   SymbolNodeDependencies,
+  isBoundedDependencies,
   matrixDependencies,
   typedDependencies,
   createSimplifyConstant

package/lib/esm/entry/dependenciesAny/dependenciesUnitClass.generated.js

@@ -17,7 +17,6 @@ import { numberDependencies } from './dependenciesNumber.generated.js';
 import { powDependencies } from './dependenciesPow.generated.js';
 import { roundDependencies } from './dependenciesRound.generated.js';
 import { subtractScalarDependencies } from './dependenciesSubtractScalar.generated.js';
-import { toBestDependencies } from './dependenciesToBest.generated.js';
 import { createUnitClass } from '../../factoriesAny.js';
 export var UnitDependencies = {
   BigNumberDependencies,
@@ -35,6 +34,5 @@ export var UnitDependencies = {
   powDependencies,
   roundDependencies,
   subtractScalarDependencies,
-  toBestDependencies,
   createUnitClass
 };

package/lib/esm/entry/dependenciesAny/dependenciesZeta.generated.js

@@ -9,6 +9,7 @@ import { divideDependencies } from './dependenciesDivide.generated.js';
 import { equalDependencies } from './dependenciesEqual.generated.js';
 import { factorialDependencies } from './dependenciesFactorial.generated.js';
 import { gammaDependencies } from './dependenciesGamma.generated.js';
+import { isBoundedDependencies } from './dependenciesIsBounded.generated.js';
 import { isNegativeDependencies } from './dependenciesIsNegative.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { piDependencies } from './dependenciesPi.generated.js';
@@ -26,6 +27,7 @@ export var zetaDependencies = {
   equalDependencies,
   factorialDependencies,
   gammaDependencies,
+  isBoundedDependencies,
   isNegativeDependencies,
   multiplyDependencies,
   piDependencies,

package/lib/esm/entry/dependenciesAny.generated.js

@@ -27,6 +27,7 @@ export { atanhDependencies } from './dependenciesAny/dependenciesAtanh.generated
 export { atomicMassDependencies } from './dependenciesAny/dependenciesAtomicMass.generated.js';
 export { avogadroDependencies } from './dependenciesAny/dependenciesAvogadro.generated.js';
 export { bellNumbersDependencies } from './dependenciesAny/dependenciesBellNumbers.generated.js';
+export { bernoulliDependencies } from './dependenciesAny/dependenciesBernoulli.generated.js';
 export { BigNumberDependencies } from './dependenciesAny/dependenciesBigNumberClass.generated.js';
 export { bigintDependencies } from './dependenciesAny/dependenciesBigint.generated.js';
 export { bignumberDependencies } from './dependenciesAny/dependenciesBignumber.generated.js';
@@ -158,6 +159,8 @@ export { intersectDependencies } from './dependenciesAny/dependenciesIntersect.g
 export { invDependencies } from './dependenciesAny/dependenciesInv.generated.js';
 export { inverseConductanceQuantumDependencies } from './dependenciesAny/dependenciesInverseConductanceQuantum.generated.js';
 export { invmodDependencies } from './dependenciesAny/dependenciesInvmod.generated.js';
+export { isBoundedDependencies } from './dependenciesAny/dependenciesIsBounded.generated.js';
+export { isFiniteDependencies } from './dependenciesAny/dependenciesIsFinite.generated.js';
 export { isIntegerDependencies } from './dependenciesAny/dependenciesIsInteger.generated.js';
 export { isNaNDependencies } from './dependenciesAny/dependenciesIsNaN.generated.js';
 export { isNegativeDependencies } from './dependenciesAny/dependenciesIsNegative.generated.js';

package/lib/esm/entry/dependenciesNumber/dependenciesBernoulli.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBernoulli } from '../../factoriesNumber.js';
+export var bernoulliDependencies = {
+  isIntegerDependencies,
+  numberDependencies,
+  typedDependencies,
+  createBernoulli
+};

package/lib/esm/entry/dependenciesNumber/dependenciesConstantNode.generated.js

@@ -3,8 +3,10 @@
  * DON'T MAKE CHANGES HERE
  */
 import { NodeDependencies } from './dependenciesNode.generated.js';
+import { isBoundedDependencies } from './dependenciesIsBounded.generated.js';
 import { createConstantNode } from '../../factoriesNumber.js';
 export var ConstantNodeDependencies = {
   NodeDependencies,
+  isBoundedDependencies,
   createConstantNode
 };

package/lib/esm/entry/dependenciesNumber/dependenciesIsBounded.generated.js

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createIsBounded } from '../../factoriesNumber.js';
+export var isBoundedDependencies = {
+  typedDependencies,
+  createIsBounded
+};

package/lib/esm/entry/dependenciesNumber/dependenciesIsFinite.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { isBoundedDependencies } from './dependenciesIsBounded.generated.js';
+import { mapDependencies } from './dependenciesMap.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createIsFinite } from '../../factoriesNumber.js';
+export var isFiniteDependencies = {
+  isBoundedDependencies,
+  mapDependencies,
+  typedDependencies,
+  createIsFinite
+};