@cortex-js/compute-engine 0.55.4 → 0.55.6

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 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.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -25,6 +25,7 @@ var ComputeEngine = (() => {
     ALGEBRA_DICTIONARY: () => DEFINITIONS_ALGEBRA,
     ARITHMETIC_DICTIONARY: () => DEFINITIONS_ARITHMETIC,
     BaseCompiler: () => BaseCompiler,
+    BigDecimal: () => BigDecimal,
     CALCULUS_DICTIONARY: () => DEFINITIONS_CALCULUS,
     COMPLEX_DICTIONARY: () => DEFINITIONS_COMPLEX,
     CORE_DICTIONARY: () => DEFINITIONS_CORE,
@@ -11112,10 +11113,6 @@ var ComputeEngine = (() => {
     // 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, expr2) => {
         const degree = machineValue(operand(expr2, 2)) ?? 1;
         const base = serializer.serialize(operand(expr2, 1));
@@ -12153,14 +12150,18 @@ var ComputeEngine = (() => {
         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, expr2) => {
+        return joinLatex([
+          serializer.serialize(operand(expr2, 1)),
+          "^\\complement"
+        ]);
+      }
     },
     {
       name: "Intersection",
@@ -12247,7 +12248,6 @@ var ComputeEngine = (() => {
     // commands like \rbrack a, b \rbrack which are unambiguous.
     {
       name: "Multiple",
-      // @todo: parse
       serialize: serializeSet
     },
     {
@@ -12256,14 +12256,28 @@ var ComputeEngine = (() => {
       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 expr2 = operand(body, 1);
+          const condition = operand(body, 2);
+          if (expr2 !== null && condition !== null)
+            return ["Set", expr2, ["Condition", condition]];
+        }
         if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
           body = operand(body, 1);
         }
@@ -12271,6 +12285,17 @@ var ComputeEngine = (() => {
         return ["Set", ...operands(body)];
       },
       serialize: (serializer, expr2) => {
+        if (nops(expr2) === 2 && operator(operand(expr2, 2)) === "Condition") {
+          const condition = operand(expr2, 2);
+          return joinLatex([
+            "\\lbrace",
+            serializer.serialize(operand(expr2, 1)),
+            "\\mid",
+            // Serialize the inner expression of the Condition wrapper
+            serializer.serialize(operand(condition, 1)),
+            "\\rbrace"
+          ]);
+        }
         return joinLatex([
           "\\lbrace",
           operands(expr2).map((x) => serializer.serialize(x)).join(", "),
@@ -12437,23 +12462,6 @@ var ComputeEngine = (() => {
     if (expr2 === null) return "";
     const h = operator(expr2);
     if (!h) return "";
-    if (h === "Set") {
-      if (nops(expr2) === 0) return "\\emptyset";
-      if (nops(expr2) === 2 && operator(operand(expr2, 2)) === "Condition") {
-        return joinLatex([
-          "\\left\\lbrace",
-          serializer.serialize(operand(expr2, 1)),
-          "\\middle\\mid",
-          serializer.serialize(operand(expr2, 2)),
-          "\\right\\rbrace"
-        ]);
-      }
-      return joinLatex([
-        "\\left\\lbrace",
-        ...operands(expr2).map((x) => serializer.serialize(x) + " ,"),
-        "\\right\\rbrace"
-      ]);
-    }
     if (h === "Multiple") {
     }
     if (h === "Range") {
@@ -13601,11 +13609,13 @@ var ComputeEngine = (() => {
         if (!parser.match("_")) return null;
         const base = parser.parseGroup();
         if (operator(base) !== "To") return null;
-        const expr2 = parser.parseArguments("implicit");
+        const expr2 = parser.parseExpression({
+          minPrec: MULTIPLICATION_PRECEDENCE
+        });
         if (!expr2) return null;
         return [
           "Limit",
-          ["Function", expr2[0], operand(base, 1)],
+          ["Function", expr2, operand(base, 1)],
           operand(base, 2)
         ];
       },
@@ -15902,12 +15912,52 @@ var ComputeEngine = (() => {
   ];
 
   // 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",
@@ -16147,80 +16197,71 @@ var ComputeEngine = (() => {
     },
     {
       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",
@@ -16232,6 +16273,10 @@ var ComputeEngine = (() => {
           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([
@@ -16319,6 +16364,28 @@ var ComputeEngine = (() => {
       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) => {
@@ -16369,7 +16436,17 @@ var ComputeEngine = (() => {
       // `["HorizontalSpacing", expr, 'op'|'bin'|rel]` -> indicate a spacing around and expression, i.e. `\mathbin{x}`, etc...
       serialize: (serializer, expr2) => {
         if (operand(expr2, 2) !== null) {
-          return serializer.serialize(operand(expr2, 1));
+          const cls = stringValue(operand(expr2, 2));
+          const inner = serializer.serialize(operand(expr2, 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(expr2, 1));
         if (v === null) return "";
@@ -16760,25 +16837,47 @@ var ComputeEngine = (() => {
       result.arguments = entry.arguments;
     return result;
   }
+  function serializeTabularBody(serializer, body) {
+    if (!body) return "";
+    if (operator(body) !== "List") return serializer.serialize(body);
+    const rows = operands(body);
+    if (rows.length === 0) return "";
+    if (!rows.every((row) => operator(row) === "List"))
+      return serializer.serialize(body);
+    return rows.map(
+      (row) => operands(row).map((cell) => serializer.serialize(cell)).join(" & ")
+    ).join(" \\\\\n");
+  }
   function makeSerializeHandler(entry, latexTrigger, idTrigger) {
     if (typeof entry.serialize === "function") return entry.serialize;
     const kind = entry["kind"] ?? "expression";
     if (kind === "environment") {
       const envName = entry["symbolTrigger"] ?? entry.name ?? "unknown";
-      return (serializer, expr2) => joinLatex([
-        `\\begin{${envName}}`,
-        serializer.serialize(operand(expr2, 1)),
-        `\\end{${envName}}`
-      ]);
+      return (serializer, expr2) => {
+        const body = operand(expr2, 1);
+        return joinLatex([
+          `\\begin{${envName}}`,
+          serializeTabularBody(serializer, body),
+          `\\end{${envName}}`
+        ]);
+      };
     }
     if (isMatchfixEntry(entry)) {
       const openDelim = typeof entry.openTrigger === "string" ? DEFAULT_DELIMITER[entry.openTrigger] : tokensToString(entry.openTrigger);
       const closeDelim = typeof entry.closeTrigger === "string" ? DEFAULT_DELIMITER[entry.closeTrigger] : tokensToString(entry.closeTrigger);
-      return (serializer, expr2) => joinLatex([
-        openDelim,
-        serializer.serialize(operand(expr2, 1)),
-        closeDelim
-      ]);
+      return (serializer, expr2) => {
+        const style = serializer.groupStyle(expr2, serializer.level + 1);
+        const inner = serializer.serialize(operand(expr2, 1));
+        if (style === "scaled")
+          return joinLatex([`\\left${openDelim}`, inner, `\\right${closeDelim}`]);
+        if (style === "big")
+          return joinLatex([
+            `\\Bigl${openDelim}`,
+            inner,
+            `\\Bigr${closeDelim}`
+          ]);
+        return joinLatex([openDelim, inner, closeDelim]);
+      };
     }
     let latex = entry.serialize;
     if (latex === void 0 && latexTrigger) latex = tokensToString(latexTrigger);
@@ -17663,6 +17762,16 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/latex-syntax/parse.ts
+  var _symbolToUnicode = null;
+  function getSymbolToUnicode() {
+    if (!_symbolToUnicode) {
+      _symbolToUnicode = /* @__PURE__ */ new Map();
+      for (const [, latex, codepoint] of SYMBOLS2) {
+        _symbolToUnicode.set(latex, String.fromCodePoint(codepoint));
+      }
+    }
+    return _symbolToUnicode;
+  }
   var DELIMITER_SHORTHAND2 = {
     "(": ["\\lparen", "("],
     ")": ["\\rparen", ")"],
@@ -18110,6 +18219,35 @@ var ComputeEngine = (() => {
         this.nextToken();
         this.skipVisualSpace();
       }
+      if (this.match("\\hspace")) {
+        this.match("*");
+        this.parseStringGroup();
+        this.skipVisualSpace();
+      }
+      if (this.match("\\hskip") || this.match("\\kern")) {
+        this.skipSpace();
+        this.match("-") || this.match("+");
+        while (/^[\d.]$/.test(this.peek)) this.nextToken();
+        for (const unit of [
+          "pt",
+          "em",
+          "mu",
+          "ex",
+          "mm",
+          "cm",
+          "in",
+          "bp",
+          "sp",
+          "dd",
+          "cc",
+          "pc",
+          "nc",
+          "nd"
+        ]) {
+          if (this.matchAll([...unit])) break;
+        }
+        this.skipVisualSpace();
+      }
       this.skipSpace();
     }
     match(token) {
@@ -18447,7 +18585,8 @@ var ComputeEngine = (() => {
         } else if (token === "<space>") {
           result += " ";
         } else if (token[0] === "\\") {
-          result += token;
+          const unicode = getSymbolToUnicode().get(token);
+          result += unicode ?? token;
         } else {
           result += token;
         }
@@ -19807,7 +19946,7 @@ var ComputeEngine = (() => {
     sansserif: (s) => `\\mathsf{${s}}`,
     monospace: (s) => `\\mathtt{${s}}`
   };
-  var Serializer4 = class {
+  var Serializer5 = class {
     options;
     dictionary;
     level = -1;
@@ -19822,11 +19961,18 @@ var ComputeEngine = (() => {
     /**
      * Serialize the expression, and if the expression is an operator
      * of precedence less than or equal to prec, wrap it in some parens.
-     * @todo: don't wrap Abs, Floor, Ceil, Delimiter
+     *
+     * Skip wrapping for matchfix operators (Abs, Floor, Ceil, Norm, etc.)
+     * and Delimiter since they already have visible delimiters.
      */
     wrap(expr2, prec) {
       if (expr2 === null || expr2 === void 0) return "";
       if (prec === void 0) {
+        const name2 = operator(expr2);
+        if (name2) {
+          const def = this.dictionary.ids.get(name2);
+          if (def?.kind === "matchfix") return this.serialize(expr2);
+        }
         return this.wrapString(
           this.serialize(expr2),
           this.options.groupStyle(expr2, this.level + 1)
@@ -20120,7 +20266,7 @@ var ComputeEngine = (() => {
     return body;
   }
   function serializeLatex(expr2, dict, options) {
-    const serializer = new Serializer4(dict, options);
+    const serializer = new Serializer5(dict, options);
     return serializer.serialize(expr2);
   }
 
@@ -42159,12 +42305,14 @@ ${e.message}
         canonical: canonicalBlock,
         evaluate: evaluateBlock
       },
-      // A condition expression tests for one or more conditions of an expression
-      // ['Condition', value, "positive"]
+      // A condition expression tests for one or more conditions of an expression.
+      // Two forms:
+      //   ['Condition', value, "positive"]  — tests value against named condition(s)
+      //   ['Condition', predicate]          — set-builder predicate (e.g. x > 0)
       Condition: {
         description: "Test whether a value satisfies one or more conditions.",
         lazy: true,
-        signature: "(value, symbol) -> boolean",
+        signature: "(expression, symbol?) -> boolean",
         evaluate: ([value, conds], { engine }) => {
           let conditions = [];
           if (isSymbol2(conds)) {
@@ -61338,33 +61486,6 @@ Error in definition of "${name}"`,
     return b;
   }
 
-  // src/compute-engine/compilation/fractal-orbit.ts
-  function computeReferenceOrbit(center, maxIter, precision) {
-    const prevPrecision = BigDecimal.precision;
-    BigDecimal.precision = precision;
-    try {
-      const cr = new BigDecimal(center[0]);
-      const ci = new BigDecimal(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],
@@ -61448,13 +61569,6 @@ Error in definition of "${name}"`,
     ];
     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, compile3, target) => {
@@ -61950,32 +62064,12 @@ Error in definition of "${name}"`,
       if (c === null || maxIter === null)
         throw new Error("Mandelbrot: missing arguments");
       const iterCode = compileIntArg(maxIter, compile3, target);
-      const strategy = selectFractalStrategy(target);
-      if (strategy === "double") {
-        const cCode = compile3(c);
-        return `_fractal_mandelbrot_dp(vec4(${cCode}, vec2(0.0)), ${iterCode})`;
-      }
-      if (strategy === "perturbation") {
-        const cCode = compile3(c);
-        return `_fractal_mandelbrot_pt(${cCode}, ${iterCode})`;
-      }
       return `_fractal_mandelbrot(${compile3(c)}, ${iterCode})`;
     },
     Julia: ([z, c, maxIter], compile3, target) => {
       if (z === null || c === null || maxIter === null)
         throw new Error("Julia: missing arguments");
       const iterCode = compileIntArg(maxIter, compile3, target);
-      const strategy = selectFractalStrategy(target);
-      if (strategy === "double") {
-        const zCode = compile3(z);
-        const cCode = compile3(c);
-        return `_fractal_julia_dp(vec4(${zCode}, vec2(0.0)), vec4(${cCode}, vec2(0.0)), ${iterCode})`;
-      }
-      if (strategy === "perturbation") {
-        const zCode = compile3(z);
-        const cCode = compile3(c);
-        return `_fractal_julia_pt(${zCode}, ${cCode}, ${iterCode})`;
-      }
       return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
     },
     // Vector/Matrix operations
@@ -62572,200 +62666,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 = `
-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 = `
-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) {
@@ -62809,188 +62709,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;
-
-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;
-
-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) {
@@ -63430,7 +63148,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];
@@ -63469,65 +63186,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_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
-        const viewport = options.hints.viewport;
-        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(expr2, _options = {}) {
@@ -68932,14 +68596,14 @@ ${code}`;
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/compute-engine.ts
-  var version = "0.55.4";
+  var version = "0.55.6";
   ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
   _setDefaultEngineFactory(
     () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
   );
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.55.4"
+    version: "0.55.6"
   };
   return __toCommonJS(compute_engine_exports);
 })();