@cortex-js/compute-engine 0.12.4 → 0.12.6

package/dist/compute-engine.min.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.12.4 */
+/** CortexJS Compute Engine 0.12.6 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __create = Object.create;
@@ -1040,21 +1040,25 @@ var ComputeEngine = (() => {
   __export(compute_engine_exports, {
     ComputeEngine: () => ComputeEngine,
     isEnvironmentEntry: () => isEnvironmentEntry,
+    isExpressionEntry: () => isExpressionEntry,
     isFunctionEntry: () => isFunctionEntry,
-    isIdentifierEntry: () => isIdentifierEntry,
     isInfixEntry: () => isInfixEntry,
     isMatchfixEntry: () => isMatchfixEntry,
     isPostfixEntry: () => isPostfixEntry,
     isPrefixEntry: () => isPrefixEntry,
+    isSymbolEntry: () => isSymbolEntry,
     version: () => version
   });
 
   // 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";
@@ -4119,9 +4123,9 @@ var ComputeEngine = (() => {
     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)
@@ -4130,18 +4134,12 @@ var ComputeEngine = (() => {
         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))
@@ -4252,8 +4250,8 @@ var ComputeEngine = (() => {
     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)];
@@ -4440,13 +4438,13 @@ var ComputeEngine = (() => {
     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);
@@ -4454,7 +4452,7 @@ var ComputeEngine = (() => {
       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) ?? []) {
@@ -4583,7 +4581,7 @@ var ComputeEngine = (() => {
     {
       trigger: ["\\ang"],
       parse: (parser) => {
-        const arg = parser.matchLatexGroup();
+        const arg = parser.parseGroup();
         return arg === null ? ["Degrees"] : ["Degrees", arg];
       }
     },
@@ -4600,7 +4598,7 @@ var ComputeEngine = (() => {
       trigger: ["\\tilde", "<{>", "\\infty", "<}>"],
       parse: "ComplexInfinity"
     },
-    { name: "Pi", trigger: ["\\pi"] },
+    { name: "Pi", kind: "symbol", trigger: ["\\pi"] },
     { trigger: ["\u03C0"], parse: "Pi" },
     {
       name: "ExponentialE",
@@ -4608,6 +4606,15 @@ var ComputeEngine = (() => {
       parse: "ExponentialE",
       serialize: "\\exponentialE"
     },
+    {
+      kind: "function",
+      trigger: "exp",
+      parse: "Exp"
+    },
+    {
+      trigger: "\\exp",
+      parse: "Exp"
+    },
     {
       name: "ImaginaryUnit",
       trigger: ["\\imaginaryI"]
@@ -4627,10 +4634,7 @@ var ComputeEngine = (() => {
     {
       trigger: "abs",
       kind: "function",
-      parse: (parser) => {
-        const arg = parser.matchArguments("enclosure");
-        return arg === null ? "Abs" : ["Abs", ...arg];
-      }
+      parse: "Abs"
     },
     {
       name: "Add",
@@ -4638,10 +4642,10 @@ var ComputeEngine = (() => {
       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);
@@ -4653,9 +4657,9 @@ var ComputeEngine = (() => {
       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 });
       }
     },
     {
@@ -4664,13 +4668,16 @@ var ComputeEngine = (() => {
       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",
@@ -4731,11 +4738,12 @@ var ComputeEngine = (() => {
     },
     {
       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",
@@ -4755,13 +4763,16 @@ var ComputeEngine = (() => {
       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",
@@ -4777,9 +4788,9 @@ var ComputeEngine = (() => {
       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];
       }
     },
@@ -4787,9 +4798,9 @@ var ComputeEngine = (() => {
       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];
       }
     },
@@ -4840,10 +4851,10 @@ var ComputeEngine = (() => {
       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);
@@ -4854,10 +4865,10 @@ var ComputeEngine = (() => {
       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);
@@ -4868,9 +4879,9 @@ var ComputeEngine = (() => {
       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
@@ -4912,7 +4923,54 @@ var ComputeEngine = (() => {
       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",
@@ -4981,10 +5039,10 @@ var ComputeEngine = (() => {
       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)];
       }
     }
@@ -4996,9 +5054,9 @@ var ComputeEngine = (() => {
       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))
@@ -5016,7 +5074,7 @@ var ComputeEngine = (() => {
       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)
@@ -5077,10 +5135,10 @@ var ComputeEngine = (() => {
     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)
@@ -5109,7 +5167,7 @@ var ComputeEngine = (() => {
       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;
       }
@@ -5129,15 +5187,18 @@ var ComputeEngine = (() => {
     //
     {
       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";
       }
     },
@@ -5146,7 +5207,6 @@ var ComputeEngine = (() => {
     //
     {
       name: "BaseForm",
-      kind: "function",
       serialize: (serializer, expr) => {
         const radix = machineValue(op(expr, 2)) ?? NaN;
         if (isFinite(radix) && radix >= 2 && radix <= 36) {
@@ -5193,9 +5253,9 @@ var ComputeEngine = (() => {
         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);
@@ -5215,22 +5275,22 @@ var ComputeEngine = (() => {
     {
       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",
@@ -5292,12 +5352,12 @@ var ComputeEngine = (() => {
       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([
@@ -5330,8 +5390,8 @@ var ComputeEngine = (() => {
       // 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;
@@ -5346,7 +5406,7 @@ var ComputeEngine = (() => {
       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;
@@ -5418,10 +5478,20 @@ var ComputeEngine = (() => {
       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}"
     },
     {
@@ -5431,9 +5501,9 @@ var ComputeEngine = (() => {
         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() + ")}";
       }
@@ -5443,7 +5513,7 @@ var ComputeEngine = (() => {
       trigger: "cases",
       kind: "environment",
       parse: (parser) => {
-        const tabular = parser.matchTabular("cases");
+        const tabular = parser.parseTabular();
         if (!tabular)
           return ["Which"];
         const result = ["Which"];
@@ -5492,9 +5562,9 @@ var ComputeEngine = (() => {
         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) {
@@ -5507,7 +5577,7 @@ var ComputeEngine = (() => {
         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);
@@ -5517,7 +5587,7 @@ var ComputeEngine = (() => {
         }
       } 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);
@@ -5526,7 +5596,7 @@ var ComputeEngine = (() => {
           parser.index = index;
         }
       } else
-        text += parser.matchChar() ?? parser.next();
+        text += parser.matchChar() ?? parser.nextToken();
     }
     if (runinStyle !== null && text) {
       runs.push(["Style", `'${text}'`, { dict: runinStyle }]);
@@ -5595,7 +5665,7 @@ var ComputeEngine = (() => {
   // src/compute-engine/latex-syntax/dictionary/definitions-inequalities.ts
   var DEFINITIONS_INEQUALITIES = [
     {
-      trigger: ["!", "<"],
+      trigger: ["\\not", "<"],
       kind: "infix",
       associativity: "right",
       precedence: 246,
@@ -5641,7 +5711,7 @@ var ComputeEngine = (() => {
       kind: "infix",
       associativity: "right",
       precedence: 241,
-      parse: "Equal"
+      parse: "LessEqual"
     },
     {
       trigger: ["\\leqslant"],
@@ -5777,7 +5847,7 @@ var ComputeEngine = (() => {
     {
       name: "NotApprox",
       // Note: Mathematica TildeTilde
-      trigger: ["\\approx"],
+      trigger: ["\\not", "\\approx"],
       kind: "infix",
       associativity: "right",
       precedence: 247
@@ -5793,7 +5863,7 @@ var ComputeEngine = (() => {
     {
       name: "NotApproxEqual",
       // Note: Mathematica NotTildeEqual
-      trigger: ["!", "\\approxeq"],
+      trigger: ["\\not", "\\approxeq"],
       kind: "infix",
       // Note: no LaTeX symbol for char U+2249
       associativity: "right",
@@ -5881,7 +5951,7 @@ var ComputeEngine = (() => {
       precedence: 244
     },
     {
-      trigger: ["!", ">"],
+      trigger: ["\\not", ">"],
       kind: "infix",
       associativity: "right",
       precedence: 244,
@@ -6044,7 +6114,7 @@ var ComputeEngine = (() => {
   // 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];
     };
   }
@@ -6098,14 +6168,14 @@ var ComputeEngine = (() => {
     {
       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",
@@ -6135,9 +6205,9 @@ var ComputeEngine = (() => {
         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;
           }
@@ -6147,9 +6217,9 @@ var ComputeEngine = (() => {
           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];
@@ -6426,7 +6496,7 @@ var ComputeEngine = (() => {
   // 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",
@@ -6461,37 +6531,11 @@ var ComputeEngine = (() => {
       }[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 = [
@@ -6520,7 +6564,6 @@ var ComputeEngine = (() => {
       parse: parseTrig("Arccot")
     },
     {
-      kind: "function",
       name: "Arcsec",
       trigger: "arcsec",
       parse: parseTrig("Arcsec")
@@ -6721,14 +6764,14 @@ var ComputeEngine = (() => {
       // 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;
@@ -6808,8 +6851,8 @@ var ComputeEngine = (() => {
       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];
       }
     },
@@ -7014,9 +7057,10 @@ var ComputeEngine = (() => {
       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))
@@ -7092,7 +7136,7 @@ var ComputeEngine = (() => {
   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", "<}>"]))
@@ -7102,7 +7146,7 @@ var ComputeEngine = (() => {
     });
     if (!found) {
       parser.index = start;
-      fn = parser.matchExpression({
+      fn = parser.parseExpression({
         minPrec: 266,
         condition: () => {
           if (parser.match("d"))
@@ -7119,7 +7163,7 @@ var ComputeEngine = (() => {
   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);
@@ -7238,30 +7282,36 @@ var ComputeEngine = (() => {
   }
   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)
     }
@@ -7367,6 +7417,7 @@ var ComputeEngine = (() => {
   var DEFINITIONS_SYMBOLS = [
     ...SYMBOLS.map(([symbol2, latex, _codepoint]) => {
       return {
+        kind: "symbol",
         name: symbol2,
         trigger: [latex],
         parse: symbol2
@@ -7374,6 +7425,7 @@ var ComputeEngine = (() => {
     }),
     ...SYMBOLS.map(([symbol2, _latex, codepoint]) => {
       return {
+        kind: "symbol",
         trigger: [String.fromCodePoint(codepoint)],
         parse: symbol2
       };
@@ -7402,98 +7454,99 @@ var ComputeEngine = (() => {
       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) {
+      /* @__PURE__ */ 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) {
-        /* @__PURE__ */ 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) {
@@ -7501,7 +7554,7 @@ var ComputeEngine = (() => {
       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;
@@ -7534,29 +7587,57 @@ var ComputeEngine = (() => {
     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") {
-      /* @__PURE__ */ 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)) {
+    /* @__PURE__ */ 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
+        /* @__PURE__ */ console.assert(
+          entry.precedence === void 0,
+          "'precedence' not allowed with ^ and _ triggers"
+        );
+      } else
         result.precedence = entry.precedence ?? 1e4;
     }
     if (result.kind === "infix" && isInfixEntry(entry)) {
@@ -7569,7 +7650,7 @@ var ComputeEngine = (() => {
       } else if (trigger && (trigger[0] === "^" || trigger[0] === "_")) {
         /* @__PURE__ */ 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))
@@ -7578,11 +7659,11 @@ var ComputeEngine = (() => {
         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
             })
@@ -7594,7 +7675,7 @@ var ComputeEngine = (() => {
       if (typeof entry.parse === "function") {
         result.parse = entry.parse;
       } else if (entry.parse !== void 0) {
-        /* @__PURE__ */ console.assert(result.kind === "identifier");
+        /* @__PURE__ */ 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") {
@@ -7604,9 +7685,9 @@ var ComputeEngine = (() => {
           /* @__PURE__ */ 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];
           };
         }
@@ -7621,7 +7702,7 @@ var ComputeEngine = (() => {
         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 = "";
@@ -7751,6 +7832,7 @@ var ComputeEngine = (() => {
     physics: [
       {
         name: "mu0",
+        kind: "symbol",
         trigger: "\\mu_0"
       }
     ],
@@ -7800,6 +7882,7 @@ var ComputeEngine = (() => {
       special = {
         "+": "plus",
         "-": "minus",
+        "\\plusmn": "pm",
         "\\pm": "pm",
         "\\ast": "ast",
         "\\dag": "dag",
@@ -7815,22 +7898,22 @@ var ComputeEngine = (() => {
       }[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;
@@ -7856,7 +7939,7 @@ var ComputeEngine = (() => {
         id += next;
       }
       while (!parser.atEnd && /\d/.test(parser.peek))
-        id += parser.next();
+        id += parser.nextToken();
     }
     while (!parser.atEnd) {
       if (parser.match("\\degree"))
@@ -7905,7 +7988,7 @@ var ComputeEngine = (() => {
     const prefix = IDENTIFIER_PREFIX[parser.peek] ?? null;
     if (prefix === null)
       return null;
-    parser.next();
+    parser.nextToken();
     if (parser.match("<{>")) {
       let body = "";
       const digit = {
@@ -7922,7 +8005,7 @@ var ComputeEngine = (() => {
       }[parser.peek] ?? "";
       if (digit) {
         body = digit;
-        parser.next();
+        parser.nextToken();
       }
       body += matchIdentifierBody(parser);
       if (body === null || !parser.match("<}>")) {
@@ -7936,7 +8019,7 @@ var ComputeEngine = (() => {
     parser.index = start;
     return null;
   }
-  function matchInvalidIdentifier(parser) {
+  function parseInvalidIdentifier(parser) {
     const start = parser.index;
     const id = matchPrefixedIdentifier(parser);
     if (id === null || isValidIdentifier(id)) {
@@ -7950,13 +8033,13 @@ var ComputeEngine = (() => {
   }
   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();
@@ -8003,10 +8086,6 @@ var ComputeEngine = (() => {
     "\\lmoustache": ["\\lmoustache"],
     "\\rmoustache": ["\\rmoustache"]
   };
-  var MIDDLE_DELIMITER = {
-    ":": [":", "\\colon"],
-    "|": ["|", "\\|", "\\mid", "\\mvert"]
-  };
   var OPEN_DELIMITER_PREFIX = {
     "\\left": "\\right",
     "\\bigl": "\\bigr",
@@ -8018,17 +8097,6 @@ var ComputeEngine = (() => {
     "\\bigg": "\\bigg",
     "\\Bigg": "\\Bigg"
   };
-  var MIDDLE_DELIMITER_PREFIX = [
-    "\\middle",
-    "\\bigm",
-    "\\Bigm",
-    "\\biggm",
-    "\\Biggm",
-    "\\big",
-    "\\Big",
-    "\\bigg",
-    "\\Bigg"
-  ];
   var CLOSE_DELIMITER = {
     "(": ")",
     "[": "]",
@@ -8183,7 +8251,7 @@ var ComputeEngine = (() => {
       this._lastPeek = peek;
       return peek;
     }
-    next() {
+    nextToken() {
       return this._tokens[this.index++];
     }
     /**
@@ -8236,15 +8304,14 @@ var ComputeEngine = (() => {
     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
@@ -8252,6 +8319,10 @@ var ComputeEngine = (() => {
      * 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(
@@ -8270,12 +8341,12 @@ var ComputeEngine = (() => {
       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") {
@@ -8308,19 +8379,19 @@ var ComputeEngine = (() => {
      * 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;
@@ -8343,11 +8414,36 @@ var ComputeEngine = (() => {
         "\\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) {
+      /* @__PURE__ */ 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;
@@ -8394,7 +8490,7 @@ var ComputeEngine = (() => {
       } 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);
@@ -8409,62 +8505,171 @@ var ComputeEngine = (() => {
       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;
@@ -8482,21 +8687,21 @@ var ComputeEngine = (() => {
       }
       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;
       }
@@ -8505,10 +8710,10 @@ var ComputeEngine = (() => {
         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;
@@ -8524,7 +8729,7 @@ var ComputeEngine = (() => {
         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;
@@ -8533,11 +8738,11 @@ var ComputeEngine = (() => {
       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;
@@ -8545,7 +8750,7 @@ var ComputeEngine = (() => {
       }
       this.index = start;
       if (this.matchAll([`\\left`, "("])) {
-        repeatingDecimals2 = this.matchDecimalDigits();
+        repeatingDecimals2 = this.parseDecimalDigits();
         if (repeatingDecimals2 && this.matchAll([`\\right`, ")"]))
           return "(" + repeatingDecimals2 + ")";
         this.index = start;
@@ -8553,7 +8758,7 @@ var ComputeEngine = (() => {
       }
       this.index = start;
       if (this.matchAll([`\\overline`, "<{>"])) {
-        repeatingDecimals2 = this.matchDecimalDigits();
+        repeatingDecimals2 = this.parseDecimalDigits();
         if (repeatingDecimals2 && this.match("<}>"))
           return "(" + repeatingDecimals2 + ")";
         this.index = start;
@@ -8561,7 +8766,7 @@ var ComputeEngine = (() => {
       }
       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;
@@ -8570,9 +8775,13 @@ var ComputeEngine = (() => {
       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("+");
@@ -8582,32 +8791,32 @@ var ComputeEngine = (() => {
         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.
@@ -8626,7 +8835,7 @@ var ComputeEngine = (() => {
       while (token === "<space>" || token === "+" || token === "-") {
         if (token === "-")
           negative = !negative;
-        this.next();
+        this.nextToken();
         token = this.peek;
       }
       let radix = 10;
@@ -8657,7 +8866,7 @@ var ComputeEngine = (() => {
         ];
         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);
@@ -8668,12 +8877,12 @@ var ComputeEngine = (() => {
       }
       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);
@@ -8681,7 +8890,7 @@ var ComputeEngine = (() => {
         return null;
       return negative ? -result : result;
     }
-    matchPrefixOperator(until) {
+    parsePrefixOperator(until) {
       if (!until)
         until = { minPrec: 0 };
       if (!until.minPrec)
@@ -8699,7 +8908,7 @@ var ComputeEngine = (() => {
       this.index = start;
       return null;
     }
-    matchInfixOperator(lhs, until) {
+    parseInfixOperator(lhs, until) {
       until ?? (until = { minPrec: 0 });
       if (until.minPrec === void 0)
         until = { ...until, minPrec: 0 };
@@ -8710,7 +8919,7 @@ var ComputeEngine = (() => {
       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;
         }
@@ -8719,99 +8928,74 @@ var ComputeEngine = (() => {
       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.
      *
@@ -8824,7 +9008,7 @@ var ComputeEngine = (() => {
       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(["|", "|"])) {
@@ -8841,28 +9025,30 @@ var ComputeEngine = (() => {
       } 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;
@@ -8886,6 +9072,9 @@ var ComputeEngine = (() => {
       this.index = start;
       return null;
     }
+    /**
+     * Used for error handling
+     * @internal */
     matchEnclosureClose() {
       const defs = this._dictionary.matchfix;
       if (defs.length === 0)
@@ -8904,7 +9093,7 @@ var ComputeEngine = (() => {
           (x) => OPEN_DELIMITER_PREFIX[x] === peek
         );
         if (prefix)
-          this.next();
+          this.nextToken();
         let openDelimiter = [];
         peek = this.peek;
         const matchingDelim = Object.keys(CLOSE_DELIMITER).find(
@@ -8915,7 +9104,7 @@ var ComputeEngine = (() => {
         if (prefix)
           openDelimiter = [prefix, ...openDelimiter];
         if (openDelimiter.length > 0) {
-          this.next();
+          this.nextToken();
           return tokensToString(openDelimiter);
         }
       }
@@ -8927,7 +9116,7 @@ var ComputeEngine = (() => {
      * 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;
@@ -8938,7 +9127,7 @@ var ComputeEngine = (() => {
           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();
@@ -8963,12 +9152,12 @@ var ComputeEngine = (() => {
         }
         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;
@@ -8983,52 +9172,74 @@ var ComputeEngine = (() => {
       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;
@@ -9041,7 +9252,7 @@ var ComputeEngine = (() => {
         }
       }
       this.index = start;
-      const id = this.matchIdentifier();
+      const id = matchIdentifier(this);
       if (id === null)
         return null;
       if (this.options.parseUnknownIdentifier?.(id, this) === "symbol")
@@ -9049,57 +9260,19 @@ var ComputeEngine = (() => {
       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) {
       /* @__PURE__ */ console.assert(lhs !== null);
-      if (lhs === null)
-        return null;
       const index = this.index;
       this.skipSpace();
       const superscripts = [];
@@ -9111,7 +9284,7 @@ var ComputeEngine = (() => {
           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);
@@ -9121,7 +9294,7 @@ var ComputeEngine = (() => {
           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);
@@ -9145,7 +9318,7 @@ var ComputeEngine = (() => {
           ];
           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)
@@ -9163,7 +9336,7 @@ var ComputeEngine = (() => {
           ];
           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)
@@ -9175,7 +9348,7 @@ var ComputeEngine = (() => {
         this.index = index;
       return result;
     }
-    matchPostfix(lhs) {
+    parsePostfixOperator(lhs, until) {
       /* @__PURE__ */ console.assert(lhs !== null);
       if (lhs === null)
         return null;
@@ -9185,7 +9358,7 @@ var ComputeEngine = (() => {
       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;
       }
@@ -9197,119 +9370,32 @@ var ComputeEngine = (() => {
      * 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.
      *
@@ -9332,12 +9418,18 @@ var ComputeEngine = (() => {
      * => 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;
@@ -9346,13 +9438,9 @@ var ComputeEngine = (() => {
         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)) {
@@ -9365,7 +9453,7 @@ var ComputeEngine = (() => {
       }
       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",
@@ -9377,7 +9465,13 @@ var ComputeEngine = (() => {
         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) {
@@ -9406,7 +9500,7 @@ var ComputeEngine = (() => {
           if (def.name)
             return [
               def.name,
-              this.matchExpression() ?? this.error("missing", start)
+              this.parseExpression() ?? this.error("missing", start)
             ];
           return this.error("unexpected-operator", start);
         }
@@ -9415,11 +9509,9 @@ var ComputeEngine = (() => {
           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;
           }
@@ -9427,7 +9519,7 @@ var ComputeEngine = (() => {
             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);
         }
@@ -9435,10 +9527,10 @@ var ComputeEngine = (() => {
       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);
@@ -9450,7 +9542,7 @@ var ComputeEngine = (() => {
             level += 1;
           if (this.peek === "]")
             level -= 1;
-          this.next();
+          this.nextToken();
         }
         this.match("]");
       }
@@ -9476,7 +9568,7 @@ var ComputeEngine = (() => {
             level += 1;
           if (this.peek === "<}>")
             level -= 1;
-          this.next();
+          this.nextToken();
         }
         this.match("<}>");
       }
@@ -9484,15 +9576,20 @@ var ComputeEngine = (() => {
     }
     /**
      * <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))
@@ -9502,7 +9599,7 @@ var ComputeEngine = (() => {
       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("<}>")) {
@@ -9513,25 +9610,25 @@ var ComputeEngine = (() => {
         }
       }
       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) {
             /* @__PURE__ */ console.assert(this.index !== index, "No token consumed");
@@ -9540,9 +9637,8 @@ var ComputeEngine = (() => {
           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);
     }
     /**
@@ -9553,9 +9649,10 @@ var ComputeEngine = (() => {
      *  | <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) {
@@ -9565,9 +9662,9 @@ var ComputeEngine = (() => {
       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;
       }
@@ -9575,7 +9672,7 @@ var ComputeEngine = (() => {
         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);
           }
@@ -9586,6 +9683,7 @@ var ComputeEngine = (() => {
           }
         }
       }
+      lhs ?? (lhs = this.parseUnexpectedLatexCommand());
       return this.decorate(lhs, start);
     }
     /**
@@ -9620,18 +9718,19 @@ var ComputeEngine = (() => {
       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) {
@@ -9975,7 +10074,7 @@ var ComputeEngine = (() => {
       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)
@@ -10055,8 +10154,11 @@ var ComputeEngine = (() => {
       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]),
@@ -10083,10 +10185,12 @@ var ComputeEngine = (() => {
           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)
@@ -10099,7 +10203,7 @@ var ComputeEngine = (() => {
                 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);
@@ -10363,7 +10467,7 @@ var ComputeEngine = (() => {
         ...DEFAULT_SERIALIZE_LATEX_OPTIONS,
         ...opts
       };
-      this.dictionary = indexLatexDictionary(
+      this._dictionary = indexLatexDictionary(
         options.dictionary ?? _LatexSyntax.getDictionary(),
         (sig) => this.onError([sig])
       );
@@ -10384,16 +10488,16 @@ var ComputeEngine = (() => {
       }
       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) {
@@ -10402,8 +10506,8 @@ var ComputeEngine = (() => {
           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;
@@ -10417,7 +10521,7 @@ var ComputeEngine = (() => {
           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;
@@ -10439,9 +10543,9 @@ var ComputeEngine = (() => {
           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(
@@ -10474,7 +10578,7 @@ var ComputeEngine = (() => {
         return this._serializer;
       this._serializer = new Serializer(
         this.options,
-        this.dictionary,
+        this._dictionary,
         this.onError
       );
       return this._serializer;
@@ -13047,6 +13151,14 @@ var ComputeEngine = (() => {
     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());
@@ -15391,7 +15503,7 @@ var ComputeEngine = (() => {
     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)
@@ -15616,15 +15728,14 @@ var ComputeEngine = (() => {
       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 });
@@ -16605,7 +16716,6 @@ var ComputeEngine = (() => {
       return result;
     }
     solve(vars) {
-      /* @__PURE__ */ console.log("solve this:", this.toString());
       if (vars.length !== 1)
         return null;
       const roots = findUnivariateRoots(this.simplify(), vars[0]);
@@ -16684,6 +16794,8 @@ var ComputeEngine = (() => {
           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 {
@@ -16714,21 +16826,22 @@ var ComputeEngine = (() => {
     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)
@@ -18841,7 +18954,7 @@ var ComputeEngine = (() => {
               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)
@@ -18870,7 +18983,7 @@ var ComputeEngine = (() => {
               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)
@@ -19237,14 +19350,13 @@ var ComputeEngine = (() => {
       },
       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]
@@ -20072,8 +20184,7 @@ var ComputeEngine = (() => {
         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)))
             ]);
           }
@@ -20096,7 +20207,7 @@ var ComputeEngine = (() => {
         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: {
@@ -20933,13 +21044,13 @@ var ComputeEngine = (() => {
               "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: {
@@ -21307,8 +21418,8 @@ var ComputeEngine = (() => {
     [
       [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}}$",
@@ -21459,6 +21570,8 @@ var ComputeEngine = (() => {
     ]
   };
   function constructibleValues(ce, head2, x) {
+    if (!x)
+      return void 0;
     const specialValues = ce.cache(
       "constructible-trigonometric-values",
       () => {
@@ -21535,6 +21648,8 @@ var ComputeEngine = (() => {
     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)
@@ -21732,7 +21847,7 @@ var ComputeEngine = (() => {
       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;
@@ -22407,7 +22522,19 @@ var ComputeEngine = (() => {
     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
@@ -22487,7 +22614,7 @@ var ComputeEngine = (() => {
     // @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': [
@@ -23388,17 +23515,20 @@ ${JSON.stringify(entry)}`
     }
     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) {
@@ -23784,16 +23914,6 @@ ${JSON.stringify(entry)}`
         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;
@@ -23803,6 +23923,20 @@ ${JSON.stringify(entry)}`
         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({
@@ -23811,7 +23945,7 @@ ${JSON.stringify(entry)}`
           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;
@@ -24075,8 +24209,8 @@ ${JSON.stringify(entry)}`
       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) {
@@ -24490,10 +24624,10 @@ ${JSON.stringify(entry)}`
   };
 
   // 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"
   };
   return __toCommonJS(compute_engine_exports);
 })();