@cortex-js/compute-engine 0.58.0 → 0.59.0

package/dist/interval.umd.cjs

@@ -1,4 +1,4 @@
-/** Interval 0.58.0 */
+/** Interval 0.59.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.Interval = {}));})(this, (function (exports) { 'use strict';
 var Interval = (() => {
   var __defProp = Object.defineProperty;
@@ -236,9 +236,18 @@ var Interval = (() => {
     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];
+    const products = [
+      _prod(a.lo, b.lo),
+      _prod(a.lo, b.hi),
+      _prod(a.hi, b.lo),
+      _prod(a.hi, b.hi)
+    ];
     return { lo: Math.min(...products), hi: Math.max(...products) };
   }
+  function _prod(x, y) {
+    if (x === 0 || y === 0) return 0;
+    return x * y;
+  }
   function mul(a, b) {
     const unwrapped = unwrapOrPropagate(a, b);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -403,6 +412,7 @@ var Interval = (() => {
     return sum;
   }
   function fpln(x, scale) {
+    if (x <= 0n) throw new RangeError("fpln: input must be positive");
     if (x === scale) return 0n;
     const xNum = Number(x);
     const scaleNum = Number(scale);
@@ -1052,9 +1062,11 @@ var Interval = (() => {
       if (Number.isFinite(thisExp) && Number.isFinite(otherExp)) {
         if (other.significand === 0n) return _BigDecimal.NAN;
         if (this.significand === 0n) return fromRaw(0n, 0);
-        return this.sub(this.div(other).trunc().mul(other)).toPrecision(
-          _BigDecimal.precision
-        );
+        const ediff = thisExp - otherExp;
+        const num = ediff >= 0 ? this.significand * pow10(ediff) : this.significand;
+        const den = ediff >= 0 ? other.significand : other.significand * pow10(-ediff);
+        const q = num / den;
+        return this.sub(fromRaw(q, 0).mul(other));
       }
       if (thisExp !== thisExp || otherExp !== otherExp) return _BigDecimal.NAN;
       if (!Number.isFinite(thisExp)) return _BigDecimal.NAN;
@@ -1099,7 +1111,10 @@ var Interval = (() => {
           return this.pow(n.neg()).inv();
         }
         const absSig = this.significand < 0n ? -this.significand : this.significand;
-        const thisLog10 = bigintDigits(absSig) + this.exponent;
+        const sigDigits = bigintDigits(absSig);
+        const dropped = sigDigits > 15 ? sigDigits - 15 : 0;
+        const lead = dropped > 0 ? Number(absSig / 10n ** BigInt(dropped)) : Number(absSig);
+        const thisLog10 = Math.log10(lead) + dropped + this.exponent;
         const resultLog10 = Number(expValue) * thisLog10;
         if (resultLog10 > 9e15) {
           return this.significand < 0n && expValue % 2n !== 0n ? _BigDecimal.NEGATIVE_INFINITY : _BigDecimal.POSITIVE_INFINITY;
@@ -1132,7 +1147,19 @@ var Interval = (() => {
         return _BigDecimal.POSITIVE_INFINITY;
       }
       if (this.significand < 0n) return _BigDecimal.NAN;
-      return n.mul(this.ln()).exp();
+      const baseSig = this.significand;
+      const decExpBase = this.exponent + bigintDigits(baseSig) - 1;
+      const nSig = n.significand < 0n ? -n.significand : n.significand;
+      const decExpN = n.exponent + bigintDigits(nSig) - 1;
+      const argMag = decExpN + Math.log10(Math.abs(decExpBase) * 2.303 + 3) + 1;
+      const extra = Math.min(20, Math.max(2, Math.ceil(argMag) + 2));
+      const savedPrec = _BigDecimal.precision;
+      _BigDecimal.precision = savedPrec + extra;
+      try {
+        return n.mul(this.ln()).exp().toPrecision(savedPrec);
+      } finally {
+        _BigDecimal.precision = savedPrec;
+      }
     }
     // ---------- Conversion methods ----------
     /** Convert to a JavaScript number. May lose precision for large values. */
@@ -1373,6 +1400,20 @@ var Interval = (() => {
     const sig = negative ? -absFp : absFp;
     return fromRaw(sig, resultExp);
   }
+  function decimalExponent(x) {
+    const sig = x.significand < 0n ? -x.significand : x.significand;
+    return x.exponent + bigintDigits(sig) - 1;
+  }
+  var MAX_SAFE_EXPONENT = BigInt(Number.MAX_SAFE_INTEGER);
+  var _ln10Fp = null;
+  var _ln10Scale = null;
+  function ln10Fixed(scale) {
+    if (_ln10Scale !== scale) {
+      _ln10Fp = fpln(10n * scale, scale);
+      _ln10Scale = scale;
+    }
+    return _ln10Fp;
+  }
   BigDecimal.prototype.sqrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
@@ -1383,9 +1424,13 @@ var Interval = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 2);
+    const m = fromRaw(this.significand, this.exponent - 2 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const sqrtFp = fpsqrt(fp, scale);
-    return fromFixedPoint(sqrtFp, scale, targetPrec);
+    const root = fromFixedPoint(sqrtFp, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.prototype.cbrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -1399,10 +1444,13 @@ var Interval = (() => {
     }
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 3);
+    const m = fromRaw(this.significand, this.exponent - 3 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const C = fp * scale * scale;
     let x;
-    const numVal = this.toNumber();
+    const numVal = m.toNumber();
     const scaleNum = Number(scale);
     if (Number.isFinite(numVal) && numVal > 0 && Number.isFinite(scaleNum)) {
       const approx = Math.cbrt(numVal);
@@ -1431,7 +1479,8 @@ var Interval = (() => {
       const diffNext = bigintAbs(next * next * next - C);
       if (diffNext < diffX) x = next;
     }
-    return fromFixedPoint(x, scale, targetPrec);
+    const root = fromFixedPoint(x, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.sqrt = function(x) {
     return x.sqrt();
@@ -1446,11 +1495,27 @@ var Interval = (() => {
       return BigDecimal.ZERO;
     }
     if (this.isZero()) return BigDecimal.ONE;
+    if (decimalExponent(this) >= 17)
+      return this.significand > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const expFp = fpexp(fp, scale);
-    return fromFixedPoint(expFp, scale, targetPrec);
+    const absSig = this.significand < 0n ? -this.significand : this.significand;
+    const magnitude = Math.max(0, this.exponent + bigintDigits(absSig));
+    const workingPrec = targetPrec + 20 + magnitude;
+    const [xFp, scale] = toFixedPoint(this, workingPrec);
+    const l10 = ln10Fixed(scale);
+    let k = xFp / l10;
+    let rFp = xFp - k * l10;
+    if (rFp < 0n) {
+      k -= 1n;
+      rFp += l10;
+    }
+    if (k > MAX_SAFE_EXPONENT || k < -MAX_SAFE_EXPONENT)
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    const expR = fromFixedPoint(fpexp(rFp, scale), scale, targetPrec);
+    const newExp = expR.exponent + Number(k);
+    if (!Number.isSafeInteger(newExp))
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    return fromRaw(expR.significand, newExp);
   };
   BigDecimal.prototype.ln = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -1462,10 +1527,16 @@ var Interval = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     if (this.eq(1)) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const lnFp = fpln(fp, scale);
-    return fromFixedPoint(lnFp, scale, targetPrec);
+    const sig = this.significand;
+    const digits = bigintDigits(sig);
+    const e = this.exponent + digits - 1;
+    const m = fromRaw(sig, -(digits - 1));
+    const eDigits = Math.abs(e).toString().length;
+    const workingPrec = targetPrec + 20 + eDigits;
+    const [mFp, scale] = toFixedPoint(m, workingPrec);
+    const l10 = ln10Fixed(scale);
+    const resultFp = fpln(mFp, scale) + BigInt(e) * l10;
+    return fromFixedPoint(resultFp, scale, targetPrec);
   };
   BigDecimal.prototype.log = function(base) {
     const b = base instanceof BigDecimal ? base : new BigDecimal(base);
@@ -1485,7 +1556,10 @@ var Interval = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp] = fpsincos(fp, scale);
     return fromFixedPoint(sinFp, scale, targetPrec);
@@ -1496,6 +1570,8 @@ var Interval = (() => {
     if (this.isZero()) return BigDecimal.ONE;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [, cosFp] = fpsincos(fp, scale);
     return fromFixedPoint(cosFp, scale, targetPrec);
@@ -1505,7 +1581,10 @@ var Interval = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp, cosFp] = fpsincos(fp, scale);
     if (cosFp === 0n) {
@@ -1523,7 +1602,9 @@ var Interval = (() => {
       return piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const atanFp = fpatan(fp, scale);
     return fromFixedPoint(atanFp, scale, targetPrec);
@@ -1540,7 +1621,9 @@ var Interval = (() => {
       return this.significand > 0n ? piHalf : piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 20;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 20 + (e < 0 ? -e : 0);
     const [xFp, scale] = toFixedPoint(this, workingPrec);
     const x2 = fpmul(xFp, xFp, scale);
     const oneMinusX2 = scale - x2;
@@ -1603,6 +1686,23 @@ var Interval = (() => {
       if (this.significand > 0n) return BigDecimal.POSITIVE_INFINITY;
       return BigDecimal.NEGATIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const expX2 = this.exp();
+        return expX2.sub(expX2.inv()).div(BigDecimal.TWO).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3)) {
+      const h = this.abs().exp().div(BigDecimal.TWO);
+      return this.significand > 0n ? h : h.neg();
+    }
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.sub(expNegX).div(BigDecimal.TWO);
@@ -1613,6 +1713,9 @@ var Interval = (() => {
     if (!this.isFinite()) {
       return BigDecimal.POSITIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.abs().exp().div(BigDecimal.TWO);
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.add(expNegX).div(BigDecimal.TWO);
@@ -1624,6 +1727,21 @@ var Interval = (() => {
       if (this.significand > 0n) return BigDecimal.ONE;
       return BigDecimal.NEGATIVE_ONE;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const exp2x2 = this.mul(BigDecimal.TWO).exp();
+        return exp2x2.sub(BigDecimal.ONE).div(exp2x2.add(BigDecimal.ONE)).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.significand > 0n ? BigDecimal.ONE : BigDecimal.NEGATIVE_ONE;
     const exp2x = this.mul(BigDecimal.TWO).exp();
     return exp2x.sub(BigDecimal.ONE).div(exp2x.add(BigDecimal.ONE));
   };
@@ -1669,9 +1787,14 @@ var Interval = (() => {
   ];
   function gammaln(z) {
     if (z < 0) return NaN;
+    let shift = 0;
+    while (z < 10) {
+      shift += Math.log(z);
+      z += 1;
+    }
     const pi = Math.PI;
     const z3 = z * z * z;
-    return z * Math.log(z) - z - 0.5 * Math.log(z) + 0.5 * Math.log(2 * pi) + 1 / (12 * z) - 1 / (360 * z3) + 1 / (1260 * z3 * z * z);
+    return z * Math.log(z) - z - 0.5 * Math.log(z) + 0.5 * Math.log(2 * pi) + 1 / (12 * z) - 1 / (360 * z3) + 1 / (1260 * z3 * z * z) - shift;
   }
   function gamma(z) {
     if (z < 0.5) return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
@@ -1683,20 +1806,43 @@ var Interval = (() => {
     return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
   }
   function erfc(x) {
-    return 1 - erf(x);
+    if (Number.isNaN(x)) return NaN;
+    if (!Number.isFinite(x)) return x > 0 ? 0 : 2;
+    if (x < 0) return 2 - erfc(-x);
+    if (x < 2) return 1 - erf(x);
+    const tiny = 1e-300;
+    let f = x === 0 ? tiny : x;
+    let c = f;
+    let d = 0;
+    for (let k = 1; k <= 500; k++) {
+      const a = k / 2;
+      d = x + a * d;
+      if (d === 0) d = tiny;
+      d = 1 / d;
+      c = x + a / c;
+      if (c === 0) c = tiny;
+      const delta = c * d;
+      f *= delta;
+      if (Math.abs(delta - 1) < 1e-17) break;
+    }
+    return Math.exp(-x * x) / (Math.sqrt(Math.PI) * f);
   }
   function erf(x) {
-    const a1 = 0.254829592;
-    const a2 = -0.284496736;
-    const a3 = 1.421413741;
-    const a4 = -1.453152027;
-    const a5 = 1.061405429;
-    const p = 0.3275911;
+    if (Number.isNaN(x)) return NaN;
+    if (x === 0) return 0;
+    if (!Number.isFinite(x)) return x > 0 ? 1 : -1;
     const sign2 = 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));
+    const ax = Math.abs(x);
+    if (ax >= 6) return sign2;
+    const x2 = ax * ax;
+    let term = ax;
+    let sum = ax;
+    for (let n = 1; n < 200; n++) {
+      term *= 2 * x2 / (2 * n + 1);
+      sum += term;
+      if (term < sum * 1e-18) break;
+    }
+    return sign2 * (2 / Math.sqrt(Math.PI)) * Math.exp(-x2) * sum;
   }
   var BERNOULLI_2K = [
     1 / 6,
@@ -1823,7 +1969,7 @@ var Interval = (() => {
       const t = x2 * x2;
       return sign2 * x * x2 * polevl(t, SN) / polevl(t, SD);
     }
-    if (x < 36) {
+    if (x < 36974) {
       const x2 = x * x;
       const t = Math.PI * x2;
       const u = 1 / (t * t);
@@ -1848,7 +1994,7 @@ var Interval = (() => {
       const t = x2 * x2;
       return sign2 * x * polevl(t, CN) / polevl(t, CD);
     }
-    if (x < 36) {
+    if (x < 36974) {
       const x2 = x * x;
       const t = Math.PI * x2;
       const u = 1 / (t * t);
@@ -1890,7 +2036,8 @@ var Interval = (() => {
   }
   function lcm(a, b) {
     if (a === 0 || b === 0) return 0;
-    const res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+    let res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+    if (res < 0n) res = -res;
     return Number(res);
   }
   function factorial(n) {
@@ -3256,172 +3403,23 @@ var Interval = (() => {
     "error",
     ...EXPRESSION_TYPES
   ];
+  var NUMERIC_TYPES_SET = new Set(
+    NUMERIC_TYPES
+  );
+  var COLLECTION_TYPES_SET = new Set(
+    COLLECTION_TYPES
+  );
+  var SCALAR_TYPES_SET = new Set(
+    SCALAR_TYPES
+  );
+  var PRIMITIVE_TYPES_SET = new Set(
+    PRIMITIVE_TYPES
+  );
   function isValidType(t) {
-    if (typeof t === "string")
-      return PRIMITIVE_TYPES.includes(t);
+    if (typeof t === "string") return PRIMITIVE_TYPES_SET.has(t);
     if (typeof t !== "object") return false;
     if (!("kind" in t)) return false;
-    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "function" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
-  }
-
-  // src/common/type/serialize.ts
-  var NEGATION_PRECEDENCE = 3;
-  var UNION_PRECEDENCE = 1;
-  var INTERSECTION_PRECEDENCE = 2;
-  var LIST_PRECEDENCE = 4;
-  var RECORD_PRECEDENCE = 5;
-  var DICTIONARY_PRECEDENCE = 6;
-  var SET_PRECEDENCE = 7;
-  var COLLECTION_PRECEDENCE = 8;
-  var TUPLE_PRECEDENCE = 9;
-  var SIGNATURE_PRECEDENCE = 10;
-  var VALUE_PRECEDENCE = 11;
-  function typeToString(type, precedence = 0) {
-    if (typeof type === "string") return type;
-    let result = "";
-    switch (type.kind) {
-      case "value":
-        if (typeof type.value === "string") result = `"${type.value}"`;
-        else if (typeof type.value === "boolean")
-          result = type.value ? "true" : "false";
-        else result = type.value.toString();
-        break;
-      case "reference":
-        result = type.name;
-        break;
-      case "negation":
-        result = `!${typeToString(type.type, NEGATION_PRECEDENCE)}`;
-        break;
-      case "union":
-        result = type.types.map((t) => typeToString(t, UNION_PRECEDENCE)).join(" | ");
-        break;
-      case "intersection":
-        result = type.types.map((t) => typeToString(t, INTERSECTION_PRECEDENCE)).join(" & ");
-        break;
-      case "expression":
-        result = `expression<${symbolName(type.operator)}>`;
-        break;
-      case "symbol":
-        result = `symbol<${symbolName(type.name)}>`;
-        break;
-      case "numeric":
-        if (Number.isFinite(type.lower) && Number.isFinite(type.upper)) {
-          result = `${type.type}<${type.lower}..${type.upper}>`;
-        } else if (Number.isFinite(type.lower)) {
-          result = `${type.type}<${type.lower}..>`;
-        } else if (Number.isFinite(type.upper)) {
-          result = `${type.type}<..${type.upper}>`;
-        } else {
-          result = `${type.type}`;
-        }
-        break;
-      case "list":
-        if (type.dimensions && typeof type.elements === "string" && NUMERIC_TYPES.includes(type.elements)) {
-          if (type.dimensions === void 0) {
-            if (type.elements === "number") result = "tensor";
-          } else if (type.dimensions.length === 1) {
-            if (type.elements === "number") {
-              if (type.dimensions[0] < 0) result = "vector";
-              else result = `vector<${type.dimensions[0]}>`;
-            } else {
-              if (type.dimensions[0] < 0)
-                result = `vector<${typeToString(type.elements)}>`;
-              else
-                result = `vector<${typeToString(type.elements)}^${type.dimensions[0]}>`;
-            }
-          } else if (type.dimensions.length === 2) {
-            const dims = type.dimensions;
-            if (type.elements === "number") {
-              if (dims[0] < 0 && dims[1] < 0) result = "matrix";
-              else result = `matrix<${dims[0]}x${dims[1]}>`;
-            } else {
-              if (dims[0] < 0 && dims[1] < 0)
-                result = `matrix<${typeToString(type.elements)}>`;
-              else
-                result = `matrix<${typeToString(type.elements)}^(${dims[0]}x${dims[1]})>`;
-            }
-          }
-        }
-        if (!result) {
-          const dimensions = type.dimensions ? type.dimensions.length === 1 ? `^${type.dimensions[0].toString()}` : `^(${type.dimensions.join("x")})` : "";
-          result = `list<${typeToString(type.elements)}${dimensions}>`;
-        }
-        break;
-      case "record":
-        const elements = Object.entries(type.elements).map(([key, value]) => `${key}: ${typeToString(value)}`).join(", ");
-        result = `record<${elements}>`;
-        break;
-      case "dictionary":
-        result = `dictionary<${typeToString(type.values)}>`;
-        break;
-      case "set":
-        result = `set<${typeToString(type.elements)}>`;
-        break;
-      case "collection":
-        result = `collection<${typeToString(type.elements)}>`;
-        break;
-      case "indexed_collection":
-        result = `indexed_collection<${typeToString(type.elements)}>`;
-        break;
-      case "tuple":
-        if (type.elements.length === 0) result = "tuple";
-        else if (type.elements.length === 1) {
-          const [el] = type.elements;
-          result = `tuple<${namedElement(el)}>`;
-        } else {
-          result = "tuple<" + type.elements.map((el) => namedElement(el)).join(", ") + ">";
-        }
-        break;
-      case "signature":
-        const args = type.args ? type.args.map((arg) => namedElement(arg)).join(", ") : "";
-        const optArgs = type.optArgs ? type.optArgs.map((arg) => namedElement(arg) + "?").join(", ") : "";
-        const varArg = type.variadicArg ? type.variadicMin === 0 ? `${namedElement(type.variadicArg)}*` : `${namedElement(type.variadicArg)}+` : "";
-        const argsList = [args, optArgs, varArg].filter((s) => s).join(", ");
-        result = `(${argsList}) -> ${typeToString(type.result)}`;
-        break;
-      default:
-        result = "error";
-    }
-    if (precedence > 0 && precedence > getPrecedence(type.kind))
-      return `(${result})`;
-    return result;
-  }
-  function namedElement(el) {
-    if (el.name) return `${el.name}: ${typeToString(el.type)}`;
-    return typeToString(el.type);
-  }
-  function symbolName(name) {
-    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
-    return `\`${name}\``;
-  }
-  function getPrecedence(kind) {
-    switch (kind) {
-      case "negation":
-        return NEGATION_PRECEDENCE;
-      case "union":
-        return UNION_PRECEDENCE;
-      case "intersection":
-        return INTERSECTION_PRECEDENCE;
-      case "list":
-        return LIST_PRECEDENCE;
-      case "record":
-        return RECORD_PRECEDENCE;
-      case "dictionary":
-        return DICTIONARY_PRECEDENCE;
-      case "set":
-        return SET_PRECEDENCE;
-      case "collection":
-      case "indexed_collection":
-        return COLLECTION_PRECEDENCE;
-      case "tuple":
-        return TUPLE_PRECEDENCE;
-      case "signature":
-        return SIGNATURE_PRECEDENCE;
-      case "value":
-        return VALUE_PRECEDENCE;
-      default:
-        return 0;
-    }
+    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "value" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "symbol" || t.kind === "expression" || t.kind === "numeric" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
   }
 
   // src/common/type/lexer.ts
@@ -4131,19 +4129,13 @@ var Interval = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -4184,19 +4176,13 @@ var Interval = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -4227,16 +4213,30 @@ var Interval = (() => {
       return this.createNode("tensor", { elementType });
     }
     parseDimensions() {
-      const dimensions = [];
       const firstDim = this.parseDimension();
       if (!firstDim) return void 0;
-      dimensions.push(firstDim);
-      while (this.match("x")) {
-        const dim = this.parseDimension();
-        if (!dim) {
-          this.error("Expected dimension after x");
+      const dimensions = [firstDim];
+      for (; ; ) {
+        const tok = this.current;
+        if (tok.type === "IDENTIFIER" && /^(x\d+)+$/.test(tok.value)) {
+          this.advance();
+          for (const m of tok.value.match(/x(\d+)/g))
+            dimensions.push(
+              this.createNode("dimension", {
+                size: parseInt(m.slice(1))
+              })
+            );
+        } else if (tok.type === "IDENTIFIER" && tok.value === "x") {
+          const next = this.lexer.peekToken();
+          if (next.type !== "NUMBER_LITERAL" && next.type !== "?")
+            this.error(
+              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
+            );
+          this.advance();
+          dimensions.push(this.parseDimension());
+        } else {
+          break;
         }
-        dimensions.push(dim);
       }
       return dimensions;
     }
@@ -4250,35 +4250,11 @@ var Interval = (() => {
       }
       return void 0;
     }
-    parseDimensionWithX() {
-      if (this.current.type === "NUMBER_LITERAL") {
-        const dimensions = [];
-        const firstDim = parseInt(this.advance().value);
-        dimensions.push(
-          this.createNode("dimension", { size: firstDim })
-        );
-        if (this.current.type === "IDENTIFIER" && this.current.value.startsWith("x")) {
-          const dimString = this.current.value;
-          const matches = dimString.match(/x(\d+)/g);
-          if (matches && matches.join("") === dimString) {
-            this.advance();
-            for (const match of matches) {
-              const dimValue = parseInt(match.substring(1));
-              dimensions.push(
-                this.createNode("dimension", { size: dimValue })
-              );
-            }
-          } else if (dimString === "x" || dimString.startsWith("x")) {
-            this.error(
-              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
-            );
-          }
-        }
-        if (dimensions.length > 1) {
-          return dimensions;
-        }
-      }
-      return void 0;
+    parseCaretDimensions() {
+      const paren = this.match("(");
+      const dimensions = this.parseDimensions();
+      if (paren) this.expect(")");
+      return dimensions;
     }
     parseTupleType() {
       if (this.current.type === "IDENTIFIER" && this.current.value === "tuple") {
@@ -4463,6 +4439,18 @@ var Interval = (() => {
             this.expect("..");
             const upperBound = this.parseValue();
             this.expect(">");
+            const lower = lowerBound?.value ?? -Infinity;
+            const upper = upperBound?.value ?? Infinity;
+            if (Number.isNaN(lower) || Number.isNaN(upper))
+              this.error(
+                "Invalid numeric type",
+                "Lower and upper bounds must be valid numbers"
+              );
+            if (lower > upper)
+              this.error(
+                `Invalid range: ${lower}..${upper}`,
+                "The lower bound must be less than the upper bound"
+              );
             return this.createNode("numeric", {
               baseType,
               lowerBound,
@@ -4477,7 +4465,7 @@ var Interval = (() => {
     parsePrimitiveType() {
       if (this.current.type === "IDENTIFIER") {
         const name = this.current.value;
-        if (PRIMITIVE_TYPES.includes(name)) {
+        if (PRIMITIVE_TYPES_SET.has(name)) {
           this.advance();
           return this.createNode("primitive", { name });
         }
@@ -4811,14 +4799,32 @@ var Interval = (() => {
   }
 
   // src/common/type/parse.ts
+  var TYPE_CACHE = /* @__PURE__ */ new Map();
+  var TYPE_CACHE_MAX_SIZE = 2048;
+  function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+    if (Object.isFrozen(obj)) return obj;
+    Object.freeze(obj);
+    for (const value of Object.values(obj)) deepFreeze(value);
+    return obj;
+  }
   function parseType(s, typeResolver) {
     if (s === void 0) return void 0;
     if (isValidType(s)) return s;
     if (typeof s !== "string") return void 0;
+    const cacheable = typeResolver === void 0;
+    if (cacheable) {
+      const cached = TYPE_CACHE.get(s);
+      if (cached !== void 0) return cached;
+    }
     try {
       const parser = new Parser(s, { typeResolver });
       const ast = parser.parseType();
       const type = buildTypeFromAST(ast, typeResolver);
+      if (cacheable) {
+        if (TYPE_CACHE.size >= TYPE_CACHE_MAX_SIZE) TYPE_CACHE.clear();
+        TYPE_CACHE.set(s, deepFreeze(type));
+      }
       return type;
     } catch (error) {
       throw new Error(
@@ -4893,19 +4899,36 @@ var Interval = (() => {
     color: [],
     expression: EXPRESSION_TYPES
   };
+  var PRIMITIVE_SUBTYPES_CLOSURE = (() => {
+    const closure = {};
+    const closeOver = (t) => {
+      if (closure[t]) return closure[t];
+      const result = /* @__PURE__ */ new Set([t]);
+      closure[t] = result;
+      for (const sub2 of PRIMITIVE_SUBTYPES[t]) {
+        if (sub2 === t) continue;
+        for (const s of closeOver(sub2)) result.add(s);
+      }
+      return result;
+    };
+    for (const t of Object.keys(PRIMITIVE_SUBTYPES))
+      closeOver(t);
+    return closure;
+  })();
   function isPrimitiveSubtype(lhs, rhs) {
     if (rhs === "any") return true;
     if (lhs === "never") return true;
     if (lhs === "unknown" || rhs === "unknown") return false;
     if (lhs === rhs) return true;
-    return PRIMITIVE_SUBTYPES[rhs].includes(lhs);
+    return PRIMITIVE_SUBTYPES_CLOSURE[rhs].has(lhs);
   }
   function isSubtype(lhs, rhs) {
-    if (typeof lhs === "string" && !PRIMITIVE_TYPES.includes(lhs))
+    if (typeof lhs === "string" && !PRIMITIVE_TYPES_SET.has(lhs))
       lhs = parseType(lhs);
-    if (typeof rhs === "string" && !PRIMITIVE_TYPES.includes(rhs))
+    if (typeof rhs === "string" && !PRIMITIVE_TYPES_SET.has(rhs))
       rhs = parseType(rhs);
     if (rhs === "any") return true;
+    if (lhs === "never") return true;
     if (rhs === "never") return false;
     if (rhs === "error") return lhs === "error";
     if (rhs === "nothing") return lhs === "nothing";
@@ -4920,7 +4943,7 @@ var Interval = (() => {
         if (typeof lhs.value === "number") {
           if (Number.isInteger(lhs.value))
             return isPrimitiveSubtype("integer", rhs);
-          return isPrimitiveSubtype("number", rhs);
+          return isPrimitiveSubtype("real", rhs);
         }
         if (typeof lhs.value === "boolean")
           return isPrimitiveSubtype("boolean", rhs);
@@ -5150,7 +5173,7 @@ var Interval = (() => {
   }
   function isNumeric(type) {
     if (typeof type === "string")
-      return NUMERIC_TYPES.includes(type);
+      return NUMERIC_TYPES_SET.has(type);
     if (type.kind === "value") return typeof type.value === "number";
     if (type.kind === "numeric") return true;
     return false;
@@ -5158,7 +5181,7 @@ var Interval = (() => {
   function isScalar(type) {
     if (isNumeric(type)) return true;
     if (typeof type === "string")
-      return SCALAR_TYPES.includes(type);
+      return SCALAR_TYPES_SET.has(type);
     if (type.kind === "value")
       return ["string", "boolean", "number"].includes(typeof type.value);
     return false;
@@ -5166,7 +5189,7 @@ var Interval = (() => {
   function isCollection(type) {
     if (isIndexedCollection(type)) return true;
     if (typeof type === "string")
-      return COLLECTION_TYPES.includes(type);
+      return COLLECTION_TYPES_SET.has(type);
     return ["collection", "set", "record", "dictionary"].includes(type.kind);
   }
   function isIndexedCollection(type) {
@@ -5205,7 +5228,7 @@ var Interval = (() => {
     if (b === "unknown") return a;
     if (isSubtype(a, b)) return a;
     if (isSubtype(b, a)) return b;
-    return superType(a, b);
+    return "never";
   }
   function widen2(a, b) {
     if (a === b) return a;
@@ -5239,16 +5262,17 @@ var Interval = (() => {
   ]);
   function unionTypes(a, b) {
     const members = [];
+    const keys = /* @__PURE__ */ new Set();
     const push = (t) => {
       if (typeof t === "object" && t.kind === "union") {
         for (const m of t.types) push(m);
         return;
       }
       const key = typeof t === "string" ? t : JSON.stringify(t);
-      if (!members.some(
-        (m) => (typeof m === "string" ? m : JSON.stringify(m)) === key
-      ))
+      if (!keys.has(key)) {
+        keys.add(key);
         members.push(t);
+      }
     };
     push(a);
     push(b);
@@ -5265,6 +5289,32 @@ var Interval = (() => {
     if (types.length === 1) return types[0];
     return types.reduce((a, b) => widen2(a, b));
   }
+  var SUPERTYPE_PROBE_ORDER = [
+    "non_finite_number",
+    "finite_integer",
+    "integer",
+    "finite_rational",
+    "rational",
+    "finite_real",
+    "real",
+    "imaginary",
+    "finite_complex",
+    "complex",
+    "finite_number",
+    "number",
+    "list",
+    "record",
+    "dictionary",
+    "set",
+    "tuple",
+    "indexed_collection",
+    "collection",
+    "scalar",
+    "value",
+    "function",
+    "expression"
+  ];
+  var PRIMITIVE_SUPERTYPE_CACHE = /* @__PURE__ */ new Map();
   function superType(a, b) {
     if (a === b) return a;
     if (a === "any" || b === "any") return "any";
@@ -5274,34 +5324,185 @@ var Interval = (() => {
     if (b === "unknown") return a;
     if (a === "nothing") return b;
     if (b === "nothing") return a;
-    if (commonSupertype(a, b, "non_finite_number")) return "non_finite_number";
-    if (commonSupertype(a, b, "finite_integer")) return "finite_integer";
-    if (commonSupertype(a, b, "integer")) return "integer";
-    if (commonSupertype(a, b, "finite_rational")) return "finite_rational";
-    if (commonSupertype(a, b, "rational")) return "rational";
-    if (commonSupertype(a, b, "finite_real")) return "finite_real";
-    if (commonSupertype(a, b, "real")) return "real";
-    if (commonSupertype(a, b, "imaginary")) return "imaginary";
-    if (commonSupertype(a, b, "finite_complex")) return "finite_complex";
-    if (commonSupertype(a, b, "complex")) return "complex";
-    if (commonSupertype(a, b, "finite_number")) return "finite_number";
-    if (commonSupertype(a, b, "number")) return "number";
-    if (commonSupertype(a, b, "list")) return "list";
-    if (commonSupertype(a, b, "record")) return "record";
-    if (commonSupertype(a, b, "dictionary")) return "dictionary";
-    if (commonSupertype(a, b, "set")) return "set";
-    if (commonSupertype(a, b, "tuple")) return "tuple";
-    if (commonSupertype(a, b, "indexed_collection")) return "indexed_collection";
-    if (commonSupertype(a, b, "collection")) return "collection";
-    if (commonSupertype(a, b, "scalar")) return "scalar";
-    if (commonSupertype(a, b, "value")) return "value";
-    if (commonSupertype(a, b, "function")) return "function";
-    if (commonSupertype(a, b, "expression")) return "expression";
+    if (typeof a === "string" && typeof b === "string") {
+      const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+      let result = PRIMITIVE_SUPERTYPE_CACHE.get(key);
+      if (result === void 0) {
+        result = "any";
+        for (const ancestor of SUPERTYPE_PROBE_ORDER) {
+          const subtypes = PRIMITIVE_SUBTYPES_CLOSURE[ancestor];
+          if (subtypes.has(a) && subtypes.has(b)) {
+            result = ancestor;
+            break;
+          }
+        }
+        PRIMITIVE_SUPERTYPE_CACHE.set(key, result);
+      }
+      return result;
+    }
+    for (const ancestor of SUPERTYPE_PROBE_ORDER)
+      if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return ancestor;
     return "any";
   }
-  function commonSupertype(a, b, ancestor) {
-    if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return true;
-    return false;
+
+  // src/common/type/serialize.ts
+  var NEGATION_PRECEDENCE = 3;
+  var UNION_PRECEDENCE = 1;
+  var INTERSECTION_PRECEDENCE = 2;
+  var LIST_PRECEDENCE = 4;
+  var RECORD_PRECEDENCE = 5;
+  var DICTIONARY_PRECEDENCE = 6;
+  var SET_PRECEDENCE = 7;
+  var COLLECTION_PRECEDENCE = 8;
+  var TUPLE_PRECEDENCE = 9;
+  var SIGNATURE_PRECEDENCE = 10;
+  var VALUE_PRECEDENCE = 11;
+  function typeToString(type, precedence = 0) {
+    if (typeof type === "string") return type;
+    let result = "";
+    switch (type.kind) {
+      case "value":
+        if (typeof type.value === "string") result = `"${type.value}"`;
+        else if (typeof type.value === "boolean")
+          result = type.value ? "true" : "false";
+        else result = type.value.toString();
+        break;
+      case "reference":
+        result = type.name;
+        break;
+      case "negation":
+        result = `!${typeToString(type.type, NEGATION_PRECEDENCE)}`;
+        break;
+      case "union":
+        result = type.types.map((t) => typeToString(t, UNION_PRECEDENCE)).join(" | ");
+        break;
+      case "intersection":
+        result = type.types.map((t) => typeToString(t, INTERSECTION_PRECEDENCE)).join(" & ");
+        break;
+      case "expression":
+        result = `expression<${symbolName(type.operator)}>`;
+        break;
+      case "symbol":
+        result = `symbol<${symbolName(type.name)}>`;
+        break;
+      case "numeric":
+        if (Number.isFinite(type.lower) && Number.isFinite(type.upper)) {
+          result = `${type.type}<${type.lower}..${type.upper}>`;
+        } else if (Number.isFinite(type.lower)) {
+          result = `${type.type}<${type.lower}..>`;
+        } else if (Number.isFinite(type.upper)) {
+          result = `${type.type}<..${type.upper}>`;
+        } else {
+          result = `${type.type}`;
+        }
+        break;
+      case "list":
+        if (type.dimensions && typeof type.elements === "string" && NUMERIC_TYPES_SET.has(type.elements)) {
+          if (type.dimensions === void 0) {
+            if (type.elements === "number") result = "tensor";
+          } else if (type.dimensions.length === 1) {
+            if (type.elements === "number") {
+              if (type.dimensions[0] < 0) result = "vector";
+              else result = `vector<${type.dimensions[0]}>`;
+            } else {
+              if (type.dimensions[0] < 0)
+                result = `vector<${typeToString(type.elements)}>`;
+              else
+                result = `vector<${typeToString(type.elements)}^${type.dimensions[0]}>`;
+            }
+          } else if (type.dimensions.length === 2) {
+            const dims = type.dimensions;
+            if (type.elements === "number") {
+              if (dims[0] < 0 && dims[1] < 0) result = "matrix";
+              else result = `matrix<${dims[0]}x${dims[1]}>`;
+            } else {
+              if (dims[0] < 0 && dims[1] < 0)
+                result = `matrix<${typeToString(type.elements)}>`;
+              else
+                result = `matrix<${typeToString(type.elements)}^(${dims[0]}x${dims[1]})>`;
+            }
+          }
+        }
+        if (!result) {
+          const dimensions = type.dimensions ? type.dimensions.length === 1 ? `^${type.dimensions[0].toString()}` : `^(${type.dimensions.join("x")})` : "";
+          result = `list<${typeToString(type.elements)}${dimensions}>`;
+        }
+        break;
+      case "record":
+        const elements = Object.entries(type.elements).map(([key, value]) => `${key}: ${typeToString(value)}`).join(", ");
+        result = `record<${elements}>`;
+        break;
+      case "dictionary":
+        result = `dictionary<${typeToString(type.values)}>`;
+        break;
+      case "set":
+        result = `set<${typeToString(type.elements)}>`;
+        break;
+      case "collection":
+        result = `collection<${typeToString(type.elements)}>`;
+        break;
+      case "indexed_collection":
+        result = `indexed_collection<${typeToString(type.elements)}>`;
+        break;
+      case "tuple":
+        if (type.elements.length === 0) result = "tuple";
+        else if (type.elements.length === 1) {
+          const [el] = type.elements;
+          result = `tuple<${namedElement(el)}>`;
+        } else {
+          result = "tuple<" + type.elements.map((el) => namedElement(el)).join(", ") + ">";
+        }
+        break;
+      case "signature":
+        const args = type.args ? type.args.map((arg) => namedElement(arg)).join(", ") : "";
+        const optArgs = type.optArgs ? type.optArgs.map((arg) => namedElement(arg) + "?").join(", ") : "";
+        const varArg = type.variadicArg ? type.variadicMin === 0 ? `${namedElement(type.variadicArg)}*` : `${namedElement(type.variadicArg)}+` : "";
+        const argsList = [args, optArgs, varArg].filter((s) => s).join(", ");
+        result = `(${argsList}) -> ${typeToString(type.result)}`;
+        break;
+      default:
+        result = "error";
+    }
+    if (precedence > 0 && precedence > getPrecedence(type.kind))
+      return `(${result})`;
+    return result;
+  }
+  function namedElement(el) {
+    if (el.name) return `${el.name}: ${typeToString(el.type)}`;
+    return typeToString(el.type);
+  }
+  function symbolName(name) {
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
+    return `\`${name}\``;
+  }
+  function getPrecedence(kind) {
+    switch (kind) {
+      case "negation":
+        return NEGATION_PRECEDENCE;
+      case "union":
+        return UNION_PRECEDENCE;
+      case "intersection":
+        return INTERSECTION_PRECEDENCE;
+      case "list":
+        return LIST_PRECEDENCE;
+      case "record":
+        return RECORD_PRECEDENCE;
+      case "dictionary":
+        return DICTIONARY_PRECEDENCE;
+      case "set":
+        return SET_PRECEDENCE;
+      case "collection":
+      case "indexed_collection":
+        return COLLECTION_PRECEDENCE;
+      case "tuple":
+        return TUPLE_PRECEDENCE;
+      case "signature":
+        return SIGNATURE_PRECEDENCE;
+      case "value":
+        return VALUE_PRECEDENCE;
+      default:
+        return 0;
+    }
   }
 
   // src/common/type/boxed-type.ts
@@ -5361,6 +5562,12 @@ var Interval = (() => {
     }
   };
 
+  // src/compute-engine/boxed-expression/constraint-subject.ts
+  var EMPTY_FACT_INDEX = Object.freeze({
+    bySubject: /* @__PURE__ */ new Map(),
+    membership: /* @__PURE__ */ new Map()
+  });
+
   // src/compute-engine/boxed-expression/stochastic-equal.ts
   var WELL_KNOWN_POINTS = [
     0,
@@ -5466,12 +5673,14 @@ var Interval = (() => {
     if (expr === null) return null;
     if (isDictionaryObject(expr)) return expr;
     const kv = keyValuePair(expr);
-    if (kv) return { [kv[0]]: kv[1] };
+    if (kv)
+      return {
+        dict: { [kv[0]]: expressionToDictionaryValue(kv[1]) ?? "Nothing" }
+      };
     if (operator(expr) === "Dictionary") {
       const dict = {};
-      const ops = operands(expr);
-      for (let i = 1; i < nops(expr); i++) {
-        const kv2 = keyValuePair(ops[i]);
+      for (const op of operands(expr)) {
+        const kv2 = keyValuePair(op);
         if (kv2) {
           dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
         }
@@ -7405,6 +7614,7 @@ var Interval = (() => {
           }
         }
         if (!variable) return null;
+        if (symbol(variable) === null) return null;
         parser.skipSpace();
         const fn = parser.parseExpression({ minPrec: 740 });
         if (!fn) return null;
@@ -7591,7 +7801,7 @@ var Interval = (() => {
     if (runs.length === 1) body = runs[0];
     else {
       if (runs.every((x) => stringValue(x) !== null))
-        body = "'" + runs.map((x) => stringValue(x)).join() + "'";
+        body = "'" + runs.map((x) => stringValue(x)).join("") + "'";
       else body = ["Text", ...runs];
     }
     return style ? ["Annotated", body, dictionaryFromEntries(style)] : body;
@@ -9124,6 +9334,8 @@ var Interval = (() => {
         const h = operator(arg);
         if (prevWasNumber && (h === "Divide" || h === "Rational")) {
           result = latexTemplate(serializer.options.multiply, result, term);
+        } else if (/^\d/.test(term)) {
+          result = latexTemplate(serializer.options.multiply, result, term);
         } else if (!serializer.options.invisibleMultiply) {
           result = joinLatex([result, term]);
         } else {
@@ -10569,7 +10781,8 @@ var Interval = (() => {
         minPrec: MULTIPLICATION_PRECEDENCE,
         condition: (parser2) => trigCommands[parser2.peek] || (until?.condition?.(parser2) ?? false)
       });
-      const head = fn === "Arctan" && args?.length === 2 ? "Arctan2" : fn;
+      const isTwoArgArctan = args?.length === 2 && (fn === "Arctan" || Array.isArray(fn) && fn[0] === "InverseFunction" && fn[1] === "Tan");
+      const head = isTwoArgArctan ? "Arctan2" : fn;
       const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
       return sup === null ? appliedFn : ["Power", appliedFn, sup];
     };
@@ -12856,6 +13069,30 @@ var Interval = (() => {
   var SOME_EMOJI = new RegExp(`(?:${POSSIBLE_EMOJI})+`, "u");
   var EMOJIS = new RegExp(`^(?:${POSSIBLE_EMOJI})+$`, "u");
 
+  // src/compute-engine/latex-syntax/parse.ts
+  var PARSE_TOKEN_EXCLUDED = /* @__PURE__ */ new Set([
+    ...'!"#$%&(),/;:?@[]\\`|~'.split(""),
+    "\\left",
+    "\\bigl",
+    "\\mleft"
+  ]);
+  var TEX_UNIT_TOKENS = [
+    "pt",
+    "em",
+    "mu",
+    "ex",
+    "mm",
+    "cm",
+    "in",
+    "bp",
+    "sp",
+    "dd",
+    "cc",
+    "pc",
+    "nc",
+    "nd"
+  ].map((unit) => [...unit]);
+
   // src/compute-engine/boxed-expression/expand.ts
   var binomials = [
     [1],
@@ -13157,6 +13394,7 @@ var Interval = (() => {
     const period = Math.abs(
       bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi))
     );
+    const divisorNegative = bVal.hi < 0;
     const flo = Math.floor(aVal.lo / period);
     const fhi = Math.floor(aVal.hi / period);
     if (flo !== fhi) {
@@ -13164,6 +13402,11 @@ var Interval = (() => {
     }
     const modLo = aVal.lo - period * flo;
     const modHi = aVal.hi - period * flo;
+    if (divisorNegative) {
+      if (modLo === 0)
+        return { kind: "singular", at: aVal.lo, continuity: "right" };
+      return ok({ lo: modLo - period, hi: modHi - period });
+    }
     return ok({ lo: Math.min(modLo, modHi), hi: Math.max(modLo, modHi) });
   }
   function remainder(a, b) {
@@ -13195,6 +13438,23 @@ var Interval = (() => {
     const [xVal] = unwrapped;
     return _gamma(xVal);
   }
+  var GAMMA_NEG_EXTREMA_X = [
+    -0.504083008264455,
+    -1.573498473162391,
+    -2.610720868444145,
+    -3.635293366436901,
+    -4.653163765628266,
+    -5.667162441556885,
+    -6.678418213073426,
+    -7.687788325031709,
+    -8.695764163640956,
+    -9.702672540001863
+  ];
+  function gammaNegStripExtremum(lo) {
+    const n = Math.floor(lo);
+    const idx = -n - 1;
+    return idx >= 0 && idx < GAMMA_NEG_EXTREMA_X.length ? GAMMA_NEG_EXTREMA_X[idx] : null;
+  }
   function _gamma(x) {
     if (x.hi >= 0 && x.lo <= 0) {
       return { kind: "singular", at: 0 };
@@ -13207,7 +13467,21 @@ var Interval = (() => {
       }
       const gLo = gamma(x.lo);
       const gHi = gamma(x.hi);
-      return ok({ lo: Math.min(gLo, gHi), hi: Math.max(gLo, gHi) });
+      let lo = Math.min(gLo, gHi);
+      let hi = Math.max(gLo, gHi);
+      const xStar = gammaNegStripExtremum(x.lo);
+      if (xStar !== null) {
+        if (xStar >= x.lo && xStar <= x.hi) {
+          const g = gamma(xStar);
+          lo = Math.min(lo, g);
+          hi = Math.max(hi, g);
+        }
+      } else {
+        const stripEven = Math.floor(x.lo) % 2 === 0;
+        if (stripEven) lo = Math.min(lo, 0);
+        else hi = Math.max(hi, 0);
+      }
+      return ok({ lo, hi });
     }
     if (x.lo >= GAMMA_MIN_X) {
       return ok({ lo: gamma(x.lo), hi: gamma(x.hi) });
@@ -13238,7 +13512,15 @@ var Interval = (() => {
       }
       const gLo = gammaln(x.lo);
       const gHi = gammaln(x.hi);
-      return ok({ lo: Math.min(gLo, gHi), hi: Math.max(gLo, gHi) });
+      let lo = Math.min(gLo, gHi);
+      const hi = Math.max(gLo, gHi);
+      const xStar = gammaNegStripExtremum(x.lo);
+      if (xStar !== null) {
+        if (xStar >= x.lo && xStar <= x.hi) lo = Math.min(lo, gammaln(xStar));
+      } else {
+        lo = -Infinity;
+      }
+      return ok({ lo, hi });
     }
     return ok({ lo: gammaln(x.lo), hi: gammaln(x.hi) });
   }
@@ -13264,6 +13546,33 @@ var Interval = (() => {
       return ok({ lo: Math.min(fLo, fHi), hi: Math.max(fLo, fHi) });
     return ok({ lo: fLo, hi: fHi });
   }
+  var MAX_INT_ENUM_POINTS = 4096;
+  function integerPoints(lo, hi, cap) {
+    const a = Math.round(lo);
+    const b = Math.round(hi);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) return null;
+    if (b - a + 1 > cap) return null;
+    const out = [];
+    for (let i = a; i <= b; i++) out.push(i);
+    return out;
+  }
+  function enumerateInteger2(a, b, f) {
+    const xs = integerPoints(a.lo, a.hi, MAX_INT_ENUM_POINTS);
+    const ys = integerPoints(b.lo, b.hi, MAX_INT_ENUM_POINTS);
+    if (!xs || !ys || xs.length * ys.length > MAX_INT_ENUM_POINTS) return null;
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (const x of xs)
+      for (const y of ys) {
+        const v = f(x, y);
+        if (Number.isFinite(v)) {
+          if (v < lo) lo = v;
+          if (v > hi) hi = v;
+        }
+      }
+    if (lo === Infinity) return null;
+    return ok({ lo, hi });
+  }
   function binomial(n, k) {
     const uN = unwrapOrPropagate(n);
     if (!Array.isArray(uN)) return uN;
@@ -13271,13 +13580,10 @@ var Interval = (() => {
     if (!Array.isArray(uK)) return uK;
     const [nVal] = uN;
     const [kVal] = uK;
-    const vals = [
-      choose(Math.round(nVal.lo), Math.round(kVal.lo)),
-      choose(Math.round(nVal.lo), Math.round(kVal.hi)),
-      choose(Math.round(nVal.hi), Math.round(kVal.lo)),
-      choose(Math.round(nVal.hi), Math.round(kVal.hi))
-    ];
-    return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
+    const enumerated = enumerateInteger2(nVal, kVal, choose);
+    if (enumerated) return enumerated;
+    const nMax = Math.round(nVal.hi);
+    return ok({ lo: 0, hi: choose(nMax, Math.floor(nMax / 2)) });
   }
   function gcd3(a, b) {
     const uA = unwrapOrPropagate(a);
@@ -13286,13 +13592,15 @@ var Interval = (() => {
     if (!Array.isArray(uB)) return uB;
     const [aVal] = uA;
     const [bVal] = uB;
-    const vals = [
-      gcd(Math.round(aVal.lo), Math.round(bVal.lo)),
-      gcd(Math.round(aVal.lo), Math.round(bVal.hi)),
-      gcd(Math.round(aVal.hi), Math.round(bVal.lo)),
-      gcd(Math.round(aVal.hi), Math.round(bVal.hi))
-    ];
-    return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
+    const enumerated = enumerateInteger2(aVal, bVal, gcd);
+    if (enumerated) return enumerated;
+    const m = Math.max(
+      Math.abs(Math.round(aVal.lo)),
+      Math.abs(Math.round(aVal.hi)),
+      Math.abs(Math.round(bVal.lo)),
+      Math.abs(Math.round(bVal.hi))
+    );
+    return ok({ lo: 0, hi: m });
   }
   function lcm3(a, b) {
     const uA = unwrapOrPropagate(a);
@@ -13301,13 +13609,11 @@ var Interval = (() => {
     if (!Array.isArray(uB)) return uB;
     const [aVal] = uA;
     const [bVal] = uB;
-    const vals = [
-      lcm(Math.round(aVal.lo), Math.round(bVal.lo)),
-      lcm(Math.round(aVal.lo), Math.round(bVal.hi)),
-      lcm(Math.round(aVal.hi), Math.round(bVal.lo)),
-      lcm(Math.round(aVal.hi), Math.round(bVal.hi))
-    ];
-    return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
+    const enumerated = enumerateInteger2(aVal, bVal, lcm);
+    if (enumerated) return enumerated;
+    const ma = Math.max(Math.abs(Math.round(aVal.lo)), Math.abs(Math.round(aVal.hi)));
+    const mb = Math.max(Math.abs(Math.round(bVal.lo)), Math.abs(Math.round(bVal.hi)));
+    return ok({ lo: 0, hi: ma * mb });
   }
   function chop2(x) {
     const unwrapped = unwrapOrPropagate(x);
@@ -13699,7 +14005,6 @@ var Interval = (() => {
     29.8116,
     32.95639
   ];
-  var SINC_GLOBAL_LO = -0.21724;
   function sinc(x) {
     const unwrapped = unwrapOrPropagate(x);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -13720,8 +14025,14 @@ var Interval = (() => {
       if (e >= xVal.lo && e <= xVal.hi) update(sincVal(e));
       if (-e >= xVal.lo && -e <= xVal.hi) update(sincVal(-e));
     }
-    if (Math.abs(xVal.lo) > lastExtremum || Math.abs(xVal.hi) > lastExtremum) {
-      update(SINC_GLOBAL_LO);
+    let minBeyondAbs = Infinity;
+    if (xVal.hi > lastExtremum)
+      minBeyondAbs = Math.min(minBeyondAbs, Math.max(xVal.lo, lastExtremum));
+    if (xVal.lo < -lastExtremum)
+      minBeyondAbs = Math.min(minBeyondAbs, -Math.min(xVal.hi, -lastExtremum));
+    if (Number.isFinite(minBeyondAbs) && minBeyondAbs > 0) {
+      update(1 / minBeyondAbs);
+      update(-1 / minBeyondAbs);
     }
     return ok({ lo, hi });
   }
@@ -13747,8 +14058,21 @@ var Interval = (() => {
       if (e >= xVal.lo && e <= xVal.hi) update(fresnelS(e));
       if (-e >= xVal.lo && -e <= xVal.hi) update(fresnelS(-e));
     }
+    fresnelConvergenceBound(xVal, FRESNEL_S_EXTREMA, fresnelS, update);
     return ok({ lo, hi });
   }
+  function fresnelConvergenceBound(xVal, extrema, scalar, update) {
+    const lastE = extrema[extrema.length - 1];
+    const amp = Math.abs(scalar(lastE) - 0.5);
+    if (xVal.hi > lastE) {
+      update(0.5 + amp);
+      update(0.5 - amp);
+    }
+    if (xVal.lo < -lastE) {
+      update(-0.5 - amp);
+      update(-0.5 + amp);
+    }
+  }
   function fresnelC2(x) {
     const unwrapped = unwrapOrPropagate(x);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -13765,6 +14089,7 @@ var Interval = (() => {
       if (e >= xVal.lo && e <= xVal.hi) update(fresnelC(e));
       if (-e >= xVal.lo && -e <= xVal.hi) update(fresnelC(-e));
     }
+    fresnelConvergenceBound(xVal, FRESNEL_C_EXTREMA, fresnelC, update);
     return ok({ lo, hi });
   }
 
@@ -13872,11 +14197,9 @@ var Interval = (() => {
     const unwrapped = unwrapOrPropagate(x, lo, hi);
     if (!Array.isArray(unwrapped)) return unwrapped;
     const [xVal, loVal, hiVal] = unwrapped;
-    const resultLo = Math.max(xVal.lo, loVal.lo);
-    const resultHi = Math.min(xVal.hi, hiVal.hi);
-    if (resultLo > resultHi) {
-      return { kind: "empty" };
-    }
+    const lowered = { lo: Math.max(xVal.lo, loVal.lo), hi: Math.max(xVal.hi, loVal.hi) };
+    const resultLo = Math.min(lowered.lo, hiVal.lo);
+    const resultHi = Math.min(lowered.hi, hiVal.hi);
     return { kind: "interval", value: { lo: resultLo, hi: resultHi } };
   }
 
@@ -13982,7 +14305,7 @@ var Interval = (() => {
   };
 
   // src/interval.ts
-  var version = "0.58.0";
+  var version = "0.59.0";
   return __toCommonJS(interval_exports);
 })();
 /*! Bundled license information: