mathjs 12.3.1 → 12.4.0

package/lib/esm/utils/map.js

@@ -12,9 +12,10 @@ import { isObject } from './is.js';
 export class ObjectWrappingMap {
   constructor(object) {
     this.wrappedObject = object;
+    this[Symbol.iterator] = this.entries;
   }
   keys() {
-    return Object.keys(this.wrappedObject);
+    return Object.keys(this.wrappedObject).values();
   }
   get(key) {
     return getSafeProperty(this.wrappedObject, key);
@@ -26,6 +27,103 @@ export class ObjectWrappingMap {
   has(key) {
     return hasSafeProperty(this.wrappedObject, key);
   }
+  entries() {
+    return mapIterator(this.keys(), key => [key, this.get(key)]);
+  }
+  forEach(callback) {
+    for (var key of this.keys()) {
+      callback(this.get(key), key, this);
+    }
+  }
+  delete(key) {
+    delete this.wrappedObject[key];
+  }
+  clear() {
+    for (var key of this.keys()) {
+      this.delete(key);
+    }
+  }
+  get size() {
+    return Object.keys(this.wrappedObject).length;
+  }
+}
+
+/**
+ * Create a map with two partitions: a and b.
+ * The set with bKeys determines which keys/values are read/written to map b,
+ * all other values are read/written to map a
+ *
+ * For example:
+ *
+ *   const a = new Map()
+ *   const b = new Map()
+ *   const p = new PartitionedMap(a, b, new Set(['x', 'y']))
+ *
+ * In this case, values `x` and `y` are read/written to map `b`,
+ * all other values are read/written to map `a`.
+ */
+export class PartitionedMap {
+  /**
+   * @param {Map} a
+   * @param {Map} b
+   * @param {Set} bKeys
+   */
+  constructor(a, b, bKeys) {
+    this.a = a;
+    this.b = b;
+    this.bKeys = bKeys;
+    this[Symbol.iterator] = this.entries;
+  }
+  get(key) {
+    return this.bKeys.has(key) ? this.b.get(key) : this.a.get(key);
+  }
+  set(key, value) {
+    if (this.bKeys.has(key)) {
+      this.b.set(key, value);
+    } else {
+      this.a.set(key, value);
+    }
+    return this;
+  }
+  has(key) {
+    return this.b.has(key) || this.a.has(key);
+  }
+  keys() {
+    return new Set([...this.a.keys(), ...this.b.keys()])[Symbol.iterator]();
+  }
+  entries() {
+    return mapIterator(this.keys(), key => [key, this.get(key)]);
+  }
+  forEach(callback) {
+    for (var key of this.keys()) {
+      callback(this.get(key), key, this);
+    }
+  }
+  delete(key) {
+    return this.bKeys.has(key) ? this.b.delete(key) : this.a.delete(key);
+  }
+  clear() {
+    this.a.clear();
+    this.b.clear();
+  }
+  get size() {
+    return [...this.keys()].length;
+  }
+}
+
+/**
+ * Create a new iterator that maps over the provided iterator, applying a mapping function to each item
+ */
+function mapIterator(it, callback) {
+  return {
+    next: () => {
+      var n = it.next();
+      return n.done ? n : {
+        value: callback(n.value),
+        done: false
+      };
+    }
+  };
 }
 
 /**

package/lib/esm/utils/scope.js

@@ -1,4 +1,4 @@
-import { createEmptyMap, assign } from './map.js';
+import { ObjectWrappingMap, PartitionedMap } from './map.js';
 
 /**
  * Create a new scope which can access the parent scope,
@@ -10,15 +10,9 @@ import { createEmptyMap, assign } from './map.js';
  * the remaining `args`.
  *
  * @param {Map} parentScope
- * @param  {...any} args
- * @returns {Map}
+ * @param  {Object} args
+ * @returns {PartitionedMap}
  */
-export function createSubScope(parentScope) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
-  }
-  if (typeof parentScope.createSubScope === 'function') {
-    return assign(parentScope.createSubScope(), ...args);
-  }
-  return assign(createEmptyMap(), parentScope, ...args);
+export function createSubScope(parentScope, args) {
+  return new PartitionedMap(parentScope, new ObjectWrappingMap(args), new Set(Object.keys(args)));
 }

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '12.3.1';
+export var version = '12.4.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": "12.3.1",
+  "version": "12.4.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",
@@ -43,21 +43,21 @@
     "@babel/register": "7.23.7",
     "@types/assert": "1.5.10",
     "@types/mocha": "10.0.6",
-    "@typescript-eslint/eslint-plugin": "6.20.0",
-    "@typescript-eslint/parser": "6.20.0",
+    "@typescript-eslint/eslint-plugin": "7.0.2",
+    "@typescript-eslint/parser": "7.0.2",
     "assert": "2.1.0",
     "babel-loader": "9.1.3",
     "benchmark": "2.1.4",
     "c8": "9.1.0",
     "codecov": "3.8.3",
-    "core-js": "3.35.1",
+    "core-js": "3.36.0",
     "del": "6.1.1",
     "dtslint": "4.2.1",
     "eslint": "8.56.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-config-standard": "17.1.0",
     "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-mocha": "10.2.0",
+    "eslint-plugin-mocha": "10.3.0",
     "eslint-plugin-n": "16.6.2",
     "eslint-plugin-prettier": "5.1.3",
     "eslint-plugin-promise": "6.1.1",
@@ -74,9 +74,9 @@
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
-    "karma-webpack": "5.0.0",
+    "karma-webpack": "5.0.1",
     "mkdirp": "3.0.1",
-    "mocha": "10.2.0",
+    "mocha": "10.3.0",
     "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -85,12 +85,12 @@
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
     "pad-right": "0.2.2",
-    "prettier": "3.2.4",
+    "prettier": "3.2.5",
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.2",
     "typescript": "5.3.3",
-    "webpack": "5.90.0",
+    "webpack": "5.90.3",
     "zeros": "1.0.0"
   },
   "type": "module",

package/types/index.d.ts

@@ -2760,22 +2760,22 @@ export interface MathJsInstance extends MathJsFactory {
    * @param args Multiple scalar values
    * @returns The mode of all values
    */
-  mode<T extends MathScalarType>(...args: T[]): T
+  mode<T extends MathScalarType>(...args: T[]): T[]
   /**
    * @param args Multiple scalar values
    * @returns The mode of all values
    */
-  mode(...args: MathScalarType[]): MathScalarType
+  mode(...args: MathScalarType[]): MathScalarType[]
   /**
    * @param A A single matrix
-   * @returns The median value
+   * @returns The mode value
    */
-  mode<T extends MathScalarType>(A: T[] | T[][]): T
+  mode<T extends MathScalarType>(A: T[] | T[][]): T[]
   /**
    * @param A A single matrix
    * @returns The mode of all values
    */
-  mode(A: MathCollection): MathScalarType
+  mode(A: MathCollection): MathScalarType[]
 
   /**
    * Compute the product of a matrix or a list with values. In case of a