mathjs 14.3.1 → 14.5.0

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

@@ -248,36 +248,46 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
       }
 
       // retrieve submatrix
-      // TODO: more efficient when creating an empty matrix and setting _data and _size manually
-      return new DenseMatrix(_getSubmatrix(matrix._data, index, size.length, 0), matrix._datatype);
+      const returnMatrix = new DenseMatrix([]);
+      const submatrix = _getSubmatrix(matrix._data, index);
+      returnMatrix._size = submatrix.size;
+      returnMatrix._datatype = matrix._datatype;
+      returnMatrix._data = submatrix.data;
+      return returnMatrix;
     }
   }
 
   /**
-   * Recursively get a submatrix of a multi dimensional matrix.
+   * Get a submatrix of a multi dimensional matrix.
    * Index is not checked for correct number or length of dimensions.
    * @memberof DenseMatrix
    * @param {Array} data
    * @param {Index} index
-   * @param {number} dims   Total number of dimensions
-   * @param {number} dim    Current dimension
    * @return {Array} submatrix
    * @private
    */
-  function _getSubmatrix(data, index, dims, dim) {
-    const last = dim === dims - 1;
-    const range = index.dimension(dim);
-    if (last) {
-      return range.map(function (i) {
-        (0, _array.validateIndex)(i, data.length);
-        return data[i];
-      }).valueOf();
-    } else {
-      return range.map(function (i) {
-        (0, _array.validateIndex)(i, data.length);
-        const child = data[i];
-        return _getSubmatrix(child, index, dims, dim + 1);
-      }).valueOf();
+  function _getSubmatrix(data, index) {
+    const maxDepth = index.size().length - 1;
+    const size = Array(maxDepth);
+    return {
+      data: getSubmatrixRecursive(data),
+      size
+    };
+    function getSubmatrixRecursive(data) {
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      const ranges = index.dimension(depth);
+      size[depth] = ranges.size()[0];
+      if (depth < maxDepth) {
+        return ranges.map(rangeIndex => {
+          (0, _array.validateIndex)(rangeIndex, data.length);
+          return getSubmatrixRecursive(data[rangeIndex], depth + 1);
+        }).valueOf();
+      } else {
+        return ranges.map(rangeIndex => {
+          (0, _array.validateIndex)(rangeIndex, data.length);
+          return data[rangeIndex];
+        }).valueOf();
+      }
     }
   }
 
@@ -365,9 +375,7 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
       _fit(matrix, size, defaultValue);
 
       // insert the sub matrix
-      const dims = iSize.length;
-      const dim = 0;
-      _setSubmatrix(matrix._data, index, submatrix, dims, dim);
+      _setSubmatrix(matrix._data, index, submatrix);
     }
     return matrix;
   }
@@ -378,23 +386,25 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
    * @param {Array} data
    * @param {Index} index
    * @param {Array} submatrix
-   * @param {number} dims   Total number of dimensions
-   * @param {number} dim
    * @private
    */
-  function _setSubmatrix(data, index, submatrix, dims, dim) {
-    const last = dim === dims - 1;
-    const range = index.dimension(dim);
-    if (last) {
-      range.forEach(function (dataIndex, subIndex) {
-        (0, _array.validateIndex)(dataIndex);
-        data[dataIndex] = submatrix[subIndex[0]];
-      });
-    } else {
-      range.forEach(function (dataIndex, subIndex) {
-        (0, _array.validateIndex)(dataIndex);
-        _setSubmatrix(data[dataIndex], index, submatrix[subIndex[0]], dims, dim + 1);
-      });
+  function _setSubmatrix(data, index, submatrix) {
+    const maxDepth = index.size().length - 1;
+    setSubmatrixRecursive(data, submatrix);
+    function setSubmatrixRecursive(data, submatrix) {
+      let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      const range = index.dimension(depth);
+      if (depth < maxDepth) {
+        range.forEach((rangeIndex, i) => {
+          (0, _array.validateIndex)(rangeIndex, data.length);
+          setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
+        });
+      } else {
+        range.forEach((rangeIndex, i) => {
+          (0, _array.validateIndex)(rangeIndex, data.length);
+          data[rangeIndex] = submatrix[i[0]];
+        });
+      }
     }
   }
 
@@ -525,62 +535,73 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
   };
 
   /**
-   * Applies a callback function to a reference to each element of the matrix
+   * Create a new matrix with the results of the callback function executed on
+   * each entry of the matrix.
    * @memberof DenseMatrix
    * @param {Function} callback   The callback function is invoked with three
-   *                              parameters: an array, an integer index to that
-   *                              array, and the Matrix being traversed.
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Matrix being traversed.
+   * @param {boolean} skipZeros   If true, the callback function is invoked only for non-zero entries
+   * @param {boolean} isUnary     If true, the callback function is invoked with one parameter
+   *
+   * @return {DenseMatrix} matrix
    */
-  DenseMatrix.prototype._forEach = function (callback) {
+  DenseMatrix.prototype.map = function (callback) {
+    let skipZeros = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let isUnary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     const me = this;
-    const s = me.size();
-    const maxDepth = s.length - 1;
-    if (maxDepth < 0) {
-      return;
+    const maxDepth = me._size.length - 1;
+    if (maxDepth < 0) return me.clone();
+    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me, 'map', isUnary);
+    const fastCallbackFn = fastCallback.fn;
+    const result = me.create(undefined, me._datatype);
+    result._size = me._size;
+    if (isUnary || fastCallback.isUnary) {
+      result._data = iterateUnary(me._data);
+      return result;
     }
     if (maxDepth === 0) {
-      const thisSize = s[0];
-      for (let i = 0; i < thisSize; i++) {
-        callback(me._data, i, [i]);
+      const inputData = me.valueOf();
+      const data = Array(inputData.length);
+      for (let i = 0; i < inputData.length; i++) {
+        data[i] = fastCallbackFn(inputData[i], [i], me);
       }
-      return;
+      result._data = data;
+      return result;
     }
-    const index = Array(s.length);
-    function recurse(data, depth) {
-      const thisSize = s[depth];
+    const index = [];
+    result._data = iterate(me._data);
+    return result;
+    function iterate(data) {
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      const result = Array(data.length);
       if (depth < maxDepth) {
-        for (let i = 0; i < thisSize; i++) {
+        for (let i = 0; i < data.length; i++) {
           index[depth] = i;
-          recurse(data[i], depth + 1);
+          result[i] = iterate(data[i], depth + 1);
         }
       } else {
-        for (let i = 0; i < thisSize; i++) {
+        for (let i = 0; i < data.length; i++) {
           index[depth] = i;
-          callback(data, i, index.slice());
+          result[i] = fastCallbackFn(data[i], index.slice(), me);
         }
       }
+      return result;
+    }
+    function iterateUnary(data) {
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      const result = Array(data.length);
+      if (depth < maxDepth) {
+        for (let i = 0; i < data.length; i++) {
+          result[i] = iterateUnary(data[i], depth + 1);
+        }
+      } else {
+        for (let i = 0; i < data.length; i++) {
+          result[i] = fastCallbackFn(data[i]);
+        }
+      }
+      return result;
     }
-    recurse(me._data, 0);
-  };
-
-  /**
-   * Create a new matrix with the results of the callback function executed on
-   * each entry of the matrix.
-   * @memberof DenseMatrix
-   * @param {Function} callback   The callback function is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the Matrix being traversed.
-   *
-   * @return {DenseMatrix} matrix
-   */
-  DenseMatrix.prototype.map = function (callback) {
-    const me = this;
-    const result = new DenseMatrix(me);
-    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me._data, 'map');
-    result._forEach(function (arr, i, index) {
-      arr[i] = fastCallback(arr[i], index, me);
-    });
-    return result;
   };
 
   /**
@@ -589,13 +610,55 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
    * @param {Function} callback   The callback function is invoked with three
    *                              parameters: the value of the element, the index
    *                              of the element, and the Matrix being traversed.
+   * @param {boolean} skipZeros   If true, the callback function is invoked only for non-zero entries
+   * @param {boolean} isUnary     If true, the callback function is invoked with one parameter
    */
   DenseMatrix.prototype.forEach = function (callback) {
+    let skipZeros = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let isUnary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     const me = this;
-    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me._data, 'map');
-    me._forEach(function (arr, i, index) {
-      fastCallback(arr[i], index, me);
-    });
+    const maxDepth = me._size.length - 1;
+    if (maxDepth < 0) return;
+    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me, 'map', isUnary);
+    const fastCallbackFn = fastCallback.fn;
+    if (isUnary || fastCallback.isUnary) {
+      iterateUnary(me._data);
+      return;
+    }
+    if (maxDepth === 0) {
+      for (let i = 0; i < me._data.length; i++) {
+        fastCallbackFn(me._data[i], [i], me);
+      }
+      return;
+    }
+    const index = [];
+    iterate(me._data);
+    function iterate(data) {
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (depth < maxDepth) {
+        for (let i = 0; i < data.length; i++) {
+          index[depth] = i;
+          iterate(data[i], depth + 1);
+        }
+      } else {
+        for (let i = 0; i < data.length; i++) {
+          index[depth] = i;
+          fastCallbackFn(data[i], index.slice(), me);
+        }
+      }
+    }
+    function iterateUnary(data) {
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (depth < maxDepth) {
+        for (let i = 0; i < data.length; i++) {
+          iterateUnary(data[i], depth + 1);
+        }
+      } else {
+        for (let i = 0; i < data.length; i++) {
+          fastCallbackFn(data[i]);
+        }
+      }
+    }
   };
 
   /**

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

@@ -882,7 +882,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     // invoke callback
     const invoke = function (v, i, j) {
       // invoke callback
-      return fastCallback(v, [i, j], me);
+      return fastCallback.fn(v, [i, j], me);
     };
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
@@ -1000,7 +1000,8 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
           const i = this._index[k];
 
           // value @ k
-          fastCallback(this._values[k], [i, j], me);
+          // TODO apply a non indexed version of algorithm in case fastCallback is not optimized
+          fastCallback.fn(this._values[k], [i, j], me);
         }
       } else {
         // create a cache holding all defined values
@@ -1014,7 +1015,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
         // and either read the value or zero
         for (let i = 0; i < rows; i++) {
           const value = i in values ? values[i] : 0;
-          fastCallback(value, [i, j], me);
+          fastCallback.fn(value, [i, j], me);
         }
       }
     }

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

@@ -624,8 +624,8 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
 
     // If at least one operand has a value, then the result should also have a value
     if (this.value !== null || other.value !== null) {
-      const valThis = this.value === null ? this._normalize(1) : this.value;
-      const valOther = other.value === null ? other._normalize(1) : other.value;
+      const valThis = this.value === null ? this._normalize(one(other.value)) : this.value;
+      const valOther = other.value === null ? other._normalize(one(this.value)) : other.value;
       res.value = multiplyScalar(valThis, valOther);
     } else {
       res.value = null;
@@ -673,8 +673,8 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
 
     // If at least one operand has a value, the result should have a value
     if (this.value !== null || other.value !== null) {
-      const valThis = this.value === null ? this._normalize(1) : this.value;
-      const valOther = other.value === null ? other._normalize(1) : other.value;
+      const valThis = this.value === null ? this._normalize(one(other.value)) : this.value;
+      const valOther = other.value === null ? other._normalize(one(this.value)) : other.value;
       res.value = divideScalar(valThis, valOther);
     } else {
       res.value = null;
@@ -730,6 +730,21 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
     }
   }
 
+  /**
+   * Create a value one with the numeric type of `typeOfValue`.
+   * For example, `one(new BigNumber(3))` returns `BigNumber(1)`
+   * @param {number | Fraction | BigNumber} typeOfValue
+   * @returns {number | Fraction | BigNumber}
+   */
+  function one(typeOfValue) {
+    // TODO: this is a workaround to prevent the following BigNumber conversion error from throwing:
+    //  "TypeError: Cannot implicitly convert a number with >15 significant digits to BigNumber"
+    //  see https://github.com/josdejong/mathjs/issues/3450
+    //      https://github.com/josdejong/mathjs/pull/3375
+    const convert = Unit._getNumberConverter((0, _is.typeOf)(typeOfValue));
+    return convert(1);
+  }
+
   /**
    * Calculate the absolute value of a unit
    * @memberof Unit

package/lib/cjs/utils/array.js

@@ -278,7 +278,7 @@ function _resize(array, size, dim, defaultValue) {
  *                                not equal that of the old ones
  */
 function reshape(array, sizes) {
-  const flatArray = flatten(array);
+  const flatArray = flatten(array, true); // since it has rectangular
   const currentLength = flatArray.length;
   if (!Array.isArray(array) || !Array.isArray(sizes)) {
     throw new TypeError('Array expected');
@@ -475,22 +475,46 @@ function _unsqueeze(array, dims, dim) {
  * Flatten a multi dimensional array, put all elements in a one dimensional
  * array
  * @param {Array} array   A multi dimensional array
+ * @param {boolean} isRectangular Optional. If the array is rectangular (not jagged)
  * @return {Array}        The flattened array (1 dimensional)
  */
 function flatten(array) {
+  let isRectangular = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   if (!Array.isArray(array)) {
     // if not an array, return as is
     return array;
   }
+  if (typeof isRectangular !== 'boolean') {
+    throw new TypeError('Boolean expected for second argument of flatten');
+  }
   const flat = [];
-  array.forEach(function callback(value) {
-    if (Array.isArray(value)) {
-      value.forEach(callback); // traverse through sub-arrays recursively
+  if (isRectangular) {
+    _flattenRectangular(array);
+  } else {
+    _flatten(array);
+  }
+  return flat;
+  function _flatten(array) {
+    for (let i = 0; i < array.length; i++) {
+      const item = array[i];
+      if (Array.isArray(item)) {
+        _flatten(item);
+      } else {
+        flat.push(item);
+      }
+    }
+  }
+  function _flattenRectangular(array) {
+    if (Array.isArray(array[0])) {
+      for (let i = 0; i < array.length; i++) {
+        _flattenRectangular(array[i]);
+      }
     } else {
-      flat.push(value);
+      for (let i = 0; i < array.length; i++) {
+        flat.push(array[i]);
+      }
     }
-  });
-  return flat;
+  }
 }
 
 /**

package/lib/cjs/utils/collection.js

@@ -36,7 +36,7 @@ function containsCollections(array) {
  */
 function deepForEach(array, callback) {
   if ((0, _is.isMatrix)(array)) {
-    array.forEach(x => callback(x));
+    array.forEach(x => callback(x), false, true);
   } else {
     (0, _array.deepForEach)(array, callback, true);
   }
@@ -57,14 +57,14 @@ function deepForEach(array, callback) {
 function deepMap(array, callback, skipZeros) {
   if (!skipZeros) {
     if ((0, _is.isMatrix)(array)) {
-      return array.map(x => callback(x));
+      return array.map(x => callback(x), false, true);
     } else {
       return (0, _array.deepMap)(array, callback, true);
     }
   }
   const skipZerosCallback = x => x === 0 ? x : callback(x);
   if ((0, _is.isMatrix)(array)) {
-    return array.map(x => skipZerosCallback(x));
+    return array.map(x => skipZerosCallback(x), false, true);
   } else {
     return (0, _array.deepMap)(array, skipZerosCallback, true);
   }

package/lib/cjs/utils/latex.js

@@ -161,6 +161,9 @@ const latexFunctions = exports.latexFunctions = {
   floor: {
     1: '\\left\\lfloor${args[0]}\\right\\rfloor'
   },
+  fraction: {
+    2: '\\frac{${args[0]}}{${args[1]}}'
+  },
   gcd: '\\gcd\\left(${args}\\right)',
   hypot: '\\hypot\\left(${args}\\right)',
   log: {
@@ -189,7 +192,7 @@ const latexFunctions = exports.latexFunctions = {
     2: '\\sqrt[${args[1]}]{${args[0]}}'
   },
   nthRoots: {
-    2: '\\{y : $y^{args[1]} = {${args[0]}}\\}'
+    2: '\\{y : y^${args[1]} = {${args[0]}}\\}'
   },
   pow: {
     2: `\\left(\${args[0]}\\right)${latexOperators.pow}{\${args[1]}}`

package/lib/cjs/utils/optimizeCallback.js

@@ -14,13 +14,20 @@ var _is = require("./is.js");
  * @param {Function} callback The original callback function to simplify.
  * @param {Array|Matrix} array The array that will be used with the callback function.
  * @param {string} name The name of the function that is using the callback.
+ * @param {boolean} [isUnary=false] If true, the callback function is unary and will be optimized as such.
  * @returns {Function} Returns a simplified version of the callback function.
  */
 function optimizeCallback(callback, array, name) {
+  let isUnary = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   if (_typedFunction.default.isTypedFunction(callback)) {
-    const firstIndex = (array.isMatrix ? array.size() : (0, _array.arraySize)(array)).map(() => 0);
-    const firstValue = array.isMatrix ? array.get(firstIndex) : (0, _array.get)(array, firstIndex);
-    const numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array);
+    let numberOfArguments;
+    if (isUnary) {
+      numberOfArguments = 1;
+    } else {
+      const firstIndex = (array.isMatrix ? array.size() : (0, _array.arraySize)(array)).map(() => 0);
+      const firstValue = array.isMatrix ? array.get(firstIndex) : (0, _array.get)(array, firstIndex);
+      numberOfArguments = _findNumberOfArgumentsTyped(callback, firstValue, firstIndex, array);
+    }
     let fastCallback;
     if (array.isMatrix && array.dataType !== 'mixed' && array.dataType !== undefined) {
       const singleSignature = _findSingleSignatureWithArity(callback, numberOfArguments);
@@ -29,21 +36,37 @@ function optimizeCallback(callback, array, name) {
       fastCallback = callback;
     }
     if (numberOfArguments >= 1 && numberOfArguments <= 3) {
-      return function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
+      return {
+        isUnary: numberOfArguments === 1,
+        fn: function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          return _tryFunctionWithArgs(fastCallback, args.slice(0, numberOfArguments), name, callback.name);
         }
-        return _tryFunctionWithArgs(fastCallback, args.slice(0, numberOfArguments), name, callback.name);
       };
     }
-    return function () {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
+    return {
+      isUnary: false,
+      fn: function () {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return _tryFunctionWithArgs(fastCallback, args, name, callback.name);
       }
-      return _tryFunctionWithArgs(fastCallback, args, name, callback.name);
     };
   }
-  return callback;
+  if (isUnary === undefined) {
+    return {
+      isUnary: _findIfCallbackIsUnary(callback),
+      fn: callback
+    };
+  } else {
+    return {
+      isUnary,
+      fn: callback
+    };
+  }
 }
 function _findSingleSignatureWithArity(callback, arity) {
   const matchingFunctions = [];
@@ -57,7 +80,32 @@ function _findSingleSignatureWithArity(callback, arity) {
     return matchingFunctions[0];
   }
 }
-function _findNumberOfArguments(callback, value, index, array) {
+
+/**
+ * Determines if a given callback function is unary (i.e., takes exactly one argument).
+ *
+ * This function checks the following conditions to determine if the callback is unary:
+ * 1. The callback function should have exactly one parameter.
+ * 2. The callback function should not use the `arguments` object.
+ * 3. The callback function should not use rest parameters (`...`).
+ * If in doubt, this function shall return `false` to be safe
+ *
+ * @param {Function} callback - The callback function to be checked.
+ * @returns {boolean} - Returns `true` if the callback is unary, otherwise `false`.
+ */
+function _findIfCallbackIsUnary(callback) {
+  if (callback.length !== 1) return false;
+  const callbackStr = callback.toString();
+  // Check if the callback function uses `arguments`
+  if (/arguments/.test(callbackStr)) return false;
+
+  // Extract the parameters of the callback function
+  const paramsStr = callbackStr.match(/\(.*?\)/);
+  // Check if the callback function uses rest parameters
+  if (/\.\.\./.test(paramsStr)) return false;
+  return true;
+}
+function _findNumberOfArgumentsTyped(callback, value, index, array) {
   const testArgs = [value, index, array];
   for (let i = 3; i > 0; i--) {
     const args = testArgs.slice(0, i);

package/lib/cjs/utils/snapshot.js

@@ -12,8 +12,7 @@ var _assert = _interopRequireDefault(require("assert"));
 var allIsFunctions = _interopRequireWildcard(require("./is.js"));
 var _create = require("../core/create.js");
 var _string = require("./string.js");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /**
  * This file contains helper methods to create expected snapshot structures
  * of both instance and ES6 exports.

package/lib/cjs/version.js

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

package/lib/esm/constants.js

@@ -70,47 +70,47 @@ export var createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?Bi
   } = _ref9;
   return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(2).ln()) : Math.LOG2E;
 });
-export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref10 => {
+export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref0 => {
   var {
     config,
     BigNumber
-  } = _ref10;
+  } = _ref0;
   return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
 });
 export var createSQRT1_2 = /* #__PURE__ */recreateFactory(
 // eslint-disable-line camelcase
-'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
+'SQRT1_2', ['config', '?BigNumber'], _ref1 => {
   var {
     config,
     BigNumber
-  } = _ref11;
+  } = _ref1;
   return config.number === 'BigNumber' ? new BigNumber('0.5').sqrt() : Math.SQRT1_2;
 });
-export var createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref12 => {
+export var createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref10 => {
   var {
     config,
     BigNumber
-  } = _ref12;
+  } = _ref10;
   return config.number === 'BigNumber' ? new BigNumber(2).sqrt() : Math.SQRT2;
 });
-export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 => {
+export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref11 => {
   var {
     Complex
-  } = _ref13;
+  } = _ref11;
   return Complex.I;
 });
 
 // for backward compatibility with v5
-export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], _ref14 => {
+export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], _ref12 => {
   var {
     pi
-  } = _ref14;
+  } = _ref12;
   return pi;
 });
-export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], _ref15 => {
+export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], _ref13 => {
   var {
     e
-  } = _ref15;
+  } = _ref13;
   return e;
 });
 export var createVersion = /* #__PURE__ */factory('version', [], () => version);