@cortex-js/compute-engine 0.19.1 → 0.20.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.19.1 */
+/** CortexJS Compute Engine 0.20.1 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3950,6 +3950,13 @@ function nops(expr) {
     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;
@@ -3964,14 +3971,6 @@ function symbol(expr) {
     return null;
   return s;
 }
-function isListLike(expr) {
-  if (expr === null)
-    return false;
-  const h = head(expr);
-  if (!h || typeof h !== "string")
-    return false;
-  return /^(List|Sequence|Tuple|Single|Pair|Triple)$/.test(h);
-}
 function keyValuePair(expr) {
   const h = head(expr);
   if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
@@ -4131,21 +4130,21 @@ function getSequence(expr) {
     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") {
@@ -4315,9 +4314,9 @@ function serializeAdd(serializer, expr) {
       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
@@ -4325,10 +4324,10 @@ function serializeAdd(serializer, expr) {
       }
     }
   } 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] === "+")
@@ -4418,7 +4417,7 @@ function serializeMultiply(serializer, expr) {
       arg = op(arg, 1);
       isNegative = !isNegative;
     }
-    term = serializer.wrap(arg, 390);
+    term = serializer.wrap(arg, MULTIPLICATION_PRECEDENCE);
     if (!result) {
       result = term;
     } else {
@@ -4667,11 +4666,14 @@ var DEFINITIONS_ARITHMETIC = [
     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);
@@ -4681,9 +4683,9 @@ var DEFINITIONS_ARITHMETIC = [
   {
     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 });
     }
@@ -4711,7 +4713,7 @@ var DEFINITIONS_ARITHMETIC = [
   { 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));
@@ -4729,7 +4731,7 @@ var DEFINITIONS_ARITHMETIC = [
   {
     name: "Divide",
     latexTrigger: "\\frac",
-    precedence: 660,
+    precedence: DIVISION_PRECEDENCE,
     // For \frac specifically, not for \div, etc..
     // handles Leibnitz notation for partial derivatives
     parse: parseFraction,
@@ -4738,14 +4740,14 @@ var DEFINITIONS_ARITHMETIC = [
   {
     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)`
@@ -4755,14 +4757,14 @@ var DEFINITIONS_ARITHMETIC = [
     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"
   },
@@ -4779,13 +4781,13 @@ var DEFINITIONS_ARITHMETIC = [
     name: "Factorial",
     latexTrigger: ["!"],
     kind: "postfix",
-    precedence: 810
+    precedence: POSTFIX_PRECEDENCE
   },
   {
     name: "Factorial2",
     latexTrigger: ["!", "!"],
     kind: "postfix",
-    precedence: 810
+    precedence: POSTFIX_PRECEDENCE
   },
   {
     name: "Floor",
@@ -4918,23 +4920,26 @@ var DEFINITIONS_ARITHMETIC = [
     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);
@@ -4944,23 +4949,77 @@ var DEFINITIONS_ARITHMETIC = [
     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 */
@@ -5000,7 +5059,7 @@ var DEFINITIONS_ARITHMETIC = [
     latexTrigger: ["\\pm"],
     kind: "infix",
     associativity: "both",
-    precedence: 270,
+    precedence: ARROW_PRECEDENCE,
     serialize: (serializer, expr) => {
       const op12 = op(expr, 1);
       if (op12 === null)
@@ -5018,7 +5077,7 @@ var DEFINITIONS_ARITHMETIC = [
   {
     latexTrigger: ["\\pm"],
     kind: "prefix",
-    precedence: 270,
+    precedence: ARROW_PRECEDENCE,
     parse: (parser, terminator) => {
       const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["PlusMinus", missingIfEmpty(rhs)];
@@ -5028,7 +5087,7 @@ var DEFINITIONS_ARITHMETIC = [
     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)];
@@ -5037,7 +5096,7 @@ var DEFINITIONS_ARITHMETIC = [
   {
     latexTrigger: ["\\plusmn"],
     kind: "prefix",
-    precedence: 270,
+    precedence: ARROW_PRECEDENCE,
     parse: (parser, terminator) => {
       const rhs = parser.parseExpression({ ...terminator, minPrec: 400 });
       return ["PlusMinus", missingIfEmpty(rhs)];
@@ -5052,9 +5111,9 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     latexTrigger: "\\prod",
-    precedence: 390,
+    precedence: MULTIPLICATION_PRECEDENCE,
     name: "Product",
-    parse: parseBigOp("Product", 390),
+    parse: parseBigOp("Product", MULTIPLICATION_PRECEDENCE),
     serialize: serializeBigOp("\\prod")
   },
   // {
@@ -5065,7 +5124,7 @@ var DEFINITIONS_ARITHMETIC = [
   // },
   {
     name: "Rational",
-    precedence: 660,
+    precedence: DIVISION_PRECEDENCE,
     serialize: (serializer, expr) => {
       if (expr && nops(expr) === 1)
         return "\\operatorname{Rational}" + serializer.wrapArguments(expr);
@@ -5088,9 +5147,9 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     latexTrigger: ["\\sum"],
-    precedence: 275,
+    precedence: ADDITION_PRECEDENCE,
     name: "Sum",
-    parse: parseBigOp("Sum", 275),
+    parse: parseBigOp("Sum", ADDITION_PRECEDENCE),
     serialize: serializeBigOp("\\sum")
   },
   {
@@ -5110,9 +5169,12 @@ var DEFINITIONS_ARITHMETIC = [
     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)];
     }
   }
@@ -5213,10 +5275,9 @@ function parseLog(command, parser) {
 
 // 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;
@@ -5240,7 +5301,40 @@ function parseSequence(parser, terminator, lhs, prec, sep) {
   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 = [
   //
@@ -5271,7 +5365,7 @@ var DEFINITIONS_CORE = [
     name: "Function",
     latexTrigger: ["\\mapsto"],
     kind: "infix",
-    precedence: 270,
+    precedence: ARROW_PRECEDENCE,
     // MathML rightwards arrow
     parse: (parser, lhs) => {
       let params = [];
@@ -5279,18 +5373,16 @@ var DEFINITIONS_CORE = [
         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")
@@ -5348,50 +5440,62 @@ var DEFINITIONS_CORE = [
       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",
@@ -5427,25 +5531,47 @@ var DEFINITIONS_CORE = [
     }
   },
   {
+    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);
     }
   },
@@ -5554,7 +5680,7 @@ var DEFINITIONS_CORE = [
     kind: "matchfix",
     openTrigger: "(",
     closeTrigger: ")",
-    parse: parseDelimiter
+    parse: parseParenDelimiter
   },
   {
     latexTrigger: [","],
@@ -5569,7 +5695,20 @@ var DEFINITIONS_CORE = [
       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: "," }];
     }
   },
   {
@@ -5597,10 +5736,6 @@ var DEFINITIONS_CORE = [
       return "";
     }
   },
-  {
-    name: "Sequence",
-    serialize: serializeOps("")
-  },
   {
     latexTrigger: [";"],
     kind: "infix",
@@ -5609,12 +5744,7 @@ var DEFINITIONS_CORE = [
       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], "';'"];
     }
   },
   {
@@ -5881,8 +6011,66 @@ function parseTextRun(parser, style) {
         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 }]);
@@ -5962,19 +6150,27 @@ function parsePrime(parser, lhs, order2) {
     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")
@@ -6015,6 +6211,80 @@ function parseRange(parser, lhs) {
   }
   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 = [
@@ -6071,7 +6341,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\leqslant"],
     kind: "infix",
     associativity: "right",
-    precedence: 265,
+    precedence: COMPARISON_PRECEDENCE + 5,
     // Note different precedence than `<=` as per MathML
     parse: "LessEqual"
   },
@@ -6080,28 +6350,28 @@ var DEFINITIONS_INEQUALITIES = [
     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"
   },
   {
@@ -6109,13 +6379,13 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["="],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   {
     latexTrigger: ["*", "="],
     kind: "infix",
     associativity: "right",
-    precedence: 260,
+    precedence: COMPARISON_PRECEDENCE,
     parse: "StarEqual"
   },
   {
@@ -6123,42 +6393,42 @@ var DEFINITIONS_INEQUALITIES = [
     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",
@@ -6166,7 +6436,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\cong"],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   {
     name: "NotTildeFullEqual",
@@ -6174,7 +6444,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\ncong"],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   {
     name: "Approx",
@@ -6198,7 +6468,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\approxeq"],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   {
     name: "NotApproxEqual",
@@ -6221,7 +6491,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["!", "="],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
     // Note different precedence than \\ne per MathML
   },
   {
@@ -6251,7 +6521,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\geqslant"],
     kind: "infix",
     associativity: "right",
-    precedence: 265,
+    precedence: COMPARISON_PRECEDENCE + 5,
     // Note: different precedence than `>=` as per MathML
     parse: "GreaterEqual"
   },
@@ -6260,14 +6530,14 @@ var DEFINITIONS_INEQUALITIES = [
     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: [">"],
@@ -6302,7 +6572,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\circeq"],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   {
     name: "TriangleEqual",
@@ -6310,7 +6580,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\triangleq"],
     kind: "infix",
     associativity: "right",
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   {
     name: "DotEqual",
@@ -6318,7 +6588,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\doteq"],
     kind: "infix",
     associativity: "right",
-    precedence: 265
+    precedence: COMPARISON_PRECEDENCE + 5
   },
   {
     name: "DotEqualDot",
@@ -6326,7 +6596,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\doteqdot"],
     kind: "infix",
     associativity: "right",
-    precedence: 265
+    precedence: COMPARISON_PRECEDENCE + 5
   },
   {
     name: "FallingDotEqual",
@@ -6334,7 +6604,7 @@ var DEFINITIONS_INEQUALITIES = [
     latexTrigger: ["\\fallingdotseq"],
     kind: "infix",
     associativity: "right",
-    precedence: 265
+    precedence: COMPARISON_PRECEDENCE + 5
   },
   {
     name: "RisingDotEqual",
@@ -6342,77 +6612,182 @@ var DEFINITIONS_INEQUALITIES = [
     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}"]);
+    }
   }
 ];
 
@@ -6566,7 +6941,15 @@ var DEFINITIONS_LOGIC = [
     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",
@@ -7319,6 +7702,9 @@ var DEFINITIONS_SETS = [
     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) ?? []];
@@ -7343,7 +7729,7 @@ var DEFINITIONS_SETS = [
     // or \\ominus
     kind: "infix",
     // @todo: parser could check that lhs and rhs are sets
-    precedence: 260
+    precedence: COMPARISON_PRECEDENCE
   },
   // Predicates/Relations
   {
@@ -7677,7 +8063,10 @@ function parseIntegralBodyExpression(expr) {
   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]);
@@ -7700,7 +8089,7 @@ function parseIntegralBodyExpression(expr) {
     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);
@@ -8443,25 +8832,26 @@ function isValidEntry(entry, onError) {
   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
@@ -8775,7 +9165,6 @@ var DEFAULT_LATEX_NUMBER_OPTIONS = {
   avoidExponentsInRange: [-7, 20]
 };
 var DEFAULT_PARSE_LATEX_OPTIONS = {
-  applyInvisibleOperator: "auto",
   skipSpace: true,
   parseArgumentsOfUnknownLatexCommands: true,
   parseNumbers: "auto",
@@ -9179,11 +9568,12 @@ var _Parser = class {
       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;
@@ -9330,7 +9720,7 @@ var _Parser = class {
   }
   parseDecimalDigits(options) {
     options ?? (options = {});
-    options.withGrouping ?? (options.withGrouping = false);
+    options.withGrouping ?? (options.withGrouping = true);
     const result = [];
     let done = false;
     while (!done) {
@@ -9355,7 +9745,7 @@ var _Parser = class {
   }
   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);
@@ -9395,7 +9785,7 @@ var _Parser = class {
       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;
@@ -9450,7 +9840,14 @@ var _Parser = class {
       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;
@@ -9461,21 +9858,17 @@ var _Parser = class {
         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();
@@ -9485,14 +9878,18 @@ var _Parser = class {
       } 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;
@@ -9501,14 +9898,14 @@ var _Parser = class {
       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 : "")
     };
   }
   /**
@@ -9636,8 +10033,13 @@ var _Parser = class {
       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 });
@@ -9896,7 +10298,7 @@ var _Parser = class {
       );
       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];
@@ -9965,75 +10367,6 @@ var _Parser = class {
     }
     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.
    *
@@ -10239,7 +10572,23 @@ var _Parser = class {
         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;
@@ -10248,11 +10597,6 @@ var _Parser = class {
         }
       }
     }
-    if (!lhs) {
-      lhs = this.parseSyntaxError();
-      while (!this.atTerminator(until))
-        this.nextToken();
-    }
     return this.decorate(lhs, start);
   }
   /**
@@ -10578,7 +10922,7 @@ var STYLE_MODIFIERS = {
   sansserif: (s) => `\\mathsf{${s}}`,
   monospace: (s) => `\\mathtt{${s}}`
 };
-var Serializer2 = class {
+var Serializer4 = class {
   constructor(options, dictionary2, onError) {
     this.level = -1;
     this.options = options;
@@ -10660,10 +11004,24 @@ var Serializer2 = class {
       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")
@@ -11056,7 +11414,7 @@ var LatexSyntax = class _LatexSyntax {
   get serializer() {
     if (this._serializer)
       return this._serializer;
-    this._serializer = new Serializer2(
+    this._serializer = new Serializer4(
       this.options,
       this._dictionary,
       this.onError
@@ -13520,11 +13878,19 @@ function flattenOps(ops2, head2) {
   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
@@ -13870,7 +14236,7 @@ var DOMAIN_ALIAS = {
   LogicOperators: [
     "FunctionOf",
     "Booleans",
-    ["OptArg", "Booleans"],
+    ["VarArg", "Booleans"],
     "Booleans"
   ],
   Predicates: ["FunctionOf", "Anything", ["VarArg", "Anything"], "Booleans"],
@@ -14190,7 +14556,7 @@ function checkArity(ce, ops2, count) {
 }
 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);
@@ -14251,7 +14617,7 @@ function checkNumericArgs(ce, ops2, options) {
         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)
@@ -14265,12 +14631,22 @@ function checkArg(ce, arg, dom) {
     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;
@@ -14446,9 +14822,9 @@ function canonicalLimits(limits) {
   } 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)
@@ -14537,7 +14913,11 @@ var NATIVE_JS_FUNCTIONS = {
   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",
@@ -14773,6 +15153,12 @@ function compileExpr(h, args, prec, target) {
     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 "";
@@ -14787,7 +15173,7 @@ function compileExpr(h, args, prec, target) {
   }
   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)
     })})`;
@@ -19866,6 +20252,12 @@ var ARITHMETIC_LIBRARY = [
       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) {
@@ -19964,7 +20356,7 @@ var ARITHMETIC_LIBRARY = [
         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);
@@ -20021,6 +20413,27 @@ var ARITHMETIC_LIBRARY = [
         )
       }
     },
+    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,
@@ -20098,7 +20511,10 @@ var ARITHMETIC_LIBRARY = [
           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"),
@@ -20132,9 +20548,9 @@ var ARITHMETIC_LIBRARY = [
             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]);
@@ -20295,7 +20711,7 @@ var ARITHMETIC_LIBRARY = [
         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);
           }
@@ -21346,7 +21762,6 @@ var CALCULUS_LIBRARY = [
           "Numbers"
         ],
         canonical: (ce, ops2) => {
-          const body = ops2[0] ?? ce.error("missing");
           let range = ops2[1];
           let index = null;
           let lower = null;
@@ -21366,9 +21781,9 @@ var CALCULUS_LIBRARY = [
           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)
@@ -21377,7 +21792,11 @@ var CALCULUS_LIBRARY = [
             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]);
         }
       }
     },
@@ -21410,15 +21829,12 @@ var COLLECTIONS_LIBRARY = {
   //
   // 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) => {
@@ -21573,7 +21989,7 @@ var COLLECTIONS_LIBRARY = {
     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]);
@@ -22159,6 +22575,17 @@ function indexes(ranges) {
   }
   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 = [
@@ -22594,19 +23021,160 @@ var CORE_LIBRARY = [
   // 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: {
@@ -22631,7 +23199,7 @@ var CORE_LIBRARY = [
       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]]);
           }
@@ -22651,11 +23219,11 @@ var CORE_LIBRARY = [
             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]
       }
     },
@@ -22750,18 +23318,17 @@ var CORE_LIBRARY = [
     },
     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];
@@ -22776,6 +23343,7 @@ var CORE_LIBRARY = [
     },
     Assume: {
       hold: "all",
+      pure: false,
       signature: {
         domain: ["FunctionOf", "Anything", "Anything"],
         evaluate: (ce, ops2) => ce.string(ce.assume(ops2[0]))
@@ -22783,6 +23351,7 @@ var CORE_LIBRARY = [
     },
     Declare: {
       hold: "all",
+      pure: false,
       signature: {
         domain: ["FunctionOf", "Symbols", "Anything"],
         canonical: (ce, args) => {
@@ -22936,17 +23505,15 @@ var CORE_LIBRARY = [
           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) {
@@ -23064,9 +23631,74 @@ var CORE_LIBRARY = [
     }
   }
 ];
+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 = {
@@ -23131,6 +23763,15 @@ var LOGIC_LIBRARY = {
     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
     }
@@ -23200,7 +23841,7 @@ function processOr(ce, args) {
   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")
@@ -23264,17 +23905,42 @@ var POLYNOMIALS_LIBRARY = [
 
 // 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;
@@ -23298,6 +23964,7 @@ var RELOP_LIBRARY = {
     complexity: 11e3,
     signature: {
       domain: "RelationalOperators",
+      canonical: (ce, args) => canonicalRelational(ce, "NotEqual", args),
       evaluate: (ce, ops2) => {
         if (ops2.length < 2)
           return ce.False;
@@ -23319,7 +23986,7 @@ var RELOP_LIBRARY = {
     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;
@@ -23346,14 +24013,14 @@ var RELOP_LIBRARY = {
     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;
@@ -23387,6 +24054,7 @@ var RELOP_LIBRARY = {
     complexity: 11e3,
     signature: {
       domain: "RelationalOperators",
+      canonical: (ce, ops2) => canonicalRelational(ce, "LessEqual", ops2),
       evaluate: (ce, ops2) => {
         if (ops2.length < 2)
           return ce.True;
@@ -23413,14 +24081,14 @@ var RELOP_LIBRARY = {
     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;
@@ -23447,94 +24115,136 @@ var RELOP_LIBRARY = {
     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 = {
@@ -26332,14 +27042,7 @@ var BoxedSymbol = class _BoxedSymbol extends _BoxedExpression {
     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;
@@ -26848,15 +27551,15 @@ var ComputeEngine = class _ComputeEngine {
       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");
@@ -27128,7 +27831,12 @@ var ComputeEngine = class _ComputeEngine {
   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)
@@ -27477,11 +28185,10 @@ var ComputeEngine = class _ComputeEngine {
       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;
       }
@@ -28114,10 +28821,10 @@ function isFunctionValue(value) {
 }
 
 // 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"
 };
 export {
   ADDITION_PRECEDENCE,