@cortex-js/compute-engine 0.13.0 → 0.14.0

package/dist/compute-engine.min.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.13.0 */
+/** CortexJS Compute Engine 0.14.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __create = Object.create;
@@ -3766,7 +3766,7 @@ var ComputeEngine = (() => {
   var DEFINITIONS_ALGEBRA = [
     {
       name: "To",
-      trigger: ["\\to"],
+      latexTrigger: ["\\to"],
       kind: "infix",
       precedence: 270
       // MathML rightwards arrow
@@ -4028,10 +4028,10 @@ var ComputeEngine = (() => {
       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) {
@@ -4556,7 +4556,7 @@ var ComputeEngine = (() => {
     { name: "EulerGamma", serialize: "\\gamma" },
     {
       name: "Degrees",
-      trigger: ["\\degree"],
+      latexTrigger: ["\\degree"],
       kind: "postfix",
       precedence: 880,
       parse: (_parser, lhs) => ["Degrees", lhs],
@@ -4565,74 +4565,82 @@ var ComputeEngine = (() => {
       }
     },
     {
-      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"
     },
     {
-      trigger: "\\mathrm{e}",
+      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"]
     },
     {
-      trigger: "\\mathrm{i}",
+      latexTrigger: "\\operatorname{i}",
+      parse: "ImaginaryUnit"
+    },
+    {
+      latexTrigger: "\\mathrm{i}",
       parse: "ImaginaryUnit"
     },
     // Operations
@@ -4643,18 +4651,18 @@ var ComputeEngine = (() => {
        * 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,
@@ -4670,7 +4678,7 @@ var ComputeEngine = (() => {
     },
     {
       kind: "prefix",
-      trigger: ["+"],
+      latexTrigger: ["+"],
       precedence: 275,
       parse: (parser, until) => {
         if (until && 275 < until.minPrec)
@@ -4681,20 +4689,22 @@ var ComputeEngine = (() => {
     {
       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,
@@ -4714,7 +4724,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "Divide",
-      trigger: "\\frac",
+      latexTrigger: "\\frac",
       precedence: 660,
       // For \frac specifically, not for \div, etc..
       // handles Leibnitz notation for partial derivatives
@@ -4723,12 +4733,12 @@ var ComputeEngine = (() => {
     },
     {
       kind: "infix",
-      trigger: "\\over",
+      latexTrigger: "\\over",
       precedence: 660,
       parse: "Divide"
     },
     {
-      trigger: ["\\/"],
+      latexTrigger: ["\\/"],
       kind: "infix",
       associativity: "non",
       precedence: 660,
@@ -4738,14 +4748,14 @@ var ComputeEngine = (() => {
       parse: "Divide"
     },
     {
-      trigger: ["/"],
+      latexTrigger: ["/"],
       kind: "infix",
       associativity: "non",
       precedence: 660,
       parse: "Divide"
     },
     {
-      trigger: ["\\div"],
+      latexTrigger: ["\\div"],
       kind: "infix",
       associativity: "non",
       precedence: 660,
@@ -4763,36 +4773,41 @@ var ComputeEngine = (() => {
     },
     {
       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"
     },
     {
@@ -4801,34 +4816,34 @@ var ComputeEngine = (() => {
     },
     {
       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);
@@ -4844,32 +4859,32 @@ var ComputeEngine = (() => {
     },
     {
       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];
@@ -4877,13 +4892,11 @@ var ComputeEngine = (() => {
       }
     },
     {
-      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];
@@ -4892,11 +4905,9 @@ var ComputeEngine = (() => {
     },
     {
       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)];
       },
@@ -4922,8 +4933,8 @@ var ComputeEngine = (() => {
       //   /** If the argument is a vector */
       /** @todo: domain check */
       kind: "matchfix",
-      openDelimiter: "||",
-      closeDelimiter: "||",
+      openTrigger: "||",
+      closeTrigger: "||",
       parse: (_parser, expr) => isEmptySequence(expr) ? null : ["Norm", expr]
     },
     {
@@ -4931,12 +4942,13 @@ var ComputeEngine = (() => {
       /** @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,
@@ -4955,47 +4967,41 @@ var ComputeEngine = (() => {
       }
     },
     {
-      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),
@@ -5012,7 +5018,7 @@ var ComputeEngine = (() => {
       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);
       }
     },
@@ -5022,7 +5028,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "Round",
-      trigger: "round",
+      identifierTrigger: "round",
       kind: "function"
     },
     {
@@ -5031,7 +5037,7 @@ var ComputeEngine = (() => {
       serialize: (serializer, expr) => serializer.wrapShort(op(expr, 1)) + "^2"
     },
     {
-      trigger: "\\sum",
+      latexTrigger: ["\\sum"],
       precedence: 275,
       name: "Sum",
       parse: parseBigOp("Sum", 275),
@@ -5040,24 +5046,22 @@ var ComputeEngine = (() => {
     {
       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)];
       }
@@ -5154,16 +5158,16 @@ var ComputeEngine = (() => {
       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
@@ -5202,7 +5206,7 @@ var ComputeEngine = (() => {
     // Constants
     //
     {
-      trigger: ["\\placeholder"],
+      latexTrigger: ["\\placeholder"],
       kind: "symbol",
       parse: (parser) => {
         while (parser.match("<space>")) {
@@ -5221,6 +5225,27 @@ var ComputeEngine = (() => {
     //
     // 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) => {
@@ -5286,7 +5311,7 @@ var ComputeEngine = (() => {
       }
     },
     {
-      trigger: ["\\mathtip"],
+      latexTrigger: ["\\mathtip"],
       parse: (parser) => {
         const op12 = parser.parseGroup();
         const op22 = parser.parseGroup();
@@ -5294,7 +5319,7 @@ var ComputeEngine = (() => {
       }
     },
     {
-      trigger: ["\\texttip"],
+      latexTrigger: ["\\texttip"],
       parse: (parser) => {
         const op12 = parser.parseGroup();
         const op22 = parser.parseGroup();
@@ -5302,8 +5327,8 @@ var ComputeEngine = (() => {
       }
     },
     {
-      trigger: ["\\error"],
-      parse: (parser) => parser.parseGroup()
+      latexTrigger: ["\\error"],
+      parse: (parser) => ["Error", parser.parseGroup()]
     },
     {
       name: "Error",
@@ -5363,10 +5388,10 @@ var ComputeEngine = (() => {
     {
       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];
@@ -5382,11 +5407,11 @@ var ComputeEngine = (() => {
     },
     {
       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"];
@@ -5396,7 +5421,7 @@ var ComputeEngine = (() => {
       }
     },
     {
-      trigger: [","],
+      latexTrigger: [","],
       kind: "infix",
       precedence: 20,
       // Unlike the matchfix version of List,
@@ -5416,7 +5441,7 @@ var ComputeEngine = (() => {
       serialize: serializeOps("")
     },
     {
-      trigger: [";"],
+      latexTrigger: [";"],
       kind: "infix",
       precedence: 19,
       parse: (parser, lhs, terminator) => {
@@ -5433,7 +5458,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "String",
-      trigger: ["\\text"],
+      latexTrigger: ["\\text"],
       parse: (scanner) => parseTextRun(scanner),
       serialize: (serializer, expr) => {
         const args = ops(expr);
@@ -5448,7 +5473,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "Subscript",
-      trigger: ["_"],
+      latexTrigger: ["_"],
       kind: "infix",
       serialize: (serializer, expr) => {
         if (nops(expr) === 2) {
@@ -5457,53 +5482,121 @@ var ComputeEngine = (() => {
         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)
+    },
+    {
+      latexTrigger: ["^", "\\tripleprime"],
+      kind: "postfix",
+      parse: (parser, lhs) => parsePrime(parser, lhs, 3)
+    },
+    {
+      latexTrigger: "'",
+      kind: "postfix",
+      precedence: 810,
+      parse: (parser, lhs) => parsePrime(parser, lhs, 1)
     },
     {
-      trigger: ["^", "\\doubleprime"],
+      latexTrigger: "\\prime",
       kind: "postfix",
-      parse: (_parser, lhs) => ["Prime", missingIfEmpty(lhs), 2]
+      precedence: 810,
+      parse: (parser, lhs) => parsePrime(parser, lhs, 1)
     },
     {
-      trigger: ["^", "\\tripleprime"],
+      latexTrigger: "\\doubleprime",
       kind: "postfix",
-      parse: (_parser, lhs) => ["Prime", missingIfEmpty(lhs), 3]
+      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}"
     },
@@ -5518,13 +5611,13 @@ var ComputeEngine = (() => {
           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)
@@ -5667,11 +5760,26 @@ var ComputeEngine = (() => {
       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,
@@ -5679,13 +5787,13 @@ var ComputeEngine = (() => {
     },
     {
       name: "NotLess",
-      trigger: ["\\nless"],
+      latexTrigger: ["\\nless"],
       kind: "infix",
       associativity: "right",
       precedence: 246
     },
     {
-      trigger: ["<"],
+      latexTrigger: ["<"],
       kind: "infix",
       associativity: "right",
       precedence: 245,
@@ -5693,13 +5801,13 @@ var ComputeEngine = (() => {
     },
     {
       name: "Less",
-      trigger: ["\\lt"],
+      latexTrigger: ["\\lt"],
       kind: "infix",
       associativity: "right",
       precedence: 245
     },
     {
-      trigger: ["<", "="],
+      latexTrigger: ["<", "="],
       kind: "infix",
       associativity: "right",
       precedence: 241,
@@ -5707,20 +5815,20 @@ var ComputeEngine = (() => {
     },
     {
       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,
@@ -5729,28 +5837,28 @@ var ComputeEngine = (() => {
     },
     {
       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,
@@ -5758,13 +5866,13 @@ var ComputeEngine = (() => {
     },
     {
       name: "Equal",
-      trigger: ["="],
+      latexTrigger: ["="],
       kind: "infix",
       associativity: "right",
       precedence: 260
     },
     {
-      trigger: ["*", "="],
+      latexTrigger: ["*", "="],
       kind: "infix",
       associativity: "right",
       precedence: 260,
@@ -5772,42 +5880,42 @@ var ComputeEngine = (() => {
     },
     {
       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
@@ -5815,7 +5923,7 @@ var ComputeEngine = (() => {
     {
       name: "TildeFullEqual",
       // MathML: approximately equal to
-      trigger: ["\\cong"],
+      latexTrigger: ["\\cong"],
       kind: "infix",
       associativity: "right",
       precedence: 260
@@ -5823,13 +5931,13 @@ var ComputeEngine = (() => {
     {
       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,
@@ -5837,7 +5945,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "Assign",
-      trigger: ["\\coloneq"],
+      latexTrigger: ["\\coloneq"],
       kind: "infix",
       associativity: "right",
       precedence: 260
@@ -5845,7 +5953,7 @@ var ComputeEngine = (() => {
     {
       name: "Approx",
       // Note: Mathematica TildeTilde
-      trigger: ["\\approx"],
+      latexTrigger: ["\\approx"],
       kind: "infix",
       associativity: "right",
       precedence: 247
@@ -5853,7 +5961,7 @@ var ComputeEngine = (() => {
     {
       name: "NotApprox",
       // Note: Mathematica TildeTilde
-      trigger: ["\\not", "\\approx"],
+      latexTrigger: ["\\not", "\\approx"],
       kind: "infix",
       associativity: "right",
       precedence: 247
@@ -5861,7 +5969,7 @@ var ComputeEngine = (() => {
     {
       name: "ApproxEqual",
       // Note: Mathematica TildeEqual, MathML: `asymptotically equal to`
-      trigger: ["\\approxeq"],
+      latexTrigger: ["\\approxeq"],
       kind: "infix",
       associativity: "right",
       precedence: 260
@@ -5869,7 +5977,7 @@ var ComputeEngine = (() => {
     {
       name: "NotApproxEqual",
       // Note: Mathematica NotTildeEqual
-      trigger: ["\\not", "\\approxeq"],
+      latexTrigger: ["\\not", "\\approxeq"],
       kind: "infix",
       // Note: no LaTeX symbol for char U+2249
       associativity: "right",
@@ -5877,14 +5985,14 @@ var ComputeEngine = (() => {
     },
     {
       name: "NotEqual",
-      trigger: ["\\ne"],
+      latexTrigger: ["\\ne"],
       kind: "infix",
       associativity: "right",
       precedence: 255
     },
     {
       name: "Unequal",
-      trigger: ["!", "="],
+      latexTrigger: ["!", "="],
       kind: "infix",
       associativity: "right",
       precedence: 260
@@ -5892,14 +6000,14 @@ var ComputeEngine = (() => {
     },
     {
       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,
@@ -5907,14 +6015,14 @@ var ComputeEngine = (() => {
       parse: "GreaterEqual"
     },
     {
-      trigger: [">", "="],
+      latexTrigger: [">", "="],
       kind: "infix",
       associativity: "right",
       precedence: 243,
       parse: "GreaterEqual"
     },
     {
-      trigger: ["\\geqslant"],
+      latexTrigger: ["\\geqslant"],
       kind: "infix",
       associativity: "right",
       precedence: 265,
@@ -5923,20 +6031,20 @@ var ComputeEngine = (() => {
     },
     {
       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,
@@ -5944,20 +6052,20 @@ var ComputeEngine = (() => {
     },
     {
       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,
@@ -5965,7 +6073,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "RingEqual",
-      trigger: ["\\circeq"],
+      latexTrigger: ["\\circeq"],
       kind: "infix",
       associativity: "right",
       precedence: 260
@@ -5973,7 +6081,7 @@ var ComputeEngine = (() => {
     {
       name: "TriangleEqual",
       // MathML: delta equal to
-      trigger: ["\\triangleq"],
+      latexTrigger: ["\\triangleq"],
       kind: "infix",
       associativity: "right",
       precedence: 260
@@ -5981,7 +6089,7 @@ var ComputeEngine = (() => {
     {
       name: "DotEqual",
       // MathML: approaches the limit
-      trigger: ["\\doteq"],
+      latexTrigger: ["\\doteq"],
       kind: "infix",
       associativity: "right",
       precedence: 265
@@ -5989,7 +6097,7 @@ var ComputeEngine = (() => {
     {
       name: "DotEqualDot",
       // MathML: Geometrically equal
-      trigger: ["\\doteqdot"],
+      latexTrigger: ["\\doteqdot"],
       kind: "infix",
       associativity: "right",
       precedence: 265
@@ -5997,7 +6105,7 @@ var ComputeEngine = (() => {
     {
       name: "FallingDotEqual",
       // MathML: approximately equal to or the image of
-      trigger: ["\\fallingdotseq"],
+      latexTrigger: ["\\fallingdotseq"],
       kind: "infix",
       associativity: "right",
       precedence: 265
@@ -6005,92 +6113,77 @@ var ComputeEngine = (() => {
     {
       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"],
+      latexTrigger: ["\\questeq"],
       kind: "infix",
       associativity: "right",
       precedence: 260
     },
-    {
-      trigger: ["\\iff"],
-      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
@@ -6102,18 +6195,187 @@ var ComputeEngine = (() => {
     // 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"
     }
   ];
 
@@ -6127,72 +6389,73 @@ var ComputeEngine = (() => {
   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
     },
@@ -6202,7 +6465,7 @@ var ComputeEngine = (() => {
       // 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;
@@ -6225,8 +6488,8 @@ var ComputeEngine = (() => {
           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];
       },
@@ -6252,128 +6515,128 @@ var ComputeEngine = (() => {
     },
     {
       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"]
     },
     {
@@ -6415,39 +6678,39 @@ var ComputeEngine = (() => {
       }
     },
     {
-      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]
     },
     {
@@ -6547,146 +6810,146 @@ var ComputeEngine = (() => {
   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")
     }
   ];
@@ -6694,77 +6957,77 @@ var ComputeEngine = (() => {
   // 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
@@ -6786,7 +7049,7 @@ var ComputeEngine = (() => {
       }
     },
     {
-      trigger: ["^", "\\complement"],
+      latexTrigger: ["^", "\\complement"],
       kind: "postfix",
       parse: (_parser, lhs) => {
         return ["Complement", lhs];
@@ -6796,14 +7059,14 @@ var ComputeEngine = (() => {
     },
     {
       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
     },
@@ -6819,7 +7082,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "Union",
-      trigger: ["\\cup"],
+      latexTrigger: ["\\cup"],
       kind: "infix",
       precedence: 350
     },
@@ -6838,13 +7101,13 @@ var ComputeEngine = (() => {
     // },
     {
       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
@@ -6852,7 +7115,7 @@ var ComputeEngine = (() => {
     },
     // Predicates/Relations
     {
-      trigger: ["\\ni"],
+      latexTrigger: ["\\ni"],
       kind: "infix",
       associativity: "right",
       precedence: 160,
@@ -6864,40 +7127,40 @@ var ComputeEngine = (() => {
     },
     {
       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
@@ -6905,7 +7168,7 @@ var ComputeEngine = (() => {
     {
       name: "SquareSubset",
       // MathML: square image of
-      trigger: ["\\sqsubset"],
+      latexTrigger: ["\\sqsubset"],
       kind: "infix",
       associativity: "right",
       precedence: 265
@@ -6913,7 +7176,7 @@ var ComputeEngine = (() => {
     {
       name: "SquareSubsetEqual",
       // MathML: square image of or equal to
-      trigger: ["\\sqsubseteq"],
+      latexTrigger: ["\\sqsubseteq"],
       kind: "infix",
       associativity: "right",
       precedence: 265
@@ -6921,7 +7184,7 @@ var ComputeEngine = (() => {
     {
       name: "SquareSuperset",
       // MathML: square original of
-      trigger: ["\\sqsupset"],
+      latexTrigger: ["\\sqsupset"],
       kind: "infix",
       associativity: "right",
       precedence: 265
@@ -6929,27 +7192,27 @@ var ComputeEngine = (() => {
     {
       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,
@@ -6957,26 +7220,26 @@ var ComputeEngine = (() => {
     },
     {
       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,
@@ -6984,7 +7247,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "SupersetEqual",
-      trigger: ["\\supseteq"],
+      latexTrigger: ["\\supseteq"],
       kind: "infix",
       associativity: "right",
       precedence: 240
@@ -7147,6 +7410,8 @@ var ComputeEngine = (() => {
       condition: () => {
         if (parser.matchAll(["\\mathrm", "<{>", "d", "<}>"]))
           found = true;
+        else if (parser.matchAll(["\\operatorname", "<{>", "d", "<}>"]))
+          found = true;
         return found;
       }
     });
@@ -7264,7 +7529,7 @@ var ComputeEngine = (() => {
           command,
           "\\!",
           serializer.serialize(fn),
-          "\\,\\mathrm{d}",
+          "\\,\\operatorname{d}",
           serializer.serialize(index)
         ]);
       }
@@ -7282,7 +7547,7 @@ var ComputeEngine = (() => {
         sub2,
         "\\!",
         serializer.serialize(fn),
-        ...index && symbol(index) !== "Nothing" ? ["\\,\\mathrm{d}", serializer.serialize(index)] : []
+        ...index && symbol(index) !== "Nothing" ? ["\\,\\operatorname{d}", serializer.serialize(index)] : []
       ]);
     };
   }
@@ -7290,35 +7555,35 @@ var ComputeEngine = (() => {
     {
       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)
     }
   ];
@@ -7425,14 +7690,14 @@ var ComputeEngine = (() => {
       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
       };
     })
@@ -7456,294 +7721,349 @@ var ComputeEngine = (() => {
     "\\rfloor": "\\rfloor"
   };
   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")
+      ;
+    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) {
-      /* @__PURE__ */ console.assert(entry.trigger);
-      if (indexedEntry.kind === "function") {
-        /* @__PURE__ */ console.assert(typeof entry.trigger === "string");
-        const fnName = entry.trigger;
-        if (!result.function.has(fnName))
-          result.function.set(fnName, [indexedEntry]);
-        else
-          result.function.set(fnName, [
-            ...result.function.get(fnName),
-            indexedEntry
-          ]);
-      } else {
-        let triggerString;
-        let tokenCount;
-        if (typeof entry.trigger === "string") {
-          triggerString = entry.trigger;
-          tokenCount = countTokens(triggerString);
-        } else {
-          triggerString = tokensToString(entry.trigger ?? []);
-          tokenCount = entry.trigger.length;
-        }
-        result.lookahead = Math.max(result.lookahead, tokenCount);
-        const kind2 = indexedEntry.kind;
-        if (result[kind2][tokenCount] === void 0)
-          result[kind2][tokenCount] = /* @__PURE__ */ new Map();
-        const list = result[kind2][tokenCount];
-        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 {
-        /* @__PURE__ */ 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 serializeStr = result.serialize;
-        result.serialize = (serializer, expr) => {
-          if (!head(expr))
-            return serializeStr;
-          return `${serializeStr}${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;
     }
-    /* @__PURE__ */ console.assert(
-      typeof entry.trigger !== "string" || entry.parse || trigger.length > 1 || "kind" in entry && entry.kind === "function",
-      `Trigger shortcuts should produce more than one token. Otherwise, not worth using them. (${triggerString})`
-    );
     if (result.kind === "symbol" && isSymbolEntry(entry)) {
       result.precedence = entry.precedence ?? 1e4;
     }
-    if ((result.kind === "infix" || result.kind === "prefix" || result.kind === "postfix") && (isInfixEntry(entry) || isPrefixEntry(entry) || isPostfixEntry(entry))) {
-      if (trigger && (trigger[0] === "^" || trigger[0] === "_")) {
+    if ((result.kind === "prefix" || result.kind === "postfix") && (isPrefixEntry(entry) || isPostfixEntry(entry))) {
+      if (tokensTrigger && (tokensTrigger[0] === "^" || tokensTrigger[0] === "_")) {
         result.precedence = 720;
         /* @__PURE__ */ 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)) {
       /* @__PURE__ */ 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] === "_")) {
-        /* @__PURE__ */ 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];
+        };
+    }
+    if (kind === "matchfix") {
+      const h = entry.parse ?? entry.name;
+      if (h)
+        return (_parser, body) => {
+          if (body === null || isEmptySequence(body))
+            return null;
+          return [h, body];
         };
-      }
-    } else {
-      if (typeof entry.parse === "function") {
-        result.parse = entry.parse;
-      } else if (entry.parse !== void 0) {
-        /* @__PURE__ */ console.assert(result.kind === "symbol" || result.kind === "expression");
-        result.parse = () => entry.parse;
-      } else if (entry.parse === void 0 && entry.name !== void 0) {
-        if (result.kind === "postfix") {
-          result.parse = (_parser, lhs) => lhs ? [entry.name, lhs] : null;
-        } else if (result.kind === "prefix") {
-          const prec = result.precedence;
-          /* @__PURE__ */ 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 === "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: [
@@ -7754,7 +8074,7 @@ var ComputeEngine = (() => {
         });
         return false;
       }
-      if (typeof entry.openDelimiter !== typeof entry.closeDelimiter) {
+      if (typeof entry.openTrigger !== typeof entry.closeTrigger) {
         onError({
           severity: "warning",
           message: [
@@ -7767,7 +8087,7 @@ var ComputeEngine = (() => {
       }
     }
     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",
@@ -7803,14 +8123,14 @@ var ComputeEngine = (() => {
         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;
@@ -7841,7 +8161,7 @@ var ComputeEngine = (() => {
       {
         name: "mu0",
         kind: "symbol",
-        trigger: "\\mu_0"
+        latexTrigger: "\\mu_0"
       }
     ],
     sets: DEFINITIONS_SETS,
@@ -7851,7 +8171,24 @@ var ComputeEngine = (() => {
 
   // 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",
@@ -7878,7 +8215,7 @@ var ComputeEngine = (() => {
     "\\breve": "_breve",
     "\\check": "_check"
   };
-  function matchIdentifierToken(parser, options) {
+  function parseIdentifierToken(parser, options) {
     if (parser.atEnd)
       return null;
     const token = parser.peek;
@@ -7916,7 +8253,7 @@ var ComputeEngine = (() => {
     }
     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;
@@ -7926,7 +8263,7 @@ var ComputeEngine = (() => {
         parser.index = start;
         return null;
       }
-      const body = matchIdentifierBody(parser);
+      const body = parseIdentifierBody(parser);
       if (body === null || !parser.match("<}>")) {
         parser.index = start;
         return null;
@@ -7939,7 +8276,7 @@ var ComputeEngine = (() => {
         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;
@@ -7968,7 +8305,7 @@ var ComputeEngine = (() => {
     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;
@@ -7976,7 +8313,7 @@ var ComputeEngine = (() => {
         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;
@@ -8015,7 +8352,7 @@ var ComputeEngine = (() => {
         body = digit;
         parser.nextToken();
       }
-      body += matchIdentifierBody(parser);
+      body += parseIdentifierBody(parser);
       if (body === null || !parser.match("<}>")) {
         parser.index = start;
         return null;
@@ -8039,7 +8376,7 @@ var ComputeEngine = (() => {
       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;
@@ -8048,19 +8385,14 @@ var ComputeEngine = (() => {
       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;
+        return id;
     }
     parser.index = start;
     return null;
@@ -8129,7 +8461,7 @@ var ComputeEngine = (() => {
     // 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: "\\,",
@@ -8269,13 +8601,12 @@ var ComputeEngine = (() => {
      * 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;
@@ -8337,42 +8668,32 @@ var ComputeEngine = (() => {
         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 - 1; i > 0; i--) {
-        if (defs[i] !== void 0) {
-          /* @__PURE__ */ 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()`.
@@ -8486,9 +8807,8 @@ var ComputeEngine = (() => {
           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) {
@@ -8497,17 +8817,15 @@ var ComputeEngine = (() => {
         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;
@@ -8534,7 +8852,7 @@ var ComputeEngine = (() => {
     // 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(""),
@@ -8593,6 +8911,7 @@ var ComputeEngine = (() => {
           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";
@@ -8636,7 +8955,7 @@ var ComputeEngine = (() => {
     }
     /** Parse an environment: `\begin{env}...\end{end}`
      */
-    parseEnvironment() {
+    parseEnvironment(until) {
       const index = this.index;
       if (!this.match("\\begin"))
         return null;
@@ -8644,22 +8963,22 @@ var ComputeEngine = (() => {
       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 */
@@ -8903,11 +9222,8 @@ var ComputeEngine = (() => {
         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)
@@ -8918,13 +9234,11 @@ var ComputeEngine = (() => {
     }
     parseInfixOperator(lhs, until) {
       until ?? (until = { minPrec: 0 });
+      /* @__PURE__ */ 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);
@@ -8966,44 +9280,6 @@ var ComputeEngine = (() => {
       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.
      *
@@ -9059,9 +9335,7 @@ var ComputeEngine = (() => {
      * @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;
@@ -9084,9 +9358,7 @@ var ComputeEngine = (() => {
      * 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;
@@ -9125,9 +9397,7 @@ var ComputeEngine = (() => {
      * 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;
@@ -9214,8 +9484,7 @@ var ComputeEngine = (() => {
         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);
@@ -9228,7 +9497,7 @@ var ComputeEngine = (() => {
       }
       if (fn === null) {
         this.index = start;
-        fn = matchIdentifier(this);
+        fn = parseIdentifier(this);
         if (!this.isFunctionHead(fn)) {
           this.index = start;
           return null;
@@ -9247,20 +9516,17 @@ var ComputeEngine = (() => {
       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")
@@ -9317,7 +9583,9 @@ var ComputeEngine = (() => {
       }
       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",
@@ -9335,7 +9603,9 @@ var ComputeEngine = (() => {
         }
       }
       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",
@@ -9360,11 +9630,8 @@ var ComputeEngine = (() => {
       /* @__PURE__ */ 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)
@@ -9428,14 +9695,14 @@ var ComputeEngine = (() => {
     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)) {
@@ -9482,9 +9749,9 @@ var ComputeEngine = (() => {
     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") {
@@ -9497,7 +9764,7 @@ var ComputeEngine = (() => {
           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") {
@@ -9508,12 +9775,13 @@ var ComputeEngine = (() => {
           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") {
@@ -9607,7 +9875,10 @@ var ComputeEngine = (() => {
       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("<}>")) {
@@ -9623,7 +9894,7 @@ var ComputeEngine = (() => {
           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))
@@ -9668,8 +9939,9 @@ var ComputeEngine = (() => {
         return null;
       }
       until ?? (until = { minPrec: 0 });
+      /* @__PURE__ */ 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);
@@ -9738,7 +10010,28 @@ var ComputeEngine = (() => {
         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) {
@@ -9978,68 +10271,11 @@ var ComputeEngine = (() => {
     // 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;
@@ -10081,7 +10317,7 @@ var ComputeEngine = (() => {
       }
       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),
@@ -10138,42 +10374,37 @@ var ComputeEngine = (() => {
       );
     }
     serializeSymbol(expr, def) {
-      const h = head(expr);
-      if (h)
-        return this.serializeFunction(expr, def);
       /* @__PURE__ */ 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) => {
@@ -10192,37 +10423,22 @@ var ComputeEngine = (() => {
           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",
@@ -10262,22 +10478,6 @@ var ComputeEngine = (() => {
       return this.options.numericSetStyle(expr, level);
     }
   };
-  function replaceLatex(template, replacement) {
-    /* @__PURE__ */ console.assert(typeof template === "string");
-    /* @__PURE__ */ 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]);
@@ -10353,7 +10553,7 @@ var ComputeEngine = (() => {
     }
     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])
@@ -10369,7 +10569,7 @@ var ComputeEngine = (() => {
       }
       while (rest.length > 0) {
         if (rest.startsWith("__")) {
-          const [sup, rest2] = parseIdentifierBody(
+          const [sup, rest2] = parseIdentifierBody2(
             rest.substring(2),
             false,
             "none"
@@ -10377,7 +10577,7 @@ var ComputeEngine = (() => {
           sups.push(sup);
           rest = rest2;
         } else if (rest.startsWith("_")) {
-          const [sub2, rest2] = parseIdentifierBody(
+          const [sub2, rest2] = parseIdentifierBody2(
             rest.substring(1),
             false,
             "none"
@@ -10416,19 +10616,19 @@ var ComputeEngine = (() => {
     }
     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;
   }
 
@@ -10518,7 +10718,7 @@ var ComputeEngine = (() => {
       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;
@@ -10539,20 +10739,23 @@ var ComputeEngine = (() => {
           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 }],
@@ -11700,6 +11903,9 @@ var ComputeEngine = (() => {
       [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;
@@ -13181,11 +13387,79 @@ var ComputeEngine = (() => {
   // 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 Function("_", `return ${js}`);
+      return new ComputeEngineFunction(js);
     } catch (e) {
       console.error(`${e}
 ${expr.latex}
@@ -13206,7 +13480,12 @@ ${js}`);
         ExponentialE: "Math.E",
         I: "Math.I",
         NaN: "Number.NaN",
-        ImaginaryUnit: "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;
@@ -13235,9 +13514,8 @@ ${js}`);
           return "";
         return `-${compile(arg, freeVars, 3)}`;
       }
-      if (h === "Error") {
-        return "NaN";
-      }
+      if (h === "Error")
+        throw new Error("Error");
       if (h === "Sum")
         return compileLoop(expr, "+");
       if (h === "Product")
@@ -13245,7 +13523,7 @@ ${js}`);
       if (h === "Root") {
         const arg = expr.op1;
         if (arg === null)
-          return "";
+          throw new Error("Root: no argument");
         const exp2 = expr.op2;
         if (exp2 === null)
           return `Math.sqrt(${compile(arg, freeVars, 0)})`;
@@ -13254,24 +13532,63 @@ ${js}`);
       if (h === "Factorial") {
         const arg = expr.op1;
         if (arg === null)
-          return "";
-        return `${compile(arg, freeVars, 3)}!`;
+          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: ["+", 1],
-        Subtract: ["-", 1],
-        Multiply: ["*", 2],
-        Divide: ["/", 3]
+        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 "";
-        const result = [];
-        for (const arg of args2)
-          result.push(compile(arg, freeVars, op3[1]));
-        return op3[1] < prec ? `(${result.join(op3[0])})` : result.join(op3[0]);
+        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",
@@ -13283,13 +13600,18 @@ ${js}`);
         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",
@@ -13323,7 +13645,7 @@ ${js}`);
         // Erfi: 'Math.erfi',
         // Zeta: 'Math.zeta',
         // PolyGamma: 'Math.polygamma',
-        // HurwitzZeta: 'Math.hurwitzZeta',
+        // HurwitzZeta: 'Math.hurwitzZeta', $$\zeta (s,a)=\sum _{n=0}^{\infty }{\frac {1}{(n+a)^{s}}}$$
         // DirichletEta: 'Math.dirichletEta',
         // Beta: 'Math.beta',
         // Binomial: 'Math.binomial',
@@ -13396,7 +13718,7 @@ ${js}`);
       if (args !== null) {
         const result = [];
         for (const arg of args)
-          result.push(compile(arg, freeVars, 0));
+          result.push(compile(arg, freeVars));
         return `${fn}(${result.join(", ")})`;
       }
     }
@@ -13405,18 +13727,18 @@ ${js}`);
   function compileLoop(expr, op3) {
     const args = expr.ops;
     if (args === null)
-      return "NaN";
+      throw new Error("Sum: no arguments");
     if (!expr.op1 || !expr.op2)
-      return "NaN";
+      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;
-  })()`;
+    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
@@ -13744,8 +14066,20 @@ ${js}`);
     N(_options) {
       return this.evaluate();
     }
-    compile() {
-      return compileToJavascript(this);
+    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;
     }
   };
 
@@ -15578,33 +15912,6 @@ ${js}`);
     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());
@@ -19057,7 +19364,7 @@ ${js}`);
         }
       },
       Erf: {
-        description: "Complementary Error Function",
+        description: "Error Function",
         complexity: 7500
       },
       Erfc: {
@@ -19065,7 +19372,7 @@ ${js}`);
         complexity: 7500
       },
       Factorial: {
-        description: "The factorial function",
+        description: "Factorial Function",
         wikidata: "Q120976",
         complexity: 9e3,
         signature: {
@@ -19104,7 +19411,7 @@ ${js}`);
         wikidata: "Q190573",
         complexity: 8e3,
         signature: {
-          domain: ["Function", "Number", "Number", "Number"],
+          domain: ["Function", "Number", "Number"],
           N: (ce, ops2) => applyN(
             ops2[0],
             (x) => gamma(x),
@@ -19116,7 +19423,7 @@ ${js}`);
       LogGamma: {
         complexity: 8e3,
         signature: {
-          domain: ["Function", "Number", "Number", "Number"],
+          domain: ["Function", "Number", "Number"],
           N: (ce, ops2) => applyN(
             ops2[0],
             (x) => lngamma(x),
@@ -20159,7 +20466,7 @@ ${js}`);
       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" } },
@@ -20171,6 +20478,11 @@ ${js}`);
          */
         signature: { domain: "Function" }
       },
+      Derivative: {
+        signature: {
+          domain: ["Function", "Function", ["Maybe", "Number"], "Function"]
+        }
+      },
       Domain: {
         /** Return the domain of an expression */
         signature: {
@@ -20546,7 +20858,7 @@ ${js}`);
     // 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,
@@ -20620,6 +20932,10 @@ ${js}`);
             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")
@@ -22792,26 +23108,6 @@ ${js}`);
     );
   }
 
-  // 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") {
@@ -23842,14 +24138,15 @@ ${JSON.stringify(entry)}`
      * 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 */
@@ -24791,9 +25088,29 @@ ${JSON.stringify(entry)}`
       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)
@@ -24909,10 +25226,10 @@ ${JSON.stringify(entry)}`
   };
 
   // src/compute-engine.ts
-  var version = "0.13.0";
+  var version = "0.14.0";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.13.0"
+    version: "0.14.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();