feat: enhance fractal compilation with precision strategies and reference orbit computation

- Introduced precision tiers for fractal compilation based on viewport hints, allowing for single, double, and perturbation strategies.
- Added functions to select fractal strategies and compute reference orbits for perturbation methods.
- Implemented double-single (DS) arithmetic preamble for GLSL and WGSL, including core functions for error-free arithmetic.
- Created emulated double-precision fractal preambles for Mandelbrot and Julia in both GLSL and WGSL.
- Updated compilation options to include hints for precision-adaptive strategies and added staleness checks for viewport changes.
- Enhanced tests for fractal compilation, ensuring correct strategy selection and orbit computation.

Author: arnog

CHANGELOG.md

@@ -2,12 +2,20 @@
 
 #### Fixed
 
-- **LaTeX parsing: interval notation with `\lbrack`/`\lparen`** — parsing
-  `\lbrack5,7)` or `\left\lbrack5,7\right)` now correctly produces an
-  `Interval` expression. Previously, when the open delimiter was a LaTeX
-  command (e.g., `\lbrack`), the parser incorrectly required the close
-  delimiter to also be a LaTeX command (e.g., `\rparen` instead of `)`),
-  causing mismatched-delimiter intervals to fail.
+- **[#254](https://github.com/cortex-js/compute-engine/issues/254) LaTeX
+  parsing: interval notation with `\lbrack`/`\lparen`** — parsing `\lbrack5,7)`
+  or `\left\lbrack5,7\right)` now correctly produces an `Interval` expression.
+  Previously, when the open delimiter was a LaTeX command (e.g., `\lbrack`), the
+  parser incorrectly required the close delimiter to also be a LaTeX command
+  (e.g., `\rparen` instead of `)`), causing mismatched-delimiter intervals to
+  fail.
+- **LaTeX parsing: invalid symbols in `\mathrm{}` and related prefixes** —
+  invalid content inside `\mathrm{}`, `\operatorname{}`, etc. (e.g.,
+  `\mathrm{=}` or `\mathrm{DavidBowie👨🏻‍🎤}`) now produces the correct
+  `invalid-symbol` error instead of cascading parse errors. Also fixed
+  `matchPrefixedSymbol` leaking parser state on failure, and emoji sequences
+  are now properly recognized inside symbol prefixes (e.g.,
+  `\operatorname{😎🤏😳🕶🤏}`).
 
 #### Added
 

src/compute-engine/compilation/fractal-orbit.ts

@@ -0,0 +1,54 @@
+import { BigDecimal } from '../../big-decimal';
+
+/**
+ * Compute a Mandelbrot reference orbit at arbitrary precision.
+ *
+ * Iterates z -> z^2 + c starting from z = 0, using BigDecimal arithmetic
+ * at the specified precision (decimal digits). Stops early if |z|^2 > 256
+ * (well past the escape radius of 2, giving a margin for perturbation).
+ *
+ * @param center - Reference point [re, im] as numbers (converted to BigDecimal)
+ * @param maxIter - Maximum number of iterations
+ * @param precision - BigDecimal working precision (decimal digits)
+ * @returns Float32Array of [re0, im0, re1, im1, ...] orbit points
+ */
+export function computeReferenceOrbit(
+  center: [number, number],
+  maxIter: number,
+  precision: number
+): Float32Array {
+  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: number[] = [];
+
+    for (let i = 0; i < maxIter; i++) {
+      points.push(zr.toNumber(), zi.toNumber());
+
+      // z = z^2 + c
+      // Truncate to working precision after each multiply to prevent
+      // exponential significand growth (mul doubles digit count).
+      const zr2 = zr.mul(zr).toPrecision(precision);
+      const zi2 = zi.mul(zi).toPrecision(precision);
+
+      // |z|^2 > 256? (escape with margin)
+      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;
+  }
+}