mathjs 13.1.1 → 13.2.1

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

@@ -0,0 +1,95 @@
+import { factory } from '../../../utils/factory.js';
+var name = 'transformCallback';
+var dependencies = ['typed'];
+export var createTransformCallback = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    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) {
+    var signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      var [signature, callbackFunction] = _ref2;
+      var 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];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var 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];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var idx = _transformDims(args[numberOfArrays]);
+      var 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/esm/function/algebra/derivative.js

@@ -65,14 +65,18 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     var res = _derivative(expr, constNodes);
     return options.simplify ? simplify(res) : res;
   }
-  typed.addConversion({
-    from: 'identifier',
-    to: 'SymbolNode',
-    convert: parse
-  });
+  function parseIdentifier(string) {
+    var symbol = parse(string);
+    if (!symbol.isSymbolNode) {
+      throw new TypeError('Invalid variable. ' + "Cannot parse ".concat(JSON.stringify(string), " into a variable in function derivative"));
+    }
+    return symbol;
+  }
   var 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}) {
@@ -86,11 +90,6 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     }
     */
   });
-  typed.removeConversion({
-    from: 'identifier',
-    to: 'SymbolNode',
-    convert: parse
-  });
   derivative._simplify = true;
   derivative.toTex = function (deriv) {
     return _derivTex.apply(null, deriv.args);

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

@@ -5,26 +5,15 @@ import { createUtil } from './simplify/util.js';
 import { hasOwnProperty } from '../../utils/object.js';
 import { createEmptyMap, createMap } from '../../utils/map.js';
 var name = 'simplify';
-var 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'];
+var dependencies = ['typed', 'parse', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    config,
     typed,
     parse,
-    add,
-    subtract,
-    multiply,
-    divide,
-    pow,
-    isZero,
     equal,
     resolve,
     simplifyConstant,
     simplifyCore,
-    fraction,
-    bignumber,
-    mathWithTransform,
-    matrix,
     AccessorNode,
     ArrayNode,
     ConstantNode,
@@ -189,7 +178,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   simplify.realContext = realContext;
   simplify.positiveContext = positiveContext;
   function removeParens(node) {
-    return node.transform(function (node, path, parent) {
+    return node.transform(function (node) {
       return isParenthesisNode(node) ? removeParens(node.content) : node;
     });
   }

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

@@ -1,4 +1,4 @@
-import { applyCallback } from '../../utils/applyCallback.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 import { filter, filterRegExp } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'filter';
@@ -56,8 +56,9 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @private
  */
 function _filterCallback(x, callback) {
+  var fastCallback = optimizeCallback(callback, x, 'filter');
   return filter(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    return applyCallback(callback, value, [index], array, 'filter');
+    return fastCallback(value, [index], array);
   });
 }

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

@@ -1,6 +1,6 @@
-import { applyCallback } from '../../utils/applyCallback.js';
-import { forEach as forEachArray } from '../../utils/array.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 import { factory } from '../../utils/factory.js';
+import { recurse } from '../../utils/array.js';
 var name = 'forEach';
 var dependencies = ['typed'];
 export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -45,16 +45,5 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @private
  */
 function _forEach(array, callback) {
-  var _recurse = function recurse(value, index) {
-    if (Array.isArray(value)) {
-      forEachArray(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 applyCallback(callback, value, index, array, 'forEach');
-    }
-  };
-  _recurse(array, []);
+  recurse(array, [], array, optimizeCallback(callback, array, name));
 }

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

@@ -1,5 +1,5 @@
-import { applyCallback } from '../../utils/applyCallback.js';
-import { arraySize, broadcastSizes, broadcastTo, get } from '../../utils/array.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
+import { arraySize, broadcastSizes, broadcastTo, get, recurse } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'map';
 var dependencies = ['typed'];
@@ -129,36 +129,14 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
       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 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 recurse(array, [], array, optimizeCallback(callback, array, name));
   }
-}
+});

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

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-this-alias
 import { isArray, isBigNumber, isCollection, isIndex, isMatrix, isNumber, isString, typeOf } from '../../utils/is.js';
 import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo, get } from '../../utils/array.js';
 import { format } from '../../utils/string.js';
@@ -5,7 +6,7 @@ import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
-import { applyCallback } from '../../utils/applyCallback.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -516,6 +517,66 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     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
+    var me = this;
+    var s = me.size();
+
+    // if there is only one dimension, just loop through it
+    if (s.length === 1) {
+      for (var i = 0; i < s[0]; i++) {
+        callback(me._data, i, [i]);
+      }
+      return;
+    }
+
+    // keep track of the current index permutation
+    var index = Array(s.length).fill(0);
+
+    // store a reference of each dimension of the matrix for faster access
+    var data = Array(s.length - 1);
+    var last = data.length - 1;
+    data[0] = me._data[0];
+    for (var _i = 0; _i < last; _i++) {
+      data[_i + 1] = data[_i][0];
+    }
+    index[last] = -1;
+    while (true) {
+      var _i2 = void 0;
+      for (_i2 = last; _i2 >= 0; _i2--) {
+        // march index to the next permutation
+        index[_i2]++;
+        if (index[_i2] === s[_i2]) {
+          index[_i2] = 0;
+          continue;
+        }
+
+        // update references to matrix dimensions
+        data[_i2] = _i2 === 0 ? me._data[index[_i2]] : data[_i2 - 1][index[_i2]];
+        for (var j = _i2; j < last; j++) {
+          data[j + 1] = data[j][0];
+        }
+
+        // loop through the last dimension and map each value
+        for (var _j = 0; _j < s[data.length]; _j++) {
+          index[data.length] = _j;
+          callback(data[last], _j, index.slice(0));
+        }
+        break;
+      }
+      if (_i2 === -1) {
+        break;
+      }
+    }
+  };
+
   /**
    * Create a new matrix with the results of the callback function executed on
    * each entry of the matrix.
@@ -527,24 +588,13 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {DenseMatrix} matrix
    */
   DenseMatrix.prototype.map = function (callback) {
-    // matrix instance
     var me = this;
-    var _recurse = function recurse(value, index) {
-      if (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 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
-    var data = _recurse(this._data, []);
-    var datatype = this._datatype !== undefined ? getArrayDataType(data, typeOf) : undefined;
-    return new DenseMatrix(data, datatype);
+    var result = new DenseMatrix(me);
+    var fastCallback = optimizeCallback(callback, me._data, 'map');
+    result._forEach(function (arr, i, index) {
+      arr[i] = fastCallback(arr[i], index, me);
+    });
+    return result;
   };
 
   /**
@@ -555,18 +605,11 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    *                              of the element, and the Matrix being traversed.
    */
   DenseMatrix.prototype.forEach = function (callback) {
-    // matrix instance
     var me = this;
-    var _recurse2 = function recurse(value, index) {
-      if (isArray(value)) {
-        value.forEach(function (child, i) {
-          _recurse2(child, index.concat(i));
-        });
-      } else {
-        callback(value, index, me);
-      }
-    };
-    _recurse2(this._data, []);
+    var fastCallback = optimizeCallback(callback, me._data, 'map');
+    me._forEach(function (arr, i, index) {
+      fastCallback(arr[i], index, me);
+    });
   };
 
   /**
@@ -574,10 +617,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {Iterable<{ value, index: number[] }>}
    */
   DenseMatrix.prototype[Symbol.iterator] = function* () {
-    var _recurse3 = function* recurse(value, index) {
+    var _recurse = function* recurse(value, index) {
       if (isArray(value)) {
         for (var i = 0; i < value.length; i++) {
-          yield* _recurse3(value[i], index.concat(i));
+          yield* _recurse(value[i], index.concat(i));
         }
       } else {
         yield {
@@ -586,7 +629,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
         };
       }
     };
-    yield* _recurse3(this._data, []);
+    yield* _recurse(this._data, []);
   };
 
   /**

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

@@ -180,6 +180,9 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @returns {Range | null} range
    */
   Index.prototype.dimension = function (dim) {
+    if (typeof dim !== 'number') {
+      return null;
+    }
     return this._dimensions[dim] || null;
   };
 

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

@@ -5,7 +5,7 @@ import { clone, deepStrictEqual } from '../../utils/object.js';
 import { arraySize, getArrayDataType, processSizesWildcard, unsqueeze, validateIndex } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { DimensionError } from '../../error/DimensionError.js';
-import { applyCallback } from '../../utils/applyCallback.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 var name = 'SparseMatrix';
 var dependencies = ['typed', 'equalScalar', 'Matrix'];
 export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -872,10 +872,11 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // rows and columns
     var rows = this._size[0];
     var columns = this._size[1];
+    var fastCallback = optimizeCallback(callback, me, 'map');
     // invoke callback
     var invoke = function invoke(v, i, j) {
       // invoke callback
-      return 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);
@@ -980,6 +981,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // rows and columns
     var rows = this._size[0];
     var columns = this._size[1];
+    var fastCallback = optimizeCallback(callback, me, 'forEach');
     // loop columns
     for (var j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
@@ -992,7 +994,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
           var 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
@@ -1006,7 +1008,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
         // and either read the value or zero
         for (var _i7 = 0; _i7 < rows; _i7++) {
           var value = _i7 in values ? values[_i7] : 0;
-          callback(value, [_i7, j], me);
+          fastCallback(value, [_i7, j], me);
         }
       }
     }
@@ -1405,6 +1407,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // indeces for column j
     var k0 = ptr[j];
     var k1 = ptr[j + 1];
+
     // loop
     for (var k = k0; k < k1; k++) {
       // invoke callback

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

@@ -36,7 +36,7 @@ export var createResultSet = /* #__PURE__ */factory(name, dependencies, () => {
    * @returns {string} string
    */
   ResultSet.prototype.toString = function () {
-    return '[' + this.entries.join(', ') + ']';
+    return '[' + this.entries.map(String).join(', ') + ']';
   };
 
   /**

package/lib/esm/utils/array.js

@@ -806,6 +806,27 @@ export 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.
+ */
+export 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/esm/utils/optimizeCallback.js

@@ -0,0 +1,88 @@
+import typed from 'typed-function';
+import { get, arraySize } from './array.js';
+import { typeOf as _typeOf } from './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.
+ */
+export function optimizeCallback(callback, array, name) {
+  if (typed.isTypedFunction(callback)) {
+    var firstIndex = (array.isMatrix ? array.size() : arraySize(array)).map(() => 0);
+    var firstValue = array.isMatrix ? array.get(firstIndex) : get(array, firstIndex);
+    var hasSingleSignature = Object.keys(callback.signatures).length === 1;
+    var numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array);
+    var 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) {
+  var testArgs = [value, index, array];
+  for (var i = 3; i > 0; i--) {
+    var args = testArgs.slice(0, i);
+    if (typed.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') {
+    var argsDesc = [];
+    argsDesc.push("value: ".concat(_typeOf(args[0])));
+    if (args.length >= 2) {
+      argsDesc.push("index: ".concat(_typeOf(args[1])));
+    }
+    if (args.length >= 3) {
+      argsDesc.push("array: ".concat(_typeOf(args[2])));
+    }
+    throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "".concat(callbackName, "(").concat(argsDesc.join(', '), ") at index ").concat(JSON.stringify(args[1])));
+  } else {
+    throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "to function ".concat(callbackName, ": ").concat(err.message));
+  }
+}

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '13.1.1';
+export var version = '13.2.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.