@cortex-js/compute-engine 0.55.6 → 0.57.0

package/dist/latex-syntax.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.6 */
+/** Compute Engine 0.57.0 */
 
 // src/math-json/utils.ts
 var MISSING = ["Error", "'missing'"];
@@ -1146,6 +1146,7 @@ var SCALAR_TYPES = [
 ];
 var VALUE_TYPES = [
   "value",
+  "color",
   ...COLLECTION_TYPES,
   ...SCALAR_TYPES
 ];
@@ -2797,6 +2798,7 @@ var PRIMITIVE_SUBTYPES = {
   symbol: [],
   boolean: [],
   string: [],
+  color: [],
   expression: EXPRESSION_TYPES
 };
 function isPrimitiveSubtype(lhs, rhs) {
@@ -3679,6 +3681,64 @@ function parseQuantifier(kind) {
 }
 
 // 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"];
@@ -4150,6 +4210,15 @@ var DEFINITIONS_CORE = [
     }
   },
   { 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",
@@ -4170,6 +4239,29 @@ var DEFINITIONS_CORE = [
     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: ["_"],
@@ -4252,6 +4344,29 @@ var DEFINITIONS_CORE = [
       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",
@@ -4436,13 +4551,24 @@ var DEFINITIONS_CORE = [
       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),
@@ -4454,13 +4580,27 @@ var DEFINITIONS_CORE = [
             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
       ]);
     }
   },
@@ -4493,6 +4633,18 @@ var DEFINITIONS_CORE = [
     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",
@@ -4697,7 +4849,10 @@ var DEFINITIONS_CORE = [
       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];
     }
@@ -5138,7 +5293,12 @@ function parseBrackets(parser, body) {
   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 === ".;.") {
@@ -5151,12 +5311,37 @@ function parseBrackets(parser, body) {
     }
     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);
@@ -5408,6 +5593,35 @@ function parseForExpression(parser, until) {
     ["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,
@@ -7326,6 +7540,8 @@ var DEFINITIONS_ARITHMETIC = [
     precedence: DIVISION_PRECEDENCE,
     parse: "Mod"
   },
+  // Function-style alias: `\operatorname{mod}(a, b)`
+  { latexTrigger: "\\operatorname{mod}", parse: "Mod" },
   {
     latexTrigger: "\\pmod",
     kind: "prefix",
@@ -7566,6 +7782,13 @@ var DEFINITIONS_ARITHMETIC = [
       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) {
@@ -8990,7 +9213,9 @@ var DEFINITIONS_STATISTICS = [
       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
@@ -9998,7 +10223,7 @@ var DEFINITIONS_OTHERS = [
         36: "\\qquad"
       }[v] ?? "";
     }
-  }
+  },
   // if (
   //   [
   //     '\\!',
@@ -10022,6 +10247,121 @@ var DEFINITIONS_OTHERS = [
   //     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
@@ -10052,7 +10392,8 @@ var LATEX_DICTIONARY = [
   ...DEFINITIONS_STATISTICS,
   ...DEFINITIONS_UNITS,
   ...DEFINITIONS_OTHERS,
-  ...DEFINITIONS_PHYSICS
+  ...DEFINITIONS_PHYSICS,
+  ...DEFINITIONS_COLORS
 ];
 
 // src/math-json/symbols.ts
@@ -10217,6 +10558,17 @@ function addEntry(result, entry, onError) {
     } 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) {
@@ -10408,11 +10760,7 @@ function makeSerializeHandler(entry, latexTrigger, idTrigger) {
       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]);
     };
   }
@@ -13141,7 +13489,7 @@ var _Parser = class __Parser {
     }
     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",
@@ -13655,6 +14003,19 @@ var _Parser = class __Parser {
     }
     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;
@@ -14317,6 +14678,19 @@ var _Parser = class __Parser {
       } 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("\\")) {
@@ -14825,6 +15199,28 @@ function toDecimalNumber(wholePart, fractionalPart, exp) {
 }
 
 // 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}`,
@@ -14868,6 +15264,7 @@ var Serializer5 = class {
   constructor(dictionary, options) {
     this.dictionary = dictionary;
     this.options = {
+      dotNotation: false,
       dmsFormat: false,
       angleNormalization: "none",
       ...options
@@ -14966,6 +15363,8 @@ var Serializer5 = class {
     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);
@@ -15208,6 +15607,8 @@ function defaultParseOptions(opts) {
     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,
@@ -15240,6 +15641,7 @@ function defaultSerializeOptions(opts) {
     invisiblePlus: "",
     multiply: "\\times",
     missingSymbol: "\\blacksquare",
+    dotNotation: false,
     dmsFormat: false,
     angleNormalization: "none",
     // Style callbacks -- use same defaults as the engine
@@ -15308,7 +15710,7 @@ function serialize(expr) {
 }
 
 // src/latex-syntax.ts
-var version = "0.55.6";
+var version = "0.57.0";
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,