@cortex-js/compute-engine 0.55.5 → 0.56.0

package/dist/latex-syntax.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.5 */
+/** Compute Engine 0.56.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) {
@@ -4743,10 +4745,6 @@ var DEFINITIONS_CORE = [
   // Lagrange notation
   {
     name: "Derivative",
-    // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
-    // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
-    // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
-    // Newton notation (\dot{v}, \ddot{v}) is implemented below
     serialize: (serializer, expr) => {
       const degree = machineValue(operand(expr, 2)) ?? 1;
       const base = serializer.serialize(operand(expr, 1));
@@ -5784,14 +5782,18 @@ var DEFINITIONS_SETS = [
       return ["Complement", lhs];
     }
     // precedence: 240,
-    // @todo: serialize for the multiple argument case
   },
   {
     name: "Complement",
     latexTrigger: ["^", "<{>", "\\complement", "<}>"],
-    kind: "postfix"
+    kind: "postfix",
     // precedence: 240,
-    // @todo: serialize for the multiple argument case
+    serialize: (serializer, expr) => {
+      return joinLatex([
+        serializer.serialize(operand(expr, 1)),
+        "^\\complement"
+      ]);
+    }
   },
   {
     name: "Intersection",
@@ -5878,7 +5880,6 @@ var DEFINITIONS_SETS = [
   // commands like \rbrack a, b \rbrack which are unambiguous.
   {
     name: "Multiple",
-    // @todo: parse
     serialize: serializeSet
   },
   {
@@ -5887,14 +5888,28 @@ var DEFINITIONS_SETS = [
     kind: "infix",
     precedence: 350
   },
+  // \mid as a separator/operator (used in set-builder notation: {x \mid x > 0})
+  // Low precedence so it binds loosely — everything on each side is parsed first
+  {
+    name: "Divides",
+    latexTrigger: ["\\mid"],
+    kind: "infix",
+    precedence: 160
+  },
   {
     name: "Set",
     kind: "matchfix",
     openTrigger: "{",
     closeTrigger: "}",
-    // @todo: the set syntax can also include conditions...
     parse: (_parser, body) => {
       if (isEmptySequence(body)) return "EmptySet";
+      const h = operator(body);
+      if (h === "Divides" || h === "Colon") {
+        const expr = operand(body, 1);
+        const condition = operand(body, 2);
+        if (expr !== null && condition !== null)
+          return ["Set", expr, ["Condition", condition]];
+      }
       if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
         body = operand(body, 1);
       }
@@ -5902,6 +5917,17 @@ var DEFINITIONS_SETS = [
       return ["Set", ...operands(body)];
     },
     serialize: (serializer, expr) => {
+      if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
+        const condition = operand(expr, 2);
+        return joinLatex([
+          "\\lbrace",
+          serializer.serialize(operand(expr, 1)),
+          "\\mid",
+          // Serialize the inner expression of the Condition wrapper
+          serializer.serialize(operand(condition, 1)),
+          "\\rbrace"
+        ]);
+      }
       return joinLatex([
         "\\lbrace",
         operands(expr).map((x) => serializer.serialize(x)).join(", "),
@@ -6068,23 +6094,6 @@ function serializeSet(serializer, expr) {
   if (expr === null) return "";
   const h = operator(expr);
   if (!h) return "";
-  if (h === "Set") {
-    if (nops(expr) === 0) return "\\emptyset";
-    if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
-      return joinLatex([
-        "\\left\\lbrace",
-        serializer.serialize(operand(expr, 1)),
-        "\\middle\\mid",
-        serializer.serialize(operand(expr, 2)),
-        "\\right\\rbrace"
-      ]);
-    }
-    return joinLatex([
-      "\\left\\lbrace",
-      ...operands(expr).map((x) => serializer.serialize(x) + " ,"),
-      "\\right\\rbrace"
-    ]);
-  }
   if (h === "Multiple") {
   }
   if (h === "Range") {
@@ -7232,11 +7241,13 @@ var DEFINITIONS_ARITHMETIC = [
       if (!parser.match("_")) return null;
       const base = parser.parseGroup();
       if (operator(base) !== "To") return null;
-      const expr = parser.parseArguments("implicit");
+      const expr = parser.parseExpression({
+        minPrec: MULTIPLICATION_PRECEDENCE
+      });
       if (!expr) return null;
       return [
         "Limit",
-        ["Function", expr[0], operand(base, 1)],
+        ["Function", expr, operand(base, 1)],
         operand(base, 2)
       ];
     },
@@ -7317,6 +7328,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",
@@ -7557,6 +7570,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) {
@@ -8981,7 +9001,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
@@ -9440,12 +9462,52 @@ var DEFINITIONS_UNITS = [
 ];
 
 // src/compute-engine/latex-syntax/dictionary/definitions-other.ts
+var TEX_UNITS = [
+  "pt",
+  "em",
+  "mu",
+  "ex",
+  "mm",
+  "cm",
+  "in",
+  "bp",
+  "sp",
+  "dd",
+  "cc",
+  "pc",
+  "nc",
+  "nd"
+];
+function skipTexDimension(parser) {
+  parser.skipSpace();
+  if (parser.peek === "-" || parser.peek === "+") parser.nextToken();
+  while (/^[\d.]$/.test(parser.peek)) parser.nextToken();
+  for (const unit of TEX_UNITS) {
+    if (parser.matchAll([...unit])) return;
+  }
+}
 function parseSingleArg(cmd) {
   return (parser) => {
     const arg = parser.parseGroup();
     return arg === null ? [cmd] : [cmd, arg];
   };
 }
+function parseMathStyleSwitch(mathStyle) {
+  return (parser) => {
+    const body = parser.parseExpression();
+    if (body !== null && !isEmptySequence(body))
+      return ["Annotated", body, { dict: { mathStyle } }];
+    return "Nothing";
+  };
+}
+function parseSizeSwitch(size) {
+  return (parser) => {
+    const body = parser.parseExpression();
+    if (body !== null && !isEmptySequence(body))
+      return ["Annotated", body, { dict: { size } }];
+    return "Nothing";
+  };
+}
 var DEFINITIONS_OTHERS = [
   {
     name: "Overscript",
@@ -9685,80 +9747,71 @@ var DEFINITIONS_OTHERS = [
   },
   {
     latexTrigger: ["\\displaystyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("normal")
   },
   {
     latexTrigger: ["\\textstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("compact")
   },
   {
     latexTrigger: ["\\scriptstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("script")
   },
   {
     latexTrigger: ["\\scriptscriptstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("scriptscript")
   },
   {
     latexTrigger: ["\\color"],
     parse: (parser) => {
-      parser.parseGroup();
+      const color = parser.parseStringGroup();
+      if (color !== null) {
+        const body = parser.parseExpression();
+        if (body !== null && !isEmptySequence(body))
+          return ["Annotated", body, { dict: { color } }];
+      }
       return "Nothing";
     }
   },
   {
     latexTrigger: ["\\tiny"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(1)
   },
   {
     latexTrigger: ["\\scriptsize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(2)
   },
   {
     latexTrigger: ["\\footnotesize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(3)
   },
   {
     latexTrigger: ["\\small"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(4)
   },
   {
     latexTrigger: ["\\normalsize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(5)
   },
   {
     latexTrigger: ["\\large"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(6)
   },
   {
     latexTrigger: ["\\Large"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(7)
   },
   {
     latexTrigger: ["\\LARGE"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(8)
   },
   {
     latexTrigger: ["\\huge"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(9)
   },
   {
     latexTrigger: ["\\Huge"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(10)
   },
   {
     name: "Annotated",
@@ -9770,6 +9823,10 @@ var DEFINITIONS_OTHERS = [
         result = joinLatex(["{\\displaystyle", result, "}"]);
       else if (dict.dict.mathStyle === "compact")
         result = joinLatex(["{\\textstyle", result, "}"]);
+      else if (dict.dict.mathStyle === "script")
+        result = joinLatex(["{\\scriptstyle", result, "}"]);
+      else if (dict.dict.mathStyle === "scriptscript")
+        result = joinLatex(["{\\scriptscriptstyle", result, "}"]);
       const v = dict.dict.size;
       if (v !== null && v >= 1 && v <= 10) {
         result = joinLatex([
@@ -9857,6 +9914,28 @@ var DEFINITIONS_OTHERS = [
     latexTrigger: ["\\enspace"],
     parse: () => ["HorizontalSpacing", 9]
   },
+  {
+    latexTrigger: ["\\hspace"],
+    parse: (parser) => {
+      if (parser.peek === "*") parser.nextToken();
+      parser.parseStringGroup();
+      return ["HorizontalSpacing", 0];
+    }
+  },
+  {
+    latexTrigger: ["\\hskip"],
+    parse: (parser) => {
+      skipTexDimension(parser);
+      return ["HorizontalSpacing", 0];
+    }
+  },
+  {
+    latexTrigger: ["\\kern"],
+    parse: (parser) => {
+      skipTexDimension(parser);
+      return ["HorizontalSpacing", 0];
+    }
+  },
   {
     latexTrigger: ["\\phantom"],
     parse: (parser) => {
@@ -9907,7 +9986,17 @@ var DEFINITIONS_OTHERS = [
     // `["HorizontalSpacing", expr, 'op'|'bin'|rel]` -> indicate a spacing around and expression, i.e. `\mathbin{x}`, etc...
     serialize: (serializer, expr) => {
       if (operand(expr, 2) !== null) {
-        return serializer.serialize(operand(expr, 1));
+        const cls = stringValue(operand(expr, 2));
+        const inner = serializer.serialize(operand(expr, 1));
+        if (cls === "bin") return `\\mathbin{${inner}}`;
+        if (cls === "op") return `\\mathop{${inner}}`;
+        if (cls === "rel") return `\\mathrel{${inner}}`;
+        if (cls === "ord") return `\\mathord{${inner}}`;
+        if (cls === "open") return `\\mathopen{${inner}}`;
+        if (cls === "close") return `\\mathclose{${inner}}`;
+        if (cls === "punct") return `\\mathpunct{${inner}}`;
+        if (cls === "inner") return `\\mathinner{${inner}}`;
+        return inner;
       }
       const v = machineValue(operand(expr, 1));
       if (v === null) return "";
@@ -9922,7 +10011,7 @@ var DEFINITIONS_OTHERS = [
         36: "\\qquad"
       }[v] ?? "";
     }
-  }
+  },
   // if (
   //   [
   //     '\\!',
@@ -9946,6 +10035,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
@@ -9976,7 +10180,8 @@ var LATEX_DICTIONARY = [
   ...DEFINITIONS_STATISTICS,
   ...DEFINITIONS_UNITS,
   ...DEFINITIONS_OTHERS,
-  ...DEFINITIONS_PHYSICS
+  ...DEFINITIONS_PHYSICS,
+  ...DEFINITIONS_COLORS
 ];
 
 // src/math-json/symbols.ts
@@ -10141,6 +10346,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) {
@@ -10298,25 +10514,43 @@ function makeIndexedEntry(entry, onError) {
     result.arguments = entry.arguments;
   return result;
 }
+function serializeTabularBody(serializer, body) {
+  if (!body) return "";
+  if (operator(body) !== "List") return serializer.serialize(body);
+  const rows = operands(body);
+  if (rows.length === 0) return "";
+  if (!rows.every((row) => operator(row) === "List"))
+    return serializer.serialize(body);
+  return rows.map(
+    (row) => operands(row).map((cell) => serializer.serialize(cell)).join(" & ")
+  ).join(" \\\\\n");
+}
 function makeSerializeHandler(entry, latexTrigger, idTrigger) {
   if (typeof entry.serialize === "function") return entry.serialize;
   const kind = entry["kind"] ?? "expression";
   if (kind === "environment") {
     const envName = entry["symbolTrigger"] ?? entry.name ?? "unknown";
-    return (serializer, expr) => joinLatex([
-      `\\begin{${envName}}`,
-      serializer.serialize(operand(expr, 1)),
-      `\\end{${envName}}`
-    ]);
+    return (serializer, expr) => {
+      const body = operand(expr, 1);
+      return joinLatex([
+        `\\begin{${envName}}`,
+        serializeTabularBody(serializer, body),
+        `\\end{${envName}}`
+      ]);
+    };
   }
   if (isMatchfixEntry(entry)) {
     const openDelim = typeof entry.openTrigger === "string" ? DEFAULT_DELIMITER[entry.openTrigger] : tokensToString(entry.openTrigger);
     const closeDelim = typeof entry.closeTrigger === "string" ? DEFAULT_DELIMITER[entry.closeTrigger] : tokensToString(entry.closeTrigger);
-    return (serializer, expr) => joinLatex([
-      openDelim,
-      serializer.serialize(operand(expr, 1)),
-      closeDelim
-    ]);
+    return (serializer, expr) => {
+      const style = serializer.groupStyle(expr, serializer.level + 1);
+      const inner = serializer.serialize(operand(expr, 1));
+      if (style === "scaled")
+        return joinLatex([`\\left${openDelim}`, inner, `\\right${closeDelim}`]);
+      if (style === "big")
+        return joinLatex([`\\Bigl${openDelim}`, inner, `\\Bigr${closeDelim}`]);
+      return joinLatex([openDelim, inner, closeDelim]);
+    };
   }
   let latex = entry.serialize;
   if (latex === void 0 && latexTrigger) latex = tokensToString(latexTrigger);
@@ -12579,6 +12813,16 @@ function parseNumber(parser, fmt) {
 }
 
 // src/compute-engine/latex-syntax/parse.ts
+var _symbolToUnicode = null;
+function getSymbolToUnicode() {
+  if (!_symbolToUnicode) {
+    _symbolToUnicode = /* @__PURE__ */ new Map();
+    for (const [, latex, codepoint] of SYMBOLS) {
+      _symbolToUnicode.set(latex, String.fromCodePoint(codepoint));
+    }
+  }
+  return _symbolToUnicode;
+}
 var DELIMITER_SHORTHAND2 = {
   "(": ["\\lparen", "("],
   ")": ["\\rparen", ")"],
@@ -13026,6 +13270,35 @@ var _Parser = class __Parser {
       this.nextToken();
       this.skipVisualSpace();
     }
+    if (this.match("\\hspace")) {
+      this.match("*");
+      this.parseStringGroup();
+      this.skipVisualSpace();
+    }
+    if (this.match("\\hskip") || this.match("\\kern")) {
+      this.skipSpace();
+      if (!this.match("-")) this.match("+");
+      while (/^[\d.]$/.test(this.peek)) this.nextToken();
+      for (const unit of [
+        "pt",
+        "em",
+        "mu",
+        "ex",
+        "mm",
+        "cm",
+        "in",
+        "bp",
+        "sp",
+        "dd",
+        "cc",
+        "pc",
+        "nc",
+        "nd"
+      ]) {
+        if (this.matchAll([...unit])) break;
+      }
+      this.skipVisualSpace();
+    }
     this.skipSpace();
   }
   match(token) {
@@ -13363,7 +13636,8 @@ var _Parser = class __Parser {
       } else if (token === "<space>") {
         result += " ";
       } else if (token[0] === "\\") {
-        result += token;
+        const unicode = getSymbolToUnicode().get(token);
+        result += unicode ?? token;
       } else {
         result += token;
       }
@@ -13517,6 +13791,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;
@@ -14723,7 +15010,7 @@ var STYLE_MODIFIERS = {
   sansserif: (s) => `\\mathsf{${s}}`,
   monospace: (s) => `\\mathtt{${s}}`
 };
-var Serializer4 = class {
+var Serializer5 = class {
   options;
   dictionary;
   level = -1;
@@ -14738,11 +15025,18 @@ var Serializer4 = class {
   /**
    * Serialize the expression, and if the expression is an operator
    * of precedence less than or equal to prec, wrap it in some parens.
-   * @todo: don't wrap Abs, Floor, Ceil, Delimiter
+   *
+   * Skip wrapping for matchfix operators (Abs, Floor, Ceil, Norm, etc.)
+   * and Delimiter since they already have visible delimiters.
    */
   wrap(expr, prec) {
     if (expr === null || expr === void 0) return "";
     if (prec === void 0) {
+      const name2 = operator(expr);
+      if (name2) {
+        const def = this.dictionary.ids.get(name2);
+        if (def?.kind === "matchfix") return this.serialize(expr);
+      }
       return this.wrapString(
         this.serialize(expr),
         this.options.groupStyle(expr, this.level + 1)
@@ -15036,7 +15330,7 @@ function serializeSymbol(s, style = "auto") {
   return body;
 }
 function serializeLatex(expr, dict, options) {
-  const serializer = new Serializer4(dict, options);
+  const serializer = new Serializer5(dict, options);
   return serializer.serialize(expr);
 }
 
@@ -15163,7 +15457,7 @@ function serialize(expr) {
 }
 
 // src/latex-syntax.ts
-var version = "0.55.5";
+var version = "0.56.0";
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,