@cortex-js/compute-engine 0.55.6 → 0.57.0

package/dist/latex-syntax.umd.cjs

@@ -1,4 +1,4 @@
-/** LatexSyntax 0.55.6 */
+/** LatexSyntax 0.57.0 */
     (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.LatexSyntax = {}));})(this, (function (exports) { 'use strict';
 var LatexSyntax = (() => {
   var __defProp = Object.defineProperty;
@@ -1190,6 +1190,7 @@ var LatexSyntax = (() => {
   ];
   var VALUE_TYPES = [
     "value",
+    "color",
     ...COLLECTION_TYPES,
     ...SCALAR_TYPES
   ];
@@ -2841,6 +2842,7 @@ var LatexSyntax = (() => {
     symbol: [],
     boolean: [],
     string: [],
+    color: [],
     expression: EXPRESSION_TYPES
   };
   function isPrimitiveSubtype(lhs, rhs) {
@@ -3723,6 +3725,64 @@ var LatexSyntax = (() => {
   }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
+  var COMPONENT_ACCESS_HEADS = {
+    x: "First",
+    y: "Second",
+    z: "Third",
+    real: "Real",
+    re: "Real",
+    imag: "Imaginary",
+    im: "Imaginary",
+    count: "Length",
+    total: "Sum",
+    max: "Max",
+    min: "Min"
+  };
+  function memberHead(name) {
+    return COMPONENT_ACCESS_HEADS[name] ?? null;
+  }
+  function parseComponentAccess(parser, lhs) {
+    parser.skipVisualSpace();
+    if (parser.match("\\operatorname")) {
+      const name = parser.parseStringGroup();
+      if (name === null) return null;
+      const head = memberHead(name.trim());
+      if (head === null) return null;
+      return [head, lhs];
+    }
+    const tok = parser.peek;
+    if (typeof tok === "string" && tok.startsWith("\\")) {
+      const bare = tok.slice(1);
+      const head = memberHead(bare);
+      if (head !== null) {
+        parser.nextToken();
+        return [head, lhs];
+      }
+      return null;
+    }
+    if (typeof tok === "string" && /^[a-zA-Z]$/.test(tok)) {
+      const head = memberHead(tok);
+      if (head === null) return null;
+      parser.nextToken();
+      return [head, lhs];
+    }
+    return null;
+  }
+  function parseWhenRestriction(parser, lhs, close) {
+    parser.addBoundary(close);
+    parser.skipVisualSpace();
+    const cond = parser.parseExpression({ minPrec: 0 });
+    if (cond === null) {
+      parser.removeBoundary();
+      return null;
+    }
+    parser.skipVisualSpace();
+    if (!parser.matchBoundary()) {
+      parser.removeBoundary();
+      return null;
+    }
+    return ["When", lhs, cond];
+  }
   function parseSequence(parser, terminator, lhs, prec, sep) {
     if (terminator && terminator.minPrec >= prec) return null;
     const result = lhs ? [lhs] : ["Nothing"];
@@ -4194,6 +4254,15 @@ var LatexSyntax = (() => {
       }
     },
     { name: "LatexTokens", serialize: serializeLatexTokens },
+    // Component-access postfix: expr.member  (C3)
+    // The '.' trigger is consumed before the parse function is called.
+    // Precedence 850 > 810 (At/indexing) so .x chains tightly.
+    {
+      kind: "postfix",
+      precedence: 850,
+      latexTrigger: ["."],
+      parse: parseComponentAccess
+    },
     {
       name: "At",
       kind: "postfix",
@@ -4214,6 +4283,29 @@ var LatexSyntax = (() => {
       latexTrigger: ["\\left", "\\lbrack"],
       parse: parseAt("\\right", "\\rbrack")
     },
+    // When-restriction: `expr\left\{cond\right\}` → `When(expr, cond)` (D3)
+    {
+      name: "When",
+      kind: "postfix",
+      precedence: 800,
+      latexTrigger: ["\\left", "\\{"],
+      parse: (parser, lhs) => parseWhenRestriction(parser, lhs, ["\\right", "\\}"]),
+      serialize: (serializer, expr) => {
+        const e = operand(expr, 1);
+        const cond = operand(expr, 2);
+        if (!e || !cond) return "";
+        const clauses = operator(cond) === "And" ? operands(cond) ?? [] : [cond];
+        const inner = clauses.map((c) => `\\left\\{${serializer.serialize(c)}\\right\\}`).join("");
+        return `${serializer.serialize(e)}${inner}`;
+      }
+    },
+    // When-restriction: bare `expr\{cond\}` → `When(expr, cond)`
+    {
+      kind: "postfix",
+      precedence: 800,
+      latexTrigger: ["\\{"],
+      parse: (parser, lhs) => parseWhenRestriction(parser, lhs, ["\\}"])
+    },
     {
       kind: "postfix",
       latexTrigger: ["_"],
@@ -4296,6 +4388,29 @@ var LatexSyntax = (() => {
         return "";
       }
     },
+    // Additional triggers for Range: `...`, `\ldots`, and `\dots` are
+    // equivalent to `..` when used as infix operators (e.g. `[1...9]`).
+    // No `name` field here — names must be unique per the dictionary rules;
+    // the first Range entry owns the name. When there is no LHS the symbol
+    // entries near the top of the file still fire (ContinuationPlaceholder).
+    {
+      latexTrigger: [".", ".", "."],
+      kind: "infix",
+      precedence: 800,
+      parse: parseRange
+    },
+    {
+      latexTrigger: ["\\ldots"],
+      kind: "infix",
+      precedence: 800,
+      parse: parseRange
+    },
+    {
+      latexTrigger: ["\\dots"],
+      kind: "infix",
+      precedence: 800,
+      parse: parseRange
+    },
     {
       latexTrigger: [";"],
       kind: "infix",
@@ -4480,13 +4595,24 @@ var LatexSyntax = (() => {
         const args = operands(expr);
         if (!args || args.length < 2) return "";
         const body = args[0];
-        const indexing = args[1];
-        if (operator(indexing) === "Element") {
-          const index = operand(indexing, 1);
-          const range = operand(indexing, 2);
-          if (operator(range) === "Range") {
-            const lo = operand(range, 1);
-            const hi = operand(range, 2);
+        const elements = args.slice(1);
+        const allElements = elements.every((e) => operator(e) === "Element");
+        if (!allElements) {
+          return joinLatex([
+            "\\operatorname{Loop}(",
+            serializer.serialize(body),
+            ", ",
+            serializer.serialize(elements[0]),
+            ")"
+          ]);
+        }
+        if (elements.length === 1) {
+          const elem = elements[0];
+          const index = operand(elem, 1);
+          const coll = operand(elem, 2);
+          if (operator(coll) === "Range") {
+            const lo = operand(coll, 1);
+            const hi = operand(coll, 2);
             return joinLatex([
               "\\text{for }",
               serializer.serialize(index),
@@ -4498,13 +4624,27 @@ var LatexSyntax = (() => {
               serializer.serialize(body)
             ]);
           }
+          return joinLatex([
+            serializer.serialize(body),
+            " \\operatorname{for} ",
+            serializer.serialize(index),
+            " = ",
+            serializer.serialize(coll)
+          ]);
         }
+        const bindings = elements.map((elem) => {
+          const name = operand(elem, 1);
+          const coll = operand(elem, 2);
+          return joinLatex([
+            serializer.serialize(name),
+            " = ",
+            serializer.serialize(coll)
+          ]);
+        }).join(", ");
         return joinLatex([
-          "\\operatorname{Loop}(",
           serializer.serialize(body),
-          ", ",
-          serializer.serialize(indexing),
-          ")"
+          " \\operatorname{for} ",
+          bindings
         ]);
       }
     },
@@ -4537,6 +4677,18 @@ var LatexSyntax = (() => {
       precedence: 245,
       parse: (parser, until) => parseForExpression(parser, until)
     },
+    // \operatorname{for} as postfix infix (list comprehension):
+    //   `body \operatorname{for} x = L_1, y = L_2`
+    // Precedence 19 — just below comma (20) so the body is allowed to use
+    // any operator (including comma sequencing) up to the keyword, and the
+    // bindings can be comma-separated below us.
+    {
+      symbolTrigger: "for",
+      kind: "infix",
+      associativity: "none",
+      precedence: 19,
+      parse: (parser, lhs, until) => parseForComprehension(parser, lhs, until)
+    },
     // \operatorname{break}
     {
       symbolTrigger: "break",
@@ -4741,7 +4893,10 @@ var LatexSyntax = (() => {
         if (!sym || !parser.getSymbolType(sym).matches("function")) return null;
         parser.addBoundary([")"]);
         const expr = parser.parseExpression(until);
-        if (!parser.matchBoundary()) return null;
+        if (!parser.matchBoundary()) {
+          parser.removeBoundary();
+          return null;
+        }
         if (!parser.match("<}>")) return null;
         return ["Derivative", lhs, expr];
       }
@@ -5182,7 +5337,12 @@ var LatexSyntax = (() => {
     if (isEmptySequence(body)) return ["List"];
     const h = operator(body);
     if (h === "Range" || h === "Linspace") return body;
-    if (h === "Sequence") return ["List", ...operands(body)];
+    if (h === "Sequence") {
+      const elems = operands(body);
+      const inferred = tryInferRangeFromElements(elems, parser);
+      if (inferred) return inferred;
+      return ["List", ...elems];
+    }
     if (h === "Delimiter") {
       const delim = stringValue(operand(body, 2)) ?? "...";
       if (delim === ";" || delim === ".;.") {
@@ -5195,12 +5355,37 @@ var LatexSyntax = (() => {
       }
       if (delim === "," || delim === ".,.") {
         body = operand(body, 1);
-        if (operator(body) === "Sequence") return ["List", ...operands(body)];
+        if (operator(body) === "Sequence") {
+          const elems = operands(body);
+          const inferred = tryInferRangeFromElements(elems, parser);
+          if (inferred) return inferred;
+          return ["List", ...elems];
+        }
         return ["List", body ?? "Nothing"];
       }
     }
     return ["List", body];
   }
+  function tryInferRangeFromElements(elems, parser) {
+    if (elems.length < 4) return null;
+    const penultimate = elems[elems.length - 2];
+    if (symbol(penultimate) !== "ContinuationPlaceholder") return null;
+    const samples = elems.slice(0, -2);
+    const endExpr = elems[elems.length - 1];
+    if (samples.length < 2) return null;
+    const sampleNums = samples.map(machineValue);
+    if (sampleNums.some((n) => n === null)) return null;
+    const nums = sampleNums;
+    const step = nums[nums.length - 1] - nums[nums.length - 2];
+    const tol = parser.options.tolerance;
+    if (Math.abs(step) < tol)
+      return parser.error("degenerate-range-step", parser.index);
+    for (let i = 1; i < nums.length; i++) {
+      if (Math.abs(nums[i] - nums[i - 1] - step) > tol)
+        return parser.error("inconsistent-range-samples", parser.index);
+    }
+    return ["Range", nums[0], endExpr, step];
+  }
   function serializeList(serializer, expr) {
     if (nops(expr) > 1 && operands(expr).every((x) => {
       const op = operator(x);
@@ -5452,6 +5637,35 @@ var LatexSyntax = (() => {
       ["Element", index, ["Range", lower, upper]]
     ];
   }
+  function parseForComprehension(parser, lhs, until) {
+    const bindingTerminator = {
+      minPrec: 21,
+      // Above comma (20) and ; (19), so `x = L_1` is captured whole
+      condition: (p) => {
+        if (until?.condition?.(p)) return true;
+        const saved = p.index;
+        p.skipVisualSpace();
+        const isComma = p.peek === ",";
+        p.index = saved;
+        return isComma;
+      }
+    };
+    const elements = [];
+    do {
+      parser.skipVisualSpace();
+      const binding = parser.parseExpression(bindingTerminator);
+      if (binding === null) break;
+      const op = operator(binding);
+      if (op !== "Equal" && op !== "Assign") return null;
+      const name = operand(binding, 1);
+      const list = operand(binding, 2);
+      if (!name || !list) return null;
+      elements.push(["Element", name, list]);
+      parser.skipVisualSpace();
+    } while (parser.match(","));
+    if (elements.length === 0) return null;
+    return ["Loop", lhs, ...elements];
+  }
   function parseWhereExpression(parser, lhs, until) {
     const bindingTerminator = {
       minPrec: 21,
@@ -7370,6 +7584,8 @@ var LatexSyntax = (() => {
       precedence: DIVISION_PRECEDENCE,
       parse: "Mod"
     },
+    // Function-style alias: `\operatorname{mod}(a, b)`
+    { latexTrigger: "\\operatorname{mod}", parse: "Mod" },
     {
       latexTrigger: "\\pmod",
       kind: "prefix",
@@ -7610,6 +7826,13 @@ var LatexSyntax = (() => {
         const rhs = serializer.wrap(operand(expr, 2), ADDITION_PRECEDENCE + 3);
         return joinLatex([lhs, "-", rhs]);
       }
+    },
+    // Euclidean distance between two points (tuples of numbers).
+    {
+      name: "Distance",
+      latexTrigger: ["\\operatorname{distance}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{distance}" + serializer.wrapArguments(expr)
     }
   ];
   function getIndexAssignment(expr, upper) {
@@ -9034,7 +9257,9 @@ var LatexSyntax = (() => {
         if (!expr || !symbol(expr)) return null;
         return ["Mean", expr];
       }
-    }
+    },
+    // Function-style alias: `\operatorname{var}(...)`
+    { latexTrigger: "\\operatorname{var}", parse: "Variance" }
   ];
 
   // src/compute-engine/numerics/unit-data.ts
@@ -10042,7 +10267,7 @@ var LatexSyntax = (() => {
           36: "\\qquad"
         }[v] ?? "";
       }
-    }
+    },
     // if (
     //   [
     //     '\\!',
@@ -10066,6 +10291,121 @@ var LatexSyntax = (() => {
     //     name: '',
     //     trigger: '\\check',
     // },
+    // ---------------------------------------------------------------------------
+    // Function-style aliases for collection / random operators that some
+    // notations write in lowercase (e.g. `\operatorname{shuffle}(L)`).
+    // The capitalized library entries already exist; these are pure parse
+    // aliases so the lowercase names don't land in `unsupported-operator`.
+    // ---------------------------------------------------------------------------
+    { latexTrigger: "\\operatorname{random}", parse: "Random" },
+    { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
+    { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
+    { latexTrigger: "\\operatorname{join}", parse: "Join" },
+    // ---------------------------------------------------------------------------
+    // Geometric primitive heads. Registered as known typed heads so consumers
+    // can branch on the operator name; CE itself doesn't render them. The
+    // library entries (with no evaluator) live in `library/core.ts`.
+    // ---------------------------------------------------------------------------
+    {
+      name: "Triangle",
+      latexTrigger: ["\\operatorname{triangle}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{triangle}" + serializer.wrapArguments(expr)
+    },
+    // Desmos's geometric `vector(p1, p2)` — a directed segment between two
+    // points. Routed to a dedicated head (not the existing column-vector
+    // `Vector`, which has a narrower `(number+) -> vector` signature).
+    {
+      name: "GeometricVector",
+      latexTrigger: ["\\operatorname{vector}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{vector}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "Sphere",
+      latexTrigger: ["\\operatorname{sphere}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{sphere}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "Segment",
+      latexTrigger: ["\\operatorname{segment}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{segment}" + serializer.wrapArguments(expr)
+    }
+  ];
+
+  // src/compute-engine/latex-syntax/dictionary/definitions-colors.ts
+  var DEFINITIONS_COLORS = [
+    // Color constructors (one per colorspace, preserves space on evaluation)
+    {
+      name: "Rgb",
+      latexTrigger: ["\\operatorname{rgb}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{rgb}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "Hsv",
+      latexTrigger: ["\\operatorname{hsv}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{hsv}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "Hsl",
+      latexTrigger: ["\\operatorname{hsl}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{hsl}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "Oklab",
+      latexTrigger: ["\\operatorname{oklab}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{oklab}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "Oklch",
+      latexTrigger: ["\\operatorname{oklch}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{oklch}" + serializer.wrapArguments(expr)
+    },
+    // Conversion functions (color → color in the named space)
+    {
+      name: "AsRgb",
+      latexTrigger: ["\\operatorname{asRgb}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{asRgb}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "AsHsv",
+      latexTrigger: ["\\operatorname{asHsv}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{asHsv}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "AsHsl",
+      latexTrigger: ["\\operatorname{asHsl}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{asHsl}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "AsOklab",
+      latexTrigger: ["\\operatorname{asOklab}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{asOklab}" + serializer.wrapArguments(expr)
+    },
+    {
+      name: "AsOklch",
+      latexTrigger: ["\\operatorname{asOklch}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{asOklch}" + serializer.wrapArguments(expr)
+    },
+    // Perceptual difference (returns a scalar in [0, ~1])
+    {
+      name: "ColorDelta",
+      latexTrigger: ["\\operatorname{colorDelta}"],
+      kind: "function",
+      serialize: (serializer, expr) => "\\operatorname{colorDelta}" + serializer.wrapArguments(expr)
+    }
   ];
 
   // src/compute-engine/latex-syntax/dictionary/default-dictionary.ts
@@ -10096,7 +10436,8 @@ var LatexSyntax = (() => {
     ...DEFINITIONS_STATISTICS,
     ...DEFINITIONS_UNITS,
     ...DEFINITIONS_OTHERS,
-    ...DEFINITIONS_PHYSICS
+    ...DEFINITIONS_PHYSICS,
+    ...DEFINITIONS_COLORS
   ];
 
   // src/math-json/symbols.ts
@@ -10261,6 +10602,17 @@ var LatexSyntax = (() => {
       } else if (Array.isArray(openTrigger) && openTrigger.length > 0) {
         openTokens.push(openTrigger[0]);
       }
+      const closeTrigger = indexedEntry.closeTrigger;
+      const closeTokens = /* @__PURE__ */ new Set();
+      if (typeof closeTrigger === "string") {
+        const variants = DELIMITER_SHORTHAND[closeTrigger];
+        if (variants) for (const v of variants) closeTokens.add(v);
+        else closeTokens.add(closeTrigger);
+        if (closeTrigger === "||") closeTokens.add("|");
+      } else if (Array.isArray(closeTrigger) && closeTrigger.length > 0) {
+        closeTokens.add(closeTrigger[0]);
+      }
+      indexedEntry.closeTokens = closeTokens;
       for (const token of openTokens) {
         const existing = result.matchfixByOpen.get(token);
         if (existing) {
@@ -10452,11 +10804,7 @@ var LatexSyntax = (() => {
         if (style === "scaled")
           return joinLatex([`\\left${openDelim}`, inner, `\\right${closeDelim}`]);
         if (style === "big")
-          return joinLatex([
-            `\\Bigl${openDelim}`,
-            inner,
-            `\\Bigr${closeDelim}`
-          ]);
+          return joinLatex([`\\Bigl${openDelim}`, inner, `\\Bigr${closeDelim}`]);
         return joinLatex([openDelim, inner, closeDelim]);
       };
     }
@@ -13185,7 +13533,7 @@ var LatexSyntax = (() => {
       }
       if (this.match("\\hskip") || this.match("\\kern")) {
         this.skipSpace();
-        this.match("-") || this.match("+");
+        if (!this.match("-")) this.match("+");
         while (/^[\d.]$/.test(this.peek)) this.nextToken();
         for (const unit of [
           "pt",
@@ -13699,6 +14047,19 @@ var LatexSyntax = (() => {
       }
       for (const def of defs) {
         this.index = start;
+        if (def.closeTokens.size > 0) {
+          let found = false;
+          const tokens = this._tokens;
+          for (let i = start; i < tokens.length; i++) {
+            if (def.closeTokens.has(tokens[i])) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) continue;
+        }
+        if (typeof def.openTrigger === "string" && def.openTrigger === "." && !OPEN_DELIMITER_PREFIX[currentToken])
+          continue;
         const matched = this.matchDelimiter(def.openTrigger, def.closeTrigger);
         if (!matched) continue;
         const bodyStart = this.index;
@@ -14361,6 +14722,19 @@ var LatexSyntax = (() => {
         } while (postfix !== null);
       }
       if (result !== null) result = this.parseSupsub(result);
+      if (result !== null) {
+        let postfix = null;
+        let index = this.index;
+        do {
+          postfix = this.parsePostfixOperator(result, until);
+          result = postfix ?? result;
+          if (this.index === index && postfix !== null) {
+            console.assert(this.index !== index, "No token consumed");
+            break;
+          }
+          index = this.index;
+        } while (postfix !== null);
+      }
       if (result === null) {
         result = this.options.parseUnexpectedToken?.(null, this) ?? null;
         if (result === null && this.peek.startsWith("\\")) {
@@ -14869,6 +15243,28 @@ var LatexSyntax = (() => {
   }
 
   // src/compute-engine/latex-syntax/serializer.ts
+  var DOT_NOTATION_MAP = {
+    First: ".x",
+    Second: ".y",
+    Third: ".z",
+    Real: ".\\operatorname{real}",
+    Imaginary: ".\\operatorname{imag}",
+    Length: ".\\operatorname{count}",
+    Sum: ".\\operatorname{total}",
+    Max: ".\\max",
+    Min: ".\\min"
+  };
+  function trySerializeDotNotation(serializer, expr) {
+    if (!serializer.options.dotNotation) return null;
+    const ops = operands(expr);
+    if (!ops || ops.length !== 1) return null;
+    const head = operator(expr);
+    if (!head) return null;
+    const suffix = DOT_NOTATION_MAP[head];
+    if (suffix === void 0) return null;
+    const lhs = serializer.wrap(ops[0], 810);
+    return `${lhs}${suffix}`;
+  }
   var ACCENT_MODIFIERS = {
     deg: (s) => `${s}\\degree`,
     prime: (s) => `${s}^{\\prime}`,
@@ -14912,6 +15308,7 @@ var LatexSyntax = (() => {
     constructor(dictionary, options) {
       this.dictionary = dictionary;
       this.options = {
+        dotNotation: false,
         dmsFormat: false,
         angleNormalization: "none",
         ...options
@@ -15010,6 +15407,8 @@ var LatexSyntax = (() => {
       return def?.serialize?.(this, expr) ?? serializeSymbol(symbol(expr)) ?? "";
     }
     serializeFunction(expr, def) {
+      const dotResult = trySerializeDotNotation(this, expr);
+      if (dotResult !== null) return dotResult;
       if (def?.serialize) return def.serialize(this, expr);
       const h = operator(expr);
       return serializeSymbol(h, "auto") + this.wrapArguments(expr);
@@ -15252,6 +15651,8 @@ var LatexSyntax = (() => {
       preserveLatex: opts.preserveLatex ?? false,
       quantifierScope: opts.quantifierScope ?? "tight",
       timeDerivativeVariable: opts.timeDerivativeVariable ?? "t",
+      // Standalone mode has no engine; use the same default as ComputeEngine
+      tolerance: 1e-7,
       // Callbacks -- standalone mode has no engine, so these are stubs
       getSymbolType: (_id) => BoxedType.unknown,
       hasSubscriptEvaluate: (_id) => false,
@@ -15284,6 +15685,7 @@ var LatexSyntax = (() => {
       invisiblePlus: "",
       multiply: "\\times",
       missingSymbol: "\\blacksquare",
+      dotNotation: false,
       dmsFormat: false,
       angleNormalization: "none",
       // Style callbacks -- use same defaults as the engine
@@ -15352,7 +15754,7 @@ var LatexSyntax = (() => {
   }
 
   // src/latex-syntax.ts
-  var version = "0.55.6";
+  var version = "0.57.0";
   return __toCommonJS(latex_syntax_exports);
 })();
 Object.assign(exports, LatexSyntax); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/math-json.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.6 */
+/** Compute Engine 0.57.0 */
 
 // src/math-json/utils.ts
 function isNumberObject(expr) {
@@ -115,7 +115,7 @@ function expressionToDictionaryValue(expr) {
 }
 
 // src/math-json.ts
-var version = "0.55.6";
+var version = "0.57.0";
 export {
   dictionaryFromExpression,
   isFunctionObject,