@cortex-js/compute-engine 0.12.4 → 0.12.6

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.12.4 */
+/** CortexJS Compute Engine 0.12.6 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1029,11 +1029,14 @@ var require_complex = __commonJS({
 });
 
 // src/compute-engine/latex-syntax/public.ts
-function isIdentifierEntry(entry) {
-  return !("kind" in entry) || entry.kind === "identifier";
+function isExpressionEntry(entry) {
+  return !("kind" in entry) || entry.kind === "expression";
+}
+function isSymbolEntry(entry) {
+  return "kind" in entry && entry.kind === "symbol";
 }
 function isFunctionEntry(entry) {
-  return !("kind" in entry) || entry.kind === "function";
+  return "kind" in entry && entry.kind === "function";
 }
 function isMatchfixEntry(entry) {
   return "kind" in entry && entry.kind === "matchfix";
@@ -4098,9 +4101,9 @@ function applyAssociativeOperator(op3, lhs, rhs, associativity = "both") {
   return [op3, lhs, rhs];
 }
 function getSequence(expr) {
-  let h = head(expr);
   if (expr === null)
     return null;
+  let h = head(expr);
   if (h === "Delimiter") {
     expr = op(expr, 1);
     if (expr === null)
@@ -4109,18 +4112,12 @@ function getSequence(expr) {
       return [expr];
   }
   h = head(expr);
-  if (h === "Sequence")
-    return ops(expr) ?? [];
-  return null;
+  if (h !== "Sequence")
+    return null;
+  return ops(expr) ?? [];
 }
 function isEmptySequence(expr) {
-  if (expr === null)
-    return false;
-  if (head(expr) !== "Sequence")
-    return false;
-  if (nops(expr) !== 0)
-    return false;
-  return true;
+  return expr !== null && head(expr) === "Sequence" && nops(expr) === 0;
 }
 function missingIfEmpty(expr) {
   if (expr === null || isEmptySequence(expr))
@@ -4231,8 +4228,8 @@ function numeratorDenominator(expr) {
   return [numerator, denominator];
 }
 function parseRoot(parser) {
-  const degree = parser.matchLatexOptionalGroup();
-  const base = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
+  const degree = parser.parseOptionalGroup();
+  const base = parser.parseGroup() ?? parser.parseToken();
   if (base === null || isEmptySequence(base)) {
     if (degree !== null)
       return ["Root", MISSING, missingIfEmpty(degree)];
@@ -4419,13 +4416,13 @@ function serializeMultiply(serializer, expr) {
   return isNegative ? "-" + result : result;
 }
 function parseFraction(parser) {
-  let numer = parser.matchLatexGroup();
+  let numer = parser.parseGroup();
   let denom = null;
   if (numer === null) {
-    numer = parser.matchSingleAtomArgument();
-    denom = parser.matchSingleAtomArgument();
+    numer = parser.parseToken();
+    denom = parser.parseToken();
   } else {
-    denom = parser.matchLatexGroup();
+    denom = parser.parseGroup();
   }
   numer = missingIfEmpty(numer);
   denom = missingIfEmpty(denom);
@@ -4433,7 +4430,7 @@ function parseFraction(parser) {
     const degree = op(numer, 3) ?? null;
     let fn = op(numer, 1);
     if (fn === null)
-      fn = missingIfEmpty(parser.matchExpression());
+      fn = missingIfEmpty(parser.parseExpression());
     let vars = [];
     if (head(denom) === "Multiply") {
       for (const arg of ops(denom) ?? []) {
@@ -4562,7 +4559,7 @@ var DEFINITIONS_ARITHMETIC = [
   {
     trigger: ["\\ang"],
     parse: (parser) => {
-      const arg = parser.matchLatexGroup();
+      const arg = parser.parseGroup();
       return arg === null ? ["Degrees"] : ["Degrees", arg];
     }
   },
@@ -4579,7 +4576,7 @@ var DEFINITIONS_ARITHMETIC = [
     trigger: ["\\tilde", "<{>", "\\infty", "<}>"],
     parse: "ComplexInfinity"
   },
-  { name: "Pi", trigger: ["\\pi"] },
+  { name: "Pi", kind: "symbol", trigger: ["\\pi"] },
   { trigger: ["\u03C0"], parse: "Pi" },
   {
     name: "ExponentialE",
@@ -4587,6 +4584,15 @@ var DEFINITIONS_ARITHMETIC = [
     parse: "ExponentialE",
     serialize: "\\exponentialE"
   },
+  {
+    kind: "function",
+    trigger: "exp",
+    parse: "Exp"
+  },
+  {
+    trigger: "\\exp",
+    parse: "Exp"
+  },
   {
     name: "ImaginaryUnit",
     trigger: ["\\imaginaryI"]
@@ -4606,10 +4612,7 @@ var DEFINITIONS_ARITHMETIC = [
   {
     trigger: "abs",
     kind: "function",
-    parse: (parser) => {
-      const arg = parser.matchArguments("enclosure");
-      return arg === null ? "Abs" : ["Abs", ...arg];
-    }
+    parse: "Abs"
   },
   {
     name: "Add",
@@ -4617,10 +4620,10 @@ var DEFINITIONS_ARITHMETIC = [
     kind: "infix",
     associativity: "both",
     precedence: 275,
-    parse: (parser, until, lhs) => {
-      if (275 < until.minPrec)
+    parse: (parser, lhs, until) => {
+      if (until && 275 < until.minPrec)
         return null;
-      const rhs = parser.matchExpression({ ...until, minPrec: 275 });
+      const rhs = parser.parseExpression({ ...until, minPrec: 275 });
       if (rhs === null)
         return null;
       return applyAssociativeOperator("Add", lhs, rhs);
@@ -4632,9 +4635,9 @@ var DEFINITIONS_ARITHMETIC = [
     trigger: ["+"],
     precedence: 275,
     parse: (parser, until) => {
-      if (275 < until.minPrec)
+      if (until && 275 < until.minPrec)
         return null;
-      return parser.matchExpression({ ...until, minPrec: 400 });
+      return parser.parseExpression({ ...until, minPrec: 400 });
     }
   },
   {
@@ -4643,13 +4646,16 @@ var DEFINITIONS_ARITHMETIC = [
     openDelimiter: "\\lceil",
     closeDelimiter: "\\rceil"
   },
+  {
+    kind: "matchfix",
+    openDelimiter: ["\u2308"],
+    closeDelimiter: ["\u2309"],
+    parse: (_, body) => ["Ceil", body]
+  },
   {
     trigger: "ceil",
     kind: "function",
-    parse: (parser) => {
-      const arg = parser.matchArguments("enclosure");
-      return arg === null ? "Ceil" : ["Ceil", ...arg];
-    }
+    parse: "Ceil"
   },
   {
     name: "Complex",
@@ -4710,11 +4716,12 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Exp",
-    serialize: (serializer, expr) => joinLatex([
-      "\\exponentialE^{",
-      serializer.serialize(missingIfEmpty(op(expr, 1))),
-      "}"
-    ])
+    serialize: (serializer, expr) => {
+      const op12 = op(expr, 1);
+      if (symbol(op12) || machineValue(op12) !== null)
+        return joinLatex(["\\exponentialE^{", serializer.serialize(op12)]);
+      return joinLatex(["\\exp", serializer.wrap(missingIfEmpty(op12))]);
+    }
   },
   {
     name: "Factorial",
@@ -4734,13 +4741,16 @@ var DEFINITIONS_ARITHMETIC = [
     openDelimiter: "\\lfloor",
     closeDelimiter: "\\rfloor"
   },
+  {
+    kind: "matchfix",
+    openDelimiter: ["\u230A"],
+    closeDelimiter: ["\u230B"],
+    parse: (_, body) => ["Floor", body]
+  },
   {
     trigger: "floor",
     kind: "function",
-    parse: (parser) => {
-      const arg = parser.matchArguments("enclosure");
-      return arg === null ? "Floor" : ["Floor", ...arg];
-    }
+    parse: "Floor"
   },
   {
     name: "Gcd",
@@ -4756,9 +4766,9 @@ var DEFINITIONS_ARITHMETIC = [
     trigger: ["\\lg"],
     serialize: (serializer, expr) => "\\log_{10}" + serializer.wrapArguments(expr),
     parse: (parser) => {
-      const arg = parser.matchArguments("implicit");
+      const arg = parser.parseArguments("implicit");
       if (arg === null)
-        return ["Lg"];
+        return "Lg";
       return ["Log", ...arg, 10];
     }
   },
@@ -4766,9 +4776,9 @@ var DEFINITIONS_ARITHMETIC = [
     name: "Lb",
     trigger: "\\lb",
     parse: (parser) => {
-      const arg = parser.matchArguments("implicit");
+      const arg = parser.parseArguments("implicit");
       if (arg === null)
-        return ["Log"];
+        return "Log";
       return ["Log", ...arg, 2];
     }
   },
@@ -4819,10 +4829,10 @@ var DEFINITIONS_ARITHMETIC = [
     kind: "infix",
     associativity: "both",
     precedence: 390,
-    parse: (parser, terminator, lhs) => {
-      if (391 < terminator.minPrec)
+    parse: (parser, lhs, terminator) => {
+      if (terminator && 391 < terminator.minPrec)
         return null;
-      const rhs = parser.matchExpression({ ...terminator, minPrec: 392 });
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 392 });
       if (rhs === null)
         return ["Multiply", lhs, MISSING];
       return applyAssociativeOperator("Multiply", lhs, rhs);
@@ -4833,10 +4843,10 @@ var DEFINITIONS_ARITHMETIC = [
     kind: "infix",
     associativity: "both",
     precedence: 390,
-    parse: (parser, terminator, lhs) => {
-      if (391 < terminator.minPrec)
+    parse: (parser, lhs, terminator) => {
+      if (terminator && 391 < terminator.minPrec)
         return null;
-      const rhs = parser.matchExpression({ ...terminator, minPrec: 392 });
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 392 });
       if (rhs === null)
         return ["Multiply", lhs, MISSING];
       return applyAssociativeOperator("Multiply", lhs, rhs);
@@ -4847,9 +4857,9 @@ var DEFINITIONS_ARITHMETIC = [
     trigger: ["-"],
     kind: "prefix",
     parse: (parser, terminator) => {
-      if (276 < terminator.minPrec)
+      if (terminator && 276 < terminator.minPrec)
         return null;
-      const rhs = parser.matchExpression({ ...terminator, minPrec: 400 });
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["Negate", missingIfEmpty(rhs)];
     },
     precedence: 275
@@ -4891,7 +4901,54 @@ var DEFINITIONS_ARITHMETIC = [
     trigger: ["\\pm"],
     kind: "infix",
     associativity: "both",
-    precedence: 270
+    precedence: 270,
+    serialize: (serializer, expr) => {
+      const op12 = op(expr, 1);
+      if (op12 === null)
+        return "\\pm";
+      if (nops(expr) === 1)
+        return joinLatex(["\\pm", serializer.serialize(op12)]);
+      const op22 = op(expr, 2);
+      return joinLatex([
+        serializer.serialize(op12),
+        "\\pm",
+        serializer.serialize(op22)
+      ]);
+    }
+  },
+  {
+    trigger: ["\\pm"],
+    kind: "prefix",
+    precedence: 270,
+    parse: (parser, terminator) => {
+      if (terminator && 270 < terminator.minPrec)
+        return null;
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
+      return ["PlusMinus", missingIfEmpty(rhs)];
+    }
+  },
+  {
+    trigger: ["\\plusmn"],
+    kind: "infix",
+    associativity: "both",
+    precedence: 270,
+    parse: (parser, lhs, terminator) => {
+      if (270 < terminator.minPrec)
+        return null;
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
+      return ["PlusMinus", lhs, missingIfEmpty(rhs)];
+    }
+  },
+  {
+    trigger: ["\\plusmn"],
+    kind: "prefix",
+    precedence: 270,
+    parse: (parser, terminator) => {
+      if (terminator && 270 < terminator.minPrec)
+        return null;
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
+      return ["PlusMinus", missingIfEmpty(rhs)];
+    }
   },
   {
     name: "Power",
@@ -4960,10 +5017,10 @@ var DEFINITIONS_ARITHMETIC = [
     kind: "infix",
     associativity: "both",
     precedence: 275,
-    parse: (parser, terminator, lhs) => {
+    parse: (parser, lhs, terminator) => {
       if (276 < terminator.minPrec)
         return null;
-      const rhs = parser.matchExpression({ ...terminator, minPrec: 277 });
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 277 });
       return ["Subtract", lhs, missingIfEmpty(rhs)];
     }
   }
@@ -4975,9 +5032,9 @@ function parseBigOp(name, prec) {
     let sub2 = null;
     while (!(sub2 && sup) && (parser.peek === "_" || parser.peek === "^")) {
       if (parser.match("_"))
-        sub2 = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
+        sub2 = parser.parseGroup() ?? parser.parseToken();
       else if (parser.match("^"))
-        sup = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
+        sup = parser.parseGroup() ?? parser.parseToken();
       parser.skipSpace();
     }
     if (sub2 === "Nothing" || isEmptySequence(sub2))
@@ -4995,7 +5052,7 @@ function parseBigOp(name, prec) {
     const sym = symbol(index);
     if (sym)
       parser.computeEngine?.pushScope({ [sym]: { domain: "Integer" } });
-    const fn = parser.matchExpression({ minPrec: prec + 1 });
+    const fn = parser.parseExpression({ minPrec: prec + 1 });
     if (sym)
       parser.computeEngine?.popScope();
     if (!fn)
@@ -5056,10 +5113,10 @@ function parseLog(command, parser) {
   let sub2 = null;
   let base = null;
   if (parser.match("_")) {
-    sub2 = parser.matchStringArgument() ?? parser.next();
+    sub2 = parser.parseStringGroup()?.trim() ?? parser.nextToken();
     base = Number.parseFloat(sub2 ?? "10");
   }
-  const arg = parser.matchArguments("implicit");
+  const arg = parser.parseArguments("implicit");
   if (arg === null)
     return [command];
   if (base === 10)
@@ -5088,7 +5145,7 @@ function parseSequence(parser, terminator, lhs, prec, sep) {
     if (parser.atTerminator(terminator)) {
       result.push("Nothing");
     } else {
-      const rhs = parser.matchExpression({ ...terminator, minPrec: prec });
+      const rhs = parser.parseExpression({ ...terminator, minPrec: prec });
       result.push(rhs ?? "Nothing");
       done = rhs === null;
     }
@@ -5108,15 +5165,18 @@ var DEFINITIONS_CORE = [
   //
   {
     trigger: ["\\placeholder"],
+    kind: "symbol",
     parse: (parser) => {
-      parser.skipSpaceTokens();
+      while (parser.match("<space>")) {
+      }
       if (parser.match("["))
         while (!parser.match("]") && !parser.atBoundary)
-          parser.next();
-      parser.skipSpaceTokens();
+          parser.nextToken();
+      while (parser.match("<space>")) {
+      }
       if (parser.match("<{>"))
         while (!parser.match("<}>") && !parser.atBoundary)
-          parser.next();
+          parser.nextToken();
       return "Nothing";
     }
   },
@@ -5125,7 +5185,6 @@ var DEFINITIONS_CORE = [
   //
   {
     name: "BaseForm",
-    kind: "function",
     serialize: (serializer, expr) => {
       const radix = machineValue(op(expr, 2)) ?? NaN;
       if (isFinite(radix) && radix >= 2 && radix <= 36) {
@@ -5172,9 +5231,9 @@ var DEFINITIONS_CORE = [
       let close = "";
       if (argCount > 1) {
         const op22 = stringValue(op(expr, 2)) ?? "";
-        open = op22[0] ?? "";
-        close = op22[1] ?? "";
-        sep = op22[2] ?? "";
+        open = op22[0] ?? "(";
+        close = op22[1] ?? ")";
+        sep = op22[2] ?? ",";
       }
       const body = head(arg1) === "List" ? serializeSequence(sep)(serializer, arg1) : serializer.serialize(arg1);
       serializer.wrapString(body, style, stringValue(op(expr, 2)) ?? void 0);
@@ -5194,22 +5253,22 @@ var DEFINITIONS_CORE = [
   {
     trigger: ["\\mathtip"],
     parse: (parser) => {
-      const op12 = parser.matchLatexGroup();
-      const op22 = parser.matchLatexGroup();
+      const op12 = parser.parseGroup();
+      const op22 = parser.parseGroup();
       return op12;
     }
   },
   {
     trigger: ["\\texttip"],
     parse: (parser) => {
-      const op12 = parser.matchLatexGroup();
-      const op22 = parser.matchLatexGroup();
+      const op12 = parser.parseGroup();
+      const op22 = parser.parseGroup();
       return op12;
     }
   },
   {
     trigger: ["\\error"],
-    parse: (parser) => parser.matchLatexGroup()
+    parse: (parser) => parser.parseGroup()
   },
   {
     name: "Error",
@@ -5271,12 +5330,12 @@ var DEFINITIONS_CORE = [
     kind: "matchfix",
     openDelimiter: "[",
     closeDelimiter: "]",
-    parse: (_parser, lhs) => {
-      if (lhs === null)
+    parse: (_parser, body) => {
+      if (body === null)
         return ["List"];
-      if (head(lhs) !== "Sequence" && head(lhs) !== "List")
-        return ["List", lhs];
-      return ["List", ...ops(lhs) ?? []];
+      if (head(body) !== "Sequence" && head(body) !== "List")
+        return ["List", body];
+      return ["List", ...ops(body) ?? []];
     },
     serialize: (serializer, expr) => {
       return joinLatex([
@@ -5309,8 +5368,8 @@ var DEFINITIONS_CORE = [
     // when the comma operator is used, the lhs and rhs are flattened,
     // i.e. `1,2,3` -> `["Delimiter", ["List", 1, 2, 3],  ","]`,
     // and `1, (2, 3)` -> `["Delimiter",
-    // ["Sequence", 1, ["Delimiter", ["List", 2, 3],  "(", ",", ")"]],  ","],
-    parse: (parser, terminator, lhs) => {
+    // ["Sequence", 1, ["Delimiter", ["List", 2, 3],  "()", ","]]],
+    parse: (parser, lhs, terminator) => {
       const seq = parseSequence(parser, terminator, lhs, 20, ",");
       if (seq === null)
         return null;
@@ -5325,7 +5384,7 @@ var DEFINITIONS_CORE = [
     trigger: [";"],
     kind: "infix",
     precedence: 19,
-    parse: (parser, terminator, lhs) => {
+    parse: (parser, lhs, terminator) => {
       const seq = parseSequence(parser, terminator, lhs, 19, ";");
       if (seq === null)
         return null;
@@ -5397,10 +5456,20 @@ var DEFINITIONS_CORE = [
     kind: "postfix",
     parse: (_parser, lhs) => ["Prime", missingIfEmpty(lhs), 2]
   },
+  {
+    trigger: ["^", "\\tripleprime"],
+    kind: "postfix",
+    parse: (_parser, lhs) => ["Prime", missingIfEmpty(lhs), 3]
+  },
   {
     name: "InverseFunction",
-    // trigger: '^{-1}',
-    // kind: 'postfix',
+    trigger: "^{-1}",
+    kind: "postfix",
+    parse: (parser, lhs) => {
+      if (parser.computeEngine?.box(lhs)?.domain.isFunction)
+        return ["InverseFunction", lhs];
+      return null;
+    },
     serialize: (serializer, expr) => serializer.serialize(op(expr, 1)) + "^{-1}"
   },
   {
@@ -5410,9 +5479,9 @@ var DEFINITIONS_CORE = [
       const base = serializer.serialize(op(expr, 1));
       if (degree === 1)
         return base + "^{\\prime}";
-      else if (degree === 2)
+      if (degree === 2)
         return base + "^{\\doubleprime}";
-      else if (degree === 3)
+      if (degree === 3)
         return base + "^{\\tripleprime}";
       return base + "^{(" + Number(degree).toString() + ")}";
     }
@@ -5422,7 +5491,7 @@ var DEFINITIONS_CORE = [
     trigger: "cases",
     kind: "environment",
     parse: (parser) => {
-      const tabular = parser.matchTabular("cases");
+      const tabular = parser.parseTabular();
       if (!tabular)
         return ["Which"];
       const result = ["Which"];
@@ -5471,9 +5540,9 @@ function parseTextRun(parser, style) {
       runs.push(parseTextRun(parser));
     } else if (parser.match("\\textbf") && parser.match("<{>")) {
       runs.push(parseTextRun(parser, { "font-weight": "bold" }));
-    } else if (parser.match("\\color") && parser.match("<{>")) {
-      const color = parser.matchColor();
-      if (color && parser.match("<}>")) {
+    } else if (parser.match("\\color")) {
+      const color = parser.parseStringGroup();
+      if (color !== null) {
         if (runinStyle !== null && text) {
           runs.push(["Style", text, { dict: runinStyle }]);
         } else if (text) {
@@ -5486,7 +5555,7 @@ function parseTextRun(parser, style) {
       text += " ";
     } else if (parser.match("<$>")) {
       const index = parser.index;
-      const expr = parser.matchExpression() ?? ["Sequence"];
+      const expr = parser.parseExpression() ?? ["Sequence"];
       parser.skipSpace();
       if (parser.match("<$>")) {
         runs.push(expr);
@@ -5496,7 +5565,7 @@ function parseTextRun(parser, style) {
       }
     } else if (parser.match("<$$>")) {
       const index = parser.index;
-      const expr = parser.matchExpression() ?? ["Sequence"];
+      const expr = parser.parseExpression() ?? ["Sequence"];
       parser.skipSpace();
       if (parser.match("<$$>")) {
         runs.push(expr);
@@ -5505,7 +5574,7 @@ function parseTextRun(parser, style) {
         parser.index = index;
       }
     } else
-      text += parser.matchChar() ?? parser.next();
+      text += parser.matchChar() ?? parser.nextToken();
   }
   if (runinStyle !== null && text) {
     runs.push(["Style", `'${text}'`, { dict: runinStyle }]);
@@ -5574,7 +5643,7 @@ function errorContextAsLatex(serializer, error) {
 // src/compute-engine/latex-syntax/dictionary/definitions-inequalities.ts
 var DEFINITIONS_INEQUALITIES = [
   {
-    trigger: ["!", "<"],
+    trigger: ["\\not", "<"],
     kind: "infix",
     associativity: "right",
     precedence: 246,
@@ -5620,7 +5689,7 @@ var DEFINITIONS_INEQUALITIES = [
     kind: "infix",
     associativity: "right",
     precedence: 241,
-    parse: "Equal"
+    parse: "LessEqual"
   },
   {
     trigger: ["\\leqslant"],
@@ -5756,7 +5825,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "NotApprox",
     // Note: Mathematica TildeTilde
-    trigger: ["\\approx"],
+    trigger: ["\\not", "\\approx"],
     kind: "infix",
     associativity: "right",
     precedence: 247
@@ -5772,7 +5841,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "NotApproxEqual",
     // Note: Mathematica NotTildeEqual
-    trigger: ["!", "\\approxeq"],
+    trigger: ["\\not", "\\approxeq"],
     kind: "infix",
     // Note: no LaTeX symbol for char U+2249
     associativity: "right",
@@ -5860,7 +5929,7 @@ var DEFINITIONS_INEQUALITIES = [
     precedence: 244
   },
   {
-    trigger: ["!", ">"],
+    trigger: ["\\not", ">"],
     kind: "infix",
     associativity: "right",
     precedence: 244,
@@ -6023,7 +6092,7 @@ var DEFINITIONS_LOGIC = [
 // src/compute-engine/latex-syntax/dictionary/definitions-other.ts
 function parseSingleArg(cmd) {
   return (parser) => {
-    const arg = parser.matchLatexGroup();
+    const arg = parser.parseGroup();
     return arg === null ? [cmd] : [cmd, arg];
   };
 }
@@ -6077,14 +6146,14 @@ var DEFINITIONS_OTHERS = [
   {
     name: "Transpose",
     trigger: ["^", "T"],
-    kind: "infix"
+    kind: "postfix"
     // @todo: if lhs is a list/tensor
   },
   {
     // @todo: if lhs is a list/tensor
     name: "ConjugateTranspose",
     trigger: ["^", "H"],
-    kind: "infix"
+    kind: "postfix"
   },
   {
     name: "StringJoin",
@@ -6114,9 +6183,9 @@ var DEFINITIONS_OTHERS = [
       while (!done) {
         parser.skipSpace();
         if (parser.match("_")) {
-          sub2 = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
+          sub2 = parser.parseGroup() ?? parser.parseToken();
         } else if (parser.match("^")) {
-          sup = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
+          sup = parser.parseGroup() ?? parser.parseToken();
         } else {
           done = true;
         }
@@ -6126,9 +6195,9 @@ var DEFINITIONS_OTHERS = [
         sub2 = ["List", ...seq];
       if (sub2 === null || sup === null)
         return null;
-      let rhs = parser.matchLatexGroup() ?? "Nothing";
+      let rhs = parser.parseGroup() ?? "Nothing";
       if (rhs !== "Nothing" && !isEmptySequence(rhs)) {
-        const arg = parser.matchArguments("enclosure") ?? ["Nothing"];
+        const arg = parser.parseArguments() ?? ["Nothing"];
         rhs = [rhs, ...arg];
       }
       return ["PartialDerivative", rhs, sub2, sup];
@@ -6405,7 +6474,7 @@ var DEFINITIONS_OTHERS = [
 // src/compute-engine/latex-syntax/dictionary/definitions-trigonometry.ts
 function parseTrig(op3) {
   return (parser, until) => {
-    let head2 = {
+    const head2 = {
       "\\arcsin": "Arcsin",
       "\\arccos": "Arccos",
       "\\arctan": "Arctan",
@@ -6440,37 +6509,11 @@ function parseTrig(op3) {
     }[op3 ?? ""] ?? op3 ?? "";
     if (parser.atTerminator(until))
       return head2;
-    let isInverse = false;
-    let primeLevel = 0;
-    let sup = null;
-    parser.skipSpace();
-    const start = parser.index;
-    if (parser.match("^")) {
-      parser.skipSpace();
-      const superscriptIndex = parser.index;
-      if (parser.matchAll(["<{>", "-", "1", "<}>"]))
-        isInverse = true;
-      else {
-        parser.index = start;
-        parser.index = start;
-        primeLevel = parser.matchPrimeSuffix();
-        if (primeLevel === 0) {
-          parser.index = superscriptIndex;
-          sup = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
-        }
-      }
-    }
-    primeLevel += parser.matchPrimeSuffix();
-    if (isInverse)
-      head2 = ["InverseFunction", head2];
-    if (primeLevel === 1)
-      head2 = ["Derivative", head2];
-    else if (primeLevel > 1)
-      head2 = ["Derivative", head2, primeLevel];
-    const args = parser.matchArguments("implicit", until);
-    if (args === null)
-      return sup ? [["Power", [head2], sup]] : head2;
-    return sup ? ["Power", [head2, ...args], sup] : [head2, ...args];
+    const fn = parser.parsePostfixOperator(head2, until);
+    if (fn !== null)
+      return fn;
+    const args = parser.parseArguments("implicit", until);
+    return args === null ? head2 : [head2, ...args];
   };
 }
 var DEFINITIONS_TRIGONOMETRY = [
@@ -6499,7 +6542,6 @@ var DEFINITIONS_TRIGONOMETRY = [
     parse: parseTrig("Arccot")
   },
   {
-    kind: "function",
     name: "Arcsec",
     trigger: "arcsec",
     parse: parseTrig("Arcsec")
@@ -6700,14 +6742,14 @@ var DEFINITIONS_SETS = [
     // Caution: cartesian product is not associative
     precedence: 390,
     // Same as Multiply?
-    parse: (parser, until, lhs) => {
+    parse: (parser, lhs, until) => {
       if (390 < until.minPrec)
         return null;
       const ce = parser.computeEngine;
       if (!ce || !ce.box(lhs).domain.isCompatible("Set"))
         return null;
       const index = parser.index;
-      const rhs = parser.matchExpression({ ...until, minPrec: 390 });
+      const rhs = parser.parseExpression({ ...until, minPrec: 390 });
       if (rhs === null || ce.box(lhs).domain.isCompatible("Set") !== true) {
         parser.index = index;
         return null;
@@ -6787,8 +6829,8 @@ var DEFINITIONS_SETS = [
     associativity: "right",
     precedence: 160,
     // As per MathML, lower precedence
-    parse: (parser, terminator, lhs) => {
-      const rhs = parser.matchExpression(terminator);
+    parse: (parser, lhs, terminator) => {
+      const rhs = parser.parseExpression(terminator);
       return rhs === null ? null : ["Element", rhs, lhs];
     }
   },
@@ -6993,9 +7035,10 @@ function parseIntegral(command, n = 1) {
     let sub2 = null;
     while (!(sub2 !== null && sup !== null) && (parser.peek === "_" || parser.peek === "^")) {
       if (parser.match("_"))
-        sub2 = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
-      else if (parser.match("^"))
-        sup = parser.matchLatexGroup() ?? parser.matchSingleAtomArgument();
+        sub2 = parser.parseGroup() ?? parser.parseToken();
+      else if (parser.match("^")) {
+        sup = parser.parseGroup() ?? parser.parseToken();
+      }
       parser.skipSpace();
     }
     if (sub2 === "Nothing" || isEmptySequence(sub2))
@@ -7071,7 +7114,7 @@ function makeRange(range) {
 function parseIntegralBody(parser, n = 1) {
   const start = parser.index;
   let found = false;
-  let fn = parser.matchExpression({
+  let fn = parser.parseExpression({
     minPrec: 266,
     condition: () => {
       if (parser.matchAll(["\\mathrm", "<{>", "d", "<}>"]))
@@ -7081,7 +7124,7 @@ function parseIntegralBody(parser, n = 1) {
   });
   if (!found) {
     parser.index = start;
-    fn = parser.matchExpression({
+    fn = parser.parseExpression({
       minPrec: 266,
       condition: () => {
         if (parser.match("d"))
@@ -7098,7 +7141,7 @@ function parseIntegralBody(parser, n = 1) {
 function parseIndexes(parser, n = 1) {
   parser.skipSpace();
   const result = [];
-  const index = symbol(parser.matchSymbol());
+  const index = symbol(parser.parseSymbol());
   if (index === null)
     return [];
   result.push(index);
@@ -7217,30 +7260,36 @@ function serializeIntegral(command) {
 }
 var DEFINITIONS_CALCULUS = [
   {
+    kind: "expression",
     name: "Integrate",
     trigger: ["\\int"],
     parse: parseIntegral("Integrate"),
     serialize: serializeIntegral("\\int")
   },
   {
+    kind: "expression",
     trigger: ["\\iint"],
     parse: parseIntegral("Integrate", 2)
   },
   {
+    kind: "expression",
     trigger: ["\\iiint"],
     parse: parseIntegral("Integrate", 3)
   },
   {
+    kind: "expression",
     name: "CircularIntegrate",
     trigger: ["\\oint"],
     parse: parseIntegral("CircularIntegrate"),
     serialize: serializeIntegral("\\oint")
   },
   {
+    kind: "expression",
     trigger: ["\\oiint"],
     parse: parseIntegral("CircularIntegrate", 2)
   },
   {
+    kind: "expression",
     trigger: ["\\oiiint"],
     parse: parseIntegral("CircularIntegrate", 3)
   }
@@ -7346,6 +7395,7 @@ var SYMBOLS = [
 var DEFINITIONS_SYMBOLS = [
   ...SYMBOLS.map(([symbol2, latex, _codepoint]) => {
     return {
+      kind: "symbol",
       name: symbol2,
       trigger: [latex],
       parse: symbol2
@@ -7353,6 +7403,7 @@ var DEFINITIONS_SYMBOLS = [
   }),
   ...SYMBOLS.map(([symbol2, _latex, codepoint]) => {
     return {
+      kind: "symbol",
       trigger: [String.fromCodePoint(codepoint)],
       parse: symbol2
     };
@@ -7381,98 +7432,99 @@ function triggerLength(trigger) {
     return trigger.length;
   return 1;
 }
+function addEntry(result, entry, onError) {
+  const [trigger, indexedEntry] = makeIndexedEntry(entry, onError);
+  if (indexedEntry === null)
+    return;
+  const kind = "kind" in entry ? entry.kind : "expression";
+  if (trigger && trigger.length === 2 && /[_^]/.test(trigger[0]) && trigger[1] !== "<{>" && kind !== "function" && entry.name) {
+    let parse = entry.parse;
+    if (parse === void 0) {
+      if (kind === "symbol")
+        parse = entry.name;
+      if (kind === "postfix" || kind === "prefix")
+        parse = (_parser, expr) => [entry.name, expr];
+    }
+    addEntry(
+      result,
+      {
+        ...entry,
+        kind,
+        parse,
+        name: void 0,
+        trigger: [trigger[0], "<{>", trigger[1], "<}>"]
+      },
+      onError
+    );
+  }
+  if (indexedEntry.name !== void 0) {
+    if (result.name.has(indexedEntry.name)) {
+      onError({
+        severity: "warning",
+        message: [
+          "invalid-dictionary-entry",
+          indexedEntry.name,
+          "Duplicate definition. The name must be unique, but a trigger can be used by multiple definitions."
+        ]
+      });
+    }
+    result.name.set(indexedEntry.name, indexedEntry);
+  }
+  if (indexedEntry.kind === "matchfix") {
+    result.matchfix.push(indexedEntry);
+  } else if (indexedEntry.kind === "environment") {
+    const triggerString = tokensToString(entry.trigger ?? "");
+    if (result.environment.has(triggerString)) {
+      onError({
+        severity: "warning",
+        message: [
+          "invalid-dictionary-entry",
+          triggerString,
+          "Duplicate environment definition"
+        ]
+      });
+    }
+    result.environment.set(triggerString, indexedEntry);
+  } else if (trigger) {
+    console.assert(entry.trigger);
+    const triggerString = tokensToString(entry.trigger ?? "");
+    const n = triggerLength(trigger);
+    result.lookahead = Math.max(result.lookahead, n);
+    if (indexedEntry.kind === "function") {
+      if (!result.function.has(triggerString))
+        result.function.set(triggerString, [indexedEntry]);
+      else
+        result.function.set(triggerString, [
+          ...result.function.get(triggerString),
+          indexedEntry
+        ]);
+    } else {
+      const kind2 = indexedEntry.kind;
+      if (result[kind2][n] === void 0)
+        result[kind2][n] = /* @__PURE__ */ new Map();
+      const list = result[kind2][n];
+      if (list.has(triggerString))
+        list.get(triggerString).push(indexedEntry);
+      else
+        list.set(triggerString, [indexedEntry]);
+    }
+  }
+}
 function indexLatexDictionary(dic, onError) {
   const result = {
     lookahead: 1,
     name: /* @__PURE__ */ new Map(),
+    expression: /* @__PURE__ */ new Map(),
     function: /* @__PURE__ */ new Map(),
-    identifier: [],
+    symbol: [],
     infix: [],
     prefix: [],
     postfix: [],
     environment: /* @__PURE__ */ new Map(),
     matchfix: []
   };
-  for (const entry of dic) {
-    const [trigger, indexedEntry] = makeIndexedEntry(entry, onError);
-    if (indexedEntry === null)
-      continue;
-    if (indexedEntry.name !== void 0) {
-      if (result.name.has(indexedEntry.name)) {
-        onError({
-          severity: "warning",
-          message: [
-            "invalid-dictionary-entry",
-            indexedEntry.name,
-            "Duplicate definition"
-          ]
-        });
-      }
-      result.name.set(indexedEntry.name, indexedEntry);
-    }
-    if (indexedEntry.kind === "matchfix") {
-      result.matchfix.push(indexedEntry);
-    } else if (indexedEntry.kind === "environment") {
-      const triggerString = tokensToString(entry.trigger ?? "");
-      if (result.environment.has(triggerString)) {
-        onError({
-          severity: "warning",
-          message: [
-            "invalid-dictionary-entry",
-            triggerString,
-            "Duplicate environment definition"
-          ]
-        });
-      }
-      result.environment.set(triggerString, indexedEntry);
-    } else if (trigger) {
-      console.assert(entry.trigger);
-      const triggerString = tokensToString(entry.trigger ?? "");
-      const n = triggerLength(trigger);
-      result.lookahead = Math.max(result.lookahead, n);
-      if (indexedEntry.kind === "function") {
-        if (!result.function.has(triggerString))
-          result.function.set(triggerString, [indexedEntry]);
-        else
-          result.function.set(triggerString, [
-            ...result.function.get(triggerString),
-            indexedEntry
-          ]);
-      } else if (indexedEntry.kind === "identifier") {
-        if (result.identifier[n] === void 0)
-          result.identifier[n] = /* @__PURE__ */ new Map();
-        const list = result.identifier[n];
-        if (list.has(triggerString))
-          list.get(triggerString).push(indexedEntry);
-        else
-          list.set(triggerString, [indexedEntry]);
-      } else if (indexedEntry.kind === "prefix") {
-        if (result.prefix[n] === void 0)
-          result.prefix[n] = /* @__PURE__ */ new Map();
-        const list = result.prefix[n];
-        if (list.has(triggerString))
-          list.get(triggerString).push(indexedEntry);
-        else
-          list.set(triggerString, [indexedEntry]);
-      } else if (indexedEntry.kind === "infix") {
-        if (result.infix[n] === void 0)
-          result.infix[n] = /* @__PURE__ */ new Map();
-        const list = result.infix[n];
-        if (list.has(triggerString))
-          list.get(triggerString).push(indexedEntry);
-        else
-          list.set(triggerString, [indexedEntry]);
-      } else if (indexedEntry.kind === "postfix") {
-        if (result.postfix[n] === void 0)
-          result.postfix[n] = /* @__PURE__ */ new Map();
-        const list = result.postfix[n];
-        if (list.has(triggerString))
-          list.get(triggerString).push(indexedEntry);
-        else
-          list.set(triggerString, [indexedEntry]);
-      }
-    }
-  }
+  for (const entry of dic)
+    addEntry(result, entry, onError);
   return result;
 }
 function makeIndexedEntry(entry, onError) {
@@ -7480,7 +7532,7 @@ function makeIndexedEntry(entry, onError) {
     return [null, null];
   const result = {
     name: entry.name,
-    kind: "kind" in entry ? entry.kind : "identifier"
+    kind: "kind" in entry ? entry.kind : "expression"
   };
   if (result.kind === "matchfix" && isMatchfixEntry(entry)) {
     result.openDelimiter = entry.openDelimiter;
@@ -7513,29 +7565,57 @@ function makeIndexedEntry(entry, onError) {
   const triggerString = trigger ? tokensToString(trigger) : "";
   if (result.kind === "function" && isFunctionEntry(entry)) {
     result.serialize = entry.serialize;
-    if (triggerString && !entry.serialize)
-      result.serialize = (serializer, expr) => `\\mathrm{${triggerString}}${serializer.wrapArguments(expr)}`;
-    result.parse = entry.parse;
-    if (!result.parse && entry.name)
-      result.parse = (parser) => {
-        const arg = parser.matchArguments("enclosure");
-        return arg === null ? entry.name : [entry.name, ...arg];
-      };
+    if (triggerString && !entry.serialize) {
+      if (triggerString.startsWith("\\")) {
+        result.serialize = (serializer, expr) => `${triggerString}${serializer.wrapArguments(expr)}`;
+      } else
+        result.serialize = (serializer, expr) => `\\mathrm{${triggerString}}${serializer.wrapArguments(expr)}`;
+    }
+    if (typeof entry.parse === "function")
+      result.parse = entry.parse;
+    else if (typeof entry.parse === "string")
+      result.parse = () => entry.parse;
+    else if (entry.name)
+      result.parse = () => entry.name;
     return [triggerString, result];
   }
-  if (typeof entry.trigger === "string") {
-    console.assert(
-      entry.parse || trigger.length > 1,
-      `Trigger shortcut should produce more than one token. Otherwise, not worth using the shortcut. (${triggerString})`
-    );
+  if (result.kind === "expression" && isExpressionEntry(entry)) {
+    result.serialize = entry.serialize ?? triggerString;
+    if (typeof result.serialize === "string") {
+      const serializeExpr = result.serialize;
+      result.serialize = (serializer, expr) => {
+        if (!head(expr))
+          return serializer.serialize(serializeExpr);
+        return `${serializer.serialize(
+          serializeExpr
+        )}${serializer.wrapArguments(expr)}`;
+      };
+    }
+    {
+      if (typeof entry.parse === "function") {
+        result.parse = entry.parse;
+      } else {
+        const parseResult = entry.parse ?? entry.name;
+        result.parse = () => parseResult;
+      }
+    }
+    return [triggerString, result];
   }
-  if (result.kind === "identifier" && isIdentifierEntry(entry)) {
+  console.assert(
+    typeof entry.trigger !== "string" || entry.parse || trigger.length > 1 || "kind" in entry && entry.kind === "function",
+    `Trigger shortcuts should produce more than one token. Otherwise, not worth using them. (${triggerString})`
+  );
+  if (result.kind === "symbol" && isSymbolEntry(entry)) {
     result.precedence = entry.precedence ?? 1e4;
   }
   if ((result.kind === "infix" || result.kind === "prefix" || result.kind === "postfix") && (isInfixEntry(entry) || isPrefixEntry(entry) || isPostfixEntry(entry))) {
-    if (trigger && (trigger[0] === "^" || trigger[0] === "_"))
+    if (trigger && (trigger[0] === "^" || trigger[0] === "_")) {
       result.precedence = 720;
-    else
+      console.assert(
+        entry.precedence === void 0,
+        "'precedence' not allowed with ^ and _ triggers"
+      );
+    } else
       result.precedence = entry.precedence ?? 1e4;
   }
   if (result.kind === "infix" && isInfixEntry(entry)) {
@@ -7548,7 +7628,7 @@ function makeIndexedEntry(entry, onError) {
     } else if (trigger && (trigger[0] === "^" || trigger[0] === "_")) {
       console.assert(!entry.parse);
       const name = entry.parse ?? entry.name;
-      result.parse = (_scanner, _terminator, arg) => [
+      result.parse = (_scanner, arg, _terminator) => [
         name,
         missingIfEmpty(op(arg, 1)),
         missingIfEmpty(op(arg, 2))
@@ -7557,11 +7637,11 @@ function makeIndexedEntry(entry, onError) {
       const head2 = entry.parse ?? entry.name;
       const prec = result.precedence;
       const associativity = result.associativity;
-      result.parse = (scanner, terminator, lhs) => {
+      result.parse = (scanner, lhs, terminator) => {
         if (prec < terminator.minPrec)
           return null;
         const rhs = missingIfEmpty(
-          scanner.matchExpression({
+          scanner.parseExpression({
             ...terminator,
             minPrec: prec
           })
@@ -7573,7 +7653,7 @@ function makeIndexedEntry(entry, onError) {
     if (typeof entry.parse === "function") {
       result.parse = entry.parse;
     } else if (entry.parse !== void 0) {
-      console.assert(result.kind === "identifier");
+      console.assert(result.kind === "symbol" || result.kind === "expression");
       result.parse = () => entry.parse;
     } else if (entry.parse === void 0 && entry.name !== void 0) {
       if (result.kind === "postfix") {
@@ -7583,9 +7663,9 @@ function makeIndexedEntry(entry, onError) {
         console.assert(entry.name);
         const head2 = entry.name;
         result.parse = (parser, terminator) => {
-          if (prec < terminator.minPrec)
+          if (terminator && prec < terminator.minPrec)
             return null;
-          const rhs = parser.matchExpression({ ...terminator, minPrec: prec });
+          const rhs = parser.parseExpression({ ...terminator, minPrec: prec });
           return rhs === null ? null : [head2, rhs];
         };
       }
@@ -7600,7 +7680,7 @@ function makeIndexedEntry(entry, onError) {
       result.serialize = triggerString + "#1";
     } else if (result.kind === "infix") {
       result.serialize = "#1" + triggerString + "#2";
-    } else if (result.kind === "identifier") {
+    } else if (result.kind === "symbol") {
       result.serialize = triggerString;
     } else {
       result.serialize = "";
@@ -7730,6 +7810,7 @@ var DEFAULT_LATEX_DICTIONARY = {
   physics: [
     {
       name: "mu0",
+      kind: "symbol",
       trigger: "\\mu_0"
     }
   ],
@@ -7779,6 +7860,7 @@ function matchIdentifierToken(parser, options) {
     special = {
       "+": "plus",
       "-": "minus",
+      "\\plusmn": "pm",
       "\\pm": "pm",
       "\\ast": "ast",
       "\\dag": "dag",
@@ -7794,22 +7876,22 @@ function matchIdentifierToken(parser, options) {
     }[token];
   }
   if (special) {
-    parser.next();
+    parser.nextToken();
     return special;
   }
   const i = SYMBOLS.findIndex((x) => x[1] === token);
   if (i >= 0) {
-    parser.next();
+    parser.nextToken();
     return SYMBOLS[i][0];
   }
-  return parser.matchChar() ?? parser.next();
+  return parser.matchChar() ?? parser.nextToken();
 }
 function matchIdentifierBody(parser) {
   let id = matchPrefixedIdentifier(parser);
   const start = parser.index;
   const prefix = IDENTIFIER_MODIFIER[parser.peek] ?? null;
   if (prefix) {
-    parser.next();
+    parser.nextToken();
     if (!parser.match("<{>")) {
       parser.index = start;
       return null;
@@ -7835,7 +7917,7 @@ function matchIdentifierBody(parser) {
       id += next;
     }
     while (!parser.atEnd && /\d/.test(parser.peek))
-      id += parser.next();
+      id += parser.nextToken();
   }
   while (!parser.atEnd) {
     if (parser.match("\\degree"))
@@ -7884,7 +7966,7 @@ function matchPrefixedIdentifier(parser) {
   const prefix = IDENTIFIER_PREFIX[parser.peek] ?? null;
   if (prefix === null)
     return null;
-  parser.next();
+  parser.nextToken();
   if (parser.match("<{>")) {
     let body = "";
     const digit = {
@@ -7901,7 +7983,7 @@ function matchPrefixedIdentifier(parser) {
     }[parser.peek] ?? "";
     if (digit) {
       body = digit;
-      parser.next();
+      parser.nextToken();
     }
     body += matchIdentifierBody(parser);
     if (body === null || !parser.match("<}>")) {
@@ -7915,7 +7997,7 @@ function matchPrefixedIdentifier(parser) {
   parser.index = start;
   return null;
 }
-function matchInvalidIdentifier(parser) {
+function parseInvalidIdentifier(parser) {
   const start = parser.index;
   const id = matchPrefixedIdentifier(parser);
   if (id === null || isValidIdentifier(id)) {
@@ -7929,13 +8011,13 @@ function matchInvalidIdentifier(parser) {
 }
 function matchIdentifier(parser) {
   if (/^[a-zA-Z]$/.test(parser.peek) || /^\p{XIDS}$/u.test(parser.peek))
-    return parser.next();
+    return parser.nextToken();
   const start = parser.index;
   let id = matchPrefixedIdentifier(parser);
   if (!id) {
     id = "";
     while (!parser.atEnd && ONLY_EMOJIS.test(id + parser.peek))
-      id += parser.next();
+      id += parser.nextToken();
   }
   if (id) {
     id = id.normalize();
@@ -7982,10 +8064,6 @@ var DELIMITER_SHORTHAND = {
   "\\lmoustache": ["\\lmoustache"],
   "\\rmoustache": ["\\rmoustache"]
 };
-var MIDDLE_DELIMITER = {
-  ":": [":", "\\colon"],
-  "|": ["|", "\\|", "\\mid", "\\mvert"]
-};
 var OPEN_DELIMITER_PREFIX = {
   "\\left": "\\right",
   "\\bigl": "\\bigr",
@@ -7997,17 +8075,6 @@ var OPEN_DELIMITER_PREFIX = {
   "\\bigg": "\\bigg",
   "\\Bigg": "\\Bigg"
 };
-var MIDDLE_DELIMITER_PREFIX = [
-  "\\middle",
-  "\\bigm",
-  "\\Bigm",
-  "\\biggm",
-  "\\Biggm",
-  "\\big",
-  "\\Big",
-  "\\bigg",
-  "\\Bigg"
-];
 var CLOSE_DELIMITER = {
   "(": ")",
   "[": "]",
@@ -8162,7 +8229,7 @@ var _Parser = class {
     this._lastPeek = peek;
     return peek;
   }
-  next() {
+  nextToken() {
     return this._tokens[this.index++];
   }
   /**
@@ -8215,15 +8282,14 @@ var _Parser = class {
   latexAhead(n) {
     return this.latex(this.index, this.index + n);
   }
-  latexBefore() {
-    return this.latex(0, this.index);
-  }
-  latexAfter() {
-    return this.latex(this.index);
-  }
+  // latexBefore(): string {
+  //   return this.latex(0, this.index);
+  // }
+  // latexAfter(): string {
+  //   return this.latex(this.index);
+  // }
   /**
-   * Return at most `this._dictionary.lookahead` strings made from the tokens
-   * ahead.
+   * Return at most `this._dictionary.lookahead` LaTeX tokens.
    *
    * The index in the returned array correspond to the number of tokens.
    * Note that since a token can be longer than one char ('\\pi', but also
@@ -8231,6 +8297,10 @@ var _Parser = class {
    * does not match that index. However, knowing the index is important
    * to know by how many tokens to advance.
    *
+   * For example:
+   *
+   * `[empty, '\\sqrt', '\\sqrt{', '\\sqrt{2', '\\sqrt{2}']`
+   *
    */
   lookAhead() {
     let n = Math.min(
@@ -8249,12 +8319,12 @@ var _Parser = class {
     if (kind === "function") {
       const start = this.index;
       if (this.match("\\operatorname") || this.match("\\mathrm") || this.match("\\mathit")) {
-        const fn = this.matchStringArgument();
+        const fn = this.parseStringGroup()?.trim();
         const n = this.index - start;
         this.index = start;
-        if (fn !== null && this._dictionary.function.has(fn))
-          return this._dictionary.function.get(fn).map((x) => [x, n]);
-        return null;
+        if (!fn || !this._dictionary.function.has(fn))
+          return null;
+        return this._dictionary.function.get(fn).map((x) => [x, n]);
       }
       return null;
     } else if (kind === "operator") {
@@ -8287,19 +8357,19 @@ var _Parser = class {
    * instead.
    */
   skipSpace() {
-    if (!this.options.skipSpace)
-      return false;
     if (!this.atEnd && this.peek === "<{>") {
       const index = this.index;
-      this.next();
+      this.nextToken();
       while (this.match("<space>")) {
       }
-      if (this.next() === "<}>") {
+      if (this.nextToken() === "<}>") {
         this.skipSpace();
         return true;
       }
       this.index = index;
     }
+    if (!this.options.skipSpace)
+      return false;
     let result = false;
     while (this.match("<space>"))
       result = true;
@@ -8322,11 +8392,36 @@ var _Parser = class {
       "\\quad",
       "\\qquad"
     ].includes(this.peek)) {
-      this.next();
+      this.nextToken();
       this.skipVisualSpace();
     }
     this.skipSpace();
   }
+  match(token) {
+    if (this._tokens[this.index] === token) {
+      this.index++;
+      return true;
+    }
+    return false;
+  }
+  matchAll(tokens) {
+    console.assert(Array.isArray(tokens));
+    if (tokens.length === 0)
+      return false;
+    let matched = true;
+    let i = 0;
+    do {
+      matched = this._tokens[this.index + i] === tokens[i++];
+    } while (matched && i < tokens.length);
+    if (matched)
+      this.index += i;
+    return matched;
+  }
+  matchAny(tokens) {
+    if (tokens.includes(this._tokens[this.index]))
+      return this._tokens[this.index++];
+    return "";
+  }
   matchChar() {
     const index = this.index;
     let caretCount = 0;
@@ -8373,7 +8468,7 @@ var _Parser = class {
     } else if (this.match("\\unicode")) {
       this.skipSpaceTokens();
       if (this.peek === "<{>") {
-        this.next();
+        this.nextToken();
         const codepoint = this.matchLatexNumber();
         if (this.match("<}>") && codepoint !== null && codepoint >= 0 && codepoint <= 1114111) {
           return String.fromCodePoint(codepoint);
@@ -8388,62 +8483,171 @@ var _Parser = class {
     this.index = index;
     return null;
   }
-  matchColor(_background = false) {
-    let s = "";
-    while (!this.atEnd && this.peek !== "}")
-      s += this.next();
-    return s;
-  }
-  matchLatexDimension() {
-    return null;
-  }
-  match(token) {
-    if (this._tokens[this.index] === token) {
-      this.index++;
-      return true;
+  parseGroup() {
+    const start = this.index;
+    this.skipSpaceTokens();
+    if (this.match("<{>")) {
+      this.addBoundary(["<}>"]);
+      const expr = this.parseExpression();
+      this.skipSpace();
+      if (this.matchBoundary())
+        return expr ?? ["Sequence"];
+      const from = this.index;
+      while (!this.matchBoundary() && !this.atEnd)
+        this.nextToken();
+      const err = this.error("syntax-error", from);
+      return expr ? ["Sequence", expr, err] : err;
     }
-    return false;
+    this.index = start;
+    return null;
   }
-  matchAll(tokens) {
-    if (typeof tokens === "string")
-      tokens = [tokens];
-    if (tokens.length === 0)
-      return false;
-    let matched = true;
-    let i = 0;
-    do {
-      matched = this._tokens[this.index + i] === tokens[i++];
-    } while (matched && i < tokens.length);
-    if (matched)
-      this.index += i;
-    return matched;
+  // Some LaTeX commands (but not all) can accept an argument without braces,
+  // for example `^` , `\sqrt` or `\frac`.
+  // This argument will usually be a single token, but can be a sequence of
+  // tokens (e.g. `\sqrt\frac12` or `\sqrt\mathrm{speed}`).
+  parseToken() {
+    const excluding = [
+      ...'!"#$%&(),/;:?@[]\\`|~'.split(""),
+      "\\left",
+      "\\bigl"
+    ];
+    if (excluding.includes(this.peek))
+      return null;
+    if (/^[0-9]$/.test(this.peek))
+      return parseInt(this.nextToken());
+    const result = this.parseGenericExpression() ?? this.parseSymbol();
+    if (!result)
+      return null;
+    return result;
   }
-  matchAny(tokens) {
-    if (tokens.includes(this._tokens[this.index]))
-      return this._tokens[this.index++];
-    return "";
+  parseOptionalGroup() {
+    const index = this.index;
+    this.skipSpaceTokens();
+    if (this.match("[")) {
+      this.addBoundary(["]"]);
+      const expr = this.parseExpression();
+      this.skipSpace();
+      if (this.matchBoundary())
+        return expr;
+      return this.boundaryError("expected-closing-delimiter");
+    }
+    this.index = index;
+    return null;
   }
-  matchSequence(tokens) {
+  /**
+   * Parse an expression in a tabular format, where rows are separated by `\\`
+   * and columns by `&`.
+   *
+   * Return rows of sparse columns: empty rows are indicated with `Nothing`,
+   * and empty cells are also indicated with `Nothing`.
+   */
+  parseTabular() {
     const result = [];
-    while (tokens.includes(this._tokens[this.index]))
-      result.push(this._tokens[this.index++]);
+    let row = [];
+    let expr = null;
+    while (!this.atBoundary) {
+      this.skipSpace();
+      if (this.match("&")) {
+        row.push(expr ?? "Nothing");
+        expr = null;
+      } else if (this.match("\\\\") || this.match("\\cr")) {
+        this.skipSpace();
+        this.parseOptionalGroup();
+        if (expr !== null)
+          row.push(expr);
+        result.push(row);
+        row = [];
+        expr = null;
+      } else {
+        const cell = [];
+        let peek = this.peek;
+        while (peek !== "&" && peek !== "\\\\" && peek !== "\\cr" && !this.atBoundary) {
+          expr = this.parseExpression({
+            condition: (p) => {
+              const peek2 = p.peek;
+              return peek2 === "&" || peek2 === "\\\\" || peek2 === "\\cr";
+            }
+          });
+          if (expr)
+            cell.push(expr);
+          else {
+            cell.push(["Error", ["'unexpected-token'", peek]]);
+            this.nextToken();
+          }
+          this.skipSpace();
+          peek = this.peek;
+        }
+        if (cell.length > 1)
+          expr = ["Sequence", ...cell];
+        else
+          expr = cell[0] ?? "Nothing";
+      }
+    }
+    if (expr !== null)
+      row.push(expr);
+    if (row.length > 0)
+      result.push(row);
     return result;
   }
-  matchOptionalSign() {
+  /** Parse a group as a a string, for example for `\operatorname` or `\begin` */
+  parseStringGroup() {
+    const start = this.index;
+    while (this.match("<space>")) {
+    }
+    if (this.match("<{>")) {
+      this.addBoundary(["<}>"]);
+      const arg = this.parseStringGroupContent();
+      if (this.matchBoundary())
+        return arg;
+      this.removeBoundary();
+    }
+    this.index = start;
+    return null;
+  }
+  /** Parse an environment: `\begin{env}...\end{end}`
+   */
+  parseEnvironment() {
+    const index = this.index;
+    if (!this.match("\\begin"))
+      return null;
+    const name = this.parseStringGroup()?.trim();
+    if (!name)
+      return this.error("expected-environment-name", index);
+    this.addBoundary(["\\end", "<{>", ...name.split(""), "<}>"]);
+    const def = this._dictionary.environment.get(name);
+    if (!def) {
+      this.parseTabular();
+      this.skipSpace();
+      if (!this.matchBoundary())
+        return this.boundaryError("unbalanced-environment");
+      return this.error(["unknown-environment", { str: name }], index);
+    }
+    const expr = def.parse(this, [], []);
+    this.skipSpace();
+    if (!this.matchBoundary())
+      return this.boundaryError("unbalanced-environment");
+    if (expr !== null)
+      return this.decorate(expr, index);
+    this.index = index;
+    return null;
+  }
+  /** If the next token matches a `+` or `-` sign, return it and advance the index.
+   * Otherwise return `''` and do not advance */
+  parseOptionalSign() {
     let isNegative = !!this.matchAny(["-", "\u2212"]);
     while (this.matchAny(["+", "\uFE62"]) || this.skipSpace())
       if (this.matchAny(["-", "\u2212"]))
         isNegative = !isNegative;
     return isNegative ? "-" : "+";
   }
-  matchDecimalDigits(options) {
+  parseDecimalDigits(options) {
     options ?? (options = {});
     options.withGrouping ?? (options.withGrouping = false);
     const result = [];
     let done = false;
     while (!done) {
       while (/^[0-9]$/.test(this.peek)) {
-        result.push(this.next());
+        result.push(this.nextToken());
         this.skipVisualSpace();
       }
       done = true;
@@ -8461,21 +8665,21 @@ var _Parser = class {
     }
     return result.join("");
   }
-  matchSignedInteger(options) {
+  parseSignedInteger(options) {
     options ?? (options = {});
     options.withGrouping ?? (options.withGrouping = false);
     const start = this.index;
-    const sign2 = this.matchOptionalSign();
-    const result = this.matchDecimalDigits(options);
+    const sign2 = this.parseOptionalSign();
+    const result = this.parseDecimalDigits(options);
     if (result)
       return sign2 === "-" ? "-" + result : result;
     this.index = start;
     return "";
   }
-  matchExponent() {
+  parseExponent() {
     const start = this.index;
     if (this.matchAny(["e", "E"])) {
-      const exponent = this.matchSignedInteger({ withGrouping: false });
+      const exponent = this.parseSignedInteger({ withGrouping: false });
       if (exponent)
         return "e" + exponent;
     }
@@ -8484,10 +8688,10 @@ var _Parser = class {
       this.skipSpaceTokens();
       if (this.match("1") && this.match("0") && this.match("^")) {
         if (/^[0-9]$/.test(this.peek))
-          return "e" + this.next();
+          return "e" + this.nextToken();
         if (this.match("<{>")) {
           this.skipSpaceTokens();
-          const exponent = this.matchSignedInteger();
+          const exponent = this.parseSignedInteger();
           this.skipSpaceTokens();
           if (this.match("<}>") && exponent)
             return "e" + exponent;
@@ -8503,7 +8707,7 @@ var _Parser = class {
       this.skipSpaceTokens();
       if (this.matchAll(this._beginExponentMarkerTokens)) {
         this.skipSpaceTokens();
-        const exponent = this.matchSignedInteger();
+        const exponent = this.parseSignedInteger();
         this.skipSpaceTokens();
         if (this.matchAll(this._endExponentMarkerTokens) && exponent)
           return "e" + exponent;
@@ -8512,11 +8716,11 @@ var _Parser = class {
     this.index = start;
     return "";
   }
-  matchRepeatingDecimal() {
+  parseRepeatingDecimal() {
     const start = this.index;
     let repeatingDecimals2 = "";
     if (this.match("(")) {
-      repeatingDecimals2 = this.matchDecimalDigits();
+      repeatingDecimals2 = this.parseDecimalDigits();
       if (repeatingDecimals2 && this.match(")"))
         return "(" + repeatingDecimals2 + ")";
       this.index = start;
@@ -8524,7 +8728,7 @@ var _Parser = class {
     }
     this.index = start;
     if (this.matchAll([`\\left`, "("])) {
-      repeatingDecimals2 = this.matchDecimalDigits();
+      repeatingDecimals2 = this.parseDecimalDigits();
       if (repeatingDecimals2 && this.matchAll([`\\right`, ")"]))
         return "(" + repeatingDecimals2 + ")";
       this.index = start;
@@ -8532,7 +8736,7 @@ var _Parser = class {
     }
     this.index = start;
     if (this.matchAll([`\\overline`, "<{>"])) {
-      repeatingDecimals2 = this.matchDecimalDigits();
+      repeatingDecimals2 = this.parseDecimalDigits();
       if (repeatingDecimals2 && this.match("<}>"))
         return "(" + repeatingDecimals2 + ")";
       this.index = start;
@@ -8540,7 +8744,7 @@ var _Parser = class {
     }
     this.index = start;
     if (this.matchAll(this._beginRepeatingDigitsTokens)) {
-      repeatingDecimals2 = this.matchDecimalDigits();
+      repeatingDecimals2 = this.parseDecimalDigits();
       if (repeatingDecimals2 && this.matchAll(this._endRepeatingDigitsTokens))
         return "(" + repeatingDecimals2 + ")";
       this.index = start;
@@ -8549,9 +8753,13 @@ var _Parser = class {
     this.index = start;
     return "";
   }
-  matchNumber() {
+  /**
+   * Parse a number, with an optional sign, exponent, decimal marker,
+   * repeating decimals, etc...
+   */
+  parseNumber() {
     if (!this.options.parseNumbers)
-      return "";
+      return null;
     const start = this.index;
     this.skipVisualSpace();
     this.match("+");
@@ -8561,32 +8769,32 @@ var _Parser = class {
       const peek = this.peek;
       if (peek !== "\\overline" && peek !== this._beginRepeatingDigitsTokens[0] && !/[0-9\(]/.test(peek)) {
         this.index = start;
-        return "";
+        return null;
       }
       dotPrefix = true;
     } else {
-      result = this.matchDecimalDigits({ withGrouping: true });
+      result = this.parseDecimalDigits({ withGrouping: true });
       if (!result) {
         this.index = start;
-        return "";
+        return null;
       }
     }
     let hasDecimal = true;
     if (!dotPrefix && (this.match(".") || this.matchAll(this._decimalMarkerTokens)))
-      result += "." + this.matchDecimalDigits({ withGrouping: true });
+      result += "." + this.parseDecimalDigits({ withGrouping: true });
     else if (dotPrefix)
-      result = "0." + this.matchDecimalDigits({ withGrouping: true });
+      result = "0." + this.parseDecimalDigits({ withGrouping: true });
     else
       hasDecimal = false;
     if (hasDecimal) {
-      const repeat = this.matchRepeatingDecimal();
+      const repeat = this.parseRepeatingDecimal();
       if (repeat)
         result += repeat;
       else if (this.match("\\ldots") || this.matchAll(this._truncationMarkerTokens)) {
       }
     }
     this.skipVisualSpace();
-    return result + this.matchExponent();
+    return result + this.parseExponent();
   }
   /**
    * A Latex number can be a decimal, hex or octal number.
@@ -8605,7 +8813,7 @@ var _Parser = class {
     while (token === "<space>" || token === "+" || token === "-") {
       if (token === "-")
         negative = !negative;
-      this.next();
+      this.nextToken();
       token = this.peek;
     }
     let radix = 10;
@@ -8636,7 +8844,7 @@ var _Parser = class {
       ];
       isInteger = true;
     } else if (this.match("`")) {
-      token = this.next();
+      token = this.nextToken();
       if (token) {
         if (token.startsWith("\\") && token.length === 2) {
           return (negative ? -1 : 1) * (token.codePointAt(1) ?? 0);
@@ -8647,12 +8855,12 @@ var _Parser = class {
     }
     let value = "";
     while (digits.includes(this.peek)) {
-      value += this.next();
+      value += this.nextToken();
     }
     if (!isInteger && this.match(".")) {
       value += ".";
       while (digits.includes(this.peek)) {
-        value += this.next();
+        value += this.nextToken();
       }
     }
     const result = isInteger ? Number.parseInt(value, radix) : Number.parseFloat(value);
@@ -8660,7 +8868,7 @@ var _Parser = class {
       return null;
     return negative ? -result : result;
   }
-  matchPrefixOperator(until) {
+  parsePrefixOperator(until) {
     if (!until)
       until = { minPrec: 0 };
     if (!until.minPrec)
@@ -8678,7 +8886,7 @@ var _Parser = class {
     this.index = start;
     return null;
   }
-  matchInfixOperator(lhs, until) {
+  parseInfixOperator(lhs, until) {
     until ?? (until = { minPrec: 0 });
     if (until.minPrec === void 0)
       until = { ...until, minPrec: 0 };
@@ -8689,7 +8897,7 @@ var _Parser = class {
     for (const [def, n] of defs) {
       if (def.precedence >= until.minPrec) {
         this.index = start + n;
-        const rhs = def.parse(this, until, lhs);
+        const rhs = def.parse(this, lhs, until);
         if (rhs)
           return rhs;
       }
@@ -8698,99 +8906,74 @@ var _Parser = class {
     return null;
   }
   /**
-   * - 'enclosure' : will look for an argument inside an enclosure (open/close fence)
+   * This returns an array of arguments (as in a function application),
+   * or null if there is no match.
+   *
+   * - 'enclosure' : will look for an argument inside an enclosure
+   *   (open/close fence)
    * - 'implicit': either an expression inside a pair of `()`, or just a product
    *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
+   *
    */
-  matchArguments(kind, until) {
-    if (!kind)
-      return null;
+  parseArguments(kind = "enclosure", until) {
     if (this.atTerminator(until))
       return null;
-    const savedIndex = this.index;
-    const group = this.matchEnclosure();
-    if (kind === "enclosure" && head(group) === "Delimiter") {
-      if (op(group, 1) === "Sequence")
-        return ops(op(group, 1)) ?? [];
-      return [op(group, 1) ?? ["Sequence"]];
-    }
-    if (kind === "implicit") {
-      if (head(group) === "Delimiter") {
-        if (head(op(group, 1)) === "Sequence")
-          return getSequence(group) ?? [];
-        return [op(group, 1) ?? ["Sequence"]];
-      }
-      if (group !== null)
-        return [group];
-      const primary = this.matchExpression({ ...until, minPrec: 390 });
-      if (primary !== null)
-        return [primary];
-      return null;
-    }
-    this.index = savedIndex;
-    return null;
-  }
-  /**
-   * A function can be followed by the following suffixes:
-   * - a `\prime`, `\doubleprime`, `'`, `(n)` to indicate a derivative
-   * - a subscript to indicate an argument
-   * - an argument, optionally inside an enclosure
-   */
-  matchFunctionSuffix(id) {
-    let fn = id;
-    do {
-      const pf = this.matchPostfix(fn);
-      if (pf === null)
-        break;
-      fn = pf;
-    } while (true);
-    const seq = this.matchArguments("enclosure");
-    return seq ? [fn, ...seq] : id;
-  }
-  /** A prime suffix is a sequence of `'`, `\prime` or `\doubleprime`
-   * after a function or in a superscript.
-   */
-  matchPrimeSuffix() {
-    this.skipSpace();
-    const start = this.index;
-    let count = 0;
-    if (this.match("^")) {
-      if (this.match("<{>")) {
-        if (this.match("(")) {
-          const n = this.matchNumber();
-          if (n && this.match(")"))
-            return parseInt(n);
-          this.index = start;
-          return 0;
-        }
-        do {
-          const c = countPrimeLevel(this);
-          if (c === 0)
-            break;
-          count += c;
-        } while (true);
-        if (count !== 0 && this.match("<}>"))
-          return count;
-        this.index = start;
-        return 0;
-      }
-      count = countPrimeLevel(this);
-      if (count !== 0)
-        return count;
-      this.index = start;
-      return 0;
+    const savedIndex = this.index;
+    const group = this.parseEnclosure();
+    if (kind === "enclosure") {
+      if (group === null)
+        return null;
+      return getSequence(group) ?? [];
     }
-    do {
-      const c = countPrimeLevel(this);
-      if (c === 0)
-        break;
-      count += c;
-    } while (true);
-    if (count !== 0)
-      return count;
-    this.index = start;
-    return 0;
+    if (kind === "implicit") {
+      if (head(group) === "Delimiter")
+        return getSequence(group) ?? [];
+      if (group !== null)
+        return [group];
+      const primary = this.parseExpression({ ...until, minPrec: 390 });
+      return primary === null ? null : [primary];
+    }
+    this.index = savedIndex;
+    return null;
   }
+  /** A prime suffix is a sequence of `'`, `\prime` or `\doubleprime`
+   * after a function or in a superscript.
+   */
+  // matchPrimeSuffix(): number {
+  //   this.skipSpace();
+  //   const start = this.index;
+  //   let count = 0;
+  //   if (this.match('^')) {
+  //     if (this.match('<{>')) {
+  //       if (this.match('(')) {
+  //         const n = this.parseNumber();
+  //         if (n && this.match(')')) return parseInt(n);
+  //         this.index = start;
+  //         return 0;
+  //       }
+  //       do {
+  //         const c = countPrimeLevel(this);
+  //         if (c === 0) break;
+  //         count += c;
+  //       } while (true);
+  //       if (count !== 0 && this.match('<}>')) return count;
+  //       this.index = start;
+  //       return 0;
+  //     }
+  //     count = countPrimeLevel(this);
+  //     if (count !== 0) return count;
+  //     this.index = start;
+  //     return 0;
+  //   }
+  //   do {
+  //     const c = countPrimeLevel(this);
+  //     if (c === 0) break;
+  //     count += c;
+  //   } while (true);
+  //   if (count !== 0) return count;
+  //   this.index = start;
+  //   return 0;
+  // }
   /** If matches the normalized open delimiter, return the
    * expected closing delimiter.
    *
@@ -8803,7 +8986,7 @@ var _Parser = class {
     const index = this.index;
     const closePrefix = OPEN_DELIMITER_PREFIX[this.peek];
     if (closePrefix)
-      this.next();
+      this.nextToken();
     const alternatives = DELIMITER_SHORTHAND[openDelim] ?? [openDelim];
     const result = closePrefix ? [closePrefix] : [];
     if (alternatives.includes("||") && this.matchAll(["|", "|"])) {
@@ -8820,28 +9003,30 @@ var _Parser = class {
     } else {
       result.push(closeDelim);
     }
-    this.next();
+    this.nextToken();
     return result;
   }
-  matchMiddleDelimiter(delimiter) {
-    const delimiters = MIDDLE_DELIMITER[delimiter] ?? [delimiter];
-    if (MIDDLE_DELIMITER_PREFIX.includes(this.peek)) {
-      const index = this.index;
-      this.next();
-      if (delimiters.includes(this.peek)) {
-        this.next();
-        return true;
-      }
-      this.index = index;
-      return false;
-    } else if (delimiters.include(this.peek)) {
-      this.next();
-      return true;
-    }
-    return false;
-  }
+  // matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean {
+  //   const delimiters = MIDDLE_DELIMITER[delimiter] ?? [delimiter];
+  //   if (MIDDLE_DELIMITER_PREFIX.includes(this.peek)) {
+  //     const index = this.index;
+  //     this.nextToken();
+  //     if (delimiters.includes(this.peek)) {
+  //       this.nextToken();
+  //       return true;
+  //     }
+  //     this.index = index;
+  //     return false;
+  //   } else if (delimiters.include(this.peek)) {
+  //     this.nextToken();
+  //     return true;
+  //   }
+  //   return false;
+  // }
   /** For error handling, when there is potentially a mismatched delimiter.
    * Return a LaTeX fragment of the expected closing delimiter
+   *
+   * @internal
    */
   matchEnclosureOpen() {
     const defs = this._dictionary.matchfix;
@@ -8865,6 +9050,9 @@ var _Parser = class {
     this.index = start;
     return null;
   }
+  /**
+   * Used for error handling
+   * @internal */
   matchEnclosureClose() {
     const defs = this._dictionary.matchfix;
     if (defs.length === 0)
@@ -8883,7 +9071,7 @@ var _Parser = class {
         (x) => OPEN_DELIMITER_PREFIX[x] === peek
       );
       if (prefix)
-        this.next();
+        this.nextToken();
       let openDelimiter = [];
       peek = this.peek;
       const matchingDelim = Object.keys(CLOSE_DELIMITER).find(
@@ -8894,7 +9082,7 @@ var _Parser = class {
       if (prefix)
         openDelimiter = [prefix, ...openDelimiter];
       if (openDelimiter.length > 0) {
-        this.next();
+        this.nextToken();
         return tokensToString(openDelimiter);
       }
     }
@@ -8906,7 +9094,7 @@ var _Parser = class {
    * optionally followed multiple times by a separator and another expression,
    * and finally a closing matching operator.
    */
-  matchEnclosure() {
+  parseEnclosure() {
     const defs = this._dictionary.matchfix;
     if (defs.length === 0)
       return null;
@@ -8917,7 +9105,7 @@ var _Parser = class {
         if (!this.matchAll(def.openDelimiter))
           continue;
         this.addBoundary(def.closeDelimiter);
-        const body2 = this.matchExpression();
+        const body2 = this.parseExpression();
         this.skipSpace();
         if (!this.matchBoundary()) {
           this.removeBoundary();
@@ -8942,12 +9130,12 @@ var _Parser = class {
       }
       this.addBoundary(closeDelimiter);
       const bodyStart = this.index;
-      let body = this.matchExpression();
+      let body = this.parseExpression();
       this.skipSpace();
       if (!this.matchBoundary()) {
         this.removeBoundary();
         this.index = bodyStart;
-        body = this.matchExpression();
+        body = this.parseExpression();
         if (!this.matchAll(closeDelimiter)) {
           if (!this.atEnd)
             continue;
@@ -8962,52 +9150,74 @@ var _Parser = class {
     this.index = start;
     return null;
   }
-  matchIdentifier() {
-    return matchIdentifier(this);
-  }
   /**
-   * A function is an identifier followed by arguments
-   * - a single letter identifier with explicit arguments `f(x)`
-   * - a multiletter identifier with explicit arguments `\mathrm{floor}(x)`
-   * - an identifier: `\mathrm{floor}`
-   * - a command with implicit arguments: `\cos x` (via a  custom parser)
-   *
+   * A generic expression is used for dictionary entries that take do
+   * some complex (non-standard) parsing. This includes trig functions (to
+   * parse implicit arguments), and integrals (to parse the integrand and
+   * limits and the "dx" terminator).
    */
-  matchFunction(until) {
+  parseGenericExpression(until) {
     if (this.atTerminator(until))
       return null;
     const start = this.index;
-    const fnDefs = this.peekDefinitions("function");
-    if (fnDefs) {
-      for (const [def, tokenCount] of fnDefs) {
-        this.index = start + tokenCount;
-        if (typeof def.parse === "function") {
-          const result = def.parse(this, until);
-          if (result)
-            return result;
-        } else {
-          return this.matchFunctionSuffix(def.name);
-        }
+    let expr = null;
+    const fnDefs = this.peekDefinitions("expression") ?? [];
+    for (const [def, tokenCount] of fnDefs) {
+      this.index = start + tokenCount;
+      if (typeof def.parse === "function") {
+        expr = def.parse(this, until);
+        if (expr !== null)
+          return expr;
+      } else {
+        return def.name;
       }
     }
     this.index = start;
-    const fn = this.matchIdentifier();
-    if (fn === null)
+    return null;
+  }
+  /**
+   * A function is an identifier followed by postfix operators
+   * (`\prime`...) and some arguments.
+   */
+  parseFunction(until) {
+    if (this.atTerminator(until))
       return null;
-    if (this.options.parseUnknownIdentifier?.(fn, this) !== "function") {
+    const start = this.index;
+    let fn = null;
+    const fnDefs = this.peekDefinitions("function") ?? [];
+    for (const [def, tokenCount] of fnDefs) {
+      this.index = start + tokenCount;
+      if (typeof def.parse === "function") {
+        fn = def.parse(this, until);
+        if (fn !== null)
+          break;
+      } else {
+        fn = def.name;
+        break;
+      }
+    }
+    if (fn === null) {
       this.index = start;
-      return null;
+      fn = matchIdentifier(this);
+      if (!this.isFunctionHead(fn)) {
+        this.index = start;
+        return null;
+      }
     }
-    return this.matchFunctionSuffix(fn);
+    do {
+      const pf = this.parsePostfixOperator(fn);
+      if (pf === null)
+        break;
+      fn = pf;
+    } while (true);
+    const seq = this.isFunctionHead(fn) ? this.parseArguments() : null;
+    return seq ? [fn, ...seq] : fn;
   }
-  /**
-   * A symbol is an identifier or a custom definition
-   */
-  matchSymbol(until) {
+  parseSymbol(until) {
     if (this.atTerminator(until))
       return null;
     const start = this.index;
-    const defs = this.peekDefinitions("identifier");
+    const defs = this.peekDefinitions("symbol");
     if (defs) {
       for (const [def, tokenCount] of defs) {
         this.index = start + tokenCount;
@@ -9020,7 +9230,7 @@ var _Parser = class {
       }
     }
     this.index = start;
-    const id = this.matchIdentifier();
+    const id = matchIdentifier(this);
     if (id === null)
       return null;
     if (this.options.parseUnknownIdentifier?.(id, this) === "symbol")
@@ -9028,57 +9238,19 @@ var _Parser = class {
     this.index = start;
     return null;
   }
-  matchLatexOptionalGroup() {
-    const index = this.index;
-    this.skipSpaceTokens();
-    if (this.match("[")) {
-      this.addBoundary(["]"]);
-      const expr = this.matchExpression();
-      this.skipSpace();
-      if (this.matchBoundary())
-        return expr;
-      return this.boundaryError("expected-closing-delimiter");
-    }
-    this.index = index;
-    return null;
-  }
-  // Some LaTeX commands (but not all) can accept an argument without braces,
-  // for example `^` , `\sqrt` or `\frac`.
-  matchSingleAtomArgument() {
-    const excluding = [...'!"#$%&(),/;:?@[]`|~'.split(""), "\\left", "\\bigl"];
-    if (excluding.includes(this.peek))
-      return null;
-    if (/^[0-9]$/.test(this.peek))
-      return parseInt(this.next());
-    if (/^[^\\#]$/.test(this.peek) && isValidIdentifier(this.peek))
-      return this.next();
-    const sym = this.matchSymbol();
-    if (sym)
-      return sym;
-    return null;
-  }
-  matchLatexGroup() {
-    const start = this.index;
-    this.skipSpaceTokens();
-    if (this.match("<{>")) {
-      this.addBoundary(["<}>"]);
-      const expr = this.matchExpression();
-      this.skipSpace();
-      if (this.matchBoundary())
-        return expr ?? ["Sequence"];
-      const from = this.index;
-      while (!this.matchBoundary() && !this.atEnd)
-        this.next();
-      const err = this.error("syntax-error", from);
-      return expr ? ["Sequence", expr, err] : err;
-    }
-    this.index = start;
-    return null;
-  }
-  matchSupsub(lhs) {
+  /**
+   * Parse a sequence superfix/subfix operator, e.g. `^{*}`
+   *
+   * Superfix and subfix need special handling:
+   *
+   * - they act mostly like an infix operator, but they are commutative, i.e.
+   * `x_a^b` should be parsed identically to `x^b_a`.
+   *
+   * - furthermore, in LaTeX `x^a^b` parses the same as `x^a{}^b`.
+   *
+   */
+  parseSupsub(lhs) {
     console.assert(lhs !== null);
-    if (lhs === null)
-      return null;
     const index = this.index;
     this.skipSpace();
     const superscripts = [];
@@ -9090,7 +9262,7 @@ var _Parser = class {
         if (this.match("_") || this.match("^"))
           subscripts.push(this.error("syntax-error", subIndex));
         else {
-          const sub2 = this.matchLatexGroup() ?? this.matchSingleAtomArgument() ?? this.matchStringArgument();
+          const sub2 = this.parseGroup() ?? this.parseToken() ?? this.parseStringGroup();
           if (sub2 === null)
             return this.error("missing", index);
           subscripts.push(sub2);
@@ -9100,7 +9272,7 @@ var _Parser = class {
         if (this.match("_") || this.match("^"))
           superscripts.push(this.error("syntax-error", subIndex));
         else {
-          const sup = this.matchLatexGroup() ?? this.matchSingleAtomArgument();
+          const sup = this.parseGroup() ?? this.parseToken();
           if (sup === null)
             return this.error("missing", index);
           superscripts.push(sup);
@@ -9124,7 +9296,7 @@ var _Parser = class {
         ];
         for (const def of defs) {
           if (typeof def.parse === "function")
-            result = def.parse(this, { minPrec: 0 }, arg);
+            result = def.parse(this, arg, { minPrec: 0 });
           else
             result = arg;
           if (result)
@@ -9142,7 +9314,7 @@ var _Parser = class {
         ];
         for (const def of defs) {
           if (typeof def.parse === "function")
-            result = def.parse(this, { minPrec: 0 }, arg);
+            result = def.parse(this, arg, { minPrec: 0 });
           else
             result = arg;
           if (result)
@@ -9154,7 +9326,7 @@ var _Parser = class {
       this.index = index;
     return result;
   }
-  matchPostfix(lhs) {
+  parsePostfixOperator(lhs, until) {
     console.assert(lhs !== null);
     if (lhs === null)
       return null;
@@ -9164,7 +9336,7 @@ var _Parser = class {
     const start = this.index;
     for (const [def, n] of defs) {
       this.index = start + n;
-      const result = def.parse(this, lhs);
+      const result = def.parse(this, lhs, until);
       if (result !== null)
         return result;
     }
@@ -9176,119 +9348,32 @@ var _Parser = class {
    * Not suitable for general purpose text, e.g. argument of a `\text{}
    * command. See `matchChar()` instead.
    */
-  matchString() {
+  parseStringGroupContent() {
+    const start = this.index;
     let result = "";
-    while (!this.atBoundary) {
-      const token = this.peek;
+    let level = 0;
+    while (!this.atBoundary || level > 0) {
+      const token = this.nextToken();
       if (token === "<$>" || token === "<$$>") {
+        this.index = start;
         return "";
+      }
+      if (token === "<{>") {
+        level += 1;
+        result += "\\{";
+      } else if (token === "<}>") {
+        level -= 1;
+        result += "\\}";
       } else if (token === "<space>") {
-        this.next();
         result += " ";
       } else if (token[0] === "\\") {
-        result += this.next();
-      } else {
-        result += this.next();
-      }
-    }
-    return result;
-  }
-  /** Match a string as an argument (in a `{}` pair) */
-  matchStringArgument() {
-    const start = this.index;
-    this.skipSpaceTokens();
-    if (this.match("<{>")) {
-      this.addBoundary(["<}>"]);
-      while (this.match("<space>")) {
-      }
-      const arg = this.matchString();
-      if (this.matchBoundary())
-        return arg.trimEnd();
-      this.removeBoundary();
-    }
-    this.index = start;
-    return null;
-  }
-  /**
-   * Match an expression in a tabular format, where rows are separated by `\\`
-   * and columns by `&`.
-   *
-   * Return rows of sparse columns: empty rows are indicated with `Nothing`,
-   * and empty cells are also indicated with `Nothing`.
-   */
-  matchTabular() {
-    const result = [];
-    let row = [];
-    let expr = null;
-    while (!this.atBoundary) {
-      this.skipSpace();
-      if (this.match("&")) {
-        row.push(expr ?? "Nothing");
-        expr = null;
-      } else if (this.match("\\\\") || this.match("\\cr")) {
-        this.skipSpace();
-        this.matchLatexOptionalGroup();
-        if (expr !== null)
-          row.push(expr);
-        result.push(row);
-        row = [];
-        expr = null;
+        result += token;
       } else {
-        const cell = [];
-        let peek = this.peek;
-        while (peek !== "&" && peek !== "\\\\" && peek !== "\\cr" && !this.atBoundary) {
-          expr = this.matchExpression({
-            condition: (p) => {
-              const peek2 = p.peek;
-              return peek2 === "&" || peek2 === "\\\\" || peek2 === "\\cr";
-            }
-          });
-          if (expr)
-            cell.push(expr);
-          else {
-            cell.push(["Error", ["'unexpected-token'", peek]]);
-            this.next();
-          }
-          this.skipSpace();
-          peek = this.peek;
-        }
-        if (cell.length > 1)
-          expr = ["Sequence", ...cell];
-        else
-          expr = cell[0] ?? "Nothing";
+        result += token;
       }
     }
-    if (expr !== null)
-      row.push(expr);
-    if (row.length > 0)
-      result.push(row);
     return result;
   }
-  matchEnvironment() {
-    const index = this.index;
-    if (!this.match("\\begin"))
-      return null;
-    const name = this.matchStringArgument();
-    if (name === null)
-      return this.error("expected-environment-name", index);
-    this.addBoundary(["\\end", "<{>", ...name.split(""), "<}>"]);
-    const def = this._dictionary.environment.get(name);
-    if (!def) {
-      this.matchTabular();
-      this.skipSpace();
-      if (!this.matchBoundary())
-        return this.boundaryError("unbalanced-environment");
-      return this.error(["unknown-environment", { str: name }], index);
-    }
-    const expr = def.parse(this, [], []);
-    this.skipSpace();
-    if (!this.matchBoundary())
-      return this.boundaryError("unbalanced-environment");
-    if (expr !== null)
-      return this.decorate(expr, index);
-    this.index = index;
-    return null;
-  }
   /**
    * Apply an invisible operator between two expressions.
    *
@@ -9311,12 +9396,18 @@ var _Parser = class {
    * => lhs is a number, rhs is a number, but not a literal
    */
   applyInvisibleOperator(until, lhs) {
-    if (lhs === null || head(lhs) === "Error" || symbol(lhs) === "Nothing" || isEmptySequence(lhs) || this.atTerminator(until) || this.options.applyInvisibleOperator === null)
+    if (lhs === null || this.options.applyInvisibleOperator === null || head(lhs) === "Error" || symbol(lhs) === "Nothing" || isEmptySequence(lhs) || this.atTerminator(until))
       return null;
+    if (this.isFunctionHead(lhs)) {
+      const args = this.parseArguments("enclosure", until);
+      if (args === null)
+        return null;
+      return [lhs, ...args];
+    }
     if (this.peekDefinitions("operator") !== null)
       return null;
     const start = this.index;
-    const rhs = this.matchExpression({ ...until, minPrec: 390 });
+    const rhs = this.parseExpression({ ...until, minPrec: 390 });
     if (rhs === null || symbol(rhs) === "Nothing" || isEmptySequence(rhs)) {
       this.index = start;
       return null;
@@ -9325,13 +9416,9 @@ var _Parser = class {
       return applyAssociativeOperator("Sequence", lhs, rhs);
     if (typeof this.options.applyInvisibleOperator === "function")
       return this.options.applyInvisibleOperator(this, lhs, rhs);
-    const lhsSymbol = symbol(lhs);
-    if (lhsSymbol) {
-      const isFunction = this.options.parseUnknownIdentifier(lhsSymbol, this) === "function";
-      if (isFunction) {
-        const seq = getSequence(rhs);
-        return seq ? [lhs, ...seq] : lhsSymbol;
-      }
+    if (this.isFunctionHead(lhs)) {
+      const seq = getSequence(rhs);
+      return seq ? [lhs, ...seq] : lhs;
     }
     const lhsNumber = machineValue(lhs);
     if (lhsNumber !== null && Number.isInteger(lhsNumber)) {
@@ -9344,7 +9431,7 @@ var _Parser = class {
     }
     if (head(rhs) === "Delimiter") {
       if (head(op(rhs, 1)) === "Sequence")
-        return [lhsSymbol ?? lhs, ...ops(op(rhs, 1)) ?? []];
+        return [lhs, ...ops(op(rhs, 1)) ?? []];
       if (!op(rhs, 1) || symbol(op(rhs, 1)) === "Nothing")
         return applyAssociativeOperator(
           "Sequence",
@@ -9356,7 +9443,13 @@ var _Parser = class {
       return applyAssociativeOperator("Sequence", lhs, rhs);
     return applyAssociativeOperator("Multiply", lhs, rhs);
   }
-  matchUnexpectedLatexCommand() {
+  /**
+   * This is an error handling method. We've encountered a LaTeX command
+   * but were not able to match it to any entry in the LaTeX dictionary,
+   * or ran into it in an unexpected context (postfix operator lacking an
+   * argument, for example)
+   */
+  parseUnexpectedLatexCommand() {
     const start = this.index;
     let opDefs = this.peekDefinitions("operator");
     if (opDefs) {
@@ -9385,7 +9478,7 @@ var _Parser = class {
         if (def.name)
           return [
             def.name,
-            this.matchExpression() ?? this.error("missing", start)
+            this.parseExpression() ?? this.error("missing", start)
           ];
         return this.error("unexpected-operator", start);
       }
@@ -9394,11 +9487,9 @@ var _Parser = class {
         const [def, n] = opDefs[0];
         this.index += n;
         if (typeof def.parse === "function") {
-          const result = def.parse(
-            this,
-            { minPrec: 0 },
-            this.error("missing", start)
-          );
+          const result = def.parse(this, this.error("missing", start), {
+            minPrec: 0
+          });
           if (result)
             return result;
         }
@@ -9406,7 +9497,7 @@ var _Parser = class {
           return [
             def.name,
             this.error("missing", start),
-            this.matchExpression() ?? this.error("missing", start)
+            this.parseExpression() ?? this.error("missing", start)
           ];
         return this.error("unexpected-operator", start);
       }
@@ -9414,10 +9505,10 @@ var _Parser = class {
     const command = this.peek;
     if (!command || command[0] !== "\\")
       return null;
-    this.next();
+    this.nextToken();
     this.skipSpaceTokens();
     if (command === "\\end") {
-      const name = this.matchStringArgument();
+      const name = this.parseStringGroup();
       if (name === null)
         return this.error("expected-environment-name", start);
       return this.error(["unbalanced-environment", { str: name }], start);
@@ -9429,7 +9520,7 @@ var _Parser = class {
           level += 1;
         if (this.peek === "]")
           level -= 1;
-        this.next();
+        this.nextToken();
       }
       this.match("]");
     }
@@ -9455,7 +9546,7 @@ var _Parser = class {
           level += 1;
         if (this.peek === "<}>")
           level -= 1;
-        this.next();
+        this.nextToken();
       }
       this.match("<}>");
     }
@@ -9463,15 +9554,20 @@ var _Parser = class {
   }
   /**
    * <primary> :=
-   * (<number> | <symbol> | <environment> | <matchfix-expr>) <subsup>* <postfix-operator>*
+   *  (<number> | <symbol> | <environment> | <matchfix-expr>)
+   *    <subsup>* <postfix-operator>*
    *
-   * <symbol> ::= (<symbol-id> | (<latex-command><latex-arguments>)) <arguments>
+   * <symbol> ::=
+   *  (<symbol-id> | (<latex-command><latex-arguments>)) <arguments>
    *
    * <matchfix-expr> :=
-   *  <matchfix-op-open> <expression> [<matchfix-op-separator> <expression>] <matchfix-op-close>
+   *  <matchfix-op-open>
+   *  <expression>
+   *  (<matchfix-op-separator> <expression>)*
+   *  <matchfix-op-close>
    *
    */
-  matchPrimary(until) {
+  parsePrimary(until) {
     if (this.atBoundary)
       return null;
     if (this.atTerminator(until))
@@ -9481,7 +9577,7 @@ var _Parser = class {
     if (this.match("<}>"))
       return this.error("unexpected-closing-delimiter", start);
     if (this.match("<{>")) {
-      result = this.matchExpression({ condition: (p) => p.peek === "<}>" });
+      result = this.parseExpression({ condition: (p) => p.peek === "<}>" });
       if (result === null)
         return this.error("expected-expression", start);
       if (!this.match("<}>")) {
@@ -9492,25 +9588,25 @@ var _Parser = class {
       }
     }
     if (result === null) {
-      const num = this.matchNumber();
-      if (num)
+      const num = this.parseNumber();
+      if (num !== null)
         result = { num };
     }
-    result ?? (result = this.matchEnclosure());
-    result ?? (result = this.matchEnvironment());
+    result ?? (result = this.parseEnclosure());
+    result ?? (result = this.parseEnvironment());
     if (result === null && this.matchAll(this._positiveInfinityTokens))
       result = { num: "+Infinity" };
     if (result === null && this.matchAll(this._negativeInfinityTokens))
       result = { num: "-Infinity" };
     if (result === null && this.matchAll(this._notANumberTokens))
       result = { num: "NaN" };
-    result ?? (result = this.matchFunction(until) ?? this.matchSymbol(until) ?? matchInvalidIdentifier(this));
+    result ?? (result = this.parseGenericExpression(until) ?? this.parseFunction(until) ?? this.parseSymbol(until) ?? parseInvalidIdentifier(this));
     if (result !== null) {
       result = this.decorate(result, start);
       let postfix = null;
       let index = this.index;
       do {
-        postfix = this.matchPostfix(result);
+        postfix = this.parsePostfixOperator(result, until);
         result = postfix ?? result;
         if (this.index === index && postfix !== null) {
           console.assert(this.index !== index, "No token consumed");
@@ -9519,9 +9615,8 @@ var _Parser = class {
         index = this.index;
       } while (postfix !== null);
     }
-    result ?? (result = this.matchUnexpectedLatexCommand());
     if (result !== null)
-      result = this.matchSupsub(result);
+      result = this.parseSupsub(result);
     return this.decorate(result, start);
   }
   /**
@@ -9532,9 +9627,10 @@ var _Parser = class {
    *  | <prefix-op> <primary>
    *  | <primary> <infix-op> <expression>
    *
-   * Stop when an operator of precedence less than `until.minPrec` is encountered
+   * Stop when an operator of precedence less than `until.minPrec`
+   * is encountered
    */
-  matchExpression(until) {
+  parseExpression(until) {
     const start = this.index;
     this.skipSpace();
     if (this.atBoundary) {
@@ -9544,9 +9640,9 @@ var _Parser = class {
     until ?? (until = { minPrec: 0 });
     if (until.minPrec === void 0)
       until.minPrec = 0;
-    let lhs = this.matchPrefixOperator({ ...until, minPrec: 0 });
+    let lhs = this.parsePrefixOperator({ ...until, minPrec: 0 });
     if (lhs === null) {
-      lhs = this.matchPrimary(until);
+      lhs = this.parsePrimary(until);
       if (head(lhs) === "Sequence" && nops(lhs) === 0)
         lhs = null;
     }
@@ -9554,7 +9650,7 @@ var _Parser = class {
       let done = false;
       while (!done && !this.atTerminator(until)) {
         this.skipSpace();
-        let result = this.matchInfixOperator(lhs, until);
+        let result = this.parseInfixOperator(lhs, until);
         if (result === null) {
           result = this.applyInvisibleOperator(until, lhs);
         }
@@ -9565,6 +9661,7 @@ var _Parser = class {
         }
       }
     }
+    lhs ?? (lhs = this.parseUnexpectedLatexCommand());
     return this.decorate(lhs, start);
   }
   /**
@@ -9599,18 +9696,19 @@ var _Parser = class {
     const latex = this.latex(fromToken, this.index);
     return latex ? ["Error", msg, ["Latex", { str: latex }]] : ["Error", msg];
   }
+  isFunctionHead(expr) {
+    if (expr === null)
+      return false;
+    const s = symbol(expr);
+    if (!s)
+      return this.computeEngine.box(expr).domain.isFunction;
+    if (this.computeEngine && this.computeEngine.lookupFunction(s) !== void 0)
+      return true;
+    if (this.options.parseUnknownIdentifier?.(s, this) === "function")
+      return true;
+    return false;
+  }
 };
-function countPrimeLevel(parser) {
-  if (parser.match("\\tripleprime"))
-    return 3;
-  if (parser.match("\\doubleprime"))
-    return 2;
-  if (parser.match("\\prime"))
-    return 1;
-  if (parser.match("'"))
-    return 1;
-  return 0;
-}
 
 // src/compute-engine/latex-syntax/serialize-number.ts
 function formatFractionalPart(m, options) {
@@ -9954,7 +10052,7 @@ var Serializer = class {
     const name = head(expr);
     if (typeof name === "string" && name !== "Delimiter" && name !== "Subscript") {
       const def = this.dictionary.name.get(name);
-      if (def && (def.kind === "identifier" || def.kind === "prefix" || def.kind === "infix" || def.kind === "postfix") && def.precedence < prec)
+      if (def && (def.kind === "symbol" || def.kind === "prefix" || def.kind === "infix" || def.kind === "postfix") && def.precedence < prec)
         return this.wrapString(
           this.serialize(expr),
           this.options.applyFunctionStyle(expr, this.level)
@@ -10034,8 +10132,11 @@ var Serializer = class {
     if (typeof h === "string" && h.length > 0 && h[0] === "\\") {
       return joinLatex([h, ...args.map((x) => `{${this.serialize(x)}}`)]);
     }
-    if (typeof h === "string")
+    if (typeof h === "string") {
+      if (h.length === 1)
+        return serializeIdentifier(h) + this.wrapArguments(expr);
       return serializeIdentifier(h, "upright") + this.wrapArguments(expr);
+    }
     const style = this.options.applyFunctionStyle(expr, this.level);
     return "\\mathrm{Apply}" + this.wrapString(
       this.serialize(h) + ", " + this.serialize(["List", ...args]),
@@ -10062,10 +10163,12 @@ var Serializer = class {
         const symbolName = symbol(expr);
         if (symbolName !== null) {
           const def = this.dictionary.name.get(symbolName);
-          if (def?.kind === "identifier")
+          if (def?.kind === "symbol")
             return this.serializeSymbol(expr, def);
           if (def?.kind === "function")
             return this.serializeFunction(expr, def);
+          if (typeof def?.serialize === "function")
+            return def.serialize(this, expr);
         }
         const dict = dictionary(expr);
         if (dict !== null)
@@ -10078,7 +10181,7 @@ var Serializer = class {
               return def.serialize(this, expr);
             if (def.kind === "infix" || def.kind === "postfix" || def.kind === "prefix")
               return serializeOperator(this, expr, def);
-            if (def.kind === "identifier")
+            if (def.kind === "symbol")
               return this.serializeSymbol(expr, def);
             if (def.kind === "function")
               return this.serializeFunction(expr, def);
@@ -10342,7 +10445,7 @@ var LatexSyntax = class _LatexSyntax {
       ...DEFAULT_SERIALIZE_LATEX_OPTIONS,
       ...opts
     };
-    this.dictionary = indexLatexDictionary(
+    this._dictionary = indexLatexDictionary(
       options.dictionary ?? _LatexSyntax.getDictionary(),
       (sig) => this.onError([sig])
     );
@@ -10363,16 +10466,16 @@ var LatexSyntax = class _LatexSyntax {
     }
     if (!DEFAULT_LATEX_DICTIONARY[category])
       return [];
-    return [...DEFAULT_LATEX_DICTIONARY[category]];
+    return Object.freeze([...DEFAULT_LATEX_DICTIONARY[category]]);
   }
   parse(latex) {
     const parser = new _Parser(
       tokenize(latex, []),
       this.options,
-      this.dictionary,
+      this._dictionary,
       this.computeEngine
     );
-    let expr = parser.matchExpression();
+    let expr = parser.parseExpression();
     if (!parser.atEnd) {
       const opDefs = parser.peekDefinitions("infix");
       if (opDefs) {
@@ -10381,8 +10484,8 @@ var LatexSyntax = class _LatexSyntax {
         parser.index += n;
         const result = def.parse(
           parser,
-          { minPrec: 0 },
-          expr ?? parser.error("missing", start)
+          expr ?? parser.error("missing", start),
+          { minPrec: 0 }
         );
         if (result)
           return result;
@@ -10396,7 +10499,7 @@ var LatexSyntax = class _LatexSyntax {
         parser.index = start;
       }
       const index = parser.index;
-      const id = parser.matchIdentifier();
+      const id = matchIdentifier(parser);
       if (id) {
         const idError = parser.error(["unexpected-identifier", id], index);
         return expr ? ["Sequence", expr, idError] : idError;
@@ -10418,9 +10521,9 @@ var LatexSyntax = class _LatexSyntax {
         return expr ? ["Sequence", expr, enclosureError] : enclosureError;
       }
       const rest = parser.index;
-      const token = parser.next();
+      const token = parser.nextToken();
       while (!parser.atEnd)
-        parser.next();
+        parser.nextToken();
       if (!token)
         return parser.error("syntax-error", rest);
       const error = parser.error(
@@ -10453,7 +10556,7 @@ var LatexSyntax = class _LatexSyntax {
       return this._serializer;
     this._serializer = new Serializer(
       this.options,
-      this.dictionary,
+      this._dictionary,
       this.onError
     );
     return this._serializer;
@@ -13027,6 +13130,14 @@ function ancestors(dom) {
   gDomainLiterals[dom] = new Set(result);
   return result;
 }
+function domainSetsLibrary() {
+  const table = {};
+  for (const dom of Object.keys(DOMAIN_LITERAL)) {
+    if (dom !== "Domain" && dom !== "Nothing" && dom !== "String" && dom !== "Symbol" && dom !== "List" && dom !== "Tuple" && dom !== "Sequence")
+      table[dom] = { domain: "Set" };
+  }
+  return table;
+}
 
 // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
 var import_complex6 = __toESM(require_complex());
@@ -15371,7 +15482,7 @@ function expandMultinomial(expr) {
   const ce = expr.engine;
   if (expr.op1.head === "Negate") {
     const sign2 = exp2 % 2 === 0 ? 1 : -1;
-    const result2 = expandMultinomial(ce.box(["Power", expr.op1.op1, expr.op2]));
+    const result2 = expandMultinomial(ce.pow(expr.op1.op1, expr.op2));
     if (result2 === null)
       return null;
     if (sign2 > 0)
@@ -15596,15 +15707,14 @@ function assumeEquality(proposition) {
     const sols = findUnivariateRoots(proposition, lhs2);
     if (sols.length === 0) {
       ce.assumptions.set(
-        ce.box([
-          "Equal",
+        ce.fn("Equal", [
           ce.add([proposition.op1.canonical, ce.neg(proposition.op2.canonical)]).simplify(),
           0
         ]),
         true
       );
     }
-    const val = sols.length === 1 ? sols[0] : ce.box(["List", ...sols]);
+    const val = sols.length === 1 ? sols[0] : ce.fn("List", sols);
     const def = ce.lookupSymbol(lhs2);
     if (!def) {
       ce.defineSymbol(lhs2, { value: val });
@@ -16586,7 +16696,6 @@ var BoxedFunction = class _BoxedFunction extends AbstractBoxedExpression {
     return result;
   }
   solve(vars) {
-    console.log("solve this:", this.toString());
     if (vars.length !== 1)
       return null;
     const roots = findUnivariateRoots(this.simplify(), vars[0]);
@@ -16665,6 +16774,8 @@ function makeCanonicalFunction(ce, head2, ops2, metadata) {
         xs.push(y);
     }
   }
+  if (!xs.every((x) => x.isValid))
+    return new BoxedFunction(ce, head2, xs, { metadata, canonical: false });
   const sig = def.signature;
   if (sig.canonical) {
     try {
@@ -16695,21 +16806,22 @@ function makeCanonicalFunction(ce, head2, ops2, metadata) {
   return new BoxedFunction(ce, head2, xs, { metadata, def, canonical: true });
 }
 function apply(fn, args) {
+  const ce = fn.engine;
   if (fn.head !== "Lambda")
-    return fn.engine._fn(fn.evaluate(), args);
+    return ce._fn(fn.evaluate(), args);
   const subs2 = {
-    "__": fn.engine.tuple(args),
-    "_#": fn.engine.number(args.length)
+    "__": ce.tuple(args),
+    "_#": ce.number(args.length)
   };
   let n = 1;
   for (const op3 of args)
     subs2[`_${n++}`] = op3;
   subs2["_"] = subs2["_1"];
-  const savedContext = this.context;
-  this.context = fn.scope ?? null;
-  const result = fn.subs(subs2).evaluate();
-  this.context = savedContext;
-  return result;
+  const savedContext = ce.context;
+  ce.context = fn.scope ?? null;
+  const result = fn.subs(subs2);
+  ce.context = savedContext;
+  return result.op1.evaluate();
 }
 function holdMap(xs, skip, associativeHead, f) {
   if (xs.length === 0)
@@ -18824,7 +18936,7 @@ var ARITHMETIC_LIBRARY = [
             return ce._NEGATIVE_INFINITY;
           if (ops2.length === 1)
             return ops2[0];
-          return ce.box(["Max", ...ops2]);
+          return ce.fn("Max", ops2);
         },
         evaluate: (ce, ops2) => {
           if (ops2.length === 0)
@@ -18853,7 +18965,7 @@ var ARITHMETIC_LIBRARY = [
             return ce._NEGATIVE_INFINITY;
           if (ops2.length === 1)
             return ops2[0];
-          return ce.box(["Min", ...ops2]);
+          return ce.fn("Min", ops2);
         },
         evaluate: (ce, ops2) => {
           if (ops2.length === 0)
@@ -19220,14 +19332,13 @@ var ARITHMETIC_LIBRARY = [
     },
     Half: {
       constant: true,
-      holdUntil: "never",
+      holdUntil: "evaluate",
       value: ["Rational", 1, 2]
     },
     ImaginaryUnit: {
       domain: "ImaginaryNumber",
       constant: true,
       holdUntil: "evaluate",
-      // @todo maybe?
       wikidata: "Q193796",
       flags: { imaginary: true },
       value: ["Complex", 0, 1]
@@ -20055,8 +20166,7 @@ var CORE_LIBRARY = [
       signature: {
         domain: ["Function", ["Maybe", ["Sequence", "Anything"]], "String"],
         evaluate: (ce, ops2) => {
-          return ce.box([
-            "Latex",
+          return ce.fn("Latex", [
             ce.string(tokensToString(ops2.map((x) => x.string ?? x.latex)))
           ]);
         }
@@ -20079,7 +20189,7 @@ var CORE_LIBRARY = [
       hold: "all",
       signature: {
         domain: ["Function", ["Maybe", ["Sequence", "Anything"]], "String"],
-        evaluate: (ce, ops2) => ce.box(["Latex", ce.string(joinLatex(ops2.map((x) => x.latex)))])
+        evaluate: (ce, ops2) => ce.fn("Latex", [ce.string(joinLatex(ops2.map((x) => x.latex)))])
       }
     },
     SplitAsLatexTokens: {
@@ -20916,13 +21026,13 @@ var TRIGONOMETRY_LIBRARY = [
             "Number"
           ]);
           if (ops2.length !== 1)
-            return ce.box(["Degrees", ops2]);
+            return ce.fn("Degrees", ops2, { canonical: false });
           const arg = ops2[0];
           if (arg.numericValue === null || !arg.isValid)
-            return ce.box(["Degrees", arg]);
+            return ce.fn("Degrees", ops2, { canonical: false });
           return ce.div(ce.mul([arg, ce.symbol("Pi")]), ce.number(180));
         },
-        evaluate: (ce, ops2) => ce.mul([ops2[0], ce.box(["Divide", "Pi", 180])])
+        evaluate: (ce, ops2) => ce.mul([ops2[0], ce.div(ce.symbol("Pi"), ce.number(180))])
       }
     },
     Hypot: {
@@ -21290,8 +21400,8 @@ var CONSTRUCTIBLE_VALUES = [
   [
     [1, 8],
     {
-      Sin: "$\\frac\\sqrt{2-\\sqrt2}{2}$",
-      Cos: "$\\frac {\\sqrt {2+{\\sqrt {2}}}}{2}$",
+      Sin: "$\\frac{\\sqrt{2-\\sqrt2}}{2}$",
+      Cos: "$\\frac{\\sqrt {2+{\\sqrt {2}}}}{2}$",
       Tan: "$\\sqrt{2} - 1$",
       Cot: "$\\sqrt{2} + 1$",
       Sec: "$\\sqrt{ 4 - 2\\sqrt{2}}$",
@@ -21442,6 +21552,8 @@ var TRIG_IDENTITIES = {
   ]
 };
 function constructibleValues(ce, head2, x) {
+  if (!x)
+    return void 0;
   const specialValues = ce.cache(
     "constructible-trigonometric-values",
     () => {
@@ -21518,6 +21630,8 @@ function processInverseFunction(ce, xs) {
   return newHead ? ce.symbol(newHead) : void 0;
 }
 function evalTrig(ce, mode, head2, op3) {
+  if (!op3)
+    return void 0;
   if (mode === "evaluate") {
     const result = constructibleValues(ce, head2, op3)?.evaluate();
     if (result)
@@ -21715,7 +21829,7 @@ var BoxedSymbolDefinitionImpl = class {
     this._flags = def.flags ? normalizeFlags(def.flags) : void 0;
     this._domain = def.domain ? ce.domain(def.domain) : void 0;
     this.constant = def.constant ?? false;
-    this.holdUntil = def.holdUntil ?? "simplify";
+    this.holdUntil = def.holdUntil ?? "evaluate";
     if (this.constant) {
       this._defValue = def.value;
       this._value = null;
@@ -22390,7 +22504,19 @@ function isSymbolDefinition(def) {
   return !!def && typeof def === "object" && ("domain" in def || "value" in def || "constant" in def);
 }
 function isFunctionDefinition(def) {
-  return !!def && typeof def === "object" && ("complexity" in def || "numeric" in def || "signature" in def);
+  if (def === void 0 || def === null)
+    return false;
+  if (typeof def !== "object")
+    return false;
+  if ("complexity" in def || "numeric" in def || "signature" in def)
+    return true;
+  if (!("domain" in def))
+    return false;
+  if (def.domain === void 0)
+    return false;
+  if (typeof def.domain === "string")
+    return def.domain === "Function";
+  return def.domain.isFunction;
 }
 
 // src/compute-engine/library/library.ts
@@ -22470,7 +22596,7 @@ var LIBRARIES = {
   // @todo // volume, speed, area
   "domains": [],
   "core": CORE_LIBRARY,
-  "collections": [SETS_LIBRARY, COLLECTIONS_LIBRARY],
+  "collections": [SETS_LIBRARY, COLLECTIONS_LIBRARY, domainSetsLibrary()],
   // 'domains': getDomainsDictionary(),
   "linear-algebra": [],
   //@todo   // 'linear-algebra': [
@@ -23371,17 +23497,20 @@ var BoxedSymbol = class _BoxedSymbol extends AbstractBoxedExpression {
   }
   simplify(options) {
     const def = this.symbolDefinition;
-    if ((def?.holdUntil === "never" || def?.holdUntil === "simplify") && def.value)
+    if (def?.holdUntil === "simplify" && def.value)
       return def.value.simplify(options);
     return options?.rules ? this.replace(options.rules) ?? this : this;
   }
   evaluate(options) {
     const def = this.symbolDefinition;
-    if (def?.holdUntil !== "N")
-      return def?.value?.evaluate(options) ?? this;
+    if (def && (def.holdUntil === "simplify" || def.holdUntil === "evaluate"))
+      return def.value?.evaluate(options) ?? this;
     return this;
   }
   N(options) {
+    const def = this.symbolDefinition;
+    if (def && def.holdUntil === "never")
+      return this;
     return this.symbolDefinition?.value?.N(options) ?? this;
   }
   replace(rules, options) {
@@ -23767,16 +23896,6 @@ var ComputeEngine = class _ComputeEngine {
       this._tolerance = NUMERIC_TOLERANCE;
     this._bignumTolerance = this.bignum(this._tolerance);
   }
-  /** @internal */
-  bignum(a) {
-    if (typeof a === "bigint")
-      return new this._bignum(a.toString());
-    return new this._bignum(a);
-  }
-  /** @internal */
-  complex(a, b) {
-    return new import_complex19.Complex(a, b);
-  }
   chop(n) {
     if (typeof n === "number" && Math.abs(n) <= this._tolerance)
       return 0;
@@ -23786,6 +23905,20 @@ var ComputeEngine = class _ComputeEngine {
       return 0;
     return n;
   }
+  bignum(a) {
+    if (typeof a === "bigint")
+      return new this._bignum(a.toString());
+    return new this._bignum(a);
+  }
+  complex(a, b) {
+    return new import_complex19.Complex(a, b);
+  }
+  isBignum(a) {
+    return a instanceof Decimal;
+  }
+  isComplex(a) {
+    return a instanceof import_complex19.Complex;
+  }
   get latexSyntax() {
     if (!this._latexSyntax)
       this._latexSyntax = new LatexSyntax({
@@ -23794,7 +23927,7 @@ var ComputeEngine = class _ComputeEngine {
         precision: this.precision,
         avoidExponentsInRange: [-6, this.precision],
         onError: (err) => {
-          throw new Error(err[0].message.toString());
+          throw new Error(JSON.stringify(err[0].message));
         }
       });
     return this._latexSyntax;
@@ -24058,8 +24191,8 @@ var ComputeEngine = class _ComputeEngine {
     const bxs = xs;
     return bxs.every((x) => x.isCanonical) ? bxs : bxs.map((x) => x.canonical);
   }
-  fn(head2, ops2, metadata) {
-    return boxFunction(this, head2, ops2, { metadata, canonical: true });
+  fn(head2, ops2, options) {
+    return boxFunction(this, head2, ops2, options ?? { canonical: true });
   }
   /** @internal */
   _fn(head2, ops2, metadata) {
@@ -24473,20 +24606,21 @@ var ComputeEngine = class _ComputeEngine {
 };
 
 // src/compute-engine.ts
-var version = "0.12.4";
+var version = "0.12.6";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.12.4"
+  version: "0.12.6"
 };
 export {
   ComputeEngine,
   isEnvironmentEntry,
+  isExpressionEntry,
   isFunctionEntry,
-  isIdentifierEntry,
   isInfixEntry,
   isMatchfixEntry,
   isPostfixEntry,
   isPrefixEntry,
+  isSymbolEntry,
   version
 };
 /*! Bundled license information: