@cortex-js/compute-engine 0.19.1 → 0.20.1

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.19.1 */
+/** CortexJS Compute Engine 0.20.1 */
     (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;
@@ -3980,6 +3980,13 @@ var ComputeEngine = (() => {
       return Math.max(0, expr.fn.length - 1);
     return 0;
   }
+  function unhold(expr) {
+    if (expr === null || expr === void 0)
+      return null;
+    if (head(expr) === "Hold")
+      return op(expr, 1);
+    return expr;
+  }
   function symbol(expr) {
     if (expr === null || expr === void 0)
       return null;
@@ -3994,14 +4001,6 @@ var ComputeEngine = (() => {
       return null;
     return s;
   }
-  function isListLike(expr) {
-    if (expr === null)
-      return false;
-    const h = head(expr);
-    if (!h || typeof h !== "string")
-      return false;
-    return /^(List|Sequence|Tuple|Single|Pair|Triple)$/.test(h);
-  }
   function keyValuePair(expr) {
     const h = head(expr);
     if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
@@ -4161,21 +4160,21 @@ var ComputeEngine = (() => {
       expr = op(expr, 1);
       if (expr === null)
         return [];
-      if (head(expr) !== "Sequence")
+      h = head(expr);
+      if (h !== "Sequence")
         return [expr];
     }
-    h = head(expr);
     if (h !== "Sequence")
       return null;
     return ops(expr) ?? [];
   }
   function isEmptySequence(expr) {
-    return expr !== null && head(expr) === "Sequence" && nops(expr) === 0;
+    return head(expr) === "Sequence" && nops(expr) === 0;
   }
   function missingIfEmpty(expr) {
-    if (expr === null || isEmptySequence(expr))
+    if (isEmptySequence(expr))
       return MISSING;
-    return expr;
+    return expr ?? MISSING;
   }
   function countFunctionLeaves(xs) {
     if (xs[0] === "Square") {
@@ -4345,9 +4344,9 @@ var ComputeEngine = (() => {
         if (val < 0) {
           result += serializer.serialize(arg);
         } else if (head(arg) === "Negate") {
-          result += serializer.wrap(arg, 275);
+          result += serializer.wrap(arg, ADDITION_PRECEDENCE);
         } else {
-          const term = serializer.wrap(arg, 275);
+          const term = serializer.wrap(arg, ADDITION_PRECEDENCE);
           if (term[0] === "-" || term[0] === "+")
             result += term;
           else
@@ -4355,10 +4354,10 @@ var ComputeEngine = (() => {
         }
       }
     } else if (name === "Subtract") {
-      result = serializer.wrap(arg, 275);
+      result = serializer.wrap(arg, ADDITION_PRECEDENCE);
       const arg2 = op(expr, 2);
       if (arg2 !== null) {
-        const term = serializer.wrap(arg2, 275);
+        const term = serializer.wrap(arg2, ADDITION_PRECEDENCE);
         if (term[0] === "-")
           result += "+" + term.slice(1);
         else if (term[0] === "+")
@@ -4448,7 +4447,7 @@ var ComputeEngine = (() => {
         arg = op(arg, 1);
         isNegative = !isNegative;
       }
-      term = serializer.wrap(arg, 390);
+      term = serializer.wrap(arg, MULTIPLICATION_PRECEDENCE);
       if (!result) {
         result = term;
       } else {
@@ -4697,11 +4696,14 @@ var ComputeEngine = (() => {
       latexTrigger: ["+"],
       kind: "infix",
       associativity: "both",
-      precedence: 275,
+      precedence: ADDITION_PRECEDENCE,
       parse: (parser, lhs, until) => {
-        if (until && 275 < until.minPrec)
+        if (until && ADDITION_PRECEDENCE < until.minPrec)
           return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 275 });
+        const rhs = parser.parseExpression({
+          ...until,
+          minPrec: ADDITION_PRECEDENCE
+        });
         if (rhs === null)
           return null;
         return applyAssociativeOperator("Add", lhs, rhs);
@@ -4711,9 +4713,9 @@ var ComputeEngine = (() => {
     {
       kind: "prefix",
       latexTrigger: ["+"],
-      precedence: 275,
+      precedence: ADDITION_PRECEDENCE,
       parse: (parser, until) => {
-        if (until && 275 < until.minPrec)
+        if (until && ADDITION_PRECEDENCE < until.minPrec)
           return null;
         return parser.parseExpression({ ...until, minPrec: 400 });
       }
@@ -4741,7 +4743,7 @@ var ComputeEngine = (() => {
     { name: "Chop", identifierTrigger: "chop", kind: "function", parse: "Chop" },
     {
       name: "Complex",
-      precedence: 274,
+      precedence: ADDITION_PRECEDENCE - 1,
       // One less than precedence of `Add`: used for correct wrapping
       serialize: (serializer, expr) => {
         const re = machineValue(op(expr, 1));
@@ -4759,7 +4761,7 @@ var ComputeEngine = (() => {
     {
       name: "Divide",
       latexTrigger: "\\frac",
-      precedence: 660,
+      precedence: DIVISION_PRECEDENCE,
       // For \frac specifically, not for \div, etc..
       // handles Leibnitz notation for partial derivatives
       parse: parseFraction,
@@ -4768,14 +4770,14 @@ var ComputeEngine = (() => {
     {
       kind: "infix",
       latexTrigger: "\\over",
-      precedence: 660,
+      precedence: DIVISION_PRECEDENCE,
       parse: "Divide"
     },
     {
       latexTrigger: ["\\/"],
       kind: "infix",
       associativity: "non",
-      precedence: 660,
+      precedence: DIVISION_PRECEDENCE,
       // ??? MathML has 265, but it's wrong.
       // It has to be at least higher than multiply
       // e.g. `1/2+3*x` -> `1/2 + 3*x` , not `1/(2+3*x)`
@@ -4785,14 +4787,14 @@ var ComputeEngine = (() => {
       latexTrigger: ["/"],
       kind: "infix",
       associativity: "non",
-      precedence: 660,
+      precedence: DIVISION_PRECEDENCE,
       parse: "Divide"
     },
     {
       latexTrigger: ["\\div"],
       kind: "infix",
       associativity: "non",
-      precedence: 660,
+      precedence: DIVISION_PRECEDENCE,
       // ??? according to MathML
       parse: "Divide"
     },
@@ -4809,13 +4811,13 @@ var ComputeEngine = (() => {
       name: "Factorial",
       latexTrigger: ["!"],
       kind: "postfix",
-      precedence: 810
+      precedence: POSTFIX_PRECEDENCE
     },
     {
       name: "Factorial2",
       latexTrigger: ["!", "!"],
       kind: "postfix",
-      precedence: 810
+      precedence: POSTFIX_PRECEDENCE
     },
     {
       name: "Floor",
@@ -4948,23 +4950,26 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\mp"],
       kind: "infix",
       associativity: "both",
-      precedence: 270
+      precedence: ARROW_PRECEDENCE
     },
     {
       name: "Multiply",
       latexTrigger: ["\\times"],
       kind: "infix",
       associativity: "both",
-      precedence: 390,
+      precedence: MULTIPLICATION_PRECEDENCE,
       serialize: serializeMultiply
     },
     {
       latexTrigger: ["\\cdot"],
       kind: "infix",
       associativity: "both",
-      precedence: 390,
+      precedence: MULTIPLICATION_PRECEDENCE,
       parse: (parser, lhs, terminator) => {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: 392 });
+        const rhs = parser.parseExpression({
+          ...terminator,
+          minPrec: MULTIPLICATION_PRECEDENCE + 2
+        });
         if (rhs === null)
           return ["Multiply", lhs, MISSING];
         return applyAssociativeOperator("Multiply", lhs, rhs);
@@ -4974,23 +4979,77 @@ var ComputeEngine = (() => {
       latexTrigger: ["*"],
       kind: "infix",
       associativity: "both",
-      precedence: 390,
+      precedence: MULTIPLICATION_PRECEDENCE,
       parse: (parser, lhs, terminator) => {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: 392 });
+        const rhs = parser.parseExpression({
+          ...terminator,
+          minPrec: MULTIPLICATION_PRECEDENCE + 2
+        });
         if (rhs === null)
           return ["Multiply", lhs, MISSING];
         return applyAssociativeOperator("Multiply", lhs, rhs);
       }
     },
+    // Infix modulo, as in `26 \bmod 5`
+    {
+      name: "Mod",
+      latexTrigger: "\\bmod",
+      kind: "infix",
+      precedence: DIVISION_PRECEDENCE,
+      serialize: (serializer, expr) => {
+        if (nops(expr) !== 2)
+          return "";
+        const lhs = serializer.serialize(op(expr, 1));
+        const rhs = serializer.serialize(op(expr, 2));
+        return joinLatex([lhs, "\\bmod", rhs]);
+      }
+    },
+    // Synonym to \\bmod
+    {
+      latexTrigger: "\\mod",
+      kind: "infix",
+      precedence: DIVISION_PRECEDENCE,
+      parse: "Mod"
+    },
+    {
+      latexTrigger: "\\pmod",
+      kind: "prefix",
+      precedence: COMPARISON_PRECEDENCE,
+      parse: (parser) => {
+        const rhs = parser.parseGroup() ?? parser.parseToken();
+        return ["Mod", missingIfEmpty(rhs)];
+      }
+    },
+    {
+      name: "Congruent",
+      serialize: (serializer, expr) => {
+        const lhs = serializer.serialize(op(expr, 1));
+        const rhs = serializer.serialize(op(expr, 2));
+        if (op(expr, 3) === null)
+          return joinLatex([lhs, "\\equiv", rhs]);
+        const modulus = serializer.serialize(op(expr, 3));
+        return joinLatex([lhs, "\\equiv", rhs, "\\pmod{", modulus, "}"]);
+      }
+    },
     {
       name: "Negate",
       latexTrigger: ["-"],
       kind: "prefix",
+      precedence: ADDITION_PRECEDENCE,
       parse: (parser, terminator) => {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
+        if (/\d/.test(parser.peek))
+          return null;
+        const index = parser.index;
+        if (parser.parseNumber() !== null) {
+          parser.index = index;
+          return null;
+        }
+        const rhs = parser.parseExpression({
+          ...terminator,
+          minPrec: ADDITION_PRECEDENCE + 1
+        });
         return ["Negate", missingIfEmpty(rhs)];
-      },
-      precedence: 275
+      }
     },
     // {
     //   /** If the argument is a vector */
@@ -5030,7 +5089,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\pm"],
       kind: "infix",
       associativity: "both",
-      precedence: 270,
+      precedence: ARROW_PRECEDENCE,
       serialize: (serializer, expr) => {
         const op12 = op(expr, 1);
         if (op12 === null)
@@ -5048,7 +5107,7 @@ var ComputeEngine = (() => {
     {
       latexTrigger: ["\\pm"],
       kind: "prefix",
-      precedence: 270,
+      precedence: ARROW_PRECEDENCE,
       parse: (parser, terminator) => {
         const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
         return ["PlusMinus", missingIfEmpty(rhs)];
@@ -5058,7 +5117,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\plusmn"],
       kind: "infix",
       associativity: "both",
-      precedence: 270,
+      precedence: ARROW_PRECEDENCE,
       parse: (parser, lhs, terminator) => {
         const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
         return ["PlusMinus", lhs, missingIfEmpty(rhs)];
@@ -5067,7 +5126,7 @@ var ComputeEngine = (() => {
     {
       latexTrigger: ["\\plusmn"],
       kind: "prefix",
-      precedence: 270,
+      precedence: ARROW_PRECEDENCE,
       parse: (parser, terminator) => {
         const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
         return ["PlusMinus", missingIfEmpty(rhs)];
@@ -5082,9 +5141,9 @@ var ComputeEngine = (() => {
     },
     {
       latexTrigger: "\\prod",
-      precedence: 390,
+      precedence: MULTIPLICATION_PRECEDENCE,
       name: "Product",
-      parse: parseBigOp("Product", 390),
+      parse: parseBigOp("Product", MULTIPLICATION_PRECEDENCE),
       serialize: serializeBigOp("\\prod")
     },
     // {
@@ -5095,7 +5154,7 @@ var ComputeEngine = (() => {
     // },
     {
       name: "Rational",
-      precedence: 660,
+      precedence: DIVISION_PRECEDENCE,
       serialize: (serializer, expr) => {
         if (expr && nops(expr) === 1)
           return "\\operatorname{Rational}" + serializer.wrapArguments(expr);
@@ -5118,9 +5177,9 @@ var ComputeEngine = (() => {
     },
     {
       latexTrigger: ["\\sum"],
-      precedence: 275,
+      precedence: ADDITION_PRECEDENCE,
       name: "Sum",
-      parse: parseBigOp("Sum", 275),
+      parse: parseBigOp("Sum", ADDITION_PRECEDENCE),
       serialize: serializeBigOp("\\sum")
     },
     {
@@ -5140,9 +5199,12 @@ var ComputeEngine = (() => {
       latexTrigger: ["-"],
       kind: "infix",
       associativity: "both",
-      precedence: 275,
+      precedence: ADDITION_PRECEDENCE,
       parse: (parser, lhs, terminator) => {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: 277 });
+        const rhs = parser.parseExpression({
+          ...terminator,
+          minPrec: ADDITION_PRECEDENCE + 2
+        });
         return ["Subtract", lhs, missingIfEmpty(rhs)];
       }
     }
@@ -5243,10 +5305,9 @@ var ComputeEngine = (() => {
 
   // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
   function parseSequence(parser, terminator, lhs, prec, sep) {
-    console.assert(lhs !== null);
     if (terminator.minPrec >= prec)
       return null;
-    const result = [lhs];
+    const result = lhs ? [lhs] : ["Nothing"];
     let done = false;
     while (!done) {
       done = true;
@@ -5270,7 +5331,40 @@ var ComputeEngine = (() => {
     return result;
   }
   function serializeOps(sep = "") {
-    return (serializer, expr) => (ops(expr) ?? []).map((x) => serializer.serialize(x)).join(sep);
+    return (serializer, expr) => {
+      if (!expr)
+        return "";
+      const xs = ops(expr) ?? [];
+      if (xs.length === 0)
+        return "";
+      if (xs.length === 1)
+        return serializer.serialize(xs[0]);
+      sep = {
+        "&": "\\&",
+        ":": "\\colon",
+        "|": "\\mvert",
+        "-": "-",
+        "\xB7": "\\cdot",
+        // U+00B7 MIDDLE DOT
+        "\u2012": "-",
+        // U+2012 FIGURE DASH
+        "\u2013": "--",
+        // U+2013 EN DASH
+        "\u2014": "---",
+        // U+2014 EM DASH
+        "\u2015": "-",
+        // U+2015 HORIZONTAL BAR
+        "\u2022": "\\bullet",
+        // U+2022 BULLET
+        "\u2026": "\\ldots"
+      }[sep] ?? sep;
+      const ys = xs.reduce((acc, item) => {
+        acc.push(serializer.serialize(item), sep);
+        return acc;
+      }, []);
+      ys.pop();
+      return joinLatex(ys);
+    };
   }
   var DEFINITIONS_CORE = [
     //
@@ -5301,7 +5395,7 @@ var ComputeEngine = (() => {
       name: "Function",
       latexTrigger: ["\\mapsto"],
       kind: "infix",
-      precedence: 270,
+      precedence: ARROW_PRECEDENCE,
       // MathML rightwards arrow
       parse: (parser, lhs) => {
         let params = [];
@@ -5309,18 +5403,16 @@ var ComputeEngine = (() => {
           lhs = op(lhs, 1) ?? "Nothing";
         if (head(lhs) === "Sequence") {
           for (const x of ops(lhs) ?? []) {
-            if (symbol(x))
-              params.push(symbol(x));
-            else
+            if (!symbol(x))
               return null;
+            params.push(symbol(x));
           }
         } else {
-          if (symbol(lhs))
-            params = [symbol(lhs)];
-          else
+          if (!symbol(lhs))
             return null;
+          params = [symbol(lhs)];
         }
-        let rhs = parser.parseExpression({ minPrec: 270 }) ?? "Nothing";
+        let rhs = parser.parseExpression({ minPrec: ARROW_PRECEDENCE }) ?? "Nothing";
         if (head(rhs) === "Delimiter")
           rhs = op(rhs, 1) ?? "Nothing";
         if (head(rhs) === "Sequence")
@@ -5378,50 +5470,62 @@ var ComputeEngine = (() => {
         return ["Apply", rhs, lhs];
       }
     },
+    // The mathtools package includes several synonmyms for \colonequals. The
+    // current preferred one is `\coloneq`
     {
       name: "Assign",
-      latexTrigger: "\\coloneqq",
+      latexTrigger: "\\coloneq",
       kind: "infix",
       associativity: "right",
-      precedence: 260,
+      precedence: ASSIGNMENT_PRECEDENCE,
       // parse: (parser: Parser, lhs: Expression) => {
       //   const rhs = parser.parseExpression({ minPrec: 260 }) ?? 'Nothing';
       //   return ['Assign', lhs, rhs];
       // },
       serialize: (serializer, expr) => {
+        const id = unhold(op(expr, 1));
+        if (head(op(expr, 2)) === "Function") {
+          const op_2 = op(expr, 2);
+          const body = unhold(op(op_2, 1));
+          const args = ops(op_2)?.slice(1) ?? [];
+          return joinLatex([
+            serializer.serialize(id),
+            serializer.wrapString(
+              args.map((x) => serializer.serialize(x)).join(", "),
+              serializer.options.applyFunctionStyle(expr, serializer.level)
+            ),
+            "\\coloneq",
+            serializer.serialize(body)
+          ]);
+        }
         return joinLatex([
-          serializer.serialize(op(expr, 1)),
-          "\\coloneqq",
+          serializer.serialize(id),
+          "\\coloneq",
           serializer.serialize(op(expr, 2))
         ]);
-      }
+      },
+      parse: parseAssign
     },
     {
       latexTrigger: [":", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260,
-      parse: "Assign"
+      precedence: ASSIGNMENT_PRECEDENCE,
+      parse: parseAssign
     },
-    // {
-    //   kind: 'function',
-    //   latexTrigger: ':=', // \coloneqq
-    //   parse: (parser: Parser, lhs: Expression) => {
-    //     const rhs = parser.parseExpression({ minPrec: 270 }) ?? 'Nothing';
-    //     return ['Assign', lhs, rhs];
-    //   },
-    // },
     {
       latexTrigger: "\\colonequals",
-      // \coloneqq
       kind: "infix",
       associativity: "right",
-      precedence: 260,
-      parse: "Assign"
-      // parse: (parser: Parser, lhs: Expression) => {
-      //   const rhs = parser.parseExpression({ minPrec: 270 }) ?? 'Nothing';
-      //   return ['Assign', lhs, rhs];
-      // },
+      precedence: ASSIGNMENT_PRECEDENCE,
+      parse: parseAssign
+    },
+    {
+      latexTrigger: "\\coloneqq",
+      kind: "infix",
+      associativity: "right",
+      precedence: ASSIGNMENT_PRECEDENCE,
+      parse: parseAssign
     },
     {
       name: "BaseForm",
@@ -5457,25 +5561,47 @@ var ComputeEngine = (() => {
       }
     },
     {
+      name: "Sequence",
+      // Use a space as a separator, otherwise a sequence of numbers
+      // could be interpreted as a single number.
+      serialize: serializeOps(" ")
+    },
+    {
+      name: "InvisibleOperator",
+      serialize: serializeOps("")
+    },
+    {
+      // The first argument is a function expression.
+      // The second (optional) argument is a string specifying the
+      // delimiters and separator.
       name: "Delimiter",
       serialize: (serializer, expr) => {
-        const argCount = nops(expr);
-        if (argCount === 0)
-          return "";
-        const style = serializer.options.groupStyle(expr, serializer.level + 1);
         const arg1 = op(expr, 1);
+        const style = serializer.options.groupStyle(expr, serializer.level + 1);
         const h1 = head(arg1);
-        const defaultFence = { List: "[],", Sequence: "" }[typeof h1 === "string" ? h1 : ""] ?? "(),";
-        let open = defaultFence[0] ?? "";
-        let close = defaultFence[1] ?? "";
-        let sep = defaultFence[2] ?? "";
-        if (argCount > 1) {
-          const op22 = stringValue(op(expr, 2)) ?? "";
-          open = op22[0] ?? defaultFence[0];
-          close = op22[1] ?? defaultFence[1];
-          sep = op22[2] ?? defaultFence[2];
-        }
-        const body = isListLike(arg1) ? serializeOps(sep)(serializer, arg1) : serializer.serialize(arg1);
+        let delims = {
+          Set: "{,}",
+          List: "[,]",
+          Tuple: "(,)",
+          Single: "(,)",
+          Pair: "(,)",
+          Triple: "(,)",
+          Sequence: "(,)",
+          String: '""'
+        }[typeof h1 === "string" ? h1 : ""] ?? "(,)";
+        if (nops(expr) > 1) {
+          const op22 = stringValue(op(expr, 2));
+          if (typeof op22 === "string" && op22.length <= 3)
+            delims = op22;
+        }
+        let [open, sep, close] = ["", "", ""];
+        if (delims.length === 3)
+          [open, sep, close] = delims;
+        else if (delims.length === 2)
+          [open, close] = delims;
+        else if (delims.length === 1)
+          sep = delims;
+        const body = arg1 ? ops(arg1) ? serializeOps(sep)(serializer, arg1) : serializer.serialize(arg1) : "";
         return serializer.wrapString(body, style, open + close);
       }
     },
@@ -5584,7 +5710,7 @@ var ComputeEngine = (() => {
       kind: "matchfix",
       openTrigger: "(",
       closeTrigger: ")",
-      parse: parseDelimiter
+      parse: parseParenDelimiter
     },
     {
       latexTrigger: [","],
@@ -5599,7 +5725,20 @@ var ComputeEngine = (() => {
         const seq = parseSequence(parser, terminator, lhs, 20, ",");
         if (seq === null)
           return null;
-        return ["Sequence", ...seq];
+        return ["Delimiter", ["Sequence", ...seq], { str: "," }];
+      }
+    },
+    // Entry to handle the case of a single comma
+    // with a missing lhs.
+    {
+      latexTrigger: [","],
+      kind: "prefix",
+      precedence: 20,
+      parse: (parser, terminator) => {
+        const seq = parseSequence(parser, terminator, null, 20, ",");
+        if (seq === null)
+          return null;
+        return ["Delimiter", ["Sequence", ...seq], { str: "," }];
       }
     },
     {
@@ -5627,10 +5766,6 @@ var ComputeEngine = (() => {
         return "";
       }
     },
-    {
-      name: "Sequence",
-      serialize: serializeOps("")
-    },
     {
       latexTrigger: [";"],
       kind: "infix",
@@ -5639,12 +5774,7 @@ var ComputeEngine = (() => {
         const seq = parseSequence(parser, terminator, lhs, 19, ";");
         if (seq === null)
           return null;
-        return [
-          "Sequence",
-          ...seq.map(
-            (x) => head(x) === "Sequence" ? ["List", ...ops(x) ?? []] : x
-          )
-        ];
+        return ["Delimiter", ["Sequence", ...seq], "';'"];
       }
     },
     {
@@ -5911,8 +6041,66 @@ var ComputeEngine = (() => {
           text += "$$";
           parser.index = index;
         }
-      } else
-        text += parser.matchChar() ?? parser.nextToken();
+      } else {
+        const c = parser.matchChar() ?? parser.nextToken();
+        text += {
+          "\\enskip": "\u2002",
+          //  en space
+          "\\enspace": "\u2002",
+          //  en space
+          "\\quad": "\u2003",
+          //  em space
+          "\\qquad": "\u2003\u2003",
+          //  2 em space
+          "\\space": "\u2003",
+          //  em space
+          "\\ ": "\u2003",
+          //  em space
+          "\\;": "\u2004",
+          //  three per em space
+          "\\,": "\u2009",
+          //  thin space
+          "\\:": "\u205F",
+          //  medium mathematical space
+          "\\!": "",
+          //  negative thin space
+          "\\{": "{",
+          "\\}": "}",
+          "\\$": "$",
+          "\\&": "&",
+          "\\#": "#",
+          "\\%": "%",
+          "\\_": "_",
+          "\\textbackslash": "\\",
+          "\\textasciitilde": "~",
+          "\\textasciicircum": "^",
+          "\\textless": "<",
+          "\\textgreater": ">",
+          "\\textbar": "|",
+          "\\textunderscore": "_",
+          "\\textbraceleft": "{",
+          "\\textbraceright": "}",
+          "\\textasciigrave": "`",
+          "\\textquotesingle": "'",
+          "\\textquotedblleft": "\u201C",
+          "\\textquotedblright": "\u201D",
+          "\\textquotedbl": '"',
+          "\\textquoteleft": "\u2018",
+          "\\textquoteright": "\u2019",
+          "\\textbullet": "\u2022",
+          "\\textdagger": "\u2020",
+          "\\textdaggerdbl": "\u2021",
+          "\\textsection": "\xA7",
+          "\\textparagraph": "\xB6",
+          "\\textperiodcentered": "\xB7",
+          "\\textellipsis": "\u2026",
+          "\\textemdash": "\u2014",
+          "\\textendash": "\u2013",
+          "\\textregistered": "\xAE",
+          "\\texttrademark": "\u2122",
+          "\\textdegree": "\xB0"
+        }[c] ?? c;
+      }
     }
     if (runinStyle !== null && text) {
       runs.push(["Style", `'${text}'`, { dict: runinStyle }]);
@@ -5992,19 +6180,27 @@ var ComputeEngine = (() => {
       return ["Prime", missingIfEmpty(lhs)];
     return ["Prime", missingIfEmpty(lhs), order2];
   }
-  function parseDelimiter(_parser, body) {
+  function parseParenDelimiter(_parser, body) {
     if (body === null || isEmptySequence(body))
-      return ["Sequence"];
+      return ["Delimiter"];
+    if (head(body) === "Delimiter" && op(body, 2)) {
+      const delims = stringValue(op(body, 2));
+      if (delims?.length === 1) {
+        return ["Delimiter", op(body, 1) ?? ["Sequence"], { str: `(${delims})` }];
+      }
+    }
     if (head(body) === "Sequence") {
       if (nops(body) === 0)
         return ["Delimiter"];
-      return ["Delimiter", ["Sequence", ...ops(body) ?? []]];
+      return ["Delimiter", body];
     }
-    return ["Delimiter", body];
+    return ["Delimiter", ["Sequence", body]];
   }
   function parseList(_parser, body) {
     if (body === null || isEmptySequence(body))
       return ["List"];
+    if (head(body) === "Delimiter")
+      return parseList(_parser, op(body, 1));
     if (head(body) === "Range")
       return body;
     if (head(body) !== "Sequence" && head(body) !== "List")
@@ -6045,6 +6241,80 @@ var ComputeEngine = (() => {
     }
     return ["Range", start, end];
   }
+  var DELIMITERS_SHORTHAND = {
+    "(": "(",
+    ")": ")",
+    "[": "\\lbrack",
+    "]": "\\rbrack",
+    "\u27E6": "\\llbrack",
+    // U+27E6 MATHEMATICAL LEFT WHITE SQUARE BRACKET
+    "\u27E7": "\\rrbrack",
+    // U+27E7 MATHEMATICAL RIGHT WHITE SQUARE BRACKET
+    "{": "\\lbrace",
+    "}": "\\rbrace",
+    "<": "\\langle",
+    ">": "\\rangle",
+    // '|': '\\vert',
+    "\u2016": "\\Vert",
+    // U+2016 DOUBLE VERTICAL LINE
+    "\\": "\\backslash",
+    "\u2308": "\\lceil",
+    // ⌈ U+2308 LEFT CEILING
+    "\u2309": "\\rceil",
+    // U+2309 RIGHT CEILING
+    "\u230A": "\\lfloor",
+    // ⌊ U+230A LEFT FLOOR
+    "\u230B": "\\rfloor",
+    // ⌋ U+230B RIGHT FLOOR
+    "\u231C": "\\ulcorner",
+    // ⌜ U+231C TOP LEFT CORNER
+    "\u231D": "\\urcorner",
+    // ⌝ U+231D TOP RIGHT CORNER
+    "\u231E": "\\llcorner",
+    // ⌞ U+231E BOTTOM LEFT CORNER
+    "\u231F": "\\lrcorner",
+    // ⌟ U+231F BOTTOM RIGHT CORNER
+    "\u23B0": "\\lmoustache",
+    // U+23B0 UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION
+    "\u23B1": "\\rmoustache"
+    // U+23B1 UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION
+    // '⎹': '', // U+23B9 DIVIDES
+    // '⎾': '', // U+23BE RIGHT PARENTHESIS UPPER HOOK
+    // '⎿': '', // U+23BF RIGHT PARENTHESIS LOWER HOOK
+  };
+  function parseAssign(parser, lhs) {
+    const index = parser.index;
+    if (head(lhs) === "InvisibleOperator" && nops(lhs) === 2 && head(op(lhs, 2)) === "Delimiter" && head(op(op(lhs, 2), 1)) === "Sequence") {
+      const fn = symbol(op(lhs, 1));
+      if (!fn)
+        return null;
+      const args = ops(op(op(lhs, 2), 1));
+      const rhs2 = parser.parseExpression({ minPrec: 0 });
+      if (rhs2 === null) {
+        parser.index = index;
+        return null;
+      }
+      return ["Assign", fn, ["Function", rhs2, ...args ?? []]];
+    }
+    if (typeof head(lhs) === "string") {
+      const fn = head(lhs);
+      const args = ops(lhs) ?? [];
+      const rhs2 = parser.parseExpression({ minPrec: 0 });
+      if (rhs2 === null) {
+        parser.index = index;
+        return null;
+      }
+      return ["Assign", fn, ["Function", rhs2, ...args]];
+    }
+    if (!symbol(lhs))
+      return null;
+    const rhs = parser.parseExpression({ minPrec: 0 });
+    if (rhs === null) {
+      parser.index = index;
+      return null;
+    }
+    return ["Assign", lhs, rhs];
+  }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-inequalities.ts
   var DEFINITIONS_INEQUALITIES = [
@@ -6101,7 +6371,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\leqslant"],
       kind: "infix",
       associativity: "right",
-      precedence: 265,
+      precedence: COMPARISON_PRECEDENCE + 5,
       // Note different precedence than `<=` as per MathML
       parse: "LessEqual"
     },
@@ -6110,28 +6380,28 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\lneqq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "NotLessNotEqual",
       latexTrigger: ["\\nleqq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "LessOverEqual",
       latexTrigger: ["\\leqq"],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
     },
     {
       name: "GreaterOverEqual",
       latexTrigger: ["\\geqq"],
       kind: "infix",
       associativity: "right",
-      precedence: 265,
+      precedence: COMPARISON_PRECEDENCE + 5,
       parse: "GreaterEqual"
     },
     {
@@ -6139,13 +6409,13 @@ var ComputeEngine = (() => {
       latexTrigger: ["="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       latexTrigger: ["*", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260,
+      precedence: COMPARISON_PRECEDENCE,
       parse: "StarEqual"
     },
     {
@@ -6153,42 +6423,42 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\star", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "PlusEqual",
       latexTrigger: ["+", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "MinusEqual",
       latexTrigger: ["-", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "SlashEqual",
       latexTrigger: ["/", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "EqualEqual",
       latexTrigger: ["=", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "EqualEqualEqual",
       latexTrigger: ["=", "=", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
     },
     {
       name: "TildeFullEqual",
@@ -6196,7 +6466,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\cong"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "NotTildeFullEqual",
@@ -6204,7 +6474,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\ncong"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "Approx",
@@ -6228,7 +6498,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\approxeq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "NotApproxEqual",
@@ -6251,7 +6521,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["!", "="],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
       // Note different precedence than \\ne per MathML
     },
     {
@@ -6281,7 +6551,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\geqslant"],
       kind: "infix",
       associativity: "right",
-      precedence: 265,
+      precedence: COMPARISON_PRECEDENCE + 5,
       // Note: different precedence than `>=` as per MathML
       parse: "GreaterEqual"
     },
@@ -6290,14 +6560,14 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\gneqq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "NotGreaterNotEqual",
       latexTrigger: ["\\ngeqq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       latexTrigger: [">"],
@@ -6332,7 +6602,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\circeq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "TriangleEqual",
@@ -6340,7 +6610,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\triangleq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "DotEqual",
@@ -6348,7 +6618,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\doteq"],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
     },
     {
       name: "DotEqualDot",
@@ -6356,7 +6626,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\doteqdot"],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
     },
     {
       name: "FallingDotEqual",
@@ -6364,7 +6634,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\fallingdotseq"],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
     },
     {
       name: "RisingDotEqual",
@@ -6372,77 +6642,182 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\fallingdotseq"],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
     },
     {
       name: "QuestionEqual",
       latexTrigger: ["\\questeq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "MuchLess",
       latexTrigger: ["\\ll"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "MuchGreater",
       latexTrigger: ["\\gg"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "Precedes",
       latexTrigger: ["\\prec"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "Succeeds",
       latexTrigger: ["\\succ"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "PrecedesEqual",
       latexTrigger: ["\\preccurlyeq"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "SucceedsEqual",
       latexTrigger: ["\\curlyeqprec"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "NotPrecedes",
       latexTrigger: ["\\nprec"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "NotSucceeds",
       latexTrigger: ["\\nsucc"],
       kind: "infix",
       associativity: "right",
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     {
       name: "Between",
       latexTrigger: ["\\between"],
       kind: "infix",
       associativity: "right",
-      precedence: 265
+      precedence: COMPARISON_PRECEDENCE + 5
+    }
+  ];
+
+  // src/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.ts
+  var DEFINITIONS_LINEAR_ALGEBRA = [
+    // The first argument is the matrix data.
+    // The second, optional, argument are the delimiters.
+    // The third, optional, argument is the column specification.
+    {
+      name: "Matrix",
+      // https://ctan.math.illinois.edu/macros/latex/required/tools/array.pdf
+      serialize: (serializer, expr) => {
+        const body = op(expr, 1);
+        const delims = op(expr, 2) ?? "()";
+        let columns = "";
+        if (op(expr, 3) !== null) {
+          const colsSpec = stringValue(op(expr, 3)) ?? "";
+          for (const c of colsSpec) {
+            if (c === "<")
+              columns += "l";
+            else if (c === ">")
+              columns += "r";
+            else if (c === "=")
+              columns += "c";
+            else if (c === "|")
+              columns += "|";
+            else if (c === ":")
+              columns += ":";
+          }
+        }
+        let [open, close] = ["", ""];
+        if (typeof delims === "string" && delims.length === 2)
+          [open, close] = delims;
+        const rows = [];
+        for (const row of ops(body) ?? []) {
+          const cells = [];
+          for (const cell of ops(row) ?? [])
+            cells.push(serializer.serialize(cell));
+          rows.push(cells.join(" & "));
+        }
+        const tabular = rows.join("\\\\\n");
+        const optColumns = columns.length > 0 ? `[${columns}]` : "";
+        if (open === "(" && close === ")")
+          return joinLatex([
+            "\\begin{pmatrix}",
+            optColumns,
+            tabular,
+            "\\end{pmatrix}"
+          ]);
+        if (open === "[" && close === "]")
+          return joinLatex([
+            "\\begin{bmatrix}",
+            optColumns,
+            tabular,
+            "\\end{bmatrix}"
+          ]);
+        if (open === "{" && close === "}")
+          return joinLatex([
+            "\\begin{Bmatrix}",
+            optColumns,
+            tabular,
+            "\\end{Bmatrix}"
+          ]);
+        if (open === "|" && close === "|")
+          return joinLatex([
+            "\\begin{vmatrix}",
+            optColumns,
+            tabular,
+            "\\end{vmatrix}"
+          ]);
+        if (open === "\u2016" && close === "\u2016")
+          return joinLatex([
+            "\\begin{Vmatrix}",
+            optColumns,
+            tabular,
+            "\\end{Vmatrix}"
+          ]);
+        if (open === "{" && close === ".")
+          return joinLatex([
+            "\\begin{dcases}",
+            optColumns,
+            tabular,
+            "\\end{dcases}"
+          ]);
+        if (open === "." && close === "}")
+          return joinLatex([
+            "\\begin{rcases}",
+            optColumns,
+            tabular,
+            "\\end{rcases}"
+          ]);
+        if (columns || open !== "." || close !== ".") {
+          return joinLatex([
+            "\\left",
+            DELIMITERS_SHORTHAND[open] ?? open,
+            "\\begin{array}",
+            `{${columns}}`,
+            tabular,
+            "\\end{array}",
+            "\\right",
+            DELIMITERS_SHORTHAND[close] ?? close
+          ]);
+        }
+        return joinLatex(["\\begin{matrix}", tabular, "\\end{matrix}"]);
+      }
     }
   ];
 
@@ -6596,7 +6971,15 @@ var ComputeEngine = (() => {
       kind: "infix",
       associativity: "right",
       precedence: 219,
-      parse: "Equivalent"
+      parse: (parser, lhs, terminator) => {
+        const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
+        const index = parser.index;
+        const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
+        if (modulus && head(modulus) === "Mod")
+          return ["Congruent", lhs, rhs, missingIfEmpty(op(modulus, 1))];
+        parser.index = index;
+        return ["Equivalent", lhs, missingIfEmpty(rhs)];
+      }
     },
     {
       name: "Proves",
@@ -7349,6 +7732,9 @@ var ComputeEngine = (() => {
       parse: (_parser, body) => {
         if (body === null || isEmptySequence(body))
           return "EmptySet";
+        if (head(body) == "Delimiter" && stringValue(op(body, 2)) === ",") {
+          body = op(body, 1);
+        }
         if (head(body) !== "Sequence")
           return ["Set", body];
         return ["Set", ...ops(body) ?? []];
@@ -7373,7 +7759,7 @@ var ComputeEngine = (() => {
       // or \\ominus
       kind: "infix",
       // @todo: parser could check that lhs and rhs are sets
-      precedence: 260
+      precedence: COMPARISON_PRECEDENCE
     },
     // Predicates/Relations
     {
@@ -7707,7 +8093,10 @@ var ComputeEngine = (() => {
     const op12 = op(expr, 1);
     if (!op12)
       return [expr, null];
-    if (h === "Multiply") {
+    if (h === "Sequence" && nops(expr) === 1) {
+      return parseIntegralBodyExpression(op12);
+    }
+    if (h === "Multiply" || h === "InvisibleOperator") {
       const args = ops(expr);
       if (args && args.length > 1) {
         const sym = symbol(args[args.length - 2]);
@@ -7730,7 +8119,7 @@ var ComputeEngine = (() => {
       if (index) {
         if (!fn2)
           return [null, index];
-        return [["Delimiter", fn2, ...ops(expr).slice(1)], index];
+        return [["Delimiter", ["Sequence", fn2], ...ops(expr).slice(1)], index];
       }
     } else if (h === "Add") {
       const args = ops(expr);
@@ -8473,25 +8862,26 @@ var ComputeEngine = (() => {
     return true;
   }
   var DEFAULT_LATEX_DICTIONARY = {
-    algebra: DEFINITIONS_ALGEBRA,
-    arithmetic: DEFINITIONS_ARITHMETIC,
-    calculus: DEFINITIONS_CALCULUS,
-    complex: DEFINITIONS_COMPLEX,
-    core: DEFINITIONS_CORE,
-    logic: DEFINITIONS_LOGIC,
-    relop: DEFINITIONS_INEQUALITIES,
-    other: DEFINITIONS_OTHERS,
-    physics: [
+    "algebra": DEFINITIONS_ALGEBRA,
+    "arithmetic": DEFINITIONS_ARITHMETIC,
+    "calculus": DEFINITIONS_CALCULUS,
+    "complex": DEFINITIONS_COMPLEX,
+    "core": DEFINITIONS_CORE,
+    "linear-algebra": DEFINITIONS_LINEAR_ALGEBRA,
+    "logic": DEFINITIONS_LOGIC,
+    "relop": DEFINITIONS_INEQUALITIES,
+    "other": DEFINITIONS_OTHERS,
+    "physics": [
       {
         name: "mu0",
         kind: "symbol",
         latexTrigger: "\\mu_0"
       }
     ],
-    sets: DEFINITIONS_SETS,
-    statistics: DEFINITIONS_STATISTICS,
-    symbols: DEFINITIONS_SYMBOLS,
-    trigonometry: DEFINITIONS_TRIGONOMETRY
+    "sets": DEFINITIONS_SETS,
+    "statistics": DEFINITIONS_STATISTICS,
+    "symbols": DEFINITIONS_SYMBOLS,
+    "trigonometry": DEFINITIONS_TRIGONOMETRY
   };
 
   // src/compute-engine/latex-syntax/parse-identifier.ts
@@ -8805,7 +9195,6 @@ var ComputeEngine = (() => {
     avoidExponentsInRange: [-7, 20]
   };
   var DEFAULT_PARSE_LATEX_OPTIONS = {
-    applyInvisibleOperator: "auto",
     skipSpace: true,
     parseArgumentsOfUnknownLatexCommands: true,
     parseNumbers: "auto",
@@ -9209,11 +9598,12 @@ var ComputeEngine = (() => {
         this.skipSpace();
         if (this.matchBoundary())
           return expr ?? ["Sequence"];
-        const from = this.index;
         while (!this.matchBoundary() && !this.atEnd)
           this.nextToken();
-        const err = this.error("syntax-error", from);
-        return expr ? ["Sequence", expr, err] : err;
+        if (head(expr) === "Error")
+          return expr;
+        const err = this.error("expected-closing-delimiter", start);
+        return expr ? ["InvisibleOperator", expr, err] : err;
       }
       this.index = start;
       return null;
@@ -9360,7 +9750,7 @@ var ComputeEngine = (() => {
     }
     parseDecimalDigits(options) {
       options ?? (options = {});
-      options.withGrouping ?? (options.withGrouping = false);
+      options.withGrouping ?? (options.withGrouping = true);
       const result = [];
       let done = false;
       while (!done) {
@@ -9385,7 +9775,7 @@ var ComputeEngine = (() => {
     }
     parseSignedInteger(options) {
       options ?? (options = {});
-      options.withGrouping ?? (options.withGrouping = false);
+      options.withGrouping ?? (options.withGrouping = true);
       const start = this.index;
       const sign2 = this.parseOptionalSign();
       const result = this.parseDecimalDigits(options);
@@ -9425,7 +9815,7 @@ var ComputeEngine = (() => {
         this.skipSpaceTokens();
         if (this.matchAll(this._beginExponentMarkerTokens)) {
           this.skipSpaceTokens();
-          const exponent = this.parseSignedInteger();
+          const exponent = this.parseSignedInteger({ withGrouping: false });
           this.skipSpaceTokens();
           if (this.matchAll(this._endExponentMarkerTokens) && exponent)
             return exponent;
@@ -9480,7 +9870,14 @@ var ComputeEngine = (() => {
         return null;
       const start = this.index;
       this.skipVisualSpace();
-      this.match("+");
+      let sign2 = 1;
+      while (this.peek === "-" || this.peek === "+") {
+        if (this.match("-"))
+          sign2 *= -1;
+        else
+          this.match("+");
+        this.skipVisualSpace();
+      }
       let wholePart = "";
       let fractionalPart = "";
       let startsWithDecimalMarker = false;
@@ -9491,21 +9888,17 @@ var ComputeEngine = (() => {
           wholePart = "0";
         }
       } else
-        wholePart = this.parseDecimalDigits({ withGrouping: true });
+        wholePart = this.parseDecimalDigits();
       if (!wholePart) {
         this.index = start;
         return null;
       }
       const fractionalIndex = this.index;
-      let hasFractionalPart = true;
+      let hasFractionalPart = false;
       if (startsWithDecimalMarker || this.match(".") || this.matchAll(this._decimalMarkerTokens)) {
-        fractionalPart = this.parseDecimalDigits({ withGrouping: true });
-        if (!fractionalPart) {
-          this.index = fractionalIndex;
-          return { num: wholePart };
-        }
-      } else
-        hasFractionalPart = false;
+        fractionalPart = this.parseDecimalDigits();
+        hasFractionalPart = true;
+      }
       let hasRepeatingPart = false;
       if (hasFractionalPart) {
         const repeat = this.parseRepeatingDecimal();
@@ -9515,14 +9908,18 @@ var ComputeEngine = (() => {
         } else if (this.match("\\ldots") || this.matchAll(this._truncationMarkerTokens)) {
         }
       }
+      if (hasFractionalPart && !fractionalPart) {
+        this.index = fractionalIndex;
+        return { num: sign2 < 0 ? "-" + wholePart : wholePart };
+      }
       this.skipVisualSpace();
       const exponent = this.parseExponent();
       if (!hasRepeatingPart && this.options.parseNumbers === "rational") {
         const whole = parseInt(wholePart, 10);
         if (!fractionalPart) {
           if (exponent)
-            return ["Multiply", whole, ["Power", 10, exponent]];
-          return whole;
+            return ["Multiply", sign2 * whole, ["Power", 10, exponent]];
+          return sign2 * whole;
         }
         const fraction = parseInt(fractionalPart, 10);
         const n = fractionalPart.length;
@@ -9531,14 +9928,14 @@ var ComputeEngine = (() => {
         if (exponent) {
           return [
             "Multiply",
-            ["Rational", numerator, denominator],
+            ["Rational", sign2 * numerator, denominator],
             ["Power", 10, exponent]
           ];
         }
-        return ["Rational", numerator, denominator];
+        return ["Rational", sign2 * numerator, denominator];
       }
       return {
-        num: wholePart + (hasFractionalPart ? "." + fractionalPart : "") + (exponent ? "e" + exponent : "")
+        num: (sign2 < 0 ? "-" : "") + wholePart + (hasFractionalPart ? "." + fractionalPart : "") + (exponent ? "e" + exponent : "")
       };
     }
     /**
@@ -9666,8 +10063,13 @@ var ComputeEngine = (() => {
         return getSequence(group) ?? [];
       }
       if (kind === "implicit") {
-        if (head(group) === "Delimiter")
-          return getSequence(group) ?? [];
+        if (head(group) === "Delimiter") {
+          if (head(op1(group)) === "Sequence") {
+            const seq = op1(op1(group));
+            return seq ? [seq] : [];
+          }
+          return op1(group) ? [op1(group)] : [];
+        }
         if (group !== null)
           return [group];
         const primary = this.parseExpression({ ...until, minPrec: 390 });
@@ -9926,7 +10328,7 @@ var ComputeEngine = (() => {
         );
         if (defs) {
           const nonEmptySuperscripts = superscripts.filter(
-            (x) => head(x) !== "Sequence"
+            (x) => !(head(x) === "Sequence" && nops(x) === 0)
           );
           if (nonEmptySuperscripts.length !== 0) {
             const superscriptExpression = nonEmptySuperscripts.length === 1 ? nonEmptySuperscripts[0] : ["List", ...nonEmptySuperscripts];
@@ -9995,75 +10397,6 @@ var ComputeEngine = (() => {
       }
       return result;
     }
-    /**
-     * Apply an invisible operator between two expressions.
-     *
-     * If the `lhs` is an literal integer and the `rhs` is a literal rational
-     * -> 'invisible plus'
-     *
-     * That is '2 3/4' -> ['Add', 2, ['Rational', 3, 4]]
-     *
-     * If `lhs` is a number and `rhs` is a number but not a literal -> 'invisible multiply'.
-     * - 2x
-     * - 2(x+1)
-     * - x(x+1)
-     * - f(x)g(y)
-     * - 2 sin(x)
-     * - 2 f(x)
-     * - x f(x)
-     * - (x-1)(x+1)
-     * - (x+1)2 -> no
-     * - x2 -> no
-     * => lhs is a number, rhs is a number, but not a literal
-     */
-    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, minPrec: 0 });
-        if (args === null)
-          return null;
-        return [lhs, ...args];
-      }
-      const start = this.index;
-      const rhs = this.parseExpression({ ...until, minPrec: 390 });
-      if (rhs === null || symbol(rhs) === "Nothing" || isEmptySequence(rhs)) {
-        this.index = start;
-        return null;
-      }
-      if (head(rhs) === "Error")
-        return applyAssociativeOperator("Sequence", lhs, rhs);
-      if (typeof this.options.applyInvisibleOperator === "function")
-        return this.options.applyInvisibleOperator(this, lhs, rhs);
-      if (this.isFunctionHead(lhs)) {
-        const seq = getSequence(rhs);
-        return seq ? [lhs, ...seq] : lhs;
-      }
-      const lhsNumber = machineValue(lhs);
-      if (lhsNumber !== null && Number.isInteger(lhsNumber)) {
-        const rhsHead = head(rhs);
-        if (rhsHead === "Divide" || rhsHead === "Rational") {
-          const [n, d] = [machineValue(op(rhs, 1)), machineValue(op(rhs, 2))];
-          if (n !== null && d !== null && n > 0 && n <= 1e3 && d > 1 && d <= 1e3 && Number.isInteger(n) && Number.isInteger(d))
-            return ["Add", lhs, rhs];
-        }
-      }
-      if (head(rhs) === "Delimiter") {
-        if (head(op(rhs, 1)) === "Sequence")
-          return [lhs, ...ops(op(rhs, 1)) ?? []];
-        if (!op(rhs, 1) || symbol(op(rhs, 1)) === "Nothing")
-          return applyAssociativeOperator(
-            "Sequence",
-            lhs,
-            this.error("expected-expression", start)
-          );
-      }
-      if (head(rhs) === "Sequence" || head(lhs) === "Sequence" || stringValue(lhs) !== null || stringValue(rhs) !== null || dictionary(lhs) !== null || dictionary(rhs) !== null)
-        return applyAssociativeOperator("Sequence", lhs, rhs);
-      return applyAssociativeOperator("Multiply", lhs, rhs);
-    }
     /**
      * This method can be invoked when we know we're in an error situation.
      *
@@ -10269,7 +10602,23 @@ var ComputeEngine = (() => {
           this.skipSpace();
           let result = this.parseInfixOperator(lhs, until);
           if (result === null) {
-            result = this.applyInvisibleOperator(until, lhs);
+            if (this.peekDefinitions("operator").length === 0) {
+              const rhs = this.parseExpression({
+                ...until,
+                minPrec: MULTIPLICATION_PRECEDENCE
+              });
+              if (rhs !== null) {
+                if (head(lhs) === "InvisibleOperator") {
+                  if (head(rhs) === "InvisibleOperator")
+                    result = ["InvisibleOperator", ...ops(lhs), ...ops(rhs)];
+                  else
+                    result = ["InvisibleOperator", ...ops(lhs), rhs];
+                } else if (head(rhs) === "InvisibleOperator") {
+                  result = ["InvisibleOperator", lhs, ...ops(rhs)];
+                } else
+                  result = ["InvisibleOperator", lhs, rhs];
+              }
+            }
           }
           if (result !== null) {
             lhs = result;
@@ -10278,11 +10627,6 @@ var ComputeEngine = (() => {
           }
         }
       }
-      if (!lhs) {
-        lhs = this.parseSyntaxError();
-        while (!this.atTerminator(until))
-          this.nextToken();
-      }
       return this.decorate(lhs, start);
     }
     /**
@@ -10608,7 +10952,7 @@ var ComputeEngine = (() => {
     sansserif: (s) => `\\mathsf{${s}}`,
     monospace: (s) => `\\mathtt{${s}}`
   };
-  var Serializer2 = class {
+  var Serializer4 = class {
     constructor(options, dictionary2, onError) {
       this.level = -1;
       this.options = options;
@@ -10690,10 +11034,24 @@ var ComputeEngine = (() => {
         return s;
       if (fence === void 0)
         fence = "()";
-      const openFence = fence?.[0] ?? ".";
-      const closeFence = fence?.[1] ?? ".";
+      let openFence = fence?.[0] ?? ".";
+      let closeFence = fence?.[1] ?? ".";
       if ((openFence === "." || closeFence === ".") && style === "paren")
         style = "leftright";
+      if (openFence === '"')
+        openFence = "``";
+      else if (openFence === "|")
+        openFence = "\\lvert";
+      else
+        openFence = DELIMITERS_SHORTHAND[openFence] ?? openFence;
+      if (closeFence === '"')
+        closeFence = "''";
+      else if (closeFence === "|")
+        closeFence = "\\rvert";
+      else
+        closeFence = DELIMITERS_SHORTHAND[closeFence] ?? closeFence;
+      if (openFence === "." && closeFence === ".")
+        return s;
       if (style === "leftright")
         return `\\left${openFence}${s}\\right${closeFence}}`;
       if (style === "big")
@@ -11086,7 +11444,7 @@ var ComputeEngine = (() => {
     get serializer() {
       if (this._serializer)
         return this._serializer;
-      this._serializer = new Serializer2(
+      this._serializer = new Serializer4(
         this.options,
         this._dictionary,
         this.onError
@@ -13550,11 +13908,19 @@ var ComputeEngine = (() => {
     return result;
   }
   function flattenSequence(xs) {
-    if (xs.every((x) => x.head !== "Sequence"))
+    if (xs.every((x) => x.head !== "Sequence" && x.head !== "Delimiter"))
       return xs;
     const ys = [];
     for (const x of xs) {
-      if (x.isValid && x.head === "Sequence") {
+      if (!x.isValid)
+        ys.push(x);
+      else if (x.head === "Delimiter") {
+        const seq = x.op1.ops ?? [];
+        if (seq.length === 0)
+          ys.push(x.engine.box(["Tupple"]));
+        else
+          ys.push(...flattenSequence(seq));
+      } else if (x.head === "Sequence") {
         if (x.ops)
           ys.push(...x.ops);
       } else
@@ -13900,7 +14266,7 @@ var ComputeEngine = (() => {
     LogicOperators: [
       "FunctionOf",
       "Booleans",
-      ["OptArg", "Booleans"],
+      ["VarArg", "Booleans"],
       "Booleans"
     ],
     Predicates: ["FunctionOf", "Anything", ["VarArg", "Anything"], "Booleans"],
@@ -14220,7 +14586,7 @@ var ComputeEngine = (() => {
   }
   function checkNumericArgs(ce, ops2, options) {
     let count = typeof options === "number" ? options : options?.count;
-    const flatten = typeof options === "number" ? true : options?.flatten ?? true;
+    const flatten = typeof options === "number" || (options?.flatten ?? true);
     ops2 = canonical(ops2);
     if (flatten)
       ops2 = flattenSequence(ops2);
@@ -14281,7 +14647,7 @@ var ComputeEngine = (() => {
           x.infer(ce.Numbers);
     return xs;
   }
-  function checkArg(ce, arg, dom) {
+  function checkDomain(ce, arg, dom) {
     if (arg === void 0 || arg === null)
       return ce.error("missing");
     if (dom === void 0)
@@ -14295,12 +14661,22 @@ var ComputeEngine = (() => {
       return arg;
     return ce.domainError(dom, arg.domain, arg);
   }
-  function checkArgs(ce, args, doms) {
+  function checkPure(ce, arg) {
+    if (arg === void 0 || arg === null)
+      return ce.error("missing");
+    arg = arg.canonical;
+    if (!arg.isValid)
+      return arg;
+    if (arg.isPure)
+      return arg;
+    return ce.error("expected-pure-expression", arg);
+  }
+  function checkDomains(ce, args, doms) {
     if (args.length === doms.length && args.every((x, i) => !x.domain || x.domain.isCompatible(doms[i])))
       return args;
     const xs = [];
     for (let i = 0; i <= doms.length - 1; i++)
-      xs.push(checkArg(ce, args[i], doms[i]));
+      xs.push(checkDomain(ce, args[i], doms[i]));
     for (let i = doms.length; i <= args.length - 1; i++)
       xs.push(ce.error("unexpected-argument", args[i]));
     return xs;
@@ -14476,9 +14852,9 @@ var ComputeEngine = (() => {
     } else
       index = ce.domainError("Symbols", index.domain, index);
     if (lower && lower.isFinite)
-      lower = checkArg(ce, lower, "Integers");
+      lower = checkDomain(ce, lower, "Integers");
     if (upper && upper.isFinite)
-      upper = checkArg(ce, upper, "Integers");
+      upper = checkDomain(ce, upper, "Integers");
     if (lower && upper)
       return ce.tuple([index, lower, upper]);
     if (upper)
@@ -14567,7 +14943,11 @@ var ComputeEngine = (() => {
     Limit: (args, compile2) => `_SYS.limit(${compile2(args[0])}, ${compile2(args[1])})`,
     Ln: "Math.log",
     List: (args, compile2) => `[${args.map((x) => compile2(x)).join(", ")}]`,
-    Log: "Math.log10",
+    Log: (args, compile2) => {
+      if (args.length === 1)
+        return `Math.log(${compile2(args[0])})`;
+      return `(Math.log(${compile2(args[0])}) / Math.log(${compile2(args[1])}))`;
+    },
     LogGamma: "_SYS.lngamma",
     Lb: "Math.log2",
     Max: "Math.max",
@@ -14803,6 +15183,12 @@ var ComputeEngine = (() => {
       return compileLoop(h, args, target);
     if (args.every((x) => !isCollection(x))) {
       const op3 = target.operators?.(h);
+      if ((h === "NotEqual" || h === "Equal" || h === "Less" || h === "Greater" || h === "LessEqual" || h === "GreaterEqual") && args.length > 2 && op3) {
+        const result = [];
+        for (let i = 0; i < args.length - 1; i++)
+          result.push(compileExpr(h, [args[i], args[i + 1]], op3[1], target));
+        return `(${result.join(") && (")})`;
+      }
       if (op3 !== void 0) {
         if (args === null)
           return "";
@@ -14817,7 +15203,7 @@ var ComputeEngine = (() => {
     }
     if (h === "Function") {
       const params = args.slice(1).map((x) => x.symbol);
-      return `((${params.join(", ")}) => ${compile(args[0], {
+      return `((${params.join(", ")}) => ${compile(args[0].canonical, {
         ...target,
         var: (id) => params.includes(id) ? id : target.var(id)
       })})`;
@@ -19896,6 +20282,12 @@ var ComputeEngine = (() => {
         complexity: 9e3,
         signature: {
           domain: ["FunctionOf", "Numbers", "Numbers"],
+          canonical: (ce, args) => {
+            const base = args[0];
+            if (base instanceof BoxedNumber && base.isNegative)
+              return ce.neg(ce._fn("Factorial", [ce.neg(base)]));
+            return ce._fn("Factorial", [base]);
+          },
           evaluate: (ce, ops2) => {
             const n = asSmallInteger(ops2[0]);
             if (n !== null && n >= 0) {
@@ -19994,7 +20386,7 @@ var ComputeEngine = (() => {
           domain: ["FunctionOf", "Numbers", ["OptArg", "Numbers"], "Numbers"],
           canonical: (ce, ops2) => {
             if (ops2.length === 1)
-              return ce._fn("Log", [checkArg(ce, ops2[0], "Numbers")]);
+              return ce._fn("Log", [checkDomain(ce, ops2[0], "Numbers")]);
             ops2 = checkNumericArgs(ce, ops2, 2);
             if (ops2.length !== 2)
               return ce._fn("Log", ops2);
@@ -20051,6 +20443,27 @@ var ComputeEngine = (() => {
           )
         }
       },
+      Mod: {
+        description: "Modulo",
+        wikidata: "Q1799665",
+        complexity: 2500,
+        threadable: true,
+        signature: {
+          domain: ["FunctionOf", "Numbers", "Numbers", "Numbers"],
+          evaluate: (ce, ops2) => {
+            if (ops2.length !== 2)
+              return void 0;
+            const [lhs, rhs] = ops2;
+            const nLhs = lhs.value;
+            const nRhs = rhs.value;
+            if (typeof nLhs !== "number")
+              return void 0;
+            if (typeof nRhs !== "number")
+              return void 0;
+            return ce.number((nLhs % nRhs + nRhs) % nRhs);
+          }
+        }
+      },
       Multiply: {
         wikidata: "Q40276",
         associative: true,
@@ -20128,7 +20541,10 @@ var ComputeEngine = (() => {
             args = checkNumericArgs(ce, args, 2);
             if (args.length !== 2)
               return ce._fn("Power", args);
-            return ce.pow(args[0], args[1]);
+            const [base, exp2] = args;
+            if (base instanceof BoxedNumber && base.isNegative)
+              return ce.neg(ce.pow(base, exp2));
+            return ce.pow(base, exp2);
           },
           simplify: (ce, ops2) => processPower(ce, ops2[0], ops2[1], "simplify"),
           evaluate: (ce, ops2) => processPower(ce, ops2[0], ops2[1], "evaluate"),
@@ -20162,9 +20578,9 @@ var ComputeEngine = (() => {
               return ce._fn("Rational", [ce.error("missing")]);
             if (args.length === 1)
               return ce._fn("Rational", [
-                checkArg(ce, args[0], "ExtendedRealNumbers")
+                checkDomain(ce, args[0], "ExtendedRealNumbers")
               ]);
-            args = checkArgs(ce, args, ["Integers", "Integers"]);
+            args = checkDomains(ce, args, ["Integers", "Integers"]);
             if (args.length !== 2 || !args[0].isValid || !args[1].isValid)
               return ce._fn("Rational", args);
             return ce.div(args[0], args[1]);
@@ -20325,7 +20741,7 @@ var ComputeEngine = (() => {
           domain: ["FunctionOf", "Numbers", ["OptArg", "Numbers"], "Numbers"],
           canonical: (ce, args) => {
             if (args.length === 1) {
-              const x = checkArg(ce, args[0], "Numbers");
+              const x = checkDomain(ce, args[0], "Numbers");
               if (x.isValid)
                 return ce.neg(x);
             }
@@ -21376,7 +21792,6 @@ var ComputeEngine = (() => {
             "Numbers"
           ],
           canonical: (ce, ops2) => {
-            const body = ops2[0] ?? ce.error("missing");
             let range = ops2[1];
             let index = null;
             let lower = null;
@@ -21396,9 +21811,9 @@ var ComputeEngine = (() => {
             if (!index.symbol)
               index = ce.domainError("Symbols", index.domain, index);
             if (lower)
-              lower = checkArg(ce, lower, ce.Numbers);
+              lower = checkDomain(ce, lower, ce.Numbers);
             if (upper)
-              upper = checkArg(ce, upper, ce.Numbers);
+              upper = checkDomain(ce, upper, ce.Numbers);
             if (lower && upper)
               range = ce.tuple([index, lower, upper]);
             else if (upper)
@@ -21407,7 +21822,11 @@ var ComputeEngine = (() => {
               range = ce.tuple([index, lower]);
             else
               range = index;
-            return ce._fn("Integrate", [body.canonical, range]);
+            let body = ops2[0] ?? ce.error("missing");
+            body = body.canonical;
+            if (body.head === "Delimiter" && body.op1.head === "Sequence")
+              body = body.op1.op1;
+            return ce._fn("Integrate", [body, range]);
           }
         }
       },
@@ -21440,15 +21859,12 @@ var ComputeEngine = (() => {
     //
     // Data Structures
     //
-    Sequence: {
-      signature: {
-        domain: "Functions"
-      }
-    },
     List: {
       complexity: 8200,
+      hold: "all",
       signature: {
-        domain: ["FunctionOf", ["VarArg", "Anything"], "Lists"]
+        domain: ["FunctionOf", ["VarArg", "Anything"], "Lists"],
+        canonical: canonicalList
       },
       size: (expr) => expr.nops,
       iterator: (expr, start, count) => {
@@ -21603,7 +22019,7 @@ var ComputeEngine = (() => {
       signature: {
         domain: ["FunctionOf", "Strings", "Anything", "Tuples"],
         canonical: (ce, args) => {
-          const [key, value] = checkArgs(ce, args, [ce.Strings, "Values"]);
+          const [key, value] = checkDomains(ce, args, [ce.Strings, "Values"]);
           if (!key.isValid || !value.isValid)
             return ce._fn("KeyValuePair", [key, value]);
           return ce.tuple([key, value]);
@@ -22189,6 +22605,17 @@ var ComputeEngine = (() => {
     }
     return result;
   }
+  function canonicalList(ce, ops2) {
+    ops2 = ops2.map((op3) => {
+      if (op3.head === "Delimiter") {
+        if (op3.op1.head === "Sequence")
+          return ce._fn("List", canonical(op3.op1.ops));
+        return ce._fn("List", [op3.op1?.canonical ?? ce.Nothing]);
+      }
+      return op3.canonical;
+    });
+    return ce._fn("List", ops2);
+  }
 
   // src/compute-engine/library/control-structures.ts
   var CONTROL_STRUCTURES_LIBRARY = [
@@ -22624,19 +23051,160 @@ var ComputeEngine = (() => {
     // Inert functions
     //
     {
+      /**
+       * ## THEORY OF OPERATIONS: SEQUENCES
+       *
+       * There are two similar functions used to represent sequences of
+       * expressions:
+       *
+       * - `InvisibleOperator` represent a sequence of expressions
+       *  that are syntactically juxtaposed without any separator or
+       *  operators combining them. For example, `2x` is represented as
+       *  `["InvisibleOperator", 2, "x"]`. `InvisibleOperator` gets
+       *  transformed into `Multiply` (or some other semantic operation)
+       *  during canonicalization.
+       *
+       * - `Sequence` is used to represent a sequence of expressions
+       *   at a semantic level. It is a collection, but it is handled
+       *   specially when canonicalizing expressions, for example it
+       *   is automatically flattened and hoisted to the top level of the
+       *   argument list.
+       *   For example:
+       *    `["Add", "a", ["Sequence", "b", "c"]]` is canonicalized
+       *      to `["Add", "a", "b", "c"]`.
+       *
+       * The empty `Sequence` expression (i.e. `["Sequence"]`) is ignored
+       * but it can be used to represent an "empty" expression.
+       *
+       * - `Delimiter` is used to represent a group of expressions
+       *   with an open and close delimiter and separator. They capture the
+       *   input syntax, and can get transformed into other expressions
+       *   during boxing and canonicalization.
+       *   The first argument is a function expression, such as `List`
+       *   or `Sequence`. The arguments of that expression are represented
+       *   with a separator between them and delimiters around the whole
+       *   group.
+       *   The second argument specify the separator and delimiters. If not
+       *   specified, the default is the string `"(,)"`
+       *
+       * Examples:
+       * - `f(x)` ->
+       *    `["InvisibleOperator",
+       *        "f",
+       *        ["Delimiter", ["Sequence", "x"], "'(,)'"]
+       *     ]`
+       *
+       * - `1, 2; 3, 4` ->
+       *    `["Delimiter",
+       *      ["Sequence",
+       *        ["Delimiter", ["Sequence", 1, 2], "','"],
+       *        ["Delimiter", ["Sequence", 3, 4], "','"],
+       *      ],
+       *     "';'"
+       *    ]`
+       *
+       * - `2x` -> `["InvisibleOperator", 2, "x"]`
+       *
+       * - `2+` -> `["InvisibleOperator", 2, ["Error", "'unexpected-operator'", "+"]]`
+       *
+       *
+       *
+       *
+       */
+      InvisibleOperator: {
+        complexity: 9e3,
+        hold: "all",
+        signature: {
+          restParam: "Anything",
+          result: (ce, args) => {
+            if (args.length === 0)
+              return ce.domain("NothingDomain");
+            if (args.length === 1)
+              return args[0].domain;
+            return ce.Anything;
+          },
+          canonical: canonicalInvisibleOperator
+        }
+      },
+      /** See above for a theory of operations */
+      Sequence: {
+        hold: "all",
+        signature: {
+          restParam: "Anything",
+          result: (ce, args) => {
+            if (args.length === 0)
+              return ce.domain("NothingDomain");
+            if (args.length === 1)
+              return args[0].domain;
+            return ce.Anything;
+          },
+          canonical: (ce, args) => {
+            const xs = canonical(flattenSequence(args));
+            if (xs.length === 0)
+              return ce._fn("Sequence", []);
+            if (xs.length === 1)
+              return xs[0];
+            return ce._fn("Sequence", xs);
+          }
+        }
+      },
+      /** See above for a theory of operations */
       Delimiter: {
-        // Use to represent groups of expressions. Named after https://en.wikipedia.org/wiki/Delimiter
+        // Use to represent groups of expressions.
+        // Named after https://en.wikipedia.org/wiki/Delimiter
         complexity: 9e3,
-        hold: "first",
+        hold: "all",
         signature: {
-          domain: [
-            "FunctionOf",
-            "Anything",
-            ["OptArg", "Strings", "Strings"],
-            "Anything"
-          ],
+          params: ["Anything"],
+          optParams: ["Strings"],
           result: (_ce, args) => args[0].domain,
-          canonical: (ce, args) => args[0]?.canonical ?? ce.box(["Sequence"])
+          // During canonicalization, Delimiters get replaced by their first
+          // argument, which is a function expression (e.g. `List` or `Sequence`)
+          canonical: (ce, args) => {
+            if (args.length === 0)
+              return ce._fn("Tuple", []);
+            let body = args[0];
+            console.assert(body.ops !== null);
+            if (body.head === "Sequence")
+              body = ce._fn("Sequence", ce.canonical(body.ops));
+            args = [body, ...args.slice(1)];
+            if (args.length === 1)
+              return ce._fn("Delimiter", args);
+            if (args.length > 2)
+              return ce._fn("Delimiter", checkArity(ce, args, 2));
+            if ((args[1].string?.length ?? 0) > 3) {
+              return ce._fn("Delimiter", [
+                args[0],
+                ce.error("invalid-delimiter", args[1])
+              ]);
+            }
+            return ce._fn("Delimiter", [
+              args[0],
+              checkDomain(ce, args[1], "Strings")
+            ]);
+          },
+          evaluate: (ce, ops2) => {
+            if (ops2.length === 0)
+              return ce.Nothing;
+            const op12 = ops2[0];
+            if (op12.head === "Sequence" || op12.head === "Delimiter")
+              ops2 = flattenSequence(ops2[0].ops);
+            return ce._fn(
+              "Tuple",
+              ops2.map((x) => x.evaluate())
+            );
+          },
+          N: (ce, ops2) => {
+            if (ops2.length === 0)
+              return ce.Nothing;
+            const op12 = ops2[0];
+            if (op12.head === "Sequence" || op12.head === "Delimiter")
+              ops2 = flattenSequence(ops2[0].ops);
+            return ce._fn(
+              "Tuple",
+              ops2.map((x) => x.N())
+            );
+          }
         }
       },
       Error: {
@@ -22661,7 +23229,7 @@ var ComputeEngine = (() => {
         signature: {
           domain: ["FunctionOf", "Strings", ["VarArg", "Anything"], "Anything"],
           canonical: (ce, args) => {
-            const code = checkArg(ce, args[0], ce.Strings).string;
+            const code = checkDomain(ce, args[0], ce.Strings).string;
             if (code === "incompatible-domain") {
               return ce._fn("ErrorCode", [ce.string(code), args[1], args[2]]);
             }
@@ -22681,11 +23249,11 @@ var ComputeEngine = (() => {
               return ce.domain("Strings");
             if (op12.head === "Numbers")
               return ce.domain("Numbers");
-            return void 0;
+            return op12.domain;
           },
           // By definition, for arguments of the canonical expression of
           // `Hold` are not canonicalized.
-          canonical: (ce, args) => args.length !== 1 ? null : ce._fn("Hold", args),
+          canonical: (ce, args) => args.length !== 1 ? null : ce.hold(args[0]),
           evaluate: (ce, ops2) => ops2[0]
         }
       },
@@ -22780,18 +23348,17 @@ var ComputeEngine = (() => {
       },
       Assign: {
         hold: "all",
+        pure: false,
         signature: {
-          domain: ["FunctionOf", "Symbols", "Anything", "Anything"],
+          domain: ["FunctionOf", "Anything", "Anything", "Anything"],
           canonical: (ce, args) => {
             if (args.length !== 2)
               return null;
             const op12 = args[0];
-            const op22 = args[1];
             if (!op12.symbol)
               return null;
-            if (op22.symbol)
-              return ce._fn("Assign", args);
-            return ce._fn("Assign", [op12, ce._fn("Hold", [op22])]);
+            const op22 = args[1];
+            return ce._fn("Assign", [op12, op22]);
           },
           evaluate: (ce, ops2) => {
             const op12 = ops2[0];
@@ -22806,6 +23373,7 @@ var ComputeEngine = (() => {
       },
       Assume: {
         hold: "all",
+        pure: false,
         signature: {
           domain: ["FunctionOf", "Anything", "Anything"],
           evaluate: (ce, ops2) => ce.string(ce.assume(ops2[0]))
@@ -22813,6 +23381,7 @@ var ComputeEngine = (() => {
       },
       Declare: {
         hold: "all",
+        pure: false,
         signature: {
           domain: ["FunctionOf", "Symbols", "Anything"],
           canonical: (ce, args) => {
@@ -22966,17 +23535,15 @@ var ComputeEngine = (() => {
             const op22 = args[1];
             if (op12.string) {
               const base = asSmallInteger(op22);
-              if (base !== null) {
-                if (base > 1 && base <= 36) {
-                  const [value, rest] = fromDigits(op12.string, base);
-                  if (rest) {
-                    return ce.error(
-                      ["unexpected-digit", { str: rest[0] }],
-                      ["LatexString", ce.string(op12.string)]
-                    );
-                  }
-                  return ce.number(value);
+              if (base !== null && base > 1 && base <= 36) {
+                const [value, rest] = fromDigits(op12.string, base);
+                if (rest) {
+                  return ce.error(
+                    ["unexpected-digit", { str: rest[0] }],
+                    ["LatexString", ce.string(op12.string)]
+                  );
                 }
+                return ce.number(value);
               }
             }
             if (op12.symbol) {
@@ -23094,9 +23661,74 @@ var ComputeEngine = (() => {
       }
     }
   ];
+  function canonicalInvisibleOperator(ce, ops2) {
+    if (ops2.length === 0)
+      return null;
+    const lhs = ops2[0];
+    if (ops2.length === 1)
+      return canonicalInvisibleOperator(ce, [lhs.canonical]);
+    if (ops2.length === 2) {
+      const lhsNumber = asFloat(lhs);
+      if (lhsNumber !== null && Number.isInteger(lhsNumber)) {
+        const rhs2 = ops2[1];
+        if (rhs2.head === "Divide" || rhs2.head === "Rational") {
+          const [n, d] = [asFloat(rhs2.op1), asFloat(rhs2.op2)];
+          if (n !== null && d !== null && n > 0 && n <= 1e3 && d > 1 && d <= 1e3 && Number.isInteger(n) && Number.isInteger(d))
+            return ce.add([lhs.canonical, rhs2.canonical]);
+        }
+      }
+      let rhs = ops2[1];
+      if (lhs.symbol && rhs.head === "Delimiter" && !ce.lookupSymbol(lhs.symbol)) {
+        if (!ce.lookupFunction(lhs.symbol)) {
+          ce.declare(lhs.symbol, "Functions");
+        }
+        if (rhs.nops === 0)
+          return ce.box([lhs.symbol]);
+        rhs = rhs.op1;
+        if (rhs.head === "Sequence")
+          return ce.box([lhs.symbol, ...ce.canonical(rhs.ops)]);
+        return ce.box([lhs.symbol, rhs.canonical]);
+      }
+    }
+    ops2 = canonical(flattenSequence(ops2));
+    if (ops2.every(
+      (x) => x.isValid && (!x.domain || x.domain.isNumeric || isIndexableCollection(x) && !x.string)
+    ))
+      return ce._fn("Multiply", flattenOps(ops2, "Multiply"));
+    return ce._fn("Tuple", ops2);
+  }
 
   // src/compute-engine/library/linear-algebra.ts
-  var LINEAR_ALGEBRA_LIBRARY = [];
+  var LINEAR_ALGEBRA_LIBRARY = [
+    {
+      Matrix: {
+        complexity: 9e3,
+        hold: "all",
+        signature: {
+          params: ["Lists"],
+          optParams: ["Strings", "Strings"],
+          result: "Lists",
+          canonical: canonicalMatrix,
+          evaluate: (_ce, ops2) => ops2[0].evaluate(),
+          N: (_ce, ops2) => ops2[0].N()
+        }
+      }
+    }
+  ];
+  function canonicalMatrix(ce, ops2) {
+    if (ops2.length === 0)
+      return ce._fn("Matrix", []);
+    const body = ops2[0].canonical;
+    const delims = ops2[1]?.canonical;
+    const columns = ops2[2]?.canonical;
+    if (ops2.length > 3)
+      return ce._fn("Matrix", checkArity(ce, ops2, 3));
+    if (columns)
+      return ce._fn("Matrix", [body, delims, columns]);
+    if (delims)
+      return ce._fn("Matrix", [body, delims]);
+    return ce._fn("Matrix", [body]);
+  }
 
   // src/compute-engine/library/logic.ts
   var LOGIC_LIBRARY = {
@@ -23161,6 +23793,15 @@ var ComputeEngine = (() => {
       complexity: 10200,
       signature: {
         domain: "LogicOperators",
+        canonical: (ce, args) => {
+          const lhs = args[0].symbol;
+          const rhs = args[1].symbol;
+          if (lhs === "True" && rhs === "True" || lhs === "False" && rhs === "False")
+            return ce.True;
+          if (lhs === "True" && rhs === "False" || lhs === "False" && rhs === "True")
+            return ce.False;
+          return ce._fn("Equivalent", args);
+        },
         simplify: processEquivalent,
         evaluate: processEquivalent
       }
@@ -23230,7 +23871,7 @@ var ComputeEngine = (() => {
     return ce._fn("Or", ops2);
   }
   function processNot(ce, args) {
-    const op12 = args[0].symbol;
+    const op12 = args[0]?.symbol;
     if (op12 === "True")
       return ce.False;
     if (op12 === "False")
@@ -23294,17 +23935,42 @@ var ComputeEngine = (() => {
 
   // src/compute-engine/library/relational-operator.ts
   var RELOP_LIBRARY = {
+    Congruent: {
+      commutative: false,
+      complexity: 11e3,
+      numeric: true,
+      signature: {
+        simplify: (ce, ops2) => {
+          if (ops2.length < 3)
+            return void 0;
+          return ce._fn("Equal", [
+            ce.box(["Mod", ops2[0], ops2[2]]).simplify(),
+            ce.box(["Mod", ops2[1], ops2[2]]).simplify()
+          ]).simplify();
+        },
+        evaluate: (ce, ops2) => {
+          if (ops2.length < 3)
+            return void 0;
+          const [lhs, rhs, modulo] = ops2;
+          const nLhs = lhs.value;
+          const nRhs = rhs.value;
+          const nModulo = modulo.value;
+          if (typeof nLhs !== "number")
+            return void 0;
+          if (typeof nRhs !== "number")
+            return void 0;
+          if (typeof nModulo !== "number")
+            return void 0;
+          return nLhs % nModulo === nRhs % nModulo ? ce.True : ce.False;
+        }
+      }
+    },
     Equal: {
       commutative: true,
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, ops2) => {
-          return ce._fn(
-            "Equal",
-            flattenOps(flattenSequence(canonical(ops2)), "Equal")
-          );
-        },
+        canonical: (ce, args) => canonicalRelational(ce, "Equal", args),
         evaluate: (ce, ops2) => {
           if (ops2.length < 2)
             return ce.True;
@@ -23328,6 +23994,7 @@ var ComputeEngine = (() => {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "NotEqual", args),
         evaluate: (ce, ops2) => {
           if (ops2.length < 2)
             return ce.False;
@@ -23349,7 +24016,7 @@ var ComputeEngine = (() => {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, ops2) => ce._fn("Less", flattenOps(flattenSequence(canonical(ops2)), "Less")),
+        canonical: (ce, ops2) => canonicalRelational(ce, "Less", ops2),
         evaluate: (ce, ops2) => {
           if (ops2.length < 2)
             return ce.True;
@@ -23376,14 +24043,14 @@ var ComputeEngine = (() => {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("Less", args)])
+        canonical: (ce, ops2) => ce._fn("Not", [canonicalRelational(ce, "Less", ops2)])
       }
     },
     Greater: {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Less", args.reverse()),
+        canonical: (ce, ops2) => canonicalRelational(ce, "Less", ops2.reverse()),
         evaluate: (ce, ops2) => {
           if (ops2.length < 2)
             return ce.True;
@@ -23417,6 +24084,7 @@ var ComputeEngine = (() => {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
+        canonical: (ce, ops2) => canonicalRelational(ce, "LessEqual", ops2),
         evaluate: (ce, ops2) => {
           if (ops2.length < 2)
             return ce.True;
@@ -23443,14 +24111,14 @@ var ComputeEngine = (() => {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("LessEqual", args)])
+        canonical: (ce, ops2) => ce._fn("Not", [canonicalRelational(ce, "LessEqual", ops2)])
       }
     },
     GreaterEqual: {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("LessEqual", args.reverse()),
+        canonical: (ce, args) => canonicalRelational(ce, "LessEqual", args.reverse()),
         evaluate: (ce, ops2) => {
           if (ops2.length < 2)
             return ce.True;
@@ -23477,94 +24145,136 @@ var ComputeEngine = (() => {
       complexity: 11e3,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("GreaterEqual", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "GreaterEqual", args)])
       }
     },
     TildeFullEqual: {
       description: "Indicate isomorphism, congruence and homotopic equivalence",
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "TildeFullEqual", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotTildeFullEqual: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("TildeFullEqual", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "TildeFullEqual", args)])
       }
     },
     TildeEqual: {
       description: "Approximately or asymptotically equal",
       complexity: 11e3,
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "TildeEqual", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotTildeEqual: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("TildeEqual", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "TildeEqual", args)])
       }
     },
     Approx: {
       complexity: 11100,
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "Approx", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotApprox: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("Approx", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "Approx", args)])
       }
     },
     ApproxEqual: {
       complexity: 11100,
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "ApproxEqual", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotApproxEqual: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("ApproxEqual", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "ApproxEqual", args)])
       }
     },
     ApproxNotEqual: {
       complexity: 11100,
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "ApproxNotEqual", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotApproxNotEqual: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("ApproxNotEqual", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "ApproxNotEqual", args)])
       }
     },
     Precedes: {
       complexity: 11100,
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "Precedes", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotPrecedes: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("Precedes", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "Precedes", args)])
       }
     },
     Succeeds: {
-      signature: { domain: "RelationalOperators" }
+      signature: {
+        domain: "RelationalOperators",
+        canonical: (ce, args) => canonicalRelational(ce, "Succeeds", args)
+      }
       // @todo evaluate: (ce, ...args: BoxedExpression[]) => SemiBoxedExpression {}
     },
     NotSucceeds: {
       complexity: 11100,
       signature: {
         domain: "RelationalOperators",
-        canonical: (ce, args) => ce._fn("Not", [ce._fn("Succeeds", args)])
+        canonical: (ce, args) => ce._fn("Not", [canonicalRelational(ce, "Succeeds", args)])
       }
     }
   };
+  function canonicalRelational(ce, head2, ops2) {
+    ops2 = flattenOps(flattenSequence(canonical(ops2)), head2);
+    const nestedRelational = [];
+    let newOps = [];
+    for (const op3 of ops2) {
+      if (isRelationalOperator(op3)) {
+        nestedRelational.push(op3);
+        newOps.push(op3.ops[op3.ops.length - 1]);
+      } else
+        newOps.push(op3);
+    }
+    newOps = newOps.map((op3) => checkPure(ce, op3));
+    if (nestedRelational.length === 0)
+      return ce._fn(head2, newOps);
+    return ce._fn("And", [ce._fn(head2, newOps), ...nestedRelational]);
+  }
+  function isRelationalOperator(op3) {
+    return typeof op3.head === "string" && /Equal|NotEqual|Less|NotLess|Greater|NotGreater|LessEqual|NotLessNotEqual|GreaterEqual|NotGreater|NotEqual|TildeFullEqual|NotTildeFullEqual|TildeEqual|NotTildeEqual|Approx|NotApprox|ApproxEqual|NotApproxEqual|ApproxNotEqual|NotApproxNotEqual|Precedes|NotPrecedes|Succeeds|NotSucceeds/.test(
+      op3.head
+    );
+  }
 
   // src/compute-engine/library/sets.ts
   var SETS_LIBRARY = {
@@ -26362,14 +27072,7 @@ ${JSON.stringify(entry)}`
       return this._hash;
     }
     get isPure() {
-      const def = this._def ?? this.engine.lookupSymbol(this._id, this.wikidata);
-      if (!def)
-        return false;
-      if (def instanceof _BoxedSymbolDefinition)
-        return (def?.constant && def.value?.isPure) ?? false;
-      if (def instanceof _BoxedFunctionDefinition)
-        return def?.pure ?? false;
-      return false;
+      return true;
     }
     get json() {
       const wikidata = this._scope ? this.wikidata : void 0;
@@ -26878,15 +27581,15 @@ ${JSON.stringify(entry)}`
         TranscendentalNumbers: null,
         PositiveNumbers: null,
         Functions: null,
-        // (Anything^n) -> Anything
+        // (Anything*) -> Anything
         NumericFunctions: null,
-        // (Numbers^n) -> Numbers
+        // (Numbers+) -> Numbers
         RealFunctions: null,
-        // (ExtendedRealNumbers^n) -> ExtendRealNumbers
+        // (ExtendedRealNumbers+) -> ExtendRealNumbers
         LogicOperators: null,
-        // (Booleans, Booleans) -> Boolean
+        // (Booleans+) -> Boolean
         Predicates: null
-        // (Anything^n) -> Booleans
+        // (Anything+) -> Booleans
       };
       if (options !== void 0 && typeof options !== "object")
         throw Error("Unexpected argument");
@@ -27158,7 +27861,12 @@ ${JSON.stringify(entry)}`
     bignum(a) {
       if (typeof a === "bigint")
         return new this._bignum(a.toString());
-      return new this._bignum(a);
+      try {
+        return new this._bignum(a);
+      } catch (e) {
+        console.error(e);
+      }
+      return this._BIGNUM_NAN;
     }
     complex(a, b) {
       if (a instanceof Decimal)
@@ -27507,11 +28215,10 @@ ${JSON.stringify(entry)}`
         const scope = symDef.scope;
         scope?.ids?.delete(symDef.name);
         if (!args && !isFunctionValue(value)) {
-          if (value === void 0 || value === null) {
+          if (value === void 0 || value === null)
             symDef.value = void 0;
-            return this;
-          }
-          symDef.value = this.box(value);
+          else
+            symDef.value = this.box(value);
           scope?.ids?.set(symDef.name, symDef);
           return this;
         }
@@ -28144,10 +28851,10 @@ ${JSON.stringify(entry)}`
   }
 
   // src/compute-engine.ts
-  var version = "0.19.1";
+  var version = "0.20.1";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.19.1"
+    version: "0.20.1"
   };
   return __toCommonJS(compute_engine_exports);
 })();