@cortex-js/compute-engine 0.35.0 → 0.35.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.0 */
+/** Compute Engine 0.35.1 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -20105,6 +20105,14 @@ var init_base_compiler = __esm({
           return `return ${_BaseCompiler.compile(args[0], target)}`;
         if (h === "If") {
           if (args.length !== 3) throw new Error("If: wrong number of arguments");
+          const fn2 = target.functions?.(h);
+          if (fn2) {
+            if (typeof fn2 === "function") {
+              return fn2(args, (expr) => _BaseCompiler.compile(expr, target), target);
+            }
+            if (args === null) return `${fn2}()`;
+            return `${fn2}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
+          }
           return `((${_BaseCompiler.compile(args[0], target)}) ? (${_BaseCompiler.compile(
             args[1],
             target
@@ -52265,49 +52273,64 @@ function intPow2(base, n) {
   return { lo: Math.pow(base.lo, n), hi: Math.pow(base.hi, n) };
 }
 function pow3(base, exp3) {
+  const unwrapped = unwrapOrPropagate(base);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [baseVal] = unwrapped;
   if (Number.isInteger(exp3)) {
     if (exp3 >= 0) {
-      return ok(intPow2(base, exp3));
+      return ok(intPow2(baseVal, exp3));
     } else {
-      if (containsZero(base)) {
+      if (containsZero(baseVal)) {
         return { kind: "singular" };
       }
-      const denom = intPow2(base, -exp3);
+      const denom = intPow2(baseVal, -exp3);
       return ok({ lo: 1 / denom.hi, hi: 1 / denom.lo });
     }
   } else {
-    if (isNegative(base)) {
+    if (isNegative(baseVal)) {
       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 };
+    if (baseVal.lo < 0) {
+      const value = exp3 > 0 ? { lo: 0, hi: Math.pow(baseVal.hi, exp3) } : { lo: Math.pow(baseVal.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) });
+      return ok({
+        lo: Math.pow(baseVal.lo, exp3),
+        hi: Math.pow(baseVal.hi, exp3)
+      });
     } else {
-      if (base.lo === 0) {
+      if (baseVal.lo === 0) {
         return {
           kind: "partial",
-          value: { lo: Math.pow(base.hi, exp3), hi: Infinity },
+          value: { lo: Math.pow(baseVal.hi, exp3), hi: Infinity },
           domainClipped: "hi"
         };
       }
-      return ok({ lo: Math.pow(base.hi, exp3), hi: Math.pow(base.lo, exp3) });
+      return ok({
+        lo: Math.pow(baseVal.hi, exp3),
+        hi: Math.pow(baseVal.lo, exp3)
+      });
     }
   }
 }
 function powInterval(base, exp3) {
-  if (base.hi <= 0) {
+  const unwrapped = unwrapOrPropagate(base, exp3);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [baseVal, expVal] = unwrapped;
+  if (baseVal.hi <= 0) {
     return { kind: "empty" };
   }
-  if (base.lo <= 0) {
-    const posBase = { lo: Math.max(base.lo, Number.EPSILON), hi: base.hi };
+  if (baseVal.lo <= 0) {
+    const posBase = {
+      lo: Math.max(baseVal.lo, Number.EPSILON),
+      hi: baseVal.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)
+      Math.pow(posBase.lo, expVal.lo),
+      Math.pow(posBase.lo, expVal.hi),
+      Math.pow(posBase.hi, expVal.lo),
+      Math.pow(posBase.hi, expVal.hi)
     ];
     return {
       kind: "partial",
@@ -52316,10 +52339,10 @@ function powInterval(base, exp3) {
     };
   }
   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)
+    Math.pow(baseVal.lo, expVal.lo),
+    Math.pow(baseVal.lo, expVal.hi),
+    Math.pow(baseVal.hi, expVal.lo),
+    Math.pow(baseVal.hi, expVal.hi)
   ];
   return ok({ lo: Math.min(...corners), hi: Math.max(...corners) });
 }
@@ -52330,79 +52353,115 @@ function exp2(x) {
   return ok({ lo: Math.exp(xVal.lo), hi: Math.exp(xVal.hi) });
 }
 function ln2(x) {
-  if (x.hi <= 0) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi <= 0) {
     return { kind: "empty" };
   }
-  if (x.lo > 0) {
-    return ok({ lo: Math.log(x.lo), hi: Math.log(x.hi) });
+  if (xVal.lo > 0) {
+    return ok({ lo: Math.log(xVal.lo), hi: Math.log(xVal.hi) });
   }
   return {
     kind: "partial",
-    value: { lo: -Infinity, hi: Math.log(x.hi) },
+    value: { lo: -Infinity, hi: Math.log(xVal.hi) },
     domainClipped: "lo"
   };
 }
 function log102(x) {
-  if (x.hi <= 0) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi <= 0) {
     return { kind: "empty" };
   }
-  if (x.lo > 0) {
-    return ok({ lo: Math.log10(x.lo), hi: Math.log10(x.hi) });
+  if (xVal.lo > 0) {
+    return ok({ lo: Math.log10(xVal.lo), hi: Math.log10(xVal.hi) });
   }
   return {
     kind: "partial",
-    value: { lo: -Infinity, hi: Math.log10(x.hi) },
+    value: { lo: -Infinity, hi: Math.log10(xVal.hi) },
     domainClipped: "lo"
   };
 }
 function log22(x) {
-  if (x.hi <= 0) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi <= 0) {
     return { kind: "empty" };
   }
-  if (x.lo > 0) {
-    return ok({ lo: Math.log2(x.lo), hi: Math.log2(x.hi) });
+  if (xVal.lo > 0) {
+    return ok({ lo: Math.log2(xVal.lo), hi: Math.log2(xVal.hi) });
   }
   return {
     kind: "partial",
-    value: { lo: -Infinity, hi: Math.log2(x.hi) },
+    value: { lo: -Infinity, hi: Math.log2(xVal.hi) },
     domainClipped: "lo"
   };
 }
 function abs2(x) {
-  if (x.lo >= 0) {
-    return ok(x);
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo >= 0) {
+    return ok(xVal);
   }
-  if (x.hi <= 0) {
-    return ok({ lo: -x.hi, hi: -x.lo });
+  if (xVal.hi <= 0) {
+    return ok({ lo: -xVal.hi, hi: -xVal.lo });
   }
-  return ok({ lo: 0, hi: Math.max(-x.lo, x.hi) });
+  return ok({ lo: 0, hi: Math.max(-xVal.lo, xVal.hi) });
 }
 function floor2(x) {
-  return ok({ lo: Math.floor(x.lo), hi: Math.floor(x.hi) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.floor(xVal.lo), hi: Math.floor(xVal.hi) });
 }
 function ceil2(x) {
-  return ok({ lo: Math.ceil(x.lo), hi: Math.ceil(x.hi) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.ceil(xVal.lo), hi: Math.ceil(xVal.hi) });
 }
 function round2(x) {
-  return ok({ lo: Math.round(x.lo), hi: Math.round(x.hi) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.round(xVal.lo), hi: Math.round(xVal.hi) });
 }
 function min2(a, b) {
-  return ok({ lo: Math.min(a.lo, b.lo), hi: Math.min(a.hi, b.hi) });
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  return ok({
+    lo: Math.min(aVal.lo, bVal.lo),
+    hi: Math.min(aVal.hi, bVal.hi)
+  });
 }
 function max2(a, b) {
-  return ok({ lo: Math.max(a.lo, b.lo), hi: Math.max(a.hi, b.hi) });
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  return ok({
+    lo: Math.max(aVal.lo, bVal.lo),
+    hi: Math.max(aVal.hi, bVal.hi)
+  });
 }
 function mod2(a, b) {
-  if (containsZero(b)) {
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [aVal, bVal] = unwrapped;
+  if (containsZero(bVal)) {
     return { kind: "singular" };
   }
-  const bAbs = Math.max(Math.abs(b.lo), Math.abs(b.hi));
-  const aWidth = a.hi - a.lo;
+  const bAbs = Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi));
+  const aWidth = aVal.hi - aVal.lo;
   if (aWidth >= bAbs) {
     return ok({ lo: 0, hi: bAbs });
   }
-  const modLo = (a.lo % bAbs + bAbs) % bAbs;
-  const modHi = (a.hi % bAbs + bAbs) % bAbs;
+  const modLo = (aVal.lo % bAbs + bAbs) % bAbs;
+  const modHi = (aVal.hi % bAbs + bAbs) % bAbs;
   if (modLo <= modHi) {
     return ok({ lo: modLo, hi: modHi });
   } else {
@@ -52410,11 +52469,14 @@ function mod2(a, b) {
   }
 }
 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 });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo > 0) return ok({ lo: 1, hi: 1 });
+  if (xVal.hi < 0) return ok({ lo: -1, hi: -1 });
+  if (xVal.lo === 0 && xVal.hi === 0) return ok({ lo: 0, hi: 0 });
+  if (xVal.lo < 0 && xVal.hi > 0) return ok({ lo: -1, hi: 1 });
+  if (xVal.lo === 0) return ok({ lo: 0, hi: 1 });
   return ok({ lo: -1, hi: 0 });
 }
 
@@ -52424,231 +52486,298 @@ 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) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi - xVal.lo >= TWO_PI) {
     return ok({ lo: -1, hi: 1 });
   }
-  const sinLo = Math.sin(x.lo);
-  const sinHi = Math.sin(x.hi);
+  const sinLo = Math.sin(xVal.lo);
+  const sinHi = Math.sin(xVal.hi);
   let lo = Math.min(sinLo, sinHi);
   let hi = Math.max(sinLo, sinHi);
-  if (containsExtremum(x, HALF_PI, TWO_PI)) {
+  if (containsExtremum(xVal, HALF_PI, TWO_PI)) {
     hi = 1;
   }
-  if (containsExtremum(x, THREE_HALF_PI, TWO_PI)) {
+  if (containsExtremum(xVal, THREE_HALF_PI, TWO_PI)) {
     lo = -1;
   }
   return ok({ lo, hi });
 }
 function cos2(x) {
-  if (x.hi - x.lo >= TWO_PI) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi - xVal.lo >= TWO_PI) {
     return ok({ lo: -1, hi: 1 });
   }
-  const cosLo = Math.cos(x.lo);
-  const cosHi = Math.cos(x.hi);
+  const cosLo = Math.cos(xVal.lo);
+  const cosHi = Math.cos(xVal.hi);
   let lo = Math.min(cosLo, cosHi);
   let hi = Math.max(cosLo, cosHi);
-  if (containsExtremum(x, 0, TWO_PI)) {
+  if (containsExtremum(xVal, 0, TWO_PI)) {
     hi = 1;
   }
-  if (containsExtremum(x, PI2, TWO_PI)) {
+  if (containsExtremum(xVal, PI2, TWO_PI)) {
     lo = -1;
   }
   return ok({ lo, hi });
 }
 function tan2(x) {
-  if (x.hi - x.lo >= PI2) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi - xVal.lo >= PI2) {
     return { kind: "singular" };
   }
-  if (containsExtremum(x, HALF_PI, PI2)) {
-    const n = Math.ceil((x.lo - HALF_PI) / PI2);
+  if (containsExtremum(xVal, HALF_PI, PI2)) {
+    const n = Math.ceil((xVal.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);
+  const tanLo = Math.tan(xVal.lo);
+  const tanHi = Math.tan(xVal.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) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi - xVal.lo >= PI2) {
     return { kind: "singular" };
   }
-  if (containsExtremum(x, 0, PI2)) {
-    const n = Math.ceil(x.lo / PI2);
+  if (containsExtremum(xVal, 0, PI2)) {
+    const n = Math.ceil(xVal.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);
+  const cotLo = 1 / Math.tan(xVal.lo);
+  const cotHi = 1 / Math.tan(xVal.hi);
   return ok({ lo: Math.min(cotLo, cotHi), hi: Math.max(cotLo, cotHi) });
 }
 function sec(x) {
-  if (x.hi - x.lo >= PI2) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi - xVal.lo >= PI2) {
     return { kind: "singular" };
   }
-  if (containsExtremum(x, HALF_PI, PI2)) {
-    const n = Math.ceil((x.lo - HALF_PI) / PI2);
+  if (containsExtremum(xVal, HALF_PI, PI2)) {
+    const n = Math.ceil((xVal.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);
+  const secLo = 1 / Math.cos(xVal.lo);
+  const secHi = 1 / Math.cos(xVal.hi);
   let lo = Math.min(secLo, secHi);
   let hi = Math.max(secLo, secHi);
-  if (containsExtremum(x, 0, TWO_PI)) {
+  if (containsExtremum(xVal, 0, TWO_PI)) {
     lo = Math.min(lo, 1);
     hi = Math.max(hi, 1);
   }
-  if (containsExtremum(x, PI2, TWO_PI)) {
+  if (containsExtremum(xVal, 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) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi - xVal.lo >= PI2) {
     return { kind: "singular" };
   }
-  if (containsExtremum(x, 0, PI2)) {
-    const n = Math.ceil(x.lo / PI2);
+  if (containsExtremum(xVal, 0, PI2)) {
+    const n = Math.ceil(xVal.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);
+  const cscLo = 1 / Math.sin(xVal.lo);
+  const cscHi = 1 / Math.sin(xVal.hi);
   let lo = Math.min(cscLo, cscHi);
   let hi = Math.max(cscLo, cscHi);
-  if (containsExtremum(x, HALF_PI, TWO_PI)) {
+  if (containsExtremum(xVal, HALF_PI, TWO_PI)) {
     lo = Math.min(lo, 1);
     hi = Math.max(hi, 1);
   }
-  if (containsExtremum(x, THREE_HALF_PI, TWO_PI)) {
+  if (containsExtremum(xVal, 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) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo > 1 || xVal.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);
+  if (xVal.lo < -1 || xVal.hi > 1) {
+    const clippedLo = Math.max(xVal.lo, -1);
+    const clippedHi = Math.min(xVal.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"
+      domainClipped: xVal.lo < -1 && xVal.hi > 1 ? "both" : xVal.lo < -1 ? "lo" : "hi"
     };
   }
-  return ok({ lo: Math.asin(x.lo), hi: Math.asin(x.hi) });
+  return ok({ lo: Math.asin(xVal.lo), hi: Math.asin(xVal.hi) });
 }
 function acos2(x) {
-  if (x.lo > 1 || x.hi < -1) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo > 1 || xVal.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);
+  if (xVal.lo < -1 || xVal.hi > 1) {
+    const clippedLo = Math.max(xVal.lo, -1);
+    const clippedHi = Math.min(xVal.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"
+      domainClipped: xVal.lo < -1 && xVal.hi > 1 ? "both" : xVal.lo < -1 ? "lo" : "hi"
     };
   }
-  return ok({ lo: Math.acos(x.hi), hi: Math.acos(x.lo) });
+  return ok({ lo: Math.acos(xVal.hi), hi: Math.acos(xVal.lo) });
 }
 function atan3(x) {
-  return ok({ lo: Math.atan(x.lo), hi: Math.atan(x.hi) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.atan(xVal.lo), hi: Math.atan(xVal.hi) });
 }
 function atan22(y, x) {
-  if (y.lo === y.hi && x.lo === x.hi) {
-    const result = Math.atan2(y.lo, x.lo);
+  const unwrapped = unwrapOrPropagate(y, x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [yVal, xVal] = unwrapped;
+  if (yVal.lo === yVal.hi && xVal.lo === xVal.hi) {
+    const result = Math.atan2(yVal.lo, xVal.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) {
+  angles.push(Math.atan2(yVal.lo, xVal.lo));
+  angles.push(Math.atan2(yVal.lo, xVal.hi));
+  angles.push(Math.atan2(yVal.hi, xVal.lo));
+  angles.push(Math.atan2(yVal.hi, xVal.hi));
+  if (xVal.lo < 0 && yVal.lo < 0 && yVal.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) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.sinh(xVal.lo), hi: Math.sinh(xVal.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) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo >= 0) {
+    return ok({ lo: Math.cosh(xVal.lo), hi: Math.cosh(xVal.hi) });
+  } else if (xVal.hi <= 0) {
+    return ok({ lo: Math.cosh(xVal.hi), hi: Math.cosh(xVal.lo) });
   } else {
-    return ok({ lo: 1, hi: Math.max(Math.cosh(x.lo), Math.cosh(x.hi)) });
+    return ok({
+      lo: 1,
+      hi: Math.max(Math.cosh(xVal.lo), Math.cosh(xVal.hi))
+    });
   }
 }
 function tanh2(x) {
-  return ok({ lo: Math.tanh(x.lo), hi: Math.tanh(x.hi) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.tanh(xVal.lo), hi: Math.tanh(xVal.hi) });
 }
 function asinh2(x) {
-  return ok({ lo: Math.asinh(x.lo), hi: Math.asinh(x.hi) });
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  return ok({ lo: Math.asinh(xVal.lo), hi: Math.asinh(xVal.hi) });
 }
 function acosh2(x) {
-  if (x.hi < 1) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.hi < 1) {
     return { kind: "empty" };
   }
-  if (x.lo < 1) {
+  if (xVal.lo < 1) {
     return {
       kind: "partial",
-      value: { lo: 0, hi: Math.acosh(x.hi) },
+      value: { lo: 0, hi: Math.acosh(xVal.hi) },
       domainClipped: "lo"
     };
   }
-  return ok({ lo: Math.acosh(x.lo), hi: Math.acosh(x.hi) });
+  return ok({ lo: Math.acosh(xVal.lo), hi: Math.acosh(xVal.hi) });
 }
 function atanh2(x) {
-  if (x.lo >= 1 || x.hi <= -1) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  if (xVal.lo >= 1 || xVal.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);
+  if (xVal.lo <= -1 || xVal.hi >= 1) {
+    const clippedLo = Math.max(xVal.lo, -1 + Number.EPSILON);
+    const clippedHi = Math.min(xVal.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"
+      domainClipped: xVal.lo <= -1 && xVal.hi >= 1 ? "both" : xVal.lo <= -1 ? "lo" : "hi"
     };
   }
-  return ok({ lo: Math.atanh(x.lo), hi: Math.atanh(x.hi) });
+  return ok({ lo: Math.atanh(xVal.lo), hi: Math.atanh(xVal.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";
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return "maybe";
+  const [aVal, bVal] = unwrapped;
+  if (aVal.hi < bVal.lo) return "true";
+  if (aVal.lo >= bVal.hi) return "false";
   return "maybe";
 }
 function lessEqual(a, b) {
-  if (a.hi <= b.lo) return "true";
-  if (a.lo > b.hi) return "false";
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return "maybe";
+  const [aVal, bVal] = unwrapped;
+  if (aVal.hi <= bVal.lo) return "true";
+  if (aVal.lo > bVal.hi) return "false";
   return "maybe";
 }
 function greater(a, b) {
-  if (a.lo > b.hi) return "true";
-  if (a.hi <= b.lo) return "false";
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return "maybe";
+  const [aVal, bVal] = unwrapped;
+  if (aVal.lo > bVal.hi) return "true";
+  if (aVal.hi <= bVal.lo) return "false";
   return "maybe";
 }
 function greaterEqual(a, b) {
-  if (a.lo >= b.hi) return "true";
-  if (a.hi < b.lo) return "false";
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return "maybe";
+  const [aVal, bVal] = unwrapped;
+  if (aVal.lo >= bVal.hi) return "true";
+  if (aVal.hi < bVal.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";
+  const unwrapped = unwrapOrPropagate(a, b);
+  if (!Array.isArray(unwrapped)) return "maybe";
+  const [aVal, bVal] = unwrapped;
+  if (aVal.lo === aVal.hi && bVal.lo === bVal.hi && aVal.lo === bVal.lo)
+    return "true";
+  if (aVal.hi < bVal.lo || bVal.hi < aVal.lo) return "false";
   return "maybe";
 }
 function notEqual(a, b) {
@@ -52672,22 +52801,45 @@ function not(a) {
   if (a === "false") return "true";
   return "maybe";
 }
-function piecewise(x, condition, trueBranch, falseBranch) {
-  const cond = condition(x);
+function piecewise(xOrCond, conditionOrTrue, trueOrFalse, falseBranch) {
+  if (xOrCond === "true" || xOrCond === "false" || xOrCond === "maybe") {
+    const cond2 = xOrCond;
+    const trueBranch2 = conditionOrTrue;
+    const falseBranchFn2 = trueOrFalse;
+    switch (cond2) {
+      case "true":
+        return trueBranch2();
+      case "false":
+        return falseBranchFn2();
+      case "maybe":
+        return unionResults(trueBranch2(), falseBranchFn2());
+    }
+  }
+  const x = xOrCond;
+  const condition = conditionOrTrue;
+  const trueBranch = trueOrFalse;
+  const falseBranchFn = falseBranch;
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  const cond = condition(xVal);
   switch (cond) {
     case "true":
-      return trueBranch(x);
+      return trueBranch(xVal);
     case "false":
-      return falseBranch(x);
+      return falseBranchFn(xVal);
     case "maybe":
-      const t = trueBranch(x);
-      const f = falseBranch(x);
+      const t = trueBranch(xVal);
+      const f = falseBranchFn(xVal);
       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);
+  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" };
   }
@@ -52915,11 +53067,20 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
     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])}
+      () => ${compile(args[1])},
+      () => ${compile(args[2])}
     )`;
-  }
+  },
+  // Comparisons
+  Equal: (args, compile) => `_IA.equal(${compile(args[0])}, ${compile(args[1])})`,
+  NotEqual: (args, compile) => `_IA.notEqual(${compile(args[0])}, ${compile(args[1])})`,
+  LessEqual: (args, compile) => `_IA.lessEqual(${compile(args[0])}, ${compile(args[1])})`,
+  GreaterEqual: (args, compile) => `_IA.greaterEqual(${compile(args[0])}, ${compile(args[1])})`,
+  Less: (args, compile) => `_IA.less(${compile(args[0])}, ${compile(args[1])})`,
+  Greater: (args, compile) => `_IA.greater(${compile(args[0])}, ${compile(args[1])})`,
+  And: (args, compile) => `_IA.and(${compile(args[0])}, ${compile(args[1])})`,
+  Or: (args, compile) => `_IA.or(${compile(args[0])}, ${compile(args[1])})`,
+  Not: (args, compile) => `_IA.not(${compile(args[0])})`
 };
 var ComputeEngineIntervalFunction = class extends Function {
   IA = IntervalArithmetic;
@@ -53097,6 +53258,10 @@ IntervalResult ia_partial(vec2 v, float clip) {
   return IntervalResult(v, clip);
 }
 
+bool ia_is_error(float status) {
+  return status == IA_EMPTY || status == IA_ENTIRE || status == IA_SINGULAR;
+}
+
 // Addition
 IntervalResult ia_add(vec2 a, vec2 b) {
   return ia_ok(vec2(a.x + b.x - IA_EPS, a.y + b.y + IA_EPS));
@@ -53412,6 +53577,198 @@ IntervalResult ia_cosh(vec2 x) {
 IntervalResult ia_tanh(vec2 x) {
   return ia_ok(vec2(tanh(x.x) - IA_EPS, tanh(x.y) + IA_EPS));
 }
+
+// IntervalResult overloads for propagation
+IntervalResult ia_add(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_add(a.value, b.value);
+}
+
+IntervalResult ia_add(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_add(a.value, b);
+}
+
+IntervalResult ia_add(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_add(a, b.value);
+}
+
+IntervalResult ia_sub(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_sub(a.value, b.value);
+}
+
+IntervalResult ia_sub(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_sub(a.value, b);
+}
+
+IntervalResult ia_sub(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_sub(a, b.value);
+}
+
+IntervalResult ia_mul(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_mul(a.value, b.value);
+}
+
+IntervalResult ia_mul(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_mul(a.value, b);
+}
+
+IntervalResult ia_mul(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_mul(a, b.value);
+}
+
+IntervalResult ia_div(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_div(a.value, b.value);
+}
+
+IntervalResult ia_div(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_div(a.value, b);
+}
+
+IntervalResult ia_div(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_div(a, b.value);
+}
+
+IntervalResult ia_negate(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_negate(x.value);
+}
+
+IntervalResult ia_sqrt(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sqrt(x.value);
+}
+
+IntervalResult ia_square(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_square(x.value);
+}
+
+IntervalResult ia_exp(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_exp(x.value);
+}
+
+IntervalResult ia_ln(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_ln(x.value);
+}
+
+IntervalResult ia_abs(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_abs(x.value);
+}
+
+IntervalResult ia_sign(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sign(x.value);
+}
+
+IntervalResult ia_floor(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_floor(x.value);
+}
+
+IntervalResult ia_ceil(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_ceil(x.value);
+}
+
+IntervalResult ia_min(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_min(a.value, b.value);
+}
+
+IntervalResult ia_min(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_min(a.value, b);
+}
+
+IntervalResult ia_min(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_min(a, b.value);
+}
+
+IntervalResult ia_max(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_max(a.value, b.value);
+}
+
+IntervalResult ia_max(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_max(a.value, b);
+}
+
+IntervalResult ia_max(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_max(a, b.value);
+}
+
+IntervalResult ia_pow(IntervalResult base, float exp) {
+  if (ia_is_error(base.status)) return base;
+  return ia_pow(base.value, exp);
+}
+
+IntervalResult ia_sin(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sin(x.value);
+}
+
+IntervalResult ia_cos(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_cos(x.value);
+}
+
+IntervalResult ia_tan(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_tan(x.value);
+}
+
+IntervalResult ia_asin(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_asin(x.value);
+}
+
+IntervalResult ia_acos(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acos(x.value);
+}
+
+IntervalResult ia_atan(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_atan(x.value);
+}
+
+IntervalResult ia_sinh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sinh(x.value);
+}
+
+IntervalResult ia_cosh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_cosh(x.value);
+}
+
+IntervalResult ia_tanh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_tanh(x.value);
+}
 `;
 var INTERVAL_GLSL_OPERATORS = {
   Add: ["ia_add", 20],
@@ -55408,10 +55765,10 @@ function defToString(name, def, v) {
 // src/compute-engine.ts
 init_types6();
 init_base_compiler();
-var version = "0.35.0";
+var version = "0.35.1";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.35.0"
+  version: "0.35.1"
 };
 export {
   BaseCompiler,