@cortex-js/compute-engine 0.34.0 → 0.35.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.34.0 */
+/** Compute Engine 0.35.0 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var __toCommonJS = (mod3) => __copyProps(__defProp({}, "__esModule", { value: true }), mod3);
 
 // node_modules/complex-esm/dist/src/complex.js
 function logHypot(a, b) {
@@ -172,8 +172,8 @@ var init_complex = __esm({
        * @returns {Complex}
        */
       sign() {
-        var abs2 = this["abs"]();
-        return new _Complex(this["re"] / abs2, this["im"] / abs2);
+        var abs3 = this["abs"]();
+        return new _Complex(this["re"] / abs3, this["im"] / abs3);
       }
       /**
        * Adds two complex numbers
@@ -892,8 +892,8 @@ function digitsToString(d) {
   for (; w % 10 === 0; ) w /= 10;
   return str + w;
 }
-function checkInt32(i, min2, max2) {
-  if (i !== ~~i || i < min2 || i > max2) {
+function checkInt32(i, min3, max3) {
+  if (i !== ~~i || i < min3 || i > max3) {
     throw Error(invalidArgument + i);
   }
 }
@@ -1147,7 +1147,7 @@ function maxOrMin(Ctor, args, n) {
   return x;
 }
 function naturalExponential(x, sd) {
-  var denominator, guard, j, pow3, sum2, t, wpr, rep = 0, i = 0, k = 0, Ctor = x.constructor, rm = Ctor.rounding, pr = Ctor.precision;
+  var denominator, guard, j, pow4, sum2, t, wpr, rep = 0, i = 0, k = 0, Ctor = x.constructor, rm = Ctor.rounding, pr = Ctor.precision;
   if (!x.d || !x.d[0] || x.e > 17) {
     return new Ctor(x.d ? !x.d[0] ? 1 : x.s < 0 ? 0 : 1 / 0 : x.s ? x.s < 0 ? 0 : x : 0 / 0);
   }
@@ -1164,19 +1164,19 @@ function naturalExponential(x, sd) {
   }
   guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;
   wpr += guard;
-  denominator = pow3 = sum2 = new Ctor(1);
+  denominator = pow4 = sum2 = new Ctor(1);
   Ctor.precision = wpr;
   for (; ; ) {
-    pow3 = finalise(pow3.times(x), wpr, 1);
+    pow4 = finalise(pow4.times(x), wpr, 1);
     denominator = denominator.times(++i);
-    t = sum2.plus(divide(pow3, denominator, wpr, 1));
+    t = sum2.plus(divide(pow4, denominator, wpr, 1));
     if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum2.d).slice(0, wpr)) {
       j = k;
       while (j--) sum2 = finalise(sum2.times(sum2), wpr, 1);
       if (sd == null) {
         if (rep < 3 && checkRoundingDigits(sum2.d, wpr - guard, rm, rep)) {
           Ctor.precision = wpr += 10;
-          denominator = pow3 = t = new Ctor(1);
+          denominator = pow4 = t = new Ctor(1);
           i = 0;
           rep++;
         } else {
@@ -1568,8 +1568,8 @@ function cbrt(x) {
 function ceil(x) {
   return finalise(x = new this(x), x.e + 1, 2);
 }
-function clamp(x, min2, max2) {
-  return new this(x).clamp(min2, max2);
+function clamp(x, min3, max3) {
+  return new this(x).clamp(min3, max3);
 }
 function config(obj) {
   if (!obj || typeof obj !== "object") throw Error(decimalError + "Object expected");
@@ -2013,14 +2013,14 @@ var init_decimal = __esm({
     P.ceil = function() {
       return finalise(new this.constructor(this), this.e + 1, 2);
     };
-    P.clampedTo = P.clamp = function(min2, max2) {
+    P.clampedTo = P.clamp = function(min3, max3) {
       var k, x = this, Ctor = x.constructor;
-      min2 = new Ctor(min2);
-      max2 = new Ctor(max2);
-      if (!min2.s || !max2.s) return new Ctor(NaN);
-      if (min2.gt(max2)) throw Error(invalidArgument + max2);
-      k = x.cmp(min2);
-      return k < 0 ? min2 : x.cmp(max2) > 0 ? max2 : new Ctor(x);
+      min3 = new Ctor(min3);
+      max3 = new Ctor(max3);
+      if (!min3.s || !max3.s) return new Ctor(NaN);
+      if (min3.gt(max3)) throw Error(invalidArgument + max3);
+      k = x.cmp(min3);
+      return k < 0 ? min3 : x.cmp(max3) > 0 ? max3 : new Ctor(x);
     };
     P.comparedTo = P.cmp = function(y) {
       var i, j, xdL, ydL, x = this, xd = x.d, yd = (y = new x.constructor(y)).d, xs = x.s, ys = y.s;
@@ -2918,13 +2918,13 @@ var init_decimal = __esm({
         for (; !a[0] && a.length > 1; ) a.shift();
       }
       return function(x, y, pr, rm, dp, base) {
-        var cmp2, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0, yL, yz, Ctor = x.constructor, sign2 = x.s == y.s ? 1 : -1, xd = x.d, yd = y.d;
+        var cmp2, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0, yL, yz, Ctor = x.constructor, sign3 = x.s == y.s ? 1 : -1, xd = x.d, yd = y.d;
         if (!xd || !xd[0] || !yd || !yd[0]) {
           return new Ctor(
             // Return NaN if either NaN, or both Infinity or 0.
             !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN : (
               // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.
-              xd && xd[0] == 0 || !yd ? sign2 * 0 : sign2 / 0
+              xd && xd[0] == 0 || !yd ? sign3 * 0 : sign3 / 0
             )
           );
         }
@@ -2938,7 +2938,7 @@ var init_decimal = __esm({
         }
         yL = yd.length;
         xL = xd.length;
-        q = new Ctor(sign2);
+        q = new Ctor(sign3);
         qd = q.d = [];
         for (i = 0; yd[i] == (xd[i] || 0); i++) ;
         if (yd[i] > (xd[i] || 0)) e--;
@@ -5446,8 +5446,8 @@ function bigint(a) {
   let s = a.toLowerCase();
   const m = s.match(/([+-]?[0-9]*)(?:\.([0-9]+))?e([+-]?[0-9]+)$/);
   if (m) {
-    const exp2 = parseInt(m[3]);
-    const pad = exp2 - (m[2] ? m[2].length : 0);
+    const exp3 = parseInt(m[3]);
+    const pad = exp3 - (m[2] ? m[2].length : 0);
     if (pad < 0) return null;
     s = (m[1] ?? "") + (m[2] ?? "") + "0".repeat(pad);
   }
@@ -6940,8 +6940,8 @@ function rationalValue(expr) {
     denom = machineValue(d) ?? NaN;
   }
   if (h === "Power") {
-    const [base, exp2] = operands(expr);
-    const exponent = machineValue(exp2);
+    const [base, exp3] = operands(expr);
+    const exponent = machineValue(exp3);
     if (exponent === 1) {
       numer = machineValue(base);
       denom = 1;
@@ -8323,11 +8323,11 @@ function parseAssign(parser, lhs) {
     if (!fn2) return null;
     const rhs2 = parser.parseExpression({ minPrec: 0 });
     if (rhs2 === null) return null;
-    const sub2 = operand(lhs, 2);
-    if (stringValue(sub2) !== null) {
+    const sub3 = operand(lhs, 2);
+    if (stringValue(sub3) !== null) {
       return ["Assign", lhs, rhs2];
     }
-    if (symbol(sub2)) {
+    if (symbol(sub3)) {
       return ["Assign", lhs, rhs2];
     }
     return ["Assign", lhs, rhs2];
@@ -9643,12 +9643,12 @@ function formatFractionalPart(digits, wholeDigitsCount, options) {
   if (extraDigits) digits += options.truncationMarker;
   return digits;
 }
-function formatExponent(exp2, options) {
-  if (!exp2 || exp2 === "0") return "";
+function formatExponent(exp3, options) {
+  if (!exp3 || exp3 === "0") return "";
   if (options.beginExponentMarker) {
-    return options.beginExponentMarker + exp2 + (options.endExponentMarker ?? "");
+    return options.beginExponentMarker + exp3 + (options.endExponentMarker ?? "");
   }
-  return `10^{${exp2}}`;
+  return `10^{${exp3}}`;
 }
 function serializeNumber(expr, options) {
   if (expr === null) return "";
@@ -9692,9 +9692,9 @@ function serializeNumber(expr, options) {
     const [_, body, repeat2, trail] = num.match(/(.+)\(([0-9]+)\)(.*)$/) ?? [];
     num = body + repeat2.repeat(6) + trail;
   }
-  let sign2 = "";
+  let sign3 = "";
   if (num[0] === "-") {
-    sign2 = "-";
+    sign3 = "-";
     num = num.substring(1);
   } else if (num[0] === "+") {
     num = num.substring(1);
@@ -9710,25 +9710,25 @@ function serializeNumber(expr, options) {
   } else if (options.notation === "adaptiveScientific") {
     result = serializeScientificNotationNumber(num, options);
   }
-  return sign2 + (result ?? serializeAutoNotationNumber(num, {
+  return sign3 + (result ?? serializeAutoNotationNumber(num, {
     ...options
   }));
 }
 function serializeScientificNotationNumber(valString, options, expMultiple = 1) {
   let m = valString.match(/^(.*)[e|E]([-+]?[0-9]+)$/);
   if (!m) {
-    let sign2 = "";
+    let sign3 = "";
     if (valString[0] === "-") {
-      sign2 = "-";
+      sign3 = "-";
       valString = valString.substring(1);
     } else if (valString[0] === "+") {
       valString = valString.substring(1);
     }
     if (valString.indexOf(".") < 0) {
       if (valString.length === 1) {
-        valString = sign2 + valString + "e+0";
+        valString = sign3 + valString + "e+0";
       } else {
-        valString = sign2 + valString[0] + "." + valString.slice(1) + "e+" + (valString.length - 1).toString();
+        valString = sign3 + valString[0] + "." + valString.slice(1) + "e+" + (valString.length - 1).toString();
       }
     } else {
       let [_, whole, fraction] = valString.match(/^(.*)\.(.*)$/);
@@ -9738,20 +9738,20 @@ function serializeScientificNotationNumber(valString, options, expMultiple = 1)
         let leadingZeros = 0;
         while (fraction[leadingZeros] === "0") leadingZeros++;
         if (leadingZeros === fraction.length) {
-          valString = sign2 + "0e+0";
+          valString = sign3 + "0e+0";
         } else {
           const significand = fraction.slice(leadingZeros);
           const firstDigit = significand[0];
           const restDigits = significand.slice(1);
           const exponent2 = -(leadingZeros + 1);
           if (restDigits) {
-            valString = sign2 + firstDigit + "." + restDigits + "e" + exponent2;
+            valString = sign3 + firstDigit + "." + restDigits + "e" + exponent2;
           } else {
-            valString = sign2 + firstDigit + "e" + exponent2;
+            valString = sign3 + firstDigit + "e" + exponent2;
           }
         }
       } else {
-        valString = sign2 + whole[0] + "." + whole.slice(1) + fraction + "e+" + (whole.length - 1).toString();
+        valString = sign3 + whole[0] + "." + whole.slice(1) + fraction + "e+" + (whole.length - 1).toString();
       }
     }
     m = valString.match(/^(.*)[e|E]([-+]?[0-9]+)$/);
@@ -9793,11 +9793,11 @@ function serializeScientificNotationNumber(valString, options, expMultiple = 1)
 }
 function serializeAutoNotationNumber(valString, options) {
   let m = valString.match(/^(.*)[e|E]([-+]?[0-9]+)$/i);
-  let exp2 = 0;
+  let exp3 = 0;
   let originalExp = 0;
   if (m?.[1] && m[2]) {
-    exp2 = parseInt(m[2]);
-    originalExp = exp2;
+    exp3 = parseInt(m[2]);
+    originalExp = exp3;
     valString = m[1];
   }
   let wholePart = m?.[1] ?? valString;
@@ -9807,23 +9807,23 @@ function serializeAutoNotationNumber(valString, options) {
     wholePart = m[1];
     fractionalPart = m[2];
   }
-  if (exp2 !== 0 && fractionalPart) {
+  if (exp3 !== 0 && fractionalPart) {
     wholePart += fractionalPart;
-    exp2 -= fractionalPart.length;
+    exp3 -= fractionalPart.length;
     fractionalPart = "";
   }
   const avoid = options.avoidExponentsInRange;
-  if (exp2 !== 0 && avoid) {
+  if (exp3 !== 0 && avoid) {
     if (originalExp >= avoid[0] && originalExp <= avoid[1]) {
       [wholePart, fractionalPart] = toDecimalNumber(
         wholePart,
         fractionalPart,
-        exp2
+        exp3
       );
-      exp2 = 0;
+      exp3 = 0;
     }
   }
-  const exponent = formatExponent(exp2.toString(), options);
+  const exponent = formatExponent(exp3.toString(), options);
   if (fractionalPart)
     fractionalPart = options.decimalSeparator + formatFractionalPart(fractionalPart, wholePart.length, options);
   wholePart = insertWholeGroupSeparator(wholePart, options);
@@ -9876,10 +9876,10 @@ function insertFractionalGroupSeparator(numberString, options) {
 function insertWholeGroupSeparator(numberString, options) {
   return insertGroupSeparator(numberString, options, 0);
 }
-function toDecimalNumber(wholePart, fractionalPart, exp2) {
+function toDecimalNumber(wholePart, fractionalPart, exp3) {
   let combinedNumber = wholePart + fractionalPart;
   const wholeLength = wholePart.length;
-  const newDecimalPosition = wholeLength + exp2;
+  const newDecimalPosition = wholeLength + exp3;
   let newWholePart;
   let newFractionalPart;
   if (newDecimalPosition > 0) {
@@ -9991,8 +9991,8 @@ function parseSymbolBody2(s, topLevel = true, style = "auto") {
         sups.push(sup);
         rest = rest2;
       } else if (rest.startsWith("_")) {
-        const [sub2, rest2] = parseSymbolBody2(rest.substring(1), false, "none");
-        subs.push(sub2);
+        const [sub3, rest2] = parseSymbolBody2(rest.substring(1), false, "none");
+        subs.push(sub3);
         rest = rest2;
       } else {
         break;
@@ -11540,13 +11540,13 @@ var init_exact_numeric_value = __esm({
           return this.factory(this.bignumRe).pow(exponent);
         if (this.sign < 0) {
           if (Number.isInteger(exponent)) {
-            const sign2 = exponent % 2 === 0 ? 1 : -1;
+            const sign3 = exponent % 2 === 0 ? 1 : -1;
             return this.clone({
               rational: isMachineRational(this.rational) ? [
-                sign2 * (-this.rational[0]) ** exponent,
+                sign3 * (-this.rational[0]) ** exponent,
                 this.rational[1] ** exponent
               ] : [
-                BigInt(sign2) * (-this.rational[0]) ** BigInt(exponent),
+                BigInt(sign3) * (-this.rational[0]) ** BigInt(exponent),
                 this.rational[1] ** BigInt(exponent)
               ],
               radical: this.radical ** exponent
@@ -11912,34 +11912,34 @@ function multinomialCoefficient(k) {
   }
   return prod;
 }
-function* powers(n, exp2) {
+function* powers(n, exp3) {
   if (n === 1) {
-    yield [exp2];
+    yield [exp3];
     return;
   }
-  for (let i = 0; i <= exp2; i += 1)
-    for (const p of powers(n - 1, exp2 - i)) yield [i, ...p];
+  for (let i = 0; i <= exp3; i += 1)
+    for (const p of powers(n - 1, exp3 - i)) yield [i, ...p];
 }
-function expandPower(base, exp2) {
+function expandPower(base, exp3) {
   const ce = base.engine;
-  if (exp2 < 0) {
-    const expr = expandPower(base, -exp2);
+  if (exp3 < 0) {
+    const expr = expandPower(base, -exp3);
     return expr ? expr.inv() : null;
   }
-  if (exp2 === 0) return ce.One;
-  if (exp2 === 1) return expand2(base);
+  if (exp3 === 0) return ce.One;
+  if (exp3 === 1) return expand2(base);
   if (base.operator === "Negate") {
-    if (Number.isInteger(exp2)) {
-      const sign2 = exp2 % 2 === 0 ? 1 : -1;
-      const result2 = expandPower(base.op1, exp2);
+    if (Number.isInteger(exp3)) {
+      const sign3 = exp3 % 2 === 0 ? 1 : -1;
+      const result2 = expandPower(base.op1, exp3);
       if (result2 === null) return null;
-      return sign2 > 0 ? result2 : result2.neg();
+      return sign3 > 0 ? result2 : result2.neg();
     }
   }
   console.assert(base.operator !== "Subtract");
   if (base.operator !== "Add") return null;
   const terms = base.ops;
-  const it = powers(terms.length, exp2);
+  const it = powers(terms.length, exp3);
   const result = [];
   for (const val of it) {
     const product = [ce.number(multinomialCoefficient(val))];
@@ -11966,8 +11966,8 @@ function expandFunction(ce, h, ops) {
   if (h === "Negate") return expand2(ops[0])?.neg() ?? null;
   if (h === "Add") return add3(...ops.map((x) => expand2(x) ?? x));
   if (h === "Power") {
-    const exp2 = asSmallInteger(ops[1]);
-    result = exp2 !== null ? expandPower(ops[0], exp2) : null;
+    const exp3 = asSmallInteger(ops[1]);
+    result = exp3 !== null ? expandPower(ops[0], exp3) : null;
   }
   return result;
 }
@@ -12012,22 +12012,22 @@ var init_expand = __esm({
 
 // src/compute-engine/boxed-expression/negate.ts
 function canonicalNegate(expr) {
-  let sign2 = -1;
+  let sign3 = -1;
   while (expr.operator === "Negate") {
     expr = expr.op1;
-    sign2 = -sign2;
+    sign3 = -sign3;
   }
-  if (sign2 === 1) return expr;
+  if (sign3 === 1) return expr;
   if (expr.isNumberLiteral) return expr.neg();
   return expr.engine._fn("Negate", [expr]);
 }
 function negate(expr) {
-  let sign2 = -1;
+  let sign3 = -1;
   while (expr.operator === "Negate") {
     expr = expr.op1;
-    sign2 = -sign2;
+    sign3 = -sign3;
   }
-  if (sign2 === 1) return expr;
+  if (sign3 === 1) return expr;
   if (expr.numericValue !== null) return expr.neg();
   const ce = expr.engine;
   if (expr.operator === "Subtract") return expr.op2.sub(expr.op1);
@@ -12233,11 +12233,11 @@ function div2(num, denom) {
   return result.asRationalExpression();
 }
 function canonicalMultiply(ce, ops) {
-  let sign2 = 1;
+  let sign3 = 1;
   let xs = [];
   for (const op of ops) {
     const [o, s] = unnegate(op);
-    sign2 *= s;
+    sign3 *= s;
     xs.push(o);
   }
   xs = xs.filter((x) => !x.is(1));
@@ -12301,7 +12301,7 @@ function canonicalMultiply(ce, ops) {
     }
     ys.push(x);
   }
-  if (sign2 < 0) {
+  if (sign3 < 0) {
     if (ys.length === 0) return ce.number(-1);
     if (ys.length === 1) return ys[0].neg();
     return negateProduct(ce, ys);
@@ -12311,25 +12311,25 @@ function canonicalMultiply(ce, ops) {
   return ce._fn("Multiply", [...ys].sort(order));
 }
 function unnegate(op) {
-  let sign2 = 1;
+  let sign3 = 1;
   while (op.operator === "Negate") {
-    sign2 = -sign2;
+    sign3 = -sign3;
     op = op.op1;
   }
   if (op.isNumberLiteral && op.isNegative) {
-    sign2 = -sign2;
+    sign3 = -sign3;
     op = op.neg();
   }
-  return [op, sign2];
+  return [op, sign3];
 }
 function mul3(...xs) {
   console.assert(xs.length > 0);
   if (xs.length === 1) return xs[0];
   const ce = xs[0].engine;
-  const exp2 = expandProducts(ce, xs);
-  if (exp2) {
-    if (exp2.operator !== "Multiply") return exp2;
-    xs = exp2.ops;
+  const exp3 = expandProducts(ce, xs);
+  if (exp3) {
+    if (exp3.operator !== "Multiply") return exp3;
+    xs = exp3.ops;
   }
   return new Product(ce, xs).asRationalExpression();
 }
@@ -12337,10 +12337,10 @@ function mulN(...xs) {
   console.assert(xs.length > 0);
   const ce = xs[0].engine;
   xs = xs.map((x) => x.N());
-  const exp2 = expandProducts(ce, xs);
-  if (exp2) {
-    if (exp2.operator !== "Multiply") return exp2;
-    xs = exp2.ops;
+  const exp3 = expandProducts(ce, xs);
+  if (exp3) {
+    if (exp3.operator !== "Multiply") return exp3;
+    xs = exp3.ops;
   }
   return new Product(ce, xs).asExpression({ numericApproximation: true });
 }
@@ -12668,25 +12668,25 @@ var init_big_numeric_value = __esm({
           im: chop2(newModulus.mul(newArgument.sin()).toNumber())
         });
       }
-      root(exp2) {
-        if (!Number.isInteger(exp2)) return this._makeExact(NaN);
-        if (exp2 === 0) return this._makeExact(NaN);
-        if (exp2 === 1) return this;
+      root(exp3) {
+        if (!Number.isInteger(exp3)) return this._makeExact(NaN);
+        if (exp3 === 0) return this._makeExact(NaN);
+        if (exp3 === 1) return this;
         if (this.isZero) return this;
         if (this.isOne) return this;
         if (this.isNegativeOne) return this;
         if (this.im === 0) {
           if (this.decimal.isNegative()) return this._makeExact(NaN);
-          if (exp2 === 2) return this.clone(this.decimal.sqrt());
-          if (exp2 === 3) return this.clone(this.decimal.cbrt());
-          return this.clone(this.decimal.pow(1 / exp2));
+          if (exp3 === 2) return this.clone(this.decimal.sqrt());
+          if (exp3 === 3) return this.clone(this.decimal.cbrt());
+          return this.clone(this.decimal.pow(1 / exp3));
         }
         const a = this.decimal;
         const b = this.im;
         const modulus = a.mul(a).add(b * b).sqrt();
         const argument = Decimal.atan2(b, a);
-        const newModulus = modulus.pow(1 / exp2);
-        const newArgument = argument.div(exp2);
+        const newModulus = modulus.pow(1 / exp3);
+        const newArgument = argument.div(exp3);
         return this.clone({
           re: newModulus.mul(newArgument.cos()),
           im: chop2(newModulus.mul(newArgument.sin()).toNumber())
@@ -14101,12 +14101,12 @@ var init_tensors = __esm({
         const [m, n] = this.shape;
         if (m !== n) return void 0;
         if (m === 1) return this.data[0];
-        const add4 = this.field.add.bind(this.field);
-        const mul4 = this.field.mul.bind(this.field);
+        const add5 = this.field.add.bind(this.field);
+        const mul5 = this.field.mul.bind(this.field);
         const neg2 = this.field.neg.bind(this.field);
         if (m === 2) {
           const [a, b, c, d] = this.data;
-          return add4(mul4(a, d), neg2(mul4(b, c)));
+          return add5(mul5(a, d), neg2(mul5(b, c)));
         }
         const addn = this.field.addn.bind(this.field);
         const muln = this.field.muln.bind(this.field);
@@ -14123,8 +14123,8 @@ var init_tensors = __esm({
         }
         const rows = this.shape[0];
         let negated = false;
-        const div3 = this.field.div.bind(this.field);
-        const sub2 = this.field.sub.bind(this.field);
+        const div4 = this.field.div.bind(this.field);
+        const sub3 = this.field.sub.bind(this.field);
         const rowIndices = new Array(rows).fill(0).map((_, i) => i);
         const matrix = [...this.data];
         for (let k = 0; k < rows; k++) {
@@ -14147,8 +14147,8 @@ var init_tensors = __esm({
           for (let i = k + 1; i < rows; i++) {
             const i_ = rowIndices[i - 1];
             for (let j = k + 1; j < rows; j++) {
-              matrix[i_][j] = div3(
-                sub2(mul4(matrix[i_][j], piv), mul4(matrix[i_][k], matrix[k_][j])),
+              matrix[i_][j] = div4(
+                sub3(mul5(matrix[i_][j], piv), mul5(matrix[i_][k], matrix[k_][j])),
                 piv_
               );
             }
@@ -14165,13 +14165,13 @@ var init_tensors = __esm({
           const [a, b, c, d] = this.data;
           const det = this.determinant();
           if (det === void 0 || this.field.isZero(det)) return void 0;
-          const div4 = this.field.div.bind(this.field);
+          const div5 = this.field.div.bind(this.field);
           const neg2 = this.field.neg.bind(this.field);
           const inverseData2 = [
-            div4(d, det),
-            neg2(div4(b, det)),
-            neg2(div4(c, det)),
-            div4(a, det)
+            div5(d, det),
+            neg2(div5(b, det)),
+            neg2(div5(c, det)),
+            div5(a, det)
           ];
           return makeTensor(this.ce, {
             dtype: this.dtype,
@@ -14180,9 +14180,9 @@ var init_tensors = __esm({
           });
         }
         const rows = this.shape[0];
-        const div3 = this.field.div.bind(this.field);
-        const sub2 = this.field.sub.bind(this.field);
-        const mul4 = this.field.mul.bind(this.field);
+        const div4 = this.field.div.bind(this.field);
+        const sub3 = this.field.sub.bind(this.field);
+        const mul5 = this.field.mul.bind(this.field);
         const matrix = this.array;
         const identity = new Array(rows).fill(0).map((_, i) => {
           const row = new Array(rows).fill(0);
@@ -14210,9 +14210,9 @@ var init_tensors = __esm({
           for (let i = k + 1; i < rows; i++) {
             const i_ = rowIndices[i - 1];
             for (let j = k + 1; j < rows * 2; j++) {
-              augmented[i_][j] = sub2(
+              augmented[i_][j] = sub3(
                 augmented[i_][j],
-                mul4(div3(mul4(augmented[i_][k], augmented[k_][j]), piv), piv_)
+                mul5(div4(mul5(augmented[i_][k], augmented[k_][j]), piv), piv_)
               );
             }
           }
@@ -14222,14 +14222,14 @@ var init_tensors = __esm({
           for (let i = 0; i < k; i++) {
             const i_ = rowIndices[i];
             for (let j = rows; j < rows * 2; j++) {
-              augmented[i_][j] = sub2(
+              augmented[i_][j] = sub3(
                 augmented[i_][j],
-                mul4(div3(mul4(augmented[i_][k], augmented[k][j]), piv), piv)
+                mul5(div4(mul5(augmented[i_][k], augmented[k][j]), piv), piv)
               );
             }
           }
           for (let j = rows; j < rows * 2; j++) {
-            augmented[k][j] = div3(augmented[k][j], piv);
+            augmented[k][j] = div4(augmented[k][j], piv);
           }
         }
         const inverseData = augmented.map(
@@ -14595,11 +14595,11 @@ var init_boxed_tensor = __esm({
       div(rhs) {
         return this.structural.div(rhs);
       }
-      pow(exp2) {
-        return this.structural.pow(exp2);
+      pow(exp3) {
+        return this.structural.pow(exp3);
       }
-      root(exp2) {
-        return this.structural.root(exp2);
+      root(exp3) {
+        return this.structural.root(exp3);
       }
       sqrt() {
         return this.structural.sqrt();
@@ -14934,9 +14934,9 @@ function polynomialDegree(expr, variable) {
       if (expr.op2.has(variable)) return -1;
       return 0;
     }
-    const exp2 = asSmallInteger(expr.op2);
-    if (exp2 === null || exp2 < 0) return -1;
-    return baseDeg * exp2;
+    const exp3 = asSmallInteger(expr.op2);
+    if (exp3 === null || exp3 < 0) return -1;
+    return baseDeg * exp3;
   }
   if (expr.has(variable)) return -1;
   return 0;
@@ -14977,9 +14977,9 @@ function getPolynomialCoefficients(expr, variable) {
     }
     if (term.operator === "Power") {
       if (term.op1.symbol === variable) {
-        const exp2 = asSmallInteger(term.op2);
-        if (exp2 !== null && exp2 >= 0) {
-          return addCoefficient(ce.One, exp2);
+        const exp3 = asSmallInteger(term.op2);
+        if (exp3 !== null && exp3 >= 0) {
+          return addCoefficient(ce.One, exp3);
         }
       }
       if (!term.op1.has(variable)) {
@@ -14997,9 +14997,9 @@ function getPolynomialCoefficients(expr, variable) {
         } else if (factor3.symbol === variable) {
           varDeg += 1;
         } else if (factor3.operator === "Power" && factor3.op1.symbol === variable) {
-          const exp2 = asSmallInteger(factor3.op2);
-          if (exp2 !== null && exp2 >= 0) {
-            varDeg += exp2;
+          const exp3 = asSmallInteger(factor3.op2);
+          if (exp3 !== null && exp3 >= 0) {
+            varDeg += exp3;
           } else {
             return false;
           }
@@ -15358,13 +15358,13 @@ function canonicalPower(a, b) {
 }
 function canonicalRoot(a, b) {
   const ce = a.engine;
-  let exp2 = void 0;
-  if (typeof b === "number") exp2 = b;
+  let exp3 = void 0;
+  if (typeof b === "number") exp3 = b;
   else {
-    if (b.isNumberLiteral && b.im === 0) exp2 = b.re;
+    if (b.isNumberLiteral && b.im === 0) exp3 = b.re;
   }
-  if (exp2 === 1) return a;
-  if (exp2 === 2) {
+  if (exp3 === 1) return a;
+  if (exp3 === 2) {
     if (a.isNumberLiteral && a.type.matches("rational")) {
       if (a.re < SMALL_INTEGER) {
         const v = a.sqrt();
@@ -15378,86 +15378,86 @@ function canonicalRoot(a, b) {
     canonical: a.isCanonical && (typeof b === "number" || b.isCanonical)
   });
 }
-function pow2(x, exp2, { numericApproximation }) {
-  if (!x.isCanonical || typeof exp2 !== "number" && !exp2.isCanonical)
-    return x.engine._fn("Power", [x, x.engine.box(exp2)], { canonical: false });
+function pow2(x, exp3, { numericApproximation }) {
+  if (!x.isCanonical || typeof exp3 !== "number" && !exp3.isCanonical)
+    return x.engine._fn("Power", [x, x.engine.box(exp3)], { canonical: false });
   if (numericApproximation) {
     if (x.isNumberLiteral) {
-      if (typeof exp2 === "number") {
+      if (typeof exp3 === "number") {
         return apply(
           x,
-          (x2) => Math.pow(x2, exp2),
-          (x2) => x2.pow(exp2),
-          (x2) => x2.pow(exp2)
-        ) ?? pow2(x, exp2, { numericApproximation: false });
-      } else if (exp2.isNumberLiteral)
+          (x2) => Math.pow(x2, exp3),
+          (x2) => x2.pow(exp3),
+          (x2) => x2.pow(exp3)
+        ) ?? pow2(x, exp3, { numericApproximation: false });
+      } else if (exp3.isNumberLiteral)
         return apply2(
           x,
-          exp2,
-          (x2, exp3) => Math.pow(x2, exp3),
-          (x2, exp3) => x2.pow(exp3),
-          (x2, exp3) => x2.pow(exp3)
-        ) ?? pow2(x, exp2, { numericApproximation: false });
+          exp3,
+          (x2, exp4) => Math.pow(x2, exp4),
+          (x2, exp4) => x2.pow(exp4),
+          (x2, exp4) => x2.pow(exp4)
+        ) ?? pow2(x, exp3, { numericApproximation: false });
     }
   }
   const ce = x.engine;
-  if (typeof exp2 !== "number") exp2 = exp2.canonical;
-  const canonicalResult = canonicalPower(x, ce.box(exp2));
+  if (typeof exp3 !== "number") exp3 = exp3.canonical;
+  const canonicalResult = canonicalPower(x, ce.box(exp3));
   if (canonicalResult.operator !== "Power") return canonicalResult;
-  const e = typeof exp2 === "number" ? exp2 : exp2.im === 0 ? exp2.re : void 0;
+  const e = typeof exp3 === "number" ? exp3 : exp3.im === 0 ? exp3.re : void 0;
   if (x.symbol === "ComplexInfinity") return ce.NaN;
   if (x.symbol === "ExponentialE") {
-    let theta = getImaginaryFactor(exp2);
+    let theta = getImaginaryFactor(exp3);
     if (theta !== void 0) {
       theta = canonicalAngle(theta);
       if (theta !== void 0) {
         return ce.function("Cos", [theta]).add(ce.function("Sin", [theta]).mul(ce.I)).simplify();
       }
     } else {
-      if (typeof exp2 === "number") {
-        return ce.number(ce._numericValue(ce.E.N().numericValue).pow(exp2));
-      } else if (exp2.isNumberLiteral) {
+      if (typeof exp3 === "number") {
+        return ce.number(ce._numericValue(ce.E.N().numericValue).pow(exp3));
+      } else if (exp3.isNumberLiteral) {
         return ce.number(
-          ce._numericValue(ce.E.N().numericValue).pow(exp2.numericValue)
+          ce._numericValue(ce.E.N().numericValue).pow(exp3.numericValue)
         );
       }
     }
   }
   if (x.operator === "Power") {
     const [base, power] = x.ops;
-    return pow2(base, power.mul(exp2), { numericApproximation });
+    return pow2(base, power.mul(exp3), { numericApproximation });
   }
   if (x.operator === "Divide") {
     const [num, denom] = x.ops;
-    return pow2(num, exp2, { numericApproximation }).div(
-      pow2(denom, exp2, { numericApproximation })
+    return pow2(num, exp3, { numericApproximation }).div(
+      pow2(denom, exp3, { numericApproximation })
     );
   }
   if (x.operator === "Negate") {
     if (e !== void 0) {
-      if (e % 2 === 0) return pow2(x.op1, exp2, { numericApproximation });
-      return pow2(x.op1, exp2, { numericApproximation }).neg();
+      if (e % 2 === 0) return pow2(x.op1, exp3, { numericApproximation });
+      return pow2(x.op1, exp3, { numericApproximation }).neg();
     }
   }
   if (x.operator === "Sqrt") {
     if (e === 2) return x.op1;
     if (e !== void 0 && e % 2 === 0) return x.op1.pow(e / 2);
-    return pow2(x.op1, exp2, { numericApproximation }).sqrt();
+    return pow2(x.op1, exp3, { numericApproximation }).sqrt();
   }
   if (x.operator === "Exp")
-    return pow2(ce.E, x.op1.mul(exp2), { numericApproximation });
+    return pow2(ce.E, x.op1.mul(exp3), { numericApproximation });
   if (x.operator === "Multiply") {
-    const ops = x.ops.map((x2) => pow2(x2, exp2, { numericApproximation }));
+    const ops = x.ops.map((x2) => pow2(x2, exp3, { numericApproximation }));
     return ce._fn("Multiply", ops);
   }
-  if (typeof exp2 !== "number" && exp2.isNumberLiteral) {
-    const r = asRational(exp2);
+  if (typeof exp3 !== "number" && exp3.isNumberLiteral) {
+    const r = asRational(exp3);
     if (r !== void 0 && r[0] === 1)
       return root(x, ce.number(r[1]), { numericApproximation });
   }
   if (x.operator === "Root") {
     const [base, root2] = x.ops;
-    return pow2(base, ce.box(exp2).div(root2), { numericApproximation });
+    return pow2(base, ce.box(exp3).div(root2), { numericApproximation });
   }
   if (x.isNumberLiteral && Number.isInteger(e)) {
     const n = x.numericValue;
@@ -15467,37 +15467,37 @@ function pow2(x, exp2, { numericApproximation }) {
         (x2) => Math.pow(x2, e),
         (x2) => x2.pow(e),
         (x2) => x2.pow(e)
-      ) ?? ce._fn("Power", [x, ce.box(exp2)]);
+      ) ?? ce._fn("Power", [x, ce.box(exp3)]);
     } else {
       return ce.number(n.pow(e));
     }
   }
-  return ce._fn("Power", [x, ce.box(exp2)]);
+  return ce._fn("Power", [x, ce.box(exp3)]);
 }
 function root(a, b, { numericApproximation }) {
   if (!a.isCanonical || !b.isCanonical)
     return a.engine._fn("Root", [a, b], { canonical: false });
   if (numericApproximation) {
     if (a.isNumberLiteral && b.isNumberLiteral) {
-      const isNegative = a.isNegative;
+      const isNegative2 = a.isNegative;
       const isEven = b.isEven;
-      if (isNegative) a = a.neg();
+      if (isNegative2) a = a.neg();
       return apply2(
         a,
         b,
         (a2, b2) => {
           const result = Math.pow(a2, 1 / b2);
-          if (isNegative && !isEven) return -result;
+          if (isNegative2 && !isEven) return -result;
           return result;
         },
         (a2, b2) => {
           const result = a2.pow(b2.pow(-1));
-          if (isNegative && !isEven) return result.neg();
+          if (isNegative2 && !isEven) return result.neg();
           return result;
         },
         (a2, b2) => {
           const result = a2.pow(typeof b2 === "number" ? 1 / b2 : b2.inverse());
-          if (isNegative && !isEven) return result.neg();
+          if (isNegative2 && !isEven) return result.neg();
           return result;
         }
       ) ?? root(a, b, { numericApproximation: false });
@@ -15843,7 +15843,7 @@ var init_product = __esm({
        * If `this._isCanonical` a running product of exact terms is kept.
        * Otherwise, terms and their exponent are tallied.
        */
-      mul(term, exp2) {
+      mul(term, exp3) {
         console.assert(term.isCanonical || term.isStructural);
         if (this.coefficient.isNaN) return;
         if (term.isNaN) {
@@ -15851,17 +15851,17 @@ var init_product = __esm({
           return;
         }
         if (term.operator === "Multiply") {
-          for (const t of term.ops) this.mul(t, exp2);
+          for (const t of term.ops) this.mul(t, exp3);
           return;
         }
         if (term.operator === "Negate") {
-          this.mul(term.op1, exp2);
+          this.mul(term.op1, exp3);
           this.coefficient = this.coefficient.neg();
           return;
         }
         if (this._isCanonical) {
           if (term.symbol === "Nothing") return;
-          exp2 ??= [1, 1];
+          exp3 ??= [1, 1];
           const num = term.numericValue;
           if (num !== null) {
             if (term.is(1)) return;
@@ -15870,14 +15870,14 @@ var init_product = __esm({
                 this.coefficient = this.engine._numericValue(NaN);
                 return;
               }
-              this.coefficient = this.engine._numericValue(isZero(exp2) ? NaN : 0);
+              this.coefficient = this.engine._numericValue(isZero(exp3) ? NaN : 0);
               return;
             }
             if (term.is(-1)) {
-              if (isOne(exp2)) this.coefficient = this.coefficient.neg();
+              if (isOne(exp3)) this.coefficient = this.coefficient.neg();
               else {
                 this.coefficient = this.coefficient.mul(
-                  this.engine._numericValue(-1).pow(this.engine._numericValue(exp2))
+                  this.engine._numericValue(-1).pow(this.engine._numericValue(exp3))
                 );
               }
               return;
@@ -15887,21 +15887,21 @@ var init_product = __esm({
                 this.coefficient = this.engine._numericValue(NaN);
                 return;
               }
-              if (isOne(exp2)) {
+              if (isOne(exp3)) {
                 const coefSign = this.coefficient.sgn();
                 const termSign = term.isNegative ? -1 : 1;
                 const resultSign = coefSign * termSign;
                 this.coefficient = this.engine._numericValue(
                   resultSign < 0 ? -Infinity : Infinity
                 );
-              } else this.terms.push({ term, exponent: exp2 });
+              } else this.terms.push({ term, exponent: exp3 });
               return;
             }
-            if (isOne(exp2)) {
+            if (isOne(exp3)) {
               this.coefficient = this.coefficient.mul(num);
             } else
               this.coefficient = this.coefficient.mul(
-                this.engine._numericValue(num).pow(this.engine._numericValue(exp2))
+                this.engine._numericValue(num).pow(this.engine._numericValue(exp3))
               );
             return;
           }
@@ -15911,7 +15911,7 @@ var init_product = __esm({
               this.engine._numericValue({
                 radical: radical[0] * radical[1],
                 rational: [1, Number(radical[1])]
-              }).pow(this.engine._numericValue(exp2))
+              }).pow(this.engine._numericValue(exp3))
             );
             return;
           }
@@ -15920,20 +15920,20 @@ var init_product = __esm({
             if (!isSymbolicRadical) {
               let coef;
               [coef, term] = term.toNumericValue();
-              if (exp2 && !isOne(exp2))
-                coef = coef.pow(this.engine._numericValue(exp2));
+              if (exp3 && !isOne(exp3))
+                coef = coef.pow(this.engine._numericValue(exp3));
               this.coefficient = this.coefficient.mul(coef);
             }
           }
         }
-        if (term.is(1) && (!exp2 || isOne(exp2))) return;
-        if (term.is(0) === false && exp2 && isZero(exp2)) return;
+        if (term.is(1) && (!exp3 || isOne(exp3))) return;
+        if (term.is(0) === false && exp3 && isZero(exp3)) return;
         if (term.is(0)) {
-          if (exp2 && isZero(exp2)) this.coefficient = this.engine._numericValue(NaN);
+          if (exp3 && isZero(exp3)) this.coefficient = this.engine._numericValue(NaN);
           else this.coefficient = this.engine._numericValue(0);
           return;
         }
-        const exponent = exp2 ?? [1, 1];
+        const exponent = exp3 ?? [1, 1];
         if (term.operator === "Power") {
           const r = asRational(term.op2);
           if (r) {
@@ -16133,8 +16133,8 @@ function serializeSubtract(ce, a, b, options, metadata) {
 function serializePrettyJsonFunction(ce, name, args, options, metadata) {
   const exclusions = options.exclude;
   if (name === "Add" && args.length === 2 && !exclusions.includes("Subtract")) {
-    const sub2 = serializeSubtract(ce, args[0], args[1], options, metadata) ?? serializeSubtract(ce, args[1], args[0], options, metadata);
-    if (sub2) return sub2;
+    const sub3 = serializeSubtract(ce, args[0], args[1], options, metadata) ?? serializeSubtract(ce, args[1], args[0], options, metadata);
+    if (sub3) return sub3;
   }
   if (name === "Divide" && args.length === 2 && exclusions.includes("Divide")) {
     return serializeJsonFunction(
@@ -16175,8 +16175,8 @@ function serializePrettyJsonFunction(ce, name, args, options, metadata) {
     if (!exclusions.includes("Exp") && args[0]?.symbol === "ExponentialE")
       return serializeJsonFunction(ce, "Exp", [args[1]], options, metadata);
     if (args[1]?.numericValue !== null) {
-      const exp2 = asSmallInteger(args[1]);
-      if (exp2 === 2 && !exclusions.includes("Square"))
+      const exp3 = asSmallInteger(args[1]);
+      if (exp3 === 2 && !exclusions.includes("Square"))
         return serializeJsonFunction(
           ce,
           "Square",
@@ -16184,11 +16184,11 @@ function serializePrettyJsonFunction(ce, name, args, options, metadata) {
           options,
           metadata
         );
-      if (exp2 !== null && exp2 < 0 && !exclusions.includes("Divide")) {
+      if (exp3 !== null && exp3 < 0 && !exclusions.includes("Divide")) {
         return serializeJsonFunction(
           ce,
           "Divide",
-          [ce.One, exp2 === -1 ? args[0] : args[0].pow(-exp2)],
+          [ce.One, exp3 === -1 ? args[0] : args[0].pow(-exp3)],
           options,
           metadata
         );
@@ -20527,10 +20527,10 @@ var init_abstract_boxed_expression = __esm({
       div(rhs) {
         return this.engine.NaN;
       }
-      pow(exp2) {
+      pow(exp3) {
         return this.engine.NaN;
       }
-      root(exp2) {
+      root(exp3) {
         return this.engine.NaN;
       }
       sqrt() {
@@ -21071,7 +21071,7 @@ function parseRule(ce, rule, options) {
         `Invalid rule "${rule}"
 |   The condition expression contains wildcards not present in the match expression`
       );
-    condFn = (sub2) => condition.subs(sub2).canonical.evaluate()?.symbol === "True";
+    condFn = (sub3) => condition.subs(sub3).canonical.evaluate()?.symbol === "True";
   }
   return boxRule(ce, { match: match2, replace: replace2, condition: condFn, id: rule }, options);
 }
@@ -21217,19 +21217,19 @@ function applyRule(rule, expr, substitution, options) {
   const useVariations = rule.useVariations ?? options?.useVariations ?? false;
   const matchPermutations = options?.matchPermutations ?? true;
   onBeforeMatch?.(rule, expr);
-  const sub2 = match2 ? expr.match(match2, {
+  const sub3 = match2 ? expr.match(match2, {
     substitution,
     useVariations,
     recursive: false,
     matchPermutations
   }) : {};
-  if (sub2 === null) return operandsMatched ? { value: expr, because } : null;
+  if (sub3 === null) return operandsMatched ? { value: expr, because } : null;
   if (typeof condition === "function") {
     const conditionSub = {
       ...Object.fromEntries(
-        Object.entries(sub2).map(([k, v]) => [k.slice(1), v])
+        Object.entries(sub3).map(([k, v]) => [k.slice(1), v])
       ),
-      ...sub2
+      ...sub3
     };
     try {
       if (!condition(conditionSub, expr.engine))
@@ -21246,7 +21246,7 @@ function applyRule(rule, expr, substitution, options) {
   }
   if (!canonical2 && options?.canonical === void 0 && replace2 instanceof _BoxedExpression && replace2.isCanonical)
     canonical2 = true;
-  const result = typeof replace2 === "function" ? replace2(expr, sub2) : replace2.subs(sub2, { canonical: canonical2 });
+  const result = typeof replace2 === "function" ? replace2(expr, sub3) : replace2.subs(sub3, { canonical: canonical2 });
   if (!result) return null;
   onMatch?.(rule, expr, result);
   if (isRuleStep(result))
@@ -21291,10 +21291,10 @@ ${e.message}`);
   }
   return steps;
 }
-function matchAnyRules(expr, rules, sub2, options) {
+function matchAnyRules(expr, rules, sub3, options) {
   const results = [];
   for (const rule of rules.rules) {
-    const r = applyRule(rule, expr, sub2, options);
+    const r = applyRule(rule, expr, sub3, options);
     if (r !== null && !results.some((x) => x.isSame(r.value)))
       results.push(r.value);
   }
@@ -21391,8 +21391,8 @@ var init_rules = __esm({
 });
 
 // src/compute-engine/boxed-expression/solve.ts
-function filter(sub2) {
-  for (const [k, v] of Object.entries(sub2)) {
+function filter(sub3) {
+  for (const [k, v] of Object.entries(sub3)) {
     if (k !== "x" && k !== "_x" && v.has("_x")) return false;
   }
   return true;
@@ -21786,7 +21786,7 @@ var init_solve = __esm({
           ["Divide", 1, "_n"]
         ],
         useVariations: true,
-        condition: (sub2) => filter(sub2) && !sub2._n.is(0)
+        condition: (sub3) => filter(sub3) && !sub3._n.is(0)
       },
       {
         match: ["Add", ["Multiply", "_a", ["Power", "_x", "_n"]], "__b"],
@@ -21795,7 +21795,7 @@ var init_solve = __esm({
           ["Power", ["Divide", ["Negate", "__b"], "_a"], ["Divide", 1, "_n"]]
         ],
         useVariations: true,
-        condition: (sub2) => filter(sub2) && !sub2._n.is(0) && (sub2._n.isEven ?? false)
+        condition: (sub3) => filter(sub3) && !sub3._n.is(0) && (sub3._n.isEven ?? false)
       },
       //
       // Quadratic without constant: ax^2 + bx = 0
@@ -21877,7 +21877,7 @@ var init_solve = __esm({
         useVariations: true,
         onBeforeMatch: () => {
         },
-        condition: (sub2) => filter(sub2) && (sub2._a.isPositive ?? false) && (sub2.__b.isNegative ?? false)
+        condition: (sub3) => filter(sub3) && (sub3._a.isPositive ?? false) && (sub3.__b.isNegative ?? false)
       },
       // a * e^(bx) + c = 0
       {
@@ -21888,42 +21888,42 @@ var init_solve = __esm({
         ],
         replace: ["Divide", ["Ln", ["Negate", ["Divide", "__c", "__a"]]], "__b"],
         useVariations: true,
-        condition: (sub2) => filter(sub2) && ((!sub2.__a.is(0) && sub2.__c.div(sub2.__a).isNegative) ?? false)
+        condition: (sub3) => filter(sub3) && ((!sub3.__a.is(0) && sub3.__c.div(sub3.__a).isNegative) ?? false)
       },
       // a * e^(x) + c = 0
       {
         match: ["Add", ["Multiply", "__a", ["Exp", "_x"]], "__c"],
         replace: ["Ln", ["Negate", ["Divide", "__c", "__a"]]],
         useVariations: true,
-        condition: (sub2) => filter(sub2) && ((!sub2.__a.is(0) && sub2.__c.div(sub2.__a).isNegative) ?? false) && !sub2.__a.has("_x") && !sub2.__c.has("_x")
+        condition: (sub3) => filter(sub3) && ((!sub3.__a.is(0) && sub3.__c.div(sub3.__a).isNegative) ?? false) && !sub3.__a.has("_x") && !sub3.__c.has("_x")
       },
       // e^(x) + c = 0
       {
         match: ["Add", ["Exp", "_x"], "__c"],
         replace: ["Ln", ["Negate", "__c"]],
         useVariations: true,
-        condition: (sub2) => filter(sub2) && (sub2.__c.isNegative ?? false)
+        condition: (sub3) => filter(sub3) && (sub3.__c.isNegative ?? false)
       },
       // e^(bx) + c = 0
       {
         match: ["Add", ["Exp", ["Multiply", "__b", "_x"]], "__c"],
         replace: ["Divide", ["Ln", ["Negate", "__c"]], "__b"],
         useVariations: true,
-        condition: (sub2) => filter(sub2) && (sub2.__c.isNegative ?? false)
+        condition: (sub3) => filter(sub3) && (sub3.__c.isNegative ?? false)
       },
       // a * log_b(x) + c = 0
       {
         match: ["Add", ["Multiply", "__a", ["Log", "_x", "__b"]], "__c"],
         replace: ["Power", "__b", ["Negate", ["Divide", "__c", "__a"]]],
         useVariations: true,
-        condition: (sub2) => (filter(sub2) && !sub2.__a.is(0) && sub2.__b.isPositive) ?? false
+        condition: (sub3) => (filter(sub3) && !sub3.__a.is(0) && sub3.__b.isPositive) ?? false
       },
       // a * log_b(x) = 0
       {
         match: ["Multiply", "__a", ["Log", "_x", "__b"]],
         replace: ["Power", "__b", ["Negate", ["Divide", "__c", "__a"]]],
         useVariations: true,
-        condition: (sub2) => (filter(sub2) && !sub2.__a.is(0) && sub2.__b.isPositive) ?? false
+        condition: (sub3) => (filter(sub3) && !sub3.__a.is(0) && sub3.__b.isPositive) ?? false
       },
       // |ax + b| + c = 0
       {
@@ -22053,10 +22053,10 @@ var init_solve = __esm({
         match: ["Add", ["Multiply", "__a", ["Sqrt", "_x"]], "__b"],
         replace: ["Square", ["Divide", ["Negate", "__b"], "__a"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const a = sub2.__a;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const a = sub3.__a;
+          const b = sub3.__b;
           if (!a || !b) return false;
           const ratio = b.div(a);
           return ratio.isNonPositive ?? true;
@@ -22088,10 +22088,10 @@ var init_solve = __esm({
         match: ["Add", ["Multiply", "__a", ["Sin", "_x"]], "__b"],
         replace: ["Arcsin", ["Divide", ["Negate", "__b"], "__a"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const a = sub2.__a;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const a = sub3.__a;
+          const b = sub3.__b;
           if (!a || a.is(0)) return false;
           const ratio = b.div(a).neg();
           const val = ratio.numericValue;
@@ -22109,10 +22109,10 @@ var init_solve = __esm({
           ["Arcsin", ["Divide", ["Negate", "__b"], "__a"]]
         ],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const a = sub2.__a;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const a = sub3.__a;
+          const b = sub3.__b;
           if (!a || a.is(0)) return false;
           const ratio = b.div(a).neg();
           const val = ratio.numericValue;
@@ -22126,9 +22126,9 @@ var init_solve = __esm({
         match: ["Add", ["Sin", "_x"], "__b"],
         replace: ["Arcsin", ["Negate", "__b"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const b = sub3.__b;
           const val = b.numericValue;
           if (val === null) return true;
           if (typeof val === "number") return Math.abs(val) <= 1;
@@ -22140,9 +22140,9 @@ var init_solve = __esm({
         match: ["Add", ["Sin", "_x"], "__b"],
         replace: ["Subtract", "Pi", ["Arcsin", ["Negate", "__b"]]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const b = sub3.__b;
           const val = b.numericValue;
           if (val === null) return true;
           if (typeof val === "number") return Math.abs(val) <= 1;
@@ -22155,10 +22155,10 @@ var init_solve = __esm({
         match: ["Add", ["Multiply", "__a", ["Cos", "_x"]], "__b"],
         replace: ["Arccos", ["Divide", ["Negate", "__b"], "__a"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const a = sub2.__a;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const a = sub3.__a;
+          const b = sub3.__b;
           if (!a || a.is(0)) return false;
           const ratio = b.div(a).neg();
           const val = ratio.numericValue;
@@ -22172,10 +22172,10 @@ var init_solve = __esm({
         match: ["Add", ["Multiply", "__a", ["Cos", "_x"]], "__b"],
         replace: ["Negate", ["Arccos", ["Divide", ["Negate", "__b"], "__a"]]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const a = sub2.__a;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const a = sub3.__a;
+          const b = sub3.__b;
           if (!a || a.is(0)) return false;
           const ratio = b.div(a).neg();
           const val = ratio.numericValue;
@@ -22189,9 +22189,9 @@ var init_solve = __esm({
         match: ["Add", ["Cos", "_x"], "__b"],
         replace: ["Arccos", ["Negate", "__b"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const b = sub3.__b;
           const val = b.numericValue;
           if (val === null) return true;
           if (typeof val === "number") return Math.abs(val) <= 1;
@@ -22203,9 +22203,9 @@ var init_solve = __esm({
         match: ["Add", ["Cos", "_x"], "__b"],
         replace: ["Negate", ["Arccos", ["Negate", "__b"]]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          const b = sub2.__b;
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          const b = sub3.__b;
           const val = b.numericValue;
           if (val === null) return true;
           if (typeof val === "number") return Math.abs(val) <= 1;
@@ -22218,9 +22218,9 @@ var init_solve = __esm({
         match: ["Add", ["Multiply", "__a", ["Tan", "_x"]], "__b"],
         replace: ["Arctan", ["Divide", ["Negate", "__b"], "__a"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          return !sub2.__a.is(0);
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          return !sub3.__a.is(0);
         }
       },
       // tan(x) + b = 0  =>  x = arctan(-b)  (when a = 1)
@@ -22235,9 +22235,9 @@ var init_solve = __esm({
         match: ["Add", ["Multiply", "__a", ["Cot", "_x"]], "__b"],
         replace: ["Arccot", ["Divide", ["Negate", "__b"], "__a"]],
         useVariations: true,
-        condition: (sub2) => {
-          if (!filter(sub2)) return false;
-          return !sub2.__a.is(0);
+        condition: (sub3) => {
+          if (!filter(sub3)) return false;
+          return !sub3.__a.is(0);
         }
       },
       // cot(x) + b = 0  =>  x = arccot(-b)
@@ -24165,11 +24165,11 @@ function erf(x) {
   const a4 = -1.453152027;
   const a5 = 1.061405429;
   const p = 0.3275911;
-  const sign2 = x < 0 ? -1 : 1;
+  const sign3 = x < 0 ? -1 : 1;
   x = Math.abs(x);
   const t = 1 / (1 + p * x);
   const y = ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t;
-  return sign2 * (1 - y * Math.exp(-x * x));
+  return sign3 * (1 - y * Math.exp(-x * x));
 }
 function bigGammaln(ce, z) {
   if (z.isNegative()) return ce._BIGNUM_NAN;
@@ -25005,19 +25005,19 @@ var init_arithmetic = __esm({
           broadcastable: true,
           complexity: 3500,
           signature: "(number, number) -> number",
-          type: ([base, exp2]) => {
-            if (base.isNaN || exp2.isNaN) return "number";
-            if (!exp2.isFinite) return "non_finite_number";
-            if (base.isInteger && exp2.isInteger) return "finite_integer";
-            if (base.isRational && exp2.isInteger) return "finite_rational";
-            if (base.isReal && exp2.isReal) return "finite_real";
+          type: ([base, exp3]) => {
+            if (base.isNaN || exp3.isNaN) return "number";
+            if (!exp3.isFinite) return "non_finite_number";
+            if (base.isInteger && exp3.isInteger) return "finite_integer";
+            if (base.isRational && exp3.isInteger) return "finite_rational";
+            if (base.isReal && exp3.isReal) return "finite_real";
             return "finite_number";
           },
           canonical: (args, { engine }) => {
             args = checkNumericArgs(engine, args, 2);
             if (args.length !== 2) return engine._fn("Power", args);
-            const [base, exp2] = args;
-            return canonicalPower(base, exp2);
+            const [base, exp3] = args;
+            return canonicalPower(base, exp3);
           },
           sgn: ([a, b]) => {
             const aSgn = a.sgn;
@@ -25090,13 +25090,13 @@ var init_arithmetic = __esm({
           complexity: 3200,
           broadcastable: true,
           signature: "(number, number) -> number",
-          type: ([base, exp2]) => {
-            if (base.isNaN || exp2.isNaN) return "number";
-            if (base.isFinite === false || exp2.isFinite === false)
+          type: ([base, exp3]) => {
+            if (base.isNaN || exp3.isNaN) return "number";
+            if (base.isFinite === false || exp3.isFinite === false)
               return "non_finite_number";
-            if (exp2.is(0)) return "finite_integer";
-            if (exp2.is(1)) return base.type;
-            if (base.isReal && exp2.isReal) {
+            if (exp3.is(0)) return "finite_integer";
+            if (exp3.is(1)) return base.type;
+            if (base.isReal && exp3.isReal) {
               if (base.isPositive === true) return "finite_real";
               return "finite_number";
             }
@@ -25120,8 +25120,8 @@ var init_arithmetic = __esm({
           },
           canonical: (args, { engine }) => {
             args = checkNumericArgs(engine, args, 2);
-            const [base, exp2] = args;
-            return canonicalRoot(base, exp2);
+            const [base, exp3] = args;
+            return canonicalRoot(base, exp3);
           },
           evaluate: ([x, n], { numericApproximation }) => root(x, n, { numericApproximation })
         },
@@ -25980,9 +25980,9 @@ function serializeAdd(serializer, expr) {
     for (let i = 2; i < last; i++) {
       arg = ops[i - 1];
       if (serializer.options.prettify) {
-        const [newArg, sign2] = unsign(arg);
+        const [newArg, sign3] = unsign(arg);
         const term = serializer.wrap(newArg, ADDITION_PRECEDENCE);
-        if (sign2 > 0) {
+        if (sign3 > 0) {
           if (term.startsWith("+") || term.startsWith("-")) result += term;
           else result += "+" + term;
         } else {
@@ -26024,7 +26024,7 @@ function serializeMultiply(serializer, expr) {
     serializer.level += 1;
     return result;
   }
-  let isNegative = false;
+  let isNegative2 = false;
   let arg = null;
   const count = nops(expr) + 1;
   let xs = operands(expr);
@@ -26044,11 +26044,11 @@ function serializeMultiply(serializer, expr) {
       term = serializer.serialize(arg);
       if (term === "-1" && !result) {
         result = "";
-        isNegative = !isNegative;
+        isNegative2 = !isNegative2;
       } else {
         if (term[0] === "-") {
           term = term.slice(1);
-          isNegative = !isNegative;
+          isNegative2 = !isNegative2;
         }
         if (!result) result = term;
         else result = latexTemplate(serializer.options.multiply, result, term);
@@ -26081,7 +26081,7 @@ function serializeMultiply(serializer, expr) {
     }
     if (operator(arg) === "Negate") {
       arg = operand(arg, 1);
-      isNegative = !isNegative;
+      isNegative2 = !isNegative2;
     }
     term = serializer.wrap(arg, MULTIPLICATION_PRECEDENCE);
     if (!result) {
@@ -26103,7 +26103,7 @@ function serializeMultiply(serializer, expr) {
     prevWasNumber = false;
   }
   serializer.level += 1;
-  return isNegative ? "-" + result : result;
+  return isNegative2 ? "-" + result : result;
 }
 function parseFraction(parser) {
   let numer = parser.parseGroup();
@@ -26207,26 +26207,26 @@ function serializePower(serializer, expr) {
       2
     );
   }
-  const exp2 = missingIfEmpty(operand(expr, 2));
+  const exp3 = missingIfEmpty(operand(expr, 2));
   if (name === "Root")
     return serializeRoot(
       serializer,
       serializer.rootStyle(expr, serializer.level - 1),
       base,
-      exp2
+      exp3
     );
   if (serializer.options.prettify) {
-    const val2 = machineValue(exp2) ?? 1;
+    const val2 = machineValue(exp3) ?? 1;
     if (val2 === -1) {
       return serializer.serialize(["Divide", "1", base]);
     } else if (val2 < 0) {
       return serializer.serialize(["Divide", "1", ["Power", base, -val2]]);
-    } else if (operator(exp2) === "Divide" || operator(exp2) === "Rational") {
-      const num = machineValue(operand(exp2, 1));
-      const denom = machineValue(operand(exp2, 2));
+    } else if (operator(exp3) === "Divide" || operator(exp3) === "Rational") {
+      const num = machineValue(operand(exp3, 1));
+      const denom = machineValue(operand(exp3, 2));
       if (num === 1) {
         const style = serializer.rootStyle(expr, serializer.level);
-        return serializeRoot(serializer, style, base, operand(exp2, 2));
+        return serializeRoot(serializer, style, base, operand(exp3, 2));
       }
       if (num === -1) {
         if (denom === 2) {
@@ -26235,18 +26235,18 @@ function serializePower(serializer, expr) {
         return serializer.serialize([
           "Divide",
           "1",
-          ["Root", base, operand(exp2, 2)]
+          ["Root", base, operand(exp3, 2)]
         ]);
       }
       if (denom === 2) {
         return `${serializer.serialize(["Sqrt", base])}^{${serializer.serialize(
-          operand(exp2, 1)
+          operand(exp3, 1)
         )}}`;
       }
-    } else if (operator(exp2) === "Power") {
-      if (machineValue(operand(exp2, 2)) === -1) {
+    } else if (operator(exp3) === "Power") {
+      if (machineValue(operand(exp3, 2)) === -1) {
         const style = serializer.rootStyle(expr, serializer.level);
-        return serializeRoot(serializer, style, base, operand(exp2, 1));
+        return serializeRoot(serializer, style, base, operand(exp3, 1));
       }
     }
   }
@@ -26257,12 +26257,12 @@ function serializePower(serializer, expr) {
     const baseBodyLatex = wrapNegativeBase(serializer.wrapShort(baseBody));
     const baseExponentLatex = serializer.wrapShort(baseExponent);
     return `
-      ${baseBodyLatex}^{${supsub("^", baseExponentLatex, serializer.serialize(exp2))}}`;
+      ${baseBodyLatex}^{${supsub("^", baseExponentLatex, serializer.serialize(exp3))}}`;
   }
   return supsub(
     "^",
     wrapNegativeBase(serializer.wrapShort(base)),
-    serializer.serialize(exp2)
+    serializer.serialize(exp3)
   );
 }
 var DEFINITIONS_ARITHMETIC = [
@@ -27079,10 +27079,10 @@ function getSequenceOrTuple(expr) {
   }
   return [expr];
 }
-function getIndexes(sub2, sup) {
-  if (isEmptySequence(sub2)) sub2 = null;
+function getIndexes(sub3, sup) {
+  if (isEmptySequence(sub3)) sub3 = null;
   if (isEmptySequence(sup)) sup = null;
-  const subs = getSequenceOrTuple(sub2);
+  const subs = getSequenceOrTuple(sub3);
   const sups = getSequenceOrTuple(sup);
   const results = [];
   let i = 0;
@@ -27116,20 +27116,20 @@ function parseBigOp(name, reduceOp, minPrec) {
     parser.skipSpace();
     parser.pushSymbolTable();
     let sup = null;
-    let sub2 = null;
-    while (!(sub2 && sup) && (parser.peek === "_" || parser.peek === "^")) {
-      if (parser.match("_")) sub2 = parser.parseGroup() ?? parser.parseToken();
+    let sub3 = null;
+    while (!(sub3 && sup) && (parser.peek === "_" || parser.peek === "^")) {
+      if (parser.match("_")) sub3 = parser.parseGroup() ?? parser.parseToken();
       else if (parser.match("^"))
         sup = parser.parseGroup() ?? parser.parseToken();
       parser.skipSpace();
     }
-    if (!sup && !sub2) {
+    if (!sup && !sub3) {
       const collection = parser.parseExpression({ minPrec });
       parser.popSymbolTable();
       if (collection) return ["Reduce", collection, reduceOp];
       return null;
     }
-    const indexes = getIndexes(sub2, sup);
+    const indexes = getIndexes(sub3, sup);
     const fn = parser.parseExpression({ minPrec });
     parser.popSymbolTable();
     if (fn === null) return [name];
@@ -27223,47 +27223,47 @@ function serializeBigOp(command) {
   };
 }
 function parseLog(command, parser) {
-  let sub2 = null;
-  if (parser.match("_")) sub2 = parser.parseGroup() ?? parser.parseToken();
+  let sub3 = null;
+  if (parser.match("_")) sub3 = parser.parseGroup() ?? parser.parseToken();
   const args = parser.parseArguments("implicit");
-  if (args === null && sub2 === null) return [command];
-  if (args === null) return [command, sub2];
-  if (sub2 === null) return [command, ...args];
-  if (sub2 === 10) return ["Log", args[0]];
-  if (sub2 === 2) return ["Lb", ...args];
-  return ["Log", args[0], sub2];
+  if (args === null && sub3 === null) return [command];
+  if (args === null) return [command, sub3];
+  if (sub3 === null) return [command, ...args];
+  if (sub3 === 10) return ["Log", args[0]];
+  if (sub3 === 2) return ["Lb", ...args];
+  return ["Log", args[0], sub3];
 }
 function unsign(expr) {
-  let sign2 = 1;
+  let sign3 = 1;
   let newExpr = expr;
   do {
     expr = newExpr;
     const fnName = operator(expr);
     if (fnName === "Negate") {
-      sign2 *= -1;
+      sign3 *= -1;
       newExpr = operand(expr, 1);
     } else if (fnName === "Multiply") {
       const [first, firstSign] = unsign(operand(expr, 1));
       if (firstSign < 0) {
-        sign2 *= -1;
+        sign3 *= -1;
         if (first === 1) newExpr = ["Multiply", ...operands(expr).slice(1)];
         else newExpr = ["Multiply", first, ...operands(expr).slice(1)];
       }
     } else if (fnName === "Divide" || fnName === "Rational") {
       const [numer, numerSign] = unsign(operand(expr, 1));
       if (numerSign < 0) {
-        sign2 *= -1;
+        sign3 *= -1;
         newExpr = [fnName, numer, operand(expr, 2)];
       }
     } else {
       const val = machineValue(expr);
       if (val !== null && val < 0) {
-        sign2 *= -1;
+        sign3 *= -1;
         newExpr = -val;
       }
     }
   } while (newExpr !== expr);
-  return [expr, sign2];
+  return [expr, sign3];
 }
 
 // src/compute-engine/latex-syntax/dictionary/definitions.ts
@@ -28087,26 +28087,26 @@ var DEFINITIONS_OTHERS = [
     parse: (parser) => {
       let done = false;
       let sup = "Nothing";
-      let sub2 = "Nothing";
+      let sub3 = "Nothing";
       while (!done) {
         parser.skipSpace();
         if (parser.match("_")) {
-          sub2 = parser.parseGroup() ?? parser.parseToken();
+          sub3 = parser.parseGroup() ?? parser.parseToken();
         } else if (parser.match("^")) {
           sup = parser.parseGroup() ?? parser.parseToken();
         } else {
           done = true;
         }
       }
-      const seq = getSequence(sub2);
-      if (seq) sub2 = ["List", ...seq];
-      if (sub2 === null || sup === null) return null;
+      const seq = getSequence(sub3);
+      if (seq) sub3 = ["List", ...seq];
+      if (sub3 === null || sup === null) return null;
       let rhs = parser.parseGroup() ?? "Nothing";
       if (!isEmptySequence(rhs)) {
         const args = parser.parseArguments() ?? ["Nothing"];
         rhs = [rhs, ...args];
       }
-      return ["PartialDerivative", rhs, sub2, sup];
+      return ["PartialDerivative", rhs, sub3, sup];
     },
     serialize: (serializer, expr) => {
       let result = "\\partial";
@@ -29337,17 +29337,17 @@ function parseIntegral(command) {
       parser.match("\\limits");
       parser.skipSpace();
       let sup = null;
-      let sub2 = null;
-      while (!(sub2 !== null && sup !== null) && (parser.peek === "_" || parser.peek === "^")) {
-        if (parser.match("_")) sub2 = parser.parseGroup() ?? parser.parseToken();
+      let sub3 = null;
+      while (!(sub3 !== null && sup !== null) && (parser.peek === "_" || parser.peek === "^")) {
+        if (parser.match("_")) sub3 = parser.parseGroup() ?? parser.parseToken();
         else if (parser.match("^")) {
           sup = parser.parseGroup() ?? parser.parseToken();
         }
         parser.skipSpace();
       }
-      if (isEmptySequence(sub2)) sub2 = null;
+      if (isEmptySequence(sub3)) sub3 = null;
       if (isEmptySequence(sup)) sup = null;
-      subs.push(sub2 ?? "Nothing");
+      subs.push(sub3 ?? "Nothing");
       sups.push(sup ?? "Nothing");
       parser.skipVisualSpace();
       done = !parser.match(command);
@@ -29414,9 +29414,9 @@ function makeIntegral(command, fn, limits) {
   }
   const tuples = indexes.map((idx, i) => {
     const sup = limits.sups[i];
-    const sub2 = limits.subs[i];
-    if (sub2 === "Nothing" && sup === "Nothing") return idx;
-    return ["Tuple", idx, sub2, sup];
+    const sub3 = limits.subs[i];
+    if (sub3 === "Nothing" && sup === "Nothing") return idx;
+    return ["Tuple", idx, sub3, sup];
   });
   return [command, fn, ...tuples];
 }
@@ -30451,9 +30451,9 @@ function parseSymbolBody(parser) {
   while (!parser.atEnd) {
     if (parser.match("_")) {
       const hasBrace = parser.match("<{>");
-      const sub2 = parseSymbolBody(parser);
-      if (hasBrace && !parser.match("<}>") || sub2 === null) return null;
-      subs.push(sub2);
+      const sub3 = parseSymbolBody(parser);
+      if (hasBrace && !parser.match("<}>") || sub3 === null) return null;
+      subs.push(sub3);
     } else if (parser.match("^")) {
       const hasBrace = parser.match("<{>");
       const sup = parseSymbolBody(parser);
@@ -30518,14 +30518,14 @@ function parseSymbol(parser) {
           parser.index = underscoreIndex;
           break;
         }
-        const sub2 = parseSymbolBody(parser);
-        const hasOperators = sub2 !== null && /plus|minus|times|ast/.test(sub2);
-        if (sub2 === null || sub2.includes(",") || hasOperators || parser.peek !== "<}>") {
+        const sub3 = parseSymbolBody(parser);
+        const hasOperators = sub3 !== null && /plus|minus|times|ast/.test(sub3);
+        if (sub3 === null || sub3.includes(",") || hasOperators || parser.peek !== "<}>") {
           parser.index = underscoreIndex;
           break;
         }
         parser.match("<}>");
-        id2 += "_" + sub2;
+        id2 += "_" + sub3;
       } else {
         const subToken = parser.peek;
         if (/^[a-zA-Z0-9]$/.test(subToken) || /^\p{XIDS}$/u.test(subToken)) {
@@ -31357,10 +31357,10 @@ var _Parser = class {
    *
    */
   parseOptionalSign() {
-    let isNegative = !!this.matchAny(["-", "\u2212"]);
+    let isNegative2 = !!this.matchAny(["-", "\u2212"]);
     while (this.matchAny(["+", "\uFE62"]) || this.skipSpace())
-      if (this.matchAny(["-", "\u2212"])) isNegative = !isNegative;
-    return isNegative ? "-" : "+";
+      if (this.matchAny(["-", "\u2212"])) isNegative2 = !isNegative2;
+    return isNegative2 ? "-" : "+";
   }
   /** Parse a sequence of decimal digits. The part indicates which
    * grouping separator should be expected.
@@ -31392,9 +31392,9 @@ var _Parser = class {
    */
   parseSignedInteger(part) {
     const start = this.index;
-    const sign2 = this.parseOptionalSign();
+    const sign3 = this.parseOptionalSign();
     const result = this.parseDecimalDigits(part);
-    if (result) return sign2 === "-" ? "-" + result : result;
+    if (result) return sign3 === "-" ? "-" + result : result;
     this.index = start;
     return "";
   }
@@ -31497,9 +31497,9 @@ var _Parser = class {
       return null;
     const start = this.index;
     this.skipVisualSpace();
-    let sign2 = 1;
+    let sign3 = 1;
     while (this.peek === "-" || this.peek === "+") {
-      if (this.match("-")) sign2 = -sign2;
+      if (this.match("-")) sign3 = -sign3;
       else this.match("+");
       this.skipVisualSpace();
     }
@@ -31536,34 +31536,66 @@ var _Parser = class {
     if (hasFractionalPart && !fractionalPart) {
       this.index = fractionalIndex;
       if (wholePart.length < 10)
-        return numberExpression(sign2 * parseInt(wholePart, 10));
-      return { num: sign2 < 0 ? "-" + wholePart : wholePart };
+        return numberExpression(sign3 * parseInt(wholePart, 10));
+      return { num: sign3 < 0 ? "-" + wholePart : wholePart };
     }
     const exponent = this.parseExponent();
     if (!hasFractionalPart && !exponent && wholePart.length < 10)
-      return numberExpression(sign2 * parseInt(wholePart, 10));
+      return numberExpression(sign3 * parseInt(wholePart, 10));
     if (!hasRepeatingPart && this.options.parseNumbers === "rational") {
-      const whole = parseInt(wholePart, 10);
+      const isLargeInteger = wholePart.length > 16 || wholePart.length === 16 && wholePart > "9007199254740991";
       if (!fractionalPart) {
+        if (isLargeInteger) {
+          const numStr = sign3 < 0 ? "-" + wholePart : wholePart;
+          if (exponent)
+            return ["Multiply", { num: numStr }, ["Power", 10, exponent]];
+          return { num: numStr };
+        }
+        const whole2 = parseInt(wholePart, 10);
         if (exponent)
-          return ["Multiply", sign2 * whole, ["Power", 10, exponent]];
-        return numberExpression(sign2 * whole);
+          return ["Multiply", sign3 * whole2, ["Power", 10, exponent]];
+        return numberExpression(sign3 * whole2);
       }
-      const fraction = parseInt(fractionalPart, 10);
       const n = fractionalPart.length;
+      const numeratorDigits = wholePart.length + n;
+      if (numeratorDigits > 15) {
+        const wholeBig = BigInt(wholePart);
+        const fractionBig = BigInt(fractionalPart);
+        const denominatorBig = BigInt(10) ** BigInt(n);
+        const numeratorBig = wholeBig * denominatorBig + fractionBig;
+        const signedNumerator = sign3 < 0 ? -numeratorBig : numeratorBig;
+        if (exponent) {
+          return [
+            "Multiply",
+            [
+              "Rational",
+              { num: signedNumerator.toString() },
+              Number(denominatorBig)
+            ],
+            ["Power", 10, exponent]
+          ];
+        }
+        return [
+          "Rational",
+          { num: signedNumerator.toString() },
+          Number(denominatorBig)
+        ];
+      }
+      const whole = parseInt(wholePart, 10);
+      const fraction = parseInt(fractionalPart, 10);
       const numerator = whole * 10 ** n + fraction;
       const denominator = 10 ** n;
       if (exponent) {
         return [
           "Multiply",
-          ["Rational", sign2 * numerator, denominator],
+          ["Rational", sign3 * numerator, denominator],
           ["Power", 10, exponent]
         ];
       }
-      return ["Rational", sign2 * numerator, denominator];
+      return ["Rational", sign3 * numerator, denominator];
     }
     return {
-      num: (sign2 < 0 ? "-" : "") + wholePart + (hasFractionalPart ? "." + fractionalPart : "") + (exponent ? "e" + exponent : "")
+      num: (sign3 < 0 ? "-" : "") + wholePart + (hasFractionalPart ? "." + fractionalPart : "") + (exponent ? "e" + exponent : "")
     };
   }
   parsePrefixOperator(until) {
@@ -31889,12 +31921,12 @@ var _Parser = class {
         if (this.match("_") || this.match("^"))
           subscripts.push(this.error("syntax-error", subIndex));
         else {
-          let sub2 = this.parseGroup() ?? this.parseToken();
-          if (sub2 === null && this.options.strict === false && this.peek === "(")
-            sub2 = this.parseEnclosure();
-          sub2 ??= this.parseStringGroup();
-          if (sub2 === null) return this.error("missing", index);
-          subscripts.push(sub2);
+          let sub3 = this.parseGroup() ?? this.parseToken();
+          if (sub3 === null && this.options.strict === false && this.peek === "(")
+            sub3 = this.parseEnclosure();
+          sub3 ??= this.parseStringGroup();
+          if (sub3 === null) return this.error("missing", index);
+          subscripts.push(sub3);
         }
       } else if (this.match("^")) {
         subIndex = this.index;
@@ -33005,8 +33037,8 @@ function tryCyclicExpTrigIntegral(factors, index) {
   }
   return null;
 }
-function filter2(sub2) {
-  for (const [k, v] of Object.entries(sub2)) {
+function filter2(sub3) {
+  for (const [k, v] of Object.entries(sub3)) {
     if (k !== "x" && k !== "_x" && v.has("_x")) return false;
   }
   return true;
@@ -33020,7 +33052,7 @@ var INTEGRATION_RULES = [
       ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], ["Add", "_n", 1]],
       ["Multiply", "_a", ["Add", "_n", 1]]
     ],
-    condition: (sub2) => filter2(sub2) && !sub2._n.is(-1)
+    condition: (sub3) => filter2(sub3) && !sub3._n.is(-1)
   },
   // \sqrt{ax + b} -> \frac{2}{3a} (ax + b)^{3/2}
   {
@@ -33030,7 +33062,7 @@ var INTEGRATION_RULES = [
       ["Multiply", 2, ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 3]],
       ["Multiply", 3, "_a"]
     ],
-    condition: (sub2) => filter2(sub2) && sub2._a.isNumberLiteral
+    condition: (sub3) => filter2(sub3) && sub3._a.isNumberLiteral
   },
   // \sqrt[3]{ax + b} -> \frac{3}{4a} (ax + b)^{4/3}
   {
@@ -33040,13 +33072,13 @@ var INTEGRATION_RULES = [
       ["Multiply", 3, ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 4]],
       ["Multiply", 4, "_a"]
     ],
-    condition: (sub2) => filter2(sub2) && sub2._a.isNumberLiteral
+    condition: (sub3) => filter2(sub3) && sub3._a.isNumberLiteral
   },
   // a^x -> \frac{a^x}{\ln(a)} where a is a constant (doesn't contain x)
   {
     match: ["Power", "_a", "_x"],
     replace: ["Divide", ["Power", "_a", "_x"], ["Ln", "_a"]],
-    condition: (sub2) => filter2(sub2) && !sub2._a.has("_x")
+    condition: (sub3) => filter2(sub3) && !sub3._a.has("_x")
   },
   // (ax+b)^{-1} -> \ln(ax + b) / a
   {
@@ -33062,7 +33094,7 @@ var INTEGRATION_RULES = [
   {
     match: ["Power", ["Add", "_x", "__b"], -1],
     replace: ["Ln", ["Abs", ["Add", "_x", "__b"]]],
-    condition: (sub2) => filter2(sub2) && sub2._x.symbol !== null
+    condition: (sub3) => filter2(sub3) && sub3._x.symbol !== null
   },
   // 1/(ax + b) -> \ln(ax + b) / a
   {
@@ -33078,7 +33110,7 @@ var INTEGRATION_RULES = [
   {
     match: ["Divide", 1, ["Add", "_x", "__b"]],
     replace: ["Ln", ["Abs", ["Add", "_x", "__b"]]],
-    condition: (sub2) => filter2(sub2) && sub2._x.symbol !== null
+    condition: (sub3) => filter2(sub3) && sub3._x.symbol !== null
   },
   // \ln(ax + b) -> (ax + b) \ln(ax + b) - ax - b
   {
@@ -33677,7 +33709,7 @@ var INTEGRATION_RULES = [
       ["Exp", "_x"],
       ["Subtract", ["Sin", "_x"], ["Cos", "_x"]]
     ],
-    condition: (sub2) => filter2(sub2) && sub2._x.symbol !== null
+    condition: (sub3) => filter2(sub3) && sub3._x.symbol !== null
   },
   // e^x * cos(x) -> (e^x/2)(sin(x) + cos(x))
   {
@@ -33688,7 +33720,7 @@ var INTEGRATION_RULES = [
       ["Exp", "_x"],
       ["Add", ["Sin", "_x"], ["Cos", "_x"]]
     ],
-    condition: (sub2) => filter2(sub2) && sub2._x.symbol !== null
+    condition: (sub3) => filter2(sub3) && sub3._x.symbol !== null
   },
   // sin(x) * e^x -> (e^x/2)(sin(x) - cos(x)) (commuted order)
   {
@@ -33699,7 +33731,7 @@ var INTEGRATION_RULES = [
       ["Exp", "_x"],
       ["Subtract", ["Sin", "_x"], ["Cos", "_x"]]
     ],
-    condition: (sub2) => filter2(sub2) && sub2._x.symbol !== null
+    condition: (sub3) => filter2(sub3) && sub3._x.symbol !== null
   },
   // cos(x) * e^x -> (e^x/2)(sin(x) + cos(x)) (commuted order)
   {
@@ -33710,7 +33742,7 @@ var INTEGRATION_RULES = [
       ["Exp", "_x"],
       ["Add", ["Sin", "_x"], ["Cos", "_x"]]
     ],
-    condition: (sub2) => filter2(sub2) && sub2._x.symbol !== null
+    condition: (sub3) => filter2(sub3) && sub3._x.symbol !== null
   },
   // e^x * sin(ax) -> (e^x/(a² + 1))(sin(ax) - a*cos(ax)) (no constant term)
   {
@@ -34101,8 +34133,8 @@ function antiderivative(fn, index) {
       const denom = fn.op2;
       if (denom.operator === "Power") {
         const base = denom.op1;
-        const exp2 = denom.op2;
-        const n = exp2.re;
+        const exp3 = denom.op2;
+        const n = exp3.re;
         if (n !== null && Number.isInteger(n) && n > 1) {
           const linearCoeffs = getLinearCoefficients(base, index);
           if (linearCoeffs) {
@@ -34142,8 +34174,8 @@ function antiderivative(fn, index) {
       const denom = fn.op2;
       if (denom.operator === "Power") {
         const base = denom.op1;
-        const exp2 = denom.op2;
-        const n = exp2.re;
+        const exp3 = denom.op2;
+        const n = exp3.re;
         if (n !== null && Number.isInteger(n) && n > 1) {
           const quadCoeffs = getQuadraticCoefficients(base, index);
           if (quadCoeffs && quadCoeffs.b.is(0) && quadCoeffs.a.is(1)) {
@@ -35266,10 +35298,10 @@ var COMPLEX_LIBRARY = [
         const roots = [];
         const im = ops[0].im ?? 0;
         const arg = Math.atan2(im, re);
-        const mod2 = Math.sqrt(re * re + im * im);
+        const mod3 = Math.sqrt(re * re + im * im);
         for (let k = 0; k < n; k++) {
           const theta = (arg + 2 * Math.PI * k) / n;
-          const r = Math.pow(mod2, 1 / n);
+          const r = Math.pow(mod3, 1 / n);
           roots.push([r * Math.cos(theta), r * Math.sin(theta)]);
         }
         return ce.function(
@@ -36776,8 +36808,8 @@ var CORE_LIBRARY = [
           if (isValueDef(symbolDef) && symbolDef.value.subscriptEvaluate) {
             return "number";
           }
-          const sub2 = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
-          if (sub2) return "symbol";
+          const sub3 = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
+          if (sub3) return "symbol";
           if (op2.operator === "InvisibleOperator" && op2.ops) {
             const parts = op2.ops.map(
               (x) => x.symbol ?? asSmallInteger(x)?.toString()
@@ -36818,8 +36850,8 @@ var CORE_LIBRARY = [
           }
         }
         if (op1.symbol) {
-          const sub3 = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
-          if (sub3) return ce.symbol(op1.symbol + "_" + sub3);
+          const sub4 = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
+          if (sub4) return ce.symbol(op1.symbol + "_" + sub4);
           if (op2.operator === "InvisibleOperator" && op2.ops) {
             const parts = op2.ops.map(
               (x) => x.symbol ?? asSmallInteger(x)?.toString()
@@ -36831,9 +36863,9 @@ var CORE_LIBRARY = [
         }
         if (op2.operator === "Sequence")
           ce._fn("Subscript", [op1, ce._fn("List", op2.ops)]);
-        let sub2 = op2;
-        if (op2.operator === "Delimiter" && op2.op1) sub2 = op2.op1.canonical;
-        return ce._fn("Subscript", [op1, sub2]);
+        let sub3 = op2;
+        if (op2.operator === "Delimiter" && op2.op1) sub3 = op2.op1.canonical;
+        return ce._fn("Subscript", [op1, sub3]);
       },
       evaluate: (ops, { engine: ce, numericApproximation }) => {
         const [base, subscript] = ops;
@@ -36895,11 +36927,11 @@ var CORE_LIBRARY = [
           timings.push(1e3 * (globalThis.performance.now() - start));
           n -= 1;
         }
-        const max2 = Math.max(...timings);
-        const min2 = Math.min(...timings);
-        timings = timings.filter((x) => x > min2 && x < max2);
+        const max3 = Math.max(...timings);
+        const min3 = Math.min(...timings);
+        timings = timings.filter((x) => x > min3 && x < max3);
         const sum2 = timings.reduce((acc, v) => acc + v, 0);
-        if (sum2 === 0) return ce.tuple(ce.number(max2), result);
+        if (sum2 === 0) return ce.tuple(ce.number(max3), result);
         return ce.tuple(ce.number(sum2 / timings.length), result);
       }
     }
@@ -38011,8 +38043,8 @@ function computeQR(M, m, n, ce) {
     }
     norm = Math.sqrt(norm);
     if (norm < 1e-10) continue;
-    const sign2 = R[k][k] >= 0 ? 1 : -1;
-    const u0 = R[k][k] + sign2 * norm;
+    const sign3 = R[k][k] >= 0 ? 1 : -1;
+    const u0 = R[k][k] + sign3 * norm;
     const v = Array(m).fill(0);
     v[k] = 1;
     for (let i = k + 1; i < m; i++) {
@@ -39127,8 +39159,8 @@ var NUMBER_THEORY_LIBRARY = [
             const pent1 = k * (3n * k - 1n) / 2n;
             const pent2 = k * (3n * k + 1n) / 2n;
             if (pent1 > n2 && pent2 > n2) break;
-            const sign2 = k % 2n === 0n ? -1n : 1n;
-            total += sign2 * (P2(n2 - pent1) + P2(n2 - pent2));
+            const sign3 = k % 2n === 0n ? -1n : 1n;
+            total += sign3 * (P2(n2 - pent1) + P2(n2 - pent2));
           }
           memo.set(n2, total);
           return total;
@@ -39143,9 +39175,9 @@ var NUMBER_THEORY_LIBRARY = [
         const k = toBigint(n);
         if (k === null || k < 1n) return ce.False;
         const D = 8n * k + 1n;
-        const sqrt2 = BigInt(decimal_default.sqrt(ce.bignum(D)).toFixed(0));
+        const sqrt3 = BigInt(decimal_default.sqrt(ce.bignum(D)).toFixed(0));
         return ce.symbol(
-          sqrt2 * sqrt2 === D && (sqrt2 - 1n) % 2n === 0n ? "True" : "False"
+          sqrt3 * sqrt3 === D && (sqrt3 - 1n) % 2n === 0n ? "True" : "False"
         );
       }
     },
@@ -39155,8 +39187,8 @@ var NUMBER_THEORY_LIBRARY = [
       evaluate: ([n], { engine: ce }) => {
         const k = toBigint(n);
         if (k === null || k < 0n) return ce.False;
-        const sqrt2 = BigInt(decimal_default.sqrt(ce.bignum(k)).toFixed(0));
-        return ce.symbol(sqrt2 * sqrt2 === k ? "True" : "False");
+        const sqrt3 = BigInt(decimal_default.sqrt(ce.bignum(k)).toFixed(0));
+        return ce.symbol(sqrt3 * sqrt3 === k ? "True" : "False");
       }
     },
     IsOctahedral: {
@@ -39166,8 +39198,8 @@ var NUMBER_THEORY_LIBRARY = [
         const k = toBigint(n);
         if (k === null || k < 1n) return ce.False;
         const discriminant = 3n * k + 1n;
-        const sqrt2 = BigInt(decimal_default.sqrt(ce.bignum(discriminant)).toFixed(0));
-        return ce.symbol(sqrt2 * sqrt2 === discriminant ? "True" : "False");
+        const sqrt3 = BigInt(decimal_default.sqrt(ce.bignum(discriminant)).toFixed(0));
+        return ce.symbol(sqrt3 * sqrt3 === discriminant ? "True" : "False");
       }
     },
     IsCenteredSquare: {
@@ -39178,8 +39210,8 @@ var NUMBER_THEORY_LIBRARY = [
         if (k === null || k < 1n) return ce.False;
         if ((k - 1n) % 4n !== 0n) return ce.False;
         const t = (k - 1n) / 4n;
-        const sqrt2 = BigInt(decimal_default.sqrt(ce.bignum(t)).toFixed(0));
-        return ce.symbol(sqrt2 * sqrt2 * 4n + 1n === k ? "True" : "False");
+        const sqrt3 = BigInt(decimal_default.sqrt(ce.bignum(t)).toFixed(0));
+        return ce.symbol(sqrt3 * sqrt3 * 4n + 1n === k ? "True" : "False");
       }
     },
     IsHappy: {
@@ -39261,39 +39293,39 @@ function factorPerfectSquare(expr) {
       const term2 = terms[j];
       const crossTerm = terms[crossIdx];
       const sqrt1 = extractSquareRoot(term1, ce);
-      const sqrt2 = extractSquareRoot(term2, ce);
-      if (sqrt1 === null || sqrt2 === null) continue;
-      const positiveCross = ce.number(2).mul(sqrt1).mul(sqrt2);
+      const sqrt22 = extractSquareRoot(term2, ce);
+      if (sqrt1 === null || sqrt22 === null) continue;
+      const positiveCross = ce.number(2).mul(sqrt1).mul(sqrt22);
       const negativeCross = positiveCross.neg();
       if (crossTerm.isSame(positiveCross)) {
-        return ce.box(["Square", sqrt1.add(sqrt2).json]);
+        return ce.box(["Square", sqrt1.add(sqrt22).json]);
       } else if (crossTerm.isSame(negativeCross)) {
-        return ce.box(["Square", sqrt1.sub(sqrt2).json]);
+        return ce.box(["Square", sqrt1.sub(sqrt22).json]);
       }
     }
   }
   return null;
 }
 function extractSquareRoot(term, ce) {
-  const sqrt2 = term.sqrt().simplify();
-  if (sqrt2.operator === "Sqrt") return null;
-  if (sqrt2.isNumberLiteral && sqrt2.numericValue) {
-    const nv = sqrt2.numericValue;
+  const sqrt3 = term.sqrt().simplify();
+  if (sqrt3.operator === "Sqrt") return null;
+  if (sqrt3.isNumberLiteral && sqrt3.numericValue) {
+    const nv = sqrt3.numericValue;
     if (nv.radical !== void 0 && nv.radical !== 1) return null;
   }
-  if (sqrt2.operator === "Abs") {
-    return sqrt2.op1;
+  if (sqrt3.operator === "Abs") {
+    return sqrt3.op1;
   }
-  if (sqrt2.operator === "Multiply") {
-    const absFactors = sqrt2.ops.filter((op) => op.operator === "Abs");
+  if (sqrt3.operator === "Multiply") {
+    const absFactors = sqrt3.ops.filter((op) => op.operator === "Abs");
     if (absFactors.length > 0) {
-      const newOps = sqrt2.ops.map(
+      const newOps = sqrt3.ops.map(
         (op) => op.operator === "Abs" ? op.op1 : op
       );
       return ce.box(["Multiply", ...newOps.map((op) => op.json)]);
     }
   }
-  return sqrt2;
+  return sqrt3;
 }
 function factorDifferenceOfSquares(expr) {
   const ce = expr.engine;
@@ -39316,9 +39348,9 @@ function factorDifferenceOfSquares(expr) {
         absTerm = ce.box(["Multiply", ...newOps.map((op) => op.json)]);
       }
     }
-    const sqrt2 = extractSquareRoot(absTerm, ce);
-    if (sqrt2 === null) return null;
-    results.push({ sqrt: sqrt2, isNegative: isNeg });
+    const sqrt3 = extractSquareRoot(absTerm, ce);
+    if (sqrt3 === null) return null;
+    results.push({ sqrt: sqrt3, isNegative: isNeg });
   }
   const posSquares = results.filter((r) => !r.isNegative);
   const negSquares = results.filter((r) => r.isNegative);
@@ -39635,10 +39667,10 @@ var RELOP_LIBRARY = {
       let constantRatio = void 0;
       const tolerance = ce.tolerance;
       for (const testVal of testValues) {
-        const sub2 = {};
-        for (const u of unknowns) sub2[u] = testVal;
-        const v1 = expr1.subs(sub2).N();
-        const v2 = expr2.subs(sub2).N();
+        const sub3 = {};
+        for (const u of unknowns) sub3[u] = testVal;
+        const v1 = expr1.subs(sub3).N();
+        const v2 = expr2.subs(sub3).N();
         const n1 = v1.re;
         const n2 = v2.re;
         if (!Number.isFinite(n1) || !Number.isFinite(n2)) continue;
@@ -40875,9 +40907,9 @@ function* rationalIterator(self, options) {
     if (signOpt === "+-") {
       yield self.engine.number(value);
     } else {
-      const sign2 = signOpt === "-" ? -1 : 1;
+      const sign3 = signOpt === "-" ? -1 : 1;
       const [n, d] = value;
-      yield self.engine.number([sign2 * n, d]);
+      yield self.engine.number([sign3 * n, d]);
     }
   }
 }
@@ -41127,12 +41159,12 @@ function mode(values) {
   for (const v of values) {
     counts[v] = (counts[v] ?? 0) + 1;
   }
-  let max2 = 0;
+  let max3 = 0;
   let mode2 = NaN;
   for (const v in counts) {
     const c = counts[v];
-    if (c > max2) {
-      max2 = c;
+    if (c > max3) {
+      max3 = c;
       mode2 = +v;
     }
   }
@@ -41143,12 +41175,12 @@ function bigMode(bignum, values) {
   for (const v of values) {
     counts[v.toString()] = (counts[v.toString()] ?? 0) + 1;
   }
-  let max2 = 0;
+  let max3 = 0;
   let mode2 = bignum(NaN);
   for (const v in counts) {
     const c = counts[v];
-    if (c > max2) {
-      max2 = c;
+    if (c > max3) {
+      max3 = c;
       mode2 = bignum(v);
     }
   }
@@ -41336,18 +41368,18 @@ var STATISTICS_LIBRARY = [
         if (!xs.isFiniteCollection) return void 0;
         const data = Array.from(xs.each()).map((x) => x.re).filter(Number.isFinite);
         if (data.length === 0) return void 0;
-        const min2 = Math.min(...data);
-        const max2 = Math.max(...data);
+        const min3 = Math.min(...data);
+        const max3 = Math.max(...data);
         let binEdges;
         if (binsArg?.operator === "List") {
           binEdges = binsArg.ops.map((op) => op.re);
         } else {
           const binCount = toInteger(binsArg);
           if (binCount === null || binCount <= 0) return void 0;
-          const binWidth = (max2 - min2) / binCount;
+          const binWidth = (max3 - min3) / binCount;
           binEdges = Array.from(
             { length: binCount + 1 },
-            (_, i) => min2 + i * binWidth
+            (_, i) => min3 + i * binWidth
           );
         }
         const counts = Array(binEdges.length - 1).fill(0);
@@ -41376,18 +41408,18 @@ var STATISTICS_LIBRARY = [
         if (!xs.isFiniteCollection) return void 0;
         const data = Array.from(xs.each()).map((x) => x.re).filter(Number.isFinite);
         if (data.length === 0) return void 0;
-        const min2 = Math.min(...data);
-        const max2 = Math.max(...data);
+        const min3 = Math.min(...data);
+        const max3 = Math.max(...data);
         let binEdges;
         if (binsArg.isCollection) {
           binEdges = [...binsArg.each()].map((op) => op.re);
         } else {
           const binCount = toInteger(binsArg);
           if (binCount === null || binCount <= 0) return void 0;
-          const binWidth = (max2 - min2) / binCount;
+          const binWidth = (max3 - min3) / binCount;
           binEdges = Array.from(
             { length: binCount + 1 },
-            (_, i) => min2 + i * binWidth
+            (_, i) => min3 + i * binWidth
           );
         }
         const counts = Array(binEdges.length - 1).fill(0);
@@ -42037,13 +42069,13 @@ function constructibleValues(operator2, x) {
   theta = Math.abs(theta % (2 * Math.PI));
   const quadrant3 = Math.floor(theta * 2 / Math.PI);
   theta = theta % (Math.PI / 2);
-  let sign2;
-  [sign2, operator2] = TRIG_IDENTITIES[operator2]?.[quadrant3] ?? [1, operator2];
+  let sign3;
+  [sign3, operator2] = TRIG_IDENTITIES[operator2]?.[quadrant3] ?? [1, operator2];
   for (const [[n, d], value] of specialValues) {
     const r = value[operator2];
     if (r && Math.abs(theta - Math.PI * n / d) <= 1e-12) {
       if (r.symbol === "ComplexInfinity") return r;
-      return identitySign * sign2 < 0 ? r.neg() : r;
+      return identitySign * sign3 < 0 ? r.neg() : r;
     }
   }
   return void 0;
@@ -42459,8 +42491,8 @@ function costFunction(expr) {
       return 5 + costFunction(arg) + 6;
     }
     if (arg?.operator === "Power" && arg.op2?.isOdd === true && arg.op2?.isInteger === true) {
-      const exp2 = arg.op2;
-      const n = exp2.numericValue;
+      const exp3 = arg.op2;
+      const n = exp3.numericValue;
       if (typeof n === "number" && n > 1) {
         return 5 + costFunction(arg) + 10;
       }
@@ -42469,8 +42501,8 @@ function costFunction(expr) {
   } else if (["Square", "Abs"].includes(name)) nameCost = 5;
   else if (name === "Power") {
     const base = expr.ops[0];
-    const exp2 = expr.ops[1];
-    const expCost = costFunction(exp2);
+    const exp3 = expr.ops[1];
+    const expCost = costFunction(exp3);
     if (base.operator === "Negate") {
       return expCost + 4;
     }
@@ -42478,7 +42510,7 @@ function costFunction(expr) {
       const hasNegativeCoef = base.ops.some(
         (f) => f.isNumberLiteral && f.isNegative === true
       );
-      if (hasNegativeCoef && exp2.isRational === true && !exp2.isInteger) {
+      if (hasNegativeCoef && exp3.isRational === true && !exp3.isInteger) {
         return expCost + costFunction(base) + 15;
       }
       return expCost + costFunction(base);
@@ -43390,10 +43422,10 @@ function TR5(expr) {
   const ce = expr.engine;
   if (expr.operator !== "Power") return void 0;
   const base = expr.op1;
-  const exp2 = expr.op2;
-  if (!base || !exp2) return void 0;
+  const exp3 = expr.op2;
+  if (!base || !exp3) return void 0;
   if (base.operator !== "Sin") return void 0;
-  if (!exp2.is(2)) return void 0;
+  if (!exp3.is(2)) return void 0;
   const arg = base.op1;
   if (!arg) return void 0;
   return ce.One.sub(ce._fn("Cos", [arg]).pow(2));
@@ -43405,10 +43437,10 @@ function TR6(expr) {
   const ce = expr.engine;
   if (expr.operator !== "Power") return void 0;
   const base = expr.op1;
-  const exp2 = expr.op2;
-  if (!base || !exp2) return void 0;
+  const exp3 = expr.op2;
+  if (!base || !exp3) return void 0;
   if (base.operator !== "Cos") return void 0;
-  if (!exp2.is(2)) return void 0;
+  if (!exp3.is(2)) return void 0;
   const arg = base.op1;
   if (!arg) return void 0;
   return ce.One.sub(ce._fn("Sin", [arg]).pow(2));
@@ -43420,10 +43452,10 @@ function TR7(expr) {
   const ce = expr.engine;
   if (expr.operator !== "Power") return void 0;
   const base = expr.op1;
-  const exp2 = expr.op2;
-  if (!base || !exp2) return void 0;
+  const exp3 = expr.op2;
+  if (!base || !exp3) return void 0;
   if (base.operator !== "Cos") return void 0;
-  if (!exp2.is(2)) return void 0;
+  if (!exp3.is(2)) return void 0;
   const arg = base.op1;
   if (!arg) return void 0;
   return ce.One.add(ce._fn("Cos", [arg.mul(2)])).div(2);
@@ -44191,9 +44223,9 @@ function TR22(expr) {
   const ce = expr.engine;
   if (expr.operator !== "Power") return void 0;
   const base = expr.op1;
-  const exp2 = expr.op2;
-  if (!base || !exp2) return void 0;
-  if (!exp2.is(2)) return void 0;
+  const exp3 = expr.op2;
+  if (!base || !exp3) return void 0;
+  if (!exp3.is(2)) return void 0;
   const arg = base.op1;
   if (!arg) return void 0;
   if (base.operator === "Tan") {
@@ -45216,9 +45248,9 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
     (a, b) => anchorSpecificity(b) - anchorSpecificity(a)
   );
   return tryMatchAnchors(0, exprOps, substitution);
-  function tryMatchAnchors(anchorIndex, remainingOps, sub2) {
+  function tryMatchAnchors(anchorIndex, remainingOps, sub3) {
     if (anchorIndex >= sortedAnchors.length) {
-      return assignWildcards(remainingOps, sub2);
+      return assignWildcards(remainingOps, sub3);
     }
     const anchorsLeft = sortedAnchors.length - anchorIndex;
     const minWildcardNeeds = universalWildcards.length + sequenceWildcards.length;
@@ -45227,7 +45259,7 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
     }
     const anchor = sortedAnchors[anchorIndex];
     for (let i = 0; i < remainingOps.length; i++) {
-      const matchResult = matchOnce(remainingOps[i], anchor, sub2, options);
+      const matchResult = matchOnce(remainingOps[i], anchor, sub3, options);
       if (matchResult !== null) {
         const newRemaining = [...remainingOps];
         newRemaining.splice(i, 1);
@@ -45241,8 +45273,8 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
     }
     return null;
   }
-  function assignWildcards(remainingOps, sub2) {
-    const result = sub2;
+  function assignWildcards(remainingOps, sub3) {
+    const result = sub3;
     const neededForUniversal = universalWildcards.length;
     const minNeededForSequence = sequenceWildcards.length;
     const totalNeeded = neededForUniversal + minNeededForSequence;
@@ -45253,16 +45285,16 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
       result
     );
   }
-  function tryAssignWildcards(wildcards, remaining, sub2) {
+  function tryAssignWildcards(wildcards, remaining, sub3) {
     if (wildcards.length === 0) {
-      return remaining.length === 0 ? sub2 : null;
+      return remaining.length === 0 ? sub3 : null;
     }
     const [wc, ...restWildcards] = wildcards;
     const wcType = wildcardType(wc);
     const wcName = wildcardName(wc);
     if (wcType === "Wildcard") {
       for (let i = 0; i < remaining.length; i++) {
-        const newSub = captureWildcard(wcName, remaining[i], sub2);
+        const newSub = captureWildcard(wcName, remaining[i], sub3);
         if (newSub !== null) {
           const newRemaining = [...remaining];
           newRemaining.splice(i, 1);
@@ -45284,7 +45316,7 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
         for (const indices of combinations) {
           const captured = indices.map((i) => remaining[i]);
           const capturedExpr = wrapCaptured(captured);
-          const newSub = captureWildcard(wcName, capturedExpr, sub2);
+          const newSub = captureWildcard(wcName, capturedExpr, sub3);
           if (newSub !== null) {
             const newRemaining = remaining.filter(
               (_, i) => !indices.includes(i)
@@ -45304,7 +45336,7 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
     for (let count = maxCapture; count >= 0; count--) {
       if (count === 0) {
         const identity = expr.operator === "Add" ? ce.Zero : expr.operator === "Multiply" ? ce.One : ce.Nothing;
-        const newSub = captureWildcard(wcName, identity, sub2);
+        const newSub = captureWildcard(wcName, identity, sub3);
         if (newSub !== null) {
           const result = tryAssignWildcards(restWildcards, remaining, newSub);
           if (result !== null) return result;
@@ -45314,7 +45346,7 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
         for (const indices of combinations) {
           const captured = indices.map((i) => remaining[i]);
           const capturedExpr = wrapCaptured(captured);
-          const newSub = captureWildcard(wcName, capturedExpr, sub2);
+          const newSub = captureWildcard(wcName, capturedExpr, sub3);
           if (newSub !== null) {
             const newRemaining = remaining.filter(
               (_, i) => !indices.includes(i)
@@ -45785,11 +45817,11 @@ var BoxedFunction = class extends _BoxedExpression {
       return [coef.sqrt(), ce.function("Sqrt", [rest])];
     }
     if (expr.operator === "Root") {
-      const exp2 = expr.op2.re;
-      if (isNaN(exp2) || expr.op2.im !== 0) return [ce._numericValue(1), this];
+      const exp3 = expr.op2.re;
+      if (isNaN(exp3) || expr.op2.im !== 0) return [ce._numericValue(1), this];
       const [coef, rest] = expr.op1.toNumericValue();
-      if (exp2 === 2) return [coef.sqrt(), ce.function("Sqrt", [rest])];
-      return [coef.root(exp2), ce.function("Root", [rest, expr.op2])];
+      if (exp3 === 2) return [coef.sqrt(), ce.function("Sqrt", [rest])];
+      return [coef.root(exp3), ce.function("Root", [rest, expr.op2])];
     }
     if (expr.operator === "Abs") {
       const [coef, rest] = expr.op1.toNumericValue();
@@ -45806,11 +45838,11 @@ var BoxedFunction = class extends _BoxedExpression {
    * original expression.
    * <!-- This may or may not be desirable -->
    */
-  subs(sub2, options) {
+  subs(sub3, options) {
     options ??= { canonical: void 0 };
     if (options.canonical === void 0)
       options = { canonical: this.isCanonical };
-    const ops = this._ops.map((x) => x.subs(sub2, options));
+    const ops = this._ops.map((x) => x.subs(sub3, options));
     if (!ops.every((x) => x.isValid))
       return this.engine.function(this._operator, ops, { canonical: false });
     return this.engine.function(this._operator, ops, options);
@@ -45971,13 +46003,13 @@ var BoxedFunction = class extends _BoxedExpression {
     if (!this.isCanonical) throw new Error("Not canonical");
     return div2(this, rhs);
   }
-  pow(exp2) {
-    return pow2(this, exp2, { numericApproximation: false });
+  pow(exp3) {
+    return pow2(this, exp3, { numericApproximation: false });
   }
-  root(exp2) {
-    if (!this.isCanonical || typeof exp2 !== "number" && !exp2.isCanonical)
+  root(exp3) {
+    if (!this.isCanonical || typeof exp3 !== "number" && !exp3.isCanonical)
       throw new Error("Not canonical");
-    const e = typeof exp2 === "number" ? exp2 : exp2.im === 0 ? exp2.re : void 0;
+    const e = typeof exp3 === "number" ? exp3 : exp3.im === 0 ? exp3.re : void 0;
     if (e === 0) return this.engine.NaN;
     if (e === 1) return this;
     if (e === -1) return this.inv();
@@ -45988,24 +46020,24 @@ var BoxedFunction = class extends _BoxedExpression {
     }
     if (this.operator === "Divide") {
       const [num, denom] = this.ops;
-      return num.root(exp2).div(denom.root(exp2));
+      return num.root(exp3).div(denom.root(exp3));
     }
     if (this.operator === "Negate") {
       if (e !== void 0) {
-        if (e % 2 === 0) return this.op1.root(exp2);
-        return this.op1.root(exp2).neg();
+        if (e % 2 === 0) return this.op1.root(exp3);
+        return this.op1.root(exp3).neg();
       }
     }
     if (this.operator === "Sqrt") {
       if (e !== void 0) return this.op1.root(e * 2);
-      if (typeof exp2 !== "number") return this.op1.root(exp2.mul(2));
+      if (typeof exp3 !== "number") return this.op1.root(exp3.mul(2));
     }
     if (this.operator === "Root") {
       const [base, root2] = this.ops;
-      return base.root(root2.mul(exp2));
+      return base.root(root2.mul(exp3));
     }
     if (this.operator === "Multiply") {
-      const ops = this.ops.map((x) => x.root(exp2));
+      const ops = this.ops.map((x) => x.root(exp3));
       return mul3(...ops);
     }
     if (this.isNumberLiteral) {
@@ -46027,7 +46059,7 @@ var BoxedFunction = class extends _BoxedExpression {
         }
       }
     }
-    return this.engine._fn("Root", [this, this.engine.box(exp2)]);
+    return this.engine._fn("Root", [this, this.engine.box(exp3)]);
   }
   sqrt() {
     return this.root(2);
@@ -46046,12 +46078,12 @@ var BoxedFunction = class extends _BoxedExpression {
       return this.engine.One.div(base.ln());
     }
     if (this.operator === "Power") {
-      const [b, exp2] = this.ops;
+      const [b, exp3] = this.ops;
       if (b.isSame(this.engine.E)) {
-        if (!base) return exp2;
-        return exp2.div(base.ln());
+        if (!base) return exp3;
+        return exp3.div(base.ln());
       }
-      return exp2.mul(b.ln(base));
+      return exp3.mul(b.ln(base));
     }
     if (this.operator === "Root") {
       const [a, b] = this.ops;
@@ -47389,31 +47421,31 @@ var BoxedNumber = class extends _BoxedExpression {
   div(rhs) {
     return div2(this, rhs);
   }
-  pow(exp2) {
-    return pow2(this, exp2, { numericApproximation: false });
+  pow(exp3) {
+    return pow2(this, exp3, { numericApproximation: false });
   }
-  root(exp2) {
-    if (typeof exp2 === "number") {
-      if (exp2 === 0) return this.engine.NaN;
-      if (exp2 === 1) return this;
-      if (exp2 === -1) return this.inv();
-      if (exp2 === 2) return this.sqrt();
+  root(exp3) {
+    if (typeof exp3 === "number") {
+      if (exp3 === 0) return this.engine.NaN;
+      if (exp3 === 1) return this;
+      if (exp3 === -1) return this.inv();
+      if (exp3 === 2) return this.sqrt();
       if (this.isNegative) {
-        if (exp2 % 2 === 1) return this.neg().root(exp2).neg();
-        if (exp2 % 2 === 0) return this.neg().root(exp2);
+        if (exp3 % 2 === 1) return this.neg().root(exp3).neg();
+        if (exp3 % 2 === 0) return this.neg().root(exp3);
       }
     } else {
-      exp2 = exp2.canonical;
-      if (exp2.is(0)) return this.engine.NaN;
-      if (exp2.is(1)) return this;
-      if (exp2.is(-1)) return this.inv();
-      if (exp2.is(2)) return this.sqrt();
+      exp3 = exp3.canonical;
+      if (exp3.is(0)) return this.engine.NaN;
+      if (exp3.is(1)) return this;
+      if (exp3.is(-1)) return this.inv();
+      if (exp3.is(2)) return this.sqrt();
       if (this.isNegative) {
-        if (exp2.isOdd) return this.neg().root(exp2).neg();
-        if (exp2.isEven) return this.neg().root(exp2);
+        if (exp3.isOdd) return this.neg().root(exp3).neg();
+        if (exp3.isEven) return this.neg().root(exp3);
       }
     }
-    const n = typeof exp2 === "number" ? exp2 : exp2.re;
+    const n = typeof exp3 === "number" ? exp3 : exp3.re;
     if (Number.isInteger(n)) {
       if (typeof this._value === "number") {
         const r = this._value ** (1 / n);
@@ -47423,7 +47455,7 @@ var BoxedNumber = class extends _BoxedExpression {
         if (isSubtype(r.type, "integer")) return this.engine.number(r);
       }
     }
-    return this.engine._fn("Root", [this, this.engine.box(exp2)]);
+    return this.engine._fn("Root", [this, this.engine.box(exp3)]);
   }
   sqrt() {
     if (typeof this._value === "number") {
@@ -47504,9 +47536,9 @@ var BoxedNumber = class extends _BoxedExpression {
       ce.number(this._value.denominator)
     ];
   }
-  subs(sub2, options) {
+  subs(sub3, options) {
     if (this.isStructural) return this;
-    return this.structural.subs(sub2, options);
+    return this.structural.subs(sub3, options);
   }
   replace(rules, options) {
     return replace(this.structural, rules, options).at(-1)?.value ?? null;
@@ -47670,9 +47702,9 @@ function canonicalNumber(ce, value) {
     return 0;
   }
   if (typeof value[0] === "number" && !Number.isFinite(value[0])) {
-    const sign2 = value[0] > 0 ? 1 : -1;
-    if (value[0] > 0) return sign2 > 0 ? Infinity : -Infinity;
-    if (value[0] < 0) return sign2 > 0 ? -Infinity : Infinity;
+    const sign3 = value[0] > 0 ? 1 : -1;
+    if (value[0] > 0) return sign3 > 0 ? Infinity : -Infinity;
+    if (value[0] < 0) return sign3 > 0 ? -Infinity : Infinity;
     return NaN;
   }
   return ce._numericValue(value);
@@ -47816,8 +47848,8 @@ var BoxedSymbol = class extends _BoxedExpression {
   div(rhs) {
     return div2(this, rhs);
   }
-  pow(exp2) {
-    return pow2(this, exp2, { numericApproximation: false });
+  pow(exp3) {
+    return pow2(this, exp3, { numericApproximation: false });
   }
   root(n) {
     const e = typeof n === "number" ? n : n.im === 0 ? n.re : void 0;
@@ -48143,10 +48175,10 @@ var BoxedSymbol = class extends _BoxedExpression {
   replace(rules, options) {
     return replace(this, rules, options).at(-1)?.value ?? null;
   }
-  subs(sub2, options) {
+  subs(sub3, options) {
     const canonical2 = options?.canonical ?? this.isCanonical;
-    if (sub2[this._id] === void 0) return canonical2 ? this.canonical : this;
-    return this.engine.box(sub2[this._id], { canonical: canonical2 });
+    if (sub3[this._id] === void 0) return canonical2 ? this.canonical : this;
+    return this.engine.box(sub3[this._id], { canonical: canonical2 });
   }
   get _asCollection() {
     if (isValueDef(this._def)) return this._def.value.collection;
@@ -48860,38 +48892,38 @@ function simplifyAbs(x) {
   }
   if (opOperator === "Power") {
     const base = op.op1;
-    const exp2 = op.op2;
-    if (base && exp2) {
-      if (exp2.isEven === true) {
+    const exp3 = op.op2;
+    if (base && exp3) {
+      if (exp3.isEven === true) {
         return {
-          value: base.pow(exp2),
+          value: base.pow(exp3),
           because: "|x^n| -> x^n when n is even"
         };
       }
-      if (exp2.isOdd === true) {
+      if (exp3.isOdd === true) {
         return {
-          value: ce._fn("Abs", [base]).pow(exp2),
+          value: ce._fn("Abs", [base]).pow(exp3),
           because: "|x^n| -> |x|^n when n is odd"
         };
       }
-      if (exp2.isRational === false) {
+      if (exp3.isRational === false) {
         return {
-          value: ce._fn("Abs", [base]).pow(exp2),
+          value: ce._fn("Abs", [base]).pow(exp3),
           because: "|x^n| -> |x|^n when n is irrational"
         };
       }
-      if (exp2.isRational === true && exp2.isInteger === false) {
-        const num = exp2.numerator;
+      if (exp3.isRational === true && exp3.isInteger === false) {
+        const num = exp3.numerator;
         if (num) {
           if (num.isEven === true) {
             return {
-              value: base.pow(exp2),
+              value: base.pow(exp3),
               because: "|x^(p/q)| -> x^(p/q) when p is even"
             };
           }
           if (num.isOdd === true) {
             return {
-              value: ce._fn("Abs", [base]).pow(exp2),
+              value: ce._fn("Abs", [base]).pow(exp3),
               because: "|x^(p/q)| -> |x|^(p/q) when p is odd"
             };
           }
@@ -48913,22 +48945,22 @@ function simplifyAbs(x) {
 function simplifyAbsPower(x) {
   if (x.operator !== "Power") return void 0;
   const base = x.op1;
-  const exp2 = x.op2;
-  if (!base || !exp2 || base.operator !== "Abs") return void 0;
+  const exp3 = x.op2;
+  if (!base || !exp3 || base.operator !== "Abs") return void 0;
   const innerBase = base.op1;
   if (!innerBase) return void 0;
-  if (exp2.isEven === true) {
+  if (exp3.isEven === true) {
     return {
-      value: innerBase.pow(exp2),
+      value: innerBase.pow(exp3),
       because: "|x|^n -> x^n when n is even"
     };
   }
-  if (exp2.operator === "Divide") {
-    const n = exp2.op1;
-    const m = exp2.op2;
+  if (exp3.operator === "Divide") {
+    const n = exp3.op1;
+    const m = exp3.op2;
     if (n && m && n.isEven === true && m.isOdd === true) {
       return {
-        value: innerBase.pow(exp2),
+        value: innerBase.pow(exp3),
         because: "|x|^(n/m) -> x^(n/m) when n even, m odd"
       };
     }
@@ -49083,27 +49115,27 @@ function simplifyInfinity(x) {
   }
   if (op === "Power") {
     const base = x.op1;
-    const exp2 = x.op2;
-    if (base && exp2) {
+    const exp3 = x.op2;
+    if (base && exp3) {
       const baseIsInf = base.isInfinity === true;
-      const expIsInf = exp2.isInfinity === true;
+      const expIsInf = exp3.isInfinity === true;
       const baseIsPosInf = baseIsInf && base.isPositive === true;
       const baseIsNegInf = baseIsInf && base.isNegative === true;
-      const expIsPosInf = expIsInf && exp2.isPositive === true;
-      const expIsNegInf = expIsInf && exp2.isNegative === true;
+      const expIsPosInf = expIsInf && exp3.isPositive === true;
+      const expIsNegInf = expIsInf && exp3.isNegative === true;
       if (base.symbol === "ExponentialE" && expIsPosInf) {
         return { value: ce.PositiveInfinity, because: "e^(+inf) -> +inf" };
       }
       if (base.symbol === "ExponentialE" && expIsNegInf) {
         return { value: ce.Zero, because: "e^(-inf) -> 0" };
       }
-      if (base.is(1) && exp2.isFinite === true) {
+      if (base.is(1) && exp3.isFinite === true) {
         return { value: ce.One, because: "1^finite -> 1" };
       }
-      if (exp2.is(0) && baseIsInf) {
+      if (exp3.is(0) && baseIsInf) {
         return { value: ce.NaN, because: "inf^0 -> NaN" };
       }
-      if (exp2.is(0) && base.is(0) === false && base.isFinite === true) {
+      if (exp3.is(0) && base.is(0) === false && base.isFinite === true) {
         return { value: ce.One, because: "x^0 -> 1" };
       }
       if (expIsPosInf) {
@@ -49129,28 +49161,28 @@ function simplifyInfinity(x) {
         }
       }
       if (baseIsPosInf) {
-        if (exp2.isNegative === true) {
+        if (exp3.isNegative === true) {
           return { value: ce.Zero, because: "+inf^negative -> 0" };
         }
       }
       if (baseIsNegInf) {
-        if (exp2.isNegative === true) {
+        if (exp3.isNegative === true) {
           return { value: ce.Zero, because: "-inf^negative -> 0" };
         }
-        if (exp2.isInteger === true && exp2.isEven === true) {
+        if (exp3.isInteger === true && exp3.isEven === true) {
           return {
             value: ce.PositiveInfinity,
             because: "(-inf)^(even integer) -> +inf"
           };
         }
-        if (exp2.isInteger === true && exp2.isOdd === true) {
+        if (exp3.isInteger === true && exp3.isOdd === true) {
           return {
             value: ce.NegativeInfinity,
             because: "(-inf)^(odd integer) -> -inf"
           };
         }
-        if (exp2.isRational === true) {
-          const [numExpr, denomExpr] = exp2.numeratorDenominator;
+        if (exp3.isRational === true) {
+          const [numExpr, denomExpr] = exp3.numeratorDenominator;
           const num = numExpr.re;
           const denom = denomExpr.re;
           if (typeof num === "number" && typeof denom === "number" && Number.isInteger(num) && Number.isInteger(denom)) {
@@ -49192,17 +49224,17 @@ function simplifyLog(x) {
     }
     if (arg.operator === "Power") {
       const base = arg.op1;
-      const exp2 = arg.op2;
-      if (base && exp2) {
-        if (base.isNonNegative === true || exp2.isOdd === true || exp2.isRational === false) {
+      const exp3 = arg.op2;
+      if (base && exp3) {
+        if (base.isNonNegative === true || exp3.isOdd === true || exp3.isRational === false) {
           return {
-            value: exp2.mul(ce._fn("Ln", [base])),
+            value: exp3.mul(ce._fn("Ln", [base])),
             because: "ln(x^n) -> n*ln(x)"
           };
         }
-        if (exp2.isEven === true) {
+        if (exp3.isEven === true) {
           return {
-            value: exp2.mul(ce._fn("Ln", [ce._fn("Abs", [base])])),
+            value: exp3.mul(ce._fn("Ln", [ce._fn("Abs", [base])])),
             because: "ln(x^n) -> n*ln(|x|) when n even"
           };
         }
@@ -49215,11 +49247,11 @@ function simplifyLog(x) {
       for (let i = 0; i < arg.ops.length; i++) {
         const factor3 = arg.ops[i];
         if (factor3.operator === "Power" && factor3.op1?.symbol === "ExponentialE") {
-          const exp2 = factor3.op2;
+          const exp3 = factor3.op2;
           const otherFactors = arg.ops.filter((_, idx) => idx !== i);
           const remaining = otherFactors.length === 1 ? otherFactors[0] : ce._fn("Multiply", otherFactors);
           return {
-            value: exp2.add(ce._fn("Ln", [remaining])),
+            value: exp3.add(ce._fn("Ln", [remaining])),
             because: "ln(e^x * y) -> x + ln(y)"
           };
         }
@@ -49302,17 +49334,17 @@ function simplifyLog(x) {
     }
     if (arg.operator === "Power") {
       const powerBase = arg.op1;
-      const exp2 = arg.op2;
-      if (powerBase && exp2) {
-        if (powerBase.isNonNegative === true || exp2.isOdd === true || exp2.isRational === false) {
+      const exp3 = arg.op2;
+      if (powerBase && exp3) {
+        if (powerBase.isNonNegative === true || exp3.isOdd === true || exp3.isRational === false) {
           return {
-            value: exp2.mul(ce._fn("Log", [powerBase, logBase])),
+            value: exp3.mul(ce._fn("Log", [powerBase, logBase])),
             because: "log_c(x^n) -> n*log_c(x)"
           };
         }
-        if (exp2.isEven === true) {
+        if (exp3.isEven === true) {
           return {
-            value: exp2.mul(
+            value: exp3.mul(
               ce._fn("Log", [ce._fn("Abs", [powerBase]), logBase])
             ),
             because: "log_c(x^n) -> n*log_c(|x|) when n even"
@@ -49324,11 +49356,11 @@ function simplifyLog(x) {
       for (let i = 0; i < arg.ops.length; i++) {
         const factor3 = arg.ops[i];
         if (factor3.operator === "Power" && factor3.op1?.isSame(logBase)) {
-          const exp2 = factor3.op2;
+          const exp3 = factor3.op2;
           const otherFactors = arg.ops.filter((_, idx) => idx !== i);
           const remaining = otherFactors.length === 1 ? otherFactors[0] : ce._fn("Multiply", otherFactors);
           return {
-            value: exp2.add(ce._fn("Log", [remaining, logBase])),
+            value: exp3.add(ce._fn("Log", [remaining, logBase])),
             because: "log_c(c^x * y) -> x + log_c(y)"
           };
         }
@@ -49368,32 +49400,32 @@ function simplifyLog(x) {
   }
   if (op === "Power") {
     const base = x.op1;
-    const exp2 = x.op2;
-    if (!base || !exp2) return void 0;
-    if (base.symbol === "ExponentialE" && exp2.operator === "Ln") {
-      return { value: exp2.op1, because: "e^ln(x) -> x" };
+    const exp3 = x.op2;
+    if (!base || !exp3) return void 0;
+    if (base.symbol === "ExponentialE" && exp3.operator === "Ln") {
+      return { value: exp3.op1, because: "e^ln(x) -> x" };
     }
-    if (base.symbol === "ExponentialE" && exp2.operator === "Log" && exp2.op1) {
-      const logBase = exp2.op2;
+    if (base.symbol === "ExponentialE" && exp3.operator === "Log" && exp3.op1) {
+      const logBase = exp3.op2;
       const isDefaultOrBase10 = !logBase || logBase.symbol === "Nothing" || logBase.is(10);
       if (isDefaultOrBase10) {
         return {
-          value: exp2.op1.pow(ce.One.div(ce._fn("Ln", [ce.number(10)]))),
+          value: exp3.op1.pow(ce.One.div(ce._fn("Ln", [ce.number(10)]))),
           because: "e^log(x) -> x^{1/ln(10)}"
         };
       }
       if (logBase && logBase.symbol !== "ExponentialE") {
         return {
-          value: exp2.op1.pow(ce.One.div(ce._fn("Ln", [logBase]))),
+          value: exp3.op1.pow(ce.One.div(ce._fn("Ln", [logBase]))),
           because: "e^log_c(x) -> x^{1/ln(c)}"
         };
       }
     }
-    if (base.symbol === "ExponentialE" && exp2.operator === "Add" && exp2.ops) {
-      for (let i = 0; i < exp2.ops.length; i++) {
-        const term = exp2.ops[i];
+    if (base.symbol === "ExponentialE" && exp3.operator === "Add" && exp3.ops) {
+      for (let i = 0; i < exp3.ops.length; i++) {
+        const term = exp3.ops[i];
         if (term.operator === "Ln") {
-          const otherTerms = exp2.ops.filter((_, idx) => idx !== i);
+          const otherTerms = exp3.ops.filter((_, idx) => idx !== i);
           const remaining = otherTerms.length === 0 ? ce.Zero : otherTerms.length === 1 ? otherTerms[0] : ce._fn("Add", otherTerms);
           return {
             value: term.op1.mul(ce._fn("Exp", [remaining])),
@@ -49401,10 +49433,10 @@ function simplifyLog(x) {
           };
         }
       }
-      for (let i = 0; i < exp2.ops.length; i++) {
-        const term = exp2.ops[i];
+      for (let i = 0; i < exp3.ops.length; i++) {
+        const term = exp3.ops[i];
         if (term.operator !== "Log" || !term.op1) continue;
-        const otherTerms = exp2.ops.filter((_, idx) => idx !== i);
+        const otherTerms = exp3.ops.filter((_, idx) => idx !== i);
         const remaining = otherTerms.length === 0 ? ce.Zero : otherTerms.length === 1 ? otherTerms[0] : ce._fn("Add", otherTerms);
         const logBase = term.op2;
         const isDefaultOrBase10 = !logBase || logBase.symbol === "Nothing" || logBase.is(10);
@@ -49415,11 +49447,11 @@ function simplifyLog(x) {
         };
       }
     }
-    if (base.symbol === "ExponentialE" && exp2.operator === "Multiply" && exp2.ops) {
-      for (let i = 0; i < exp2.ops.length; i++) {
-        const factor3 = exp2.ops[i];
+    if (base.symbol === "ExponentialE" && exp3.operator === "Multiply" && exp3.ops) {
+      for (let i = 0; i < exp3.ops.length; i++) {
+        const factor3 = exp3.ops[i];
         if (factor3.operator === "Ln") {
-          const otherFactors = exp2.ops.filter((_, idx) => idx !== i);
+          const otherFactors = exp3.ops.filter((_, idx) => idx !== i);
           const y = otherFactors.length === 1 ? otherFactors[0] : ce._fn("Multiply", otherFactors);
           return {
             value: factor3.op1.pow(y),
@@ -49428,20 +49460,20 @@ function simplifyLog(x) {
         }
       }
     }
-    if (base.symbol === "ExponentialE" && exp2.operator === "Divide" && exp2.op1?.operator === "Ln") {
+    if (base.symbol === "ExponentialE" && exp3.operator === "Divide" && exp3.op1?.operator === "Ln") {
       return {
-        value: exp2.op1.op1.pow(ce.One.div(exp2.op2)),
+        value: exp3.op1.op1.pow(ce.One.div(exp3.op2)),
         because: "e^(ln(x) / y) -> x^(1/y)"
       };
     }
-    if (exp2.operator === "Log" && exp2.op2?.isSame(base)) {
-      return { value: exp2.op1, because: "c^log_c(x) -> x" };
+    if (exp3.operator === "Log" && exp3.op2?.isSame(base)) {
+      return { value: exp3.op1, because: "c^log_c(x) -> x" };
     }
-    if (exp2.operator === "Add" && exp2.ops) {
-      for (let i = 0; i < exp2.ops.length; i++) {
-        const term = exp2.ops[i];
+    if (exp3.operator === "Add" && exp3.ops) {
+      for (let i = 0; i < exp3.ops.length; i++) {
+        const term = exp3.ops[i];
         if (term.operator === "Log" && term.op2?.isSame(base)) {
-          const otherTerms = exp2.ops.filter((_, idx) => idx !== i);
+          const otherTerms = exp3.ops.filter((_, idx) => idx !== i);
           const remaining = otherTerms.length === 0 ? ce.Zero : otherTerms.length === 1 ? otherTerms[0] : ce._fn("Add", otherTerms);
           return {
             value: term.op1.mul(base.pow(remaining)),
@@ -49450,11 +49482,11 @@ function simplifyLog(x) {
         }
       }
     }
-    if (exp2.operator === "Multiply" && exp2.ops) {
-      for (let i = 0; i < exp2.ops.length; i++) {
-        const factor3 = exp2.ops[i];
+    if (exp3.operator === "Multiply" && exp3.ops) {
+      for (let i = 0; i < exp3.ops.length; i++) {
+        const factor3 = exp3.ops[i];
         if (factor3.operator === "Log" && factor3.op2?.isSame(base)) {
-          const otherFactors = exp2.ops.filter((_, idx) => idx !== i);
+          const otherFactors = exp3.ops.filter((_, idx) => idx !== i);
           const y = otherFactors.length === 1 ? otherFactors[0] : ce._fn("Multiply", otherFactors);
           return {
             value: factor3.op1.pow(y),
@@ -49463,9 +49495,9 @@ function simplifyLog(x) {
         }
       }
     }
-    if (exp2.operator === "Divide" && exp2.op1?.operator === "Log" && exp2.op1.op2?.isSame(base)) {
+    if (exp3.operator === "Divide" && exp3.op1?.operator === "Log" && exp3.op1.op2?.isSame(base)) {
       return {
-        value: exp2.op1.op1.pow(ce.One.div(exp2.op2)),
+        value: exp3.op1.op1.pow(ce.One.div(exp3.op2)),
         because: "c^(log_c(x) / y) -> x^(1/y)"
       };
     }
@@ -49605,8 +49637,8 @@ function simplifyPower(x) {
     }
     if (arg.operator === "Power") {
       const base = arg.op1;
-      const exp2 = arg.op2;
-      if (base && exp2?.isSame(rootIndex)) {
+      const exp3 = arg.op2;
+      if (base && exp3?.isSame(rootIndex)) {
         if (rootIndex.isEven === true) {
           return {
             value: ce._fn("Abs", [base]),
@@ -49617,8 +49649,8 @@ function simplifyPower(x) {
           return { value: base, because: "root(x^n, n) -> x when n odd" };
         }
       }
-      if (base && exp2) {
-        const resultExp = exp2.div(rootIndex);
+      if (base && exp3) {
+        const resultExp = exp3.div(rootIndex);
         if (rootIndex.isEven === true) {
           if (resultExp.isInteger === true) {
             return {
@@ -49638,7 +49670,7 @@ function simplifyPower(x) {
             }
           }
         }
-        if (rootIndex.isOdd === true && exp2.isInteger === true) {
+        if (rootIndex.isOdd === true && exp3.isInteger === true) {
           return {
             value: base.pow(resultExp),
             because: "root(x^m, n) -> x^{m/n} when n is odd"
@@ -49691,22 +49723,22 @@ function simplifyPower(x) {
     }
     if (arg.operator === "Power") {
       const base = arg.op1;
-      const exp2 = arg.op2;
-      if (base && exp2) {
-        if (exp2.is(2) && base.isNonNegative === true) {
+      const exp3 = arg.op2;
+      if (base && exp3) {
+        if (exp3.is(2) && base.isNonNegative === true) {
           return { value: base, because: "sqrt(x^2) -> x when x >= 0" };
         }
-        if (exp2.is(2)) {
+        if (exp3.is(2)) {
           return { value: ce._fn("Abs", [base]), because: "sqrt(x^2) -> |x|" };
         }
-        if (exp2.isEven === true && exp2.isPositive === true) {
+        if (exp3.isEven === true && exp3.isPositive === true) {
           return {
-            value: ce._fn("Abs", [base]).pow(exp2.div(2)),
+            value: ce._fn("Abs", [base]).pow(exp3.div(2)),
             because: "sqrt(x^{2n}) -> |x|^n"
           };
         }
-        if (exp2.isOdd === true && exp2.isInteger === true && exp2.isPositive === true) {
-          const n = exp2.sub(ce.One).div(2);
+        if (exp3.isOdd === true && exp3.isInteger === true && exp3.isPositive === true) {
+          const n = exp3.sub(ce.One).div(2);
           if (n.isPositive === true) {
             return {
               value: ce._fn("Abs", [base]).pow(n).mul(ce._fn("Sqrt", [base])),
@@ -49722,13 +49754,13 @@ function simplifyPower(x) {
       for (const factor3 of arg.ops) {
         if (factor3.operator === "Power" && factor3.op1 && factor3.op2) {
           const base = factor3.op1;
-          const exp2 = factor3.op2;
-          if (exp2.is(2)) {
+          const exp3 = factor3.op2;
+          if (exp3.is(2)) {
             perfectSquares.push(ce._fn("Abs", [base]));
-          } else if (exp2.isEven === true && exp2.isPositive === true) {
-            perfectSquares.push(ce._fn("Abs", [base]).pow(exp2.div(2)));
-          } else if (exp2.isInteger === true && exp2.isPositive === true && exp2.isOdd === true) {
-            const n = exp2.sub(ce.One).div(2);
+          } else if (exp3.isEven === true && exp3.isPositive === true) {
+            perfectSquares.push(ce._fn("Abs", [base]).pow(exp3.div(2)));
+          } else if (exp3.isInteger === true && exp3.isPositive === true && exp3.isOdd === true) {
+            const n = exp3.sub(ce.One).div(2);
             if (n.isPositive === true) {
               perfectSquares.push(ce._fn("Abs", [base]).pow(n));
             }
@@ -49758,13 +49790,13 @@ function simplifyPower(x) {
   }
   if (op === "Power") {
     const base = x.op1;
-    const exp2 = x.op2;
-    if (!base || !exp2) return void 0;
-    if (base.is(0) && exp2.isPositive === true) {
+    const exp3 = x.op2;
+    if (!base || !exp3) return void 0;
+    if (base.is(0) && exp3.isPositive === true) {
       return { value: ce.Zero, because: "0^x -> 0 when x > 0" };
     }
     if (base.is(-1)) {
-      const rat = asRational(exp2);
+      const rat = asRational(exp3);
       if (rat) {
         const [num, denom] = rat;
         const numN = Number(num);
@@ -49778,7 +49810,7 @@ function simplifyPower(x) {
       }
     }
     if (base.operator === "Multiply" && base.ops) {
-      const rat = asRational(exp2);
+      const rat = asRational(exp3);
       if (rat) {
         const [num, denom] = rat;
         const numN = Number(num);
@@ -49802,15 +49834,15 @@ function simplifyPower(x) {
             );
             const posBase = newFactors.length === 1 ? newFactors[0] : ce._fn("Multiply", newFactors);
             return {
-              value: posBase.pow(exp2).neg(),
+              value: posBase.pow(exp3).neg(),
               because: "(-a*b)^{p/q} -> -(a*b)^{p/q} when p,q odd"
             };
           }
         }
       }
     }
-    if (base.operator === "Multiply" && base.ops && exp2.isInteger === true) {
-      const newFactors = base.ops.map((factor3) => factor3.pow(exp2));
+    if (base.operator === "Multiply" && base.ops && exp3.isInteger === true) {
+      const newFactors = base.ops.map((factor3) => factor3.pow(exp3));
       return {
         value: ce._fn("Multiply", newFactors),
         because: "(a*b)^n -> a^n * b^n"
@@ -49818,19 +49850,19 @@ function simplifyPower(x) {
     }
     if (base.operator === "Negate" && base.op1) {
       const innerBase = base.op1;
-      if (exp2.isEven === true) {
+      if (exp3.isEven === true) {
         return {
-          value: innerBase.pow(exp2),
+          value: innerBase.pow(exp3),
           because: "(-x)^n -> x^n when n is even"
         };
       }
-      if (exp2.isOdd === true) {
+      if (exp3.isOdd === true) {
         return {
-          value: innerBase.pow(exp2).neg(),
+          value: innerBase.pow(exp3).neg(),
           because: "(-x)^n -> -x^n when n is odd"
         };
       }
-      const rat = asRational(exp2);
+      const rat = asRational(exp3);
       if (rat) {
         const [num, denom] = rat;
         const numN = Number(num);
@@ -49840,13 +49872,13 @@ function simplifyPower(x) {
         const denomIsOdd = denomN % 2 !== 0;
         if (numIsEven && denomIsOdd) {
           return {
-            value: innerBase.pow(exp2),
+            value: innerBase.pow(exp3),
             because: "(-x)^{n/m} -> x^{n/m} when n is even and m is odd"
           };
         }
         if (numIsOdd && denomIsOdd) {
           return {
-            value: innerBase.pow(exp2).neg(),
+            value: innerBase.pow(exp3).neg(),
             because: "(-x)^{n/m} -> -x^{n/m} when n and m are odd"
           };
         }
@@ -49854,15 +49886,15 @@ function simplifyPower(x) {
     }
     if (base.operator === "Sqrt" && base.op1) {
       const innerBase = base.op1;
-      if (exp2.isEven === true) {
+      if (exp3.isEven === true) {
         return {
-          value: innerBase.pow(exp2.div(2)),
+          value: innerBase.pow(exp3.div(2)),
           because: "sqrt(x)^n -> x^{n/2} when n is even"
         };
       }
       if (innerBase.isNonNegative === true) {
         return {
-          value: innerBase.pow(exp2.div(2)),
+          value: innerBase.pow(exp3.div(2)),
           because: "sqrt(x)^n -> x^{n/2} when x >= 0"
         };
       }
@@ -49870,7 +49902,7 @@ function simplifyPower(x) {
     if (base.operator === "Root" && base.op1 && base.op2) {
       const innerBase = base.op1;
       const rootIndex = base.op2;
-      const resultExp = exp2.div(rootIndex);
+      const resultExp = exp3.div(rootIndex);
       if (resultExp.isInteger === true || innerBase.isNonNegative === true) {
         return {
           value: innerBase.pow(resultExp),
@@ -49882,13 +49914,13 @@ function simplifyPower(x) {
       const innerBase = base.op1;
       const innerExp = base.op2;
       if (innerBase && innerExp) {
-        const bothIntegers = innerExp.isInteger === true && exp2.isInteger === true;
+        const bothIntegers = innerExp.isInteger === true && exp3.isInteger === true;
         const baseNonNeg = innerBase.isNonNegative === true;
-        const productIrrational = innerExp.mul(exp2).isRational === false;
-        const atLeastOnePositive = innerExp.isPositive === true || exp2.isPositive === true;
+        const productIrrational = innerExp.mul(exp3).isRational === false;
+        const atLeastOnePositive = innerExp.isPositive === true || exp3.isPositive === true;
         if ((bothIntegers || baseNonNeg || productIrrational) && atLeastOnePositive) {
           return {
-            value: innerBase.pow(innerExp.mul(exp2)),
+            value: innerBase.pow(innerExp.mul(exp3)),
             because: "(x^n)^m -> x^{n*m}"
           };
         }
@@ -49897,18 +49929,18 @@ function simplifyPower(x) {
     if (base.operator === "Divide" && base.op2?.is(0) === false) {
       const num = base.op1;
       const denom = base.op2;
-      if (exp2.operator === "Negate") {
+      if (exp3.operator === "Negate") {
         return {
-          value: denom.div(num).pow(exp2.op1),
+          value: denom.div(num).pow(exp3.op1),
           because: "(a/b)^{-n} -> (b/a)^n"
         };
       }
-      if (exp2.is(-1)) {
+      if (exp3.is(-1)) {
         return { value: denom.div(num), because: "(a/b)^{-1} -> b/a" };
       }
-      if (exp2.isNegative === true && exp2.isNumberLiteral) {
+      if (exp3.isNegative === true && exp3.isNumberLiteral) {
         return {
-          value: denom.div(num).pow(exp2.neg()),
+          value: denom.div(num).pow(exp3.neg()),
           because: "(a/b)^{-n} -> (b/a)^n"
         };
       }
@@ -49944,10 +49976,10 @@ function simplifyPower(x) {
     }
     if (denom.operator === "Power" && denom.op1?.is(0) === false) {
       const base = denom.op1;
-      const exp2 = denom.op2;
-      if (exp2?.operator === "Negate") {
+      const exp3 = denom.op2;
+      if (exp3?.operator === "Negate") {
         return {
-          value: num.mul(base.pow(exp2.op1)),
+          value: num.mul(base.pow(exp3.op1)),
           because: "a / b^{-n} -> a * b^n"
         };
       }
@@ -49970,9 +50002,9 @@ function simplifyPower(x) {
     if (denom.operator === "Power" && denom.op1?.operator === "Divide" && denom.op1.op2?.is(0) === false) {
       const fracNum = denom.op1.op1;
       const fracDenom = denom.op1.op2;
-      const exp2 = denom.op2;
+      const exp3 = denom.op2;
       return {
-        value: num.mul(fracDenom.div(fracNum).pow(exp2)),
+        value: num.mul(fracDenom.div(fracNum).pow(exp3)),
         because: "a / (b/c)^d -> a * (c/b)^d"
       };
     }
@@ -50147,12 +50179,12 @@ function simplifyTrig(x) {
       const left = arg.op1;
       const right = arg.op2;
       if (left?.symbol === "Pi" && right) {
-        const sign2 = PI_MINUS_SIGN[op];
-        if (sign2 !== void 0) {
+        const sign3 = PI_MINUS_SIGN[op];
+        if (sign3 !== void 0) {
           const result = ce._fn(op, [right]);
           return {
-            value: sign2 === 1 ? result : result.neg(),
-            because: `${op}(\u03C0 - x) -> ${sign2 === 1 ? "" : "-"}${op}(x)`
+            value: sign3 === 1 ? result : result.neg(),
+            because: `${op}(\u03C0 - x) -> ${sign3 === 1 ? "" : "-"}${op}(x)`
           };
         }
       }
@@ -50163,12 +50195,12 @@ function simplifyTrig(x) {
         const otherTerms = arg.ops.filter((_, idx) => idx !== piIndex);
         if (otherTerms.length === arg.ops.length - 1) {
           const remaining = otherTerms.length === 1 ? otherTerms[0] : ce._fn("Add", otherTerms);
-          const sign2 = PI_PLUS_SIGN[op];
-          if (sign2 !== void 0) {
+          const sign3 = PI_PLUS_SIGN[op];
+          if (sign3 !== void 0) {
             const result = ce._fn(op, [remaining]);
             return {
-              value: sign2 === 1 ? result : result.neg(),
-              because: `${op}(\u03C0 + x) -> ${sign2 === 1 ? "" : "-"}${op}(x)`
+              value: sign3 === 1 ? result : result.neg(),
+              because: `${op}(\u03C0 + x) -> ${sign3 === 1 ? "" : "-"}${op}(x)`
             };
           }
         }
@@ -51113,13 +51145,13 @@ var SIMPLIFY_RULES = [
     const otherTerms = [];
     for (const term of x.ops) {
       let base;
-      let exp2;
+      let exp3;
       if (term.operator === "Power") {
         base = term.op1;
-        exp2 = term.op2;
+        exp3 = term.op2;
       } else if (term.symbol) {
         base = term;
-        exp2 = ce.One;
+        exp3 = ce.One;
       } else {
         otherTerms.push(term);
         continue;
@@ -51130,7 +51162,7 @@ var SIMPLIFY_RULES = [
         group = { base, terms: [] };
         baseGroups.set(baseKey, group);
       }
-      group.terms.push({ term, exp: exp2 });
+      group.terms.push({ term, exp: exp3 });
     }
     let hasCombinations = false;
     for (const group of baseGroups.values()) {
@@ -51473,12 +51505,12 @@ var JAVASCRIPT_FUNCTIONS = {
   Power: (args, compile) => {
     const arg = args[0];
     if (arg === null) throw new Error("Power: no argument");
-    const exp2 = args[1].re;
-    if (exp2 === 0.5) return `Math.sqrt(${compile(arg)})`;
-    if (exp2 === 1 / 3) return `Math.cbrt(${compile(arg)})`;
-    if (exp2 === 1) return compile(arg);
-    if (exp2 === -1) return `(1 / (${compile(arg)}))`;
-    if (exp2 === -0.5) return `(1 / Math.sqrt(${compile(arg)}))`;
+    const exp3 = args[1].re;
+    if (exp3 === 0.5) return `Math.sqrt(${compile(arg)})`;
+    if (exp3 === 1 / 3) return `Math.cbrt(${compile(arg)})`;
+    if (exp3 === 1) return compile(arg);
+    if (exp3 === -1) return `(1 / (${compile(arg)}))`;
+    if (exp3 === -0.5) return `(1 / Math.sqrt(${compile(arg)}))`;
     return `Math.pow(${compile(arg)}, ${compile(args[1])})`;
   },
   Range: (args, compile) => {
@@ -51512,13 +51544,13 @@ var JAVASCRIPT_FUNCTIONS = {
     }
     return `Array.from({length: Math.floor((${stop} - ${start}) / ${step}) + 1}, (_, i) => ${start} + i * ${step})`;
   },
-  Root: ([arg, exp2], compile) => {
+  Root: ([arg, exp3], compile) => {
     if (arg === null) throw new Error("Root: no argument");
-    if (exp2 === null) return `Math.sqrt(${compile(arg)})`;
-    if (exp2?.re === 2) return `Math.sqrt(${compile(arg)})`;
-    if (exp2?.re === 3) return `Math.cbrt(${compile(arg)})`;
-    if (!isNaN(exp2?.re)) return `Math.pow(${compile(arg)},  ${1 / exp2.re})`;
-    return `Math.pow(${compile(arg)}, 1 / (${compile(exp2)}))`;
+    if (exp3 === null) return `Math.sqrt(${compile(arg)})`;
+    if (exp3?.re === 2) return `Math.sqrt(${compile(arg)})`;
+    if (exp3?.re === 3) return `Math.cbrt(${compile(arg)})`;
+    if (!isNaN(exp3?.re)) return `Math.pow(${compile(arg)},  ${1 / exp3.re})`;
+    return `Math.pow(${compile(arg)}, 1 / (${compile(exp3)}))`;
   },
   Random: "Math.random",
   Round: "Math.round",
@@ -52004,6 +52036,1611 @@ var GLSLTarget = class {
   }
 };
 
+// src/compute-engine/compilation/interval-javascript-target.ts
+init_base_compiler();
+
+// src/compute-engine/interval/util.ts
+function ok(value) {
+  return { kind: "interval", value };
+}
+function point(n) {
+  return { lo: n, hi: n };
+}
+function containsExtremum(x, extremum, period) {
+  const n = Math.ceil((x.lo - extremum) / period);
+  const candidate = extremum + n * period;
+  const EPS = 1e-15;
+  return candidate >= x.lo - EPS && candidate <= x.hi + EPS;
+}
+function unionResults(a, b) {
+  if (a.kind === "empty") return b;
+  if (b.kind === "empty") return a;
+  if (a.kind === "singular" || b.kind === "singular") {
+    return { kind: "singular" };
+  }
+  if (a.kind === "entire" || b.kind === "entire") {
+    return { kind: "entire" };
+  }
+  const aVal = a.value;
+  const bVal = b.value;
+  const aDomainClip = a.kind === "partial" ? a.domainClipped : null;
+  const bDomainClip = b.kind === "partial" ? b.domainClipped : null;
+  const value = {
+    lo: Math.min(aVal.lo, bVal.lo),
+    hi: Math.max(aVal.hi, bVal.hi)
+  };
+  if (aDomainClip || bDomainClip) {
+    const domainClipped = mergeDomainClip(aDomainClip, bDomainClip);
+    return { kind: "partial", value, domainClipped };
+  }
+  return { kind: "interval", value };
+}
+function mergeDomainClip(a, b) {
+  if (a === "both" || b === "both") return "both";
+  if (a === null) return b;
+  if (b === null) return a;
+  if (a === b) return a;
+  return "both";
+}
+function isPoint(x) {
+  return x.lo === x.hi;
+}
+function containsZero(x) {
+  return x.lo <= 0 && x.hi >= 0;
+}
+function isPositive2(x) {
+  return x.lo > 0;
+}
+function isNegative(x) {
+  return x.hi < 0;
+}
+function isNonNegative(x) {
+  return x.lo >= 0;
+}
+function isNonPositive(x) {
+  return x.hi <= 0;
+}
+function width(x) {
+  return x.hi - x.lo;
+}
+function midpoint(x) {
+  return (x.lo + x.hi) / 2;
+}
+function getValue(result) {
+  if (result.kind === "interval" || result.kind === "partial") {
+    return result.value;
+  }
+  return void 0;
+}
+function unwrap(input) {
+  if ("kind" in input) {
+    if (input.kind === "interval" || input.kind === "partial") {
+      return input.value;
+    }
+    return void 0;
+  }
+  return input;
+}
+function unwrapOrPropagate(...inputs) {
+  const result = [];
+  for (const input of inputs) {
+    if ("kind" in input) {
+      if (input.kind === "empty") return { kind: "empty" };
+      if (input.kind === "entire") return { kind: "entire" };
+      if (input.kind === "singular") return input;
+      result.push(input.value);
+    } else {
+      result.push(input);
+    }
+  }
+  return result;
+}
+
+// src/compute-engine/interval/arithmetic.ts
+function add4(a, b) {
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  return ok({ lo: aVal.lo + bVal.lo, hi: aVal.hi + bVal.hi });
+}
+function sub2(a, b) {
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  return ok({ lo: aVal.lo - bVal.hi, hi: aVal.hi - bVal.lo });
+}
+function negate2(x) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: -xVal.hi, hi: -xVal.lo });
+}
+function _mul(a, b) {
+  const products = [a.lo * b.lo, a.lo * b.hi, a.hi * b.lo, a.hi * b.hi];
+  return { lo: Math.min(...products), hi: Math.max(...products) };
+}
+function mul4(a, b) {
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  return ok(_mul(aVal, bVal));
+}
+function div3(a, b) {
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  return _div(aVal, bVal);
+}
+function _div(a, b) {
+  if (b.lo > 0 || b.hi < 0) {
+    return ok(_mul(a, { lo: 1 / b.hi, hi: 1 / b.lo }));
+  }
+  if (b.lo < 0 && b.hi > 0) {
+    return { kind: "singular" };
+  }
+  if (b.lo === 0 && b.hi > 0) {
+    if (a.lo >= 0) {
+      return {
+        kind: "partial",
+        value: { lo: a.lo / b.hi, hi: Infinity },
+        domainClipped: "hi"
+      };
+    } else if (a.hi <= 0) {
+      return {
+        kind: "partial",
+        value: { lo: -Infinity, hi: a.hi / b.hi },
+        domainClipped: "lo"
+      };
+    } else {
+      return { kind: "entire" };
+    }
+  }
+  if (b.hi === 0 && b.lo < 0) {
+    if (a.lo >= 0) {
+      return {
+        kind: "partial",
+        value: { lo: -Infinity, hi: a.lo / b.lo },
+        domainClipped: "lo"
+      };
+    } else if (a.hi <= 0) {
+      return {
+        kind: "partial",
+        value: { lo: a.hi / b.lo, hi: Infinity },
+        domainClipped: "hi"
+      };
+    } else {
+      return { kind: "entire" };
+    }
+  }
+  return { kind: "empty" };
+}
+
+// src/compute-engine/interval/elementary.ts
+function sqrt2(x) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return _sqrt(xVal);
+}
+function _sqrt(x) {
+  if (x.hi < 0) {
+    return { kind: "empty" };
+  }
+  if (x.lo >= 0) {
+    return ok({ lo: Math.sqrt(x.lo), hi: Math.sqrt(x.hi) });
+  }
+  return {
+    kind: "partial",
+    value: { lo: 0, hi: Math.sqrt(x.hi) },
+    domainClipped: "lo"
+  };
+}
+function square(x) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo >= 0) {
+    return ok({ lo: xVal.lo * xVal.lo, hi: xVal.hi * xVal.hi });
+  } else if (xVal.hi <= 0) {
+    return ok({ lo: xVal.hi * xVal.hi, hi: xVal.lo * xVal.lo });
+  } else {
+    return ok({ lo: 0, hi: Math.max(xVal.lo * xVal.lo, xVal.hi * xVal.hi) });
+  }
+}
+function intPow2(base, n) {
+  if (n === 0) return { lo: 1, hi: 1 };
+  if (n === 1) return base;
+  if (n % 2 === 0) {
+    if (base.lo >= 0) {
+      return { lo: Math.pow(base.lo, n), hi: Math.pow(base.hi, n) };
+    } else if (base.hi <= 0) {
+      return { lo: Math.pow(base.hi, n), hi: Math.pow(base.lo, n) };
+    } else {
+      return {
+        lo: 0,
+        hi: Math.max(Math.pow(base.lo, n), Math.pow(base.hi, n))
+      };
+    }
+  }
+  return { lo: Math.pow(base.lo, n), hi: Math.pow(base.hi, n) };
+}
+function pow3(base, exp3) {
+  if (Number.isInteger(exp3)) {
+    if (exp3 >= 0) {
+      return ok(intPow2(base, exp3));
+    } else {
+      if (containsZero(base)) {
+        return { kind: "singular" };
+      }
+      const denom = intPow2(base, -exp3);
+      return ok({ lo: 1 / denom.hi, hi: 1 / denom.lo });
+    }
+  } else {
+    if (isNegative(base)) {
+      return { kind: "empty" };
+    }
+    if (base.lo < 0) {
+      const value = exp3 > 0 ? { lo: 0, hi: Math.pow(base.hi, exp3) } : { lo: Math.pow(base.hi, exp3), hi: Infinity };
+      return { kind: "partial", value, domainClipped: "lo" };
+    }
+    if (exp3 > 0) {
+      return ok({ lo: Math.pow(base.lo, exp3), hi: Math.pow(base.hi, exp3) });
+    } else {
+      if (base.lo === 0) {
+        return {
+          kind: "partial",
+          value: { lo: Math.pow(base.hi, exp3), hi: Infinity },
+          domainClipped: "hi"
+        };
+      }
+      return ok({ lo: Math.pow(base.hi, exp3), hi: Math.pow(base.lo, exp3) });
+    }
+  }
+}
+function powInterval(base, exp3) {
+  if (base.hi <= 0) {
+    return { kind: "empty" };
+  }
+  if (base.lo <= 0) {
+    const posBase = { lo: Math.max(base.lo, Number.EPSILON), hi: base.hi };
+    const corners2 = [
+      Math.pow(posBase.lo, exp3.lo),
+      Math.pow(posBase.lo, exp3.hi),
+      Math.pow(posBase.hi, exp3.lo),
+      Math.pow(posBase.hi, exp3.hi)
+    ];
+    return {
+      kind: "partial",
+      value: { lo: Math.min(...corners2), hi: Math.max(...corners2) },
+      domainClipped: "lo"
+    };
+  }
+  const corners = [
+    Math.pow(base.lo, exp3.lo),
+    Math.pow(base.lo, exp3.hi),
+    Math.pow(base.hi, exp3.lo),
+    Math.pow(base.hi, exp3.hi)
+  ];
+  return ok({ lo: Math.min(...corners), hi: Math.max(...corners) });
+}
+function exp2(x) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.exp(xVal.lo), hi: Math.exp(xVal.hi) });
+}
+function ln2(x) {
+  if (x.hi <= 0) {
+    return { kind: "empty" };
+  }
+  if (x.lo > 0) {
+    return ok({ lo: Math.log(x.lo), hi: Math.log(x.hi) });
+  }
+  return {
+    kind: "partial",
+    value: { lo: -Infinity, hi: Math.log(x.hi) },
+    domainClipped: "lo"
+  };
+}
+function log102(x) {
+  if (x.hi <= 0) {
+    return { kind: "empty" };
+  }
+  if (x.lo > 0) {
+    return ok({ lo: Math.log10(x.lo), hi: Math.log10(x.hi) });
+  }
+  return {
+    kind: "partial",
+    value: { lo: -Infinity, hi: Math.log10(x.hi) },
+    domainClipped: "lo"
+  };
+}
+function log22(x) {
+  if (x.hi <= 0) {
+    return { kind: "empty" };
+  }
+  if (x.lo > 0) {
+    return ok({ lo: Math.log2(x.lo), hi: Math.log2(x.hi) });
+  }
+  return {
+    kind: "partial",
+    value: { lo: -Infinity, hi: Math.log2(x.hi) },
+    domainClipped: "lo"
+  };
+}
+function abs2(x) {
+  if (x.lo >= 0) {
+    return ok(x);
+  }
+  if (x.hi <= 0) {
+    return ok({ lo: -x.hi, hi: -x.lo });
+  }
+  return ok({ lo: 0, hi: Math.max(-x.lo, x.hi) });
+}
+function floor2(x) {
+  return ok({ lo: Math.floor(x.lo), hi: Math.floor(x.hi) });
+}
+function ceil2(x) {
+  return ok({ lo: Math.ceil(x.lo), hi: Math.ceil(x.hi) });
+}
+function round2(x) {
+  return ok({ lo: Math.round(x.lo), hi: Math.round(x.hi) });
+}
+function min2(a, b) {
+  return ok({ lo: Math.min(a.lo, b.lo), hi: Math.min(a.hi, b.hi) });
+}
+function max2(a, b) {
+  return ok({ lo: Math.max(a.lo, b.lo), hi: Math.max(a.hi, b.hi) });
+}
+function mod2(a, b) {
+  if (containsZero(b)) {
+    return { kind: "singular" };
+  }
+  const bAbs = Math.max(Math.abs(b.lo), Math.abs(b.hi));
+  const aWidth = a.hi - a.lo;
+  if (aWidth >= bAbs) {
+    return ok({ lo: 0, hi: bAbs });
+  }
+  const modLo = (a.lo % bAbs + bAbs) % bAbs;
+  const modHi = (a.hi % bAbs + bAbs) % bAbs;
+  if (modLo <= modHi) {
+    return ok({ lo: modLo, hi: modHi });
+  } else {
+    return ok({ lo: 0, hi: bAbs });
+  }
+}
+function sign2(x) {
+  if (x.lo > 0) return ok({ lo: 1, hi: 1 });
+  if (x.hi < 0) return ok({ lo: -1, hi: -1 });
+  if (x.lo === 0 && x.hi === 0) return ok({ lo: 0, hi: 0 });
+  if (x.lo < 0 && x.hi > 0) return ok({ lo: -1, hi: 1 });
+  if (x.lo === 0) return ok({ lo: 0, hi: 1 });
+  return ok({ lo: -1, hi: 0 });
+}
+
+// src/compute-engine/interval/trigonometric.ts
+var TWO_PI = 2 * Math.PI;
+var PI2 = Math.PI;
+var HALF_PI = Math.PI / 2;
+var THREE_HALF_PI = 3 * Math.PI / 2;
+function sin2(x) {
+  if (x.hi - x.lo >= TWO_PI) {
+    return ok({ lo: -1, hi: 1 });
+  }
+  const sinLo = Math.sin(x.lo);
+  const sinHi = Math.sin(x.hi);
+  let lo = Math.min(sinLo, sinHi);
+  let hi = Math.max(sinLo, sinHi);
+  if (containsExtremum(x, HALF_PI, TWO_PI)) {
+    hi = 1;
+  }
+  if (containsExtremum(x, THREE_HALF_PI, TWO_PI)) {
+    lo = -1;
+  }
+  return ok({ lo, hi });
+}
+function cos2(x) {
+  if (x.hi - x.lo >= TWO_PI) {
+    return ok({ lo: -1, hi: 1 });
+  }
+  const cosLo = Math.cos(x.lo);
+  const cosHi = Math.cos(x.hi);
+  let lo = Math.min(cosLo, cosHi);
+  let hi = Math.max(cosLo, cosHi);
+  if (containsExtremum(x, 0, TWO_PI)) {
+    hi = 1;
+  }
+  if (containsExtremum(x, PI2, TWO_PI)) {
+    lo = -1;
+  }
+  return ok({ lo, hi });
+}
+function tan2(x) {
+  if (x.hi - x.lo >= PI2) {
+    return { kind: "singular" };
+  }
+  if (containsExtremum(x, HALF_PI, PI2)) {
+    const n = Math.ceil((x.lo - HALF_PI) / PI2);
+    const poleAt = HALF_PI + n * PI2;
+    return { kind: "singular", at: poleAt };
+  }
+  const tanLo = Math.tan(x.lo);
+  const tanHi = Math.tan(x.hi);
+  if (tanLo > 1e10 && tanHi < -1e10 || tanLo < -1e10 && tanHi > 1e10) {
+    return { kind: "singular" };
+  }
+  return ok({ lo: tanLo, hi: tanHi });
+}
+function cot(x) {
+  if (x.hi - x.lo >= PI2) {
+    return { kind: "singular" };
+  }
+  if (containsExtremum(x, 0, PI2)) {
+    const n = Math.ceil(x.lo / PI2);
+    const poleAt = n * PI2;
+    return { kind: "singular", at: poleAt };
+  }
+  const cotLo = 1 / Math.tan(x.lo);
+  const cotHi = 1 / Math.tan(x.hi);
+  return ok({ lo: Math.min(cotLo, cotHi), hi: Math.max(cotLo, cotHi) });
+}
+function sec(x) {
+  if (x.hi - x.lo >= PI2) {
+    return { kind: "singular" };
+  }
+  if (containsExtremum(x, HALF_PI, PI2)) {
+    const n = Math.ceil((x.lo - HALF_PI) / PI2);
+    const poleAt = HALF_PI + n * PI2;
+    return { kind: "singular", at: poleAt };
+  }
+  const secLo = 1 / Math.cos(x.lo);
+  const secHi = 1 / Math.cos(x.hi);
+  let lo = Math.min(secLo, secHi);
+  let hi = Math.max(secLo, secHi);
+  if (containsExtremum(x, 0, TWO_PI)) {
+    lo = Math.min(lo, 1);
+    hi = Math.max(hi, 1);
+  }
+  if (containsExtremum(x, PI2, TWO_PI)) {
+    lo = Math.min(lo, -1);
+    hi = Math.max(hi, -1);
+  }
+  return ok({ lo, hi });
+}
+function csc(x) {
+  if (x.hi - x.lo >= PI2) {
+    return { kind: "singular" };
+  }
+  if (containsExtremum(x, 0, PI2)) {
+    const n = Math.ceil(x.lo / PI2);
+    const poleAt = n * PI2;
+    return { kind: "singular", at: poleAt };
+  }
+  const cscLo = 1 / Math.sin(x.lo);
+  const cscHi = 1 / Math.sin(x.hi);
+  let lo = Math.min(cscLo, cscHi);
+  let hi = Math.max(cscLo, cscHi);
+  if (containsExtremum(x, HALF_PI, TWO_PI)) {
+    lo = Math.min(lo, 1);
+    hi = Math.max(hi, 1);
+  }
+  if (containsExtremum(x, THREE_HALF_PI, TWO_PI)) {
+    lo = Math.min(lo, -1);
+    hi = Math.max(hi, -1);
+  }
+  return ok({ lo, hi });
+}
+function asin2(x) {
+  if (x.lo > 1 || x.hi < -1) {
+    return { kind: "empty" };
+  }
+  if (x.lo < -1 || x.hi > 1) {
+    const clippedLo = Math.max(x.lo, -1);
+    const clippedHi = Math.min(x.hi, 1);
+    return {
+      kind: "partial",
+      value: { lo: Math.asin(clippedLo), hi: Math.asin(clippedHi) },
+      domainClipped: x.lo < -1 && x.hi > 1 ? "both" : x.lo < -1 ? "lo" : "hi"
+    };
+  }
+  return ok({ lo: Math.asin(x.lo), hi: Math.asin(x.hi) });
+}
+function acos2(x) {
+  if (x.lo > 1 || x.hi < -1) {
+    return { kind: "empty" };
+  }
+  if (x.lo < -1 || x.hi > 1) {
+    const clippedLo = Math.max(x.lo, -1);
+    const clippedHi = Math.min(x.hi, 1);
+    return {
+      kind: "partial",
+      value: { lo: Math.acos(clippedHi), hi: Math.acos(clippedLo) },
+      domainClipped: x.lo < -1 && x.hi > 1 ? "both" : x.lo < -1 ? "lo" : "hi"
+    };
+  }
+  return ok({ lo: Math.acos(x.hi), hi: Math.acos(x.lo) });
+}
+function atan3(x) {
+  return ok({ lo: Math.atan(x.lo), hi: Math.atan(x.hi) });
+}
+function atan22(y, x) {
+  if (y.lo === y.hi && x.lo === x.hi) {
+    const result = Math.atan2(y.lo, x.lo);
+    return ok({ lo: result, hi: result });
+  }
+  const angles = [];
+  angles.push(Math.atan2(y.lo, x.lo));
+  angles.push(Math.atan2(y.lo, x.hi));
+  angles.push(Math.atan2(y.hi, x.lo));
+  angles.push(Math.atan2(y.hi, x.hi));
+  if (x.lo < 0 && y.lo < 0 && y.hi > 0) {
+    return ok({ lo: -PI2, hi: PI2 });
+  }
+  return ok({ lo: Math.min(...angles), hi: Math.max(...angles) });
+}
+function sinh3(x) {
+  return ok({ lo: Math.sinh(x.lo), hi: Math.sinh(x.hi) });
+}
+function cosh3(x) {
+  if (x.lo >= 0) {
+    return ok({ lo: Math.cosh(x.lo), hi: Math.cosh(x.hi) });
+  } else if (x.hi <= 0) {
+    return ok({ lo: Math.cosh(x.hi), hi: Math.cosh(x.lo) });
+  } else {
+    return ok({ lo: 1, hi: Math.max(Math.cosh(x.lo), Math.cosh(x.hi)) });
+  }
+}
+function tanh2(x) {
+  return ok({ lo: Math.tanh(x.lo), hi: Math.tanh(x.hi) });
+}
+function asinh2(x) {
+  return ok({ lo: Math.asinh(x.lo), hi: Math.asinh(x.hi) });
+}
+function acosh2(x) {
+  if (x.hi < 1) {
+    return { kind: "empty" };
+  }
+  if (x.lo < 1) {
+    return {
+      kind: "partial",
+      value: { lo: 0, hi: Math.acosh(x.hi) },
+      domainClipped: "lo"
+    };
+  }
+  return ok({ lo: Math.acosh(x.lo), hi: Math.acosh(x.hi) });
+}
+function atanh2(x) {
+  if (x.lo >= 1 || x.hi <= -1) {
+    return { kind: "empty" };
+  }
+  if (x.lo <= -1 || x.hi >= 1) {
+    const clippedLo = Math.max(x.lo, -1 + Number.EPSILON);
+    const clippedHi = Math.min(x.hi, 1 - Number.EPSILON);
+    return {
+      kind: "partial",
+      value: { lo: Math.atanh(clippedLo), hi: Math.atanh(clippedHi) },
+      domainClipped: x.lo <= -1 && x.hi >= 1 ? "both" : x.lo <= -1 ? "lo" : "hi"
+    };
+  }
+  return ok({ lo: Math.atanh(x.lo), hi: Math.atanh(x.hi) });
+}
+
+// src/compute-engine/interval/comparison.ts
+function less(a, b) {
+  if (a.hi < b.lo) return "true";
+  if (a.lo >= b.hi) return "false";
+  return "maybe";
+}
+function lessEqual(a, b) {
+  if (a.hi <= b.lo) return "true";
+  if (a.lo > b.hi) return "false";
+  return "maybe";
+}
+function greater(a, b) {
+  if (a.lo > b.hi) return "true";
+  if (a.hi <= b.lo) return "false";
+  return "maybe";
+}
+function greaterEqual(a, b) {
+  if (a.lo >= b.hi) return "true";
+  if (a.hi < b.lo) return "false";
+  return "maybe";
+}
+function equal(a, b) {
+  if (a.lo === a.hi && b.lo === b.hi && a.lo === b.lo) return "true";
+  if (a.hi < b.lo || b.hi < a.lo) return "false";
+  return "maybe";
+}
+function notEqual(a, b) {
+  const eq2 = equal(a, b);
+  if (eq2 === "true") return "false";
+  if (eq2 === "false") return "true";
+  return "maybe";
+}
+function and(a, b) {
+  if (a === "false" || b === "false") return "false";
+  if (a === "true" && b === "true") return "true";
+  return "maybe";
+}
+function or(a, b) {
+  if (a === "true" || b === "true") return "true";
+  if (a === "false" && b === "false") return "false";
+  return "maybe";
+}
+function not(a) {
+  if (a === "true") return "false";
+  if (a === "false") return "true";
+  return "maybe";
+}
+function piecewise(x, condition, trueBranch, falseBranch) {
+  const cond = condition(x);
+  switch (cond) {
+    case "true":
+      return trueBranch(x);
+    case "false":
+      return falseBranch(x);
+    case "maybe":
+      const t = trueBranch(x);
+      const f = falseBranch(x);
+      return unionResults(t, f);
+  }
+}
+function clamp2(x, lo, hi) {
+  const resultLo = Math.max(x.lo, lo.lo);
+  const resultHi = Math.min(x.hi, hi.hi);
+  if (resultLo > resultHi) {
+    return { kind: "empty" };
+  }
+  return { kind: "interval", value: { lo: resultLo, hi: resultHi } };
+}
+
+// src/compute-engine/interval/index.ts
+var IntervalArithmetic = {
+  // Utilities
+  ok,
+  point,
+  containsExtremum,
+  unionResults,
+  mergeDomainClip,
+  isPoint,
+  containsZero,
+  isPositive: isPositive2,
+  isNegative,
+  isNonNegative,
+  isNonPositive,
+  width,
+  midpoint,
+  getValue,
+  unwrap,
+  unwrapOrPropagate,
+  // Arithmetic
+  add: add4,
+  sub: sub2,
+  mul: mul4,
+  div: div3,
+  negate: negate2,
+  // Elementary
+  sqrt: sqrt2,
+  square,
+  pow: pow3,
+  powInterval,
+  exp: exp2,
+  ln: ln2,
+  log10: log102,
+  log2: log22,
+  abs: abs2,
+  floor: floor2,
+  ceil: ceil2,
+  round: round2,
+  min: min2,
+  max: max2,
+  mod: mod2,
+  sign: sign2,
+  // Trigonometric
+  sin: sin2,
+  cos: cos2,
+  tan: tan2,
+  cot,
+  sec,
+  csc,
+  asin: asin2,
+  acos: acos2,
+  atan: atan3,
+  atan2: atan22,
+  sinh: sinh3,
+  cosh: cosh3,
+  tanh: tanh2,
+  asinh: asinh2,
+  acosh: acosh2,
+  atanh: atanh2,
+  // Comparison
+  less,
+  lessEqual,
+  greater,
+  greaterEqual,
+  equal,
+  notEqual,
+  and,
+  or,
+  not,
+  piecewise,
+  clamp: clamp2
+};
+
+// src/compute-engine/compilation/interval-javascript-target.ts
+var INTERVAL_JAVASCRIPT_OPERATORS = {
+  // We use high precedence since these become function calls
+  Add: ["_IA.add", 20],
+  Negate: ["_IA.negate", 20],
+  Subtract: ["_IA.sub", 20],
+  Multiply: ["_IA.mul", 20],
+  Divide: ["_IA.div", 20],
+  // Comparisons return BoolInterval
+  Equal: ["_IA.equal", 20],
+  NotEqual: ["_IA.notEqual", 20],
+  LessEqual: ["_IA.lessEqual", 20],
+  GreaterEqual: ["_IA.greaterEqual", 20],
+  Less: ["_IA.less", 20],
+  Greater: ["_IA.greater", 20],
+  And: ["_IA.and", 20],
+  Or: ["_IA.or", 20],
+  Not: ["_IA.not", 20]
+};
+var INTERVAL_JAVASCRIPT_FUNCTIONS = {
+  // Basic arithmetic - using function call syntax
+  Add: (args, compile) => {
+    if (args.length === 0) return "_IA.point(0)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `_IA.add(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Subtract: (args, compile) => {
+    if (args.length === 0) return "_IA.point(0)";
+    if (args.length === 1) return `_IA.negate(${compile(args[0])})`;
+    if (args.length === 2)
+      return `_IA.sub(${compile(args[0])}, ${compile(args[1])})`;
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `_IA.sub(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Multiply: (args, compile) => {
+    if (args.length === 0) return "_IA.point(1)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `_IA.mul(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Divide: (args, compile) => {
+    if (args.length === 0) return "_IA.point(1)";
+    if (args.length === 1) return compile(args[0]);
+    if (args.length === 2)
+      return `_IA.div(${compile(args[0])}, ${compile(args[1])})`;
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `_IA.div(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Negate: (args, compile) => `_IA.negate(${compile(args[0])})`,
+  // Elementary functions
+  Abs: (args, compile) => `_IA.abs(${compile(args[0])})`,
+  Ceiling: (args, compile) => `_IA.ceil(${compile(args[0])})`,
+  Exp: (args, compile) => `_IA.exp(${compile(args[0])})`,
+  Floor: (args, compile) => `_IA.floor(${compile(args[0])})`,
+  Ln: (args, compile) => `_IA.ln(${compile(args[0])})`,
+  Log: (args, compile) => {
+    if (args.length === 1) return `_IA.log10(${compile(args[0])})`;
+    return `_IA.div(_IA.ln(${compile(args[0])}), _IA.ln(${compile(args[1])}))`;
+  },
+  Lb: (args, compile) => `_IA.log2(${compile(args[0])})`,
+  Max: (args, compile) => {
+    if (args.length === 0) return "_IA.point(-Infinity)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `_IA.max(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Min: (args, compile) => {
+    if (args.length === 0) return "_IA.point(Infinity)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `_IA.min(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Power: (args, compile) => {
+    const base = args[0];
+    const exp3 = args[1];
+    if (base === null) throw new Error("Power: no argument");
+    if (base.symbol === "ExponentialE") {
+      return `_IA.exp(${compile(exp3)})`;
+    }
+    if (exp3?.isNumberLiteral && exp3.im === 0) {
+      const expVal = exp3.re;
+      if (expVal === 0.5) return `_IA.sqrt(${compile(base)})`;
+      if (expVal === 2) return `_IA.square(${compile(base)})`;
+      return `_IA.pow(${compile(base)}, ${expVal})`;
+    }
+    return `_IA.powInterval(${compile(base)}, ${compile(exp3)})`;
+  },
+  Root: (args, compile) => {
+    const [arg, exp3] = args;
+    if (arg === null) throw new Error("Root: no argument");
+    if (exp3 === null) return `_IA.sqrt(${compile(arg)})`;
+    if (exp3?.re === 2) return `_IA.sqrt(${compile(arg)})`;
+    if (exp3?.isNumberLiteral && exp3.im === 0) {
+      return `_IA.pow(${compile(arg)}, ${1 / exp3.re})`;
+    }
+    return `_IA.powInterval(${compile(arg)}, _IA.div(_IA.point(1), ${compile(exp3)}))`;
+  },
+  Round: (args, compile) => `_IA.round(${compile(args[0])})`,
+  Sgn: (args, compile) => `_IA.sign(${compile(args[0])})`,
+  Sqrt: (args, compile) => `_IA.sqrt(${compile(args[0])})`,
+  Square: (args, compile) => `_IA.square(${compile(args[0])})`,
+  // Trigonometric functions
+  Sin: (args, compile) => `_IA.sin(${compile(args[0])})`,
+  Cos: (args, compile) => `_IA.cos(${compile(args[0])})`,
+  Tan: (args, compile) => `_IA.tan(${compile(args[0])})`,
+  Cot: (args, compile) => `_IA.cot(${compile(args[0])})`,
+  Sec: (args, compile) => `_IA.sec(${compile(args[0])})`,
+  Csc: (args, compile) => `_IA.csc(${compile(args[0])})`,
+  Arcsin: (args, compile) => `_IA.asin(${compile(args[0])})`,
+  Arccos: (args, compile) => `_IA.acos(${compile(args[0])})`,
+  Arctan: (args, compile) => `_IA.atan(${compile(args[0])})`,
+  // Hyperbolic functions
+  Sinh: (args, compile) => `_IA.sinh(${compile(args[0])})`,
+  Cosh: (args, compile) => `_IA.cosh(${compile(args[0])})`,
+  Tanh: (args, compile) => `_IA.tanh(${compile(args[0])})`,
+  Arsinh: (args, compile) => `_IA.asinh(${compile(args[0])})`,
+  Arcosh: (args, compile) => `_IA.acosh(${compile(args[0])})`,
+  Artanh: (args, compile) => `_IA.atanh(${compile(args[0])})`,
+  // Inverse trig (alternative names)
+  Asin: (args, compile) => `_IA.asin(${compile(args[0])})`,
+  Acos: (args, compile) => `_IA.acos(${compile(args[0])})`,
+  Atan: (args, compile) => `_IA.atan(${compile(args[0])})`,
+  // Mod
+  Mod: (args, compile) => `_IA.mod(${compile(args[0])}, ${compile(args[1])})`,
+  // Conditionals
+  If: (args, compile) => {
+    if (args.length !== 3) throw new Error("If: wrong number of arguments");
+    return `_IA.piecewise(
+      ${compile(args[0])},
+      (_x) => ${compile(args[0])},
+      (_x) => ${compile(args[1])},
+      (_x) => ${compile(args[2])}
+    )`;
+  }
+};
+var ComputeEngineIntervalFunction = class extends Function {
+  IA = IntervalArithmetic;
+  constructor(body, preamble = "") {
+    super(
+      "_IA",
+      "_",
+      preamble ? `${preamble};return ${body}` : `return ${body}`
+    );
+    return new Proxy(this, {
+      apply: (target, thisArg, argumentsList) => {
+        const processedArgs = argumentsList.map(processInput);
+        return super.apply(thisArg, [this.IA, ...processedArgs]);
+      },
+      get: (target, prop) => {
+        if (prop === "toString") return () => body;
+        if (prop === "isCompiled") return true;
+        return target[prop];
+      }
+    });
+  }
+};
+function processInput(input) {
+  if (input === null || input === void 0) {
+    return input;
+  }
+  if (typeof input === "object" && "lo" in input && "hi" in input) {
+    return input;
+  }
+  if (typeof input === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+      result[key] = processInput(value);
+    }
+    return result;
+  }
+  if (typeof input === "number") {
+    return { lo: input, hi: input };
+  }
+  return input;
+}
+var IntervalJavaScriptTarget = class {
+  getOperators() {
+    return INTERVAL_JAVASCRIPT_OPERATORS;
+  }
+  getFunctions() {
+    return INTERVAL_JAVASCRIPT_FUNCTIONS;
+  }
+  createTarget(options = {}) {
+    return {
+      language: "interval-javascript",
+      // Don't use operators - all arithmetic goes through functions
+      // because interval arithmetic returns IntervalResult, not numbers
+      operators: () => void 0,
+      functions: (id) => INTERVAL_JAVASCRIPT_FUNCTIONS[id],
+      var: (id) => {
+        const result = {
+          Pi: "_IA.point(Math.PI)",
+          ExponentialE: "_IA.point(Math.E)",
+          NaN: "{ lo: NaN, hi: NaN }",
+          ImaginaryUnit: "{ lo: NaN, hi: NaN }",
+          Half: "_IA.point(0.5)",
+          MachineEpsilon: "_IA.point(Number.EPSILON)",
+          GoldenRatio: "_IA.point((1 + Math.sqrt(5)) / 2)",
+          CatalanConstant: "_IA.point(0.91596559417721901)",
+          EulerGamma: "_IA.point(0.57721566490153286)"
+        };
+        return result[id];
+      },
+      string: (str) => JSON.stringify(str),
+      number: (n) => `_IA.point(${n})`,
+      indent: 0,
+      ws: (s) => s ?? "",
+      preamble: "",
+      ...options
+    };
+  }
+  compileToExecutable(expr, options = {}) {
+    const { functions, vars, preamble } = options;
+    const unknowns = expr.unknowns;
+    const namedFunctions = {};
+    let preambleImports = "";
+    if (functions) {
+      for (const [k, v] of Object.entries(functions)) {
+        if (typeof v === "function") {
+          preambleImports += `const ${k} = ${v.toString()};
+`;
+          namedFunctions[k] = k;
+        } else if (typeof v === "string") {
+          namedFunctions[k] = v;
+        }
+      }
+    }
+    const target = this.createTarget({
+      functions: (id) => namedFunctions?.[id] ? namedFunctions[id] : INTERVAL_JAVASCRIPT_FUNCTIONS[id],
+      var: (id) => {
+        if (vars && id in vars) return vars[id];
+        const constants = {
+          Pi: "_IA.point(Math.PI)",
+          ExponentialE: "_IA.point(Math.E)",
+          NaN: "{ lo: NaN, hi: NaN }",
+          ImaginaryUnit: "{ lo: NaN, hi: NaN }",
+          Half: "_IA.point(0.5)",
+          MachineEpsilon: "_IA.point(Number.EPSILON)",
+          GoldenRatio: "_IA.point((1 + Math.sqrt(5)) / 2)",
+          CatalanConstant: "_IA.point(0.91596559417721901)",
+          EulerGamma: "_IA.point(0.57721566490153286)"
+        };
+        if (id in constants) return constants[id];
+        if (unknowns.includes(id)) return `_.${id}`;
+        return void 0;
+      },
+      preamble: (preamble ?? "") + preambleImports
+    });
+    return compileToIntervalTarget(expr, target);
+  }
+};
+function compileToIntervalTarget(expr, target) {
+  const js = BaseCompiler.compile(expr, target);
+  return new ComputeEngineIntervalFunction(
+    js,
+    target.preamble
+  );
+}
+
+// src/compute-engine/compilation/interval-glsl-target.ts
+init_base_compiler();
+var GLSL_INTERVAL_LIBRARY = `
+// Interval Arithmetic Library for GLSL
+// Intervals are represented as vec2(lo, hi)
+// Results use IntervalResult struct with status flags
+
+// Status constants
+const float IA_NORMAL = 0.0;
+const float IA_EMPTY = 1.0;
+const float IA_ENTIRE = 2.0;
+const float IA_SINGULAR = 3.0;
+const float IA_PARTIAL_LO = 4.0;
+const float IA_PARTIAL_HI = 5.0;
+const float IA_PARTIAL_BOTH = 6.0;
+
+// Interval result struct
+struct IntervalResult {
+  vec2 value;      // (lo, hi)
+  float status;    // Status flag
+};
+
+// Epsilon for conservative bounds
+const float IA_EPS = 1e-6;
+const float IA_HUGE = 1e38;
+
+// Create a point interval
+vec2 ia_point(float x) {
+  return vec2(x, x);
+}
+
+// Create interval result
+IntervalResult ia_ok(vec2 v) {
+  return IntervalResult(v, IA_NORMAL);
+}
+
+IntervalResult ia_empty() {
+  return IntervalResult(vec2(0.0), IA_EMPTY);
+}
+
+IntervalResult ia_entire() {
+  return IntervalResult(vec2(-IA_HUGE, IA_HUGE), IA_ENTIRE);
+}
+
+IntervalResult ia_singular(float at) {
+  return IntervalResult(vec2(at, at), IA_SINGULAR);
+}
+
+IntervalResult ia_partial(vec2 v, float clip) {
+  return IntervalResult(v, clip);
+}
+
+// Addition
+IntervalResult ia_add(vec2 a, vec2 b) {
+  return ia_ok(vec2(a.x + b.x - IA_EPS, a.y + b.y + IA_EPS));
+}
+
+// Subtraction
+IntervalResult ia_sub(vec2 a, vec2 b) {
+  return ia_ok(vec2(a.x - b.y - IA_EPS, a.y - b.x + IA_EPS));
+}
+
+// Negation
+IntervalResult ia_negate(vec2 x) {
+  return ia_ok(vec2(-x.y, -x.x));
+}
+
+// Multiplication helper (returns vec2)
+vec2 ia_mul_raw(vec2 a, vec2 b) {
+  float p1 = a.x * b.x;
+  float p2 = a.x * b.y;
+  float p3 = a.y * b.x;
+  float p4 = a.y * b.y;
+  return vec2(
+    min(min(p1, p2), min(p3, p4)) - IA_EPS,
+    max(max(p1, p2), max(p3, p4)) + IA_EPS
+  );
+}
+
+// Multiplication
+IntervalResult ia_mul(vec2 a, vec2 b) {
+  return ia_ok(ia_mul_raw(a, b));
+}
+
+// Division
+IntervalResult ia_div(vec2 a, vec2 b) {
+  // Case 1: Divisor entirely positive or negative
+  if (b.x > 0.0 || b.y < 0.0) {
+    return ia_ok(ia_mul_raw(a, vec2(1.0 / b.y, 1.0 / b.x)));
+  }
+
+  // Case 2: Divisor strictly contains zero
+  if (b.x < 0.0 && b.y > 0.0) {
+    return ia_singular(0.0);
+  }
+
+  // Case 3: Divisor touches zero at lower bound [0, c]
+  if (b.x == 0.0 && b.y > 0.0) {
+    if (a.x >= 0.0) {
+      return ia_partial(vec2(a.x / b.y, IA_HUGE), IA_PARTIAL_HI);
+    } else if (a.y <= 0.0) {
+      return ia_partial(vec2(-IA_HUGE, a.y / b.y), IA_PARTIAL_LO);
+    } else {
+      return ia_entire();
+    }
+  }
+
+  // Case 4: Divisor touches zero at upper bound [c, 0]
+  if (b.y == 0.0 && b.x < 0.0) {
+    if (a.x >= 0.0) {
+      return ia_partial(vec2(-IA_HUGE, a.x / b.x), IA_PARTIAL_LO);
+    } else if (a.y <= 0.0) {
+      return ia_partial(vec2(a.y / b.x, IA_HUGE), IA_PARTIAL_HI);
+    } else {
+      return ia_entire();
+    }
+  }
+
+  // Case 5: Divisor is [0, 0]
+  return ia_empty();
+}
+
+// Square root
+IntervalResult ia_sqrt(vec2 x) {
+  if (x.y < 0.0) {
+    return ia_empty();
+  }
+  if (x.x >= 0.0) {
+    return ia_ok(vec2(sqrt(x.x), sqrt(x.y) + IA_EPS));
+  }
+  return ia_partial(vec2(0.0, sqrt(x.y) + IA_EPS), IA_PARTIAL_LO);
+}
+
+// Square
+IntervalResult ia_square(vec2 x) {
+  if (x.x >= 0.0) {
+    return ia_ok(vec2(x.x * x.x - IA_EPS, x.y * x.y + IA_EPS));
+  } else if (x.y <= 0.0) {
+    return ia_ok(vec2(x.y * x.y - IA_EPS, x.x * x.x + IA_EPS));
+  } else {
+    float m = max(-x.x, x.y);
+    return ia_ok(vec2(0.0, m * m + IA_EPS));
+  }
+}
+
+// Exponential
+IntervalResult ia_exp(vec2 x) {
+  return ia_ok(vec2(exp(x.x) - IA_EPS, exp(x.y) + IA_EPS));
+}
+
+// Natural logarithm
+IntervalResult ia_ln(vec2 x) {
+  if (x.y <= 0.0) {
+    return ia_empty();
+  }
+  if (x.x > 0.0) {
+    return ia_ok(vec2(log(x.x) - IA_EPS, log(x.y) + IA_EPS));
+  }
+  return ia_partial(vec2(-IA_HUGE, log(x.y) + IA_EPS), IA_PARTIAL_LO);
+}
+
+// Absolute value
+IntervalResult ia_abs(vec2 x) {
+  if (x.x >= 0.0) {
+    return ia_ok(x);
+  }
+  if (x.y <= 0.0) {
+    return ia_ok(vec2(-x.y, -x.x));
+  }
+  return ia_ok(vec2(0.0, max(-x.x, x.y)));
+}
+
+// Sign function
+IntervalResult ia_sign(vec2 x) {
+  if (x.x > 0.0) return ia_ok(vec2(1.0, 1.0));
+  if (x.y < 0.0) return ia_ok(vec2(-1.0, -1.0));
+  if (x.x == 0.0 && x.y == 0.0) return ia_ok(vec2(0.0, 0.0));
+  if (x.x < 0.0 && x.y > 0.0) return ia_ok(vec2(-1.0, 1.0));
+  if (x.x == 0.0) return ia_ok(vec2(0.0, 1.0));
+  return ia_ok(vec2(-1.0, 0.0));
+}
+
+// Floor
+IntervalResult ia_floor(vec2 x) {
+  return ia_ok(vec2(floor(x.x), floor(x.y)));
+}
+
+// Ceiling
+IntervalResult ia_ceil(vec2 x) {
+  return ia_ok(vec2(ceil(x.x), ceil(x.y)));
+}
+
+// Min of two intervals
+IntervalResult ia_min(vec2 a, vec2 b) {
+  return ia_ok(vec2(min(a.x, b.x), min(a.y, b.y)));
+}
+
+// Max of two intervals
+IntervalResult ia_max(vec2 a, vec2 b) {
+  return ia_ok(vec2(max(a.x, b.x), max(a.y, b.y)));
+}
+
+// Power with constant exponent
+IntervalResult ia_pow(vec2 base, float exp) {
+  if (exp == 0.0) return ia_ok(vec2(1.0, 1.0));
+  if (exp == 1.0) return ia_ok(base);
+  if (exp == 2.0) return ia_square(base);
+  if (exp == 0.5) return ia_sqrt(base);
+
+  // General case - requires positive base for non-integer exponents
+  if (base.y < 0.0) {
+    return ia_empty();
+  }
+  if (base.x < 0.0) {
+    // Partial domain
+    if (exp > 0.0) {
+      return ia_partial(vec2(0.0, pow(base.y, exp) + IA_EPS), IA_PARTIAL_LO);
+    } else {
+      return ia_partial(vec2(pow(base.y, exp) - IA_EPS, IA_HUGE), IA_PARTIAL_LO);
+    }
+  }
+
+  // Entirely non-negative
+  if (exp > 0.0) {
+    return ia_ok(vec2(pow(base.x, exp) - IA_EPS, pow(base.y, exp) + IA_EPS));
+  } else {
+    if (base.x == 0.0) {
+      return ia_partial(vec2(pow(base.y, exp) - IA_EPS, IA_HUGE), IA_PARTIAL_HI);
+    }
+    return ia_ok(vec2(pow(base.y, exp) - IA_EPS, pow(base.x, exp) + IA_EPS));
+  }
+}
+
+// Check if interval contains extremum at (extremum + n * period)
+bool ia_contains_extremum(vec2 x, float extremum, float period) {
+  float n = ceil((x.x - extremum) / period);
+  float candidate = extremum + n * period;
+  return candidate >= x.x - 1e-7 && candidate <= x.y + 1e-7;
+}
+
+// Sine
+IntervalResult ia_sin(vec2 x) {
+  const float TWO_PI = 6.28318530718;
+  const float HALF_PI = 1.57079632679;
+  const float THREE_HALF_PI = 4.71238898038;
+
+  if (x.y - x.x >= TWO_PI) {
+    return ia_ok(vec2(-1.0, 1.0));
+  }
+
+  float sinLo = sin(x.x);
+  float sinHi = sin(x.y);
+  float lo = min(sinLo, sinHi);
+  float hi = max(sinLo, sinHi);
+
+  if (ia_contains_extremum(x, HALF_PI, TWO_PI)) hi = 1.0;
+  if (ia_contains_extremum(x, THREE_HALF_PI, TWO_PI)) lo = -1.0;
+
+  return ia_ok(vec2(lo - IA_EPS, hi + IA_EPS));
+}
+
+// Cosine
+IntervalResult ia_cos(vec2 x) {
+  const float TWO_PI = 6.28318530718;
+  const float PI = 3.14159265359;
+
+  if (x.y - x.x >= TWO_PI) {
+    return ia_ok(vec2(-1.0, 1.0));
+  }
+
+  float cosLo = cos(x.x);
+  float cosHi = cos(x.y);
+  float lo = min(cosLo, cosHi);
+  float hi = max(cosLo, cosHi);
+
+  if (ia_contains_extremum(x, 0.0, TWO_PI)) hi = 1.0;
+  if (ia_contains_extremum(x, PI, TWO_PI)) lo = -1.0;
+
+  return ia_ok(vec2(lo - IA_EPS, hi + IA_EPS));
+}
+
+// Tangent
+IntervalResult ia_tan(vec2 x) {
+  const float PI = 3.14159265359;
+  const float HALF_PI = 1.57079632679;
+
+  if (x.y - x.x >= PI) {
+    return ia_singular(0.0);
+  }
+
+  if (ia_contains_extremum(x, HALF_PI, PI)) {
+    float n = ceil((x.x - HALF_PI) / PI);
+    float poleAt = HALF_PI + n * PI;
+    return ia_singular(poleAt);
+  }
+
+  float tanLo = tan(x.x);
+  float tanHi = tan(x.y);
+
+  if ((tanLo > 1e10 && tanHi < -1e10) || (tanLo < -1e10 && tanHi > 1e10)) {
+    return ia_singular(0.0);
+  }
+
+  return ia_ok(vec2(tanLo - IA_EPS, tanHi + IA_EPS));
+}
+
+// Arc sine
+IntervalResult ia_asin(vec2 x) {
+  if (x.x > 1.0 || x.y < -1.0) {
+    return ia_empty();
+  }
+
+  vec2 clipped = vec2(max(x.x, -1.0), min(x.y, 1.0));
+
+  if (x.x < -1.0 || x.y > 1.0) {
+    float clip = (x.x < -1.0 && x.y > 1.0) ? IA_PARTIAL_BOTH :
+                 (x.x < -1.0) ? IA_PARTIAL_LO : IA_PARTIAL_HI;
+    return ia_partial(vec2(asin(clipped.x) - IA_EPS, asin(clipped.y) + IA_EPS), clip);
+  }
+
+  return ia_ok(vec2(asin(x.x) - IA_EPS, asin(x.y) + IA_EPS));
+}
+
+// Arc cosine
+IntervalResult ia_acos(vec2 x) {
+  if (x.x > 1.0 || x.y < -1.0) {
+    return ia_empty();
+  }
+
+  vec2 clipped = vec2(max(x.x, -1.0), min(x.y, 1.0));
+
+  if (x.x < -1.0 || x.y > 1.0) {
+    float clip = (x.x < -1.0 && x.y > 1.0) ? IA_PARTIAL_BOTH :
+                 (x.x < -1.0) ? IA_PARTIAL_LO : IA_PARTIAL_HI;
+    // acos is decreasing, so bounds swap
+    return ia_partial(vec2(acos(clipped.y) - IA_EPS, acos(clipped.x) + IA_EPS), clip);
+  }
+
+  // acos is decreasing
+  return ia_ok(vec2(acos(x.y) - IA_EPS, acos(x.x) + IA_EPS));
+}
+
+// Arc tangent
+IntervalResult ia_atan(vec2 x) {
+  return ia_ok(vec2(atan(x.x) - IA_EPS, atan(x.y) + IA_EPS));
+}
+
+// Hyperbolic sine
+IntervalResult ia_sinh(vec2 x) {
+  return ia_ok(vec2(sinh(x.x) - IA_EPS, sinh(x.y) + IA_EPS));
+}
+
+// Hyperbolic cosine
+IntervalResult ia_cosh(vec2 x) {
+  if (x.x >= 0.0) {
+    return ia_ok(vec2(cosh(x.x) - IA_EPS, cosh(x.y) + IA_EPS));
+  } else if (x.y <= 0.0) {
+    return ia_ok(vec2(cosh(x.y) - IA_EPS, cosh(x.x) + IA_EPS));
+  } else {
+    return ia_ok(vec2(1.0 - IA_EPS, max(cosh(x.x), cosh(x.y)) + IA_EPS));
+  }
+}
+
+// Hyperbolic tangent
+IntervalResult ia_tanh(vec2 x) {
+  return ia_ok(vec2(tanh(x.x) - IA_EPS, tanh(x.y) + IA_EPS));
+}
+`;
+var INTERVAL_GLSL_OPERATORS = {
+  Add: ["ia_add", 20],
+  Negate: ["ia_negate", 20],
+  Subtract: ["ia_sub", 20],
+  Multiply: ["ia_mul", 20],
+  Divide: ["ia_div", 20]
+};
+var INTERVAL_GLSL_FUNCTIONS = {
+  Add: (args, compile) => {
+    if (args.length === 0) return "ia_point(0.0)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `ia_add(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Subtract: (args, compile) => {
+    if (args.length === 0) return "ia_point(0.0)";
+    if (args.length === 1) return `ia_negate(${compile(args[0])})`;
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `ia_sub(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Multiply: (args, compile) => {
+    if (args.length === 0) return "ia_point(1.0)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `ia_mul(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Divide: (args, compile) => {
+    if (args.length === 0) return "ia_point(1.0)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `ia_div(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Negate: (args, compile) => `ia_negate(${compile(args[0])})`,
+  // Elementary functions
+  Abs: (args, compile) => `ia_abs(${compile(args[0])})`,
+  Ceiling: (args, compile) => `ia_ceil(${compile(args[0])})`,
+  Exp: (args, compile) => `ia_exp(${compile(args[0])})`,
+  Floor: (args, compile) => `ia_floor(${compile(args[0])})`,
+  Ln: (args, compile) => `ia_ln(${compile(args[0])})`,
+  Max: (args, compile) => {
+    if (args.length === 0) return "ia_point(-1e38)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `ia_max(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Min: (args, compile) => {
+    if (args.length === 0) return "ia_point(1e38)";
+    if (args.length === 1) return compile(args[0]);
+    let result = compile(args[0]);
+    for (let i = 1; i < args.length; i++) {
+      result = `ia_min(${result}, ${compile(args[i])})`;
+    }
+    return result;
+  },
+  Power: (args, compile) => {
+    const base = args[0];
+    const exp3 = args[1];
+    if (base === null) throw new Error("Power: no argument");
+    if (base.symbol === "ExponentialE") {
+      return `ia_exp(${compile(exp3)})`;
+    }
+    if (exp3?.isNumberLiteral && exp3.im === 0) {
+      const expVal = exp3.re;
+      if (expVal === 2) return `ia_square(${compile(base)})`;
+      return `ia_pow(${compile(base)}, ${expVal})`;
+    }
+    throw new Error("Interval GLSL does not support variable exponents");
+  },
+  Sgn: (args, compile) => `ia_sign(${compile(args[0])})`,
+  Sqrt: (args, compile) => `ia_sqrt(${compile(args[0])})`,
+  Square: (args, compile) => `ia_square(${compile(args[0])})`,
+  // Trigonometric functions
+  Sin: (args, compile) => `ia_sin(${compile(args[0])})`,
+  Cos: (args, compile) => `ia_cos(${compile(args[0])})`,
+  Tan: (args, compile) => `ia_tan(${compile(args[0])})`,
+  Arcsin: (args, compile) => `ia_asin(${compile(args[0])})`,
+  Arccos: (args, compile) => `ia_acos(${compile(args[0])})`,
+  Arctan: (args, compile) => `ia_atan(${compile(args[0])})`,
+  // Hyperbolic functions
+  Sinh: (args, compile) => `ia_sinh(${compile(args[0])})`,
+  Cosh: (args, compile) => `ia_cosh(${compile(args[0])})`,
+  Tanh: (args, compile) => `ia_tanh(${compile(args[0])})`
+};
+var IntervalGLSLTarget = class {
+  getOperators() {
+    return INTERVAL_GLSL_OPERATORS;
+  }
+  getFunctions() {
+    return INTERVAL_GLSL_FUNCTIONS;
+  }
+  /**
+   * Get the GLSL interval library code.
+   *
+   * This should be included in shaders that use interval arithmetic.
+   */
+  getLibrary() {
+    return GLSL_INTERVAL_LIBRARY;
+  }
+  createTarget(options = {}) {
+    return {
+      language: "interval-glsl",
+      // Don't use operators - all arithmetic goes through functions
+      // because interval arithmetic returns IntervalResult, not numbers
+      operators: () => void 0,
+      functions: (id) => INTERVAL_GLSL_FUNCTIONS[id],
+      var: (id) => {
+        const constants = {
+          Pi: "ia_point(3.14159265359)",
+          ExponentialE: "ia_point(2.71828182846)",
+          GoldenRatio: "ia_point(1.61803398875)",
+          CatalanConstant: "ia_point(0.91596559417)",
+          EulerGamma: "ia_point(0.57721566490)"
+        };
+        if (id in constants) return constants[id];
+        return id;
+      },
+      string: (str) => JSON.stringify(str),
+      number: (n) => {
+        const str = n.toString();
+        const numStr = !str.includes(".") && !str.includes("e") && !str.includes("E") ? `${str}.0` : str;
+        return `ia_point(${numStr})`;
+      },
+      indent: 0,
+      ws: (s) => s ?? "",
+      preamble: "",
+      ...options
+    };
+  }
+  compileToExecutable(expr, options = {}) {
+    const { functions, vars } = options;
+    const target = this.createTarget({
+      functions: (id) => {
+        if (functions && id in functions) {
+          const fn = functions[id];
+          if (typeof fn === "string") return fn;
+          if (typeof fn === "function") return fn.name || id;
+        }
+        return INTERVAL_GLSL_FUNCTIONS[id];
+      },
+      var: (id) => {
+        if (vars && id in vars) return vars[id];
+        const constants = {
+          Pi: "ia_point(3.14159265359)",
+          ExponentialE: "ia_point(2.71828182846)",
+          GoldenRatio: "ia_point(1.61803398875)",
+          CatalanConstant: "ia_point(0.91596559417)",
+          EulerGamma: "ia_point(0.57721566490)"
+        };
+        if (id in constants) return constants[id];
+        return id;
+      }
+    });
+    const glslCode = BaseCompiler.compile(expr, target);
+    const result = function() {
+      return glslCode;
+    };
+    Object.defineProperty(result, "toString", {
+      value: () => glslCode
+    });
+    Object.defineProperty(result, "isCompiled", {
+      value: true
+    });
+    return result;
+  }
+  /**
+   * Compile an expression to GLSL interval code.
+   */
+  compile(expr, options = {}) {
+    const target = this.createTarget();
+    return BaseCompiler.compile(expr, target);
+  }
+  /**
+   * Create a complete GLSL interval function from an expression.
+   *
+   * @param expr - The expression to compile
+   * @param functionName - Name of the GLSL function
+   * @param parameters - Parameter names (each becomes a vec2 interval input)
+   */
+  compileFunction(expr, functionName, parameters) {
+    const target = this.createTarget();
+    const body = BaseCompiler.compile(expr, target);
+    const params = parameters.map((name) => `vec2 ${name}`).join(", ");
+    return `IntervalResult ${functionName}(${params}) {
+  return ${body};
+}`;
+  }
+  /**
+   * Create a complete GLSL fragment shader for interval function plotting.
+   *
+   * @param expr - The expression to compile
+   * @param options - Shader options
+   */
+  compileShaderFunction(expr, options = {}) {
+    const {
+      functionName = "evaluateInterval",
+      version: version2 = "300 es",
+      parameters = ["x"]
+    } = options;
+    const target = this.createTarget();
+    const body = BaseCompiler.compile(expr, target);
+    const params = parameters.map((name) => `vec2 ${name}`).join(", ");
+    return `#version ${version2}
+precision highp float;
+
+${GLSL_INTERVAL_LIBRARY}
+
+IntervalResult ${functionName}(${params}) {
+  return ${body};
+}
+`;
+  }
+};
+
 // src/compute-engine/index.ts
 init_base_compiler();
 var ComputeEngine = class _ComputeEngine {
@@ -52309,6 +53946,11 @@ var ComputeEngine = class _ComputeEngine {
     this.pushScope(void 0, "global");
     this._compilationTargets.set("javascript", new JavaScriptTarget());
     this._compilationTargets.set("glsl", new GLSLTarget());
+    this._compilationTargets.set(
+      "interval-js",
+      new IntervalJavaScriptTarget()
+    );
+    this._compilationTargets.set("interval-glsl", new IntervalGLSLTarget());
     hidePrivateProperties(this);
   }
   toJSON() {
@@ -53766,10 +55408,10 @@ function defToString(name, def, v) {
 // src/compute-engine.ts
 init_types6();
 init_base_compiler();
-var version = "0.34.0";
+var version = "0.35.0";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.34.0"
+  version: "0.35.0"
 };
 export {
   BaseCompiler,