@cortex-js/compute-engine 0.34.0 → 0.35.0

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.34.0 */
+/** Compute Engine 0.35.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -20,7 +20,7 @@ var ComputeEngine = (() => {
     }
     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) {
@@ -174,8 +174,8 @@ var ComputeEngine = (() => {
          * @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
@@ -894,8 +894,8 @@ var ComputeEngine = (() => {
     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);
     }
   }
@@ -1149,7 +1149,7 @@ var ComputeEngine = (() => {
     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);
     }
@@ -1166,19 +1166,19 @@ var ComputeEngine = (() => {
     }
     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 {
@@ -1570,8 +1570,8 @@ var ComputeEngine = (() => {
   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");
@@ -2015,14 +2015,14 @@ var ComputeEngine = (() => {
       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;
@@ -2920,13 +2920,13 @@ var ComputeEngine = (() => {
           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
               )
             );
           }
@@ -2940,7 +2940,7 @@ var ComputeEngine = (() => {
           }
           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--;
@@ -5448,8 +5448,8 @@ var ComputeEngine = (() => {
     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);
     }
@@ -6942,8 +6942,8 @@ var ComputeEngine = (() => {
       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;
@@ -8325,11 +8325,11 @@ var ComputeEngine = (() => {
       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];
@@ -9645,12 +9645,12 @@ var ComputeEngine = (() => {
     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 "";
@@ -9694,9 +9694,9 @@ var ComputeEngine = (() => {
       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);
@@ -9712,25 +9712,25 @@ var ComputeEngine = (() => {
     } 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(/^(.*)\.(.*)$/);
@@ -9740,20 +9740,20 @@ var ComputeEngine = (() => {
           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]+)$/);
@@ -9795,11 +9795,11 @@ var ComputeEngine = (() => {
   }
   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;
@@ -9809,23 +9809,23 @@ var ComputeEngine = (() => {
       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);
@@ -9878,10 +9878,10 @@ var ComputeEngine = (() => {
   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) {
@@ -9993,8 +9993,8 @@ var ComputeEngine = (() => {
           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;
@@ -11542,13 +11542,13 @@ var ComputeEngine = (() => {
             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
@@ -11914,34 +11914,34 @@ var ComputeEngine = (() => {
     }
     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))];
@@ -11968,8 +11968,8 @@ var ComputeEngine = (() => {
     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;
   }
@@ -12014,22 +12014,22 @@ var ComputeEngine = (() => {
 
   // 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);
@@ -12235,11 +12235,11 @@ var ComputeEngine = (() => {
     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));
@@ -12303,7 +12303,7 @@ var ComputeEngine = (() => {
       }
       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);
@@ -12313,25 +12313,25 @@ var ComputeEngine = (() => {
     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();
   }
@@ -12339,10 +12339,10 @@ var ComputeEngine = (() => {
     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 });
   }
@@ -12670,25 +12670,25 @@ var ComputeEngine = (() => {
             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())
@@ -14103,12 +14103,12 @@ var ComputeEngine = (() => {
           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);
@@ -14125,8 +14125,8 @@ var ComputeEngine = (() => {
           }
           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++) {
@@ -14149,8 +14149,8 @@ var ComputeEngine = (() => {
             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_
                 );
               }
@@ -14167,13 +14167,13 @@ var ComputeEngine = (() => {
             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,
@@ -14182,9 +14182,9 @@ var ComputeEngine = (() => {
             });
           }
           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);
@@ -14212,9 +14212,9 @@ var ComputeEngine = (() => {
             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_)
                 );
               }
             }
@@ -14224,14 +14224,14 @@ var ComputeEngine = (() => {
             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(
@@ -14597,11 +14597,11 @@ var ComputeEngine = (() => {
         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();
@@ -14936,9 +14936,9 @@ var ComputeEngine = (() => {
         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;
@@ -14979,9 +14979,9 @@ var ComputeEngine = (() => {
       }
       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)) {
@@ -14999,9 +14999,9 @@ var ComputeEngine = (() => {
           } 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;
             }
@@ -15360,13 +15360,13 @@ var ComputeEngine = (() => {
   }
   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();
@@ -15380,86 +15380,86 @@ var ComputeEngine = (() => {
       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;
@@ -15469,37 +15469,37 @@ var ComputeEngine = (() => {
           (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 });
@@ -15845,7 +15845,7 @@ var ComputeEngine = (() => {
          * 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) {
@@ -15853,17 +15853,17 @@ var ComputeEngine = (() => {
             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;
@@ -15872,14 +15872,14 @@ var ComputeEngine = (() => {
                   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;
@@ -15889,21 +15889,21 @@ var ComputeEngine = (() => {
                   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;
             }
@@ -15913,7 +15913,7 @@ var ComputeEngine = (() => {
                 this.engine._numericValue({
                   radical: radical[0] * radical[1],
                   rational: [1, Number(radical[1])]
-                }).pow(this.engine._numericValue(exp2))
+                }).pow(this.engine._numericValue(exp3))
               );
               return;
             }
@@ -15922,20 +15922,20 @@ var ComputeEngine = (() => {
               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) {
@@ -16135,8 +16135,8 @@ var ComputeEngine = (() => {
   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(
@@ -16177,8 +16177,8 @@ var ComputeEngine = (() => {
       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",
@@ -16186,11 +16186,11 @@ var ComputeEngine = (() => {
             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
           );
@@ -20529,10 +20529,10 @@ var ComputeEngine = (() => {
         div(rhs) {
           return this.engine.NaN;
         }
-        pow(exp2) {
+        pow(exp3) {
           return this.engine.NaN;
         }
-        root(exp2) {
+        root(exp3) {
           return this.engine.NaN;
         }
         sqrt() {
@@ -21073,7 +21073,7 @@ var ComputeEngine = (() => {
           `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);
   }
@@ -21219,19 +21219,19 @@ ${e.message}
     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))
@@ -21248,7 +21248,7 @@ ${e.message}
     }
     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))
@@ -21293,10 +21293,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);
     }
@@ -21393,8 +21393,8 @@ ${e.message}`);
   });
 
   // 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;
@@ -21788,7 +21788,7 @@ ${e.message}`);
             ["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"],
@@ -21797,7 +21797,7 @@ ${e.message}`);
             ["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
@@ -21879,7 +21879,7 @@ ${e.message}`);
           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
         {
@@ -21890,42 +21890,42 @@ ${e.message}`);
           ],
           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
         {
@@ -22055,10 +22055,10 @@ ${e.message}`);
           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;
@@ -22090,10 +22090,10 @@ ${e.message}`);
           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;
@@ -22111,10 +22111,10 @@ ${e.message}`);
             ["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;
@@ -22128,9 +22128,9 @@ ${e.message}`);
           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;
@@ -22142,9 +22142,9 @@ ${e.message}`);
           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;
@@ -22157,10 +22157,10 @@ ${e.message}`);
           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;
@@ -22174,10 +22174,10 @@ ${e.message}`);
           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;
@@ -22191,9 +22191,9 @@ ${e.message}`);
           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;
@@ -22205,9 +22205,9 @@ ${e.message}`);
           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;
@@ -22220,9 +22220,9 @@ ${e.message}`);
           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)
@@ -22237,9 +22237,9 @@ ${e.message}`);
           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)
@@ -24167,11 +24167,11 @@ ${lines.join("\n")}`;
     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;
@@ -25007,19 +25007,19 @@ ${lines.join("\n")}`;
             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;
@@ -25092,13 +25092,13 @@ ${lines.join("\n")}`;
             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";
               }
@@ -25122,8 +25122,8 @@ ${lines.join("\n")}`;
             },
             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 })
           },
@@ -25994,9 +25994,9 @@ ${lines.join("\n")}`;
       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 {
@@ -26038,7 +26038,7 @@ ${lines.join("\n")}`;
       serializer.level += 1;
       return result;
     }
-    let isNegative = false;
+    let isNegative2 = false;
     let arg = null;
     const count = nops(expr) + 1;
     let xs = operands(expr);
@@ -26058,11 +26058,11 @@ ${lines.join("\n")}`;
         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);
@@ -26095,7 +26095,7 @@ ${lines.join("\n")}`;
       }
       if (operator(arg) === "Negate") {
         arg = operand(arg, 1);
-        isNegative = !isNegative;
+        isNegative2 = !isNegative2;
       }
       term = serializer.wrap(arg, MULTIPLICATION_PRECEDENCE);
       if (!result) {
@@ -26117,7 +26117,7 @@ ${lines.join("\n")}`;
       prevWasNumber = false;
     }
     serializer.level += 1;
-    return isNegative ? "-" + result : result;
+    return isNegative2 ? "-" + result : result;
   }
   function parseFraction(parser) {
     let numer = parser.parseGroup();
@@ -26221,26 +26221,26 @@ ${lines.join("\n")}`;
         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) {
@@ -26249,18 +26249,18 @@ ${lines.join("\n")}`;
           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));
         }
       }
     }
@@ -26271,12 +26271,12 @@ ${lines.join("\n")}`;
       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 = [
@@ -27093,10 +27093,10 @@ ${lines.join("\n")}`;
     }
     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;
@@ -27130,20 +27130,20 @@ ${lines.join("\n")}`;
       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];
@@ -27237,47 +27237,47 @@ ${lines.join("\n")}`;
     };
   }
   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
@@ -28101,26 +28101,26 @@ ${lines.join("\n")}`;
       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";
@@ -29351,17 +29351,17 @@ ${lines.join("\n")}`;
         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);
@@ -29428,9 +29428,9 @@ ${lines.join("\n")}`;
     }
     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];
   }
@@ -30465,9 +30465,9 @@ ${lines.join("\n")}`;
     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);
@@ -30532,14 +30532,14 @@ ${lines.join("\n")}`;
             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)) {
@@ -31371,10 +31371,10 @@ ${lines.join("\n")}`;
      *
      */
     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.
@@ -31406,9 +31406,9 @@ ${lines.join("\n")}`;
      */
     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 "";
     }
@@ -31511,9 +31511,9 @@ ${lines.join("\n")}`;
         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();
       }
@@ -31550,34 +31550,66 @@ ${lines.join("\n")}`;
       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) {
@@ -31903,12 +31935,12 @@ ${lines.join("\n")}`;
           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;
@@ -33019,8 +33051,8 @@ ${lines.join("\n")}`;
     }
     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;
@@ -33034,7 +33066,7 @@ ${lines.join("\n")}`;
         ["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}
     {
@@ -33044,7 +33076,7 @@ ${lines.join("\n")}`;
         ["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}
     {
@@ -33054,13 +33086,13 @@ ${lines.join("\n")}`;
         ["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
     {
@@ -33076,7 +33108,7 @@ ${lines.join("\n")}`;
     {
       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
     {
@@ -33092,7 +33124,7 @@ ${lines.join("\n")}`;
     {
       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
     {
@@ -33691,7 +33723,7 @@ ${lines.join("\n")}`;
         ["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))
     {
@@ -33702,7 +33734,7 @@ ${lines.join("\n")}`;
         ["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)
     {
@@ -33713,7 +33745,7 @@ ${lines.join("\n")}`;
         ["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)
     {
@@ -33724,7 +33756,7 @@ ${lines.join("\n")}`;
         ["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)
     {
@@ -34115,8 +34147,8 @@ ${lines.join("\n")}`;
         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) {
@@ -34156,8 +34188,8 @@ ${lines.join("\n")}`;
         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)) {
@@ -35280,10 +35312,10 @@ ${lines.join("\n")}`;
           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(
@@ -36790,8 +36822,8 @@ ${lines.join("\n")}`;
             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()
@@ -36832,8 +36864,8 @@ ${lines.join("\n")}`;
             }
           }
           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()
@@ -36845,9 +36877,9 @@ ${lines.join("\n")}`;
           }
           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;
@@ -36909,11 +36941,11 @@ ${lines.join("\n")}`;
             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);
         }
       }
@@ -38025,8 +38057,8 @@ ${lines.join("\n")}`;
       }
       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++) {
@@ -39141,8 +39173,8 @@ ${lines.join("\n")}`;
               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;
@@ -39157,9 +39189,9 @@ ${lines.join("\n")}`;
           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"
           );
         }
       },
@@ -39169,8 +39201,8 @@ ${lines.join("\n")}`;
         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: {
@@ -39180,8 +39212,8 @@ ${lines.join("\n")}`;
           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: {
@@ -39192,8 +39224,8 @@ ${lines.join("\n")}`;
           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: {
@@ -39275,39 +39307,39 @@ ${lines.join("\n")}`;
         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;
@@ -39330,9 +39362,9 @@ ${lines.join("\n")}`;
           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);
@@ -39649,10 +39681,10 @@ ${lines.join("\n")}`;
         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;
@@ -40889,9 +40921,9 @@ ${lines.join("\n")}`;
       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]);
       }
     }
   }
@@ -41141,12 +41173,12 @@ ${lines.join("\n")}`;
     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;
       }
     }
@@ -41157,12 +41189,12 @@ ${lines.join("\n")}`;
     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);
       }
     }
@@ -41350,18 +41382,18 @@ ${lines.join("\n")}`;
           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);
@@ -41390,18 +41422,18 @@ ${lines.join("\n")}`;
           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);
@@ -42051,13 +42083,13 @@ ${lines.join("\n")}`;
     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;
@@ -42473,8 +42505,8 @@ Error in definition of "${name}"`,
         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;
         }
@@ -42483,8 +42515,8 @@ Error in definition of "${name}"`,
     } 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;
       }
@@ -42492,7 +42524,7 @@ Error in definition of "${name}"`,
         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);
@@ -43404,10 +43436,10 @@ Error in definition of "${name}"`,
     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));
@@ -43419,10 +43451,10 @@ Error in definition of "${name}"`,
     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));
@@ -43434,10 +43466,10 @@ Error in definition of "${name}"`,
     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);
@@ -44205,9 +44237,9 @@ Error in definition of "${name}"`,
     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") {
@@ -45230,9 +45262,9 @@ Error in definition of "${name}"`,
       (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;
@@ -45241,7 +45273,7 @@ Error in definition of "${name}"`,
       }
       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);
@@ -45255,8 +45287,8 @@ Error in definition of "${name}"`,
       }
       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;
@@ -45267,16 +45299,16 @@ Error in definition of "${name}"`,
         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);
@@ -45298,7 +45330,7 @@ Error in definition of "${name}"`,
           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)
@@ -45318,7 +45350,7 @@ Error in definition of "${name}"`,
       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;
@@ -45328,7 +45360,7 @@ Error in definition of "${name}"`,
           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)
@@ -45799,11 +45831,11 @@ Error in definition of "${name}"`,
         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();
@@ -45820,11 +45852,11 @@ Error in definition of "${name}"`,
      * 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);
@@ -45985,13 +46017,13 @@ Error in definition of "${name}"`,
       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();
@@ -46002,24 +46034,24 @@ Error in definition of "${name}"`,
       }
       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) {
@@ -46041,7 +46073,7 @@ Error in definition of "${name}"`,
           }
         }
       }
-      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);
@@ -46060,12 +46092,12 @@ Error in definition of "${name}"`,
         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;
@@ -47403,31 +47435,31 @@ Error in definition of "${name}"`,
     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);
@@ -47437,7 +47469,7 @@ Error in definition of "${name}"`,
           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") {
@@ -47518,9 +47550,9 @@ Error in definition of "${name}"`,
         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;
@@ -47684,9 +47716,9 @@ Error in definition of "${name}"`,
       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);
@@ -47830,8 +47862,8 @@ Error in definition of "${name}"`,
     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;
@@ -48157,10 +48189,10 @@ Error in definition of "${name}"`,
     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;
@@ -48874,38 +48906,38 @@ Error in definition of "${name}"`,
     }
     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"
               };
             }
@@ -48927,22 +48959,22 @@ Error in definition of "${name}"`,
   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"
         };
       }
@@ -49097,27 +49129,27 @@ Error in definition of "${name}"`,
     }
     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) {
@@ -49143,28 +49175,28 @@ Error in definition of "${name}"`,
           }
         }
         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)) {
@@ -49206,17 +49238,17 @@ Error in definition of "${name}"`,
       }
       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"
             };
           }
@@ -49229,11 +49261,11 @@ Error in definition of "${name}"`,
         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)"
             };
           }
@@ -49316,17 +49348,17 @@ Error in definition of "${name}"`,
       }
       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"
@@ -49338,11 +49370,11 @@ Error in definition of "${name}"`,
         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)"
             };
           }
@@ -49382,32 +49414,32 @@ Error in definition of "${name}"`,
     }
     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])),
@@ -49415,10 +49447,10 @@ Error in definition of "${name}"`,
             };
           }
         }
-        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);
@@ -49429,11 +49461,11 @@ Error in definition of "${name}"`,
           };
         }
       }
-      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),
@@ -49442,20 +49474,20 @@ Error in definition of "${name}"`,
           }
         }
       }
-      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)),
@@ -49464,11 +49496,11 @@ Error in definition of "${name}"`,
           }
         }
       }
-      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),
@@ -49477,9 +49509,9 @@ Error in definition of "${name}"`,
           }
         }
       }
-      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)"
         };
       }
@@ -49619,8 +49651,8 @@ Error in definition of "${name}"`,
       }
       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]),
@@ -49631,8 +49663,8 @@ Error in definition of "${name}"`,
             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 {
@@ -49652,7 +49684,7 @@ Error in definition of "${name}"`,
               }
             }
           }
-          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"
@@ -49705,22 +49737,22 @@ Error in definition of "${name}"`,
       }
       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])),
@@ -49736,13 +49768,13 @@ Error in definition of "${name}"`,
         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));
               }
@@ -49772,13 +49804,13 @@ Error in definition of "${name}"`,
     }
     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);
@@ -49792,7 +49824,7 @@ Error in definition of "${name}"`,
         }
       }
       if (base.operator === "Multiply" && base.ops) {
-        const rat = asRational(exp2);
+        const rat = asRational(exp3);
         if (rat) {
           const [num, denom] = rat;
           const numN = Number(num);
@@ -49816,15 +49848,15 @@ Error in definition of "${name}"`,
               );
               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"
@@ -49832,19 +49864,19 @@ Error in definition of "${name}"`,
       }
       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);
@@ -49854,13 +49886,13 @@ Error in definition of "${name}"`,
           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"
             };
           }
@@ -49868,15 +49900,15 @@ Error in definition of "${name}"`,
       }
       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"
           };
         }
@@ -49884,7 +49916,7 @@ Error in definition of "${name}"`,
       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),
@@ -49896,13 +49928,13 @@ Error in definition of "${name}"`,
         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}"
             };
           }
@@ -49911,18 +49943,18 @@ Error in definition of "${name}"`,
       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"
           };
         }
@@ -49958,10 +49990,10 @@ Error in definition of "${name}"`,
       }
       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"
           };
         }
@@ -49984,9 +50016,9 @@ Error in definition of "${name}"`,
       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"
         };
       }
@@ -50161,12 +50193,12 @@ Error in definition of "${name}"`,
         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)`
             };
           }
         }
@@ -50177,12 +50209,12 @@ Error in definition of "${name}"`,
           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)`
               };
             }
           }
@@ -51127,13 +51159,13 @@ Error in definition of "${name}"`,
       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;
@@ -51144,7 +51176,7 @@ Error in definition of "${name}"`,
           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()) {
@@ -51487,12 +51519,12 @@ Error in definition of "${name}"`,
     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) => {
@@ -51526,13 +51558,13 @@ Error in definition of "${name}"`,
       }
       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",
@@ -52018,6 +52050,1611 @@ Error in definition of "${name}"`,
     }
   };
 
+  // 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 {
@@ -52323,6 +53960,11 @@ Error in definition of "${name}"`,
       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() {
@@ -53780,10 +55422,10 @@ Error in definition of "${name}"`,
   // 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"
   };
   return __toCommonJS(compute_engine_exports);
 })();