@cortex-js/compute-engine 0.55.0 → 0.55.2

package/dist/compile.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.0 */
+/** Compute Engine 0.55.2 */
 
 // src/compute-engine/numerics/richardson.ts
 function extrapolate(f, x0, options = {}) {
@@ -4735,1132 +4735,1726 @@ function expressionToDictionaryValue(expr) {
   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>")) {
@@ -5870,6 +6464,7 @@ function parseTextRun(parser, style) {
       const expr = parser.parseExpression() ?? "Nothing";
       parser.skipSpace();
       if (parser.match("<$>")) {
+        flush();
         runs.push(expr);
       } else {
         text += "$";
@@ -5880,6 +6475,7 @@ function parseTextRun(parser, style) {
       const expr = parser.parseExpression() ?? "Nothing";
       parser.skipSpace();
       if (parser.match("<$$>")) {
+        flush();
         runs.push(expr);
       } else {
         text += "$$";
@@ -6230,14 +6826,20 @@ function matchTextKeyword(parser, keyword) {
   }
   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>")) {
@@ -6246,10 +6848,6 @@ function matchTextKeyword(parser, keyword) {
     parser.index = start;
     return false;
   }
-  if (text !== keyword) {
-    parser.index = start;
-    return false;
-  }
   return true;
 }
 function matchKeyword(parser, keyword) {
@@ -6491,487 +7089,41 @@ var DEFINITIONS_SYMBOLS = [
     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) {
@@ -11307,7 +11459,7 @@ var ZWJ = "\\u{200D}";
 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");
@@ -24388,7 +24540,7 @@ function compileToIntervalTarget(expr, target) {
 }
 
 // src/compile.ts
-var version = "0.55.0";
+var version = "0.55.2";
 export {
   BaseCompiler,
   GLSLTarget,