mathjs 13.1.0 → 13.2.0

package/lib/esm/utils/map.js

@@ -1,4 +1,4 @@
-import { getSafeProperty, hasSafeProperty, setSafeProperty } from './customs.js';
+import { getSafeProperty, isSafeProperty, setSafeProperty } from './customs.js';
 import { isMap, isObject } from './is.js';
 
 /**
@@ -15,7 +15,7 @@ export class ObjectWrappingMap {
     this[Symbol.iterator] = this.entries;
   }
   keys() {
-    return Object.keys(this.wrappedObject).values();
+    return Object.keys(this.wrappedObject).filter(key => this.has(key)).values();
   }
   get(key) {
     return getSafeProperty(this.wrappedObject, key);
@@ -25,7 +25,7 @@ export class ObjectWrappingMap {
     return this;
   }
   has(key) {
-    return hasSafeProperty(this.wrappedObject, key);
+    return isSafeProperty(this.wrappedObject, key) && key in this.wrappedObject;
   }
   entries() {
     return mapIterator(this.keys(), key => [key, this.get(key)]);
@@ -36,7 +36,9 @@ export class ObjectWrappingMap {
     }
   }
   delete(key) {
-    delete this.wrappedObject[key];
+    if (isSafeProperty(this.wrappedObject, key)) {
+      delete this.wrappedObject[key];
+    }
   }
   clear() {
     for (var key of this.keys()) {

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.0';
+export var version = '13.2.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "13.1.0",
+  "version": "13.2.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.25.4",
+    "@babel/runtime": "^7.25.6",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -43,11 +43,11 @@
     "@babel/preset-env": "7.25.4",
     "@babel/register": "7.24.6",
     "@types/assert": "1.5.10",
-    "@types/mocha": "10.0.7",
+    "@types/mocha": "10.0.8",
     "@typescript-eslint/eslint-plugin": "7.16.1",
     "@typescript-eslint/parser": "7.16.1",
     "assert": "2.1.0",
-    "babel-loader": "9.1.3",
+    "babel-loader": "9.2.1",
     "benchmark": "2.1.4",
     "c8": "10.1.2",
     "codecov": "3.8.3",
@@ -57,7 +57,7 @@
     "eslint": "8.57.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-config-standard": "17.1.0",
-    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-import": "2.30.0",
     "eslint-plugin-mocha": "10.5.0",
     "eslint-plugin-n": "16.6.2",
     "eslint-plugin-prettier": "5.2.1",
@@ -88,11 +88,11 @@
     "pad-right": "0.2.2",
     "prettier": "3.3.3",
     "process": "0.11.10",
-    "sinon": "18.0.0",
+    "sinon": "19.0.2",
     "sylvester": "0.0.21",
     "ts-node": "10.9.2",
     "typescript": "5.5.4",
-    "webpack": "5.94.0",
+    "webpack": "5.95.0",
     "zeros": "1.0.0"
   },
   "type": "module",

package/types/index.d.ts

@@ -246,8 +246,17 @@ export interface ConditionalNodeCtor {
   ): ConditionalNode
 }
 
-export interface ConstantNode<TValue extends string | number = number>
-  extends MathNode {
+export interface ConstantNode<
+  TValue extends
+    | string
+    | number
+    | boolean
+    | null
+    | undefined
+    | bigint
+    | BigNumber
+    | Fraction = number
+> extends MathNode {
   type: 'ConstantNode'
   isConstantNode: true
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -255,7 +264,17 @@ export interface ConstantNode<TValue extends string | number = number>
 }
 
 export interface ConstantNodeCtor {
-  new <TValue extends string | number = string>(
+  new <
+    TValue extends
+      | string
+      | number
+      | boolean
+      | null
+      | undefined
+      | bigint
+      | BigNumber
+      | Fraction = string
+  >(
     value: TValue
   ): ConstantNode<TValue>
 }
@@ -1022,6 +1041,15 @@ export interface MathJsInstance extends MathJsFactory {
   simplifyConstant(expr: MathNode | string, options?: SimplifyOptions): MathNode
   simplifyCore(expr: MathNode | string, options?: SimplifyOptions): MathNode
 
+  /**
+   * Gives the number of “leaf nodes” in the parse tree of the given
+   * expression. A leaf node is one that has no subexpressions, essentially
+   * either a symbol or a constant. Note that `5!` has just one leaf, the `5`;
+   * the unary factorial operator does not add a leaf. On the other hand,
+   * function symbols do add leaves, so `sin(x)/cos(x)` has four leaves.
+   */
+  leafCount(expr: MathNode): number
+
   /**
    *  Replaces variable nodes with their scoped values
    * @param node Tree to replace variable nodes in
@@ -2531,15 +2559,15 @@ export interface MathJsInstance extends MathJsFactory {
   /**
    * Determines if two expressions are symbolically equal, i.e. one is the
    * result of valid algebraic manipulations on the other.
-   * @param {Node|string} expr1 The first expression to compare
-   * @param {Node|string} expr2 The second expression to compare
+   * @param {Node} expr1 The first expression to compare
+   * @param {Node} expr2 The second expression to compare
    * @param {Object} [options] Optional option object, passed to simplify
    * @returns {boolean} Returns true if a valid manipulation making the
    * expressions equal is found.
    */
   symbolicEqual(
-    expr1: MathNode | string,
-    expr2: MathNode | string,
+    expr1: MathNode,
+    expr2: MathNode,
     options?: SimplifyOptions
   ): boolean
 
@@ -4869,6 +4897,15 @@ export interface MathJsChain<TValue> {
     options?: SimplifyOptions
   ): MathJsChain<MathNode>
 
+  /**
+   * Gives the number of “leaf nodes” in the parse tree of the given
+   * expression. A leaf node is one that has no subexpressions, essentially
+   * either a symbol or a constant. Note that `5!` has just one leaf, the `5`;
+   * the unary factorial operator does not add a leaf. On the other hand,
+   * function symbols do add leaves, so `sin(x)/cos(x)` has four leaves.
+   */
+  leafCount(this: MathJsChain<MathNode>): MathJsChain<number>
+
   /**
    * Calculate the Sparse Matrix LU decomposition with full pivoting.
    * Sparse Matrix A is decomposed in two matrices (L, U) and two
@@ -6123,17 +6160,16 @@ export interface MathJsChain<TValue> {
   /**
    * Determines if two expressions are symbolically equal, i.e. one is the
    * result of valid algebraic manipulations on the other.
-   * @param {Node|string} expr1 The first expression to compare
-   * @param {Node|string} expr2 The second expression to compare
+   * @param {Node} expr2 The second expression to compare
    * @param {Object} [options] Optional option object, passed to simplify
    * @returns {boolean} Returns true if a valid manipulation making the
    * expressions equal is found.
    */
   symbolicEqual(
-    this: MathJsChain<MathNode | string>,
-    expr2: MathNode | string,
+    this: MathJsChain<MathNode>,
+    expr2: MathNode,
     options?: SimplifyOptions
-  ): boolean
+  ): MathJsChain<boolean>
 
   /**
    * Test whether two values are unequal. The function tests whether the
@@ -6966,6 +7002,8 @@ export const {
   simplify,
   simplifyConstant,
   simplifyCore,
+  symbolicEqual,
+  leafCount,
   resolve,
   slu,
   usolve,

package/lib/cjs/utils/applyCallback.js

@@ -1,73 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.applyCallback = applyCallback;
-var _typedFunction = _interopRequireDefault(require("typed-function"));
-var _is = require("./is.js");
-/**
- * Invoke a callback for functions like map and filter with a matching number of arguments
- * @param {function} callback
- * @param {any} value
- * @param {number | number[]} index
- * @param {Array} array
- * @param {string} mappingFnName   The name of the function that is invoking these callbacks, for example "map" or "filter"
- * @returns {*}
- */
-function applyCallback(callback, value, index, array, mappingFnName) {
-  if (_typedFunction.default.isTypedFunction(callback)) {
-    // invoke the typed callback function with the matching number of arguments only
-
-    const args3 = [value, index, array];
-    const signature3 = _typedFunction.default.resolve(callback, args3);
-    if (signature3) {
-      return tryWithArgs(signature3.implementation, args3);
-    }
-    const args2 = [value, index];
-    const signature2 = _typedFunction.default.resolve(callback, args2);
-    if (signature2) {
-      return tryWithArgs(signature2.implementation, args2);
-    }
-    const args1 = [value];
-    const signature1 = _typedFunction.default.resolve(callback, args1);
-    if (signature1) {
-      return tryWithArgs(signature1.implementation, args1);
-    }
-
-    // fallback (will throw an exception)
-    return tryWithArgs(callback, args3);
-  } else {
-    // A regular JavaScript function
-    return callback(value, index, array);
-  }
-
-  /**
-   * @param {function} signature The selected signature of the typed-function
-   * @param {Array} args List with arguments to apply to the selected signature
-   * @returns {*} Returns the return value of the invoked signature
-   * @throws {TypeError} Throws an error when no matching signature was found
-   */
-  function tryWithArgs(signature, args) {
-    try {
-      return signature.apply(signature, args);
-    } catch (err) {
-      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)(value)}`);
-        if (args.length >= 2) {
-          argsDesc.push(`index: ${(0, _is.typeOf)(index)}`);
-        }
-        if (args.length >= 3) {
-          argsDesc.push(`array: ${(0, _is.typeOf)(array)}`);
-        }
-        throw new TypeError(`Function ${mappingFnName} cannot apply callback arguments ` + `${callback.name}(${argsDesc.join(', ')}) at index ${JSON.stringify(index)}`);
-      } else {
-        throw new TypeError(`Function ${mappingFnName} cannot apply callback arguments ` + `to function ${callback.name}: ${err.message}`);
-      }
-    }
-  }
-}

package/lib/esm/utils/applyCallback.js

@@ -1,67 +0,0 @@
-import typed from 'typed-function';
-import { typeOf as _typeOf } from './is.js';
-
-/**
- * Invoke a callback for functions like map and filter with a matching number of arguments
- * @param {function} callback
- * @param {any} value
- * @param {number | number[]} index
- * @param {Array} array
- * @param {string} mappingFnName   The name of the function that is invoking these callbacks, for example "map" or "filter"
- * @returns {*}
- */
-export function applyCallback(callback, value, index, array, mappingFnName) {
-  if (typed.isTypedFunction(callback)) {
-    // invoke the typed callback function with the matching number of arguments only
-
-    var args3 = [value, index, array];
-    var signature3 = typed.resolve(callback, args3);
-    if (signature3) {
-      return tryWithArgs(signature3.implementation, args3);
-    }
-    var args2 = [value, index];
-    var signature2 = typed.resolve(callback, args2);
-    if (signature2) {
-      return tryWithArgs(signature2.implementation, args2);
-    }
-    var args1 = [value];
-    var signature1 = typed.resolve(callback, args1);
-    if (signature1) {
-      return tryWithArgs(signature1.implementation, args1);
-    }
-
-    // fallback (will throw an exception)
-    return tryWithArgs(callback, args3);
-  } else {
-    // A regular JavaScript function
-    return callback(value, index, array);
-  }
-
-  /**
-   * @param {function} signature The selected signature of the typed-function
-   * @param {Array} args List with arguments to apply to the selected signature
-   * @returns {*} Returns the return value of the invoked signature
-   * @throws {TypeError} Throws an error when no matching signature was found
-   */
-  function tryWithArgs(signature, args) {
-    try {
-      return signature.apply(signature, args);
-    } catch (err) {
-      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(value)));
-        if (args.length >= 2) {
-          argsDesc.push("index: ".concat(_typeOf(index)));
-        }
-        if (args.length >= 3) {
-          argsDesc.push("array: ".concat(_typeOf(array)));
-        }
-        throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "".concat(callback.name, "(").concat(argsDesc.join(', '), ") at index ").concat(JSON.stringify(index)));
-      } else {
-        throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "to function ".concat(callback.name, ": ").concat(err.message));
-      }
-    }
-  }
-}