@cortex-js/compute-engine 0.12.7 → 0.14.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.12.7 */
+/** CortexJS Compute Engine 0.14.0 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3744,7 +3744,7 @@ function tokensToString(tokens) {
 var DEFINITIONS_ALGEBRA = [
   {
     name: "To",
-    trigger: ["\\to"],
+    latexTrigger: ["\\to"],
     kind: "infix",
     precedence: 270
     // MathML rightwards arrow
@@ -3949,6 +3949,14 @@ function symbol(expr) {
     return null;
   return s;
 }
+function isListLike(expr) {
+  if (expr === null)
+    return false;
+  const h = head(expr);
+  if (!h || typeof h !== "string")
+    return false;
+  return /^(List|Sequence|Tuple|Single|Pair|Triple)$/.test(h);
+}
 function keyValuePair(expr) {
   const h = head(expr);
   if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
@@ -3998,10 +4006,10 @@ function machineValue(expr) {
     return null;
   if (typeof expr === "number")
     return expr;
-  if (isNumberObject(expr))
-    return machineValueOfString(expr.num);
   if (typeof expr === "string")
     return machineValueOfString(expr);
+  if (isNumberObject(expr))
+    return machineValue(expr.num);
   return null;
 }
 function rationalValue(expr) {
@@ -4526,7 +4534,7 @@ var DEFINITIONS_ARITHMETIC = [
   { name: "EulerGamma", serialize: "\\gamma" },
   {
     name: "Degrees",
-    trigger: ["\\degree"],
+    latexTrigger: ["\\degree"],
     kind: "postfix",
     precedence: 880,
     parse: (_parser, lhs) => ["Degrees", lhs],
@@ -4535,67 +4543,83 @@ var DEFINITIONS_ARITHMETIC = [
     }
   },
   {
-    trigger: ["\\degree"],
+    latexTrigger: ["\\degree"],
     kind: "postfix",
     precedence: 880,
     parse: (_parser, lhs) => ["Degrees", lhs]
   },
   {
-    trigger: ["^", "<{>", "\\circ", "<}>"],
+    latexTrigger: ["^", "<{>", "\\circ", "<}>"],
     kind: "postfix",
     parse: (_parser, lhs) => ["Degrees", lhs]
   },
   {
-    trigger: ["^", "\\circ"],
+    latexTrigger: ["^", "\\circ"],
     kind: "postfix",
     parse: (_parser, lhs) => ["Degrees", lhs]
   },
   {
-    trigger: ["\xB0"],
+    latexTrigger: ["\xB0"],
     kind: "postfix",
     precedence: 880,
     parse: (_parser, lhs) => ["Degrees", lhs]
   },
   {
-    trigger: ["\\ang"],
+    latexTrigger: ["\\ang"],
     parse: (parser) => {
       const arg = parser.parseGroup();
       return arg === null ? ["Degrees"] : ["Degrees", arg];
     }
   },
   {
-    trigger: ["\\infty"],
+    latexTrigger: ["\\infty"],
     parse: { num: "+Infinity" }
   },
   {
     name: "ComplexInfinity",
-    trigger: ["\\tilde", "\\infty"],
+    latexTrigger: ["\\tilde", "\\infty"],
     serialize: "\\tilde\\infty"
   },
   {
-    trigger: ["\\tilde", "<{>", "\\infty", "<}>"],
+    latexTrigger: ["\\tilde", "<{>", "\\infty", "<}>"],
     parse: "ComplexInfinity"
   },
-  { name: "Pi", kind: "symbol", trigger: ["\\pi"] },
-  { trigger: ["\u03C0"], parse: "Pi" },
+  { name: "Pi", kind: "symbol", latexTrigger: ["\\pi"] },
+  { latexTrigger: ["\u03C0"], parse: "Pi" },
   {
     name: "ExponentialE",
-    trigger: ["\\exponentialE"],
+    latexTrigger: ["\\exponentialE"],
     parse: "ExponentialE",
     serialize: "\\exponentialE"
   },
+  {
+    latexTrigger: "\\operatorname{e}",
+    parse: "ExponentialE"
+  },
+  {
+    latexTrigger: "\\mathrm{e}",
+    parse: "ExponentialE"
+  },
   {
     kind: "function",
-    trigger: "exp",
+    identifierTrigger: "exp",
     parse: "Exp"
   },
   {
-    trigger: "\\exp",
+    latexTrigger: "\\exp",
     parse: "Exp"
   },
   {
     name: "ImaginaryUnit",
-    trigger: ["\\imaginaryI"]
+    latexTrigger: ["\\imaginaryI"]
+  },
+  {
+    latexTrigger: "\\operatorname{i}",
+    parse: "ImaginaryUnit"
+  },
+  {
+    latexTrigger: "\\mathrm{i}",
+    parse: "ImaginaryUnit"
   },
   // Operations
   {
@@ -4605,18 +4629,18 @@ var DEFINITIONS_ARITHMETIC = [
      * replaced with bars */
     name: "Abs",
     kind: "matchfix",
-    openDelimiter: "|",
-    closeDelimiter: "|",
-    parse: (_parser, expr) => isEmptySequence(expr) ? null : ["Abs", expr]
+    openTrigger: "|",
+    closeTrigger: "|",
+    parse: (_parser, body) => isEmptySequence(body) ? null : ["Abs", body]
   },
   {
-    trigger: "abs",
+    identifierTrigger: "abs",
     kind: "function",
     parse: "Abs"
   },
   {
     name: "Add",
-    trigger: ["+"],
+    latexTrigger: ["+"],
     kind: "infix",
     associativity: "both",
     precedence: 275,
@@ -4632,7 +4656,7 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     kind: "prefix",
-    trigger: ["+"],
+    latexTrigger: ["+"],
     precedence: 275,
     parse: (parser, until) => {
       if (until && 275 < until.minPrec)
@@ -4643,20 +4667,22 @@ var DEFINITIONS_ARITHMETIC = [
   {
     name: "Ceil",
     kind: "matchfix",
-    openDelimiter: "\\lceil",
-    closeDelimiter: "\\rceil"
+    openTrigger: "\\lceil",
+    closeTrigger: "\\rceil",
+    parse: (_parser, body) => isEmptySequence(body) ? null : ["Ceil", body]
   },
   {
     kind: "matchfix",
-    openDelimiter: ["\u2308"],
-    closeDelimiter: ["\u2309"],
-    parse: (_, body) => ["Ceil", body]
+    openTrigger: ["\u2308"],
+    closeTrigger: ["\u2309"],
+    parse: (_parser, body) => isEmptySequence(body) ? null : ["Ceil", body]
   },
   {
-    trigger: "ceil",
+    identifierTrigger: "ceil",
     kind: "function",
     parse: "Ceil"
   },
+  { name: "Chop", identifierTrigger: "chop", kind: "function", parse: "Chop" },
   {
     name: "Complex",
     precedence: 274,
@@ -4676,7 +4702,7 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Divide",
-    trigger: "\\frac",
+    latexTrigger: "\\frac",
     precedence: 660,
     // For \frac specifically, not for \div, etc..
     // handles Leibnitz notation for partial derivatives
@@ -4685,12 +4711,12 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     kind: "infix",
-    trigger: "\\over",
+    latexTrigger: "\\over",
     precedence: 660,
     parse: "Divide"
   },
   {
-    trigger: ["\\/"],
+    latexTrigger: ["\\/"],
     kind: "infix",
     associativity: "non",
     precedence: 660,
@@ -4700,14 +4726,14 @@ var DEFINITIONS_ARITHMETIC = [
     parse: "Divide"
   },
   {
-    trigger: ["/"],
+    latexTrigger: ["/"],
     kind: "infix",
     associativity: "non",
     precedence: 660,
     parse: "Divide"
   },
   {
-    trigger: ["\\div"],
+    latexTrigger: ["\\div"],
     kind: "infix",
     associativity: "non",
     precedence: 660,
@@ -4725,36 +4751,41 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Factorial",
-    trigger: ["!"],
+    latexTrigger: ["!"],
     kind: "postfix",
     precedence: 810
   },
   {
     name: "Factorial2",
-    trigger: ["!", "!"],
+    latexTrigger: ["!", "!"],
     kind: "postfix",
     precedence: 810
   },
   {
     name: "Floor",
     kind: "matchfix",
-    openDelimiter: "\\lfloor",
-    closeDelimiter: "\\rfloor"
+    openTrigger: "\\lfloor",
+    closeTrigger: "\\rfloor",
+    parse: (_parser, body) => isEmptySequence(body) ? null : ["Floor", body]
   },
   {
     kind: "matchfix",
-    openDelimiter: ["\u230A"],
-    closeDelimiter: ["\u230B"],
-    parse: (_, body) => ["Floor", body]
+    openTrigger: ["\u230A"],
+    closeTrigger: ["\u230B"],
+    parse: (_parser, body) => isEmptySequence(body) ? null : ["Floor", body]
   },
   {
-    trigger: "floor",
+    identifierTrigger: "floor",
     kind: "function",
     parse: "Floor"
   },
+  {
+    latexTrigger: ["\\Gamma"],
+    parse: "Gamma"
+  },
   {
     name: "Gcd",
-    trigger: "gcd",
+    identifierTrigger: "gcd",
     kind: "function"
   },
   {
@@ -4763,34 +4794,34 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Lg",
-    trigger: ["\\lg"],
+    latexTrigger: ["\\lg"],
     serialize: (serializer, expr) => "\\log_{10}" + serializer.wrapArguments(expr),
     parse: (parser) => {
-      const arg = parser.parseArguments("implicit");
-      if (arg === null)
+      const args = parser.parseArguments("implicit");
+      if (args === null)
         return "Lg";
-      return ["Log", ...arg, 10];
+      return ["Log", ...args, 10];
     }
   },
   {
     name: "Lb",
-    trigger: "\\lb",
+    latexTrigger: "\\lb",
     parse: (parser) => {
-      const arg = parser.parseArguments("implicit");
-      if (arg === null)
+      const args = parser.parseArguments("implicit");
+      if (args === null)
         return "Log";
-      return ["Log", ...arg, 2];
+      return ["Log", ...args, 2];
     }
   },
   {
     name: "Ln",
-    trigger: ["\\ln"],
+    latexTrigger: ["\\ln"],
     serialize: (serializer, expr) => "\\ln" + serializer.wrapArguments(expr),
     parse: (parser) => parseLog("Ln", parser)
   },
   {
     name: "Log",
-    trigger: ["\\log"],
+    latexTrigger: ["\\log"],
     parse: (parser) => parseLog("Log", parser),
     serialize: (serializer, expr) => {
       const base = op2(expr);
@@ -4806,32 +4837,32 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Lcm",
-    trigger: "lcm",
+    identifierTrigger: "lcm",
     kind: "function"
   },
+  { name: "Max", identifierTrigger: "max", kind: "function" },
+  { name: "Min", identifierTrigger: "min", kind: "function" },
   {
     name: "MinusPlus",
-    trigger: ["\\mp"],
+    latexTrigger: ["\\mp"],
     kind: "infix",
     associativity: "both",
     precedence: 270
   },
   {
     name: "Multiply",
-    trigger: ["\\times"],
+    latexTrigger: ["\\times"],
     kind: "infix",
     associativity: "both",
     precedence: 390,
     serialize: serializeMultiply
   },
   {
-    trigger: ["\\cdot"],
+    latexTrigger: ["\\cdot"],
     kind: "infix",
     associativity: "both",
     precedence: 390,
     parse: (parser, lhs, terminator) => {
-      if (terminator && 391 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 392 });
       if (rhs === null)
         return ["Multiply", lhs, MISSING];
@@ -4839,13 +4870,11 @@ var DEFINITIONS_ARITHMETIC = [
     }
   },
   {
-    trigger: ["*"],
+    latexTrigger: ["*"],
     kind: "infix",
     associativity: "both",
     precedence: 390,
     parse: (parser, lhs, terminator) => {
-      if (terminator && 391 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 392 });
       if (rhs === null)
         return ["Multiply", lhs, MISSING];
@@ -4854,11 +4883,9 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Negate",
-    trigger: ["-"],
+    latexTrigger: ["-"],
     kind: "prefix",
     parse: (parser, terminator) => {
-      if (terminator && 276 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["Negate", missingIfEmpty(rhs)];
     },
@@ -4884,8 +4911,8 @@ var DEFINITIONS_ARITHMETIC = [
     //   /** If the argument is a vector */
     /** @todo: domain check */
     kind: "matchfix",
-    openDelimiter: "||",
-    closeDelimiter: "||",
+    openTrigger: "||",
+    closeTrigger: "||",
     parse: (_parser, expr) => isEmptySequence(expr) ? null : ["Norm", expr]
   },
   {
@@ -4893,12 +4920,13 @@ var DEFINITIONS_ARITHMETIC = [
     /** @todo: domain check */
     name: "Norm",
     kind: "matchfix",
-    openDelimiter: ["\\left", "\\Vert"],
-    closeDelimiter: ["\\right", "\\Vert"]
+    openTrigger: ["\\left", "\\Vert"],
+    closeTrigger: ["\\right", "\\Vert"],
+    parse: (_parser, expr) => isEmptySequence(expr) ? null : ["Norm", expr]
   },
   {
     name: "PlusMinus",
-    trigger: ["\\pm"],
+    latexTrigger: ["\\pm"],
     kind: "infix",
     associativity: "both",
     precedence: 270,
@@ -4917,47 +4945,41 @@ var DEFINITIONS_ARITHMETIC = [
     }
   },
   {
-    trigger: ["\\pm"],
+    latexTrigger: ["\\pm"],
     kind: "prefix",
     precedence: 270,
     parse: (parser, terminator) => {
-      if (terminator && 270 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["PlusMinus", missingIfEmpty(rhs)];
     }
   },
   {
-    trigger: ["\\plusmn"],
+    latexTrigger: ["\\plusmn"],
     kind: "infix",
     associativity: "both",
     precedence: 270,
     parse: (parser, lhs, terminator) => {
-      if (270 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["PlusMinus", lhs, missingIfEmpty(rhs)];
     }
   },
   {
-    trigger: ["\\plusmn"],
+    latexTrigger: ["\\plusmn"],
     kind: "prefix",
     precedence: 270,
     parse: (parser, terminator) => {
-      if (terminator && 270 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["PlusMinus", missingIfEmpty(rhs)];
     }
   },
   {
     name: "Power",
-    trigger: ["^"],
+    latexTrigger: ["^"],
     kind: "infix",
     serialize: serializePower
   },
   {
-    trigger: "\\prod",
+    latexTrigger: "\\prod",
     precedence: 390,
     name: "Product",
     parse: parseBigOp("Product", 390),
@@ -4974,7 +4996,7 @@ var DEFINITIONS_ARITHMETIC = [
     precedence: 660,
     serialize: (serializer, expr) => {
       if (expr && nops(expr) === 1)
-        return "\\mathrm{Rational}" + serializer.wrapArguments(expr);
+        return "\\operatorname{Rational}" + serializer.wrapArguments(expr);
       return serializeFraction(serializer, expr);
     }
   },
@@ -4984,7 +5006,7 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Round",
-    trigger: "round",
+    identifierTrigger: "round",
     kind: "function"
   },
   {
@@ -4993,7 +5015,7 @@ var DEFINITIONS_ARITHMETIC = [
     serialize: (serializer, expr) => serializer.wrapShort(op(expr, 1)) + "^2"
   },
   {
-    trigger: "\\sum",
+    latexTrigger: ["\\sum"],
     precedence: 275,
     name: "Sum",
     parse: parseBigOp("Sum", 275),
@@ -5002,24 +5024,22 @@ var DEFINITIONS_ARITHMETIC = [
   {
     name: "Sign",
     // As per ISO 80000-2, "signum" is 'sgn'
-    trigger: "sgn",
+    identifierTrigger: "sgn",
     kind: "function"
   },
   {
     name: "Sqrt",
-    trigger: ["\\sqrt"],
+    latexTrigger: ["\\sqrt"],
     parse: parseRoot,
     serialize: serializePower
   },
   {
     name: "Subtract",
-    trigger: ["-"],
+    latexTrigger: ["-"],
     kind: "infix",
     associativity: "both",
     precedence: 275,
     parse: (parser, lhs, terminator) => {
-      if (276 < terminator.minPrec)
-        return null;
       const rhs = parser.parseExpression({ ...terminator, minPrec: 277 });
       return ["Subtract", lhs, missingIfEmpty(rhs)];
     }
@@ -5116,16 +5136,16 @@ function parseLog(command, parser) {
     sub2 = parser.parseStringGroup()?.trim() ?? parser.nextToken();
     base = Number.parseFloat(sub2 ?? "10");
   }
-  const arg = parser.parseArguments("implicit");
-  if (arg === null)
+  const args = parser.parseArguments("implicit");
+  if (args === null)
     return [command];
   if (base === 10)
-    return ["Log", arg[0]];
+    return ["Log", args[0]];
   if (base === 2)
-    return ["Lb", ...arg];
+    return ["Lb", ...args];
   if (sub2 === null)
-    return [command, ...arg];
-  return ["Log", ...arg, sub2];
+    return [command, ...args];
+  return ["Log", ...args, sub2];
 }
 
 // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
@@ -5156,7 +5176,7 @@ function parseSequence(parser, terminator, lhs, prec, sep) {
   }
   return result;
 }
-function serializeSequence(sep = "") {
+function serializeOps(sep = "") {
   return (serializer, expr) => (ops(expr) ?? []).map((x) => serializer.serialize(x)).join(sep);
 }
 var DEFINITIONS_CORE = [
@@ -5164,7 +5184,7 @@ var DEFINITIONS_CORE = [
   // Constants
   //
   {
-    trigger: ["\\placeholder"],
+    latexTrigger: ["\\placeholder"],
     kind: "symbol",
     parse: (parser) => {
       while (parser.match("<space>")) {
@@ -5183,6 +5203,27 @@ var DEFINITIONS_CORE = [
   //
   // Functions
   //
+  {
+    name: "Apply",
+    kind: "function",
+    identifierTrigger: "apply",
+    serialize: (serializer, expr) => serializer.serializeFunction(ops(expr))
+  },
+  {
+    latexTrigger: "\\rhd",
+    kind: "infix",
+    precedence: 20,
+    parse: "Apply"
+  },
+  {
+    latexTrigger: "\\lhd",
+    kind: "infix",
+    precedence: 20,
+    parse: (parser, lhs) => {
+      const rhs = parser.parseExpression({ minPrec: 20 }) ?? "Nothing";
+      return ["Apply", rhs, lhs];
+    }
+  },
   {
     name: "BaseForm",
     serialize: (serializer, expr) => {
@@ -5224,22 +5265,19 @@ var DEFINITIONS_CORE = [
         return "";
       const style = serializer.options.groupStyle(expr, serializer.level + 1);
       const arg1 = op(expr, 1);
-      if (argCount === 1)
-        return serializer.wrapString(serializer.serialize(arg1), style);
-      let sep = "";
-      let open = "";
-      let close = "";
+      const h1 = head(arg1);
+      const defaultFence = { List: "[],", Sequence: "" }[typeof h1 === "string" ? h1 : ""] ?? "(),";
+      let open = defaultFence[0] ?? "";
+      let close = defaultFence[1] ?? "";
+      let sep = defaultFence[2] ?? "";
       if (argCount > 1) {
         const op22 = stringValue(op(expr, 2)) ?? "";
-        open = op22[0] ?? "(";
-        close = op22[1] ?? ")";
-        sep = op22[2] ?? ",";
+        open = op22[0] ?? defaultFence[0];
+        close = op22[1] ?? defaultFence[1];
+        sep = op22[2] ?? defaultFence[2];
       }
-      const body = head(arg1) === "List" ? serializeSequence(sep)(serializer, arg1) : serializer.serialize(arg1);
-      serializer.wrapString(body, style, stringValue(op(expr, 2)) ?? void 0);
-      if (!open || !close)
-        return serializer.wrapString(body, style);
-      return `${open} ${body} ${close}`;
+      const body = isListLike(arg1) ? serializeOps(sep)(serializer, arg1) : serializer.serialize(arg1);
+      return serializer.wrapString(body, style, open + close);
     }
   },
   {
@@ -5251,7 +5289,7 @@ var DEFINITIONS_CORE = [
     }
   },
   {
-    trigger: ["\\mathtip"],
+    latexTrigger: ["\\mathtip"],
     parse: (parser) => {
       const op12 = parser.parseGroup();
       const op22 = parser.parseGroup();
@@ -5259,7 +5297,7 @@ var DEFINITIONS_CORE = [
     }
   },
   {
-    trigger: ["\\texttip"],
+    latexTrigger: ["\\texttip"],
     parse: (parser) => {
       const op12 = parser.parseGroup();
       const op22 = parser.parseGroup();
@@ -5267,8 +5305,8 @@ var DEFINITIONS_CORE = [
     }
   },
   {
-    trigger: ["\\error"],
-    parse: (parser) => parser.parseGroup()
+    latexTrigger: ["\\error"],
+    parse: (parser) => ["Error", parser.parseGroup()]
   },
   {
     name: "Error",
@@ -5328,10 +5366,10 @@ var DEFINITIONS_CORE = [
   {
     name: "List",
     kind: "matchfix",
-    openDelimiter: "[",
-    closeDelimiter: "]",
+    openTrigger: "[",
+    closeTrigger: "]",
     parse: (_parser, body) => {
-      if (body === null)
+      if (body === null || isEmptySequence(body))
         return ["List"];
       if (head(body) !== "Sequence" && head(body) !== "List")
         return ["List", body];
@@ -5340,18 +5378,18 @@ var DEFINITIONS_CORE = [
     serialize: (serializer, expr) => {
       return joinLatex([
         "\\lbrack",
-        serializeSequence(", ")(serializer, expr),
+        serializeOps(", ")(serializer, expr),
         "\\rbrack"
       ]);
     }
   },
   {
     kind: "matchfix",
-    openDelimiter: "(",
-    closeDelimiter: ")",
+    openTrigger: "(",
+    closeTrigger: ")",
     parse: (_parser, body) => {
-      if (body === null)
-        return null;
+      if (body === null || isEmptySequence(body))
+        return ["Sequence"];
       if (head(body) === "Sequence" || head(body) === "List") {
         if (nops(body) === 0)
           return ["Delimiter"];
@@ -5361,7 +5399,7 @@ var DEFINITIONS_CORE = [
     }
   },
   {
-    trigger: [","],
+    latexTrigger: [","],
     kind: "infix",
     precedence: 20,
     // Unlike the matchfix version of List,
@@ -5378,10 +5416,10 @@ var DEFINITIONS_CORE = [
   },
   {
     name: "Sequence",
-    serialize: serializeSequence("")
+    serialize: serializeOps("")
   },
   {
-    trigger: [";"],
+    latexTrigger: [";"],
     kind: "infix",
     precedence: 19,
     parse: (parser, lhs, terminator) => {
@@ -5398,7 +5436,7 @@ var DEFINITIONS_CORE = [
   },
   {
     name: "String",
-    trigger: ["\\text"],
+    latexTrigger: ["\\text"],
     parse: (scanner) => parseTextRun(scanner),
     serialize: (serializer, expr) => {
       const args = ops(expr);
@@ -5413,7 +5451,7 @@ var DEFINITIONS_CORE = [
   },
   {
     name: "Subscript",
-    trigger: ["_"],
+    latexTrigger: ["_"],
     kind: "infix",
     serialize: (serializer, expr) => {
       if (nops(expr) === 2) {
@@ -5422,53 +5460,121 @@ var DEFINITIONS_CORE = [
       return "_{" + serializer.serialize(op(expr, 1)) + "}";
     }
   },
-  { name: "Superplus", trigger: ["^", "+"], kind: "postfix" },
-  { name: "Subplus", trigger: ["_", "+"], kind: "postfix" },
-  { name: "Superminus", trigger: ["^", "-"], kind: "postfix" },
-  { name: "Subminus", trigger: ["_", "-"], kind: "postfix" },
+  { name: "Superplus", latexTrigger: ["^", "+"], kind: "postfix" },
+  { name: "Subplus", latexTrigger: ["_", "+"], kind: "postfix" },
+  { name: "Superminus", latexTrigger: ["^", "-"], kind: "postfix" },
+  { name: "Subminus", latexTrigger: ["_", "-"], kind: "postfix" },
   {
-    trigger: ["^", "*"],
+    latexTrigger: ["^", "*"],
     kind: "postfix",
     parse: (_parser, lhs) => ["Superstar", lhs]
   },
   // @todo: when lhs is a complex number, 'Conjugate'
   // { name: 'Conjugate', trigger: ['\\star'], kind: 'infix' },
-  { name: "Superstar", trigger: ["^", "\\star"], kind: "postfix" },
+  { name: "Superstar", latexTrigger: ["^", "\\star"], kind: "postfix" },
   {
-    trigger: ["_", "*"],
+    latexTrigger: ["_", "*"],
     kind: "postfix",
     parse: (_parser, lhs) => ["Substar", lhs]
   },
-  { name: "Substar", trigger: ["_", "\\star"], kind: "postfix" },
-  { name: "Superdagger", trigger: ["^", "\\dagger"], kind: "postfix" },
+  { name: "Substar", latexTrigger: ["_", "\\star"], kind: "postfix" },
+  { name: "Superdagger", latexTrigger: ["^", "\\dagger"], kind: "postfix" },
   {
-    trigger: ["^", "\\dag"],
+    latexTrigger: ["^", "\\dag"],
     kind: "postfix",
     parse: (_parser, lhs) => ["Superdagger", lhs]
   },
   {
     name: "Prime",
-    trigger: ["^", "\\prime"],
-    kind: "postfix"
+    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(op(expr, 2)) ?? 1;
+      const base = serializer.serialize(op(expr, 1));
+      if (n2 === 1)
+        return base + "^\\prime";
+      if (n2 === 2)
+        return base + "^\\doubleprime";
+      if (n2 === 3)
+        return base + "^\\tripleprime";
+      return base + "^{(" + serializer.serialize(op(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)
   },
   {
-    trigger: ["^", "\\doubleprime"],
+    latexTrigger: ["^", "\\tripleprime"],
     kind: "postfix",
-    parse: (_parser, lhs) => ["Prime", missingIfEmpty(lhs), 2]
+    parse: (parser, lhs) => parsePrime(parser, lhs, 3)
   },
   {
-    trigger: ["^", "\\tripleprime"],
+    latexTrigger: "'",
     kind: "postfix",
-    parse: (_parser, lhs) => ["Prime", missingIfEmpty(lhs), 3]
+    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)
+  },
+  {
+    latexTrigger: ["^", "<{>", "("],
+    kind: "postfix",
+    parse: (parser, lhs) => {
+      if (!parser.computeEngine?.box(lhs)?.domain.isFunction)
+        return null;
+      const start = parser.index;
+      parser.addBoundary([")"]);
+      const expr = parser.parseExpression();
+      if (!parser.matchBoundary()) {
+        parser.index = start;
+        return null;
+      }
+      if (!parser.match("<}>")) {
+        parser.index = start;
+        return null;
+      }
+      return ["Derivative", lhs, expr];
+    }
   },
   {
     name: "InverseFunction",
-    trigger: "^{-1}",
+    latexTrigger: "^{-1}",
     kind: "postfix",
     parse: (parser, lhs) => {
       if (parser.computeEngine?.box(lhs)?.domain.isFunction)
         return ["InverseFunction", lhs];
-      return null;
+      return ["Power", missingIfEmpty(lhs), -1];
     },
     serialize: (serializer, expr) => serializer.serialize(op(expr, 1)) + "^{-1}"
   },
@@ -5483,13 +5589,13 @@ var DEFINITIONS_CORE = [
         return base + "^{\\doubleprime}";
       if (degree === 3)
         return base + "^{\\tripleprime}";
-      return base + "^{(" + Number(degree).toString() + ")}";
+      return base + "^{(" + serializer.serialize(op(expr, 2)) + ")}";
     }
   },
   {
-    name: "Which",
-    trigger: "cases",
     kind: "environment",
+    name: "Which",
+    identifierTrigger: "cases",
     parse: (parser) => {
       const tabular = parser.parseTabular();
       if (!tabular)
@@ -5508,24 +5614,17 @@ var DEFINITIONS_CORE = [
       return result;
     },
     serialize: (serialize2, expr) => {
-      if (head(op(expr, 1)) !== "List")
-        return "";
-      const rows = ops(op(expr, 1)) ?? [];
-      const body = [];
-      let rowSep = "";
-      for (const row of rows) {
-        if (head(row) === "Tuple" || head(row) === "Pair") {
-          body.push(rowSep);
-          if (op(row, 2)) {
-            body.push(serialize2.serialize(op(row, 2)));
-            const condition = op(row, 1);
-            if (condition !== null)
-              body.push("&", serialize2.serialize(condition));
-          }
+      const rows = [];
+      const args = ops(expr);
+      if (args) {
+        for (let i = 0; i <= args.length - 2; i += 2) {
+          const row = [];
+          row.push(serialize2.serialize(args[i + 1]));
+          row.push(serialize2.serialize(args[i]));
+          rows.push(row.join("&"));
         }
-        rowSep = "\\\\";
       }
-      return joinLatex(["\\begin{cases}", ...body, "\\end{cases}"]);
+      return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
     }
   }
 ];
@@ -5639,11 +5738,26 @@ function errorContextAsLatex(serializer, error) {
     return serializer.serialize(op(arg, 1));
   return serializer.serialize(arg);
 }
+function parsePrime(parser, lhs, order2) {
+  const lhsh = head(lhs);
+  if (lhsh === "Derivative" || lhsh === "Prime") {
+    const n = machineValue(op(lhs, 2)) ?? 1;
+    return [lhsh, missingIfEmpty(op(lhs, 1)), n + order2];
+  }
+  if (parser.computeEngine?.box(lhs)?.domain.isFunction) {
+    if (order2 === 1)
+      return ["Derivative", lhs];
+    return ["Derivative", lhs, order2];
+  }
+  if (order2 === 1)
+    return ["Prime", missingIfEmpty(lhs)];
+  return ["Prime", missingIfEmpty(lhs), order2];
+}
 
 // src/compute-engine/latex-syntax/dictionary/definitions-inequalities.ts
 var DEFINITIONS_INEQUALITIES = [
   {
-    trigger: ["\\not", "<"],
+    latexTrigger: ["\\not", "<"],
     kind: "infix",
     associativity: "right",
     precedence: 246,
@@ -5651,13 +5765,13 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "NotLess",
-    trigger: ["\\nless"],
+    latexTrigger: ["\\nless"],
     kind: "infix",
     associativity: "right",
     precedence: 246
   },
   {
-    trigger: ["<"],
+    latexTrigger: ["<"],
     kind: "infix",
     associativity: "right",
     precedence: 245,
@@ -5665,13 +5779,13 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "Less",
-    trigger: ["\\lt"],
+    latexTrigger: ["\\lt"],
     kind: "infix",
     associativity: "right",
     precedence: 245
   },
   {
-    trigger: ["<", "="],
+    latexTrigger: ["<", "="],
     kind: "infix",
     associativity: "right",
     precedence: 241,
@@ -5679,20 +5793,20 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "LessEqual",
-    trigger: ["\\le"],
+    latexTrigger: ["\\le"],
     kind: "infix",
     associativity: "right",
     precedence: 241
   },
   {
-    trigger: ["\\leq"],
+    latexTrigger: ["\\leq"],
     kind: "infix",
     associativity: "right",
     precedence: 241,
     parse: "LessEqual"
   },
   {
-    trigger: ["\\leqslant"],
+    latexTrigger: ["\\leqslant"],
     kind: "infix",
     associativity: "right",
     precedence: 265,
@@ -5701,28 +5815,28 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "LessNotEqual",
-    trigger: ["\\lneqq"],
+    latexTrigger: ["\\lneqq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "NotLessNotEqual",
-    trigger: ["\\nleqq"],
+    latexTrigger: ["\\nleqq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "LessOverEqual",
-    trigger: ["\\leqq"],
+    latexTrigger: ["\\leqq"],
     kind: "infix",
     associativity: "right",
     precedence: 265
   },
   {
     name: "GreaterOverEqual",
-    trigger: ["\\geqq"],
+    latexTrigger: ["\\geqq"],
     kind: "infix",
     associativity: "right",
     precedence: 265,
@@ -5730,13 +5844,13 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "Equal",
-    trigger: ["="],
+    latexTrigger: ["="],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
-    trigger: ["*", "="],
+    latexTrigger: ["*", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260,
@@ -5744,42 +5858,42 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "StarEqual",
-    trigger: ["\\star", "="],
+    latexTrigger: ["\\star", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "PlusEqual",
-    trigger: ["+", "="],
+    latexTrigger: ["+", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "MinusEqual",
-    trigger: ["-", "="],
+    latexTrigger: ["-", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "SlashEqual",
-    trigger: ["/", "="],
+    latexTrigger: ["/", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "EqualEqual",
-    trigger: ["=", "="],
+    latexTrigger: ["=", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "EqualEqualEqual",
-    trigger: ["=", "=", "="],
+    latexTrigger: ["=", "=", "="],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -5787,7 +5901,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "TildeFullEqual",
     // MathML: approximately equal to
-    trigger: ["\\cong"],
+    latexTrigger: ["\\cong"],
     kind: "infix",
     associativity: "right",
     precedence: 260
@@ -5795,13 +5909,13 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "NotTildeFullEqual",
     // MathML: approximately but not actually equal to
-    trigger: ["\\ncong"],
+    latexTrigger: ["\\ncong"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
-    trigger: [":", "="],
+    latexTrigger: [":", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260,
@@ -5809,7 +5923,7 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "Assign",
-    trigger: ["\\coloneq"],
+    latexTrigger: ["\\coloneq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
@@ -5817,7 +5931,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "Approx",
     // Note: Mathematica TildeTilde
-    trigger: ["\\approx"],
+    latexTrigger: ["\\approx"],
     kind: "infix",
     associativity: "right",
     precedence: 247
@@ -5825,7 +5939,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "NotApprox",
     // Note: Mathematica TildeTilde
-    trigger: ["\\not", "\\approx"],
+    latexTrigger: ["\\not", "\\approx"],
     kind: "infix",
     associativity: "right",
     precedence: 247
@@ -5833,7 +5947,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "ApproxEqual",
     // Note: Mathematica TildeEqual, MathML: `asymptotically equal to`
-    trigger: ["\\approxeq"],
+    latexTrigger: ["\\approxeq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
@@ -5841,7 +5955,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "NotApproxEqual",
     // Note: Mathematica NotTildeEqual
-    trigger: ["\\not", "\\approxeq"],
+    latexTrigger: ["\\not", "\\approxeq"],
     kind: "infix",
     // Note: no LaTeX symbol for char U+2249
     associativity: "right",
@@ -5849,14 +5963,14 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "NotEqual",
-    trigger: ["\\ne"],
+    latexTrigger: ["\\ne"],
     kind: "infix",
     associativity: "right",
     precedence: 255
   },
   {
     name: "Unequal",
-    trigger: ["!", "="],
+    latexTrigger: ["!", "="],
     kind: "infix",
     associativity: "right",
     precedence: 260
@@ -5864,14 +5978,14 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "GreaterEqual",
-    trigger: ["\\ge"],
+    latexTrigger: ["\\ge"],
     kind: "infix",
     associativity: "right",
     precedence: 242
     // Note: different precendence than `>=` as per MathML
   },
   {
-    trigger: ["\\geq"],
+    latexTrigger: ["\\geq"],
     kind: "infix",
     associativity: "right",
     precedence: 242,
@@ -5879,14 +5993,14 @@ var DEFINITIONS_INEQUALITIES = [
     parse: "GreaterEqual"
   },
   {
-    trigger: [">", "="],
+    latexTrigger: [">", "="],
     kind: "infix",
     associativity: "right",
     precedence: 243,
     parse: "GreaterEqual"
   },
   {
-    trigger: ["\\geqslant"],
+    latexTrigger: ["\\geqslant"],
     kind: "infix",
     associativity: "right",
     precedence: 265,
@@ -5895,20 +6009,20 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "GreaterNotEqual",
-    trigger: ["\\gneqq"],
+    latexTrigger: ["\\gneqq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "NotGreaterNotEqual",
-    trigger: ["\\ngeqq"],
+    latexTrigger: ["\\ngeqq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
-    trigger: [">"],
+    latexTrigger: [">"],
     kind: "infix",
     associativity: "right",
     precedence: 245,
@@ -5916,20 +6030,20 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "Greater",
-    trigger: ["\\gt"],
+    latexTrigger: ["\\gt"],
     kind: "infix",
     associativity: "right",
     precedence: 245
   },
   {
     name: "NotGreater",
-    trigger: ["\\ngtr"],
+    latexTrigger: ["\\ngtr"],
     kind: "infix",
     associativity: "right",
     precedence: 244
   },
   {
-    trigger: ["\\not", ">"],
+    latexTrigger: ["\\not", ">"],
     kind: "infix",
     associativity: "right",
     precedence: 244,
@@ -5937,7 +6051,7 @@ var DEFINITIONS_INEQUALITIES = [
   },
   {
     name: "RingEqual",
-    trigger: ["\\circeq"],
+    latexTrigger: ["\\circeq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
@@ -5945,7 +6059,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "TriangleEqual",
     // MathML: delta equal to
-    trigger: ["\\triangleq"],
+    latexTrigger: ["\\triangleq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
@@ -5953,7 +6067,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "DotEqual",
     // MathML: approaches the limit
-    trigger: ["\\doteq"],
+    latexTrigger: ["\\doteq"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -5961,7 +6075,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "DotEqualDot",
     // MathML: Geometrically equal
-    trigger: ["\\doteqdot"],
+    latexTrigger: ["\\doteqdot"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -5969,7 +6083,7 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "FallingDotEqual",
     // MathML: approximately equal to or the image of
-    trigger: ["\\fallingdotseq"],
+    latexTrigger: ["\\fallingdotseq"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -5977,92 +6091,77 @@ var DEFINITIONS_INEQUALITIES = [
   {
     name: "RisingDotEqual",
     // MathML: image of or approximately equal to
-    trigger: ["\\fallingdotseq"],
+    latexTrigger: ["\\fallingdotseq"],
     kind: "infix",
     associativity: "right",
     precedence: 265
   },
   {
     name: "QuestionEqual",
-    trigger: ["\\questeq"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 260
-  },
-  {
-    name: "Equivalent",
-    // MathML: identical to, Mathematica: Congruent
-    trigger: ["\\equiv"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 260
-  },
-  {
-    trigger: ["\\iff"],
+    latexTrigger: ["\\questeq"],
     kind: "infix",
-    parse: "Equivalent",
     associativity: "right",
     precedence: 260
   },
   {
     name: "MuchLess",
-    trigger: ["\\ll"],
+    latexTrigger: ["\\ll"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "MuchGreater",
-    trigger: ["\\gg"],
+    latexTrigger: ["\\gg"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "Precedes",
-    trigger: ["\\prec"],
+    latexTrigger: ["\\prec"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "Succeeds",
-    trigger: ["\\succ"],
+    latexTrigger: ["\\succ"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "PrecedesEqual",
-    trigger: ["\\preccurlyeq"],
+    latexTrigger: ["\\preccurlyeq"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "SucceedsEqual",
-    trigger: ["\\curlyeqprec"],
+    latexTrigger: ["\\curlyeqprec"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "NotPrecedes",
-    trigger: ["\\nprec"],
+    latexTrigger: ["\\nprec"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "NotSucceeds",
-    trigger: ["\\nsucc"],
+    latexTrigger: ["\\nsucc"],
     kind: "infix",
     associativity: "right",
     precedence: 260
   },
   {
     name: "Between",
-    trigger: ["\\between"],
+    latexTrigger: ["\\between"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -6074,18 +6173,187 @@ var DEFINITIONS_LOGIC = [
   // Constants
   {
     name: "True",
-    trigger: ["\\mathrm", "<{>", "T", "r", "u", "e", "<}>"],
-    serialize: "\\mathrm{True}"
+    kind: "symbol",
+    latexTrigger: ["\\top"]
+    // ⊤ U+22A4
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathrm{True}",
+    parse: "True"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\operator{True}",
+    parse: "True"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathsf{T}",
+    parse: "True"
   },
   {
     name: "False",
-    trigger: ["\\mathrm", "<{>", "F", "a", "l", "s", "e", "<}>"],
-    serialize: "\\mathrm{False}"
+    kind: "symbol",
+    latexTrigger: ["\\bot"]
+    // ⊥ U+22A5
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\operator{False}",
+    parse: "True"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathsf{F}",
+    parse: "True"
   },
   {
     name: "Maybe",
-    trigger: ["\\mathrm", "<{>", "M", "a", "y", "b", "e", "<}>"],
-    serialize: "\\mathrm{Maybe}"
+    kind: "symbol",
+    latexTrigger: "\\operatorname{Maybe}",
+    serialize: "\\operatorname{Maybe}"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathrm{Maybe}",
+    parse: "Maybe"
+  },
+  // Operators
+  {
+    name: "And",
+    kind: "infix",
+    latexTrigger: ["\\land"],
+    precedence: 317
+    // serialize: '\\land',
+  },
+  { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 317 },
+  { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 317 },
+  {
+    kind: "infix",
+    latexTrigger: "\\operatorname{and}",
+    parse: "And",
+    precedence: 317
+  },
+  {
+    name: "Or",
+    kind: "infix",
+    latexTrigger: ["\\lor"],
+    precedence: 310
+  },
+  { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 310 },
+  { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 310 },
+  {
+    kind: "infix",
+    latexTrigger: "\\operatorname{or}",
+    parse: "And",
+    precedence: 310
+  },
+  {
+    name: "Xor",
+    kind: "infix",
+    latexTrigger: ["\\veebar"],
+    precedence: 315
+  },
+  // Possible alt: \oplus ⊕ U+2295
+  {
+    name: "Not",
+    kind: "prefix",
+    latexTrigger: ["\\lnot"],
+    precedence: 880
+  },
+  {
+    name: "Nand",
+    kind: "infix",
+    latexTrigger: ["\\barwedge"],
+    precedence: 315
+    // serialize: '\\mid',
+  },
+  {
+    name: "Nor",
+    kind: "infix",
+    latexTrigger: ["\u22BD"],
+    // bar vee
+    precedence: 315
+    // serialize: '\\downarrow',
+  },
+  // Functions
+  {
+    kind: "function",
+    identifierTrigger: "and",
+    parse: "And"
+  },
+  {
+    kind: "function",
+    identifierTrigger: "or",
+    parse: "Or"
+  },
+  {
+    kind: "function",
+    identifierTrigger: "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"
+  },
+  {
+    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: ["\\equiv"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: "Equivalent"
+  },
+  {
+    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"
   }
 ];
 
@@ -6099,72 +6367,73 @@ function parseSingleArg(cmd) {
 var DEFINITIONS_OTHERS = [
   {
     name: "Overscript",
-    trigger: ["\\overset"],
+    latexTrigger: ["\\overset"],
     kind: "infix",
     precedence: 700
     // @todo: not in MathML
   },
   {
     name: "Underscript",
-    trigger: ["\\underset"],
+    latexTrigger: ["\\underset"],
     kind: "infix",
     precedence: 700
     // @todo: not in MathML
   },
   {
     name: "Increment",
-    trigger: ["+", "+"],
+    latexTrigger: ["+", "+"],
     kind: "postfix",
     precedence: 880
   },
   {
     name: "Decrement",
-    trigger: ["-", "-"],
+    latexTrigger: ["-", "-"],
     kind: "postfix",
     precedence: 880
   },
   {
     name: "PreIncrement",
-    trigger: ["+", "+"],
+    latexTrigger: ["+", "+"],
     kind: "prefix",
     precedence: 880
   },
   {
     name: "PreDecrement",
-    trigger: ["-", "-"],
+    latexTrigger: ["-", "-"],
     kind: "prefix",
     precedence: 880
   },
   {
     name: "Ring",
     // Aka 'Composition', i.e. function composition
-    trigger: ["\\circ"],
+    latexTrigger: ["\\circ"],
     kind: "infix",
     precedence: 265
+    // @todo: MathML is 950
     // @todo: check lhs and rhs are functions
   },
   {
     name: "Transpose",
-    trigger: ["^", "T"],
+    latexTrigger: ["^", "T"],
     kind: "postfix"
     // @todo: if lhs is a list/tensor
   },
   {
     // @todo: if lhs is a list/tensor
     name: "ConjugateTranspose",
-    trigger: ["^", "H"],
+    latexTrigger: ["^", "H"],
     kind: "postfix"
   },
   {
     name: "StringJoin",
     // @todo From Mathematica...?
-    trigger: ["\\lt", "\\gt"],
+    latexTrigger: ["\\lt", "\\gt"],
     kind: "infix",
     precedence: 780
   },
   {
     name: "Starstar",
-    trigger: ["\\star", "\\star"],
+    latexTrigger: ["\\star", "\\star"],
     kind: "infix",
     precedence: 780
   },
@@ -6174,7 +6443,7 @@ var DEFINITIONS_OTHERS = [
     // For the Leibniz notation see 'Divide' that handles `∂f/∂x`
     name: "PartialDerivative",
     // PartialDerivative(expr, {lists of vars}, degree)
-    trigger: ["\\partial"],
+    latexTrigger: ["\\partial"],
     kind: "prefix",
     parse: (parser) => {
       let done = false;
@@ -6197,8 +6466,8 @@ var DEFINITIONS_OTHERS = [
         return null;
       let rhs = parser.parseGroup() ?? "Nothing";
       if (rhs !== "Nothing" && !isEmptySequence(rhs)) {
-        const arg = parser.parseArguments() ?? ["Nothing"];
-        rhs = [rhs, ...arg];
+        const args = parser.parseArguments() ?? ["Nothing"];
+        rhs = [rhs, ...args];
       }
       return ["PartialDerivative", rhs, sub2, sup];
     },
@@ -6224,128 +6493,128 @@ var DEFINITIONS_OTHERS = [
   },
   {
     name: "OverBar",
-    trigger: ["\\overline"],
+    latexTrigger: ["\\overline"],
     parse: parseSingleArg("OverBar")
   },
   {
     name: "UnderBar",
-    trigger: ["\\underline"],
+    latexTrigger: ["\\underline"],
     parse: parseSingleArg("UnderBar")
   },
   {
     name: "OverVector",
-    trigger: ["\\vec"],
+    latexTrigger: ["\\vec"],
     parse: parseSingleArg("OverVector")
   },
   {
     name: "OverTilde",
-    trigger: ["\\tilde"],
+    latexTrigger: ["\\tilde"],
     parse: parseSingleArg("OverTilde")
   },
   {
     name: "OverHat",
-    trigger: ["\\hat"],
+    latexTrigger: ["\\hat"],
     parse: parseSingleArg("OverHat")
   },
   {
     name: "OverRightArrow",
-    trigger: ["\\overrightarrow"],
+    latexTrigger: ["\\overrightarrow"],
     parse: parseSingleArg("OverRightArrow")
   },
   {
     name: "OverLeftArrow",
-    trigger: ["\\overleftarrow"],
+    latexTrigger: ["\\overleftarrow"],
     parse: parseSingleArg("OverLeftArrow")
   },
   {
     name: "OverRightDoubleArrow",
-    trigger: ["\\Overrightarrow"],
+    latexTrigger: ["\\Overrightarrow"],
     parse: parseSingleArg("OverRightDoubleArrow")
   },
   {
     name: "OverLeftHarpoon",
-    trigger: ["\\overleftharpoon"],
+    latexTrigger: ["\\overleftharpoon"],
     parse: parseSingleArg("OverLeftHarpoon")
   },
   {
     name: "OverRightHarpoon",
-    trigger: ["\\overrightharpoon"],
+    latexTrigger: ["\\overrightharpoon"],
     parse: parseSingleArg("OverRightHarpoon")
   },
   {
     name: "OverLeftRightArrow",
-    trigger: ["\\overleftrightarrow"],
+    latexTrigger: ["\\overleftrightarrow"],
     parse: parseSingleArg("OverLeftRightArrow")
   },
   {
     name: "OverBrace",
-    trigger: ["\\overbrace"],
+    latexTrigger: ["\\overbrace"],
     parse: parseSingleArg("OverBrace")
   },
   {
     name: "OverLineSegment",
-    trigger: ["\\overlinesegment"],
+    latexTrigger: ["\\overlinesegment"],
     parse: parseSingleArg("OverLineSegment")
   },
   {
     name: "OverGroup",
-    trigger: ["\\overgroup"],
+    latexTrigger: ["\\overgroup"],
     parse: parseSingleArg("OverGroup")
   },
   {
-    trigger: ["\\displaystyle"],
+    latexTrigger: ["\\displaystyle"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\textstyle"],
+    latexTrigger: ["\\textstyle"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\scriptstyle"],
+    latexTrigger: ["\\scriptstyle"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\scriptscriptstyle"],
+    latexTrigger: ["\\scriptscriptstyle"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\tiny"],
+    latexTrigger: ["\\tiny"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\scriptsize"],
+    latexTrigger: ["\\scriptsize"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\footnotesize"],
+    latexTrigger: ["\\footnotesize"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\small"],
+    latexTrigger: ["\\small"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\normalsize"],
+    latexTrigger: ["\\normalsize"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\large"],
+    latexTrigger: ["\\large"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\Large"],
+    latexTrigger: ["\\Large"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\LARGE"],
+    latexTrigger: ["\\LARGE"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\huge"],
+    latexTrigger: ["\\huge"],
     parse: () => ["Sequence"]
   },
   {
-    trigger: ["\\Huge"],
+    latexTrigger: ["\\Huge"],
     parse: () => ["Sequence"]
   },
   {
@@ -6387,39 +6656,39 @@ var DEFINITIONS_OTHERS = [
     }
   },
   {
-    trigger: ["\\!"],
+    latexTrigger: ["\\!"],
     parse: () => ["HorizontalSpacing", -3]
   },
   {
-    trigger: ["\\ "],
+    latexTrigger: ["\\ "],
     parse: () => ["HorizontalSpacing", 6]
   },
   {
-    trigger: ["\\:"],
+    latexTrigger: ["\\:"],
     parse: () => ["HorizontalSpacing", 4]
   },
   {
-    trigger: ["\\enskip"],
+    latexTrigger: ["\\enskip"],
     parse: () => ["HorizontalSpacing", 9]
   },
   {
-    trigger: ["\\quad"],
+    latexTrigger: ["\\quad"],
     parse: () => ["HorizontalSpacing", 18]
   },
   {
-    trigger: ["\\qquad"],
+    latexTrigger: ["\\qquad"],
     parse: () => ["HorizontalSpacing", 36]
   },
   {
-    trigger: ["\\,"],
+    latexTrigger: ["\\,"],
     parse: () => ["HorizontalSpacing", 3]
   },
   {
-    trigger: ["\\;"],
+    latexTrigger: ["\\;"],
     parse: () => ["HorizontalSpacing", 5]
   },
   {
-    trigger: ["\\enspace"],
+    latexTrigger: ["\\enspace"],
     parse: () => ["HorizontalSpacing", 9]
   },
   {
@@ -6519,146 +6788,146 @@ function parseTrig(op3) {
 var DEFINITIONS_TRIGONOMETRY = [
   {
     name: "Arcsin",
-    trigger: ["\\arcsin"],
+    latexTrigger: ["\\arcsin"],
     parse: parseTrig("Arcsin")
   },
   {
     name: "Arccos",
-    trigger: ["\\arccos"],
+    latexTrigger: ["\\arccos"],
     parse: parseTrig("Arccos")
   },
   {
     name: "Arctan",
-    trigger: ["\\arctan"],
+    latexTrigger: ["\\arctan"],
     parse: parseTrig("Arctan")
   },
   {
-    trigger: ["\\arctg"],
+    latexTrigger: ["\\arctg"],
     parse: parseTrig("Arctan")
   },
   {
     name: "Arccot",
-    trigger: ["\\arcctg"],
+    latexTrigger: ["\\arcctg"],
     parse: parseTrig("Arccot")
   },
   {
     name: "Arcsec",
-    trigger: "arcsec",
+    latexTrigger: "arcsec",
     parse: parseTrig("Arcsec")
   },
   {
     name: "Arccsc",
-    trigger: ["\\arccsc"],
+    latexTrigger: ["\\arccsc"],
     parse: parseTrig("Arccsc")
   },
   {
     name: "Arsinh",
-    trigger: ["\\arsinh"],
+    latexTrigger: ["\\arsinh"],
     parse: parseTrig("Arsinh")
   },
   {
     name: "Arcosh",
-    trigger: ["\\arcosh"],
+    latexTrigger: ["\\arcosh"],
     parse: parseTrig("Arcosh")
   },
   {
     name: "Artanh",
-    trigger: ["\\artanh"],
+    latexTrigger: ["\\artanh"],
     parse: parseTrig("Artanh")
   },
   {
     name: "Arsech",
-    trigger: ["\\arsech"],
+    latexTrigger: ["\\arsech"],
     parse: parseTrig("Arsech")
   },
   {
     name: "Arcsch",
-    trigger: ["\\arcsch"],
+    latexTrigger: ["\\arcsch"],
     parse: parseTrig("Arcsch")
   },
   {
     // Rusian hyperbolic cosine
-    trigger: ["\\ch"],
+    latexTrigger: ["\\ch"],
     parse: parseTrig("Cosh")
   },
   {
     name: "Cosec",
-    trigger: ["\\cosec"],
+    latexTrigger: ["\\cosec"],
     parse: parseTrig("Cosec")
   },
   {
     name: "Cosh",
-    trigger: ["\\cosh"],
+    latexTrigger: ["\\cosh"],
     parse: parseTrig("Cosh")
   },
   {
     name: "Cot",
-    trigger: ["\\cot"],
+    latexTrigger: ["\\cot"],
     parse: parseTrig("Cot")
   },
   {
-    trigger: ["\\cotg"],
+    latexTrigger: ["\\cotg"],
     parse: parseTrig("Cot")
   },
   {
     name: "Coth",
-    trigger: ["\\coth"],
+    latexTrigger: ["\\coth"],
     parse: parseTrig("Coth")
   },
   {
     name: "Csc",
-    trigger: ["\\csc"],
+    latexTrigger: ["\\csc"],
     parse: parseTrig("Csc")
   },
   {
     // Rusian cotangent
-    trigger: ["\\ctg"],
+    latexTrigger: ["\\ctg"],
     parse: parseTrig("Cot")
   },
   {
-    trigger: ["\\cth"],
+    latexTrigger: ["\\cth"],
     parse: parseTrig("Cotanh")
   },
   {
     name: "Sec",
-    trigger: ["\\sec"],
+    latexTrigger: ["\\sec"],
     parse: parseTrig("Sec")
   },
   {
     name: "Sinh",
-    trigger: ["\\sinh"],
+    latexTrigger: ["\\sinh"],
     parse: parseTrig("Sinh")
   },
   {
-    trigger: ["\\sh"],
+    latexTrigger: ["\\sh"],
     parse: parseTrig("Sinh")
   },
   {
     name: "Tan",
-    trigger: ["\\tan"],
+    latexTrigger: ["\\tan"],
     parse: parseTrig("Tan")
   },
   {
-    trigger: ["\\tg"],
+    latexTrigger: ["\\tg"],
     parse: parseTrig("Tan")
   },
   {
     name: "Tanh",
-    trigger: ["\\tanh"],
+    latexTrigger: ["\\tanh"],
     parse: parseTrig("Tanh")
   },
   {
-    trigger: ["\\th"],
+    latexTrigger: ["\\th"],
     parse: parseTrig("Tanh")
   },
   {
     name: "Cos",
-    trigger: ["\\cos"],
+    latexTrigger: ["\\cos"],
     parse: parseTrig("Cos")
   },
   {
     name: "Sin",
-    trigger: ["\\sin"],
+    latexTrigger: ["\\sin"],
     parse: parseTrig("Sin")
   }
 ];
@@ -6666,77 +6935,77 @@ var DEFINITIONS_TRIGONOMETRY = [
 // src/compute-engine/latex-syntax/dictionary/definitions-sets.ts
 var DEFINITIONS_SETS = [
   // Constants
-  { name: "AlgebraicNumber", trigger: "\\bar\\Q" },
-  { name: "ComplexNumber", trigger: ["\\C"] },
-  { trigger: "\\mathbb{C}", parse: "ComplexNumber" },
-  { name: "ImaginaryNumber", trigger: ["\\imaginaryI\\R"] },
-  { name: "ExtendedComplexNumber", trigger: ["\\bar\\C"] },
-  { name: "EmptySet", trigger: ["\\emptyset"] },
-  { trigger: ["\\varnothing"], parse: "EmptySet" },
+  { name: "AlgebraicNumber", latexTrigger: "\\bar\\Q" },
+  { name: "ComplexNumber", latexTrigger: ["\\C"] },
+  { latexTrigger: "\\mathbb{C}", parse: "ComplexNumber" },
+  { name: "ImaginaryNumber", latexTrigger: ["\\imaginaryI", "\\R"] },
+  { name: "ExtendedComplexNumber", latexTrigger: ["\\bar", "\\C"] },
+  { name: "EmptySet", latexTrigger: ["\\emptyset"] },
+  { latexTrigger: ["\\varnothing"], parse: "EmptySet" },
   // Parsing only
-  { name: "Integer", trigger: ["\\Z"] },
-  { trigger: "\\mathbb{Z}", parse: "Integer" },
-  { name: "RationalNumber", trigger: ["\\Q"] },
-  { name: "RealNumber", trigger: ["\\R"] },
-  { trigger: "\\mathbb{R}", parse: "RealNumber" },
-  { name: "ExtendedRealNumber", trigger: ["\\bar\\R"] },
-  { name: "TranscendentalNumber", trigger: "\\R-\\bar\\Q" },
-  { trigger: "\\R\\backslash\\bar\\Q", parse: "TranscendentalNumber" },
+  { name: "Integer", latexTrigger: ["\\Z"] },
+  { latexTrigger: "\\mathbb{Z}", parse: "Integer" },
+  { name: "RationalNumber", latexTrigger: ["\\Q"] },
+  { name: "RealNumber", latexTrigger: ["\\R"] },
+  { latexTrigger: "\\mathbb{R}", parse: "RealNumber" },
+  { name: "ExtendedRealNumber", latexTrigger: ["\\bar", "\\R"] },
+  { name: "TranscendentalNumber", latexTrigger: "\\R-\\bar\\Q" },
+  { latexTrigger: "\\R\\backslash\\bar\\Q", parse: "TranscendentalNumber" },
   // Real numbers < 0
-  { name: "NegativeNumber", trigger: "\\R^-" },
-  { trigger: "\\R^{-}", parse: "NegativeNumber" },
-  { trigger: "\\R_-", parse: "NegativeNumber" },
-  { trigger: "\\R_{-}", parse: "NegativeNumber" },
-  { trigger: "\\R^{\\lt}", parse: "NegativeNumber" },
+  { name: "NegativeNumber", latexTrigger: "\\R^-" },
+  { latexTrigger: "\\R^{-}", parse: "NegativeNumber" },
+  { latexTrigger: "\\R_-", parse: "NegativeNumber" },
+  { latexTrigger: "\\R_{-}", parse: "NegativeNumber" },
+  { latexTrigger: "\\R^{\\lt}", parse: "NegativeNumber" },
   // Real numbers > 0
-  { name: "PositiveNumber", trigger: "\\R^+" },
-  { trigger: "\\R^{+}", parse: "PositiveNumber" },
-  { trigger: "\\R_+", parse: "PositiveNumber" },
-  { trigger: "\\R_{+}", parse: "PositiveNumber" },
-  { trigger: "\\R^{\\gt}", parse: "PositiveNumber" },
+  { name: "PositiveNumber", latexTrigger: "\\R^+" },
+  { latexTrigger: "\\R^{+}", parse: "PositiveNumber" },
+  { latexTrigger: "\\R_+", parse: "PositiveNumber" },
+  { latexTrigger: "\\R_{+}", parse: "PositiveNumber" },
+  { latexTrigger: "\\R^{\\gt}", parse: "PositiveNumber" },
   // Real numbers <= 0
-  { name: "NonPositiveNumber", trigger: "\\R^{0-}" },
-  { trigger: "\\R^{-0}", parse: "NonPositiveNumber" },
-  { trigger: "\\R^{\\leq}", parse: "NonPositiveNumber" },
+  { name: "NonPositiveNumber", latexTrigger: "\\R^{0-}" },
+  { latexTrigger: "\\R^{-0}", parse: "NonPositiveNumber" },
+  { latexTrigger: "\\R^{\\leq}", parse: "NonPositiveNumber" },
   // Integers < 0
-  { name: "NegativeInteger", trigger: "\\Z^-" },
-  { trigger: "\\Z^-", parse: "NegativeInteger" },
-  { trigger: "\\Z^{-}", parse: "NegativeInteger" },
-  { trigger: "\\Z_-", parse: "NegativeInteger" },
-  { trigger: "\\Z_{-}", parse: "NegativeInteger" },
-  { trigger: "\\Z^{\\lt}", parse: "NegativeInteger" },
+  { name: "NegativeInteger", latexTrigger: "\\Z^-" },
+  { latexTrigger: "\\Z^-", parse: "NegativeInteger" },
+  { latexTrigger: "\\Z^{-}", parse: "NegativeInteger" },
+  { latexTrigger: "\\Z_-", parse: "NegativeInteger" },
+  { latexTrigger: "\\Z_{-}", parse: "NegativeInteger" },
+  { latexTrigger: "\\Z^{\\lt}", parse: "NegativeInteger" },
   // Integers >  0
-  { name: "PositiveInteger", trigger: "\\Z^+" },
-  { trigger: "\\Z^{+}", parse: "PositiveInteger" },
-  { trigger: "\\Z_+", parse: "PositiveInteger" },
-  { trigger: "\\Z_{+}", parse: "PositiveInteger" },
-  { trigger: "\\Z^{\\gt}", parse: "PositiveInteger" },
-  { trigger: "\\Z^{\\gt0}", parse: "PositiveInteger" },
-  { trigger: "\\N^+", parse: "PositiveInteger" },
-  { trigger: "\\N^{+}", parse: "PositiveInteger" },
-  { trigger: "\\N^*", parse: "PositiveInteger" },
-  { trigger: "\\N^{*}", parse: "PositiveInteger" },
-  { trigger: "\\N^\\star", parse: "PositiveInteger" },
-  { trigger: "\\N^{\\star}", parse: "PositiveInteger" },
-  { trigger: "\\N_1", parse: "PositiveInteger" },
-  { trigger: "\\N_{1}", parse: "PositiveInteger" },
+  { name: "PositiveInteger", latexTrigger: "\\Z^+" },
+  { latexTrigger: "\\Z^{+}", parse: "PositiveInteger" },
+  { latexTrigger: "\\Z_+", parse: "PositiveInteger" },
+  { latexTrigger: "\\Z_{+}", parse: "PositiveInteger" },
+  { latexTrigger: "\\Z^{\\gt}", parse: "PositiveInteger" },
+  { latexTrigger: "\\Z^{\\gt0}", parse: "PositiveInteger" },
+  { latexTrigger: "\\N^+", parse: "PositiveInteger" },
+  { latexTrigger: "\\N^{+}", parse: "PositiveInteger" },
+  { latexTrigger: "\\N^*", parse: "PositiveInteger" },
+  { latexTrigger: "\\N^{*}", parse: "PositiveInteger" },
+  { latexTrigger: "\\N^\\star", parse: "PositiveInteger" },
+  { latexTrigger: "\\N^{\\star}", parse: "PositiveInteger" },
+  { latexTrigger: "\\N_1", parse: "PositiveInteger" },
+  { latexTrigger: "\\N_{1}", parse: "PositiveInteger" },
   // https://mathvault.ca/hub/higher-math/math-symbols/algebra-symbols/
   // Integers >=  0
-  { name: "NonNegativeInteger", trigger: ["\\N"] },
-  { trigger: "\\Z^{+0}", parse: "NonNegativeInteger" },
-  { trigger: "\\Z^{\\geq}", parse: "NonNegativeInteger" },
-  { trigger: "\\Z^{\\geq0}", parse: "NonNegativeInteger" },
-  { trigger: "\\Z^{0+}", parse: "NonNegativeInteger" },
-  { trigger: "\\mathbb{N}", parse: "NonNegativeInteger" },
-  { trigger: "\\N_0", parse: "NonNegativeInteger" },
-  { trigger: "\\N_{0}", parse: "NonNegativeInteger" },
+  { name: "NonNegativeInteger", latexTrigger: ["\\N"] },
+  { latexTrigger: "\\Z^{+0}", parse: "NonNegativeInteger" },
+  { latexTrigger: "\\Z^{\\geq}", parse: "NonNegativeInteger" },
+  { latexTrigger: "\\Z^{\\geq0}", parse: "NonNegativeInteger" },
+  { latexTrigger: "\\Z^{0+}", parse: "NonNegativeInteger" },
+  { latexTrigger: "\\mathbb{N}", parse: "NonNegativeInteger" },
+  { latexTrigger: "\\N_0", parse: "NonNegativeInteger" },
+  { latexTrigger: "\\N_{0}", parse: "NonNegativeInteger" },
   //
   // Set Expressions
   //
   // @todo: could also have a `CartesianPower` function with a number `rhs`
   {
     name: "CartesianProduct",
-    trigger: ["\\times"],
+    latexTrigger: ["\\times"],
     kind: "infix",
     associativity: "right",
     // Caution: cartesian product is not associative
@@ -6758,7 +7027,7 @@ var DEFINITIONS_SETS = [
     }
   },
   {
-    trigger: ["^", "\\complement"],
+    latexTrigger: ["^", "\\complement"],
     kind: "postfix",
     parse: (_parser, lhs) => {
       return ["Complement", lhs];
@@ -6768,14 +7037,14 @@ var DEFINITIONS_SETS = [
   },
   {
     name: "Complement",
-    trigger: ["^", "<{>", "\\complement", "<}>"],
+    latexTrigger: ["^", "<{>", "\\complement", "<}>"],
     kind: "postfix"
     // precedence: 240,
     // @todo: serialize for the multiple argument case
   },
   {
     name: "Intersection",
-    trigger: ["\\cap"],
+    latexTrigger: ["\\cap"],
     kind: "infix",
     precedence: 350
   },
@@ -6791,7 +7060,7 @@ var DEFINITIONS_SETS = [
   },
   {
     name: "Union",
-    trigger: ["\\cup"],
+    latexTrigger: ["\\cup"],
     kind: "infix",
     precedence: 350
   },
@@ -6810,13 +7079,13 @@ var DEFINITIONS_SETS = [
   // },
   {
     name: "SetMinus",
-    trigger: ["\\setminus"],
+    latexTrigger: ["\\setminus"],
     kind: "infix",
     precedence: 650
   },
   {
     name: "SymmetricDifference",
-    trigger: ["\\triangle"],
+    latexTrigger: ["\\triangle"],
     // or \\ominus
     kind: "infix",
     // @todo: parser could check that lhs and rhs are sets
@@ -6824,7 +7093,7 @@ var DEFINITIONS_SETS = [
   },
   // Predicates/Relations
   {
-    trigger: ["\\ni"],
+    latexTrigger: ["\\ni"],
     kind: "infix",
     associativity: "right",
     precedence: 160,
@@ -6836,40 +7105,40 @@ var DEFINITIONS_SETS = [
   },
   {
     name: "Element",
-    trigger: ["\\in"],
+    latexTrigger: ["\\in"],
     kind: "infix",
     precedence: 240
   },
   {
     name: "NotElement",
-    trigger: ["\\notin"],
+    latexTrigger: ["\\notin"],
     kind: "infix",
     precedence: 240
   },
   {
     name: "NotSubset",
-    trigger: ["\\nsubset"],
+    latexTrigger: ["\\nsubset"],
     kind: "infix",
     associativity: "right",
     precedence: 240
   },
   {
     name: "NotSuperset",
-    trigger: ["\\nsupset"],
+    latexTrigger: ["\\nsupset"],
     kind: "infix",
     associativity: "right",
     precedence: 240
   },
   {
     name: "NotSubsetNotEqual",
-    trigger: ["\\nsubseteq"],
+    latexTrigger: ["\\nsubseteq"],
     kind: "infix",
     associativity: "right",
     precedence: 240
   },
   {
     name: "NotSupersetNotEqual",
-    trigger: ["\\nsupseteq"],
+    latexTrigger: ["\\nsupseteq"],
     kind: "infix",
     associativity: "right",
     precedence: 240
@@ -6877,7 +7146,7 @@ var DEFINITIONS_SETS = [
   {
     name: "SquareSubset",
     // MathML: square image of
-    trigger: ["\\sqsubset"],
+    latexTrigger: ["\\sqsubset"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -6885,7 +7154,7 @@ var DEFINITIONS_SETS = [
   {
     name: "SquareSubsetEqual",
     // MathML: square image of or equal to
-    trigger: ["\\sqsubseteq"],
+    latexTrigger: ["\\sqsubseteq"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -6893,7 +7162,7 @@ var DEFINITIONS_SETS = [
   {
     name: "SquareSuperset",
     // MathML: square original of
-    trigger: ["\\sqsupset"],
+    latexTrigger: ["\\sqsupset"],
     kind: "infix",
     associativity: "right",
     precedence: 265
@@ -6901,27 +7170,27 @@ var DEFINITIONS_SETS = [
   {
     name: "SquareSupersetEqual",
     // MathML: square original of or equal
-    trigger: ["\\sqsupseteq"],
+    latexTrigger: ["\\sqsupseteq"],
     kind: "infix",
     associativity: "right",
     precedence: 265
   },
   {
     name: "Subset",
-    trigger: ["\\subset"],
+    latexTrigger: ["\\subset"],
     kind: "infix",
     associativity: "right",
     precedence: 240
   },
   {
-    trigger: ["\\subsetneq"],
+    latexTrigger: ["\\subsetneq"],
     kind: "infix",
     associativity: "right",
     precedence: 240,
     parse: "Subset"
   },
   {
-    trigger: ["\\varsubsetneqq"],
+    latexTrigger: ["\\varsubsetneqq"],
     kind: "infix",
     associativity: "right",
     precedence: 240,
@@ -6929,26 +7198,26 @@ var DEFINITIONS_SETS = [
   },
   {
     name: "SubsetEqual",
-    trigger: ["\\subseteq"],
+    latexTrigger: ["\\subseteq"],
     kind: "infix",
     precedence: 240
   },
   {
     name: "Superset",
-    trigger: ["\\supset"],
+    latexTrigger: ["\\supset"],
     kind: "infix",
     associativity: "right",
     precedence: 240
   },
   {
-    trigger: ["\\supsetneq"],
+    latexTrigger: ["\\supsetneq"],
     kind: "infix",
     associativity: "right",
     precedence: 240,
     parse: "Superset"
   },
   {
-    trigger: ["\\varsupsetneq"],
+    latexTrigger: ["\\varsupsetneq"],
     kind: "infix",
     associativity: "right",
     precedence: 240,
@@ -6956,7 +7225,7 @@ var DEFINITIONS_SETS = [
   },
   {
     name: "SupersetEqual",
-    trigger: ["\\supseteq"],
+    latexTrigger: ["\\supseteq"],
     kind: "infix",
     associativity: "right",
     precedence: 240
@@ -7119,6 +7388,8 @@ function parseIntegralBody(parser, n = 1) {
     condition: () => {
       if (parser.matchAll(["\\mathrm", "<{>", "d", "<}>"]))
         found = true;
+      else if (parser.matchAll(["\\operatorname", "<{>", "d", "<}>"]))
+        found = true;
       return found;
     }
   });
@@ -7236,7 +7507,7 @@ function serializeIntegral(command) {
         command,
         "\\!",
         serializer.serialize(fn),
-        "\\,\\mathrm{d}",
+        "\\,\\operatorname{d}",
         serializer.serialize(index)
       ]);
     }
@@ -7254,7 +7525,7 @@ function serializeIntegral(command) {
       sub2,
       "\\!",
       serializer.serialize(fn),
-      ...index && symbol(index) !== "Nothing" ? ["\\,\\mathrm{d}", serializer.serialize(index)] : []
+      ...index && symbol(index) !== "Nothing" ? ["\\,\\operatorname{d}", serializer.serialize(index)] : []
     ]);
   };
 }
@@ -7262,35 +7533,35 @@ var DEFINITIONS_CALCULUS = [
   {
     kind: "expression",
     name: "Integrate",
-    trigger: ["\\int"],
+    latexTrigger: ["\\int"],
     parse: parseIntegral("Integrate"),
     serialize: serializeIntegral("\\int")
   },
   {
     kind: "expression",
-    trigger: ["\\iint"],
+    latexTrigger: ["\\iint"],
     parse: parseIntegral("Integrate", 2)
   },
   {
     kind: "expression",
-    trigger: ["\\iiint"],
+    latexTrigger: ["\\iiint"],
     parse: parseIntegral("Integrate", 3)
   },
   {
     kind: "expression",
     name: "CircularIntegrate",
-    trigger: ["\\oint"],
+    latexTrigger: ["\\oint"],
     parse: parseIntegral("CircularIntegrate"),
     serialize: serializeIntegral("\\oint")
   },
   {
     kind: "expression",
-    trigger: ["\\oiint"],
+    latexTrigger: ["\\oiint"],
     parse: parseIntegral("CircularIntegrate", 2)
   },
   {
     kind: "expression",
-    trigger: ["\\oiiint"],
+    latexTrigger: ["\\oiiint"],
     parse: parseIntegral("CircularIntegrate", 3)
   }
 ];
@@ -7397,14 +7668,14 @@ var DEFINITIONS_SYMBOLS = [
     return {
       kind: "symbol",
       name: symbol2,
-      trigger: [latex],
+      latexTrigger: [latex],
       parse: symbol2
     };
   }),
   ...SYMBOLS.map(([symbol2, _latex, codepoint]) => {
     return {
       kind: "symbol",
-      trigger: [String.fromCodePoint(codepoint)],
+      latexTrigger: [String.fromCodePoint(codepoint)],
       parse: symbol2
     };
   })
@@ -7427,293 +7698,350 @@ var DEFAULT_DELIMITER = {
   "\\rceil": "\\rceil",
   "\\rfloor": "\\rfloor"
 };
-function triggerLength(trigger) {
-  if (Array.isArray(trigger))
-    return trigger.length;
-  return 1;
-}
 function addEntry(result, entry, onError) {
-  const [trigger, indexedEntry] = makeIndexedEntry(entry, onError);
+  const indexedEntry = makeIndexedEntry(entry, onError);
   if (indexedEntry === null)
     return;
   const kind = "kind" in entry ? entry.kind : "expression";
-  if (trigger && trigger.length === 2 && /[_^]/.test(trigger[0]) && trigger[1] !== "<{>" && kind !== "function" && entry.name) {
+  const latexTrigger = indexedEntry.latexTrigger;
+  if (typeof latexTrigger === "string")
+    result.lookahead = Math.max(result.lookahead, countTokens(latexTrigger));
+  const tokensTrigger = tokenize(latexTrigger ?? "", []);
+  if (latexTrigger?.[1] === "\\prime")
+    debugger;
+  if (tokensTrigger.length === 2 && /[_^]/.test(tokensTrigger[0]) && tokensTrigger[1] !== "<{>" && kind !== "function" && kind !== "environment" && kind !== "matchfix") {
     let parse = entry.parse;
-    if (parse === void 0) {
-      if (kind === "symbol")
-        parse = entry.name;
+    if (!parse && entry.name) {
       if (kind === "postfix" || kind === "prefix")
         parse = (_parser, expr) => [entry.name, expr];
+      else
+        parse = entry.name;
     }
     addEntry(
       result,
       {
         ...entry,
         kind,
-        parse,
         name: void 0,
-        trigger: [trigger[0], "<{>", trigger[1], "<}>"]
+        serialize: void 0,
+        parse,
+        latexTrigger: [tokensTrigger[0], "<{>", tokensTrigger[1], "<}>"]
       },
       onError
     );
   }
+  result.defs.push(indexedEntry);
   if (indexedEntry.name !== void 0) {
-    if (result.name.has(indexedEntry.name)) {
+    if (result.ids.has(indexedEntry.name)) {
       onError({
         severity: "warning",
         message: [
           "invalid-dictionary-entry",
           indexedEntry.name,
-          "Duplicate definition. The name must be unique, but a trigger can be used by multiple definitions."
-        ]
-      });
-    }
-    result.name.set(indexedEntry.name, indexedEntry);
-  }
-  if (indexedEntry.kind === "matchfix") {
-    result.matchfix.push(indexedEntry);
-  } else if (indexedEntry.kind === "environment") {
-    const triggerString = tokensToString(entry.trigger ?? "");
-    if (result.environment.has(triggerString)) {
-      onError({
-        severity: "warning",
-        message: [
-          "invalid-dictionary-entry",
-          triggerString,
-          "Duplicate environment definition"
+          "Duplicate definition. The name (MathJSON identifier) must be unique, but triggers can be shared by multiple definitions."
         ]
       });
     }
-    result.environment.set(triggerString, indexedEntry);
-  } else if (trigger) {
-    console.assert(entry.trigger);
-    const triggerString = tokensToString(entry.trigger ?? "");
-    const n = triggerLength(trigger);
-    result.lookahead = Math.max(result.lookahead, n);
-    if (indexedEntry.kind === "function") {
-      if (!result.function.has(triggerString))
-        result.function.set(triggerString, [indexedEntry]);
-      else
-        result.function.set(triggerString, [
-          ...result.function.get(triggerString),
-          indexedEntry
-        ]);
-    } else {
-      const kind2 = indexedEntry.kind;
-      if (result[kind2][n] === void 0)
-        result[kind2][n] = /* @__PURE__ */ new Map();
-      const list = result[kind2][n];
-      if (list.has(triggerString))
-        list.get(triggerString).push(indexedEntry);
-      else
-        list.set(triggerString, [indexedEntry]);
-    }
+    result.ids.set(indexedEntry.name, indexedEntry);
   }
 }
 function indexLatexDictionary(dic, onError) {
   const result = {
     lookahead: 1,
-    name: /* @__PURE__ */ new Map(),
-    expression: [],
-    symbol: [],
-    infix: [],
-    prefix: [],
-    postfix: [],
-    function: /* @__PURE__ */ new Map(),
-    environment: /* @__PURE__ */ new Map(),
-    matchfix: []
+    ids: /* @__PURE__ */ new Map(),
+    defs: []
   };
   for (const entry of dic)
     addEntry(result, entry, onError);
   return result;
 }
 function makeIndexedEntry(entry, onError) {
-  if (!entryIsValid(entry, onError))
-    return [null, null];
+  if (!isValidEntry(entry, onError))
+    return null;
   const result = {
-    name: entry.name,
     kind: "kind" in entry ? entry.kind : "expression"
   };
+  let tokensTrigger = null;
+  if ("latexTrigger" in entry) {
+    if (typeof entry.latexTrigger === "string")
+      tokensTrigger = tokenize(entry.latexTrigger, []);
+    else
+      tokensTrigger = entry.latexTrigger;
+  }
+  let idTrigger = null;
+  if ("identifierTrigger" in entry) {
+    idTrigger = entry.identifierTrigger;
+  }
+  if (tokensTrigger !== null)
+    result.latexTrigger = tokensToString(tokensTrigger);
+  if (idTrigger !== null)
+    result.identifierTrigger = idTrigger;
+  if (entry.name) {
+    result.name = entry.name;
+    result.serialize = makeSerializeHandler(entry, tokensTrigger, idTrigger);
+  }
   if (result.kind === "matchfix" && isMatchfixEntry(entry)) {
-    result.openDelimiter = entry.openDelimiter;
-    result.closeDelimiter = entry.closeDelimiter;
-    if (typeof entry.serialize === "function")
-      result.serialize = entry.serialize;
-    else {
-      const openDelim = typeof result.openDelimiter === "string" ? DEFAULT_DELIMITER[result.openDelimiter] : tokensToString(result.openDelimiter);
-      const closeDelim = typeof result.closeDelimiter === "string" ? DEFAULT_DELIMITER[result.closeDelimiter] : tokensToString(result.closeDelimiter);
-      result.serialize = (serializer, expr) => joinLatex([openDelim, serializer.serialize(op(expr, 1)), closeDelim]);
-    }
-    if (typeof entry.parse === "function")
-      result.parse = entry.parse;
-    else {
-      console.assert(entry.parse || entry.name);
-      const head2 = entry.parse ?? entry.name;
-      result.parse = (_parser, expr) => [head2, expr];
-    }
-    return [null, result];
-  }
-  if (result.kind === "environment" && isEnvironmentEntry(entry)) {
-    const envName = entry.trigger;
-    result.serialize = entry.serialize ?? ((serializer, expr) => `\\begin{${envName}}${serializer.serialize(
-      op(expr, 1)
-    )}\\end{${envName}}`);
-    result.parse = entry.parse ?? (() => null);
-    return [envName, result];
-  }
-  const trigger = typeof entry.trigger === "string" ? tokenize(entry.trigger, []) : entry.trigger;
-  const triggerString = trigger ? tokensToString(trigger) : "";
-  if (result.kind === "function" && isFunctionEntry(entry)) {
-    result.serialize = entry.serialize;
-    if (triggerString && !entry.serialize) {
-      if (triggerString.startsWith("\\")) {
-        result.serialize = (serializer, expr) => `${triggerString}${serializer.wrapArguments(expr)}`;
-      } else
-        result.serialize = (serializer, expr) => `\\mathrm{${triggerString}}${serializer.wrapArguments(expr)}`;
-    }
-    if (typeof entry.parse === "function")
-      result.parse = entry.parse;
-    else if (typeof entry.parse === "string")
-      result.parse = () => entry.parse;
-    else if (entry.name)
-      result.parse = () => entry.name;
-    return [triggerString, result];
-  }
-  if (result.kind === "expression" && isExpressionEntry(entry)) {
-    result.serialize = entry.serialize ?? triggerString;
-    if (typeof result.serialize === "string") {
-      const serializeExpr = result.serialize;
-      result.serialize = (serializer, expr) => {
-        if (!head(expr))
-          return serializer.serialize(serializeExpr);
-        return `${serializer.serialize(
-          serializeExpr
-        )}${serializer.wrapArguments(expr)}`;
-      };
-    }
-    {
-      if (typeof entry.parse === "function") {
-        result.parse = entry.parse;
-      } else {
-        const parseResult = entry.parse ?? entry.name;
-        result.parse = () => parseResult;
-      }
-    }
-    return [triggerString, result];
+    result.openDelimiter = entry.openTrigger;
+    result.closeDelimiter = entry.closeTrigger;
   }
-  console.assert(
-    typeof entry.trigger !== "string" || entry.parse || trigger.length > 1 || "kind" in entry && entry.kind === "function",
-    `Trigger shortcuts should produce more than one token. Otherwise, not worth using them. (${triggerString})`
-  );
   if (result.kind === "symbol" && isSymbolEntry(entry)) {
     result.precedence = entry.precedence ?? 1e4;
   }
-  if ((result.kind === "infix" || result.kind === "prefix" || result.kind === "postfix") && (isInfixEntry(entry) || isPrefixEntry(entry) || isPostfixEntry(entry))) {
-    if (trigger && (trigger[0] === "^" || trigger[0] === "_")) {
+  if ((result.kind === "prefix" || result.kind === "postfix") && (isPrefixEntry(entry) || isPostfixEntry(entry))) {
+    if (tokensTrigger && (tokensTrigger[0] === "^" || tokensTrigger[0] === "_")) {
       result.precedence = 720;
       console.assert(
         entry.precedence === void 0,
-        "'precedence' not allowed with ^ and _ triggers"
+        "'precedence' is fixed and cannot be modified with ^ and _ triggers"
       );
     } else
       result.precedence = entry.precedence ?? 1e4;
   }
   if (result.kind === "infix" && isInfixEntry(entry)) {
     console.assert(
-      !trigger || trigger[0] !== "^" && trigger[0] !== "_" || !entry.associativity || entry.associativity === "non"
+      !tokensTrigger || tokensTrigger[0] !== "^" && tokensTrigger[0] !== "_" || !entry.associativity || entry.associativity === "non"
     );
     result.associativity = entry.associativity ?? "non";
-    if (typeof entry.parse === "function") {
-      result.parse = entry.parse;
-    } else if (trigger && (trigger[0] === "^" || trigger[0] === "_")) {
-      console.assert(!entry.parse);
-      const name = entry.parse ?? entry.name;
-      result.parse = (_scanner, arg, _terminator) => [
-        name,
+    result.precedence = entry.precedence ?? 1e4;
+  }
+  const parse = makeParseHandler(entry, tokensTrigger, idTrigger);
+  if (parse)
+    result.parse = parse;
+  return result;
+}
+function makeSerializeHandler(entry, latexTrigger, idTrigger) {
+  if (typeof entry.serialize === "function")
+    return entry.serialize;
+  const kind = entry["kind"] ?? "expression";
+  if (kind === "environment") {
+    const envName = entry["identifierTrigger"] ?? entry.name ?? "unknown";
+    return (serializer, expr) => joinLatex([
+      `\\begin{${envName}}`,
+      serializer.serialize(op(expr, 1)),
+      `\\end{${envName}}`
+    ]);
+  }
+  if (isMatchfixEntry(entry)) {
+    const openDelim = typeof entry.openTrigger === "string" ? DEFAULT_DELIMITER[entry.openTrigger] : tokensToString(entry["openDelimiter"]);
+    const closeDelim = typeof entry.closeTrigger === "string" ? DEFAULT_DELIMITER[entry.closeTrigger] : tokensToString(entry["closeDelimiter"]);
+    return (serializer, expr) => joinLatex([openDelim, serializer.serialize(op(expr, 1)), closeDelim]);
+  }
+  let latex = entry.serialize;
+  if (latex === void 0 && latexTrigger)
+    latex = tokensToString(latexTrigger);
+  if (latex) {
+    if (kind === "postfix")
+      return (serializer, expr) => joinLatex([serializer.serialize(op(expr, 1)), latex]);
+    if (kind === "prefix")
+      return (serializer, expr) => joinLatex([latex, serializer.serialize(op(expr, 1))]);
+    if (kind === "infix") {
+      return (serializer, expr) => joinLatex(
+        (ops(expr) ?? []).flatMap(
+          (val, i) => i < nops(expr) - 1 ? [serializer.serialize(val), latex] : [serializer.serialize(val)]
+        )
+      );
+    }
+    return (serializer, expr) => head(expr) ? joinLatex([latex, serializer.wrapArguments(expr)]) : latex;
+  }
+  const id = idTrigger ?? entry.name ?? "unknown";
+  if (kind === "postfix")
+    return (serializer, expr) => joinLatex([
+      serializer.serialize(op(expr, 1)),
+      serializer.serializeSymbol(id)
+    ]);
+  if (kind === "prefix")
+    return (serializer, expr) => joinLatex([
+      serializer.serializeSymbol(id),
+      serializer.serialize(op(expr, 1))
+    ]);
+  if (kind === "infix")
+    return (serializer, expr) => joinLatex([
+      serializer.serialize(op(expr, 1)),
+      serializer.serializeSymbol(id),
+      serializer.serialize(op(expr, 2))
+    ]);
+  return (serializer, expr) => head(expr) ? joinLatex([
+    serializer.serializeSymbol(id),
+    serializer.wrapArguments(expr)
+  ]) : serializer.serializeSymbol(id);
+}
+function makeParseHandler(entry, latexTrigger, idTrigger) {
+  if ("parse" in entry && typeof entry.parse === "function")
+    return entry.parse;
+  const kind = "kind" in entry ? entry.kind : "expression";
+  if (kind === "environment") {
+    const envName = entry.parse ?? idTrigger ?? entry.name;
+    if (envName)
+      return (parser, _until) => {
+        const array = parser.parseTabular();
+        if (array === null)
+          return null;
+        return [envName, ["List", array.map((row) => ["List", ...row])]];
+      };
+  }
+  if (kind === "function") {
+    const fnName = entry.parse ?? idTrigger ?? entry.name;
+    if (fnName)
+      return (parser, until) => {
+        const args = parser.parseArguments("enclosure", until);
+        return args === null ? fnName : [fnName, ...args];
+      };
+  }
+  if (kind === "symbol") {
+    const symName = entry.parse ?? idTrigger ?? entry.name;
+    if (symName)
+      return (_parser, _terminator) => symName;
+  }
+  if (kind === "prefix") {
+    const h = entry.parse ?? idTrigger ?? entry.name;
+    if (h) {
+      const prec = entry["precedence"] ?? 1e4;
+      return (parser, until) => {
+        const rhs = parser.parseExpression({
+          ...until ?? [],
+          minPrec: prec
+        });
+        return rhs === null ? null : [h, rhs];
+      };
+    }
+  }
+  if (kind === "postfix") {
+    const h = entry.parse ?? entry.name;
+    if (h)
+      return (_parser, lhs) => lhs === null ? null : [h, lhs];
+  }
+  if (kind === "infix") {
+    if (/[_^]/.test(latexTrigger?.[0] ?? "")) {
+      const h2 = entry.name ?? entry.parse;
+      return (_parser, arg) => [
+        h2,
         missingIfEmpty(op(arg, 1)),
         missingIfEmpty(op(arg, 2))
       ];
-    } else {
-      const head2 = entry.parse ?? entry.name;
-      const prec = result.precedence;
-      const associativity = result.associativity;
-      result.parse = (scanner, lhs, terminator) => {
-        if (prec < terminator.minPrec)
+    }
+    const h = entry.parse ?? idTrigger ?? entry.name;
+    const prec = entry["precedence"] ?? 1e4;
+    const associativity = entry["associativity"] ?? "non";
+    if (h)
+      return (parser, lhs, until) => {
+        if (lhs === null)
+          return null;
+        if (prec < until.minPrec)
           return null;
         const rhs = missingIfEmpty(
-          scanner.parseExpression({
-            ...terminator,
-            minPrec: prec
-          })
+          parser.parseExpression({ ...until, minPrec: prec })
         );
-        return typeof head2 === "string" ? applyAssociativeOperator(head2, lhs, rhs, associativity) : [head2, lhs, rhs];
+        return typeof h === "string" ? applyAssociativeOperator(h, lhs, rhs, associativity) : [h, lhs, rhs];
       };
-    }
-  } else {
-    if (typeof entry.parse === "function") {
-      result.parse = entry.parse;
-    } else if (entry.parse !== void 0) {
-      console.assert(result.kind === "symbol" || result.kind === "expression");
-      result.parse = () => entry.parse;
-    } else if (entry.parse === void 0 && entry.name !== void 0) {
-      if (result.kind === "postfix") {
-        result.parse = (_parser, lhs) => lhs ? [entry.name, lhs] : null;
-      } else if (result.kind === "prefix") {
-        const prec = result.precedence;
-        console.assert(entry.name);
-        const head2 = entry.name;
-        result.parse = (parser, terminator) => {
-          if (terminator && prec < terminator.minPrec)
-            return null;
-          const rhs = parser.parseExpression({ ...terminator, minPrec: prec });
-          return rhs === null ? null : [head2, rhs];
-        };
-      }
-    }
-  }
-  if (typeof entry.serialize === "function" || typeof entry.serialize === "string") {
-    result.serialize = entry.serialize;
-  } else if (trigger) {
-    if (result.kind === "postfix") {
-      result.serialize = "#1" + triggerString;
-    } else if (result.kind === "prefix") {
-      result.serialize = triggerString + "#1";
-    } else if (result.kind === "infix") {
-      result.serialize = "#1" + triggerString + "#2";
-    } else if (result.kind === "symbol") {
-      result.serialize = triggerString;
-    } else {
-      result.serialize = "";
-    }
   }
-  return [trigger ?? null, result];
+  if (kind === "matchfix") {
+    const h = entry.parse ?? entry.name;
+    if (h)
+      return (_parser, body) => {
+        if (body === null || isEmptySequence(body))
+          return null;
+        return [h, body];
+      };
+  }
+  if (kind === "expression") {
+    const parseResult = entry.parse ?? idTrigger ?? entry.name;
+    if (parseResult)
+      return () => parseResult;
+  }
+  if ("parse" in entry) {
+    const parseResult = entry.parse;
+    return () => parseResult;
+  }
+  return void 0;
 }
-function entryIsValid(entry, onError) {
-  const subject = entry.name ?? entry.trigger ?? entry["openDelimiter"];
+function isValidEntry(entry, onError) {
+  let subject = entry.name ?? entry["latexTrigger"] ?? entry["identifierTrigger"] ?? entry["openDelimiter"];
+  if (!subject) {
+    try {
+      subject = JSON.stringify(entry);
+    } catch (e) {
+      subject = "???";
+    }
+  }
+  if (Array.isArray(subject))
+    subject = tokensToString(subject);
+  if ("kind" in entry && ![
+    "expression",
+    "symbol",
+    "function",
+    "infix",
+    "postfix",
+    "prefix",
+    "matchfix",
+    "environment"
+  ].includes(entry.kind)) {
+    onError({
+      severity: "warning",
+      message: [
+        "invalid-dictionary-entry",
+        subject,
+        `The 'kind' property must be one of 'expression', 'symbol', 'function', 'infix', 'postfix', 'prefix', 'matchfix', 'environment'`
+      ]
+    });
+  }
   if (entry.serialize !== void 0 && !entry.name) {
     onError({
       severity: "warning",
       message: [
         "invalid-dictionary-entry",
         subject,
-        `Unexpected serialize property without a name property`
+        `A 'name' property must be provided if a 'serialize' handler is provided`
       ]
     });
     return false;
   }
+  if ("identifierTrigger" in entry) {
+    if (typeof entry.identifierTrigger !== "string" || !isValidIdentifier(entry.identifierTrigger)) {
+      onError({
+        severity: "warning",
+        message: [
+          "invalid-dictionary-entry",
+          subject,
+          `The 'identifierTrigger' property must be a valid identifier`
+        ]
+      });
+    }
+  }
+  if ("name" in entry) {
+    if (typeof entry.name !== "string") {
+      if (entry.name !== void 0)
+        onError({
+          severity: "warning",
+          message: [
+            "invalid-dictionary-entry",
+            subject,
+            `The 'name' property must be a string`
+          ]
+        });
+    } else if (!isValidIdentifier(entry.name)) {
+      onError({
+        severity: "warning",
+        message: [
+          "invalid-dictionary-entry",
+          entry.name,
+          `The 'name' property must be a valid identifier`
+        ]
+      });
+    }
+  }
   if (isMatchfixEntry(entry)) {
-    if (entry.trigger) {
+    if ("latexTrigger" in entry || "identifierTrigger" in isPrefixEntry) {
       onError({
         severity: "warning",
         message: [
           "invalid-dictionary-entry",
           subject,
-          `Unexpected 'trigger' "${entry.trigger}". 'matchfix' operators use a 'openDelimiter' and 'closeDelimiter' instead of a trigger. `
+          `'matchfix' operators use a 'openDelimiter' and 'closeDelimiter' instead of a 'latexTrigger' or 'identifierTrigger'. `
         ]
       });
       return false;
     }
-    if (!entry.openDelimiter || !entry.closeDelimiter) {
+    if (!entry.openTrigger || !entry.closeTrigger) {
       onError({
         severity: "warning",
         message: [
@@ -7724,7 +8052,7 @@ function entryIsValid(entry, onError) {
       });
       return false;
     }
-    if (typeof entry.openDelimiter !== typeof entry.closeDelimiter) {
+    if (typeof entry.openTrigger !== typeof entry.closeTrigger) {
       onError({
         severity: "warning",
         message: [
@@ -7737,7 +8065,7 @@ function entryIsValid(entry, onError) {
     }
   }
   if (isInfixEntry(entry) || isPostfixEntry(entry) || isPrefixEntry(entry)) {
-    if (Array.isArray(entry.trigger) && (entry.trigger[0] === "_" || entry.trigger[0] === "^") || typeof entry.trigger === "string" && (entry.trigger.startsWith("^") || entry.trigger.startsWith("_"))) {
+    if (Array.isArray(entry.latexTrigger) && (entry.latexTrigger[0] === "_" || entry.latexTrigger[0] === "^") || typeof entry.latexTrigger === "string" && (entry.latexTrigger.startsWith("^") || entry.latexTrigger.startsWith("_"))) {
       if (entry.precedence !== void 0 || entry["associativity"] !== void 0) {
         onError({
           severity: "warning",
@@ -7773,14 +8101,14 @@ function entryIsValid(entry, onError) {
       return false;
     }
   }
-  if (!isMatchfixEntry(entry)) {
-    if (!entry.trigger && !entry.name) {
+  if (!isMatchfixEntry(entry) && !isEnvironmentEntry(entry)) {
+    if (!entry.latexTrigger && !entry.identifierTrigger && !entry.name) {
       onError({
         severity: "warning",
         message: [
           "invalid-dictionary-entry",
           subject,
-          `Expected at least a 'trigger' or a 'name'`
+          `Expected a 'name', a 'latexTrigger' or a 'identifierTrigger'`
         ]
       });
       return false;
@@ -7811,7 +8139,7 @@ var DEFAULT_LATEX_DICTIONARY = {
     {
       name: "mu0",
       kind: "symbol",
-      trigger: "\\mu_0"
+      latexTrigger: "\\mu_0"
     }
   ],
   sets: DEFINITIONS_SETS,
@@ -7821,7 +8149,24 @@ var DEFAULT_LATEX_DICTIONARY = {
 
 // src/compute-engine/latex-syntax/parse-identifier.ts
 var IDENTIFIER_PREFIX = {
-  "\\operatorname": "_operator",
+  // Those are "grouping" prefix that also specify spacing
+  // around the symbol. We ignore the spacing, though.
+  "\\mathord": "",
+  "\\mathop": "",
+  "\\mathbin": "",
+  "\\mathrel": "",
+  "\\mathopen": "",
+  "\\mathclose": "",
+  "\\mathpunct": "",
+  "\\mathinner": "",
+  // This is the preferred way to specify an identifier
+  // it defines both spacing and font. By default, identifiers
+  // are wrapper with `\\operatorname{}`.
+  "\\operatorname": "",
+  // These styling commands are used to change the font of an identifier
+  // They may be problematic, as adjacent identifiers may be merged
+  // into a single identifier when used in editors, such a MathLive.
+  // For example `\mathrm{speed}\mathrm{sound}` can be confused with `\mathrm{speedsound}`
   "\\mathrm": "_upright",
   "\\mathit": "_italic",
   "\\mathbf": "_bold",
@@ -7848,7 +8193,7 @@ var IDENTIFIER_MODIFIER = {
   "\\breve": "_breve",
   "\\check": "_check"
 };
-function matchIdentifierToken(parser, options) {
+function parseIdentifierToken(parser, options) {
   if (parser.atEnd)
     return null;
   const token = parser.peek;
@@ -7886,7 +8231,7 @@ function matchIdentifierToken(parser, options) {
   }
   return parser.matchChar() ?? parser.nextToken();
 }
-function matchIdentifierBody(parser) {
+function parseIdentifierBody(parser) {
   let id = matchPrefixedIdentifier(parser);
   const start = parser.index;
   const prefix = IDENTIFIER_MODIFIER[parser.peek] ?? null;
@@ -7896,7 +8241,7 @@ function matchIdentifierBody(parser) {
       parser.index = start;
       return null;
     }
-    const body = matchIdentifierBody(parser);
+    const body = parseIdentifierBody(parser);
     if (body === null || !parser.match("<}>")) {
       parser.index = start;
       return null;
@@ -7909,7 +8254,7 @@ function matchIdentifierBody(parser) {
       const token = parser.peek;
       if (token === "<}>" || token === "_" || token === "^")
         break;
-      const next = matchIdentifierToken(parser, { toplevel: false });
+      const next = parseIdentifierToken(parser, { toplevel: false });
       if (next === null) {
         parser.index = start;
         return null;
@@ -7938,7 +8283,7 @@ function matchIdentifierBody(parser) {
   while (!parser.atEnd) {
     if (parser.match("_")) {
       const hasBrace = parser.match("<{>");
-      const sub2 = matchIdentifierBody(parser);
+      const sub2 = parseIdentifierBody(parser);
       if (hasBrace && !parser.match("<}>") || sub2 === null) {
         parser.index = start;
         return null;
@@ -7946,7 +8291,7 @@ function matchIdentifierBody(parser) {
       subs2.push(sub2);
     } else if (parser.match("^")) {
       const hasBrace = parser.match("<{>");
-      const sup = matchIdentifierBody(parser);
+      const sup = parseIdentifierBody(parser);
       if (hasBrace && !parser.match("<}>") || sup === null) {
         parser.index = start;
         return null;
@@ -7985,7 +8330,7 @@ function matchPrefixedIdentifier(parser) {
       body = digit;
       parser.nextToken();
     }
-    body += matchIdentifierBody(parser);
+    body += parseIdentifierBody(parser);
     if (body === null || !parser.match("<}>")) {
       parser.index = start;
       return null;
@@ -8009,7 +8354,7 @@ function parseInvalidIdentifier(parser) {
     start
   );
 }
-function matchIdentifier(parser) {
+function parseIdentifier(parser) {
   if (/^[a-zA-Z]$/.test(parser.peek) || /^\p{XIDS}$/u.test(parser.peek))
     return parser.nextToken();
   const start = parser.index;
@@ -8018,19 +8363,14 @@ function matchIdentifier(parser) {
     id = "";
     while (!parser.atEnd && ONLY_EMOJIS.test(id + parser.peek))
       id += parser.nextToken();
+    if (!id)
+      id = null;
   }
+  id ?? (id = parseIdentifierToken(parser, { toplevel: true }));
   if (id) {
     id = id.normalize();
     if (isValidIdentifier(id))
       return id;
-    parser.index = start;
-    return null;
-  }
-  let next = matchIdentifierToken(parser, { toplevel: true });
-  if (next) {
-    next = next.normalize();
-    if (isValidIdentifier(next))
-      return next;
   }
   parser.index = start;
   return null;
@@ -8099,7 +8439,7 @@ var DEFAULT_LATEX_NUMBER_OPTIONS = {
   // with machine numbers, up to 15 assuming 2^53 bits floating points
   positiveInfinity: "\\infty",
   negativeInfinity: "-\\infty",
-  notANumber: "\\mathrm{NaN}",
+  notANumber: "\\operatorname{NaN}",
   decimalMarker: ".",
   // Use `{,}` for comma as a decimal marker
   groupSeparator: "\\,",
@@ -8239,13 +8579,12 @@ var _Parser = class {
    * Note: the `minPrec` condition is not checked. It should be checked separately.
    */
   atTerminator(t) {
-    if (this.atBoundary)
-      return true;
-    if (t?.condition && t.condition(this))
-      return true;
-    return false;
+    return this.atBoundary || ((t?.condition && t.condition(this)) ?? false);
   }
-  /** True if the current token matches any of the boundaries we are waiting for */
+  /**
+   * True if the current token matches any of the boundaries we are
+   * waiting for.
+   */
   get atBoundary() {
     if (this.atEnd)
       return true;
@@ -8307,42 +8646,32 @@ var _Parser = class {
       this._dictionary.lookahead,
       this._tokens.length - this.index
     );
-    if (n < 0)
+    if (n <= 0)
       return [];
-    const result = Array(n + 1);
+    const result = [];
     while (n > 0)
-      result[n] = this.latexAhead(n--);
+      result.push([n, this.latexAhead(n--)]);
     return result;
   }
   peekDefinitions(kind) {
-    let defs;
-    if (kind === "function") {
-      const start = this.index;
-      if (this.match("\\operatorname") || this.match("\\mathrm") || this.match("\\mathit")) {
-        const fn = this.parseStringGroup()?.trim();
-        const n = this.index - start;
-        this.index = start;
-        if (!fn || !this._dictionary.function.has(fn))
-          return null;
-        return this._dictionary.function.get(fn).map((x) => [x, n]);
-      }
-      return null;
-    } else if (kind === "operator") {
-      defs = this.lookAhead().map(
-        (x, n) => this._dictionary.infix[n]?.get(x) ?? this._dictionary.postfix[n]?.get(x) ?? this._dictionary.prefix[n]?.get(x)
-      );
-    } else {
-      defs = this.lookAhead().map((x, n) => this._dictionary[kind][n]?.get(x));
-    }
     const result = [];
-    for (let i = defs.length; i > 0; i--) {
-      if (defs[i] !== void 0) {
-        console.assert(Array.isArray(defs[i]));
-        for (const def of defs[i])
-          result.push([def, i]);
+    const defs = [...this.getDefs(kind)];
+    for (const def of defs)
+      if (def.latexTrigger === "")
+        result.push([def, 0]);
+    for (const [n, tokens] of this.lookAhead()) {
+      for (const def of defs)
+        if (def.latexTrigger === tokens)
+          result.push([def, n]);
+    }
+    for (const def of defs) {
+      if (def.identifierTrigger) {
+        const n = peekComplexId(this, def.identifierTrigger);
+        if (n > 0)
+          result.push([def, n]);
       }
     }
-    return result.length === 0 ? null : result;
+    return result;
   }
   /** Skip strictly `<space>` tokens.
    * To also skip `{}` see `skipSpace()`.
@@ -8456,9 +8785,8 @@ var _Parser = class {
         digits += digit;
         n += 1;
       }
-      if (digits.length === caretCount) {
+      if (digits.length === caretCount)
         return String.fromCodePoint(Number.parseInt(digits, 16));
-      }
     } else if (this.match("\\char")) {
       let codepoint = Math.floor(this.matchLatexNumber() ?? Number.NaN);
       if (!Number.isFinite(codepoint) || codepoint < 0 || codepoint > 1114111) {
@@ -8467,17 +8795,15 @@ var _Parser = class {
       return String.fromCodePoint(codepoint);
     } else if (this.match("\\unicode")) {
       this.skipSpaceTokens();
-      if (this.peek === "<{>") {
-        this.nextToken();
+      if (this.match("<{>")) {
         const codepoint = this.matchLatexNumber();
         if (this.match("<}>") && codepoint !== null && codepoint >= 0 && codepoint <= 1114111) {
           return String.fromCodePoint(codepoint);
         }
       } else {
         const codepoint = this.matchLatexNumber();
-        if (codepoint !== null && codepoint >= 0 && codepoint <= 1114111) {
+        if (codepoint !== null && codepoint >= 0 && codepoint <= 1114111)
           return String.fromCodePoint(codepoint);
-        }
       }
     }
     this.index = index;
@@ -8504,7 +8830,7 @@ var _Parser = class {
   // Some LaTeX commands (but not all) can accept an argument without braces,
   // for example `^` , `\sqrt` or `\frac`.
   // This argument will usually be a single token, but can be a sequence of
-  // tokens (e.g. `\sqrt\frac12` or `\sqrt\mathrm{speed}`).
+  // tokens (e.g. `\sqrt\frac12` or `\sqrt\operatorname{speed}`).
   parseToken() {
     const excluding = [
       ...'!"#$%&(),/;:?@[]\\`|~'.split(""),
@@ -8563,6 +8889,7 @@ var _Parser = class {
         let peek = this.peek;
         while (peek !== "&" && peek !== "\\\\" && peek !== "\\cr" && !this.atBoundary) {
           expr = this.parseExpression({
+            minPrec: 0,
             condition: (p) => {
               const peek2 = p.peek;
               return peek2 === "&" || peek2 === "\\\\" || peek2 === "\\cr";
@@ -8606,7 +8933,7 @@ var _Parser = class {
   }
   /** Parse an environment: `\begin{env}...\end{end}`
    */
-  parseEnvironment() {
+  parseEnvironment(until) {
     const index = this.index;
     if (!this.match("\\begin"))
       return null;
@@ -8614,22 +8941,22 @@ var _Parser = class {
     if (!name)
       return this.error("expected-environment-name", index);
     this.addBoundary(["\\end", "<{>", ...name.split(""), "<}>"]);
-    const def = this._dictionary.environment.get(name);
-    if (!def) {
-      this.parseTabular();
-      this.skipSpace();
-      if (!this.matchBoundary())
-        return this.boundaryError("unbalanced-environment");
-      return this.error(["unknown-environment", { str: name }], index);
-    }
-    const expr = def.parse(this, [], []);
+    for (const def of this.getDefs("environment"))
+      if (def.identifierTrigger === name) {
+        const expr = def.parse(this, until);
+        this.skipSpace();
+        if (!this.matchBoundary())
+          return this.boundaryError("unbalanced-environment");
+        if (expr !== null)
+          return this.decorate(expr, index);
+        this.index = index;
+        return null;
+      }
+    this.parseTabular();
     this.skipSpace();
     if (!this.matchBoundary())
       return this.boundaryError("unbalanced-environment");
-    if (expr !== null)
-      return this.decorate(expr, index);
-    this.index = index;
-    return null;
+    return this.error(["unknown-environment", { str: name }], index);
   }
   /** If the next token matches a `+` or `-` sign, return it and advance the index.
    * Otherwise return `''` and do not advance */
@@ -8873,11 +9200,8 @@ var _Parser = class {
       until = { minPrec: 0 };
     if (!until.minPrec)
       until = { ...until, minPrec: 0 };
-    const defs = this.peekDefinitions("prefix");
-    if (defs === null)
-      return null;
     const start = this.index;
-    for (const [def, n] of defs) {
+    for (const [def, n] of this.peekDefinitions("prefix")) {
       this.index = start + n;
       const rhs = def.parse(this, until);
       if (rhs)
@@ -8888,13 +9212,11 @@ var _Parser = class {
   }
   parseInfixOperator(lhs, until) {
     until ?? (until = { minPrec: 0 });
+    console.assert(until.minPrec !== void 0);
     if (until.minPrec === void 0)
       until = { ...until, minPrec: 0 };
-    const defs = this.peekDefinitions("infix");
-    if (defs === null)
-      return null;
     const start = this.index;
-    for (const [def, n] of defs) {
+    for (const [def, n] of this.peekDefinitions("infix")) {
       if (def.precedence >= until.minPrec) {
         this.index = start + n;
         const rhs = def.parse(this, lhs, until);
@@ -8936,44 +9258,6 @@ var _Parser = class {
     this.index = savedIndex;
     return null;
   }
-  /** A prime suffix is a sequence of `'`, `\prime` or `\doubleprime`
-   * after a function or in a superscript.
-   */
-  // matchPrimeSuffix(): number {
-  //   this.skipSpace();
-  //   const start = this.index;
-  //   let count = 0;
-  //   if (this.match('^')) {
-  //     if (this.match('<{>')) {
-  //       if (this.match('(')) {
-  //         const n = this.parseNumber();
-  //         if (n && this.match(')')) return parseInt(n);
-  //         this.index = start;
-  //         return 0;
-  //       }
-  //       do {
-  //         const c = countPrimeLevel(this);
-  //         if (c === 0) break;
-  //         count += c;
-  //       } while (true);
-  //       if (count !== 0 && this.match('<}>')) return count;
-  //       this.index = start;
-  //       return 0;
-  //     }
-  //     count = countPrimeLevel(this);
-  //     if (count !== 0) return count;
-  //     this.index = start;
-  //     return 0;
-  //   }
-  //   do {
-  //     const c = countPrimeLevel(this);
-  //     if (c === 0) break;
-  //     count += c;
-  //   } while (true);
-  //   if (count !== 0) return count;
-  //   this.index = start;
-  //   return 0;
-  // }
   /** If matches the normalized open delimiter, return the
    * expected closing delimiter.
    *
@@ -9029,9 +9313,7 @@ var _Parser = class {
    * @internal
    */
   matchEnclosureOpen() {
-    const defs = this._dictionary.matchfix;
-    if (defs.length === 0)
-      return null;
+    const defs = this.getDefs("matchfix");
     const start = this.index;
     for (const def of defs) {
       this.index = start;
@@ -9054,9 +9336,7 @@ var _Parser = class {
    * Used for error handling
    * @internal */
   matchEnclosureClose() {
-    const defs = this._dictionary.matchfix;
-    if (defs.length === 0)
-      return null;
+    const defs = this.getDefs("matchfix");
     const start = this.index;
     for (const def of defs) {
       this.index = start;
@@ -9095,9 +9375,7 @@ var _Parser = class {
    * and finally a closing matching operator.
    */
   parseEnclosure() {
-    const defs = this._dictionary.matchfix;
-    if (defs.length === 0)
-      return null;
+    const defs = this.getDefs("matchfix");
     const start = this.index;
     for (const def of defs) {
       this.index = start;
@@ -9184,8 +9462,7 @@ var _Parser = class {
       return null;
     const start = this.index;
     let fn = null;
-    const fnDefs = this.peekDefinitions("function") ?? [];
-    for (const [def, tokenCount] of fnDefs) {
+    for (const [def, tokenCount] of this.peekDefinitions("function")) {
       this.index = start + tokenCount;
       if (typeof def.parse === "function") {
         fn = def.parse(this, until);
@@ -9198,7 +9475,7 @@ var _Parser = class {
     }
     if (fn === null) {
       this.index = start;
-      fn = matchIdentifier(this);
+      fn = parseIdentifier(this);
       if (!this.isFunctionHead(fn)) {
         this.index = start;
         return null;
@@ -9217,20 +9494,17 @@ var _Parser = class {
     if (this.atTerminator(until))
       return null;
     const start = this.index;
-    const defs = this.peekDefinitions("symbol");
-    if (defs) {
-      for (const [def, tokenCount] of defs) {
-        this.index = start + tokenCount;
-        if (typeof def.parse === "function") {
-          const result = def.parse(this, until);
-          if (result)
-            return result;
-        } else
-          return def.name;
-      }
+    for (const [def, tokenCount] of this.peekDefinitions("symbol")) {
+      this.index = start + tokenCount;
+      if (typeof def.parse === "function") {
+        const result = def.parse(this, until);
+        if (result)
+          return result;
+      } else
+        return def.name;
     }
     this.index = start;
-    const id = matchIdentifier(this);
+    const id = parseIdentifier(this);
     if (id === null)
       return null;
     if (this.options.parseUnknownIdentifier?.(id, this) === "symbol")
@@ -9287,7 +9561,9 @@ var _Parser = class {
     }
     let result = lhs;
     if (subscripts.length > 0) {
-      const defs = this._dictionary.infix[1]?.get("_");
+      const defs = [...this.getDefs("infix")].filter(
+        (x) => x.latexTrigger === "_"
+      );
       if (defs) {
         const arg = [
           "Subscript",
@@ -9305,7 +9581,9 @@ var _Parser = class {
       }
     }
     if (superscripts.length > 0) {
-      const defs = this._dictionary.infix[1]?.get("^");
+      const defs = [...this.getDefs("infix")].filter(
+        (x) => x.latexTrigger === "^"
+      );
       if (defs) {
         const arg = [
           "Superscript",
@@ -9330,11 +9608,8 @@ var _Parser = class {
     console.assert(lhs !== null);
     if (lhs === null)
       return null;
-    const defs = this.peekDefinitions("postfix");
-    if (defs === null)
-      return null;
     const start = this.index;
-    for (const [def, n] of defs) {
+    for (const [def, n] of this.peekDefinitions("postfix")) {
       this.index = start + n;
       const result = def.parse(this, lhs, until);
       if (result !== null)
@@ -9398,14 +9673,14 @@ var _Parser = class {
   applyInvisibleOperator(until, lhs) {
     if (lhs === null || this.options.applyInvisibleOperator === null || head(lhs) === "Error" || symbol(lhs) === "Nothing" || isEmptySequence(lhs) || this.atTerminator(until))
       return null;
+    if (this.peekDefinitions("operator").length > 0)
+      return null;
     if (this.isFunctionHead(lhs)) {
-      const args = this.parseArguments("enclosure", until);
+      const args = this.parseArguments("enclosure", { ...until, minPrec: 0 });
       if (args === null)
         return null;
       return [lhs, ...args];
     }
-    if (this.peekDefinitions("operator") !== null)
-      return null;
     const start = this.index;
     const rhs = this.parseExpression({ ...until, minPrec: 390 });
     if (rhs === null || symbol(rhs) === "Nothing" || isEmptySequence(rhs)) {
@@ -9452,9 +9727,9 @@ var _Parser = class {
   parseUnexpectedLatexCommand() {
     const start = this.index;
     let opDefs = this.peekDefinitions("operator");
-    if (opDefs) {
+    if (opDefs.length > 0) {
       opDefs = this.peekDefinitions("postfix");
-      if (opDefs) {
+      if (opDefs.length > 0) {
         const [def, n] = opDefs[0];
         this.index += n;
         if (typeof def.parse === "function") {
@@ -9467,7 +9742,7 @@ var _Parser = class {
         return this.error("unexpected-operator", start);
       }
       opDefs = this.peekDefinitions("prefix");
-      if (opDefs) {
+      if (opDefs.length > 0) {
         const [def, n] = opDefs[0];
         this.index += n;
         if (typeof def.parse === "function") {
@@ -9478,12 +9753,13 @@ var _Parser = class {
         if (def.name)
           return [
             def.name,
+            // @todo: pass a precedence?
             this.parseExpression() ?? this.error("missing", start)
           ];
         return this.error("unexpected-operator", start);
       }
       opDefs = this.peekDefinitions("infix");
-      if (opDefs) {
+      if (opDefs.length > 0) {
         const [def, n] = opDefs[0];
         this.index += n;
         if (typeof def.parse === "function") {
@@ -9577,7 +9853,10 @@ var _Parser = class {
     if (this.match("<}>"))
       return this.error("unexpected-closing-delimiter", start);
     if (this.match("<{>")) {
-      result = this.parseExpression({ condition: (p) => p.peek === "<}>" });
+      result = this.parseExpression({
+        minPrec: 0,
+        condition: (p) => p.peek === "<}>"
+      });
       if (result === null)
         return this.error("expected-expression", start);
       if (!this.match("<}>")) {
@@ -9593,7 +9872,7 @@ var _Parser = class {
         result = { num };
     }
     result ?? (result = this.parseEnclosure());
-    result ?? (result = this.parseEnvironment());
+    result ?? (result = this.parseEnvironment(until));
     if (result === null && this.matchAll(this._positiveInfinityTokens))
       result = { num: "+Infinity" };
     if (result === null && this.matchAll(this._negativeInfinityTokens))
@@ -9638,8 +9917,9 @@ var _Parser = class {
       return null;
     }
     until ?? (until = { minPrec: 0 });
+    console.assert(until.minPrec !== void 0);
     if (until.minPrec === void 0)
-      until.minPrec = 0;
+      until = { ...until, minPrec: 0 };
     let lhs = this.parsePrefixOperator({ ...until, minPrec: 0 });
     if (lhs === null) {
       lhs = this.parsePrimary(until);
@@ -9708,7 +9988,28 @@ var _Parser = class {
       return true;
     return false;
   }
+  /** Return all defs of the specified kind */
+  *getDefs(kind) {
+    if (kind === "operator") {
+      for (const def of this._dictionary.defs)
+        if (/^prefix|infix|postfix/.test(def.kind))
+          yield def;
+    } else {
+      for (const def of this._dictionary.defs)
+        if (def.kind === kind)
+          yield def;
+    }
+  }
 };
+function peekComplexId(parser, id) {
+  const start = parser.index;
+  const candidate = parseIdentifier(parser)?.trim();
+  if (candidate === null)
+    return 0;
+  const result = candidate !== id ? 0 : parser.index - start;
+  parser.index = start;
+  return result;
+}
 
 // src/compute-engine/latex-syntax/serialize-number.ts
 function formatFractionalPart(m, options) {
@@ -9948,68 +10249,11 @@ var STYLE_MODIFIERS = {
   // Unicode uses 'double-struck' for 'blackboard'
   // Supplemental
   blackboard: (s) => `\\mathbb{${s}}`,
-  // boldItalic: (s) => `\\mathbf{\\mathit{${s}}}`,
   calligraphic: (s) => `\\mathcal{${s}}`,
-  // scriptBold: (s) => `\\mathbf{\\mathscr{${s}}}`,
-  // calligraphicBold: (s) => `\\mathbf{\\mathcal{${s}}}`,
   gothic: (s) => `\\mathfrak{${s}}`,
-  // gothicBold: (s) => `\\mathbf{\\mathfrak{${s}}}`,
-  // frakturBold: (s) => `\\mathbf{\\mathfrak{${s}}}`,
-  sansSerif: (s) => `\\mathsf{${s}}`,
-  // sansSerifBold: (s) => `\\mathbf{\\mathsf{${s}}}`,
-  // sansSerifItalic: (s) => `\\mathit{\\mathsf{${s}}}`,
+  sansserif: (s) => `\\mathsf{${s}}`,
   monospace: (s) => `\\mathtt{${s}}`
 };
-function serializeOperator(serializer, expr, def) {
-  let result = "";
-  const count = nops(expr);
-  const name = headName(expr);
-  if (def.kind === "postfix") {
-    if (count !== 1) {
-      serializer.onError([
-        {
-          severity: "warning",
-          message: [
-            "postfix-operator-requires-one-operand",
-            serializer.serializeSymbol(name)
-          ]
-        }
-      ]);
-    }
-    return replaceLatex(def.serialize, [
-      serializer.wrap(op(expr, 1), def.precedence)
-    ]);
-  }
-  if (def.kind === "prefix") {
-    if (count !== 1) {
-      serializer.onError([
-        {
-          severity: "warning",
-          message: [
-            "prefix-operator-requires-one-operand",
-            serializer.serializeSymbol(name)
-          ]
-        }
-      ]);
-    }
-    return replaceLatex(def.serialize, [
-      serializer.wrap(op(expr, 1), def.precedence + 1)
-    ]);
-  }
-  if (def.kind === "infix") {
-    result = serializer.wrap(op(expr, 1), def.precedence);
-    for (let i = 2; i < count + 1; i++) {
-      const arg = op(expr, i);
-      if (arg !== null) {
-        result = replaceLatex(def.serialize, [
-          result,
-          serializer.wrap(arg, def.precedence)
-        ]);
-      }
-    }
-  }
-  return result;
-}
 var Serializer = class {
   constructor(options, dictionary2, onError) {
     this.level = -1;
@@ -10051,7 +10295,7 @@ var Serializer = class {
     }
     const name = head(expr);
     if (typeof name === "string" && name !== "Delimiter" && name !== "Subscript") {
-      const def = this.dictionary.name.get(name);
+      const def = this.dictionary.ids.get(name);
       if (def && (def.kind === "symbol" || def.kind === "prefix" || def.kind === "infix" || def.kind === "postfix") && def.precedence < prec)
         return this.wrapString(
           this.serialize(expr),
@@ -10089,14 +10333,16 @@ var Serializer = class {
   wrapString(s, style, fence) {
     if (style === "none")
       return s;
-    const openFence = fence?.[0] ?? "(";
-    const closeFence = fence?.[1] ?? ")";
+    if (fence === void 0)
+      fence = "()";
+    const openFence = fence?.[0] ?? ".";
+    const closeFence = fence?.[1] ?? ".";
     if ((openFence === "." || closeFence === ".") && style === "paren")
       style = "leftright";
     if (style === "leftright")
-      return `${openFence === "." ? "" : `\\left(${openFence}`}${s}${closeFence === "." ? "" : `\\right(${closeFence}`})`;
+      return `\\left${openFence}${s}\\right${closeFence}}`;
     if (style === "big")
-      return `${openFence === "." ? "" : `\\Bigl(${openFence}`}${s}${closeFence === "." ? "" : `\\Bigr(${closeFence}`})`;
+      return `${openFence === "." ? "" : `\\Bigl${openFence}`}${s}${closeFence === "." ? "" : `\\Bigr${closeFence}`})`;
     return openFence + s + closeFence;
   }
   wrapArguments(expr) {
@@ -10106,42 +10352,37 @@ var Serializer = class {
     );
   }
   serializeSymbol(expr, def) {
-    const h = head(expr);
-    if (h)
-      return this.serializeFunction(expr, def);
     console.assert(typeof expr === "string" || isSymbolObject(expr));
-    if (typeof def?.serialize === "string")
-      return def.serialize;
-    else if (typeof def?.serialize === "function")
-      return def.serialize(this, expr);
-    return serializeIdentifier(symbol(expr)) ?? "";
+    if (def?.kind === "function") {
+      return serializeIdentifier(symbol(expr) ?? "") ?? "";
+    }
+    return def?.serialize?.(this, expr) ?? serializeIdentifier(symbol(expr)) ?? "";
   }
   serializeFunction(expr, def) {
+    if (def?.serialize)
+      return def.serialize(this, expr);
     const h = head(expr);
-    if (!h)
-      return this.serializeSymbol(expr, def);
+    if (typeof h === "string")
+      return serializeIdentifier(h, "auto") + this.wrapArguments(expr);
     const args = ops(expr) ?? [];
-    if (def) {
-      if (typeof def.serialize === "function")
-        return def.serialize(this, expr);
+    if (args.length === 1) {
       return joinLatex([
-        def.serialize ?? h,
-        this.wrapArguments(expr)
+        this.serialize(args[0]),
+        "\\rhd",
+        this.wrapString(
+          this.serialize(h),
+          this.options.applyFunctionStyle(expr, this.level)
+        )
       ]);
     }
-    if (typeof h === "string" && h.length > 0 && h[0] === "\\") {
-      return joinLatex([h, ...args.map((x) => `{${this.serialize(x)}}`)]);
-    }
-    if (typeof h === "string") {
-      if (h.length === 1)
-        return serializeIdentifier(h) + this.wrapArguments(expr);
-      return serializeIdentifier(h, "upright") + this.wrapArguments(expr);
-    }
     const style = this.options.applyFunctionStyle(expr, this.level);
-    return "\\mathrm{Apply}" + this.wrapString(
-      this.serialize(h) + ", " + this.serialize(["List", ...args]),
-      style
-    );
+    return joinLatex([
+      "\\operatorname{apply}",
+      this.wrapString(
+        this.serialize(h) + ", " + this.serialize(["List", ...args]),
+        style
+      )
+    ]);
   }
   serializeDictionary(dict) {
     return `\\left\\lbrack\\begin{array}{lll}${Object.keys(dict).map((x) => {
@@ -10160,37 +10401,22 @@ var Serializer = class {
         const s = stringValue(expr);
         if (s !== null)
           return `\\text{${s}}`;
-        const symbolName = symbol(expr);
-        if (symbolName !== null) {
-          const def = this.dictionary.name.get(symbolName);
-          if (def?.kind === "symbol")
-            return this.serializeSymbol(expr, def);
-          if (def?.kind === "function")
-            return this.serializeFunction(expr, def);
-          if (typeof def?.serialize === "function")
-            return def.serialize(this, expr);
-        }
         const dict = dictionary(expr);
         if (dict !== null)
           return this.serializeDictionary(dict);
+        const symbolName = symbol(expr);
+        if (symbolName !== null) {
+          return this.serializeSymbol(
+            expr,
+            this.dictionary.ids.get(symbolName)
+          );
+        }
         const fnName = headName(expr);
         if (fnName) {
-          const def = this.dictionary.name.get(fnName);
-          if (def) {
-            if (typeof def.serialize === "function")
-              return def.serialize(this, expr);
-            if (def.kind === "infix" || def.kind === "postfix" || def.kind === "prefix")
-              return serializeOperator(this, expr, def);
-            if (def.kind === "symbol")
-              return this.serializeSymbol(expr, def);
-            if (def.kind === "function")
-              return this.serializeFunction(expr, def);
-            return "";
-          }
-        }
-        if (symbolName !== null || Array.isArray(expr) || isFunctionObject(expr)) {
-          return this.serializeSymbol(expr);
+          return this.serializeFunction(expr, this.dictionary.ids.get(fnName));
         }
+        if (head(expr) !== null)
+          return this.serializeFunction(expr);
         this.onError([
           {
             severity: "warning",
@@ -10230,22 +10456,6 @@ var Serializer = class {
     return this.options.numericSetStyle(expr, level);
   }
 };
-function replaceLatex(template, replacement) {
-  console.assert(typeof template === "string");
-  console.assert(template.length > 0);
-  let result = template;
-  for (let i = 0; i < replacement.length; i++) {
-    let s = replacement[i] ?? "";
-    if (/[a-zA-Z*]/.test(s[0])) {
-      const m = result.match(new RegExp("(.*)#" + Number(i + 1).toString()));
-      if (m && /\\[a-zA-Z*]+/.test(m[1])) {
-        s = " " + s;
-      }
-    }
-    result = result.replace("#" + Number(i + 1).toString(), s);
-  }
-  return result;
-}
 function specialName(s) {
   const prefix = s.match(/^([^_]+)/)?.[1] ?? "";
   let i = SYMBOLS.findIndex((x) => prefix === x[0]);
@@ -10321,7 +10531,7 @@ function parseModifiers(s) {
   }
   return [body, accent, styles, rest];
 }
-function parseIdentifierBody(s, topLevel = true, style = "auto") {
+function parseIdentifierBody2(s, topLevel = true, style = "auto") {
   let [body, accents, styles, rest] = parseModifiers(s);
   for (const accent of accents) {
     if (ACCENT_MODIFIERS[accent])
@@ -10337,7 +10547,7 @@ function parseIdentifierBody(s, topLevel = true, style = "auto") {
     }
     while (rest.length > 0) {
       if (rest.startsWith("__")) {
-        const [sup, rest2] = parseIdentifierBody(
+        const [sup, rest2] = parseIdentifierBody2(
           rest.substring(2),
           false,
           "none"
@@ -10345,7 +10555,7 @@ function parseIdentifierBody(s, topLevel = true, style = "auto") {
         sups.push(sup);
         rest = rest2;
       } else if (rest.startsWith("_")) {
-        const [sub2, rest2] = parseIdentifierBody(
+        const [sub2, rest2] = parseIdentifierBody2(
           rest.substring(1),
           false,
           "none"
@@ -10384,19 +10594,19 @@ function parseIdentifierBody(s, topLevel = true, style = "auto") {
   }
   return [body, rest];
 }
-function serializeIdentifier(s, defaultMulticharStyle = "auto") {
+function serializeIdentifier(s, style = "auto") {
   if (s === null)
     return null;
   if (ONLY_EMOJIS.test(s))
     return s;
   const m = s.match(/^(_+)(.*)/);
   if (m) {
-    const [body2, rest2] = parseIdentifierBody(m[2], true, "none");
-    return `\\mathrm{${"\\_".repeat(m[1].length) + body2 + rest2}}`;
+    const [body2, rest2] = parseIdentifierBody2(m[2], true, "none");
+    return `\\operatorname{${"\\_".repeat(m[1].length) + body2 + rest2}}`;
   }
-  const [body, rest] = parseIdentifierBody(s, true, defaultMulticharStyle);
+  const [body, rest] = parseIdentifierBody2(s, true, style);
   if (rest.length > 0)
-    return `\\mathrm{${s}}`;
+    return `\\operatorname{${s}}`;
   return body;
 }
 
@@ -10486,7 +10696,7 @@ var LatexSyntax = class _LatexSyntax {
     let expr = parser.parseExpression();
     if (!parser.atEnd) {
       const opDefs = parser.peekDefinitions("infix");
-      if (opDefs) {
+      if (opDefs.length > 0) {
         const start = parser.index;
         const [def, n] = opDefs[0];
         parser.index += n;
@@ -10507,20 +10717,23 @@ var LatexSyntax = class _LatexSyntax {
         parser.index = start;
       }
       const index = parser.index;
-      const id = matchIdentifier(parser);
+      const id = parseIdentifier(parser);
       if (id) {
         const idError = parser.error(["unexpected-identifier", id], index);
         return expr ? ["Sequence", expr, idError] : idError;
       }
+      let openDelimiter = parser.peek;
       const closeDelimiter = parser.matchEnclosureOpen();
       if (closeDelimiter) {
+        parser.parseExpression();
+        parser.match(closeDelimiter);
         const enclosureError = parser.error(
-          ["expected-close-delimiter", { str: closeDelimiter }],
+          ["unexpected-open-delimiter", { str: openDelimiter }],
           index
         );
         return expr ? ["Sequence", expr, enclosureError] : enclosureError;
       }
-      const openDelimiter = parser.matchEnclosureClose();
+      openDelimiter = parser.matchEnclosureClose();
       if (openDelimiter) {
         const enclosureError = parser.error(
           ["expected-open-delimiter", { str: openDelimiter }],
@@ -11668,6 +11881,9 @@ function gcd(a, b) {
     [a, b] = [b, a % b];
   return a < 0 ? -a : a;
 }
+function lcm(a, b) {
+  return a * b / gcd(a, b);
+}
 function factorial(n) {
   if (!Number.isInteger(n) || n < 0)
     return NaN;
@@ -13149,6 +13365,362 @@ function domainSetsLibrary() {
 
 // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
 var import_complex6 = __toESM(require_complex());
+
+// src/compute-engine/library/utils.ts
+function isSymbolDefinition(def) {
+  return !!def && typeof def === "object" && ("domain" in def || "value" in def || "constant" in def);
+}
+function isFunctionDefinition(def) {
+  if (def === void 0 || def === null)
+    return false;
+  if (typeof def !== "object")
+    return false;
+  if ("complexity" in def || "numeric" in def || "signature" in def)
+    return true;
+  if (!("domain" in def))
+    return false;
+  if (def.domain === void 0)
+    return false;
+  if (typeof def.domain === "string")
+    return def.domain === "Function";
+  return def.domain.isFunction;
+}
+function normalizeLimits(range) {
+  let lower = 1;
+  let upper = lower + MAX_ITERATION;
+  let index = "Nothing";
+  let isFinite2 = true;
+  if (range.head === "Tuple" || range.head === "Triple" || range.head === "Pair" || range.head === "Single") {
+    index = (range.op1.head === "Hold" ? range.op1.op1.symbol : range.op1.symbol) ?? "Nothing";
+    lower = asSmallInteger(range.op2) ?? 1;
+    if (!Number.isFinite(lower))
+      isFinite2 = false;
+    if (range.op3.isNothing || range.op3.isInfinity) {
+      isFinite2 = false;
+    } else {
+      const u = asSmallInteger(range.op3);
+      if (u === null)
+        isFinite2 = false;
+      else {
+        upper = u;
+        if (!Number.isFinite(upper))
+          isFinite2 = false;
+      }
+    }
+    if (!isFinite2 && Number.isFinite(lower))
+      upper = lower + MAX_ITERATION;
+  }
+  return [index, lower, upper, isFinite2];
+}
+
+// src/compute-engine/compile.ts
+var ComputeEngineFunction = class extends Function {
+  constructor(body) {
+    super("_SYS", "_", `return ${body}`);
+    this.sys = {
+      factorial,
+      gamma,
+      lngamma,
+      gcd,
+      lcm,
+      chop
+    };
+    return new Proxy(this, {
+      apply: (target, thisArg, argumentsList) => super.apply(thisArg, [this.sys, ...argumentsList]),
+      get: (target, prop) => {
+        if (prop === "toString")
+          return () => body;
+        return target[prop];
+      }
+    });
+  }
+};
+function compileToJavascript(expr) {
+  const js = compile(expr, expr.freeVars);
+  try {
+    return new ComputeEngineFunction(js);
+  } catch (e) {
+    console.error(`${e}
+${expr.latex}
+${js}`);
+  }
+  return void 0;
+}
+function compile(expr, freeVars = [], prec = 0) {
+  const f = asFloat(expr);
+  if (f !== null)
+    return f.toString();
+  const s = expr.symbol;
+  if (s !== null) {
+    const result = {
+      True: "true",
+      False: "false",
+      Pi: "Math.PI",
+      ExponentialE: "Math.E",
+      I: "Math.I",
+      NaN: "Number.NaN",
+      ImaginaryUnit: "NaN",
+      Half: "0.5",
+      MachineEpsilon: "Number.EPSILON",
+      GoldenRatio: "((1 + Math.sqrt(5)) / 2)",
+      CatalanConstant: "0.91596559417721901",
+      EulerGamma: "0.57721566490153286"
+    }[s];
+    if (result !== void 0)
+      return result;
+    if (freeVars.includes(s))
+      return `_.${s}`;
+    return s;
+  }
+  const str = expr.string;
+  if (str !== null)
+    return JSON.stringify(str);
+  const keys = expr.keys;
+  if (keys !== null) {
+    const result = [];
+    for (const key of keys) {
+      const value = expr.getKey(key);
+      if (value)
+        result.push(`${key}: ${compile(value, freeVars, 0)}`);
+    }
+    return `{${result.join(", ")}}`;
+  }
+  const h = expr.head;
+  if (typeof h === "string") {
+    if (h === "Negate") {
+      const arg = expr.op1;
+      if (arg === null)
+        return "";
+      return `-${compile(arg, freeVars, 3)}`;
+    }
+    if (h === "Error")
+      throw new Error("Error");
+    if (h === "Sum")
+      return compileLoop(expr, "+");
+    if (h === "Product")
+      return compileLoop(expr, "*");
+    if (h === "Root") {
+      const arg = expr.op1;
+      if (arg === null)
+        throw new Error("Root: no argument");
+      const exp2 = expr.op2;
+      if (exp2 === null)
+        return `Math.sqrt(${compile(arg, freeVars, 0)})`;
+      return `Math.pow(${compile(arg, freeVars)}, 1/${compile(exp2, freeVars)}`;
+    }
+    if (h === "Factorial") {
+      const arg = expr.op1;
+      if (arg === null)
+        throw new Error("Factorial: no argument");
+      return `_SYS.factorial(${compile(arg, freeVars)})`;
+    }
+    if (h === "Power") {
+      const arg = expr.op1;
+      if (arg === null)
+        throw new Error("Power: no argument");
+      const exp2 = asFloat(expr.op2);
+      if (exp2 === 0.5)
+        return `Math.sqrt(${compile(arg, freeVars)})`;
+      if (exp2 === 1 / 3)
+        return `Math.cbrt(${compile(arg, freeVars)})`;
+      if (exp2 === 1)
+        return compile(arg, freeVars);
+      if (exp2 === -1)
+        return `1 / ${compile(arg, freeVars)}`;
+      if (exp2 === -0.5)
+        return `1 / Math.sqrt(${compile(arg, freeVars)})`;
+    }
+    if (h === "Square") {
+      const arg = expr.op1;
+      if (arg === null)
+        throw new Error("Square: no argument");
+      return `Math.pow(${compile(arg, freeVars)}, 2)`;
+    }
+    const OPS = {
+      Add: ["+", 11],
+      Negate: ["-", 14],
+      // Unary operator
+      Subtract: ["-", 11],
+      Multiply: ["*", 12],
+      Divide: ["/", 13],
+      Equal: ["===", 8],
+      NotEqual: ["!==", 8],
+      LessEqual: ["<=", 9],
+      GreaterEqual: [">=", 9],
+      Less: ["<", 9],
+      Greater: [">", 9],
+      And: ["&&", 4],
+      Or: ["||", 3],
+      Not: ["!", 14]
+      // Unary operator
+      // Xor: ['^', 6], // That's bitwise XOR, not logical XOR
+      // Possible solution is to use `a ? !b : b` instead of `a ^ b`
+    };
+    const op3 = OPS[h];
+    if (op3 !== void 0) {
+      const args2 = expr.ops;
+      if (args2 === null)
+        return "";
+      let resultStr;
+      if (args2.length === 1) {
+        resultStr = `${op3[0]}${compile(args2[0], freeVars, op3[1])}`;
+      } else {
+        resultStr = args2.map((arg) => compile(arg, freeVars, op3[1])).join(` ${op3[0]} `);
+      }
+      return op3[1] < prec ? `(${resultStr})` : resultStr;
+    }
+    const fn = {
+      Abs: "Math.abs",
+      Arccos: "Math.acos",
+      Arcosh: "Math.acosh",
+      Arsin: "Math.asin",
+      Arsinh: "Math.asinh",
+      Arctan: "Math.atan",
+      Artanh: "Math.atanh",
+      // Math.cbrt
+      Ceiling: "Math.ceil",
+      Chop: "_SYS.chop",
+      Cos: "Math.cos",
+      Cosh: "Math.cosh",
+      Exp: "Math.exp",
+      Floor: "Math.floor",
+      Gamma: "_SYS.gamma",
+      Gcd: "_SYS.gcd",
+      // Math.hypot
+      Lcm: "_SYS.lcm",
+      Ln: "Math.log",
+      Log: "Math.log10",
+      LogGamma: "_SYS.lngamma",
+      Lb: "Math.log2",
+      Max: "Math.max",
+      Min: "Math.min",
+      Power: "Math.pow",
+      Random: "Math.random",
+      Round: "Math.round",
+      Sgn: "Math.sign",
+      Sin: "Math.sin",
+      Sinh: "Math.sinh",
+      Sqrt: "Math.sqrt",
+      Tan: "Math.tan",
+      Tanh: "Math.tanh"
+      // Factorial: 'factorial',    // TODO: implement
+      // Hallucinated by Copilot, but interesting ideas...
+      // Cot: 'Math.cot',
+      // Sec: 'Math.sec',
+      // Csc: 'Math.csc',
+      // ArcCot: 'Math.acot',
+      // ArcSec: 'Math.asec',
+      // ArcCsc: 'Math.acsc',
+      // Coth: 'Math.coth',
+      // Sech: 'Math.sech',
+      // Csch: 'Math.csch',
+      // ArcCoth: 'Math.acoth',
+      // ArcSech: 'Math.asech',
+      // ArcCsch: 'Math.acsch',
+      // Root: 'Math.root',
+      // Gamma: 'Math.gamma',
+      // Erf: 'Math.erf',
+      // Erfc: 'Math.erfc',
+      // Erfi: 'Math.erfi',
+      // Zeta: 'Math.zeta',
+      // PolyGamma: 'Math.polygamma',
+      // HurwitzZeta: 'Math.hurwitzZeta', $$\zeta (s,a)=\sum _{n=0}^{\infty }{\frac {1}{(n+a)^{s}}}$$
+      // DirichletEta: 'Math.dirichletEta',
+      // Beta: 'Math.beta',
+      // Binomial: 'Math.binomial',
+      // Mod: 'Math.mod',
+      // Quotient: 'Math.quotient',
+      // GCD: 'Math.gcd',
+      // LCM: 'Math.lcm',
+      // Divisors: 'Math.divisors',
+      // PrimeQ: 'Math.isPrime',
+      // PrimePi: 'Math.primePi',
+      // Prime: 'Math.prime',
+      // NextPrime: 'Math.nextPrime',
+      // PreviousPrime: 'Math.prevPrime',
+      // PrimePowerQ: 'Math.isPrimePower',
+      // PrimePowerPi: 'Math.primePowerPi',
+      // PrimePower: 'Math.primePower',
+      // NextPrimePower: 'Math.nextPrimePower',
+      // PreviousPrimePower: 'Math.prevPrimePower',
+      // PrimeFactors: 'Math.primeFactors',
+      // DivisorSigma: 'Math.divisorSigma',
+      // DivisorSigma0: 'Math.divisorSigma0',
+      // DivisorSigma1: 'Math.divisorSigma1',
+      // DivisorSigma2: 'Math.divisorSigma2',
+      // DivisorSigma3: 'Math.divisorSigma3',
+      // DivisorSigma4: 'Math.divisorSigma4',
+      // DivisorCount: 'Math.divisorCount',
+      // DivisorSum: 'Math.divisorSum',
+      // MoebiusMu: 'Math.moebiusMu',
+      // LiouvilleLambda: 'Math.liouvilleLambda',
+      // CarmichaelLambda: 'Math.carmichaelLambda',
+      // EulerPhi: 'Math.eulerPhi',
+      // EulerPsi: 'Math.eulerPsi',
+      // EulerGamma: 'Math.eulerGamma',
+      // HarmonicNumber: 'Math.harmonicNumber',
+      // BernoulliB: 'Math.bernoulliB',
+      // StirlingS1: 'Math.stirlingS1',
+      // StirlingS2: 'Math.stirlingS2',
+      // BellB: 'Math.bellB',
+      // BellNumber: 'Math.bellNumber',
+      // LahS: 'Math.lahS',
+      // LahL: 'Math.lahL',
+      // RiemannR: 'Math.riemannR',
+      // RiemannZeta: 'Math.riemannZeta',
+      // RiemannXi: 'Math.riemannXi',
+      // RiemannH: 'Math.riemannH',
+      // RiemannZ: 'Math.riemannZ',
+      // RiemannS: 'Math.riemannS',
+      // RiemannXiZero: 'Math.riemannXiZero',
+      // RiemannZetaZero: 'Math.riemannZetaZero',
+      // RiemannHZero: 'Math.riemannHZero',
+      // RiemannSZero: 'Math.riemannSZero',
+      // RiemannPrimeCount: 'Math.riemannPrimeCount',
+      // RiemannRLog: 'Math.riemannRLog',
+      // RiemannRLogDerivative: 'Math.riemannRLogDerivative',
+      // RiemannRLogZero: 'Math.riemannRLogZero',
+      // RiemannRLogZeroDerivative: 'Math.riemannRLogZeroDerivative',
+      // RiemannRZero: 'Math.riemannRZero',
+      // RiemannRDerivative: 'Math.riemannRDerivative',
+      // RiemannXiZeroDerivative: 'Math.riemannXiZeroDerivative',
+      // RiemannZetaZeroDerivative: 'Math.riemannZetaZeroDerivative',
+      // RiemannHZeroDerivative: 'Math.riemannHZeroDerivative',
+      // RiemannSZeroDerivative: 'Math.riemannSZeroDerivative',
+      // RiemannSZeroDerivative2: 'Math.riemannSZeroDerivative2',
+      // RiemannSZeroDerivative3: 'Math.riemannSZeroDerivative3',
+      // RiemannSZeroDerivative4: 'Math.riemannSZeroDerivative4',
+      // RiemannSZeroDerivative5: 'Math.riemannSZeroDerivative5',
+      // RiemannSZeroDerivative6: 'Math.riemannSZeroDerivative6',
+    }[h] ?? h;
+    const args = expr.ops;
+    if (args !== null) {
+      const result = [];
+      for (const arg of args)
+        result.push(compile(arg, freeVars));
+      return `${fn}(${result.join(", ")})`;
+    }
+  }
+  return "";
+}
+function compileLoop(expr, op3) {
+  const args = expr.ops;
+  if (args === null)
+    throw new Error("Sum: no arguments");
+  if (!expr.op1 || !expr.op2)
+    throw new Error("Sum: no limits");
+  const [index, lower, upper, isFinite2] = normalizeLimits(expr.op2);
+  const fn = compile(expr.op1, [...expr.op1.freeVars, index], 0);
+  return `(() => {
+  let acc = ${op3 === "+" ? "0" : "1"};
+  const fn = (_) => ${fn};
+  for (let i = ${lower}; i <= ${upper}; i++)
+    acc ${op3}= fn({ ..._, ${index}: i });
+  return acc;
+})()`;
+}
+
+// src/compute-engine/boxed-expression/abstract-boxed-expression.ts
 var AbstractBoxedExpression = class {
   constructor(ce, metadata) {
     this.engine = ce;
@@ -13473,6 +14045,21 @@ var AbstractBoxedExpression = class {
   N(_options) {
     return this.evaluate();
   }
+  compile(to = "javascript", options) {
+    if (to !== "javascript")
+      return void 0;
+    options ?? (options = { optimize: ["simplify", "evaluate"] });
+    let expr = this;
+    if (options.optimize.includes("simplify"))
+      expr = expr.simplify();
+    if (options.optimize.includes("evaluate"))
+      expr = expr.evaluate();
+    try {
+      return compileToJavascript(expr);
+    } catch (e) {
+    }
+    return void 0;
+  }
 };
 
 // src/compute-engine/boxed-expression/serialize.ts
@@ -14935,7 +15522,7 @@ function validateNumericArgs(ce, ops2, count) {
     }
   }
   return xs.map(
-    (op3) => !op3.isValid || op3.isNumber ? op3 : ce.error(["incompatible-domain", "Number", op3.domain], op3)
+    (op3) => op3 && !op3.isValid || op3.isNumber ? op3 : ce.error(["incompatible-domain", "Number", op3.domain], op3)
   );
 }
 function validateSignature(sig, ops2, codomain) {
@@ -15304,33 +15891,6 @@ function evalSummation(ce, expr, range, mode) {
   ce.context = savedContext;
   return result ?? void 0;
 }
-function normalizeLimits(range) {
-  let lower = 1;
-  let upper = lower + MAX_ITERATION;
-  let index = "Nothing";
-  let isFinite2 = true;
-  if (range.head === "Tuple" || range.head === "Triple" || range.head === "Pair" || range.head === "Single") {
-    index = (range.op1.head === "Hold" ? range.op1.op1.symbol : range.op1.symbol) ?? "Nothing";
-    lower = asSmallInteger(range.op2) ?? 1;
-    if (!Number.isFinite(lower))
-      isFinite2 = false;
-    if (range.op3.isNothing || range.op3.isInfinity) {
-      isFinite2 = false;
-    } else {
-      const u = asSmallInteger(range.op3);
-      if (u === null)
-        isFinite2 = false;
-      else {
-        upper = u;
-        if (!Number.isFinite(upper))
-          isFinite2 = false;
-      }
-    }
-    if (!isFinite2 && Number.isFinite(lower))
-      upper = lower + MAX_ITERATION;
-  }
-  return [index, lower, upper, isFinite2];
-}
 
 // src/compute-engine/symbolic/negate.ts
 var import_complex9 = __toESM(require_complex());
@@ -15643,7 +16203,6 @@ var UNIVARIATE_ROOTS = [
   // ],
 ];
 function findUnivariateRoots(expr, x) {
-  console.log("findUnivariateRoots", expr.toString(), x);
   const ce = expr.engine;
   if (expr.head === "Equal") {
     expr = ce.add([expr.op1.canonical, ce.neg(expr.op2.canonical)]).simplify();
@@ -18787,7 +19346,7 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     Erf: {
-      description: "Complementary Error Function",
+      description: "Error Function",
       complexity: 7500
     },
     Erfc: {
@@ -18795,7 +19354,7 @@ var ARITHMETIC_LIBRARY = [
       complexity: 7500
     },
     Factorial: {
-      description: "The factorial function",
+      description: "Factorial Function",
       wikidata: "Q120976",
       complexity: 9e3,
       signature: {
@@ -18834,7 +19393,7 @@ var ARITHMETIC_LIBRARY = [
       wikidata: "Q190573",
       complexity: 8e3,
       signature: {
-        domain: ["Function", "Number", "Number", "Number"],
+        domain: ["Function", "Number", "Number"],
         N: (ce, ops2) => applyN(
           ops2[0],
           (x) => gamma(x),
@@ -18846,7 +19405,7 @@ var ARITHMETIC_LIBRARY = [
     LogGamma: {
       complexity: 8e3,
       signature: {
-        domain: ["Function", "Number", "Number", "Number"],
+        domain: ["Function", "Number", "Number"],
         N: (ce, ops2) => applyN(
           ops2[0],
           (x) => lngamma(x),
@@ -19582,6 +20141,18 @@ function randomExpression(level) {
   level ?? (level = 1);
   if (level === 1) {
     const h = oneOf([
+      [
+        "Sqrt",
+        [
+          "Multiply",
+          6,
+          [
+            "Sum",
+            ["Divide", 1, ["Power", "n", 2]],
+            ["Triple", ["Hold", "n"], 1, { num: "+Infinity" }]
+          ]
+        ]
+      ],
       "Add",
       "Add",
       "Add",
@@ -19600,13 +20171,16 @@ function randomExpression(level) {
       "Negate",
       "trig"
     ]);
-    return randomExpressionWithHead(h, 1);
+    if (typeof h === "string")
+      return randomExpressionWithHead(h, 1);
+    return h;
   }
   if (level === 2) {
-    if (Math.random() > 0.5)
-      return randomExpression(3);
-    if (Math.random() > 0.75)
+    const r = Math.random();
+    if (r > 0.75)
       return randomExpression(1);
+    if (r > 0.5)
+      return randomExpression(3);
     const h = oneOf([
       "Multiply",
       "Multiply",
@@ -19660,7 +20234,7 @@ function randomExpression(level) {
     ["Rational", 12, 15],
     ["Rational", 15, 12],
     "ExponentialE",
-    "ImaginaryUnit",
+    // 'ImaginaryUnit',
     ["Sqrt", 3],
     ["Sqrt", 5],
     ["Sqrt", 15],
@@ -19678,8 +20252,8 @@ function randomExpression(level) {
     ["Power", "x", 4],
     ["Subtract", "x", 1],
     ["Add", "x", 1],
-    "a",
-    "b",
+    // 'a',
+    // 'b',
     "Pi"
   ]);
 }
@@ -19874,7 +20448,7 @@ var CORE_LIBRARY = [
     Apply: {
       signature: {
         domain: "Function",
-        evaluate: (ce, ops2) => apply(ops2[0], ops2.slice(1))
+        evaluate: (_ce, ops2) => apply(ops2[0], ops2.slice(1))
       }
     },
     About: { signature: { domain: "Function" } },
@@ -19886,6 +20460,11 @@ var CORE_LIBRARY = [
        */
       signature: { domain: "Function" }
     },
+    Derivative: {
+      signature: {
+        domain: ["Function", "Function", ["Maybe", "Number"], "Function"]
+      }
+    },
     Domain: {
       /** Return the domain of an expression */
       signature: {
@@ -20261,7 +20840,7 @@ var LOGIC_LIBRARY = {
   // expressions into CNF (Conjunctive Normal Form)
   // https://en.wikipedia.org/wiki/Conjunctive_normal_form
   // using rules (with a rule set that's kinda the inverse of the
-  // logic rules for simplify
+  // logic rules for simplify)
   And: {
     wikidata: "Q191081",
     threadable: true,
@@ -20335,6 +20914,10 @@ var LOGIC_LIBRARY = {
           return ops2[1] ? ops2[1].evaluate() : ce.box("Nothing");
         return ops2[2] ? ops2[2].evaluate() : ce.box("Nothing");
       },
+      // @todo: probably don't need a N() handler. Doesn't make a difference
+      // for the evaluation of booleans. Also, don't need to call N() on the
+      // arguments, the caller should have done that. Same for evaluate()
+      // and simplify() above
       N: (ce, ops2) => {
         const cond = ops2[0];
         if (cond && cond.symbol === "True")
@@ -22507,26 +23090,6 @@ function makeFunctionDefinition(engine, name, def) {
   );
 }
 
-// src/compute-engine/library/utils.ts
-function isSymbolDefinition(def) {
-  return !!def && typeof def === "object" && ("domain" in def || "value" in def || "constant" in def);
-}
-function isFunctionDefinition(def) {
-  if (def === void 0 || def === null)
-    return false;
-  if (typeof def !== "object")
-    return false;
-  if ("complexity" in def || "numeric" in def || "signature" in def)
-    return true;
-  if (!("domain" in def))
-    return false;
-  if (def.domain === void 0)
-    return false;
-  if (typeof def.domain === "string")
-    return def.domain === "Function";
-  return def.domain.isFunction;
-}
-
 // src/compute-engine/library/library.ts
 function getStandardLibrary(categories) {
   if (categories === "all") {
@@ -23557,14 +24120,15 @@ var ComputeEngine = class _ComputeEngine {
    * perform calculations using arbitrary precision floating point numbers.
    * Use `"auto"` or `"complex"` to allow calculations on complex numbers.
    *
-   * @param options.numericPrecision Specific how many digits of precision for the
-   * numeric calculations. Default is 100.
+   * @param options.numericPrecision Specific how many digits of precision
+   * for the numeric calculations. Default is 100.
    *
-   * @param options.tolerance If the absolute value of the difference of two numbers
-   * is less than `tolerance`, they are considered equal. Used by `chop()` as well.
+   * @param options.tolerance If the absolute value of the difference of two
+   * numbers is less than `tolerance`, they are considered equal. Used by
+   * `chop()` as well.
    *
-   * @param options.defaultDomain If an unknown symbol is encountered, assume it should
-   * be a variable in this domain. **Default** `ExtendedRealNumber`
+   * @param options.defaultDomain If an unknown symbol is encountered, assume
+   * this is its domain. **Default** `ExtendedRealNumber`
    */
   constructor(options) {
     /** @internal */
@@ -23925,6 +24489,10 @@ var ComputeEngine = class _ComputeEngine {
     return new this._bignum(a);
   }
   complex(a, b) {
+    if (a instanceof Decimal)
+      a = a.toNumber();
+    if (b instanceof Decimal)
+      b = b.toNumber();
     return new import_complex19.Complex(a, b);
   }
   isBignum(a) {
@@ -24502,9 +25070,29 @@ var ComputeEngine = class _ComputeEngine {
     this.latexSyntax.updateOptions(opts);
   }
   get jsonSerializationOptions() {
-    if (this._useRawJsonSerializationOptions)
-      return this._rawJsonSerializationOptions;
-    return this._jsonSerializationOptions;
+    if (this._useRawJsonSerializationOptions) {
+      return new Proxy(this._rawJsonSerializationOptions, {
+        get(options, prop) {
+          if (!(prop in options))
+            return void 0;
+          return options[prop];
+        }
+      });
+    }
+    const self = this;
+    return new Proxy(this._jsonSerializationOptions, {
+      get(options, prop) {
+        if (!(prop in options))
+          return void 0;
+        return options[prop];
+      },
+      set(options, prop, value) {
+        if (!(prop in options))
+          return false;
+        self.jsonSerializationOptions = { [prop]: value };
+        return true;
+      }
+    });
   }
   set jsonSerializationOptions(val) {
     if (val.exclude)
@@ -24620,10 +25208,10 @@ var ComputeEngine = class _ComputeEngine {
 };
 
 // src/compute-engine.ts
-var version = "0.12.7";
+var version = "0.14.0";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.12.7"
+  version: "0.14.0"
 };
 export {
   ComputeEngine,