solve-engine 1.1.0 → 1.2.0

package/dist/{chunk-7ZX6B7SY.cjs → chunk-FR7RNOPT.cjs}

@@ -1,63 +1,63 @@
 'use strict';
 
 var chunkFEAIOR7N_cjs = require('./chunk-FEAIOR7N.cjs');
-var chunkZVTWQLK4_cjs = require('./chunk-ZVTWQLK4.cjs');
-var chunkHIQ5HSZL_cjs = require('./chunk-HIQ5HSZL.cjs');
-var chunk2TZKENDH_cjs = require('./chunk-2TZKENDH.cjs');
+var chunkKXDQKVNX_cjs = require('./chunk-KXDQKVNX.cjs');
+var chunkA2DZ5BEJ_cjs = require('./chunk-A2DZ5BEJ.cjs');
+var chunkIT74O4BE_cjs = require('./chunk-IT74O4BE.cjs');
 var chunkEJ3ILXX6_cjs = require('./chunk-EJ3ILXX6.cjs');
 var chunkAMOJYLG2_cjs = require('./chunk-AMOJYLG2.cjs');
-var chunkB4HBEFTB_cjs = require('./chunk-B4HBEFTB.cjs');
+var chunkMIGXCBXT_cjs = require('./chunk-MIGXCBXT.cjs');
 
 // src/symbolic/MultivariateFactor.ts
 function exactRoot(value, degree) {
-  const rootOf = degree === 2 ? chunkHIQ5HSZL_cjs.exactIntegerSqrt : chunkHIQ5HSZL_cjs.exactIntegerCbrt;
+  const rootOf = degree === 2 ? chunkA2DZ5BEJ_cjs.exactIntegerSqrt : chunkA2DZ5BEJ_cjs.exactIntegerCbrt;
   const numerator = rootOf(value.n);
   const denominator = rootOf(value.d);
   return numerator === null || denominator === null ? null : { n: numerator, d: denominator };
 }
 function monomialRoot(key, degree) {
-  const monomial = chunkHIQ5HSZL_cjs.monomialFromKey(key);
+  const monomial = chunkA2DZ5BEJ_cjs.monomialFromKey(key);
   const root = /* @__PURE__ */ new Map();
   for (const [name, exponent] of monomial) {
     if (exponent % degree !== 0) return null;
     root.set(name, exponent / degree);
   }
-  return chunkHIQ5HSZL_cjs.monomialToKey(root);
+  return chunkA2DZ5BEJ_cjs.monomialToKey(root);
 }
 function monomialMul(a, b) {
-  const product2 = chunkHIQ5HSZL_cjs.monomialFromKey(a);
-  for (const [name, exponent] of chunkHIQ5HSZL_cjs.monomialFromKey(b)) {
+  const product2 = chunkA2DZ5BEJ_cjs.monomialFromKey(a);
+  for (const [name, exponent] of chunkA2DZ5BEJ_cjs.monomialFromKey(b)) {
     product2.set(name, (product2.get(name) ?? 0) + exponent);
   }
-  return chunkHIQ5HSZL_cjs.monomialToKey(product2);
+  return chunkA2DZ5BEJ_cjs.monomialToKey(product2);
 }
 function monomialDiv(a, b) {
-  const quotient = chunkHIQ5HSZL_cjs.monomialFromKey(a);
-  for (const [name, exponent] of chunkHIQ5HSZL_cjs.monomialFromKey(b)) {
+  const quotient = chunkA2DZ5BEJ_cjs.monomialFromKey(a);
+  for (const [name, exponent] of chunkA2DZ5BEJ_cjs.monomialFromKey(b)) {
     const remaining = (quotient.get(name) ?? 0) - exponent;
     if (remaining <= 0) quotient.delete(name);
     else quotient.set(name, remaining);
   }
-  return chunkHIQ5HSZL_cjs.monomialToKey(quotient);
+  return chunkA2DZ5BEJ_cjs.monomialToKey(quotient);
 }
 function monomialGcd(a, b) {
-  const left = chunkHIQ5HSZL_cjs.monomialFromKey(a);
+  const left = chunkA2DZ5BEJ_cjs.monomialFromKey(a);
   const shared = /* @__PURE__ */ new Map();
-  for (const [name, exponent] of chunkHIQ5HSZL_cjs.monomialFromKey(b)) {
+  for (const [name, exponent] of chunkA2DZ5BEJ_cjs.monomialFromKey(b)) {
     const other = left.get(name);
     if (other !== void 0) shared.set(name, Math.min(other, exponent));
   }
-  return chunkHIQ5HSZL_cjs.monomialToKey(shared);
+  return chunkA2DZ5BEJ_cjs.monomialToKey(shared);
 }
 function namesOf(keys) {
   const names = /* @__PURE__ */ new Set();
-  for (const key of keys) for (const name of chunkHIQ5HSZL_cjs.monomialFromKey(key).keys()) names.add(name);
+  for (const key of keys) for (const name of chunkA2DZ5BEJ_cjs.monomialFromKey(key).keys()) names.add(name);
   return [...names].sort();
 }
 function termsToNode(terms) {
   const map = /* @__PURE__ */ new Map();
   for (const term of terms) map.set(term.key, term.coefficient);
-  return chunkHIQ5HSZL_cjs.fromPolynomial({ terms: map, vars: namesOf(terms.map((term) => term.key)) });
+  return chunkA2DZ5BEJ_cjs.fromPolynomial({ terms: map, vars: namesOf(terms.map((term) => term.key)) });
 }
 function product(factors) {
   let result = factors[0];
@@ -66,7 +66,7 @@ function product(factors) {
 }
 function orderedTerms(p) {
   const terms = [...p.terms].map(([key, coefficient]) => ({ key, coefficient }));
-  return terms.sort((a, b) => chunkHIQ5HSZL_cjs.compareMonomials(a.key, b.key, p.vars));
+  return terms.sort((a, b) => chunkA2DZ5BEJ_cjs.compareMonomials(a.key, b.key, p.vars));
 }
 function factorMultivariate(p) {
   if (p.vars.length < 2) return null;
@@ -94,7 +94,7 @@ function factorBinomial(first, second) {
   return product([linear, termsToNode([squareOf(cubes.a), middle, squareOf(cubes.b)])]);
 }
 function asPowerPair(first, second, degree) {
-  const magnitude2 = second.coefficient.n < 0n ? chunkHIQ5HSZL_cjs.rationalNeg(second.coefficient) : second.coefficient;
+  const magnitude2 = second.coefficient.n < 0n ? chunkA2DZ5BEJ_cjs.rationalNeg(second.coefficient) : second.coefficient;
   const firstRoot = exactRoot(first.coefficient, degree);
   const secondRoot = exactRoot(magnitude2, degree);
   if (firstRoot === null || secondRoot === null) return null;
@@ -104,10 +104,10 @@ function asPowerPair(first, second, degree) {
   return { a: { key: firstKey, coefficient: firstRoot }, b: { key: secondKey, coefficient: secondRoot } };
 }
 function negated(term) {
-  return { key: term.key, coefficient: chunkHIQ5HSZL_cjs.rationalNeg(term.coefficient) };
+  return { key: term.key, coefficient: chunkA2DZ5BEJ_cjs.rationalNeg(term.coefficient) };
 }
 function multiplyTerms(a, b) {
-  return { key: monomialMul(a.key, b.key), coefficient: chunkHIQ5HSZL_cjs.rationalMul(a.coefficient, b.coefficient) };
+  return { key: monomialMul(a.key, b.key), coefficient: chunkA2DZ5BEJ_cjs.rationalMul(a.coefficient, b.coefficient) };
 }
 function squareOf(term) {
   return multiplyTerms(term, term);
@@ -119,12 +119,12 @@ function factorPerfectSquare(terms) {
   if (roots === null) return null;
   const cross = multiplyTerms(roots.a, roots.b);
   if (cross.key !== middle.key) return null;
-  const twice = chunkHIQ5HSZL_cjs.rationalMul(cross.coefficient, { n: 2n, d: 1n });
+  const twice = chunkA2DZ5BEJ_cjs.rationalMul(cross.coefficient, { n: 2n, d: 1n });
   const negative = middle.coefficient.n < 0n;
-  const magnitude2 = negative ? chunkHIQ5HSZL_cjs.rationalNeg(middle.coefficient) : middle.coefficient;
-  if (!chunkHIQ5HSZL_cjs.isRationalOne(chunkHIQ5HSZL_cjs.rationalDiv(magnitude2, twice))) return null;
+  const magnitude2 = negative ? chunkA2DZ5BEJ_cjs.rationalNeg(middle.coefficient) : middle.coefficient;
+  if (!chunkA2DZ5BEJ_cjs.isRationalOne(chunkA2DZ5BEJ_cjs.rationalDiv(magnitude2, twice))) return null;
   const base = termsToNode([roots.a, negative ? negated(roots.b) : roots.b]);
-  return { kind: "pow", base, exponent: chunkHIQ5HSZL_cjs.constNode(2) };
+  return { kind: "pow", base, exponent: chunkA2DZ5BEJ_cjs.constNode(2) };
 }
 function factorByGrouping(terms) {
   const pairings = [
@@ -149,7 +149,7 @@ function splitPair(first, second) {
   const common = { key: shared, coefficient: first.coefficient };
   const cofactor = [
     { key: monomialDiv(first.key, shared), coefficient: { n: 1n, d: 1n } },
-    { key: monomialDiv(second.key, shared), coefficient: chunkHIQ5HSZL_cjs.rationalDiv(second.coefficient, first.coefficient) }
+    { key: monomialDiv(second.key, shared), coefficient: chunkA2DZ5BEJ_cjs.rationalDiv(second.coefficient, first.coefficient) }
   ];
   return cofactor[0].key === cofactor[1].key ? null : { common, cofactor };
 }
@@ -189,14 +189,14 @@ function divisors(value) {
   return found;
 }
 function evaluateAt(descending, x) {
-  let total = chunkHIQ5HSZL_cjs.RATIONAL_ZERO;
-  for (const coeff of descending) total = chunkHIQ5HSZL_cjs.rationalAdd(chunkHIQ5HSZL_cjs.rationalMul(total, x), coeff);
+  let total = chunkA2DZ5BEJ_cjs.RATIONAL_ZERO;
+  for (const coeff of descending) total = chunkA2DZ5BEJ_cjs.rationalAdd(chunkA2DZ5BEJ_cjs.rationalMul(total, x), coeff);
   return total;
 }
 function divideByRoot(descending, root) {
   const quotient = [descending[0]];
   for (let i = 1; i < descending.length - 1; i++) {
-    quotient.push(chunkHIQ5HSZL_cjs.rationalAdd(descending[i], chunkHIQ5HSZL_cjs.rationalMul(quotient[i - 1], root)));
+    quotient.push(chunkA2DZ5BEJ_cjs.rationalAdd(descending[i], chunkA2DZ5BEJ_cjs.rationalMul(quotient[i - 1], root)));
   }
   return quotient;
 }
@@ -211,14 +211,14 @@ function rationalRoots(descending) {
   const numeratorDivisors = divisors(trailing);
   const denominatorDivisors = divisors(leading);
   if (numeratorDivisors === null || denominatorDivisors === null) {
-    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
       "SYMBOLIC_FACTOR_LIMIT_EXCEEDED",
       "This polynomial's coefficients have too many divisors to search for rational roots.",
       { limit: FACTOR_MAX_ROOT_CANDIDATES }
     );
   }
   if (numeratorDivisors.length * denominatorDivisors.length > FACTOR_MAX_ROOT_CANDIDATES) {
-    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
       "SYMBOLIC_FACTOR_LIMIT_EXCEEDED",
       "This polynomial has too many candidate rational roots to test.",
       { limit: FACTOR_MAX_ROOT_CANDIDATES }
@@ -233,25 +233,25 @@ function rationalRoots(descending) {
         const key = `${candidate.n}/${candidate.d}`;
         if (seen.has(key)) continue;
         seen.add(key);
-        if (chunkHIQ5HSZL_cjs.isRationalZero(evaluateAt(descending, candidate))) roots.push(candidate);
+        if (chunkA2DZ5BEJ_cjs.isRationalZero(evaluateAt(descending, candidate))) roots.push(candidate);
       }
     }
   }
   return roots;
 }
 function linearFactorNode(variable, root) {
-  if (chunkHIQ5HSZL_cjs.isRationalZero(root)) return chunkHIQ5HSZL_cjs.varNode(variable);
-  return root.n > 0n ? { kind: "sub", left: chunkHIQ5HSZL_cjs.varNode(variable), right: chunkHIQ5HSZL_cjs.constNode(root) } : { kind: "add", left: chunkHIQ5HSZL_cjs.varNode(variable), right: chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalNeg(root)) };
+  if (chunkA2DZ5BEJ_cjs.isRationalZero(root)) return chunkA2DZ5BEJ_cjs.varNode(variable);
+  return root.n > 0n ? { kind: "sub", left: chunkA2DZ5BEJ_cjs.varNode(variable), right: chunkA2DZ5BEJ_cjs.constNode(root) } : { kind: "add", left: chunkA2DZ5BEJ_cjs.varNode(variable), right: chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalNeg(root)) };
 }
 function coefficientsToNode(descending, variable) {
   const degree = descending.length - 1;
   const terms = /* @__PURE__ */ new Map();
   descending.forEach((coeff, index) => {
-    if (chunkHIQ5HSZL_cjs.isRationalZero(coeff)) return;
+    if (chunkA2DZ5BEJ_cjs.isRationalZero(coeff)) return;
     const power3 = degree - index;
     terms.set(power3 === 0 ? "" : power3 === 1 ? variable : `${variable}^${power3}`, coeff);
   });
-  return chunkHIQ5HSZL_cjs.fromPolynomial({ terms, vars: terms.size > 0 ? [variable] : [] });
+  return chunkA2DZ5BEJ_cjs.fromPolynomial({ terms, vars: terms.size > 0 ? [variable] : [] });
 }
 function factorUnivariate(descending, variable) {
   const factors = [];
@@ -260,7 +260,7 @@ function factorUnivariate(descending, variable) {
   while (roots.length > 0 && remaining.length > 2) {
     for (const root of roots) {
       let multiplicity = 0;
-      while (remaining.length > 1 && chunkHIQ5HSZL_cjs.isRationalZero(evaluateAt(remaining, root))) {
+      while (remaining.length > 1 && chunkA2DZ5BEJ_cjs.isRationalZero(evaluateAt(remaining, root))) {
         remaining = divideByRoot(remaining, root);
         multiplicity++;
       }
@@ -271,17 +271,17 @@ function factorUnivariate(descending, variable) {
   const leftoverDegree = remaining.length - 1;
   if (leftoverDegree >= 1) {
     factors.push({ base: coefficientsToNode(remaining, variable), power: 1 });
-    return { content: chunkHIQ5HSZL_cjs.RATIONAL_ONE, factors };
+    return { content: chunkA2DZ5BEJ_cjs.RATIONAL_ONE, factors };
   }
-  return { content: remaining.length === 1 ? remaining[0] : chunkHIQ5HSZL_cjs.RATIONAL_ONE, factors };
+  return { content: remaining.length === 1 ? remaining[0] : chunkA2DZ5BEJ_cjs.RATIONAL_ONE, factors };
 }
 function factorizationToNode(factorization) {
   const pieces = [];
-  if (!chunkHIQ5HSZL_cjs.isRationalOne(factorization.content)) pieces.push(chunkHIQ5HSZL_cjs.constNode(factorization.content));
+  if (!chunkA2DZ5BEJ_cjs.isRationalOne(factorization.content)) pieces.push(chunkA2DZ5BEJ_cjs.constNode(factorization.content));
   for (const factor of factorization.factors) {
-    pieces.push(factor.power === 1 ? factor.base : chunkHIQ5HSZL_cjs.powNode(factor.base, chunkHIQ5HSZL_cjs.constNode({ n: BigInt(factor.power), d: 1n })));
+    pieces.push(factor.power === 1 ? factor.base : chunkA2DZ5BEJ_cjs.powNode(factor.base, chunkA2DZ5BEJ_cjs.constNode({ n: BigInt(factor.power), d: 1n })));
   }
-  if (pieces.length === 0) return chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.RATIONAL_ONE);
+  if (pieces.length === 0) return chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.RATIONAL_ONE);
   let result = pieces[0];
   for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
   return result;
@@ -293,7 +293,7 @@ function contentOf(p) {
     numeratorGcd = gcd(numeratorGcd, coeff.n);
     denominatorLcm = lcm(denominatorLcm, coeff.d);
   }
-  if (numeratorGcd === 0n) return chunkHIQ5HSZL_cjs.RATIONAL_ONE;
+  if (numeratorGcd === 0n) return chunkA2DZ5BEJ_cjs.RATIONAL_ONE;
   return { n: numeratorGcd, d: denominatorLcm };
 }
 function extractCommonMonomial(p) {
@@ -339,48 +339,48 @@ function monomialNode(monomial) {
   let result = null;
   for (const name of names) {
     const exponent = monomial.get(name);
-    const factor = exponent === 1 ? chunkHIQ5HSZL_cjs.varNode(name) : chunkHIQ5HSZL_cjs.powNode(chunkHIQ5HSZL_cjs.varNode(name), chunkHIQ5HSZL_cjs.constNode({ n: BigInt(exponent), d: 1n }));
+    const factor = exponent === 1 ? chunkA2DZ5BEJ_cjs.varNode(name) : chunkA2DZ5BEJ_cjs.powNode(chunkA2DZ5BEJ_cjs.varNode(name), chunkA2DZ5BEJ_cjs.constNode({ n: BigInt(exponent), d: 1n }));
     result = result === null ? factor : { kind: "mul", left: result, right: factor };
   }
   return result;
 }
 function factorSymbolic(node) {
-  const polynomial = chunkHIQ5HSZL_cjs.toPolynomial(node);
+  const polynomial = chunkA2DZ5BEJ_cjs.toPolynomial(node);
   if (polynomial === null || polynomial.terms.size === 0) return node;
-  if (chunkHIQ5HSZL_cjs.polyDegree(polynomial) > FACTOR_MAX_DEGREE) return node;
+  if (chunkA2DZ5BEJ_cjs.polyDegree(polynomial) > FACTOR_MAX_DEGREE) return node;
   if (polynomial.vars.length === 0) return node;
   const content = contentOf(polynomial);
-  const primitive = chunkHIQ5HSZL_cjs.isRationalOne(content) ? polynomial : scaleTerms(polynomial, chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.RATIONAL_ONE, content));
+  const primitive = chunkA2DZ5BEJ_cjs.isRationalOne(content) ? polynomial : scaleTerms(polynomial, chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.RATIONAL_ONE, content));
   const { monomial, reduced } = extractCommonMonomial(primitive);
   const monomialFactor = monomialNode(monomial);
-  const variable = chunkHIQ5HSZL_cjs.polyUnivariateVar(reduced);
+  const variable = chunkA2DZ5BEJ_cjs.polyUnivariateVar(reduced);
   if (variable === null) {
     const patterned = factorMultivariate(reduced);
     if (patterned !== null) return assemble(content, monomialFactor, patterned);
     const pieces2 = buildPieces(content, monomialFactor, reduced);
     return pieces2 ?? node;
   }
-  const descending = [...chunkHIQ5HSZL_cjs.polyCoefficients(reduced, variable)].reverse();
+  const descending = [...chunkA2DZ5BEJ_cjs.polyCoefficients(reduced, variable)].reverse();
   const factorization = factorUnivariate(descending, variable);
-  const combinedContent = chunkHIQ5HSZL_cjs.rationalMul(content, factorization.content);
-  const isUnchanged = factorization.factors.length <= 1 && (factorization.factors[0]?.power ?? 1) === 1 && monomialFactor === null && chunkHIQ5HSZL_cjs.isRationalOne(combinedContent);
+  const combinedContent = chunkA2DZ5BEJ_cjs.rationalMul(content, factorization.content);
+  const isUnchanged = factorization.factors.length <= 1 && (factorization.factors[0]?.power ?? 1) === 1 && monomialFactor === null && chunkA2DZ5BEJ_cjs.isRationalOne(combinedContent);
   if (isUnchanged) return node;
   const pieces = [];
-  if (!chunkHIQ5HSZL_cjs.isRationalOne(combinedContent)) pieces.push(chunkHIQ5HSZL_cjs.constNode(combinedContent));
+  if (!chunkA2DZ5BEJ_cjs.isRationalOne(combinedContent)) pieces.push(chunkA2DZ5BEJ_cjs.constNode(combinedContent));
   if (monomialFactor !== null) pieces.push(monomialFactor);
-  pieces.push(factorizationToNode({ content: chunkHIQ5HSZL_cjs.RATIONAL_ONE, factors: factorization.factors }));
+  pieces.push(factorizationToNode({ content: chunkA2DZ5BEJ_cjs.RATIONAL_ONE, factors: factorization.factors }));
   let result = pieces[0];
   for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
   return result;
 }
 function scaleTerms(p, k) {
   const terms = /* @__PURE__ */ new Map();
-  for (const [key, coeff] of p.terms) terms.set(key, chunkHIQ5HSZL_cjs.rationalMul(coeff, k));
+  for (const [key, coeff] of p.terms) terms.set(key, chunkA2DZ5BEJ_cjs.rationalMul(coeff, k));
   return { terms, vars: p.vars };
 }
 function assemble(content, monomialFactor, factored) {
   const pieces = [];
-  if (!chunkHIQ5HSZL_cjs.isRationalOne(content)) pieces.push(chunkHIQ5HSZL_cjs.constNode(content));
+  if (!chunkA2DZ5BEJ_cjs.isRationalOne(content)) pieces.push(chunkA2DZ5BEJ_cjs.constNode(content));
   if (monomialFactor !== null) pieces.push(monomialFactor);
   pieces.push(factored);
   let result = pieces[0];
@@ -388,11 +388,11 @@ function assemble(content, monomialFactor, factored) {
   return result;
 }
 function buildPieces(content, monomialFactor, reduced) {
-  if (monomialFactor === null && chunkHIQ5HSZL_cjs.isRationalOne(content)) return null;
+  if (monomialFactor === null && chunkA2DZ5BEJ_cjs.isRationalOne(content)) return null;
   const pieces = [];
-  if (!chunkHIQ5HSZL_cjs.isRationalOne(content)) pieces.push(chunkHIQ5HSZL_cjs.constNode(content));
+  if (!chunkA2DZ5BEJ_cjs.isRationalOne(content)) pieces.push(chunkA2DZ5BEJ_cjs.constNode(content));
   if (monomialFactor !== null) pieces.push(monomialFactor);
-  pieces.push(chunkHIQ5HSZL_cjs.fromPolynomial(reduced));
+  pieces.push(chunkA2DZ5BEJ_cjs.fromPolynomial(reduced));
   let result = pieces[0];
   for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
   return result;
@@ -403,103 +403,103 @@ var TWO = { n: 2n, d: 1n };
 var THREE = { n: 3n, d: 1n };
 var FOUR = { n: 4n, d: 1n };
 function depressCubic(a, b, c, d) {
-  const shift = chunkHIQ5HSZL_cjs.rationalNeg(chunkHIQ5HSZL_cjs.rationalDiv(b, chunkHIQ5HSZL_cjs.rationalMul(THREE, a)));
-  const p = chunkHIQ5HSZL_cjs.rationalDiv(
-    chunkHIQ5HSZL_cjs.rationalSub(chunkHIQ5HSZL_cjs.rationalMul(THREE, chunkHIQ5HSZL_cjs.rationalMul(a, c)), chunkHIQ5HSZL_cjs.rationalMul(b, b)),
-    chunkHIQ5HSZL_cjs.rationalMul(THREE, chunkHIQ5HSZL_cjs.rationalMul(a, a))
+  const shift = chunkA2DZ5BEJ_cjs.rationalNeg(chunkA2DZ5BEJ_cjs.rationalDiv(b, chunkA2DZ5BEJ_cjs.rationalMul(THREE, a)));
+  const p = chunkA2DZ5BEJ_cjs.rationalDiv(
+    chunkA2DZ5BEJ_cjs.rationalSub(chunkA2DZ5BEJ_cjs.rationalMul(THREE, chunkA2DZ5BEJ_cjs.rationalMul(a, c)), chunkA2DZ5BEJ_cjs.rationalMul(b, b)),
+    chunkA2DZ5BEJ_cjs.rationalMul(THREE, chunkA2DZ5BEJ_cjs.rationalMul(a, a))
   );
-  const twoBCubed = chunkHIQ5HSZL_cjs.rationalMul(TWO, chunkHIQ5HSZL_cjs.rationalMul(b, chunkHIQ5HSZL_cjs.rationalMul(b, b)));
-  const nineABC = chunkHIQ5HSZL_cjs.rationalMul({ n: 9n, d: 1n }, chunkHIQ5HSZL_cjs.rationalMul(a, chunkHIQ5HSZL_cjs.rationalMul(b, c)));
-  const twentySevenAAD = chunkHIQ5HSZL_cjs.rationalMul({ n: 27n, d: 1n }, chunkHIQ5HSZL_cjs.rationalMul(chunkHIQ5HSZL_cjs.rationalMul(a, a), d));
-  const q = chunkHIQ5HSZL_cjs.rationalDiv(
-    chunkHIQ5HSZL_cjs.rationalAdd(chunkHIQ5HSZL_cjs.rationalSub(twoBCubed, nineABC), twentySevenAAD),
-    chunkHIQ5HSZL_cjs.rationalMul({ n: 27n, d: 1n }, chunkHIQ5HSZL_cjs.rationalMul(a, chunkHIQ5HSZL_cjs.rationalMul(a, a)))
+  const twoBCubed = chunkA2DZ5BEJ_cjs.rationalMul(TWO, chunkA2DZ5BEJ_cjs.rationalMul(b, chunkA2DZ5BEJ_cjs.rationalMul(b, b)));
+  const nineABC = chunkA2DZ5BEJ_cjs.rationalMul({ n: 9n, d: 1n }, chunkA2DZ5BEJ_cjs.rationalMul(a, chunkA2DZ5BEJ_cjs.rationalMul(b, c)));
+  const twentySevenAAD = chunkA2DZ5BEJ_cjs.rationalMul({ n: 27n, d: 1n }, chunkA2DZ5BEJ_cjs.rationalMul(chunkA2DZ5BEJ_cjs.rationalMul(a, a), d));
+  const q = chunkA2DZ5BEJ_cjs.rationalDiv(
+    chunkA2DZ5BEJ_cjs.rationalAdd(chunkA2DZ5BEJ_cjs.rationalSub(twoBCubed, nineABC), twentySevenAAD),
+    chunkA2DZ5BEJ_cjs.rationalMul({ n: 27n, d: 1n }, chunkA2DZ5BEJ_cjs.rationalMul(a, chunkA2DZ5BEJ_cjs.rationalMul(a, a)))
   );
   return { p, q, shift };
 }
 function solveCubic(a, b, c, d) {
   const { p, q, shift } = depressCubic(a, b, c, d);
-  const discriminant = chunkHIQ5HSZL_cjs.rationalNeg(
-    chunkHIQ5HSZL_cjs.rationalAdd(
-      chunkHIQ5HSZL_cjs.rationalMul(FOUR, chunkHIQ5HSZL_cjs.rationalMul(p, chunkHIQ5HSZL_cjs.rationalMul(p, p))),
-      chunkHIQ5HSZL_cjs.rationalMul({ n: 27n, d: 1n }, chunkHIQ5HSZL_cjs.rationalMul(q, q))
+  const discriminant = chunkA2DZ5BEJ_cjs.rationalNeg(
+    chunkA2DZ5BEJ_cjs.rationalAdd(
+      chunkA2DZ5BEJ_cjs.rationalMul(FOUR, chunkA2DZ5BEJ_cjs.rationalMul(p, chunkA2DZ5BEJ_cjs.rationalMul(p, p))),
+      chunkA2DZ5BEJ_cjs.rationalMul({ n: 27n, d: 1n }, chunkA2DZ5BEJ_cjs.rationalMul(q, q))
     )
   );
-  if (chunkHIQ5HSZL_cjs.rationalCompare(discriminant, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) > 0) {
+  if (chunkA2DZ5BEJ_cjs.rationalCompare(discriminant, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) > 0) {
     return { exact: [], approximate: trigonometricRoots(p, q, shift) };
   }
-  if (chunkHIQ5HSZL_cjs.isRationalZero(discriminant)) return { exact: repeatedCubicRoots(p, q, shift), approximate: [] };
+  if (chunkA2DZ5BEJ_cjs.isRationalZero(discriminant)) return { exact: repeatedCubicRoots(p, q, shift), approximate: [] };
   return { exact: cardanoRoots(p, q, shift), approximate: [] };
 }
 function repeatedCubicRoots(p, q, shift) {
-  if (chunkHIQ5HSZL_cjs.isRationalZero(p)) return [chunkHIQ5HSZL_cjs.constNode(shift)];
-  const simple = chunkHIQ5HSZL_cjs.rationalAdd(chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(THREE, q), p), shift);
-  const repeated = chunkHIQ5HSZL_cjs.rationalAdd(chunkHIQ5HSZL_cjs.rationalNeg(chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(THREE, q), chunkHIQ5HSZL_cjs.rationalMul(TWO, p))), shift);
-  const ordered = [simple, repeated].sort(chunkHIQ5HSZL_cjs.rationalCompare);
-  return ordered.map(chunkHIQ5HSZL_cjs.constNode);
+  if (chunkA2DZ5BEJ_cjs.isRationalZero(p)) return [chunkA2DZ5BEJ_cjs.constNode(shift)];
+  const simple = chunkA2DZ5BEJ_cjs.rationalAdd(chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(THREE, q), p), shift);
+  const repeated = chunkA2DZ5BEJ_cjs.rationalAdd(chunkA2DZ5BEJ_cjs.rationalNeg(chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(THREE, q), chunkA2DZ5BEJ_cjs.rationalMul(TWO, p))), shift);
+  const ordered = [simple, repeated].sort(chunkA2DZ5BEJ_cjs.rationalCompare);
+  return ordered.map(chunkA2DZ5BEJ_cjs.constNode);
 }
 function cardanoRoots(p, q, shift) {
-  const half = chunkHIQ5HSZL_cjs.rationalNeg(chunkHIQ5HSZL_cjs.rationalDiv(q, TWO));
-  const radicand = chunkHIQ5HSZL_cjs.rationalAdd(
-    chunkHIQ5HSZL_cjs.rationalMul(chunkHIQ5HSZL_cjs.rationalDiv(q, TWO), chunkHIQ5HSZL_cjs.rationalDiv(q, TWO)),
-    chunkHIQ5HSZL_cjs.rationalMul(chunkHIQ5HSZL_cjs.rationalDiv(p, THREE), chunkHIQ5HSZL_cjs.rationalMul(chunkHIQ5HSZL_cjs.rationalDiv(p, THREE), chunkHIQ5HSZL_cjs.rationalDiv(p, THREE)))
+  const half = chunkA2DZ5BEJ_cjs.rationalNeg(chunkA2DZ5BEJ_cjs.rationalDiv(q, TWO));
+  const radicand = chunkA2DZ5BEJ_cjs.rationalAdd(
+    chunkA2DZ5BEJ_cjs.rationalMul(chunkA2DZ5BEJ_cjs.rationalDiv(q, TWO), chunkA2DZ5BEJ_cjs.rationalDiv(q, TWO)),
+    chunkA2DZ5BEJ_cjs.rationalMul(chunkA2DZ5BEJ_cjs.rationalDiv(p, THREE), chunkA2DZ5BEJ_cjs.rationalMul(chunkA2DZ5BEJ_cjs.rationalDiv(p, THREE), chunkA2DZ5BEJ_cjs.rationalDiv(p, THREE)))
   );
-  const inner = chunkHIQ5HSZL_cjs.surdNode(radicand);
-  const u = { kind: "call", name: "cbrt", args: [{ kind: "add", left: chunkHIQ5HSZL_cjs.constNode(half), right: inner }] };
-  const v = { kind: "call", name: "cbrt", args: [{ kind: "sub", left: chunkHIQ5HSZL_cjs.constNode(half), right: inner }] };
+  const inner = chunkA2DZ5BEJ_cjs.surdNode(radicand);
+  const u = { kind: "call", name: "cbrt", args: [{ kind: "add", left: chunkA2DZ5BEJ_cjs.constNode(half), right: inner }] };
+  const v = { kind: "call", name: "cbrt", args: [{ kind: "sub", left: chunkA2DZ5BEJ_cjs.constNode(half), right: inner }] };
   const sum = { kind: "add", left: u, right: v };
   const difference = { kind: "sub", left: u, right: v };
-  const real = { kind: "add", left: chunkHIQ5HSZL_cjs.constNode(shift), right: { kind: "div", left: { kind: "neg", operand: sum }, right: chunkHIQ5HSZL_cjs.constNode(TWO) } };
+  const real = { kind: "add", left: chunkA2DZ5BEJ_cjs.constNode(shift), right: { kind: "div", left: { kind: "neg", operand: sum }, right: chunkA2DZ5BEJ_cjs.constNode(TWO) } };
   const imaginary = {
     kind: "mul",
-    left: { kind: "div", left: { kind: "mul", left: difference, right: chunkHIQ5HSZL_cjs.surdNode(THREE) }, right: chunkHIQ5HSZL_cjs.constNode(TWO) },
-    right: chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.COMPLEX_I)
+    left: { kind: "div", left: { kind: "mul", left: difference, right: chunkA2DZ5BEJ_cjs.surdNode(THREE) }, right: chunkA2DZ5BEJ_cjs.constNode(TWO) },
+    right: chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.COMPLEX_I)
   };
   return [
-    { kind: "add", left: chunkHIQ5HSZL_cjs.constNode(shift), right: sum },
+    { kind: "add", left: chunkA2DZ5BEJ_cjs.constNode(shift), right: sum },
     { kind: "sub", left: real, right: imaginary },
     { kind: "add", left: real, right: imaginary }
   ];
 }
 function trigonometricRoots(p, q, shift) {
-  const pNumber = chunkHIQ5HSZL_cjs.rationalToNumber(p);
-  const qNumber = chunkHIQ5HSZL_cjs.rationalToNumber(q);
-  const shiftNumber = chunkHIQ5HSZL_cjs.rationalToNumber(shift);
+  const pNumber = chunkA2DZ5BEJ_cjs.rationalToNumber(p);
+  const qNumber = chunkA2DZ5BEJ_cjs.rationalToNumber(q);
+  const shiftNumber = chunkA2DZ5BEJ_cjs.rationalToNumber(shift);
   const magnitude2 = 2 * Math.sqrt(-pNumber / 3);
   const ratio = 3 * qNumber / (2 * pNumber) * Math.sqrt(-3 / pNumber);
   const angle = Math.acos(Math.min(1, Math.max(-1, ratio))) / 3;
   return [0, 1, 2].map((k) => magnitude2 * Math.cos(angle - 2 * Math.PI * k / 3) + shiftNumber).sort((left, right) => left - right);
 }
 function depressQuartic(b, c, d, e) {
-  const shift = chunkHIQ5HSZL_cjs.rationalNeg(chunkHIQ5HSZL_cjs.rationalDiv(b, FOUR));
-  const bb = chunkHIQ5HSZL_cjs.rationalMul(b, b);
-  const p = chunkHIQ5HSZL_cjs.rationalSub(c, chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(THREE, bb), { n: 8n, d: 1n }));
-  const q = chunkHIQ5HSZL_cjs.rationalAdd(
-    chunkHIQ5HSZL_cjs.rationalSub(d, chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(b, c), TWO)),
-    chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(bb, b), { n: 8n, d: 1n })
+  const shift = chunkA2DZ5BEJ_cjs.rationalNeg(chunkA2DZ5BEJ_cjs.rationalDiv(b, FOUR));
+  const bb = chunkA2DZ5BEJ_cjs.rationalMul(b, b);
+  const p = chunkA2DZ5BEJ_cjs.rationalSub(c, chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(THREE, bb), { n: 8n, d: 1n }));
+  const q = chunkA2DZ5BEJ_cjs.rationalAdd(
+    chunkA2DZ5BEJ_cjs.rationalSub(d, chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(b, c), TWO)),
+    chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(bb, b), { n: 8n, d: 1n })
   );
-  const r = chunkHIQ5HSZL_cjs.rationalSub(
-    chunkHIQ5HSZL_cjs.rationalAdd(
-      chunkHIQ5HSZL_cjs.rationalSub(e, chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(b, d), FOUR)),
-      chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(bb, c), { n: 16n, d: 1n })
+  const r = chunkA2DZ5BEJ_cjs.rationalSub(
+    chunkA2DZ5BEJ_cjs.rationalAdd(
+      chunkA2DZ5BEJ_cjs.rationalSub(e, chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(b, d), FOUR)),
+      chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(bb, c), { n: 16n, d: 1n })
     ),
-    chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalMul(THREE, chunkHIQ5HSZL_cjs.rationalMul(bb, bb)), { n: 256n, d: 1n })
+    chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalMul(THREE, chunkA2DZ5BEJ_cjs.rationalMul(bb, bb)), { n: 256n, d: 1n })
   );
   return { p, q, r, shift };
 }
 function solveQuartic(a, b, c, d, e, solveQuadratic2) {
-  const monic = (value) => chunkHIQ5HSZL_cjs.rationalDiv(value, a);
+  const monic = (value) => chunkA2DZ5BEJ_cjs.rationalDiv(value, a);
   const { p, q, r, shift } = depressQuartic(monic(b), monic(c), monic(d), monic(e));
-  const roots = chunkHIQ5HSZL_cjs.isRationalZero(q) ? biquadraticRoots(p, r) : splitQuarticRoots(p, q, r, solveQuadratic2);
+  const roots = chunkA2DZ5BEJ_cjs.isRationalZero(q) ? biquadraticRoots(p, r) : splitQuarticRoots(p, q, r, solveQuadratic2);
   if (roots === null) return null;
-  const shifted = chunkHIQ5HSZL_cjs.isRationalZero(shift) ? roots : roots.map((root) => ({ kind: "add", left: chunkHIQ5HSZL_cjs.constNode(shift), right: root }));
+  const shifted = chunkA2DZ5BEJ_cjs.isRationalZero(shift) ? roots : roots.map((root) => ({ kind: "add", left: chunkA2DZ5BEJ_cjs.constNode(shift), right: root }));
   return { exact: distinct(shifted), approximate: [] };
 }
 function distinct(roots) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
   for (const root of roots) {
-    const key = chunkHIQ5HSZL_cjs.symbolicKey(chunkHIQ5HSZL_cjs.simplifySymbolic(root));
+    const key = chunkA2DZ5BEJ_cjs.symbolicKey(chunkA2DZ5BEJ_cjs.simplifySymbolic(root));
     if (seen.has(key)) continue;
     seen.add(key);
     unique.push(root);
@@ -507,51 +507,51 @@ function distinct(roots) {
   return unique;
 }
 function biquadraticRoots(p, r) {
-  const discriminant = chunkHIQ5HSZL_cjs.rationalSub(chunkHIQ5HSZL_cjs.rationalMul(p, p), chunkHIQ5HSZL_cjs.rationalMul(FOUR, r));
-  if (chunkHIQ5HSZL_cjs.rationalCompare(discriminant, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) < 0) return complexBiquadraticRoots(p, r);
-  const root = chunkHIQ5HSZL_cjs.exactRationalSqrt(discriminant);
-  if (root !== null) return rationalSquareRoots(chunkHIQ5HSZL_cjs.rationalNeg(p), root, chunkHIQ5HSZL_cjs.isRationalZero(discriminant));
+  const discriminant = chunkA2DZ5BEJ_cjs.rationalSub(chunkA2DZ5BEJ_cjs.rationalMul(p, p), chunkA2DZ5BEJ_cjs.rationalMul(FOUR, r));
+  if (chunkA2DZ5BEJ_cjs.rationalCompare(discriminant, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) < 0) return complexBiquadraticRoots(p, r);
+  const root = chunkA2DZ5BEJ_cjs.exactRationalSqrt(discriminant);
+  if (root !== null) return rationalSquareRoots(chunkA2DZ5BEJ_cjs.rationalNeg(p), root, chunkA2DZ5BEJ_cjs.isRationalZero(discriminant));
   return nestedSquareRoots(p, r, discriminant);
 }
 function rationalSquareRoots(negatedP, root, repeated) {
-  const values = repeated ? [chunkHIQ5HSZL_cjs.rationalDiv(negatedP, TWO)] : [chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalAdd(negatedP, root), TWO), chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalSub(negatedP, root), TWO)];
+  const values = repeated ? [chunkA2DZ5BEJ_cjs.rationalDiv(negatedP, TWO)] : [chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalAdd(negatedP, root), TWO), chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalSub(negatedP, root), TWO)];
   const roots = [];
   for (const value of values) {
-    if (chunkHIQ5HSZL_cjs.isRationalZero(value)) {
-      roots.push(chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.RATIONAL_ZERO));
+    if (chunkA2DZ5BEJ_cjs.isRationalZero(value)) {
+      roots.push(chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO));
       continue;
     }
-    const square = chunkHIQ5HSZL_cjs.signedSurdNode(value);
+    const square = chunkA2DZ5BEJ_cjs.signedSurdNode(value);
     roots.push({ kind: "neg", operand: square }, square);
   }
   return roots;
 }
 function nestedSquareRoots(p, r, discriminant) {
-  const negatedP = chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalNeg(p));
-  const surd = chunkHIQ5HSZL_cjs.surdNode(discriminant);
-  const negativeP = chunkHIQ5HSZL_cjs.rationalCompare(p, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) <= 0;
+  const negatedP = chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalNeg(p));
+  const surd = chunkA2DZ5BEJ_cjs.surdNode(discriminant);
+  const negativeP = chunkA2DZ5BEJ_cjs.rationalCompare(p, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) <= 0;
   const solutions = [
-    { node: halved({ kind: "add", left: negatedP, right: surd }), positive: negativeP || chunkHIQ5HSZL_cjs.rationalCompare(r, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) <= 0 },
-    { node: halved({ kind: "sub", left: negatedP, right: surd }), positive: negativeP && chunkHIQ5HSZL_cjs.rationalCompare(r, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) >= 0 }
+    { node: halved({ kind: "add", left: negatedP, right: surd }), positive: negativeP || chunkA2DZ5BEJ_cjs.rationalCompare(r, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) <= 0 },
+    { node: halved({ kind: "sub", left: negatedP, right: surd }), positive: negativeP && chunkA2DZ5BEJ_cjs.rationalCompare(r, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) >= 0 }
   ];
   const roots = [];
   for (const { node, positive } of solutions) {
     const radicand = positive ? node : { kind: "neg", operand: node };
     const magnitude2 = { kind: "call", name: "sqrt", args: [radicand] };
-    const square = positive ? magnitude2 : { kind: "mul", left: magnitude2, right: chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.COMPLEX_I) };
+    const square = positive ? magnitude2 : { kind: "mul", left: magnitude2, right: chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.COMPLEX_I) };
     roots.push({ kind: "neg", operand: square }, square);
   }
   return roots;
 }
 function halved(node) {
-  return { kind: "div", left: node, right: chunkHIQ5HSZL_cjs.constNode(TWO) };
+  return { kind: "div", left: node, right: chunkA2DZ5BEJ_cjs.constNode(TWO) };
 }
 function complexBiquadraticRoots(p, r) {
-  const centre = chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalNeg(p), TWO);
-  const modulus = chunkHIQ5HSZL_cjs.exactRationalSqrt(r);
-  const re = modulus === null ? nestedSurd(chunkHIQ5HSZL_cjs.surdNode(r), centre) : chunkHIQ5HSZL_cjs.surdNode(chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalAdd(modulus, centre), TWO));
-  const imaginaryMagnitude = modulus === null ? nestedSurd(chunkHIQ5HSZL_cjs.surdNode(r), chunkHIQ5HSZL_cjs.rationalNeg(centre)) : chunkHIQ5HSZL_cjs.surdNode(chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalSub(modulus, centre), TWO));
-  const im = { kind: "mul", left: imaginaryMagnitude, right: chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.COMPLEX_I) };
+  const centre = chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalNeg(p), TWO);
+  const modulus = chunkA2DZ5BEJ_cjs.exactRationalSqrt(r);
+  const re = modulus === null ? nestedSurd(chunkA2DZ5BEJ_cjs.surdNode(r), centre) : chunkA2DZ5BEJ_cjs.surdNode(chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalAdd(modulus, centre), TWO));
+  const imaginaryMagnitude = modulus === null ? nestedSurd(chunkA2DZ5BEJ_cjs.surdNode(r), chunkA2DZ5BEJ_cjs.rationalNeg(centre)) : chunkA2DZ5BEJ_cjs.surdNode(chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalSub(modulus, centre), TWO));
+  const im = { kind: "mul", left: imaginaryMagnitude, right: chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.COMPLEX_I) };
   const first = { kind: "add", left: re, right: im };
   const second = { kind: "sub", left: re, right: im };
   return [
@@ -562,28 +562,28 @@ function complexBiquadraticRoots(p, r) {
   ];
 }
 function nestedSurd(surd, offset) {
-  const shifted = offset.n >= 0n ? { kind: "add", left: surd, right: chunkHIQ5HSZL_cjs.constNode(offset) } : { kind: "sub", left: surd, right: chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalNeg(offset)) };
+  const shifted = offset.n >= 0n ? { kind: "add", left: surd, right: chunkA2DZ5BEJ_cjs.constNode(offset) } : { kind: "sub", left: surd, right: chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalNeg(offset)) };
   return { kind: "call", name: "sqrt", args: [halved(shifted)] };
 }
 function splitQuarticRoots(p, q, r, solveQuadratic2) {
   const resolvent = [
     { n: 1n, d: 1n },
-    chunkHIQ5HSZL_cjs.rationalMul(TWO, p),
-    chunkHIQ5HSZL_cjs.rationalSub(chunkHIQ5HSZL_cjs.rationalMul(p, p), chunkHIQ5HSZL_cjs.rationalMul(FOUR, r)),
-    chunkHIQ5HSZL_cjs.rationalNeg(chunkHIQ5HSZL_cjs.rationalMul(q, q))
+    chunkA2DZ5BEJ_cjs.rationalMul(TWO, p),
+    chunkA2DZ5BEJ_cjs.rationalSub(chunkA2DZ5BEJ_cjs.rationalMul(p, p), chunkA2DZ5BEJ_cjs.rationalMul(FOUR, r)),
+    chunkA2DZ5BEJ_cjs.rationalNeg(chunkA2DZ5BEJ_cjs.rationalMul(q, q))
   ];
   for (const z of rationalRoots(resolvent)) {
-    if (chunkHIQ5HSZL_cjs.rationalCompare(z, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) <= 0) continue;
-    const alpha = chunkHIQ5HSZL_cjs.exactRationalSqrt(z);
+    if (chunkA2DZ5BEJ_cjs.rationalCompare(z, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) <= 0) continue;
+    const alpha = chunkA2DZ5BEJ_cjs.exactRationalSqrt(z);
     if (alpha === null) continue;
-    const sum = chunkHIQ5HSZL_cjs.rationalAdd(p, z);
-    const difference = chunkHIQ5HSZL_cjs.rationalDiv(q, alpha);
-    const beta = chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalSub(sum, difference), TWO);
-    const gamma = chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalAdd(sum, difference), TWO);
+    const sum = chunkA2DZ5BEJ_cjs.rationalAdd(p, z);
+    const difference = chunkA2DZ5BEJ_cjs.rationalDiv(q, alpha);
+    const beta = chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalSub(sum, difference), TWO);
+    const gamma = chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalAdd(sum, difference), TWO);
     const one2 = { n: 1n, d: 1n };
     return [
       ...solveQuadratic2(one2, alpha, beta),
-      ...solveQuadratic2(one2, chunkHIQ5HSZL_cjs.rationalNeg(alpha), gamma)
+      ...solveQuadratic2(one2, chunkA2DZ5BEJ_cjs.rationalNeg(alpha), gamma)
     ];
   }
   return null;
@@ -640,8 +640,8 @@ function differentiate(descending) {
 }
 function squareFreeDoubles(descending) {
   const ascending = [...descending].reverse();
-  const squareFree = [...chunkHIQ5HSZL_cjs.squareFreePart(ascending)].reverse();
-  const doubles = squareFree.map(chunkHIQ5HSZL_cjs.rationalToNumber);
+  const squareFree = [...chunkA2DZ5BEJ_cjs.squareFreePart(ascending)].reverse();
+  const doubles = squareFree.map(chunkA2DZ5BEJ_cjs.rationalToNumber);
   if (doubles.some((value) => !Number.isFinite(value))) return null;
   return doubles;
 }
@@ -764,59 +764,59 @@ function approximateRoots(descending) {
 // src/symbolic/Solve.ts
 var SOLVE_MAX_DEGREE = 8;
 function evaluateRational(descending, x) {
-  let total = chunkHIQ5HSZL_cjs.RATIONAL_ZERO;
-  for (const coeff of descending) total = chunkHIQ5HSZL_cjs.rationalAdd(chunkHIQ5HSZL_cjs.rationalMul(total, x), coeff);
+  let total = chunkA2DZ5BEJ_cjs.RATIONAL_ZERO;
+  for (const coeff of descending) total = chunkA2DZ5BEJ_cjs.rationalAdd(chunkA2DZ5BEJ_cjs.rationalMul(total, x), coeff);
   return total;
 }
 function divideByRoot2(descending, root) {
   const quotient = [descending[0]];
   for (let i = 1; i < descending.length - 1; i++) {
-    quotient.push(chunkHIQ5HSZL_cjs.rationalAdd(descending[i], chunkHIQ5HSZL_cjs.rationalMul(quotient[i - 1], root)));
+    quotient.push(chunkA2DZ5BEJ_cjs.rationalAdd(descending[i], chunkA2DZ5BEJ_cjs.rationalMul(quotient[i - 1], root)));
   }
   return quotient;
 }
 function solveQuadratic(a, b, c) {
-  const discriminant = chunkHIQ5HSZL_cjs.rationalSub(chunkHIQ5HSZL_cjs.rationalMul(b, b), chunkHIQ5HSZL_cjs.rationalMul(rational4(), chunkHIQ5HSZL_cjs.rationalMul(a, c)));
-  const twoA = chunkHIQ5HSZL_cjs.rationalMul(rational2(), a);
-  if (chunkHIQ5HSZL_cjs.rationalCompare(discriminant, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) < 0) {
-    return complexQuadraticRoots(chunkHIQ5HSZL_cjs.rationalNeg(b), discriminant, twoA);
-  }
-  if (chunkHIQ5HSZL_cjs.isRationalZero(discriminant)) return [chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalNeg(b), twoA))];
-  const rootN = chunkHIQ5HSZL_cjs.exactIntegerSqrt(discriminant.n);
-  const rootD = chunkHIQ5HSZL_cjs.exactIntegerSqrt(discriminant.d);
+  const discriminant = chunkA2DZ5BEJ_cjs.rationalSub(chunkA2DZ5BEJ_cjs.rationalMul(b, b), chunkA2DZ5BEJ_cjs.rationalMul(rational4(), chunkA2DZ5BEJ_cjs.rationalMul(a, c)));
+  const twoA = chunkA2DZ5BEJ_cjs.rationalMul(rational2(), a);
+  if (chunkA2DZ5BEJ_cjs.rationalCompare(discriminant, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) < 0) {
+    return complexQuadraticRoots(chunkA2DZ5BEJ_cjs.rationalNeg(b), discriminant, twoA);
+  }
+  if (chunkA2DZ5BEJ_cjs.isRationalZero(discriminant)) return [chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalNeg(b), twoA))];
+  const rootN = chunkA2DZ5BEJ_cjs.exactIntegerSqrt(discriminant.n);
+  const rootD = chunkA2DZ5BEJ_cjs.exactIntegerSqrt(discriminant.d);
   if (rootN !== null && rootD !== null) {
     const root = { n: rootN, d: rootD };
-    const plus = chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalAdd(chunkHIQ5HSZL_cjs.rationalNeg(b), root), twoA);
-    const minus = chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalSub(chunkHIQ5HSZL_cjs.rationalNeg(b), root), twoA);
-    return chunkHIQ5HSZL_cjs.rationalCompare(minus, plus) <= 0 ? [chunkHIQ5HSZL_cjs.constNode(minus), chunkHIQ5HSZL_cjs.constNode(plus)] : [chunkHIQ5HSZL_cjs.constNode(plus), chunkHIQ5HSZL_cjs.constNode(minus)];
-  }
-  const surd = chunkHIQ5HSZL_cjs.surdNode(discriminant);
-  const ascending = chunkHIQ5HSZL_cjs.rationalCompare(twoA, chunkHIQ5HSZL_cjs.RATIONAL_ZERO) > 0;
-  const lower = { kind: "div", left: { kind: "sub", left: chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalNeg(b)), right: surd }, right: chunkHIQ5HSZL_cjs.constNode(twoA) };
-  const upper = { kind: "div", left: { kind: "add", left: chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalNeg(b)), right: surd }, right: chunkHIQ5HSZL_cjs.constNode(twoA) };
+    const plus = chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalAdd(chunkA2DZ5BEJ_cjs.rationalNeg(b), root), twoA);
+    const minus = chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalSub(chunkA2DZ5BEJ_cjs.rationalNeg(b), root), twoA);
+    return chunkA2DZ5BEJ_cjs.rationalCompare(minus, plus) <= 0 ? [chunkA2DZ5BEJ_cjs.constNode(minus), chunkA2DZ5BEJ_cjs.constNode(plus)] : [chunkA2DZ5BEJ_cjs.constNode(plus), chunkA2DZ5BEJ_cjs.constNode(minus)];
+  }
+  const surd = chunkA2DZ5BEJ_cjs.surdNode(discriminant);
+  const ascending = chunkA2DZ5BEJ_cjs.rationalCompare(twoA, chunkA2DZ5BEJ_cjs.RATIONAL_ZERO) > 0;
+  const lower = { kind: "div", left: { kind: "sub", left: chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalNeg(b)), right: surd }, right: chunkA2DZ5BEJ_cjs.constNode(twoA) };
+  const upper = { kind: "div", left: { kind: "add", left: chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalNeg(b)), right: surd }, right: chunkA2DZ5BEJ_cjs.constNode(twoA) };
   return ascending ? [lower, upper] : [upper, lower];
 }
 function complexQuadraticRoots(negatedB, discriminant, twoA) {
-  const magnitude2 = chunkHIQ5HSZL_cjs.rationalNeg(discriminant);
-  const rootN = chunkHIQ5HSZL_cjs.exactIntegerSqrt(magnitude2.n);
-  const rootD = chunkHIQ5HSZL_cjs.exactIntegerSqrt(magnitude2.d);
+  const magnitude2 = chunkA2DZ5BEJ_cjs.rationalNeg(discriminant);
+  const rootN = chunkA2DZ5BEJ_cjs.exactIntegerSqrt(magnitude2.n);
+  const rootD = chunkA2DZ5BEJ_cjs.exactIntegerSqrt(magnitude2.d);
   if (rootN !== null && rootD !== null) {
-    const imaginary2 = chunkHIQ5HSZL_cjs.rationalDiv({ n: rootN, d: rootD }, twoA);
-    const real2 = chunkHIQ5HSZL_cjs.rationalDiv(negatedB, twoA);
+    const imaginary2 = chunkA2DZ5BEJ_cjs.rationalDiv({ n: rootN, d: rootD }, twoA);
+    const real2 = chunkA2DZ5BEJ_cjs.rationalDiv(negatedB, twoA);
     return [
-      chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.complex(real2, chunkHIQ5HSZL_cjs.rationalNeg(imaginary2))),
-      chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.complex(real2, imaginary2))
+      chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.complex(real2, chunkA2DZ5BEJ_cjs.rationalNeg(imaginary2))),
+      chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.complex(real2, imaginary2))
     ];
   }
-  const real = chunkHIQ5HSZL_cjs.rationalDiv(negatedB, twoA);
-  const scaledRadicand = chunkHIQ5HSZL_cjs.rationalDiv(magnitude2, chunkHIQ5HSZL_cjs.rationalMul(twoA, twoA));
-  const imaginary = { kind: "mul", left: chunkHIQ5HSZL_cjs.surdNode(scaledRadicand), right: chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.COMPLEX_I) };
-  if (chunkHIQ5HSZL_cjs.isRationalZero(real)) {
+  const real = chunkA2DZ5BEJ_cjs.rationalDiv(negatedB, twoA);
+  const scaledRadicand = chunkA2DZ5BEJ_cjs.rationalDiv(magnitude2, chunkA2DZ5BEJ_cjs.rationalMul(twoA, twoA));
+  const imaginary = { kind: "mul", left: chunkA2DZ5BEJ_cjs.surdNode(scaledRadicand), right: chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.COMPLEX_I) };
+  if (chunkA2DZ5BEJ_cjs.isRationalZero(real)) {
     return [{ kind: "neg", operand: imaginary }, imaginary];
   }
   return [
-    { kind: "sub", left: chunkHIQ5HSZL_cjs.constNode(real), right: imaginary },
-    { kind: "add", left: chunkHIQ5HSZL_cjs.constNode(real), right: imaginary }
+    { kind: "sub", left: chunkA2DZ5BEJ_cjs.constNode(real), right: imaginary },
+    { kind: "add", left: chunkA2DZ5BEJ_cjs.constNode(real), right: imaginary }
   ];
 }
 function rational2() {
@@ -829,7 +829,7 @@ function realApproximation(value) {
   return { re: value, im: 0 };
 }
 function solveForVariable(lhs, rhs, variable) {
-  const polynomial = chunkHIQ5HSZL_cjs.toPolynomial({ kind: "sub", left: lhs, right: rhs });
+  const polynomial = chunkA2DZ5BEJ_cjs.toPolynomial({ kind: "sub", left: lhs, right: rhs });
   if (polynomial === null) {
     return {
       kind: "unsupported",
@@ -837,7 +837,7 @@ function solveForVariable(lhs, rhs, variable) {
     };
   }
   const others = polynomial.vars.filter((name) => name !== variable);
-  const degree = chunkHIQ5HSZL_cjs.polyDegree(polynomial, variable);
+  const degree = chunkA2DZ5BEJ_cjs.polyDegree(polynomial, variable);
   if (others.length > 0) {
     if (degree !== 1) {
       return {
@@ -853,7 +853,7 @@ function solveForVariable(lhs, rhs, variable) {
   if (degree > SOLVE_MAX_DEGREE) {
     return { kind: "unsupported", reason: `degree ${degree} is above the supported maximum of ${SOLVE_MAX_DEGREE}` };
   }
-  const descending = [...chunkHIQ5HSZL_cjs.polyCoefficients(polynomial, variable)].reverse();
+  const descending = [...chunkA2DZ5BEJ_cjs.polyCoefficients(polynomial, variable)].reverse();
   return solveUnivariate(descending);
 }
 function solveLinearWithOtherUnknowns(polynomial, variable) {
@@ -878,8 +878,8 @@ function solveLinearWithOtherUnknowns(polynomial, variable) {
     }
     return [...names].sort();
   };
-  const coefficient = chunkHIQ5HSZL_cjs.fromPolynomial({ terms: coefficientTerms, vars: namesOf2(coefficientTerms) });
-  const constant = chunkHIQ5HSZL_cjs.fromPolynomial({ terms: constantTerms, vars: namesOf2(constantTerms) });
+  const coefficient = chunkA2DZ5BEJ_cjs.fromPolynomial({ terms: coefficientTerms, vars: namesOf2(coefficientTerms) });
+  const constant = chunkA2DZ5BEJ_cjs.fromPolynomial({ terms: constantTerms, vars: namesOf2(constantTerms) });
   return {
     kind: "roots",
     exact: [{ kind: "div", left: { kind: "neg", operand: constant }, right: coefficient }],
@@ -899,34 +899,34 @@ function extractRationalRoots(descending) {
   const roots = [];
   let remaining = [...descending];
   let powersOfX = 0;
-  while (remaining.length > 1 && chunkHIQ5HSZL_cjs.isRationalZero(remaining[remaining.length - 1])) {
+  while (remaining.length > 1 && chunkA2DZ5BEJ_cjs.isRationalZero(remaining[remaining.length - 1])) {
     remaining = remaining.slice(0, -1);
     powersOfX++;
   }
-  if (powersOfX > 0) roots.push(chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
+  if (powersOfX > 0) roots.push(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
   while (remaining.length > 1) {
     const found = rationalRoots(remaining);
     if (found.length === 0) break;
     for (const root of found) {
       let multiplicity = 0;
-      while (remaining.length > 1 && chunkHIQ5HSZL_cjs.isRationalZero(evaluateRational(remaining, root))) {
+      while (remaining.length > 1 && chunkA2DZ5BEJ_cjs.isRationalZero(evaluateRational(remaining, root))) {
         remaining = divideByRoot2(remaining, root);
         multiplicity++;
       }
       if (multiplicity > 0) roots.push(root);
     }
   }
-  return { roots: roots.sort(chunkHIQ5HSZL_cjs.rationalCompare), remaining };
+  return { roots: roots.sort(chunkA2DZ5BEJ_cjs.rationalCompare), remaining };
 }
 function solveUnivariate(descending) {
   const { roots, remaining } = extractRationalRoots(descending);
-  const exact = roots.map(chunkHIQ5HSZL_cjs.constNode);
+  const exact = roots.map(chunkA2DZ5BEJ_cjs.constNode);
   const approximate = [];
   const leftoverDegree = remaining.length - 1;
   const solvedDegree = descending.length - remaining.length;
   if (leftoverDegree <= 0) return finish(exact, approximate, solvedDegree, 0, "");
   if (leftoverDegree === 1) {
-    exact.push(chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalDiv(chunkHIQ5HSZL_cjs.rationalNeg(remaining[1]), remaining[0])));
+    exact.push(chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalDiv(chunkA2DZ5BEJ_cjs.rationalNeg(remaining[1]), remaining[0])));
     return finish(exact, approximate, solvedDegree + 1, 0, "");
   }
   if (leftoverDegree === 2) {
@@ -1014,15 +1014,15 @@ function valueToSymbolic(v) {
   if (v.type === 13 /* Error */ || v.type === 12 /* Pending */) return null;
   const numeric = v.toNumber();
   if (!Number.isFinite(numeric)) return null;
-  return chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalFromNumber(numeric));
+  return chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalFromNumber(numeric));
 }
 function symbolicToValue(node) {
-  const simplified = chunkHIQ5HSZL_cjs.simplifySymbolic(node);
-  if (simplified.kind === "const") return chunk2TZKENDH_cjs.numberValue(chunkHIQ5HSZL_cjs.rationalToNumber(simplified.value));
-  return chunk2TZKENDH_cjs.symbolicValue(simplified);
+  const simplified = chunkA2DZ5BEJ_cjs.simplifySymbolic(node);
+  if (simplified.kind === "const") return chunkIT74O4BE_cjs.numberValue(chunkA2DZ5BEJ_cjs.rationalToNumber(simplified.value));
+  return chunkIT74O4BE_cjs.symbolicValue(simplified);
 }
 function unsupported(what) {
-  return chunk2TZKENDH_cjs.errorValue(
+  return chunkIT74O4BE_cjs.errorValue(
     "SYMBOLIC_UNSUPPORTED_FUNCTION",
     `"${what}" cannot be applied to an expression that still contains an unknown.`
   );
@@ -1031,7 +1031,7 @@ function symbolicPow(l, r) {
   const base = valueToSymbolic(l);
   const exponent = valueToSymbolic(r);
   if (base === null || exponent === null) return unsupported("^");
-  return symbolicToValue(chunkHIQ5HSZL_cjs.powNode(base, exponent));
+  return symbolicToValue(chunkA2DZ5BEJ_cjs.powNode(base, exponent));
 }
 function symbolicNeg(v) {
   const operand = valueToSymbolic(v);
@@ -1041,39 +1041,39 @@ function symbolicNeg(v) {
 function symbolicBuiltin(index, args) {
   const nodes = [];
   for (const arg of args) {
-    const faulted = chunk2TZKENDH_cjs.faultedOperand(arg);
+    const faulted = chunkIT74O4BE_cjs.faultedOperand(arg);
     if (faulted) return faulted;
     const node = valueToSymbolic(arg);
     if (node === null) return unsupported(SYMBOLIC_BUILTIN_NAMES[index] ?? `builtin ${index}`);
     nodes.push(node);
   }
   if (index === POW_BUILTIN_INDEX && nodes.length === 2) {
-    return symbolicToValue(chunkHIQ5HSZL_cjs.powNode(nodes[0], nodes[1]));
+    return symbolicToValue(chunkA2DZ5BEJ_cjs.powNode(nodes[0], nodes[1]));
   }
   const name = SYMBOLIC_BUILTIN_NAMES[index];
   if (name === void 0) return unsupported(`builtin ${index}`);
-  return symbolicToValue(chunkHIQ5HSZL_cjs.callNode(name, nodes));
+  return symbolicToValue(chunkA2DZ5BEJ_cjs.callNode(name, nodes));
 }
 function rootToValue(root) {
   const value = symbolicToValue(root);
-  if (value.type === 0 /* Number */ && !Number.isInteger(value.toNumber())) return chunk2TZKENDH_cjs.symbolicValue(root);
+  if (value.type === 0 /* Number */ && !Number.isInteger(value.toNumber())) return chunkIT74O4BE_cjs.symbolicValue(root);
   return value;
 }
 function approximateRootToValue(root) {
-  if (root.im === 0) return chunk2TZKENDH_cjs.numberValue(root.re);
-  return chunk2TZKENDH_cjs.symbolicValue(chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.complex(chunkHIQ5HSZL_cjs.rationalFromNumber(root.re), chunkHIQ5HSZL_cjs.rationalFromNumber(root.im))));
+  if (root.im === 0) return chunkIT74O4BE_cjs.numberValue(root.re);
+  return chunkIT74O4BE_cjs.symbolicValue(chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.complex(chunkA2DZ5BEJ_cjs.rationalFromNumber(root.re), chunkA2DZ5BEJ_cjs.rationalFromNumber(root.im))));
 }
 function solveOutcomeToValue(outcome) {
   switch (outcome.kind) {
     case "identity":
-      return chunk2TZKENDH_cjs.stringValue("true for every value");
+      return chunkIT74O4BE_cjs.stringValue("true for every value");
     case "contradiction":
-      return chunk2TZKENDH_cjs.stringValue("no solution");
+      return chunkIT74O4BE_cjs.stringValue("no solution");
     case "unsupported":
-      return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_SOLVE_UNSUPPORTED", `Cannot solve this equation: ${outcome.reason}.`);
+      return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_SOLVE_UNSUPPORTED", `Cannot solve this equation: ${outcome.reason}.`);
     case "incomplete": {
       const found = outcome.exact.length + outcome.approximate.length;
-      return chunk2TZKENDH_cjs.errorValue(
+      return chunkIT74O4BE_cjs.errorValue(
         "SYMBOLIC_SOLVE_INCOMPLETE",
         `Only ${found} of this equation's ${found + outcome.missing} roots could be found: ${outcome.reason}.`
       );
@@ -1081,9 +1081,9 @@ function solveOutcomeToValue(outcome) {
     case "roots": {
       const values = outcome.exact.map(rootToValue);
       for (const approximate of outcome.approximate) values.push(approximateRootToValue(approximate));
-      if (values.length === 0) return chunk2TZKENDH_cjs.stringValue("no solution");
+      if (values.length === 0) return chunkIT74O4BE_cjs.stringValue("no solution");
       if (values.length === 1) return values[0];
-      return chunk2TZKENDH_cjs.matrixValue(1, values.length, values.map((v) => v.type === 9 /* Symbolic */ ? v.value : v.toNumber()));
+      return chunkIT74O4BE_cjs.matrixValue(1, values.length, values.map((v) => v.type === 9 /* Symbolic */ ? v.value : v.toNumber()));
     }
   }
 }
@@ -1091,7 +1091,7 @@ function solveEquationValues(lhsValue, rhsValue, variable) {
   const lhs = valueToSymbolic(lhsValue);
   const rhs = valueToSymbolic(rhsValue);
   if (lhs === null || rhs === null) {
-    return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "An equation side has no exact value to solve with.");
+    return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "An equation side has no exact value to solve with.");
   }
   return solveOutcomeToValue(solveForVariable(lhs, rhs, variable));
 }
@@ -1104,13 +1104,13 @@ function unifyUom(l, r) {
     }
     const lMeasure = chunkEJ3ILXX6_cjs.getMeasure(l.unit);
     const rMeasure = chunkEJ3ILXX6_cjs.getMeasure(r.unit);
-    const isCurrency = chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(l.unit) && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(r.unit);
+    const isCurrency = chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(l.unit) && chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(r.unit);
     if (lMeasure && lMeasure === rMeasure) {
       const rvConverted = chunkEJ3ILXX6_cjs.convertUnit(r.toNumber(), r.unit, l.unit);
       return { lv: l.toNumber(), rv: rvConverted, unit: l.unit, sameMeasure: true };
     }
     if (isCurrency) {
-      const rvConverted = chunkZVTWQLK4_cjs.sharedCurrencyExchange.convertSync(r.toNumber(), r.unit, l.unit);
+      const rvConverted = chunkKXDQKVNX_cjs.sharedCurrencyExchange.convertSync(r.toNumber(), r.unit, l.unit);
       if (rvConverted !== null) {
         return { lv: l.toNumber(), rv: rvConverted, unit: l.unit, sameMeasure: true };
       }
@@ -1136,8 +1136,8 @@ function largestFiniteMagnitude(a, b, c) {
 function compareUom(l, r) {
   const { lv, rv, sameMeasure } = unifyUom(l, r);
   if (!sameMeasure) return { lv, rv, equal: false, sameMeasure: false };
-  if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */ && l.unit !== void 0 && l.unit === r.unit && l.exact !== void 0 && r.exact !== void 0 && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(l.unit)) {
-    return { lv, rv, equal: chunkHIQ5HSZL_cjs.decimalCompare(l.exact, r.exact) === 0, sameMeasure: true };
+  if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */ && l.unit !== void 0 && l.unit === r.unit && l.exact !== void 0 && r.exact !== void 0 && chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(l.unit)) {
+    return { lv, rv, equal: chunkA2DZ5BEJ_cjs.decimalCompare(l.exact, r.exact) === 0, sameMeasure: true };
   }
   if (lv === rv) return { lv, rv, equal: true, sameMeasure: true };
   if (!Number.isFinite(lv) || !Number.isFinite(rv)) return { lv, rv, equal: false, sameMeasure: true };
@@ -1156,7 +1156,7 @@ var COMBINE_VERBS = {
   div: "divided"
 };
 function describeMeasure(unit) {
-  if (chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(unit)) return "money";
+  if (chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(unit)) return "money";
   const measure = chunkEJ3ILXX6_cjs.getMeasure(unit);
   if (measure === void 0) return void 0;
   return MEASURE_NOUNS[measure] ?? measure;
@@ -1188,14 +1188,14 @@ function incomparableUnitsError(l, r) {
   const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
   const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
   const named = describeMeasureMismatch(lUnit, rUnit, "compared");
-  return chunk2TZKENDH_cjs.errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
+  return chunkIT74O4BE_cjs.errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
 }
 function toBigIntOperand(v) {
   if (v.type === 2 /* BigInt */) return v.value;
   const n = v.toNumber();
   if (!Number.isInteger(n)) {
     const shown = Number.isNaN(n) ? "NaN" : String(n);
-    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
       "BIGINT_INEXACT_OPERAND",
       `A whole-number (n) value can only be combined with another whole number, and ${shown} is not one`,
       { operand: shown }
@@ -1204,7 +1204,7 @@ function toBigIntOperand(v) {
   return BigInt(n);
 }
 function bigIntDivisionByZero() {
-  return chunkB4HBEFTB_cjs.ErrorFactory.execution(
+  return chunkMIGXCBXT_cjs.ErrorFactory.execution(
     "BIGINT_DIVISION_BY_ZERO",
     "Division by zero: a whole-number (n) division is exact integer division, which has no answer at zero, unlike 1 / 0 which is Infinity"
   );
@@ -1230,11 +1230,11 @@ function power(base, exponent) {
 }
 function operandExactDecimal(v) {
   if (v.exact !== void 0) return v.exact;
-  return chunkHIQ5HSZL_cjs.decimalFromNumberIfExact(v.toNumber());
+  return chunkA2DZ5BEJ_cjs.decimalFromNumberIfExact(v.toNumber());
 }
 function exactMoneyOp(l, r, op) {
-  const lMoney = l.type === 6 /* Uom */ && l.unit !== void 0 && l.exact !== void 0 && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(l.unit);
-  const rMoney = r.type === 6 /* Uom */ && r.unit !== void 0 && r.exact !== void 0 && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(r.unit);
+  const lMoney = l.type === 6 /* Uom */ && l.unit !== void 0 && l.exact !== void 0 && chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(l.unit);
+  const rMoney = r.type === 6 /* Uom */ && r.unit !== void 0 && r.exact !== void 0 && chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(r.unit);
   if (!lMoney && !rMoney) return null;
   let ld;
   let rd;
@@ -1259,25 +1259,25 @@ function exactMoneyOp(l, r, op) {
   let result;
   switch (op) {
     case "add":
-      result = chunkHIQ5HSZL_cjs.decimalAdd(ld, rd);
+      result = chunkA2DZ5BEJ_cjs.decimalAdd(ld, rd);
       break;
     case "sub":
-      result = chunkHIQ5HSZL_cjs.decimalSubtract(ld, rd);
+      result = chunkA2DZ5BEJ_cjs.decimalSubtract(ld, rd);
       break;
     case "mul":
-      result = chunkHIQ5HSZL_cjs.decimalMultiply(ld, rd);
+      result = chunkA2DZ5BEJ_cjs.decimalMultiply(ld, rd);
       break;
     case "div":
-      if (chunkHIQ5HSZL_cjs.decimalIsZero(rd)) return null;
-      result = chunkHIQ5HSZL_cjs.decimalDivide(ld, rd);
+      if (chunkA2DZ5BEJ_cjs.decimalIsZero(rd)) return null;
+      result = chunkA2DZ5BEJ_cjs.decimalDivide(ld, rd);
       break;
   }
-  return chunk2TZKENDH_cjs.uomValueExact(chunkHIQ5HSZL_cjs.decimalToNumber(result), unit, result);
+  return chunkIT74O4BE_cjs.uomValueExact(chunkA2DZ5BEJ_cjs.decimalToNumber(result), unit, result);
 }
 function operandRational(v) {
   if (v.rational !== void 0) return v.rational;
   if ((v.type === 0 /* Number */ || v.type === 1 /* Hex */) && typeof v.value === "number" && Number.isInteger(v.value)) {
-    return chunkHIQ5HSZL_cjs.rational(BigInt(v.value));
+    return chunkA2DZ5BEJ_cjs.rational(BigInt(v.value));
   }
   return null;
 }
@@ -1286,27 +1286,27 @@ function exactRationalOp(l, r, op) {
   if (lr === null) return null;
   const rr = operandRational(r);
   if (rr === null) return null;
-  if (op === "div" && chunkHIQ5HSZL_cjs.isRationalZero(rr)) return null;
+  if (op === "div" && chunkA2DZ5BEJ_cjs.isRationalZero(rr)) return null;
   let result;
   try {
     switch (op) {
       case "add":
-        result = chunkHIQ5HSZL_cjs.rationalAdd(lr, rr);
+        result = chunkA2DZ5BEJ_cjs.rationalAdd(lr, rr);
         break;
       case "sub":
-        result = chunkHIQ5HSZL_cjs.rationalSub(lr, rr);
+        result = chunkA2DZ5BEJ_cjs.rationalSub(lr, rr);
         break;
       case "mul":
-        result = chunkHIQ5HSZL_cjs.rationalMul(lr, rr);
+        result = chunkA2DZ5BEJ_cjs.rationalMul(lr, rr);
         break;
       case "div":
-        result = chunkHIQ5HSZL_cjs.rationalDiv(lr, rr);
+        result = chunkA2DZ5BEJ_cjs.rationalDiv(lr, rr);
         break;
     }
   } catch {
     return null;
   }
-  return chunk2TZKENDH_cjs.numberValueRational(chunkHIQ5HSZL_cjs.rationalToNumber(result), result);
+  return chunkIT74O4BE_cjs.numberValueRational(chunkA2DZ5BEJ_cjs.rationalToNumber(result), result);
 }
 function uncertainOp(l, r, op) {
   if (l.type !== 0 /* Number */ || r.type !== 0 /* Number */) return null;
@@ -1334,14 +1334,14 @@ function uncertainOp(l, r, op) {
       sigma = Math.hypot(sa / b, a * sb / (b * b));
       break;
   }
-  return chunk2TZKENDH_cjs.numberValueUncertain(center, sigma);
+  return chunkIT74O4BE_cjs.numberValueUncertain(center, sigma);
 }
 function compareRationalOperands(l, r) {
   const lr = operandRational(l);
   if (lr === null) return null;
   const rr = operandRational(r);
   if (rr === null) return null;
-  return chunkHIQ5HSZL_cjs.rationalCompare(lr, rr);
+  return chunkA2DZ5BEJ_cjs.rationalCompare(lr, rr);
 }
 function binaryOp(l, r, op, bigOp, symbolicOp) {
   if (l.type === 13 /* Error */) return l;
@@ -1352,22 +1352,22 @@ function binaryOp(l, r, op, bigOp, symbolicOp) {
     const left = valueToSymbolic(l);
     const right = valueToSymbolic(r);
     if (left === null || right === null) {
-      return chunk2TZKENDH_cjs.errorValue(
+      return chunkIT74O4BE_cjs.errorValue(
         "SYMBOLIC_NONFINITE_OPERAND",
         "A symbolic expression cannot combine with a value that has no exact number (NaN or infinity)."
       );
     }
     const node = { kind: symbolicOp, left, right };
-    return chunk2TZKENDH_cjs.symbolicValue(chunkHIQ5HSZL_cjs.simplifySymbolic(node));
+    return chunkIT74O4BE_cjs.symbolicValue(chunkA2DZ5BEJ_cjs.simplifySymbolic(node));
   }
   if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-    return chunk2TZKENDH_cjs.numberValue(op(l.value, r.value));
+    return chunkIT74O4BE_cjs.numberValue(op(l.value, r.value));
   }
   if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
     const lb = toBigIntOperand(l);
     const rb = toBigIntOperand(r);
-    if (bigOp) return chunk2TZKENDH_cjs.bigIntValue(bigOp(lb, rb));
-    return chunk2TZKENDH_cjs.bigIntValue(lb + rb);
+    if (bigOp) return chunkIT74O4BE_cjs.bigIntValue(bigOp(lb, rb));
+    return chunkIT74O4BE_cjs.bigIntValue(lb + rb);
   }
   if (l.type === 6 /* Uom */ || r.type === 6 /* Uom */) {
     if (symbolicOp) {
@@ -1379,33 +1379,33 @@ function binaryOp(l, r, op, bigOp, symbolicOp) {
       const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
       const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
       const named = describeMeasureMismatch(lUnit, rUnit, combineVerb(symbolicOp));
-      return chunk2TZKENDH_cjs.errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
+      return chunkIT74O4BE_cjs.errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
     }
-    return chunk2TZKENDH_cjs.uomValue(op(lv, rv), unit);
+    return chunkIT74O4BE_cjs.uomValue(op(lv, rv), unit);
   }
   if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
     const lm = l.value;
     const rm = r.value;
-    if (!chunkHIQ5HSZL_cjs.sameShape(lm, rm)) {
-      return chunk2TZKENDH_cjs.errorValue("DIMENSION_MISMATCH", `Cannot combine matrices of different shapes: ${lm.rows}x${lm.cols} and ${rm.rows}x${rm.cols}`);
+    if (!chunkA2DZ5BEJ_cjs.sameShape(lm, rm)) {
+      return chunkIT74O4BE_cjs.errorValue("DIMENSION_MISMATCH", `Cannot combine matrices of different shapes: ${lm.rows}x${lm.cols} and ${rm.rows}x${rm.cols}`);
     }
     const result = new Array(lm.data.length);
     for (let i = 0; i < lm.data.length; i++) result[i] = op(lm.data[i], rm.data[i]);
-    return chunk2TZKENDH_cjs.matrixValue(lm.rows, lm.cols, result);
+    return chunkIT74O4BE_cjs.matrixValue(lm.rows, lm.cols, result);
   }
   if (l.type === 7 /* Matrix */) {
     const lm = l.value;
     const scalar = r.toNumber();
     const result = lm.data.map((v) => op(v, scalar));
-    return chunk2TZKENDH_cjs.matrixValue(lm.rows, lm.cols, result);
+    return chunkIT74O4BE_cjs.matrixValue(lm.rows, lm.cols, result);
   }
   if (r.type === 7 /* Matrix */) {
     const rm = r.value;
     const scalar = l.toNumber();
     const result = rm.data.map((v) => op(scalar, v));
-    return chunk2TZKENDH_cjs.matrixValue(rm.rows, rm.cols, result);
+    return chunkIT74O4BE_cjs.matrixValue(rm.rows, rm.cols, result);
   }
-  return chunk2TZKENDH_cjs.numberValue(op(l.toNumber(), r.toNumber()));
+  return chunkIT74O4BE_cjs.numberValue(op(l.toNumber(), r.toNumber()));
 }
 
 // src/vm/OpRegistry.ts
@@ -1444,7 +1444,7 @@ var OpRegistry = class {
    */
   allocateOpcode() {
     if (this.nextOpcode > MAX_OPCODE) {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.config(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.config(
         "OPCODE_POOL_EXHAUSTED",
         `OpRegistry: dynamic opcode pool exhausted (max ${MAX_OPCODE - DYNAMIC_OPCODE_START} allocations).`
       );
@@ -1455,88 +1455,111 @@ var OpRegistry = class {
 var sharedOpRegistry = new OpRegistry();
 
 // src/vm/MoneyExact.ts
-var ONE_DECIMAL = chunkHIQ5HSZL_cjs.decimalFromInteger(1);
+var ONE_DECIMAL = chunkA2DZ5BEJ_cjs.decimalFromInteger(1);
 function moneyExactMagnitude(operand, unit) {
-  if (!chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(unit)) return null;
-  return operand.exact ?? chunkHIQ5HSZL_cjs.decimalFromNumberIfExact(operand.toNumber());
+  if (!chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(unit)) return null;
+  return operand.exact ?? chunkA2DZ5BEJ_cjs.decimalFromNumberIfExact(operand.toNumber());
 }
 function decimalFromShortDecimal(n) {
   if (!Number.isFinite(n)) return null;
-  if (Number.isInteger(n)) return chunkHIQ5HSZL_cjs.decimalFromInteger(BigInt(n));
+  if (Number.isInteger(n)) return chunkA2DZ5BEJ_cjs.decimalFromInteger(BigInt(n));
   const s = String(n);
   if (!/^-?\d+\.\d+$/.test(s)) return null;
-  return chunkHIQ5HSZL_cjs.decimalFromLiteral(s);
+  return chunkA2DZ5BEJ_cjs.decimalFromLiteral(s);
 }
 function scaleMoneyExact(amount, factor, unit) {
   const base = moneyExactMagnitude(amount, unit);
   const factorDecimal = decimalFromShortDecimal(factor);
   if (base !== null && factorDecimal !== null) {
-    const result = chunkHIQ5HSZL_cjs.decimalMultiply(base, factorDecimal);
-    return chunk2TZKENDH_cjs.uomValueExact(chunkHIQ5HSZL_cjs.decimalToNumber(result), unit, result);
+    const result = chunkA2DZ5BEJ_cjs.decimalMultiply(base, factorDecimal);
+    return chunkIT74O4BE_cjs.uomValueExact(chunkA2DZ5BEJ_cjs.decimalToNumber(result), unit, result);
   }
-  return chunk2TZKENDH_cjs.uomValue(amount.toNumber() * factor, unit);
+  return chunkIT74O4BE_cjs.uomValue(amount.toNumber() * factor, unit);
 }
 function scaleMoneyByPercent(money, unit, percent, sign) {
   const base = moneyExactMagnitude(money, unit);
   const percentDecimal = decimalFromShortDecimal(percent);
   if (base !== null && percentDecimal !== null) {
-    const factor = chunkHIQ5HSZL_cjs.decimalAdd(ONE_DECIMAL, sign === 1 ? percentDecimal : chunkHIQ5HSZL_cjs.decimalNegate(percentDecimal));
-    const result = chunkHIQ5HSZL_cjs.decimalMultiply(base, factor);
-    return chunk2TZKENDH_cjs.uomValueExact(chunkHIQ5HSZL_cjs.decimalToNumber(result), unit, result);
+    const factor = chunkA2DZ5BEJ_cjs.decimalAdd(ONE_DECIMAL, sign === 1 ? percentDecimal : chunkA2DZ5BEJ_cjs.decimalNegate(percentDecimal));
+    const result = chunkA2DZ5BEJ_cjs.decimalMultiply(base, factor);
+    return chunkIT74O4BE_cjs.uomValueExact(chunkA2DZ5BEJ_cjs.decimalToNumber(result), unit, result);
   }
-  return chunk2TZKENDH_cjs.uomValue(money.toNumber() * (1 + sign * percent), unit);
+  return chunkIT74O4BE_cjs.uomValue(money.toNumber() * (1 + sign * percent), unit);
 }
 function onePlusRateDecimal(rate) {
   const rateDecimal = decimalFromShortDecimal(rate);
-  return rateDecimal === null ? null : chunkHIQ5HSZL_cjs.decimalAdd(ONE_DECIMAL, rateDecimal);
+  return rateDecimal === null ? null : chunkA2DZ5BEJ_cjs.decimalAdd(ONE_DECIMAL, rateDecimal);
 }
 function removeTaxExact(money, unit, rate) {
   const base = moneyExactMagnitude(money, unit);
   const divisor = onePlusRateDecimal(rate);
-  if (base === null || divisor === null || chunkHIQ5HSZL_cjs.decimalIsZero(divisor)) return null;
-  const quotient = chunkHIQ5HSZL_cjs.decimalDivide(base, divisor);
-  return chunk2TZKENDH_cjs.uomValueExact(chunkHIQ5HSZL_cjs.decimalToNumber(quotient), unit, quotient);
+  if (base === null || divisor === null || chunkA2DZ5BEJ_cjs.decimalIsZero(divisor)) return null;
+  const quotient = chunkA2DZ5BEJ_cjs.decimalDivide(base, divisor);
+  return chunkIT74O4BE_cjs.uomValueExact(chunkA2DZ5BEJ_cjs.decimalToNumber(quotient), unit, quotient);
 }
 function taxInExact(money, unit, rate) {
   const base = moneyExactMagnitude(money, unit);
   const divisor = onePlusRateDecimal(rate);
-  if (base === null || divisor === null || chunkHIQ5HSZL_cjs.decimalIsZero(divisor)) return null;
-  const tax = chunkHIQ5HSZL_cjs.decimalSubtract(base, chunkHIQ5HSZL_cjs.decimalDivide(base, divisor));
-  return chunk2TZKENDH_cjs.uomValueExact(chunkHIQ5HSZL_cjs.decimalToNumber(tax), unit, tax);
+  if (base === null || divisor === null || chunkA2DZ5BEJ_cjs.decimalIsZero(divisor)) return null;
+  const tax = chunkA2DZ5BEJ_cjs.decimalSubtract(base, chunkA2DZ5BEJ_cjs.decimalDivide(base, divisor));
+  return chunkIT74O4BE_cjs.uomValueExact(chunkA2DZ5BEJ_cjs.decimalToNumber(tax), unit, tax);
+}
+function splitEachExact(amount, n) {
+  const unit = amount.unit;
+  const cents = unit !== void 0 && chunkKXDQKVNX_cjs.sharedCurrencyExchange.isCurrency(unit) ? centsOfMoney(amount, unit) : null;
+  if (cents === null) {
+    return { unit, shares: [{ value: amount.toNumber() / n, count: n }] };
+  }
+  const divisor = BigInt(n);
+  const baseCents = cents / divisor;
+  const remainder = cents - baseCents * divisor;
+  const extraShares = Number(remainder < 0n ? -remainder : remainder);
+  const step = cents < 0n ? -1n : 1n;
+  const base = centShare(baseCents, n - extraShares);
+  if (extraShares === 0) return { unit, shares: [base] };
+  return { unit, shares: [base, centShare(baseCents + step, extraShares)] };
+}
+function centShare(cents, count) {
+  const exact = chunkA2DZ5BEJ_cjs.makeDecimal(cents, 2);
+  return { value: chunkA2DZ5BEJ_cjs.decimalToNumber(exact), exact, count };
+}
+function centsOfMoney(amount, unit) {
+  const base = moneyExactMagnitude(amount, unit);
+  return base === null ? null : chunkA2DZ5BEJ_cjs.decimalRound(base, 2).coef;
 }
 
 // src/symbolic/PartialFractions.ts
 var APART_MAX_DEGREE = 12;
 function multiply2(a, b) {
   if (a.length === 0 || b.length === 0) return [];
-  const product2 = new Array(a.length + b.length - 1).fill(chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
+  const product2 = new Array(a.length + b.length - 1).fill(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
   a.forEach((left, i) => {
     b.forEach((right, j) => {
-      product2[i + j] = chunkHIQ5HSZL_cjs.rationalAdd(product2[i + j], chunkHIQ5HSZL_cjs.rationalMul(left, right));
+      product2[i + j] = chunkA2DZ5BEJ_cjs.rationalAdd(product2[i + j], chunkA2DZ5BEJ_cjs.rationalMul(left, right));
     });
   });
   return product2;
 }
 function power2(base, exponent) {
-  let result = [chunkHIQ5HSZL_cjs.RATIONAL_ONE];
+  let result = [chunkA2DZ5BEJ_cjs.RATIONAL_ONE];
   for (let i = 0; i < exponent; i++) result = multiply2(result, base);
   return result;
 }
 function scale(coefficients, factor) {
-  return coefficients.map((coefficient) => chunkHIQ5HSZL_cjs.rationalDiv(coefficient, factor));
+  return coefficients.map((coefficient) => chunkA2DZ5BEJ_cjs.rationalDiv(coefficient, factor));
 }
 function denominatorFactors(ascending, variable) {
   const factors = [];
   let lowest = 0;
-  while (lowest < ascending.length && chunkHIQ5HSZL_cjs.isRationalZero(ascending[lowest])) lowest++;
-  if (lowest > 0) factors.push({ base: [chunkHIQ5HSZL_cjs.RATIONAL_ZERO, chunkHIQ5HSZL_cjs.RATIONAL_ONE], power: lowest });
+  while (lowest < ascending.length && chunkA2DZ5BEJ_cjs.isRationalZero(ascending[lowest])) lowest++;
+  if (lowest > 0) factors.push({ base: [chunkA2DZ5BEJ_cjs.RATIONAL_ZERO, chunkA2DZ5BEJ_cjs.RATIONAL_ONE], power: lowest });
   const remaining = ascending.slice(lowest);
   if (remaining.length > 1) {
     const factorization = factorUnivariate([...remaining].reverse(), variable);
     for (const factor of factorization.factors) {
-      const polynomial = chunkHIQ5HSZL_cjs.toPolynomial(factor.base);
+      const polynomial = chunkA2DZ5BEJ_cjs.toPolynomial(factor.base);
       if (polynomial === null) return null;
-      factors.push({ base: [...chunkHIQ5HSZL_cjs.polyCoefficients(polynomial, variable)], power: factor.power });
+      factors.push({ base: [...chunkA2DZ5BEJ_cjs.polyCoefficients(polynomial, variable)], power: factor.power });
     }
   }
   return factors.length > 0 ? factors : null;
@@ -1555,10 +1578,10 @@ function enumerateUnknowns(factors) {
 }
 function unknownColumn(unknown, factors, denominator) {
   const divisor = power2(factors[unknown.factor].base, unknown.power);
-  const { quotient, remainder } = chunkHIQ5HSZL_cjs.polynomialDivide(denominator, divisor);
-  if (!chunkHIQ5HSZL_cjs.isZeroPolynomial(remainder)) return null;
-  const shift = new Array(unknown.degree).fill(chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
-  shift.push(chunkHIQ5HSZL_cjs.RATIONAL_ONE);
+  const { quotient, remainder } = chunkA2DZ5BEJ_cjs.polynomialDivide(denominator, divisor);
+  if (!chunkA2DZ5BEJ_cjs.isZeroPolynomial(remainder)) return null;
+  const shift = new Array(unknown.degree).fill(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
+  shift.push(chunkA2DZ5BEJ_cjs.RATIONAL_ONE);
   return multiply2(quotient, shift);
 }
 function solveLinearSystem(matrix, target) {
@@ -1566,7 +1589,7 @@ function solveLinearSystem(matrix, target) {
   for (let column = 0; column < size; column++) {
     let pivot = -1;
     for (let row = column; row < size; row++) {
-      if (!chunkHIQ5HSZL_cjs.isRationalZero(matrix[row][column])) {
+      if (!chunkA2DZ5BEJ_cjs.isRationalZero(matrix[row][column])) {
         pivot = row;
         break;
       }
@@ -1575,21 +1598,21 @@ function solveLinearSystem(matrix, target) {
     [matrix[column], matrix[pivot]] = [matrix[pivot], matrix[column]];
     [target[column], target[pivot]] = [target[pivot], target[column]];
     for (let row = 0; row < size; row++) {
-      if (row === column || chunkHIQ5HSZL_cjs.isRationalZero(matrix[row][column])) continue;
-      const factor = chunkHIQ5HSZL_cjs.rationalDiv(matrix[row][column], matrix[column][column]);
+      if (row === column || chunkA2DZ5BEJ_cjs.isRationalZero(matrix[row][column])) continue;
+      const factor = chunkA2DZ5BEJ_cjs.rationalDiv(matrix[row][column], matrix[column][column]);
       for (let k = column; k < size; k++) {
-        matrix[row][k] = chunkHIQ5HSZL_cjs.rationalSub(matrix[row][k], chunkHIQ5HSZL_cjs.rationalMul(factor, matrix[column][k]));
+        matrix[row][k] = chunkA2DZ5BEJ_cjs.rationalSub(matrix[row][k], chunkA2DZ5BEJ_cjs.rationalMul(factor, matrix[column][k]));
       }
-      target[row] = chunkHIQ5HSZL_cjs.rationalSub(target[row], chunkHIQ5HSZL_cjs.rationalMul(factor, target[column]));
+      target[row] = chunkA2DZ5BEJ_cjs.rationalSub(target[row], chunkA2DZ5BEJ_cjs.rationalMul(factor, target[column]));
     }
   }
-  return target.map((value, index) => chunkHIQ5HSZL_cjs.rationalDiv(value, matrix[index][index]));
+  return target.map((value, index) => chunkA2DZ5BEJ_cjs.rationalDiv(value, matrix[index][index]));
 }
 function partialFractions(numerator, denominator, variable) {
   if (denominator.length < 2 || denominator.length - 1 > APART_MAX_DEGREE) return null;
-  const shared = chunkHIQ5HSZL_cjs.coefficientGcd(numerator, denominator);
-  const reducedNumerator = shared.length > 1 ? chunkHIQ5HSZL_cjs.polynomialDivide(numerator, shared).quotient : [...numerator];
-  const reducedDenominator = shared.length > 1 ? chunkHIQ5HSZL_cjs.polynomialDivide(denominator, shared).quotient : [...denominator];
+  const shared = chunkA2DZ5BEJ_cjs.coefficientGcd(numerator, denominator);
+  const reducedNumerator = shared.length > 1 ? chunkA2DZ5BEJ_cjs.polynomialDivide(numerator, shared).quotient : [...numerator];
+  const reducedDenominator = shared.length > 1 ? chunkA2DZ5BEJ_cjs.polynomialDivide(denominator, shared).quotient : [...denominator];
   if (reducedDenominator.length === 1) {
     return { polynomial: scale(reducedNumerator, reducedDenominator[0]), terms: [] };
   }
@@ -1597,8 +1620,8 @@ function partialFractions(numerator, denominator, variable) {
   const leading = reducedDenominator[reducedDenominator.length - 1];
   const monicDenominator = scale(reducedDenominator, leading);
   const scaledNumerator = scale(reducedNumerator, leading);
-  const { quotient, remainder } = chunkHIQ5HSZL_cjs.polynomialDivide(scaledNumerator, monicDenominator);
-  if (chunkHIQ5HSZL_cjs.isZeroPolynomial(remainder)) return { polynomial: quotient, terms: [] };
+  const { quotient, remainder } = chunkA2DZ5BEJ_cjs.polynomialDivide(scaledNumerator, monicDenominator);
+  if (chunkA2DZ5BEJ_cjs.isZeroPolynomial(remainder)) return { polynomial: quotient, terms: [] };
   const factors = denominatorFactors(monicDenominator, variable);
   if (factors === null) return null;
   const terms = solveForNumerators(factors, monicDenominator, remainder);
@@ -1616,10 +1639,10 @@ function solveForNumerators(factors, denominator, remainder) {
   }
   const matrix = [];
   for (let row = 0; row < size; row++) {
-    matrix.push(columns.map((column) => column[row] ?? chunkHIQ5HSZL_cjs.RATIONAL_ZERO));
+    matrix.push(columns.map((column) => column[row] ?? chunkA2DZ5BEJ_cjs.RATIONAL_ZERO));
   }
   const target = [];
-  for (let row = 0; row < size; row++) target.push(remainder[row] ?? chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
+  for (let row = 0; row < size; row++) target.push(remainder[row] ?? chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
   const solution = solveLinearSystem(matrix, target);
   if (solution === null) return null;
   return groupSolution(unknowns, solution, factors);
@@ -1635,8 +1658,8 @@ function groupSolution(unknowns, solution, factors) {
   const terms = [];
   for (const [key, coefficients] of grouped) {
     const [factorIndex, termPower] = key.split(":").map(Number);
-    const filled = [...coefficients].map((value) => value ?? chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
-    if (filled.every(chunkHIQ5HSZL_cjs.isRationalZero)) continue;
+    const filled = [...coefficients].map((value) => value ?? chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
+    if (filled.every(chunkA2DZ5BEJ_cjs.isRationalZero)) continue;
     terms.push({ numerator: filled, base: factors[factorIndex].base, power: termPower });
   }
   return terms;
@@ -1644,11 +1667,11 @@ function groupSolution(unknowns, solution, factors) {
 function coefficientsToNode2(coefficients, variable) {
   const terms = /* @__PURE__ */ new Map();
   coefficients.forEach((coefficient, exponent) => {
-    if (chunkHIQ5HSZL_cjs.isRationalZero(coefficient)) return;
+    if (chunkA2DZ5BEJ_cjs.isRationalZero(coefficient)) return;
     terms.set(exponent === 0 ? "" : exponent === 1 ? variable : `${variable}^${exponent}`, coefficient);
   });
-  if (terms.size === 0) return chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
-  return chunkHIQ5HSZL_cjs.fromPolynomial({ terms, vars: coefficients.length > 1 ? [variable] : [] });
+  if (terms.size === 0) return chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
+  return chunkA2DZ5BEJ_cjs.fromPolynomial({ terms, vars: coefficients.length > 1 ? [variable] : [] });
 }
 function apartSymbolic(node) {
   const parts = asRationalFunction(node);
@@ -1658,9 +1681,9 @@ function apartSymbolic(node) {
   let result = decomposition.polynomial.length > 0 ? coefficientsToNode2(decomposition.polynomial, parts.variable) : null;
   for (const term of decomposition.terms) {
     const base = coefficientsToNode2(term.base, parts.variable);
-    const denominator = term.power === 1 ? base : chunkHIQ5HSZL_cjs.powNode(base, chunkHIQ5HSZL_cjs.constNode({ n: BigInt(term.power), d: 1n }));
+    const denominator = term.power === 1 ? base : chunkA2DZ5BEJ_cjs.powNode(base, chunkA2DZ5BEJ_cjs.constNode({ n: BigInt(term.power), d: 1n }));
     const negative = isNegativeNumerator(term.numerator);
-    const numerator = negative ? term.numerator.map((coefficient) => chunkHIQ5HSZL_cjs.rationalNeg(coefficient)) : term.numerator;
+    const numerator = negative ? term.numerator.map((coefficient) => chunkA2DZ5BEJ_cjs.rationalNeg(coefficient)) : term.numerator;
     const piece = {
       kind: "div",
       left: coefficientsToNode2(numerator, parts.variable),
@@ -1669,22 +1692,22 @@ function apartSymbolic(node) {
     if (result === null) result = negative ? { kind: "neg", operand: piece } : piece;
     else result = { kind: negative ? "sub" : "add", left: result, right: piece };
   }
-  return result === null ? node : chunkHIQ5HSZL_cjs.simplifySymbolic(result);
+  return result === null ? node : chunkA2DZ5BEJ_cjs.simplifySymbolic(result);
 }
 function isNegativeNumerator(coefficients) {
   return coefficients.some((coefficient) => coefficient.n < 0n) && coefficients.every((coefficient) => coefficient.n <= 0n);
 }
 function asRationalFunction(node) {
   if (node.kind !== "div") return null;
-  const numerator = chunkHIQ5HSZL_cjs.toPolynomial(node.left);
-  const denominator = chunkHIQ5HSZL_cjs.toPolynomial(node.right);
+  const numerator = chunkA2DZ5BEJ_cjs.toPolynomial(node.left);
+  const denominator = chunkA2DZ5BEJ_cjs.toPolynomial(node.right);
   if (numerator === null || denominator === null) return null;
-  const variable = chunkHIQ5HSZL_cjs.polyUnivariateVar(denominator);
+  const variable = chunkA2DZ5BEJ_cjs.polyUnivariateVar(denominator);
   if (variable === null) return null;
   if (numerator.vars.some((name) => name !== variable)) return null;
   return {
-    numerator: chunkHIQ5HSZL_cjs.polyCoefficients(numerator, variable),
-    denominator: chunkHIQ5HSZL_cjs.polyCoefficients(denominator, variable),
+    numerator: chunkA2DZ5BEJ_cjs.polyCoefficients(numerator, variable),
+    denominator: chunkA2DZ5BEJ_cjs.polyCoefficients(denominator, variable),
     variable
   };
 }
@@ -1692,66 +1715,66 @@ function asRationalFunction(node) {
 // src/symbolic/Derivative.ts
 var DERIVATIVE_MAX_ORDER = 16;
 function zero() {
-  return chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
+  return chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
 }
 function one() {
-  return chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.RATIONAL_ONE);
+  return chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.RATIONAL_ONE);
 }
 function functionDerivative(name, argument) {
   switch (name) {
     case "sin":
-      return chunkHIQ5HSZL_cjs.callNode("cos", [argument]);
+      return chunkA2DZ5BEJ_cjs.callNode("cos", [argument]);
     case "cos":
-      return { kind: "neg", operand: chunkHIQ5HSZL_cjs.callNode("sin", [argument]) };
+      return { kind: "neg", operand: chunkA2DZ5BEJ_cjs.callNode("sin", [argument]) };
     case "tan":
-      return { kind: "div", left: one(), right: chunkHIQ5HSZL_cjs.powNode(chunkHIQ5HSZL_cjs.callNode("cos", [argument]), chunkHIQ5HSZL_cjs.constNode(2)) };
+      return { kind: "div", left: one(), right: chunkA2DZ5BEJ_cjs.powNode(chunkA2DZ5BEJ_cjs.callNode("cos", [argument]), chunkA2DZ5BEJ_cjs.constNode(2)) };
     case "exp":
-      return chunkHIQ5HSZL_cjs.callNode("exp", [argument]);
+      return chunkA2DZ5BEJ_cjs.callNode("exp", [argument]);
     case "log":
       return { kind: "div", left: one(), right: argument };
     case "sqrt":
       return {
         kind: "div",
         left: one(),
-        right: { kind: "mul", left: chunkHIQ5HSZL_cjs.constNode(2), right: chunkHIQ5HSZL_cjs.callNode("sqrt", [argument]) }
+        right: { kind: "mul", left: chunkA2DZ5BEJ_cjs.constNode(2), right: chunkA2DZ5BEJ_cjs.callNode("sqrt", [argument]) }
       };
     case "asin":
-      return { kind: "div", left: one(), right: chunkHIQ5HSZL_cjs.callNode("sqrt", [oneMinusSquare(argument)]) };
+      return { kind: "div", left: one(), right: chunkA2DZ5BEJ_cjs.callNode("sqrt", [oneMinusSquare(argument)]) };
     case "acos":
-      return { kind: "neg", operand: { kind: "div", left: one(), right: chunkHIQ5HSZL_cjs.callNode("sqrt", [oneMinusSquare(argument)]) } };
+      return { kind: "neg", operand: { kind: "div", left: one(), right: chunkA2DZ5BEJ_cjs.callNode("sqrt", [oneMinusSquare(argument)]) } };
     case "atan":
       return { kind: "div", left: one(), right: onePlusSquare(argument) };
     case "sinh":
-      return chunkHIQ5HSZL_cjs.callNode("cosh", [argument]);
+      return chunkA2DZ5BEJ_cjs.callNode("cosh", [argument]);
     case "cosh":
-      return chunkHIQ5HSZL_cjs.callNode("sinh", [argument]);
+      return chunkA2DZ5BEJ_cjs.callNode("sinh", [argument]);
     case "tanh":
-      return { kind: "div", left: one(), right: chunkHIQ5HSZL_cjs.powNode(chunkHIQ5HSZL_cjs.callNode("cosh", [argument]), chunkHIQ5HSZL_cjs.constNode(2)) };
+      return { kind: "div", left: one(), right: chunkA2DZ5BEJ_cjs.powNode(chunkA2DZ5BEJ_cjs.callNode("cosh", [argument]), chunkA2DZ5BEJ_cjs.constNode(2)) };
     case "abs":
-      return chunkHIQ5HSZL_cjs.callNode("sign", [argument]);
+      return chunkA2DZ5BEJ_cjs.callNode("sign", [argument]);
     default:
       return null;
   }
 }
 function oneMinusSquare(argument) {
-  return { kind: "sub", left: one(), right: chunkHIQ5HSZL_cjs.powNode(argument, chunkHIQ5HSZL_cjs.constNode(2)) };
+  return { kind: "sub", left: one(), right: chunkA2DZ5BEJ_cjs.powNode(argument, chunkA2DZ5BEJ_cjs.constNode(2)) };
 }
 function onePlusSquare(argument) {
-  return { kind: "add", left: one(), right: chunkHIQ5HSZL_cjs.powNode(argument, chunkHIQ5HSZL_cjs.constNode(2)) };
+  return { kind: "add", left: one(), right: chunkA2DZ5BEJ_cjs.powNode(argument, chunkA2DZ5BEJ_cjs.constNode(2)) };
 }
 function differentiate2(node, variable, order = 1) {
   if (order < 0 || !Number.isInteger(order)) {
-    throw chunkB4HBEFTB_cjs.ErrorFactory.execution("SYMBOLIC_DERIVATIVE_ORDER_LIMIT", "A derivative order must be a whole number, at least zero.");
+    throw chunkMIGXCBXT_cjs.ErrorFactory.execution("SYMBOLIC_DERIVATIVE_ORDER_LIMIT", "A derivative order must be a whole number, at least zero.");
   }
   if (order > DERIVATIVE_MAX_ORDER) {
-    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
       "SYMBOLIC_DERIVATIVE_ORDER_LIMIT",
       `A derivative order above ${DERIVATIVE_MAX_ORDER} is not supported.`,
       { limit: DERIVATIVE_MAX_ORDER }
     );
   }
-  let result = chunkHIQ5HSZL_cjs.simplifySymbolic(node);
-  for (let i = 0; i < order; i++) result = chunkHIQ5HSZL_cjs.simplifySymbolic(derive(result, variable));
+  let result = chunkA2DZ5BEJ_cjs.simplifySymbolic(node);
+  for (let i = 0; i < order; i++) result = chunkA2DZ5BEJ_cjs.simplifySymbolic(derive(result, variable));
   return result;
 }
 function derive(node, variable) {
@@ -1781,7 +1804,7 @@ function derive(node, variable) {
           left: { kind: "mul", left: derive(node.left, variable), right: node.right },
           right: { kind: "mul", left: node.left, right: derive(node.right, variable) }
         },
-        right: chunkHIQ5HSZL_cjs.powNode(node.right, chunkHIQ5HSZL_cjs.constNode(2))
+        right: chunkA2DZ5BEJ_cjs.powNode(node.right, chunkA2DZ5BEJ_cjs.constNode(2))
       };
     case "pow":
       return derivePow(node, variable);
@@ -1795,79 +1818,79 @@ function derive(node, variable) {
 }
 function derivePow(node, variable) {
   if (node.exponent.kind === "const") {
-    const reduced = chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalSub(node.exponent.value, chunkHIQ5HSZL_cjs.RATIONAL_ONE));
+    const reduced = chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalSub(node.exponent.value, chunkA2DZ5BEJ_cjs.RATIONAL_ONE));
     return {
       kind: "mul",
-      left: { kind: "mul", left: node.exponent, right: chunkHIQ5HSZL_cjs.powNode(node.base, reduced) },
+      left: { kind: "mul", left: node.exponent, right: chunkA2DZ5BEJ_cjs.powNode(node.base, reduced) },
       right: derive(node.base, variable)
     };
   }
   if (node.base.kind === "const" && node.base.value.n > 0n) {
     return {
       kind: "mul",
-      left: { kind: "mul", left: node, right: chunkHIQ5HSZL_cjs.callNode("log", [node.base]) },
+      left: { kind: "mul", left: node, right: chunkA2DZ5BEJ_cjs.callNode("log", [node.base]) },
       right: derive(node.exponent, variable)
     };
   }
   return unevaluated(node, variable);
 }
 function unevaluated(node, variable) {
-  return chunkHIQ5HSZL_cjs.callNode("der", [node, chunkHIQ5HSZL_cjs.varNode(variable)]);
+  return chunkA2DZ5BEJ_cjs.callNode("der", [node, chunkA2DZ5BEJ_cjs.varNode(variable)]);
 }
 
 // src/symbolic/Integral.ts
 function asLinear(node, variable) {
-  const polynomial = chunkHIQ5HSZL_cjs.toPolynomial(node);
+  const polynomial = chunkA2DZ5BEJ_cjs.toPolynomial(node);
   if (polynomial === null) return null;
   const others = polynomial.vars.filter((name) => name !== variable);
   if (others.length > 0) return null;
-  if (chunkHIQ5HSZL_cjs.polyDegree(polynomial, variable) > 1) return null;
-  const ascending = chunkHIQ5HSZL_cjs.polyCoefficients(polynomial, variable);
+  if (chunkA2DZ5BEJ_cjs.polyDegree(polynomial, variable) > 1) return null;
+  const ascending = chunkA2DZ5BEJ_cjs.polyCoefficients(polynomial, variable);
   const intercept = ascending[0] ?? { n: 0n, d: 1n };
   const slope = ascending[1] ?? { n: 0n, d: 1n };
-  return chunkHIQ5HSZL_cjs.isRationalZero(slope) ? null : { slope, intercept };
+  return chunkA2DZ5BEJ_cjs.isRationalZero(slope) ? null : { slope, intercept };
 }
 function integratePolynomial(node, variable) {
-  const polynomial = chunkHIQ5HSZL_cjs.toPolynomial(node);
+  const polynomial = chunkA2DZ5BEJ_cjs.toPolynomial(node);
   if (polynomial === null) return null;
   const others = polynomial.vars.filter((name) => name !== variable);
   if (others.length > 0) {
     return { ok: false, reason: `it involves more than one unknown (${others.join(", ")})` };
   }
-  const ascending = chunkHIQ5HSZL_cjs.polyCoefficients(polynomial, variable);
-  let result = chunkHIQ5HSZL_cjs.constNode(0);
+  const ascending = chunkA2DZ5BEJ_cjs.polyCoefficients(polynomial, variable);
+  let result = chunkA2DZ5BEJ_cjs.constNode(0);
   ascending.forEach((coeff, power3) => {
-    if (chunkHIQ5HSZL_cjs.isRationalZero(coeff)) return;
+    if (chunkA2DZ5BEJ_cjs.isRationalZero(coeff)) return;
     const nextPower = power3 + 1;
-    const scaled = chunkHIQ5HSZL_cjs.rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
+    const scaled = chunkA2DZ5BEJ_cjs.rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
     const term = {
       kind: "mul",
-      left: chunkHIQ5HSZL_cjs.constNode(scaled),
-      right: nextPower === 1 ? chunkHIQ5HSZL_cjs.varNode(variable) : chunkHIQ5HSZL_cjs.powNode(chunkHIQ5HSZL_cjs.varNode(variable), chunkHIQ5HSZL_cjs.constNode(nextPower))
+      left: chunkA2DZ5BEJ_cjs.constNode(scaled),
+      right: nextPower === 1 ? chunkA2DZ5BEJ_cjs.varNode(variable) : chunkA2DZ5BEJ_cjs.powNode(chunkA2DZ5BEJ_cjs.varNode(variable), chunkA2DZ5BEJ_cjs.constNode(nextPower))
     };
     result = { kind: "add", left: result, right: term };
   });
-  return { ok: true, value: chunkHIQ5HSZL_cjs.simplifySymbolic(result) };
+  return { ok: true, value: chunkA2DZ5BEJ_cjs.simplifySymbolic(result) };
 }
 function integrateStandardForm(node, variable) {
   if (node.kind !== "call" || node.args.length !== 1) return null;
   const linear = asLinear(node.args[0], variable);
   if (linear === null) return null;
   const inner = node.args[0];
-  const divideBySlope = (value) => chunkHIQ5HSZL_cjs.simplifySymbolic({ kind: "div", left: value, right: chunkHIQ5HSZL_cjs.constNode(linear.slope) });
+  const divideBySlope = (value) => chunkA2DZ5BEJ_cjs.simplifySymbolic({ kind: "div", left: value, right: chunkA2DZ5BEJ_cjs.constNode(linear.slope) });
   switch (node.name) {
     case "exp":
-      return { ok: true, value: divideBySlope(chunkHIQ5HSZL_cjs.callNode("exp", [inner])) };
+      return { ok: true, value: divideBySlope(chunkA2DZ5BEJ_cjs.callNode("exp", [inner])) };
     case "sin":
-      return { ok: true, value: divideBySlope({ kind: "neg", operand: chunkHIQ5HSZL_cjs.callNode("cos", [inner]) }) };
+      return { ok: true, value: divideBySlope({ kind: "neg", operand: chunkA2DZ5BEJ_cjs.callNode("cos", [inner]) }) };
     case "cos":
-      return { ok: true, value: divideBySlope(chunkHIQ5HSZL_cjs.callNode("sin", [inner])) };
+      return { ok: true, value: divideBySlope(chunkA2DZ5BEJ_cjs.callNode("sin", [inner])) };
     case "log":
       return {
         ok: true,
         value: divideBySlope({
           kind: "sub",
-          left: { kind: "mul", left: inner, right: chunkHIQ5HSZL_cjs.callNode("log", [inner]) },
+          left: { kind: "mul", left: inner, right: chunkA2DZ5BEJ_cjs.callNode("log", [inner]) },
           right: inner
         })
       };
@@ -1882,18 +1905,18 @@ function integrateReciprocalForms(node, variable) {
   if (linear !== null) {
     return {
       ok: true,
-      value: chunkHIQ5HSZL_cjs.simplifySymbolic({
+      value: chunkA2DZ5BEJ_cjs.simplifySymbolic({
         kind: "div",
-        left: chunkHIQ5HSZL_cjs.callNode("log", [node.right]),
-        right: chunkHIQ5HSZL_cjs.constNode(linear.slope)
+        left: chunkA2DZ5BEJ_cjs.callNode("log", [node.right]),
+        right: chunkA2DZ5BEJ_cjs.constNode(linear.slope)
       })
     };
   }
-  const denominator = chunkHIQ5HSZL_cjs.toPolynomial(node.right);
+  const denominator = chunkA2DZ5BEJ_cjs.toPolynomial(node.right);
   if (denominator !== null && denominator.vars.length === 1 && denominator.vars[0] === variable) {
-    const ascending = chunkHIQ5HSZL_cjs.polyCoefficients(denominator, variable);
-    const isOnePlusSquare = ascending.length === 3 && isRationalOneNode(ascending[0]) && chunkHIQ5HSZL_cjs.isRationalZero(ascending[1]) && isRationalOneNode(ascending[2]);
-    if (isOnePlusSquare) return { ok: true, value: chunkHIQ5HSZL_cjs.callNode("atan", [chunkHIQ5HSZL_cjs.varNode(variable)]) };
+    const ascending = chunkA2DZ5BEJ_cjs.polyCoefficients(denominator, variable);
+    const isOnePlusSquare = ascending.length === 3 && isRationalOneNode(ascending[0]) && chunkA2DZ5BEJ_cjs.isRationalZero(ascending[1]) && isRationalOneNode(ascending[2]);
+    if (isOnePlusSquare) return { ok: true, value: chunkA2DZ5BEJ_cjs.callNode("atan", [chunkA2DZ5BEJ_cjs.varNode(variable)]) };
   }
   return null;
 }
@@ -1905,7 +1928,7 @@ function integrateRationalFunction(node, variable) {
   if (parts === null || parts.variable !== variable) return null;
   const decomposition = partialFractions(parts.numerator, parts.denominator, variable);
   if (decomposition === null) return null;
-  let result = decomposition.polynomial.length > 0 ? polynomialAntiderivative(decomposition.polynomial, variable) : chunkHIQ5HSZL_cjs.constNode(0);
+  let result = decomposition.polynomial.length > 0 ? polynomialAntiderivative(decomposition.polynomial, variable) : chunkA2DZ5BEJ_cjs.constNode(0);
   for (const term of decomposition.terms) {
     const piece = integrateTerm(term, variable);
     if (piece === null) {
@@ -1916,72 +1939,72 @@ function integrateRationalFunction(node, variable) {
     }
     result = { kind: "add", left: result, right: piece };
   }
-  return { ok: true, value: chunkHIQ5HSZL_cjs.simplifySymbolic(result) };
+  return { ok: true, value: chunkA2DZ5BEJ_cjs.simplifySymbolic(result) };
 }
 function integrateTerm(term, variable) {
   const baseDegree = term.base.length - 1;
   const base = coefficientsToNode2(term.base, variable);
   if (baseDegree === 1) {
-    const coefficient = term.numerator[0] ?? chunkHIQ5HSZL_cjs.RATIONAL_ZERO;
+    const coefficient = term.numerator[0] ?? chunkA2DZ5BEJ_cjs.RATIONAL_ZERO;
     if (term.power === 1) {
-      return { kind: "mul", left: chunkHIQ5HSZL_cjs.constNode(coefficient), right: chunkHIQ5HSZL_cjs.callNode("log", [base]) };
+      return { kind: "mul", left: chunkA2DZ5BEJ_cjs.constNode(coefficient), right: chunkA2DZ5BEJ_cjs.callNode("log", [base]) };
     }
     const reduced = term.power - 1;
-    const scaled = chunkHIQ5HSZL_cjs.rationalDiv(coefficient, { n: BigInt(-reduced), d: 1n });
+    const scaled = chunkA2DZ5BEJ_cjs.rationalDiv(coefficient, { n: BigInt(-reduced), d: 1n });
     return {
       kind: "div",
-      left: chunkHIQ5HSZL_cjs.constNode(scaled),
-      right: chunkHIQ5HSZL_cjs.powNode(base, chunkHIQ5HSZL_cjs.constNode({ n: BigInt(reduced), d: 1n }))
+      left: chunkA2DZ5BEJ_cjs.constNode(scaled),
+      right: chunkA2DZ5BEJ_cjs.powNode(base, chunkA2DZ5BEJ_cjs.constNode({ n: BigInt(reduced), d: 1n }))
     };
   }
   if (baseDegree !== 2 || term.power !== 1) return null;
   return integrateQuadraticTerm(term, variable, base);
 }
 function integrateQuadraticTerm(term, variable, base) {
-  const constant = term.numerator[0] ?? chunkHIQ5HSZL_cjs.RATIONAL_ZERO;
-  const linear = term.numerator[1] ?? chunkHIQ5HSZL_cjs.RATIONAL_ZERO;
+  const constant = term.numerator[0] ?? chunkA2DZ5BEJ_cjs.RATIONAL_ZERO;
+  const linear = term.numerator[1] ?? chunkA2DZ5BEJ_cjs.RATIONAL_ZERO;
   const [q, p] = term.base;
   const half = { n: 1n, d: 2n };
-  const halfP = chunkHIQ5HSZL_cjs.rationalMul(p, half);
+  const halfP = chunkA2DZ5BEJ_cjs.rationalMul(p, half);
   const logarithm = {
     kind: "mul",
-    left: chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.rationalMul(linear, half)),
-    right: chunkHIQ5HSZL_cjs.callNode("log", [base])
+    left: chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.rationalMul(linear, half)),
+    right: chunkA2DZ5BEJ_cjs.callNode("log", [base])
   };
-  const leftover = chunkHIQ5HSZL_cjs.rationalSub(constant, chunkHIQ5HSZL_cjs.rationalMul(linear, halfP));
-  if (chunkHIQ5HSZL_cjs.isRationalZero(leftover)) return logarithm;
-  const width = chunkHIQ5HSZL_cjs.surdNode(chunkHIQ5HSZL_cjs.rationalSub(q, chunkHIQ5HSZL_cjs.rationalMul(halfP, halfP)));
+  const leftover = chunkA2DZ5BEJ_cjs.rationalSub(constant, chunkA2DZ5BEJ_cjs.rationalMul(linear, halfP));
+  if (chunkA2DZ5BEJ_cjs.isRationalZero(leftover)) return logarithm;
+  const width = chunkA2DZ5BEJ_cjs.surdNode(chunkA2DZ5BEJ_cjs.rationalSub(q, chunkA2DZ5BEJ_cjs.rationalMul(halfP, halfP)));
   const shifted = {
     kind: "add",
-    left: chunkHIQ5HSZL_cjs.varNode(variable),
-    right: chunkHIQ5HSZL_cjs.constNode(halfP)
+    left: chunkA2DZ5BEJ_cjs.varNode(variable),
+    right: chunkA2DZ5BEJ_cjs.constNode(halfP)
   };
   const arctangent = {
     kind: "mul",
-    left: { kind: "div", left: chunkHIQ5HSZL_cjs.constNode(leftover), right: width },
-    right: chunkHIQ5HSZL_cjs.callNode("atan", [{ kind: "div", left: shifted, right: width }])
+    left: { kind: "div", left: chunkA2DZ5BEJ_cjs.constNode(leftover), right: width },
+    right: chunkA2DZ5BEJ_cjs.callNode("atan", [{ kind: "div", left: shifted, right: width }])
   };
-  return chunkHIQ5HSZL_cjs.isRationalZero(linear) ? arctangent : { kind: "add", left: logarithm, right: arctangent };
+  return chunkA2DZ5BEJ_cjs.isRationalZero(linear) ? arctangent : { kind: "add", left: logarithm, right: arctangent };
 }
 function polynomialAntiderivative(ascending, variable) {
-  let result = chunkHIQ5HSZL_cjs.constNode(0);
+  let result = chunkA2DZ5BEJ_cjs.constNode(0);
   ascending.forEach((coeff, exponent) => {
-    if (chunkHIQ5HSZL_cjs.isRationalZero(coeff)) return;
+    if (chunkA2DZ5BEJ_cjs.isRationalZero(coeff)) return;
     const nextPower = exponent + 1;
-    const scaled = chunkHIQ5HSZL_cjs.rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
+    const scaled = chunkA2DZ5BEJ_cjs.rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
     const term = {
       kind: "mul",
-      left: chunkHIQ5HSZL_cjs.constNode(scaled),
-      right: nextPower === 1 ? chunkHIQ5HSZL_cjs.varNode(variable) : chunkHIQ5HSZL_cjs.powNode(chunkHIQ5HSZL_cjs.varNode(variable), chunkHIQ5HSZL_cjs.constNode(nextPower))
+      left: chunkA2DZ5BEJ_cjs.constNode(scaled),
+      right: nextPower === 1 ? chunkA2DZ5BEJ_cjs.varNode(variable) : chunkA2DZ5BEJ_cjs.powNode(chunkA2DZ5BEJ_cjs.varNode(variable), chunkA2DZ5BEJ_cjs.constNode(nextPower))
     };
     result = { kind: "add", left: result, right: term };
   });
   return result;
 }
 function integrate(node, variable) {
-  const simplified = chunkHIQ5HSZL_cjs.simplifySymbolic(node);
-  if (!chunkHIQ5HSZL_cjs.freeVariables(simplified).has(variable)) {
-    return { ok: true, value: chunkHIQ5HSZL_cjs.simplifySymbolic({ kind: "mul", left: simplified, right: chunkHIQ5HSZL_cjs.varNode(variable) }) };
+  const simplified = chunkA2DZ5BEJ_cjs.simplifySymbolic(node);
+  if (!chunkA2DZ5BEJ_cjs.freeVariables(simplified).has(variable)) {
+    return { ok: true, value: chunkA2DZ5BEJ_cjs.simplifySymbolic({ kind: "mul", left: simplified, right: chunkA2DZ5BEJ_cjs.varNode(variable) }) };
   }
   const polynomial = integratePolynomial(simplified, variable);
   if (polynomial !== null) return polynomial;
@@ -1998,13 +2021,13 @@ function integrate(node, variable) {
     if (!right.ok) return right;
     return {
       ok: true,
-      value: chunkHIQ5HSZL_cjs.simplifySymbolic({ kind: simplified.kind, left: left.value, right: right.value })
+      value: chunkA2DZ5BEJ_cjs.simplifySymbolic({ kind: simplified.kind, left: left.value, right: right.value })
     };
   }
   if (simplified.kind === "mul" && simplified.left.kind === "const") {
     const inner = integrate(simplified.right, variable);
     if (!inner.ok) return inner;
-    return { ok: true, value: chunkHIQ5HSZL_cjs.simplifySymbolic({ kind: "mul", left: simplified.left, right: inner.value }) };
+    return { ok: true, value: chunkA2DZ5BEJ_cjs.simplifySymbolic({ kind: "mul", left: simplified.left, right: inner.value }) };
   }
   return {
     ok: false,
@@ -2016,33 +2039,33 @@ function integrate(node, variable) {
 var TAYLOR_MAX_DEGREE = 16;
 function taylorSeries(node, variable, point, degree) {
   if (degree < 0 || !Number.isInteger(degree) || degree > TAYLOR_MAX_DEGREE) {
-    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
       "SYMBOLIC_TAYLOR_DEGREE_LIMIT",
       `A Taylor degree must be a whole number from 0 to ${TAYLOR_MAX_DEGREE}.`,
       { limit: TAYLOR_MAX_DEGREE }
     );
   }
-  const pointNode = chunkHIQ5HSZL_cjs.constNode(point);
+  const pointNode = chunkA2DZ5BEJ_cjs.constNode(point);
   let factorial = 1n;
-  let result = chunkHIQ5HSZL_cjs.constNode(chunkHIQ5HSZL_cjs.RATIONAL_ZERO);
+  let result = chunkA2DZ5BEJ_cjs.constNode(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO);
   for (let order = 0; order <= degree; order++) {
     if (order > 0) factorial *= BigInt(order);
     const derivative = differentiate2(node, variable, order);
-    const atPoint = chunkHIQ5HSZL_cjs.simplifySymbolic(chunkHIQ5HSZL_cjs.substitute(derivative, variable, pointNode));
+    const atPoint = chunkA2DZ5BEJ_cjs.simplifySymbolic(chunkA2DZ5BEJ_cjs.substitute(derivative, variable, pointNode));
     if (atPoint.kind !== "const") {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.execution(
         "SYMBOLIC_TAYLOR_INEXACT",
         `The derivative of order ${order} does not reduce to an exact number at the expansion point, so this series cannot be computed exactly.`,
         { order }
       );
     }
-    const coefficient = chunkHIQ5HSZL_cjs.rationalDiv(atPoint.value, { n: factorial, d: 1n });
-    if (chunkHIQ5HSZL_cjs.isRationalZero(coefficient)) continue;
-    const shifted = chunkHIQ5HSZL_cjs.isRationalZero(point) ? chunkHIQ5HSZL_cjs.varNode(variable) : { kind: "sub", left: chunkHIQ5HSZL_cjs.varNode(variable), right: pointNode };
-    const power3 = order === 0 ? chunkHIQ5HSZL_cjs.constNode(1) : order === 1 ? shifted : chunkHIQ5HSZL_cjs.powNode(shifted, chunkHIQ5HSZL_cjs.constNode(order));
-    result = { kind: "add", left: result, right: { kind: "mul", left: chunkHIQ5HSZL_cjs.constNode(coefficient), right: power3 } };
+    const coefficient = chunkA2DZ5BEJ_cjs.rationalDiv(atPoint.value, { n: factorial, d: 1n });
+    if (chunkA2DZ5BEJ_cjs.isRationalZero(coefficient)) continue;
+    const shifted = chunkA2DZ5BEJ_cjs.isRationalZero(point) ? chunkA2DZ5BEJ_cjs.varNode(variable) : { kind: "sub", left: chunkA2DZ5BEJ_cjs.varNode(variable), right: pointNode };
+    const power3 = order === 0 ? chunkA2DZ5BEJ_cjs.constNode(1) : order === 1 ? shifted : chunkA2DZ5BEJ_cjs.powNode(shifted, chunkA2DZ5BEJ_cjs.constNode(order));
+    result = { kind: "add", left: result, right: { kind: "mul", left: chunkA2DZ5BEJ_cjs.constNode(coefficient), right: power3 } };
   }
-  return chunkHIQ5HSZL_cjs.simplifySymbolic(result);
+  return chunkA2DZ5BEJ_cjs.simplifySymbolic(result);
 }
 function jacobian(functions, variables) {
   return functions.map((fn) => variables.map((variable) => differentiate2(fn, variable)));
@@ -2176,26 +2199,26 @@ function extremum(args, wantLargest) {
       const bestUnit = best.type === 6 /* Uom */ ? best.unit : void 0;
       const otherUnit = a.type === 6 /* Uom */ ? a.unit : void 0;
       const named = describeMeasureMismatch(bestUnit, otherUnit, "compared");
-      return chunk2TZKENDH_cjs.errorValue(
+      return chunkIT74O4BE_cjs.errorValue(
         "INCOMPATIBLE_UNITS",
         named ?? `Cannot compare incompatible units: ${bestUnit ?? "?"} and ${otherUnit ?? "?"}`
       );
     }
     if (wantLargest ? rv > lv : rv < lv) best = a;
   }
-  if (hasNaN) return chunk2TZKENDH_cjs.numberValue(NaN);
-  if (best === void 0) return chunk2TZKENDH_cjs.numberValue(wantLargest ? -Infinity : Infinity);
-  return best.type === 6 /* Uom */ ? best : chunk2TZKENDH_cjs.numberValue(best.toNumber());
+  if (hasNaN) return chunkIT74O4BE_cjs.numberValue(NaN);
+  if (best === void 0) return chunkIT74O4BE_cjs.numberValue(wantLargest ? -Infinity : Infinity);
+  return best.type === 6 /* Uom */ ? best : chunkIT74O4BE_cjs.numberValue(best.toNumber());
 }
 function keepUnit(operand, magnitude2) {
-  if (operand.type === 6 /* Uom */ && operand.unit !== void 0) return chunk2TZKENDH_cjs.uomValue(magnitude2, operand.unit);
-  return chunk2TZKENDH_cjs.numberValue(magnitude2);
+  if (operand.type === 6 /* Uom */ && operand.unit !== void 0) return chunkIT74O4BE_cjs.uomValue(magnitude2, operand.unit);
+  return chunkIT74O4BE_cjs.numberValue(magnitude2);
 }
 function roundToPlaces(source, places) {
   const p = Number.isFinite(places) ? Math.min(100, Math.max(0, Math.trunc(places))) : 0;
   if (source.exact !== void 0) {
-    const rounded = chunkHIQ5HSZL_cjs.decimalRound(source.exact, p);
-    return withPlaces(source, chunkHIQ5HSZL_cjs.decimalToNumber(rounded), p, rounded);
+    const rounded = chunkA2DZ5BEJ_cjs.decimalRound(source.exact, p);
+    return withPlaces(source, chunkA2DZ5BEJ_cjs.decimalToNumber(rounded), p, rounded);
   }
   const value = source.toNumber();
   if (!Number.isFinite(value)) return withPlaces(source, value, p);
@@ -2205,7 +2228,7 @@ function roundToPlaces(source, places) {
   return withPlaces(source, Math.round(scaled) / scale2, p);
 }
 function withPlaces(source, magnitude2, places, exact) {
-  const result = source.type === 6 /* Uom */ && source.unit !== void 0 ? chunk2TZKENDH_cjs.uomValue(magnitude2, source.unit) : chunk2TZKENDH_cjs.numberValue(magnitude2);
+  const result = source.type === 6 /* Uom */ && source.unit !== void 0 ? chunkIT74O4BE_cjs.uomValue(magnitude2, source.unit) : chunkIT74O4BE_cjs.numberValue(magnitude2);
   result.decimalPlaces = places;
   if (exact !== void 0) result.exact = exact;
   return result;
@@ -2213,7 +2236,7 @@ function withPlaces(source, magnitude2, places, exact) {
 function nonFiniteEuclidOperand(a, b, name) {
   if (Number.isFinite(a) && Number.isFinite(b)) return null;
   const culprit = Number.isFinite(a) ? b : a;
-  return chunk2TZKENDH_cjs.errorValue(
+  return chunkIT74O4BE_cjs.errorValue(
     "INVALID_INTEGER_OPERAND",
     `${name} needs two whole numbers, and ${Number.isNaN(culprit) ? "one of them has no value" : "one of them is infinite"}`
   );
@@ -2235,18 +2258,18 @@ var builtinFunctions = {
   // first, so sqrt(-4) is 2i rather than an approximation.
   0: (args) => {
     const value = args[0].toNumber();
-    if (value >= 0) return chunk2TZKENDH_cjs.numberValue(Math.sqrt(value));
-    return symbolicToValue(chunkHIQ5HSZL_cjs.callNode("sqrt", [chunkHIQ5HSZL_cjs.constNode(value)]));
+    if (value >= 0) return chunkIT74O4BE_cjs.numberValue(Math.sqrt(value));
+    return symbolicToValue(chunkA2DZ5BEJ_cjs.callNode("sqrt", [chunkA2DZ5BEJ_cjs.constNode(value)]));
   },
   // abs(a): for a Matrix, "|a|" (Calca's determinant-pipe notation) is a
   // valid alias for det(a) (index 64), reusing the SAME implementation
   // not a separate one. Plain-number abs is unaffected.
-  1: (args) => args[0].type === 7 /* Matrix */ ? chunkHIQ5HSZL_cjs.determinant(args[0].value) : keepUnit(args[0], Math.abs(args[0].toNumber())),
+  1: (args) => args[0].type === 7 /* Matrix */ ? chunkA2DZ5BEJ_cjs.determinant(args[0].value) : keepUnit(args[0], Math.abs(args[0].toNumber())),
   // sin/cos/tan accept an angle with a unit; see angleInRadians().
-  2: (args) => chunk2TZKENDH_cjs.numberValue(Math.sin(angleInRadians(args[0]))),
-  3: (args) => chunk2TZKENDH_cjs.numberValue(Math.cos(angleInRadians(args[0]))),
-  4: (args) => chunk2TZKENDH_cjs.numberValue(Math.tan(angleInRadians(args[0]))),
-  5: (args) => chunk2TZKENDH_cjs.numberValue(Math.log(args[0].toNumber())),
+  2: (args) => chunkIT74O4BE_cjs.numberValue(Math.sin(angleInRadians(args[0]))),
+  3: (args) => chunkIT74O4BE_cjs.numberValue(Math.cos(angleInRadians(args[0]))),
+  4: (args) => chunkIT74O4BE_cjs.numberValue(Math.tan(angleInRadians(args[0]))),
+  5: (args) => chunkIT74O4BE_cjs.numberValue(Math.log(args[0].toNumber())),
   // round/ceil/floor keep a unit for the same reason abs does; see keepUnit().
   6: (args) => keepUnit(args[0], Math.ceil(args[0].toNumber())),
   7: (args) => keepUnit(args[0], Math.floor(args[0].toNumber())),
@@ -2261,31 +2284,31 @@ var builtinFunctions = {
   // rather than as a running number.
   9: (args) => extremum(args, false),
   10: (args) => extremum(args, true),
-  11: (args) => chunk2TZKENDH_cjs.numberValue(Math.asin(args[0].toNumber())),
-  12: (args) => chunk2TZKENDH_cjs.numberValue(Math.acos(args[0].toNumber())),
-  13: (args) => chunk2TZKENDH_cjs.numberValue(Math.atan(args[0].toNumber())),
-  14: (args) => chunk2TZKENDH_cjs.numberValue(Math.atan2(args[0].toNumber(), args[1].toNumber())),
-  15: (args) => chunk2TZKENDH_cjs.numberValue(Math.sinh(args[0].toNumber())),
-  16: (args) => chunk2TZKENDH_cjs.numberValue(Math.cosh(args[0].toNumber())),
-  17: (args) => chunk2TZKENDH_cjs.numberValue(Math.tanh(args[0].toNumber())),
-  18: (args) => chunk2TZKENDH_cjs.numberValue(Math.asinh(args[0].toNumber())),
-  19: (args) => chunk2TZKENDH_cjs.numberValue(Math.acosh(args[0].toNumber())),
-  20: (args) => chunk2TZKENDH_cjs.numberValue(Math.atanh(args[0].toNumber())),
-  21: (args) => chunk2TZKENDH_cjs.numberValue(Math.cbrt(args[0].toNumber())),
-  22: (args) => chunk2TZKENDH_cjs.numberValue(Math.clz32(args[0].toNumber())),
-  23: (args) => chunk2TZKENDH_cjs.numberValue(Math.expm1(args[0].toNumber())),
-  24: (args) => chunk2TZKENDH_cjs.numberValue(Math.exp(args[0].toNumber())),
-  25: (args) => chunk2TZKENDH_cjs.numberValue(Math.fround(args[0].toNumber())),
+  11: (args) => chunkIT74O4BE_cjs.numberValue(Math.asin(args[0].toNumber())),
+  12: (args) => chunkIT74O4BE_cjs.numberValue(Math.acos(args[0].toNumber())),
+  13: (args) => chunkIT74O4BE_cjs.numberValue(Math.atan(args[0].toNumber())),
+  14: (args) => chunkIT74O4BE_cjs.numberValue(Math.atan2(args[0].toNumber(), args[1].toNumber())),
+  15: (args) => chunkIT74O4BE_cjs.numberValue(Math.sinh(args[0].toNumber())),
+  16: (args) => chunkIT74O4BE_cjs.numberValue(Math.cosh(args[0].toNumber())),
+  17: (args) => chunkIT74O4BE_cjs.numberValue(Math.tanh(args[0].toNumber())),
+  18: (args) => chunkIT74O4BE_cjs.numberValue(Math.asinh(args[0].toNumber())),
+  19: (args) => chunkIT74O4BE_cjs.numberValue(Math.acosh(args[0].toNumber())),
+  20: (args) => chunkIT74O4BE_cjs.numberValue(Math.atanh(args[0].toNumber())),
+  21: (args) => chunkIT74O4BE_cjs.numberValue(Math.cbrt(args[0].toNumber())),
+  22: (args) => chunkIT74O4BE_cjs.numberValue(Math.clz32(args[0].toNumber())),
+  23: (args) => chunkIT74O4BE_cjs.numberValue(Math.expm1(args[0].toNumber())),
+  24: (args) => chunkIT74O4BE_cjs.numberValue(Math.exp(args[0].toNumber())),
+  25: (args) => chunkIT74O4BE_cjs.numberValue(Math.fround(args[0].toNumber())),
   // hypot: left as .map()+spread (unlike min/max above), Math.hypot uses
   // a numerically-stable scaling algorithm internally to avoid overflow
   // for very large/small inputs; a naive manual reimplementation risks
   // silently changing results at the extremes, so the tiny array
   // allocation here is the safer trade.
-  26: (args) => chunk2TZKENDH_cjs.numberValue(Math.hypot(...args.map((a) => a.toNumber()))),
-  27: (args) => chunk2TZKENDH_cjs.numberValue(Math.imul(args[0].toNumber(), args[1].toNumber())),
-  28: (args) => chunk2TZKENDH_cjs.numberValue(Math.log10(args[0].toNumber())),
-  29: (args) => chunk2TZKENDH_cjs.numberValue(Math.log1p(args[0].toNumber())),
-  30: (args) => chunk2TZKENDH_cjs.numberValue(Math.log2(args[0].toNumber())),
+  26: (args) => chunkIT74O4BE_cjs.numberValue(Math.hypot(...args.map((a) => a.toNumber()))),
+  27: (args) => chunkIT74O4BE_cjs.numberValue(Math.imul(args[0].toNumber(), args[1].toNumber())),
+  28: (args) => chunkIT74O4BE_cjs.numberValue(Math.log10(args[0].toNumber())),
+  29: (args) => chunkIT74O4BE_cjs.numberValue(Math.log1p(args[0].toNumber())),
+  30: (args) => chunkIT74O4BE_cjs.numberValue(Math.log2(args[0].toNumber())),
   // pow(): the spelled-out form of `^`, so a Matrix base means the same
   // repeated matrix multiplication `^` means. Without this branch
   // `pow([1,2;3,4], 2)` was Math.pow of a value whose toNumber() is 0, and
@@ -2293,21 +2316,21 @@ var builtinFunctions = {
   31: (args) => {
     if (args[0].type === 7 /* Matrix */) {
       if (args[1].type !== 0 /* Number */) {
-        return chunk2TZKENDH_cjs.errorValue("MATRIX_POWER_UNSUPPORTED", `pow: a matrix's exponent must be a whole number, as in "pow([1,2;3,4], 2)".`);
+        return chunkIT74O4BE_cjs.errorValue("MATRIX_POWER_UNSUPPORTED", `pow: a matrix's exponent must be a whole number, as in "pow([1,2;3,4], 2)".`);
       }
-      return chunkHIQ5HSZL_cjs.matrixPower(args[0].value, args[1].value);
+      return chunkA2DZ5BEJ_cjs.matrixPower(args[0].value, args[1].value);
     }
     if (args[1].type === 7 /* Matrix */) {
-      return chunk2TZKENDH_cjs.errorValue("MATRIX_POWER_UNSUPPORTED", `pow: a matrix may only be the base, as in "pow([1,2;3,4], 2)".`);
+      return chunkIT74O4BE_cjs.errorValue("MATRIX_POWER_UNSUPPORTED", `pow: a matrix may only be the base, as in "pow([1,2;3,4], 2)".`);
     }
-    return chunk2TZKENDH_cjs.numberValue(power(args[0].toNumber(), args[1].toNumber()));
+    return chunkIT74O4BE_cjs.numberValue(power(args[0].toNumber(), args[1].toNumber()));
   },
-  32: () => chunk2TZKENDH_cjs.numberValue(Math.random()),
+  32: () => chunkIT74O4BE_cjs.numberValue(Math.random()),
   // takes no arguments, unlike its neighbours
-  33: (args) => chunk2TZKENDH_cjs.numberValue(Math.sign(args[0].toNumber())),
-  34: (args) => chunk2TZKENDH_cjs.numberValue(Math.trunc(args[0].toNumber())),
-  35: (args) => chunk2TZKENDH_cjs.numberValue(args[0].toNumber() * Math.PI / 180),
-  36: (args) => chunk2TZKENDH_cjs.numberValue(args[0].toNumber() * 180 / Math.PI),
+  33: (args) => chunkIT74O4BE_cjs.numberValue(Math.sign(args[0].toNumber())),
+  34: (args) => chunkIT74O4BE_cjs.numberValue(Math.trunc(args[0].toNumber())),
+  35: (args) => chunkIT74O4BE_cjs.numberValue(args[0].toNumber() * Math.PI / 180),
+  36: (args) => chunkIT74O4BE_cjs.numberValue(args[0].toNumber() * 180 / Math.PI),
   // 37: diceRoll(from, to), random integer in range [from, to] inclusive.
   // A reversed range (from > to) used to silently produce values outside
   // [to, from] via a negative-length Math.random() spread (e.g.
@@ -2317,9 +2340,9 @@ var builtinFunctions = {
     const from = args[0].toNumber();
     const to = args[1].toNumber();
     if (from > to) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `roll: invalid range, ${from} is greater than ${to}`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `roll: invalid range, ${from} is greater than ${to}`);
     }
-    return chunk2TZKENDH_cjs.numberValue(Math.floor(Math.random() * (to - from + 1)) + from);
+    return chunkIT74O4BE_cjs.numberValue(Math.floor(Math.random() * (to - from + 1)) + from);
   },
   // gcd(a, b), Euclidean algorithm. Negative inputs are treated by
   // magnitude (gcd is conventionally defined over non-negative integers).
@@ -2328,7 +2351,7 @@ var builtinFunctions = {
     const b = Math.trunc(Math.abs(args[1].toNumber()));
     const nonFinite = nonFiniteEuclidOperand(a, b, "gcd");
     if (nonFinite) return nonFinite;
-    return chunk2TZKENDH_cjs.numberValue(euclidGcd(a, b));
+    return chunkIT74O4BE_cjs.numberValue(euclidGcd(a, b));
   },
   // lcm(a, b) = |a*b| / gcd(a, b), via the same Euclidean gcd inline
   // (a standalone gcd() call site, no shared helper needed for two uses).
@@ -2337,8 +2360,8 @@ var builtinFunctions = {
     const b = Math.trunc(Math.abs(args[1].toNumber()));
     const nonFinite = nonFiniteEuclidOperand(a, b, "lcm");
     if (nonFinite) return nonFinite;
-    if (a === 0 || b === 0) return chunk2TZKENDH_cjs.numberValue(0);
-    return chunk2TZKENDH_cjs.numberValue(a / euclidGcd(a, b) * b);
+    if (a === 0 || b === 0) return chunkIT74O4BE_cjs.numberValue(0);
+    return chunkIT74O4BE_cjs.numberValue(a / euclidGcd(a, b) * b);
   },
   // permutation(n, r) = n! / (n-r)!, computed as a running product
   // rather than two full factorials, so it stays exact for n well
@@ -2359,19 +2382,19 @@ var builtinFunctions = {
     const n = Math.trunc(args[0].toNumber());
     const r = Math.trunc(args[1].toNumber());
     if (n < 0 || r < 0 || r > n) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `permutation: invalid n=${n}, r=${r} (require 0 <= r <= n)`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `permutation: invalid n=${n}, r=${r} (require 0 <= r <= n)`);
     }
     let result = 1;
     for (let i = 0; i < r; i++) {
       result *= n - i;
       if (!Number.isFinite(result)) {
-        return chunk2TZKENDH_cjs.errorValue(
+        return chunkIT74O4BE_cjs.errorValue(
           "PERMUTATION_OVERFLOW",
           `permutation: P(${n}, ${r}) exceeds the maximum representable double (it passed it after ${i + 1} of ${r} factors)`
         );
       }
     }
-    return chunk2TZKENDH_cjs.numberValue(result);
+    return chunkIT74O4BE_cjs.numberValue(result);
   },
   // combination(n, r) = n! / (r! * (n-r)!), multiply-then-divide one
   // step at a time (standard technique) keeps every intermediate result
@@ -2387,42 +2410,42 @@ var builtinFunctions = {
     const n = Math.trunc(args[0].toNumber());
     const r = Math.trunc(args[1].toNumber());
     if (n < 0 || r < 0 || r > n) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `combination: invalid n=${n}, r=${r} (require 0 <= r <= n)`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `combination: invalid n=${n}, r=${r} (require 0 <= r <= n)`);
     }
     const k = Math.min(r, n - r);
     let result = 1;
     for (let i = 0; i < k; i++) {
       result = result * (n - i) / (i + 1);
       if (!Number.isFinite(result)) {
-        return chunk2TZKENDH_cjs.errorValue(
+        return chunkIT74O4BE_cjs.errorValue(
           "COMBINATION_OVERFLOW",
           `combination: C(${n}, ${r}) exceeds the maximum representable double (it passed it after ${i + 1} of ${k} steps)`
         );
       }
     }
-    return chunk2TZKENDH_cjs.numberValue(Math.round(result));
+    return chunkIT74O4BE_cjs.numberValue(Math.round(result));
   },
   // average(...), arithmetic mean of any number of arguments. Backs the
   // MathPhrases package's "average of X, Y, Z" (packages/mathphrases/).
   42: (args) => {
-    if (args.length === 0) return chunk2TZKENDH_cjs.numberValue(0);
+    if (args.length === 0) return chunkIT74O4BE_cjs.numberValue(0);
     const sum = args.reduce((acc, a) => acc + a.toNumber(), 0);
-    return chunk2TZKENDH_cjs.numberValue(sum / args.length);
+    return chunkIT74O4BE_cjs.numberValue(sum / args.length);
   },
   // median(...), middle value; average of the two middle values for an
   // even argument count.
   43: (args) => {
-    if (args.length === 0) return chunk2TZKENDH_cjs.numberValue(0);
+    if (args.length === 0) return chunkIT74O4BE_cjs.numberValue(0);
     const sorted = args.map((a) => a.toNumber()).sort((a, b) => a - b);
     const mid = Math.floor(sorted.length / 2);
-    return chunk2TZKENDH_cjs.numberValue(
+    return chunkIT74O4BE_cjs.numberValue(
       sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid]
     );
   },
   // total(...), sum of any number of arguments.
-  44: (args) => chunk2TZKENDH_cjs.numberValue(args.reduce((acc, a) => acc + a.toNumber(), 0)),
+  44: (args) => chunkIT74O4BE_cjs.numberValue(args.reduce((acc, a) => acc + a.toNumber(), 0)),
   // count(...), number of arguments passed.
-  45: (args) => chunk2TZKENDH_cjs.numberValue(args.length),
+  45: (args) => chunkIT74O4BE_cjs.numberValue(args.length),
   // proportion(a, b, c) -> d such that a:b = c:d, i.e. d = c * (b/a)
   // "A is to B as C is to what". Unit-aware via unifyUom: "5 km is to
   // 500m as 5 cm is to what" unifies 5km/500m to a 10:1 ratio (500m ==
@@ -2433,10 +2456,10 @@ var builtinFunctions = {
     const [a, b, c] = args;
     const { lv: aNum, rv: bNum } = unifyUom(a, b);
     if (aNum === 0) {
-      return chunk2TZKENDH_cjs.errorValue("PROPORTION_DIVIDE_BY_ZERO", `Cannot compute proportion: "${a.value}" is zero`);
+      return chunkIT74O4BE_cjs.errorValue("PROPORTION_DIVIDE_BY_ZERO", `Cannot compute proportion: "${a.value}" is zero`);
     }
     const result = c.toNumber() * (bNum / aNum);
-    return c.type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(result, c.unit) : chunk2TZKENDH_cjs.numberValue(result);
+    return c.type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(result, c.unit) : chunkIT74O4BE_cjs.numberValue(result);
   },
   // clamp(value, lo, hi), restrict value to [lo, hi]. Backs
   // "clamp X between Y and Z" / "clamp X from Y to Z".
@@ -2445,9 +2468,9 @@ var builtinFunctions = {
     const lo = args[1].toNumber();
     const hi = args[2].toNumber();
     if (lo > hi) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `clamp: invalid range, ${lo} is greater than ${hi}`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `clamp: invalid range, ${lo} is greater than ${hi}`);
     }
-    return chunk2TZKENDH_cjs.numberValue(Math.min(Math.max(value, lo), hi));
+    return chunkIT74O4BE_cjs.numberValue(Math.min(Math.max(value, lo), hi));
   },
   // hex(n), Python/JS-style call-syntax hex formatting, e.g. hex(255) ->
   // "0xFF". Distinct from the Converters package's `255 as hex` (see
@@ -2457,16 +2480,16 @@ var builtinFunctions = {
   // function call that returns an ordinary String value, matching
   // Python's hex()/JS convention of a function returning display text,
   // not a numeric type.
-  48: (args) => chunk2TZKENDH_cjs.hexValue(args[0].toNumber()),
+  48: (args) => chunkIT74O4BE_cjs.hexValue(args[0].toNumber()),
   // bin(n). Same call-syntax shape as hex() above, e.g. bin(10) -> "0b1010".
-  49: (args) => chunk2TZKENDH_cjs.hexValue(args[0].toNumber(), "bin"),
+  49: (args) => chunkIT74O4BE_cjs.hexValue(args[0].toNumber(), "bin"),
   // int(x), coerce ANY value (Number, Percentage, Uom, String, Hex, ...)
   // to a plain integer Number, truncating any fractional part toward
   // zero (Math.trunc semantics: int(5.7) -> 5, int(-5.7) -> -5). Distinct
   // from the Converters package's `x as number` (TO_NUMBER opcode),
   // which only strips a unit/percentage wrapper and keeps any decimal
   // part (e.g. "5.7 as number" -> 5.7), int() additionally truncates.
-  50: (args) => chunk2TZKENDH_cjs.numberValue(Math.trunc(args[0].toNumber())),
+  50: (args) => chunkIT74O4BE_cjs.numberValue(Math.trunc(args[0].toNumber())),
   // ── Finance (packages/finance/) ──────────────────────────────────────
   // All finance builtins preserve the principal/amount argument's Uom
   // unit (e.g. a currency like "$") onto the result, matching
@@ -2487,10 +2510,10 @@ var builtinFunctions = {
     const rate = args[1].toNumber();
     const years = args[2].toNumber();
     if (1 + rate <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `compoundInterest: rate ${rate} makes (1 + rate) non-positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `compoundInterest: rate ${rate} makes (1 + rate) non-positive`);
     }
     const fv = principal * Math.pow(1 + rate, years);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(fv, args[0].unit) : chunk2TZKENDH_cjs.numberValue(fv);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(fv, args[0].unit) : chunkIT74O4BE_cjs.numberValue(fv);
   },
   // compoundInterestEarned(principal, rate, years) -> FV - principal, the
   // interest-only portion. Backs "interest on $P over Y years at R%" and
@@ -2500,10 +2523,10 @@ var builtinFunctions = {
     const rate = args[1].toNumber();
     const years = args[2].toNumber();
     if (1 + rate <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `interestEarned: rate ${rate} makes (1 + rate) non-positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `interestEarned: rate ${rate} makes (1 + rate) non-positive`);
     }
     const interest = principal * (Math.pow(1 + rate, years) - 1);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(interest, args[0].unit) : chunk2TZKENDH_cjs.numberValue(interest);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(interest, args[0].unit) : chunkIT74O4BE_cjs.numberValue(interest);
   },
   // compoundInterestRate(principal, futureValue, years) -> the rate (as a
   // decimal fraction) needed to grow principal to futureValue over years.
@@ -2515,12 +2538,12 @@ var builtinFunctions = {
     const futureValue = args[1].toNumber();
     const years = args[2].toNumber();
     if (principal <= 0 || futureValue <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `compoundInterestRate: principal and futureValue must both be positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `compoundInterestRate: principal and futureValue must both be positive`);
     }
     if (years <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `compoundInterestRate: years must be greater than 0`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `compoundInterestRate: years must be greater than 0`);
     }
-    return chunk2TZKENDH_cjs.numberValue(Math.pow(futureValue / principal, 1 / years) - 1);
+    return chunkIT74O4BE_cjs.numberValue(Math.pow(futureValue / principal, 1 / years) - 1);
   },
   // compoundInterestYears(principal, futureValue, rate) -> the number of
   // years needed to grow principal to futureValue at a fixed rate.
@@ -2530,12 +2553,12 @@ var builtinFunctions = {
     const futureValue = args[1].toNumber();
     const rate = args[2].toNumber();
     if (principal <= 0 || futureValue <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `compoundInterestYears: principal and futureValue must both be positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `compoundInterestYears: principal and futureValue must both be positive`);
     }
     if (1 + rate <= 0 || rate === 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `compoundInterestYears: rate ${rate} is not usable (must be > -1 and not 0)`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `compoundInterestYears: rate ${rate} is not usable (must be > -1 and not 0)`);
     }
-    return chunk2TZKENDH_cjs.numberValue(Math.log(futureValue / principal) / Math.log(1 + rate));
+    return chunkIT74O4BE_cjs.numberValue(Math.log(futureValue / principal) / Math.log(1 + rate));
   },
   // loanRepayment(principal, rate, years, periodsPerYear), standard
   // amortizing-loan repayment (mortgage formula), redistributed evenly
@@ -2553,13 +2576,13 @@ var builtinFunctions = {
     const rate = args[1].toNumber();
     const years = args[2].toNumber();
     const periodsPerYear = args[3].toNumber();
-    if (principal <= 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `loanRepayment: principal must be positive`);
-    if (years <= 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `loanRepayment: years must be positive`);
-    if (rate < 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `loanRepayment: rate must not be negative`);
-    if (periodsPerYear < 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `loanRepayment: periodsPerYear must not be negative`);
+    if (principal <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `loanRepayment: principal must be positive`);
+    if (years <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `loanRepayment: years must be positive`);
+    if (rate < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `loanRepayment: rate must not be negative`);
+    if (periodsPerYear < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `loanRepayment: periodsPerYear must not be negative`);
     const { totalRepayment } = amortizeLoan(principal, rate, years);
     const result = periodsPerYear === 0 ? totalRepayment : totalRepayment / (years * periodsPerYear);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(result, args[0].unit) : chunk2TZKENDH_cjs.numberValue(result);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(result, args[0].unit) : chunkIT74O4BE_cjs.numberValue(result);
   },
   // loanInterest(principal, rate, years, periodsPerYear), the interest
   // portion of index 55's repayment, same periodsPerYear convention.
@@ -2569,13 +2592,13 @@ var builtinFunctions = {
     const rate = args[1].toNumber();
     const years = args[2].toNumber();
     const periodsPerYear = args[3].toNumber();
-    if (principal <= 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `loanInterest: principal must be positive`);
-    if (years <= 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `loanInterest: years must be positive`);
-    if (rate < 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `loanInterest: rate must not be negative`);
-    if (periodsPerYear < 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `loanInterest: periodsPerYear must not be negative`);
+    if (principal <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `loanInterest: principal must be positive`);
+    if (years <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `loanInterest: years must be positive`);
+    if (rate < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `loanInterest: rate must not be negative`);
+    if (periodsPerYear < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `loanInterest: periodsPerYear must not be negative`);
     const { totalInterest } = amortizeLoan(principal, rate, years);
     const result = periodsPerYear === 0 ? totalInterest : totalInterest / (years * periodsPerYear);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(result, args[0].unit) : chunk2TZKENDH_cjs.numberValue(result);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(result, args[0].unit) : chunkIT74O4BE_cjs.numberValue(result);
   },
   // monthlyPayment(principal, rate, years), convenience 3-arg wrapper
   // around index 55's monthly case, for direct function-call use without
@@ -2584,11 +2607,11 @@ var builtinFunctions = {
     const principal = args[0].toNumber();
     const rate = args[1].toNumber();
     const years = args[2].toNumber();
-    if (principal <= 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `monthlyPayment: principal must be positive`);
-    if (years <= 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RANGE", `monthlyPayment: years must be positive`);
-    if (rate < 0) return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `monthlyPayment: rate must not be negative`);
+    if (principal <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `monthlyPayment: principal must be positive`);
+    if (years <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `monthlyPayment: years must be positive`);
+    if (rate < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `monthlyPayment: rate must not be negative`);
     const { monthlyPayment } = amortizeLoan(principal, rate, years);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(monthlyPayment, args[0].unit) : chunk2TZKENDH_cjs.numberValue(monthlyPayment);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(monthlyPayment, args[0].unit) : chunkIT74O4BE_cjs.numberValue(monthlyPayment);
   },
   // taxAdd(amount, rate) -> amount * (1 + rate), the tax-inclusive total.
   // Backs the taxAdd() function-call form, whose name promises exactly this.
@@ -2601,7 +2624,7 @@ var builtinFunctions = {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
     if (args[0].type === 6 /* Uom */) return scaleMoneyByPercent(args[0], args[0].unit, rate, 1);
-    return chunk2TZKENDH_cjs.numberValue(amount * (1 + rate));
+    return chunkIT74O4BE_cjs.numberValue(amount * (1 + rate));
   },
   // taxRemove(amount, rate) -> amount / (1 + rate), extracts the
   // pre-tax amount from a tax-INCLUSIVE total. Backs "tax off $X at R%" /
@@ -2610,12 +2633,12 @@ var builtinFunctions = {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
     if (1 + rate <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `taxRemove: rate ${rate} makes (1 + rate) non-positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `taxRemove: rate ${rate} makes (1 + rate) non-positive`);
     }
     if (args[0].type === 6 /* Uom */) {
-      return removeTaxExact(args[0], args[0].unit, rate) ?? chunk2TZKENDH_cjs.uomValue(amount / (1 + rate), args[0].unit);
+      return removeTaxExact(args[0], args[0].unit, rate) ?? chunkIT74O4BE_cjs.uomValue(amount / (1 + rate), args[0].unit);
     }
-    return chunk2TZKENDH_cjs.numberValue(amount / (1 + rate));
+    return chunkIT74O4BE_cjs.numberValue(amount / (1 + rate));
   },
   // inflationAdjust(amount, fromYear, toYear) -- CPI-based inflation
   // adjustment between two arbitrary years, using the bundled CPI-U
@@ -2635,13 +2658,13 @@ var builtinFunctions = {
     const toYear = args[2].toNumber();
     const ratio = inflationRatio(fromYear, toYear);
     if (ratio === void 0) {
-      return chunk2TZKENDH_cjs.errorValue(
+      return chunkIT74O4BE_cjs.errorValue(
         "INFLATION_YEAR_OUT_OF_RANGE",
         `inflationAdjust: fromYear ${fromYear} or toYear ${toYear} is outside the bundled CPI table's range (${CPI_MIN_YEAR}-${CPI_MAX_YEAR})`
       );
     }
     const result = amount * ratio;
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(result, args[0].unit) : chunk2TZKENDH_cjs.numberValue(result);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(result, args[0].unit) : chunkIT74O4BE_cjs.numberValue(result);
   },
   // root(n, x) -- the n-th root of x (Numi's `root n (x)` phrasing maps
   // to this same call-style form; see FunctionCallParselet's name map).
@@ -2652,7 +2675,7 @@ var builtinFunctions = {
   61: (args) => {
     const n = args[0].toNumber();
     const x = args[1].toNumber();
-    return chunk2TZKENDH_cjs.numberValue(power(x, 1 / n));
+    return chunkIT74O4BE_cjs.numberValue(power(x, 1 / n));
   },
   // fact(n) / factorial(n) -- integer factorial. Deliberately rejects
   // negative or non-integer input (factorial isn't defined for either
@@ -2663,14 +2686,14 @@ var builtinFunctions = {
   62: (args) => {
     const n = args[0].toNumber();
     if (!Number.isInteger(n) || n < 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_FACTORIAL_INPUT", `fact: ${n} is not a non-negative integer`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_FACTORIAL_INPUT", `fact: ${n} is not a non-negative integer`);
     }
     if (n > 170) {
-      return chunk2TZKENDH_cjs.errorValue("FACTORIAL_OVERFLOW", `fact: ${n}! exceeds the maximum representable double (170! is the largest finite factorial)`);
+      return chunkIT74O4BE_cjs.errorValue("FACTORIAL_OVERFLOW", `fact: ${n}! exceeds the maximum representable double (170! is the largest finite factorial)`);
     }
     let result = 1;
     for (let i = 2; i <= n; i++) result *= i;
-    return chunk2TZKENDH_cjs.numberValue(result);
+    return chunkIT74O4BE_cjs.numberValue(result);
   },
   // ── Matrix (packages/matrix/) ────────────────────────────────────────
   // transpose(a)/det(a)/inv(a)/dot(a,b), reachable both via ordinary
@@ -2683,17 +2706,17 @@ var builtinFunctions = {
   // own transpose (a 1x1 "matrix" transposed is itself), matches this
   // engine's existing convention of treating a scalar as a trivial 1x1
   // matrix (see Value.ts's toNumber()/isNaN() 1x1 special case).
-  63: (args) => args[0].type === 7 /* Matrix */ ? chunkHIQ5HSZL_cjs.transpose(args[0].value) : args[0],
+  63: (args) => args[0].type === 7 /* Matrix */ ? chunkA2DZ5BEJ_cjs.transpose(args[0].value) : args[0],
   // det(a), determinant. A plain Number's "determinant" is itself (the
   // determinant of a 1x1 matrix [x] is x).
-  64: (args) => args[0].type === 7 /* Matrix */ ? chunkHIQ5HSZL_cjs.determinant(args[0].value) : chunk2TZKENDH_cjs.numberValue(args[0].toNumber()),
+  64: (args) => args[0].type === 7 /* Matrix */ ? chunkA2DZ5BEJ_cjs.determinant(args[0].value) : chunkIT74O4BE_cjs.numberValue(args[0].toNumber()),
   // inv(a), matrix inverse for a Matrix; for a plain Number, `1/x`
   // (byte-identical to `Math.pow(x, -1)`, which is what `x^-1` computed
   // before this feature existed. See PrecedenceParser.ts's `^-1`
   // special-case doc comment for why this must stay exact).
   65: (args) => {
-    if (args[0].type === 7 /* Matrix */) return chunkHIQ5HSZL_cjs.inverse(args[0].value);
-    return chunk2TZKENDH_cjs.numberValue(1 / args[0].toNumber());
+    if (args[0].type === 7 /* Matrix */) return chunkA2DZ5BEJ_cjs.inverse(args[0].value);
+    return chunkIT74O4BE_cjs.numberValue(1 / args[0].toNumber());
   },
   // dot(a, b), matrix product / scalar-broadcast, the SAME dispatch as
   // the `*` operator between two matrices (vm/VM.ts's MUL case). Plain
@@ -2703,10 +2726,10 @@ var builtinFunctions = {
   66: (args) => {
     const [a, b] = args;
     if (a.type === 0 /* Number */ && b.type === 0 /* Number */) {
-      return chunk2TZKENDH_cjs.numberValue(a.toNumber() * b.toNumber());
+      return chunkIT74O4BE_cjs.numberValue(a.toNumber() * b.toNumber());
     }
     const toMatrix = (v) => v.type === 7 /* Matrix */ ? v.value : { rows: 1, cols: 1, data: [v.toNumber()], hasSymbolic: false };
-    return chunkHIQ5HSZL_cjs.matrixMultiply(toMatrix(a), toMatrix(b));
+    return chunkA2DZ5BEJ_cjs.matrixMultiply(toMatrix(a), toMatrix(b));
   },
   // ── Symbolic algebra (packages/symbolic/) ──
   // expand(expr), multiplying out every product and power. Reached only
@@ -2720,7 +2743,7 @@ var builtinFunctions = {
   67: (args) => {
     const [value] = args;
     if (value.type !== 9 /* Symbolic */) return value;
-    return symbolicToValue(chunkHIQ5HSZL_cjs.expandSymbolic(value.value));
+    return symbolicToValue(chunkA2DZ5BEJ_cjs.expandSymbolic(value.value));
   },
   // factor(expr), writing a polynomial as a product of irreducible factors
   // over the RATIONALS. x^2-2 and x^2+1 come back unchanged, which is the
@@ -2737,7 +2760,7 @@ var builtinFunctions = {
   69: (args) => {
     const [lhsValue, rhsValue, variableValue] = args;
     if (variableValue?.type !== 3 /* String */) {
-      return chunk2TZKENDH_cjs.errorValue("SOLVE_REQUIRES_VARIABLE_NAME", "solve's second argument must be the name of the unknown.");
+      return chunkIT74O4BE_cjs.errorValue("SOLVE_REQUIRES_VARIABLE_NAME", "solve's second argument must be the name of the unknown.");
     }
     return solveEquationValues(lhsValue, rhsValue, variableValue.value);
   },
@@ -2748,7 +2771,7 @@ var builtinFunctions = {
     const variable = symbolicVariableName(variableValue, "der");
     if (typeof variable !== "string") return variable;
     const expression = valueToSymbolic(target);
-    if (expression === null) return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "der needs an expression with an exact value.");
+    if (expression === null) return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "der needs an expression with an exact value.");
     return symbolicToValue(differentiate2(expression, variable, orderValue?.toNumber() ?? 1));
   },
   // integral(expr, variable), the indefinite integral without a constant of
@@ -2759,9 +2782,9 @@ var builtinFunctions = {
     const variable = symbolicVariableName(variableValue, "integral");
     if (typeof variable !== "string") return variable;
     const expression = valueToSymbolic(target);
-    if (expression === null) return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "integral needs an expression with an exact value.");
+    if (expression === null) return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "integral needs an expression with an exact value.");
     const result = integrate(expression, variable);
-    if (!result.ok) return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_INTEGRAL_UNSUPPORTED", `Cannot integrate this: ${result.reason}.`);
+    if (!result.ok) return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_INTEGRAL_UNSUPPORTED", `Cannot integrate this: ${result.reason}.`);
     return symbolicToValue(result.value);
   },
   // taylor(expr, variable = point, degree).
@@ -2772,7 +2795,7 @@ var builtinFunctions = {
     const expression = valueToSymbolic(target);
     const point = valueToSymbolic(pointValue);
     if (expression === null || point === null || point.kind !== "const") {
-      return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "taylor needs an expression and an exact expansion point.");
+      return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "taylor needs an expression and an exact expansion point.");
     }
     return symbolicToValue(taylorSeries(expression, variable, point.value, degreeValue.toNumber()));
   },
@@ -2782,23 +2805,23 @@ var builtinFunctions = {
     const functions = [];
     for (const arg of args) {
       const node = valueToSymbolic(arg);
-      if (node === null) return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "jacobian needs expressions with exact values.");
+      if (node === null) return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", "jacobian needs expressions with exact values.");
       functions.push(node);
     }
     const variables = /* @__PURE__ */ new Set();
-    for (const fn of functions) for (const name of chunkHIQ5HSZL_cjs.freeVariables(fn)) variables.add(name);
+    for (const fn of functions) for (const name of chunkA2DZ5BEJ_cjs.freeVariables(fn)) variables.add(name);
     const sorted = [...variables].sort();
-    if (sorted.length === 0) return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_JACOBIAN_NO_VARIABLES", "jacobian needs at least one unknown to differentiate against.");
+    if (sorted.length === 0) return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_JACOBIAN_NO_VARIABLES", "jacobian needs at least one unknown to differentiate against.");
     const rows = jacobian(functions, sorted);
     const rowMajor = [];
     for (const row of rows) {
-      for (const cell of row) rowMajor.push(chunkHIQ5HSZL_cjs.symbolicToEntry(cell));
+      for (const cell of row) rowMajor.push(chunkA2DZ5BEJ_cjs.symbolicToEntry(cell));
     }
-    return chunk2TZKENDH_cjs.matrixValue(rows.length, sorted.length, chunkHIQ5HSZL_cjs.rowMajorToColumnMajor(rows.length, sorted.length, rowMajor));
+    return chunkIT74O4BE_cjs.matrixValue(rows.length, sorted.length, chunkA2DZ5BEJ_cjs.rowMajorToColumnMajor(rows.length, sorted.length, rowMajor));
   },
   // An imaginary literal, 3i. The parselet pushes the numeric part and this
   // turns it into an exact imaginary value.
-  74: (args) => symbolicToValue(chunkHIQ5HSZL_cjs.complexNode(chunkHIQ5HSZL_cjs.complex(chunkHIQ5HSZL_cjs.RATIONAL_ZERO, chunkHIQ5HSZL_cjs.rationalFromNumber(args[0].toNumber())))),
+  74: (args) => symbolicToValue(chunkA2DZ5BEJ_cjs.complexNode(chunkA2DZ5BEJ_cjs.complex(chunkA2DZ5BEJ_cjs.RATIONAL_ZERO, chunkA2DZ5BEJ_cjs.rationalFromNumber(args[0].toNumber())))),
   // conj(z), re(z) and im(z). Each folds immediately for a literal and stays
   // symbolic for anything still carrying an unknown.
   75: (args) => applyComplexAccessor("conj", args[0]),
@@ -2808,7 +2831,7 @@ var builtinFunctions = {
   78: (args) => {
     const value = args[0];
     if (value.type !== 9 /* Symbolic */) return value;
-    return symbolicToValue(chunkHIQ5HSZL_cjs.cancelSymbolic(value.value));
+    return symbolicToValue(chunkA2DZ5BEJ_cjs.cancelSymbolic(value.value));
   },
   // apart(expr), the partial-fraction decomposition of a rational function.
   79: (args) => {
@@ -2823,13 +2846,13 @@ var builtinFunctions = {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
     if (1 + rate <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `taxIn: rate ${rate} makes (1 + rate) non-positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `taxIn: rate ${rate} makes (1 + rate) non-positive`);
     }
     const tax = amount - amount / (1 + rate);
     if (args[0].type === 6 /* Uom */) {
-      return taxInExact(args[0], args[0].unit, rate) ?? chunk2TZKENDH_cjs.uomValue(tax, args[0].unit);
+      return taxInExact(args[0], args[0].unit, rate) ?? chunkIT74O4BE_cjs.uomValue(tax, args[0].unit);
     }
-    return chunk2TZKENDH_cjs.numberValue(tax);
+    return chunkIT74O4BE_cjs.numberValue(tax);
   },
   // taxOn(amount, rate) -> amount * rate, the tax itself.
   //
@@ -2842,21 +2865,21 @@ var builtinFunctions = {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
     if (args[0].type === 6 /* Uom */) return scaleMoneyExact(args[0], rate, args[0].unit);
-    return chunk2TZKENDH_cjs.numberValue(amount * rate);
+    return chunkIT74O4BE_cjs.numberValue(amount * rate);
   },
   // ── Degree-taking trig (sind/cosd/tand and the inverses) ──────────────
   // The "d" spellings take and return degrees rather than radians, which is
   // the convention every scientific calculator uses. sin(90 degrees) is the
   // other way to say the same thing; both exist because both get typed.
-  87: (args) => chunk2TZKENDH_cjs.numberValue(Math.sin(args[0].toNumber() * Math.PI / 180)),
-  88: (args) => chunk2TZKENDH_cjs.numberValue(Math.cos(args[0].toNumber() * Math.PI / 180)),
-  89: (args) => chunk2TZKENDH_cjs.numberValue(Math.tan(args[0].toNumber() * Math.PI / 180)),
-  90: (args) => chunk2TZKENDH_cjs.numberValue(Math.asin(args[0].toNumber()) * 180 / Math.PI),
-  91: (args) => chunk2TZKENDH_cjs.numberValue(Math.acos(args[0].toNumber()) * 180 / Math.PI),
-  92: (args) => chunk2TZKENDH_cjs.numberValue(Math.atan(args[0].toNumber()) * 180 / Math.PI),
+  87: (args) => chunkIT74O4BE_cjs.numberValue(Math.sin(args[0].toNumber() * Math.PI / 180)),
+  88: (args) => chunkIT74O4BE_cjs.numberValue(Math.cos(args[0].toNumber() * Math.PI / 180)),
+  89: (args) => chunkIT74O4BE_cjs.numberValue(Math.tan(args[0].toNumber() * Math.PI / 180)),
+  90: (args) => chunkIT74O4BE_cjs.numberValue(Math.asin(args[0].toNumber()) * 180 / Math.PI),
+  91: (args) => chunkIT74O4BE_cjs.numberValue(Math.acos(args[0].toNumber()) * 180 / Math.PI),
+  92: (args) => chunkIT74O4BE_cjs.numberValue(Math.atan(args[0].toNumber()) * 180 / Math.PI),
   // daysCount(n) -> n labelled as days. "days in Q3" is a count of days
   // and should say so; a bare 92 loses what was being counted.
-  93: (args) => chunk2TZKENDH_cjs.uomValue(args[0].toNumber(), "days"),
+  93: (args) => chunkIT74O4BE_cjs.uomValue(args[0].toNumber(), "days"),
   // asTwoUnits(value, majorUnit, minorUnit) -> "12 min 30 s".
   //
   // "12.5 minutes in minutes and seconds" asks for one quantity split
@@ -2870,25 +2893,25 @@ var builtinFunctions = {
     const major = typeof args[1]?.value === "string" ? args[1].value : void 0;
     const minor = typeof args[2]?.value === "string" ? args[2].value : void 0;
     if (major === void 0 || minor === void 0) {
-      return chunk2TZKENDH_cjs.errorValue("UNKNOWN_UNIT", 'both units have to be named, as in "12.5 minutes in minutes and seconds"');
+      return chunkIT74O4BE_cjs.errorValue("UNKNOWN_UNIT", 'both units have to be named, as in "12.5 minutes in minutes and seconds"');
     }
     const majorEntry = chunkAMOJYLG2_cjs.UNIT_TABLE[major.toLowerCase()];
     const minorEntry = chunkAMOJYLG2_cjs.UNIT_TABLE[minor.toLowerCase()];
     if (majorEntry === void 0 || minorEntry === void 0) {
-      return chunk2TZKENDH_cjs.errorValue("UNKNOWN_UNIT", `${major} and ${minor}: one of these is not a unit`);
+      return chunkIT74O4BE_cjs.errorValue("UNKNOWN_UNIT", `${major} and ${minor}: one of these is not a unit`);
     }
     if (majorEntry[0] !== minorEntry[0]) {
-      return chunk2TZKENDH_cjs.errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor} measure different things`);
+      return chunkIT74O4BE_cjs.errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor} measure different things`);
     }
     if (minorEntry[1] >= majorEntry[1]) {
-      return chunk2TZKENDH_cjs.errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor}: name the larger unit first`);
+      return chunkIT74O4BE_cjs.errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor}: name the larger unit first`);
     }
     const source = args[0];
     const sourceEntry = source.type === 6 /* Uom */ && source.unit !== void 0 ? chunkAMOJYLG2_cjs.UNIT_TABLE[source.unit.toLowerCase()] : void 0;
     const inBase = source.toNumber() * (sourceEntry?.[1] ?? majorEntry[1]);
     const majorCount = Math.floor(inBase / majorEntry[1]);
     const minorCount = Math.round((inBase - majorCount * majorEntry[1]) / minorEntry[1] * 1e3) / 1e3;
-    return chunk2TZKENDH_cjs.stringValue(`${majorCount} ${major} ${minorCount} ${minor}`);
+    return chunkIT74O4BE_cjs.stringValue(`${majorCount} ${major} ${minorCount} ${minor}`);
   },
   // makeRate(value, denominatorUnit) -> value per that unit.
   //
@@ -2904,9 +2927,9 @@ var builtinFunctions = {
     const denominator = String(args[1].value);
     const numerator = source.type === 6 /* Uom */ && source.unit !== void 0 ? source.unit : "";
     if (numerator.includes("/")) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE_UNIT", `${numerator}/${denominator}: that is already a rate`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE_UNIT", `${numerator}/${denominator}: that is already a rate`);
     }
-    return chunk2TZKENDH_cjs.uomValue(source.toNumber(), `${numerator}/${denominator}`);
+    return chunkIT74O4BE_cjs.uomValue(source.toNumber(), `${numerator}/${denominator}`);
   },
   // atRate(quantity, rate) -> whichever of the two the question implies.
   //
@@ -2921,7 +2944,7 @@ var builtinFunctions = {
     const left = args[0];
     const rate = args[1];
     if (rate.type !== 6 /* Uom */ || rate.unit === void 0 || !rate.unit.includes("/")) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", 'at: the right-hand side has to be a rate, as in "$30/hour"');
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", 'at: the right-hand side has to be a rate, as in "$30/hour"');
     }
     const slash = rate.unit.indexOf("/");
     const numerator = rate.unit.slice(0, slash);
@@ -2932,17 +2955,17 @@ var builtinFunctions = {
     if (leftEntry !== void 0 && denominatorEntry !== void 0 && leftEntry[0] === denominatorEntry[0]) {
       const inDenominator = left.toNumber() * leftEntry[1] / denominatorEntry[1];
       const total = inDenominator * rate.toNumber();
-      return numerator === "" ? chunk2TZKENDH_cjs.numberValue(total) : chunk2TZKENDH_cjs.uomValue(total, numerator);
+      return numerator === "" ? chunkIT74O4BE_cjs.numberValue(total) : chunkIT74O4BE_cjs.uomValue(total, numerator);
     }
     if (leftUnit !== void 0 && leftUnit === numerator) {
       const count = left.toNumber() / rate.toNumber();
-      return chunk2TZKENDH_cjs.uomValue(count, pluraliseUnit(denominator, count));
+      return chunkIT74O4BE_cjs.uomValue(count, pluraliseUnit(denominator, count));
     }
     if (leftUnit === void 0) {
       const total = left.toNumber() * rate.toNumber();
-      return numerator === "" ? chunk2TZKENDH_cjs.numberValue(total) : chunk2TZKENDH_cjs.uomValue(total, numerator);
+      return numerator === "" ? chunkIT74O4BE_cjs.numberValue(total) : chunkIT74O4BE_cjs.uomValue(total, numerator);
     }
-    return chunk2TZKENDH_cjs.errorValue("INCOMPATIBLE_UNITS", `at: ${leftUnit} matches neither side of ${rate.unit}`);
+    return chunkIT74O4BE_cjs.errorValue("INCOMPATIBLE_UNITS", `at: ${leftUnit} matches neither side of ${rate.unit}`);
   },
   // ── Investments (packages/finance/) ────────────────────────────────────
   // compoundFutureValueEvery(principal, rate, years, periodsPerYear)
@@ -2957,13 +2980,13 @@ var builtinFunctions = {
     const years = args[2].toNumber();
     const perYear = args[3].toNumber();
     if (perYear <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `compounding: ${perYear} periods per year is not a period`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `compounding: ${perYear} periods per year is not a period`);
     }
     if (1 + rate / perYear <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `compounding: rate ${rate} makes each period non-positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `compounding: rate ${rate} makes each period non-positive`);
     }
     const fv = principal * Math.pow(1 + rate / perYear, perYear * years);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(fv, args[0].unit) : chunk2TZKENDH_cjs.numberValue(fv);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(fv, args[0].unit) : chunkIT74O4BE_cjs.numberValue(fv);
   },
   // compoundInterestEarnedEvery(principal, rate, years, periodsPerYear)
   // The interest-only portion of index 80, i.e. FV - P.
@@ -2973,10 +2996,10 @@ var builtinFunctions = {
     const years = args[2].toNumber();
     const perYear = args[3].toNumber();
     if (perYear <= 0 || 1 + rate / perYear <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `compounding: rate ${rate} over ${perYear} periods per year is not usable`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `compounding: rate ${rate} over ${perYear} periods per year is not usable`);
     }
     const interest = principal * (Math.pow(1 + rate / perYear, perYear * years) - 1);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(interest, args[0].unit) : chunk2TZKENDH_cjs.numberValue(interest);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(interest, args[0].unit) : chunkIT74O4BE_cjs.numberValue(interest);
   },
   // presentValue(futureValue, rate, years) -> FV / (1 + r)^y, what a sum
   // promised in the future is worth today. The inverse of index 51.
@@ -2985,10 +3008,10 @@ var builtinFunctions = {
     const rate = args[1].toNumber();
     const years = args[2].toNumber();
     if (1 + rate <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", `presentValue: rate ${rate} makes (1 + rate) non-positive`);
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `presentValue: rate ${rate} makes (1 + rate) non-positive`);
     }
     const pv = future / Math.pow(1 + rate, years);
-    return args[0].type === 6 /* Uom */ ? chunk2TZKENDH_cjs.uomValue(pv, args[0].unit) : chunk2TZKENDH_cjs.numberValue(pv);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(pv, args[0].unit) : chunkIT74O4BE_cjs.numberValue(pv);
   },
   // returnOnInvestment(invested, returned) -> (returned - invested) /
   // invested, the gain as a multiple of what was put in. $500 in and $1,500
@@ -2999,9 +3022,9 @@ var builtinFunctions = {
     const invested = args[0].toNumber();
     const returned = args[1].toNumber();
     if (invested === 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", "roi: nothing was invested, so there is no return on it");
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", "roi: nothing was invested, so there is no return on it");
     }
-    return chunk2TZKENDH_cjs.numberValue((returned - invested) / invested);
+    return chunkIT74O4BE_cjs.numberValue((returned - invested) / invested);
   },
   // annualisedReturn(invested, returned, years) -> CAGR, the constant
   // yearly rate that turns `invested` into `returned` over `years`:
@@ -3012,15 +3035,15 @@ var builtinFunctions = {
     const returned = args[1].toNumber();
     const years = args[2].toNumber();
     if (invested <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", "annual return: the amount invested must be positive");
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", "annual return: the amount invested must be positive");
     }
     if (years <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", "annual return: the period must be longer than zero");
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", "annual return: the period must be longer than zero");
     }
     if (returned <= 0) {
-      return chunk2TZKENDH_cjs.errorValue("INVALID_RATE", "annual return: nothing was returned, so there is no annual rate");
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", "annual return: nothing was returned, so there is no annual rate");
     }
-    return chunk2TZKENDH_cjs.percentageValue(Math.pow(returned / invested, 1 / years) - 1);
+    return chunkIT74O4BE_cjs.percentageValue(Math.pow(returned / invested, 1 / years) - 1);
   },
   // roundToPlaces(value, places) -> value rounded to that many decimal
   // places, backing `<value> to <n> dp` (converters/parselets/
@@ -3032,16 +3055,74 @@ var builtinFunctions = {
   // fractional part to round at all, and the round trip through 1e23 was
   // pure loss. Asking for fewer decimal places than a number has cannot
   // change it, so a value that is already whole is returned untouched.
-  97: (args) => roundToPlaces(args[0], args[1].toNumber())
+  97: (args) => roundToPlaces(args[0], args[1].toNumber()),
+  // splitEach(amount, n): a per-person bill split, `split $180 between 4` and
+  // `$120 + 18% split 3 ways`. Backs both split spellings (see
+  // BillSplitParselets.ts). Money stays exact and the shares add back to the
+  // total to the cent (see splitEachExact in MoneyExact.ts). A bare number
+  // splits to a bare number; the odd penny is named, not rounded away.
+  98: (args) => {
+    const n = args[1].toNumber();
+    if (!Number.isInteger(n) || n < 1) {
+      return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `split: the number of shares must be a whole number of at least 1, not ${args[1].toNumber()}.`);
+    }
+    return chunkIT74O4BE_cjs.splitValue(splitEachExact(args[0], n));
+  },
+  // ── Savings goals ──────────────────────────────────────────────
+  // savingsGoalPayment(target, duration, annualRate): the level contribution
+  // per month that reaches `target` over `duration` (months or years), at an
+  // optional annual rate compounded monthly. Backs "how much per month to
+  // save/reach <target> in <duration> [at <rate>]".
+  99: (args) => {
+    const target = args[0].toNumber();
+    const months = monthsOfDuration(args[1]);
+    const annualRate = args[2].toNumber();
+    if (months === null) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `savings goal: the duration must be in months or years, e.g. "in 2 years".`);
+    if (target <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `savings goal: the target must be positive.`);
+    if (months <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `savings goal: the duration must be positive.`);
+    if (annualRate < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `savings goal: the rate must not be negative.`);
+    const payment = annuityPayment(target, annualRate / 12, months);
+    return args[0].type === 6 /* Uom */ ? chunkIT74O4BE_cjs.uomValue(payment, args[0].unit) : chunkIT74O4BE_cjs.numberValue(payment);
+  },
+  // savingsGoalPeriods(target, contribution, periodsPerYear, annualRate,
+  // periodUnit): how many whole periods of `contribution` reach `target`,
+  // rounded UP, since a part period has not yet reached the goal. Backs
+  // "how long to save <target> at <amount> <period> [at <rate>]".
+  100: (args) => {
+    const target = args[0].toNumber();
+    const contribution = args[1].toNumber();
+    const periodsPerYear = args[2].toNumber();
+    const annualRate = args[3].toNumber();
+    const unit = typeof args[4]?.value === "string" ? args[4].value : "periods";
+    if (target <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `savings goal: the target must be positive.`);
+    if (contribution <= 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RANGE", `savings goal: the contribution must be positive.`);
+    if (annualRate < 0) return chunkIT74O4BE_cjs.errorValue("INVALID_RATE", `savings goal: the rate must not be negative.`);
+    const periods = annuityPeriods(target, contribution, annualRate / periodsPerYear);
+    return chunkIT74O4BE_cjs.uomValue(periods, unit);
+  }
 };
+function monthsOfDuration(duration) {
+  if (duration.type !== 6 /* Uom */) return null;
+  const unit = duration.unit;
+  if (unit === "months" || unit === "month") return duration.toNumber();
+  if (unit === "years" || unit === "year") return duration.toNumber() * 12;
+  return null;
+}
+function annuityPayment(target, i, months) {
+  return i === 0 ? target / months : target * i / (Math.pow(1 + i, months) - 1);
+}
+function annuityPeriods(target, contribution, i) {
+  const raw = i === 0 ? target / contribution : Math.log(1 + target * i / contribution) / Math.log(1 + i);
+  return Math.ceil(raw - 1e-9);
+}
 function applyComplexAccessor(name, value) {
   const node = valueToSymbolic(value);
-  if (node === null) return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", name + " needs a value with an exact number.");
-  return symbolicToValue(chunkHIQ5HSZL_cjs.callNode(name, [node]));
+  if (node === null) return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_NONFINITE_OPERAND", name + " needs a value with an exact number.");
+  return symbolicToValue(chunkA2DZ5BEJ_cjs.callNode(name, [node]));
 }
 function symbolicVariableName(value, verb) {
   if (value?.type !== 3 /* String */) {
-    return chunk2TZKENDH_cjs.errorValue("SYMBOLIC_REQUIRES_VARIABLE_NAME", `${verb} needs the name of an unknown.`);
+    return chunkIT74O4BE_cjs.errorValue("SYMBOLIC_REQUIRES_VARIABLE_NAME", `${verb} needs the name of an unknown.`);
   }
   return value.value;
 }
@@ -3058,7 +3139,7 @@ var MAX_PLUGIN_FUNCTION_INDEX = 255;
 var nextPluginFunctionIndex = 0;
 function allocatePluginFunctionIndex() {
   if (nextPluginFunctionIndex > MAX_PLUGIN_FUNCTION_INDEX) {
-    throw chunkB4HBEFTB_cjs.ErrorFactory.config(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.config(
       "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED",
       `allocatePluginFunctionIndex: pool exhausted (max ${MAX_PLUGIN_FUNCTION_INDEX + 1} allocations).`
     );
@@ -3218,5 +3299,5 @@ exports.toBigIntOperand = toBigIntOperand;
 exports.uncertainOp = uncertainOp;
 exports.unifyUom = unifyUom;
 exports.unregisterAsConverter = unregisterAsConverter;
-//# sourceMappingURL=chunk-7ZX6B7SY.cjs.map
-//# sourceMappingURL=chunk-7ZX6B7SY.cjs.map
+//# sourceMappingURL=chunk-FR7RNOPT.cjs.map
+//# sourceMappingURL=chunk-FR7RNOPT.cjs.map