@danielsimonjr/mathts-functions 0.10.0 → 0.11.0

package/dist/index.js

@@ -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 {
@@ -8008,6 +8038,11 @@ function delaunayTriangulation(points) {
   return triangles.filter((t) => !t.some((v) => v >= n)).map((t) => [...t]);
 }
 function voronoiDiagram(points, bounds) {
+  if (!Array.isArray(bounds) || bounds.length !== 4) {
+    throw new TypeError(
+      "voronoiDiagram: bounds must be a [xMin, yMin, xMax, yMax] tuple (the clipping box)"
+    );
+  }
   const n = points.length;
   if (n >= GEOMETRY_WASM_THRESHOLD) {
     const wasm = wasmLoader.getModule();
@@ -8305,7 +8340,11 @@ function convexHull3DJS(points) {
     const horizon = [];
     for (const fi of visible) {
       const fv = hull[fi];
-      const edges = [[fv[0], fv[1]], [fv[1], fv[2]], [fv[2], fv[0]]];
+      const edges = [
+        [fv[0], fv[1]],
+        [fv[1], fv[2]],
+        [fv[2], fv[0]]
+      ];
       for (const [ea, eb] of edges) {
         let shared = false;
         for (const fj of visible) {
@@ -13936,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) {
@@ -15993,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(", ")}.`
     );
   }
 }
@@ -17542,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;
@@ -17580,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) {
@@ -20175,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");
     },
@@ -20234,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`);
       }
     });
   }
@@ -26653,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",
@@ -26801,8 +26705,8 @@ var dependencies156 = [
   "concat"
 ];
 var createCompare = /* @__PURE__ */ factory(
-  name156,
-  dependencies156,
+  name155,
+  dependencies155,
   ({
     typed: typed3,
     config,
@@ -26823,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) {
@@ -26852,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;
       }
@@ -26864,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,
@@ -26877,7 +26781,7 @@ var createCompareText = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name157,
+      name156,
       compareText2,
       matrixAlgorithmSuite({
         elop: compareText2,
@@ -26888,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());
       }
@@ -26927,8 +26831,8 @@ var createDeepEqual = /* @__PURE__ */ factory(
 );
 
 // src/relational/larger.ts
-var name159 = "larger";
-var dependencies159 = [
+var name158 = "larger";
+var dependencies158 = [
   "typed",
   "config",
   "bignumber",
@@ -26938,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 });
@@ -26954,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,
@@ -26981,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);
       }
@@ -26993,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 });
@@ -27009,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,
@@ -27034,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);
       }
@@ -27046,8 +26950,8 @@ var createLargerEqNumber = /* @__PURE__ */ factory(
 );
 
 // src/relational/smaller.ts
-var name161 = "smaller";
-var dependencies161 = [
+var name160 = "smaller";
+var dependencies160 = [
   "typed",
   "config",
   "bignumber",
@@ -27057,8 +26961,8 @@ var dependencies161 = [
   "SparseMatrix"
 ];
 var createSmaller = /* @__PURE__ */ factory(
-  name161,
-  dependencies161,
+  name160,
+  dependencies160,
   ({
     typed: typed3,
     config,
@@ -27081,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,
@@ -27108,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);
       }
@@ -27120,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 });
@@ -27136,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,
@@ -27159,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);
       }
@@ -27171,8 +27075,8 @@ var createSmallerEqNumber = /* @__PURE__ */ factory(
 );
 
 // src/relational/unequal.ts
-var name163 = "unequal";
-var dependencies163 = [
+var name162 = "unequal";
+var dependencies162 = [
   "typed",
   "config",
   "equalScalar",
@@ -27182,8 +27086,8 @@ var dependencies163 = [
   "SparseMatrix"
 ];
 var createUnequal = /* @__PURE__ */ factory(
-  name163,
-  dependencies163,
+  name162,
+  dependencies162,
   ({
     typed: typed3,
     config: _config,
@@ -27202,7 +27106,7 @@ var createUnequal = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name163,
+      name162,
       createUnequalNumber({ typed: typed3, equalScalar: equalScalar3 }),
       matrixAlgorithmSuite({
         elop: _unequal,
@@ -27217,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;
@@ -27241,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 });
@@ -27258,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
@@ -27280,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,
@@ -27292,7 +27196,7 @@ var createTo = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name165,
+      name164,
       {
         "Unit, Unit | string": (x, unit2) => x.to(unit2)
       },
@@ -27302,8 +27206,8 @@ var createTo = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/dotPow.ts
-var name166 = "dotPow";
-var dependencies166 = [
+var name165 = "dotPow";
+var dependencies165 = [
   "typed",
   "equalScalar",
   "matrix",
@@ -27313,8 +27217,8 @@ var dependencies166 = [
   "SparseMatrix"
 ];
 var createDotPow = /* @__PURE__ */ factory(
-  name166,
-  dependencies166,
+  name165,
+  dependencies165,
   ({
     typed: typed3,
     equalScalar: equalScalar3,
@@ -27343,7 +27247,7 @@ var createDotPow = /* @__PURE__ */ factory(
     }
     const powScalar = typed3(powScalarSignatures);
     return typed3(
-      name166,
+      name165,
       matrixAlgorithmSuite({
         elop: powScalar,
         SS: matAlgo07xSSf,
@@ -27356,8 +27260,8 @@ var createDotPow = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/fix.ts
-var name167 = "fix";
-var dependencies167 = [
+var name166 = "fix";
+var dependencies166 = [
   "typed",
   "Complex",
   "matrix",
@@ -27368,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);
       },
@@ -27382,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 });
@@ -27471,8 +27375,8 @@ var createFix = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/invmod.ts
-var name168 = "invmod";
-var dependencies168 = [
+var name167 = "invmod";
+var dependencies167 = [
   "typed",
   "config",
   "BigNumber",
@@ -27484,8 +27388,8 @@ var dependencies168 = [
   "isInteger"
 ];
 var createInvmod = /* @__PURE__ */ factory(
-  name168,
-  dependencies168,
+  name167,
+  dependencies167,
   ({
     typed: typed3,
     config: _config,
@@ -27497,7 +27401,7 @@ var createInvmod = /* @__PURE__ */ factory(
     add: add2,
     isInteger: isInteger3
   }) => {
-    return typed3(name168, {
+    return typed3(name167, {
       "number, number": invmod2,
       "BigNumber, BigNumber": invmod2
     });
@@ -27518,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 });
@@ -27534,7 +27438,7 @@ var createAnd = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name169,
+      name168,
       {
         "number, number": andNumber,
         "Complex, Complex": function(x, y) {
@@ -27599,8 +27503,8 @@ var createAnd = /* @__PURE__ */ factory(
 );
 
 // src/combinatorics/composition.ts
-var name170 = "composition";
-var dependencies170 = [
+var name169 = "composition";
+var dependencies169 = [
   "typed",
   "addScalar",
   "combinations",
@@ -27610,8 +27514,8 @@ var dependencies170 = [
   "larger"
 ];
 var createComposition = /* @__PURE__ */ factory(
-  name170,
-  dependencies170,
+  name169,
+  dependencies169,
   ({
     typed: typed3,
     addScalar: addScalar2,
@@ -27621,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");
@@ -27644,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);
       },
@@ -27743,8 +27647,8 @@ var createPartitionSelect = /* @__PURE__ */ factory(
 );
 
 // src/matrix/pinv.ts
-var name172 = "pinv";
-var dependencies172 = [
+var name171 = "pinv";
+var dependencies171 = [
   "typed",
   "matrix",
   "inv",
@@ -27759,8 +27663,8 @@ var dependencies172 = [
   "Complex"
 ];
 var createPinv = /* @__PURE__ */ factory(
-  name172,
-  dependencies172,
+  name171,
+  dependencies171,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -27775,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) {
@@ -27901,8 +27805,8 @@ function flattenToFloat646(matrix2, rows, cols) {
   }
   return result;
 }
-var name173 = "qr";
-var dependencies173 = [
+var name172 = "qr";
+var dependencies172 = [
   "typed",
   "matrix",
   "zeros",
@@ -27920,8 +27824,8 @@ var dependencies173 = [
   "complex"
 ];
 var createQr = /* @__PURE__ */ factory(
-  name173,
-  dependencies173,
+  name172,
+  dependencies172,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -27939,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);
       },
@@ -28077,8 +27981,8 @@ var createQr = /* @__PURE__ */ factory(
 );
 
 // src/matrix/range.ts
-var name174 = "range";
-var dependencies174 = [
+var name173 = "range";
+var dependencies173 = [
   "typed",
   "config",
   "?matrix",
@@ -28093,8 +27997,8 @@ var dependencies174 = [
   "isPositive"
 ];
 var createRange = /* @__PURE__ */ factory(
-  name174,
-  dependencies174,
+  name173,
+  dependencies173,
   ({
     typed: typed3,
     config,
@@ -28108,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,
@@ -28253,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,
@@ -28288,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) {
@@ -28326,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);
@@ -28485,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));
       }
@@ -28509,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)
@@ -28588,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)
@@ -28658,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 });
@@ -28670,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,
@@ -28714,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",
@@ -28726,8 +28630,8 @@ var dependencies181 = [
   "isPositive"
 ];
 var createHypot = /* @__PURE__ */ factory(
-  name181,
-  dependencies181,
+  name180,
+  dependencies180,
   ({
     typed: typed3,
     abs: abs2,
@@ -28738,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))
@@ -28793,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",
@@ -28805,8 +28709,8 @@ var dependencies182 = [
   "abs"
 ];
 var createDistance = /* @__PURE__ */ factory(
-  name182,
-  dependencies182,
+  name181,
+  dependencies181,
   ({
     typed: typed3,
     addScalar: addScalar2,
@@ -28817,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)) {
@@ -29158,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");
@@ -29185,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;
       },
@@ -29214,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,
@@ -29227,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);
@@ -29278,8 +29182,8 @@ var createSort = /* @__PURE__ */ factory(
 );
 
 // src/combinatorics/stirlingS2.ts
-var name186 = "stirlingS2";
-var dependencies186 = [
+var name185 = "stirlingS2";
+var dependencies185 = [
   "typed",
   "addScalar",
   "subtractScalar",
@@ -29295,8 +29199,8 @@ var dependencies186 = [
   "larger"
 ];
 var createStirlingS2 = /* @__PURE__ */ factory(
-  name186,
-  dependencies186,
+  name185,
+  dependencies185,
   ({
     typed: typed3,
     addScalar: addScalar2,
@@ -29314,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");
@@ -29351,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) {
@@ -29396,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");
@@ -29439,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)) {
@@ -29474,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: "+",
@@ -29527,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;
@@ -29540,7 +29444,7 @@ var createLeafCount = /* @__PURE__ */ factory(
       });
       return count2 || 1;
     }
-    return typed3(name191, {
+    return typed3(name190, {
       Node: function(expr) {
         return countLeaves(expr);
       }
@@ -29629,8 +29533,8 @@ function createMap2(mapOrObject) {
 }
 
 // src/algebra/resolve.ts
-var name192 = "resolve";
-var dependencies192 = [
+var name191 = "resolve";
+var dependencies191 = [
   "typed",
   "parse",
   "ConstantNode",
@@ -29639,8 +29543,8 @@ var dependencies192 = [
   "ParenthesisNode"
 ];
 var createResolve = /* @__PURE__ */ factory(
-  name192,
-  dependencies192,
+  name191,
+  dependencies191,
   ({
     typed: typed3,
     parse: parse3,
@@ -29719,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,
@@ -29758,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)) {
@@ -29784,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];
         }
@@ -29907,8 +29811,8 @@ var createUtil = /* @__PURE__ */ factory(
 );
 
 // src/algebra/simplifyConstant.ts
-var name194 = "simplifyConstant";
-var dependencies194 = [
+var name193 = "simplifyConstant";
+var dependencies193 = [
   "typed",
   "config",
   "mathWithTransform",
@@ -29927,8 +29831,8 @@ var dependencies194 = [
   "SymbolNode"
 ];
 var createSimplifyConstant = /* @__PURE__ */ factory(
-  name194,
-  dependencies194,
+  name193,
+  dependencies193,
   ({
     typed: typed3,
     config,
@@ -30317,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);
       }
@@ -30360,8 +30264,8 @@ function interleavedToComplex(data, n, complex2) {
   }
   return result;
 }
-var name196 = "fft";
-var dependencies196 = [
+var name195 = "fft";
+var dependencies195 = [
   "typed",
   "matrix",
   "addScalar",
@@ -30378,8 +30282,8 @@ var dependencies196 = [
   "complex"
 ];
 var createFft = /* @__PURE__ */ factory(
-  name196,
-  dependencies196,
+  name195,
+  dependencies195,
   ({
     typed: typed3,
     matrix: _matrix,
@@ -30396,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);
@@ -30517,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)) {
@@ -30553,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);
@@ -30598,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]);
           }
         }
       }
@@ -30617,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);
         }
       });
     }
@@ -30629,8 +30533,8 @@ var createChainClass = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/subtract.ts
-var name198 = "subtract";
-var dependencies198 = [
+var name197 = "subtract";
+var dependencies197 = [
   "typed",
   "matrix",
   "equalScalar",
@@ -30641,8 +30545,8 @@ var dependencies198 = [
   "nodeOperations"
 ];
 var createSubtract = /* @__PURE__ */ factory(
-  name198,
-  dependencies198,
+  name197,
+  dependencies197,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -30664,7 +30568,7 @@ var createSubtract = /* @__PURE__ */ factory(
       concat: concat3
     });
     return typed3(
-      name198,
+      name197,
       {
         // =========================================================================
         // NODE SIGNATURES - Must be FIRST (before 'any, any')
@@ -30699,8 +30603,8 @@ var createSubtract = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/divide.ts
-var name199 = "divide";
-var dependencies199 = [
+var name198 = "divide";
+var dependencies198 = [
   "typed",
   "matrix",
   "multiply",
@@ -30710,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 });
@@ -30806,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);
@@ -30847,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++) {
@@ -31127,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();
       },
@@ -31148,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);
@@ -31164,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, {});
       }
     });
@@ -31186,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();
       },
@@ -31219,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 {
@@ -31456,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 {
       /**
@@ -31691,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();
@@ -31717,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();
@@ -31743,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()));
       },
@@ -31792,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()));
@@ -31881,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",
@@ -31896,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;
@@ -31973,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) {
@@ -32030,8 +31934,8 @@ function flattenToFloat647(matrix2, rows, cols) {
   }
   return result;
 }
-var name212 = "lup";
-var dependencies212 = [
+var name211 = "lup";
+var dependencies211 = [
   "typed",
   "matrix",
   "abs",
@@ -32047,8 +31951,8 @@ var dependencies212 = [
   "Spa"
 ];
 var createLup = /* @__PURE__ */ factory(
-  name212,
-  dependencies212,
+  name211,
+  dependencies211,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -32064,7 +31968,7 @@ var createLup = /* @__PURE__ */ factory(
     SparseMatrix,
     Spa
   }) => {
-    return typed3(name212, {
+    return typed3(name211, {
       DenseMatrix: function(m) {
         return _denseLUP(m);
       },
@@ -32425,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;
@@ -32470,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",
@@ -32481,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) {
@@ -32584,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",
@@ -32598,8 +32502,8 @@ var dependencies215 = [
   "SparseMatrix"
 ];
 var createSlu = /* @__PURE__ */ factory(
-  name215,
-  dependencies215,
+  name214,
+  dependencies214,
   ({
     typed: typed3,
     abs: abs2,
@@ -32626,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(
@@ -32684,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",
@@ -32698,8 +32602,8 @@ var dependencies216 = [
   "SparseMatrix"
 ];
 var createCsChol = /* @__PURE__ */ factory(
-  name216,
-  dependencies216,
+  name215,
+  dependencies215,
   ({
     divideScalar: divideScalar2,
     sqrt: sqrt2,
@@ -32796,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";
@@ -32892,8 +32796,8 @@ var createSpaClass = /* @__PURE__ */ factory(
 );
 
 // src/geometry/intersect.ts
-var name218 = "intersect";
-var dependencies218 = [
+var name217 = "intersect";
+var dependencies217 = [
   "typed",
   "config",
   "abs",
@@ -32911,8 +32815,8 @@ var dependencies218 = [
   "isNumeric"
 ];
 var createIntersect = /* @__PURE__ */ factory(
-  name218,
-  dependencies218,
+  name217,
+  dependencies217,
   ({
     typed: typed3,
     config,
@@ -33168,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)
@@ -33233,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 {
@@ -33274,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)
@@ -33303,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,
@@ -33317,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);
@@ -33409,8 +33313,8 @@ var createVariance = /* @__PURE__ */ factory(
 );
 
 // src/statistics/quantileSeq.ts
-var name222 = "quantileSeq";
-var dependencies222 = [
+var name221 = "quantileSeq";
+var dependencies221 = [
   "typed",
   "?bignumber",
   "add",
@@ -33426,8 +33330,8 @@ var dependencies222 = [
   "mapSlices"
 ];
 var createQuantileSeq = /* @__PURE__ */ factory(
-  name222,
-  dependencies222,
+  name221,
+  dependencies221,
   ({
     typed: typed3,
     bignumber: bignumber2,
@@ -33443,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,
@@ -33529,8 +33433,8 @@ var createQuantileSeq = /* @__PURE__ */ factory(
 );
 
 // src/probability/kldivergence.ts
-var name223 = "kldivergence";
-var dependencies223 = [
+var name222 = "kldivergence";
+var dependencies222 = [
   "typed",
   "matrix",
   "divide",
@@ -33542,8 +33446,8 @@ var dependencies223 = [
   "isNumeric"
 ];
 var createKldivergence = /* @__PURE__ */ factory(
-  name223,
-  dependencies223,
+  name222,
+  dependencies222,
   ({
     typed: typed3,
     matrix: matrix2,
@@ -33555,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));
       },
@@ -33607,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;
@@ -33632,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);
@@ -33762,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) {
@@ -33791,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) {
@@ -33832,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) {
@@ -33863,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) {
@@ -33897,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;
@@ -33932,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;
@@ -33957,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 [];
@@ -34274,8 +34178,8 @@ function getOperator(fn) {
 }
 
 // src/algebra/simplifyCore.ts
-var name233 = "simplifyCore";
-var dependencies233 = [
+var name232 = "simplifyCore";
+var dependencies232 = [
   "typed",
   "parse",
   "equal",
@@ -34296,8 +34200,8 @@ var dependencies233 = [
   "SymbolNode"
 ];
 var createSimplifyCore = /* @__PURE__ */ factory(
-  name233,
-  dependencies233,
+  name232,
+  dependencies232,
   ({
     typed: typed3,
     parse: _parse2,
@@ -34526,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",
@@ -34548,8 +34452,8 @@ var dependencies234 = [
   "re"
 ];
 var createPolynomialRoot = /* @__PURE__ */ factory(
-  name234,
-  dependencies234,
+  name233,
+  dependencies233,
   ({
     typed: typed3,
     isZero: isZero2,
@@ -34565,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])) {
@@ -34653,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",
@@ -34672,8 +34576,8 @@ var dependencies235 = [
   "unaryMinus"
 ];
 var createSolveODE = /* @__PURE__ */ factory(
-  name235,
-  dependencies235,
+  name234,
+  dependencies234,
   ({
     typed: typed3,
     add: add2,
@@ -35002,8 +34906,8 @@ var createSolveODE = /* @__PURE__ */ factory(
 );
 
 // src/special/zeta.ts
-var name236 = "zeta";
-var dependencies236 = [
+var name235 = "zeta";
+var dependencies235 = [
   "typed",
   "config",
   "multiply",
@@ -35023,8 +34927,8 @@ var dependencies236 = [
   "pi"
 ];
 var createZeta = /* @__PURE__ */ factory(
-  name236,
-  dependencies236,
+  name235,
+  dependencies235,
   ({
     typed: typed3,
     config,
@@ -35051,7 +34955,7 @@ var createZeta = /* @__PURE__ */ factory(
         () => 20
       );
     }
-    return typed3(name236, {
+    return typed3(name235, {
       number: zetaNumber,
       BigNumber: (s) => zetaNumeric(
         s,
@@ -35128,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)) {
@@ -35983,8 +35887,8 @@ function createRealSymmetric({
 }
 
 // src/matrix/eigs.ts
-var name238 = "eigs";
-var dependencies238 = [
+var name237 = "eigs";
+var dependencies237 = [
   "config",
   "typed",
   "matrix",
@@ -36020,8 +35924,8 @@ var dependencies238 = [
   "dot"
 ];
 var createEigs = /* @__PURE__ */ factory(
-  name238,
-  dependencies238,
+  name237,
+  dependencies237,
   ({
     config,
     typed: typed3,
@@ -36308,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;
@@ -36469,8 +36373,8 @@ function isPlainNumberArray(arr7) {
   }
   return true;
 }
-var name240 = "corr";
-var dependencies240 = [
+var name239 = "corr";
+var dependencies239 = [
   "typed",
   "matrix",
   "mean",
@@ -36483,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);
       },
@@ -36566,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, ...)
@@ -36626,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)
@@ -36690,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);
@@ -36729,8 +36633,8 @@ function isConstantExpression(x) {
 }
 
 // src/algebra/simplify.ts
-var name244 = "simplify";
-var dependencies244 = [
+var name243 = "simplify";
+var dependencies243 = [
   "typed",
   "parse",
   "equal",
@@ -36749,8 +36653,8 @@ var dependencies244 = [
   "replacer"
 ];
 var createSimplify = /* @__PURE__ */ factory(
-  name244,
-  dependencies244,
+  name243,
+  dependencies243,
   ({
     typed: typed3,
     parse: parse3,
@@ -37565,8 +37469,8 @@ var createSimplify = /* @__PURE__ */ factory(
 );
 
 // src/algebra/derivative.ts
-var name245 = "derivative";
-var dependencies245 = [
+var name244 = "derivative";
+var dependencies244 = [
   "typed",
   "config",
   "parse",
@@ -37581,8 +37485,8 @@ var dependencies245 = [
   "SymbolNode"
 ];
 var createDerivative = /* @__PURE__ */ factory(
-  name245,
-  dependencies245,
+  name244,
+  dependencies244,
   ({
     typed: typed3,
     config,
@@ -37621,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)),
@@ -38122,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",
@@ -38139,8 +38043,8 @@ var dependencies246 = [
   "eigs"
 ];
 var createNorm = /* @__PURE__ */ factory(
-  name246,
-  dependencies246,
+  name245,
+  dependencies245,
   ({
     typed: typed3,
     abs: abs2,
@@ -38156,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();
@@ -38334,8 +38238,8 @@ var createNorm = /* @__PURE__ */ factory(
 );
 
 // src/algebra/rationalize.ts
-var name247 = "rationalize";
-var dependencies247 = [
+var name246 = "rationalize";
+var dependencies246 = [
   "config",
   "typed",
   "equal",
@@ -38364,8 +38268,8 @@ var dependencies247 = [
   "ParenthesisNode"
 ];
 var createRationalize = /* @__PURE__ */ factory(
-  name247,
-  dependencies247,
+  name246,
+  dependencies246,
   ({
     config: _config,
     typed: typed3,
@@ -38454,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,
@@ -38492,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);
@@ -38800,8 +38704,8 @@ var createRationalize = /* @__PURE__ */ factory(
 );
 
 // src/set/setUnion.ts
-var name248 = "setUnion";
-var dependencies248 = [
+var name247 = "setUnion";
+var dependencies247 = [
   "typed",
   "size",
   "concat",
@@ -38811,8 +38715,8 @@ var dependencies248 = [
   "Index"
 ];
 var createSetUnion = /* @__PURE__ */ factory(
-  name248,
-  dependencies248,
+  name247,
+  dependencies247,
   ({
     typed: typed3,
     size: size2,
@@ -38822,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);
@@ -38838,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,
@@ -38859,8 +38763,8 @@ var createSymbolicEqual = /* @__PURE__ */ factory(
 );
 
 // src/matrix/rotationMatrix.ts
-var name250 = "rotationMatrix";
-var dependencies250 = [
+var name249 = "rotationMatrix";
+var dependencies249 = [
   "typed",
   "config",
   "multiplyScalar",
@@ -38875,8 +38779,8 @@ var dependencies250 = [
   "sin"
 ];
 var createRotationMatrix = /* @__PURE__ */ factory(
-  name250,
-  dependencies250,
+  name249,
+  dependencies249,
   ({
     typed: typed3,
     config,
@@ -38891,7 +38795,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
     cos: cos2,
     sin: sin2
   }) => {
-    return typed3(name250, {
+    return typed3(name249, {
       "": function() {
         return config.matrix === "Matrix" ? matrix2([]) : [];
       },
@@ -39002,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 {
@@ -39043,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);
@@ -39089,8 +38993,8 @@ var createRotate = /* @__PURE__ */ factory(
 );
 
 // src/algebra/sylvester.ts
-var name253 = "sylvester";
-var dependencies253 = [
+var name252 = "sylvester";
+var dependencies252 = [
   "typed",
   "schur",
   "matrixFromColumns",
@@ -39108,8 +39012,8 @@ var dependencies253 = [
   "abs"
 ];
 var createSylvester = /* @__PURE__ */ factory(
-  name253,
-  dependencies253,
+  name252,
+  dependencies252,
   ({
     typed: typed3,
     schur: schur2,
@@ -39127,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);
@@ -39201,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));
       },
@@ -39437,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);
@@ -39450,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;
     }
@@ -39800,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;
@@ -40307,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() {
@@ -42084,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);
 }
@@ -43063,6 +42967,12 @@ function kmeans(data, k, opts = {}) {
   return { labels, centroids, inertia, iterations, converged };
 }
 function spectralClustering(adjacency, k, opts = {}) {
+  const n0 = adjacency.length;
+  if (n0 === 0 || adjacency.some((row2) => row2.length !== n0)) {
+    throw new Error(
+      `spectralClustering: adjacency must be a square n\xD7n matrix (got ${n0}\xD7${adjacency[0]?.length ?? 0})`
+    );
+  }
   const L = laplacianMatrix(adjacency, { normalized: true });
   const { eigenvectors } = _eigs2(L);
   const n = adjacency.length;