@cortex-js/compute-engine 0.55.5 → 0.55.6

package/dist/compile.umd.cjs

@@ -1,4 +1,4 @@
-/** Compile 0.55.5 */
+/** Compile 0.55.6 */
     (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.Compile = {}));})(this, (function (exports) { 'use strict';
 var Compile = (() => {
   var __defProp = Object.defineProperty;
@@ -6273,10 +6273,6 @@ var Compile = (() => {
     // Lagrange notation
     {
       name: "Derivative",
-      // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
-      // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
-      // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
-      // Newton notation (\dot{v}, \ddot{v}) is implemented below
       serialize: (serializer, expr) => {
         const degree = machineValue(operand(expr, 2)) ?? 1;
         const base = serializer.serialize(operand(expr, 1));
@@ -7314,14 +7310,18 @@ var Compile = (() => {
         return ["Complement", lhs];
       }
       // precedence: 240,
-      // @todo: serialize for the multiple argument case
     },
     {
       name: "Complement",
       latexTrigger: ["^", "<{>", "\\complement", "<}>"],
-      kind: "postfix"
+      kind: "postfix",
       // precedence: 240,
-      // @todo: serialize for the multiple argument case
+      serialize: (serializer, expr) => {
+        return joinLatex([
+          serializer.serialize(operand(expr, 1)),
+          "^\\complement"
+        ]);
+      }
     },
     {
       name: "Intersection",
@@ -7408,7 +7408,6 @@ var Compile = (() => {
     // commands like \rbrack a, b \rbrack which are unambiguous.
     {
       name: "Multiple",
-      // @todo: parse
       serialize: serializeSet
     },
     {
@@ -7417,14 +7416,28 @@ var Compile = (() => {
       kind: "infix",
       precedence: 350
     },
+    // \mid as a separator/operator (used in set-builder notation: {x \mid x > 0})
+    // Low precedence so it binds loosely — everything on each side is parsed first
+    {
+      name: "Divides",
+      latexTrigger: ["\\mid"],
+      kind: "infix",
+      precedence: 160
+    },
     {
       name: "Set",
       kind: "matchfix",
       openTrigger: "{",
       closeTrigger: "}",
-      // @todo: the set syntax can also include conditions...
       parse: (_parser, body) => {
         if (isEmptySequence(body)) return "EmptySet";
+        const h = operator(body);
+        if (h === "Divides" || h === "Colon") {
+          const expr = operand(body, 1);
+          const condition = operand(body, 2);
+          if (expr !== null && condition !== null)
+            return ["Set", expr, ["Condition", condition]];
+        }
         if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
           body = operand(body, 1);
         }
@@ -7432,6 +7445,17 @@ var Compile = (() => {
         return ["Set", ...operands(body)];
       },
       serialize: (serializer, expr) => {
+        if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
+          const condition = operand(expr, 2);
+          return joinLatex([
+            "\\lbrace",
+            serializer.serialize(operand(expr, 1)),
+            "\\mid",
+            // Serialize the inner expression of the Condition wrapper
+            serializer.serialize(operand(condition, 1)),
+            "\\rbrace"
+          ]);
+        }
         return joinLatex([
           "\\lbrace",
           operands(expr).map((x) => serializer.serialize(x)).join(", "),
@@ -7598,23 +7622,6 @@ var Compile = (() => {
     if (expr === null) return "";
     const h = operator(expr);
     if (!h) return "";
-    if (h === "Set") {
-      if (nops(expr) === 0) return "\\emptyset";
-      if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
-        return joinLatex([
-          "\\left\\lbrace",
-          serializer.serialize(operand(expr, 1)),
-          "\\middle\\mid",
-          serializer.serialize(operand(expr, 2)),
-          "\\right\\rbrace"
-        ]);
-      }
-      return joinLatex([
-        "\\left\\lbrace",
-        ...operands(expr).map((x) => serializer.serialize(x) + " ,"),
-        "\\right\\rbrace"
-      ]);
-    }
     if (h === "Multiple") {
     }
     if (h === "Range") {
@@ -8732,11 +8739,13 @@ var Compile = (() => {
         if (!parser.match("_")) return null;
         const base = parser.parseGroup();
         if (operator(base) !== "To") return null;
-        const expr = parser.parseArguments("implicit");
+        const expr = parser.parseExpression({
+          minPrec: MULTIPLICATION_PRECEDENCE
+        });
         if (!expr) return null;
         return [
           "Limit",
-          ["Function", expr[0], operand(base, 1)],
+          ["Function", expr, operand(base, 1)],
           operand(base, 2)
         ];
       },
@@ -10940,12 +10949,52 @@ var Compile = (() => {
   ];
 
   // src/compute-engine/latex-syntax/dictionary/definitions-other.ts
+  var TEX_UNITS = [
+    "pt",
+    "em",
+    "mu",
+    "ex",
+    "mm",
+    "cm",
+    "in",
+    "bp",
+    "sp",
+    "dd",
+    "cc",
+    "pc",
+    "nc",
+    "nd"
+  ];
+  function skipTexDimension(parser) {
+    parser.skipSpace();
+    if (parser.peek === "-" || parser.peek === "+") parser.nextToken();
+    while (/^[\d.]$/.test(parser.peek)) parser.nextToken();
+    for (const unit of TEX_UNITS) {
+      if (parser.matchAll([...unit])) return;
+    }
+  }
   function parseSingleArg(cmd) {
     return (parser) => {
       const arg = parser.parseGroup();
       return arg === null ? [cmd] : [cmd, arg];
     };
   }
+  function parseMathStyleSwitch(mathStyle) {
+    return (parser) => {
+      const body = parser.parseExpression();
+      if (body !== null && !isEmptySequence(body))
+        return ["Annotated", body, { dict: { mathStyle } }];
+      return "Nothing";
+    };
+  }
+  function parseSizeSwitch(size) {
+    return (parser) => {
+      const body = parser.parseExpression();
+      if (body !== null && !isEmptySequence(body))
+        return ["Annotated", body, { dict: { size } }];
+      return "Nothing";
+    };
+  }
   var DEFINITIONS_OTHERS = [
     {
       name: "Overscript",
@@ -11185,80 +11234,71 @@ var Compile = (() => {
     },
     {
       latexTrigger: ["\\displaystyle"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseMathStyleSwitch("normal")
     },
     {
       latexTrigger: ["\\textstyle"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseMathStyleSwitch("compact")
     },
     {
       latexTrigger: ["\\scriptstyle"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseMathStyleSwitch("script")
     },
     {
       latexTrigger: ["\\scriptscriptstyle"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseMathStyleSwitch("scriptscript")
     },
     {
       latexTrigger: ["\\color"],
       parse: (parser) => {
-        parser.parseGroup();
+        const color = parser.parseStringGroup();
+        if (color !== null) {
+          const body = parser.parseExpression();
+          if (body !== null && !isEmptySequence(body))
+            return ["Annotated", body, { dict: { color } }];
+        }
         return "Nothing";
       }
     },
     {
       latexTrigger: ["\\tiny"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(1)
     },
     {
       latexTrigger: ["\\scriptsize"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(2)
     },
     {
       latexTrigger: ["\\footnotesize"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(3)
     },
     {
       latexTrigger: ["\\small"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(4)
     },
     {
       latexTrigger: ["\\normalsize"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(5)
     },
     {
       latexTrigger: ["\\large"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(6)
     },
     {
       latexTrigger: ["\\Large"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(7)
     },
     {
       latexTrigger: ["\\LARGE"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(8)
     },
     {
       latexTrigger: ["\\huge"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(9)
     },
     {
       latexTrigger: ["\\Huge"],
-      parse: () => "Nothing"
-      // @todo: parse as ['Annotated'...]
+      parse: parseSizeSwitch(10)
     },
     {
       name: "Annotated",
@@ -11270,6 +11310,10 @@ var Compile = (() => {
           result = joinLatex(["{\\displaystyle", result, "}"]);
         else if (dict.dict.mathStyle === "compact")
           result = joinLatex(["{\\textstyle", result, "}"]);
+        else if (dict.dict.mathStyle === "script")
+          result = joinLatex(["{\\scriptstyle", result, "}"]);
+        else if (dict.dict.mathStyle === "scriptscript")
+          result = joinLatex(["{\\scriptscriptstyle", result, "}"]);
         const v = dict.dict.size;
         if (v !== null && v >= 1 && v <= 10) {
           result = joinLatex([
@@ -11357,6 +11401,28 @@ var Compile = (() => {
       latexTrigger: ["\\enspace"],
       parse: () => ["HorizontalSpacing", 9]
     },
+    {
+      latexTrigger: ["\\hspace"],
+      parse: (parser) => {
+        if (parser.peek === "*") parser.nextToken();
+        parser.parseStringGroup();
+        return ["HorizontalSpacing", 0];
+      }
+    },
+    {
+      latexTrigger: ["\\hskip"],
+      parse: (parser) => {
+        skipTexDimension(parser);
+        return ["HorizontalSpacing", 0];
+      }
+    },
+    {
+      latexTrigger: ["\\kern"],
+      parse: (parser) => {
+        skipTexDimension(parser);
+        return ["HorizontalSpacing", 0];
+      }
+    },
     {
       latexTrigger: ["\\phantom"],
       parse: (parser) => {
@@ -11407,7 +11473,17 @@ var Compile = (() => {
       // `["HorizontalSpacing", expr, 'op'|'bin'|rel]` -> indicate a spacing around and expression, i.e. `\mathbin{x}`, etc...
       serialize: (serializer, expr) => {
         if (operand(expr, 2) !== null) {
-          return serializer.serialize(operand(expr, 1));
+          const cls = stringValue(operand(expr, 2));
+          const inner = serializer.serialize(operand(expr, 1));
+          if (cls === "bin") return `\\mathbin{${inner}}`;
+          if (cls === "op") return `\\mathop{${inner}}`;
+          if (cls === "rel") return `\\mathrel{${inner}}`;
+          if (cls === "ord") return `\\mathord{${inner}}`;
+          if (cls === "open") return `\\mathopen{${inner}}`;
+          if (cls === "close") return `\\mathclose{${inner}}`;
+          if (cls === "punct") return `\\mathpunct{${inner}}`;
+          if (cls === "inner") return `\\mathinner{${inner}}`;
+          return inner;
         }
         const v = machineValue(operand(expr, 1));
         if (v === null) return "";
@@ -15099,8 +15175,7 @@ ${lines.join("\n")}`;
         vars: options?.vars,
         imports: options?.imports,
         preamble: options?.preamble,
-        realOnly: options?.realOnly,
-        hints: options?.hints
+        realOnly: options?.realOnly
       });
     } catch (e) {
       if (options?.fallback ?? true) {
@@ -20782,43 +20857,6 @@ ${lines.join("\n")}`;
     return b;
   }
 
-  // src/compute-engine/compilation/fractal-orbit.ts
-  function toBigDecimal(v) {
-    if (typeof v === "object" && "hi" in v)
-      return new BigDecimal(v.hi).add(new BigDecimal(v.lo));
-    return new BigDecimal(v);
-  }
-  function hpToNumber(v) {
-    if (typeof v === "number") return v;
-    if (typeof v === "string") return Number(v);
-    return v.hi + v.lo;
-  }
-  function computeReferenceOrbit(center, maxIter, precision) {
-    const prevPrecision = BigDecimal.precision;
-    BigDecimal.precision = precision;
-    try {
-      const cr = toBigDecimal(center[0]);
-      const ci = toBigDecimal(center[1]);
-      let zr = BigDecimal.ZERO;
-      let zi = BigDecimal.ZERO;
-      const ESCAPE = new BigDecimal(256);
-      const points = [];
-      for (let i = 0; i < maxIter; i++) {
-        points.push(zr.toNumber(), zi.toNumber());
-        const zr2 = zr.mul(zr).toPrecision(precision);
-        const zi2 = zi.mul(zi).toPrecision(precision);
-        const mag2 = zr2.add(zi2);
-        if (mag2.cmp(ESCAPE) > 0) break;
-        const new_zi = zr.mul(zi).toPrecision(precision).mul(2).add(ci);
-        zr = zr2.sub(zi2).add(cr);
-        zi = new_zi;
-      }
-      return new Float32Array(points);
-    } finally {
-      BigDecimal.precision = prevPrecision;
-    }
-  }
-
   // src/compute-engine/compilation/gpu-target.ts
   var GPU_OPERATORS = {
     Add: ["+", 11],
@@ -20902,13 +20940,6 @@ ${lines.join("\n")}`;
     ];
     return lines.join("\n");
   }
-  function selectFractalStrategy(target) {
-    const radius = target.hints?.viewport?.radius;
-    if (radius === void 0) return "single";
-    if (radius > 1e-6) return "single";
-    if (radius > 1e-14) return "double";
-    return "perturbation";
-  }
   var GPU_FUNCTIONS = {
     // Variadic arithmetic (for function-call form, e.g., with vectors)
     Add: (args, compile2, target) => {
@@ -21404,32 +21435,12 @@ ${lines.join("\n")}`;
       if (c === null || maxIter === null)
         throw new Error("Mandelbrot: missing arguments");
       const iterCode = compileIntArg(maxIter, compile2, target);
-      const strategy = selectFractalStrategy(target);
-      if (strategy === "double") {
-        const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
-        return `_fractal_mandelbrot_dp(${dpCoord}, ${iterCode})`;
-      }
-      if (strategy === "perturbation") {
-        const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
-        return `_fractal_mandelbrot_pt(${ptDelta}, ${iterCode})`;
-      }
       return `_fractal_mandelbrot(${compile2(c)}, ${iterCode})`;
     },
     Julia: ([z, c, maxIter], compile2, target) => {
       if (z === null || c === null || maxIter === null)
         throw new Error("Julia: missing arguments");
       const iterCode = compileIntArg(maxIter, compile2, target);
-      const strategy = selectFractalStrategy(target);
-      if (strategy === "double") {
-        const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
-        const cCode = compile2(c);
-        return `_fractal_julia_dp(${dpCoord}, vec4(${cCode}, vec2(0.0)), ${iterCode})`;
-      }
-      if (strategy === "perturbation") {
-        const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
-        const cCode = compile2(c);
-        return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
-      }
       return `_fractal_julia(${compile2(z)}, ${compile2(c)}, ${iterCode})`;
     },
     // Vector/Matrix operations
@@ -22026,232 +22037,6 @@ fn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {
   for (var k2: i32 = 2; k2 <= M; k2 += 2) { norm += 2.0 * vals[k2]; }
   return sgn * vals[n] / norm;
 }
-`;
-  var GPU_DS_ARITHMETIC_PREAMBLE_GLSL = `
-// Split a float into high and low parts for exact multiplication
-vec2 ds_split(float a) {
-  const float SPLIT = 4097.0; // 2^12 + 1
-  float t = SPLIT * a;
-  float hi = t - (t - a);
-  float lo = a - hi;
-  return vec2(hi, lo);
-}
-
-// Create a double-single from a single float
-vec2 ds_from(float a) {
-  return vec2(a, 0.0);
-}
-
-// Error-free addition (Knuth TwoSum)
-vec2 ds_add(vec2 a, vec2 b) {
-  float s = a.x + b.x;
-  float v = s - a.x;
-  float e = (a.x - (s - v)) + (b.x - v);
-  float lo = (a.y + b.y) + e;
-  float hi = s + lo;
-  lo = lo - (hi - s);
-  return vec2(hi, lo);
-}
-
-// Double-single subtraction
-vec2 ds_sub(vec2 a, vec2 b) {
-  return ds_add(a, vec2(-b.x, -b.y));
-}
-
-// Error-free multiplication (Dekker TwoProduct)
-vec2 ds_mul(vec2 a, vec2 b) {
-  float p = a.x * b.x;
-  vec2 sa = ds_split(a.x);
-  vec2 sb = ds_split(b.x);
-  float err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;
-  err += a.x * b.y + a.y * b.x;
-  float hi = p + err;
-  float lo = err - (hi - p);
-  return vec2(hi, lo);
-}
-
-// Optimized self-multiply
-vec2 ds_sqr(vec2 a) {
-  float p = a.x * a.x;
-  vec2 sa = ds_split(a.x);
-  float err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;
-  err += 2.0 * a.x * a.y;
-  float hi = p + err;
-  float lo = err - (hi - p);
-  return vec2(hi, lo);
-}
-
-// Compare magnitude: returns -1, 0, or 1
-float ds_cmp(vec2 a, vec2 b) {
-  float d = a.x - b.x;
-  if (d != 0.0) return sign(d);
-  return sign(a.y - b.y);
-}
-`;
-  var GPU_DS_ARITHMETIC_PREAMBLE_WGSL = `
-fn ds_split(a: f32) -> vec2f {
-  const SPLIT: f32 = 4097.0;
-  let t = SPLIT * a;
-  let hi = t - (t - a);
-  let lo = a - hi;
-  return vec2f(hi, lo);
-}
-
-fn ds_from(a: f32) -> vec2f {
-  return vec2f(a, 0.0);
-}
-
-fn ds_add(a: vec2f, b: vec2f) -> vec2f {
-  let s = a.x + b.x;
-  let v = s - a.x;
-  let e = (a.x - (s - v)) + (b.x - v);
-  let lo_t = (a.y + b.y) + e;
-  let hi = s + lo_t;
-  let lo = lo_t - (hi - s);
-  return vec2f(hi, lo);
-}
-
-fn ds_sub(a: vec2f, b: vec2f) -> vec2f {
-  return ds_add(a, vec2f(-b.x, -b.y));
-}
-
-fn ds_mul(a: vec2f, b: vec2f) -> vec2f {
-  let p = a.x * b.x;
-  let sa = ds_split(a.x);
-  let sb = ds_split(b.x);
-  var err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;
-  err += a.x * b.y + a.y * b.x;
-  let hi = p + err;
-  let lo = err - (hi - p);
-  return vec2f(hi, lo);
-}
-
-fn ds_sqr(a: vec2f) -> vec2f {
-  let p = a.x * a.x;
-  let sa = ds_split(a.x);
-  var err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;
-  err += 2.0 * a.x * a.y;
-  let hi = p + err;
-  let lo = err - (hi - p);
-  return vec2f(hi, lo);
-}
-
-fn ds_cmp(a: vec2f, b: vec2f) -> f32 {
-  let d = a.x - b.x;
-  if (d != 0.0) { return sign(d); }
-  return sign(a.y - b.y);
-}
-`;
-  var GPU_FRACTAL_DP_PREAMBLE_GLSL = `
-uniform float _dp_cx_hi;
-uniform float _dp_cx_lo;
-uniform float _dp_cy_hi;
-uniform float _dp_cy_lo;
-uniform float _dp_w;
-uniform float _dp_h;
-
-vec4 _dp_coord() {
-  // Per-pixel offset from center \u2014 small, so float-precise
-  float dx = (v_uv.x - 0.5) * _dp_w;
-  float dy = (v_uv.y - 0.5) * _dp_h;
-  // Combine center (hi+lo) + delta with emulated double precision
-  vec2 cre = ds_add(vec2(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
-  vec2 cim = ds_add(vec2(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
-  return vec4(cre.x, cim.x, cre.y, cim.y);
-}
-
-float _fractal_mandelbrot_dp(vec4 c, int maxIter) {
-  // c = (re_hi, im_hi, re_lo, im_lo)
-  vec2 cr = vec2(c.x, c.z);  // real part as ds
-  vec2 ci = vec2(c.y, c.w);  // imag part as ds
-  vec2 zr = vec2(0.0, 0.0);
-  vec2 zi = vec2(0.0, 0.0);
-  for (int i = 0; i < maxIter; i++) {
-    vec2 zr2 = ds_sqr(zr);
-    vec2 zi2 = ds_sqr(zi);
-    // |z|^2 > 4.0 ?
-    vec2 mag2 = ds_add(zr2, zi2);
-    if (mag2.x > 4.0)
-      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);
-    // z = z^2 + c
-    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci); // 2*zr*zi + ci
-    zr = ds_add(ds_sub(zr2, zi2), cr);                    // zr^2 - zi^2 + cr
-    zi = new_zi;
-  }
-  return 1.0;
-}
-
-float _fractal_julia_dp(vec4 z_in, vec4 c, int maxIter) {
-  vec2 zr = vec2(z_in.x, z_in.z);
-  vec2 zi = vec2(z_in.y, z_in.w);
-  vec2 cr = vec2(c.x, c.z);
-  vec2 ci = vec2(c.y, c.w);
-  for (int i = 0; i < maxIter; i++) {
-    vec2 zr2 = ds_sqr(zr);
-    vec2 zi2 = ds_sqr(zi);
-    vec2 mag2 = ds_add(zr2, zi2);
-    if (mag2.x > 4.0)
-      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);
-    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
-    zr = ds_add(ds_sub(zr2, zi2), cr);
-    zi = new_zi;
-  }
-  return 1.0;
-}
-`;
-  var GPU_FRACTAL_DP_PREAMBLE_WGSL = `
-@group(0) @binding(10) var<uniform> _dp_cx_hi: f32;
-@group(0) @binding(11) var<uniform> _dp_cx_lo: f32;
-@group(0) @binding(12) var<uniform> _dp_cy_hi: f32;
-@group(0) @binding(13) var<uniform> _dp_cy_lo: f32;
-@group(0) @binding(14) var<uniform> _dp_w: f32;
-@group(0) @binding(15) var<uniform> _dp_h: f32;
-
-fn _dp_coord(uv: vec2f) -> vec4f {
-  let dx = (uv.x - 0.5) * _dp_w;
-  let dy = (uv.y - 0.5) * _dp_h;
-  let cre = ds_add(vec2f(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
-  let cim = ds_add(vec2f(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
-  return vec4f(cre.x, cim.x, cre.y, cim.y);
-}
-
-fn _fractal_mandelbrot_dp(c: vec4f, maxIter: i32) -> f32 {
-  let cr = vec2f(c.x, c.z);
-  let ci = vec2f(c.y, c.w);
-  var zr = vec2f(0.0, 0.0);
-  var zi = vec2f(0.0, 0.0);
-  for (var i: i32 = 0; i < maxIter; i++) {
-    let zr2 = ds_sqr(zr);
-    let zi2 = ds_sqr(zi);
-    let mag2 = ds_add(zr2, zi2);
-    if (mag2.x > 4.0) {
-      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);
-    }
-    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
-    zr = ds_add(ds_sub(zr2, zi2), cr);
-    zi = new_zi;
-  }
-  return 1.0;
-}
-
-fn _fractal_julia_dp(z_in: vec4f, c: vec4f, maxIter: i32) -> f32 {
-  var zr = vec2f(z_in.x, z_in.z);
-  var zi = vec2f(z_in.y, z_in.w);
-  let cr = vec2f(c.x, c.z);
-  let ci = vec2f(c.y, c.w);
-  for (var i: i32 = 0; i < maxIter; i++) {
-    let zr2 = ds_sqr(zr);
-    let zi2 = ds_sqr(zi);
-    let mag2 = ds_add(zr2, zi2);
-    if (mag2.x > 4.0) {
-      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);
-    }
-    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
-    zr = ds_add(ds_sub(zr2, zi2), cr);
-    zi = new_zi;
-  }
-  return 1.0;
-}
 `;
   var GPU_FRACTAL_PREAMBLE_GLSL = `
 float _fractal_mandelbrot(vec2 c, int maxIter) {
@@ -22295,208 +22080,6 @@ fn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {
   }
   return 1.0;
 }
-`;
-  var GPU_FRACTAL_PT_PREAMBLE_GLSL = `
-uniform sampler2D _refOrbit;
-uniform int _refOrbitLen;
-uniform int _refOrbitTexWidth;
-uniform float _pt_offset_x;
-uniform float _pt_offset_y;
-uniform float _pt_w;
-uniform float _pt_h;
-
-vec2 _pt_delta() {
-  float dx = _pt_offset_x + (v_uv.x - 0.5) * _pt_w;
-  float dy = _pt_offset_y + (v_uv.y - 0.5) * _pt_h;
-  return vec2(dx, dy);
-}
-
-vec2 _pt_fetch_orbit(int i) {
-  int y = i / _refOrbitTexWidth;
-  int x = i - y * _refOrbitTexWidth;
-  return texelFetch(_refOrbit, ivec2(x, y), 0).rg;
-}
-
-float _fractal_mandelbrot_pt(vec2 delta_c, int maxIter) {
-  float dr = 0.0;
-  float di = 0.0;
-  int orbitLen = min(maxIter, _refOrbitLen);
-  for (int i = 0; i < orbitLen; i++) {
-    vec2 Zn = _pt_fetch_orbit(i);
-    // delta_{n+1} = 2*Z_n*delta_n + delta_n^2 + delta_c
-    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
-    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
-    dr = new_dr;
-    di = new_di;
-    // Full z = Z_{n+1} + delta for escape check
-    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);
-    float zr = Zn1.x + dr;
-    float zi = Zn1.y + di;
-    float mag2 = zr * zr + zi * zi;
-    if (mag2 > 4.0)
-      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
-    // Glitch detection: |delta|^2 > |Z|^2
-    float dmag2 = dr * dr + di * di;
-    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
-    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
-      // Rebase to absolute coordinates and continue with single-float
-      float abs_zr = Zn1.x + dr;
-      float abs_zi = Zn1.y + di;
-      // Reconstruct absolute c from reference + delta
-      // (Use ds_from for the concept, but single-float suffices for fallback)
-      float cx = abs_zr - dr + delta_c.x;
-      float cy = abs_zi - di + delta_c.y;
-      for (int j = i + 1; j < maxIter; j++) {
-        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;
-        abs_zi = 2.0 * abs_zr * abs_zi + cy;
-        abs_zr = new_zr;
-        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;
-        if (mag2 > 4.0)
-          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
-      }
-      return 1.0;
-    }
-  }
-  return 1.0;
-}
-
-float _fractal_julia_pt(vec2 z_delta, vec2 delta_c, int maxIter) {
-  float dr = z_delta.x;
-  float di = z_delta.y;
-  int orbitLen = min(maxIter, _refOrbitLen);
-  for (int i = 0; i < orbitLen; i++) {
-    vec2 Zn = _pt_fetch_orbit(i);
-    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
-    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
-    dr = new_dr;
-    di = new_di;
-    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);
-    float zr = Zn1.x + dr;
-    float zi = Zn1.y + di;
-    float mag2 = zr * zr + zi * zi;
-    if (mag2 > 4.0)
-      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
-    float dmag2 = dr * dr + di * di;
-    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
-    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
-      float abs_zr = Zn1.x + dr;
-      float abs_zi = Zn1.y + di;
-      float cx = delta_c.x;
-      float cy = delta_c.y;
-      for (int j = i + 1; j < maxIter; j++) {
-        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;
-        abs_zi = 2.0 * abs_zr * abs_zi + cy;
-        abs_zr = new_zr;
-        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;
-        if (mag2 > 4.0)
-          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
-      }
-      return 1.0;
-    }
-  }
-  return 1.0;
-}
-`;
-  var GPU_FRACTAL_PT_PREAMBLE_WGSL = `
-@group(0) @binding(1) var _refOrbit: texture_2d<f32>;
-var<uniform> _refOrbitLen: i32;
-var<uniform> _refOrbitTexWidth: i32;
-var<uniform> _pt_offset_x: f32;
-var<uniform> _pt_offset_y: f32;
-var<uniform> _pt_w: f32;
-var<uniform> _pt_h: f32;
-
-fn _pt_delta(uv: vec2f) -> vec2f {
-  let dx = _pt_offset_x + (uv.x - 0.5) * _pt_w;
-  let dy = _pt_offset_y + (uv.y - 0.5) * _pt_h;
-  return vec2f(dx, dy);
-}
-
-fn _pt_fetch_orbit(i: i32) -> vec2f {
-  let y = i / _refOrbitTexWidth;
-  let x = i - y * _refOrbitTexWidth;
-  return textureLoad(_refOrbit, vec2i(x, y), 0).rg;
-}
-
-fn _fractal_mandelbrot_pt(delta_c: vec2f, maxIter: i32) -> f32 {
-  var dr: f32 = 0.0;
-  var di: f32 = 0.0;
-  let orbitLen = min(maxIter, _refOrbitLen);
-  for (var i: i32 = 0; i < orbitLen; i++) {
-    let Zn = _pt_fetch_orbit(i);
-    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
-    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
-    dr = new_dr;
-    di = new_di;
-    var Zn1 = vec2f(0.0);
-    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }
-    let zr = Zn1.x + dr;
-    let zi = Zn1.y + di;
-    var mag2 = zr * zr + zi * zi;
-    if (mag2 > 4.0) {
-      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
-    }
-    let dmag2 = dr * dr + di * di;
-    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
-    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
-      var f_zr = Zn1.x + dr;
-      var f_zi = Zn1.y + di;
-      let cx = delta_c.x;
-      let cy = delta_c.y;
-      for (var j: i32 = i + 1; j < maxIter; j++) {
-        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;
-        f_zi = 2.0 * f_zr * f_zi + cy;
-        f_zr = t_zr;
-        mag2 = f_zr * f_zr + f_zi * f_zi;
-        if (mag2 > 4.0) {
-          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
-        }
-      }
-      return 1.0;
-    }
-  }
-  return 1.0;
-}
-
-fn _fractal_julia_pt(z_delta: vec2f, delta_c: vec2f, maxIter: i32) -> f32 {
-  var dr = z_delta.x;
-  var di = z_delta.y;
-  let orbitLen = min(maxIter, _refOrbitLen);
-  for (var i: i32 = 0; i < orbitLen; i++) {
-    let Zn = _pt_fetch_orbit(i);
-    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
-    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
-    dr = new_dr;
-    di = new_di;
-    var Zn1 = vec2f(0.0);
-    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }
-    let zr = Zn1.x + dr;
-    let zi = Zn1.y + di;
-    var mag2 = zr * zr + zi * zi;
-    if (mag2 > 4.0) {
-      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
-    }
-    let dmag2 = dr * dr + di * di;
-    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
-    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
-      var f_zr = Zn1.x + dr;
-      var f_zi = Zn1.y + di;
-      let cx = delta_c.x;
-      let cy = delta_c.y;
-      for (var j: i32 = i + 1; j < maxIter; j++) {
-        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;
-        f_zi = 2.0 * f_zr * f_zi + cy;
-        f_zr = t_zr;
-        mag2 = f_zr * f_zr + f_zi * f_zi;
-        if (mag2 > 4.0) {
-          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
-        }
-      }
-      return 1.0;
-    }
-  }
-  return 1.0;
-}
 `;
   var GPU_COLOR_PREAMBLE_GLSL = `
 float _gpu_srgb_to_linear(float c) {
@@ -22936,7 +22519,6 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       const constants = this.getConstants();
       const v2 = this.languageId === "wgsl" ? "vec2f" : "vec2";
       const target = this.createTarget({
-        hints: options.hints,
         functions: (id) => {
           if (userFunctions && id in userFunctions) {
             const fn = userFunctions[id];
@@ -22975,89 +22557,12 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       if (code.includes("_gpu_besselJ"))
         preamble += this.languageId === "wgsl" ? GPU_BESSELJ_PREAMBLE_WGSL : GPU_BESSELJ_PREAMBLE_GLSL;
       if (code.includes("_fractal_")) {
-        if (code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) {
-          preamble += this.languageId === "wgsl" ? GPU_DS_ARITHMETIC_PREAMBLE_WGSL : GPU_DS_ARITHMETIC_PREAMBLE_GLSL;
-          preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PT_PREAMBLE_WGSL : GPU_FRACTAL_PT_PREAMBLE_GLSL;
-        } else if (code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) {
-          preamble += this.languageId === "wgsl" ? GPU_DS_ARITHMETIC_PREAMBLE_WGSL : GPU_DS_ARITHMETIC_PREAMBLE_GLSL;
-          preamble += this.languageId === "wgsl" ? GPU_FRACTAL_DP_PREAMBLE_WGSL : GPU_FRACTAL_DP_PREAMBLE_GLSL;
-        } else {
-          preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
-        }
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
       }
       if (code.includes("_gpu_srgb_to") || code.includes("_gpu_oklab") || code.includes("_gpu_oklch") || code.includes("_gpu_color_mix") || code.includes("_gpu_apca")) {
         preamble += this.languageId === "wgsl" ? GPU_COLOR_PREAMBLE_WGSL : GPU_COLOR_PREAMBLE_GLSL;
       }
       if (preamble) result.preamble = preamble;
-      if (code.includes("_fractal_") && options.hints?.viewport) {
-        const strategy = selectFractalStrategy(target);
-        const radius = options.hints.viewport.radius;
-        switch (strategy) {
-          case "single":
-            result.staleWhen = { radiusBelow: 1e-6 };
-            break;
-          case "double":
-            result.staleWhen = { radiusBelow: 1e-14, radiusAbove: 1e-5 };
-            break;
-          case "perturbation":
-            result.staleWhen = {
-              radiusAbove: 1e-5,
-              radiusBelow: radius * 0.01,
-              centerDistance: radius * 2
-            };
-            break;
-        }
-      }
-      if ((code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) && options.hints?.viewport) {
-        const cx = hpToNumber(options.hints.viewport.center[0]);
-        const cy = hpToNumber(options.hints.viewport.center[1]);
-        const size = options.hints.viewport.radius * 2;
-        const cx_hi = Math.fround(cx);
-        const cy_hi = Math.fround(cy);
-        result.uniforms = {
-          ...result.uniforms,
-          _dp_cx_hi: cx_hi,
-          _dp_cx_lo: cx - cx_hi,
-          _dp_cy_hi: cy_hi,
-          _dp_cy_lo: cy - cy_hi,
-          _dp_w: size,
-          _dp_h: size
-        };
-      }
-      if ((code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
-        const viewport = options.hints.viewport;
-        const size = viewport.radius * 2;
-        result.uniforms = {
-          ...result.uniforms,
-          _pt_offset_x: 0,
-          _pt_offset_y: 0,
-          _pt_w: size,
-          _pt_h: size
-        };
-        const digits = Math.max(50, Math.ceil(-Math.log10(viewport.radius)) + 10);
-        const maxIter = 1e3;
-        const orbit = computeReferenceOrbit(
-          viewport.center,
-          maxIter,
-          digits
-        );
-        const orbitLen = orbit.length / 2;
-        const texWidth = Math.min(orbitLen, 4096);
-        const texHeight = Math.ceil(orbitLen / texWidth);
-        result.textures = {
-          _refOrbit: {
-            data: orbit,
-            width: texWidth,
-            height: texHeight,
-            format: "rg32f"
-          }
-        };
-        result.uniforms = {
-          ...result.uniforms,
-          _refOrbitLen: orbitLen,
-          _refOrbitTexWidth: texWidth
-        };
-      }
       return result;
     }
     compileToSource(expr, _options = {}) {
@@ -25392,7 +24897,7 @@ ${code}`;
   }
 
   // src/compile.ts
-  var version = "0.55.5";
+  var version = "0.55.6";
   return __toCommonJS(compile_exports);
 })();
 /*! Bundled license information: