@danielsimonjr/mathts-functions 0.57.0 → 0.59.0

package/dist/index.js

@@ -101,7 +101,7 @@ __export(typed_exports, {
   cholesky: () => cholesky,
   coefficientList: () => coefficientList,
   collect: () => collect,
-  combinations: () => combinations,
+  combinations: () => combinations2,
   combinationsWithRep: () => combinationsWithRep,
   combine: () => combine,
   compare: () => compare,
@@ -131,7 +131,7 @@ __export(typed_exports, {
   dagostinoTest: () => dagostinoTest,
   dct: () => dct,
   deepEqual: () => deepEqual,
-  degree: () => degree,
+  degree: () => degree2,
   delaunayTriangulation: () => delaunayTriangulation,
   differences: () => differences,
   digamma: () => digamma,
@@ -454,7 +454,7 @@ __export(typed_exports, {
   studentTTest: () => studentTTest,
   studentTTestPaired: () => studentTTestPaired,
   subfactorial: () => subfactorial,
-  substitute: () => substitute,
+  substitute: () => substitute2,
   subtract: () => subtract,
   sum: () => sum,
   symbolicPartialDerivative: () => symbolicPartialDerivative,
@@ -3341,8 +3341,8 @@ function resetGpuFft() {
   resources = null;
 }
 function stageUniformsFor(res, n, inverse) {
-  const key = `${n}:${inverse ? 1 : 0}`;
-  const cached = res.stageUniforms.get(key);
+  const key2 = `${n}:${inverse ? 1 : 0}`;
+  const cached = res.stageUniforms.get(key2);
   if (cached) return cached;
   const stages = Math.log2(n);
   const bufs = [];
@@ -3355,7 +3355,7 @@ function stageUniformsFor(res, n, inverse) {
     res.device.queue.writeBuffer(u, 0, new Uint32Array([n, ns, inverse ? 1 : 0, 0]));
     bufs.push(u);
   }
-  res.stageUniforms.set(key, bufs);
+  res.stageUniforms.set(key2, bufs);
   return bufs;
 }
 var isPowerOf2 = (n) => n > 0 && (n & n - 1) === 0;
@@ -8957,14 +8957,14 @@ function voronoiDiagram(points, bounds) {
     const uy = ((a[0] * a[0] + a[1] * a[1]) * (c[0] - b[0]) + (b[0] * b[0] + b[1] * b[1]) * (a[0] - c[0]) + (c[0] * c[0] + c[1] * c[1]) * (b[0] - a[0])) / D;
     const cx = Math.max(bounds[0], Math.min(bounds[2], ux));
     const cy = Math.max(bounds[1], Math.min(bounds[3], uy));
-    const key = tri.slice().sort().join(",");
-    triCircumcenters.set(key, vertices.length);
+    const key2 = tri.slice().sort().join(",");
+    triCircumcenters.set(key2, vertices.length);
     vertices.push([cx, cy]);
   }
   const regions = Array.from({ length: points.length }, () => []);
   for (const tri of triangles) {
-    const key = tri.slice().sort().join(",");
-    const vIdx = triCircumcenters.get(key);
+    const key2 = tri.slice().sort().join(",");
+    const vIdx = triCircumcenters.get(key2);
     if (vIdx !== void 0) {
       for (const pIdx of tri) {
         if (!regions[pIdx].includes(vIdx)) {
@@ -9444,9 +9444,9 @@ function discriminantDispatch(p) {
   return discriminantJS(p);
 }
 var WASM_POLY_FIT_THRESHOLD = 1024;
-function polyFitJS(xs, ys, degree2, buildRow) {
+function polyFitJS(xs, ys, degree3, buildRow) {
   const n = xs.length;
-  const k = degree2 + 1;
+  const k = degree3 + 1;
   if (n < k) return null;
   const A = [];
   for (let i = 0; i < n; i++) {
@@ -9523,22 +9523,22 @@ function legendreBasisRow(x, k) {
   }
   return row2;
 }
-function polyFitJSFallback(xs, ys, degree2) {
-  const result = polyFitJS(xs, ys, degree2, powerBasisRow);
+function polyFitJSFallback(xs, ys, degree3) {
+  const result = polyFitJS(xs, ys, degree3, powerBasisRow);
   if (!result) throw new Error("polyFit: rank-deficient or insufficient data");
   return result;
 }
-function chebFitJSFallback(xs, ys, degree2) {
-  const result = polyFitJS(xs, ys, degree2, chebBasisRow);
+function chebFitJSFallback(xs, ys, degree3) {
+  const result = polyFitJS(xs, ys, degree3, chebBasisRow);
   if (!result) throw new Error("chebyshevFit: rank-deficient or insufficient data");
   return result;
 }
-function legendreFitJSFallback(xs, ys, degree2) {
-  const result = polyFitJS(xs, ys, degree2, legendreBasisRow);
+function legendreFitJSFallback(xs, ys, degree3) {
+  const result = polyFitJS(xs, ys, degree3, legendreBasisRow);
   if (!result) throw new Error("legendreFit: rank-deficient or insufficient data");
   return result;
 }
-function fitDispatch(xs, ys, degree2, asName, jsFallback) {
+function fitDispatch(xs, ys, degree3, asName, jsFallback) {
   if (xs.length !== ys.length) throw new Error("xs and ys must have the same length");
   if (xs.length >= WASM_POLY_FIT_THRESHOLD) {
     const wasm = getWasm();
@@ -9549,26 +9549,26 @@ function fitDispatch(xs, ys, degree2, asName, jsFallback) {
           [xs, ys],
           (mod3, [hx, hy]) => asReadReturnedF64(
             mod3,
-            mod3[asName](hx, hy, degree2)
+            mod3[asName](hx, hy, degree3)
           )
         );
-        if (out && out.length === degree2 + 1 && out.every((v) => Number.isFinite(v))) {
+        if (out && out.length === degree3 + 1 && out.every((v) => Number.isFinite(v))) {
           return out;
         }
       } catch {
       }
     }
   }
-  return jsFallback(xs, ys, degree2);
+  return jsFallback(xs, ys, degree3);
 }
-function polyFitDispatch(xs, ys, degree2) {
-  return fitDispatch(xs, ys, degree2, "poly_fit_f64", polyFitJSFallback);
+function polyFitDispatch(xs, ys, degree3) {
+  return fitDispatch(xs, ys, degree3, "poly_fit_f64", polyFitJSFallback);
 }
-function chebFitDispatch(xs, ys, degree2) {
-  return fitDispatch(xs, ys, degree2, "cheb_fit_f64", chebFitJSFallback);
+function chebFitDispatch(xs, ys, degree3) {
+  return fitDispatch(xs, ys, degree3, "cheb_fit_f64", chebFitJSFallback);
 }
-function legendreFitDispatch(xs, ys, degree2) {
-  return fitDispatch(xs, ys, degree2, "legendre_fit_f64", legendreFitJSFallback);
+function legendreFitDispatch(xs, ys, degree3) {
+  return fitDispatch(xs, ys, degree3, "legendre_fit_f64", legendreFitJSFallback);
 }
 
 // src/typed/polynomial-ideal.ts
@@ -9582,10 +9582,10 @@ function cmpPowers(a, b) {
 function normalize(p) {
   const byKey = /* @__PURE__ */ new Map();
   for (const t of p) {
-    const key = t.powers.join(",");
-    const existing = byKey.get(key);
+    const key2 = t.powers.join(",");
+    const existing = byKey.get(key2);
     if (existing) existing.coeff += t.coeff;
-    else byKey.set(key, { coeff: t.coeff, powers: [...t.powers] });
+    else byKey.set(key2, { coeff: t.coeff, powers: [...t.powers] });
   }
   return [...byKey.values()].filter((t) => Math.abs(t.coeff) > EPS).sort((a, b) => cmpPowers(b.powers, a.powers));
 }
@@ -9824,6 +9824,1295 @@ function polyToString(p, vars) {
   return terms.join(" + ").replace(/\+ -/g, "- ");
 }
 
+// src/typed/factorization/integer-poly.ts
+function trim(p) {
+  let n = p.length;
+  while (n > 0 && p[n - 1] === 0n) {
+    n -= 1;
+  }
+  return p.slice(0, n);
+}
+function degree(p) {
+  const t = trim(p);
+  return t.length - 1;
+}
+function lc(p) {
+  const t = trim(p);
+  return t.length === 0 ? 0n : t[t.length - 1];
+}
+function isZero(p) {
+  return trim(p).length === 0;
+}
+function add2(a, b) {
+  const n = Math.max(a.length, b.length);
+  const out = new Array(n);
+  for (let i = 0; i < n; i += 1) {
+    const av = i < a.length ? a[i] : 0n;
+    const bv = i < b.length ? b[i] : 0n;
+    out[i] = av + bv;
+  }
+  return trim(out);
+}
+function sub(a, b) {
+  const n = Math.max(a.length, b.length);
+  const out = new Array(n);
+  for (let i = 0; i < n; i += 1) {
+    const av = i < a.length ? a[i] : 0n;
+    const bv = i < b.length ? b[i] : 0n;
+    out[i] = av - bv;
+  }
+  return trim(out);
+}
+function neg(a) {
+  return a.map((c) => -c);
+}
+function mul(a, b) {
+  const ta = trim(a);
+  const tb = trim(b);
+  if (ta.length === 0 || tb.length === 0) {
+    return [];
+  }
+  const out = new Array(ta.length + tb.length - 1).fill(0n);
+  for (let i = 0; i < ta.length; i += 1) {
+    const ai = ta[i];
+    if (ai === 0n) continue;
+    for (let j = 0; j < tb.length; j += 1) {
+      out[i + j] += ai * tb[j];
+    }
+  }
+  return trim(out);
+}
+function scalarMul(p, k) {
+  return trim(p.map((c) => c * k));
+}
+function bigintGcd(a, b) {
+  let x = a < 0n ? -a : a;
+  let y = b < 0n ? -b : b;
+  while (y !== 0n) {
+    const t = x % y;
+    x = y;
+    y = t;
+  }
+  return x;
+}
+function content(p) {
+  const t = trim(p);
+  let g = 0n;
+  for (const c of t) {
+    g = bigintGcd(g, c);
+  }
+  return g;
+}
+function primitivePart(p) {
+  const t = trim(p);
+  if (t.length === 0) {
+    return [];
+  }
+  const g = content(t);
+  const divided = g === 0n ? t.slice() : t.map((c) => c / g);
+  const reduced = trim(divided);
+  if (reduced.length === 0) {
+    return reduced;
+  }
+  return lc(reduced) < 0n ? neg(reduced) : reduced;
+}
+function exactDivide(a, b) {
+  const tb = trim(b);
+  if (tb.length === 0) {
+    return null;
+  }
+  let rem = trim(a);
+  if (rem.length === 0) {
+    return [];
+  }
+  const db = tb.length - 1;
+  const lb = tb[db];
+  const dq = rem.length - 1 - db;
+  if (dq < 0) {
+    return null;
+  }
+  const q = new Array(dq + 1).fill(0n);
+  while (!isZero(rem) && degree(rem) >= db) {
+    const dr = degree(rem);
+    const lrRaw = rem[dr];
+    if (lrRaw % lb !== 0n) {
+      return null;
+    }
+    const coeff = lrRaw / lb;
+    const shift = dr - db;
+    q[shift] = coeff;
+    for (let i = 0; i <= db; i += 1) {
+      rem[shift + i] -= coeff * tb[i];
+    }
+    rem = trim(rem);
+  }
+  if (!isZero(rem)) {
+    return null;
+  }
+  return trim(q);
+}
+function derivative(p) {
+  const t = trim(p);
+  if (t.length <= 1) {
+    return [];
+  }
+  const out = new Array(t.length - 1);
+  for (let i = 1; i < t.length; i += 1) {
+    out[i - 1] = t[i] * BigInt(i);
+  }
+  return trim(out);
+}
+function pseudoRemainder(a, b) {
+  const db = degree(b);
+  const lb = lc(b);
+  let rem = trim(a);
+  while (!isZero(rem) && degree(rem) >= db) {
+    const dr = degree(rem);
+    const lr = rem[dr];
+    const shift = dr - db;
+    const scaled = rem.map((c) => c * lb);
+    for (let i = 0; i <= db; i += 1) {
+      scaled[shift + i] -= lr * b[i];
+    }
+    rem = trim(scaled);
+  }
+  return rem;
+}
+function polyGcdZ(a, b) {
+  let x = primitivePart(a);
+  let y = primitivePart(b);
+  if (isZero(x)) {
+    return y;
+  }
+  if (isZero(y)) {
+    return x;
+  }
+  if (degree(x) < degree(y)) {
+    [x, y] = [y, x];
+  }
+  while (!isZero(y)) {
+    const r = pseudoRemainder(x, y);
+    x = y;
+    y = primitivePart(r);
+  }
+  return x;
+}
+function isqrt(n) {
+  if (n < 0n) {
+    throw new RangeError("isqrt: negative input");
+  }
+  if (n < 2n) {
+    return n;
+  }
+  let x0 = n;
+  let x1 = (x0 + 1n) / 2n;
+  while (x1 < x0) {
+    x0 = x1;
+    x1 = (x0 + n / x0) / 2n;
+  }
+  return x0;
+}
+function landauMignotte(p) {
+  const t = trim(p);
+  const d = t.length - 1;
+  if (d < 0) {
+    return 1n;
+  }
+  const n = BigInt(d + 1);
+  const lcAbs = t[d] < 0n ? -t[d] : t[d];
+  const powerOfTwo = 1n << BigInt(d);
+  const sq = isqrt(n);
+  const sqrtCeil = sq * sq === n ? sq : sq + 1n;
+  const bound = sqrtCeil * powerOfTwo * (lcAbs === 0n ? 1n : lcAbs);
+  return bound > 0n ? bound : 1n;
+}
+function modSymmetric(p, m) {
+  const half = m / 2n;
+  return p.map((c) => {
+    let r = c % m;
+    if (r < 0n) {
+      r += m;
+    }
+    if (r > half) {
+      r -= m;
+    }
+    return r;
+  });
+}
+
+// src/typed/factorization/finite-field.ts
+function modP(a, p) {
+  const r = a % p;
+  return r < 0n ? r + p : r;
+}
+function reduceModP(a, p) {
+  return trim(a.map((c) => modP(c, p)));
+}
+function addP(a, b, p) {
+  const n = Math.max(a.length, b.length);
+  const out = new Array(n);
+  for (let i = 0; i < n; i += 1) {
+    const av = i < a.length ? a[i] : 0n;
+    const bv = i < b.length ? b[i] : 0n;
+    out[i] = modP(av + bv, p);
+  }
+  return trim(out);
+}
+function subP(a, b, p) {
+  const n = Math.max(a.length, b.length);
+  const out = new Array(n);
+  for (let i = 0; i < n; i += 1) {
+    const av = i < a.length ? a[i] : 0n;
+    const bv = i < b.length ? b[i] : 0n;
+    out[i] = modP(av - bv, p);
+  }
+  return trim(out);
+}
+function mulP(a, b, p) {
+  const ta = trim(a);
+  const tb = trim(b);
+  if (ta.length === 0 || tb.length === 0) {
+    return [];
+  }
+  const out = new Array(ta.length + tb.length - 1).fill(0n);
+  for (let i = 0; i < ta.length; i += 1) {
+    const ai = ta[i];
+    if (ai === 0n) continue;
+    for (let j = 0; j < tb.length; j += 1) {
+      out[i + j] = modP(out[i + j] + ai * tb[j], p);
+    }
+  }
+  return trim(out);
+}
+function invModP(a, p) {
+  const ar = modP(a, p);
+  if (ar === 0n) {
+    throw new RangeError("invModP: 0 has no modular inverse");
+  }
+  let oldR = ar;
+  let r = p;
+  let oldS = 1n;
+  let s = 0n;
+  while (r !== 0n) {
+    const q = oldR / r;
+    [oldR, r] = [r, oldR - q * r];
+    [oldS, s] = [s, oldS - q * s];
+  }
+  return modP(oldS, p);
+}
+function makeMonicP(a, p) {
+  const t = reduceModP(a, p);
+  if (isZero(t)) {
+    return [];
+  }
+  const inv3 = invModP(lc(t), p);
+  return trim(t.map((c) => modP(c * inv3, p)));
+}
+function divmodP(a, b, p) {
+  const tb = reduceModP(b, p);
+  if (isZero(tb)) {
+    throw new RangeError("divmodP: division by the zero polynomial");
+  }
+  const db = degree(tb);
+  const invLb = invModP(lc(tb), p);
+  let rem = reduceModP(a, p);
+  const dq = degree(rem) - db;
+  const q = dq >= 0 ? new Array(dq + 1).fill(0n) : [];
+  while (!isZero(rem) && degree(rem) >= db) {
+    const dr = degree(rem);
+    const shift = dr - db;
+    const coeff = modP(rem[dr] * invLb, p);
+    q[shift] = coeff;
+    for (let i = 0; i <= db; i += 1) {
+      rem[shift + i] = modP(rem[shift + i] - coeff * tb[i], p);
+    }
+    rem = trim(rem);
+  }
+  return { q: trim(q), r: rem };
+}
+function gcdP(a, b, p) {
+  let x = reduceModP(a, p);
+  let y = reduceModP(b, p);
+  if (isZero(x)) {
+    return makeMonicP(y, p);
+  }
+  if (isZero(y)) {
+    return makeMonicP(x, p);
+  }
+  while (!isZero(y)) {
+    const { r } = divmodP(x, y, p);
+    x = y;
+    y = r;
+  }
+  return makeMonicP(x, p);
+}
+function powModPolyP(base, e, mod3, p) {
+  if (e < 0n) {
+    throw new RangeError("powModPolyP: negative exponent not supported");
+  }
+  let result = [1n];
+  let b = divmodP(base, mod3, p).r;
+  let exp2 = e;
+  while (exp2 > 0n) {
+    if (exp2 & 1n) {
+      result = divmodP(mulP(result, b, p), mod3, p).r;
+    }
+    b = divmodP(mulP(b, b, p), mod3, p).r;
+    exp2 >>= 1n;
+  }
+  return reduceModP(result, p);
+}
+var X_POLY = [0n, 1n];
+function distinctDegreeFactor(f, p) {
+  const result = [];
+  let v = makeMonicP(f, p);
+  if (degree(v) <= 0) {
+    return result;
+  }
+  let w = divmodP(X_POLY, v, p).r;
+  let i = 1;
+  while (degree(v) >= 2 * i) {
+    w = powModPolyP(w, p, v, p);
+    const g = gcdP(v, subP(w, X_POLY, p), p);
+    if (degree(g) > 0) {
+      result.push({ deg: i, prod: g });
+      v = divmodP(v, g, p).q;
+      w = divmodP(w, v, p).r;
+    }
+    i += 1;
+  }
+  if (degree(v) > 0) {
+    result.push({ deg: degree(v), prod: v });
+  }
+  return result;
+}
+function* trialPolys(p) {
+  let deg = 1;
+  while (true) {
+    const count2 = p ** BigInt(deg);
+    for (let k = 0n; k < count2; k += 1n) {
+      const poly = new Array(deg + 1);
+      let kk = k;
+      for (let idx = 0; idx < deg; idx += 1) {
+        poly[idx] = kk % p;
+        kk /= p;
+      }
+      poly[deg] = 1n;
+      yield trim(poly);
+    }
+    deg += 1;
+  }
+}
+function edSplit(f, d, p, out) {
+  if (degree(f) === d) {
+    out.push(f);
+    return;
+  }
+  const trials = trialPolys(p);
+  while (true) {
+    const next = trials.next();
+    if (next.done) {
+      return;
+    }
+    const t = next.value;
+    let g;
+    if (p === 2n) {
+      let trace3 = [];
+      let cur = divmodP(t, f, p).r;
+      for (let i = 0; i < d; i += 1) {
+        trace3 = addP(trace3, cur, p);
+        cur = divmodP(mulP(cur, cur, p), f, p).r;
+      }
+      g = gcdP(f, trace3, p);
+    } else {
+      const e = (p ** BigInt(d) - 1n) / 2n;
+      const h = powModPolyP(t, e, f, p);
+      g = gcdP(f, subP(h, [1n], p), p);
+    }
+    const dg = degree(g);
+    if (dg > 0 && dg < degree(f)) {
+      edSplit(g, d, p, out);
+      edSplit(divmodP(f, g, p).q, d, p, out);
+      return;
+    }
+  }
+}
+function equalDegreeFactor(f, d, p) {
+  const out = [];
+  edSplit(makeMonicP(f, p), d, p, out);
+  return out;
+}
+function factorModP(f, p) {
+  const fm = makeMonicP(f, p);
+  const d = degree(fm);
+  if (d <= 0) {
+    return [];
+  }
+  if (d === 1) {
+    return [fm];
+  }
+  const factors = [];
+  for (const { deg, prod: prod2 } of distinctDegreeFactor(fm, p)) {
+    if (degree(prod2) === deg) {
+      factors.push(prod2);
+    } else {
+      for (const g of equalDegreeFactor(prod2, deg, p)) {
+        factors.push(g);
+      }
+    }
+  }
+  return factors;
+}
+
+// src/typed/factorization/hensel.ts
+function reduceIntoRange(poly, m) {
+  const out = poly.map((c) => {
+    const r = c % m;
+    return r < 0n ? r + m : r;
+  });
+  let n = out.length;
+  while (n > 0 && out[n - 1] === 0n) {
+    n -= 1;
+  }
+  return out.slice(0, n);
+}
+function scalarExactDiv(poly, m) {
+  return poly.map((c) => c / m);
+}
+function productModP(polys, p) {
+  let acc = [1n];
+  for (const g of polys) {
+    acc = mulP(acc, g, p);
+  }
+  return acc;
+}
+function bezoutModP(g, h, p) {
+  let oldR = reduceModP(g, p);
+  let r = reduceModP(h, p);
+  let oldS = [1n];
+  let s = [];
+  let oldT = [];
+  let t = [1n];
+  while (!isZero(r)) {
+    const { q } = divmodP(oldR, r, p);
+    const newR = subP(oldR, mulP(q, r, p), p);
+    oldR = r;
+    r = newR;
+    const newS = subP(oldS, mulP(q, s, p), p);
+    oldS = s;
+    s = newS;
+    const newT = subP(oldT, mulP(q, t, p), p);
+    oldT = t;
+    t = newT;
+  }
+  const inv3 = invModP(lc(oldR), p);
+  return {
+    s: mulP(oldS, [inv3], p),
+    t: mulP(oldT, [inv3], p)
+  };
+}
+function diophantineModP(c, g, h, s, t, p) {
+  const { q, r: dg } = divmodP(mulP(t, c, p), g, p);
+  const dh = addP(mulP(s, c, p), mulP(q, h, p), p);
+  return { dg, dh };
+}
+function henselLiftTwo(f, g, h, p, targetPk) {
+  const gBase = reduceModP(g, p);
+  const hBase = reduceModP(h, p);
+  const { s, t } = bezoutModP(gBase, hBase, p);
+  let bigG = gBase;
+  let bigH = hBase;
+  let mod3 = p;
+  while (mod3 < targetPk) {
+    const nextMod = mod3 * p;
+    const e = sub(f, mul(bigG, bigH));
+    const c = reduceModP(scalarExactDiv(e, mod3), p);
+    const { dg, dh } = diophantineModP(c, gBase, hBase, s, t, p);
+    bigG = reduceIntoRange(add2(bigG, scalarMul(dg, mod3)), nextMod);
+    bigH = reduceIntoRange(add2(bigH, scalarMul(dh, mod3)), nextMod);
+    mod3 = nextMod;
+  }
+  return { g: bigG, h: bigH };
+}
+function henselLift(f, factorsModP, p, targetPk) {
+  const n = factorsModP.length;
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [modSymmetric(f, targetPk)];
+  }
+  const mid = n >> 1;
+  const left = factorsModP.slice(0, mid);
+  const right = factorsModP.slice(mid);
+  const gBase = productModP(left, p);
+  const hBase = productModP(right, p);
+  const { g: bigG, h: bigH } = henselLiftTwo(f, gBase, hBase, p, targetPk);
+  const leftLifted = henselLift(bigG, left, p, targetPk);
+  const rightLifted = henselLift(bigH, right, p, targetPk);
+  return [...leftLifted, ...rightLifted];
+}
+
+// src/typed/factorization/square-free.ts
+function squareFreeDecompose(f) {
+  const p = primitivePart(f);
+  const result = [];
+  const fPrime = derivative(p);
+  const g = polyGcdZ(p, fPrime);
+  const b0 = exactDivide(p, g);
+  const c0 = exactDivide(fPrime, g);
+  if (b0 === null || c0 === null) {
+    throw new Error(
+      "squareFreeDecompose: exact division failed against gcd(f, f'); f/g and f'/g must divide evenly"
+    );
+  }
+  let b = b0;
+  let d = sub(c0, derivative(b));
+  let i = 1;
+  while (degree(b) > 0) {
+    const a = polyGcdZ(b, d);
+    if (degree(a) > 0) {
+      result.push({ factor: primitivePart(a), mult: i });
+    }
+    const nextB = exactDivide(b, a);
+    const nextC = exactDivide(d, a);
+    if (nextB === null || nextC === null) {
+      throw new Error("squareFreeDecompose: exact division b/a or d/a failed");
+    }
+    b = nextB;
+    d = sub(nextC, derivative(b));
+    i += 1;
+  }
+  return result;
+}
+
+// src/typed/factorization/zassenhaus.ts
+var MAX_MODULAR_FACTORS = 24;
+var PRIME_CANDIDATE_WINDOW = 5;
+function log3(message) {
+  console.warn(message);
+}
+function isPrime(n) {
+  if (n < 2n) return false;
+  if (n < 4n) return true;
+  if (n % 2n === 0n) return false;
+  for (let i = 3n; i * i <= n; i += 2n) {
+    if (n % i === 0n) return false;
+  }
+  return true;
+}
+function invMod(a, m) {
+  let oldR = (a % m + m) % m;
+  let r = m;
+  let oldS = 1n;
+  let s = 0n;
+  while (r !== 0n) {
+    const q = oldR / r;
+    [oldR, r] = [r, oldR - q * r];
+    [oldS, s] = [s, oldS - q * s];
+  }
+  if (oldR !== 1n) {
+    throw new RangeError("invMod: arguments are not coprime");
+  }
+  return (oldS % m + m) % m;
+}
+function isImageSquareFree(g, p) {
+  const gbar = reduceModP(g, p);
+  const gbarDeriv = reduceModP(derivative(g), p);
+  return degree(gcdP(gbar, gbarDeriv, p)) === 0;
+}
+function selectPrime(g, L) {
+  let best = null;
+  let considered = 0;
+  let candidate = 2n;
+  while (considered < PRIME_CANDIDATE_WINDOW) {
+    while (!isPrime(candidate) || L % candidate === 0n || !isImageSquareFree(g, candidate)) {
+      candidate += 1n;
+    }
+    const gp = makeMonicP(reduceModP(g, candidate), candidate);
+    const modFactors = factorModP(gp, candidate);
+    if (best === null || modFactors.length < best.modFactors.length) {
+      best = { p: candidate, modFactors };
+    }
+    considered += 1;
+    candidate += 1n;
+    if (best.modFactors.length === 1) {
+      break;
+    }
+  }
+  return best;
+}
+function powAtLeast(p, bound) {
+  let pk = p;
+  while (pk < bound) {
+    pk *= p;
+  }
+  return pk;
+}
+function* combinations(n, k) {
+  if (k < 0 || k > n) return;
+  const idx = Array.from({ length: k }, (_, i) => i);
+  while (true) {
+    yield idx.slice();
+    let i = k - 1;
+    while (i >= 0 && idx[i] === n - k + i) {
+      i -= 1;
+    }
+    if (i < 0) return;
+    idx[i] += 1;
+    for (let j = i + 1; j < k; j += 1) {
+      idx[j] = idx[j - 1] + 1;
+    }
+  }
+}
+function subsetCandidate(pool, indices, L, Pk) {
+  let prod2 = [1n];
+  for (const i of indices) {
+    prod2 = mul(prod2, pool[i]);
+  }
+  return primitivePart(modSymmetric(scalarMul(prod2, L), Pk));
+}
+function factorSquareFree(g) {
+  if (degree(g) <= 0) {
+    return [];
+  }
+  if (degree(g) === 1) {
+    return [primitivePart(g)];
+  }
+  const L = lc(g);
+  const { p, modFactors } = selectPrime(g, L);
+  if (modFactors.length === 1) {
+    return [primitivePart(g)];
+  }
+  if (modFactors.length > MAX_MODULAR_FACTORS) {
+    log3(
+      `factorUnivariateZ: ${modFactors.length} modular factors exceeds cap ${MAX_MODULAR_FACTORS}; returning square-free part of degree ${degree(g)} unfactored`
+    );
+    return [primitivePart(g)];
+  }
+  const n = BigInt(degree(g));
+  const Labs = L < 0n ? -L : L;
+  const bound = 2n * n * Labs * landauMignotte(g) + 1n;
+  const Pk = powAtLeast(p, bound);
+  const Linv = invMod((L % Pk + Pk) % Pk, Pk);
+  const gMonic = modSymmetric(scalarMul(g, Linv), Pk);
+  const u = henselLift(gMonic, modFactors, p, Pk);
+  const found = [];
+  let pool = u.slice();
+  let gCur = g;
+  let Lcur = lc(gCur);
+  let size2 = 1;
+  while (2 * size2 <= pool.length) {
+    let matched = null;
+    for (const indices of combinations(pool.length, size2)) {
+      const cand = subsetCandidate(pool, indices, Lcur, Pk);
+      if (degree(cand) < 1) {
+        continue;
+      }
+      if (exactDivide(gCur, cand) !== null) {
+        matched = { cand, indices };
+        break;
+      }
+    }
+    if (matched === null) {
+      size2 += 1;
+      continue;
+    }
+    const quotient = exactDivide(gCur, matched.cand);
+    if (quotient === null) {
+      throw new Error("factorUnivariateZ: recombination divisor stopped dividing");
+    }
+    found.push(primitivePart(matched.cand));
+    gCur = quotient;
+    Lcur = lc(gCur);
+    const drop = new Set(matched.indices);
+    pool = pool.filter((_, i) => !drop.has(i));
+  }
+  if (degree(gCur) > 0) {
+    found.push(primitivePart(gCur));
+  }
+  return found;
+}
+function comparePolys(a, b) {
+  const da = degree(a);
+  const db = degree(b);
+  if (da !== db) {
+    return da - db;
+  }
+  const ta = trim(a);
+  const tb = trim(b);
+  for (let i = 0; i < ta.length; i += 1) {
+    if (ta[i] !== tb[i]) {
+      return ta[i] < tb[i] ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function factorUnivariateZ(f) {
+  const tf = trim(f);
+  if (isZero(tf)) {
+    return { constant: 0n, factors: [] };
+  }
+  if (tf.length === 1) {
+    return { constant: tf[0], factors: [] };
+  }
+  const cont = content(tf);
+  const sign3 = lc(tf) < 0n ? -1n : 1n;
+  const constant = cont * sign3;
+  const prim = primitivePart(tf);
+  if (degree(prim) === 1) {
+    return { constant, factors: [{ poly: prim, mult: 1 }] };
+  }
+  const factors = [];
+  for (const { factor: g, mult } of squareFreeDecompose(prim)) {
+    for (const irreducible of factorSquareFree(g)) {
+      factors.push({ poly: irreducible, mult });
+    }
+  }
+  factors.sort((a, b) => comparePolys(a.poly, b.poly));
+  return { constant, factors };
+}
+
+// src/typed/factorization/multi-poly.ts
+function key(exps) {
+  return exps.join(",");
+}
+function unkey(k) {
+  if (k === "") {
+    return [];
+  }
+  return k.split(",").map((s) => Number(s));
+}
+function fromTerms(vars, entries) {
+  const terms = /* @__PURE__ */ new Map();
+  for (const [exps, coeff] of entries) {
+    if (exps.length !== vars.length) {
+      throw new RangeError("fromTerms: exponent vector length must match vars.length");
+    }
+    const k = key(exps);
+    const prev = terms.get(k) ?? 0n;
+    const next = prev + coeff;
+    if (next === 0n) {
+      terms.delete(k);
+    } else {
+      terms.set(k, next);
+    }
+  }
+  return { vars: vars.slice(), terms };
+}
+function degreeIn(p, varIndex) {
+  let d = -1;
+  for (const k of p.terms.keys()) {
+    const exps = unkey(k);
+    if (exps[varIndex] > d) {
+      d = exps[varIndex];
+    }
+  }
+  return d;
+}
+function totalDegree(p) {
+  let d = -1;
+  for (const k of p.terms.keys()) {
+    const exps = unkey(k);
+    const s = exps.reduce((a, b) => a + b, 0);
+    if (s > d) {
+      d = s;
+    }
+  }
+  return d;
+}
+function isZero2(p) {
+  return p.terms.size === 0;
+}
+function equals(a, b) {
+  if (a.vars.length !== b.vars.length) return false;
+  for (let i = 0; i < a.vars.length; i += 1) {
+    if (a.vars[i] !== b.vars[i]) return false;
+  }
+  if (a.terms.size !== b.terms.size) return false;
+  for (const [k, v] of a.terms) {
+    if (b.terms.get(k) !== v) return false;
+  }
+  return true;
+}
+function addMP(a, b) {
+  const terms = new Map(a.terms);
+  for (const [k, v] of b.terms) {
+    const next = (terms.get(k) ?? 0n) + v;
+    if (next === 0n) {
+      terms.delete(k);
+    } else {
+      terms.set(k, next);
+    }
+  }
+  return { vars: a.vars.slice(), terms };
+}
+function subMP(a, b) {
+  return addMP(a, negMP(b));
+}
+function mulMP(a, b) {
+  const n = a.vars.length;
+  const terms = /* @__PURE__ */ new Map();
+  for (const [ka, ca] of a.terms) {
+    const ea = unkey(ka);
+    for (const [kb, cb] of b.terms) {
+      const eb = unkey(kb);
+      const exps = new Array(n);
+      for (let i = 0; i < n; i += 1) {
+        exps[i] = ea[i] + eb[i];
+      }
+      const k = key(exps);
+      const next = (terms.get(k) ?? 0n) + ca * cb;
+      if (next === 0n) {
+        terms.delete(k);
+      } else {
+        terms.set(k, next);
+      }
+    }
+  }
+  return { vars: a.vars.slice(), terms };
+}
+function negMP(p) {
+  const terms = /* @__PURE__ */ new Map();
+  for (const [k, v] of p.terms) {
+    terms.set(k, -v);
+  }
+  return { vars: p.vars.slice(), terms };
+}
+function canonicalCompare(expsA, expsB) {
+  const da = expsA.reduce((a, b) => a + b, 0);
+  const db = expsB.reduce((a, b) => a + b, 0);
+  if (da !== db) {
+    return db - da;
+  }
+  for (let i = 0; i < expsA.length; i += 1) {
+    if (expsA[i] !== expsB[i]) {
+      return expsB[i] - expsA[i];
+    }
+  }
+  return 0;
+}
+function leadingTerm(p) {
+  let best = null;
+  for (const [k, v] of p.terms) {
+    const exps = unkey(k);
+    if (best === null || canonicalCompare(exps, best.exps) < 0) {
+      best = { exps, coeff: v };
+    }
+  }
+  return best;
+}
+function integerContentMP(p) {
+  let g = 0n;
+  for (const v of p.terms.values()) {
+    g = bigintGcd(g, v);
+  }
+  return g;
+}
+function primitivePartMP(p) {
+  if (isZero2(p)) {
+    return { vars: p.vars.slice(), terms: /* @__PURE__ */ new Map() };
+  }
+  const g = integerContentMP(p);
+  const terms = /* @__PURE__ */ new Map();
+  for (const [k, v] of p.terms) {
+    terms.set(k, g === 0n ? v : v / g);
+  }
+  const divided = { vars: p.vars.slice(), terms };
+  const lead = leadingTerm(divided);
+  if (lead !== null && lead.coeff < 0n) {
+    return negMP(divided);
+  }
+  return divided;
+}
+function multiExactDivide(a, b) {
+  const bLead = leadingTerm(b);
+  if (bLead === null) {
+    return null;
+  }
+  const n = a.vars.length;
+  let remainder = a;
+  const quotientEntries = [];
+  while (!isZero2(remainder)) {
+    const rLead = leadingTerm(remainder);
+    if (rLead === null) {
+      break;
+    }
+    const qExps = new Array(n);
+    for (let i = 0; i < n; i += 1) {
+      const diff2 = rLead.exps[i] - bLead.exps[i];
+      if (diff2 < 0) {
+        return null;
+      }
+      qExps[i] = diff2;
+    }
+    if (rLead.coeff % bLead.coeff !== 0n) {
+      return null;
+    }
+    const qCoeff = rLead.coeff / bLead.coeff;
+    quotientEntries.push([qExps, qCoeff]);
+    const qTerm = fromTerms(a.vars, [[qExps, qCoeff]]);
+    remainder = subMP(remainder, mulMP(qTerm, b));
+  }
+  return fromTerms(a.vars, quotientEntries);
+}
+function fromAlgebraExpr(expr, vars) {
+  try {
+    const parsed = polyFromExpression(expr, vars);
+    const entries = [];
+    for (const term of parsed) {
+      if (!Number.isInteger(term.coeff)) {
+        return null;
+      }
+      entries.push([term.powers, BigInt(term.coeff)]);
+    }
+    return fromTerms(vars, entries);
+  } catch {
+    return null;
+  }
+}
+function toAlgebraString(p) {
+  if (p.terms.size === 0) return "0";
+  const fmt = (c) => c.toString();
+  const terms = [...p.terms].map(([k, v]) => ({ exps: unkey(k), coeff: v })).reverse().map(({ exps, coeff }) => {
+    const varPart = exps.map((e, i) => e === 0 ? "" : e === 1 ? p.vars[i] : `${p.vars[i]}^${e}`).filter(Boolean).join("*");
+    return varPart ? `${fmt(coeff)}*${varPart}` : fmt(coeff);
+  });
+  return terms.join(" + ").replace(/\+ -/g, "- ");
+}
+
+// src/typed/factorization/kronecker.ts
+function substitutionBases(p) {
+  const n = p.vars.length;
+  const bases = new Array(n);
+  let prod2 = 1n;
+  for (let k = 0; k < n; k += 1) {
+    bases[k] = prod2;
+    const d = degreeIn(p, k);
+    const radix = d < 0 ? 1n : BigInt(d) + 1n;
+    prod2 *= radix;
+  }
+  return bases;
+}
+function substitutedDegree(p, bases) {
+  let total = 0n;
+  for (let i = 0; i < bases.length; i += 1) {
+    const d = degreeIn(p, i);
+    const dd = d < 0 ? 0n : BigInt(d);
+    total += dd * bases[i];
+  }
+  return total;
+}
+function substitute(p, bases) {
+  const maxDeg = substitutedDegree(p, bases);
+  if (maxDeg > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError(
+      `substitute: substituted degree ${maxDeg.toString()} exceeds Number.MAX_SAFE_INTEGER`
+    );
+  }
+  const len = Number(maxDeg) + 1;
+  const out = new Array(len).fill(0n);
+  for (const [k, coeff] of p.terms) {
+    const exps = unkey(k);
+    let deg = 0n;
+    for (let i = 0; i < exps.length; i += 1) {
+      deg += BigInt(exps[i]) * bases[i];
+    }
+    const idx = Number(deg);
+    out[idx] += coeff;
+  }
+  return trim(out);
+}
+function backSubstitute(u, bases, degBounds, vars) {
+  const n = bases.length;
+  const trimmed = trim(u);
+  const entries = [];
+  for (let e = 0; e < trimmed.length; e += 1) {
+    const coeff = trimmed[e];
+    if (coeff === 0n) {
+      continue;
+    }
+    let remaining = BigInt(e);
+    const exps = new Array(n);
+    for (let i = 0; i < n; i += 1) {
+      const radix = BigInt(degBounds[i]) + 1n;
+      exps[i] = Number(remaining % radix);
+      remaining = remaining / radix;
+    }
+    if (remaining !== 0n) {
+      return null;
+    }
+    entries.push([exps, coeff]);
+  }
+  return fromTerms(vars, entries);
+}
+
+// src/typed/factorization/kronecker-factor.ts
+var KRONECKER_MAX_DEGREE = 2000n;
+var MAX_MODULAR_FACTORS2 = 24;
+function log4(message) {
+  console.warn(message);
+}
+function* subsetsOfSize(n, s) {
+  if (s === 0) {
+    yield [];
+    return;
+  }
+  if (s > n) {
+    return;
+  }
+  const idx = Array.from({ length: s }, (_, i) => i);
+  for (; ; ) {
+    yield idx.slice();
+    let i = s - 1;
+    while (i >= 0 && idx[i] === n - s + i) {
+      i -= 1;
+    }
+    if (i < 0) {
+      return;
+    }
+    idx[i] += 1;
+    for (let j = i + 1; j < s; j += 1) {
+      idx[j] = idx[j - 1] + 1;
+    }
+  }
+}
+function removeIndices(pool, indices) {
+  const sorted = [...indices].sort((a, b) => b - a);
+  for (const i of sorted) {
+    pool.splice(i, 1);
+  }
+}
+function subsetProduct(pool, indices) {
+  let prod2 = [1n];
+  for (const idx of indices) {
+    prod2 = mul(prod2, pool[idx]);
+  }
+  return prod2;
+}
+function candidateFor(pool, indices, bases, degBounds, vars) {
+  const back = backSubstitute(subsetProduct(pool, indices), bases, degBounds, vars);
+  if (back === null) {
+    return null;
+  }
+  const cand = primitivePartMP(back);
+  if (totalDegree(cand) < 1) {
+    return null;
+  }
+  return cand;
+}
+function findMatchingSubset(pool, s, cand, bases, degBounds, vars) {
+  for (const indices of subsetsOfSize(pool.length, s)) {
+    const c = candidateFor(pool, indices, bases, degBounds, vars);
+    if (c !== null && equals(c, cand)) {
+      return indices;
+    }
+  }
+  return null;
+}
+function factorMultivariateKronecker(p) {
+  if (p.vars.length < 2) {
+    return null;
+  }
+  if (isZero2(p) || totalDegree(p) < 1) {
+    return null;
+  }
+  const cont = integerContentMP(p);
+  const pLead = leadingTerm(p);
+  const sign3 = pLead !== null && pLead.coeff < 0n ? -1n : 1n;
+  let constant = cont * sign3;
+  const g = primitivePartMP(p);
+  const bases = substitutionBases(g);
+  if (substitutedDegree(g, bases) > KRONECKER_MAX_DEGREE) {
+    log4(
+      `factorMultivariateKronecker: substituted degree exceeds KRONECKER_MAX_DEGREE=${KRONECKER_MAX_DEGREE.toString()}; declining`
+    );
+    return null;
+  }
+  const image = substitute(g, bases);
+  const uf = factorUnivariateZ(image);
+  const totalCount = uf.factors.reduce((acc, f) => acc + f.mult, 0);
+  if (totalCount <= 1) {
+    return { constant, factors: [{ poly: g, mult: 1 }] };
+  }
+  const pool = [];
+  for (const { poly, mult } of uf.factors) {
+    for (let i = 0; i < mult; i += 1) {
+      pool.push(poly);
+    }
+  }
+  if (pool.length > MAX_MODULAR_FACTORS2) {
+    log4(
+      `factorMultivariateKronecker: ${pool.length} univariate factors exceeds MAX_MODULAR_FACTORS=${MAX_MODULAR_FACTORS2}; returning input whole`
+    );
+    return { constant, factors: [{ poly: g, mult: 1 }] };
+  }
+  const degBounds = g.vars.map((_, i) => degreeIn(g, i));
+  let gCur = g;
+  const found = [];
+  let s = 1;
+  while (pool.length > 0 && 2 * s <= pool.length) {
+    let extracted = false;
+    for (const indices of subsetsOfSize(pool.length, s)) {
+      const cand = candidateFor(pool, indices, bases, degBounds, g.vars);
+      if (cand === null) {
+        continue;
+      }
+      const quotient = multiExactDivide(gCur, cand);
+      if (quotient === null) {
+        continue;
+      }
+      gCur = quotient;
+      removeIndices(pool, indices);
+      let mult = 1;
+      for (; ; ) {
+        const next = multiExactDivide(gCur, cand);
+        if (next === null) {
+          break;
+        }
+        const copy = findMatchingSubset(pool, s, cand, bases, degBounds, g.vars);
+        if (copy === null) {
+          break;
+        }
+        removeIndices(pool, copy);
+        gCur = next;
+        mult += 1;
+      }
+      found.push({ poly: cand, mult });
+      extracted = true;
+      break;
+    }
+    if (extracted) {
+      s = 1;
+    } else {
+      s += 1;
+    }
+  }
+  if (!isZero2(gCur)) {
+    const c = integerContentMP(gCur);
+    const l = leadingTerm(gCur);
+    const sgn = l !== null && l.coeff < 0n ? -1n : 1n;
+    constant *= c * sgn;
+    if (totalDegree(gCur) >= 1) {
+      found.push({ poly: primitivePartMP(gCur), mult: 1 });
+    }
+  }
+  found.sort((a, b) => {
+    const la = leadingTerm(a.poly);
+    const lb = leadingTerm(b.poly);
+    if (la === null || lb === null) {
+      return 0;
+    }
+    return canonicalCompare(la.exps, lb.exps);
+  });
+  return { constant, factors: found };
+}
+
+// src/typed/factorization/index.ts
+var INT_TOLERANCE = 1e-7;
+function polyToDense(p) {
+  let maxPow = 0;
+  for (const t of p) maxPow = Math.max(maxPow, t.powers[0] ?? 0);
+  const dense = new Array(maxPow + 1).fill(0);
+  for (const t of p) dense[t.powers[0]] += t.coeff;
+  let n = dense.length;
+  while (n > 0 && Math.abs(dense[n - 1]) < 1e-9) n -= 1;
+  return dense.slice(0, n);
+}
+function cleanUnivariatePoly(coeffs, v) {
+  const parts = [];
+  for (let i = coeffs.length - 1; i >= 0; i -= 1) {
+    const c = Math.round(coeffs[i]);
+    if (c === 0) continue;
+    const abs2 = Math.abs(c);
+    let term;
+    if (i === 0) {
+      term = String(abs2);
+    } else {
+      const varPart = i === 1 ? v : `${v}^${i}`;
+      term = abs2 === 1 ? varPart : `${abs2}*${varPart}`;
+    }
+    if (parts.length === 0) {
+      parts.push(c < 0 ? `-${term}` : term);
+    } else {
+      parts.push(c < 0 ? "-" : "+", term);
+    }
+  }
+  return parts.length === 0 ? "0" : parts.join(" ");
+}
+function renderLinearFactor(poly, v) {
+  const b = poly[0];
+  const a = poly[1];
+  const base = a === 1n ? v : `${a}*${v}`;
+  if (b === 0n) return `(${base})`;
+  return b < 0n ? `(${base} - ${-b})` : `(${base} + ${b})`;
+}
+function renderIntPoly(coeffs, v) {
+  const parts = [];
+  for (let i = coeffs.length - 1; i >= 0; i -= 1) {
+    const c = coeffs[i];
+    if (c === 0n) continue;
+    const abs2 = c < 0n ? -c : c;
+    let term;
+    if (i === 0) {
+      term = abs2.toString();
+    } else {
+      const varPart = i === 1 ? v : `${v}^${i}`;
+      term = abs2 === 1n ? varPart : `${abs2}*${varPart}`;
+    }
+    if (parts.length === 0) {
+      parts.push(c < 0n ? `-${term}` : term);
+    } else {
+      parts.push(c < 0n ? "-" : "+", term);
+    }
+  }
+  return parts.length === 0 ? "0" : parts.join(" ");
+}
+function renderFactor(poly, v) {
+  if (degree(poly) === 1) return renderLinearFactor(poly, v);
+  return `(${renderIntPoly(poly, v)})`;
+}
+function factorPolynomialUnivariate(expr, v) {
+  let dense;
+  try {
+    dense = polyToDense(polyFromExpression(expr, [v]));
+  } catch {
+    return null;
+  }
+  if (dense.length < 2) return null;
+  for (const c of dense) {
+    if (!Number.isFinite(c) || Math.abs(c - Math.round(c)) > INT_TOLERANCE) return null;
+  }
+  const intPoly = dense.map((c) => BigInt(Math.round(c)));
+  const fact = factorUnivariateZ(intPoly);
+  if (fact.factors.length === 1 && fact.factors[0].mult === 1) return null;
+  const parts = [];
+  if (fact.constant !== 1n) parts.push(String(fact.constant));
+  for (const { poly, mult } of fact.factors) {
+    const term = renderFactor(poly, v);
+    for (let i = 0; i < mult; i += 1) parts.push(term);
+  }
+  return parts.join("*");
+}
+function renderMultiFactorization(fact) {
+  const parts = [];
+  if (fact.constant !== 1n) parts.push(String(fact.constant));
+  for (const { poly, mult } of fact.factors) {
+    const term = `(${toAlgebraString(poly)})`;
+    parts.push(mult > 1 ? `${term}^${mult}` : term);
+  }
+  return parts.join("*");
+}
+function factorMultivariateString(expr, vars, minFactors = 2) {
+  const p = fromAlgebraExpr(expr, vars);
+  if (p === null) return null;
+  const fact = factorMultivariateKronecker(p);
+  if (fact === null) return null;
+  const count2 = fact.factors.reduce((acc, f) => acc + f.mult, 0);
+  if (count2 < minFactors) return null;
+  return renderMultiFactorization(fact);
+}
+
 // src/typed/algebra.ts
 var MATH_KEYWORDS = /* @__PURE__ */ new Set([
   "sin",
@@ -10002,7 +11291,7 @@ function polynomialRemainder(a, b) {
   const [, remainder] = polyDivMod(a, b);
   return remainder.length === 0 ? [0] : remainder;
 }
-function degree(coeffs) {
+function degree2(coeffs) {
   const trimmed = trimPoly(coeffs);
   if (trimmed.length === 1 && trimmed[0] === 0) return 0;
   return trimmed.length - 1;
@@ -10062,20 +11351,20 @@ function variables(expr) {
   }
   return [...vars].sort();
 }
-function substitute(expr, vars) {
+function substitute2(expr, vars) {
   let result = expr;
   const keys = Object.keys(vars).sort((a, b) => b.length - a.length);
-  for (const key of keys) {
-    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const key2 of keys) {
+    const escaped = key2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const pattern = new RegExp("\\b" + escaped + "\\b", "g");
-    result = result.replace(pattern, vars[key]);
+    result = result.replace(pattern, vars[key2]);
   }
   return result;
 }
 function isNearInt(c) {
   return Math.abs(c - Math.round(c)) < 1e-7;
 }
-function polyToDense(p) {
+function polyToDense2(p) {
   let maxPow = 0;
   for (const t of p) maxPow = Math.max(maxPow, t.powers[0] ?? 0);
   const dense = new Array(maxPow + 1).fill(0);
@@ -10241,11 +11530,11 @@ function tryMonomialDiffOfSquares(poly, vars) {
   const [t1, t2] = poly;
   if (Math.sign(t1.coeff) === Math.sign(t2.coeff)) return null;
   const pos = t1.coeff > 0 ? t1 : t2;
-  const neg = t1.coeff > 0 ? t2 : t1;
+  const neg2 = t1.coeff > 0 ? t2 : t1;
   const cp = perfectIntSqrt(Math.round(pos.coeff));
-  const cn = perfectIntSqrt(Math.round(-neg.coeff));
+  const cn = perfectIntSqrt(Math.round(-neg2.coeff));
   if (cp === null || cn === null) return null;
-  if (!pos.powers.every((e) => e % 2 === 0) || !neg.powers.every((e) => e % 2 === 0)) return null;
+  if (!pos.powers.every((e) => e % 2 === 0) || !neg2.powers.every((e) => e % 2 === 0)) return null;
   const half = (t) => t.powers.map((e) => e / 2);
   const term = (c, powers) => {
     const mon = monomialString(powers, vars);
@@ -10253,7 +11542,7 @@ function tryMonomialDiffOfSquares(poly, vars) {
     return c === 1 ? mon : `${c}*${mon}`;
   };
   const A = term(cp, half(pos));
-  const B = term(cn, half(neg));
+  const B = term(cn, half(neg2));
   return [`(${A} - ${B})`, `(${A} + ${B})`];
 }
 function factorMultivariate(expr, vars) {
@@ -10264,9 +11553,9 @@ function factorMultivariate(expr, vars) {
     return null;
   }
   if (poly.length < 2 || !poly.every((t) => isNearInt(t.coeff))) return null;
-  let content = 0;
-  for (const t of poly) content = gcdNum(content, Math.abs(Math.round(t.coeff)));
-  if (content === 0) return null;
+  let content2 = 0;
+  for (const t of poly) content2 = gcdNum(content2, Math.abs(Math.round(t.coeff)));
+  if (content2 === 0) return null;
   const nVars = vars.length;
   const monPow = new Array(nVars).fill(Infinity);
   for (const t of poly)
@@ -10274,43 +11563,60 @@ function factorMultivariate(expr, vars) {
   const hasMonomial = monPow.some((e) => e > 0);
   const cofactor = normalize(
     poly.map((t) => ({
-      coeff: Math.round(t.coeff) / content,
+      coeff: Math.round(t.coeff) / content2,
       powers: t.powers.map((e, i) => e - monPow[i])
     }))
   );
   const dsq = tryMonomialDiffOfSquares(cofactor, vars);
   if (!hasMonomial && !dsq) return null;
   const parts = [];
-  if (content > 1) parts.push(String(content));
+  if (content2 > 1) parts.push(String(content2));
   if (hasMonomial) parts.push(monomialString(monPow, vars));
   if (dsq) parts.push(dsq[0], dsq[1]);
   else parts.push(`(${polyToString(cofactor, vars)})`);
-  return parts.join("*");
+  const monomialFactors = monPow.reduce((acc, e) => acc + e, 0);
+  const count2 = monomialFactors + (dsq ? 2 : 1);
+  return { text: parts.join("*"), count: count2 };
 }
 function factor(expr) {
   const univariateVars = variables(expr);
   if (univariateVars.length >= 2) {
     const mv = factorMultivariate(expr, univariateVars);
-    if (mv !== null) return mv;
+    if (mv === null) {
+      const kron2 = factorMultivariateString(expr, univariateVars);
+      if (kron2 !== null) return kron2;
+    } else {
+      const refined = factorMultivariateString(expr, univariateVars, mv.count + 1);
+      if (refined !== null) return refined;
+      return mv.text;
+    }
   }
   if (univariateVars.length === 1) {
     try {
       const v = univariateVars[0];
-      const dense = polyToDense(polyFromExpression(expr, [v]));
-      if (degree(dense) >= 2 && dense.every(isNearInt)) {
+      const dense = polyToDense2(polyFromExpression(expr, [v]));
+      if (degree2(dense) >= 2 && dense.every(isNearInt)) {
         const intDense = dense.map((c) => Math.round(c));
         const { roots, remainder } = findRationalLinearFactors(intDense);
         if (roots.length > 0) {
           const factors = roots.map((r) => formatLinearFactor(r, v));
-          if (degree(remainder) >= 1) {
+          if (degree2(remainder) >= 2) {
+            const remExpr = cleanUnivariatePoly(remainder, v);
+            const routed2 = factorPolynomialUnivariate(remExpr, v);
+            factors.push(routed2 ?? `(${remExpr})`);
+          } else if (degree2(remainder) >= 1) {
             factors.push(`(${polyToString(denseToPoly(remainder), [v])})`);
           } else if (remainder[0] !== 1) {
             factors.unshift(String(remainder[0]));
           }
           return factors.join("*");
         }
+        const routed = factorPolynomialUnivariate(expr, v);
+        if (routed !== null) return routed;
       }
-    } catch {
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn("factor: univariate engine path failed, falling back: " + message);
     }
   }
   const normalized = expr.replace(/\s*-\s*/g, " + -");
@@ -10400,13 +11706,13 @@ function cancel(expr) {
         if (dens.length > 0) {
           const numStr = nums.length ? nums.join("*") : "1";
           const denStr = dens.join("*");
-          const N2 = polyToDense(polyFromExpression(numStr, [v]));
-          const D = polyToDense(polyFromExpression(denStr, [v]));
+          const N2 = polyToDense2(polyFromExpression(numStr, [v]));
+          const D = polyToDense2(polyFromExpression(denStr, [v]));
           if (N2.every(isNearInt) && D.every(isNearInt)) {
             const Nint = N2.map((c) => Math.round(c));
             const Dint = D.map((c) => Math.round(c));
             const g = polynomialGCD(Nint, Dint);
-            if (degree(g) >= 1) {
+            if (degree2(g) >= 1) {
               let Nq = polynomialQuotient(Nint, g).map((c) => Math.round(c * 1e6) / 1e6);
               let Dq = polynomialQuotient(Dint, g).map((c) => Math.round(c * 1e6) / 1e6);
               let contentGcd = 0;
@@ -10419,7 +11725,7 @@ function cancel(expr) {
                 Nq = Nq.map((c) => -c);
                 Dq = Dq.map((c) => -c);
               }
-              if (degree(Dq) === 0) {
+              if (degree2(Dq) === 0) {
                 const c = Dq[0];
                 if (c !== 1) Nq = Nq.map((x) => x / c);
                 return polyToString(denseToPoly(Nq), [v]);
@@ -10501,23 +11807,23 @@ function apart(expr) {
         if (dens.length > 0) {
           const numStr = nums.length ? nums.join("*") : "1";
           const denStr = dens.join("*");
-          const N2 = polyToDense(polyFromExpression(numStr, [v]));
-          const D = polyToDense(polyFromExpression(denStr, [v]));
-          if (degree(D) >= 1 && N2.every(isNearInt) && D.every(isNearInt)) {
+          const N2 = polyToDense2(polyFromExpression(numStr, [v]));
+          const D = polyToDense2(polyFromExpression(denStr, [v]));
+          if (degree2(D) >= 1 && N2.every(isNearInt) && D.every(isNearInt)) {
             let Nint = N2.map((c) => Math.round(c));
             const Dint = D.map((c) => Math.round(c));
             let quotientPrefix = "";
-            if (degree(Nint) >= degree(Dint)) {
+            if (degree2(Nint) >= degree2(Dint)) {
               const q = polynomialQuotient(Nint, Dint);
               const r = polynomialRemainder(Nint, Dint);
-              if (degree(r) === 0 && r[0] === 0) {
+              if (degree2(r) === 0 && r[0] === 0) {
                 return polyToString(denseToPoly(q), [v]);
               }
               quotientPrefix = `${polyToString(denseToPoly(q), [v])} + `;
               Nint = r.map((c) => Math.round(c));
             }
             const { roots, remainder, repeated } = findRationalLinearFactors(Dint);
-            if (!repeated && degree(remainder) === 0 && roots.length === degree(Dint)) {
+            if (!repeated && degree2(remainder) === 0 && roots.length === degree2(Dint)) {
               const Dprime = polyder(Dint);
               const termStrs = roots.map((root2) => {
                 const nAtRoot = ratPolyval(Nint, root2);
@@ -10766,7 +12072,7 @@ var typedAlgebra = {
   polynomialLCM,
   polynomialQuotient,
   polynomialRemainder,
-  degree,
+  degree: degree2,
   coefficientList,
   discriminant,
   differences,
@@ -10774,7 +12080,7 @@ var typedAlgebra = {
   expand,
   factor,
   collect,
-  substitute,
+  substitute: substitute2,
   variables,
   cancel,
   together,
@@ -11420,19 +12726,19 @@ function pchipEndSlope(x0, x1, _x2, _y0, _y1, _y2, d0, d1) {
   }
   return slope;
 }
-function polyFit(xs, ys, degree2) {
-  if (xs.length !== ys.length || xs.length < degree2 + 1) {
+function polyFit(xs, ys, degree3) {
+  if (xs.length !== ys.length || xs.length < degree3 + 1) {
     throw new Error("polyFit requires more data points than polynomial degree");
   }
   if (xs.length >= WASM_POLY_FIT_THRESHOLD) {
     try {
-      const result = polyFitDispatch(new Float64Array(xs), new Float64Array(ys), degree2);
+      const result = polyFitDispatch(new Float64Array(xs), new Float64Array(ys), degree3);
       return Array.from(result);
     } catch {
     }
   }
   const n = xs.length;
-  const m = degree2 + 1;
+  const m = degree3 + 1;
   const VtV = Array.from({ length: m }, () => new Array(m).fill(0));
   const Vty = new Array(m).fill(0);
   for (let i = 0; i < n; i++) {
@@ -11481,19 +12787,19 @@ function polyFit(xs, ys, degree2) {
   }
   return coeffs;
 }
-function chebyshevFit(xs, ys, degree2) {
-  if (xs.length !== ys.length || xs.length < degree2 + 1) {
+function chebyshevFit(xs, ys, degree3) {
+  if (xs.length !== ys.length || xs.length < degree3 + 1) {
     throw new Error("chebyshevFit requires more data points than polynomial degree");
   }
   if (xs.length >= WASM_POLY_FIT_THRESHOLD) {
     try {
-      const result = chebFitDispatch(new Float64Array(xs), new Float64Array(ys), degree2);
+      const result = chebFitDispatch(new Float64Array(xs), new Float64Array(ys), degree3);
       return Array.from(result);
     } catch {
     }
   }
   const n = xs.length;
-  const k = degree2 + 1;
+  const k = degree3 + 1;
   function chebRow(x) {
     const row2 = new Array(k);
     let tPrev = 1, tCurr = x;
@@ -11541,19 +12847,19 @@ function chebyshevFit(xs, ys, degree2) {
   }
   return coeffs;
 }
-function legendreFit(xs, ys, degree2) {
-  if (xs.length !== ys.length || xs.length < degree2 + 1) {
+function legendreFit(xs, ys, degree3) {
+  if (xs.length !== ys.length || xs.length < degree3 + 1) {
     throw new Error("legendreFit requires more data points than polynomial degree");
   }
   if (xs.length >= WASM_POLY_FIT_THRESHOLD) {
     try {
-      const result = legendreFitDispatch(new Float64Array(xs), new Float64Array(ys), degree2);
+      const result = legendreFitDispatch(new Float64Array(xs), new Float64Array(ys), degree3);
       return Array.from(result);
     } catch {
     }
   }
   const n = xs.length;
-  const k = degree2 + 1;
+  const k = degree3 + 1;
   function legRow(x) {
     const row2 = new Array(k);
     let pPrev = 1, pCurr = x;
@@ -12647,7 +13953,7 @@ var createSolveODE = /* @__PURE__ */ factory(
   dependencies,
   ({
     typed: typed3,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -12866,7 +14172,7 @@ var createSolveODE = /* @__PURE__ */ factory(
           const m = Math.min(coeffs.length, stages.length);
           let acc = multiply2(coeffs[0], stages[0]);
           for (let j = 1; j < m; j++) {
-            acc = add4(acc, multiply2(coeffs[j], stages[j]));
+            acc = add5(acc, multiply2(coeffs[j], stages[j]));
           }
           return acc;
         }
@@ -12879,14 +14185,14 @@ var createSolveODE = /* @__PURE__ */ factory(
           h = trimStep(t[n], tf, h);
           k.push(f(t[n], y[n]));
           for (let i = 1; i < c.length; ++i) {
-            k.push(f(add4(t[n], multiply2(c[i], h)), add4(y[n], multiply2(h, stageCombo(a[i], k)))));
+            k.push(f(add5(t[n], multiply2(c[i], h)), add5(y[n], multiply2(h, stageCombo(a[i], k)))));
           }
           const errComb = stageCombo(deltaB, k);
           const errArr = Array.isArray(errComb) ? errComb : [errComb];
           const TE = max2(abs2(map3(errArr, (X) => isUnit(X) ? X.value : X)));
           if (TE < tol && tol / TE > 1 / 4) {
-            t.push(add4(t[n], h));
-            y.push(add4(y[n], multiply2(h, stageCombo(b, k))));
+            t.push(add5(t[n], h));
+            y.push(add5(y[n], multiply2(h, stageCombo(b, k))));
             n++;
           }
           let delta = 0.84 * (tol / TE) ** (1 / 5);
@@ -12980,7 +14286,7 @@ var createSolveODE = /* @__PURE__ */ factory(
     function _createTrimStep(isForwards) {
       const outOfBounds = isForwards ? larger2 : smaller2;
       return function(t, tf, h) {
-        const next = add4(t, h);
+        const next = add5(t, h);
         return outOfBounds(next, tf) ? subtract3(tf, t) : h;
       };
     }
@@ -14065,9 +15371,9 @@ function bezierCurve(controlPoints, t) {
   }
   return points[0];
 }
-function bspline(controlPoints, degree2, t) {
+function bspline(controlPoints, degree3, t) {
   const n = controlPoints.length;
-  const p = degree2;
+  const p = degree3;
   if (n <= p) throw new Error("bspline: need more control points than degree");
   const m = n + p + 1;
   const knots = new Array(m);
@@ -14811,8 +16117,8 @@ function residue(p, q) {
 function polyRoots(coeffs) {
   const n = coeffs.length - 1;
   if (n <= 0) return [];
-  const lc = coeffs[n];
-  const c = coeffs.map((v) => v / lc);
+  const lc2 = coeffs[n];
+  const c = coeffs.map((v) => v / lc2);
   const roots = [];
   for (let i = 0; i < n; i++) {
     const angle = 2 * Math.PI * i / n + 0.4;
@@ -15811,19 +17117,19 @@ function minimumSpanningTree(adj) {
   const n = adj.length;
   if (n === 0) return [];
   const inMST = new Array(n).fill(false);
-  const key = new Array(n).fill(Infinity);
+  const key2 = new Array(n).fill(Infinity);
   const parent = new Array(n).fill(-1);
-  key[0] = 0;
+  key2[0] = 0;
   for (let count2 = 0; count2 < n; count2++) {
     let u = -1;
     for (let v = 0; v < n; v++) {
-      if (!inMST[v] && (u === -1 || key[v] < key[u])) u = v;
+      if (!inMST[v] && (u === -1 || key2[v] < key2[u])) u = v;
     }
-    if (u === -1 || key[u] === Infinity) break;
+    if (u === -1 || key2[u] === Infinity) break;
     inMST[u] = true;
     for (let v = 0; v < n; v++) {
-      if (adj[u][v] > 0 && !inMST[v] && adj[u][v] < key[v]) {
-        key[v] = adj[u][v];
+      if (adj[u][v] > 0 && !inMST[v] && adj[u][v] < key2[v]) {
+        key2[v] = adj[u][v];
         parent[v] = u;
       }
     }
@@ -19557,8 +20863,8 @@ function bigNumberToBase(bn, base, wordSize) {
   return numberToBase(n, base, wordSize);
 }
 function interpolate2(template, values, options) {
-  return template.replace(printTemplate, function(original, key) {
-    const keys = key.split(".");
+  return template.replace(printTemplate, function(original, key2) {
+    const keys = key2.split(".");
     let value = values[keys.shift()];
     if (value !== void 0 && value.isMatrix) {
       value = value.toArray();
@@ -19704,7 +21010,7 @@ function combinationsExact(n, k) {
 var bernoulli = mathTyped16("bernoulli", {
   number: (n) => bernoulliNumber(n)
 });
-var combinations = mathTyped16("combinations", {
+var combinations2 = mathTyped16("combinations", {
   "number, number": (n, k) => combinationsExact(n, k)
 });
 var combinationsWithRep = mathTyped16("combinationsWithRep", {
@@ -19834,7 +21140,7 @@ function _pick(arr10, n, weights) {
 }
 var typedProbability = {
   bernoulli,
-  combinations,
+  combinations: combinations2,
   combinationsWithRep,
   multinomial,
   permutations,
@@ -20090,7 +21396,7 @@ __export(factories_exports, {
   csch: () => csch,
   ctranspose: () => ctranspose,
   cumsum: () => cumsum,
-  derivative: () => derivative,
+  derivative: () => derivative2,
   det: () => det,
   deuteronMass: () => deuteronMass,
   diag: () => diag,
@@ -20204,8 +21510,8 @@ __export(factories_exports, {
   isNegative: () => isNegative,
   isNumeric: () => isNumeric,
   isPositive: () => isPositive,
-  isPrime: () => isPrime,
-  isZero: () => isZero,
+  isPrime: () => isPrime2,
+  isZero: () => isZero3,
   josephson: () => josephson,
   kldivergence: () => kldivergence,
   klitzing: () => klitzing,
@@ -22171,8 +23477,8 @@ var createPrint = /* @__PURE__ */ factory(
   }
 );
 function _print(template, values, options) {
-  return template.replace(printTemplate, function(original, key) {
-    const keys = key.split(".");
+  return template.replace(printTemplate, function(original, key2) {
+    const keys = key2.split(".");
     let value = values[keys.shift()];
     if (value !== void 0 && value.isMatrix) {
       value = value.toArray();
@@ -23126,41 +24432,41 @@ var createDot = /* @__PURE__ */ factory(
       const bdt = isMatrix(b) ? b._datatype || b.getDataType() : void 0;
       const aIsColumn = _size(a).length === 2;
       const bIsColumn = _size(b).length === 2;
-      let add4 = addScalar2;
-      let mul = multiplyScalar2;
+      let add5 = addScalar2;
+      let mul2 = multiplyScalar2;
       if (adt && bdt && adt === bdt && typeof adt === "string" && adt !== "mixed") {
         const dt = adt;
-        add4 = typed3.find(addScalar2, [dt, dt]);
-        mul = typed3.find(multiplyScalar2, [dt, dt]);
+        add5 = typed3.find(addScalar2, [dt, dt]);
+        mul2 = typed3.find(multiplyScalar2, [dt, dt]);
       }
-      if (!aIsColumn && !bIsColumn && add4 === addScalar2 && mul === multiplyScalar2 && _isFlatNumbers(adata) && _isFlatNumbers(bdata)) {
+      if (!aIsColumn && !bIsColumn && add5 === addScalar2 && mul2 === multiplyScalar2 && _isFlatNumbers(adata) && _isFlatNumbers(bdata)) {
         return pairwiseDot2(adata, bdata);
       }
       if (!aIsColumn && !bIsColumn) {
-        let c = mul(conj3(adata[0]), bdata[0]);
+        let c = mul2(conj3(adata[0]), bdata[0]);
         for (let i = 1; i < N2; i++) {
-          c = add4(c, mul(conj3(adata[i]), bdata[i]));
+          c = add5(c, mul2(conj3(adata[i]), bdata[i]));
         }
         return c;
       }
       if (!aIsColumn && bIsColumn) {
-        let c = mul(conj3(adata[0]), bdata[0][0]);
+        let c = mul2(conj3(adata[0]), bdata[0][0]);
         for (let i = 1; i < N2; i++) {
-          c = add4(c, mul(conj3(adata[i]), bdata[i][0]));
+          c = add5(c, mul2(conj3(adata[i]), bdata[i][0]));
         }
         return c;
       }
       if (aIsColumn && !bIsColumn) {
-        let c = mul(conj3(adata[0][0]), bdata[0]);
+        let c = mul2(conj3(adata[0][0]), bdata[0]);
         for (let i = 1; i < N2; i++) {
-          c = add4(c, mul(conj3(adata[i][0]), bdata[i]));
+          c = add5(c, mul2(conj3(adata[i][0]), bdata[i]));
         }
         return c;
       }
       {
-        let c = mul(conj3(adata[0][0]), bdata[0][0]);
+        let c = mul2(conj3(adata[0][0]), bdata[0][0]);
         for (let i = 1; i < N2; i++) {
-          c = add4(c, mul(conj3(adata[i][0]), bdata[i][0]));
+          c = add5(c, mul2(conj3(adata[i][0]), bdata[i][0]));
         }
         return c;
       }
@@ -23172,8 +24478,8 @@ var createDot = /* @__PURE__ */ factory(
       const yindex = y._index;
       const yvalues = y._values;
       let c = 0;
-      const add4 = addScalar2;
-      const mul = multiplyScalar2;
+      const add5 = addScalar2;
+      const mul2 = multiplyScalar2;
       let i = 0;
       let j = 0;
       while (i < xindex.length && j < yindex.length) {
@@ -23188,7 +24494,7 @@ var createDot = /* @__PURE__ */ factory(
           continue;
         }
         if (I2 === J) {
-          c = add4(c, mul(xvalues[i], yvalues[j]));
+          c = add5(c, mul2(xvalues[i], yvalues[j]));
           i++;
           j++;
         }
@@ -24084,7 +25390,7 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    isZero: isZero2
+    isZero: isZero4
   }) => {
     return typed3(name91, {
       "Array | Matrix, function, string, string": function(size2, fn, format4, datatype) {
@@ -24116,7 +25422,7 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
       m.resize(size2);
       m.forEach(function(_, index) {
         const val = fn(index);
-        if (isZero2(val)) return;
+        if (isZero4(val)) return;
         m.set(index, val);
       });
       return m;
@@ -24280,7 +25586,7 @@ var dependencies95 = ["typed", "matrix", "add"];
 var createTrace = /* @__PURE__ */ factory(
   name95,
   dependencies95,
-  ({ typed: typed3, matrix: matrix2, add: add4 }) => {
+  ({ typed: typed3, matrix: matrix2, add: add5 }) => {
     return typed3("trace", {
       Array: function _arrayTrace(x) {
         return _denseTrace(matrix2(x));
@@ -24304,7 +25610,7 @@ var createTrace = /* @__PURE__ */ factory(
           if (rows === cols) {
             let sum3 = 0;
             for (let i = 0; i < rows; i++) {
-              sum3 = add4(sum3, data[i][i]);
+              sum3 = add5(sum3, data[i][i]);
             }
             return sum3;
           } else {
@@ -24331,7 +25637,7 @@ var createTrace = /* @__PURE__ */ factory(
             for (let k = k0; k < k1; k++) {
               const i = index[k];
               if (i === j) {
-                sum3 = add4(sum3, values[k]);
+                sum3 = add5(sum3, values[k]);
                 break;
               }
               if (i > j) {
@@ -24382,7 +25688,7 @@ var dependencies96 = [
 var createDet = /* @__PURE__ */ factory(
   name96,
   dependencies96,
-  ({ typed: typed3, matrix: matrix2, subtractScalar: subtractScalar2, multiply: multiply2, divideScalar: divideScalar2, isZero: isZero2, unaryMinus: unaryMinus2 }) => {
+  ({ typed: typed3, matrix: matrix2, subtractScalar: subtractScalar2, multiply: multiply2, divideScalar: divideScalar2, isZero: isZero4, unaryMinus: unaryMinus2 }) => {
     return typed3(name96, {
       any: function(x) {
         return clone(x);
@@ -24477,10 +25783,10 @@ var createDet = /* @__PURE__ */ factory(
         }
         for (let k = 0; k < rows; k++) {
           let k_ = rowIndices[k];
-          if (isZero2(matrix3[k_][k])) {
+          if (isZero4(matrix3[k_][k])) {
             let _k;
             for (_k = k + 1; _k < rows; _k++) {
-              if (!isZero2(matrix3[rowIndices[_k]][k])) {
+              if (!isZero4(matrix3[rowIndices[_k]][k])) {
                 k_ = rowIndices[_k];
                 rowIndices[_k] = rowIndices[k];
                 rowIndices[k] = k_;
@@ -24698,7 +26004,7 @@ var dependencies98 = ["add", "multiply", "transpose"];
 var createCsAmd = /* @__PURE__ */ factory(
   name98,
   dependencies98,
-  ({ add: add4, multiply: multiply2, transpose: transpose5 }) => {
+  ({ add: add5, multiply: multiply2, transpose: transpose5 }) => {
     function _tryWasmAmd(a, n) {
       const wasm = wasmLoader.getModule();
       if (!wasm || !a._ptr || !a._index) return null;
@@ -24752,7 +26058,7 @@ var createCsAmd = /* @__PURE__ */ factory(
       const next = 2 * (n + 1);
       const head = 3 * (n + 1);
       const elen = 4 * (n + 1);
-      const degree2 = 5 * (n + 1);
+      const degree3 = 5 * (n + 1);
       const w = 6 * (n + 1);
       const hhead = 7 * (n + 1);
       const last2 = P2;
@@ -24768,9 +26074,9 @@ var createCsAmd = /* @__PURE__ */ factory(
         nv,
         w,
         elen,
-        degree2
+        degree3
       );
-      let nel = _initializeDegreeLists(n, cptr, W, degree2, elen, w, dense, nv, head, last2, next);
+      let nel = _initializeDegreeLists(n, cptr, W, degree3, elen, w, dense, nv, head, last2, next);
       let mindeg = 0;
       let i, j, k, k1, k2, e, pj, ln, nvi, pk, eln, p1, p2, pn, h, d;
       while (nel < n) {
@@ -24811,7 +26117,7 @@ var createCsAmd = /* @__PURE__ */ factory(
             if (last2[i] !== -1) {
               W[next + last2[i]] = W[next + i];
             } else {
-              W[head + W[degree2 + i]] = W[next + i];
+              W[head + W[degree3 + i]] = W[next + i];
             }
           }
           if (e !== k) {
@@ -24822,7 +26128,7 @@ var createCsAmd = /* @__PURE__ */ factory(
         if (elenk !== 0) {
           cnz = pk2;
         }
-        W[degree2 + k] = dk;
+        W[degree3 + k] = dk;
         cptr[k] = pk1;
         W[len + k] = pk2 - pk1;
         W[elen + k] = -2;
@@ -24839,7 +26145,7 @@ var createCsAmd = /* @__PURE__ */ factory(
             if (W[w + e] >= mark) {
               W[w + e] -= nvi;
             } else if (W[w + e] !== 0) {
-              W[w + e] = W[degree2 + e] + wnvi;
+              W[w + e] = W[degree3 + e] + wnvi;
             }
           }
         }
@@ -24884,7 +26190,7 @@ var createCsAmd = /* @__PURE__ */ factory(
             W[nv + i] = 0;
             W[elen + i] = -1;
           } else {
-            W[degree2 + i] = Math.min(W[degree2 + i], d);
+            W[degree3 + i] = Math.min(W[degree3 + i], d);
             cindex[pn] = cindex[p3];
             cindex[p3] = cindex[p1];
             cindex[p1] = k;
@@ -24895,7 +26201,7 @@ var createCsAmd = /* @__PURE__ */ factory(
             last2[i] = h;
           }
         }
-        W[degree2 + k] = dk;
+        W[degree3 + k] = dk;
         lemax = Math.max(lemax, dk);
         mark = _wclear(mark + lemax, lemax, W, w, n);
         for (pk = pk1; pk < pk2; pk++) {
@@ -24940,7 +26246,7 @@ var createCsAmd = /* @__PURE__ */ factory(
             continue;
           }
           W[nv + i] = nvi;
-          d = W[degree2 + i] + dk - nvi;
+          d = W[degree3 + i] + dk - nvi;
           d = Math.min(d, n - nel - nvi);
           if (W[head + d] !== -1) {
             last2[W[head + d]] = i;
@@ -24949,7 +26255,7 @@ var createCsAmd = /* @__PURE__ */ factory(
           last2[i] = -1;
           W[head + d] = i;
           mindeg = Math.min(mindeg, d);
-          W[degree2 + i] = d;
+          W[degree3 + i] = d;
           cindex[p++] = i;
         }
         W[nv + k] = nvk;
@@ -24994,7 +26300,7 @@ var createCsAmd = /* @__PURE__ */ factory(
     function _createTargetMatrix(order, a, m, n, dense) {
       const at = transpose5(a);
       if (order === 1 && n === m) {
-        return add4(a, at);
+        return add5(a, at);
       }
       if (order === 2) {
         const tindex = at._index;
@@ -25016,7 +26322,7 @@ var createCsAmd = /* @__PURE__ */ factory(
       }
       return multiply2(at, a);
     }
-    function _initializeQuotientGraph(n, cptr, W, len, head, last2, next, hhead, nv, w, elen, degree2) {
+    function _initializeQuotientGraph(n, cptr, W, len, head, last2, next, hhead, nv, w, elen, degree3) {
       for (let k = 0; k < n; k++) {
         W[len + k] = cptr[k + 1] - cptr[k];
       }
@@ -25029,7 +26335,7 @@ var createCsAmd = /* @__PURE__ */ factory(
         W[nv + i] = 1;
         W[w + i] = 1;
         W[elen + i] = 0;
-        W[degree2 + i] = W[len + i];
+        W[degree3 + i] = W[len + i];
       }
       const mark = _wclear(0, 0, W, w, n);
       W[elen + n] = -2;
@@ -25037,10 +26343,10 @@ var createCsAmd = /* @__PURE__ */ factory(
       W[w + n] = 0;
       return mark;
     }
-    function _initializeDegreeLists(n, cptr, W, degree2, elen, w, dense, nv, head, last2, next) {
+    function _initializeDegreeLists(n, cptr, W, degree3, elen, w, dense, nv, head, last2, next) {
       let nel = 0;
       for (let i = 0; i < n; i++) {
-        const d = W[degree2 + i];
+        const d = W[degree3 + i];
         if (d === 0) {
           W[elen + i] = -2;
           nel++;
@@ -25343,8 +26649,8 @@ var dependencies100 = ["add", "multiply", "transpose"];
 var createCsSqr = /* @__PURE__ */ factory(
   name100,
   dependencies100,
-  ({ add: add4, multiply: multiply2, transpose: transpose5 }) => {
-    const csAmd2 = createCsAmd({ add: add4, multiply: multiply2, transpose: transpose5 });
+  ({ add: add5, multiply: multiply2, transpose: transpose5 }) => {
+    const csAmd2 = createCsAmd({ add: add5, multiply: multiply2, transpose: transpose5 });
     const csCounts2 = createCsCounts({ transpose: transpose5 });
     return function csSqr2(order, a, qr2) {
       const aptr = a._ptr;
@@ -26860,7 +28166,7 @@ var createCatalan = /* @__PURE__ */ factory(
     addScalar: addScalar2,
     divideScalar: divideScalar2,
     multiplyScalar: multiplyScalar2,
-    combinations: combinations3,
+    combinations: combinations4,
     isNegative: isNegative2,
     isInteger: isInteger3
   }) => {
@@ -26869,7 +28175,7 @@ var createCatalan = /* @__PURE__ */ factory(
         if (!isInteger3(n) || isNegative2(n)) {
           throw new TypeError("Non-negative integer value expected in function catalan");
         }
-        return divideScalar2(combinations3(multiplyScalar2(n, 2), n), addScalar2(n, 1));
+        return divideScalar2(combinations4(multiplyScalar2(n, 2), n), addScalar2(n, 1));
       }
     });
   }
@@ -27356,7 +28662,7 @@ var createSubset = /* @__PURE__ */ factory(
     typed: typed3,
     matrix: matrix2,
     zeros: zeros4,
-    add: add4
+    add: add5
   }) => {
     const referTo = typed3.referTo;
     return typed3(name119, {
@@ -27415,7 +28721,7 @@ var createSubset = /* @__PURE__ */ factory(
       const indexSize = index.size();
       if (indexSize.every((d) => d > 0)) {
         try {
-          return add4(replacement, zeros4(indexSize));
+          return add5(replacement, zeros4(indexSize));
         } catch {
           return replacement;
         }
@@ -27505,11 +28811,11 @@ function _getObjectProperty(object, index) {
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
-  const key = index.dimension(0);
-  if (typeof key !== "string") {
+  const key2 = index.dimension(0);
+  if (typeof key2 !== "string") {
     throw new TypeError("String expected as index to retrieve an object property");
   }
-  return getSafeProperty(object, key);
+  return getSafeProperty(object, key2);
 }
 function _setObjectProperty(object, index, replacement) {
   if (isEmptyIndex(index)) {
@@ -27518,12 +28824,12 @@ function _setObjectProperty(object, index, replacement) {
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
-  const key = index.dimension(0);
-  if (typeof key !== "string") {
+  const key2 = index.dimension(0);
+  if (typeof key2 !== "string") {
     throw new TypeError("String expected as index to retrieve an object property");
   }
   const updated = clone(object);
-  setSafeProperty(updated, key, replacement);
+  setSafeProperty(updated, key2, replacement);
   return updated;
 }
 
@@ -28088,7 +29394,7 @@ var dependencies127 = ["typed", "add", "multiply", "Complex", "number"];
 var createZpk2tf = /* @__PURE__ */ factory(
   name127,
   dependencies127,
-  ({ typed: typed3, add: add4, multiply: multiply2, Complex: Complex13, number: number2 }) => {
+  ({ typed: typed3, add: add5, multiply: multiply2, Complex: Complex13, number: number2 }) => {
     return typed3(name127, {
       "Array,Array,number": function(z, p, k) {
         return _zpk2tf(z, p, k);
@@ -28133,7 +29439,7 @@ var createZpk2tf = /* @__PURE__ */ factory(
         c[i] = Complex13(0, 0);
         for (let j = 0; j < a.length; j++) {
           if (i - j >= 0 && i - j < b.length) {
-            c[i] = add4(c[i], multiply2(a[j], b[i - j]));
+            c[i] = add5(c[i], multiply2(a[j], b[i - j]));
           }
         }
       }
@@ -28160,7 +29466,7 @@ var dependencies128 = ["typed", "add", "unaryPlus"];
 var createCumSum = /* @__PURE__ */ factory(
   name128,
   dependencies128,
-  ({ typed: typed3, add: add4, unaryPlus: unaryPlus2 }) => {
+  ({ typed: typed3, add: add5, unaryPlus: unaryPlus2 }) => {
     return typed3(name128, {
       // sum([a, b, c, d, ...])
       Array: _cumsum,
@@ -28201,7 +29507,7 @@ var createCumSum = /* @__PURE__ */ factory(
       }
       const sums = [unaryPlus2(array[0])];
       for (let i = 1; i < array.length; ++i) {
-        sums.push(add4(sums[i - 1], array[i]));
+        sums.push(add5(sums[i - 1], array[i]));
       }
       return sums;
     }
@@ -28259,7 +29565,7 @@ var dependencies129 = ["typed", "config", "add", "numeric", "parseNumberWithConf
 var createSum = /* @__PURE__ */ factory(
   name129,
   dependencies129,
-  ({ typed: typed3, config: config2, add: add4, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
+  ({ typed: typed3, config: config2, add: add5, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
     return typed3(name129, {
       // sum(string) - single string input
       string: function(x) {
@@ -28285,7 +29591,7 @@ var createSum = /* @__PURE__ */ factory(
       deepForEach(array, function(value) {
         try {
           const converted = typeof value === "string" ? parseNumberWithConfig2(value) : value;
-          sum3 = sum3 === void 0 ? converted : add4(sum3, converted);
+          sum3 = sum3 === void 0 ? converted : add5(sum3, converted);
         } catch (err) {
           throw improveErrorMessage(err, "sum", value);
         }
@@ -28298,7 +29604,7 @@ var createSum = /* @__PURE__ */ factory(
     function _nsumDim(array, dim) {
       try {
         const dimValue = typeof dim === "number" ? dim : dim.valueOf();
-        const sum3 = reduce2(array, dimValue, add4);
+        const sum3 = reduce2(array, dimValue, add5);
         return sum3;
       } catch (err) {
         throw improveErrorMessage(err, "sum", void 0);
@@ -29349,7 +30655,7 @@ var dependencies143 = ["typed", "config", "divideScalar", "log", "Complex"];
 var createLog1p = /* @__PURE__ */ factory(
   name143,
   dependencies143,
-  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log3, Complex: Complex13 }) => {
+  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log5, Complex: Complex13 }) => {
     return typed3(name143, {
       number: function(x) {
         if (x >= -1 || config2.predictable) {
@@ -29372,7 +30678,7 @@ var createLog1p = /* @__PURE__ */ factory(
       ),
       "any, any": typed3.referToSelf(
         (self) => (x, base) => {
-          return divideScalar2(self(x), log3(base));
+          return divideScalar2(self(x), log5(base));
         }
       )
     });
@@ -30960,7 +32266,7 @@ var createInvmod = /* @__PURE__ */ factory(
     equal: equal2,
     smaller: smaller2,
     mod: mod3,
-    add: add4,
+    add: add5,
     isInteger: isInteger3
   }) => {
     return typed3(name168, {
@@ -30977,7 +32283,7 @@ var createInvmod = /* @__PURE__ */ factory(
       const [gcd2, invValue] = resVal;
       if (!equal2(gcd2, 1)) return NaN;
       let inv3 = mod3(invValue, b);
-      if (smaller2(inv3, 0)) inv3 = add4(inv3, b);
+      if (smaller2(inv3, 0)) inv3 = add5(inv3, b);
       return inv3;
     }
   }
@@ -31081,7 +32387,7 @@ var createComposition = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     addScalar: addScalar2,
-    combinations: combinations3,
+    combinations: combinations4,
     isPositive: isPositive2,
     isNegative: _isNegative,
     isInteger: isInteger3,
@@ -31094,7 +32400,7 @@ var createComposition = /* @__PURE__ */ factory(
         } else if (larger2(k, n)) {
           throw new TypeError("k must be less than or equal to n in function composition");
         }
-        return combinations3(addScalar2(n, -1), addScalar2(k, -1));
+        return combinations4(addScalar2(n, -1), addScalar2(k, -1));
       }
     });
   }
@@ -31238,7 +32544,7 @@ var createPinv = /* @__PURE__ */ factory(
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
-    add: add4,
+    add: add5,
     Complex: Complex13
   }) => {
     return typed3(name172, {
@@ -31320,7 +32626,7 @@ var createPinv = /* @__PURE__ */ factory(
           if (i2 === r) continue;
           val = M[i2][lead];
           for (let j = 0; j < cols; j++) {
-            M[i2][j] = add4(M[i2][j], multiply2(-1, multiply2(val, M[r][j])));
+            M[i2][j] = add5(M[i2][j], multiply2(-1, multiply2(val, M[r][j])));
           }
         }
         lead++;
@@ -31334,12 +32640,12 @@ var createPinv = /* @__PURE__ */ factory(
       return { C, F };
     }
     function _isZero(x) {
-      return equal2(add4(x, Complex13(1, 1)), add4(0, Complex13(1, 1)));
+      return equal2(add5(x, Complex13(1, 1)), add5(0, Complex13(1, 1)));
     }
     function _isZeros(arr10) {
       return deepEqual3(
-        add4(arr10, Complex13(1, 1)),
-        add4(multiply2(arr10, 0), Complex13(1, 1))
+        add5(arr10, Complex13(1, 1)),
+        add5(multiply2(arr10, 0), Complex13(1, 1))
       );
     }
   }
@@ -31393,7 +32699,7 @@ var createQr = /* @__PURE__ */ factory(
     matrix: matrix2,
     zeros: zeros4,
     identity: identity2,
-    isZero: isZero2,
+    isZero: isZero4,
     equal: equal2,
     sign: sign3,
     sqrt: sqrt2,
@@ -31479,7 +32785,7 @@ var createQr = /* @__PURE__ */ factory(
           alphaSquared = addScalar2(alphaSquared, multiplyScalar2(Rdata[i][k], conj3(Rdata[i][k])));
         }
         const alpha = multiplyScalar2(sgn, sqrt2(alphaSquared));
-        if (!isZero2(alpha)) {
+        if (!isZero4(alpha)) {
           const u1 = subtractScalar2(pivot, alpha);
           w[k] = 1;
           for (i = k + 1; i < rows; i++) {
@@ -31570,8 +32876,8 @@ var createRange = /* @__PURE__ */ factory(
     smallerEq: smallerEq2,
     larger: larger2,
     largerEq: largerEq2,
-    add: add4,
-    isZero: isZero2,
+    add: add5,
+    isZero: isZero4,
     isPositive: isPositive2
   }) => {
     return typed3(name174, {
@@ -31678,12 +32984,12 @@ var createRange = /* @__PURE__ */ factory(
     }
     function _range(start, end, step, includeEnd) {
       const array = [];
-      if (isZero2(step)) throw new Error("Step must be non-zero");
+      if (isZero4(step)) throw new Error("Step must be non-zero");
       const ongoing = isPositive2(step) ? includeEnd ? smallerEq2 : smaller2 : includeEnd ? largerEq2 : larger2;
       let x = start;
       while (ongoing(x, end)) {
         array.push(x);
-        x = add4(x, step);
+        x = add5(x, step);
       }
       return array;
     }
@@ -31946,10 +33252,10 @@ var dependencies177 = ["typed", "compareText", "isZero"];
 var createEqualText = /* @__PURE__ */ factory(
   name177,
   dependencies177,
-  ({ typed: typed3, compareText: compareText4, isZero: isZero2 }) => {
+  ({ typed: typed3, compareText: compareText4, isZero: isZero4 }) => {
     return typed3(name177, {
       "any, any": function(x, y) {
-        return isZero2(compareText4(x, y));
+        return isZero4(compareText4(x, y));
       }
     });
   }
@@ -33515,9 +34821,9 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
         return obj;
       }
       if (isObjectNode(obj) && index.dimensions.length === 1 && isConstantNode(index.dimensions[0])) {
-        const key = index.dimensions[0].value;
-        if (key in obj.properties) {
-          return obj.properties[key];
+        const key2 = index.dimensions[0].value;
+        if (key2 in obj.properties) {
+          return obj.properties[key2];
         }
         return new ConstantNode();
       }
@@ -34620,9 +35926,9 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
        * list of this heap. Running time: O(1) actual.
        * @memberof FibonacciHeap
        */
-      insert(key, value) {
+      insert(key2, value) {
         const node = {
-          key,
+          key: key2,
           value,
           degree: 0
         };
@@ -34632,7 +35938,7 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
           node.right = minimum.right;
           minimum.right = node;
           node.right.left = node;
-          if (smaller2(key, minimum.key)) {
+          if (smaller2(key2, minimum.key)) {
             this._minimum = node;
           }
         } else {
@@ -34714,8 +36020,8 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
         this.extractMinimum();
       }
     }
-    function _decreaseKey(minimum, node, key) {
-      node.key = key;
+    function _decreaseKey(minimum, node, key2) {
+      node.key = key2;
       const parent = node.parent;
       if (parent && smaller2(node.key, parent.key)) {
         _cut(minimum, node, parent);
@@ -35277,7 +36583,7 @@ var dependencies211 = [
 var createSqrtm = /* @__PURE__ */ factory(
   name211,
   dependencies211,
-  ({ typed: typed3, abs: abs2, add: add4, multiply: multiply2, map: map3, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
+  ({ typed: typed3, abs: abs2, add: add5, multiply: multiply2, map: map3, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
     const _maxIterations = 1e3;
     const _tolerance = 1e-6;
     function _tryWasmSqrtm(A, n) {
@@ -35343,8 +36649,8 @@ var createSqrtm = /* @__PURE__ */ factory(
       let Z = identity2(size2(A));
       do {
         const Yk = Y;
-        Y = multiply2(0.5, add4(Yk, inv3(Z)));
-        Z = multiply2(0.5, add4(Z, inv3(Yk)));
+        Y = multiply2(0.5, add5(Yk, inv3(Z)));
+        Z = multiply2(0.5, add5(Z, inv3(Yk)));
         error = max2(abs2(subtract3(Y, Yk)));
         if (error > _tolerance && ++iterations > _maxIterations) {
           throw new Error("computing square root of matrix: iterative method could not converge");
@@ -35982,7 +37288,7 @@ var createSlu = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add4,
+    add: add5,
     multiply: multiply2,
     transpose: transpose5,
     divideScalar: divideScalar2,
@@ -35991,7 +37297,7 @@ var createSlu = /* @__PURE__ */ factory(
     largerEq: largerEq2,
     SparseMatrix
   }) => {
-    const csSqr2 = createCsSqr({ add: add4, multiply: multiply2, transpose: transpose5 });
+    const csSqr2 = createCsSqr({ add: add5, multiply: multiply2, transpose: transpose5 });
     const csLu2 = createCsLu({
       abs: abs2,
       divideScalar: divideScalar2,
@@ -36296,7 +37602,7 @@ var createIntersect = /* @__PURE__ */ factory(
     typed: typed3,
     config: config2,
     abs: abs2,
-    add: add4,
+    add: add5,
     addScalar: addScalar2,
     matrix: matrix2,
     multiply: multiply2,
@@ -36306,7 +37612,7 @@ var createIntersect = /* @__PURE__ */ factory(
     smaller: smaller2,
     equalScalar: equalScalar3,
     flatten: flatten5,
-    isZero: isZero2,
+    isZero: isZero4,
     isNumeric: isNumeric2
   }) => {
     return typed3("intersect", {
@@ -36421,7 +37727,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d1[0], d2[1]),
         multiplyScalar2(d2[0], d1[1])
       );
-      if (isZero2(det2)) return null;
+      if (isZero4(det2)) return null;
       if (smaller2(abs2(det2), config2.relTol)) {
         return null;
       }
@@ -36436,7 +37742,7 @@ var createIntersect = /* @__PURE__ */ factory(
         ),
         det2
       );
-      return add4(multiply2(d1, t), o1);
+      return add5(multiply2(d1, t), o1);
     }
     function _tryWasmIntersect2d(p1a, p1b, p2a, p2b) {
       const wasm = wasmLoader.getModule();
@@ -36495,7 +37801,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d2121, d4343),
         multiplyScalar2(d4321, d4321)
       );
-      if (isZero2(denominator)) return null;
+      if (isZero4(denominator)) return null;
       const ta = divideScalar2(numerator, denominator);
       const tb = divideScalar2(addScalar2(d1343, multiplyScalar2(ta, d4321)), d4343);
       const pax = addScalar2(x1, multiplyScalar2(ta, subtract3(x2, x1)));
@@ -36552,7 +37858,7 @@ var dependencies219 = ["typed", "add", "divide"];
 var createMean = /* @__PURE__ */ factory(
   name219,
   dependencies219,
-  ({ typed: typed3, add: add4, divide: divide2 }) => {
+  ({ typed: typed3, add: add5, divide: divide2 }) => {
     return typed3(name219, {
       // mean([a, b, c, d, ...])
       "Array | Matrix": _mean2,
@@ -36569,7 +37875,7 @@ var createMean = /* @__PURE__ */ factory(
     function _nmeanDim(array, dim) {
       try {
         const dimValue = typeof dim === "number" ? dim : dim.valueOf();
-        const sum3 = reduce2(array, dimValue, add4);
+        const sum3 = reduce2(array, dimValue, add5);
         const s = Array.isArray(array) ? arraySize(array) : array.size();
         return divide2(sum3, s[dimValue]);
       } catch (err) {
@@ -36597,7 +37903,7 @@ var createMean = /* @__PURE__ */ factory(
       let num2 = 0;
       deepForEach(array, function(value) {
         try {
-          sum3 = sum3 === void 0 ? value : add4(sum3, value);
+          sum3 = sum3 === void 0 ? value : add5(sum3, value);
           num2++;
         } catch (err) {
           throw improveErrorMessage(err, "mean", value);
@@ -36617,7 +37923,7 @@ var dependencies220 = ["typed", "add", "divide", "compare", "partitionSelect"];
 var createMedian = /* @__PURE__ */ factory(
   name220,
   dependencies220,
-  ({ typed: typed3, add: add4, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
+  ({ typed: typed3, add: add5, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
     function _median2(array) {
       try {
         const flat = flatten2(array.valueOf());
@@ -36650,7 +37956,7 @@ var createMedian = /* @__PURE__ */ factory(
     });
     const middle2 = typed3({
       "number | BigNumber | Complex | Unit, number | BigNumber | Complex | Unit": function(left, right) {
-        return divide2(add4(left, right), 2);
+        return divide2(add5(left, right), 2);
       }
     });
     return typed3(name220, {
@@ -36689,7 +37995,7 @@ var createVariance = /* @__PURE__ */ factory(
   dependencies221,
   ({
     typed: typed3,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -36738,7 +38044,7 @@ var createVariance = /* @__PURE__ */ factory(
       let num2 = 0;
       deepForEach(array, function(value) {
         try {
-          sum3 = sum3 === void 0 ? value : add4(sum3, value);
+          sum3 = sum3 === void 0 ? value : add5(sum3, value);
           num2++;
         } catch (err) {
           throw improveErrorMessage(err, "variance", value);
@@ -36749,7 +38055,7 @@ var createVariance = /* @__PURE__ */ factory(
       sum3 = void 0;
       deepForEach(array, function(value) {
         const diff2 = subtract3(value, mean7);
-        sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add4(sum3, multiply2(diff2, diff2));
+        sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add5(sum3, multiply2(diff2, diff2));
       });
       if (mathIsNaN(sum3)) {
         return sum3;
@@ -36824,7 +38130,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     bignumber: bignumber2,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     divide: divide2,
     multiply: multiply2,
@@ -36872,7 +38178,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
             "N must be less than or equal to 2^32-1, as that is the maximum length of an Array"
           );
         }
-        const nPlusOne = add4(probOrN, 1);
+        const nPlusOne = add5(probOrN, 1);
         probArr = [];
         for (let i = 0; smaller2(i, probOrN); i++) {
           const prob = divide2(i + 1, nPlusOne);
@@ -36929,11 +38235,11 @@ var createQuantileSeq = /* @__PURE__ */ factory(
           return integerPart % 2 === 0 ? left : right;
         }
         case "midpoint":
-          return divide2(add4(left, right), 2);
+          return divide2(add5(left, right), 2);
         case "linear":
         default: {
           const fracPartConverted = isBigNumber(left) && isNumber(fracPart) ? bignumber2(fracPart) : fracPart;
-          return add4(
+          return add5(
             multiply2(left, subtract3(1, fracPartConverted)),
             multiply2(right, fracPartConverted)
           );
@@ -36967,7 +38273,7 @@ var createKldivergence = /* @__PURE__ */ factory(
     multiply: multiply2,
     map: map3,
     dotDivide: dotDivide2,
-    log: log3,
+    log: log5,
     isNumeric: isNumeric2
   }) => {
     return typed3(name223, {
@@ -37009,7 +38315,7 @@ var createKldivergence = /* @__PURE__ */ factory(
       const result = sum3(
         multiply2(
           qnorm,
-          map3(dotDivide2(qnorm, pnorm), (x) => log3(x))
+          map3(dotDivide2(qnorm, pnorm), (x) => log5(x))
         )
       );
       if (isNumeric2(result)) {
@@ -37027,7 +38333,7 @@ var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInt
 var createMultinomial = /* @__PURE__ */ factory(
   name224,
   dependencies224,
-  ({ typed: typed3, add: add4, divide: divide2, multiply: multiply2, factorial: factorial6, isInteger: isInteger3, isPositive: isPositive2 }) => {
+  ({ typed: typed3, add: add5, divide: divide2, multiply: multiply2, factorial: factorial6, isInteger: isInteger3, isPositive: isPositive2 }) => {
     return typed3(name224, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
@@ -37036,7 +38342,7 @@ var createMultinomial = /* @__PURE__ */ factory(
           if (!isInteger3(ai) || !isPositive2(ai)) {
             throw new TypeError("Positive integer value expected in function multinomial");
           }
-          sum3 = add4(sum3, ai);
+          sum3 = add5(sum3, ai);
           denom = multiply2(denom, factorial6(ai));
         });
         return divide2(factorial6(sum3), denom);
@@ -37052,7 +38358,7 @@ var dependencies225 = ["typed", "add", "multiply", "Complex", "divide", "matrix"
 var createFreqz = /* @__PURE__ */ factory(
   name225,
   dependencies225,
-  ({ typed: typed3, add: add4, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
+  ({ typed: typed3, add: add5, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
     return typed3(name225, {
       "Array, Array": function(b, a) {
         const w = createBins(512);
@@ -37146,13 +38452,13 @@ var createFreqz = /* @__PURE__ */ factory(
         let sumNum = Complex13(0, 0);
         let sumDen = Complex13(0, 0);
         for (let j = 0; j < b.length; j++) {
-          sumNum = add4(
+          sumNum = add5(
             sumNum,
             multiply2(b[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
         for (let j = 0; j < a.length; j++) {
-          sumDen = add4(
+          sumDen = add5(
             sumDen,
             multiply2(a[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
@@ -37717,7 +39023,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
     typed: typed3,
     parse: _parse2,
     equal: equal2,
-    isZero: isZero2,
+    isZero: isZero4,
     add: _add,
     subtract: _subtract,
     multiply: _multiply2,
@@ -37815,10 +39121,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         const a0 = _simplifyCore(node.args[0], options);
         let a1 = _simplifyCore(node.args[1], options);
         if (node.op === "+") {
-          if (isConstantNode(a0) && isZero2(a0.value)) {
+          if (isConstantNode(a0) && isZero4(a0.value)) {
             return a1;
           }
-          if (isConstantNode(a1) && isZero2(a1.value)) {
+          if (isConstantNode(a1) && isZero4(a1.value)) {
             return a0;
           }
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === "-") {
@@ -37830,24 +39136,24 @@ var createSimplifyCore = /* @__PURE__ */ factory(
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === "-") {
             return _simplifyCore(new OperatorNode("+", "add", [a0, a1.args[0]]), options);
           }
-          if (isConstantNode(a0) && isZero2(a0.value)) {
+          if (isConstantNode(a0) && isZero4(a0.value)) {
             return _simplifyCore(new OperatorNode("-", "unaryMinus", [a1]));
           }
-          if (isConstantNode(a1) && isZero2(a1.value)) {
+          if (isConstantNode(a1) && isZero4(a1.value)) {
             return a0;
           }
           return new OperatorNode(node.op, node.fn, [a0, a1]);
         }
         if (node.op === "*") {
           if (isConstantNode(a0)) {
-            if (isZero2(a0.value)) {
+            if (isZero4(a0.value)) {
               return node0;
             } else if (equal2(a0.value, 1)) {
               return a1;
             }
           }
           if (isConstantNode(a1)) {
-            if (isZero2(a1.value)) {
+            if (isZero4(a1.value)) {
               return node0;
             } else if (equal2(a1.value, 1)) {
               return a0;
@@ -37859,7 +39165,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
           return new OperatorNode(node.op, node.fn, [a0, a1], node.implicit);
         }
         if (node.op === "/") {
-          if (isConstantNode(a0) && isZero2(a0.value)) {
+          if (isConstantNode(a0) && isZero4(a0.value)) {
             return node0;
           }
           if (isConstantNode(a1) && equal2(a1.value, 1)) {
@@ -37869,7 +39175,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         }
         if (node.op === "^") {
           if (isConstantNode(a1)) {
-            if (isZero2(a1.value)) {
+            if (isZero4(a1.value)) {
               return node1;
             } else if (equal2(a1.value, 1)) {
               return a0;
@@ -37967,9 +39273,9 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
   dependencies234,
   ({
     typed: typed3,
-    isZero: isZero2,
+    isZero: isZero4,
     equalScalar: equalScalar3,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -37983,7 +39289,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
     return typed3(name234, {
       "number|Complex, ...number|Complex": (constant, restCoeffs) => {
         const coeffs = [constant, ...restCoeffs];
-        while (coeffs.length > 0 && isZero2(coeffs[coeffs.length - 1])) {
+        while (coeffs.length > 0 && isZero4(coeffs[coeffs.length - 1])) {
           coeffs.pop();
         }
         if (coeffs.length < 2) {
@@ -38011,15 +39317,15 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             const denom = unaryMinus2(multiply2(3, a));
             const D0_1 = multiply2(b, b);
             const D0_2 = multiply2(3, a, c);
-            const D1_1 = add4(multiply2(2, b, b, b), multiply2(27, a, a, d));
+            const D1_1 = add5(multiply2(2, b, b, b), multiply2(27, a, a, d));
             const D1_2 = multiply2(9, a, b, c);
             if (equalScalar3(D0_1, D0_2) && equalScalar3(D1_1, D1_2)) {
               return [divide2(b, denom)];
             }
             const Delta0 = subtract3(D0_1, D0_2);
             const Delta1 = subtract3(D1_1, D1_2);
-            const discriminant1 = add4(multiply2(18, a, b, c, d), multiply2(b, b, c, c));
-            const discriminant2 = add4(
+            const discriminant1 = add5(multiply2(18, a, b, c, d), multiply2(b, b, c, c));
+            const discriminant2 = add5(
               multiply2(4, b, b, b, d),
               multiply2(4, a, c, c, c),
               multiply2(27, a, a, d, d)
@@ -38027,7 +39333,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             if (equalScalar3(discriminant1, discriminant2)) {
               return [
                 divide2(
-                  subtract3(multiply2(4, a, b, c), add4(multiply2(9, a, a, d), multiply2(b, b, b))),
+                  subtract3(multiply2(4, a, b, c), add5(multiply2(9, a, a, d), multiply2(b, b, b))),
                   multiply2(a, Delta0)
                 ),
                 // simple root
@@ -38040,7 +39346,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
               Ccubed = Delta1;
             } else {
               Ccubed = divide2(
-                add4(
+                add5(
                   Delta1,
                   sqrt2(subtract3(multiply2(Delta1, Delta1), multiply2(4, Delta0, Delta0, Delta0)))
                 ),
@@ -38048,7 +39354,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
               );
             }
             const allRoots = true;
-            const rawRoots = cbrt3(Ccubed, allRoots).toArray().map((C) => divide2(add4(b, C, divide2(Delta0, C)), denom));
+            const rawRoots = cbrt3(Ccubed, allRoots).toArray().map((C) => divide2(add5(b, C, divide2(Delta0, C)), denom));
             return rawRoots.map((r) => {
               if (typeOf3(r) === "Complex" && equalScalar3(re3(r), re3(r) + im3(r))) {
                 return re3(r);
@@ -38104,7 +39410,7 @@ var createZeta = /* @__PURE__ */ factory(
     gamma: gamma2,
     sin: sin2,
     subtract: subtract3,
-    add: add4,
+    add: add5,
     Complex: Complex13,
     BigNumber: BigNumber9,
     pi
@@ -38172,20 +39478,20 @@ var createZeta = /* @__PURE__ */ factory(
     }
     function d(k, n) {
       let S = k;
-      for (let j = k; smallerEq2(j, n); j = add4(j, 1)) {
+      for (let j = k; smallerEq2(j, n); j = add5(j, 1)) {
         const factor2 = divide2(
-          multiply2(factorial6(add4(n, subtract3(j, 1))), pow2(4, j)),
+          multiply2(factorial6(add5(n, subtract3(j, 1))), pow2(4, j)),
           multiply2(factorial6(subtract3(n, j)), factorial6(multiply2(2, j)))
         );
-        S = add4(S, factor2);
+        S = add5(S, factor2);
       }
       return multiply2(n, S);
     }
     function f(s, n, createValue) {
       const c = divide2(1, multiply2(d(createValue(0), n), subtract3(1, pow2(2, subtract3(1, s)))));
       let S = createValue(0);
-      for (let k = createValue(1); smallerEq2(k, n); k = add4(k, 1)) {
-        S = add4(S, divide2(multiply2((-1) ** (k - 1), d(k, n)), pow2(k, s)));
+      for (let k = createValue(1); smallerEq2(k, n); k = add5(k, 1)) {
+        S = add5(S, divide2(multiply2((-1) ** (k - 1), d(k, n)), pow2(k, s)));
       }
       return multiply2(c, S);
     }
@@ -38622,11 +39928,11 @@ function createComplexEigs({
       M[i] = Array(N2).fill(0);
     }
     let I2 = 0;
-    for (const sub3 of arr10) {
-      const n = sub3.length;
+    for (const sub4 of arr10) {
+      const n = sub4.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
-          M[I2 + i][I2 + j] = sub3[i][j];
+          M[I2 + i][I2 + j] = sub4[i][j];
         }
       }
       I2 += n;
@@ -38734,7 +40040,7 @@ function createRealSymmetric({
   inv: inv3,
   bignumber: bignumber2,
   multiply: multiply2,
-  add: add4
+  add: add5
 }) {
   function bigGte(a, b) {
     if (typeof a === "number" && typeof b === "number") return a >= b;
@@ -38931,7 +40237,7 @@ function createRealSymmetric({
       subtract3(multiplyScalar2(c2, Hij[i][i]), csHij),
       multiplyScalar2(s2, Hij[j][j])
     );
-    const Ajj = add4(
+    const Ajj = add5(
       multiplyScalar2(s2, Hij[i][i]),
       csHij,
       multiplyScalar2(c2, Hij[j][j])
@@ -39103,7 +40409,7 @@ var createEigs = /* @__PURE__ */ factory(
     inv: inv3,
     bignumber: bignumber2,
     multiply: multiply2,
-    add: add4,
+    add: add5,
     larger: larger2,
     column: _column,
     flatten: flatten5,
@@ -39135,7 +40441,7 @@ var createEigs = /* @__PURE__ */ factory(
       bignumber: bignumber2,
       complex: complex3,
       multiply: multiply2,
-      add: add4
+      add: add5
     });
     const doComplexEigs = createComplexEigs({
       addScalar: addScalar2,
@@ -40158,10 +41464,10 @@ var createSimplify = /* @__PURE__ */ factory(
         const native = /* @__PURE__ */ new Map();
         const sm = scope;
         if (typeof sm.forEach === "function") {
-          sm.forEach((value, key) => native.set(key, value));
+          sm.forEach((value, key2) => native.set(key2, value));
         } else {
-          for (const [key, value] of Object.entries(scope)) {
-            native.set(key, value);
+          for (const [key2, value] of Object.entries(scope)) {
+            native.set(key2, value);
           }
         }
         scope = native;
@@ -40351,19 +41657,19 @@ var createSimplify = /* @__PURE__ */ factory(
       } else if (!match2.placeholders) {
         return match1;
       }
-      for (const key in match1.placeholders) {
-        if (hasOwnProperty(match1.placeholders, key)) {
-          res.placeholders[key] = match1.placeholders[key];
-          if (hasOwnProperty(match2.placeholders, key)) {
-            if (!_exactMatch(match1.placeholders[key], match2.placeholders[key])) {
+      for (const key2 in match1.placeholders) {
+        if (hasOwnProperty(match1.placeholders, key2)) {
+          res.placeholders[key2] = match1.placeholders[key2];
+          if (hasOwnProperty(match2.placeholders, key2)) {
+            if (!_exactMatch(match1.placeholders[key2], match2.placeholders[key2])) {
               return null;
             }
           }
         }
       }
-      for (const key in match2.placeholders) {
-        if (hasOwnProperty(match2.placeholders, key)) {
-          res.placeholders[key] = match2.placeholders[key];
+      for (const key2 in match2.placeholders) {
+        if (hasOwnProperty(match2.placeholders, key2)) {
+          res.placeholders[key2] = match2.placeholders[key2];
         }
       }
       return res;
@@ -40605,7 +41911,7 @@ var createDerivative = /* @__PURE__ */ factory(
     parse: parse3,
     simplify: simplify2,
     equal: equal2,
-    isZero: isZero2,
+    isZero: isZero4,
     numeric: numeric2,
     ConstantNode,
     FunctionNode,
@@ -40637,7 +41943,7 @@ var createDerivative = /* @__PURE__ */ factory(
       }
       return symbol;
     }
-    const derivative2 = typed3(name244, {
+    const derivative3 = typed3(name244, {
       "Node, SymbolNode": plainDerivative,
       "Node, SymbolNode, Object": plainDerivative,
       "Node, string": (node, symbol) => plainDerivative(node, parseIdentifier(symbol)),
@@ -40653,8 +41959,8 @@ var createDerivative = /* @__PURE__ */ factory(
       }
       */
     });
-    derivative2._simplify = true;
-    derivative2.toTex = function(deriv) {
+    derivative3._simplify = true;
+    derivative3.toTex = function(deriv) {
       return _derivTex(...deriv.args);
     };
     const _derivTex = typed3("_derivTex", {
@@ -41081,7 +42387,7 @@ var createDerivative = /* @__PURE__ */ factory(
           const arg0 = node.args[0];
           const arg1 = node.args[1];
           if (isConst2(arg0)) {
-            if (isConstantNode(arg0) && (isZero2(arg0.value) || equal2(arg0.value, 1))) {
+            if (isConstantNode(arg0) && (isZero4(arg0.value) || equal2(arg0.value, 1))) {
               return createConstantNode2(0);
             }
             return new OperatorNode("*", "multiply", [
@@ -41094,7 +42400,7 @@ var createDerivative = /* @__PURE__ */ factory(
           }
           if (isConst2(arg1)) {
             if (isConstantNode(arg1)) {
-              if (isZero2(arg1.value)) {
+              if (isZero4(arg1.value)) {
                 return createConstantNode2(0);
               }
               if (equal2(arg1.value, 1)) {
@@ -41132,7 +42438,7 @@ var createDerivative = /* @__PURE__ */ factory(
     function createConstantNode2(value, valueType) {
       return new ConstantNode(numeric2(value, valueType || safeNumberType(String(value), config2)));
     }
-    return derivative2;
+    return derivative3;
   }
 );
 
@@ -41161,7 +42467,7 @@ var createNorm = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add4,
+    add: add5,
     pow: pow2,
     conj: conj3,
     sqrt: sqrt2,
@@ -41266,7 +42572,7 @@ var createNorm = /* @__PURE__ */ factory(
         if (!equalScalar3(p, 0)) {
           let n = 0;
           x.forEach(function(value) {
-            n = add4(pow2(abs2(value), p), n);
+            n = add5(pow2(abs2(value), p), n);
           }, true);
           return pow2(n, 1 / p);
         }
@@ -41277,7 +42583,7 @@ var createNorm = /* @__PURE__ */ factory(
     function _matrixNormFrobenius(x) {
       let fro = 0;
       x.forEach(function(value) {
-        fro = add4(fro, multiply2(value, conj3(value)));
+        fro = add5(fro, multiply2(value, conj3(value)));
       });
       return abs2(sqrt2(fro));
     }
@@ -41286,7 +42592,7 @@ var createNorm = /* @__PURE__ */ factory(
       let maxc = 0;
       x.forEach(function(value, index) {
         const j = index[1];
-        const cj = add4(c[j] || 0, abs2(value));
+        const cj = add5(c[j] || 0, abs2(value));
         if (larger2(cj, maxc)) {
           maxc = cj;
         }
@@ -41310,7 +42616,7 @@ var createNorm = /* @__PURE__ */ factory(
       let maxr = 0;
       x.forEach(function(value, index) {
         const i = index[0];
-        const ri = add4(r[i] || 0, abs2(value));
+        const ri = add5(r[i] || 0, abs2(value));
         if (larger2(ri, maxr)) {
           maxr = ri;
         }
@@ -42144,7 +43450,7 @@ var createSylvester = /* @__PURE__ */ factory(
     transpose: transpose5,
     index,
     subset: subset2,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     identity: identity2,
     lusolve: lusolve2,
@@ -42192,7 +43498,7 @@ var createSylvester = /* @__PURE__ */ factory(
         if (k < n - 1 && abs2(subset2(G, index(k + 1, k))) > 1e-5) {
           let RHS = vc(subset2(D, index(all, [k])), subset2(D, index(all, [k + 1])));
           for (let j = 0; j < k; j++) {
-            RHS = add4(
+            RHS = add5(
               RHS,
               vc(multiply2(y[j], subset2(G, index(j, k))), multiply2(y[j], subset2(G, index(j, k + 1))))
             );
@@ -42201,7 +43507,7 @@ var createSylvester = /* @__PURE__ */ factory(
           const gmk = multiply2(identity2(m), multiply2(-1, subset2(G, index(k + 1, k))));
           const gkm = multiply2(identity2(m), multiply2(-1, subset2(G, index(k, k + 1))));
           const gmm = multiply2(identity2(m), multiply2(-1, subset2(G, index(k + 1, k + 1))));
-          const LHS = vc(hc(add4(F, gkk), gmk), hc(gkm, add4(F, gmm)));
+          const LHS = vc(hc(add5(F, gkk), gmk), hc(gkm, add5(F, gmm)));
           const yAux = lusolve2(LHS, RHS);
           y[k] = yAux.subset(index(range2(0, m), [0]));
           y[k + 1] = yAux.subset(index(range2(m, 2 * m), [0]));
@@ -42209,7 +43515,7 @@ var createSylvester = /* @__PURE__ */ factory(
         } else {
           let RHS = subset2(D, index(all, [k]));
           for (let j = 0; j < k; j++) {
-            RHS = add4(RHS, multiply2(y[j], subset2(G, index(j, k))));
+            RHS = add5(RHS, multiply2(y[j], subset2(G, index(j, k))));
           }
           const gkk = subset2(G, index(k, k));
           const LHS = subtract3(F, multiply2(gkk, identity2(m)));
@@ -42534,7 +43840,7 @@ var getMatrixDataType = createGetMatrixDataType(
 var map2 = createMap(factoryScope);
 var size = createSize(factoryScope);
 var squeeze2 = createSqueeze(factoryScope);
-var combinations2 = createCombinations(factoryScope);
+var combinations3 = createCombinations(factoryScope);
 var combinationsWithRep2 = createCombinationsWithRep(
   factoryScope
 );
@@ -42558,7 +43864,7 @@ var isNaN2 = createIsNaN(factoryScope);
 var isNegative = createIsNegative(factoryScope);
 var isNumeric = createIsNumeric(factoryScope);
 var isPositive = createIsPositive(factoryScope);
-var isPrime = createIsPrime(factoryScope);
+var isPrime2 = createIsPrime(factoryScope);
 var numeric = createNumeric(factoryScope);
 var typeOf2 = createTypeOf(factoryScope);
 var factory_abs = createAbs(factoryScope);
@@ -42605,7 +43911,7 @@ factoryScope.atan = factory_atan;
 factoryScope.atanh = factory_atanh;
 factoryScope.bitNot = bitNot2;
 factoryScope.clone = clone2;
-factoryScope.combinations = combinations2;
+factoryScope.combinations = combinations3;
 factoryScope.combinationsWithRep = combinationsWithRep2;
 factoryScope.conj = conj2;
 factoryScope.cos = factory_cos;
@@ -42624,7 +43930,7 @@ factoryScope.isNaN = isNaN2;
 factoryScope.isNegative = isNegative;
 factoryScope.isNumeric = isNumeric;
 factoryScope.isPositive = isPositive;
-factoryScope.isPrime = isPrime;
+factoryScope.isPrime = isPrime2;
 factoryScope.lgamma = lgamma2;
 factoryScope.log2 = factory_log2;
 factoryScope.log10 = factory_log10;
@@ -42671,7 +43977,7 @@ var hasNumericValue = createHasNumericValue(
   factoryScope
 );
 var isFinite2 = createIsFinite(factoryScope);
-var isZero = createIsZero(factoryScope);
+var isZero3 = createIsZero(factoryScope);
 var factory_unaryPlus = createUnaryPlus(
   factoryScope
 );
@@ -42683,7 +43989,7 @@ factoryScope.unaryPlus = factory_unaryPlus;
 factoryScope.flatten = flatten3;
 factoryScope.hasNumericValue = hasNumericValue;
 factoryScope.isFinite = isFinite2;
-factoryScope.isZero = isZero;
+factoryScope.isZero = isZero3;
 factoryScope.prod = prod;
 factoryScope.dot = factory_dot;
 factoryScope.squeeze = squeeze2;
@@ -43150,8 +44456,8 @@ var setSymDifference2 = createSetSymDifference(
 factoryScope.setSymDifference = setSymDifference2;
 var simplify = createSimplify(factoryScope);
 factoryScope.simplify = simplify;
-var derivative = createDerivative(factoryScope);
-factoryScope.derivative = derivative;
+var derivative2 = createDerivative(factoryScope);
+factoryScope.derivative = derivative2;
 var factory_norm = createNorm(factoryScope);
 factoryScope.norm = factory_norm;
 var rationalize = createRationalize(
@@ -43376,7 +44682,7 @@ var mathScope = {
 };
 {
   const mwt = factoryScope.mathWithTransform;
-  for (const key of [
+  for (const key2 of [
     "and",
     "bitAnd",
     "bitOr",
@@ -43403,7 +44709,7 @@ var mathScope = {
     "sum",
     "variance"
   ]) {
-    if (typeof mwt[key] === "function") mathScope[key] = mwt[key];
+    if (typeof mwt[key2] === "function") mathScope[key2] = mwt[key2];
   }
 }
 var parse = factoryScope.parse;
@@ -43434,7 +44740,7 @@ function parser() {
     },
     /** Clear all retained variables. */
     clear() {
-      for (const key of Object.keys(scope)) delete scope[key];
+      for (const key2 of Object.keys(scope)) delete scope[key2];
     }
   };
 }
@@ -44072,9 +45378,9 @@ function numericRealRoots(expr, varName) {
   const addRoot = (r) => {
     const rounded = Math.round(r);
     const clean = Math.abs(r - rounded) < 1e-8 ? rounded : r;
-    const key = clean.toFixed(8);
-    if (!seen.has(key)) {
-      seen.add(key);
+    const key2 = clean.toFixed(8);
+    if (!seen.has(key2)) {
+      seen.add(key2);
       roots.push(clean);
     }
   };
@@ -44143,25 +45449,25 @@ function solve(equation, varName) {
       return Math.abs(x - rounded) < 1e-8 ? rounded : x;
     }, pushReal2 = function(x) {
       const clean = cleanComponent2(x);
-      const key = `r${clean.toFixed(8)}`;
-      if (!seen.has(key)) {
-        seen.add(key);
+      const key2 = `r${clean.toFixed(8)}`;
+      if (!seen.has(key2)) {
+        seen.add(key2);
         reals.push(clean);
       }
     };
     var cleanComponent = cleanComponent2, pushReal = pushReal2;
     const [c0, c1, c2, c3] = coeffs;
     const eps = 1e-9;
-    let degree2 = 0;
-    if (Math.abs(c3) > eps) degree2 = 3;
-    else if (Math.abs(c2) > eps) degree2 = 2;
-    else if (Math.abs(c1) > eps) degree2 = 1;
-    if (degree2 === 0) {
+    let degree3 = 0;
+    if (Math.abs(c3) > eps) degree3 = 3;
+    else if (Math.abs(c2) > eps) degree3 = 2;
+    else if (Math.abs(c1) > eps) degree3 = 1;
+    if (degree3 === 0) {
       return [];
     }
     let raw;
     try {
-      const args = [c0, c1, c2, c3].slice(0, degree2 + 1);
+      const args = [c0, c1, c2, c3].slice(0, degree3 + 1);
       raw = polynomialRoot(...args);
     } catch {
       return numericRealRoots(expr, varName);
@@ -44176,9 +45482,9 @@ function solve(equation, varName) {
         } else {
           const re3 = cleanComponent2(r.re);
           const im3 = cleanComponent2(r.im);
-          const key = `${re3.toFixed(8)}|${im3.toFixed(8)}`;
-          if (!seen.has(key)) {
-            seen.add(key);
+          const key2 = `${re3.toFixed(8)}|${im3.toFixed(8)}`;
+          if (!seen.has(key2)) {
+            seen.add(key2);
             complexRoots.push(new Complex10(re3, im3));
           }
         }
@@ -44259,15 +45565,15 @@ function asymptotic(expr, varName, towards = Infinity) {
     const avgOrder = (logRatio1 + logRatio2) / 2;
     const roundedOrder = Math.round(avgOrder * 2) / 2;
     const coefficient = f3 / Math.pow(x3, roundedOrder);
-    let leadingTerm;
+    let leadingTerm2;
     if (roundedOrder === 0) {
-      leadingTerm = formatCoeff(coefficient);
+      leadingTerm2 = formatCoeff(coefficient);
     } else if (roundedOrder === 1) {
-      leadingTerm = `${formatCoeff(coefficient)}*${varName}`;
+      leadingTerm2 = `${formatCoeff(coefficient)}*${varName}`;
     } else {
-      leadingTerm = `${formatCoeff(coefficient)}*${varName}^${roundedOrder}`;
+      leadingTerm2 = `${formatCoeff(coefficient)}*${varName}^${roundedOrder}`;
     }
-    return { leadingTerm, order: roundedOrder, coefficient };
+    return { leadingTerm: leadingTerm2, order: roundedOrder, coefficient };
   }
   const lim = limit(expr, varName, towards);
   return { leadingTerm: formatCoeff(lim), order: 0, coefficient: lim };
@@ -44872,8 +46178,8 @@ function _combineLikeTerms(expr) {
     const cvpMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)\^(\d+)$/);
     if (cvpMatch) {
       const c = cvpMatch[1] === "" || cvpMatch[1] === "+" ? 1 : cvpMatch[1] === "-" ? -1 : Number(cvpMatch[1]);
-      const key = cvpMatch[2] + "^" + cvpMatch[3];
-      termMap.set(key, (termMap.get(key) ?? 0) + c);
+      const key2 = cvpMatch[2] + "^" + cvpMatch[3];
+      termMap.set(key2, (termMap.get(key2) ?? 0) + c);
       continue;
     }
     const cvMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)$/);
@@ -44885,16 +46191,16 @@ function _combineLikeTerms(expr) {
     otherTerms.push(t);
   }
   const parts = [];
-  for (const [key, c] of termMap) {
+  for (const [key2, c] of termMap) {
     if (Math.abs(c) < 1e-12) continue;
-    if (key === "__const__") {
+    if (key2 === "__const__") {
       parts.push(String(c));
     } else if (Math.abs(c - 1) < 1e-12) {
-      parts.push(key);
+      parts.push(key2);
     } else if (Math.abs(c + 1) < 1e-12) {
-      parts.push("-" + key);
+      parts.push("-" + key2);
     } else {
-      parts.push(c + "*" + key);
+      parts.push(c + "*" + key2);
     }
   }
   parts.push(...otherTerms);
@@ -45048,8 +46354,8 @@ function casSimplify(input) {
         const cvpMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)\^(\d+)$/);
         if (cvpMatch) {
           const c = cvpMatch[1] === "" || cvpMatch[1] === "+" ? 1 : cvpMatch[1] === "-" ? -1 : Number(cvpMatch[1]);
-          const key = cvpMatch[2] + "^" + cvpMatch[3];
-          termMap.set(key, (termMap.get(key) ?? 0) + c);
+          const key2 = cvpMatch[2] + "^" + cvpMatch[3];
+          termMap.set(key2, (termMap.get(key2) ?? 0) + c);
           continue;
         }
         const cvMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)$/);
@@ -45061,16 +46367,16 @@ function casSimplify(input) {
         otherTerms.push(t);
       }
       const parts = [];
-      for (const [key, c] of termMap) {
+      for (const [key2, c] of termMap) {
         if (Math.abs(c) < 1e-12) continue;
-        if (key === "__const__") {
+        if (key2 === "__const__") {
           parts.push(String(c));
         } else if (Math.abs(c - 1) < 1e-12) {
-          parts.push(key);
+          parts.push(key2);
         } else if (Math.abs(c + 1) < 1e-12) {
-          parts.push("-" + key);
+          parts.push("-" + key2);
         } else {
-          parts.push(c + "*" + key);
+          parts.push(c + "*" + key2);
         }
       }
       parts.push(...otherTerms);
@@ -45296,16 +46602,16 @@ function discreteLog(g, h, p) {
   const table = /* @__PURE__ */ new Map();
   let cur = 1n;
   for (let j = 0n; j < m; j++) {
-    const key = cur.toString();
-    if (!table.has(key)) table.set(key, j);
+    const key2 = cur.toString();
+    if (!table.has(key2)) table.set(key2, j);
     cur = cur * G % P2;
   }
   const gm = modPowBig(G, m, P2);
   const gInvM = modInverseBig(gm, P2);
   let gamma2 = H;
   for (let i = 0n; i < m; i++) {
-    const key = gamma2.toString();
-    const j = table.get(key);
+    const key2 = gamma2.toString();
+    const j = table.get(key2);
     if (j !== void 0) {
       return Number(i * m + j);
     }
@@ -46415,7 +47721,7 @@ function scale(alpha, x) {
 function subtract2(a, b) {
   return a.map((v, i) => v - b[i]);
 }
-function add2(a, b) {
+function add3(a, b) {
   return a.map((v, i) => v + b[i]);
 }
 function zeros2(n) {
@@ -46584,7 +47890,7 @@ function cg(a, b, opts) {
     z = applyM(r);
     const rzNew = dot2(r, z);
     const beta2 = rzNew / rzOld;
-    p = add2(z, scale(beta2, p));
+    p = add3(z, scale(beta2, p));
     rzOld = rzNew;
   }
   return { x, iterations, converged: residual < tol, residual };
@@ -46751,7 +48057,7 @@ function bicgstab(a, b, opts) {
       p = r.slice();
     } else {
       const beta2 = rhoNew / rho * (alpha / omega);
-      p = add2(r, scale(beta2, subtract2(p, scale(omega, v))));
+      p = add3(r, scale(beta2, subtract2(p, scale(omega, v))));
     }
     rho = rhoNew;
     const pHat = applyM(p);
@@ -47004,12 +48310,12 @@ function svds(A, k = 1, opts) {
 }
 
 // src/numeric/structured-solvers.ts
-function thomasSolve(sub3, diag2, sup, d) {
+function thomasSolve(sub4, diag2, sup, d) {
   const n = diag2.length;
   if (n === 0) return [];
-  if (sub3.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
+  if (sub4.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
     throw new Error(
-      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub3.length}, sup=${sup.length}, d=${d.length}`
+      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub4.length}, sup=${sup.length}, d=${d.length}`
     );
   }
   const cp = new Array(n).fill(0);
@@ -47018,12 +48324,12 @@ function thomasSolve(sub3, diag2, sup, d) {
   cp[0] = n > 1 ? sup[0] / diag2[0] : 0;
   dp[0] = d[0] / diag2[0];
   for (let i = 1; i < n; i++) {
-    const m = diag2[i] - sub3[i - 1] * cp[i - 1];
+    const m = diag2[i] - sub4[i - 1] * cp[i - 1];
     if (m === 0) {
       throw new Error(`thomasSolve: zero pivot at row ${i} (no pivoting is performed)`);
     }
     cp[i] = i < n - 1 ? sup[i] / m : 0;
-    dp[i] = (d[i] - sub3[i - 1] * dp[i - 1]) / m;
+    dp[i] = (d[i] - sub4[i - 1] * dp[i - 1]) / m;
   }
   const x = new Array(n);
   x[n - 1] = dp[n - 1];
@@ -47957,7 +49263,7 @@ function bsplineEval(spline, xnew) {
 }
 
 // src/numeric/monte-carlo.ts
-function isPrime2(x) {
+function isPrime3(x) {
   if (x < 2) return false;
   for (let i = 2; i * i <= x; i++) {
     if (x % i === 0) return false;
@@ -47969,7 +49275,7 @@ function nthPrime(k) {
   let candidate = 1;
   while (count2 < k) {
     candidate++;
-    if (isPrime2(candidate)) count2++;
+    if (isPrime3(candidate)) count2++;
   }
   return candidate;
 }
@@ -48607,18 +49913,18 @@ function nelderMead(f, x0, opts = {}) {
     for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) c[j] += pts[i][j] / n;
     return c;
   };
-  const add4 = (a, b, s) => a.map((v, i) => v + s * b[i]);
-  const sub3 = (a, b) => a.map((v, i) => v - b[i]);
+  const add5 = (a, b, s) => a.map((v, i) => v + s * b[i]);
+  const sub4 = (a, b) => a.map((v, i) => v - b[i]);
   for (; iter < maxIter; iter++) {
     const order = fv.map((_, i) => i).sort((i, j) => fv[i] - fv[j]);
     simplex = order.map((i) => simplex[i]);
     fv = order.map((i) => fv[i]);
     if (Math.abs(fv[n] - fv[0]) <= tol * (Math.abs(fv[0]) + tol)) break;
     const c = centroid2(simplex.slice(0, n));
-    const xr = add4(c, sub3(c, simplex[n]), alpha);
+    const xr = add5(c, sub4(c, simplex[n]), alpha);
     const fr = f(xr);
     if (fr < fv[0]) {
-      const xe = add4(c, sub3(c, simplex[n]), gamma2);
+      const xe = add5(c, sub4(c, simplex[n]), gamma2);
       const fe = f(xe);
       if (fe < fr) {
         simplex[n] = xe;
@@ -48631,14 +49937,14 @@ function nelderMead(f, x0, opts = {}) {
       simplex[n] = xr;
       fv[n] = fr;
     } else {
-      const xc = add4(c, sub3(simplex[n], c), rho);
+      const xc = add5(c, sub4(simplex[n], c), rho);
       const fc = f(xc);
       if (fc < fv[n]) {
         simplex[n] = xc;
         fv[n] = fc;
       } else {
         for (let i = 1; i <= n; i++) {
-          simplex[i] = add4(simplex[0], sub3(simplex[i], simplex[0]), sigma);
+          simplex[i] = add5(simplex[0], sub4(simplex[i], simplex[0]), sigma);
           fv[i] = f(simplex[i]);
         }
       }
@@ -49655,23 +50961,23 @@ function polyFromRoots(roots) {
   return c.map((z) => z.re);
 }
 function relativeDegree(z, p) {
-  const degree2 = p.length - z.length;
-  if (degree2 < 0) throw new Error("Improper transfer function: fewer poles than zeros");
-  return degree2;
+  const degree3 = p.length - z.length;
+  if (degree3 < 0) throw new Error("Improper transfer function: fewer poles than zeros");
+  return degree3;
 }
 function lp2lpZpk(z, p, k, wo) {
-  const degree2 = relativeDegree(z, p);
+  const degree3 = relativeDegree(z, p);
   return {
     z: z.map((zv) => cScale2(zv, wo)),
     p: p.map((pv) => cScale2(pv, wo)),
-    k: k * Math.pow(wo, degree2)
+    k: k * Math.pow(wo, degree3)
   };
 }
 function lp2hpZpk(z, p, k, wo) {
-  const degree2 = relativeDegree(z, p);
+  const degree3 = relativeDegree(z, p);
   const woC = new Complex11(wo, 0);
   const zHp = z.map((zv) => cDiv2(woC, zv));
-  for (let i = 0; i < degree2; i++) zHp.push(new Complex11(0, 0));
+  for (let i = 0; i < degree3; i++) zHp.push(new Complex11(0, 0));
   let prodZ = new Complex11(1, 0);
   for (const zv of z) prodZ = cMul2(prodZ, zv.negate());
   let prodP = new Complex11(1, 0);
@@ -49679,7 +50985,7 @@ function lp2hpZpk(z, p, k, wo) {
   return { z: zHp, p: p.map((pv) => cDiv2(woC, pv)), k: k * cDiv2(prodZ, prodP).re };
 }
 function lp2bpZpk(z, p, k, wo, bw) {
-  const degree2 = relativeDegree(z, p);
+  const degree3 = relativeDegree(z, p);
   const wo2 = new Complex11(wo * wo, 0);
   const shift = (roots) => {
     const lp = roots.map((r) => cScale2(r, bw / 2));
@@ -49688,11 +50994,11 @@ function lp2bpZpk(z, p, k, wo, bw) {
     return plus.concat(minus);
   };
   const zBp = shift(z);
-  for (let i = 0; i < degree2; i++) zBp.push(new Complex11(0, 0));
-  return { z: zBp, p: shift(p), k: k * Math.pow(bw, degree2) };
+  for (let i = 0; i < degree3; i++) zBp.push(new Complex11(0, 0));
+  return { z: zBp, p: shift(p), k: k * Math.pow(bw, degree3) };
 }
 function lp2bsZpk(z, p, k, wo, bw) {
-  const degree2 = relativeDegree(z, p);
+  const degree3 = relativeDegree(z, p);
   const wo2 = new Complex11(wo * wo, 0);
   const bw2 = new Complex11(bw / 2, 0);
   const shift = (roots) => {
@@ -49702,8 +51008,8 @@ function lp2bsZpk(z, p, k, wo, bw) {
     return plus.concat(minus);
   };
   const zBs = shift(z);
-  for (let i = 0; i < degree2; i++) zBs.push(new Complex11(0, wo));
-  for (let i = 0; i < degree2; i++) zBs.push(new Complex11(0, -wo));
+  for (let i = 0; i < degree3; i++) zBs.push(new Complex11(0, wo));
+  for (let i = 0; i < degree3; i++) zBs.push(new Complex11(0, -wo));
   let prodZ = new Complex11(1, 0);
   for (const zv of z) prodZ = cMul2(prodZ, zv.negate());
   let prodP = new Complex11(1, 0);
@@ -49711,10 +51017,10 @@ function lp2bsZpk(z, p, k, wo, bw) {
   return { z: zBs, p: shift(p), k: k * cDiv2(prodZ, prodP).re };
 }
 function bilinearZpk(z, p, k, fs) {
-  const degree2 = relativeDegree(z, p);
+  const degree3 = relativeDegree(z, p);
   const fs2 = new Complex11(2 * fs, 0);
   const zZ = z.map((zv) => cDiv2(cAdd2(fs2, zv), cSub2(fs2, zv)));
-  for (let i = 0; i < degree2; i++) zZ.push(new Complex11(-1, 0));
+  for (let i = 0; i < degree3; i++) zZ.push(new Complex11(-1, 0));
   let prodZ = new Complex11(1, 0);
   for (const zv of z) prodZ = cMul2(prodZ, cSub2(fs2, zv));
   let prodP = new Complex11(1, 0);
@@ -50899,10 +52205,10 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
   const wtx = [0, ...w];
   const dimsize = Math.ceil(numtaps / 2 + 2);
   const wrksize = gridDensity * dimsize;
-  const neg = jtype === 1 ? 0 : 1;
+  const neg2 = jtype === 1 ? 0 : 1;
   const nodd = numtaps % 2;
   let nfcns = Math.floor(numtaps / 2);
-  if (nodd === 1 && neg === 0) nfcns += 1;
+  if (nodd === 1 && neg2 === 0) nfcns += 1;
   const des = new Array(wrksize + 2).fill(0);
   const grid = new Array(wrksize + 2).fill(0);
   const wt = new Array(wrksize + 2).fill(0);
@@ -50911,7 +52217,7 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
   let delf = gridDensity * nfcns;
   delf = 0.5 / delf;
   grid[1] = edge[1];
-  if (neg !== 0 && edge[1] < delf) grid[1] = delf;
+  if (neg2 !== 0 && edge[1] < delf) grid[1] = delf;
   let j = 1;
   let l = 1;
   let lband = 1;
@@ -50934,10 +52240,10 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
     grid[j] = edge[l];
   }
   let ngrid = j - 1;
-  if (neg === nodd && grid[ngrid] > 0.5 - delf) --ngrid;
+  if (neg2 === nodd && grid[ngrid] > 0.5 - delf) --ngrid;
   if (ngrid < nfcns + 1)
     throw new Error("remez: band too narrow for the requested numtaps (grid underflow)");
-  if (neg <= 0) {
+  if (neg2 <= 0) {
     if (nodd !== 1) {
       for (j = 1; j <= ngrid; j++) {
         const change = Math.cos(PI * grid[j]);
@@ -50968,7 +52274,7 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
   const h = new Array(numtaps + 1).fill(0);
   const nz = nfcns + 1;
   const nm1 = nfcns - 1;
-  if (neg <= 0) {
+  if (neg2 <= 0) {
     if (nodd !== 0) {
       for (j = 1; j <= nm1; j++) h[j] = 0.5 * alpha[nz - j];
       h[nfcns] = alpha[1];
@@ -50992,9 +52298,9 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
   }
   for (j = 1; j <= nfcns; j++) {
     const k = numtaps + 1 - j;
-    h[k] = neg === 0 ? h[j] : -h[j];
+    h[k] = neg2 === 0 ? h[j] : -h[j];
   }
-  if (neg === 1 && nodd === 1) h[nz] = 0;
+  if (neg2 === 1 && nodd === 1) h[nz] = 0;
   return h.slice(1);
 }
 
@@ -51729,10 +53035,10 @@ function setDisjoint(a, b) {
 
 // src/geometry/intersect3d.ts
 var EPS3 = 1e-12;
-function sub(a, b) {
+function sub2(a, b) {
   return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 }
-function add3(a, b) {
+function add4(a, b) {
   return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
 }
 function scale3(a, s) {
@@ -51745,13 +53051,13 @@ function cross2(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function rayTriangleIntersect(origin, dir, v0, v1, v2) {
-  const e1 = sub(v1, v0);
-  const e2 = sub(v2, v0);
+  const e1 = sub2(v1, v0);
+  const e2 = sub2(v2, v0);
   const pvec = cross2(dir, e2);
   const det2 = dot7(e1, pvec);
   if (Math.abs(det2) < EPS3) return null;
   const invDet = 1 / det2;
-  const tvec = sub(origin, v0);
+  const tvec = sub2(origin, v0);
   const u = dot7(tvec, pvec) * invDet;
   if (u < 0 || u > 1) return null;
   const qvec = cross2(tvec, e1);
@@ -51759,21 +53065,21 @@ function rayTriangleIntersect(origin, dir, v0, v1, v2) {
   if (v < 0 || u + v > 1) return null;
   const t = dot7(e2, qvec) * invDet;
   if (t < 0) return null;
-  return { point: add3(origin, scale3(dir, t)), t };
+  return { point: add4(origin, scale3(dir, t)), t };
 }
 function rayPlaneIntersect(origin, dir, planePoint, planeNormal) {
   const denom = dot7(dir, planeNormal);
   if (Math.abs(denom) < EPS3) return null;
-  const t = dot7(sub(planePoint, origin), planeNormal) / denom;
-  return { point: add3(origin, scale3(dir, t)), t };
+  const t = dot7(sub2(planePoint, origin), planeNormal) / denom;
+  return { point: add4(origin, scale3(dir, t)), t };
 }
 function clamp01(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function segmentSegmentClosest(p1, p2, q1, q2) {
-  const d1 = sub(p2, p1);
-  const d2 = sub(q2, q1);
-  const r = sub(p1, q1);
+  const d1 = sub2(p2, p1);
+  const d2 = sub2(q2, q1);
+  const r = sub2(p1, q1);
   const a = dot7(d1, d1);
   const e = dot7(d2, d2);
   const f = dot7(d2, r);
@@ -51804,9 +53110,9 @@ function segmentSegmentClosest(p1, p2, q1, q2) {
       }
     }
   }
-  const point1 = add3(p1, scale3(d1, s));
-  const point2 = add3(q1, scale3(d2, t));
-  const distance2 = Math.sqrt(dot7(sub(point1, point2), sub(point1, point2)));
+  const point1 = add4(p1, scale3(d1, s));
+  const point2 = add4(q1, scale3(d2, t));
+  const distance2 = Math.sqrt(dot7(sub2(point1, point2), sub2(point1, point2)));
   return { point1, point2, distance: distance2 };
 }
 
@@ -51964,14 +53270,14 @@ function alphaShape(points, alpha) {
       [t[2], t[0]]
     ];
     for (const [u, v] of es) {
-      const key = `${Math.min(u, v)},${Math.max(u, v)}`;
-      edgeCount.set(key, (edgeCount.get(key) ?? 0) + 1);
+      const key2 = `${Math.min(u, v)},${Math.max(u, v)}`;
+      edgeCount.set(key2, (edgeCount.get(key2) ?? 0) + 1);
     }
   }
   const edges = [];
-  for (const [key, count2] of edgeCount) {
+  for (const [key2, count2] of edgeCount) {
     if (count2 === 1) {
-      const [lo, hi] = key.split(",").map(Number);
+      const [lo, hi] = key2.split(",").map(Number);
       edges.push([lo, hi]);
     }
   }
@@ -51979,7 +53285,7 @@ function alphaShape(points, alpha) {
 }
 
 // src/geometry/spherical-voronoi.ts
-function sub2(a, b) {
+function sub3(a, b) {
   return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 }
 function cross3(a, b) {
@@ -52013,7 +53319,7 @@ function sphericalVoronoi(points, radius = 1, center3 = [0, 0, 0]) {
   if (points[0].length !== 3) {
     throw new Error("sphericalVoronoi: only 3-D point sets are supported");
   }
-  const gen = points.map((p) => normalize2(sub2(p, center3)));
+  const gen = points.map((p) => normalize2(sub3(p, center3)));
   const faces = convexHull3D(points);
   const vertices = [];
   const vertDir = [];
@@ -52022,7 +53328,7 @@ function sphericalVoronoi(points, radius = 1, center3 = [0, 0, 0]) {
     const a = gen[f[0]];
     const b = gen[f[1]];
     const c = gen[f[2]];
-    let nrm = cross3(sub2(b, a), sub2(c, a));
+    let nrm = cross3(sub3(b, a), sub3(c, a));
     if (dot8(nrm, a) < 0) nrm = [-nrm[0], -nrm[1], -nrm[2]];
     const dir = normalize2(nrm);
     vertDir.push(dir);
@@ -52042,7 +53348,7 @@ function sphericalVoronoi(points, radius = 1, center3 = [0, 0, 0]) {
     const withAngle = facs.map((fi) => {
       const d = vertDir[fi];
       const tang = normalize2(
-        sub2(d, [gdir[0] * dot8(d, gdir), gdir[1] * dot8(d, gdir), gdir[2] * dot8(d, gdir)])
+        sub3(d, [gdir[0] * dot8(d, gdir), gdir[1] * dot8(d, gdir), gdir[2] * dot8(d, gdir)])
       );
       if (ref === null) {
         ref = tang;
@@ -52212,9 +53518,9 @@ function halfspaceIntersection(halfspaces, interiorPoint) {
   const vertices = [];
   const seen = /* @__PURE__ */ new Set();
   for (const v of candidates) {
-    const key = quantum > 0 ? v.map((x) => Math.round(x / quantum)).join(",") : v.join(",");
-    if (seen.has(key)) continue;
-    seen.add(key);
+    const key2 = quantum > 0 ? v.map((x) => Math.round(x / quantum)).join(",") : v.join(",");
+    if (seen.has(key2)) continue;
+    seen.add(key2);
     vertices.push(v);
   }
   if (dim === 2 && vertices.length > 2) {
@@ -52889,8 +54195,8 @@ function buildMatrix(cls, q) {
 }
 var modeCache = /* @__PURE__ */ new Map();
 function solveClass(cls, q) {
-  const key = `${cls}:${q}`;
-  const cached = modeCache.get(key);
+  const key2 = `${cls}:${q}`;
+  const cached = modeCache.get(key2);
   if (cached) return cached;
   const harmonics = harmonicsFor(cls);
   const { values, vectors } = eig4(buildMatrix(cls, q));
@@ -52914,7 +54220,7 @@ function solveClass(cls, q) {
     for (let k = 0; k < N; k++) coeffs[k] *= sign3;
     return { a: values[idx].re, coeffs, harmonics };
   });
-  modeCache.set(key, modes);
+  modeCache.set(key2, modes);
   return modes;
 }
 function checkOrder(n, min2, name254) {
@@ -53434,14 +54740,14 @@ function graphColoring(adj) {
   const n = adj.length;
   const colors = new Array(n).fill(-1);
   if (n === 0) return colors;
-  const degree2 = new Array(n).fill(0);
+  const degree3 = new Array(n).fill(0);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      if (i !== j && _undirectedEdgeExists(adj, i, j)) degree2[i]++;
+      if (i !== j && _undirectedEdgeExists(adj, i, j)) degree3[i]++;
     }
   }
   const order = Array.from({ length: n }, (_, i) => i).sort(
-    (a, b) => degree2[b] - degree2[a] || a - b
+    (a, b) => degree3[b] - degree3[a] || a - b
   );
   for (const v of order) {
     const usedByNeighbor = /* @__PURE__ */ new Set();
@@ -54305,7 +55611,7 @@ export {
   coherence,
   collect,
   column,
-  combinations,
+  combinations2 as combinations,
   combinationsGen,
   combinationsWithRep,
   combine,
@@ -54381,10 +55687,10 @@ export {
   decimate,
   deconvolve,
   deepEqual,
-  degree,
+  degree2 as degree,
   delaunay,
   delaunayTriangulation,
-  derivative,
+  derivative2 as derivative,
   derivativeAt,
   describe,
   det,
@@ -54684,8 +55990,8 @@ export {
   isNegative,
   isNumeric,
   isPositive,
-  isPrime,
-  isZero,
+  isPrime2 as isPrime,
+  isZero3 as isZero,
   istft,
   jacobiCN,
   jacobiDN,
@@ -55122,7 +56428,7 @@ export {
   studentizedRangeQuantile,
   subfactorial,
   subset,
-  substitute,
+  substitute2 as substitute,
   subtract,
   subtractScalar,
   sum,