mathjs 12.3.0 → 12.3.2

package/lib/esm/expression/Help.js

@@ -3,10 +3,10 @@ import { clone } from '../utils/object.js';
 import { format } from '../utils/string.js';
 import { factory } from '../utils/factory.js';
 var name = 'Help';
-var dependencies = ['parse'];
+var dependencies = ['evaluate'];
 export var createHelpClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    parse
+    evaluate
   } = _ref;
   /**
    * Documentation object
@@ -55,14 +55,26 @@ export var createHelpClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     }
     if (doc.examples) {
       desc += 'Examples:\n';
-      var scope = {};
+
+      // after evaluating the examples, we restore config in case the examples
+      // did change the config.
+      var configChanged = false;
+      var originalConfig = evaluate('config()');
+      var scope = {
+        config: newConfig => {
+          configChanged = true;
+          return evaluate('config(newConfig)', {
+            newConfig
+          });
+        }
+      };
       for (var i = 0; i < doc.examples.length; i++) {
         var expr = doc.examples[i];
         desc += '    ' + expr + '\n';
         var res = void 0;
         try {
           // note: res can be undefined when `expr` is an empty string
-          res = parse(expr).compile().evaluate(scope);
+          res = evaluate(expr, scope);
         } catch (e) {
           res = e;
         }
@@ -73,6 +85,11 @@ export var createHelpClass = /* #__PURE__ */factory(name, dependencies, _ref =>
         }
       }
       desc += '\n';
+      if (configChanged) {
+        evaluate('config(originalConfig)', {
+          originalConfig
+        });
+      }
     }
     if (doc.mayThrow && doc.mayThrow.length) {
       desc += 'Throws: ' + doc.mayThrow.join(', ') + '\n\n';

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/function/string/bin.js

@@ -19,8 +19,8 @@ var dependencies = ['typed', 'format'];
  *    oct
  *    hex
  *
- * @param {number} value    Value to be stringified
- * @param {number} wordSize Optional word size (see `format`)
+ * @param {number | BigNumber} value    Value to be stringified
+ * @param {number | BigNumber} wordSize Optional word size (see `format`)
  * @return {string}         The formatted value
  */
 export var createBin = factory(name, dependencies, _ref => {
@@ -34,7 +34,7 @@ export var createBin = factory(name, dependencies, _ref => {
         notation: 'bin'
       });
     },
-    'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
+    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, wordSize) {
       return format(n, {
         notation: 'bin',
         wordSize

package/lib/esm/function/string/format.js

@@ -42,7 +42,7 @@ export var createFormat = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      - `'bin'`, `'oct'`, or `'hex'`
    *        Format the number using binary, octal, or hexadecimal notation.
    *        For example `'0b1101'` and `'0x10fe'`.
-   *    - `wordSize: number`
+   *    - `wordSize: number | BigNumber`
    *      The word size in bits to use for formatting in binary, octal, or
    *      hexadecimal notation. To be used only with `'bin'`, `'oct'`, or `'hex'`
    *      values for `notation` option. When this option is defined the value
@@ -50,7 +50,7 @@ export var createFormat = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      size and the size suffix is appended to the output.
    *      For example `format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'`.
    *      Default value is undefined.
-   *    - `precision: number`
+   *    - `precision: number | BigNumber`
    *      Limit the number of digits of the formatted value.
    *      For regular numbers, must be a number between `0` and `16`.
    *      For bignumbers, the maximum depends on the configured precision,
@@ -126,6 +126,6 @@ export var createFormat = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     any: formatString,
-    'any, Object | function | number': formatString
+    'any, Object | function | number | BigNumber': formatString
   });
 });

package/lib/esm/function/string/hex.js

@@ -18,8 +18,8 @@ var dependencies = ['typed', 'format'];
  *    oct
  *    bin
  *
- * @param {number} value    Value to be stringified
- * @param {number} wordSize Optional word size (see `format`)
+ * @param {number | BigNumber} value    Value to be stringified
+ * @param {number | BigNumber} wordSize Optional word size (see `format`)
  * @return {string}         The formatted value
  */
 export var createHex = factory(name, dependencies, _ref => {
@@ -33,7 +33,7 @@ export var createHex = factory(name, dependencies, _ref => {
         notation: 'hex'
       });
     },
-    'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
+    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, wordSize) {
       return format(n, {
         notation: 'hex',
         wordSize

package/lib/esm/function/string/oct.js

@@ -19,8 +19,8 @@ var dependencies = ['typed', 'format'];
  *    bin
  *    hex
  *
- * @param {number} value    Value to be stringified
- * @param {number} wordSize Optional word size (see `format`)
+ * @param {number | BigNumber} value    Value to be stringified
+ * @param {number | BigNumber} wordSize Optional word size (see `format`)
  * @return {string}         The formatted value
  */
 
@@ -35,7 +35,7 @@ export var createOct = factory(name, dependencies, _ref => {
         notation: 'oct'
       });
     },
-    'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
+    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, wordSize) {
       return format(n, {
         notation: 'oct',
         wordSize

package/lib/esm/type/unit/physicalConstants.js

@@ -44,7 +44,7 @@ export var createAvogadro = /* #__PURE__ */unitFactory('avogadro', '6.02214076e2
 export var createBoltzmann = /* #__PURE__ */unitFactory('boltzmann', '1.380649e-23', 'J K^-1');
 export var createFaraday = /* #__PURE__ */unitFactory('faraday', '96485.33212331001', 'C mol^-1');
 export var createFirstRadiation = /* #__PURE__ */unitFactory('firstRadiation', '3.7417718521927573e-16', 'W m^2');
-// export const createSpectralRadiance = /* #__PURE__ */ unitFactory('spectralRadiance', '1.1910429723971881e-16', 'W m^2 sr^-1') // TODO spectralRadiance
+// TODO spectralRadiance = 1.1910429723971881e-16 W m^2 sr^-1
 export var createLoschmidt = /* #__PURE__ */unitFactory('loschmidt', '2.686780111798444e25', 'm^-3');
 export var createGasConstant = /* #__PURE__ */unitFactory('gasConstant', '8.31446261815324', 'J K^-1 mol^-1');
 export var createMolarPlanckConstant = /* #__PURE__ */unitFactory('molarPlanckConstant', '3.990312712893431e-10', 'J s mol^-1');

package/lib/esm/utils/bignumber/formatter.js

@@ -1,4 +1,5 @@
-import { isInteger } from '../number.js';
+import { isBigNumber, isNumber } from '../is.js';
+import { isInteger, normalizeFormatOptions } from '../number.js';
 
 /**
  * Formats a BigNumber in a given base
@@ -119,7 +120,7 @@ function formatBigNumberToBase(n, base, size) {
  *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
  *
  * @param {BigNumber} value
- * @param {Object | Function | number} [options]
+ * @param {Object | Function | number | BigNumber} [options]
  * @return {string} str The formatted value
  */
 export function format(value, options) {
@@ -132,30 +133,11 @@ export function format(value, options) {
   if (!value.isFinite()) {
     return value.isNaN() ? 'NaN' : value.gt(0) ? 'Infinity' : '-Infinity';
   }
-
-  // default values for options
-  var notation = 'auto';
-  var precision;
-  var wordSize;
-  if (options !== undefined) {
-    // determine notation from options
-    if (options.notation) {
-      notation = options.notation;
-    }
-
-    // determine precision from options
-    if (typeof options === 'number') {
-      precision = options;
-    } else if (options.precision !== undefined) {
-      precision = options.precision;
-    }
-    if (options.wordSize) {
-      wordSize = options.wordSize;
-      if (typeof wordSize !== 'number') {
-        throw new Error('Option "wordSize" must be a number');
-      }
-    }
-  }
+  var {
+    notation,
+    precision,
+    wordSize
+  } = normalizeFormatOptions(options);
 
   // handle the various notations
   switch (notation) {
@@ -175,8 +157,8 @@ export function format(value, options) {
       {
         // determine lower and upper bound for exponential notation.
         // TODO: implement support for upper and lower to be BigNumbers themselves
-        var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3;
-        var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5;
+        var lowerExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.lowerExp, -3);
+        var upperExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.upperExp, 5);
 
         // handle special case zero
         if (value.isZero()) return '0';
@@ -249,4 +231,13 @@ export function toExponential(value, precision) {
  */
 export function toFixed(value, precision) {
   return value.toFixed(precision);
+}
+function _toNumberOrDefault(value, defaultValue) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isBigNumber(value)) {
+    return value.toNumber();
+  } else {
+    return defaultValue;
+  }
 }

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/number.js

@@ -1,4 +1,4 @@
-import { isNumber } from './is.js';
+import { isBigNumber, isNumber, isObject } from './is.js';
 
 /**
  * @typedef {{sign: '+' | '-' | '', coefficients: number[], exponent: number}} SplitValue
@@ -21,7 +21,7 @@ export function isInteger(value) {
  * @param {number} x
  * @returns {number}
  */
-export var sign = /* #__PURE__ */Math.sign || function (x) {
+export var sign = Math.sign || function (x) {
   if (x > 0) {
     return 1;
   } else if (x < 0) {
@@ -36,7 +36,7 @@ export var sign = /* #__PURE__ */Math.sign || function (x) {
  * @param {number} x
  * @returns {number}
  */
-export var log2 = /* #__PURE__ */Math.log2 || function log2(x) {
+export var log2 = Math.log2 || function log2(x) {
   return Math.log(x) / Math.LN2;
 };
 
@@ -45,7 +45,7 @@ export var log2 = /* #__PURE__ */Math.log2 || function log2(x) {
  * @param {number} x
  * @returns {number}
  */
-export var log10 = /* #__PURE__ */Math.log10 || function log10(x) {
+export var log10 = Math.log10 || function log10(x) {
   return Math.log(x) / Math.LN10;
 };
 
@@ -54,7 +54,7 @@ export var log10 = /* #__PURE__ */Math.log10 || function log10(x) {
  * @param {number} x
  * @returns {number}
  */
-export var log1p = /* #__PURE__ */Math.log1p || function (x) {
+export var log1p = Math.log1p || function (x) {
   return Math.log(x + 1);
 };
 
@@ -67,7 +67,7 @@ export var log1p = /* #__PURE__ */Math.log1p || function (x) {
  * @param {number} x
  * @returns {number} Returns the cubic root of x
  */
-export var cbrt = /* #__PURE__ */Math.cbrt || function cbrt(x) {
+export var cbrt = Math.cbrt || function cbrt(x) {
   if (x === 0) {
     return x;
   }
@@ -91,7 +91,7 @@ export var cbrt = /* #__PURE__ */Math.cbrt || function cbrt(x) {
  * @param {number} x
  * @return {number} res
  */
-export var expm1 = /* #__PURE__ */Math.expm1 || function expm1(x) {
+export var expm1 = Math.expm1 || function expm1(x) {
   return x >= 2e-4 || x <= -2e-4 ? Math.exp(x) - 1 : x + x * x / 2 + x * x * x / 6;
 };
 
@@ -234,30 +234,11 @@ export function format(value, options) {
   } else if (isNaN(value)) {
     return 'NaN';
   }
-
-  // default values for options
-  var notation = 'auto';
-  var precision;
-  var wordSize;
-  if (options) {
-    // determine notation from options
-    if (options.notation) {
-      notation = options.notation;
-    }
-
-    // determine precision from options
-    if (isNumber(options)) {
-      precision = options;
-    } else if (isNumber(options.precision)) {
-      precision = options.precision;
-    }
-    if (options.wordSize) {
-      wordSize = options.wordSize;
-      if (typeof wordSize !== 'number') {
-        throw new Error('Option "wordSize" must be a number');
-      }
-    }
-  }
+  var {
+    notation,
+    precision,
+    wordSize
+  } = normalizeFormatOptions(options);
 
   // handle the various notations
   switch (notation) {
@@ -275,7 +256,7 @@ export function format(value, options) {
       return formatNumberToBase(value, 16, wordSize);
     case 'auto':
       // remove trailing zeros after the decimal point
-      return toPrecision(value, precision, options && options).replace(/((\.\d*?)(0+))($|e)/, function () {
+      return toPrecision(value, precision, options).replace(/((\.\d*?)(0+))($|e)/, function () {
         var digits = arguments[2];
         var e = arguments[4];
         return digits !== '.' ? digits + e : e;
@@ -285,6 +266,49 @@ export function format(value, options) {
   }
 }
 
+/**
+ * Normalize format options into an object:
+ *   {
+ *     notation: string,
+ *     precision: number | undefined,
+ *     wordSize: number | undefined
+ *   }
+ */
+export function normalizeFormatOptions(options) {
+  // default values for options
+  var notation = 'auto';
+  var precision;
+  var wordSize;
+  if (options !== undefined) {
+    if (isNumber(options)) {
+      precision = options;
+    } else if (isBigNumber(options)) {
+      precision = options.toNumber();
+    } else if (isObject(options)) {
+      if (options.precision !== undefined) {
+        precision = _toNumberOrThrow(options.precision, () => {
+          throw new Error('Option "precision" must be a number or BigNumber');
+        });
+      }
+      if (options.wordSize !== undefined) {
+        wordSize = _toNumberOrThrow(options.wordSize, () => {
+          throw new Error('Option "wordSize" must be a number or BigNumber');
+        });
+      }
+      if (options.notation) {
+        notation = options.notation;
+      }
+    } else {
+      throw new Error('Unsupported type of options, number, BigNumber, or object expected');
+    }
+  }
+  return {
+    notation,
+    precision,
+    wordSize
+  };
+}
+
 /**
  * Split a number into sign, coefficients, and exponent
  * @param {number | string} value
@@ -448,8 +472,8 @@ export function toPrecision(value, precision, options) {
   }
 
   // determine lower and upper bound for exponential notation.
-  var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3;
-  var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5;
+  var lowerExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.lowerExp, -3);
+  var upperExp = _toNumberOrDefault(options === null || options === void 0 ? void 0 : options.upperExp, 5);
   var split = splitNumber(value);
   var rounded = precision ? roundDigits(split, precision) : split;
   if (rounded.exponent < lowerExp || rounded.exponent >= upperExp) {
@@ -654,4 +678,22 @@ export function copysign(x, y) {
   var signx = x > 0 ? true : x < 0 ? false : 1 / x === Infinity;
   var signy = y > 0 ? true : y < 0 ? false : 1 / y === Infinity;
   return signx ^ signy ? -x : x;
+}
+function _toNumberOrThrow(value, onError) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isBigNumber(value)) {
+    return value.toNumber();
+  } else {
+    onError();
+  }
+}
+function _toNumberOrDefault(value, defaultValue) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isBigNumber(value)) {
+    return value.toNumber();
+  } else {
+    return defaultValue;
+  }
 }

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.0';
+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.0",
+  "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",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.23.8",
+    "@babel/runtime": "^7.23.9",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -36,21 +36,21 @@
     "typed-function": "^4.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.23.7",
+    "@babel/core": "7.23.9",
     "@babel/plugin-transform-object-assign": "7.23.3",
-    "@babel/plugin-transform-runtime": "7.23.7",
-    "@babel/preset-env": "7.23.8",
+    "@babel/plugin-transform-runtime": "7.23.9",
+    "@babel/preset-env": "7.23.9",
     "@babel/register": "7.23.7",
     "@types/assert": "1.5.10",
     "@types/mocha": "10.0.6",
-    "@typescript-eslint/eslint-plugin": "6.18.1",
-    "@typescript-eslint/parser": "6.18.1",
+    "@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",
-    "c8": "9.0.0",
+    "c8": "9.1.0",
     "codecov": "3.8.3",
-    "core-js": "3.35.0",
+    "core-js": "3.35.1",
     "del": "6.1.1",
     "dtslint": "4.2.1",
     "eslint": "8.56.0",
@@ -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.1.1",
+    "prettier": "3.2.5",
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.2",
     "typescript": "5.3.3",
-    "webpack": "5.89.0",
+    "webpack": "5.90.1",
     "zeros": "1.0.0"
   },
   "type": "module",