mathjs 14.6.0 → 14.8.0

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

@@ -225,6 +225,8 @@ export { nthRootDependencies } from './dependenciesAny/dependenciesNthRoot.gener
 export { nthRootsDependencies } from './dependenciesAny/dependenciesNthRoots.generated.js';
 export { nuclearMagnetonDependencies } from './dependenciesAny/dependenciesNuclearMagneton.generated.js';
 export { nullDependencies } from './dependenciesAny/dependenciesNull.generated.js';
+export { nullishDependencies } from './dependenciesAny/dependenciesNullish.generated.js';
+export { nullishTransformDependencies } from './dependenciesAny/dependenciesNullishTransform.generated.js';
 export { numberDependencies } from './dependenciesAny/dependenciesNumber.generated.js';
 export { numericDependencies } from './dependenciesAny/dependenciesNumeric.generated.js';
 export { ObjectNodeDependencies } from './dependenciesAny/dependenciesObjectNode.generated.js';

package/lib/esm/entry/impureFunctionsAny.generated.js

@@ -4,10 +4,10 @@ import _extends from "@babel/runtime/helpers/extends";
  * DON'T MAKE CHANGES HERE
  */
 import { config } from './configReadonly.js';
-import { createNode, createObjectNode, createOperatorNode, createParenthesisNode, createRelationalNode, createArrayNode, createBlockNode, createConditionalNode, createConstantNode, createRangeNode, createReviver, createChainClass, createFunctionAssignmentNode, createChain, createAccessorNode, createAssignmentNode, createIndexNode, createSymbolNode, createFunctionNode, createParse, createResolve, createSimplifyConstant, createCompile, createSimplifyCore, createEvaluate, createHelpClass, createParserClass, createSimplify, createSymbolicEqual, createLeafCount, createParser, createRationalize, createDerivative, createHelp, createMapSlicesTransform, createFilterTransform, createForEachTransform, createMapTransform, createOrTransform, createAndTransform, createConcatTransform, createIndexTransform, createPrintTransform, createSumTransform, createBitAndTransform, createMinTransform, createSubsetTransform, createBitOrTransform, createCumSumTransform, createDiffTransform, createMaxTransform, createRangeTransform, createRowTransform, createColumnTransform, createMeanTransform, createQuantileSeqTransform, createVarianceTransform, createStdTransform } from '../factoriesAny.js';
+import { createNode, createObjectNode, createOperatorNode, createParenthesisNode, createRelationalNode, createArrayNode, createBlockNode, createConditionalNode, createConstantNode, createRangeNode, createReviver, createChainClass, createFunctionAssignmentNode, createChain, createAccessorNode, createAssignmentNode, createIndexNode, createSymbolNode, createFunctionNode, createParse, createResolve, createSimplifyConstant, createCompile, createSimplifyCore, createEvaluate, createHelpClass, createParserClass, createSimplify, createSymbolicEqual, createLeafCount, createParser, createRationalize, createDerivative, createHelp, createMapSlicesTransform, createFilterTransform, createForEachTransform, createMapTransform, createOrTransform, createAndTransform, createConcatTransform, createIndexTransform, createPrintTransform, createSumTransform, createBitAndTransform, createMinTransform, createNullishTransform, createSubsetTransform, createBitOrTransform, createCumSumTransform, createDiffTransform, createMaxTransform, createRangeTransform, createRowTransform, createColumnTransform, createMeanTransform, createQuantileSeqTransform, createVarianceTransform, createStdTransform } from '../factoriesAny.js';
 import { BigNumber, Complex, e, _false, fineStructure, Fraction, i, _Infinity, LN10, LOG10E, Matrix, _NaN, _null, phi, Range, ResultSet, SQRT1_2,
 // eslint-disable-line camelcase
-sackurTetrode, tau, _true, version, DenseMatrix, efimovFactor, LN2, pi, replacer, SQRT2, typed, weakMixingAngle, abs, acos, acot, acsc, addScalar, arg, asech, asinh, atan, atanh, bigint, bitNot, boolean, clone, combinations, complex, conj, cos, cot, csc, cube, equalScalar, erf, exp, expm1, filter, flatten, forEach, format, getMatrixDataType, hex, im, isInteger, isNegative, isPositive, isZero, LOG2E, lgamma, log10, log2, map, multiplyScalar, not, number, oct, pickRandom, print, random, re, sec, sign, sin, SparseMatrix, splitUnit, square, string, subtractScalar, tan, toBest, typeOf, acosh, acsch, asec, bignumber, combinationsWithRep, cosh, csch, isNaN, isPrime, mapSlices, matrix, matrixFromFunction, ones, randomInt, reshape, sech, sinh, sparse, sqrt, squeeze, tanh, transpose, xgcd, zeros, acoth, asin, bin, concat, coth, ctranspose, diag, dotMultiply, equal, fraction, identity, isNumeric, kron, largerEq, leftShift, mode, nthRoot, numeric, prod, resize, rightArithShift, round, size, smaller, to, unaryMinus, unequal, xor, add, atan2, bitAnd, bitOr, bitXor, cbrt, compare, compareText, count, deepEqual, divideScalar, dotDivide, equalText, floor, gcd, hasNumericValue, hypot, ImmutableDenseMatrix, Index, larger, log, lsolve, matrixFromColumns, max, min, mod, nthRoots, or, partitionSelect, qr, rightLogShift, smallerEq, subset, subtract, trace, usolve, catalan, compareNatural, composition, diff, distance, dot, FibonacciHeap, index, invmod, lcm, log1p, lsolveAll, matrixFromRows, multiply, range, row, setCartesian, setDistinct, setIsSubset, setPowerset, slu, sort, unaryPlus, usolveAll, zpk2tf, and, ceil, column, cross, det, fix, inv, pinv, pow, setDifference, setMultiplicity, setSymDifference, Spa, sqrtm, sum, Unit, vacuumImpedance, wienDisplacement, atomicMass, bohrMagneton, boltzmann, conductanceQuantum, coulomb, createUnit, deuteronMass, dotPow, electricConstant, elementaryCharge, expm, faraday, fft, gamma, gravitationConstant, hartreeEnergy, ifft, inverseConductanceQuantum, klitzing, loschmidt, magneticConstant, molarMass, molarPlanckConstant, neutronMass, nuclearMagneton, planckCharge, planckLength, planckTemperature, protonMass, quantumOfCirculation, reducedPlanckConstant, rydberg, secondRadiation, setSize, speedOfLight, stefanBoltzmann, thomsonCrossSection, avogadro, bohrRadius, coulombConstant, divide, electronMass, factorial, firstRadiation, gravity, intersect, lup, magneticFluxQuantum, molarMassC12, multinomial, permutations, planckMass, polynomialRoot, setIntersect, solveODE, stirlingS2, unit, bellNumbers, cumsum, eigs, fermiCoupling, gasConstant, kldivergence, lusolve, mean, molarVolume, planckConstant, quantileSeq, setUnion, variance, classicalElectronRadius, median, corr, freqz, mad, std, zeta, norm, rotationMatrix, planckTime, schur, rotate, sylvester, lyap } from './pureFunctionsAny.generated.js';
+sackurTetrode, tau, _true, version, DenseMatrix, efimovFactor, LN2, pi, replacer, SQRT2, typed, weakMixingAngle, abs, acos, acot, acsc, addScalar, arg, asech, asinh, atan, atanh, bigint, bitNot, boolean, clone, combinations, complex, conj, cos, cot, csc, cube, equalScalar, erf, exp, expm1, filter, flatten, forEach, format, getMatrixDataType, hex, im, isInteger, isNegative, isPositive, isZero, LOG2E, lgamma, log10, log2, map, multiplyScalar, not, number, oct, pickRandom, print, random, re, sec, sign, sin, SparseMatrix, splitUnit, square, string, subtractScalar, tan, toBest, typeOf, acosh, acsch, asec, bignumber, combinationsWithRep, cosh, csch, isNaN, isPrime, mapSlices, matrix, matrixFromFunction, ones, randomInt, reshape, sech, sinh, sparse, sqrt, squeeze, tanh, transpose, xgcd, zeros, acoth, asin, bin, concat, coth, ctranspose, diag, dotMultiply, equal, fraction, identity, isNumeric, kron, largerEq, leftShift, mode, nthRoot, numeric, prod, resize, rightArithShift, round, size, smaller, to, unaryMinus, unequal, xor, add, atan2, bitAnd, bitOr, bitXor, cbrt, compare, compareText, count, deepEqual, divideScalar, dotDivide, equalText, floor, gcd, hasNumericValue, hypot, ImmutableDenseMatrix, Index, larger, log, lsolve, matrixFromColumns, max, min, mod, nthRoots, nullish, or, partitionSelect, qr, rightLogShift, smallerEq, subset, subtract, trace, usolve, catalan, compareNatural, composition, diff, distance, dot, FibonacciHeap, index, invmod, lcm, log1p, lsolveAll, matrixFromRows, multiply, range, row, setCartesian, setDistinct, setIsSubset, setPowerset, slu, sort, unaryPlus, usolveAll, zpk2tf, and, ceil, column, cross, det, fix, inv, pinv, pow, setDifference, setMultiplicity, setSymDifference, Spa, sqrtm, sum, Unit, vacuumImpedance, wienDisplacement, atomicMass, bohrMagneton, boltzmann, conductanceQuantum, coulomb, createUnit, deuteronMass, dotPow, electricConstant, elementaryCharge, expm, faraday, fft, gamma, gravitationConstant, hartreeEnergy, ifft, inverseConductanceQuantum, klitzing, loschmidt, magneticConstant, molarMass, molarPlanckConstant, neutronMass, nuclearMagneton, planckCharge, planckLength, planckTemperature, protonMass, quantumOfCirculation, reducedPlanckConstant, rydberg, secondRadiation, setSize, speedOfLight, stefanBoltzmann, thomsonCrossSection, avogadro, bohrRadius, coulombConstant, divide, electronMass, factorial, firstRadiation, gravity, intersect, lup, magneticFluxQuantum, molarMassC12, multinomial, permutations, planckMass, polynomialRoot, setIntersect, solveODE, stirlingS2, unit, bellNumbers, cumsum, eigs, fermiCoupling, gasConstant, kldivergence, lusolve, mean, molarVolume, planckConstant, quantileSeq, setUnion, variance, classicalElectronRadius, median, corr, freqz, mad, std, zeta, norm, rotationMatrix, planckTime, schur, rotate, sylvester, lyap } from './pureFunctionsAny.generated.js';
 var math = {}; // NOT pure!
 var mathWithTransform = {}; // NOT pure!
 var classes = {}; // NOT pure!
@@ -402,6 +402,7 @@ _extends(math, {
   min,
   mod,
   nthRoots,
+  nullish,
   or,
   partitionSelect,
   qr,
@@ -617,6 +618,13 @@ _extends(mathWithTransform, math, {
     smaller,
     typed
   }),
+  nullish: createNullishTransform({
+    deepEqual,
+    flatten,
+    matrix,
+    size,
+    typed
+  }),
   subset: createSubsetTransform({
     add,
     matrix,

package/lib/esm/entry/pureFunctionsAny.generated.js

@@ -5,7 +5,7 @@
 import { config } from './configReadonly.js';
 import { createBigNumberClass, createComplexClass, createE, createFalse, createFineStructure, createFractionClass, createI, createInfinity, createLN10, createLOG10E, createMatrixClass, createNaN, createNull, createPhi, createRangeClass, createResultSet, createSQRT1_2,
 // eslint-disable-line camelcase
-createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBigint, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCos, createCot, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createFlatten, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLgamma, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createSubtractScalar, createTan, createToBest, createTypeOf, createAcosh, createAcsch, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createMapSlices, createMatrix, createMatrixFromFunction, createOnes, createRandomInt, createReshape, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createTranspose, createXgcd, createZeros, createAcoth, createAsin, createBin, createConcat, createCoth, createCtranspose, createDiag, createDotMultiply, createEqual, createFraction, createIdentity, createIsNumeric, createKron, createLargerEq, createLeftShift, createMode, createNthRoot, createNumeric, createProd, createResize, createRightArithShift, createRound, createSize, createSmaller, createTo, createUnaryMinus, createUnequal, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCbrt, createCompare, createCompareText, createCount, createDeepEqual, createDivideScalar, createDotDivide, createEqualText, createFloor, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolve, createMatrixFromColumns, createMax, createMin, createMod, createNthRoots, createOr, createPartitionSelect, createQr, createRightLogShift, createSmallerEq, createSubset, createSubtract, createTrace, createUsolve, createCatalan, createCompareNatural, createComposition, createDiff, createDistance, createDot, createFibonacciHeapClass, createIndex, createInvmod, createLcm, createLog1p, createLsolveAll, createMatrixFromRows, createMultiply, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createUnaryPlus, createUsolveAll, createZpk2tf, createAnd, createCeil, createColumn, createCross, createDet, createFix, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createSqrtm, createSum, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSetSize, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulombConstant, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createIntersect, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetIntersect, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createCumSum, createEigs, createFermiCoupling, createGasConstant, createKldivergence, createLusolve, createMean, createMolarVolume, createPlanckConstant, createQuantileSeq, createSetUnion, createVariance, createClassicalElectronRadius, createMedian, createCorr, createFreqz, createMad, createStd, createZeta, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
+createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBigint, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCos, createCot, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createFlatten, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLgamma, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createSubtractScalar, createTan, createToBest, createTypeOf, createAcosh, createAcsch, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createMapSlices, createMatrix, createMatrixFromFunction, createOnes, createRandomInt, createReshape, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createTranspose, createXgcd, createZeros, createAcoth, createAsin, createBin, createConcat, createCoth, createCtranspose, createDiag, createDotMultiply, createEqual, createFraction, createIdentity, createIsNumeric, createKron, createLargerEq, createLeftShift, createMode, createNthRoot, createNumeric, createProd, createResize, createRightArithShift, createRound, createSize, createSmaller, createTo, createUnaryMinus, createUnequal, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCbrt, createCompare, createCompareText, createCount, createDeepEqual, createDivideScalar, createDotDivide, createEqualText, createFloor, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolve, createMatrixFromColumns, createMax, createMin, createMod, createNthRoots, createNullish, createOr, createPartitionSelect, createQr, createRightLogShift, createSmallerEq, createSubset, createSubtract, createTrace, createUsolve, createCatalan, createCompareNatural, createComposition, createDiff, createDistance, createDot, createFibonacciHeapClass, createIndex, createInvmod, createLcm, createLog1p, createLsolveAll, createMatrixFromRows, createMultiply, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createUnaryPlus, createUsolveAll, createZpk2tf, createAnd, createCeil, createColumn, createCross, createDet, createFix, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createSqrtm, createSum, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSetSize, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulombConstant, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createIntersect, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetIntersect, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createCumSum, createEigs, createFermiCoupling, createGasConstant, createKldivergence, createLusolve, createMean, createMolarVolume, createPlanckConstant, createQuantileSeq, createSetUnion, createVariance, createClassicalElectronRadius, createMedian, createCorr, createFreqz, createMad, createStd, createZeta, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
 export var BigNumber = /* #__PURE__ */createBigNumberClass({
   config
 });
@@ -771,6 +771,13 @@ export var nthRoots = /* #__PURE__ */createNthRoots({
   divideScalar,
   typed
 });
+export var nullish = /* #__PURE__ */createNullish({
+  deepEqual,
+  flatten,
+  matrix,
+  size,
+  typed
+});
 export var or = /* #__PURE__ */createOr({
   DenseMatrix,
   concat,

package/lib/esm/expression/Parser.js

@@ -1,4 +1,5 @@
 import { factory } from '../utils/factory.js';
+import { isFunction } from '../utils/is.js';
 import { createEmptyMap, toObject } from '../utils/map.js';
 var name = 'Parser';
 var dependencies = ['evaluate', 'parse'];
@@ -154,7 +155,40 @@ export var createParserClass = /* #__PURE__ */factory(name, dependencies, _ref =
   Parser.prototype.clear = function () {
     this.scope.clear();
   };
+  Parser.prototype.toJSON = function () {
+    var json = {
+      mathjs: 'Parser',
+      variables: {},
+      functions: {}
+    };
+    for (var [_name2, value] of this.scope) {
+      if (isFunction(value)) {
+        if (!isExpressionFunction(value)) {
+          throw new Error("Cannot serialize external function ".concat(_name2));
+        }
+        json.functions[_name2] = "".concat(value.syntax, " = ").concat(value.expr);
+      } else {
+        json.variables[_name2] = value;
+      }
+    }
+    return json;
+  };
+  Parser.fromJSON = function (json) {
+    var parser = new Parser();
+    Object.entries(json.variables).forEach(_ref2 => {
+      var [name, value] = _ref2;
+      return parser.set(name, value);
+    });
+    Object.entries(json.functions).forEach(_ref3 => {
+      var [_name, fn] = _ref3;
+      return parser.evaluate(fn);
+    });
+    return parser;
+  };
   return Parser;
 }, {
   isClass: true
-});
+});
+function isExpressionFunction(value) {
+  return typeof value === 'function' && typeof value.syntax === 'string' && typeof value.expr === 'string';
+}

package/lib/esm/expression/embeddedDocs/embeddedDocs.js

@@ -112,6 +112,7 @@ import { distanceDocs } from './function/geometry/distance.js';
 import { intersectDocs } from './function/geometry/intersect.js';
 import { andDocs } from './function/logical/and.js';
 import { notDocs } from './function/logical/not.js';
+import { nullishDocs } from './function/logical/nullish.js';
 import { orDocs } from './function/logical/or.js';
 import { xorDocs } from './function/logical/xor.js';
 import { mapSlicesDocs } from './function/matrix/mapSlices.js';
@@ -581,6 +582,7 @@ export var embeddedDocs = {
   // functions - logical
   and: andDocs,
   not: notDocs,
+  nullish: nullishDocs,
   or: orDocs,
   xor: xorDocs,
   // functions - matrix

package/lib/esm/expression/embeddedDocs/function/logical/nullish.js

@@ -0,0 +1,8 @@
+export var nullishDocs = {
+  name: 'nullish',
+  category: 'Logical',
+  syntax: ['x ?? y', 'nullish(x, y)'],
+  description: 'Nullish coalescing operator. Returns the right-hand operand when the left-hand operand is null or undefined, and otherwise returns the left-hand operand.',
+  examples: ['null ?? 42', 'undefined ?? 42', '0 ?? 42', 'false ?? 42', 'null ?? undefined ?? 42'],
+  seealso: ['and', 'or', 'not']
+};

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

@@ -98,7 +98,8 @@ export var createFunctionAssignmentNode = /* #__PURE__ */factory(name, dependenc
       });
 
       // compile the function expression with the child args
-      var evalExpr = this.expr._compile(math, childArgNames);
+      var expr = this.expr;
+      var evalExpr = expr._compile(math, childArgNames);
       var name = this.name;
       var params = this.params;
       var signature = join(this.types, ',');
@@ -114,6 +115,7 @@ export var createFunctionAssignmentNode = /* #__PURE__ */factory(name, dependenc
         };
         var fn = typed(name, signatures);
         fn.syntax = syntax;
+        fn.expr = expr.toString();
         scope.set(name, fn);
         return fn;
       };

package/lib/esm/expression/operators.js

@@ -221,6 +221,13 @@ export var properties = [{
     associativity: 'right',
     associativeWith: []
   }
+}, {
+  // nullish coalescing
+  'OperatorNode:nullish': {
+    op: '??',
+    associativity: 'left',
+    associativeWith: []
+  }
 }, {
   // factorial
   'OperatorNode:factorial': {

package/lib/esm/expression/parse.js

@@ -47,7 +47,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     node1.compile().evaluate() // 5
    *
    *     let scope = {a:3, b:4}
-   *     const node2 = math.parse('a * b') // 12
+   *     const node2 = math.parse('a * b')
    *     node2.evaluate(scope) // 12
    *     const code2 = node2.compile()
    *     code2.evaluate(scope) // 12
@@ -129,6 +129,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     '=': true,
     ':': true,
     '?': true,
+    '??': true,
     '==': true,
     '!=': true,
     '<': true,
@@ -1108,7 +1109,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parsePow(state) {
     var node, name, fn, params;
-    node = parseLeftHandOperators(state);
+    node = parseNullishCoalescing(state);
     if (state.token === '^' || state.token === '.^') {
       name = state.token;
       fn = name === '^' ? 'pow' : 'dotPow';
@@ -1119,6 +1120,21 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     return node;
   }
 
+  /**
+   * nullish coalescing operator
+   * @return {Node} node
+   * @private
+   */
+  function parseNullishCoalescing(state) {
+    var node = parseLeftHandOperators(state);
+    while (state.token === '??') {
+      // eslint-disable-line no-unmodified-loop-condition
+      getTokenSkipNewline(state);
+      node = new OperatorNode('??', 'nullish', [node, parseLeftHandOperators(state)]);
+    }
+    return node;
+  }
+
   /**
    * Left hand operators: factorial x!, ctranspose x'
    * @return {Node} node

package/lib/esm/expression/transform/nullish.transform.js

@@ -0,0 +1,37 @@
+import { createNullish } from '../../function/logical/nullish.js';
+import { factory } from '../../utils/factory.js';
+import { isCollection } from '../../utils/is.js';
+var name = 'nullish';
+var dependencies = ['typed', 'matrix', 'size', 'flatten', 'deepEqual'];
+export var createNullishTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    size,
+    flatten,
+    deepEqual
+  } = _ref;
+  var nullish = createNullish({
+    typed,
+    matrix,
+    size,
+    flatten,
+    deepEqual
+  });
+  function nullishTransform(args, math, scope) {
+    var left = args[0].compile().evaluate(scope);
+
+    // If left is not a collection and not nullish, short-circuit and return it
+    if (!isCollection(left) && left != null && left !== undefined) {
+      return left;
+    }
+
+    // Otherwise evaluate right and apply full nullish semantics (incl. element-wise)
+    var right = args[1].compile().evaluate(scope);
+    return nullish(left, right);
+  }
+  nullishTransform.rawArgs = true;
+  return nullishTransform;
+}, {
+  isTransformFunction: true
+});

package/lib/esm/factoriesAny.js

@@ -66,6 +66,7 @@ export { createConj } from './function/complex/conj.js';
 export { createIm } from './function/complex/im.js';
 export { createRe } from './function/complex/re.js';
 export { createNot } from './function/logical/not.js';
+export { createNullish } from './function/logical/nullish.js';
 export { createOr } from './function/logical/or.js';
 export { createXor } from './function/logical/xor.js';
 export { createConcat } from './function/matrix/concat.js';
@@ -294,5 +295,6 @@ export { createVarianceTransform } from './expression/transform/variance.transfo
 export { createPrintTransform } from './expression/transform/print.transform.js';
 export { createAndTransform } from './expression/transform/and.transform.js';
 export { createOrTransform } from './expression/transform/or.transform.js';
+export { createNullishTransform } from './expression/transform/nullish.transform.js';
 export { createBitAndTransform } from './expression/transform/bitAnd.transform.js';
 export { createBitOrTransform } from './expression/transform/bitOr.transform.js';

package/lib/esm/function/logical/nullish.js

@@ -0,0 +1,81 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
+import { createMatAlgo13xDD } from '../../type/matrix/utils/matAlgo13xDD.js';
+import { DimensionError } from '../../error/DimensionError.js';
+var name = 'nullish';
+var dependencies = ['typed', 'matrix', 'size', 'flatten', 'deepEqual'];
+export var createNullish = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    size,
+    flatten,
+    deepEqual
+  } = _ref;
+  var matAlgo03xDSf = createMatAlgo03xDSf({
+    typed
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  var matAlgo13xDD = createMatAlgo13xDD({
+    typed
+  });
+
+  /**
+   * Nullish coalescing operator (??). Returns the right-hand side operand
+   * when the left-hand side operand is null or undefined, and otherwise
+   * returns the left-hand side operand.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.nullish(x, y)
+   *
+   * Examples:
+   *
+   *    math.nullish(null, 42)        // returns 42
+   *    math.nullish(undefined, 42)   // returns 42
+   *    math.nullish(0, 42)           // returns 0
+   *    math.nullish(false, 42)       // returns false
+   *    math.nullish('', 42)          // returns ''
+   *
+   *    // Object property access with fallback
+   *    const obj = {foo: 7, bar: 3}
+   *    math.nullish(obj.baz, 0)      // returns 0
+   *
+   * See also:
+   *
+   *    and, or, not
+   *
+   * @param  {*} x First value to check
+   * @param  {*} y Fallback value
+   * @return {*} Returns y when x is null or undefined, otherwise returns x
+   */
+
+  return typed(name, {
+    // Scalar and SparseMatrix-first short-circuit handlers
+    'number|bigint|Complex|BigNumber|Fraction|Unit|string|boolean|SparseMatrix, any': (x, _y) => x,
+    'null, any': (_x, y) => y,
+    'undefined, any': (_x, y) => y,
+    // SparseMatrix-first with collection RHS: enforce exact shape match
+    'SparseMatrix, Array | Matrix': (x, y) => {
+      var sx = flatten(size(x).valueOf()); // work around #3529/#3530
+      var sy = flatten(size(y).valueOf());
+      if (deepEqual(sx, sy)) return x;
+      throw new DimensionError(sx, sy);
+    },
+    // DenseMatrix-first handlers (no broadcasting between collections)
+    'DenseMatrix, DenseMatrix': typed.referToSelf(self => (x, y) => matAlgo13xDD(x, y, self)),
+    'DenseMatrix, SparseMatrix': typed.referToSelf(self => (x, y) => matAlgo03xDSf(x, y, self, false)),
+    'DenseMatrix, Array': typed.referToSelf(self => (x, y) => matAlgo13xDD(x, matrix(y), self)),
+    'DenseMatrix, any': typed.referToSelf(self => (x, y) => matAlgo14xDs(x, y, self, false)),
+    // Array-first handlers (bridge via matrix() where needed)
+    'Array, Array': typed.referToSelf(self => (x, y) => matAlgo13xDD(matrix(x), matrix(y), self).valueOf()),
+    'Array, DenseMatrix': typed.referToSelf(self => (x, y) => matAlgo13xDD(matrix(x), y, self)),
+    'Array, SparseMatrix': typed.referToSelf(self => (x, y) => matAlgo03xDSf(matrix(x), y, self, false)),
+    'Array, any': typed.referToSelf(self => (x, y) => matAlgo14xDs(matrix(x), y, self, false).valueOf())
+  });
+});

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

@@ -16,7 +16,7 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     isPositive
   } = _ref;
   /**
-   * Create an array from a range.
+   * Create a matrix or array containing a range of values.
    * By default, the range end is excluded. This can be customized by providing
    * an extra parameter `includeEnd`.
    *
@@ -44,10 +44,12 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    * - `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
+   * The function returns a `DenseMatrix` when the library is configured with
+   * `config = { matrix: 'Matrix' }, and returns an Array otherwise.
+   * Note that the type of the returned values is taken from the type of the
+   * provided start/end value. If only one of 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:

package/lib/esm/type/matrix/DenseMatrix.js

@@ -672,24 +672,28 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       }
       return;
     }
-    var index = [];
-    var _recurse = function* recurse(value, depth) {
-      if (depth < maxDepth) {
-        for (var _i9 = 0; _i9 < value.length; _i9++) {
-          index[depth] = _i9;
-          yield* _recurse(value[_i9], depth + 1);
-        }
-      } else {
-        for (var _i0 = 0; _i0 < value.length; _i0++) {
-          index[depth] = _i0;
-          yield {
-            value: value[_i0],
-            index: index.slice()
-          };
-        }
+
+    // Multi-dimensional matrix: iterate over all elements
+    var index = Array(maxDepth + 1).fill(0);
+    var totalElements = this._size.reduce((a, b) => a * b, 1);
+    for (var count = 0; count < totalElements; count++) {
+      // Traverse to the current element using indices
+      var current = this._data;
+      for (var d = 0; d < maxDepth; d++) {
+        current = current[index[d]];
       }
-    };
-    yield* _recurse(this._data, 0);
+      yield {
+        value: current[index[maxDepth]],
+        index: index.slice()
+      };
+
+      // Increment indices for next element
+      for (var _d = maxDepth; _d >= 0; _d--) {
+        index[_d]++;
+        if (index[_d] < this._size[_d]) break;
+        index[_d] = 0;
+      }
+    }
   };
 
   /**

package/lib/esm/type/string.js

@@ -17,13 +17,13 @@ export var createString = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *    math.string(4.2)               // returns string '4.2'
-   *    math.string(math.complex(3, 2) // returns string '3 + 2i'
+   *    math.string(4.2)                // returns string '4.2'
+   *    math.string(math.complex(3, 2)) // returns string '3 + 2i'
    *
    *    const u = math.unit(5, 'km')
-   *    math.string(u.to('m'))         // returns string '5000 m'
+   *    math.string(u.to('m'))          // returns string '5000 m'
    *
-   *    math.string([true, false])     // returns ['true', 'false']
+   *    math.string([true, false])      // returns ['true', 'false']
    *
    * See also:
    *

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.6.0';
+export var version = '14.8.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": "14.6.0",
+  "version": "14.8.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",
@@ -36,31 +36,30 @@
     "typed-function": "^4.2.1"
   },
   "devDependencies": {
-    "@babel/core": "7.28.0",
+    "@babel/core": "7.28.4",
     "@babel/plugin-transform-object-assign": "7.27.1",
     "@babel/plugin-transform-optional-catch-binding": "7.27.1",
-    "@babel/plugin-transform-runtime": "7.28.0",
-    "@babel/preset-env": "7.28.0",
-    "@babel/register": "7.27.1",
+    "@babel/plugin-transform-runtime": "7.28.3",
+    "@babel/preset-env": "7.28.3",
+    "@babel/register": "7.28.3",
     "@types/assert": "1.5.11",
     "@types/mocha": "10.0.10",
-    "@typescript-eslint/eslint-plugin": "8.38.0",
-    "@typescript-eslint/parser": "8.38.0",
+    "@typescript-eslint/eslint-plugin": "8.44.1",
+    "@typescript-eslint/parser": "8.44.1",
     "assert": "2.1.0",
     "babel-loader": "10.0.0",
     "c8": "10.1.3",
     "codecov": "3.8.3",
-    "core-js": "3.44.0",
-    "del": "8.0.0",
-    "dtslint": "4.2.1",
+    "del": "8.0.1",
     "eigen": "0.2.2",
+    "es-check": "9.3.1",
     "eslint": "8.57.1",
     "eslint-config-prettier": "9.1.0",
     "eslint-config-standard": "17.1.0",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-mocha": "10.5.0",
     "eslint-plugin-n": "16.6.2",
-    "eslint-plugin-prettier": "5.5.3",
+    "eslint-plugin-prettier": "5.5.4",
     "eslint-plugin-promise": "6.6.0",
     "expect-type": "1.2.2",
     "expr-eval": "2.0.2",
@@ -78,7 +77,7 @@
     "karma-webdriver-launcher": "1.0.8",
     "karma-webpack": "5.0.1",
     "mkdirp": "3.0.1",
-    "mocha": "11.7.1",
+    "mocha": "11.7.2",
     "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -90,10 +89,10 @@
     "process": "0.11.10",
     "sinon": "21.0.0",
     "sylvester": "0.0.21",
-    "tinybench": "4.0.1",
+    "tinybench": "5.0.1",
     "ts-node": "10.9.2",
-    "typescript": "5.8.3",
-    "webpack": "5.100.2",
+    "typescript": "5.9.2",
+    "webpack": "5.101.3",
     "zeros": "1.0.0"
   },
   "type": "module",
@@ -149,7 +148,7 @@
     "test": "npm run test:src && npm run lint",
     "test:src": "mocha test/unit-tests",
     "test:generated": "mocha test/generated-code-tests",
-    "test:node": "mocha test/node-tests/*.test.js test/node-tests/**/*.test.js",
+    "test:node": "mocha test/node-tests/*.test.{js,cjs,mjs} test/node-tests/**/*.test.{js,cjs,mjs}",
     "test:all": "npm run test:src && npm run test:generated && npm run test:node && npm run test:types",
     "test:browser": "karma start test/browser-test-config/local-karma.js",
     "test:lambdatest": "karma start test/browser-test-config/lambdatest-karma.js",

package/types/index.d.ts

@@ -1904,6 +1904,14 @@ export interface MathJsInstance extends MathJsFactory {
    */
   det(x: MathCollection): number
 
+  /**
+   * Calculate the difference between adjacent elements of a matrix or array.
+   * @param x A matrix or array
+   * @param dim The dimension to apply the difference on.
+   * @returns A matrix or array containing the differences
+   */
+  diff<T extends MathCollection>(x: T, dim?: number | BigNumber): T
+
   /**
    * Create a diagonal matrix or retrieve the diagonal of a matrix. When x
    * is a vector, a matrix with vector x on the diagonal will be returned.
@@ -4079,7 +4087,8 @@ export const {
   concatTransformDependencies,
   stdTransformDependencies,
   sumTransformDependencies,
-  varianceTransformDependencies
+  varianceTransformDependencies,
+  printTransformDependencies
 }: Record<string, FactoryFunctionMap>
 
 export interface Matrix<T = MathGeneric> {
@@ -5805,6 +5814,15 @@ export interface MathJsChain<TValue> {
     y: MathCollection
   ): MathJsChain<MathCollection>
 
+  /**
+   * Calculate the difference between adjacent elements of the chained matrix or array.
+   * @param dim The dimension to apply the difference on.
+   */
+  diff<T extends MathCollection>(
+    this: MathJsChain<T>,
+    dim?: number | BigNumber
+  ): MathJsChain<T>
+
   /**
    * Calculate the determinant of a matrix.
    */

package/types/tslint.json

@@ -1,6 +0,0 @@
-{
-  "extends": "dtslint/dtslint.json",
-  "rules": {
-    "no-redundant-jsdoc": false
-  }
-}