mathjs 13.1.1 → 13.2.1

package/lib/cjs/expression/transform/utils/transformCallback.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTransformCallback = void 0;
+var _factory = require("../../../utils/factory.js");
+const name = 'transformCallback';
+const dependencies = ['typed'];
+const createTransformCallback = exports.createTransformCallback = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+         * Transforms the given callback function based on its type and number of arrays.
+         *
+         * @param {Function} callback - The callback function to transform.
+         * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+         * @returns {*} - The transformed callback function.
+         */
+  return function (callback, numberOfArrays) {
+    if (typed.isTypedFunction(callback)) {
+      return _transformTypedCallbackFunction(callback, numberOfArrays);
+    } else {
+      return _transformCallbackFunction(callback, callback.length, numberOfArrays);
+    }
+  };
+
+  /**
+       * Transforms the given typed callback function based on the number of arrays.
+       *
+       * @param {Function} typedFunction - The typed callback function to transform.
+       * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+       * @returns {*} - The transformed callback function.
+       */
+  function _transformTypedCallbackFunction(typedFunction, numberOfArrays) {
+    const signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      let [signature, callbackFunction] = _ref2;
+      const numberOfCallbackInputs = signature.split(',').length;
+      if (typed.isTypedFunction(callbackFunction)) {
+        return [signature, _transformTypedCallbackFunction(callbackFunction, numberOfArrays)];
+      } else {
+        return [signature, _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays)];
+      }
+    }));
+    if (typeof typedFunction.name === 'string') {
+      return typed(typedFunction.name, signatures);
+    } else {
+      return typed(signatures);
+    }
+  }
+});
+
+/**
+     * Transforms the callback function based on the number of callback inputs and arrays.
+     * There are three cases:
+     * 1. The callback function has N arguments.
+     * 2. The callback function has N+1 arguments.
+     * 3. The callback function has 2N+1 arguments.
+     *
+     * @param {Function} callbackFunction - The callback function to transform.
+     * @param {number} numberOfCallbackInputs - The number of callback inputs.
+     * @param {number} numberOfArrays - The number of arrays.
+     * @returns {Function} The transformed callback function.
+     */
+function _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays) {
+  if (numberOfCallbackInputs === numberOfArrays) {
+    return callbackFunction;
+  } else if (numberOfCallbackInputs === numberOfArrays + 1) {
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      return callbackFunction(...vals, idx);
+    };
+  } else if (numberOfCallbackInputs > numberOfArrays + 1) {
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      const rest = args.slice(numberOfArrays + 1);
+      return callbackFunction(...vals, idx, ...rest);
+    };
+  } else {
+    return callbackFunction;
+  }
+}
+
+/**
+   * Transforms the dimensions by adding 1 to each dimension.
+   *
+   * @param {Array} dims - The dimensions to transform.
+   * @returns {Array} The transformed dimensions.
+   */
+function _transformDims(dims) {
+  return dims.map(dim => dim + 1);
+}

package/lib/cjs/function/algebra/derivative.js

@@ -71,14 +71,18 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
     const res = _derivative(expr, constNodes);
     return options.simplify ? simplify(res) : res;
   }
-  typed.addConversion({
-    from: 'identifier',
-    to: 'SymbolNode',
-    convert: parse
-  });
+  function parseIdentifier(string) {
+    const symbol = parse(string);
+    if (!symbol.isSymbolNode) {
+      throw new TypeError('Invalid variable. ' + `Cannot parse ${JSON.stringify(string)} into a variable in function derivative`);
+    }
+    return symbol;
+  }
   const derivative = typed(name, {
     'Node, SymbolNode': plainDerivative,
-    'Node, SymbolNode, Object': plainDerivative
+    'Node, SymbolNode, Object': plainDerivative,
+    'Node, string': (node, symbol) => plainDerivative(node, parseIdentifier(symbol)),
+    'Node, string, Object': (node, symbol, options) => plainDerivative(node, parseIdentifier(symbol), options)
 
     /* TODO: implement and test syntax with order of derivatives -> implement as an option {order: number}
     'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
@@ -92,11 +96,6 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
     }
     */
   });
-  typed.removeConversion({
-    from: 'identifier',
-    to: 'SymbolNode',
-    convert: parse
-  });
   derivative._simplify = true;
   derivative.toTex = function (deriv) {
     return _derivTex.apply(null, deriv.args);

package/lib/cjs/function/algebra/simplify.js

@@ -11,26 +11,15 @@ var _util = require("./simplify/util.js");
 var _object = require("../../utils/object.js");
 var _map = require("../../utils/map.js");
 const name = 'simplify';
-const dependencies = ['config', 'typed', 'parse', 'add', 'subtract', 'multiply', 'divide', 'pow', 'isZero', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', '?fraction', '?bignumber', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+const dependencies = ['typed', 'parse', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 const createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    config,
     typed,
     parse,
-    add,
-    subtract,
-    multiply,
-    divide,
-    pow,
-    isZero,
     equal,
     resolve,
     simplifyConstant,
     simplifyCore,
-    fraction,
-    bignumber,
-    mathWithTransform,
-    matrix,
     AccessorNode,
     ArrayNode,
     ConstantNode,
@@ -195,7 +184,7 @@ const createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.fact
   simplify.realContext = realContext;
   simplify.positiveContext = positiveContext;
   function removeParens(node) {
-    return node.transform(function (node, path, parent) {
+    return node.transform(function (node) {
       return (0, _is.isParenthesisNode)(node) ? removeParens(node.content) : node;
     });
   }

package/lib/cjs/function/matrix/filter.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createFilter = void 0;
-var _applyCallback = require("../../utils/applyCallback.js");
+var _optimizeCallback = require("../../utils/optimizeCallback.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 const name = 'filter';
@@ -62,8 +62,9 @@ const createFilter = exports.createFilter = /* #__PURE__ */(0, _factory.factory)
  * @private
  */
 function _filterCallback(x, callback) {
+  const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, x, 'filter');
   return (0, _array.filter)(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    return (0, _applyCallback.applyCallback)(callback, value, [index], array, 'filter');
+    return fastCallback(value, [index], array);
   });
 }

package/lib/cjs/function/matrix/forEach.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createForEach = void 0;
-var _applyCallback = require("../../utils/applyCallback.js");
-var _array = require("../../utils/array.js");
+var _optimizeCallback = require("../../utils/optimizeCallback.js");
 var _factory = require("../../utils/factory.js");
+var _array = require("../../utils/array.js");
 const name = 'forEach';
 const dependencies = ['typed'];
 const createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -51,16 +51,5 @@ const createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factor
  * @private
  */
 function _forEach(array, callback) {
-  const recurse = function (value, index) {
-    if (Array.isArray(value)) {
-      (0, _array.forEach)(value, function (child, i) {
-        // we create a copy of the index array and append the new index value
-        recurse(child, index.concat(i));
-      });
-    } else {
-      // invoke the callback function with the right number of arguments
-      return (0, _applyCallback.applyCallback)(callback, value, index, array, 'forEach');
-    }
-  };
-  recurse(array, []);
+  (0, _array.recurse)(array, [], array, (0, _optimizeCallback.optimizeCallback)(callback, array, name));
 }

package/lib/cjs/function/matrix/map.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMap = void 0;
-var _applyCallback = require("../../utils/applyCallback.js");
+var _optimizeCallback = require("../../utils/optimizeCallback.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 const name = 'map';
@@ -135,36 +135,14 @@ const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name,
       return 0;
     }
   }
-});
-
-/**
- * Map for a multi dimensional array
- * @param {Array} array
- * @param {Function} callback
- * @return {Array}
- * @private
- */
-function _mapArray(array, callback) {
-  return _recurse(array, [], array, callback);
-}
-
-/**
- * Recursive function to map a multi-dimensional array.
- *
- * @param {*} value - The current value being processed in the array.
- * @param {Array} index - The index of the current value being processed in the array.
- * @param {Array} array - The array being processed.
- * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
- * @returns {*} The new array with each element being the result of the callback function.
- */
-function _recurse(value, index, array, callback) {
-  if (Array.isArray(value)) {
-    return value.map(function (child, i) {
-      // we create a copy of the index array and append the new index value
-      return _recurse(child, index.concat(i), array, callback);
-    });
-  } else {
-    // invoke the callback function with the right number of arguments
-    return (0, _applyCallback.applyCallback)(callback, value, index, array, 'map');
+  /**
+  * Map for a multi dimensional array
+  * @param {Array} array
+  * @param {Function} callback
+  * @return {Array}
+  * @private
+  */
+  function _mapArray(array, callback) {
+    return (0, _array.recurse)(array, [], array, (0, _optimizeCallback.optimizeCallback)(callback, array, name));
   }
-}
+});

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 13.1.1
- * @date    2024-08-27
+ * @version 13.2.1
+ * @date    2024-11-06
  *
  * @license
  * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>

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

@@ -11,7 +11,9 @@ var _number = require("../../utils/number.js");
 var _object = require("../../utils/object.js");
 var _DimensionError = require("../../error/DimensionError.js");
 var _factory = require("../../utils/factory.js");
-var _applyCallback = require("../../utils/applyCallback.js");
+var _optimizeCallback = require("../../utils/optimizeCallback.js");
+// deno-lint-ignore-file no-this-alias
+
 const name = 'DenseMatrix';
 const dependencies = ['Matrix'];
 const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -522,6 +524,66 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     return this._size.slice(0); // return a clone of _size
   };
 
+  /**
+   * Applies a callback function to a reference to each element 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.
+   */
+  DenseMatrix.prototype._forEach = function (callback) {
+    // matrix instance
+    const me = this;
+    const s = me.size();
+
+    // if there is only one dimension, just loop through it
+    if (s.length === 1) {
+      for (let i = 0; i < s[0]; i++) {
+        callback(me._data, i, [i]);
+      }
+      return;
+    }
+
+    // keep track of the current index permutation
+    const index = Array(s.length).fill(0);
+
+    // store a reference of each dimension of the matrix for faster access
+    const data = Array(s.length - 1);
+    const last = data.length - 1;
+    data[0] = me._data[0];
+    for (let i = 0; i < last; i++) {
+      data[i + 1] = data[i][0];
+    }
+    index[last] = -1;
+    while (true) {
+      let i;
+      for (i = last; i >= 0; i--) {
+        // march index to the next permutation
+        index[i]++;
+        if (index[i] === s[i]) {
+          index[i] = 0;
+          continue;
+        }
+
+        // update references to matrix dimensions
+        data[i] = i === 0 ? me._data[index[i]] : data[i - 1][index[i]];
+        for (let j = i; j < last; j++) {
+          data[j + 1] = data[j][0];
+        }
+
+        // loop through the last dimension and map each value
+        for (let j = 0; j < s[data.length]; j++) {
+          index[data.length] = j;
+          callback(data[last], j, index.slice(0));
+        }
+        break;
+      }
+      if (i === -1) {
+        break;
+      }
+    }
+  };
+
   /**
    * Create a new matrix with the results of the callback function executed on
    * each entry of the matrix.
@@ -533,24 +595,13 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
    * @return {DenseMatrix} matrix
    */
   DenseMatrix.prototype.map = function (callback) {
-    // matrix instance
     const me = this;
-    const recurse = function (value, index) {
-      if ((0, _is.isArray)(value)) {
-        return value.map(function (child, i) {
-          return recurse(child, index.concat(i));
-        });
-      } else {
-        // invoke the callback function with the right number of arguments
-        return (0, _applyCallback.applyCallback)(callback, value, index, me, 'map');
-      }
-    };
-
-    // determine the new datatype when the original matrix has datatype defined
-    // TODO: should be done in matrix constructor instead
-    const data = recurse(this._data, []);
-    const datatype = this._datatype !== undefined ? (0, _array.getArrayDataType)(data, _is.typeOf) : undefined;
-    return new DenseMatrix(data, datatype);
+    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;
   };
 
   /**
@@ -561,18 +612,11 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
    *                              of the element, and the Matrix being traversed.
    */
   DenseMatrix.prototype.forEach = function (callback) {
-    // matrix instance
     const me = this;
-    const recurse = function (value, index) {
-      if ((0, _is.isArray)(value)) {
-        value.forEach(function (child, i) {
-          recurse(child, index.concat(i));
-        });
-      } else {
-        callback(value, index, me);
-      }
-    };
-    recurse(this._data, []);
+    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me._data, 'map');
+    me._forEach(function (arr, i, index) {
+      fastCallback(arr[i], index, me);
+    });
   };
 
   /**

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

@@ -186,6 +186,9 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @returns {Range | null} range
    */
   Index.prototype.dimension = function (dim) {
+    if (typeof dim !== 'number') {
+      return null;
+    }
     return this._dimensions[dim] || null;
   };
 

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

@@ -11,7 +11,7 @@ var _object = require("../../utils/object.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _DimensionError = require("../../error/DimensionError.js");
-var _applyCallback = require("../../utils/applyCallback.js");
+var _optimizeCallback = require("../../utils/optimizeCallback.js");
 const name = 'SparseMatrix';
 const dependencies = ['typed', 'equalScalar', 'Matrix'];
 const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -878,10 +878,11 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     // rows and columns
     const rows = this._size[0];
     const columns = this._size[1];
+    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me, 'map');
     // invoke callback
     const invoke = function (v, i, j) {
       // invoke callback
-      return (0, _applyCallback.applyCallback)(callback, v, [i, j], me, 'map');
+      return fastCallback(v, [i, j], me);
     };
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
@@ -986,6 +987,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     // rows and columns
     const rows = this._size[0];
     const columns = this._size[1];
+    const fastCallback = (0, _optimizeCallback.optimizeCallback)(callback, me, 'forEach');
     // loop columns
     for (let j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
@@ -998,7 +1000,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
           const i = this._index[k];
 
           // value @ k
-          callback(this._values[k], [i, j], me);
+          fastCallback(this._values[k], [i, j], me);
         }
       } else {
         // create a cache holding all defined values
@@ -1012,7 +1014,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;
-          callback(value, [i, j], me);
+          fastCallback(value, [i, j], me);
         }
       }
     }
@@ -1411,6 +1413,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     // indeces for column j
     const k0 = ptr[j];
     const k1 = ptr[j + 1];
+
     // loop
     for (let k = k0; k < k1; k++) {
       // invoke callback

package/lib/cjs/type/resultset/ResultSet.js

@@ -42,7 +42,7 @@ const createResultSet = exports.createResultSet = /* #__PURE__ */(0, _factory.fa
    * @returns {string} string
    */
   ResultSet.prototype.toString = function () {
-    return '[' + this.entries.join(', ') + ']';
+    return '[' + this.entries.map(String).join(', ') + ']';
   };
 
   /**

package/lib/cjs/utils/array.js

@@ -25,6 +25,7 @@ exports.join = join;
 exports.last = last;
 exports.map = map;
 exports.processSizesWildcard = processSizesWildcard;
+exports.recurse = recurse;
 exports.reshape = reshape;
 exports.resize = resize;
 exports.squeeze = squeeze;
@@ -840,6 +841,27 @@ function get(array, index) {
   return index.reduce((acc, curr) => acc[curr], array);
 }
 
+/**
+ * Recursive function to map a multi-dimensional array.
+ *
+ * @param {*} value - The current value being processed in the array.
+ * @param {Array} index - The index of the current value being processed in the array.
+ * @param {Array} array - The array being processed.
+ * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
+ * @returns {*} The new array with each element being the result of the callback function.
+ */
+function recurse(value, index, array, callback) {
+  if (Array.isArray(value)) {
+    return value.map(function (child, i) {
+      // we create a copy of the index array and append the new index value
+      return recurse(child, index.concat(i), array, callback);
+    });
+  } else {
+    // invoke the callback function with the right number of arguments
+    return callback(value, index, array);
+  }
+}
+
 /**
  * Deep clones a multidimensional array
  * @param {Array} array

package/lib/cjs/utils/optimizeCallback.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.optimizeCallback = optimizeCallback;
+var _typedFunction = _interopRequireDefault(require("typed-function"));
+var _array = require("./array.js");
+var _is = require("./is.js");
+/**
+ * Simplifies a callback function by reducing its complexity and potentially improving its performance.
+ *
+ * @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.
+ * @returns {Function} Returns a simplified version of the callback function.
+ */
+function optimizeCallback(callback, array, name) {
+  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 hasSingleSignature = Object.keys(callback.signatures).length === 1;
+    const numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array);
+    const fastCallback = hasSingleSignature ? Object.values(callback.signatures)[0] : 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 _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 _tryFunctionWithArgs(fastCallback, args, name, callback.name);
+    };
+  }
+  return callback;
+}
+function _findNumberOfArguments(callback, value, index, array) {
+  const testArgs = [value, index, array];
+  for (let i = 3; i > 0; i--) {
+    const args = testArgs.slice(0, i);
+    if (_typedFunction.default.resolve(callback, args) !== null) {
+      return i;
+    }
+  }
+}
+
+/**
+   * @param {function} func The selected function taken from one of the signatures of the callback function
+   * @param {Array} args List with arguments to apply to the selected signature
+   * @param {string} mappingFnName the name of the function that is using the callback
+   * @param {string} callbackName the name of the callback function
+   * @returns {*} Returns the return value of the invoked signature
+   * @throws {TypeError} Throws an error when no matching signature was found
+   */
+function _tryFunctionWithArgs(func, args, mappingFnName, callbackName) {
+  try {
+    return func(...args);
+  } catch (err) {
+    _createCallbackError(err, args, mappingFnName, callbackName);
+  }
+}
+
+/**
+ * Creates and throws a detailed TypeError when a callback function fails.
+ *
+ * @param {Error} err The original error thrown by the callback function.
+ * @param {Array} args The arguments that were passed to the callback function.
+ * @param {string} mappingFnName The name of the function that is using the callback.
+ * @param {string} callbackName The name of the callback function.
+ * @throws {TypeError} Throws a detailed TypeError with enriched error message.
+ */
+function _createCallbackError(err, args, mappingFnName, callbackName) {
+  var _err$data;
+  // Enrich the error message so the user understands that it took place inside the callback function
+  if (err instanceof TypeError && ((_err$data = err.data) === null || _err$data === void 0 ? void 0 : _err$data.category) === 'wrongType') {
+    const argsDesc = [];
+    argsDesc.push(`value: ${(0, _is.typeOf)(args[0])}`);
+    if (args.length >= 2) {
+      argsDesc.push(`index: ${(0, _is.typeOf)(args[1])}`);
+    }
+    if (args.length >= 3) {
+      argsDesc.push(`array: ${(0, _is.typeOf)(args[2])}`);
+    }
+    throw new TypeError(`Function ${mappingFnName} cannot apply callback arguments ` + `${callbackName}(${argsDesc.join(', ')}) at index ${JSON.stringify(args[1])}`);
+  } else {
+    throw new TypeError(`Function ${mappingFnName} cannot apply callback arguments ` + `to function ${callbackName}: ${err.message}`);
+  }
+}

package/lib/cjs/version.js

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