@cortex-js/compute-engine 0.55.6 → 0.57.0

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -17,14 +17,63 @@ export declare class BaseCompiler {
      */
     private static compileBlock;
     /**
-     * Compile a Loop expression with Element(index, Range(lo, hi)) indexing.
-     * Generates: (() => { for (let i = lo; i <= hi; i++) { body } })()
+     * Compile a Loop expression.
      *
-     * The loop counter is always a raw number. For targets that wrap numeric
-     * values (e.g. interval-js wraps with `_IA.point()`), references to the
-     * loop index inside the body are wrapped via `target.number`.
+     * Two forms are supported:
+     *
+     * 1. **Imperative / single-Element form** (existing behaviour):
+     *    `Loop(body, Element(i, Range(lo, hi)))`
+     *    Generates a raw `for (let i = lo; i <= hi; i++) { body }` loop wrapped
+     *    in an IIFE.  The loop counter is always a plain number.  For targets
+     *    that wrap numeric values (e.g. interval-js uses `_IA.point()`),
+     *    references to the loop index inside the body are re-wrapped via
+     *    `target.number`.  `break` / `continue` / `return` are preserved.
+     *
+     * 2. **Comprehension / variadic-Element form** (new):
+     *    `Loop(body, Element(x, coll1), Element(y, coll2), …)`
+     *    When two or more `Element` clauses are present — or when the single
+     *    Element's collection is not a `Range` — the loop is compiled as a
+     *    comprehension that collects results into an array.  Each clause
+     *    produces a `for (const name of collection)` loop, nested
+     *    outermost-to-innermost, and the innermost body pushes into `result`.
+     *
+     *    Example output (JS):
+     *    ```js
+     *    (() => { const result = [];
+     *      for (const x of [1,2]) { for (const y of [3,4]) { result.push(body); } }
+     *      return result; })()
+     *    ```
+     *
+     *    GLSL: multi-Element comprehension is not trivially representable in
+     *    GLSL (no dynamic arrays, no push).  A compile-time error is thrown.
+     *    TODO(E3-GLSL): support GLSL multi-Element via a pre-declared fixed-size
+     *    array or by unrolling when bounds are known at compile time.
      */
     private static compileForLoop;
+    /**
+     * Returns `true` when the given collection expression is a `Range` whose
+     * runtime semantics match the legacy imperative for-loop shape
+     * `for (let i = lo; i <= hi; i++)`.
+     *
+     * Concretely: integer-ascending bounds and step omitted-or-1. When bounds
+     * are not statically numeric we accept the Range (the historical
+     * behaviour) — runtime mismatch in the descending-unknown-bounds case is
+     * left as a known limitation; callers can force the iterable path by
+     * supplying an explicit step.
+     */
+    private static isLegacyCompatibleRange;
+    /**
+     * Compile a `Range(lo, hi)` or `Range(lo, hi, step)` expression into a JS
+     * iterable expression. Mirrors the runtime semantics in
+     * `library/collections.ts` Range:
+     *     count    = step === 0 ? 0 : max(0, floor((hi - lo) / step) + 1)
+     *     element  = lo + step * k          (0-indexed)
+     * Default step is 1 when omitted. Bounds and step may be fractional.
+     *
+     * Only used from the comprehension path in `compileForLoop`.
+     * Caller must have already verified `isFunction(rangeExpr, 'Range')`.
+     */
+    private static compileRangeIterable;
     /**
      * Compile a loop body expression as statements (not wrapped in IIFE).
      * Handles Break, Continue, Return as statements, and If as if-else when

package/dist/types/compute-engine/compilation/compile-expression.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { Expression, JSSource } from '../global-types';
 import type { CompileTarget, CompilationResult } from './types';
 type CompileExpressionOptions<T extends string = string> = {

package/dist/types/compute-engine/compilation/constant-folding.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Constant folding utilities for GPU compilation.
  *
  * These helpers allow compilation handlers to detect compile-time constants,

package/dist/types/compute-engine/compilation/glsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/compilation/gpu-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -123,16 +123,26 @@ export declare const GPU_FRACTAL_PREAMBLE_WGSL = "\nfn _fractal_mandelbrot(c: ve
 /**
  * GPU color space conversion preamble (GLSL syntax).
  *
- * Provides sRGB ↔ OKLab ↔ OKLCh conversions, color mixing in OKLCh
- * with shorter-arc hue interpolation, and APCA contrast calculation.
+ * Canonical color value: vec3 OKLCh `(L, C, H_deg)` — same convention as the
+ * interpreted/JS-runtime layer. Shaders that write to a sRGB framebuffer must
+ * wrap the final color in `_gpu_oklch_to_srgb()` at the boundary.
+ *
+ * Hue is in degrees throughout (matching the boxed-expression convention).
+ * `_gpu_color_mix` interpolates directly in OKLCh — no sRGB pinch — and
+ * special-cases achromatic endpoints (C ≈ 0) so e.g. mixing red with white
+ * preserves red's hue rather than drifting through arbitrary hues.
  *
  * WGSL targets must adapt syntax (vec3f, atan2→atan2, etc.).
  */
-export declare const GPU_COLOR_PREAMBLE_GLSL = "\nfloat _gpu_srgb_to_linear(float c) {\n  if (c <= 0.04045) return c / 12.92;\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfloat _gpu_linear_to_srgb(float c) {\n  if (c <= 0.0031308) return 12.92 * c;\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nvec3 _gpu_srgb_to_oklab(vec3 rgb) {\n  float r = _gpu_srgb_to_linear(rgb.x);\n  float g = _gpu_srgb_to_linear(rgb.y);\n  float b = _gpu_srgb_to_linear(rgb.z);\n  float l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  float m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  float s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nvec3 _gpu_oklab_to_srgb(vec3 lab) {\n  float l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  float m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  float s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  float l = l_ * l_ * l_;\n  float m = m_ * m_ * m_;\n  float s = s_ * s_ * s_;\n  float r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  float g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  float b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), 0.0, 1.0);\n}\n\nvec3 _gpu_oklab_to_oklch(vec3 lab) {\n  float C = length(lab.yz);\n  float H = atan(lab.z, lab.y);\n  return vec3(lab.x, C, H);\n}\n\nvec3 _gpu_oklch_to_oklab(vec3 lch) {\n  return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nvec3 _gpu_color_mix(vec3 rgb1, vec3 rgb2, float t) {\n  vec3 lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));\n  vec3 lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));\n  float L = mix(lch1.x, lch2.x, t);\n  float C = mix(lch1.y, lch2.y, t);\n  float dh = lch2.z - lch1.z;\n  const float PI = 3.14159265359;\n  if (dh > PI) dh -= 2.0 * PI;\n  if (dh < -PI) dh += 2.0 * PI;\n  float H = lch1.z + dh * t;\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3(L, C, H)));\n}\n\nfloat _gpu_apca(vec3 bg, vec3 fg) {\n  float bgR = _gpu_srgb_to_linear(bg.x);\n  float bgG = _gpu_srgb_to_linear(bg.y);\n  float bgB = _gpu_srgb_to_linear(bg.z);\n  float fgR = _gpu_srgb_to_linear(fg.x);\n  float fgG = _gpu_srgb_to_linear(fg.y);\n  float fgB = _gpu_srgb_to_linear(fg.z);\n  float bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  float fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  float bgC = pow(bgY, 0.56);\n  float fgC = pow(fgY, 0.57);\n  float contrast = (bgC > fgC)\n    ? (bgC - fgC) * 1.14\n    : (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
+export declare const GPU_COLOR_PREAMBLE_GLSL = "\nfloat _gpu_srgb_to_linear(float c) {\n  if (c <= 0.04045) return c / 12.92;\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfloat _gpu_linear_to_srgb(float c) {\n  if (c <= 0.0031308) return 12.92 * c;\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nvec3 _gpu_srgb_to_oklab(vec3 rgb) {\n  float r = _gpu_srgb_to_linear(rgb.x);\n  float g = _gpu_srgb_to_linear(rgb.y);\n  float b = _gpu_srgb_to_linear(rgb.z);\n  float l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  float m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  float s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nvec3 _gpu_oklab_to_srgb(vec3 lab) {\n  float l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  float m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  float s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  float l = l_ * l_ * l_;\n  float m = m_ * m_ * m_;\n  float s = s_ * s_ * s_;\n  float r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  float g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  float b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), 0.0, 1.0);\n}\n\nvec3 _gpu_oklab_to_oklch(vec3 lab) {\n  float C = length(lab.yz);\n  float H = atan(lab.z, lab.y) * (180.0 / 3.14159265359);\n  if (H < 0.0) H += 360.0;\n  return vec3(lab.x, C, H);\n}\n\nvec3 _gpu_oklch_to_oklab(vec3 lch) {\n  float h_rad = lch.z * (3.14159265359 / 180.0);\n  return vec3(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));\n}\n\nvec3 _gpu_srgb_to_oklch(vec3 rgb) {\n  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));\n}\n\nvec3 _gpu_oklch_to_srgb(vec3 lch) {\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));\n}\n\n// HSL conversion. Hue in degrees, saturation/lightness in 0-1.\nvec3 _gpu_hsl_to_rgb(vec3 hsl) {\n  float h = hsl.x;\n  float s = hsl.y;\n  float l = hsl.z;\n  float c = (1.0 - abs(2.0 * l - 1.0)) * s;\n  float h6 = h / 60.0;\n  float x = c * (1.0 - abs(mod(h6, 2.0) - 1.0));\n  float r = 0.0;\n  float g = 0.0;\n  float b = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  float m = l - c / 2.0;\n  return vec3(r + m, g + m, b + m);\n}\n\nvec3 _gpu_rgb_to_hsl(vec3 rgb) {\n  float maxc = max(max(rgb.x, rgb.y), rgb.z);\n  float minc = min(min(rgb.x, rgb.y), rgb.z);\n  float l = (maxc + minc) / 2.0;\n  float d = maxc - minc;\n  if (d < 1e-6) return vec3(0.0, 0.0, l);\n  float s = d / (1.0 - abs(2.0 * l - 1.0));\n  float h;\n  if (maxc == rgb.x)      h = mod((rgb.y - rgb.z) / d, 6.0);\n  else if (maxc == rgb.y) h = (rgb.z - rgb.x) / d + 2.0;\n  else                    h = (rgb.x - rgb.y) / d + 4.0;\n  h *= 60.0;\n  if (h < 0.0) h += 360.0;\n  return vec3(h, s, l);\n}\n\n// HSV conversion. Hue in degrees, saturation/value in 0-1.\nvec3 _gpu_hsv_to_rgb(vec3 hsv) {\n  float h = hsv.x;\n  float s = hsv.y;\n  float v = hsv.z;\n  float c = v * s;\n  float h6 = h / 60.0;\n  float x = c * (1.0 - abs(mod(h6, 2.0) - 1.0));\n  float r = 0.0;\n  float g = 0.0;\n  float b = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  float m = v - c;\n  return vec3(r + m, g + m, b + m);\n}\n\nvec3 _gpu_rgb_to_hsv(vec3 rgb) {\n  float maxc = max(max(rgb.x, rgb.y), rgb.z);\n  float minc = min(min(rgb.x, rgb.y), rgb.z);\n  float v = maxc;\n  float d = maxc - minc;\n  if (d < 1e-6) return vec3(0.0, 0.0, v);\n  float s = (maxc < 1e-6) ? 0.0 : d / maxc;\n  float h;\n  if (maxc == rgb.x)      h = mod((rgb.y - rgb.z) / d, 6.0);\n  else if (maxc == rgb.y) h = (rgb.z - rgb.x) / d + 2.0;\n  else                    h = (rgb.x - rgb.y) / d + 4.0;\n  h *= 60.0;\n  if (h < 0.0) h += 360.0;\n  return vec3(h, s, v);\n}\n\nvec3 _gpu_color_mix(vec3 lch1, vec3 lch2, float t) {\n  float L = mix(lch1.x, lch2.x, t);\n  float C = mix(lch1.y, lch2.y, t);\n  bool a1 = lch1.y < 1e-6;\n  bool a2 = lch2.y < 1e-6;\n  float H;\n  if (a1 && a2) {\n    H = lch1.z;\n  } else if (a1) {\n    H = lch2.z;\n  } else if (a2) {\n    H = lch1.z;\n  } else {\n    float dh = lch2.z - lch1.z;\n    if (dh > 180.0) dh -= 360.0;\n    if (dh < -180.0) dh += 360.0;\n    H = lch1.z + dh * t;\n    if (H < 0.0) H += 360.0;\n    if (H >= 360.0) H -= 360.0;\n  }\n  return vec3(L, C, H);\n}\n\nfloat _gpu_apca(vec3 lch_bg, vec3 lch_fg) {\n  vec3 bg = _gpu_oklch_to_srgb(lch_bg);\n  vec3 fg = _gpu_oklch_to_srgb(lch_fg);\n  float bgR = _gpu_srgb_to_linear(bg.x);\n  float bgG = _gpu_srgb_to_linear(bg.y);\n  float bgB = _gpu_srgb_to_linear(bg.z);\n  float fgR = _gpu_srgb_to_linear(fg.x);\n  float fgG = _gpu_srgb_to_linear(fg.y);\n  float fgB = _gpu_srgb_to_linear(fg.z);\n  float bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  float fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  float bgC = pow(bgY, 0.56);\n  float fgC = pow(fgY, 0.57);\n  float contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
 /**
  * GPU color space conversion preamble (WGSL syntax).
+ *
+ * Same convention as the GLSL preamble: canonical color value is `vec3f`
+ * OKLCh `(L, C, H_deg)`. Shaders writing to a sRGB framebuffer must wrap
+ * their final color in `_gpu_oklch_to_srgb()`.
  */
-export declare const GPU_COLOR_PREAMBLE_WGSL = "\nfn _gpu_srgb_to_linear(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn _gpu_linear_to_srgb(c: f32) -> f32 {\n  if (c <= 0.0031308) { return 12.92 * c; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn _gpu_srgb_to_oklab(rgb: vec3f) -> vec3f {\n  let r = _gpu_srgb_to_linear(rgb.x);\n  let g = _gpu_srgb_to_linear(rgb.y);\n  let b = _gpu_srgb_to_linear(rgb.z);\n  let l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  let m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  let s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3f(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nfn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {\n  let l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  let m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  let s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  let l = l_ * l_ * l_;\n  let m = m_ * m_ * m_;\n  let s = s_ * s_ * s_;\n  let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  let b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3f(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), vec3f(0.0), vec3f(1.0));\n}\n\nfn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {\n  let C = length(lab.yz);\n  let H = atan2(lab.z, lab.y);\n  return vec3f(lab.x, C, H);\n}\n\nfn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {\n  return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nfn _gpu_color_mix(rgb1: vec3f, rgb2: vec3f, t: f32) -> vec3f {\n  let lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));\n  let lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));\n  let L = mix(lch1.x, lch2.x, t);\n  let C = mix(lch1.y, lch2.y, t);\n  let PI = 3.14159265359;\n  var dh = lch2.z - lch1.z;\n  if (dh > PI) { dh -= 2.0 * PI; }\n  if (dh < -PI) { dh += 2.0 * PI; }\n  let H = lch1.z + dh * t;\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3f(L, C, H)));\n}\n\nfn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {\n  let bgR = _gpu_srgb_to_linear(bg.x);\n  let bgG = _gpu_srgb_to_linear(bg.y);\n  let bgB = _gpu_srgb_to_linear(bg.z);\n  let fgR = _gpu_srgb_to_linear(fg.x);\n  let fgG = _gpu_srgb_to_linear(fg.y);\n  let fgB = _gpu_srgb_to_linear(fg.z);\n  let bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  let fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  let bgC = pow(bgY, 0.56);\n  let fgC = pow(fgY, 0.57);\n  let contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
+export declare const GPU_COLOR_PREAMBLE_WGSL = "\nfn _gpu_srgb_to_linear(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn _gpu_linear_to_srgb(c: f32) -> f32 {\n  if (c <= 0.0031308) { return 12.92 * c; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn _gpu_srgb_to_oklab(rgb: vec3f) -> vec3f {\n  let r = _gpu_srgb_to_linear(rgb.x);\n  let g = _gpu_srgb_to_linear(rgb.y);\n  let b = _gpu_srgb_to_linear(rgb.z);\n  let l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  let m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  let s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3f(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nfn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {\n  let l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  let m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  let s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  let l = l_ * l_ * l_;\n  let m = m_ * m_ * m_;\n  let s = s_ * s_ * s_;\n  let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  let b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3f(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), vec3f(0.0), vec3f(1.0));\n}\n\nfn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y) * (180.0 / 3.14159265359);\n  if (H < 0.0) { H = H + 360.0; }\n  return vec3f(lab.x, C, H);\n}\n\nfn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {\n  let h_rad = lch.z * (3.14159265359 / 180.0);\n  return vec3f(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));\n}\n\nfn _gpu_srgb_to_oklch(rgb: vec3f) -> vec3f {\n  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));\n}\n\nfn _gpu_oklch_to_srgb(lch: vec3f) -> vec3f {\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));\n}\n\nfn _gpu_hsl_to_rgb(hsl: vec3f) -> vec3f {\n  let h = hsl.x;\n  let s = hsl.y;\n  let l = hsl.z;\n  let c = (1.0 - abs(2.0 * l - 1.0)) * s;\n  let h6 = h / 60.0;\n  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));\n  var r: f32 = 0.0;\n  var g: f32 = 0.0;\n  var b: f32 = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  let m = l - c / 2.0;\n  return vec3f(r + m, g + m, b + m);\n}\n\nfn _gpu_rgb_to_hsl(rgb: vec3f) -> vec3f {\n  let maxc = max(max(rgb.x, rgb.y), rgb.z);\n  let minc = min(min(rgb.x, rgb.y), rgb.z);\n  let l = (maxc + minc) / 2.0;\n  let d = maxc - minc;\n  if (d < 1e-6) { return vec3f(0.0, 0.0, l); }\n  let s = d / (1.0 - abs(2.0 * l - 1.0));\n  var h: f32;\n  if (maxc == rgb.x) {\n    let v = (rgb.y - rgb.z) / d;\n    h = v - 6.0 * floor(v / 6.0);\n  } else if (maxc == rgb.y) {\n    h = (rgb.z - rgb.x) / d + 2.0;\n  } else {\n    h = (rgb.x - rgb.y) / d + 4.0;\n  }\n  h = h * 60.0;\n  if (h < 0.0) { h = h + 360.0; }\n  return vec3f(h, s, l);\n}\n\nfn _gpu_hsv_to_rgb(hsv: vec3f) -> vec3f {\n  let h = hsv.x;\n  let s = hsv.y;\n  let v = hsv.z;\n  let c = v * s;\n  let h6 = h / 60.0;\n  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));\n  var r: f32 = 0.0;\n  var g: f32 = 0.0;\n  var b: f32 = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  let m = v - c;\n  return vec3f(r + m, g + m, b + m);\n}\n\nfn _gpu_rgb_to_hsv(rgb: vec3f) -> vec3f {\n  let maxc = max(max(rgb.x, rgb.y), rgb.z);\n  let minc = min(min(rgb.x, rgb.y), rgb.z);\n  let v = maxc;\n  let d = maxc - minc;\n  if (d < 1e-6) { return vec3f(0.0, 0.0, v); }\n  var s: f32 = 0.0;\n  if (maxc >= 1e-6) { s = d / maxc; }\n  var h: f32;\n  if (maxc == rgb.x) {\n    let q = (rgb.y - rgb.z) / d;\n    h = q - 6.0 * floor(q / 6.0);\n  } else if (maxc == rgb.y) {\n    h = (rgb.z - rgb.x) / d + 2.0;\n  } else {\n    h = (rgb.x - rgb.y) / d + 4.0;\n  }\n  h = h * 60.0;\n  if (h < 0.0) { h = h + 360.0; }\n  return vec3f(h, s, v);\n}\n\nfn _gpu_color_mix(lch1: vec3f, lch2: vec3f, t: f32) -> vec3f {\n  let L = mix(lch1.x, lch2.x, t);\n  let C = mix(lch1.y, lch2.y, t);\n  let a1 = lch1.y < 1e-6;\n  let a2 = lch2.y < 1e-6;\n  var H: f32;\n  if (a1 && a2) {\n    H = lch1.z;\n  } else if (a1) {\n    H = lch2.z;\n  } else if (a2) {\n    H = lch1.z;\n  } else {\n    var dh = lch2.z - lch1.z;\n    if (dh > 180.0) { dh = dh - 360.0; }\n    if (dh < -180.0) { dh = dh + 360.0; }\n    H = lch1.z + dh * t;\n    if (H < 0.0) { H = H + 360.0; }\n    if (H >= 360.0) { H = H - 360.0; }\n  }\n  return vec3f(L, C, H);\n}\n\nfn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {\n  let bg = _gpu_oklch_to_srgb(lch_bg);\n  let fg = _gpu_oklch_to_srgb(lch_fg);\n  let bgR = _gpu_srgb_to_linear(bg.x);\n  let bgG = _gpu_srgb_to_linear(bg.y);\n  let bgB = _gpu_srgb_to_linear(bg.z);\n  let fgR = _gpu_srgb_to_linear(fg.x);\n  let fgG = _gpu_srgb_to_linear(fg.y);\n  let fgB = _gpu_srgb_to_linear(fg.z);\n  let bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  let fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  let bgC = pow(bgY, 0.56);\n  let fgC = pow(fgY, 0.57);\n  let contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
 /**
  * Abstract base class for GPU shader compilation targets.
  *

package/dist/types/compute-engine/compilation/interval-javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import { chop, factorial, factorial2, gcd, lcm, limit } from '../numerics/numeric';
 import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc } from '../numerics/special-functions';
 import { choose } from '../boxed-expression/expand';
@@ -16,8 +16,19 @@ export declare class ComputeEngineFunction extends Function {
         contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
         colorToColorspace(input: string | number[], space: string): number[];
         colormap(name: string, arg?: number): number[] | number[][];
-        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        _interpolatePalette(colors: number[][], t: number): number[];
         colorFromColorspace(components: number[], space: string): number[];
+        rgb(r: number, g: number, b: number, alpha?: number): number[];
+        hsv(h: number, s: number, v: number, alpha?: number): number[];
+        hsl(h: number, s: number, l: number, alpha?: number): number[];
+        oklab(L: number, a: number, b: number, alpha?: number): number[];
+        oklch(L: number, C: number, H: number, alpha?: number): number[];
+        asRgb(input: string | number[]): number[];
+        asHsv(input: string | number[]): number[];
+        asHsl(input: string | number[]): number[];
+        asOklab(input: string | number[]): number[];
+        colorDelta(a: string | number[], b: string | number[]): number;
+        distance(a: number[], b: number[]): number;
         chop: typeof chop;
         factorial: typeof factorial;
         factorial2: typeof factorial2;
@@ -195,8 +206,19 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
         colorToColorspace(input: string | number[], space: string): number[];
         colormap(name: string, arg?: number): number[] | number[][];
-        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        _interpolatePalette(colors: number[][], t: number): number[];
         colorFromColorspace(components: number[], space: string): number[];
+        rgb(r: number, g: number, b: number, alpha?: number): number[];
+        hsv(h: number, s: number, v: number, alpha?: number): number[];
+        hsl(h: number, s: number, l: number, alpha?: number): number[];
+        oklab(L: number, a: number, b: number, alpha?: number): number[];
+        oklch(L: number, C: number, H: number, alpha?: number): number[];
+        asRgb(input: string | number[]): number[];
+        asHsv(input: string | number[]): number[];
+        asHsl(input: string | number[]): number[];
+        asOklab(input: string | number[]): number[];
+        colorDelta(a: string | number[], b: string | number[]): number;
+        distance(a: number[], b: number[]): number;
         chop: typeof chop;
         factorial: typeof factorial;
         factorial2: typeof factorial2;

package/dist/types/compute-engine/compilation/python-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation

package/dist/types/compute-engine/compilation/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 /**
  * Source code in the target language
  */

package/dist/types/compute-engine/compilation/wgsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

package/dist/types/compute-engine/engine-assumptions.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { MathJsonSymbol } from '../math-json/types';
 export declare function ask(ce: IComputeEngine, pattern: Expression): BoxedSubstitution[];
 export declare function verify(ce: IComputeEngine, query: Expression): boolean | undefined;

package/dist/types/compute-engine/engine-cache.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
     private _entries;
     getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     invalidate(cacheName: string): void;

package/dist/types/compute-engine/engine-common-symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

package/dist/types/compute-engine/engine-compilation-targets.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { LanguageTarget } from './compilation/types';
 /**
  * Internal registry for compilation targets.

package/dist/types/compute-engine/engine-configuration-lifecycle.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

package/dist/types/compute-engine/engine-declarations.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { MathJsonSymbol } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AssignValue, Expression, BoxedDefinition, SymbolDefinition, IComputeEngine, Scope } from './global-types';

package/dist/types/compute-engine/engine-expression-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import { BigDecimal } from '../big-decimal';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';

package/dist/types/compute-engine/engine-extension-contracts.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { LanguageTarget, CompilationOptions } from './compilation/types';
 export declare function assertCompilationTargetName(name: unknown): string;
 export declare function assertLibraryName(name: unknown): string;

package/dist/types/compute-engine/engine-library-bootstrap.d.ts

@@ -1,3 +1,3 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare function resolveBootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): LibraryDefinition[];
 export declare function loadLibraryDefinitions(engine: ComputeEngine, libraries: readonly LibraryDefinition[]): void;

package/dist/types/compute-engine/engine-numeric-configuration.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _precision;

package/dist/types/compute-engine/engine-runtime-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

package/dist/types/compute-engine/engine-scope.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;
 export declare function pushEvalContext(ce: IComputeEngine, scope: Scope, name?: string): void;

package/dist/types/compute-engine/engine-sequences.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare function declareSequence(ce: IComputeEngine, name: string, def: SequenceDefinition): IComputeEngine;
 export declare function getSequenceStatus(ce: IComputeEngine, name: string): SequenceStatus;
 export declare function getSequence(ce: IComputeEngine, name: string): SequenceInfo | undefined;

package/dist/types/compute-engine/engine-simplification-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 /**
  * Internal holder for simplification rules and their cache-staleness marker.
  *

package/dist/types/compute-engine/engine-startup-coordinator.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;

package/dist/types/compute-engine/engine-type-resolver.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 type ResolverScope = {
     parent: ResolverScope | null;
     types?: Record<string, TypeReference>;

package/dist/types/compute-engine/engine-validation-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { Expression, Metadata, ExpressionInput } from './global-types';
 type ValidationHost = {

package/dist/types/compute-engine/free-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';

package/dist/types/compute-engine/function-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

package/dist/types/compute-engine/global-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

package/dist/types/compute-engine/index.d.ts

@@ -1,12 +1,12 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import { BigDecimal } from '../big-decimal';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
 import type { OneOf } from '../common/one-of';
 import type { ConfigurationChangeListener } from '../common/configuration-change';
 import type { MathJsonExpression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
-import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, ILatexSyntax, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition } from './global-types';
-import type { LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
+import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, ILatexSyntax, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition, OperatorInfo } from './global-types';
+import type { LibraryCategory, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/types';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
 import type { FormOption } from './types-serialization';
@@ -174,6 +174,7 @@ export declare class ComputeEngine implements IComputeEngine {
         precision?: number | 'machine';
         tolerance?: number | 'auto';
         latexSyntax?: ILatexSyntax;
+        latexOptions?: Partial<ParseLatexOptions & SerializeLatexOptions>;
     });
     toJSON(): string;
     [Symbol.toStringTag]: string;
@@ -436,6 +437,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * lexical scope and going up the scope chain.
      */
     lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
+    operatorInfo(head: string): OperatorInfo | undefined;
     /**
      * Associate a new definition to a symbol in the current context.
      *
@@ -650,6 +652,25 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal Returns the LatexSyntax instance, lazily creating one
      *  if a factory is registered. Throws if no LatexSyntax is available. */
     _requireLatexSyntax(): ILatexSyntax;
+    /** @internal Engine-wide LaTeX parse/serialize options (e.g. decimalSeparator).
+     *  Merged into every `parse()` and `toLatex()` call between the LatexSyntax
+     *  instance defaults and any per-call overrides. */
+    private _latexOptions;
+    /** Engine-wide LaTeX parse/serialize options.
+     *
+     * These options are merged into every `parse()` and `toLatex()` call.
+     * Precedence (most-specific wins):
+     *   1. LatexSyntax instance defaults (set at its construction)
+     *   2. `ce.latexOptions` (this property)
+     *   3. Per-call options passed to `ce.parse()` / `expr.toLatex()`
+     *
+     * Assigning replaces the whole bag. Use spread to merge:
+     * ```ts
+     * ce.latexOptions = { ...ce.latexOptions, decimalSeparator: '{,}' };
+     * ```
+     */
+    get latexOptions(): Partial<ParseLatexOptions & SerializeLatexOptions>;
+    set latexOptions(options: Partial<ParseLatexOptions & SerializeLatexOptions>);
     /**
      * Parse a LaTeX string and return a boxed expression.
      *

package/dist/types/compute-engine/interval/arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

package/dist/types/compute-engine/interval/comparison.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

package/dist/types/compute-engine/interval/elementary.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary

package/dist/types/compute-engine/interval/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations

package/dist/types/compute-engine/interval/trigonometric.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

package/dist/types/compute-engine/interval/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Interval arithmetic types for reliable function evaluation
  *
  * @module interval/types

package/dist/types/compute-engine/interval/util.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

package/dist/types/compute-engine/latex-syntax/dictionary/default-dictionary.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
  * Default LaTeX dictionary assembly.
  *
  * This file imports all individual domain dictionaries and assembles them
@@ -21,8 +21,9 @@ import { DEFINITIONS_LINEAR_ALGEBRA } from './definitions-linear-algebra';
 import { DEFINITIONS_STATISTICS } from './definitions-statistics';
 import { DEFINITIONS_UNITS } from './definitions-units';
 import { DEFINITIONS_OTHERS } from './definitions-other';
-export { DEFINITIONS_CORE, DEFINITIONS_SYMBOLS, DEFINITIONS_ALGEBRA, DEFINITIONS_LOGIC, DEFINITIONS_SETS, DEFINITIONS_INEQUALITIES, DEFINITIONS_ARITHMETIC, DEFINITIONS_COMPLEX, DEFINITIONS_TRIGONOMETRY, DEFINITIONS_CALCULUS, DEFINITIONS_LINEAR_ALGEBRA, DEFINITIONS_STATISTICS, DEFINITIONS_UNITS, DEFINITIONS_OTHERS, };
-export { DEFINITIONS_CORE as CORE_DICTIONARY, DEFINITIONS_SYMBOLS as SYMBOLS_DICTIONARY, DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY, DEFINITIONS_LOGIC as LOGIC_DICTIONARY, DEFINITIONS_SETS as SETS_DICTIONARY, DEFINITIONS_INEQUALITIES as INEQUALITIES_DICTIONARY, DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY, DEFINITIONS_COMPLEX as COMPLEX_DICTIONARY, DEFINITIONS_TRIGONOMETRY as TRIGONOMETRY_DICTIONARY, DEFINITIONS_CALCULUS as CALCULUS_DICTIONARY, DEFINITIONS_LINEAR_ALGEBRA as LINEAR_ALGEBRA_DICTIONARY, DEFINITIONS_STATISTICS as STATISTICS_DICTIONARY, DEFINITIONS_UNITS as UNITS_DICTIONARY, DEFINITIONS_OTHERS as OTHERS_DICTIONARY, };
+import { DEFINITIONS_COLORS } from './definitions-colors';
+export { DEFINITIONS_CORE, DEFINITIONS_SYMBOLS, DEFINITIONS_ALGEBRA, DEFINITIONS_LOGIC, DEFINITIONS_SETS, DEFINITIONS_INEQUALITIES, DEFINITIONS_ARITHMETIC, DEFINITIONS_COMPLEX, DEFINITIONS_TRIGONOMETRY, DEFINITIONS_CALCULUS, DEFINITIONS_LINEAR_ALGEBRA, DEFINITIONS_STATISTICS, DEFINITIONS_UNITS, DEFINITIONS_OTHERS, DEFINITIONS_COLORS, };
+export { DEFINITIONS_CORE as CORE_DICTIONARY, DEFINITIONS_SYMBOLS as SYMBOLS_DICTIONARY, DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY, DEFINITIONS_LOGIC as LOGIC_DICTIONARY, DEFINITIONS_SETS as SETS_DICTIONARY, DEFINITIONS_INEQUALITIES as INEQUALITIES_DICTIONARY, DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY, DEFINITIONS_COMPLEX as COMPLEX_DICTIONARY, DEFINITIONS_TRIGONOMETRY as TRIGONOMETRY_DICTIONARY, DEFINITIONS_CALCULUS as CALCULUS_DICTIONARY, DEFINITIONS_LINEAR_ALGEBRA as LINEAR_ALGEBRA_DICTIONARY, DEFINITIONS_STATISTICS as STATISTICS_DICTIONARY, DEFINITIONS_UNITS as UNITS_DICTIONARY, DEFINITIONS_OTHERS as OTHERS_DICTIONARY, DEFINITIONS_COLORS as COLORS_DICTIONARY, };
 /**
  * LaTeX dictionary entries for physics constants that have LaTeX triggers.
  * These were previously inline in the physics library definition.

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-colors.d.ts

@@ -0,0 +1,10 @@
+/* 0.57.0 */
+/**
+ * LaTeX dictionary for color constructors and conversions.
+ *
+ * Constructors preserve their colorspace on evaluation; the head is the
+ * discriminator. A `Color` value type may be introduced later — for now
+ * each constructor returns a tuple-shaped value and downstream code
+ * branches on the operator name.
+ */
+export declare const DEFINITIONS_COLORS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.6 */
+/* 0.57.0 */
 import type { MathJsonExpression } from '../../../math-json';
 export declare const DEFINITIONS_LOGIC: LatexDictionary;
 export declare function parseQuantifier(kind: 'NotForAll' | 'NotExists' | 'ForAll' | 'Exists' | 'ExistsUnique'): (parser: Parser, terminator: Readonly<Terminator>) => MathJsonExpression | null;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-relational-operators.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.6 */
+/* 0.57.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;