@danielsimonjr/mathts-functions 0.57.0 → 0.58.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,
@@ -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
@@ -9824,6 +9824,842 @@ 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/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("*");
+}
+
 // src/typed/algebra.ts
 var MATH_KEYWORDS = /* @__PURE__ */ new Set([
   "sin",
@@ -10002,7 +10838,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;
@@ -10075,7 +10911,7 @@ function substitute(expr, vars) {
 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 +11077,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 +11089,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 +11100,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,14 +11110,14 @@ 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)})`);
@@ -10296,21 +11132,29 @@ function factor(expr) {
   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 +11244,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 +11263,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 +11345,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 +11610,7 @@ var typedAlgebra = {
   polynomialLCM,
   polynomialQuotient,
   polynomialRemainder,
-  degree,
+  degree: degree2,
   coefficientList,
   discriminant,
   differences,
@@ -11420,19 +12264,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 +12325,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 +12385,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 +13491,7 @@ var createSolveODE = /* @__PURE__ */ factory(
   dependencies,
   ({
     typed: typed3,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -12866,7 +13710,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 +13723,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 +13824,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 +14909,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 +15655,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;
@@ -19704,7 +20548,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 +20678,7 @@ function _pick(arr10, n, weights) {
 }
 var typedProbability = {
   bernoulli,
-  combinations,
+  combinations: combinations2,
   combinationsWithRep,
   multinomial,
   permutations,
@@ -20090,7 +20934,7 @@ __export(factories_exports, {
   csch: () => csch,
   ctranspose: () => ctranspose,
   cumsum: () => cumsum,
-  derivative: () => derivative,
+  derivative: () => derivative2,
   det: () => det,
   deuteronMass: () => deuteronMass,
   diag: () => diag,
@@ -20204,8 +21048,8 @@ __export(factories_exports, {
   isNegative: () => isNegative,
   isNumeric: () => isNumeric,
   isPositive: () => isPositive,
-  isPrime: () => isPrime,
-  isZero: () => isZero,
+  isPrime: () => isPrime2,
+  isZero: () => isZero2,
   josephson: () => josephson,
   kldivergence: () => kldivergence,
   klitzing: () => klitzing,
@@ -23126,41 +23970,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 +24016,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 +24032,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 +24928,7 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    isZero: isZero2
+    isZero: isZero3
   }) => {
     return typed3(name91, {
       "Array | Matrix, function, string, string": function(size2, fn, format4, datatype) {
@@ -24116,7 +24960,7 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
       m.resize(size2);
       m.forEach(function(_, index) {
         const val = fn(index);
-        if (isZero2(val)) return;
+        if (isZero3(val)) return;
         m.set(index, val);
       });
       return m;
@@ -24280,7 +25124,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 +25148,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 +25175,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 +25226,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: isZero3, unaryMinus: unaryMinus2 }) => {
     return typed3(name96, {
       any: function(x) {
         return clone(x);
@@ -24477,10 +25321,10 @@ var createDet = /* @__PURE__ */ factory(
         }
         for (let k = 0; k < rows; k++) {
           let k_ = rowIndices[k];
-          if (isZero2(matrix3[k_][k])) {
+          if (isZero3(matrix3[k_][k])) {
             let _k;
             for (_k = k + 1; _k < rows; _k++) {
-              if (!isZero2(matrix3[rowIndices[_k]][k])) {
+              if (!isZero3(matrix3[rowIndices[_k]][k])) {
                 k_ = rowIndices[_k];
                 rowIndices[_k] = rowIndices[k];
                 rowIndices[k] = k_;
@@ -24698,7 +25542,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 +25596,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 +25612,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 +25655,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 +25666,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 +25683,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 +25728,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 +25739,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 +25784,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 +25793,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 +25838,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 +25860,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 +25873,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 +25881,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 +26187,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 +27704,7 @@ var createCatalan = /* @__PURE__ */ factory(
     addScalar: addScalar2,
     divideScalar: divideScalar2,
     multiplyScalar: multiplyScalar2,
-    combinations: combinations3,
+    combinations: combinations4,
     isNegative: isNegative2,
     isInteger: isInteger3
   }) => {
@@ -26869,7 +27713,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 +28200,7 @@ var createSubset = /* @__PURE__ */ factory(
     typed: typed3,
     matrix: matrix2,
     zeros: zeros4,
-    add: add4
+    add: add5
   }) => {
     const referTo = typed3.referTo;
     return typed3(name119, {
@@ -27415,7 +28259,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;
         }
@@ -28088,7 +28932,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 +28977,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 +29004,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 +29045,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 +29103,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 +29129,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 +29142,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 +30193,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: log4, Complex: Complex13 }) => {
     return typed3(name143, {
       number: function(x) {
         if (x >= -1 || config2.predictable) {
@@ -29372,7 +30216,7 @@ var createLog1p = /* @__PURE__ */ factory(
       ),
       "any, any": typed3.referToSelf(
         (self) => (x, base) => {
-          return divideScalar2(self(x), log3(base));
+          return divideScalar2(self(x), log4(base));
         }
       )
     });
@@ -30960,7 +31804,7 @@ var createInvmod = /* @__PURE__ */ factory(
     equal: equal2,
     smaller: smaller2,
     mod: mod3,
-    add: add4,
+    add: add5,
     isInteger: isInteger3
   }) => {
     return typed3(name168, {
@@ -30977,7 +31821,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 +31925,7 @@ var createComposition = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     addScalar: addScalar2,
-    combinations: combinations3,
+    combinations: combinations4,
     isPositive: isPositive2,
     isNegative: _isNegative,
     isInteger: isInteger3,
@@ -31094,7 +31938,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 +32082,7 @@ var createPinv = /* @__PURE__ */ factory(
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
-    add: add4,
+    add: add5,
     Complex: Complex13
   }) => {
     return typed3(name172, {
@@ -31320,7 +32164,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 +32178,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 +32237,7 @@ var createQr = /* @__PURE__ */ factory(
     matrix: matrix2,
     zeros: zeros4,
     identity: identity2,
-    isZero: isZero2,
+    isZero: isZero3,
     equal: equal2,
     sign: sign3,
     sqrt: sqrt2,
@@ -31479,7 +32323,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 (!isZero3(alpha)) {
           const u1 = subtractScalar2(pivot, alpha);
           w[k] = 1;
           for (i = k + 1; i < rows; i++) {
@@ -31570,8 +32414,8 @@ var createRange = /* @__PURE__ */ factory(
     smallerEq: smallerEq2,
     larger: larger2,
     largerEq: largerEq2,
-    add: add4,
-    isZero: isZero2,
+    add: add5,
+    isZero: isZero3,
     isPositive: isPositive2
   }) => {
     return typed3(name174, {
@@ -31678,12 +32522,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 (isZero3(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 +32790,10 @@ var dependencies177 = ["typed", "compareText", "isZero"];
 var createEqualText = /* @__PURE__ */ factory(
   name177,
   dependencies177,
-  ({ typed: typed3, compareText: compareText4, isZero: isZero2 }) => {
+  ({ typed: typed3, compareText: compareText4, isZero: isZero3 }) => {
     return typed3(name177, {
       "any, any": function(x, y) {
-        return isZero2(compareText4(x, y));
+        return isZero3(compareText4(x, y));
       }
     });
   }
@@ -35277,7 +36121,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 +36187,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 +36826,7 @@ var createSlu = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add4,
+    add: add5,
     multiply: multiply2,
     transpose: transpose5,
     divideScalar: divideScalar2,
@@ -35991,7 +36835,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 +37140,7 @@ var createIntersect = /* @__PURE__ */ factory(
     typed: typed3,
     config: config2,
     abs: abs2,
-    add: add4,
+    add: add5,
     addScalar: addScalar2,
     matrix: matrix2,
     multiply: multiply2,
@@ -36306,7 +37150,7 @@ var createIntersect = /* @__PURE__ */ factory(
     smaller: smaller2,
     equalScalar: equalScalar3,
     flatten: flatten5,
-    isZero: isZero2,
+    isZero: isZero3,
     isNumeric: isNumeric2
   }) => {
     return typed3("intersect", {
@@ -36421,7 +37265,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d1[0], d2[1]),
         multiplyScalar2(d2[0], d1[1])
       );
-      if (isZero2(det2)) return null;
+      if (isZero3(det2)) return null;
       if (smaller2(abs2(det2), config2.relTol)) {
         return null;
       }
@@ -36436,7 +37280,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 +37339,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d2121, d4343),
         multiplyScalar2(d4321, d4321)
       );
-      if (isZero2(denominator)) return null;
+      if (isZero3(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 +37396,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 +37413,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 +37441,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 +37461,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 +37494,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 +37533,7 @@ var createVariance = /* @__PURE__ */ factory(
   dependencies221,
   ({
     typed: typed3,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -36738,7 +37582,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 +37593,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 +37668,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     bignumber: bignumber2,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     divide: divide2,
     multiply: multiply2,
@@ -36872,7 +37716,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 +37773,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 +37811,7 @@ var createKldivergence = /* @__PURE__ */ factory(
     multiply: multiply2,
     map: map3,
     dotDivide: dotDivide2,
-    log: log3,
+    log: log4,
     isNumeric: isNumeric2
   }) => {
     return typed3(name223, {
@@ -37009,7 +37853,7 @@ var createKldivergence = /* @__PURE__ */ factory(
       const result = sum3(
         multiply2(
           qnorm,
-          map3(dotDivide2(qnorm, pnorm), (x) => log3(x))
+          map3(dotDivide2(qnorm, pnorm), (x) => log4(x))
         )
       );
       if (isNumeric2(result)) {
@@ -37027,7 +37871,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 +37880,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 +37896,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 +37990,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 +38561,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
     typed: typed3,
     parse: _parse2,
     equal: equal2,
-    isZero: isZero2,
+    isZero: isZero3,
     add: _add,
     subtract: _subtract,
     multiply: _multiply2,
@@ -37815,10 +38659,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) && isZero3(a0.value)) {
             return a1;
           }
-          if (isConstantNode(a1) && isZero2(a1.value)) {
+          if (isConstantNode(a1) && isZero3(a1.value)) {
             return a0;
           }
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === "-") {
@@ -37830,24 +38674,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) && isZero3(a0.value)) {
             return _simplifyCore(new OperatorNode("-", "unaryMinus", [a1]));
           }
-          if (isConstantNode(a1) && isZero2(a1.value)) {
+          if (isConstantNode(a1) && isZero3(a1.value)) {
             return a0;
           }
           return new OperatorNode(node.op, node.fn, [a0, a1]);
         }
         if (node.op === "*") {
           if (isConstantNode(a0)) {
-            if (isZero2(a0.value)) {
+            if (isZero3(a0.value)) {
               return node0;
             } else if (equal2(a0.value, 1)) {
               return a1;
             }
           }
           if (isConstantNode(a1)) {
-            if (isZero2(a1.value)) {
+            if (isZero3(a1.value)) {
               return node0;
             } else if (equal2(a1.value, 1)) {
               return a0;
@@ -37859,7 +38703,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) && isZero3(a0.value)) {
             return node0;
           }
           if (isConstantNode(a1) && equal2(a1.value, 1)) {
@@ -37869,7 +38713,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         }
         if (node.op === "^") {
           if (isConstantNode(a1)) {
-            if (isZero2(a1.value)) {
+            if (isZero3(a1.value)) {
               return node1;
             } else if (equal2(a1.value, 1)) {
               return a0;
@@ -37967,9 +38811,9 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
   dependencies234,
   ({
     typed: typed3,
-    isZero: isZero2,
+    isZero: isZero3,
     equalScalar: equalScalar3,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -37983,7 +38827,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 && isZero3(coeffs[coeffs.length - 1])) {
           coeffs.pop();
         }
         if (coeffs.length < 2) {
@@ -38011,15 +38855,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 +38871,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 +38884,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 +38892,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 +38948,7 @@ var createZeta = /* @__PURE__ */ factory(
     gamma: gamma2,
     sin: sin2,
     subtract: subtract3,
-    add: add4,
+    add: add5,
     Complex: Complex13,
     BigNumber: BigNumber9,
     pi
@@ -38172,20 +39016,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 +39466,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 +39578,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 +39775,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 +39947,7 @@ var createEigs = /* @__PURE__ */ factory(
     inv: inv3,
     bignumber: bignumber2,
     multiply: multiply2,
-    add: add4,
+    add: add5,
     larger: larger2,
     column: _column,
     flatten: flatten5,
@@ -39135,7 +39979,7 @@ var createEigs = /* @__PURE__ */ factory(
       bignumber: bignumber2,
       complex: complex3,
       multiply: multiply2,
-      add: add4
+      add: add5
     });
     const doComplexEigs = createComplexEigs({
       addScalar: addScalar2,
@@ -40605,7 +41449,7 @@ var createDerivative = /* @__PURE__ */ factory(
     parse: parse3,
     simplify: simplify2,
     equal: equal2,
-    isZero: isZero2,
+    isZero: isZero3,
     numeric: numeric2,
     ConstantNode,
     FunctionNode,
@@ -40637,7 +41481,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 +41497,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 +41925,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) && (isZero3(arg0.value) || equal2(arg0.value, 1))) {
               return createConstantNode2(0);
             }
             return new OperatorNode("*", "multiply", [
@@ -41094,7 +41938,7 @@ var createDerivative = /* @__PURE__ */ factory(
           }
           if (isConst2(arg1)) {
             if (isConstantNode(arg1)) {
-              if (isZero2(arg1.value)) {
+              if (isZero3(arg1.value)) {
                 return createConstantNode2(0);
               }
               if (equal2(arg1.value, 1)) {
@@ -41132,7 +41976,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 +42005,7 @@ var createNorm = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add4,
+    add: add5,
     pow: pow2,
     conj: conj3,
     sqrt: sqrt2,
@@ -41266,7 +42110,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 +42121,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 +42130,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 +42154,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 +42988,7 @@ var createSylvester = /* @__PURE__ */ factory(
     transpose: transpose5,
     index,
     subset: subset2,
-    add: add4,
+    add: add5,
     subtract: subtract3,
     identity: identity2,
     lusolve: lusolve2,
@@ -42192,7 +43036,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 +43045,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 +43053,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 +43378,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 +43402,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 +43449,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 +43468,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 +43515,7 @@ var hasNumericValue = createHasNumericValue(
   factoryScope
 );
 var isFinite2 = createIsFinite(factoryScope);
-var isZero = createIsZero(factoryScope);
+var isZero2 = createIsZero(factoryScope);
 var factory_unaryPlus = createUnaryPlus(
   factoryScope
 );
@@ -42683,7 +43527,7 @@ factoryScope.unaryPlus = factory_unaryPlus;
 factoryScope.flatten = flatten3;
 factoryScope.hasNumericValue = hasNumericValue;
 factoryScope.isFinite = isFinite2;
-factoryScope.isZero = isZero;
+factoryScope.isZero = isZero2;
 factoryScope.prod = prod;
 factoryScope.dot = factory_dot;
 factoryScope.squeeze = squeeze2;
@@ -43150,8 +43994,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(
@@ -44152,16 +44996,16 @@ function solve(equation, varName) {
     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);
@@ -46415,7 +47259,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 +47428,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 +47595,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 +47848,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 +47862,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 +48801,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 +48813,7 @@ function nthPrime(k) {
   let candidate = 1;
   while (count2 < k) {
     candidate++;
-    if (isPrime2(candidate)) count2++;
+    if (isPrime3(candidate)) count2++;
   }
   return candidate;
 }
@@ -48607,18 +49451,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 +49475,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 +50499,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 +50523,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 +50532,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 +50546,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 +50555,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 +51743,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 +51755,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 +51778,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 +51812,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 +51836,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 +52573,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 +52589,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 +52603,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 +52648,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 };
 }
 
@@ -51979,7 +52823,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 +52857,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 +52866,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 +52886,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;
@@ -53434,14 +54278,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 +55149,7 @@ export {
   coherence,
   collect,
   column,
-  combinations,
+  combinations2 as combinations,
   combinationsGen,
   combinationsWithRep,
   combine,
@@ -54381,10 +55225,10 @@ export {
   decimate,
   deconvolve,
   deepEqual,
-  degree,
+  degree2 as degree,
   delaunay,
   delaunayTriangulation,
-  derivative,
+  derivative2 as derivative,
   derivativeAt,
   describe,
   det,
@@ -54684,8 +55528,8 @@ export {
   isNegative,
   isNumeric,
   isPositive,
-  isPrime,
-  isZero,
+  isPrime2 as isPrime,
+  isZero2 as isZero,
   istft,
   jacobiCN,
   jacobiDN,