solve-engine 1.2.0 → 2.1.0

package/dist/chunk-A2DZ5BEJ.cjs

@@ -1,1930 +0,0 @@
-'use strict';
-
-var chunkIT74O4BE_cjs = require('./chunk-IT74O4BE.cjs');
-var chunkMIGXCBXT_cjs = require('./chunk-MIGXCBXT.cjs');
-
-// src/decimal/Decimal.ts
-var DEFAULT_DIVISION_SCALE = 20;
-var POW10 = [1n];
-function pow10(n) {
-  if (n < 0) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.internal("DECIMAL_NEGATIVE_POWER", `pow10 needs a non-negative exponent, got ${n}`, { exponent: n });
-  }
-  for (let i = POW10.length; i <= n; i++) POW10[i] = POW10[i - 1] * 10n;
-  return POW10[n];
-}
-function makeDecimal(coef, scale) {
-  if (!Number.isInteger(scale) || scale < 0) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.internal("DECIMAL_INVALID_SCALE", `A decimal scale must be a non-negative integer, got ${scale}`, { scale });
-  }
-  return { coef, scale };
-}
-function decimalFromInteger(n) {
-  return { coef: typeof n === "bigint" ? n : BigInt(n), scale: 0 };
-}
-function decimalFromNumberIfExact(n) {
-  if (!Number.isFinite(n) || !Number.isInteger(n)) return null;
-  return decimalFromInteger(BigInt(n));
-}
-function decimalFromLiteral(text) {
-  let s = text;
-  let negative = false;
-  if (s.startsWith("-")) {
-    negative = true;
-    s = s.slice(1);
-  } else if (s.startsWith("+")) {
-    s = s.slice(1);
-  }
-  const dot = s.indexOf(".");
-  const intPart = dot < 0 ? s : s.slice(0, dot);
-  const fracPart = dot < 0 ? "" : s.slice(dot + 1);
-  const digits = intPart + fracPart || "0";
-  if (!/^[0-9]+$/.test(digits)) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.parsing("INVALID_DECIMAL_LITERAL", `Not a decimal literal: "${text}"`, { raw: text });
-  }
-  let coef = BigInt(digits);
-  if (negative) coef = -coef;
-  return { coef, scale: fracPart.length };
-}
-function align(a, b) {
-  if (a.scale === b.scale) return { ca: a.coef, cb: b.coef, scale: a.scale };
-  if (a.scale > b.scale) return { ca: a.coef, cb: b.coef * pow10(a.scale - b.scale), scale: a.scale };
-  return { ca: a.coef * pow10(b.scale - a.scale), cb: b.coef, scale: b.scale };
-}
-function decimalAdd(a, b) {
-  const { ca, cb, scale } = align(a, b);
-  return { coef: ca + cb, scale };
-}
-function decimalSubtract(a, b) {
-  const { ca, cb, scale } = align(a, b);
-  return { coef: ca - cb, scale };
-}
-function decimalMultiply(a, b) {
-  return { coef: a.coef * b.coef, scale: a.scale + b.scale };
-}
-function decimalNegate(a) {
-  return { coef: -a.coef, scale: a.scale };
-}
-function decimalIsZero(a) {
-  return a.coef === 0n;
-}
-function roundCoefToScale(coef, scale, targetScale) {
-  if (targetScale >= scale) return coef * pow10(targetScale - scale);
-  const divisor = pow10(scale - targetScale);
-  const negative = coef < 0n;
-  const magnitude = negative ? -coef : coef;
-  let q = magnitude / divisor;
-  const r = magnitude % divisor;
-  if (r * 2n >= divisor) q += 1n;
-  return negative ? -q : q;
-}
-function decimalRound(a, targetScale) {
-  return { coef: roundCoefToScale(a.coef, a.scale, targetScale), scale: targetScale };
-}
-function decimalDivide(a, b, maxFractionDigits = DEFAULT_DIVISION_SCALE) {
-  if (decimalIsZero(b)) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.internal("DECIMAL_DIVISION_BY_ZERO", "decimalDivide was called with a zero divisor", {});
-  }
-  const s = maxFractionDigits;
-  const numerator = a.coef * pow10(s + b.scale);
-  const denominator = b.coef * pow10(a.scale);
-  const negative = numerator < 0n !== denominator < 0n;
-  const num = numerator < 0n ? -numerator : numerator;
-  const den = denominator < 0n ? -denominator : denominator;
-  let q = num / den;
-  const r = num % den;
-  if (r * 2n >= den) q += 1n;
-  return { coef: negative ? -q : q, scale: s };
-}
-function decimalCompare(a, b) {
-  const { ca, cb } = align(a, b);
-  if (ca < cb) return -1;
-  if (ca > cb) return 1;
-  return 0;
-}
-function decimalToString(a) {
-  const negative = a.coef < 0n;
-  let digits = (negative ? -a.coef : a.coef).toString();
-  if (a.scale === 0) return negative ? `-${digits}` : digits;
-  if (digits.length <= a.scale) digits = digits.padStart(a.scale + 1, "0");
-  const cut = digits.length - a.scale;
-  const whole = digits.slice(0, cut);
-  const frac = digits.slice(cut);
-  return `${negative ? "-" : ""}${whole}.${frac}`;
-}
-function decimalToNumber(a) {
-  return Number(decimalToString(a));
-}
-function decimalToFixed(a, fractionDigits) {
-  const rounded = decimalRound(a, fractionDigits);
-  const negative = rounded.coef < 0n && rounded.coef !== 0n;
-  let digits = (rounded.coef < 0n ? -rounded.coef : rounded.coef).toString();
-  if (fractionDigits === 0) return negative ? `-${digits}` : digits;
-  if (digits.length <= fractionDigits) digits = digits.padStart(fractionDigits + 1, "0");
-  const cut = digits.length - fractionDigits;
-  const whole = digits.slice(0, cut);
-  const frac = digits.slice(cut);
-  return `${negative ? "-" : ""}${whole}.${frac}`;
-}
-
-// src/symbolic/Rational.ts
-var RATIONAL_ZERO = { n: 0n, d: 1n };
-var RATIONAL_ONE = { n: 1n, d: 1n };
-var RATIONAL_MINUS_ONE = { n: -1n, d: 1n };
-var RATIONAL_MAX_BITS = 4096;
-var MAX_MAGNITUDE = 1n << BigInt(RATIONAL_MAX_BITS);
-function bigintPow(base, exponent) {
-  let result = 1n;
-  let factor = base;
-  let remaining = exponent;
-  while (remaining > 0n) {
-    if (remaining % 2n === 1n) result *= factor;
-    factor *= factor;
-    remaining /= 2n;
-  }
-  return result;
-}
-function gcd(a, b) {
-  let x = a < 0n ? -a : a;
-  let y = b < 0n ? -b : b;
-  while (y !== 0n) {
-    const remainder = x % y;
-    x = y;
-    y = remainder;
-  }
-  return x;
-}
-function guardMagnitude(n, d) {
-  const magnitude = n < 0n ? -n : n;
-  if (magnitude >= MAX_MAGNITUDE || d >= MAX_MAGNITUDE) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
-      "SYMBOLIC_RATIONAL_OVERFLOW",
-      `This calculation produced a fraction too large to represent exactly (over ${RATIONAL_MAX_BITS} bits).`,
-      { limitBits: RATIONAL_MAX_BITS }
-    );
-  }
-}
-function normalize(n, d) {
-  if (d === 0n) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
-  }
-  if (n === 0n) return RATIONAL_ZERO;
-  let numerator = d < 0n ? -n : n;
-  let denominator = d < 0n ? -d : d;
-  const divisor = gcd(numerator, denominator);
-  numerator /= divisor;
-  denominator /= divisor;
-  guardMagnitude(numerator, denominator);
-  return { n: numerator, d: denominator };
-}
-function rational(numerator, denominator = 1n) {
-  return normalize(numerator, denominator);
-}
-var DECIMAL_FORM = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
-function rationalFromNumber(value) {
-  if (!Number.isFinite(value)) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
-      "SYMBOLIC_NONFINITE_OPERAND",
-      `"${String(value)}" has no exact value, so it cannot appear in a symbolic expression.`,
-      { value: String(value) }
-    );
-  }
-  if (Number.isInteger(value)) return normalize(BigInt(value), 1n);
-  const parts = DECIMAL_FORM.exec(String(value));
-  if (parts === null) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.internal(
-      "INTERNAL_RATIONAL_PARSE",
-      `Internal error: could not read "${String(value)}" as a decimal number.`,
-      { value: String(value) }
-    );
-  }
-  const [, sign, integerDigits, fractionDigits = "", exponentDigits] = parts;
-  let numerator = BigInt(integerDigits + fractionDigits);
-  let denominator = bigintPow(10n, BigInt(fractionDigits.length));
-  const exponent = exponentDigits === void 0 ? 0 : Number(exponentDigits);
-  if (exponent > 0) numerator *= bigintPow(10n, BigInt(exponent));
-  else if (exponent < 0) denominator *= bigintPow(10n, BigInt(-exponent));
-  return normalize(sign === "-" ? -numerator : numerator, denominator);
-}
-function rationalToNumber(r) {
-  if (r.d === 1n) return Number(r.n);
-  const direct = Number(r.n) / Number(r.d);
-  if (!Number.isNaN(direct)) return direct;
-  const GUARD_BITS = 64n;
-  return Number((r.n << GUARD_BITS) / r.d) / 2 ** 64;
-}
-function rationalAdd(a, b) {
-  return normalize(a.n * b.d + b.n * a.d, a.d * b.d);
-}
-function rationalSub(a, b) {
-  return normalize(a.n * b.d - b.n * a.d, a.d * b.d);
-}
-function rationalMul(a, b) {
-  return normalize(a.n * b.n, a.d * b.d);
-}
-function rationalDiv(a, b) {
-  if (b.n === 0n) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
-  }
-  return normalize(a.n * b.d, a.d * b.n);
-}
-function rationalNeg(r) {
-  return r.n === 0n ? RATIONAL_ZERO : { n: -r.n, d: r.d };
-}
-function rationalPow(base, exponent) {
-  if (exponent === 0n) return RATIONAL_ONE;
-  if (exponent < 0n) {
-    if (base.n === 0n) {
-      throw chunkMIGXCBXT_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
-    }
-    const positive = -exponent;
-    return normalize(bigintPow(base.d, positive), bigintPow(base.n, positive));
-  }
-  return normalize(bigintPow(base.n, exponent), bigintPow(base.d, exponent));
-}
-function rationalCompare(a, b) {
-  const left = a.n * b.d;
-  const right = b.n * a.d;
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-}
-function isRationalZero(r) {
-  return r.n === 0n;
-}
-function isRationalOne(r) {
-  return r.n === 1n && r.d === 1n;
-}
-function isRationalMinusOne(r) {
-  return r.n === -1n && r.d === 1n;
-}
-function isRationalInteger(r) {
-  return r.d === 1n;
-}
-var MAX_DECIMAL_DIGITS = 10;
-var MAX_FRACTION_COMPONENT = 1000000n;
-function formatRational(r) {
-  if (r.d === 1n) return String(r.n);
-  let remaining = r.d;
-  let twos = 0;
-  let fives = 0;
-  while (remaining % 2n === 0n) {
-    remaining /= 2n;
-    twos++;
-  }
-  while (remaining % 5n === 0n) {
-    remaining /= 5n;
-    fives++;
-  }
-  const terminates = remaining === 1n;
-  const decimals = Math.max(twos, fives);
-  if (!terminates || decimals > MAX_DECIMAL_DIGITS) {
-    const magnitude = r.n < 0n ? -r.n : r.n;
-    if (magnitude <= MAX_FRACTION_COMPONENT && r.d <= MAX_FRACTION_COMPONENT) return `${r.n}/${r.d}`;
-    return String(Math.round(rationalToNumber(r) * 1e10) / 1e10);
-  }
-  const scaled = (r.n < 0n ? -r.n : r.n) * bigintPow(10n, BigInt(decimals)) / r.d;
-  const digits = String(scaled).padStart(decimals + 1, "0");
-  const whole = digits.slice(0, digits.length - decimals);
-  const fraction = digits.slice(digits.length - decimals).replace(/0+$/, "");
-  const sign = r.n < 0n ? "-" : "";
-  return fraction.length === 0 ? `${sign}${whole}` : `${sign}${whole}.${fraction}`;
-}
-
-// src/symbolic/Complex.ts
-var COMPLEX_ZERO = { re: RATIONAL_ZERO, im: RATIONAL_ZERO };
-var COMPLEX_ONE = { re: RATIONAL_ONE, im: RATIONAL_ZERO };
-var COMPLEX_I = { re: RATIONAL_ZERO, im: RATIONAL_ONE };
-function complex(re, im = RATIONAL_ZERO) {
-  return { re, im };
-}
-function isComplexZero(z) {
-  return isRationalZero(z.re) && isRationalZero(z.im);
-}
-function complexAdd(a, b) {
-  return { re: rationalAdd(a.re, b.re), im: rationalAdd(a.im, b.im) };
-}
-function complexSub(a, b) {
-  return { re: rationalSub(a.re, b.re), im: rationalSub(a.im, b.im) };
-}
-function complexMul(a, b) {
-  return {
-    re: rationalSub(rationalMul(a.re, b.re), rationalMul(a.im, b.im)),
-    im: rationalAdd(rationalMul(a.re, b.im), rationalMul(a.im, b.re))
-  };
-}
-function complexDiv(a, b) {
-  if (isComplexZero(b)) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a complex expression.");
-  }
-  const denominator = rationalAdd(rationalMul(b.re, b.re), rationalMul(b.im, b.im));
-  return {
-    re: rationalDiv(rationalAdd(rationalMul(a.re, b.re), rationalMul(a.im, b.im)), denominator),
-    im: rationalDiv(rationalSub(rationalMul(a.im, b.re), rationalMul(a.re, b.im)), denominator)
-  };
-}
-function complexNeg(z) {
-  return { re: rationalNeg(z.re), im: rationalNeg(z.im) };
-}
-function complexConjugate(z) {
-  return { re: z.re, im: rationalNeg(z.im) };
-}
-function complexNormSquared(z) {
-  return rationalAdd(rationalMul(z.re, z.re), rationalMul(z.im, z.im));
-}
-function complexPow(base, exponent) {
-  if (exponent === 0n) return COMPLEX_ONE;
-  if (exponent < 0n) {
-    if (isComplexZero(base)) {
-      throw chunkMIGXCBXT_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
-    }
-    return complexDiv(COMPLEX_ONE, complexPow(base, -exponent));
-  }
-  let result = COMPLEX_ONE;
-  let factor = base;
-  let remaining = exponent;
-  while (remaining > 0n) {
-    if (remaining % 2n === 1n) result = complexMul(result, factor);
-    factor = complexMul(factor, factor);
-    remaining /= 2n;
-  }
-  return result;
-}
-function complexEquals(a, b) {
-  return a.re.n === b.re.n && a.re.d === b.re.d && a.im.n === b.im.n && a.im.d === b.im.d;
-}
-function formatComplex(z) {
-  if (isRationalZero(z.im)) return formatRational(z.re);
-  const magnitude = z.im.n < 0n ? rationalNeg(z.im) : z.im;
-  const imaginary = isRationalOne(magnitude) ? "i" : `${formatRational(magnitude)}i`;
-  if (isRationalZero(z.re)) return z.im.n < 0n ? `-${imaginary}` : imaginary;
-  return z.im.n < 0n ? `${formatRational(z.re)}-${imaginary}` : `${formatRational(z.re)}+${imaginary}`;
-}
-function exactComplexSqrt(z) {
-  if (isComplexZero(z)) return COMPLEX_ZERO;
-  const modulus = exactRationalSqrt(complexNormSquared(z));
-  if (modulus === null) return null;
-  const two = { n: 2n, d: 1n };
-  const realPart = exactRationalSqrt(rationalDiv(rationalAdd(modulus, z.re), two));
-  if (realPart === null) return null;
-  if (isRationalZero(realPart)) {
-    const imaginaryPart2 = exactRationalSqrt(rationalDiv(rationalSub(modulus, z.re), two));
-    return imaginaryPart2 === null ? null : { re: RATIONAL_ZERO, im: imaginaryPart2 };
-  }
-  const imaginaryPart = rationalDiv(z.im, rationalMul(two, realPart));
-  return { re: realPart, im: imaginaryPart };
-}
-function exactRationalSqrt(value) {
-  if (value.n < 0n) return null;
-  const numerator = exactBigintSqrt(value.n);
-  const denominator = exactBigintSqrt(value.d);
-  return numerator === null || denominator === null ? null : { n: numerator, d: denominator };
-}
-function exactBigintSqrt(value) {
-  if (value < 0n) return null;
-  if (value < 2n) return value;
-  let previous = value;
-  let current = (value + 1n) / 2n;
-  while (current < previous) {
-    previous = current;
-    current = (previous + value / previous) / 2n;
-  }
-  return previous * previous === value ? previous : null;
-}
-
-// src/symbolic/SymbolicNode.ts
-var SYMBOLIC_MAX_NODES = 1e4;
-function constNode(value) {
-  return { kind: "const", value: typeof value === "number" ? rationalFromNumber(value) : value };
-}
-function varNode(name) {
-  return { kind: "var", name };
-}
-function powNode(base, exponent) {
-  return { kind: "pow", base, exponent };
-}
-function callNode(name, args) {
-  return { kind: "call", name, args };
-}
-function symbolicKey(node) {
-  switch (node.kind) {
-    case "const":
-      return `${node.value.n}/${node.value.d}`;
-    case "complex":
-      return `C(${node.value.re.n}/${node.value.re.d},${node.value.im.n}/${node.value.im.d})`;
-    case "var":
-      return `v:${node.name}`;
-    case "neg":
-      return `-(${symbolicKey(node.operand)})`;
-    case "pow":
-      return `^(${symbolicKey(node.base)},${symbolicKey(node.exponent)})`;
-    case "call":
-      return `${node.name}(${node.args.map(symbolicKey).join(",")})`;
-    case "add":
-      return `+(${symbolicKey(node.left)},${symbolicKey(node.right)})`;
-    case "sub":
-      return `-(${symbolicKey(node.left)},${symbolicKey(node.right)})`;
-    case "mul":
-      return `*(${symbolicKey(node.left)},${symbolicKey(node.right)})`;
-    case "div":
-      return `/(${symbolicKey(node.left)},${symbolicKey(node.right)})`;
-  }
-}
-function nodesEqual(a, b) {
-  if (a.kind !== b.kind) return false;
-  switch (a.kind) {
-    case "const": {
-      const other = b;
-      return a.value.n === other.value.n && a.value.d === other.value.d;
-    }
-    case "complex":
-      return complexEquals(a.value, b.value);
-    case "var":
-      return a.name === b.name;
-    case "neg":
-      return nodesEqual(a.operand, b.operand);
-    case "pow": {
-      const other = b;
-      return nodesEqual(a.base, other.base) && nodesEqual(a.exponent, other.exponent);
-    }
-    case "call": {
-      const other = b;
-      if (a.name !== other.name || a.args.length !== other.args.length) return false;
-      return a.args.every((arg, i) => nodesEqual(arg, other.args[i]));
-    }
-    case "add":
-    case "sub":
-    case "mul":
-    case "div": {
-      const other = b;
-      return nodesEqual(a.left, other.left) && nodesEqual(a.right, other.right);
-    }
-  }
-}
-function nodeCount(node, limit = Number.POSITIVE_INFINITY) {
-  const pending = [node];
-  let total = 0;
-  while (pending.length > 0) {
-    const current = pending.pop();
-    total++;
-    if (total > limit) return total;
-    switch (current.kind) {
-      case "const":
-      case "complex":
-      case "var":
-        break;
-      case "neg":
-        pending.push(current.operand);
-        break;
-      case "pow":
-        pending.push(current.base, current.exponent);
-        break;
-      case "call":
-        for (const arg of current.args) pending.push(arg);
-        break;
-      case "add":
-      case "sub":
-      case "mul":
-      case "div":
-        pending.push(current.left, current.right);
-        break;
-    }
-  }
-  return total;
-}
-function freeVariables(node) {
-  const names = /* @__PURE__ */ new Set();
-  collectVariables(node, names);
-  return names;
-}
-function collectVariables(node, into) {
-  switch (node.kind) {
-    case "const":
-    case "complex":
-      return;
-    case "var":
-      into.add(node.name);
-      return;
-    case "neg":
-      collectVariables(node.operand, into);
-      return;
-    case "pow":
-      collectVariables(node.base, into);
-      collectVariables(node.exponent, into);
-      return;
-    case "call":
-      for (const arg of node.args) collectVariables(arg, into);
-      return;
-    case "add":
-    case "sub":
-    case "mul":
-    case "div":
-      collectVariables(node.left, into);
-      collectVariables(node.right, into);
-  }
-}
-function substitute(node, variable, replacement) {
-  switch (node.kind) {
-    case "const":
-    case "complex":
-      return node;
-    case "var":
-      return node.name === variable ? replacement : node;
-    case "neg":
-      return { kind: "neg", operand: substitute(node.operand, variable, replacement) };
-    case "pow":
-      return {
-        kind: "pow",
-        base: substitute(node.base, variable, replacement),
-        exponent: substitute(node.exponent, variable, replacement)
-      };
-    case "call":
-      return { kind: "call", name: node.name, args: node.args.map((arg) => substitute(arg, variable, replacement)) };
-    case "add":
-    case "sub":
-    case "mul":
-    case "div":
-      return {
-        kind: node.kind,
-        left: substitute(node.left, variable, replacement),
-        right: substitute(node.right, variable, replacement)
-      };
-  }
-}
-function complexNode(value) {
-  if (value.im.n === 0n) return { kind: "const", value: value.re };
-  return { kind: "complex", value };
-}
-
-// src/symbolic/Polynomial.ts
-var EXPAND_MAX_POW_EXPONENT = 32;
-var POLYNOMIAL_MAX_TERMS = 2e3;
-var POLYNOMIAL_MAX_DEGREE = 64;
-function monomialToKey(monomial) {
-  const names = [...monomial.keys()].sort();
-  return names.map((name) => monomial.get(name) === 1 ? name : `${name}^${monomial.get(name)}`).join("*");
-}
-function monomialFromKey(key) {
-  const monomial = /* @__PURE__ */ new Map();
-  if (key === "") return monomial;
-  for (const factor of key.split("*")) {
-    const caret = factor.indexOf("^");
-    if (caret === -1) monomial.set(factor, 1);
-    else monomial.set(factor.slice(0, caret), Number(factor.slice(caret + 1)));
-  }
-  return monomial;
-}
-function monomialDegree(key) {
-  let total = 0;
-  for (const exponent of monomialFromKey(key).values()) total += exponent;
-  return total;
-}
-function build(terms) {
-  const kept = /* @__PURE__ */ new Map();
-  const names = /* @__PURE__ */ new Set();
-  for (const [key, coeff] of terms) {
-    if (isRationalZero(coeff)) continue;
-    if (monomialDegree(key) > POLYNOMIAL_MAX_DEGREE) return null;
-    kept.set(key, coeff);
-    for (const name of monomialFromKey(key).keys()) names.add(name);
-  }
-  if (kept.size > POLYNOMIAL_MAX_TERMS) return null;
-  return { terms: kept, vars: [...names].sort() };
-}
-function constantPolynomial(value) {
-  return isRationalZero(value) ? { terms: /* @__PURE__ */ new Map(), vars: [] } : { terms: /* @__PURE__ */ new Map([["", value]]), vars: [] };
-}
-function polyAdd(a, b) {
-  const terms = new Map(a.terms);
-  for (const [key, coeff] of b.terms) {
-    const existing = terms.get(key);
-    terms.set(key, existing === void 0 ? coeff : rationalAdd(existing, coeff));
-  }
-  return build(terms);
-}
-function polySub(a, b) {
-  return polyAdd(a, polyScale(b, RATIONAL_MINUS_ONE));
-}
-function polyMul(a, b) {
-  if (a.terms.size * b.terms.size > POLYNOMIAL_MAX_TERMS) return null;
-  const terms = /* @__PURE__ */ new Map();
-  for (const [leftKey, leftCoeff] of a.terms) {
-    const leftMonomial = monomialFromKey(leftKey);
-    for (const [rightKey, rightCoeff] of b.terms) {
-      const combined = new Map(leftMonomial);
-      for (const [name, exponent] of monomialFromKey(rightKey)) {
-        combined.set(name, (combined.get(name) ?? 0) + exponent);
-      }
-      const key = monomialToKey(combined);
-      const coeff = rationalMul(leftCoeff, rightCoeff);
-      const existing = terms.get(key);
-      terms.set(key, existing === void 0 ? coeff : rationalAdd(existing, coeff));
-    }
-  }
-  return build(terms);
-}
-function polyPow(p, exponent) {
-  if (exponent < 0 || !Number.isInteger(exponent) || exponent > EXPAND_MAX_POW_EXPONENT) return null;
-  let result = constantPolynomial(RATIONAL_ONE);
-  for (let i = 0; i < exponent; i++) {
-    const next = polyMul(result, p);
-    if (next === null) return null;
-    result = next;
-  }
-  return result;
-}
-function polyScale(p, k) {
-  if (isRationalZero(k)) return { terms: /* @__PURE__ */ new Map(), vars: [] };
-  const terms = /* @__PURE__ */ new Map();
-  for (const [key, coeff] of p.terms) terms.set(key, rationalMul(coeff, k));
-  return { terms, vars: p.vars };
-}
-function polyDegree(p, variable) {
-  let highest = 0;
-  for (const key of p.terms.keys()) {
-    const degree = variable === void 0 ? monomialDegree(key) : monomialFromKey(key).get(variable) ?? 0;
-    if (degree > highest) highest = degree;
-  }
-  return highest;
-}
-function polyUnivariateVar(p) {
-  return p.vars.length === 1 ? p.vars[0] : null;
-}
-function polyCoefficients(p, variable) {
-  const degree = polyDegree(p, variable);
-  const coefficients = new Array(degree + 1).fill(RATIONAL_ZERO);
-  for (const [key, coeff] of p.terms) {
-    coefficients[monomialFromKey(key).get(variable) ?? 0] = coeff;
-  }
-  return coefficients;
-}
-function toPolynomial(node, allowDistribution = true) {
-  switch (node.kind) {
-    case "const":
-      return constantPolynomial(node.value);
-    case "var":
-      return { terms: /* @__PURE__ */ new Map([[node.name, RATIONAL_ONE]]), vars: [node.name] };
-    case "neg": {
-      const operand = toPolynomial(node.operand, allowDistribution);
-      return operand === null ? null : polyScale(operand, RATIONAL_MINUS_ONE);
-    }
-    case "add": {
-      const left = toPolynomial(node.left, allowDistribution);
-      const right = left === null ? null : toPolynomial(node.right, allowDistribution);
-      return left === null || right === null ? null : polyAdd(left, right);
-    }
-    case "sub": {
-      const left = toPolynomial(node.left, allowDistribution);
-      const right = left === null ? null : toPolynomial(node.right, allowDistribution);
-      return left === null || right === null ? null : polySub(left, right);
-    }
-    case "mul": {
-      const left = toPolynomial(node.left, allowDistribution);
-      const right = left === null ? null : toPolynomial(node.right, allowDistribution);
-      if (left === null || right === null) return null;
-      if (!allowDistribution && (left.terms.size > 1 || right.terms.size > 1)) return null;
-      return polyMul(left, right);
-    }
-    case "div": {
-      const right = toPolynomial(node.right, allowDistribution);
-      if (right === null || right.vars.length > 0) return null;
-      const divisor = right.terms.get("") ?? RATIONAL_ZERO;
-      if (isRationalZero(divisor)) return null;
-      const left = toPolynomial(node.left, allowDistribution);
-      return left === null ? null : polyScale(left, rationalDiv(RATIONAL_ONE, divisor));
-    }
-    case "pow": {
-      if (node.exponent.kind !== "const" || !isRationalInteger(node.exponent.value)) return null;
-      const exponent = Number(node.exponent.value.n);
-      const base = toPolynomial(node.base, allowDistribution);
-      if (base === null) return null;
-      if (!allowDistribution && base.terms.size > 1) return null;
-      return polyPow(base, exponent);
-    }
-    case "complex":
-      return null;
-    case "call":
-      return null;
-  }
-}
-function compareMonomials(a, b, vars) {
-  const degreeDifference = monomialDegree(b) - monomialDegree(a);
-  if (degreeDifference !== 0) return degreeDifference;
-  const left = monomialFromKey(a);
-  const right = monomialFromKey(b);
-  for (const name of vars) {
-    const difference = (right.get(name) ?? 0) - (left.get(name) ?? 0);
-    if (difference !== 0) return difference;
-  }
-  return 0;
-}
-function monomialToNode(key) {
-  const monomial = monomialFromKey(key);
-  const names = [...monomial.keys()].sort();
-  let result = null;
-  for (const name of names) {
-    const exponent = monomial.get(name);
-    const factor = exponent === 1 ? varNode(name) : powNode(varNode(name), constNode({ n: BigInt(exponent), d: 1n }));
-    result = result === null ? factor : { kind: "mul", left: result, right: factor };
-  }
-  return result ?? constNode(RATIONAL_ONE);
-}
-function termToNode(key, coeff) {
-  if (key === "") return constNode(coeff);
-  const magnitude = coeff.n < 0n ? rationalNeg(coeff) : coeff;
-  const monomial = monomialToNode(key);
-  const positive = isRationalOne(magnitude) ? monomial : { kind: "mul", left: constNode(magnitude), right: monomial };
-  return coeff.n < 0n ? { kind: "neg", operand: positive } : positive;
-}
-function fromPolynomial(p) {
-  const keys = [...p.terms.keys()].sort((a, b) => compareMonomials(a, b, p.vars));
-  if (keys.length === 0) return constNode(RATIONAL_ZERO);
-  if (p.terms.get(keys[0]).n < 0n) {
-    const firstPositive = keys.findIndex((key) => p.terms.get(key).n > 0n);
-    if (firstPositive > 0) keys.unshift(...keys.splice(firstPositive, 1));
-  }
-  let result = termToNode(keys[0], p.terms.get(keys[0]));
-  for (let i = 1; i < keys.length; i++) {
-    const coeff = p.terms.get(keys[i]);
-    if (coeff.n < 0n) {
-      result = { kind: "sub", left: result, right: termToNode(keys[i], rationalNeg(coeff)) };
-    } else {
-      result = { kind: "add", left: result, right: termToNode(keys[i], coeff) };
-    }
-  }
-  return result;
-}
-function expandSymbolic(node) {
-  const polynomial = toPolynomial(node);
-  return polynomial === null ? node : fromPolynomial(polynomial);
-}
-
-// src/symbolic/Gcd.ts
-function trim(coefficients) {
-  let last = coefficients.length - 1;
-  while (last >= 0 && isRationalZero(coefficients[last])) last--;
-  return coefficients.slice(0, last + 1);
-}
-function isZeroPolynomial(coefficients) {
-  return coefficients.every(isRationalZero);
-}
-function polynomialDivide(dividend, divisor) {
-  const numerator = trim([...dividend]);
-  const denominator = trim([...divisor]);
-  if (denominator.length === 0) throw new Error("polynomialDivide: division by the zero polynomial");
-  const divisorDegree = denominator.length - 1;
-  const leading = denominator[divisorDegree];
-  const remainder = [...numerator];
-  const quotient = new Array(Math.max(0, numerator.length - divisorDegree)).fill(RATIONAL_ZERO);
-  for (let degree = remainder.length - 1; degree >= divisorDegree; degree--) {
-    if (isRationalZero(remainder[degree])) continue;
-    const factor = rationalDiv(remainder[degree], leading);
-    const offset = degree - divisorDegree;
-    quotient[offset] = factor;
-    for (let i = 0; i <= divisorDegree; i++) {
-      remainder[offset + i] = rationalSub(remainder[offset + i], rationalMul(factor, denominator[i]));
-    }
-  }
-  return { quotient: trim(quotient), remainder: trim(remainder) };
-}
-function monic(coefficients) {
-  const trimmed = trim(coefficients);
-  if (trimmed.length === 0) return trimmed;
-  const leading = trimmed[trimmed.length - 1];
-  if (isRationalOne(leading)) return trimmed;
-  return trimmed.map((coefficient) => rationalDiv(coefficient, leading));
-}
-function coefficientGcd(a, b) {
-  let left = trim([...a]);
-  let right = trim([...b]);
-  while (right.length > 0) {
-    const { remainder } = polynomialDivide(left, right);
-    left = right;
-    right = remainder;
-  }
-  return monic(left);
-}
-function polynomialGcd(a, b) {
-  const variable = sharedVariable(a, b);
-  if (variable === void 0) return null;
-  if (variable === null) return toPolynomial({ kind: "const", value: RATIONAL_ONE });
-  const gcd2 = coefficientGcd(polyCoefficients(a, variable), polyCoefficients(b, variable));
-  return coefficientsToPolynomial(gcd2, variable);
-}
-function sharedVariable(a, b) {
-  const names = /* @__PURE__ */ new Set([...a.vars, ...b.vars]);
-  if (names.size === 0) return null;
-  if (names.size > 1) return void 0;
-  return [...names][0];
-}
-function coefficientsToPolynomial(coefficients, variable) {
-  const terms = /* @__PURE__ */ new Map();
-  coefficients.forEach((coefficient, power) => {
-    if (isRationalZero(coefficient)) return;
-    terms.set(power === 0 ? "" : power === 1 ? variable : `${variable}^${power}`, coefficient);
-  });
-  return { terms, vars: terms.size > 0 && coefficients.length > 1 ? [variable] : [] };
-}
-function cancelRational(numerator, denominator) {
-  const gcd2 = polynomialGcd(numerator, denominator);
-  if (gcd2 === null) return null;
-  if (polyDegree(gcd2) === 0) return null;
-  const variable = polyUnivariateVar(gcd2);
-  if (variable === null) return null;
-  const gcdCoefficients = polyCoefficients(gcd2, variable);
-  const reducedNumerator = polynomialDivide(polyCoefficients(numerator, variable), gcdCoefficients);
-  const reducedDenominator = polynomialDivide(polyCoefficients(denominator, variable), gcdCoefficients);
-  return {
-    numerator: coefficientsToPolynomial(reducedNumerator.quotient, variable),
-    denominator: coefficientsToPolynomial(reducedDenominator.quotient, variable)
-  };
-}
-function cancelSymbolic(node) {
-  if (node.kind !== "div") return node;
-  const numerator = toPolynomial(node.left);
-  const denominator = toPolynomial(node.right);
-  if (numerator === null || denominator === null) return node;
-  const reduced = cancelRational(numerator, denominator);
-  if (reduced === null) return node;
-  return divideOutConstant(reduced.numerator, reduced.denominator, node);
-}
-function divideOutConstant(numerator, denominator, original) {
-  if (polyDegree(denominator) === 0) {
-    const constant = denominator.terms.get("") ?? RATIONAL_ONE;
-    if (isRationalZero(constant)) return original;
-    const scaled = /* @__PURE__ */ new Map();
-    for (const [key, coefficient] of numerator.terms) scaled.set(key, rationalDiv(coefficient, constant));
-    return fromPolynomial({ terms: scaled, vars: numerator.vars });
-  }
-  return { kind: "div", left: fromPolynomial(numerator), right: fromPolynomial(denominator) };
-}
-function squareFreePart(coefficients) {
-  const trimmed = trim([...coefficients]);
-  if (trimmed.length <= 1) return monic(trimmed);
-  const derivative = [];
-  for (let power = 1; power < trimmed.length; power++) {
-    derivative.push(rationalMul(trimmed[power], { n: BigInt(power), d: 1n }));
-  }
-  const shared = coefficientGcd(trimmed, derivative);
-  if (shared.length <= 1) return monic(trimmed);
-  return monic(polynomialDivide(trimmed, shared).quotient);
-}
-
-// src/symbolic/Radicals.ts
-function exactIntegerSqrt(value) {
-  if (value < 0n) return null;
-  if (value < 2n) return value;
-  let previous = value;
-  let current = (value + 1n) / 2n;
-  while (current < previous) {
-    previous = current;
-    current = (previous + value / previous) / 2n;
-  }
-  return previous * previous === value ? previous : null;
-}
-function exactIntegerCbrt(value) {
-  const negative = value < 0n;
-  const magnitude = negative ? -value : value;
-  if (magnitude < 2n) return negative ? -magnitude : magnitude;
-  let low = 1n;
-  let high = magnitude;
-  while (low <= high) {
-    const middle = (low + high) / 2n;
-    const cube = middle * middle * middle;
-    if (cube === magnitude) return negative ? -middle : middle;
-    if (cube < magnitude) low = middle + 1n;
-    else high = middle - 1n;
-  }
-  return null;
-}
-function exactRationalSqrt2(value) {
-  const numerator = exactIntegerSqrt(value.n);
-  const denominator = exactIntegerSqrt(value.d);
-  return numerator === null || denominator === null ? null : { n: numerator, d: denominator };
-}
-function surdNode(value) {
-  const radicand = value.n * value.d;
-  let extracted = 1n;
-  let remaining = radicand;
-  for (let factor = 2n; factor * factor <= remaining; factor++) {
-    const square = factor * factor;
-    while (remaining % square === 0n) {
-      remaining /= square;
-      extracted *= factor;
-    }
-  }
-  const scale = rational(extracted, value.d);
-  if (remaining === 1n) return constNode(scale);
-  const root = { kind: "call", name: "sqrt", args: [constNode({ n: remaining, d: 1n })] };
-  return scale.n === 1n && scale.d === 1n ? root : { kind: "mul", left: constNode(scale), right: root };
-}
-function signedSurdNode(value) {
-  if (value.n >= 0n) return surdNode(value);
-  return { kind: "call", name: "sqrt", args: [constNode(value)] };
-}
-
-// src/symbolic/Simplify.ts
-function flattenSum(node, negated, out, depth = 0) {
-  if (depth >= MAX_SIMPLIFY_DEPTH) return false;
-  switch (node.kind) {
-    case "add":
-      return flattenSum(node.left, negated, out, depth + 1) && flattenSum(node.right, negated, out, depth + 1);
-    case "sub":
-      return flattenSum(node.left, negated, out, depth + 1) && flattenSum(node.right, !negated, out, depth + 1);
-    case "neg":
-      return flattenSum(node.operand, !negated, out, depth + 1);
-    case "const":
-      out.push({ coeff: negated ? rationalNeg(node.value) : node.value, name: null });
-      return true;
-    case "var":
-      out.push({ coeff: negated ? RATIONAL_MINUS_ONE : RATIONAL_ONE, name: node.name });
-      return true;
-    default:
-      return false;
-  }
-}
-function collectTerms(node) {
-  const flat = [];
-  if (!flattenSum(node, false, flat)) return node;
-  const order = [];
-  const coeffByName = /* @__PURE__ */ new Map();
-  let constant = RATIONAL_ZERO;
-  for (const term of flat) {
-    if (term.name === null) {
-      constant = rationalAdd(constant, term.coeff);
-      continue;
-    }
-    const existing = coeffByName.get(term.name);
-    if (existing === void 0) {
-      order.push(term.name);
-      coeffByName.set(term.name, term.coeff);
-    } else {
-      coeffByName.set(term.name, rationalAdd(existing, term.coeff));
-    }
-  }
-  const termNodes = [];
-  for (const name of order) {
-    const coeff = coeffByName.get(name);
-    if (isRationalZero(coeff)) continue;
-    if (isRationalOne(coeff)) termNodes.push(varNode(name));
-    else if (isRationalMinusOne(coeff)) termNodes.push({ kind: "neg", operand: varNode(name) });
-    else termNodes.push({ kind: "mul", left: constNode(coeff), right: varNode(name) });
-  }
-  if (termNodes.length === 0) return constNode(constant);
-  let result = termNodes[0];
-  for (let i = 1; i < termNodes.length; i++) {
-    result = { kind: "add", left: result, right: termNodes[i] };
-  }
-  if (!isRationalZero(constant)) {
-    result = { kind: "add", left: result, right: constNode(constant) };
-  }
-  return result;
-}
-function collectSum(node) {
-  const polynomial = toPolynomial(node, false);
-  if (polynomial !== null) return fromPolynomial(polynomial);
-  return collectTerms(node);
-}
-function rationalFloor(r) {
-  const truncated = r.n / r.d;
-  return r.n < 0n && truncated * r.d !== r.n ? truncated - 1n : truncated;
-}
-var MAX_FOLDED_FACTORIAL = 500n;
-function foldCall(name, args) {
-  const first = args[0];
-  switch (name) {
-    case "abs":
-      return args.length === 1 ? first.n < 0n ? rationalNeg(first) : first : null;
-    case "sign":
-      if (args.length !== 1) return null;
-      return first.n === 0n ? RATIONAL_ZERO : { n: first.n < 0n ? -1n : 1n, d: 1n };
-    case "floor":
-      return args.length === 1 ? { n: rationalFloor(first), d: 1n } : null;
-    case "ceil":
-      return args.length === 1 ? { n: -rationalFloor(rationalNeg(first)), d: 1n } : null;
-    case "trunc":
-      return args.length === 1 ? { n: first.n / first.d, d: 1n } : null;
-    case "round":
-      return args.length === 1 ? { n: rationalFloor(rationalAdd(first, { n: 1n, d: 2n })), d: 1n } : null;
-    case "sqrt": {
-      if (args.length !== 1 || first.n < 0n) return null;
-      const rootN = exactIntegerSqrt(first.n);
-      const rootD = exactIntegerSqrt(first.d);
-      return rootN === null || rootD === null ? null : { n: rootN, d: rootD };
-    }
-    case "cbrt": {
-      if (args.length !== 1) return null;
-      const rootN = exactIntegerCbrt(first.n);
-      const rootD = exactIntegerCbrt(first.d);
-      return rootN === null || rootD === null ? null : { n: rootN, d: rootD };
-    }
-    // Exact values at the points where these functions are rational. Every
-    // entry is exact, not rounded, which is what lets a Taylor series about
-    // the origin come out with exact coefficients. Deliberately narrow:
-    // `sin(1)` and `log(2)` are irrational and must stay symbolic.
-    case "sin":
-    case "tan":
-    case "asin":
-    case "atan":
-    case "sinh":
-    case "tanh":
-      return args.length === 1 && isRationalZero(first) ? RATIONAL_ZERO : null;
-    case "cos":
-    case "exp":
-    case "cosh":
-      return args.length === 1 && isRationalZero(first) ? RATIONAL_ONE : null;
-    case "log":
-      return args.length === 1 && isRationalOne(first) ? RATIONAL_ZERO : null;
-    case "acos":
-      return args.length === 1 && isRationalOne(first) ? RATIONAL_ZERO : null;
-    case "fact": {
-      if (args.length !== 1 || !isRationalInteger(first) || first.n < 0n || first.n > MAX_FOLDED_FACTORIAL) return null;
-      let total = 1n;
-      for (let i = 2n; i <= first.n; i++) total *= i;
-      return { n: total, d: 1n };
-    }
-    default:
-      return null;
-  }
-}
-function simplifySymbolic(node) {
-  if (nodeCount(node, SYMBOLIC_MAX_NODES) > SYMBOLIC_MAX_NODES) {
-    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
-      "SYMBOLIC_NODE_LIMIT_EXCEEDED",
-      `This symbolic expression is too large to simplify (over ${SYMBOLIC_MAX_NODES} terms).`,
-      { limit: SYMBOLIC_MAX_NODES }
-    );
-  }
-  const depthOnEntry = walkDepth;
-  try {
-    return simplifyNode(node);
-  } finally {
-    walkDepth = depthOnEntry;
-  }
-}
-var MAX_SIMPLIFY_DEPTH = 900;
-var walkDepth = 0;
-function simplifyNode(node) {
-  if (walkDepth >= MAX_SIMPLIFY_DEPTH) return node;
-  walkDepth++;
-  const simplified = simplifyNodeAt(node);
-  walkDepth--;
-  return simplified;
-}
-function asComplex(node) {
-  if (node.kind === "complex") return node.value;
-  if (node.kind === "const") return complex(node.value);
-  return null;
-}
-function foldComplexBinary(kind, left, right) {
-  if (left.kind !== "complex" && right.kind !== "complex") return null;
-  const a = asComplex(left);
-  const b = asComplex(right);
-  if (a === null || b === null) return null;
-  switch (kind) {
-    case "add":
-      return complexNode(complexAdd(a, b));
-    case "sub":
-      return complexNode(complexSub(a, b));
-    case "mul":
-      return complexNode(complexMul(a, b));
-    case "div":
-      return isComplexZero(b) ? null : complexNode(complexDiv(a, b));
-  }
-}
-function foldComplexCall(name, args) {
-  if (args.length !== 1) return null;
-  const value = asComplex(args[0]);
-  if (value === null) return null;
-  switch (name) {
-    case "sqrt": {
-      const root = exactComplexSqrt(value);
-      if (root !== null) return complexNode(root);
-      if (isRationalZero(value.im) && value.re.n < 0n) {
-        return {
-          kind: "mul",
-          left: { kind: "call", name: "sqrt", args: [constNode(rationalNeg(value.re))] },
-          right: complexNode(COMPLEX_I)
-        };
-      }
-      return null;
-    }
-    case "conj":
-      return complexNode(complexConjugate(value));
-    case "re":
-      return constNode(value.re);
-    case "im":
-      return constNode(value.im);
-    case "abs": {
-      if (isRationalZero(value.im)) return null;
-      const modulus = exactComplexSqrt(complex(complexNormSquared(value)));
-      return modulus === null || !isRationalZero(modulus.im) ? null : constNode(modulus.re);
-    }
-    default:
-      return null;
-  }
-}
-function simplifyNodeAt(node) {
-  switch (node.kind) {
-    case "const":
-    case "complex":
-    case "var":
-      return node;
-    case "neg": {
-      const operand = simplifyNode(node.operand);
-      if (operand.kind === "const") return constNode(rationalNeg(operand.value));
-      if (operand.kind === "complex") return complexNode(complexNeg(operand.value));
-      if (operand.kind === "neg") return operand.operand;
-      return { kind: "neg", operand };
-    }
-    case "add": {
-      const left = simplifyNode(node.left);
-      const right = simplifyNode(node.right);
-      if (left.kind === "const" && right.kind === "const") return constNode(rationalAdd(left.value, right.value));
-      const foldedAdd = foldComplexBinary("add", left, right);
-      if (foldedAdd !== null) return foldedAdd;
-      if (left.kind === "const" && isRationalZero(left.value)) return right;
-      if (right.kind === "const" && isRationalZero(right.value)) return left;
-      return collectSum({ kind: "add", left, right });
-    }
-    case "sub": {
-      const left = simplifyNode(node.left);
-      const right = simplifyNode(node.right);
-      if (left.kind === "const" && right.kind === "const") return constNode(rationalSub(left.value, right.value));
-      const foldedSub = foldComplexBinary("sub", left, right);
-      if (foldedSub !== null) return foldedSub;
-      if (right.kind === "const" && isRationalZero(right.value)) return left;
-      if (left.kind === "const" && isRationalZero(left.value)) return simplifyNode({ kind: "neg", operand: right });
-      return collectSum({ kind: "sub", left, right });
-    }
-    case "mul": {
-      const left = simplifyNode(node.left);
-      const right = simplifyNode(node.right);
-      if (left.kind === "const" && right.kind === "const") return constNode(rationalMul(left.value, right.value));
-      const foldedMul = foldComplexBinary("mul", left, right);
-      if (foldedMul !== null) return foldedMul;
-      if (left.kind === "const" && isRationalZero(left.value) || right.kind === "const" && isRationalZero(right.value)) {
-        return constNode(RATIONAL_ZERO);
-      }
-      if (left.kind === "const" && isRationalOne(left.value)) return right;
-      if (right.kind === "const" && isRationalOne(right.value)) return left;
-      if (left.kind === "const" && isRationalMinusOne(left.value)) return simplifyNode({ kind: "neg", operand: right });
-      if (right.kind === "const" && isRationalMinusOne(right.value)) return simplifyNode({ kind: "neg", operand: left });
-      if (left.kind === "const" && right.kind === "mul" && right.left.kind === "const") {
-        return simplifyNode({ kind: "mul", left: constNode(rationalMul(left.value, right.left.value)), right: right.right });
-      }
-      if (right.kind === "const" && left.kind === "mul" && left.left.kind === "const") {
-        return simplifyNode({ kind: "mul", left: constNode(rationalMul(right.value, left.left.value)), right: left.right });
-      }
-      if (left.kind === "div" && left.left.kind === "const" && isRationalOne(left.left.value)) {
-        return simplifyNode({ kind: "div", left: right, right: left.right });
-      }
-      if (right.kind === "div" && right.left.kind === "const" && isRationalOne(right.left.value)) {
-        return simplifyNode({ kind: "div", left, right: right.right });
-      }
-      return { kind: "mul", left, right };
-    }
-    case "div": {
-      const left = simplifyNode(node.left);
-      const right = simplifyNode(node.right);
-      if (left.kind === "const" && right.kind === "const" && !isRationalZero(right.value)) {
-        return constNode(rationalDiv(left.value, right.value));
-      }
-      const foldedDiv = foldComplexBinary("div", left, right);
-      if (foldedDiv !== null) return foldedDiv;
-      if (right.kind === "const" && isRationalOne(right.value)) return left;
-      if (left.kind === "const" && isRationalZero(left.value)) return constNode(RATIONAL_ZERO);
-      if (left.kind === "mul") {
-        if (nodesEqual(left.left, right)) return left.right;
-        if (nodesEqual(left.right, right)) return left.left;
-      }
-      const cancelled = cancelSymbolic({ kind: "div", left, right });
-      if (cancelled.kind !== "div" || cancelled.left !== left || cancelled.right !== right) {
-        return simplifyNode(cancelled);
-      }
-      if (left.kind === "neg" && left.operand.kind === "mul") {
-        const product = left.operand;
-        if (nodesEqual(product.left, right)) return simplifyNode({ kind: "neg", operand: product.right });
-        if (nodesEqual(product.right, right)) return simplifyNode({ kind: "neg", operand: product.left });
-      }
-      return { kind: "div", left, right };
-    }
-    case "pow": {
-      const base = simplifyNode(node.base);
-      const exponent = simplifyNode(node.exponent);
-      if (exponent.kind === "const") {
-        if (isRationalZero(exponent.value)) return constNode(RATIONAL_ONE);
-        if (isRationalOne(exponent.value)) return base;
-        if (base.kind === "const" && isRationalInteger(exponent.value)) {
-          return constNode(rationalPow(base.value, exponent.value.n));
-        }
-        if (base.kind === "complex" && isRationalInteger(exponent.value)) {
-          return complexNode(complexPow(base.value, exponent.value.n));
-        }
-      }
-      if (base.kind === "const" && isRationalOne(base.value)) return constNode(RATIONAL_ONE);
-      if (base.kind === "const" && isRationalZero(base.value) && exponent.kind === "const" && exponent.value.n > 0n) {
-        return constNode(RATIONAL_ZERO);
-      }
-      if (base.kind === "pow" && base.exponent.kind === "const" && exponent.kind === "const" && isRationalInteger(base.exponent.value) && isRationalInteger(exponent.value)) {
-        return simplifyNode({
-          kind: "pow",
-          base: base.base,
-          exponent: constNode(rationalMul(base.exponent.value, exponent.value))
-        });
-      }
-      return { kind: "pow", base, exponent };
-    }
-    case "call": {
-      const args = node.args.map(simplifyNode);
-      if (args.every((arg) => arg.kind === "const")) {
-        const folded = foldCall(node.name, args.map((arg) => arg.value));
-        if (folded !== null) return constNode(folded);
-      }
-      const complexFolded = foldComplexCall(node.name, args);
-      if (complexFolded !== null) return complexFolded;
-      return { kind: "call", name: node.name, args };
-    }
-  }
-}
-
-// src/symbolic/SymbolicFormat.ts
-function tryExtractCoeffVar(node) {
-  if (node.left.kind === "const" && node.right.kind === "var") return { coeff: node.left.value, name: node.right.name };
-  if (node.right.kind === "const" && node.left.kind === "var") return { coeff: node.right.value, name: node.left.name };
-  return null;
-}
-function tryExtractCoeffPow(node) {
-  if (node.left.kind === "const" && node.right.kind === "pow") return { coeff: node.left.value, power: node.right };
-  if (node.right.kind === "const" && node.left.kind === "pow") return { coeff: node.right.value, power: node.left };
-  return null;
-}
-function isAtomic(node) {
-  if (node.kind === "var" || node.kind === "call") return true;
-  return node.kind === "const" && node.value.n >= 0n;
-}
-function formatCoefficient(coeff, text) {
-  if (coeff.n === 1n && coeff.d === 1n) return text;
-  if (coeff.n === -1n && coeff.d === 1n) return `-${text}`;
-  return `${formatRational(coeff)}${text}`;
-}
-var MAX_FORMAT_DEPTH = 600;
-var ELIDED = "...";
-function formatFactor(node, depth) {
-  if (depth >= MAX_FORMAT_DEPTH) return ELIDED;
-  switch (node.kind) {
-    case "const":
-      return formatRational(node.value);
-    case "complex":
-      return node.value.re.n !== 0n && node.value.im.n !== 0n ? `(${formatComplex(node.value)})` : formatComplex(node.value);
-    case "var":
-      return node.name;
-    case "add":
-    case "sub":
-      return `(${formatSum(node, depth)})`;
-    case "neg":
-      return `-${formatFactor(node.operand, depth + 1)}`;
-    case "call":
-      return `${node.name}(${node.args.map((arg) => formatSum(arg, depth + 1)).join(", ")})`;
-    case "pow": {
-      const base = isAtomic(node.base) ? formatFactor(node.base, depth + 1) : `(${formatSum(node.base, depth + 1)})`;
-      const exponent = isAtomic(node.exponent) ? formatFactor(node.exponent, depth + 1) : `(${formatSum(node.exponent, depth + 1)})`;
-      return `${base}^${exponent}`;
-    }
-    case "mul": {
-      const coeffVar = tryExtractCoeffVar(node);
-      if (coeffVar) return formatCoefficient(coeffVar.coeff, coeffVar.name);
-      const coeffPow = tryExtractCoeffPow(node);
-      if (coeffPow) return formatCoefficient(coeffPow.coeff, formatFactor(coeffPow.power, depth + 1));
-      if (node.left.kind === "const" && node.right.kind === "mul") {
-        const inner = formatFactor(node.right, depth + 1);
-        if (!/^[\d.]/.test(inner)) return formatCoefficient(node.left.value, inner);
-      }
-      return `${formatFactor(node.left, depth + 1)}*${formatFactor(node.right, depth + 1)}`;
-    }
-    case "div": {
-      const denominator = formatFactor(node.right, depth + 1);
-      const needsBrackets = node.right.kind === "mul" || node.right.kind === "div";
-      return `${formatFactor(node.left, depth + 1)}/${needsBrackets ? `(${denominator})` : denominator}`;
-    }
-  }
-}
-function collectDisplayTerms(node, negated, out, depth) {
-  if (depth >= MAX_FORMAT_DEPTH) {
-    out.push({ negated, text: ELIDED });
-    return;
-  }
-  switch (node.kind) {
-    case "add":
-      collectDisplayTerms(node.left, negated, out, depth + 1);
-      collectDisplayTerms(node.right, negated, out, depth + 1);
-      return;
-    case "sub":
-      collectDisplayTerms(node.left, negated, out, depth + 1);
-      collectDisplayTerms(node.right, !negated, out, depth + 1);
-      return;
-    case "neg":
-      collectDisplayTerms(node.operand, !negated, out, depth + 1);
-      return;
-    case "const": {
-      if (node.value.n === 0n) return;
-      const isNegative = node.value.n < 0n;
-      const magnitude = isNegative ? { n: -node.value.n, d: node.value.d } : node.value;
-      out.push({ negated: isNegative !== negated, text: formatRational(magnitude) });
-      return;
-    }
-    case "complex": {
-      const { re, im } = node.value;
-      if (re.n !== 0n) {
-        const negativeReal = re.n < 0n;
-        out.push({ negated: negativeReal !== negated, text: formatRational(negativeReal ? { n: -re.n, d: re.d } : re) });
-      }
-      if (im.n !== 0n) {
-        const negativeImaginary = im.n < 0n;
-        const magnitude = negativeImaginary ? { n: -im.n, d: im.d } : im;
-        const text = magnitude.n === 1n && magnitude.d === 1n ? "i" : `${formatRational(magnitude)}i`;
-        out.push({ negated: negativeImaginary !== negated, text });
-      }
-      return;
-    }
-    default: {
-      const text = formatFactor(node, depth);
-      const liftsSign = (node.kind === "mul" || node.kind === "div") && text.startsWith("-");
-      if (liftsSign) out.push({ negated: !negated, text: text.slice(1) });
-      else out.push({ negated, text });
-    }
-  }
-}
-function formatSymbolic(node) {
-  try {
-    return formatSum(node, 0);
-  } catch (thrown) {
-    if (thrown instanceof RangeError) return ELIDED;
-    throw thrown;
-  }
-}
-function formatSum(node, depth) {
-  const terms = [];
-  collectDisplayTerms(node, false, terms, depth);
-  if (terms.length === 0) return "0";
-  let out = "";
-  terms.forEach((term, index) => {
-    if (index === 0) out += term.negated ? `-${term.text}` : term.text;
-    else out += term.negated ? `-${term.text}` : `+${term.text}`;
-  });
-  return out;
-}
-
-// src/vm/MatrixOps.ts
-function matIndex(m, index) {
-  return m.data[index];
-}
-function matAt(m, row, col) {
-  return m.data[row + col * m.rows];
-}
-function inBounds(m, row, col) {
-  return row >= 0 && row < m.rows && col >= 0 && col < m.cols;
-}
-function sameShape(a, b) {
-  return a.rows === b.rows && a.cols === b.cols;
-}
-function isSquare(m) {
-  return m.rows === m.cols;
-}
-function entryToSymbolic(entry) {
-  if (typeof entry === "object" && entry !== null) return entry;
-  if (typeof entry === "boolean") return constNode(entry ? 1 : 0);
-  return constNode(entry);
-}
-function symbolicToEntry(node) {
-  const simplified = simplifySymbolic(node);
-  return simplified.kind === "const" ? rationalToNumber(simplified.value) : simplified;
-}
-function matrixEntryToValue(cell) {
-  if (typeof cell === "boolean") return chunkIT74O4BE_cjs.boolValue(cell);
-  if (typeof cell === "object" && cell !== null) return chunkIT74O4BE_cjs.symbolicValue(cell);
-  return chunkIT74O4BE_cjs.numberValue(cell);
-}
-function rowMajorToColumnMajor(rows, cols, rowMajorData) {
-  const data = new Array(rows * cols);
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c < cols; c++) {
-      data[r + c * rows] = rowMajorData[r * cols + c];
-    }
-  }
-  return data;
-}
-function columnMajorToRowMajor(m) {
-  const data = new Array(m.rows * m.cols);
-  for (let r = 0; r < m.rows; r++) {
-    for (let c = 0; c < m.cols; c++) {
-      data[r * m.cols + c] = matAt(m, r, c);
-    }
-  }
-  return data;
-}
-function matrixMultiply(l, r) {
-  const lIsScalar = l.rows === 1 && l.cols === 1;
-  const rIsScalar = r.rows === 1 && r.cols === 1;
-  const useSymbolic = l.hasSymbolic || r.hasSymbolic;
-  if (lIsScalar || rIsScalar) {
-    const [scalarOperand, matrixOperand] = lIsScalar ? [l, r] : [r, l];
-    if (useSymbolic) {
-      const scalarNode = entryToSymbolic(scalarOperand.data[0]);
-      const result2 = matrixOperand.data.map((v) => symbolicToEntry(simplifySymbolic({ kind: "mul", left: entryToSymbolic(v), right: scalarNode })));
-      return chunkIT74O4BE_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result2);
-    }
-    const scalar = scalarOperand.data[0];
-    const result = matrixOperand.data.map((v) => v * scalar);
-    return chunkIT74O4BE_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result);
-  }
-  if (l.cols !== r.rows) {
-    return chunkIT74O4BE_cjs.errorValue(
-      "DIMENSION_MISMATCH",
-      `Cannot multiply a ${l.rows}x${l.cols} matrix by a ${r.rows}x${r.cols} matrix \u2014 inner dimensions must match (${l.cols} !== ${r.rows}).`
-    );
-  }
-  const resultRows = l.rows;
-  const resultCols = r.cols;
-  const data = chunkIT74O4BE_cjs.checkedArray(resultRows * resultCols, "matrix cells");
-  for (let row = 0; row < resultRows; row++) {
-    for (let col = 0; col < resultCols; col++) {
-      if (useSymbolic) {
-        let acc = constNode(0);
-        for (let k = 0; k < l.cols; k++) {
-          const term = { kind: "mul", left: entryToSymbolic(matAt(l, row, k)), right: entryToSymbolic(matAt(r, k, col)) };
-          acc = simplifySymbolic({ kind: "add", left: acc, right: term });
-        }
-        data[row + col * resultRows] = symbolicToEntry(acc);
-      } else {
-        let sum = 0;
-        for (let k = 0; k < l.cols; k++) {
-          sum += matAt(l, row, k) * matAt(r, k, col);
-        }
-        data[row + col * resultRows] = sum;
-      }
-    }
-  }
-  return chunkIT74O4BE_cjs.matrixValue(resultRows, resultCols, data);
-}
-function matrixPower(m, exponent) {
-  if (!isSquare(m)) {
-    return chunkIT74O4BE_cjs.errorValue("MATRIX_POWER_REQUIRES_SQUARE_MATRIX", `^: only a square matrix can be raised to a power (got ${m.rows}x${m.cols}).`);
-  }
-  if (!Number.isInteger(exponent) || exponent < 0) {
-    return chunkIT74O4BE_cjs.errorValue(
-      "MATRIX_POWER_REQUIRES_WHOLE_EXPONENT",
-      `^: a matrix can only be raised to a whole number of 0 or more (got ${exponent}); "^-1" means the inverse and "^T" the transpose.`
-    );
-  }
-  const n = m.rows;
-  const identity = new Array(n * n).fill(0);
-  for (let i = 0; i < n; i++) identity[i + i * n] = 1;
-  let accumulated = { rows: n, cols: n, data: identity, hasSymbolic: false };
-  let squared = m;
-  let remaining = exponent;
-  while (remaining > 0) {
-    if (remaining % 2 === 1) {
-      const product = matrixMultiply(accumulated, squared);
-      if (product.type === 13 /* Error */) return product;
-      accumulated = product.value;
-    }
-    remaining = Math.floor(remaining / 2);
-    if (remaining > 0) {
-      const doubled = matrixMultiply(squared, squared);
-      if (doubled.type === 13 /* Error */) return doubled;
-      squared = doubled.value;
-    }
-  }
-  return chunkIT74O4BE_cjs.matrixValue(accumulated.rows, accumulated.cols, accumulated.data);
-}
-function matrixCompare(l, r, cmp) {
-  if (!sameShape(l, r)) {
-    return chunkIT74O4BE_cjs.errorValue(
-      "DIMENSION_MISMATCH",
-      `Cannot compare matrices of different shapes: ${l.rows}x${l.cols} and ${r.rows}x${r.cols}`
-    );
-  }
-  const data = new Array(l.data.length);
-  for (let i = 0; i < l.data.length; i++) data[i] = cmp(l.data[i], r.data[i]);
-  return chunkIT74O4BE_cjs.matrixValue(l.rows, l.cols, data);
-}
-function transpose(m) {
-  const data = new Array(m.rows * m.cols);
-  for (let r = 0; r < m.cols; r++) {
-    for (let c = 0; c < m.rows; c++) {
-      data[r + c * m.cols] = matAt(m, c, r);
-    }
-  }
-  return chunkIT74O4BE_cjs.matrixValue(m.cols, m.rows, data);
-}
-function toWorkingRows(m) {
-  const rows = [];
-  for (let r = 0; r < m.rows; r++) {
-    const row = [];
-    for (let c = 0; c < m.cols; c++) row.push(matAt(m, r, c));
-    rows.push(row);
-  }
-  return rows;
-}
-var EXACT_DETERMINANT_DIMENSION_LIMIT = 12;
-function toIntegerRows(m) {
-  if (m.rows > EXACT_DETERMINANT_DIMENSION_LIMIT) return null;
-  const rows = [];
-  for (let r = 0; r < m.rows; r++) {
-    const row = [];
-    for (let c = 0; c < m.cols; c++) {
-      const cell = matAt(m, r, c);
-      if (typeof cell !== "number" || !Number.isSafeInteger(cell)) return null;
-      row.push(BigInt(cell));
-    }
-    rows.push(row);
-  }
-  return rows;
-}
-function integerDeterminant(rows) {
-  const n = rows.length;
-  let previous = 1n;
-  let sign = 1n;
-  for (let k = 0; k < n - 1; k++) {
-    if (rows[k][k] === 0n) {
-      let candidate = -1;
-      for (let r = k + 1; r < n; r++) {
-        if (rows[r][k] !== 0n) {
-          candidate = r;
-          break;
-        }
-      }
-      if (candidate === -1) return 0n;
-      const swapped = rows[k];
-      rows[k] = rows[candidate];
-      rows[candidate] = swapped;
-      sign = -sign;
-    }
-    for (let i = k + 1; i < n; i++) {
-      for (let j = k + 1; j < n; j++) {
-        rows[i][j] = (rows[i][j] * rows[k][k] - rows[i][k] * rows[k][j]) / previous;
-      }
-    }
-    previous = rows[k][k];
-  }
-  return sign * rows[n - 1][n - 1];
-}
-function numericDeterminant(m) {
-  const integers = toIntegerRows(m);
-  if (integers !== null) return chunkIT74O4BE_cjs.numberValue(Number(integerDeterminant(integers)));
-  const n = m.rows;
-  const a = toWorkingRows(m);
-  let det = 1;
-  for (let col = 0; col < n; col++) {
-    let pivotRow = col;
-    let maxAbs = Math.abs(a[col][col]);
-    for (let r = col + 1; r < n; r++) {
-      if (Math.abs(a[r][col]) > maxAbs) {
-        maxAbs = Math.abs(a[r][col]);
-        pivotRow = r;
-      }
-    }
-    if (maxAbs === 0) return chunkIT74O4BE_cjs.numberValue(0);
-    if (pivotRow !== col) {
-      const tmp = a[col];
-      a[col] = a[pivotRow];
-      a[pivotRow] = tmp;
-      det = -det;
-    }
-    det *= a[col][col];
-    for (let r = col + 1; r < n; r++) {
-      const factor = a[r][col] / a[col][col];
-      if (factor === 0) continue;
-      for (let c = col; c < n; c++) a[r][c] -= factor * a[col][c];
-    }
-  }
-  return chunkIT74O4BE_cjs.numberValue(det);
-}
-function symbolicDeterminant(m) {
-  const n = m.rows;
-  const a = [];
-  for (let r = 0; r < n; r++) {
-    const row = [];
-    for (let c = 0; c < n; c++) row.push(entryToSymbolic(matAt(m, r, c)));
-    a.push(row);
-  }
-  let det = constNode(1);
-  for (let col = 0; col < n; col++) {
-    const pivot = simplifySymbolic(a[col][col]);
-    if (pivot.kind === "const" && isRationalZero(pivot.value)) return chunkIT74O4BE_cjs.numberValue(0);
-    det = simplifySymbolic({ kind: "mul", left: det, right: pivot });
-    for (let r = col + 1; r < n; r++) {
-      const factor = simplifySymbolic({ kind: "div", left: a[r][col], right: pivot });
-      for (let c = col; c < n; c++) {
-        a[r][c] = simplifySymbolic({ kind: "sub", left: a[r][c], right: { kind: "mul", left: factor, right: a[col][c] } });
-      }
-    }
-  }
-  return det.kind === "const" ? chunkIT74O4BE_cjs.numberValue(rationalToNumber(det.value)) : chunkIT74O4BE_cjs.symbolicValue(det);
-}
-function determinant(m) {
-  if (!isSquare(m)) {
-    return chunkIT74O4BE_cjs.errorValue("DETERMINANT_REQUIRES_SQUARE_MATRIX", `det: matrix must be square (got ${m.rows}x${m.cols}).`);
-  }
-  return m.hasSymbolic ? symbolicDeterminant(m) : numericDeterminant(m);
-}
-function numericInverse(m) {
-  const n = m.rows;
-  const a = toWorkingRows(m);
-  for (let r = 0; r < n; r++) {
-    for (let c = 0; c < n; c++) a[r].push(c === r ? 1 : 0);
-  }
-  for (let col = 0; col < n; col++) {
-    let pivotRow = col;
-    let maxAbs = Math.abs(a[col][col]);
-    for (let r = col + 1; r < n; r++) {
-      if (Math.abs(a[r][col]) > maxAbs) {
-        maxAbs = Math.abs(a[r][col]);
-        pivotRow = r;
-      }
-    }
-    if (maxAbs < 1e-10) {
-      return chunkIT74O4BE_cjs.errorValue("SINGULAR_MATRIX", `inv: a ${n}x${n} matrix with a zero (or near-zero) pivot column is not invertible.`);
-    }
-    if (pivotRow !== col) {
-      const tmp = a[col];
-      a[col] = a[pivotRow];
-      a[pivotRow] = tmp;
-    }
-    const pivot = a[col][col];
-    for (let c = 0; c < 2 * n; c++) a[col][c] /= pivot;
-    for (let r = 0; r < n; r++) {
-      if (r === col) continue;
-      const factor = a[r][col];
-      if (factor === 0) continue;
-      for (let c = 0; c < 2 * n; c++) a[r][c] -= factor * a[col][c];
-    }
-  }
-  const data = new Array(n * n);
-  for (let r = 0; r < n; r++) {
-    for (let c = 0; c < n; c++) data[r + c * n] = a[r][n + c];
-  }
-  return chunkIT74O4BE_cjs.matrixValue(n, n, data);
-}
-var SYMBOLIC_INVERSE_DIMENSION_LIMIT = 9;
-function symbolicInverse(m) {
-  const n = m.rows;
-  if (n >= SYMBOLIC_INVERSE_DIMENSION_LIMIT) {
-    return chunkIT74O4BE_cjs.errorValue(
-      "SYMBOLIC_INVERSE_DIMENSION_LIMIT",
-      `Symbolic matrix inversion is limited to matrices smaller than ${SYMBOLIC_INVERSE_DIMENSION_LIMIT}x${SYMBOLIC_INVERSE_DIMENSION_LIMIT} (got ${n}x${n}).`
-    );
-  }
-  const a = [];
-  for (let r = 0; r < n; r++) {
-    const row = [];
-    for (let c = 0; c < n; c++) row.push(entryToSymbolic(matAt(m, r, c)));
-    for (let c = 0; c < n; c++) row.push(constNode(c === r ? 1 : 0));
-    a.push(row);
-  }
-  for (let col = 0; col < n; col++) {
-    const pivot = simplifySymbolic(a[col][col]);
-    if (pivot.kind === "const" && isRationalZero(pivot.value)) {
-      return chunkIT74O4BE_cjs.errorValue(
-        "SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT",
-        `Symbolic inverse: the pivot at row/col ${col} is exactly zero \u2014 this matrix's structure isn't invertible via this engine's diagonal-first symbolic elimination (no row-swapping); try reordering rows manually.`
-      );
-    }
-    for (let r = 0; r < n; r++) {
-      if (r === col) continue;
-      const factor = simplifySymbolic({ kind: "div", left: a[r][col], right: pivot });
-      if (factor.kind === "const" && isRationalZero(factor.value)) continue;
-      for (let c = 0; c < 2 * n; c++) {
-        a[r][c] = simplifySymbolic({ kind: "sub", left: a[r][c], right: { kind: "mul", left: factor, right: a[col][c] } });
-      }
-    }
-    for (let c = 0; c < 2 * n; c++) {
-      a[col][c] = simplifySymbolic({ kind: "div", left: a[col][c], right: pivot });
-    }
-  }
-  const data = new Array(n * n);
-  for (let r = 0; r < n; r++) {
-    for (let c = 0; c < n; c++) data[r + c * n] = symbolicToEntry(a[r][n + c]);
-  }
-  return chunkIT74O4BE_cjs.matrixValue(n, n, data);
-}
-function inverse(m) {
-  if (!isSquare(m)) {
-    return chunkIT74O4BE_cjs.errorValue("INVERSE_REQUIRES_SQUARE_MATRIX", `inv: matrix must be square (got ${m.rows}x${m.cols}).`);
-  }
-  return m.hasSymbolic ? symbolicInverse(m) : numericInverse(m);
-}
-function tooLarge(length, maxElements) {
-  return chunkIT74O4BE_cjs.errorValue(
-    "COLLECTION_TOO_LARGE",
-    `This collection has ${length} elements, past the limit of ${maxElements} (see the engine's vm.maxCollectionSize setting).`
-  );
-}
-function collectionToValues(v, maxElements = Number.POSITIVE_INFINITY) {
-  const faulted = chunkIT74O4BE_cjs.faultedOperand(v);
-  if (faulted) return faulted;
-  if (v.type === 7 /* Matrix */) {
-    const m = v.value;
-    if (m.data.length > maxElements) return tooLarge(m.data.length, maxElements);
-    return m.data.map(matrixEntryToValue);
-  }
-  if (v.type === 8 /* Range */) {
-    const r = v.value;
-    const length = r.max - r.min + 1;
-    if (length > maxElements) return tooLarge(length, maxElements);
-    const out = new Array(length);
-    for (let i = 0; i < length; i++) out[i] = chunkIT74O4BE_cjs.numberValue(r.min + i);
-    return out;
-  }
-  return chunkIT74O4BE_cjs.errorValue(
-    "MAP_REDUCE_REQUIRES_COLLECTION",
-    `map/reduce requires a Matrix or Range collection (e.g. "[1,2,3]" or "0:3").`
-  );
-}
-
-// src/uom/CurrencyAliases.ts
-var CURRENCY_SYMBOL_ALIASES = {
-  "$": "USD",
-  "\xA3": "GBP",
-  "\u20AC": "EUR",
-  // ¥ is genuinely ambiguous between JPY and CNY in real-world usage, JPY
-  // is the conventional default (matches Numi/most calculator apps' own
-  // choice); a user wanting CNY specifically can still type "CNY" directly.
-  "\xA5": "JPY",
-  "\u20BD": "RUB",
-  "\u20A9": "KRW",
-  "\u20B9": "INR",
-  "\u20BA": "TRY",
-  "\u20B4": "UAH",
-  "\u20AA": "ILS",
-  "\u20AB": "VND",
-  "\u20A6": "NGN",
-  "\u20B1": "PHP"
-};
-var CURRENCY_WORD_ALIASES = {
-  dollar: "USD",
-  dollars: "USD",
-  euro: "EUR",
-  euros: "EUR",
-  yen: "JPY",
-  ruble: "RUB",
-  rubles: "RUB",
-  rouble: "RUB",
-  roubles: "RUB",
-  won: "KRW",
-  rupee: "INR",
-  rupees: "INR",
-  yuan: "CNY",
-  renminbi: "CNY",
-  franc: "CHF",
-  francs: "CHF",
-  rand: "ZAR",
-  krona: "SEK",
-  kronor: "SEK",
-  krone: "NOK",
-  kroner: "NOK",
-  real: "BRL",
-  reais: "BRL",
-  peso: "MXN",
-  pesos: "MXN",
-  shekel: "ILS",
-  shekels: "ILS",
-  lira: "TRY",
-  hryvnia: "UAH",
-  hryvnias: "UAH",
-  zloty: "PLN",
-  zlotys: "PLN",
-  forint: "HUF",
-  koruna: "CZK",
-  dirham: "AED",
-  dirhams: "AED",
-  riyal: "SAR",
-  riyals: "SAR",
-  rial: "SAR",
-  rials: "SAR",
-  ringgit: "MYR",
-  rupiah: "IDR",
-  baht: "THB",
-  dong: "VND",
-  naira: "NGN"
-};
-function resolveCurrencyAlias(text) {
-  return CURRENCY_SYMBOL_ALIASES[text] ?? CURRENCY_WORD_ALIASES[text.toLowerCase()];
-}
-var CURRENCY_DISPLAY = {
-  USD: { symbol: "$", position: "prefix", spaced: false },
-  AUD: { symbol: "$", position: "prefix", spaced: false },
-  CAD: { symbol: "$", position: "prefix", spaced: false },
-  NZD: { symbol: "$", position: "prefix", spaced: false },
-  HKD: { symbol: "$", position: "prefix", spaced: false },
-  SGD: { symbol: "$", position: "prefix", spaced: false },
-  MXN: { symbol: "$", position: "prefix", spaced: false },
-  GBP: { symbol: "\xA3", position: "prefix", spaced: false },
-  // English-language convention (€100.00), many EU locales instead suffix
-  // with a space ("100,00 €"); this engine's default locale is "en", so
-  // the English convention was chosen. A locale-aware override would be a
-  // reasonable future extension, not attempted here.
-  EUR: { symbol: "\u20AC", position: "prefix", spaced: false },
-  JPY: { symbol: "\xA5", position: "prefix", spaced: false },
-  CNY: { symbol: "\xA5", position: "prefix", spaced: false },
-  KRW: { symbol: "\u20A9", position: "prefix", spaced: false },
-  INR: { symbol: "\u20B9", position: "prefix", spaced: false },
-  // Russian convention places the ruble sign AFTER the amount, with a space.
-  RUB: { symbol: "\u20BD", position: "suffix", spaced: true },
-  TRY: { symbol: "\u20BA", position: "prefix", spaced: false },
-  UAH: { symbol: "\u20B4", position: "suffix", spaced: true },
-  ILS: { symbol: "\u20AA", position: "prefix", spaced: false },
-  // Vietnamese convention: no space, symbol after the amount.
-  VND: { symbol: "\u20AB", position: "suffix", spaced: false },
-  NGN: { symbol: "\u20A6", position: "prefix", spaced: false },
-  PHP: { symbol: "\u20B1", position: "prefix", spaced: false },
-  BRL: { symbol: "R$", position: "prefix", spaced: false },
-  ZAR: { symbol: "R", position: "prefix", spaced: false },
-  // Scandinavian convention: amount then "kr", space-separated.
-  SEK: { symbol: "kr", position: "suffix", spaced: true },
-  NOK: { symbol: "kr", position: "suffix", spaced: true },
-  DKK: { symbol: "kr", position: "suffix", spaced: true },
-  PLN: { symbol: "z\u0142", position: "suffix", spaced: true },
-  CHF: { symbol: "Fr", position: "suffix", spaced: true },
-  HUF: { symbol: "Ft", position: "suffix", spaced: true },
-  CZK: { symbol: "K\u010D", position: "suffix", spaced: true }
-};
-
-exports.COMPLEX_I = COMPLEX_I;
-exports.CURRENCY_DISPLAY = CURRENCY_DISPLAY;
-exports.RATIONAL_ONE = RATIONAL_ONE;
-exports.RATIONAL_ZERO = RATIONAL_ZERO;
-exports.callNode = callNode;
-exports.cancelSymbolic = cancelSymbolic;
-exports.coefficientGcd = coefficientGcd;
-exports.collectionToValues = collectionToValues;
-exports.columnMajorToRowMajor = columnMajorToRowMajor;
-exports.compareMonomials = compareMonomials;
-exports.complex = complex;
-exports.complexNode = complexNode;
-exports.constNode = constNode;
-exports.decimalAdd = decimalAdd;
-exports.decimalCompare = decimalCompare;
-exports.decimalDivide = decimalDivide;
-exports.decimalFromInteger = decimalFromInteger;
-exports.decimalFromLiteral = decimalFromLiteral;
-exports.decimalFromNumberIfExact = decimalFromNumberIfExact;
-exports.decimalIsZero = decimalIsZero;
-exports.decimalMultiply = decimalMultiply;
-exports.decimalNegate = decimalNegate;
-exports.decimalRound = decimalRound;
-exports.decimalSubtract = decimalSubtract;
-exports.decimalToFixed = decimalToFixed;
-exports.decimalToNumber = decimalToNumber;
-exports.determinant = determinant;
-exports.exactIntegerCbrt = exactIntegerCbrt;
-exports.exactIntegerSqrt = exactIntegerSqrt;
-exports.exactRationalSqrt = exactRationalSqrt2;
-exports.expandSymbolic = expandSymbolic;
-exports.formatSymbolic = formatSymbolic;
-exports.freeVariables = freeVariables;
-exports.fromPolynomial = fromPolynomial;
-exports.inBounds = inBounds;
-exports.inverse = inverse;
-exports.isRationalOne = isRationalOne;
-exports.isRationalZero = isRationalZero;
-exports.isZeroPolynomial = isZeroPolynomial;
-exports.makeDecimal = makeDecimal;
-exports.matAt = matAt;
-exports.matIndex = matIndex;
-exports.matrixCompare = matrixCompare;
-exports.matrixEntryToValue = matrixEntryToValue;
-exports.matrixMultiply = matrixMultiply;
-exports.matrixPower = matrixPower;
-exports.monomialFromKey = monomialFromKey;
-exports.monomialToKey = monomialToKey;
-exports.polyCoefficients = polyCoefficients;
-exports.polyDegree = polyDegree;
-exports.polyUnivariateVar = polyUnivariateVar;
-exports.polynomialDivide = polynomialDivide;
-exports.powNode = powNode;
-exports.rational = rational;
-exports.rationalAdd = rationalAdd;
-exports.rationalCompare = rationalCompare;
-exports.rationalDiv = rationalDiv;
-exports.rationalFromNumber = rationalFromNumber;
-exports.rationalMul = rationalMul;
-exports.rationalNeg = rationalNeg;
-exports.rationalSub = rationalSub;
-exports.rationalToNumber = rationalToNumber;
-exports.resolveCurrencyAlias = resolveCurrencyAlias;
-exports.rowMajorToColumnMajor = rowMajorToColumnMajor;
-exports.sameShape = sameShape;
-exports.signedSurdNode = signedSurdNode;
-exports.simplifySymbolic = simplifySymbolic;
-exports.squareFreePart = squareFreePart;
-exports.substitute = substitute;
-exports.surdNode = surdNode;
-exports.symbolicKey = symbolicKey;
-exports.symbolicToEntry = symbolicToEntry;
-exports.toPolynomial = toPolynomial;
-exports.transpose = transpose;
-exports.varNode = varNode;
-//# sourceMappingURL=chunk-A2DZ5BEJ.cjs.map
-//# sourceMappingURL=chunk-A2DZ5BEJ.cjs.map