npm - @danielsimonjr/mathts-functions - Versions diffs - 0.10.1 → 0.11.1 - Mend

@danielsimonjr/mathts-functions 0.10.1 → 0.11.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/factories/index.d.ts +1 -1
package/dist/factories/index.d.ts.map +1 -1
package/dist/index.js +600 -696
package/dist/linalg-extra.d.ts.map +1 -1
package/dist/typed/arithmetic.d.ts.map +1 -1
package/package.json +1 -1
package/dist/matrix/expm.d.ts +0 -27
package/dist/matrix/expm.d.ts.map +0 -1

package/dist/index.js CHANGED Viewed

@@ -1581,7 +1581,37 @@ var pow = mathTyped("pow", {
   "BigNumber, BigNumber": (a, b) => a.pow(b.valueOf()),
   // Dual numbers (forward-mode AD): constant or variable exponent.
   "Dual, number": (a, b) => a.powConst(b),
-  "Dual, Dual": (a, b) => a.pow(b)
+  "Dual, Dual": (a, b) => a.pow(b),
+  // Matrix power A^n for a square 2-D array and non-negative integer n, via binary
+  // exponentiation on the native DenseMatrix backend (accelerated matmul, B2). Element-
+  // wise power is `dotPow`; negative/fractional matrix powers need eigendecomposition —
+  // use the async `matrixPower(A, p)`.
+  "Array, number": (a, b) => {
+    if (!Array.isArray(a[0])) {
+      throw new TypeError(
+        "pow(Array, number): expected a square 2-D matrix; use dotPow for element-wise power"
+      );
+    }
+    const m = a;
+    const n = m.length;
+    if (m.some((row2) => row2.length !== n)) {
+      throw new RangeError(`pow: matrix must be square (got ${n}\xD7${m[0]?.length ?? 0})`);
+    }
+    if (!Number.isInteger(b) || b < 0) {
+      throw new Error(
+        "pow: only non-negative integer exponents are supported for matrices here; use matrixPower(A, p) for negative or fractional powers"
+      );
+    }
+    let result = DenseMatrix2.identity(n);
+    let base = DenseMatrix2.fromArray(m);
+    let e = b;
+    while (e > 0) {
+      if (e % 2 === 1) result = backendManager2.multiply(result, base);
+      e = Math.floor(e / 2);
+      if (e > 0) base = backendManager2.multiply(base, base);
+    }
+    return result.toArray();
+  }
 });
 var sqrt = mathTyped("sqrt", {
   number: (a) => {
@@ -3084,8 +3114,8 @@ import { computePool as computePool4 } from "@danielsimonjr/mathts-parallel";
 // src/wasm/signal/wasm-bridge.ts
 var WASM_SIGNAL_THRESHOLD = 4096;
-function windowTypeCode(name255) {
-  switch (name255) {
+function windowTypeCode(name254) {
+  switch (name254) {
     case "hann":
     case "hanning":
       return 0;
@@ -6432,7 +6462,7 @@ function ellipticEIncompleteScalar(phi, m) {
 function ellipticPiIncompleteScalar(n, phi, m) {
   return _ellipticPiIncomplete(n, phi, m);
 }
-function multiArrayDispatch(name255, inputs, js) {
+function multiArrayDispatch(name254, inputs, js) {
   const n = inputs[0].length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
     const wasm = getWasm();
@@ -6441,7 +6471,7 @@ function multiArrayDispatch(name255, inputs, js) {
         const out = withAsF64(
           wasm,
           inputs,
-          (mod2, headers) => asReadReturnedF64(mod2, mod2[name255](...headers))
+          (mod2, headers) => asReadReturnedF64(mod2, mod2[name254](...headers))
         );
         if (out) return out;
       } catch {
@@ -13945,11 +13975,11 @@ function trace(A) {
   for (let i = 0; i < A.length; i++) t += A[i][i];
   return t;
 }
-function assertSquare(A, name255) {
+function assertSquare(A, name254) {
   const m = A.length;
-  if (m === 0) throw new Error(`${name255}: empty matrix`);
+  if (m === 0) throw new Error(`${name254}: empty matrix`);
   const n = A[0].length;
-  if (m !== n) throw new Error(`${name255}: matrix must be square (got ${m}x${n})`);
+  if (m !== n) throw new Error(`${name254}: matrix must be square (got ${m}x${n})`);
   return n;
 }
 async function characteristicPolynomial(A) {
@@ -16002,28 +16032,28 @@ var MathjsError = class _MathjsError extends Error {
 };
 // src/utils/factory.ts
-function factory(name255, dependencies255, create, meta) {
+function factory(name254, dependencies254, create, meta) {
   function assertAndCreate(scope) {
-    const deps = pickShallow(scope, dependencies255.map(stripOptionalNotation));
-    assertDependencies(name255, dependencies255, scope);
+    const deps = pickShallow(scope, dependencies254.map(stripOptionalNotation));
+    assertDependencies(name254, dependencies254, scope);
     return create(deps);
   }
   assertAndCreate.isFactory = true;
-  assertAndCreate.fn = name255;
-  assertAndCreate.dependencies = dependencies255.slice().sort();
+  assertAndCreate.fn = name254;
+  assertAndCreate.dependencies = dependencies254.slice().sort();
   if (meta) {
     assertAndCreate.meta = meta;
   }
   return assertAndCreate;
 }
-function assertDependencies(name255, dependencies255, scope) {
-  const allDefined = dependencies255.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
+function assertDependencies(name254, dependencies254, scope) {
+  const allDefined = dependencies254.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
   if (!allDefined) {
-    const missingDependencies = dependencies255.filter(
+    const missingDependencies = dependencies254.filter(
       (dependency) => scope[dependency] === void 0
     );
     throw new MathjsError(
-      `Cannot create function "${name255}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
+      `Cannot create function "${name254}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
     );
   }
 }
@@ -17551,7 +17581,7 @@ var createNot = /* @__PURE__ */ factory(
 // src/utils/optimizeCallback.ts
 import typed2 from "typed-function";
-function optimizeCallback(callback, array, name255, isUnary) {
+function optimizeCallback(callback, array, name254, isUnary) {
   const typedAny = typed2;
   if (typedAny.isTypedFunction(callback)) {
     let numberOfArguments;
@@ -17589,14 +17619,14 @@ function optimizeCallback(callback, array, name255, isUnary) {
         fn: (...args) => _tryFunctionWithArgs(
           fastCallback,
           args.slice(0, numberOfArguments),
-          name255,
+          name254,
           callback.name
         )
       };
     }
     return {
       isUnary: false,
-      fn: (...args) => _tryFunctionWithArgs(fastCallback, args, name255, callback.name)
+      fn: (...args) => _tryFunctionWithArgs(fastCallback, args, name254, callback.name)
     };
   }
   if (isUnary === void 0) {
@@ -20184,8 +20214,8 @@ var createIdentity = /* @__PURE__ */ factory(
 );
 // src/matrix/utils/zerosAndOnes.ts
-function createZerosAndOnes(name255, defaultValue, { typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) {
-  return typed3(name255, {
+function createZerosAndOnes(name254, defaultValue, { typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) {
+  return typed3(name254, {
     "": function() {
       return config.matrix === "Array" ? _zerosAndOnes([]) : _zerosAndOnes([], "default");
     },
@@ -20243,7 +20273,7 @@ function createZerosAndOnes(name255, defaultValue, { typed: typed3, config, matr
   function _validate(size2) {
     size2.forEach(function(value) {
       if (typeof value !== "number" || !isInteger(value) || value < 0) {
-        throw new Error(`Parameters in function ${name255} must be positive integers`);
+        throw new Error(`Parameters in function ${name254} must be positive integers`);
       }
     });
   }
@@ -26662,144 +26692,9 @@ var createXor = /* @__PURE__ */ factory(
   }
 );
-// src/matrix/expm.ts
-var WASM_EXPM_THRESHOLD = 16;
-var name155 = "expm";
-var dependencies155 = ["typed", "abs", "add", "identity", "inv", "multiply"];
-var createExpm = /* @__PURE__ */ factory(
-  name155,
-  dependencies155,
-  ({ typed: typed3, abs: abs2, add: add2, identity: identity2, inv: inv2, multiply: multiply2 }) => {
-    return typed3(name155, {
-      Matrix: function(A) {
-        const size2 = A.size();
-        if (size2.length !== 2 || size2[0] !== size2[1]) {
-          throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
-        }
-        const n = size2[0];
-        const wasmResult = _tryWasmExpm(A, n);
-        if (wasmResult !== null) {
-          return wasmResult;
-        }
-        const eps = 1e-15;
-        const infNorm = infinityNorm(A);
-        const params = findParams(infNorm, eps);
-        const q = params.q;
-        const j = params.j;
-        const Apos = multiply2(A, Math.pow(2, -j));
-        let N = identity2(n);
-        let D = identity2(n);
-        let factor2 = 1;
-        let AposToI = Apos;
-        let alternate = -1;
-        for (let i = 1; i <= q; i++) {
-          if (i > 1) {
-            AposToI = multiply2(AposToI, Apos);
-            alternate = -alternate;
-          }
-          factor2 = factor2 * (q - i + 1) / ((2 * q - i + 1) * i);
-          N = add2(N, multiply2(factor2, AposToI));
-          D = add2(D, multiply2(factor2 * alternate, AposToI));
-        }
-        let R = multiply2(inv2(D), N);
-        for (let i = 0; i < j; i++) {
-          R = multiply2(R, R);
-        }
-        return isSparseMatrix(A) ? A.createSparseMatrix(R) : R;
-      }
-    });
-    function _tryWasmExpm(A, n) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm || n * n < WASM_EXPM_THRESHOLD) return null;
-      const data = A._data;
-      if (!data || !Array.isArray(data)) return null;
-      try {
-        const flat = new Float64Array(n * n);
-        for (let i = 0; i < n; i++) {
-          const row2 = data[i];
-          if (!Array.isArray(row2)) return null;
-          for (let j = 0; j < n; j++) {
-            if (typeof row2[j] !== "number") return null;
-            flat[i * n + j] = row2[j];
-          }
-        }
-        const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
-        const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(n * n);
-        const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(6 * n * n);
-        try {
-          const status = wasm.expm(matrixAlloc.ptr, n, resultAlloc.ptr, workAlloc.ptr);
-          if (status === 0) {
-            const result = [];
-            for (let i = 0; i < n; i++) {
-              const row2 = [];
-              for (let j = 0; j < n; j++) {
-                row2[j] = resultAlloc.array[i * n + j];
-              }
-              result[i] = row2;
-            }
-            const matA = A;
-            if (isSparseMatrix(A)) {
-              return matA.createSparseMatrix({ data: result, size: [n, n] });
-            }
-            return matA.createDenseMatrix({
-              data: result,
-              size: [n, n],
-              datatype: matA._datatype
-            });
-          }
-        } finally {
-          wasmLoader.free(matrixAlloc.ptr);
-          wasmLoader.free(resultAlloc.ptr);
-          wasmLoader.free(workAlloc.ptr);
-        }
-      } catch {
-      }
-      return null;
-    }
-    function infinityNorm(A) {
-      const n = A.size()[0];
-      let infNorm = 0;
-      for (let i = 0; i < n; i++) {
-        let rowSum = 0;
-        for (let j = 0; j < n; j++) {
-          rowSum += abs2(A.get([i, j]));
-        }
-        infNorm = Math.max(rowSum, infNorm);
-      }
-      return infNorm;
-    }
-    function findParams(infNorm, eps) {
-      const maxSearchSize = 30;
-      for (let k = 0; k < maxSearchSize; k++) {
-        for (let q = 0; q <= k; q++) {
-          const j = k - q;
-          if (errorEstimate(infNorm, q, j) < eps) {
-            return { q, j };
-          }
-        }
-      }
-      throw new Error(
-        "Could not find acceptable parameters to compute the matrix exponential (try increasing maxSearchSize in expm.js)"
-      );
-    }
-    function errorEstimate(infNorm, q, j) {
-      let qfac = 1;
-      for (let i = 2; i <= q; i++) {
-        qfac *= i;
-      }
-      let twoqfac = qfac;
-      for (let i = q + 1; i <= 2 * q; i++) {
-        twoqfac *= i;
-      }
-      const twoqp1fac = twoqfac * (2 * q + 1);
-      return 8 * Math.pow(infNorm / Math.pow(2, j), 2 * q) * qfac * qfac / (twoqfac * twoqp1fac);
-    }
-  }
-);
 // src/relational/compare.ts
-var name156 = "compare";
-var dependencies156 = [
+var name155 = "compare";
+var dependencies155 = [
   "typed",
   "config",
   "matrix",
@@ -26810,8 +26705,8 @@ var dependencies156 = [
   "concat"
 ];
 var createCompare = /* @__PURE__ */ factory(
-  name156,
-  dependencies156,
+  name155,
+  dependencies155,
   ({
     typed: typed3,
     config,
@@ -26832,7 +26727,7 @@ var createCompare = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
-      name156,
+      name155,
       createCompareNumber({ typed: typed3, config }),
       {
         "boolean, boolean": function(x, y) {
@@ -26861,10 +26756,10 @@ var createCompare = /* @__PURE__ */ factory(
   }
 );
 var createCompareNumber = /* @__PURE__ */ factory(
-  name156,
+  name155,
   ["typed", "config"],
   ({ typed: typed3, config }) => {
-    return typed3(name156, {
+    return typed3(name155, {
       "number, number": function(x, y) {
         return nearlyEqual(x, y, config.relTol, config.absTol) ? 0 : x > y ? 1 : -1;
       }
@@ -26873,12 +26768,12 @@ var createCompareNumber = /* @__PURE__ */ factory(
 );
 // src/relational/compareText.ts
-var name157 = "compareText";
-var dependencies157 = ["typed", "matrix", "concat"];
+var name156 = "compareText";
+var dependencies156 = ["typed", "matrix", "concat"];
 compareText2.signature = "any, any";
 var createCompareText = /* @__PURE__ */ factory(
-  name157,
-  dependencies157,
+  name156,
+  dependencies156,
   ({ typed: typed3, matrix: matrix2, concat: concat3 }) => {
     const matrixAlgorithmSuite = createMatrixAlgorithmSuite({
       typed: typed3,
@@ -26886,7 +26781,7 @@ var createCompareText = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name157,
+      name156,
       compareText2,
       matrixAlgorithmSuite({
         elop: compareText2,
@@ -26897,13 +26792,13 @@ var createCompareText = /* @__PURE__ */ factory(
 );
 // src/relational/deepEqual.ts
-var name158 = "deepEqual";
-var dependencies158 = ["typed", "equal"];
+var name157 = "deepEqual";
+var dependencies157 = ["typed", "equal"];
 var createDeepEqual = /* @__PURE__ */ factory(
-  name158,
-  dependencies158,
+  name157,
+  dependencies157,
   ({ typed: typed3, equal: equal2 }) => {
-    return typed3(name158, {
+    return typed3(name157, {
       "any, any": function(x, y) {
         return _deepEqual2(x.valueOf(), y.valueOf());
       }
@@ -26936,8 +26831,8 @@ var createDeepEqual = /* @__PURE__ */ factory(
 );
 // src/relational/larger.ts
-var name159 = "larger";
-var dependencies159 = [
+var name158 = "larger";
+var dependencies158 = [
   "typed",
   "config",
   "bignumber",
@@ -26947,8 +26842,8 @@ var dependencies159 = [
   "SparseMatrix"
 ];
 var createLarger = /* @__PURE__ */ factory(
-  name159,
-  dependencies159,
+  name158,
+  dependencies158,
   ({ typed: typed3, config, bignumber: bignumber2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
@@ -26963,7 +26858,7 @@ var createLarger = /* @__PURE__ */ factory(
       return x.gt(y) && !nearlyEqual2(x, y, config.relTol, config.absTol);
     }
     return typed3(
-      name159,
+      name158,
       createLargerNumber({ typed: typed3, config }),
       {
         "boolean, boolean": (x, y) => x > y,
@@ -26990,10 +26885,10 @@ var createLarger = /* @__PURE__ */ factory(
   }
 );
 var createLargerNumber = /* @__PURE__ */ factory(
-  name159,
+  name158,
   ["typed", "config"],
   ({ typed: typed3, config }) => {
-    return typed3(name159, {
+    return typed3(name158, {
       "number, number": function(x, y) {
         return x > y && !nearlyEqual(x, y, config.relTol, config.absTol);
       }
@@ -27002,11 +26897,11 @@ var createLargerNumber = /* @__PURE__ */ factory(
 );
 // src/relational/largerEq.ts
-var name160 = "largerEq";
-var dependencies160 = ["typed", "config", "matrix", "DenseMatrix", "concat", "SparseMatrix"];
+var name159 = "largerEq";
+var dependencies159 = ["typed", "config", "matrix", "DenseMatrix", "concat", "SparseMatrix"];
 var createLargerEq = /* @__PURE__ */ factory(
-  name160,
-  dependencies160,
+  name159,
+  dependencies159,
   ({ typed: typed3, config, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
@@ -27018,7 +26913,7 @@ var createLargerEq = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
-      name160,
+      name159,
       createLargerEqNumber({ typed: typed3, config }),
       {
         "boolean, boolean": (x, y) => x >= y,
@@ -27043,10 +26938,10 @@ var createLargerEq = /* @__PURE__ */ factory(
   }
 );
 var createLargerEqNumber = /* @__PURE__ */ factory(
-  name160,
+  name159,
   ["typed", "config"],
   ({ typed: typed3, config }) => {
-    return typed3(name160, {
+    return typed3(name159, {
       "number, number": function(x, y) {
         return x >= y || nearlyEqual(x, y, config.relTol, config.absTol);
       }
@@ -27055,8 +26950,8 @@ var createLargerEqNumber = /* @__PURE__ */ factory(
 );
 // src/relational/smaller.ts
-var name161 = "smaller";
-var dependencies161 = [
+var name160 = "smaller";
+var dependencies160 = [
   "typed",
   "config",
   "bignumber",
@@ -27066,8 +26961,8 @@ var dependencies161 = [
   "SparseMatrix"
 ];
 var createSmaller = /* @__PURE__ */ factory(
-  name161,
-  dependencies161,
+  name160,
+  dependencies160,
   ({
     typed: typed3,
     config,
@@ -27090,7 +26985,7 @@ var createSmaller = /* @__PURE__ */ factory(
       return x.lt(y) && !nearlyEqual2(x, y, config.relTol, config.absTol);
     }
     return typed3(
-      name161,
+      name160,
       createSmallerNumber({ typed: typed3, config }),
       {
         "boolean, boolean": (x, y) => x < y,
@@ -27117,10 +27012,10 @@ var createSmaller = /* @__PURE__ */ factory(
   }
 );
 var createSmallerNumber = /* @__PURE__ */ factory(
-  name161,
+  name160,
   ["typed", "config"],
   ({ typed: typed3, config }) => {
-    return typed3(name161, {
+    return typed3(name160, {
       "number, number": function(x, y) {
         return x < y && !nearlyEqual(x, y, config.relTol, config.absTol);
       }
@@ -27129,11 +27024,11 @@ var createSmallerNumber = /* @__PURE__ */ factory(
 );
 // src/relational/smallerEq.ts
-var name162 = "smallerEq";
-var dependencies162 = ["typed", "config", "matrix", "DenseMatrix", "concat", "SparseMatrix"];
+var name161 = "smallerEq";
+var dependencies161 = ["typed", "config", "matrix", "DenseMatrix", "concat", "SparseMatrix"];
 var createSmallerEq = /* @__PURE__ */ factory(
-  name162,
-  dependencies162,
+  name161,
+  dependencies161,
   ({ typed: typed3, config, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
@@ -27145,7 +27040,7 @@ var createSmallerEq = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
-      name162,
+      name161,
       createSmallerEqNumber({ typed: typed3, config }),
       {
         "boolean, boolean": (x, y) => x <= y,
@@ -27168,10 +27063,10 @@ var createSmallerEq = /* @__PURE__ */ factory(
   }
 );
 var createSmallerEqNumber = /* @__PURE__ */ factory(
-  name162,
+  name161,
   ["typed", "config"],
   ({ typed: typed3, config }) => {
-    return typed3(name162, {
+    return typed3(name161, {
       "number, number": function(x, y) {
         return x <= y || nearlyEqual(x, y, config.relTol, config.absTol);
       }
@@ -27180,8 +27075,8 @@ var createSmallerEqNumber = /* @__PURE__ */ factory(
 );
 // src/relational/unequal.ts
-var name163 = "unequal";
-var dependencies163 = [
+var name162 = "unequal";
+var dependencies162 = [
   "typed",
   "config",
   "equalScalar",
@@ -27191,8 +27086,8 @@ var dependencies163 = [
   "SparseMatrix"
 ];
 var createUnequal = /* @__PURE__ */ factory(
-  name163,
-  dependencies163,
+  name162,
+  dependencies162,
   ({
     typed: typed3,
     config: _config,
@@ -27211,7 +27106,7 @@ var createUnequal = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name163,
+      name162,
       createUnequalNumber({ typed: typed3, equalScalar: equalScalar3 }),
       matrixAlgorithmSuite({
         elop: _unequal,
@@ -27226,10 +27121,10 @@ var createUnequal = /* @__PURE__ */ factory(
   }
 );
 var createUnequalNumber = factory(
-  name163,
+  name162,
   ["typed", "equalScalar"],
   ({ typed: typed3, equalScalar: equalScalar3 }) => {
-    return typed3(name163, {
+    return typed3(name162, {
       "any, any": function(x, y) {
         if (x === null) {
           return y !== null;
@@ -27250,11 +27145,11 @@ var createUnequalNumber = factory(
 );
 // src/trigonometry/atan2.ts
-var name164 = "atan2";
-var dependencies164 = ["typed", "matrix", "equalScalar", "BigNumber", "DenseMatrix", "concat"];
+var name163 = "atan2";
+var dependencies163 = ["typed", "matrix", "equalScalar", "BigNumber", "DenseMatrix", "concat"];
 var createAtan2 = /* @__PURE__ */ factory(
-  name164,
-  dependencies164,
+  name163,
+  dependencies163,
   ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
@@ -27267,7 +27162,7 @@ var createAtan2 = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name164,
+      name163,
       {
         "number, number": Math.atan2,
         // Complex numbers doesn't seem to have a reasonable implementation of
@@ -27289,11 +27184,11 @@ var createAtan2 = /* @__PURE__ */ factory(
 );
 // src/unit/to.ts
-var name165 = "to";
-var dependencies165 = ["typed", "matrix", "concat"];
+var name164 = "to";
+var dependencies164 = ["typed", "matrix", "concat"];
 var createTo = /* @__PURE__ */ factory(
-  name165,
-  dependencies165,
+  name164,
+  dependencies164,
   ({ typed: typed3, matrix: matrix2, concat: concat3 }) => {
     const matrixAlgorithmSuite = createMatrixAlgorithmSuite({
       typed: typed3,
@@ -27301,7 +27196,7 @@ var createTo = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name165,
+      name164,
       {
         "Unit, Unit | string": (x, unit2) => x.to(unit2)
       },
@@ -27311,8 +27206,8 @@ var createTo = /* @__PURE__ */ factory(
 );
 // src/arithmetic/dotPow.ts
-var name166 = "dotPow";
-var dependencies166 = [
+var name165 = "dotPow";
+var dependencies165 = [
   "typed",
   "equalScalar",
   "matrix",
@@ -27322,8 +27217,8 @@ var dependencies166 = [
   "SparseMatrix"
 ];
 var createDotPow = /* @__PURE__ */ factory(
-  name166,
-  dependencies166,
+  name165,
+  dependencies165,
   ({
     typed: typed3,
     equalScalar: equalScalar3,
@@ -27352,7 +27247,7 @@ var createDotPow = /* @__PURE__ */ factory(
     }
     const powScalar = typed3(powScalarSignatures);
     return typed3(
-      name166,
+      name165,
       matrixAlgorithmSuite({
         elop: powScalar,
         SS: matAlgo07xSSf,
@@ -27365,8 +27260,8 @@ var createDotPow = /* @__PURE__ */ factory(
 );
 // src/arithmetic/fix.ts
-var name167 = "fix";
-var dependencies167 = [
+var name166 = "fix";
+var dependencies166 = [
   "typed",
   "Complex",
   "matrix",
@@ -27377,10 +27272,10 @@ var dependencies167 = [
   "DenseMatrix"
 ];
 var createFixNumber = /* @__PURE__ */ factory(
-  name167,
+  name166,
   ["typed", "ceil", "floor"],
   ({ typed: typed3, ceil: ceil2, floor: floor2 }) => {
-    return typed3(name167, {
+    return typed3(name166, {
       number: function(x) {
         return x > 0 ? floor2(x) : ceil2(x);
       },
@@ -27391,8 +27286,8 @@ var createFixNumber = /* @__PURE__ */ factory(
   }
 );
 var createFix = /* @__PURE__ */ factory(
-  name167,
-  dependencies167,
+  name166,
+  dependencies166,
   ({ typed: typed3, Complex: Complex12, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -27480,8 +27375,8 @@ var createFix = /* @__PURE__ */ factory(
 );
 // src/arithmetic/invmod.ts
-var name168 = "invmod";
-var dependencies168 = [
+var name167 = "invmod";
+var dependencies167 = [
   "typed",
   "config",
   "BigNumber",
@@ -27493,8 +27388,8 @@ var dependencies168 = [
   "isInteger"
 ];
 var createInvmod = /* @__PURE__ */ factory(
-  name168,
-  dependencies168,
+  name167,
+  dependencies167,
   ({
     typed: typed3,
     config: _config,
@@ -27506,7 +27401,7 @@ var createInvmod = /* @__PURE__ */ factory(
     add: add2,
     isInteger: isInteger3
   }) => {
-    return typed3(name168, {
+    return typed3(name167, {
       "number, number": invmod2,
       "BigNumber, BigNumber": invmod2
     });
@@ -27527,11 +27422,11 @@ var createInvmod = /* @__PURE__ */ factory(
 );
 // src/logical/and.ts
-var name169 = "and";
-var dependencies169 = ["typed", "matrix", "equalScalar", "zeros", "not", "concat"];
+var name168 = "and";
+var dependencies168 = ["typed", "matrix", "equalScalar", "zeros", "not", "concat"];
 var createAnd = /* @__PURE__ */ factory(
-  name169,
-  dependencies169,
+  name168,
+  dependencies168,
   ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, not: not3, concat: concat3 }) => {
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo06xS0S0 = createMatAlgo06xS0S0({ typed: typed3, equalScalar: equalScalar3 });
@@ -27543,7 +27438,7 @@ var createAnd = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name169,
+      name168,
       {
         "number, number": andNumber,
         "Complex, Complex": function(x, y) {
@@ -27608,8 +27503,8 @@ var createAnd = /* @__PURE__ */ factory(
 );
 // src/combinatorics/composition.ts
-var name170 = "composition";
-var dependencies170 = [
+var name169 = "composition";
+var dependencies169 = [
   "typed",
   "addScalar",
   "combinations",
@@ -27619,8 +27514,8 @@ var dependencies170 = [
   "larger"
 ];
 var createComposition = /* @__PURE__ */ factory(
-  name170,
-  dependencies170,
+  name169,
+  dependencies169,
   ({
     typed: typed3,
     addScalar: addScalar2,
@@ -27630,7 +27525,7 @@ var createComposition = /* @__PURE__ */ factory(
     isInteger: isInteger3,
     larger: larger2
   }) => {
-    return typed3(name170, {
+    return typed3(name169, {
       "number | BigNumber, number | BigNumber": function(n, k) {
         if (!isInteger3(n) || !isPositive2(n) || !isInteger3(k) || !isPositive2(k)) {
           throw new TypeError("Positive integer value expected in function composition");
@@ -27653,15 +27548,15 @@ function isFlatNumberArray4(arr7) {
   }
   return true;
 }
-var name171 = "partitionSelect";
-var dependencies171 = ["typed", "isNumeric", "isNaN", "compare"];
+var name170 = "partitionSelect";
+var dependencies170 = ["typed", "isNumeric", "isNaN", "compare"];
 var createPartitionSelect = /* @__PURE__ */ factory(
-  name171,
-  dependencies171,
+  name170,
+  dependencies170,
   ({ typed: typed3, isNumeric: isNumeric2, isNaN: mathIsNaN, compare: compare2 }) => {
     const asc = compare2;
     const desc = (a, b) => -compare2(a, b);
-    return typed3(name171, {
+    return typed3(name170, {
       "Array | Matrix, number": function(x, k) {
         return _partitionSelect(x, k, asc);
       },
@@ -27752,8 +27647,8 @@ var createPartitionSelect = /* @__PURE__ */ factory(
 );
 // src/matrix/pinv.ts
-var name172 = "pinv";
-var dependencies172 = [
+var name171 = "pinv";
+var dependencies171 = [
   "typed",
   "matrix",
   "inv",
@@ -27768,8 +27663,8 @@ var dependencies172 = [
   "Complex"
 ];
 var createPinv = /* @__PURE__ */ factory(
-  name172,
-  dependencies172,
+  name171,
+  dependencies171,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -27784,7 +27679,7 @@ var createPinv = /* @__PURE__ */ factory(
     add: add2,
     Complex: Complex12
   }) => {
-    return typed3(name172, {
+    return typed3(name171, {
       "Array | Matrix": function(x) {
         const size2 = isMatrix(x) ? x.size() : arraySize(x);
         switch (size2.length) {
@@ -27910,8 +27805,8 @@ function flattenToFloat646(matrix2, rows, cols) {
   }
   return result;
 }
-var name173 = "qr";
-var dependencies173 = [
+var name172 = "qr";
+var dependencies172 = [
   "typed",
   "matrix",
   "zeros",
@@ -27929,8 +27824,8 @@ var dependencies173 = [
   "complex"
 ];
 var createQr = /* @__PURE__ */ factory(
-  name173,
-  dependencies173,
+  name172,
+  dependencies172,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -27948,7 +27843,7 @@ var createQr = /* @__PURE__ */ factory(
     subtractScalar: subtractScalar2,
     complex: complex2
   }) => {
-    const qrTyped = typed3(name173, {
+    const qrTyped = typed3(name172, {
       DenseMatrix: function(m) {
         return _denseQR(m);
       },
@@ -28086,8 +27981,8 @@ var createQr = /* @__PURE__ */ factory(
 );
 // src/matrix/range.ts
-var name174 = "range";
-var dependencies174 = [
+var name173 = "range";
+var dependencies173 = [
   "typed",
   "config",
   "?matrix",
@@ -28102,8 +27997,8 @@ var dependencies174 = [
   "isPositive"
 ];
 var createRange = /* @__PURE__ */ factory(
-  name174,
-  dependencies174,
+  name173,
+  dependencies173,
   ({
     typed: typed3,
     config,
@@ -28117,7 +28012,7 @@ var createRange = /* @__PURE__ */ factory(
     isZero: isZero2,
     isPositive: isPositive2
   }) => {
-    return typed3(name174, {
+    return typed3(name173, {
       // TODO: simplify signatures when typed-function supports default values and optional arguments
       string: _strRange,
       "string, boolean": _strRange,
@@ -28262,11 +28157,11 @@ var createRange = /* @__PURE__ */ factory(
 );
 // src/probability/gamma.ts
-var name175 = "gamma";
-var dependencies175 = ["typed", "config", "multiplyScalar", "pow", "BigNumber", "Complex"];
+var name174 = "gamma";
+var dependencies174 = ["typed", "config", "multiplyScalar", "pow", "BigNumber", "Complex"];
 var createGamma = /* @__PURE__ */ factory(
-  name175,
-  dependencies175,
+  name174,
+  dependencies174,
   ({
     typed: typed3,
     config,
@@ -28297,7 +28192,7 @@ var createGamma = /* @__PURE__ */ factory(
       const expt = t.neg().exp();
       return x.mul(twoPiSqrt).mul(tpow).mul(expt);
     }
-    return typed3(name175, {
+    return typed3(name174, {
       number: gammaNumber,
       Complex: gammaComplex,
       BigNumber: function(n) {
@@ -28335,14 +28230,14 @@ var createGamma = /* @__PURE__ */ factory(
 // src/relational/compareNatural.ts
 import naturalSort2 from "javascript-natural-sort";
-var name176 = "compareNatural";
-var dependencies176 = ["typed", "compare"];
+var name175 = "compareNatural";
+var dependencies175 = ["typed", "compare"];
 var createCompareNatural = /* @__PURE__ */ factory(
-  name176,
-  dependencies176,
+  name175,
+  dependencies175,
   ({ typed: typed3, compare: compare2 }) => {
     const compareBooleans = compare2.signatures["boolean,boolean"];
-    return typed3(name176, { "any, any": _compareNatural2 });
+    return typed3(name175, { "any, any": _compareNatural2 });
     function _compareNatural2(x, y) {
       const typeX = typeOf(x);
       const typeY = typeOf(y);
@@ -28494,13 +28389,13 @@ function compareComplexNumbers(x, y) {
 }
 // src/relational/equalText.ts
-var name177 = "equalText";
-var dependencies177 = ["typed", "compareText", "isZero"];
+var name176 = "equalText";
+var dependencies176 = ["typed", "compareText", "isZero"];
 var createEqualText = /* @__PURE__ */ factory(
-  name177,
-  dependencies177,
+  name176,
+  dependencies176,
   ({ typed: typed3, compareText: compareText4, isZero: isZero2 }) => {
-    return typed3(name177, {
+    return typed3(name176, {
       "any, any": function(x, y) {
         return isZero2(compareText4(x, y));
       }
@@ -28518,13 +28413,13 @@ function isFlatNumberArray5(arr7) {
   }
   return true;
 }
-var name178 = "max";
-var dependencies178 = ["typed", "config", "numeric", "larger", "isNaN"];
+var name177 = "max";
+var dependencies177 = ["typed", "config", "numeric", "larger", "isNaN"];
 var createMax = /* @__PURE__ */ factory(
-  name178,
-  dependencies178,
+  name177,
+  dependencies177,
   ({ typed: typed3, config, numeric: numeric2, larger: larger2, isNaN: mathIsNaN }) => {
-    return typed3(name178, {
+    return typed3(name177, {
       // max([a, b, c, d, ...])
       "Array | Matrix": _max,
       // max([a, b, c, d, ...], dim)
@@ -28597,13 +28492,13 @@ function isFlatNumberArray6(arr7) {
   }
   return true;
 }
-var name179 = "min";
-var dependencies179 = ["typed", "config", "numeric", "smaller", "isNaN"];
+var name178 = "min";
+var dependencies178 = ["typed", "config", "numeric", "smaller", "isNaN"];
 var createMin = /* @__PURE__ */ factory(
-  name179,
-  dependencies179,
+  name178,
+  dependencies178,
   ({ typed: typed3, config, numeric: numeric2, smaller: smaller2, isNaN: mathIsNaN }) => {
-    return typed3(name179, {
+    return typed3(name178, {
       // min([a, b, c, d, ...])
       "Array | Matrix": _min,
       // min([a, b, c, d, ...], dim)
@@ -28667,11 +28562,11 @@ var createMin = /* @__PURE__ */ factory(
 );
 // src/logical/nullish.ts
-var name180 = "nullish";
-var dependencies180 = ["typed", "matrix", "size", "flatten", "deepEqual"];
+var name179 = "nullish";
+var dependencies179 = ["typed", "matrix", "size", "flatten", "deepEqual"];
 var createNullish = /* @__PURE__ */ factory(
-  name180,
-  dependencies180,
+  name179,
+  dependencies179,
   ({ typed: typed3, matrix: matrix2, size: size2, flatten: _flatten, deepEqual: deepEqual3 }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -28679,7 +28574,7 @@ var createNullish = /* @__PURE__ */ factory(
     const toMatrix = (arr7) => {
       return matrix2(arr7);
     };
-    return typed3(name180, {
+    return typed3(name179, {
       // 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,
@@ -28723,8 +28618,8 @@ var createNullish = /* @__PURE__ */ factory(
 // src/arithmetic/hypot.ts
 var WASM_HYPOT_THRESHOLD = 50;
-var name181 = "hypot";
-var dependencies181 = [
+var name180 = "hypot";
+var dependencies180 = [
   "typed",
   "abs",
   "addScalar",
@@ -28735,8 +28630,8 @@ var dependencies181 = [
   "isPositive"
 ];
 var createHypot = /* @__PURE__ */ factory(
-  name181,
-  dependencies181,
+  name180,
+  dependencies180,
   ({
     typed: typed3,
     abs: abs2,
@@ -28747,7 +28642,7 @@ var createHypot = /* @__PURE__ */ factory(
     smaller: smaller2,
     isPositive: isPositive2
   }) => {
-    return typed3(name181, {
+    return typed3(name180, {
       "... number | BigNumber": _hypot,
       Array: _hypot,
       Matrix: (M) => _hypot(flatten2(M.toArray(), true))
@@ -28802,8 +28697,8 @@ var createHypot = /* @__PURE__ */ factory(
 // src/geometry/distance.ts
 var WASM_DISTANCE_THRESHOLD = 4;
-var name182 = "distance";
-var dependencies182 = [
+var name181 = "distance";
+var dependencies181 = [
   "typed",
   "addScalar",
   "subtractScalar",
@@ -28814,8 +28709,8 @@ var dependencies182 = [
   "abs"
 ];
 var createDistance = /* @__PURE__ */ factory(
-  name182,
-  dependencies182,
+  name181,
+  dependencies181,
   ({
     typed: typed3,
     addScalar: addScalar2,
@@ -28826,7 +28721,7 @@ var createDistance = /* @__PURE__ */ factory(
     sqrt: sqrt2,
     abs: abs2
   }) => {
-    return typed3(name182, {
+    return typed3(name181, {
       "Array, Array, Array": function(x, y, z) {
         if (x.length === 2 && y.length === 2 && z.length === 2) {
           if (!_2d(x)) {
@@ -29167,13 +29062,13 @@ var createDistance = /* @__PURE__ */ factory(
 );
 // src/probability/factorial.ts
-var name183 = "factorial";
-var dependencies183 = ["typed", "gamma"];
+var name182 = "factorial";
+var dependencies182 = ["typed", "gamma"];
 var createFactorial = /* @__PURE__ */ factory(
-  name183,
-  dependencies183,
+  name182,
+  dependencies182,
   ({ typed: typed3, gamma: gamma2 }) => {
-    return typed3(name183, {
+    return typed3(name182, {
       number: function(n) {
         if (n < 0) {
           throw new Error("Value must be non-negative");
@@ -29194,13 +29089,13 @@ var createFactorial = /* @__PURE__ */ factory(
 );
 // src/set/setSize.ts
-var name184 = "setSize";
-var dependencies184 = ["typed", "compareNatural"];
+var name183 = "setSize";
+var dependencies183 = ["typed", "compareNatural"];
 var createSetSize = /* @__PURE__ */ factory(
-  name184,
-  dependencies184,
+  name183,
+  dependencies183,
   ({ typed: typed3, compareNatural: compareNatural3 }) => {
-    return typed3(name184, {
+    return typed3(name183, {
       "Array | Matrix": function(a) {
         return Array.isArray(a) ? flatten2(a).length : flatten2(a.toArray()).length;
       },
@@ -29223,11 +29118,11 @@ var createSetSize = /* @__PURE__ */ factory(
 );
 // src/matrix/sort.ts
-var name185 = "sort";
-var dependencies185 = ["typed", "matrix", "compare", "compareNatural"];
+var name184 = "sort";
+var dependencies184 = ["typed", "matrix", "compare", "compareNatural"];
 var createSort = /* @__PURE__ */ factory(
-  name185,
-  dependencies185,
+  name184,
+  dependencies184,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -29236,7 +29131,7 @@ var createSort = /* @__PURE__ */ factory(
   }) => {
     const compareAsc = compare2;
     const compareDesc = (a, b) => -compare2(a, b);
-    return typed3(name185, {
+    return typed3(name184, {
       Array: function(x) {
         _arrayIsVector(x);
         return x.sort(compareAsc);
@@ -29287,8 +29182,8 @@ var createSort = /* @__PURE__ */ factory(
 );
 // src/combinatorics/stirlingS2.ts
-var name186 = "stirlingS2";
-var dependencies186 = [
+var name185 = "stirlingS2";
+var dependencies185 = [
   "typed",
   "addScalar",
   "subtractScalar",
@@ -29304,8 +29199,8 @@ var dependencies186 = [
   "larger"
 ];
 var createStirlingS2 = /* @__PURE__ */ factory(
-  name186,
-  dependencies186,
+  name185,
+  dependencies185,
   ({
     typed: typed3,
     addScalar: addScalar2,
@@ -29323,7 +29218,7 @@ var createStirlingS2 = /* @__PURE__ */ factory(
   }) => {
     const smallCache = [];
     const bigCache = [];
-    return typed3(name186, {
+    return typed3(name185, {
       "number | BigNumber, number | BigNumber": function(n, k) {
         if (!isInteger3(n) || isNegative2(n) || !isInteger3(k) || isNegative2(k)) {
           throw new TypeError("Non-negative integer value expected in function stirlingS2");
@@ -29360,13 +29255,13 @@ var createStirlingS2 = /* @__PURE__ */ factory(
 );
 // src/probability/permutations.ts
-var name187 = "permutations";
-var dependencies187 = ["typed", "factorial"];
+var name186 = "permutations";
+var dependencies186 = ["typed", "factorial"];
 var createPermutations = /* @__PURE__ */ factory(
-  name187,
-  dependencies187,
+  name186,
+  dependencies186,
   ({ typed: typed3, factorial: factorial4 }) => {
-    return typed3(name187, {
+    return typed3(name186, {
       "number | BigNumber": factorial4,
       "number, number": function(n, k) {
         if (!isInteger(n) || n < 0) {
@@ -29405,13 +29300,13 @@ function isPositiveInteger3(n) {
 }
 // src/combinatorics/bellNumbers.ts
-var name188 = "bellNumbers";
-var dependencies188 = ["typed", "addScalar", "isNegative", "isInteger", "stirlingS2"];
+var name187 = "bellNumbers";
+var dependencies187 = ["typed", "addScalar", "isNegative", "isInteger", "stirlingS2"];
 var createBellNumbers = /* @__PURE__ */ factory(
-  name188,
-  dependencies188,
+  name187,
+  dependencies187,
   ({ typed: typed3, addScalar: addScalar2, isNegative: isNegative2, isInteger: isInteger3, stirlingS2: stirlingS22 }) => {
-    return typed3(name188, {
+    return typed3(name187, {
       "number | BigNumber": function(n) {
         if (!isInteger3(n) || isNegative2(n)) {
           throw new TypeError("Non-negative integer value expected in function bellNumbers");
@@ -29448,11 +29343,11 @@ import {
 } from "@danielsimonjr/mathts-expression";
 // src/type/resultset/ResultSet.ts
-var name189 = "ResultSet";
-var dependencies189 = [];
+var name188 = "ResultSet";
+var dependencies188 = [];
 var createResultSet = /* @__PURE__ */ factory(
-  name189,
-  dependencies189,
+  name188,
+  dependencies188,
   () => {
     function ResultSet(entries) {
       if (!(this instanceof ResultSet)) {
@@ -29483,11 +29378,11 @@ var createResultSet = /* @__PURE__ */ factory(
 );
 // src/arithmetic/utils/nodeOperations.ts
-var name190 = "nodeOperations";
-var dependencies190 = ["ConstantNode", "OperatorNode"];
+var name189 = "nodeOperations";
+var dependencies189 = ["ConstantNode", "OperatorNode"];
 var createNodeOperations = /* @__PURE__ */ factory(
-  name190,
-  dependencies190,
+  name189,
+  dependencies189,
   ({ ConstantNode, OperatorNode }) => {
     const OPERATOR_MAP = {
       add: "+",
@@ -29536,11 +29431,11 @@ var createNodeOperations = /* @__PURE__ */ factory(
 );
 // src/algebra/leafCount.ts
-var name191 = "leafCount";
-var dependencies191 = ["parse", "typed"];
+var name190 = "leafCount";
+var dependencies190 = ["parse", "typed"];
 var createLeafCount = /* @__PURE__ */ factory(
-  name191,
-  dependencies191,
+  name190,
+  dependencies190,
   ({ parse: _parse2, typed: typed3 }) => {
     function countLeaves(node) {
       let count2 = 0;
@@ -29549,7 +29444,7 @@ var createLeafCount = /* @__PURE__ */ factory(
       });
       return count2 || 1;
     }
-    return typed3(name191, {
+    return typed3(name190, {
       Node: function(expr) {
         return countLeaves(expr);
       }
@@ -29638,8 +29533,8 @@ function createMap2(mapOrObject) {
 }
 // src/algebra/resolve.ts
-var name192 = "resolve";
-var dependencies192 = [
+var name191 = "resolve";
+var dependencies191 = [
   "typed",
   "parse",
   "ConstantNode",
@@ -29648,8 +29543,8 @@ var dependencies192 = [
   "ParenthesisNode"
 ];
 var createResolve = /* @__PURE__ */ factory(
-  name192,
-  dependencies192,
+  name191,
+  dependencies191,
   ({
     typed: typed3,
     parse: parse3,
@@ -29728,11 +29623,11 @@ var createResolve = /* @__PURE__ */ factory(
 );
 // src/algebra/simplify/util.ts
-var name193 = "simplifyUtil";
-var dependencies193 = ["FunctionNode", "OperatorNode", "SymbolNode"];
+var name192 = "simplifyUtil";
+var dependencies192 = ["FunctionNode", "OperatorNode", "SymbolNode"];
 var createUtil = /* @__PURE__ */ factory(
-  name193,
-  dependencies193,
+  name192,
+  dependencies192,
   ({
     FunctionNode,
     OperatorNode,
@@ -29767,23 +29662,23 @@ var createUtil = /* @__PURE__ */ factory(
       log: { total: T }
     };
     function hasProperty(nodeOrName, property, context = defaultContext) {
-      let name255 = defaultName;
+      let name254 = defaultName;
       if (typeof nodeOrName === "string") {
-        name255 = nodeOrName;
+        name254 = nodeOrName;
       } else if (isOperatorNode(nodeOrName)) {
-        name255 = nodeOrName.fn.toString();
+        name254 = nodeOrName.fn.toString();
       } else if (isFunctionNode(nodeOrName)) {
-        name255 = nodeOrName.name;
+        name254 = nodeOrName.name;
       } else if (isParenthesisNode(nodeOrName)) {
-        name255 = "paren";
+        name254 = "paren";
       }
-      if (hasOwnProperty(context, name255)) {
-        const properties2 = context[name255];
+      if (hasOwnProperty(context, name254)) {
+        const properties2 = context[name254];
         if (hasOwnProperty(properties2, property)) {
           return properties2[property];
         }
-        if (hasOwnProperty(defaultContext, name255)) {
-          return defaultContext[name255][property];
+        if (hasOwnProperty(defaultContext, name254)) {
+          return defaultContext[name254][property];
         }
       }
       if (hasOwnProperty(context, defaultName)) {
@@ -29793,8 +29688,8 @@ var createUtil = /* @__PURE__ */ factory(
         }
         return defaultContext[defaultName][property];
       }
-      if (hasOwnProperty(defaultContext, name255)) {
-        const properties2 = defaultContext[name255];
+      if (hasOwnProperty(defaultContext, name254)) {
+        const properties2 = defaultContext[name254];
         if (hasOwnProperty(properties2, property)) {
           return properties2[property];
         }
@@ -29916,8 +29811,8 @@ var createUtil = /* @__PURE__ */ factory(
 );
 // src/algebra/simplifyConstant.ts
-var name194 = "simplifyConstant";
-var dependencies194 = [
+var name193 = "simplifyConstant";
+var dependencies193 = [
   "typed",
   "config",
   "mathWithTransform",
@@ -29936,8 +29831,8 @@ var dependencies194 = [
   "SymbolNode"
 ];
 var createSimplifyConstant = /* @__PURE__ */ factory(
-  name194,
-  dependencies194,
+  name193,
+  dependencies193,
   ({
     typed: typed3,
     config,
@@ -30326,13 +30221,13 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
 );
 // src/type/unit/function/splitUnit.ts
-var name195 = "splitUnit";
-var dependencies195 = ["typed"];
+var name194 = "splitUnit";
+var dependencies194 = ["typed"];
 var createSplitUnit = /* @__PURE__ */ factory(
-  name195,
-  dependencies195,
+  name194,
+  dependencies194,
   ({ typed: typed3 }) => {
-    return typed3(name195, {
+    return typed3(name194, {
       "Unit, Array": function(unit2, parts) {
         return unit2.splitUnit(parts);
       }
@@ -30369,8 +30264,8 @@ function interleavedToComplex(data, n, complex2) {
   }
   return result;
 }
-var name196 = "fft";
-var dependencies196 = [
+var name195 = "fft";
+var dependencies195 = [
   "typed",
   "matrix",
   "addScalar",
@@ -30387,8 +30282,8 @@ var dependencies196 = [
   "complex"
 ];
 var createFft = /* @__PURE__ */ factory(
-  name196,
-  dependencies196,
+  name195,
+  dependencies195,
   ({
     typed: typed3,
     matrix: _matrix,
@@ -30405,7 +30300,7 @@ var createFft = /* @__PURE__ */ factory(
     log2: log23,
     complex: complex2
   }) => {
-    return typed3(name196, {
+    return typed3(name195, {
       Array: _ndFft,
       Matrix: function(matrix2) {
         return matrix2.create(_ndFft(matrix2.valueOf()), matrix2._datatype);
@@ -30526,11 +30421,11 @@ var createFft = /* @__PURE__ */ factory(
 );
 // src/type/chain/Chain.ts
-var name197 = "Chain";
-var dependencies197 = ["?on", "math", "typed"];
+var name196 = "Chain";
+var dependencies196 = ["?on", "math", "typed"];
 var createChainClass = /* @__PURE__ */ factory(
-  name197,
-  dependencies197,
+  name196,
+  dependencies196,
   ({ on, math, typed: typed3 }) => {
     function Chain2(value) {
       if (!(this instanceof Chain2)) {
@@ -30562,15 +30457,15 @@ var createChainClass = /* @__PURE__ */ factory(
     Chain2.fromJSON = function(json) {
       return new Chain2(json.value);
     };
-    function createProxy(name255, fn) {
+    function createProxy(name254, fn) {
       if (typeof fn === "function") {
-        Chain2.prototype[name255] = chainify(
+        Chain2.prototype[name254] = chainify(
           fn
         );
       }
     }
-    function createLazyProxy(name255, resolver) {
-      lazy(Chain2.prototype, name255, function outerResolver() {
+    function createLazyProxy(name254, resolver) {
+      lazy(Chain2.prototype, name254, function outerResolver() {
         const fn = resolver();
         if (typeof fn === "function") {
           return chainify(fn);
@@ -30607,9 +30502,9 @@ var createChainClass = /* @__PURE__ */ factory(
       if (typeof arg0 === "string") {
         createProxy(arg0, arg1);
       } else {
-        for (const name255 in arg0) {
-          if (hasOwnProperty(arg0, name255) && excludedNames[name255] === void 0) {
-            createLazyProxy(name255, () => arg0[name255]);
+        for (const name254 in arg0) {
+          if (hasOwnProperty(arg0, name254) && excludedNames[name254] === void 0) {
+            createLazyProxy(name254, () => arg0[name254]);
           }
         }
       }
@@ -30626,9 +30521,9 @@ var createChainClass = /* @__PURE__ */ factory(
     };
     Chain2.createProxy(math);
     if (on) {
-      on("import", function(name255, resolver, path) {
+      on("import", function(name254, resolver, path) {
         if (!path) {
-          createLazyProxy(name255, resolver);
+          createLazyProxy(name254, resolver);
         }
       });
     }
@@ -30638,8 +30533,8 @@ var createChainClass = /* @__PURE__ */ factory(
 );
 // src/arithmetic/subtract.ts
-var name198 = "subtract";
-var dependencies198 = [
+var name197 = "subtract";
+var dependencies197 = [
   "typed",
   "matrix",
   "equalScalar",
@@ -30650,8 +30545,8 @@ var dependencies198 = [
   "nodeOperations"
 ];
 var createSubtract = /* @__PURE__ */ factory(
-  name198,
-  dependencies198,
+  name197,
+  dependencies197,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -30673,7 +30568,7 @@ var createSubtract = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name198,
+      name197,
       {
         // =========================================================================
         // NODE SIGNATURES - Must be FIRST (before 'any, any')
@@ -30708,8 +30603,8 @@ var createSubtract = /* @__PURE__ */ factory(
 );
 // src/arithmetic/divide.ts
-var name199 = "divide";
-var dependencies199 = [
+var name198 = "divide";
+var dependencies198 = [
   "typed",
   "matrix",
   "multiply",
@@ -30719,8 +30614,8 @@ var dependencies199 = [
   "nodeOperations"
 ];
 var createDivide = /* @__PURE__ */ factory(
-  name199,
-  dependencies199,
+  name198,
+  dependencies198,
   ({ typed: typed3, matrix: matrix2, multiply: multiply2, equalScalar: equalScalar3, divideScalar: divideScalar2, inv: inv2, nodeOperations: nodeOperations2 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -30815,13 +30710,13 @@ function interleavedToComplex2(data, n, complex2) {
   }
   return result;
 }
-var name200 = "ifft";
-var dependencies200 = ["typed", "fft", "dotDivide", "conj", "complex"];
+var name199 = "ifft";
+var dependencies199 = ["typed", "fft", "dotDivide", "conj", "complex"];
 var createIfft = /* @__PURE__ */ factory(
-  name200,
-  dependencies200,
+  name199,
+  dependencies199,
   ({ typed: typed3, fft: fft2, dotDivide: dotDivide2, conj: conj3, complex: complex2 }) => {
-    return typed3(name200, {
+    return typed3(name199, {
       "Array | Matrix": function(arr7) {
         const size2 = isMatrix(arr7) ? arr7.size() : arraySize(arr7);
         const totalSize = size2.reduce((acc, curr) => acc * curr, 1);
@@ -30856,11 +30751,11 @@ var createIfft = /* @__PURE__ */ factory(
 );
 // src/type/matrix/MatrixIndex.ts
-var name201 = "Index";
-var dependencies201 = ["ImmutableDenseMatrix", "getMatrixDataType"];
+var name200 = "Index";
+var dependencies200 = ["ImmutableDenseMatrix", "getMatrixDataType"];
 var createIndexClass = /* @__PURE__ */ factory(
-  name201,
-  dependencies201,
+  name200,
+  dependencies200,
   ({ ImmutableDenseMatrix, getMatrixDataType: getMatrixDataType2 }) => {
     function _createImmutableMatrix(arg3) {
       for (let i = 0, l = arg3.length; i < l; i++) {
@@ -31136,16 +31031,16 @@ function _booleansArrayToNumbersForIndex(booleanArrayIndex) {
 }
 // src/type/chain/function/chain.ts
-var name202 = "chain";
-var dependencies202 = ["typed", "Chain"];
+var name201 = "chain";
+var dependencies201 = ["typed", "Chain"];
 var createChain = /* @__PURE__ */ factory(
-  name202,
-  dependencies202,
+  name201,
+  dependencies201,
   ({
     typed: typed3,
     Chain: Chain2
   }) => {
-    return typed3(name202, {
+    return typed3(name201, {
       "": function() {
         return new Chain2();
       },
@@ -31157,13 +31052,13 @@ var createChain = /* @__PURE__ */ factory(
 );
 // src/type/unit/function/createUnit.ts
-var name203 = "createUnit";
-var dependencies203 = ["typed", "Unit"];
+var name202 = "createUnit";
+var dependencies202 = ["typed", "Unit"];
 var createCreateUnit = /* @__PURE__ */ factory(
-  name203,
-  dependencies203,
+  name202,
+  dependencies202,
   ({ typed: typed3, Unit: Unit2 }) => {
-    return typed3(name203, {
+    return typed3(name202, {
       // General function signature. First parameter is an object where each property is the definition of a new unit. The object keys are the unit names and the values are the definitions. The values can be objects, strings, or Units. If a property is an empty object or an empty string, a new base unit is created. The second parameter is the options.
       "Object, Object": function(obj, options) {
         return Unit2.createUnit(obj, options);
@@ -31173,21 +31068,21 @@ var createCreateUnit = /* @__PURE__ */ factory(
         return Unit2.createUnit(obj, {});
       },
       // Shortcut method for creating one unit.
-      "string, Unit | string | Object, Object": function(name255, def, options) {
+      "string, Unit | string | Object, Object": function(name254, def, options) {
         const obj = {};
-        obj[name255] = def;
+        obj[name254] = def;
         return Unit2.createUnit(obj, options);
       },
       // Same as above but without the options.
-      "string, Unit | string | Object": function(name255, def) {
+      "string, Unit | string | Object": function(name254, def) {
         const obj = {};
-        obj[name255] = def;
+        obj[name254] = def;
         return Unit2.createUnit(obj, {});
       },
       // Without a definition, creates a base unit.
-      string: function(name255) {
+      string: function(name254) {
         const obj = {};
-        obj[name255] = {};
+        obj[name254] = {};
         return Unit2.createUnit(obj, {});
       }
     });
@@ -31195,13 +31090,13 @@ var createCreateUnit = /* @__PURE__ */ factory(
 );
 // src/type/unit/function/unit.ts
-var name204 = "unit";
-var dependencies204 = ["typed", "Unit"];
+var name203 = "unit";
+var dependencies203 = ["typed", "Unit"];
 var createUnitFunction = /* @__PURE__ */ factory(
-  name204,
-  dependencies204,
+  name203,
+  dependencies203,
   ({ typed: typed3, Unit: Unit2 }) => {
-    return typed3(name204, {
+    return typed3(name203, {
       Unit: function(x) {
         return x.clone();
       },
@@ -31228,11 +31123,11 @@ var createUnitFunction = /* @__PURE__ */ factory(
 import { createUnitClass } from "@danielsimonjr/mathts-core/internal";
 // src/type/matrix/FibonacciHeap.ts
-var name205 = "FibonacciHeap";
-var dependencies205 = ["smaller", "larger"];
+var name204 = "FibonacciHeap";
+var dependencies204 = ["smaller", "larger"];
 var createFibonacciHeapClass = /* @__PURE__ */ factory(
-  name205,
-  dependencies205,
+  name204,
+  dependencies204,
   ({ smaller: smaller2, larger: larger2 }) => {
     const oneOverLogPhi = 1 / Math.log((1 + Math.sqrt(5)) / 2);
     class FibonacciHeap {
@@ -31465,11 +31360,11 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
 );
 // src/type/matrix/ImmutableDenseMatrix.ts
-var name206 = "ImmutableDenseMatrix";
-var dependencies206 = ["smaller", "DenseMatrix"];
+var name205 = "ImmutableDenseMatrix";
+var dependencies205 = ["smaller", "DenseMatrix"];
 var createImmutableDenseMatrixClass = /* @__PURE__ */ factory(
-  name206,
-  dependencies206,
+  name205,
+  dependencies205,
   ({ smaller: smaller2, DenseMatrix: DenseMatrix6 }) => {
     class ImmutableDenseMatrix extends DenseMatrix6 {
       /**
@@ -31700,13 +31595,13 @@ var createImmutableDenseMatrixClass = /* @__PURE__ */ factory(
 );
 // src/matrix/column.ts
-var name207 = "column";
-var dependencies207 = ["typed", "Index", "matrix", "range"];
+var name206 = "column";
+var dependencies206 = ["typed", "Index", "matrix", "range"];
 var createColumn = /* @__PURE__ */ factory(
-  name207,
-  dependencies207,
+  name206,
+  dependencies206,
   ({ typed: typed3, Index: Index2, matrix: matrix2, range: range2 }) => {
-    return typed3(name207, {
+    return typed3(name206, {
       "Matrix, number": _column,
       "Array, number": function(value, column2) {
         return _column(matrix2(clone(value)), column2).valueOf();
@@ -31726,13 +31621,13 @@ var createColumn = /* @__PURE__ */ factory(
 );
 // src/matrix/row.ts
-var name208 = "row";
-var dependencies208 = ["typed", "Index", "matrix", "range"];
+var name207 = "row";
+var dependencies207 = ["typed", "Index", "matrix", "range"];
 var createRow = /* @__PURE__ */ factory(
-  name208,
-  dependencies208,
+  name207,
+  dependencies207,
   ({ typed: typed3, Index: Index2, matrix: matrix2, range: range2 }) => {
-    return typed3(name208, {
+    return typed3(name207, {
       "Matrix, number": _row,
       "Array, number": function(value, row2) {
         return _row(matrix2(clone(value)), row2).valueOf();
@@ -31752,18 +31647,18 @@ var createRow = /* @__PURE__ */ factory(
 );
 // src/matrix/cross.ts
-var name209 = "cross";
-var dependencies209 = ["typed", "matrix", "subtract", "multiply"];
+var name208 = "cross";
+var dependencies208 = ["typed", "matrix", "subtract", "multiply"];
 var createCross = /* @__PURE__ */ factory(
-  name209,
-  dependencies209,
+  name208,
+  dependencies208,
   ({
     typed: typed3,
     matrix: matrix2,
     subtract: subtract2,
     multiply: multiply2
   }) => {
-    return typed3(name209, {
+    return typed3(name208, {
       "Matrix, Matrix": function(x, y) {
         return matrix2(_cross(x.toArray(), y.toArray()));
       },
@@ -31801,18 +31696,18 @@ var createCross = /* @__PURE__ */ factory(
 );
 // src/matrix/diff.ts
-var name210 = "diff";
-var dependencies210 = ["typed", "matrix", "subtract", "number"];
+var name209 = "diff";
+var dependencies209 = ["typed", "matrix", "subtract", "number"];
 var createDiff = /* @__PURE__ */ factory(
-  name210,
-  dependencies210,
+  name209,
+  dependencies209,
   ({
     typed: typed3,
     matrix: matrix2,
     subtract: subtract2,
     number: number2
   }) => {
-    return typed3(name210, {
+    return typed3(name209, {
       "Array | Matrix": function(arr7) {
         if (isMatrix(arr7)) {
           return matrix2(_diff(arr7.toArray()));
@@ -31890,8 +31785,8 @@ var createDiff = /* @__PURE__ */ factory(
 // src/matrix/sqrtm.ts
 var WASM_SQRTM_THRESHOLD = 16;
-var name211 = "sqrtm";
-var dependencies211 = [
+var name210 = "sqrtm";
+var dependencies210 = [
   "typed",
   "abs",
   "add",
@@ -31905,8 +31800,8 @@ var dependencies211 = [
   "identity"
 ];
 var createSqrtm = /* @__PURE__ */ factory(
-  name211,
-  dependencies211,
+  name210,
+  dependencies210,
   ({ typed: typed3, abs: abs2, add: add2, multiply: multiply2, map: map2, sqrt: sqrt2, subtract: subtract2, inv: inv2, size: size2, max: max2, identity: identity2 }) => {
     const _maxIterations = 1e3;
     const _tolerance = 1e-6;
@@ -31982,7 +31877,7 @@ var createSqrtm = /* @__PURE__ */ factory(
       } while (error > _tolerance);
       return Y;
     }
-    return typed3(name211, {
+    return typed3(name210, {
       "Array | Matrix": function(A) {
         const sizeArray = isMatrix(A) ? A.size() : arraySize(A);
         switch (sizeArray.length) {
@@ -32039,8 +31934,8 @@ function flattenToFloat647(matrix2, rows, cols) {
   }
   return result;
 }
-var name212 = "lup";
-var dependencies212 = [
+var name211 = "lup";
+var dependencies211 = [
   "typed",
   "matrix",
   "abs",
@@ -32056,8 +31951,8 @@ var dependencies212 = [
   "Spa"
 ];
 var createLup = /* @__PURE__ */ factory(
-  name212,
-  dependencies212,
+  name211,
+  dependencies211,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -32073,7 +31968,7 @@ var createLup = /* @__PURE__ */ factory(
     SparseMatrix,
     Spa
   }) => {
-    return typed3(name212, {
+    return typed3(name211, {
       DenseMatrix: function(m) {
         return _denseLUP(m);
       },
@@ -32434,11 +32329,11 @@ function csReach(g, b, k, xi, pinv2) {
 }
 // src/algebra/sparse/csSpsolve.ts
-var name213 = "csSpsolve";
-var dependencies213 = ["divideScalar", "multiply", "subtract"];
+var name212 = "csSpsolve";
+var dependencies212 = ["divideScalar", "multiply", "subtract"];
 var createCsSpsolve = /* @__PURE__ */ factory(
-  name213,
-  dependencies213,
+  name212,
+  dependencies212,
   ({ divideScalar: divideScalar2, multiply: multiply2, subtract: subtract2 }) => {
     return function csSpsolve2(g, b, k, xi, x, pinv2, lo) {
       const gvalues = g._values;
@@ -32479,8 +32374,8 @@ var createCsSpsolve = /* @__PURE__ */ factory(
 );
 // src/algebra/sparse/csLu.ts
-var name214 = "csLu";
-var dependencies214 = [
+var name213 = "csLu";
+var dependencies213 = [
   "abs",
   "divideScalar",
   "multiply",
@@ -32490,8 +32385,8 @@ var dependencies214 = [
   "SparseMatrix"
 ];
 var createCsLu = /* @__PURE__ */ factory(
-  name214,
-  dependencies214,
+  name213,
+  dependencies213,
   ({ abs: abs2, divideScalar: divideScalar2, multiply: multiply2, subtract: subtract2, larger: larger2, largerEq: largerEq2, SparseMatrix }) => {
     const csSpsolve2 = createCsSpsolve({ divideScalar: divideScalar2, multiply: multiply2, subtract: subtract2 });
     return function csLu2(m, s, tol) {
@@ -32593,8 +32488,8 @@ var createCsLu = /* @__PURE__ */ factory(
 );
 // src/algebra/decomposition/slu.ts
-var name215 = "slu";
-var dependencies215 = [
+var name214 = "slu";
+var dependencies214 = [
   "typed",
   "abs",
   "add",
@@ -32607,8 +32502,8 @@ var dependencies215 = [
   "SparseMatrix"
 ];
 var createSlu = /* @__PURE__ */ factory(
-  name215,
-  dependencies215,
+  name214,
+  dependencies214,
   ({
     typed: typed3,
     abs: abs2,
@@ -32635,7 +32530,7 @@ var createSlu = /* @__PURE__ */ factory(
       // expects; the two declared shapes don't structurally overlap, so cast
       // through unknown.
     });
-    return typed3(name215, {
+    return typed3(name214, {
       "SparseMatrix, number, number": function(a, order, threshold) {
         if (!isInteger(order) || order < 0 || order > 3) {
           throw new Error(
@@ -32693,8 +32588,8 @@ function csEreach(a, k, parent, w) {
 }
 // src/algebra/sparse/csChol.ts
-var name216 = "csChol";
-var dependencies216 = [
+var name215 = "csChol";
+var dependencies215 = [
   "divideScalar",
   "sqrt",
   "subtract",
@@ -32707,8 +32602,8 @@ var dependencies216 = [
   "SparseMatrix"
 ];
 var createCsChol = /* @__PURE__ */ factory(
-  name216,
-  dependencies216,
+  name215,
+  dependencies215,
   ({
     divideScalar: divideScalar2,
     sqrt: sqrt2,
@@ -32805,11 +32700,11 @@ var createCsChol = /* @__PURE__ */ factory(
 );
 // src/type/matrix/Spa.ts
-var name217 = "Spa";
-var dependencies217 = ["addScalar", "equalScalar", "FibonacciHeap"];
+var name216 = "Spa";
+var dependencies216 = ["addScalar", "equalScalar", "FibonacciHeap"];
 var createSpaClass = /* @__PURE__ */ factory(
-  name217,
-  dependencies217,
+  name216,
+  dependencies216,
   ({ addScalar: addScalar2, equalScalar: equalScalar3, FibonacciHeap }) => {
     class Spa {
       type = "Spa";
@@ -32901,8 +32796,8 @@ var createSpaClass = /* @__PURE__ */ factory(
 );
 // src/geometry/intersect.ts
-var name218 = "intersect";
-var dependencies218 = [
+var name217 = "intersect";
+var dependencies217 = [
   "typed",
   "config",
   "abs",
@@ -32920,8 +32815,8 @@ var dependencies218 = [
   "isNumeric"
 ];
 var createIntersect = /* @__PURE__ */ factory(
-  name218,
-  dependencies218,
+  name217,
+  dependencies217,
   ({
     typed: typed3,
     config,
@@ -33177,13 +33072,13 @@ function isFlatNumberArray7(arr7) {
   }
   return true;
 }
-var name219 = "mean";
-var dependencies219 = ["typed", "add", "divide"];
+var name218 = "mean";
+var dependencies218 = ["typed", "add", "divide"];
 var createMean = /* @__PURE__ */ factory(
-  name219,
-  dependencies219,
+  name218,
+  dependencies218,
   ({ typed: typed3, add: add2, divide: divide2 }) => {
-    return typed3(name219, {
+    return typed3(name218, {
       // mean([a, b, c, d, ...])
       "Array | Matrix": _mean2,
       // mean([a, b, c, d, ...], dim)
@@ -33242,11 +33137,11 @@ var createMean = /* @__PURE__ */ factory(
 );
 // src/statistics/median.ts
-var name220 = "median";
-var dependencies220 = ["typed", "add", "divide", "compare", "partitionSelect"];
+var name219 = "median";
+var dependencies219 = ["typed", "add", "divide", "compare", "partitionSelect"];
 var createMedian = /* @__PURE__ */ factory(
-  name220,
-  dependencies220,
+  name219,
+  dependencies219,
   ({ typed: typed3, add: add2, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
     function _median(array) {
       try {
@@ -33283,7 +33178,7 @@ var createMedian = /* @__PURE__ */ factory(
         return divide2(add2(left, right), 2);
       }
     });
-    return typed3(name220, {
+    return typed3(name219, {
       // median([a, b, c, d, ...])
       "Array | Matrix": _median,
       // median([a, b, c, d, ...], dim)
@@ -33312,11 +33207,11 @@ function isFlatNumberArray8(arr7) {
   return true;
 }
 var DEFAULT_NORMALIZATION = "unbiased";
-var name221 = "variance";
-var dependencies221 = ["typed", "add", "subtract", "multiply", "divide", "mapSlices", "isNaN"];
+var name220 = "variance";
+var dependencies220 = ["typed", "add", "subtract", "multiply", "divide", "mapSlices", "isNaN"];
 var createVariance = /* @__PURE__ */ factory(
-  name221,
-  dependencies221,
+  name220,
+  dependencies220,
   ({
     typed: typed3,
     add: add2,
@@ -33326,7 +33221,7 @@ var createVariance = /* @__PURE__ */ factory(
     mapSlices: mapSlices2,
     isNaN: mathIsNaN
   }) => {
-    return typed3(name221, {
+    return typed3(name220, {
       // variance([a, b, c, d, ...])
       "Array | Matrix": function(array) {
         return _var(array, DEFAULT_NORMALIZATION);
@@ -33418,8 +33313,8 @@ var createVariance = /* @__PURE__ */ factory(
 );
 // src/statistics/quantileSeq.ts
-var name222 = "quantileSeq";
-var dependencies222 = [
+var name221 = "quantileSeq";
+var dependencies221 = [
   "typed",
   "?bignumber",
   "add",
@@ -33435,8 +33330,8 @@ var dependencies222 = [
   "mapSlices"
 ];
 var createQuantileSeq = /* @__PURE__ */ factory(
-  name222,
-  dependencies222,
+  name221,
+  dependencies221,
   ({
     typed: typed3,
     bignumber: bignumber2,
@@ -33452,7 +33347,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
     larger: larger2,
     mapSlices: mapSlices2
   }) => {
-    return typed3(name222, {
+    return typed3(name221, {
       "Array | Matrix, number | BigNumber": (data, p) => _quantileSeqProbNumber(data, p, false),
       "Array | Matrix, number | BigNumber, number": (data, prob, dim) => _quantileSeqDim(data, prob, false, dim, _quantileSeqProbNumber),
       "Array | Matrix, number | BigNumber, boolean": _quantileSeqProbNumber,
@@ -33538,8 +33433,8 @@ var createQuantileSeq = /* @__PURE__ */ factory(
 );
 // src/probability/kldivergence.ts
-var name223 = "kldivergence";
-var dependencies223 = [
+var name222 = "kldivergence";
+var dependencies222 = [
   "typed",
   "matrix",
   "divide",
@@ -33551,8 +33446,8 @@ var dependencies223 = [
   "isNumeric"
 ];
 var createKldivergence = /* @__PURE__ */ factory(
-  name223,
-  dependencies223,
+  name222,
+  dependencies222,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -33564,7 +33459,7 @@ var createKldivergence = /* @__PURE__ */ factory(
     log: log3,
     isNumeric: isNumeric2
   }) => {
-    return typed3(name223, {
+    return typed3(name222, {
       "Array, Array": function(q, p) {
         return _kldiv(matrix2(q), matrix2(p));
       },
@@ -33616,13 +33511,13 @@ var createKldivergence = /* @__PURE__ */ factory(
 );
 // src/probability/multinomial.ts
-var name224 = "multinomial";
-var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInteger", "isPositive"];
+var name223 = "multinomial";
+var dependencies223 = ["typed", "add", "divide", "multiply", "factorial", "isInteger", "isPositive"];
 var createMultinomial = /* @__PURE__ */ factory(
-  name224,
-  dependencies224,
+  name223,
+  dependencies223,
   ({ typed: typed3, add: add2, divide: divide2, multiply: multiply2, factorial: factorial4, isInteger: isInteger3, isPositive: isPositive2 }) => {
-    return typed3(name224, {
+    return typed3(name223, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
         let denom = 1;
@@ -33641,13 +33536,13 @@ var createMultinomial = /* @__PURE__ */ factory(
 // src/signal/freqz.ts
 var WASM_FREQZ_THRESHOLD = 32;
-var name225 = "freqz";
-var dependencies225 = ["typed", "add", "multiply", "Complex", "divide", "matrix"];
+var name224 = "freqz";
+var dependencies224 = ["typed", "add", "multiply", "Complex", "divide", "matrix"];
 var createFreqz = /* @__PURE__ */ factory(
-  name225,
-  dependencies225,
+  name224,
+  dependencies224,
   ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex12, divide: divide2, matrix: matrix2 }) => {
-    return typed3(name225, {
+    return typed3(name224, {
       "Array, Array": function(b, a) {
         const w = createBins(512);
         return _freqz(b, a, w);
@@ -33771,13 +33666,13 @@ var createFreqz = /* @__PURE__ */ factory(
 );
 // src/set/setCartesian.ts
-var name226 = "setCartesian";
-var dependencies226 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
+var name225 = "setCartesian";
+var dependencies225 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
 var createSetCartesian = /* @__PURE__ */ factory(
-  name226,
-  dependencies226,
+  name225,
+  dependencies225,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
-    return typed3(name226, {
+    return typed3(name225, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         let result = [];
         if (subset2(size2(a1), new Index2(0)) !== 0 && subset2(size2(a2), new Index2(0)) !== 0) {
@@ -33800,13 +33695,13 @@ var createSetCartesian = /* @__PURE__ */ factory(
 );
 // src/set/setDifference.ts
-var name227 = "setDifference";
-var dependencies227 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
+var name226 = "setDifference";
+var dependencies226 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
 var createSetDifference = /* @__PURE__ */ factory(
-  name227,
-  dependencies227,
+  name226,
+  dependencies226,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
-    return typed3(name227, {
+    return typed3(name226, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         let result;
         if (subset2(size2(a1), new Index2(0)) === 0) {
@@ -33841,13 +33736,13 @@ var createSetDifference = /* @__PURE__ */ factory(
 );
 // src/set/setDistinct.ts
-var name228 = "setDistinct";
-var dependencies228 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
+var name227 = "setDistinct";
+var dependencies227 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
 var createSetDistinct = /* @__PURE__ */ factory(
-  name228,
-  dependencies228,
+  name227,
+  dependencies227,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
-    return typed3(name228, {
+    return typed3(name227, {
       "Array | Matrix": function(a) {
         let result;
         if (subset2(size2(a), new Index2(0)) === 0) {
@@ -33872,13 +33767,13 @@ var createSetDistinct = /* @__PURE__ */ factory(
 );
 // src/set/setIntersect.ts
-var name229 = "setIntersect";
-var dependencies229 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
+var name228 = "setIntersect";
+var dependencies228 = ["typed", "size", "subset", "compareNatural", "Index", "DenseMatrix"];
 var createSetIntersect = /* @__PURE__ */ factory(
-  name229,
-  dependencies229,
+  name228,
+  dependencies228,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
-    return typed3(name229, {
+    return typed3(name228, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         let result;
         if (subset2(size2(a1), new Index2(0)) === 0 || subset2(size2(a2), new Index2(0)) === 0) {
@@ -33906,13 +33801,13 @@ var createSetIntersect = /* @__PURE__ */ factory(
 );
 // src/set/setIsSubset.ts
-var name230 = "setIsSubset";
-var dependencies230 = ["typed", "size", "subset", "compareNatural", "Index"];
+var name229 = "setIsSubset";
+var dependencies229 = ["typed", "size", "subset", "compareNatural", "Index"];
 var createSetIsSubset = /* @__PURE__ */ factory(
-  name230,
-  dependencies230,
+  name229,
+  dependencies229,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2 }) => {
-    return typed3(name230, {
+    return typed3(name229, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         if (subset2(size2(a1), new Index2(0)) === 0) {
           return true;
@@ -33941,13 +33836,13 @@ var createSetIsSubset = /* @__PURE__ */ factory(
 );
 // src/set/setMultiplicity.ts
-var name231 = "setMultiplicity";
-var dependencies231 = ["typed", "size", "subset", "compareNatural", "Index"];
+var name230 = "setMultiplicity";
+var dependencies230 = ["typed", "size", "subset", "compareNatural", "Index"];
 var createSetMultiplicity = /* @__PURE__ */ factory(
-  name231,
-  dependencies231,
+  name230,
+  dependencies230,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2 }) => {
-    return typed3(name231, {
+    return typed3(name230, {
       "number | BigNumber | Fraction | Complex, Array | Matrix": function(e, a) {
         if (subset2(size2(a), new Index2(0)) === 0) {
           return 0;
@@ -33966,13 +33861,13 @@ var createSetMultiplicity = /* @__PURE__ */ factory(
 );
 // src/set/setPowerset.ts
-var name232 = "setPowerset";
-var dependencies232 = ["typed", "size", "subset", "compareNatural", "Index"];
+var name231 = "setPowerset";
+var dependencies231 = ["typed", "size", "subset", "compareNatural", "Index"];
 var createSetPowerset = /* @__PURE__ */ factory(
-  name232,
-  dependencies232,
+  name231,
+  dependencies231,
   ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2 }) => {
-    return typed3(name232, {
+    return typed3(name231, {
       "Array | Matrix": function(a) {
         if (subset2(size2(a), new Index2(0)) === 0) {
           return [];
@@ -34283,8 +34178,8 @@ function getOperator(fn) {
 }
 // src/algebra/simplifyCore.ts
-var name233 = "simplifyCore";
-var dependencies233 = [
+var name232 = "simplifyCore";
+var dependencies232 = [
   "typed",
   "parse",
   "equal",
@@ -34305,8 +34200,8 @@ var dependencies233 = [
   "SymbolNode"
 ];
 var createSimplifyCore = /* @__PURE__ */ factory(
-  name233,
-  dependencies233,
+  name232,
+  dependencies232,
   ({
     typed: typed3,
     parse: _parse2,
@@ -34535,13 +34430,13 @@ var createSimplifyCore = /* @__PURE__ */ factory(
       }
       return node;
     }
-    return typed3(name233, { Node: _simplifyCore, "Node,Object": _simplifyCore });
+    return typed3(name232, { Node: _simplifyCore, "Node,Object": _simplifyCore });
   }
 );
 // src/algebra/polynomialRoot.ts
-var name234 = "polynomialRoot";
-var dependencies234 = [
+var name233 = "polynomialRoot";
+var dependencies233 = [
   "typed",
   "isZero",
   "equalScalar",
@@ -34557,8 +34452,8 @@ var dependencies234 = [
   "re"
 ];
 var createPolynomialRoot = /* @__PURE__ */ factory(
-  name234,
-  dependencies234,
+  name233,
+  dependencies233,
   ({
     typed: typed3,
     isZero: isZero2,
@@ -34574,7 +34469,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
     im: im3,
     re: re3
   }) => {
-    return typed3(name234, {
+    return typed3(name233, {
       "number|Complex, ...number|Complex": (constant, restCoeffs) => {
         const coeffs = [constant, ...restCoeffs];
         while (coeffs.length > 0 && isZero2(coeffs[coeffs.length - 1])) {
@@ -34662,8 +34557,8 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
 // src/numeric/solveODE.ts
 var WASM_ODE_THRESHOLD = 10;
-var name235 = "solveODE";
-var dependencies235 = [
+var name234 = "solveODE";
+var dependencies234 = [
   "typed",
   "add",
   "subtract",
@@ -34681,8 +34576,8 @@ var dependencies235 = [
   "unaryMinus"
 ];
 var createSolveODE = /* @__PURE__ */ factory(
-  name235,
-  dependencies235,
+  name234,
+  dependencies234,
   ({
     typed: typed3,
     add: add2,
@@ -35011,8 +34906,8 @@ var createSolveODE = /* @__PURE__ */ factory(
 );
 // src/special/zeta.ts
-var name236 = "zeta";
-var dependencies236 = [
+var name235 = "zeta";
+var dependencies235 = [
   "typed",
   "config",
   "multiply",
@@ -35032,8 +34927,8 @@ var dependencies236 = [
   "pi"
 ];
 var createZeta = /* @__PURE__ */ factory(
-  name236,
-  dependencies236,
+  name235,
+  dependencies235,
   ({
     typed: typed3,
     config,
@@ -35060,7 +34955,7 @@ var createZeta = /* @__PURE__ */ factory(
         () => 20
       );
     }
-    return typed3(name236, {
+    return typed3(name235, {
       number: zetaNumber,
       BigNumber: (s) => zetaNumeric(
         s,
@@ -35137,13 +35032,13 @@ var createZeta = /* @__PURE__ */ factory(
 );
 // src/type/matrix/function/index.ts
-var name237 = "index";
-var dependencies237 = ["typed", "Index"];
+var name236 = "index";
+var dependencies236 = ["typed", "Index"];
 var createIndex = /* @__PURE__ */ factory(
-  name237,
-  dependencies237,
+  name236,
+  dependencies236,
   ({ typed: typed3, Index: Index2 }) => {
-    return typed3(name237, {
+    return typed3(name236, {
       "...number | string | BigNumber | Range | Array | Matrix": function(args) {
         const ranges = args.map(function(arg3) {
           if (isBigNumber(arg3)) {
@@ -35992,8 +35887,8 @@ function createRealSymmetric({
 }
 // src/matrix/eigs.ts
-var name238 = "eigs";
-var dependencies238 = [
+var name237 = "eigs";
+var dependencies237 = [
   "config",
   "typed",
   "matrix",
@@ -36029,8 +35924,8 @@ var dependencies238 = [
   "dot"
 ];
 var createEigs = /* @__PURE__ */ factory(
-  name238,
-  dependencies238,
+  name237,
+  dependencies237,
   ({
     config,
     typed: typed3,
@@ -36317,16 +36212,16 @@ function vectorToFloat643(vec) {
   }
   return result;
 }
-var name239 = "lusolve";
-var dependencies239 = ["typed", "matrix", "lup", "slu", "usolve", "lsolve", "DenseMatrix"];
+var name238 = "lusolve";
+var dependencies238 = ["typed", "matrix", "lup", "slu", "usolve", "lsolve", "DenseMatrix"];
 var createLusolve = /* @__PURE__ */ factory(
-  name239,
-  dependencies239,
+  name238,
+  dependencies238,
   ({ typed: typed3, matrix: matrix2, lup: lup2, slu: slu2, usolve: usolve2, lsolve: lsolve2, DenseMatrix: DenseMatrix6 }) => {
     const solveValidation = createSolveValidation({
       DenseMatrix: DenseMatrix6
     });
-    return typed3(name239, {
+    return typed3(name238, {
       "Array, Array | Matrix": function(a, b) {
         const rows = a.length;
         const columns = a[0]?.length || 0;
@@ -36478,8 +36373,8 @@ function isPlainNumberArray(arr7) {
   }
   return true;
 }
-var name240 = "corr";
-var dependencies240 = [
+var name239 = "corr";
+var dependencies239 = [
   "typed",
   "matrix",
   "mean",
@@ -36492,10 +36387,10 @@ var dependencies240 = [
   "divide"
 ];
 var createCorr = /* @__PURE__ */ factory(
-  name240,
-  dependencies240,
+  name239,
+  dependencies239,
   ({ typed: typed3, matrix: matrix2, sqrt: sqrt2, sum: sum3, add: add2, subtract: subtract2, multiply: multiply2, pow: pow2, divide: divide2 }) => {
-    return typed3(name240, {
+    return typed3(name239, {
       "Array, Array": function(A, B) {
         return _corr(A, B);
       },
@@ -36575,13 +36470,13 @@ function isPlainNumberArray2(arr7) {
   }
   return true;
 }
-var name241 = "mad";
-var dependencies241 = ["typed", "abs", "map", "median", "subtract"];
+var name240 = "mad";
+var dependencies240 = ["typed", "abs", "map", "median", "subtract"];
 var createMad = /* @__PURE__ */ factory(
-  name241,
-  dependencies241,
+  name240,
+  dependencies240,
   ({ typed: typed3, abs: abs2, map: map2, median: median2, subtract: subtract2 }) => {
-    return typed3(name241, {
+    return typed3(name240, {
       // mad([a, b, c, d, ...])
       "Array | Matrix": _mad,
       // mad(a, b, c, d, ...)
@@ -36635,13 +36530,13 @@ function isFlatNumberArray9(arr7) {
   }
   return true;
 }
-var name242 = "std";
-var dependencies242 = ["typed", "map", "sqrt", "variance"];
+var name241 = "std";
+var dependencies241 = ["typed", "map", "sqrt", "variance"];
 var createStd = /* @__PURE__ */ factory(
-  name242,
-  dependencies242,
+  name241,
+  dependencies241,
   ({ typed: typed3, map: map2, sqrt: sqrt2, variance: variance2 }) => {
-    return typed3(name242, {
+    return typed3(name241, {
       // std([a, b, c, d, ...])
       "Array | Matrix": _std,
       // std([a, b, c, d, ...], normalization)
@@ -36699,13 +36594,13 @@ var createStd = /* @__PURE__ */ factory(
 );
 // src/set/setSymDifference.ts
-var name243 = "setSymDifference";
-var dependencies243 = ["typed", "size", "concat", "subset", "setDifference", "Index"];
+var name242 = "setSymDifference";
+var dependencies242 = ["typed", "size", "concat", "subset", "setDifference", "Index"];
 var createSetSymDifference = /* @__PURE__ */ factory(
-  name243,
-  dependencies243,
+  name242,
+  dependencies242,
   ({ typed: typed3, size: size2, concat: concat3, subset: subset2, setDifference: setDifference3, Index: Index2 }) => {
-    return typed3(name243, {
+    return typed3(name242, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         if (subset2(size2(a1), new Index2(0)) === 0) {
           return flatten2(a2);
@@ -36738,8 +36633,8 @@ function isConstantExpression(x) {
 }
 // src/algebra/simplify.ts
-var name244 = "simplify";
-var dependencies244 = [
+var name243 = "simplify";
+var dependencies243 = [
   "typed",
   "parse",
   "equal",
@@ -36758,8 +36653,8 @@ var dependencies244 = [
   "replacer"
 ];
 var createSimplify = /* @__PURE__ */ factory(
-  name244,
-  dependencies244,
+  name243,
+  dependencies243,
   ({
     typed: typed3,
     parse: parse3,
@@ -37574,8 +37469,8 @@ var createSimplify = /* @__PURE__ */ factory(
 );
 // src/algebra/derivative.ts
-var name245 = "derivative";
-var dependencies245 = [
+var name244 = "derivative";
+var dependencies244 = [
   "typed",
   "config",
   "parse",
@@ -37590,8 +37485,8 @@ var dependencies245 = [
   "SymbolNode"
 ];
 var createDerivative = /* @__PURE__ */ factory(
-  name245,
-  dependencies245,
+  name244,
+  dependencies244,
   ({
     typed: typed3,
     config,
@@ -37630,7 +37525,7 @@ var createDerivative = /* @__PURE__ */ factory(
       }
       return symbol;
     }
-    const derivative2 = typed3(name245, {
+    const derivative2 = typed3(name244, {
       "Node, SymbolNode": plainDerivative,
       "Node, SymbolNode, Object": plainDerivative,
       "Node, string": (node, symbol) => plainDerivative(node, parseIdentifier(symbol)),
@@ -38131,8 +38026,8 @@ var createDerivative = /* @__PURE__ */ factory(
 // src/arithmetic/norm.ts
 var WASM_NORM_THRESHOLD = 100;
-var name246 = "norm";
-var dependencies246 = [
+var name245 = "norm";
+var dependencies245 = [
   "typed",
   "abs",
   "add",
@@ -38148,8 +38043,8 @@ var dependencies246 = [
   "eigs"
 ];
 var createNorm = /* @__PURE__ */ factory(
-  name246,
-  dependencies246,
+  name245,
+  dependencies245,
   ({
     typed: typed3,
     abs: abs2,
@@ -38165,7 +38060,7 @@ var createNorm = /* @__PURE__ */ factory(
     ctranspose: ctranspose2,
     eigs: eigs2
   }) => {
-    return typed3(name246, {
+    return typed3(name245, {
       number: Math.abs,
       Complex: function(x) {
         return x.abs();
@@ -38343,8 +38238,8 @@ var createNorm = /* @__PURE__ */ factory(
 );
 // src/algebra/rationalize.ts
-var name247 = "rationalize";
-var dependencies247 = [
+var name246 = "rationalize";
+var dependencies246 = [
   "config",
   "typed",
   "equal",
@@ -38373,8 +38268,8 @@ var dependencies247 = [
   "ParenthesisNode"
 ];
 var createRationalize = /* @__PURE__ */ factory(
-  name247,
-  dependencies247,
+  name246,
+  dependencies246,
   ({
     config: _config,
     typed: typed3,
@@ -38463,7 +38358,7 @@ var createRationalize = /* @__PURE__ */ factory(
       retRationalize.expression = expr;
       return retRationalize;
     }
-    return typed3(name247, {
+    return typed3(name246, {
       Node: _rationalize,
       "Node, boolean": (expr, detailed) => _rationalize(expr, {}, detailed),
       "Node, Object": _rationalize,
@@ -38501,10 +38396,10 @@ var createRationalize = /* @__PURE__ */ factory(
             }
           }
         } else if (tp === "SymbolNode") {
-          const name255 = node2.name;
-          const pos = variables2.indexOf(name255);
+          const name254 = node2.name;
+          const pos = variables2.indexOf(name254);
           if (pos === -1) {
-            variables2.push(name255);
+            variables2.push(name254);
           }
         } else if (tp === "ParenthesisNode") {
           recPoly(node2.content);
@@ -38809,8 +38704,8 @@ var createRationalize = /* @__PURE__ */ factory(
 );
 // src/set/setUnion.ts
-var name248 = "setUnion";
-var dependencies248 = [
+var name247 = "setUnion";
+var dependencies247 = [
   "typed",
   "size",
   "concat",
@@ -38820,8 +38715,8 @@ var dependencies248 = [
   "Index"
 ];
 var createSetUnion = /* @__PURE__ */ factory(
-  name248,
-  dependencies248,
+  name247,
+  dependencies247,
   ({
     typed: typed3,
     size: size2,
@@ -38831,7 +38726,7 @@ var createSetUnion = /* @__PURE__ */ factory(
     setSymDifference: setSymDifference3,
     Index: Index2
   }) => {
-    return typed3(name248, {
+    return typed3(name247, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         if (subset2(size2(a1), new Index2(0)) === 0) {
           return flatten2(a2);
@@ -38847,18 +38742,18 @@ var createSetUnion = /* @__PURE__ */ factory(
 );
 // src/algebra/symbolicEqual.ts
-var name249 = "symbolicEqual";
-var dependencies249 = ["parse", "simplify", "typed", "OperatorNode"];
+var name248 = "symbolicEqual";
+var dependencies248 = ["parse", "simplify", "typed", "OperatorNode"];
 var createSymbolicEqual = /* @__PURE__ */ factory(
-  name249,
-  dependencies249,
+  name248,
+  dependencies248,
   ({ parse: _parse2, simplify: simplify2, typed: typed3, OperatorNode }) => {
     function _symbolicEqual(e1, e2, options = {}) {
       const diff2 = new OperatorNode("-", "subtract", [e1, e2]);
       const simplified = simplify2(diff2, [], options);
       return isConstantNode(simplified) && !simplified.value;
     }
-    return typed3(name249, {
+    return typed3(name248, {
       "string, string": (s1, s2) => _symbolicEqual(_parse2(s1), _parse2(s2)),
       "string, string, Object": (s1, s2, options) => _symbolicEqual(_parse2(s1), _parse2(s2), options),
       "Node, Node": _symbolicEqual,
@@ -38868,8 +38763,8 @@ var createSymbolicEqual = /* @__PURE__ */ factory(
 );
 // src/matrix/rotationMatrix.ts
-var name250 = "rotationMatrix";
-var dependencies250 = [
+var name249 = "rotationMatrix";
+var dependencies249 = [
   "typed",
   "config",
   "multiplyScalar",
@@ -38884,8 +38779,8 @@ var dependencies250 = [
   "sin"
 ];
 var createRotationMatrix = /* @__PURE__ */ factory(
-  name250,
-  dependencies250,
+  name249,
+  dependencies249,
   ({
     typed: typed3,
     config,
@@ -38900,7 +38795,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
     cos: cos2,
     sin: sin2
   }) => {
-    return typed3(name250, {
+    return typed3(name249, {
       "": function() {
         return config.matrix === "Matrix" ? matrix2([]) : [];
       },
@@ -39011,13 +38906,13 @@ function isPlainNumberMatrix9(matrix2) {
   }
   return true;
 }
-var name251 = "schur";
-var dependencies251 = ["typed", "matrix"];
+var name250 = "schur";
+var dependencies250 = ["typed", "matrix"];
 var createSchur = /* @__PURE__ */ factory(
-  name251,
-  dependencies251,
+  name250,
+  dependencies250,
   ({ typed: typed3, matrix: matrix2 }) => {
-    return typed3(name251, {
+    return typed3(name250, {
       Array: function(X) {
         const r = _schur(X);
         return {
@@ -39052,17 +38947,17 @@ var createSchur = /* @__PURE__ */ factory(
 );
 // src/matrix/rotate.ts
-var name252 = "rotate";
-var dependencies252 = ["typed", "multiply", "rotationMatrix"];
+var name251 = "rotate";
+var dependencies251 = ["typed", "multiply", "rotationMatrix"];
 var createRotate = /* @__PURE__ */ factory(
-  name252,
-  dependencies252,
+  name251,
+  dependencies251,
   ({
     typed: typed3,
     multiply: multiply2,
     rotationMatrix: rotationMatrix2
   }) => {
-    return typed3(name252, {
+    return typed3(name251, {
       "Array , number | BigNumber | Complex | Unit": function(w, theta) {
         _validateSize(w, 2);
         const matrixRes = multiply2(rotationMatrix2(theta), w);
@@ -39098,8 +38993,8 @@ var createRotate = /* @__PURE__ */ factory(
 );
 // src/algebra/sylvester.ts
-var name253 = "sylvester";
-var dependencies253 = [
+var name252 = "sylvester";
+var dependencies252 = [
   "typed",
   "schur",
   "matrixFromColumns",
@@ -39117,8 +39012,8 @@ var dependencies253 = [
   "abs"
 ];
 var createSylvester = /* @__PURE__ */ factory(
-  name253,
-  dependencies253,
+  name252,
+  dependencies252,
   ({
     typed: typed3,
     schur: schur2,
@@ -39136,7 +39031,7 @@ var createSylvester = /* @__PURE__ */ factory(
     lusolve: lusolve2,
     abs: abs2
   }) => {
-    return typed3(name253, {
+    return typed3(name252, {
       "Matrix, Matrix, Matrix": _sylvester,
       "Array, Matrix, Matrix": function(A, B, C) {
         return _sylvester(matrix2(A), B, C);
@@ -39210,13 +39105,13 @@ var createSylvester = /* @__PURE__ */ factory(
 );
 // src/algebra/lyap.ts
-var name254 = "lyap";
-var dependencies254 = ["typed", "matrix", "sylvester", "multiply", "transpose"];
+var name253 = "lyap";
+var dependencies253 = ["typed", "matrix", "sylvester", "multiply", "transpose"];
 var createLyap = /* @__PURE__ */ factory(
-  name254,
-  dependencies254,
+  name253,
+  dependencies253,
   ({ typed: typed3, matrix: matrix2, sylvester: sylvester2, multiply: multiply2, transpose: transpose3 }) => {
-    return typed3(name254, {
+    return typed3(name253, {
       "Matrix, Matrix": function(A, Q2) {
         return sylvester2(A, transpose3(A), multiply2(-1, Q2));
       },
@@ -39446,11 +39341,11 @@ var createPlanckTemperature = /* @__PURE__ */ unitFactory(
   "1.416785e+32",
   "K"
 );
-function unitFactory(name255, valueStr, unitStr) {
-  const dependencies255 = ["config", "Unit", "BigNumber"];
+function unitFactory(name254, valueStr, unitStr) {
+  const dependencies254 = ["config", "Unit", "BigNumber"];
   return factory(
-    name255,
-    dependencies255,
+    name254,
+    dependencies254,
     ({ config, Unit: Unit2, BigNumber: BigNumber9 }) => {
       const value = config.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
       const unit2 = new Unit2(value, unitStr);
@@ -39459,11 +39354,11 @@ function unitFactory(name255, valueStr, unitStr) {
     }
   );
 }
-function numberFactory(name255, value) {
-  const dependencies255 = ["config", "BigNumber"];
+function numberFactory(name254, value) {
+  const dependencies254 = ["config", "BigNumber"];
   return factory(
-    name255,
-    dependencies255,
+    name254,
+    dependencies254,
     ({ config, BigNumber: BigNumber9 }) => {
       return config.number === "BigNumber" ? new BigNumber9(value) : value;
     }
@@ -39809,7 +39704,7 @@ var or2 = createOr(factoryScope);
 factoryScope.or = or2;
 var xor2 = createXor(factoryScope);
 factoryScope.xor = xor2;
-var expm = createExpm(factoryScope);
+var expm = matrixExpm;
 factoryScope.expm = expm;
 var factory_atan2 = createAtan2(factoryScope);
 factoryScope.atan2 = factory_atan2;
@@ -40316,16 +40211,16 @@ function parser() {
       return evaluate(expr, scope);
     },
     /** Read a retained variable. */
-    get(name255) {
-      return scope[name255];
+    get(name254) {
+      return scope[name254];
     },
     /** Set a retained variable. */
-    set(name255, value) {
-      scope[name255] = value;
+    set(name254, value) {
+      scope[name254] = value;
     },
     /** Remove a retained variable. */
-    remove(name255) {
-      delete scope[name255];
+    remove(name254) {
+      delete scope[name254];
     },
     /** Clear all retained variables. */
     clear() {
@@ -42093,10 +41988,10 @@ var Help = createHelpClass({
   evaluate: helpEvaluate
 });
 function help(search) {
-  const name255 = typeof search === "string" ? search : typeof search === "function" ? search.name : void 0;
-  const doc = typeof name255 === "string" && Object.prototype.hasOwnProperty.call(embeddedDocs, name255) ? embeddedDocs[name255] : void 0;
+  const name254 = typeof search === "string" ? search : typeof search === "function" ? search.name : void 0;
+  const doc = typeof name254 === "string" && Object.prototype.hasOwnProperty.call(embeddedDocs, name254) ? embeddedDocs[name254] : void 0;
   if (!doc) {
-    throw new Error(`No documentation found on "${String(name255 ?? search)}"`);
+    throw new Error(`No documentation found on "${String(name254 ?? search)}"`);
   }
   return new Help(doc);
 }
@@ -42575,8 +42470,9 @@ function realSchur(M) {
   let A = M.map((r) => r.slice());
   let U = identityArr(n);
   let m = n;
+  const normM = Math.max(...M.map((r) => r.reduce((s, v) => s + Math.abs(v), 0)), 1e-300);
   for (let iter = 0; iter < 8e3 && m > 1; iter++) {
-    if (Math.abs(A[m - 1][m - 2]) < 1e-14 * (Math.abs(A[m - 2][m - 2]) + Math.abs(A[m - 1][m - 1]))) {
+    if (Math.abs(A[m - 1][m - 2]) < 1e-14 * (Math.abs(A[m - 2][m - 2]) + Math.abs(A[m - 1][m - 1]) || normM)) {
       A[m - 1][m - 2] = 0;
       m--;
       continue;
@@ -42587,6 +42483,14 @@ function realSchur(M) {
     const d = A[m - 1][m - 1];
     const delta = (a - d) / 2;
     const disc = delta * delta + b * c;
+    if (disc < 0) {
+      if (m === 2) break;
+      if (Math.abs(A[m - 2][m - 3]) < 1e-14 * (Math.abs(A[m - 3][m - 3]) + Math.abs(a) || normM)) {
+        A[m - 2][m - 3] = 0;
+        m -= 2;
+        continue;
+      }
+    }
     const denom = Math.abs(delta) + Math.sqrt(Math.abs(disc));
     const s = disc >= 0 && denom > 1e-300 ? d - (Math.sign(delta) || 1) * (b * c) / denom : d;
     const As = A.map((r, i) => r.map((v, j) => v - (i === j ? s : 0)));