@cortex-js/compute-engine 0.55.0 → 0.55.2

package/dist/compile.umd.cjs

@@ -1,4 +1,4 @@
-/** Compile 0.55.0 */
+/** Compile 0.55.2 */
     (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.Compile = {}));})(this, (function (exports) { 'use strict';
 var Compile = (() => {
   var __defProp = Object.defineProperty;
@@ -4768,1132 +4768,1726 @@ var Compile = (() => {
     return expr;
   }
 
-  // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
-  function parseSequence(parser, terminator, lhs, prec, sep) {
-    if (terminator && terminator.minPrec >= prec) return null;
-    const result = lhs ? [lhs] : ["Nothing"];
-    let done = false;
-    while (!done) {
-      done = true;
-      parser.skipSpace();
-      while (parser.match(sep)) {
-        result.push("Nothing");
-        parser.skipSpace();
-      }
-      parser.skipVisualSpace();
-      if (parser.atTerminator(terminator)) {
-        result.push("Nothing");
-      } else {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: prec });
-        result.push(rhs ?? "Nothing");
-        done = rhs === null;
-      }
-      if (!done) {
-        parser.skipSpace();
-        done = !parser.match(sep);
-        if (!done) parser.skipVisualSpace();
-      }
-    }
-    return result;
-  }
-  function serializeOps(sep = "") {
-    return (serializer, expr) => {
-      if (!expr) return "";
-      const xs = operands(expr);
-      if (xs.length === 0) return "";
-      if (xs.length === 1) return serializer.serialize(xs[0]);
-      sep = {
-        "&": "\\&",
-        ":": "\\colon",
-        "|": "\\mvert",
-        "-": "-",
-        "\xB7": "\\cdot",
-        // U+00B7 MIDDLE DOT
-        "\u2012": "-",
-        // U+2012 FIGURE DASH
-        "\u2013": "--",
-        // U+2013 EN DASH
-        "\u2014": "---",
-        // U+2014 EM DASH
-        "\u2015": "-",
-        // U+2015 HORIZONTAL BAR
-        "\u2022": "\\bullet",
-        // U+2022 BULLET
-        "\u2026": "\\ldots"
-      }[sep] ?? sep;
-      const ys = xs.reduce((acc, item) => {
-        acc.push(serializer.serialize(item), sep);
-        return acc;
-      }, []);
-      ys.pop();
-      return joinLatex(ys);
-    };
-  }
-  var DEFINITIONS_CORE = [
-    //
+  // src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
+  var DEFINITIONS_LOGIC = [
     // Constants
-    //
     {
-      latexTrigger: ["\\placeholder"],
+      name: "True",
       kind: "symbol",
-      parse: (parser) => {
-        while (parser.match("<space>")) {
-        }
-        if (parser.match("["))
-          while (!parser.match("]") && !parser.atBoundary) parser.nextToken();
-        while (parser.match("<space>")) {
-        }
-        if (parser.match("<{>"))
-          while (!parser.match("<}>") && !parser.atBoundary) parser.nextToken();
-        return "Nothing";
-      }
+      latexTrigger: ["\\top"]
+      // ⊤ U+22A4
     },
-    { name: "ContinuationPlaceholder", latexTrigger: ["\\dots"] },
-    { latexTrigger: ["\\ldots"], parse: "ContinuationPlaceholder" },
-    { latexTrigger: [".", ".", "."], parse: "ContinuationPlaceholder" },
-    //
-    // Functions
-    //
-    // Anonymous function, i.e. `(x) \mapsto x^2`
     {
-      name: "Function",
-      latexTrigger: ["\\mapsto"],
-      kind: "infix",
-      precedence: ARROW_PRECEDENCE,
-      // MathML rightwards arrow
-      parse: (parser, lhs, _until) => {
-        let params = [];
-        if (operator(lhs) === "Delimiter") lhs = operand(lhs, 1) ?? "Nothing";
-        if (operator(lhs) === "Sequence") {
-          for (const x of operands(lhs)) {
-            if (!symbol(x)) return null;
-            params.push(symbol(x));
-          }
-        } else {
-          if (!symbol(lhs)) return null;
-          params = [symbol(lhs)];
-        }
-        let rhs = parser.parseExpression({ minPrec: ARROW_PRECEDENCE }) ?? "Nothing";
-        if (operator(rhs) === "Delimiter") rhs = operand(rhs, 1) ?? "Nothing";
-        if (operator(rhs) === "Sequence") rhs = ["Block", ...operands(rhs)];
-        return ["Function", rhs, ...params];
-      },
-      serialize: (serializer, expr) => {
-        const args = operands(expr);
-        if (args.length < 1) return "()\\mapsto()";
-        if (args.length === 1)
-          return joinLatex([
-            "()",
-            "\\mapsto",
-            serializer.serialize(operand(expr, 1))
-          ]);
-        if (args.length === 2) {
-          return joinLatex([
-            serializer.serialize(operand(expr, 2)),
-            "\\mapsto",
-            serializer.serialize(operand(expr, 1))
-          ]);
-        }
-        return joinLatex([
-          serializer.wrapString(
-            operands(expr)?.slice(1).map((x) => serializer.serialize(x)).join(", "),
-            "normal"
-          ),
-          "\\mapsto",
-          serializer.serialize(operand(expr, 1))
-        ]);
-      }
+      kind: "symbol",
+      latexTrigger: "\\mathrm{True}",
+      parse: "True"
     },
     {
-      name: "Apply",
-      kind: "function",
-      symbolTrigger: "apply",
-      serialize: (serializer, expr) => {
-        const lhs = operand(expr, 1);
-        const h = operator(lhs);
-        if (h === "InverseFunction" || h === "Derivative") {
-          const style2 = serializer.options.applyFunctionStyle(
-            expr,
-            serializer.level
-          );
-          const args = operands(expr).slice(1);
-          return serializer.serializeFunction(
-            lhs,
-            serializer.dictionary.ids.get(h)
-          ) + serializer.wrapString(
-            args.map((x) => serializer.serialize(x)).join(", "),
-            style2
-          );
-        }
-        const rhs = operand(expr, 2);
-        if (typeof lhs === "string" || !rhs) {
-          const fn = operands(expr).slice(1);
-          return serializer.serialize(fn);
-        }
-        if (nops(expr) === 2) {
-          return joinLatex([
-            serializer.wrap(lhs, 20),
-            "\\lhd",
-            serializer.wrap(rhs, 20)
-          ]);
-        }
-        const style = serializer.options.applyFunctionStyle(
-          expr,
-          serializer.level
-        );
-        return joinLatex([
-          "\\operatorname{apply}",
-          serializer.wrapString(
-            serializer.serialize(h) + ", " + serializer.serialize(["List", ...operands(expr)]),
-            style
-          )
-        ]);
-      }
+      kind: "symbol",
+      latexTrigger: "\\operatorname{True}",
+      parse: "True"
     },
     {
-      latexTrigger: "\\lhd",
-      kind: "infix",
-      precedence: 20,
-      parse: "Apply"
+      kind: "symbol",
+      latexTrigger: "\\mathsf{T}",
+      parse: "True"
     },
     {
-      latexTrigger: "\\rhd",
+      name: "False",
+      kind: "symbol",
+      latexTrigger: ["\\bot"]
+      // ⊥ U+22A5
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\operatorname{False}",
+      parse: "False"
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\mathsf{F}",
+      parse: "False"
+    },
+    // Operators
+    // Logic operators have lower precedence than comparisons (245)
+    // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
+    // See https://github.com/cortex-js/compute-engine/issues/243
+    {
+      name: "And",
       kind: "infix",
-      precedence: 20,
-      parse: (parser, lhs, _until) => {
-        const rhs = parser.parseExpression({ minPrec: 21 }) ?? "Nothing";
-        return ["Apply", rhs, lhs];
-      }
+      latexTrigger: ["\\land"],
+      precedence: 235
+      // serialize: '\\land',
     },
+    { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
+    { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
     {
-      name: "EvaluateAt",
-      openTrigger: ".",
-      closeTrigger: "|",
-      kind: "matchfix",
-      serialize: (serializer, expr) => {
-        const fn = operand(expr, 1);
-        if (!fn) return "";
-        const args = operands(expr).slice(1);
-        if (operator(fn) === "Function") {
-          const parameters = operands(fn).slice(1);
-          let body = operand(fn, 1);
-          if (operator(body) === "Block" && nops(body) === 1)
-            body = operand(body, 1);
-          if (parameters.length > 0) {
-            return `\\left.\\left(${serializer.serialize(
-              body
-            )}\\right)\\right|_{${parameters.map(
-              (x, i) => `${serializer.serialize(x)}=${serializer.serialize(args[i])}`
-            ).join(", ")}}`;
-          }
-        }
-        return `\\left.\\left(${serializer.serialize(fn)}\\right)\\right|_{${args.map((x) => serializer.serialize(x)).join(", ")}}`;
-      }
+      kind: "infix",
+      latexTrigger: "\\operatorname{and}",
+      parse: "And",
+      precedence: 235
     },
-    // The mathtools package includes several synonmyms for \colonequals. The
-    // preferred one as of summer 2022 is `\coloneq` (see § 3.7.3 https://ctan.math.illinois.edu/macros/latex/contrib/mathtools/mathtools.pdf)
     {
-      name: "Assign",
-      latexTrigger: "\\coloneq",
+      name: "Or",
       kind: "infix",
-      associativity: "right",
-      precedence: ASSIGNMENT_PRECEDENCE,
-      serialize: (serializer, expr) => {
-        const id = unhold(operand(expr, 1));
-        if (operator(operand(expr, 2)) === "Function") {
-          const op_2 = operand(expr, 2);
-          const body = unhold(operand(op_2, 1));
-          const args = operands(op_2).slice(1);
-          return joinLatex([
-            serializer.serialize(id),
-            serializer.wrapString(
-              args.map((x) => serializer.serialize(x)).join(", "),
-              serializer.options.applyFunctionStyle(expr, serializer.level)
-            ),
-            "\\coloneq",
-            serializer.serialize(body)
-          ]);
-        }
-        return joinLatex([
-          serializer.serialize(id),
-          "\\coloneq",
-          serializer.serialize(operand(expr, 2))
-        ]);
-      },
-      parse: parseAssign
+      latexTrigger: ["\\lor"],
+      precedence: 230
     },
+    { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
+    { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
     {
-      latexTrigger: "\\coloneqq",
       kind: "infix",
-      associativity: "right",
-      precedence: ASSIGNMENT_PRECEDENCE,
-      parse: parseAssign
+      latexTrigger: "\\operatorname{or}",
+      parse: "Or",
+      precedence: 230
     },
-    // From the colonequals package:
     {
-      latexTrigger: "\\colonequals",
+      name: "Xor",
       kind: "infix",
-      associativity: "right",
-      precedence: ASSIGNMENT_PRECEDENCE,
-      parse: parseAssign
+      latexTrigger: ["\\veebar"],
+      precedence: 232
     },
+    // Possible alt: \oplus ⊕ U+2295
     {
-      latexTrigger: [":", "="],
-      kind: "infix",
-      associativity: "right",
-      precedence: ASSIGNMENT_PRECEDENCE,
-      parse: parseAssign
+      name: "Not",
+      kind: "prefix",
+      latexTrigger: ["\\lnot"],
+      precedence: 880
     },
-    // General colon operator (type annotation, mapping notation)
-    // Precedence below assignment (260) so `:=` takes priority,
-    // and below arrows (270) so `f: A \to B` parses as `Colon(f, To(A, B))`
     {
-      name: "Colon",
-      latexTrigger: ":",
+      kind: "prefix",
+      latexTrigger: ["\\neg"],
+      parse: "Not",
+      precedence: 880
+    },
+    {
+      name: "Nand",
       kind: "infix",
-      associativity: "right",
-      precedence: 250,
-      serialize: (serializer, expr) => joinLatex([
-        serializer.serialize(operand(expr, 1)),
-        "\\colon",
-        serializer.serialize(operand(expr, 2))
-      ])
+      latexTrigger: ["\\barwedge"],
+      precedence: 232
+      // serialize: '\\mid',
     },
     {
-      latexTrigger: "\\colon",
+      name: "Nor",
       kind: "infix",
-      associativity: "right",
-      precedence: 250,
-      parse: "Colon"
+      latexTrigger: ["\u22BD"],
+      // bar vee
+      precedence: 232
+      // serialize: '\\downarrow',
     },
+    // Functions
     {
-      name: "BaseForm",
-      serialize: (serializer, expr) => {
-        const radix = machineValue(operand(expr, 2)) ?? NaN;
-        if (isFinite(radix) && radix >= 2 && radix <= 36) {
-          const num = machineValue(operand(expr, 1)) ?? NaN;
-          if (isFinite(num) && Number.isInteger(num)) {
-            let digits = Number(num).toString(radix);
-            let groupLength = 0;
-            if (radix === 2) {
-              groupLength = 4;
-            } else if (radix === 10) {
-              groupLength = 4;
-            } else if (radix === 16) {
-              groupLength = 2;
-            } else if (radix > 16) {
-              groupLength = 4;
-            }
-            if (groupLength > 0) {
-              const oldDigits = digits;
-              digits = "";
-              for (let i = 0; i < oldDigits.length; i++) {
-                if (i > 0 && i % groupLength === 0) digits = "\\, " + digits;
-                digits = oldDigits[oldDigits.length - i - 1] + digits;
-              }
-            }
-            return `(\\text{${digits}}_{${radix}}`;
-          }
-        }
-        return "\\operatorname{BaseForm}(" + serializer.serialize(operand(expr, 1)) + ", " + serializer.serialize(operand(expr, 2)) + ")";
-      }
+      kind: "function",
+      symbolTrigger: "and",
+      parse: "And"
     },
     {
-      name: "Sequence",
-      // Use a space as a separator, otherwise a sequence of numbers
-      // could be interpreted as a single number.
-      serialize: serializeOps(" ")
+      kind: "function",
+      symbolTrigger: "or",
+      parse: "Or"
     },
     {
-      name: "InvisibleOperator",
-      serialize: serializeOps("")
+      kind: "function",
+      symbolTrigger: "not",
+      parse: "Not"
     },
+    // Relations
     {
-      // The first argument is a function expression.
-      // The second (optional) argument is a string specifying the
-      // delimiters and separator.
-      name: "Delimiter",
-      serialize: (serializer, expr) => {
-        const style = serializer.options.groupStyle(expr, serializer.level + 1);
-        const arg1 = operand(expr, 1);
-        let delims = {
-          Set: "{,}",
-          List: "[,]",
-          Tuple: "(,)",
-          Single: "(,)",
-          Pair: "(,)",
-          Triple: "(,)",
-          Sequence: "(,)",
-          String: '""'
-        }[operator(arg1)];
-        const items = delims ? arg1 : ["Sequence", arg1];
-        delims ??= "(,)";
-        if (nops(expr) > 1) {
-          const op2 = stringValue(operand(expr, 2));
-          if (typeof op2 === "string" && op2.length <= 3) delims = op2;
-        }
-        let [open, sep, close] = ["", "", ""];
-        if (delims.length === 3) [open, sep, close] = delims;
-        else if (delims.length === 2) [open, close] = delims;
-        else if (delims.length === 1) sep = delims;
-        const body = arg1 ? items ? serializeOps(sep)(serializer, items) : serializer.serialize(arg1) : "";
-        return serializer.wrapString(body, style, open + close);
-      }
+      name: "Implies",
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      latexTrigger: ["\\implies"],
+      serialize: "\\implies"
     },
     {
-      name: "Tuple",
-      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
+      latexTrigger: ["\\Rightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
     },
     {
-      name: "Pair",
-      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
+      latexTrigger: ["\\rightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
     },
     {
-      name: "Triple",
-      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
+      latexTrigger: ["\\Longrightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
     },
     {
-      name: "Single",
-      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
+      latexTrigger: ["\\longrightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
     },
     {
-      name: "Domain",
-      serialize: (serializer, expr) => {
-        if (operator(expr) === "Error") return serializer.serialize(expr);
-        return `\\mathbf{${serializer.serialize(operand(expr, 1))}}`;
+      // Non-strict mode: => for implies
+      latexTrigger: ["=", ">"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: (parser, lhs, until) => {
+        if (parser.options.strict !== false) return null;
+        const rhs = parser.parseExpression({ ...until, minPrec: 220 });
+        if (rhs === null) return null;
+        return ["Implies", lhs, rhs];
       }
     },
     {
-      latexTrigger: ["\\mathtip"],
-      parse: (parser) => {
-        const op1 = parser.parseGroup();
-        parser.parseGroup();
-        return op1;
-      }
+      name: "Equivalent",
+      // MathML: identical to, Mathematica: Congruent
+      latexTrigger: ["\\iff"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219
     },
     {
-      latexTrigger: ["\\texttip"],
-      parse: (parser) => {
-        const op1 = parser.parseGroup();
-        parser.parseGroup();
-        return op1;
-      }
+      latexTrigger: ["\\Leftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
     },
     {
-      latexTrigger: ["\\error"],
-      parse: (parser) => ["Error", parser.parseGroup()]
+      latexTrigger: ["\\leftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
     },
     {
-      name: "Error",
-      serialize: (serializer, expr) => {
-        const op1 = operand(expr, 1);
-        if (stringValue(op1) === "missing")
-          return `\\error{${serializer.options.missingSymbol ?? "\\placeholder{}"}}`;
-        const where = errorContextAsLatex(serializer, expr) || "\\blacksquare";
-        const code = operator(op1) === "ErrorCode" ? stringValue(operand(op1, 1)) : stringValue(op1);
-        if (code === "incompatible-type") {
-          if (symbol(operand(op1, 3)) === "Undefined") {
-            return `\\mathtip{\\error{${where}}}{\\notin ${serializer.serialize(
-              operand(op1, 2)
-            )}}`;
-          }
-          return `\\mathtip{\\error{${where}}}{\\in ${serializer.serialize(
-            operand(op1, 3)
-          )}\\notin ${serializer.serialize(operand(op1, 2))}}`;
-        }
-        if (typeof code === "string") return `\\error{${where}}`;
-        return `\\error{${where}}`;
-      }
-    },
-    {
-      name: "ErrorCode",
-      serialize: (serializer, expr) => {
-        const code = stringValue(operand(expr, 1));
-        if (code === "missing")
-          return serializer.options.missingSymbol ?? "\\placeholder{}";
-        if (code === "unexpected-command" || code === "unexpected-operator" || code === "unexpected-token" || code === "invalid-symbol" || code === "unknown-environment" || code === "unexpected-base" || code === "incompatible-type") {
-          return "";
-        }
-        return `\\texttip{\\error{\\blacksquare}}{\\mathtt{${code}}}`;
-      }
+      latexTrigger: ["\\Longleftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
     },
     {
-      name: "FromLatex",
-      serialize: (_serializer, expr) => {
-        return `\\texttt{${sanitizeLatex(stringValue(operand(expr, 1)))}}`;
-      }
+      latexTrigger: ["\\longleftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
     },
     {
-      name: "Latex",
-      serialize: (serializer, expr) => {
-        if (expr === null) return "";
-        return joinLatex(
-          mapArgs(expr, (x) => stringValue(x) ?? serializer.serialize(x))
-        );
+      // Non-strict mode: <=> for equivalence
+      latexTrigger: ["<", "=", ">"],
+      kind: "infix",
+      precedence: 219,
+      associativity: "right",
+      parse: (parser, lhs, until) => {
+        if (parser.options.strict !== false) return null;
+        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        if (rhs === null) return null;
+        return ["Equivalent", lhs, rhs];
       }
     },
     {
-      name: "LatexString",
-      serialize: (serializer, expr) => {
-        if (expr === null) return "";
-        return joinLatex(mapArgs(expr, (x) => serializer.serialize(x)));
+      latexTrigger: ["\\equiv"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: (parser, lhs, terminator) => {
+        const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
+        const index = parser.index;
+        const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
+        if (modulus !== null && operator(modulus) === "Mod")
+          return ["Congruent", lhs, rhs, missingIfEmpty(operand(modulus, 1))];
+        parser.index = index;
+        return ["Equivalent", lhs, missingIfEmpty(rhs)];
       }
     },
-    { name: "LatexTokens", serialize: serializeLatexTokens },
     {
-      name: "At",
-      kind: "postfix",
-      precedence: 810,
-      latexTrigger: ["["],
-      parse: parseAt("]"),
-      serialize: (serializer, expr) => joinLatex(["\\lbrack", serializeOps(", ")(serializer, expr), "\\rbrack"])
+      name: "Proves",
+      kind: "infix",
+      latexTrigger: ["\\vdash"],
+      precedence: 220,
+      associativity: "right",
+      serialize: "\\vdash"
     },
     {
-      kind: "postfix",
-      precedence: 810,
-      latexTrigger: ["\\lbrack"],
-      parse: parseAt("\\rbrack")
+      name: "Entails",
+      kind: "infix",
+      latexTrigger: ["\\vDash"],
+      precedence: 220,
+      associativity: "right",
+      serialize: "\\vDash"
     },
     {
-      kind: "postfix",
-      precedence: 810,
-      latexTrigger: ["\\left", "\\lbrack"],
-      parse: parseAt("\\right", "\\rbrack")
+      name: "Satisfies",
+      kind: "infix",
+      latexTrigger: ["\\models"],
+      precedence: 220,
+      associativity: "right",
+      serialize: "\\models"
     },
+    // Quantifiers: for all, exists
     {
-      kind: "postfix",
-      latexTrigger: ["_"],
-      parse: (parser, lhs, _until) => {
-        let rhs = parser.parseGroup() ?? parser.parseToken();
-        if (rhs === null && parser.options.strict === false && parser.peek === "(")
-          rhs = parser.parseEnclosure();
-        const sym2 = symbol(lhs);
-        if (rhs !== null && (sym2 && parser.getSymbolType(sym2).matches("indexed_collection") || operator(lhs) === "List")) {
-          if (operator(rhs) === "Delimiter") rhs = operand(rhs, 1) ?? "Nothing";
-          if (operator(rhs) === "Sequence") return ["At", lhs, ...operands(rhs)];
-          return ["At", lhs, rhs];
-        }
-        return ["Subscript", lhs, rhs];
-      }
+      name: "ForAll",
+      kind: "prefix",
+      latexTrigger: ["\\forall"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE
+      serialize: serializeQuantifier("\\forall"),
+      parse: parseQuantifier("ForAll")
     },
     {
-      name: "List",
-      kind: "matchfix",
-      openTrigger: "[",
-      closeTrigger: "]",
-      parse: parseBrackets,
-      serialize: serializeList
+      name: "Exists",
+      kind: "prefix",
+      latexTrigger: ["\\exists"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: serializeQuantifier("\\exists"),
+      parse: parseQuantifier("Exists")
     },
     {
-      kind: "matchfix",
-      openTrigger: "(",
-      closeTrigger: ")",
-      parse: parseParenDelimiter
+      name: "ExistsUnique",
+      kind: "prefix",
+      latexTrigger: ["\\exists", "!"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: serializeQuantifier("\\exists!"),
+      parse: parseQuantifier("ExistsUnique")
     },
     {
-      latexTrigger: [","],
-      kind: "infix",
-      precedence: 20,
-      // Unlike the matchfix version of List,
-      // 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, lhs, terminator) => {
-        const seq = parseSequence(parser, terminator, lhs, 20, ",");
-        if (seq === null) return null;
-        return ["Delimiter", ["Sequence", ...seq], { str: "," }];
-      }
+      name: "NotForAll",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\forall"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE
+      serialize: serializeQuantifier("\\lnot\\forall"),
+      parse: parseQuantifier("NotForAll")
     },
-    // Entry to handle the case of a single comma
-    // with a missing lhs.
     {
-      latexTrigger: [","],
+      name: "NotExists",
       kind: "prefix",
-      precedence: 20,
-      parse: (parser, terminator) => {
-        const seq = parseSequence(parser, terminator, null, 20, ",");
-        if (seq === null) return null;
-        return ["Delimiter", ["Sequence", ...seq], { str: "," }];
-      }
+      latexTrigger: ["\\lnot", "\\exists"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: serializeQuantifier("\\lnot\\exists"),
+      parse: parseQuantifier("NotExists")
     },
     {
-      name: "Range",
-      latexTrigger: [".", "."],
-      kind: "infix",
-      // associativity: 'left',
-      precedence: 800,
-      parse: parseRange,
+      name: "KroneckerDelta",
+      kind: "prefix",
+      latexTrigger: ["\\delta", "_"],
+      precedence: 200,
       serialize: (serializer, expr) => {
         const args = operands(expr);
-        if (args.length === 0) return "";
-        if (args.length === 1)
-          return "1.." + serializer.serialize(operand(expr, 1));
-        if (args.length === 2)
-          return serializer.wrap(operand(expr, 1), 10) + ".." + serializer.wrap(operand(expr, 2), 10);
-        if (args.length === 3) {
-          const step = machineValue(operand(expr, 3));
-          const start = machineValue(operand(expr, 1));
-          if (step !== null && start !== null) {
-            return serializer.wrap(operand(expr, 1), 10) + ".." + serializer.wrap(start + step, 10) + ".." + serializer.wrap(operand(expr, 2), 10);
-          }
-          return serializer.wrap(operand(expr, 1), 10) + "..(" + (serializer.wrap(operand(expr, 1), ADDITION_PRECEDENCE) + "+" + serializer.wrap(operand(expr, 3), ADDITION_PRECEDENCE)) + ").." + serializer.wrap(operand(expr, 2), 10);
+        if (args.length === 0) return "\\delta";
+        if (args.every((x) => symbol(x)))
+          return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join("")}}`;
+        return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join(", ")}}`;
+      },
+      parse: (parser) => {
+        const group = parser.parseGroup();
+        if (group === null) {
+          const token = parser.parseToken();
+          if (!token) return null;
+          return ["KroneckerDelta", token];
         }
-        return "";
+        const seq = getSequence(group);
+        if (seq && seq.length <= 2) return ["KroneckerDelta", ...seq];
+        if (operator(group) === "InvisibleOperator")
+          return ["KroneckerDelta", ...operands(group)];
+        if (group !== null) return ["KroneckerDelta", group];
+        return null;
       }
     },
+    // Iverson brackets. Also called the "indicator function"
+    // Must have a single argument, a relational expression, i.e.
+    // `[ a = b ]` or `[ x \leq 0 ]`
+    // Otherwise, it gets rejected, it could be something else, like a list or
+    // tuple.
     {
-      latexTrigger: [";"],
-      kind: "infix",
-      precedence: 19,
-      parse: (parser, lhs, terminator) => {
-        const seq = parseSequence(parser, terminator, lhs, 19, ";");
-        if (seq === null) return null;
-        if (seq.some((e) => operator(e) === "Assign"))
-          return buildBlockFromSequence(seq);
-        return ["Delimiter", ["Sequence", ...seq], "';'"];
+      name: "Boole",
+      kind: "matchfix",
+      openTrigger: "[",
+      closeTrigger: "]",
+      // serialize: (serializer: Serializer, expr: MathJsonExpression) => {
+      //   const args = ops(expr);
+      //   return `[${serializer.serialize(arg)}]`;
+      // },
+      parse: (_parser, body) => {
+        const h = operator(body);
+        if (!h) return null;
+        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
+        return ["Boole", body];
       }
     },
-    // \text{where} — variable binding infix
     {
-      latexTrigger: ["\\text"],
-      kind: "infix",
-      associativity: "none",
-      precedence: 21,
-      // Above ; (19) and , (20), very low binding
-      parse: (parser, lhs, until) => {
-        const start = parser.index;
-        if (!matchTextKeyword(parser, "where")) {
-          parser.index = start;
-          return null;
-        }
-        return parseWhereExpression(parser, lhs, until);
+      kind: "matchfix",
+      openTrigger: "\\llbracket",
+      closeTrigger: "\\rrbracket",
+      parse: (_parser, body) => {
+        const h = operator(body);
+        if (!h) return null;
+        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
+        return ["Boole", body];
       }
     },
-    // \operatorname{where}
-    {
-      symbolTrigger: "where",
-      kind: "infix",
-      associativity: "none",
-      precedence: 21,
-      parse: (parser, lhs, until) => parseWhereExpression(parser, lhs, until)
-    },
-    // Block serializer — used by both `where` and semicolon blocks
+    // Predicate application in First-Order Logic.
+    // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
     {
-      name: "Block",
+      name: "Predicate",
       serialize: (serializer, expr) => {
         const args = operands(expr);
-        if (!args || args.length === 0) return "";
-        const parts = args.filter((a) => operator(a) !== "Declare").map((a) => serializer.serialize(a));
-        return parts.join("; ");
+        if (args.length === 0) return "";
+        const pred = args[0];
+        const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
+        if (args.length === 1) return predStr;
+        const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
+        return `${predStr}(${argStrs.join(", ")})`;
+      }
+    }
+  ];
+  function serializeQuantifier(quantifierSymbol) {
+    return (serializer, expr) => {
+      const args = operands(expr);
+      if (args.length === 0) return quantifierSymbol;
+      if (args.length === 1)
+        return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
+      const boundVar = serializer.serialize(args[0]);
+      const body = serializer.serialize(args[1]);
+      return `${quantifierSymbol} ${boundVar}, ${body}`;
+    };
+  }
+  function tightBindingCondition(p, terminator) {
+    return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
+  }
+  function parseQuantifier(kind) {
+    return (parser, terminator) => {
+      const index = parser.index;
+      const useTightBinding = parser.options.quantifierScope !== "loose";
+      const symbol2 = parser.parseSymbol(terminator);
+      if (symbol2) {
+        parser.skipSpace();
+        if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
+          const bodyTerminator = useTightBinding ? {
+            ...terminator,
+            condition: (p) => tightBindingCondition(p, terminator)
+          } : terminator;
+          parser.enterQuantifierScope();
+          const body2 = parser.parseExpression(bodyTerminator);
+          parser.exitQuantifierScope();
+          return [kind, symbol2, missingIfEmpty(body2)];
+        }
+        parser.enterQuantifierScope();
+        const body = parser.parseEnclosure();
+        parser.exitQuantifierScope();
+        if (body) return [kind, symbol2, missingIfEmpty(body)];
+      }
+      parser.index = index;
+      const condTerminator = {
+        ...terminator,
+        condition: (p) => p.peek === ":" || p.peek === "\\colon" || (terminator.condition?.(p) ?? false)
+      };
+      const condition = parser.parseExpression(condTerminator);
+      if (condition === null) return null;
+      parser.skipSpace();
+      if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
+        const bodyTerminator = useTightBinding ? {
+          ...terminator,
+          condition: (p) => tightBindingCondition(p, terminator)
+        } : terminator;
+        parser.enterQuantifierScope();
+        const body = parser.parseExpression(bodyTerminator);
+        parser.exitQuantifierScope();
+        return [kind, condition, missingIfEmpty(body)];
+      }
+      if (parser.match("(")) {
+        parser.enterQuantifierScope();
+        const body = parser.parseExpression(terminator);
+        parser.exitQuantifierScope();
+        if (!parser.match(")")) return null;
+        return [kind, condition, missingIfEmpty(body)];
+      }
+      return null;
+    };
+  }
+
+  // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
+  function parseSequence(parser, terminator, lhs, prec, sep) {
+    if (terminator && terminator.minPrec >= prec) return null;
+    const result = lhs ? [lhs] : ["Nothing"];
+    let done = false;
+    while (!done) {
+      done = true;
+      parser.skipSpace();
+      while (parser.match(sep)) {
+        result.push("Nothing");
+        parser.skipSpace();
+      }
+      parser.skipVisualSpace();
+      if (parser.atTerminator(terminator)) {
+        result.push("Nothing");
+      } else {
+        const rhs = parser.parseExpression({ ...terminator, minPrec: prec });
+        result.push(rhs ?? "Nothing");
+        done = rhs === null;
+      }
+      if (!done) {
+        parser.skipSpace();
+        done = !parser.match(sep);
+        if (!done) parser.skipVisualSpace();
+      }
+    }
+    return result;
+  }
+  function serializeOps(sep = "") {
+    return (serializer, expr) => {
+      if (!expr) return "";
+      const xs = operands(expr);
+      if (xs.length === 0) return "";
+      if (xs.length === 1) return serializer.serialize(xs[0]);
+      sep = {
+        "&": "\\&",
+        ":": "\\colon",
+        "|": "\\mvert",
+        "-": "-",
+        "\xB7": "\\cdot",
+        // U+00B7 MIDDLE DOT
+        "\u2012": "-",
+        // U+2012 FIGURE DASH
+        "\u2013": "--",
+        // U+2013 EN DASH
+        "\u2014": "---",
+        // U+2014 EM DASH
+        "\u2015": "-",
+        // U+2015 HORIZONTAL BAR
+        "\u2022": "\\bullet",
+        // U+2022 BULLET
+        "\u2026": "\\ldots"
+      }[sep] ?? sep;
+      const ys = xs.reduce((acc, item) => {
+        acc.push(serializer.serialize(item), sep);
+        return acc;
+      }, []);
+      ys.pop();
+      return joinLatex(ys);
+    };
+  }
+  var DEFINITIONS_CORE = [
+    //
+    // Constants
+    //
+    {
+      latexTrigger: ["\\placeholder"],
+      kind: "symbol",
+      parse: (parser) => {
+        while (parser.match("<space>")) {
+        }
+        if (parser.match("["))
+          while (!parser.match("]") && !parser.atBoundary) parser.nextToken();
+        while (parser.match("<space>")) {
+        }
+        if (parser.match("<{>"))
+          while (!parser.match("<}>") && !parser.atBoundary) parser.nextToken();
+        return "Nothing";
       }
     },
-    // Serializer for If expressions (separate from the parser entry
-    // because name-based entries affect kind-based indexing)
+    { name: "ContinuationPlaceholder", latexTrigger: ["\\dots"] },
+    { latexTrigger: ["\\ldots"], parse: "ContinuationPlaceholder" },
+    { latexTrigger: [".", ".", "."], parse: "ContinuationPlaceholder" },
+    //
+    // Functions
+    //
+    // Anonymous function, i.e. `(x) \mapsto x^2`
     {
-      name: "If",
+      name: "Function",
+      latexTrigger: ["\\mapsto"],
+      kind: "infix",
+      precedence: ARROW_PRECEDENCE,
+      // MathML rightwards arrow
+      parse: (parser, lhs, _until) => {
+        let params = [];
+        if (operator(lhs) === "Delimiter") lhs = operand(lhs, 1) ?? "Nothing";
+        if (operator(lhs) === "Sequence") {
+          for (const x of operands(lhs)) {
+            if (!symbol(x)) return null;
+            params.push(symbol(x));
+          }
+        } else {
+          if (!symbol(lhs)) return null;
+          params = [symbol(lhs)];
+        }
+        let rhs = parser.parseExpression({ minPrec: ARROW_PRECEDENCE }) ?? "Nothing";
+        if (operator(rhs) === "Delimiter") rhs = operand(rhs, 1) ?? "Nothing";
+        if (operator(rhs) === "Sequence") rhs = ["Block", ...operands(rhs)];
+        return ["Function", rhs, ...params];
+      },
       serialize: (serializer, expr) => {
         const args = operands(expr);
-        if (!args || args.length < 3) return "";
+        if (args.length < 1) return "()\\mapsto()";
+        if (args.length === 1)
+          return joinLatex([
+            "()",
+            "\\mapsto",
+            serializer.serialize(operand(expr, 1))
+          ]);
+        if (args.length === 2) {
+          return joinLatex([
+            serializer.serialize(operand(expr, 2)),
+            "\\mapsto",
+            serializer.serialize(operand(expr, 1))
+          ]);
+        }
         return joinLatex([
-          "\\text{if }",
-          serializer.serialize(args[0]),
-          "\\text{ then }",
-          serializer.serialize(args[1]),
-          "\\text{ else }",
-          serializer.serialize(args[2])
+          serializer.wrapString(
+            operands(expr)?.slice(1).map((x) => serializer.serialize(x)).join(", "),
+            "normal"
+          ),
+          "\\mapsto",
+          serializer.serialize(operand(expr, 1))
         ]);
       }
     },
-    // Serializer for Loop expressions
     {
-      name: "Loop",
+      name: "Apply",
+      kind: "function",
+      symbolTrigger: "apply",
       serialize: (serializer, expr) => {
-        const args = operands(expr);
-        if (!args || args.length < 2) return "";
-        const body = args[0];
-        const indexing = args[1];
-        if (operator(indexing) === "Element") {
-          const index = operand(indexing, 1);
-          const range2 = operand(indexing, 2);
-          if (operator(range2) === "Range") {
-            const lo = operand(range2, 1);
-            const hi = operand(range2, 2);
-            return joinLatex([
-              "\\text{for }",
-              serializer.serialize(index),
-              "\\text{ from }",
-              serializer.serialize(lo),
-              "\\text{ to }",
-              serializer.serialize(hi),
-              "\\text{ do }",
-              serializer.serialize(body)
-            ]);
-          }
+        const lhs = operand(expr, 1);
+        const h = operator(lhs);
+        if (h === "InverseFunction" || h === "Derivative") {
+          const style2 = serializer.options.applyFunctionStyle(
+            expr,
+            serializer.level
+          );
+          const args = operands(expr).slice(1);
+          return serializer.serializeFunction(
+            lhs,
+            serializer.dictionary.ids.get(h)
+          ) + serializer.wrapString(
+            args.map((x) => serializer.serialize(x)).join(", "),
+            style2
+          );
+        }
+        const rhs = operand(expr, 2);
+        if (typeof lhs === "string" || !rhs) {
+          const fn = operands(expr).slice(1);
+          return serializer.serialize(fn);
+        }
+        if (nops(expr) === 2) {
+          return joinLatex([
+            serializer.wrap(lhs, 20),
+            "\\lhd",
+            serializer.wrap(rhs, 20)
+          ]);
         }
+        const style = serializer.options.applyFunctionStyle(
+          expr,
+          serializer.level
+        );
         return joinLatex([
-          "\\operatorname{Loop}(",
-          serializer.serialize(body),
-          ", ",
-          serializer.serialize(indexing),
-          ")"
+          "\\operatorname{apply}",
+          serializer.wrapString(
+            serializer.serialize(h) + ", " + serializer.serialize(["List", ...operands(expr)]),
+            style
+          )
         ]);
       }
     },
-    // Serializer for Break
-    { name: "Break", serialize: () => "\\text{break}" },
-    // Serializer for Continue
-    { name: "Continue", serialize: () => "\\text{continue}" },
-    // Serializer for Return
     {
-      name: "Return",
-      serialize: (serializer, expr) => {
-        const arg = operand(expr, 1);
-        if (!arg || symbol(arg) === "Nothing") return "\\text{return}";
-        return joinLatex(["\\text{return }", serializer.serialize(arg)]);
-      }
+      latexTrigger: "\\lhd",
+      kind: "infix",
+      precedence: 20,
+      parse: "Apply"
     },
-    // Also match `\operatorname{if}` / `\mathrm{if}`
     {
-      symbolTrigger: "if",
-      kind: "prefix",
-      precedence: 245,
-      parse: (parser, until) => {
-        return parseIfExpression(parser, until);
+      latexTrigger: "\\rhd",
+      kind: "infix",
+      precedence: 20,
+      parse: (parser, lhs, _until) => {
+        const rhs = parser.parseExpression({ minPrec: 21 }) ?? "Nothing";
+        return ["Apply", rhs, lhs];
       }
     },
-    // \operatorname{for}
-    {
-      symbolTrigger: "for",
-      kind: "prefix",
-      precedence: 245,
-      parse: (parser, until) => parseForExpression(parser, until)
-    },
-    // \operatorname{break}
-    {
-      symbolTrigger: "break",
-      kind: "prefix",
-      precedence: 245,
-      parse: () => ["Break"]
-    },
-    // \operatorname{continue}
     {
-      symbolTrigger: "continue",
-      kind: "prefix",
-      precedence: 245,
-      parse: () => ["Continue"]
-    },
-    // \operatorname{return}
-    {
-      symbolTrigger: "return",
-      kind: "prefix",
-      precedence: 245,
-      parse: (parser, until) => [
-        "Return",
-        parser.parseExpression(until) ?? "Nothing"
-      ]
+      name: "EvaluateAt",
+      openTrigger: ".",
+      closeTrigger: "|",
+      kind: "matchfix",
+      serialize: (serializer, expr) => {
+        const fn = operand(expr, 1);
+        if (!fn) return "";
+        const args = operands(expr).slice(1);
+        if (operator(fn) === "Function") {
+          const parameters = operands(fn).slice(1);
+          let body = operand(fn, 1);
+          if (operator(body) === "Block" && nops(body) === 1)
+            body = operand(body, 1);
+          if (parameters.length > 0) {
+            return `\\left.\\left(${serializer.serialize(
+              body
+            )}\\right)\\right|_{${parameters.map(
+              (x, i) => `${serializer.serialize(x)}=${serializer.serialize(args[i])}`
+            ).join(", ")}}`;
+          }
+        }
+        return `\\left.\\left(${serializer.serialize(fn)}\\right)\\right|_{${args.map((x) => serializer.serialize(x)).join(", ")}}`;
+      }
     },
+    // The mathtools package includes several synonmyms for \colonequals. The
+    // preferred one as of summer 2022 is `\coloneq` (see § 3.7.3 https://ctan.math.illinois.edu/macros/latex/contrib/mathtools/mathtools.pdf)
     {
-      name: "String",
-      latexTrigger: ["\\text"],
-      parse: (parser, until) => {
-        const start = parser.index;
-        if (matchTextKeyword(parser, "if"))
-          return parseIfExpression(parser, until);
-        parser.index = start;
-        if (matchTextKeyword(parser, "for"))
-          return parseForExpression(parser, until);
-        parser.index = start;
-        if (matchTextKeyword(parser, "break"))
-          return ["Break"];
-        parser.index = start;
-        if (matchTextKeyword(parser, "continue"))
-          return ["Continue"];
-        parser.index = start;
-        if (matchTextKeyword(parser, "return"))
-          return [
-            "Return",
-            parser.parseExpression(until) ?? "Nothing"
-          ];
-        parser.index = start;
-        return parseTextRun(parser);
-      },
+      name: "Assign",
+      latexTrigger: "\\coloneq",
+      kind: "infix",
+      associativity: "right",
+      precedence: ASSIGNMENT_PRECEDENCE,
       serialize: (serializer, expr) => {
-        const args = operands(expr);
-        if (args.length === 0) return "\\text{}";
+        const id = unhold(operand(expr, 1));
+        if (operator(operand(expr, 2)) === "Function") {
+          const op_2 = operand(expr, 2);
+          const body = unhold(operand(op_2, 1));
+          const args = operands(op_2).slice(1);
+          return joinLatex([
+            serializer.serialize(id),
+            serializer.wrapString(
+              args.map((x) => serializer.serialize(x)).join(", "),
+              serializer.options.applyFunctionStyle(expr, serializer.level)
+            ),
+            "\\coloneq",
+            serializer.serialize(body)
+          ]);
+        }
         return joinLatex([
-          "\\text{",
-          args.map((x) => serializer.serialize(x)).join(""),
-          "}"
+          serializer.serialize(id),
+          "\\coloneq",
+          serializer.serialize(operand(expr, 2))
         ]);
-      }
+      },
+      parse: parseAssign
     },
     {
-      name: "Subscript",
-      latexTrigger: ["_"],
+      latexTrigger: "\\coloneqq",
       kind: "infix",
-      serialize: (serializer, expr) => {
-        if (nops(expr) === 2) {
-          return serializer.serialize(operand(expr, 1)) + "_{" + serializer.serialize(operand(expr, 2)) + "}";
-        }
-        return "_{" + serializer.serialize(operand(expr, 1)) + "}";
-      }
+      associativity: "right",
+      precedence: ASSIGNMENT_PRECEDENCE,
+      parse: parseAssign
     },
-    { name: "Superplus", latexTrigger: ["^", "+"], kind: "postfix" },
-    { name: "Subplus", latexTrigger: ["_", "+"], kind: "postfix" },
+    // From the colonequals package:
     {
-      name: "Superminus",
-      latexTrigger: ["^", "-"],
-      kind: "postfix",
-      parse: (parser, lhs) => {
-        if (parser.options.strict === false && /^[0-9]$/.test(parser.peek))
-          return null;
-        return ["Superminus", lhs];
-      }
+      latexTrigger: "\\colonequals",
+      kind: "infix",
+      associativity: "right",
+      precedence: ASSIGNMENT_PRECEDENCE,
+      parse: parseAssign
     },
-    { name: "Subminus", latexTrigger: ["_", "-"], kind: "postfix" },
     {
-      latexTrigger: ["^", "*"],
-      kind: "postfix",
-      parse: (_parser, lhs) => ["Superstar", lhs]
+      latexTrigger: [":", "="],
+      kind: "infix",
+      associativity: "right",
+      precedence: ASSIGNMENT_PRECEDENCE,
+      parse: parseAssign
     },
-    // { name: 'Superstar', latexTrigger: ['^', '\\star'], kind: 'postfix' },
+    // General colon operator (type annotation, mapping notation)
+    // Precedence below assignment (260) so `:=` takes priority,
+    // and below arrows (270) so `f: A \to B` parses as `Colon(f, To(A, B))`
     {
-      latexTrigger: ["_", "*"],
-      kind: "postfix",
-      parse: (_parser, lhs) => ["Substar", lhs]
+      name: "Colon",
+      latexTrigger: ":",
+      kind: "infix",
+      associativity: "right",
+      precedence: 250,
+      serialize: (serializer, expr) => joinLatex([
+        serializer.serialize(operand(expr, 1)),
+        "\\colon",
+        serializer.serialize(operand(expr, 2))
+      ])
     },
-    { name: "Substar", latexTrigger: ["_", "\\star"], kind: "postfix" },
-    { name: "Superdagger", latexTrigger: ["^", "\\dagger"], kind: "postfix" },
     {
-      latexTrigger: ["^", "\\dag"],
-      kind: "postfix",
-      parse: (_parser, lhs) => ["Superdagger", lhs]
+      latexTrigger: "\\colon",
+      kind: "infix",
+      associativity: "right",
+      precedence: 250,
+      parse: "Colon"
     },
     {
-      name: "Prime",
-      latexTrigger: ["^", "\\prime"],
-      // Note: we don't need a precedence because the trigger is '^'
-      // and '^' (and '_') are treated specially by the parser.
-      kind: "postfix",
-      parse: (parser, lhs) => parsePrime(parser, lhs, 1),
+      name: "BaseForm",
       serialize: (serializer, expr) => {
-        const n2 = machineValue(operand(expr, 2)) ?? 1;
-        const base = serializer.serialize(operand(expr, 1));
-        if (n2 === 1) return base + "^\\prime";
-        if (n2 === 2) return base + "^\\doubleprime";
-        if (n2 === 3) return base + "^\\tripleprime";
-        return base + "^{(" + serializer.serialize(operand(expr, 2)) + ")}";
+        const radix = machineValue(operand(expr, 2)) ?? NaN;
+        if (isFinite(radix) && radix >= 2 && radix <= 36) {
+          const num = machineValue(operand(expr, 1)) ?? NaN;
+          if (isFinite(num) && Number.isInteger(num)) {
+            let digits = Number(num).toString(radix);
+            let groupLength = 0;
+            if (radix === 2) {
+              groupLength = 4;
+            } else if (radix === 10) {
+              groupLength = 4;
+            } else if (radix === 16) {
+              groupLength = 2;
+            } else if (radix > 16) {
+              groupLength = 4;
+            }
+            if (groupLength > 0) {
+              const oldDigits = digits;
+              digits = "";
+              for (let i = 0; i < oldDigits.length; i++) {
+                if (i > 0 && i % groupLength === 0) digits = "\\, " + digits;
+                digits = oldDigits[oldDigits.length - i - 1] + digits;
+              }
+            }
+            return `(\\text{${digits}}_{${radix}}`;
+          }
+        }
+        return "\\operatorname{BaseForm}(" + serializer.serialize(operand(expr, 1)) + ", " + serializer.serialize(operand(expr, 2)) + ")";
       }
     },
     {
-      latexTrigger: "^{\\prime\\prime}",
-      kind: "postfix",
-      parse: (parser, lhs) => parsePrime(parser, lhs, 2)
+      name: "Sequence",
+      // Use a space as a separator, otherwise a sequence of numbers
+      // could be interpreted as a single number.
+      serialize: serializeOps(" ")
     },
     {
-      latexTrigger: "^{\\prime\\prime\\prime}",
-      kind: "postfix",
-      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+      name: "InvisibleOperator",
+      serialize: serializeOps("")
     },
     {
-      latexTrigger: ["^", "\\doubleprime"],
-      kind: "postfix",
-      parse: (parser, lhs) => parsePrime(parser, lhs, 2)
+      // The first argument is a function expression.
+      // The second (optional) argument is a string specifying the
+      // delimiters and separator.
+      name: "Delimiter",
+      serialize: (serializer, expr) => {
+        const style = serializer.options.groupStyle(expr, serializer.level + 1);
+        const arg1 = operand(expr, 1);
+        let delims = {
+          Set: "{,}",
+          List: "[,]",
+          Tuple: "(,)",
+          Single: "(,)",
+          Pair: "(,)",
+          Triple: "(,)",
+          Sequence: "(,)",
+          String: '""'
+        }[operator(arg1)];
+        const items = delims ? arg1 : ["Sequence", arg1];
+        delims ??= "(,)";
+        if (nops(expr) > 1) {
+          const op2 = stringValue(operand(expr, 2));
+          if (typeof op2 === "string" && op2.length <= 3) delims = op2;
+        }
+        let [open, sep, close] = ["", "", ""];
+        if (delims.length === 3) [open, sep, close] = delims;
+        else if (delims.length === 2) [open, close] = delims;
+        else if (delims.length === 1) sep = delims;
+        const body = arg1 ? items ? serializeOps(sep)(serializer, items) : serializer.serialize(arg1) : "";
+        return serializer.wrapString(body, style, open + close);
+      }
     },
     {
-      latexTrigger: ["^", "\\tripleprime"],
-      kind: "postfix",
-      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+      name: "Tuple",
+      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
     },
     {
-      latexTrigger: "'",
-      kind: "postfix",
-      precedence: 810,
-      parse: (parser, lhs) => parsePrime(parser, lhs, 1)
+      name: "Pair",
+      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
     },
     {
-      latexTrigger: "\\prime",
-      kind: "postfix",
-      precedence: 810,
-      parse: (parser, lhs) => parsePrime(parser, lhs, 1)
+      name: "Triple",
+      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
     },
     {
-      latexTrigger: "\\doubleprime",
-      kind: "postfix",
-      precedence: 810,
-      parse: (parser, lhs) => parsePrime(parser, lhs, 2)
+      name: "Single",
+      serialize: (serializer, expr) => joinLatex(["(", serializeOps(",")(serializer, expr), ")"])
     },
     {
-      latexTrigger: "\\tripleprime",
-      kind: "postfix",
-      precedence: 810,
-      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+      name: "Domain",
+      serialize: (serializer, expr) => {
+        if (operator(expr) === "Error") return serializer.serialize(expr);
+        return `\\mathbf{${serializer.serialize(operand(expr, 1))}}`;
+      }
     },
-    // Lagrange Notation for n-th order derivatives,
-    // i.e. f^{(n)} -> Derivative(f, n)
     {
-      latexTrigger: ["^", "<{>", "("],
-      kind: "postfix",
-      parse: (parser, lhs, until) => {
-        const sym2 = symbol(lhs);
-        if (!sym2 || !parser.getSymbolType(sym2).matches("function")) return null;
-        parser.addBoundary([")"]);
-        const expr = parser.parseExpression(until);
-        if (!parser.matchBoundary()) return null;
-        if (!parser.match("<}>")) return null;
-        return ["Derivative", lhs, expr];
+      latexTrigger: ["\\mathtip"],
+      parse: (parser) => {
+        const op1 = parser.parseGroup();
+        parser.parseGroup();
+        return op1;
       }
     },
     {
-      name: "InverseFunction",
-      latexTrigger: "^{-1",
-      // Note: the closing brace is not included
-      kind: "postfix",
-      parse: (parser, lhs) => {
-        if (operator(lhs) === "Matrix") {
-          parser.match("<}>");
-          return ["Inverse", lhs];
-        }
-        const sym2 = symbol(lhs);
-        if (!sym2) return null;
-        const symType = parser.getSymbolType(sym2);
-        if (symType.matches(new BoxedType("matrix"))) {
-          parser.match("<}>");
-          return ["Inverse", lhs];
-        }
-        if (!symType.matches("function")) return null;
-        let primeCount = 0;
-        while (!parser.atEnd && !parser.match("<}>")) {
-          if (parser.match("'")) primeCount++;
-          else if (parser.match("\\prime")) primeCount++;
-          else if (parser.match("\\doubleprime")) primeCount += 2;
-          else if (parser.match("\\tripleprime")) primeCount += 3;
-          else return null;
-        }
-        if (primeCount === 1)
-          return ["Derivative", ["InverseFunction", lhs]];
-        if (primeCount > 0)
-          return [
-            "Derivative",
-            ["InverseFunction", lhs],
-            primeCount
-          ];
-        return ["InverseFunction", lhs];
-      },
-      serialize: (serializer, expr) => serializer.serialize(operand(expr, 1)) + "^{-1}"
+      latexTrigger: ["\\texttip"],
+      parse: (parser) => {
+        const op1 = parser.parseGroup();
+        parser.parseGroup();
+        return op1;
+      }
     },
-    // Lagrange notation
     {
-      name: "Derivative",
-      // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
-      // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
-      // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
-      // Newton notation (\dot{v}, \ddot{v}) is implemented below
-      serialize: (serializer, expr) => {
-        const degree = machineValue(operand(expr, 2)) ?? 1;
-        const base = serializer.serialize(operand(expr, 1));
-        if (degree === 1) return base + "^{\\prime}";
-        if (degree === 2) return base + "^{\\doubleprime}";
-        if (degree === 3) return base + "^{\\tripleprime}";
-        return base + "^{(" + serializer.serialize(operand(expr, 2)) + ")}";
-      }
+      latexTrigger: ["\\error"],
+      parse: (parser) => ["Error", parser.parseGroup()]
     },
-    // Serializer for D (partial derivative) - outputs Leibniz notation
     {
-      name: "D",
+      name: "Error",
       serialize: (serializer, expr) => {
-        if (operator(expr) !== "D") return "D";
-        const fn = operand(expr, 1);
-        const variable = operand(expr, 2);
-        if (!fn || !variable) return "D";
-        let order2 = 1;
-        let innerFn = fn;
-        while (operator(innerFn) === "D") {
-          const innerVar = operand(innerFn, 2);
-          if (symbol(innerVar) === symbol(variable)) {
-            order2++;
-            innerFn = operand(innerFn, 1);
-          } else {
-            break;
+        const op1 = operand(expr, 1);
+        if (stringValue(op1) === "missing")
+          return `\\error{${serializer.options.missingSymbol ?? "\\placeholder{}"}}`;
+        const where = errorContextAsLatex(serializer, expr) || "\\blacksquare";
+        const code = operator(op1) === "ErrorCode" ? stringValue(operand(op1, 1)) : stringValue(op1);
+        if (code === "incompatible-type") {
+          if (symbol(operand(op1, 3)) === "Undefined") {
+            return `\\mathtip{\\error{${where}}}{\\notin ${serializer.serialize(
+              operand(op1, 2)
+            )}}`;
           }
+          return `\\mathtip{\\error{${where}}}{\\in ${serializer.serialize(
+            operand(op1, 3)
+          )}\\notin ${serializer.serialize(operand(op1, 2))}}`;
         }
-        let bodyToSerialize = innerFn;
-        if (operator(innerFn) === "Function") {
-          bodyToSerialize = operand(innerFn, 1) ?? innerFn;
-        }
-        const fnLatex = serializer.serialize(bodyToSerialize);
-        const varLatex = serializer.serialize(variable);
-        if (order2 === 1) {
-          return `\\frac{\\mathrm{d}}{\\mathrm{d}${varLatex}}${fnLatex}`;
-        }
-        return `\\frac{\\mathrm{d}^{${order2}}}{\\mathrm{d}${varLatex}^{${order2}}}${fnLatex}`;
+        if (typeof code === "string") return `\\error{${where}}`;
+        return `\\error{${where}}`;
       }
     },
-    // Newton notation for time derivatives: \dot{x}, \ddot{x}, etc.
     {
-      name: "NewtonDerivative1",
-      latexTrigger: ["\\dot"],
-      kind: "prefix",
-      precedence: 740,
-      parse: (parser) => {
-        const body = parser.parseGroup();
-        if (body === null) return null;
-        const t = parser.options.timeDerivativeVariable;
-        return ["D", body, t];
+      name: "ErrorCode",
+      serialize: (serializer, expr) => {
+        const code = stringValue(operand(expr, 1));
+        if (code === "missing")
+          return serializer.options.missingSymbol ?? "\\placeholder{}";
+        if (code === "unexpected-command" || code === "unexpected-operator" || code === "unexpected-token" || code === "invalid-symbol" || code === "unknown-environment" || code === "unexpected-base" || code === "incompatible-type") {
+          return "";
+        }
+        return `\\texttip{\\error{\\blacksquare}}{\\mathtt{${code}}}`;
       }
     },
     {
-      name: "NewtonDerivative2",
-      latexTrigger: ["\\ddot"],
-      kind: "prefix",
-      precedence: 740,
-      parse: (parser) => {
-        const body = parser.parseGroup();
-        if (body === null) return null;
-        const t = parser.options.timeDerivativeVariable;
-        return ["D", ["D", body, t], t];
+      name: "FromLatex",
+      serialize: (_serializer, expr) => {
+        return `\\texttt{${sanitizeLatex(stringValue(operand(expr, 1)))}}`;
       }
     },
     {
-      name: "NewtonDerivative3",
-      latexTrigger: ["\\dddot"],
-      kind: "prefix",
-      precedence: 740,
-      parse: (parser) => {
-        const body = parser.parseGroup();
-        if (body === null) return null;
-        const t = parser.options.timeDerivativeVariable;
-        return ["D", ["D", ["D", body, t], t], t];
+      name: "Latex",
+      serialize: (serializer, expr) => {
+        if (expr === null) return "";
+        return joinLatex(
+          mapArgs(expr, (x) => stringValue(x) ?? serializer.serialize(x))
+        );
       }
     },
     {
-      name: "NewtonDerivative4",
-      latexTrigger: ["\\ddddot"],
-      kind: "prefix",
-      precedence: 740,
-      parse: (parser) => {
-        const body = parser.parseGroup();
-        if (body === null) return null;
-        const t = parser.options.timeDerivativeVariable;
-        return ["D", ["D", ["D", ["D", body, t], t], t], t];
+      name: "LatexString",
+      serialize: (serializer, expr) => {
+        if (expr === null) return "";
+        return joinLatex(mapArgs(expr, (x) => serializer.serialize(x)));
       }
     },
-    // Euler notation for derivatives: D_x f, D^2_x f, D_x^2 f
-    // Uses latexTrigger to intercept before symbol parsing combines D with subscript
+    { name: "LatexTokens", serialize: serializeLatexTokens },
     {
-      name: "EulerDerivative",
-      latexTrigger: ["D"],
-      kind: "expression",
-      parse: (parser) => {
-        let degree = 1;
-        let variable = null;
-        let done = false;
-        while (!done) {
-          if (parser.match("_")) {
-            variable = parser.parseGroup() ?? parser.parseToken();
-            if (!variable) return null;
-          } else if (parser.match("^")) {
-            const degExpr = parser.parseGroup() ?? parser.parseToken();
-            degree = machineValue(degExpr) ?? 1;
-          } else {
-            done = true;
-          }
-        }
-        if (!variable) return null;
-        parser.skipSpace();
-        const fn = parser.parseExpression({ minPrec: 740 });
-        if (!fn) return null;
-        let result = fn;
-        for (let i = 0; i < degree; i++) {
-          result = ["D", result, variable];
+      name: "At",
+      kind: "postfix",
+      precedence: 810,
+      latexTrigger: ["["],
+      parse: parseAt("]"),
+      serialize: (serializer, expr) => joinLatex(["\\lbrack", serializeOps(", ")(serializer, expr), "\\rbrack"])
+    },
+    {
+      kind: "postfix",
+      precedence: 810,
+      latexTrigger: ["\\lbrack"],
+      parse: parseAt("\\rbrack")
+    },
+    {
+      kind: "postfix",
+      precedence: 810,
+      latexTrigger: ["\\left", "\\lbrack"],
+      parse: parseAt("\\right", "\\rbrack")
+    },
+    {
+      kind: "postfix",
+      latexTrigger: ["_"],
+      parse: (parser, lhs, _until) => {
+        let rhs = parser.parseGroup() ?? parser.parseToken();
+        if (rhs === null && parser.options.strict === false && parser.peek === "(")
+          rhs = parser.parseEnclosure();
+        const sym2 = symbol(lhs);
+        if (rhs !== null && (sym2 && parser.getSymbolType(sym2).matches("indexed_collection") || operator(lhs) === "List")) {
+          if (operator(rhs) === "Delimiter") rhs = operand(rhs, 1) ?? "Nothing";
+          if (operator(rhs) === "Sequence") return ["At", lhs, ...operands(rhs)];
+          return ["At", lhs, rhs];
         }
-        return result;
+        return ["Subscript", lhs, rhs];
       }
     },
     {
-      kind: "environment",
-      name: "Which",
-      symbolTrigger: "cases",
-      parse: parseCasesEnvironment,
-      serialize: (serialize, expr) => {
-        const rows = [];
+      name: "List",
+      kind: "matchfix",
+      openTrigger: "[",
+      closeTrigger: "]",
+      parse: parseBrackets,
+      serialize: serializeList
+    },
+    {
+      kind: "matchfix",
+      openTrigger: "(",
+      closeTrigger: ")",
+      parse: parseParenDelimiter
+    },
+    {
+      latexTrigger: [","],
+      kind: "infix",
+      precedence: 20,
+      // Unlike the matchfix version of List,
+      // 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, lhs, terminator) => {
+        const seq = parseSequence(parser, terminator, lhs, 20, ",");
+        if (seq === null) return null;
+        return ["Delimiter", ["Sequence", ...seq], { str: "," }];
+      }
+    },
+    // Entry to handle the case of a single comma
+    // with a missing lhs.
+    {
+      latexTrigger: [","],
+      kind: "prefix",
+      precedence: 20,
+      parse: (parser, terminator) => {
+        const seq = parseSequence(parser, terminator, null, 20, ",");
+        if (seq === null) return null;
+        return ["Delimiter", ["Sequence", ...seq], { str: "," }];
+      }
+    },
+    {
+      name: "Range",
+      latexTrigger: [".", "."],
+      kind: "infix",
+      // associativity: 'left',
+      precedence: 800,
+      parse: parseRange,
+      serialize: (serializer, expr) => {
         const args = operands(expr);
-        if (args.length > 0) {
-          for (let i = 0; i <= args.length - 2; i += 2) {
-            const row = [];
-            row.push(serialize.serialize(args[i + 1]));
-            row.push(serialize.serialize(args[i]));
-            rows.push(row.join("&"));
+        if (args.length === 0) return "";
+        if (args.length === 1)
+          return "1.." + serializer.serialize(operand(expr, 1));
+        if (args.length === 2)
+          return serializer.wrap(operand(expr, 1), 10) + ".." + serializer.wrap(operand(expr, 2), 10);
+        if (args.length === 3) {
+          const step = machineValue(operand(expr, 3));
+          const start = machineValue(operand(expr, 1));
+          if (step !== null && start !== null) {
+            return serializer.wrap(operand(expr, 1), 10) + ".." + serializer.wrap(start + step, 10) + ".." + serializer.wrap(operand(expr, 2), 10);
           }
+          return serializer.wrap(operand(expr, 1), 10) + "..(" + (serializer.wrap(operand(expr, 1), ADDITION_PRECEDENCE) + "+" + serializer.wrap(operand(expr, 3), ADDITION_PRECEDENCE)) + ").." + serializer.wrap(operand(expr, 2), 10);
         }
-        return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
+        return "";
       }
     },
     {
-      kind: "environment",
-      symbolTrigger: "dcases",
-      parse: parseCasesEnvironment
+      latexTrigger: [";"],
+      kind: "infix",
+      precedence: 19,
+      parse: (parser, lhs, terminator) => {
+        const seq = parseSequence(parser, terminator, lhs, 19, ";");
+        if (seq === null) return null;
+        if (seq.some((e) => operator(e) === "Assign"))
+          return buildBlockFromSequence(seq);
+        return ["Delimiter", ["Sequence", ...seq], "';'"];
+      }
     },
+    // \text{where} — variable binding infix
     {
-      kind: "environment",
-      symbolTrigger: "rcases",
-      parse: parseCasesEnvironment
-    }
-  ];
-  function parseTextRun(parser, style) {
-    if (!parser.match("<{>")) return "''";
-    const runs = [];
-    let text = "";
-    let runinStyle = null;
-    const flush = () => {
-      if (runinStyle !== null && text) {
-        runs.push(["Annotated", `'${text}'`, dictionaryFromEntries(runinStyle)]);
-      } else if (text) {
-        runs.push(`'${text}'`);
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "none",
+      precedence: 21,
+      // Above ; (19) and , (20), very low binding
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "where")) {
+          parser.index = start;
+          return null;
+        }
+        return parseWhereExpression(parser, lhs, until);
       }
-      text = "";
-      runinStyle = null;
-    };
-    while (!parser.atEnd && !parser.match("<}>")) {
-      if (parser.peek === "<{>") {
-        flush();
-        runs.push(parseTextRun(parser));
-      } else if (parser.match("\\textbf")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontWeight: "bold" }));
-      } else if (parser.match("\\textmd")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontStyle: "normal" }));
-      } else if (parser.match("\\textup")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontStyle: "normal" }));
-      } else if (parser.match("\\textsl")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontStyle: "italic" }));
-      } else if (parser.match("\\textit")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontStyle: "italic" }));
-      } else if (parser.match("\\texttt")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontFamily: "monospace" }));
-      } else if (parser.match("\\textsf")) {
-        flush();
-        runs.push(parseTextRun(parser, { fontFamily: "sans-serif" }));
-      } else if (parser.match("\\textcolor")) {
-        const pos = parser.index;
-        const color = parser.parseStringGroup();
-        const body2 = parser.parseExpression();
-        if (color !== null && body2 !== null) {
-          runs.push(["Annotated", body2, { dict: { color } }]);
-        } else {
-          parser.index = pos;
-          text += "\\textcolor";
+    },
+    // \operatorname{where}
+    {
+      symbolTrigger: "where",
+      kind: "infix",
+      associativity: "none",
+      precedence: 21,
+      parse: (parser, lhs, until) => parseWhereExpression(parser, lhs, until)
+    },
+    // \text{and} — logical conjunction infix
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 235,
+      // Same as \land
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "and")) {
+          parser.index = start;
+          return null;
         }
-      } else if (parser.match("\\color")) {
-        const color = parser.parseStringGroup();
-        if (color !== null) {
-          flush();
+        const rhs = parser.parseExpression({ ...until, minPrec: 235 });
+        return ["And", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{or} — logical disjunction infix
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 230,
+      // Same as \lor
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "or")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 230 });
+        return ["Or", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{iff} — biconditional (if and only if)
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      // Same as \iff
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "iff")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        return ["Equivalent", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{if and only if} — verbose biconditional
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "if and only if")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        return ["Equivalent", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{such that} — constraint separator (like : in set-builder notation)
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 21,
+      // Low precedence to capture full condition (same as 'where')
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "such that")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 21 });
+        return ["Colon", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{for all} — universal quantifier
+    {
+      latexTrigger: ["\\text"],
+      kind: "prefix",
+      precedence: 200,
+      // Same as \forall
+      parse: (parser, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "for all")) {
+          parser.index = start;
+          return null;
+        }
+        return parseQuantifier("ForAll")(parser, until);
+      }
+    },
+    // \text{there exists} — existential quantifier
+    {
+      latexTrigger: ["\\text"],
+      kind: "prefix",
+      precedence: 200,
+      // Same as \exists
+      parse: (parser, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "there exists")) {
+          parser.index = start;
+          return null;
+        }
+        return parseQuantifier("Exists")(parser, until);
+      }
+    },
+    // Block serializer — used by both `where` and semicolon blocks
+    {
+      name: "Block",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (!args || args.length === 0) return "";
+        const parts = args.filter((a) => operator(a) !== "Declare").map((a) => serializer.serialize(a));
+        return parts.join("; ");
+      }
+    },
+    // Serializer for If expressions (separate from the parser entry
+    // because name-based entries affect kind-based indexing)
+    {
+      name: "If",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (!args || args.length < 3) return "";
+        return joinLatex([
+          "\\text{if }",
+          serializer.serialize(args[0]),
+          "\\text{ then }",
+          serializer.serialize(args[1]),
+          "\\text{ else }",
+          serializer.serialize(args[2])
+        ]);
+      }
+    },
+    // Serializer for Loop expressions
+    {
+      name: "Loop",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (!args || args.length < 2) return "";
+        const body = args[0];
+        const indexing = args[1];
+        if (operator(indexing) === "Element") {
+          const index = operand(indexing, 1);
+          const range2 = operand(indexing, 2);
+          if (operator(range2) === "Range") {
+            const lo = operand(range2, 1);
+            const hi = operand(range2, 2);
+            return joinLatex([
+              "\\text{for }",
+              serializer.serialize(index),
+              "\\text{ from }",
+              serializer.serialize(lo),
+              "\\text{ to }",
+              serializer.serialize(hi),
+              "\\text{ do }",
+              serializer.serialize(body)
+            ]);
+          }
+        }
+        return joinLatex([
+          "\\operatorname{Loop}(",
+          serializer.serialize(body),
+          ", ",
+          serializer.serialize(indexing),
+          ")"
+        ]);
+      }
+    },
+    // Serializer for Break
+    { name: "Break", serialize: () => "\\text{break}" },
+    // Serializer for Continue
+    { name: "Continue", serialize: () => "\\text{continue}" },
+    // Serializer for Return
+    {
+      name: "Return",
+      serialize: (serializer, expr) => {
+        const arg = operand(expr, 1);
+        if (!arg || symbol(arg) === "Nothing") return "\\text{return}";
+        return joinLatex(["\\text{return }", serializer.serialize(arg)]);
+      }
+    },
+    // Also match `\operatorname{if}` / `\mathrm{if}`
+    {
+      symbolTrigger: "if",
+      kind: "prefix",
+      precedence: 245,
+      parse: (parser, until) => {
+        return parseIfExpression(parser, until);
+      }
+    },
+    // \operatorname{for}
+    {
+      symbolTrigger: "for",
+      kind: "prefix",
+      precedence: 245,
+      parse: (parser, until) => parseForExpression(parser, until)
+    },
+    // \operatorname{break}
+    {
+      symbolTrigger: "break",
+      kind: "prefix",
+      precedence: 245,
+      parse: () => ["Break"]
+    },
+    // \operatorname{continue}
+    {
+      symbolTrigger: "continue",
+      kind: "prefix",
+      precedence: 245,
+      parse: () => ["Continue"]
+    },
+    // \operatorname{return}
+    {
+      symbolTrigger: "return",
+      kind: "prefix",
+      precedence: 245,
+      parse: (parser, until) => [
+        "Return",
+        parser.parseExpression(until) ?? "Nothing"
+      ]
+    },
+    // Text serializer — reconstructs \text{...} with inline $...$ for math
+    {
+      name: "Text",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (args.length === 0) return "";
+        let firstStr = -1;
+        let lastStr = -1;
+        for (let i = 0; i < args.length; i++) {
+          if (stringValue(args[i]) !== null) {
+            if (firstStr < 0) firstStr = i;
+            lastStr = i;
+          }
+        }
+        if (firstStr < 0)
+          return joinLatex(args.map((a) => serializer.serialize(a)));
+        const parts = [];
+        for (let i = 0; i < firstStr; i++)
+          parts.push(serializer.serialize(args[i]));
+        let textContent = "";
+        for (let i = firstStr; i <= lastStr; i++) {
+          const s = stringValue(args[i]);
+          if (s !== null) textContent += sanitizeLatex(s);
+          else if (operator(args[i]) === "Annotated" || operator(args[i]) === "Text")
+            textContent += serializer.serialize(args[i]);
+          else textContent += "$" + serializer.serialize(args[i]) + "$";
+        }
+        parts.push("\\text{" + textContent + "}");
+        for (let i = lastStr + 1; i < args.length; i++)
+          parts.push(serializer.serialize(args[i]));
+        return joinLatex(parts);
+      }
+    },
+    {
+      name: "String",
+      latexTrigger: ["\\text"],
+      parse: (parser, until) => {
+        const start = parser.index;
+        if (matchTextKeyword(parser, "if"))
+          return parseIfExpression(parser, until);
+        parser.index = start;
+        if (matchTextKeyword(parser, "for"))
+          return parseForExpression(parser, until);
+        parser.index = start;
+        if (matchTextKeyword(parser, "break"))
+          return ["Break"];
+        parser.index = start;
+        if (matchTextKeyword(parser, "continue"))
+          return ["Continue"];
+        parser.index = start;
+        if (matchTextKeyword(parser, "return"))
+          return [
+            "Return",
+            parser.parseExpression(until) ?? "Nothing"
+          ];
+        parser.index = start;
+        return parseTextRun(parser);
+      },
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (args.length === 0) return "\\text{}";
+        return joinLatex([
+          "\\text{",
+          args.map((x) => serializer.serialize(x)).join(""),
+          "}"
+        ]);
+      }
+    },
+    {
+      name: "Subscript",
+      latexTrigger: ["_"],
+      kind: "infix",
+      serialize: (serializer, expr) => {
+        if (nops(expr) === 2) {
+          return serializer.serialize(operand(expr, 1)) + "_{" + serializer.serialize(operand(expr, 2)) + "}";
+        }
+        return "_{" + serializer.serialize(operand(expr, 1)) + "}";
+      }
+    },
+    { name: "Superplus", latexTrigger: ["^", "+"], kind: "postfix" },
+    { name: "Subplus", latexTrigger: ["_", "+"], kind: "postfix" },
+    {
+      name: "Superminus",
+      latexTrigger: ["^", "-"],
+      kind: "postfix",
+      parse: (parser, lhs) => {
+        if (parser.options.strict === false && /^[0-9]$/.test(parser.peek))
+          return null;
+        return ["Superminus", lhs];
+      }
+    },
+    { name: "Subminus", latexTrigger: ["_", "-"], kind: "postfix" },
+    {
+      latexTrigger: ["^", "*"],
+      kind: "postfix",
+      parse: (_parser, lhs) => ["Superstar", lhs]
+    },
+    // { name: 'Superstar', latexTrigger: ['^', '\\star'], kind: 'postfix' },
+    {
+      latexTrigger: ["_", "*"],
+      kind: "postfix",
+      parse: (_parser, lhs) => ["Substar", lhs]
+    },
+    { name: "Substar", latexTrigger: ["_", "\\star"], kind: "postfix" },
+    { name: "Superdagger", latexTrigger: ["^", "\\dagger"], kind: "postfix" },
+    {
+      latexTrigger: ["^", "\\dag"],
+      kind: "postfix",
+      parse: (_parser, lhs) => ["Superdagger", lhs]
+    },
+    {
+      name: "Prime",
+      latexTrigger: ["^", "\\prime"],
+      // Note: we don't need a precedence because the trigger is '^'
+      // and '^' (and '_') are treated specially by the parser.
+      kind: "postfix",
+      parse: (parser, lhs) => parsePrime(parser, lhs, 1),
+      serialize: (serializer, expr) => {
+        const n2 = machineValue(operand(expr, 2)) ?? 1;
+        const base = serializer.serialize(operand(expr, 1));
+        if (n2 === 1) return base + "^\\prime";
+        if (n2 === 2) return base + "^\\doubleprime";
+        if (n2 === 3) return base + "^\\tripleprime";
+        return base + "^{(" + serializer.serialize(operand(expr, 2)) + ")}";
+      }
+    },
+    {
+      latexTrigger: "^{\\prime\\prime}",
+      kind: "postfix",
+      parse: (parser, lhs) => parsePrime(parser, lhs, 2)
+    },
+    {
+      latexTrigger: "^{\\prime\\prime\\prime}",
+      kind: "postfix",
+      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+    },
+    {
+      latexTrigger: ["^", "\\doubleprime"],
+      kind: "postfix",
+      parse: (parser, lhs) => parsePrime(parser, lhs, 2)
+    },
+    {
+      latexTrigger: ["^", "\\tripleprime"],
+      kind: "postfix",
+      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+    },
+    {
+      latexTrigger: "'",
+      kind: "postfix",
+      precedence: 810,
+      parse: (parser, lhs) => parsePrime(parser, lhs, 1)
+    },
+    {
+      latexTrigger: "\\prime",
+      kind: "postfix",
+      precedence: 810,
+      parse: (parser, lhs) => parsePrime(parser, lhs, 1)
+    },
+    {
+      latexTrigger: "\\doubleprime",
+      kind: "postfix",
+      precedence: 810,
+      parse: (parser, lhs) => parsePrime(parser, lhs, 2)
+    },
+    {
+      latexTrigger: "\\tripleprime",
+      kind: "postfix",
+      precedence: 810,
+      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+    },
+    // Lagrange Notation for n-th order derivatives,
+    // i.e. f^{(n)} -> Derivative(f, n)
+    {
+      latexTrigger: ["^", "<{>", "("],
+      kind: "postfix",
+      parse: (parser, lhs, until) => {
+        const sym2 = symbol(lhs);
+        if (!sym2 || !parser.getSymbolType(sym2).matches("function")) return null;
+        parser.addBoundary([")"]);
+        const expr = parser.parseExpression(until);
+        if (!parser.matchBoundary()) return null;
+        if (!parser.match("<}>")) return null;
+        return ["Derivative", lhs, expr];
+      }
+    },
+    {
+      name: "InverseFunction",
+      latexTrigger: "^{-1",
+      // Note: the closing brace is not included
+      kind: "postfix",
+      parse: (parser, lhs) => {
+        if (operator(lhs) === "Matrix") {
+          parser.match("<}>");
+          return ["Inverse", lhs];
+        }
+        const sym2 = symbol(lhs);
+        if (!sym2) return null;
+        const symType = parser.getSymbolType(sym2);
+        if (symType.matches(new BoxedType("matrix"))) {
+          parser.match("<}>");
+          return ["Inverse", lhs];
+        }
+        if (!symType.matches("function")) return null;
+        let primeCount = 0;
+        while (!parser.atEnd && !parser.match("<}>")) {
+          if (parser.match("'")) primeCount++;
+          else if (parser.match("\\prime")) primeCount++;
+          else if (parser.match("\\doubleprime")) primeCount += 2;
+          else if (parser.match("\\tripleprime")) primeCount += 3;
+          else return null;
+        }
+        if (primeCount === 1)
+          return ["Derivative", ["InverseFunction", lhs]];
+        if (primeCount > 0)
+          return [
+            "Derivative",
+            ["InverseFunction", lhs],
+            primeCount
+          ];
+        return ["InverseFunction", lhs];
+      },
+      serialize: (serializer, expr) => serializer.serialize(operand(expr, 1)) + "^{-1}"
+    },
+    // Lagrange notation
+    {
+      name: "Derivative",
+      // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
+      // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
+      // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
+      // Newton notation (\dot{v}, \ddot{v}) is implemented below
+      serialize: (serializer, expr) => {
+        const degree = machineValue(operand(expr, 2)) ?? 1;
+        const base = serializer.serialize(operand(expr, 1));
+        if (degree === 1) return base + "^{\\prime}";
+        if (degree === 2) return base + "^{\\doubleprime}";
+        if (degree === 3) return base + "^{\\tripleprime}";
+        return base + "^{(" + serializer.serialize(operand(expr, 2)) + ")}";
+      }
+    },
+    // Serializer for D (partial derivative) - outputs Leibniz notation
+    {
+      name: "D",
+      serialize: (serializer, expr) => {
+        if (operator(expr) !== "D") return "D";
+        const fn = operand(expr, 1);
+        const variable = operand(expr, 2);
+        if (!fn || !variable) return "D";
+        let order2 = 1;
+        let innerFn = fn;
+        while (operator(innerFn) === "D") {
+          const innerVar = operand(innerFn, 2);
+          if (symbol(innerVar) === symbol(variable)) {
+            order2++;
+            innerFn = operand(innerFn, 1);
+          } else {
+            break;
+          }
+        }
+        let bodyToSerialize = innerFn;
+        if (operator(innerFn) === "Function") {
+          bodyToSerialize = operand(innerFn, 1) ?? innerFn;
+        }
+        const fnLatex = serializer.serialize(bodyToSerialize);
+        const varLatex = serializer.serialize(variable);
+        if (order2 === 1) {
+          return `\\frac{\\mathrm{d}}{\\mathrm{d}${varLatex}}${fnLatex}`;
+        }
+        return `\\frac{\\mathrm{d}^{${order2}}}{\\mathrm{d}${varLatex}^{${order2}}}${fnLatex}`;
+      }
+    },
+    // Newton notation for time derivatives: \dot{x}, \ddot{x}, etc.
+    {
+      name: "NewtonDerivative1",
+      latexTrigger: ["\\dot"],
+      kind: "prefix",
+      precedence: 740,
+      parse: (parser) => {
+        const body = parser.parseGroup();
+        if (body === null) return null;
+        const t = parser.options.timeDerivativeVariable;
+        return ["D", body, t];
+      }
+    },
+    {
+      name: "NewtonDerivative2",
+      latexTrigger: ["\\ddot"],
+      kind: "prefix",
+      precedence: 740,
+      parse: (parser) => {
+        const body = parser.parseGroup();
+        if (body === null) return null;
+        const t = parser.options.timeDerivativeVariable;
+        return ["D", ["D", body, t], t];
+      }
+    },
+    {
+      name: "NewtonDerivative3",
+      latexTrigger: ["\\dddot"],
+      kind: "prefix",
+      precedence: 740,
+      parse: (parser) => {
+        const body = parser.parseGroup();
+        if (body === null) return null;
+        const t = parser.options.timeDerivativeVariable;
+        return ["D", ["D", ["D", body, t], t], t];
+      }
+    },
+    {
+      name: "NewtonDerivative4",
+      latexTrigger: ["\\ddddot"],
+      kind: "prefix",
+      precedence: 740,
+      parse: (parser) => {
+        const body = parser.parseGroup();
+        if (body === null) return null;
+        const t = parser.options.timeDerivativeVariable;
+        return ["D", ["D", ["D", ["D", body, t], t], t], t];
+      }
+    },
+    // Euler notation for derivatives: D_x f, D^2_x f, D_x^2 f
+    // Uses latexTrigger to intercept before symbol parsing combines D with subscript
+    {
+      name: "EulerDerivative",
+      latexTrigger: ["D"],
+      kind: "expression",
+      parse: (parser) => {
+        let degree = 1;
+        let variable = null;
+        let done = false;
+        while (!done) {
+          if (parser.match("_")) {
+            variable = parser.parseGroup() ?? parser.parseToken();
+            if (!variable) return null;
+          } else if (parser.match("^")) {
+            const degExpr = parser.parseGroup() ?? parser.parseToken();
+            degree = machineValue(degExpr) ?? 1;
+          } else {
+            done = true;
+          }
+        }
+        if (!variable) return null;
+        parser.skipSpace();
+        const fn = parser.parseExpression({ minPrec: 740 });
+        if (!fn) return null;
+        let result = fn;
+        for (let i = 0; i < degree; i++) {
+          result = ["D", result, variable];
+        }
+        return result;
+      }
+    },
+    {
+      kind: "environment",
+      name: "Which",
+      symbolTrigger: "cases",
+      parse: parseCasesEnvironment,
+      serialize: (serialize, expr) => {
+        const rows = [];
+        const args = operands(expr);
+        if (args.length > 0) {
+          for (let i = 0; i <= args.length - 2; i += 2) {
+            const row = [];
+            row.push(serialize.serialize(args[i + 1]));
+            row.push(serialize.serialize(args[i]));
+            rows.push(row.join("&"));
+          }
+        }
+        return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
+      }
+    },
+    {
+      kind: "environment",
+      symbolTrigger: "dcases",
+      parse: parseCasesEnvironment
+    },
+    {
+      kind: "environment",
+      symbolTrigger: "rcases",
+      parse: parseCasesEnvironment
+    }
+  ];
+  function parseTextRun(parser, style) {
+    if (!parser.match("<{>")) return "''";
+    const runs = [];
+    let text = "";
+    let runinStyle = null;
+    const flush = () => {
+      if (runinStyle !== null && text) {
+        runs.push(["Annotated", `'${text}'`, dictionaryFromEntries(runinStyle)]);
+      } else if (text) {
+        runs.push(`'${text}'`);
+      }
+      text = "";
+      runinStyle = null;
+    };
+    while (!parser.atEnd && !parser.match("<}>")) {
+      if (parser.peek === "<{>") {
+        flush();
+        runs.push(parseTextRun(parser));
+      } else if (parser.match("\\textbf")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontWeight: "bold" }));
+      } else if (parser.match("\\textmd")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontStyle: "normal" }));
+      } else if (parser.match("\\textup")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontStyle: "normal" }));
+      } else if (parser.match("\\textsl")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontStyle: "italic" }));
+      } else if (parser.match("\\textit")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontStyle: "italic" }));
+      } else if (parser.match("\\texttt")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontFamily: "monospace" }));
+      } else if (parser.match("\\textsf")) {
+        flush();
+        runs.push(parseTextRun(parser, { fontFamily: "sans-serif" }));
+      } else if (parser.match("\\textcolor")) {
+        const pos = parser.index;
+        const color = parser.parseStringGroup();
+        if (color !== null) {
+          flush();
+          const body2 = parseTextRun(parser);
+          runs.push(["Annotated", body2, dictionaryFromEntries({ color })]);
+        } else {
+          parser.index = pos;
+          text += "\\textcolor";
+        }
+      } else if (parser.match("\\color")) {
+        const color = parser.parseStringGroup();
+        if (color !== null) {
+          flush();
           runinStyle = { color };
         }
       } else if (parser.match("<space>")) {
@@ -5903,6 +6497,7 @@ var Compile = (() => {
         const expr = parser.parseExpression() ?? "Nothing";
         parser.skipSpace();
         if (parser.match("<$>")) {
+          flush();
           runs.push(expr);
         } else {
           text += "$";
@@ -5913,6 +6508,7 @@ var Compile = (() => {
         const expr = parser.parseExpression() ?? "Nothing";
         parser.skipSpace();
         if (parser.match("<$$>")) {
+          flush();
           runs.push(expr);
         } else {
           text += "$$";
@@ -6263,14 +6859,20 @@ var Compile = (() => {
     }
     while (parser.match("<space>")) {
     }
-    let text = "";
-    while (!parser.atEnd && parser.peek !== "<}>" && parser.peek !== "<space>") {
-      const tok = parser.peek;
-      if (/^[a-zA-Z]$/.test(tok)) {
-        text += tok;
-        parser.nextToken();
+    for (let i = 0; i < keyword.length; i++) {
+      if (keyword[i] === " ") {
+        if (!parser.match("<space>")) {
+          parser.index = start;
+          return false;
+        }
+        while (parser.match("<space>")) {
+        }
       } else {
-        break;
+        if (parser.peek !== keyword[i]) {
+          parser.index = start;
+          return false;
+        }
+        parser.nextToken();
       }
     }
     while (parser.match("<space>")) {
@@ -6279,10 +6881,6 @@ var Compile = (() => {
       parser.index = start;
       return false;
     }
-    if (text !== keyword) {
-      parser.index = start;
-      return false;
-    }
     return true;
   }
   function matchKeyword(parser, keyword) {
@@ -6524,487 +7122,41 @@ var Compile = (() => {
       return {
         kind: "symbol",
         name: symbol2,
-        latexTrigger: [latex],
-        parse: symbol2
-      };
-    }),
-    ...SYMBOLS.map(([symbol2, _latex, codepoint]) => {
-      return {
-        kind: "symbol",
-        latexTrigger: [String.fromCodePoint(codepoint)],
-        parse: symbol2
-      };
-    })
-  ];
-
-  // src/compute-engine/latex-syntax/dictionary/definitions-algebra.ts
-  var DEFINITIONS_ALGEBRA = [
-    {
-      name: "To",
-      latexTrigger: ["\\to"],
-      kind: "infix",
-      precedence: 270
-      // MathML rightwards arrow
-    },
-    {
-      // Non-strict mode: -> for maps-to arrow
-      latexTrigger: ["-", ">"],
-      kind: "infix",
-      precedence: 270,
-      parse: (parser, lhs, until) => {
-        if (parser.options.strict !== false) return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 270 });
-        if (rhs === null) return null;
-        return ["To", lhs, rhs];
-      }
-    }
-  ];
-
-  // src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
-  var DEFINITIONS_LOGIC = [
-    // Constants
-    {
-      name: "True",
-      kind: "symbol",
-      latexTrigger: ["\\top"]
-      // ⊤ U+22A4
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\mathrm{True}",
-      parse: "True"
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\operatorname{True}",
-      parse: "True"
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\mathsf{T}",
-      parse: "True"
-    },
-    {
-      name: "False",
-      kind: "symbol",
-      latexTrigger: ["\\bot"]
-      // ⊥ U+22A5
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\operatorname{False}",
-      parse: "False"
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\mathsf{F}",
-      parse: "False"
-    },
-    // Operators
-    // Logic operators have lower precedence than comparisons (245)
-    // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
-    // See https://github.com/cortex-js/compute-engine/issues/243
-    {
-      name: "And",
-      kind: "infix",
-      latexTrigger: ["\\land"],
-      precedence: 235
-      // serialize: '\\land',
-    },
-    { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
-    { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
-    {
-      kind: "infix",
-      latexTrigger: "\\operatorname{and}",
-      parse: "And",
-      precedence: 235
-    },
-    {
-      name: "Or",
-      kind: "infix",
-      latexTrigger: ["\\lor"],
-      precedence: 230
-    },
-    { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
-    { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
-    {
-      kind: "infix",
-      latexTrigger: "\\operatorname{or}",
-      parse: "Or",
-      precedence: 230
-    },
-    {
-      name: "Xor",
-      kind: "infix",
-      latexTrigger: ["\\veebar"],
-      precedence: 232
-    },
-    // Possible alt: \oplus ⊕ U+2295
-    {
-      name: "Not",
-      kind: "prefix",
-      latexTrigger: ["\\lnot"],
-      precedence: 880
-    },
-    {
-      kind: "prefix",
-      latexTrigger: ["\\neg"],
-      parse: "Not",
-      precedence: 880
-    },
-    {
-      name: "Nand",
-      kind: "infix",
-      latexTrigger: ["\\barwedge"],
-      precedence: 232
-      // serialize: '\\mid',
-    },
-    {
-      name: "Nor",
-      kind: "infix",
-      latexTrigger: ["\u22BD"],
-      // bar vee
-      precedence: 232
-      // serialize: '\\downarrow',
-    },
-    // Functions
-    {
-      kind: "function",
-      symbolTrigger: "and",
-      parse: "And"
-    },
-    {
-      kind: "function",
-      symbolTrigger: "or",
-      parse: "Or"
-    },
-    {
-      kind: "function",
-      symbolTrigger: "not",
-      parse: "Not"
-    },
-    // Relations
-    {
-      name: "Implies",
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      latexTrigger: ["\\implies"],
-      serialize: "\\implies"
-    },
-    {
-      latexTrigger: ["\\Rightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      latexTrigger: ["\\rightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      latexTrigger: ["\\Longrightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      latexTrigger: ["\\longrightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      // Non-strict mode: => for implies
-      latexTrigger: ["=", ">"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: (parser, lhs, until) => {
-        if (parser.options.strict !== false) return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 220 });
-        if (rhs === null) return null;
-        return ["Implies", lhs, rhs];
-      }
-    },
-    {
-      name: "Equivalent",
-      // MathML: identical to, Mathematica: Congruent
-      latexTrigger: ["\\iff"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219
-    },
-    {
-      latexTrigger: ["\\Leftrightarrow"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
-    },
-    {
-      latexTrigger: ["\\leftrightarrow"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
-    },
-    {
-      latexTrigger: ["\\Longleftrightarrow"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
-    },
+        latexTrigger: [latex],
+        parse: symbol2
+      };
+    }),
+    ...SYMBOLS.map(([symbol2, _latex, codepoint]) => {
+      return {
+        kind: "symbol",
+        latexTrigger: [String.fromCodePoint(codepoint)],
+        parse: symbol2
+      };
+    })
+  ];
+
+  // src/compute-engine/latex-syntax/dictionary/definitions-algebra.ts
+  var DEFINITIONS_ALGEBRA = [
     {
-      latexTrigger: ["\\longleftrightarrow"],
+      name: "To",
+      latexTrigger: ["\\to"],
       kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
+      precedence: 270
+      // MathML rightwards arrow
     },
     {
-      // Non-strict mode: <=> for equivalence
-      latexTrigger: ["<", "=", ">"],
+      // Non-strict mode: -> for maps-to arrow
+      latexTrigger: ["-", ">"],
       kind: "infix",
-      precedence: 219,
-      associativity: "right",
+      precedence: 270,
       parse: (parser, lhs, until) => {
         if (parser.options.strict !== false) return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        const rhs = parser.parseExpression({ ...until, minPrec: 270 });
         if (rhs === null) return null;
-        return ["Equivalent", lhs, rhs];
-      }
-    },
-    {
-      latexTrigger: ["\\equiv"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: (parser, lhs, terminator) => {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
-        const index = parser.index;
-        const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
-        if (modulus !== null && operator(modulus) === "Mod")
-          return ["Congruent", lhs, rhs, missingIfEmpty(operand(modulus, 1))];
-        parser.index = index;
-        return ["Equivalent", lhs, missingIfEmpty(rhs)];
-      }
-    },
-    {
-      name: "Proves",
-      kind: "infix",
-      latexTrigger: ["\\vdash"],
-      precedence: 220,
-      associativity: "right",
-      serialize: "\\vdash"
-    },
-    {
-      name: "Entails",
-      kind: "infix",
-      latexTrigger: ["\\vDash"],
-      precedence: 220,
-      associativity: "right",
-      serialize: "\\vDash"
-    },
-    {
-      name: "Satisfies",
-      kind: "infix",
-      latexTrigger: ["\\models"],
-      precedence: 220,
-      associativity: "right",
-      serialize: "\\models"
-    },
-    // Quantifiers: for all, exists
-    {
-      name: "ForAll",
-      kind: "prefix",
-      latexTrigger: ["\\forall"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE
-      serialize: serializeQuantifier("\\forall"),
-      parse: parseQuantifier("ForAll")
-    },
-    {
-      name: "Exists",
-      kind: "prefix",
-      latexTrigger: ["\\exists"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: serializeQuantifier("\\exists"),
-      parse: parseQuantifier("Exists")
-    },
-    {
-      name: "ExistsUnique",
-      kind: "prefix",
-      latexTrigger: ["\\exists", "!"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: serializeQuantifier("\\exists!"),
-      parse: parseQuantifier("ExistsUnique")
-    },
-    {
-      name: "NotForAll",
-      kind: "prefix",
-      latexTrigger: ["\\lnot", "\\forall"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE
-      serialize: serializeQuantifier("\\lnot\\forall"),
-      parse: parseQuantifier("NotForAll")
-    },
-    {
-      name: "NotExists",
-      kind: "prefix",
-      latexTrigger: ["\\lnot", "\\exists"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: serializeQuantifier("\\lnot\\exists"),
-      parse: parseQuantifier("NotExists")
-    },
-    {
-      name: "KroneckerDelta",
-      kind: "prefix",
-      latexTrigger: ["\\delta", "_"],
-      precedence: 200,
-      serialize: (serializer, expr) => {
-        const args = operands(expr);
-        if (args.length === 0) return "\\delta";
-        if (args.every((x) => symbol(x)))
-          return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join("")}}`;
-        return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join(", ")}}`;
-      },
-      parse: (parser) => {
-        const group = parser.parseGroup();
-        if (group === null) {
-          const token = parser.parseToken();
-          if (!token) return null;
-          return ["KroneckerDelta", token];
-        }
-        const seq = getSequence(group);
-        if (seq && seq.length <= 2) return ["KroneckerDelta", ...seq];
-        if (operator(group) === "InvisibleOperator")
-          return ["KroneckerDelta", ...operands(group)];
-        if (group !== null) return ["KroneckerDelta", group];
-        return null;
-      }
-    },
-    // Iverson brackets. Also called the "indicator function"
-    // Must have a single argument, a relational expression, i.e.
-    // `[ a = b ]` or `[ x \leq 0 ]`
-    // Otherwise, it gets rejected, it could be something else, like a list or
-    // tuple.
-    {
-      name: "Boole",
-      kind: "matchfix",
-      openTrigger: "[",
-      closeTrigger: "]",
-      // serialize: (serializer: Serializer, expr: MathJsonExpression) => {
-      //   const args = ops(expr);
-      //   return `[${serializer.serialize(arg)}]`;
-      // },
-      parse: (_parser, body) => {
-        const h = operator(body);
-        if (!h) return null;
-        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
-        return ["Boole", body];
-      }
-    },
-    {
-      kind: "matchfix",
-      openTrigger: "\\llbracket",
-      closeTrigger: "\\rrbracket",
-      parse: (_parser, body) => {
-        const h = operator(body);
-        if (!h) return null;
-        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
-        return ["Boole", body];
-      }
-    },
-    // Predicate application in First-Order Logic.
-    // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
-    {
-      name: "Predicate",
-      serialize: (serializer, expr) => {
-        const args = operands(expr);
-        if (args.length === 0) return "";
-        const pred = args[0];
-        const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
-        if (args.length === 1) return predStr;
-        const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
-        return `${predStr}(${argStrs.join(", ")})`;
+        return ["To", lhs, rhs];
       }
     }
   ];
-  function serializeQuantifier(quantifierSymbol) {
-    return (serializer, expr) => {
-      const args = operands(expr);
-      if (args.length === 0) return quantifierSymbol;
-      if (args.length === 1)
-        return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
-      const boundVar = serializer.serialize(args[0]);
-      const body = serializer.serialize(args[1]);
-      return `${quantifierSymbol} ${boundVar}, ${body}`;
-    };
-  }
-  function tightBindingCondition(p, terminator) {
-    return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
-  }
-  function parseQuantifier(kind) {
-    return (parser, terminator) => {
-      const index = parser.index;
-      const useTightBinding = parser.options.quantifierScope !== "loose";
-      const symbol2 = parser.parseSymbol(terminator);
-      if (symbol2) {
-        parser.skipSpace();
-        if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-          const bodyTerminator = useTightBinding ? {
-            ...terminator,
-            condition: (p) => tightBindingCondition(p, terminator)
-          } : terminator;
-          parser.enterQuantifierScope();
-          const body2 = parser.parseExpression(bodyTerminator);
-          parser.exitQuantifierScope();
-          return [kind, symbol2, missingIfEmpty(body2)];
-        }
-        parser.enterQuantifierScope();
-        const body = parser.parseEnclosure();
-        parser.exitQuantifierScope();
-        if (body) return [kind, symbol2, missingIfEmpty(body)];
-      }
-      parser.index = index;
-      const condTerminator = {
-        ...terminator,
-        condition: (p) => p.peek === ":" || p.peek === "\\colon" || (terminator.condition?.(p) ?? false)
-      };
-      const condition = parser.parseExpression(condTerminator);
-      if (condition === null) return null;
-      parser.skipSpace();
-      if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
-        const bodyTerminator = useTightBinding ? {
-          ...terminator,
-          condition: (p) => tightBindingCondition(p, terminator)
-        } : terminator;
-        parser.enterQuantifierScope();
-        const body = parser.parseExpression(bodyTerminator);
-        parser.exitQuantifierScope();
-        return [kind, condition, missingIfEmpty(body)];
-      }
-      if (parser.match("(")) {
-        parser.enterQuantifierScope();
-        const body = parser.parseExpression(terminator);
-        parser.exitQuantifierScope();
-        if (!parser.match(")")) return null;
-        return [kind, condition, missingIfEmpty(body)];
-      }
-      return null;
-    };
-  }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-sets.ts
   function parseIntervalBody(body, openLeft, openRight) {
@@ -11340,7 +11492,7 @@ var Compile = (() => {
   var FLAG_SEQUENCE = "\\p{RI}\\p{RI}";
   var TAG_MOD = `(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})`;
   var EMOJI_MOD = `(?:\\p{EMod}|${VS16}${KEYCAP}?|${TAG_MOD})`;
-  var EMOJI_NOT_SYMBOL = `(?:(?=\\P{XIDC})\\p{Emoji})`;
+  var EMOJI_NOT_SYMBOL = `(?:(?=\\P{XIDC})(?=[^\\x23\\x2a\\x30-\\x39])\\p{Emoji})`;
   var ZWJ_ELEMENT = `(?:${EMOJI_NOT_SYMBOL}${EMOJI_MOD}*|\\p{Emoji}${EMOJI_MOD}+|${FLAG_SEQUENCE})`;
   var POSSIBLE_EMOJI = `(?:${ZWJ_ELEMENT})(${ZWJ}${ZWJ_ELEMENT})*`;
   var SOME_EMOJI = new RegExp(`(?:${POSSIBLE_EMOJI})+`, "u");
@@ -24421,7 +24573,7 @@ ${code}`;
   }
 
   // src/compile.ts
-  var version = "0.55.0";
+  var version = "0.55.2";
   return __toCommonJS(compile_exports);
 })();
 /*! Bundled license information: