mathjs 12.3.1 → 12.3.2

package/lib/cjs/expression/node/OperatorNode.js

@@ -13,6 +13,7 @@ var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
+var _scope = require("../../utils/scope.js");
 var _string = require("../../utils/string.js");
 var _customs = require("../../utils/customs.js");
 var _operators = require("../operators.js");
@@ -311,7 +312,7 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
           // "raw" evaluation
           var rawArgs = this.args;
           return function evalOperatorNode(scope, args, context) {
-            return fn(rawArgs, math, scope);
+            return fn(rawArgs, math, (0, _scope.createSubScope)(scope, args));
           };
         } else if (evalArgs.length === 1) {
           var evalArg0 = evalArgs[0];

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

@@ -5,12 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.compileInlineExpression = compileInlineExpression;
 var _is = require("../../../utils/is.js");
-var _scope = require("../../../utils/scope.js");
+var _map = require("../../../utils/map.js");
 /**
  * Compile an inline expression like "x > 0"
  * @param {Node} expression
  * @param {Object} math
- * @param {Object} scope
+ * @param {Map} scope
  * @return {function} Returns a function with one argument which fills in the
  *                    undefined variable (like "x") and evaluates the expression
  */
@@ -25,10 +25,11 @@ function compileInlineExpression(expression, math, scope) {
 
   // create a test function for this equation
   var name = symbol.name; // variable name
-  var subScope = (0, _scope.createSubScope)(scope);
+  var argsScope = new Map();
+  var subScope = new _map.PartitionedMap(scope, argsScope, new Set([name]));
   var eq = expression.compile();
   return function inlineExpression(x) {
-    subScope.set(name, x);
+    argsScope.set(name, x);
     return eq.evaluate(subScope);
   };
 }

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 12.3.1
- * @date    2024-02-01
+ * @version 12.3.2
+ * @date    2024-02-08
  *
  * @license
  * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/utils/map.js

@@ -4,12 +4,13 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ObjectWrappingMap = void 0;
+exports.PartitionedMap = exports.ObjectWrappingMap = void 0;
 exports.assign = assign;
 exports.createEmptyMap = createEmptyMap;
 exports.createMap = createMap;
 exports.isMap = isMap;
 exports.toObject = toObject;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _customs = require("./customs.js");
@@ -33,7 +34,7 @@ var ObjectWrappingMap = exports.ObjectWrappingMap = /*#__PURE__*/function () {
   (0, _createClass2["default"])(ObjectWrappingMap, [{
     key: "keys",
     value: function keys() {
-      return Object.keys(this.wrappedObject);
+      return Object.keys(this.wrappedObject).values();
     }
   }, {
     key: "get",
@@ -51,9 +52,168 @@ var ObjectWrappingMap = exports.ObjectWrappingMap = /*#__PURE__*/function () {
     value: function has(key) {
       return (0, _customs.hasSafeProperty)(this.wrappedObject, key);
     }
+  }, {
+    key: "entries",
+    value: function entries() {
+      var _this = this;
+      return mapIterator(this.keys(), function (key) {
+        return [key, _this.get(key)];
+      });
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callback) {
+      var _iterator = _createForOfIteratorHelper(this.keys()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var key = _step.value;
+          callback(this.get(key), key, this);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "delete",
+    value: function _delete(key) {
+      delete this.wrappedObject[key];
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      var _iterator2 = _createForOfIteratorHelper(this.keys()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var key = _step2.value;
+          this["delete"](key);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return Object.keys(this.wrappedObject).length;
+    }
   }]);
   return ObjectWrappingMap;
 }();
+/**
+ * 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`.
+ */
+var PartitionedMap = exports.PartitionedMap = /*#__PURE__*/function () {
+  /**
+   * @param {Map} a
+   * @param {Map} b
+   * @param {Set} bKeys
+   */
+  function PartitionedMap(a, b, bKeys) {
+    (0, _classCallCheck2["default"])(this, PartitionedMap);
+    this.a = a;
+    this.b = b;
+    this.bKeys = bKeys;
+  }
+  (0, _createClass2["default"])(PartitionedMap, [{
+    key: "get",
+    value: function get(key) {
+      return this.bKeys.has(key) ? this.b.get(key) : this.a.get(key);
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (this.bKeys.has(key)) {
+        this.b.set(key, value);
+      } else {
+        this.a.set(key, value);
+      }
+      return this;
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      return this.b.has(key) || this.a.has(key);
+    }
+  }, {
+    key: "keys",
+    value: function keys() {
+      return new Set([].concat((0, _toConsumableArray2["default"])(this.a.keys()), (0, _toConsumableArray2["default"])(this.b.keys())))[Symbol.iterator]();
+    }
+  }, {
+    key: "entries",
+    value: function entries() {
+      var _this2 = this;
+      return mapIterator(this.keys(), function (key) {
+        return [key, _this2.get(key)];
+      });
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callback) {
+      var _iterator3 = _createForOfIteratorHelper(this.keys()),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var key = _step3.value;
+          callback(this.get(key), key, this);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }, {
+    key: "delete",
+    value: function _delete(key) {
+      return this.bKeys.has(key) ? this.b["delete"](key) : this.a["delete"](key);
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.a.clear();
+      this.b.clear();
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return (0, _toConsumableArray2["default"])(this.keys()).length;
+    }
+  }]);
+  return PartitionedMap;
+}();
+/**
+ * Create a new iterator that maps over the provided iterator, applying a mapping function to each item
+ */
+function mapIterator(it, callback) {
+  return {
+    next: function next() {
+      var n = it.next();
+      return n.done ? n : {
+        value: callback(n.value),
+        done: false
+      };
+    }
+  };
+}
+
 /**
  * Creates an empty map, or whatever your platform's polyfill is.
  *
@@ -93,18 +253,18 @@ function toObject(map) {
     return map.wrappedObject;
   }
   var object = {};
-  var _iterator = _createForOfIteratorHelper(map.keys()),
-    _step;
+  var _iterator4 = _createForOfIteratorHelper(map.keys()),
+    _step4;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var key = _step.value;
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var key = _step4.value;
       var value = map.get(key);
       (0, _customs.setSafeProperty)(object, key, value);
     }
   } catch (err) {
-    _iterator.e(err);
+    _iterator4.e(err);
   } finally {
-    _iterator.f();
+    _iterator4.f();
   }
   return object;
 }
@@ -143,17 +303,17 @@ function assign(map) {
       continue;
     }
     if (isMap(args)) {
-      var _iterator2 = _createForOfIteratorHelper(args.keys()),
-        _step2;
+      var _iterator5 = _createForOfIteratorHelper(args.keys()),
+        _step5;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var key = _step2.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var key = _step5.value;
           map.set(key, args.get(key));
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator2.f();
+        _iterator5.f();
       }
     } else if ((0, _is.isObject)(args)) {
       for (var _i2 = 0, _Object$keys = Object.keys(args); _i2 < _Object$keys.length; _i2++) {

package/lib/cjs/utils/scope.js

@@ -15,15 +15,9 @@ var _map = require("./map.js");
  * the remaining `args`.
  *
  * @param {Map} parentScope
- * @param  {...any} args
- * @returns {Map}
+ * @param  {Object} args
+ * @returns {PartitionedMap}
  */
-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 _map.assign.apply(void 0, [parentScope.createSubScope()].concat(args));
-  }
-  return _map.assign.apply(void 0, [(0, _map.createEmptyMap)(), parentScope].concat(args));
+function createSubScope(parentScope, args) {
+  return new _map.PartitionedMap(parentScope, new _map.ObjectWrappingMap(args), new Set(Object.keys(args)));
 }

package/lib/cjs/version.js

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

package/lib/esm/expression/node/OperatorNode.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { isNode, isConstantNode, isOperatorNode, isParenthesisNode } from '../../utils/is.js';
 import { map } from '../../utils/array.js';
+import { createSubScope } from '../../utils/scope.js';
 import { escape } from '../../utils/string.js';
 import { getSafeProperty, isSafeMethod } from '../../utils/customs.js';
 import { getAssociativity, getPrecedence, isAssociativeWith, properties } from '../operators.js';
@@ -289,7 +290,7 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         // "raw" evaluation
         var rawArgs = this.args;
         return function evalOperatorNode(scope, args, context) {
-          return fn(rawArgs, math, scope);
+          return fn(rawArgs, math, createSubScope(scope, args));
         };
       } else if (evalArgs.length === 1) {
         var evalArg0 = evalArgs[0];

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

@@ -1,11 +1,11 @@
 import { isSymbolNode } from '../../../utils/is.js';
-import { createSubScope } from '../../../utils/scope.js';
+import { PartitionedMap } from '../../../utils/map.js';
 
 /**
  * Compile an inline expression like "x > 0"
  * @param {Node} expression
  * @param {Object} math
- * @param {Object} scope
+ * @param {Map} scope
  * @return {function} Returns a function with one argument which fills in the
  *                    undefined variable (like "x") and evaluates the expression
  */
@@ -20,10 +20,11 @@ export function compileInlineExpression(expression, math, scope) {
 
   // create a test function for this equation
   var name = symbol.name; // variable name
-  var subScope = createSubScope(scope);
+  var argsScope = new Map();
+  var subScope = new PartitionedMap(scope, argsScope, new Set([name]));
   var eq = expression.compile();
   return function inlineExpression(x) {
-    subScope.set(name, x);
+    argsScope.set(name, x);
     return eq.evaluate(subScope);
   };
 }

package/lib/esm/utils/map.js

@@ -14,7 +14,7 @@ export class ObjectWrappingMap {
     this.wrappedObject = object;
   }
   keys() {
-    return Object.keys(this.wrappedObject);
+    return Object.keys(this.wrappedObject).values();
   }
   get(key) {
     return getSafeProperty(this.wrappedObject, key);
@@ -26,6 +26,102 @@ 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;
+  }
+  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.3.2';
 // 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.3.2",
   "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,8 +43,8 @@
     "@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": "6.21.0",
+    "@typescript-eslint/parser": "6.21.0",
     "assert": "2.1.0",
     "babel-loader": "9.1.3",
     "benchmark": "2.1.4",
@@ -74,7 +74,7 @@
     "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-junit-reporter": "2.2.1",
@@ -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.1",
     "zeros": "1.0.0"
   },
   "type": "module",