mathjs 14.1.0 → 14.2.0

package/lib/cjs/function/matrix/{apply.js → mapSlices.js}

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createApply = void 0;
+exports.createMapSlices = void 0;
 var _factory = require("../../utils/factory.js");
 var _array = require("../../utils/array.js");
 var _is = require("../../utils/is.js");
 var _IndexError = require("../../error/IndexError.js");
-const name = 'apply';
+const name = 'mapSlices';
 const dependencies = ['typed', 'isInteger'];
-const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+const createMapSlices = exports.createMapSlices = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     isInteger
@@ -22,7 +22,7 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
    *
    * Syntax:
    *
-   *     math.apply(A, dim, callback)
+   *     math.mapSlices(A, dim, callback)
    *
    * Where:
    *
@@ -33,19 +33,24 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
    *    const A = [[1, 2], [3, 4]]
    *    const sum = math.sum
    *
-   *    math.apply(A, 0, sum)             // returns [4, 6]
-   *    math.apply(A, 1, sum)             // returns [3, 7]
+   *    math.mapSlices(A, 0, sum)             // returns [4, 6]
+   *    math.mapSlices(A, 1, sum)             // returns [3, 7]
    *
    * See also:
    *
    *    map, filter, forEach
    *
+   * Note:
+   *
+   *    `mapSlices()` is also currently available via its deprecated
+   *    synonym `apply()`.
+   *
    * @param {Array | Matrix} array   The input Matrix
    * @param {number} dim             The dimension along which the callback is applied
    * @param {Function} callback      The callback function that is applied. This Function
    *                                 should take an array or 1-d matrix as an input and
    *                                 return a number.
-   * @return {Array | Matrix} res    The residual matrix with the function applied over some dimension.
+   * @return {Array | Matrix} res    The residual matrix with the function mapped on the slices over some dimension.
    */
   return typed(name, {
     'Array | Matrix, number | BigNumber, function': function (mat, dim, callback) {
@@ -57,12 +62,14 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
         throw new _IndexError.IndexError(dim, size.length);
       }
       if ((0, _is.isMatrix)(mat)) {
-        return mat.create(_apply(mat.valueOf(), dim, callback), mat.datatype());
+        return mat.create(_mapSlices(mat.valueOf(), dim, callback), mat.datatype());
       } else {
-        return _apply(mat, dim, callback);
+        return _mapSlices(mat, dim, callback);
       }
     }
   });
+}, {
+  formerly: 'apply'
 });
 
 /**
@@ -73,7 +80,7 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
  * @returns {Array} ret
  * @private
  */
-function _apply(mat, dim, callback) {
+function _mapSlices(mat, dim, callback) {
   let i, ret, tran;
   if (dim <= 0) {
     if (!Array.isArray(mat[0])) {
@@ -82,14 +89,14 @@ function _apply(mat, dim, callback) {
       tran = _switch(mat);
       ret = [];
       for (i = 0; i < tran.length; i++) {
-        ret[i] = _apply(tran[i], dim - 1, callback);
+        ret[i] = _mapSlices(tran[i], dim - 1, callback);
       }
       return ret;
     }
   } else {
     ret = [];
     for (i = 0; i < mat.length; i++) {
-      ret[i] = _apply(mat[i], dim - 1, callback);
+      ret[i] = _mapSlices(mat[i], dim - 1, callback);
     }
     return ret;
   }

package/lib/cjs/function/matrix/matrixFromFunction.js

@@ -15,8 +15,10 @@ const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__
   } = _ref;
   /**
    * Create a matrix by evaluating a generating function at each index.
-   * The simplest overload returns a multi-dimensional array as long as `size` is an array.
-   * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
+   * The simplest overload returns a multi-dimensional array as long as `size`
+   * is an array.
+   * Passing `size` as a Matrix or specifying a `format` will result in
+   * returning a Matrix.
    *
    * Syntax:
    *
@@ -26,6 +28,37 @@ const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__
    *    math.matrixFromFunction(size, format, fn)
    *    math.matrixFromFunction(size, format, datatype, fn)
    *
+   * Where:
+   *
+   *    - `size: (number[] | Matrix)`
+   *      A vector giving the extent of the array to be created in each
+   *      dimension. If size has one entry, a vector is created; if it
+   *      has two, a rectangular array/Matrix is created; if three, a
+   *      three-dimensional array/Matrix is created; and so on.
+   *    - `fn: (index: number[]) => MathType`
+   *      The callback function that will generate the entries of the
+   *      matrix. It is called in turn with the index of each entry of
+   *      the matrix. The index is always an ordinary array of numbers
+   *      with the same length as _size_. So for vectors, you will get
+   *      indices like `[0]` or `[1]`, whereas for matrices, you will
+   *      get indices like `[2, 0]` or `[1,3]`. The return value may
+   *      be any type that can go in an array or Matrix entry, although
+   *      if you supply the _datatype_ argument, you must yourself ensure
+   *      the type of the return value matches. Note that currently,
+   *      your callback _fn_ will receive 0-based indices for the matrix
+   *      entries, regardless of whether matrixFromFunction is invoked
+   *      directly from JavaScript or via the mathjs expression language.
+   *    - `format: 'dense'|'sparse'`
+   *      Specifies the storage format for the resulting Matrix. Note that
+   *      if this argument is given, the return value will always be a
+   *      Matrix (rather than possibly an Array).
+   *    - `datatype: string`
+   *      Specifies the data type of entries of the new matrix. If given,
+   *      it should be the name of a data type that mathjs supports, as
+   *      returned by the math.typeOf function. It is up to the caller
+   *      to make certain that all values returned by _fn_ are consistent
+   *      with this datatype if specified.
+   *
    * Examples:
    *
    *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
@@ -34,7 +67,7 @@ const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__
    *
    * See also:
    *
-   *    matrix, zeros
+   *    matrix, typeOf, zeros
    *
    * @param {Array | Matrix} size   The size of the matrix to be created
    * @param {function} fn           Callback function invoked for every entry in the matrix

package/lib/cjs/function/matrix/range.js

@@ -41,36 +41,48 @@ const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(n
    *
    * - `str: string`
    *   A string 'start:end' or 'start:step:end'
-   * - `start: {number | BigNumber | Unit}`
+   * - `start: {number | bigint | BigNumber | Fraction | Unit}`
    *   Start of the range
-   * - `end: number | BigNumber | Unit`
+   * - `end: number | bigint | BigNumber | Fraction | Unit`
    *   End of the range, excluded by default, included when parameter includeEnd=true
-   * - `step: number | BigNumber | Unit`
+   * - `step: number | bigint | BigNumber | Fraction | Unit`
    *   Step size. Default value is 1.
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
    *
+   * Note that the return type of the range is taken from the type of
+   * the start/end. If only one these is a built-in `number` type, it will
+   * be promoted to the type of the other endpoint. However, in the case of
+   * Unit values, both endpoints must have compatible units, and the return
+   * value will have compatible units as well.
+   *
    * Examples:
    *
    *     math.range(2, 6)        // [2, 3, 4, 5]
    *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
    *     math.range('2:1:6')     // [2, 3, 4, 5]
    *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *     math.range(2, math.fraction(8,3), math.fraction(1,3)) // [fraction(2), fraction(7,3)]
    *     math.range(math.unit(2, 'm'), math.unit(-3, 'm'), math.unit(-1, 'm')) // [2 m, 1 m, 0 m , -1 m, -2 m]
    *
    * See also:
    *
    *     ones, zeros, size, subset
    *
-   * @param {*} args   Parameters describing the ranges `start`, `end`, and optional `step`.
+   * @param {*} args   Parameters describing the range's `start`, `end`, and optional `step`.
    * @return {Array | Matrix} range
    */
   return typed(name, {
     // TODO: simplify signatures when typed-function supports default values and optional arguments
 
-    // TODO: a number or boolean should not be converted to string here
     string: _strRange,
     'string, boolean': _strRange,
+    number: function (oops) {
+      throw new TypeError(`Too few arguments to function range(): ${oops}`);
+    },
+    boolean: function (oops) {
+      throw new TypeError(`Unexpected type of argument 1 to function range(): ${oops}, number|bigint|BigNumber|Fraction`);
+    },
     'number, number': function (start, end) {
       return _out(_range(start, end, 1, false));
     },
@@ -83,6 +95,31 @@ const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(n
     'number, number, number, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    // Handle bigints; if either limit is bigint, range should be too
+    'bigint, bigint|number': function (start, end) {
+      return _out(_range(start, end, 1n, false));
+    },
+    'number, bigint': function (start, end) {
+      return _out(_range(BigInt(start), end, 1n, false));
+    },
+    'bigint, bigint|number, bigint|number': function (start, end, step) {
+      return _out(_range(start, end, BigInt(step), false));
+    },
+    'number, bigint, bigint|number': function (start, end, step) {
+      return _out(_range(BigInt(start), end, BigInt(step), false));
+    },
+    'bigint, bigint|number, boolean': function (start, end, includeEnd) {
+      return _out(_range(start, end, 1n, includeEnd));
+    },
+    'number, bigint, boolean': function (start, end, includeEnd) {
+      return _out(_range(BigInt(start), end, 1n, includeEnd));
+    },
+    'bigint, bigint|number, bigint|number, boolean': function (start, end, step, includeEnd) {
+      return _out(_range(start, end, BigInt(step), includeEnd));
+    },
+    'number, bigint, bigint|number, boolean': function (start, end, step, includeEnd) {
+      return _out(_range(BigInt(start), end, BigInt(step), includeEnd));
+    },
     'BigNumber, BigNumber': function (start, end) {
       const BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), false));
@@ -97,6 +134,18 @@ const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(n
     'BigNumber, BigNumber, BigNumber, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    'Fraction, Fraction': function (start, end) {
+      return _out(_range(start, end, 1, false));
+    },
+    'Fraction, Fraction, Fraction': function (start, end, step) {
+      return _out(_range(start, end, step, false));
+    },
+    'Fraction, Fraction, boolean': function (start, end, includeEnd) {
+      return _out(_range(start, end, 1, includeEnd));
+    },
+    'Fraction, Fraction, Fraction, boolean': function (start, end, step, includeEnd) {
+      return _out(_range(start, end, step, includeEnd));
+    },
     'Unit, Unit, Unit': function (start, end, step) {
       return _out(_range(start, end, step, false));
     },

package/lib/cjs/function/statistics/quantileSeq.js

@@ -7,9 +7,8 @@ exports.createQuantileSeq = void 0;
 var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var _apply = require("../matrix/apply.js");
 const name = 'quantileSeq';
-const dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+const dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger', 'mapSlices'];
 const createQuantileSeq = exports.createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -23,13 +22,9 @@ const createQuantileSeq = exports.createQuantileSeq = /* #__PURE__ */(0, _factor
     isInteger,
     smaller,
     smallerEq,
-    larger
+    larger,
+    mapSlices
   } = _ref;
-  const apply = (0, _apply.createApply)({
-    typed,
-    isInteger
-  });
-
   /**
    * Compute the prob order quantile of a matrix or a list with values.
    * The sequence is sorted and the middle value is returned.
@@ -75,7 +70,7 @@ const createQuantileSeq = exports.createQuantileSeq = /* #__PURE__ */(0, _factor
     'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection)
   });
   function _quantileSeqDim(data, prob, sorted, dim, fn) {
-    return apply(data, dim, x => fn(x, prob, sorted));
+    return mapSlices(data, dim, x => fn(x, prob, sorted));
   }
   function _quantileSeqProbNumber(data, probOrN, sorted) {
     let probArr;

package/lib/cjs/function/statistics/variance.js

@@ -10,7 +10,7 @@ var _factory = require("../../utils/factory.js");
 var _improveErrorMessage = require("./utils/improveErrorMessage.js");
 const DEFAULT_NORMALIZATION = 'unbiased';
 const name = 'variance';
-const dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
+const dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'mapSlices', 'isNaN'];
 const createVariance = exports.createVariance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -18,7 +18,7 @@ const createVariance = exports.createVariance = /* #__PURE__ */(0, _factory.fact
     subtract,
     multiply,
     divide,
-    apply,
+    mapSlices,
     isNaN
   } = _ref;
   /**
@@ -151,7 +151,7 @@ const createVariance = exports.createVariance = /* #__PURE__ */(0, _factory.fact
       if (array.length === 0) {
         throw new SyntaxError('Function variance requires one or more parameters (0 provided)');
       }
-      return apply(array, dim, x => _var(x, normalization));
+      return mapSlices(array, dim, x => _var(x, normalization));
     } catch (err) {
       throw (0, _improveErrorMessage.improveErrorMessage)(err, 'variance');
     }

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

@@ -17,7 +17,7 @@ const dependencies = ['typed', 'format'];
  *
  * Examples:
  *
- *    math.hex(240) // returns "0xF0"
+ *    math.hex(240) // returns "0xf0"
  *
  * See also:
  *

package/lib/cjs/function/trigonometry/acoth.js

@@ -28,7 +28,7 @@ const createAcoth = exports.createAcoth = /* #__PURE__ */(0, _factory.factory)(n
    *
    * Examples:
    *
-   *    math.acoth(0.5)       // returns 0.8047189562170503
+   *    math.acoth(0.5)     // returns 0.5493061443340548 - 1.5707963267948966i
    *
    * See also:
    *

package/lib/cjs/function/trigonometry/acsc.js

@@ -29,7 +29,7 @@ const createAcsc = exports.createAcsc = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    math.acsc(2)             // returns 0.5235987755982989
    *    math.acsc(0.5)           // returns Complex 1.5707963267948966 -1.3169578969248166i
-   *    math.acsc(math.csc(1.5)) // returns number ~1.5
+   *    math.acsc(math.csc(1.5)) // returns number 1.5
    *
    * See also:
    *

package/lib/cjs/function/trigonometry/asin.js

@@ -26,7 +26,7 @@ const createAsin = exports.createAsin = /* #__PURE__ */(0, _factory.factory)(nam
    * Examples:
    *
    *    math.asin(0.5)           // returns number 0.5235987755982989
-   *    math.asin(math.sin(1.5)) // returns number ~1.5
+   *    math.asin(math.sin(1.5)) // returns number 1.5
    *
    *    math.asin(2)             // returns Complex 1.5707963267948966 -1.3169578969248166i
    *

package/lib/cjs/function/trigonometry/atan2.js

@@ -62,9 +62,10 @@ const createAtan2 = exports.createAtan2 = /* #__PURE__ */(0, _factory.factory)(n
    *
    *    math.atan2(2, 2) / math.pi       // returns number 0.25
    *
-   *    const angle = math.unit(60, 'deg') // returns Unit 60 deg
+   *    const angle = math.unit(60, 'deg')
    *    const x = math.cos(angle)
    *    const y = math.sin(angle)
+   *    math.atan2(y, x) * 180 / math.pi  // returns 60
    *
    *    math.atan(2)             // returns number 1.1071487177940904
    *

package/lib/cjs/function/trigonometry/cos.js

@@ -34,7 +34,7 @@ const createCos = exports.createCos = /* #__PURE__ */(0, _factory.factory)(name,
    *    math.cos(math.unit(60, 'deg'))   // returns number  0.5
    *
    *    const angle = 0.2
-   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number 1
    *
    * See also:
    *

package/lib/cjs/function/trigonometry/sin.js

@@ -34,7 +34,7 @@ const createSin = exports.createSin = /* #__PURE__ */(0, _factory.factory)(name,
    *    math.sin(math.unit(30, 'deg'))   // returns number 0.5
    *
    *    const angle = 0.2
-   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number 1
    *
    * See also:
    *

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 14.1.0
- * @date    2025-01-24
+ * @version 14.2.0
+ * @date    2025-01-30
  *
  * @license
  * Copyright (C) 2013-2025 Jos de Jong <wjosdejong@gmail.com>

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

@@ -48,6 +48,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
       const arg = arguments[i];
       const argIsArray = (0, _is.isArray)(arg);
       const argIsMatrix = (0, _is.isMatrix)(arg);
+      const argType = typeof arg;
       let sourceSize = null;
       if ((0, _is.isRange)(arg)) {
         this._dimensions.push(arg);
@@ -69,13 +70,15 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
         if (size.length !== 1 || size[0] !== 1 || sourceSize !== null) {
           this._isScalar = false;
         }
-      } else if (typeof arg === 'number') {
+      } else if (argType === 'number') {
         this._dimensions.push(_createImmutableMatrix([arg]));
-      } else if (typeof arg === 'string') {
+      } else if (argType === 'bigint') {
+        this._dimensions.push(_createImmutableMatrix([Number(arg)]));
+      } else if (argType === 'string') {
         // object property (arguments.count should be 1)
         this._dimensions.push(arg);
       } else {
-        throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
+        throw new TypeError('Dimension must be an Array, Matrix, number, bigint, string, or Range');
       }
       this._sourceSize.push(sourceSize);
       // TODO: implement support for wildcard '*'

package/lib/cjs/type/matrix/Range.js

@@ -11,14 +11,21 @@ const name = 'Range';
 const dependencies = [];
 const createRangeClass = exports.createRangeClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, () => {
   /**
-   * Create a range. A range has a start, step, and end, and contains functions
-   * to iterate over the range.
+   * Create a range of numbers. A range has a start, step, and end,
+   * and contains functions to iterate over the range.
    *
    * A range can be constructed as:
    *
    *     const range = new Range(start, end)
    *     const range = new Range(start, end, step)
    *
+   * Note that the endpoints and step may be specified with other numeric
+   * types such as bigint or BigNumber, but they will be demoted to the
+   * built-in `number` type and the Range will only contain numbers. The
+   * rationale for this demotion is that Range objects are primarily used
+   * for indexing Matrix objects, and Matrix objects may only be indexed
+   * with `number`s.
+   *
    * To get the result of the range:
    *     range.forEach(function (x) {
    *         console.log(x)
@@ -51,22 +58,22 @@ const createRangeClass = exports.createRangeClass = /* #__PURE__ */(0, _factory.
     if (hasStart) {
       if ((0, _is.isBigNumber)(start)) {
         start = start.toNumber();
-      } else if (typeof start !== 'number') {
-        throw new TypeError('Parameter start must be a number');
+      } else if (typeof start !== 'number' && !(0, _is.isBigInt)(start)) {
+        throw new TypeError('Parameter start must be a number or bigint');
       }
     }
     if (hasEnd) {
       if ((0, _is.isBigNumber)(end)) {
         end = end.toNumber();
-      } else if (typeof end !== 'number') {
-        throw new TypeError('Parameter end must be a number');
+      } else if (typeof end !== 'number' && !(0, _is.isBigInt)(end)) {
+        throw new TypeError('Parameter end must be a number or bigint');
       }
     }
     if (hasStep) {
       if ((0, _is.isBigNumber)(step)) {
         step = step.toNumber();
-      } else if (typeof step !== 'number') {
-        throw new TypeError('Parameter step must be a number');
+      } else if (typeof step !== 'number' && !(0, _is.isBigInt)(step)) {
+        throw new TypeError('Parameter step must be a number or bigint');
       }
     }
     this.start = hasStart ? parseFloat(start) : 0;

package/lib/cjs/utils/factory.js

@@ -31,8 +31,11 @@ var _object = require("./object.js");
  * @param {string} name           Name of the function to be created
  * @param {string[]} dependencies The names of all required dependencies
  * @param {function} create       Callback function called with an object with all dependencies
- * @param {Object} [meta]         Optional object with meta information that will be attached
- *                                to the created factory function as property `meta`.
+ * @param {Object} [meta]
+ *     Optional object with meta information that will be attached
+ *     to the created factory function as property `meta`. For explanation
+ *     of what meta properties can be specified and what they mean, see
+ *     docs/core/extension.md.
  * @returns {function}
  */
 function factory(name, dependencies, create, meta) {

package/lib/cjs/utils/snapshot.js

@@ -110,16 +110,22 @@ function createSnapshotFromFactories(factories) {
   const allClasses = {};
   const allNodeClasses = {};
   Object.keys(factories).forEach(factoryName => {
+    var _factory$meta$formerl, _factory$meta;
     const factory = factories[factoryName];
     const name = factory.fn;
     const isTransformFunction = factory.meta && factory.meta.isTransformFunction;
     const isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'function';
     const dependenciesName = factory.fn + (isTransformFunction ? 'Transform' : '') + 'Dependencies';
+    const former = (_factory$meta$formerl = (_factory$meta = factory.meta) === null || _factory$meta === void 0 ? void 0 : _factory$meta.formerly) !== null && _factory$meta$formerl !== void 0 ? _factory$meta$formerl : '';
     allFactoryFunctions[factoryName] = 'function';
     allFunctionsConstantsClasses[name] = validateTypeOf(math[name]);
+    if (former) {
+      allFunctionsConstantsClasses[former] = allFunctionsConstantsClasses[name];
+    }
     allDependencyCollections[dependenciesName] = 'Object';
     if (isTransformFunction) {
       allTransformFunctions[name] = 'function';
+      if (former) allTransformFunctions[former] = 'function';
     }
     if (isClass) {
       if ((0, _string.endsWith)(name, 'Node')) {
@@ -129,6 +135,7 @@ function createSnapshotFromFactories(factories) {
       }
     } else {
       allFunctionsConstants[name] = validateTypeOf(math[name]);
+      if (former) allFunctionsConstants[former] = allFunctionsConstants[name];
     }
   });
   let embeddedDocs = {};
@@ -140,7 +147,7 @@ function createSnapshotFromFactories(factories) {
       embeddedDocs[name] = 'Object';
     }
   });
-  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
   const allTypeChecks = {};
   Object.keys(allIsFunctions).forEach(name => {
     if (name.indexOf('is') === 0) {

package/lib/cjs/version.js

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

package/lib/esm/core/function/import.js

@@ -217,6 +217,7 @@ export function importFactory(typed, load, math, importedFactories) {
    * @private
    */
   function _importFactory(factory, options) {
+    var _factory$meta$formerl, _factory$meta;
     var name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : factory.fn;
     if (name.includes('.')) {
       throw new Error('Factory name should not contain a nested path. ' + 'Name: ' + JSON.stringify(name));
@@ -260,28 +261,37 @@ export function importFactory(typed, load, math, importedFactories) {
         throw new Error('Cannot import "' + name + '": already exists');
       }
     };
+    var former = (_factory$meta$formerl = (_factory$meta = factory.meta) === null || _factory$meta === void 0 ? void 0 : _factory$meta.formerly) !== null && _factory$meta$formerl !== void 0 ? _factory$meta$formerl : '';
+    var needsTransform = isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory);
+    var withTransform = math.expression.mathWithTransform;
 
     // TODO: add unit test with non-lazy factory
     if (!factory.meta || factory.meta.lazy !== false) {
       lazy(namespace, name, resolver);
+      if (former) lazy(namespace, former, resolver);
 
       // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
       if (existing && existingTransform) {
         _deleteTransform(name);
+        if (former) _deleteTransform(former);
       } else {
-        if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
-          lazy(math.expression.mathWithTransform, name, () => namespace[name]);
+        if (needsTransform) {
+          lazy(withTransform, name, () => namespace[name]);
+          if (former) lazy(withTransform, former, () => namespace[name]);
         }
       }
     } else {
       namespace[name] = resolver();
+      if (former) namespace[former] = namespace[name];
 
       // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
       if (existing && existingTransform) {
         _deleteTransform(name);
+        if (former) _deleteTransform(former);
       } else {
-        if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
-          lazy(math.expression.mathWithTransform, name, () => namespace[name]);
+        if (needsTransform) {
+          lazy(withTransform, name, () => namespace[name]);
+          if (former) lazy(withTransform, former, () => namespace[name]);
         }
       }
     }

package/lib/esm/entry/{dependenciesNumber/dependenciesApply.generated.js → dependenciesAny/dependenciesMapSlices.generated.js}

@@ -4,9 +4,9 @@
  */
 import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
-import { createApply } from '../../factoriesNumber.js';
-export var applyDependencies = {
+import { createMapSlices } from '../../factoriesAny.js';
+export var mapSlicesDependencies = {
   isIntegerDependencies,
   typedDependencies,
-  createApply
+  createMapSlices
 };

package/lib/esm/entry/{dependenciesNumber/dependenciesApplyTransform.generated.js → dependenciesAny/dependenciesMapSlicesTransform.generated.js}

@@ -4,9 +4,9 @@
  */
 import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
-import { createApplyTransform } from '../../factoriesNumber.js';
-export var applyTransformDependencies = {
+import { createMapSlicesTransform } from '../../factoriesAny.js';
+export var mapSlicesTransformDependencies = {
   isIntegerDependencies,
   typedDependencies,
-  createApplyTransform
+  createMapSlicesTransform
 };

package/lib/esm/entry/dependenciesAny/dependenciesQuantileSeq.generated.js

@@ -8,6 +8,7 @@ import { compareDependencies } from './dependenciesCompare.generated.js';
 import { divideDependencies } from './dependenciesDivide.generated.js';
 import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
+import { mapSlicesDependencies } from './dependenciesMapSlices.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { partitionSelectDependencies } from './dependenciesPartitionSelect.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
@@ -22,6 +23,7 @@ export var quantileSeqDependencies = {
   divideDependencies,
   isIntegerDependencies,
   largerDependencies,
+  mapSlicesDependencies,
   multiplyDependencies,
   partitionSelectDependencies,
   smallerDependencies,