@cortex-js/compute-engine 0.55.4 → 0.55.6

package/dist/latex-syntax.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 0.55.6 */
 
 // src/math-json/utils.ts
 var MISSING = ["Error", "'missing'"];
@@ -4743,10 +4743,6 @@ var DEFINITIONS_CORE = [
   // Lagrange notation
   {
     name: "Derivative",
-    // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
-    // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
-    // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
-    // Newton notation (\dot{v}, \ddot{v}) is implemented below
     serialize: (serializer, expr) => {
       const degree = machineValue(operand(expr, 2)) ?? 1;
       const base = serializer.serialize(operand(expr, 1));
@@ -5784,14 +5780,18 @@ var DEFINITIONS_SETS = [
       return ["Complement", lhs];
     }
     // precedence: 240,
-    // @todo: serialize for the multiple argument case
   },
   {
     name: "Complement",
     latexTrigger: ["^", "<{>", "\\complement", "<}>"],
-    kind: "postfix"
+    kind: "postfix",
     // precedence: 240,
-    // @todo: serialize for the multiple argument case
+    serialize: (serializer, expr) => {
+      return joinLatex([
+        serializer.serialize(operand(expr, 1)),
+        "^\\complement"
+      ]);
+    }
   },
   {
     name: "Intersection",
@@ -5878,7 +5878,6 @@ var DEFINITIONS_SETS = [
   // commands like \rbrack a, b \rbrack which are unambiguous.
   {
     name: "Multiple",
-    // @todo: parse
     serialize: serializeSet
   },
   {
@@ -5887,14 +5886,28 @@ var DEFINITIONS_SETS = [
     kind: "infix",
     precedence: 350
   },
+  // \mid as a separator/operator (used in set-builder notation: {x \mid x > 0})
+  // Low precedence so it binds loosely — everything on each side is parsed first
+  {
+    name: "Divides",
+    latexTrigger: ["\\mid"],
+    kind: "infix",
+    precedence: 160
+  },
   {
     name: "Set",
     kind: "matchfix",
     openTrigger: "{",
     closeTrigger: "}",
-    // @todo: the set syntax can also include conditions...
     parse: (_parser, body) => {
       if (isEmptySequence(body)) return "EmptySet";
+      const h = operator(body);
+      if (h === "Divides" || h === "Colon") {
+        const expr = operand(body, 1);
+        const condition = operand(body, 2);
+        if (expr !== null && condition !== null)
+          return ["Set", expr, ["Condition", condition]];
+      }
       if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
         body = operand(body, 1);
       }
@@ -5902,6 +5915,17 @@ var DEFINITIONS_SETS = [
       return ["Set", ...operands(body)];
     },
     serialize: (serializer, expr) => {
+      if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
+        const condition = operand(expr, 2);
+        return joinLatex([
+          "\\lbrace",
+          serializer.serialize(operand(expr, 1)),
+          "\\mid",
+          // Serialize the inner expression of the Condition wrapper
+          serializer.serialize(operand(condition, 1)),
+          "\\rbrace"
+        ]);
+      }
       return joinLatex([
         "\\lbrace",
         operands(expr).map((x) => serializer.serialize(x)).join(", "),
@@ -6068,23 +6092,6 @@ function serializeSet(serializer, expr) {
   if (expr === null) return "";
   const h = operator(expr);
   if (!h) return "";
-  if (h === "Set") {
-    if (nops(expr) === 0) return "\\emptyset";
-    if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
-      return joinLatex([
-        "\\left\\lbrace",
-        serializer.serialize(operand(expr, 1)),
-        "\\middle\\mid",
-        serializer.serialize(operand(expr, 2)),
-        "\\right\\rbrace"
-      ]);
-    }
-    return joinLatex([
-      "\\left\\lbrace",
-      ...operands(expr).map((x) => serializer.serialize(x) + " ,"),
-      "\\right\\rbrace"
-    ]);
-  }
   if (h === "Multiple") {
   }
   if (h === "Range") {
@@ -7232,11 +7239,13 @@ var DEFINITIONS_ARITHMETIC = [
       if (!parser.match("_")) return null;
       const base = parser.parseGroup();
       if (operator(base) !== "To") return null;
-      const expr = parser.parseArguments("implicit");
+      const expr = parser.parseExpression({
+        minPrec: MULTIPLICATION_PRECEDENCE
+      });
       if (!expr) return null;
       return [
         "Limit",
-        ["Function", expr[0], operand(base, 1)],
+        ["Function", expr, operand(base, 1)],
         operand(base, 2)
       ];
     },
@@ -9440,12 +9449,52 @@ var DEFINITIONS_UNITS = [
 ];
 
 // src/compute-engine/latex-syntax/dictionary/definitions-other.ts
+var TEX_UNITS = [
+  "pt",
+  "em",
+  "mu",
+  "ex",
+  "mm",
+  "cm",
+  "in",
+  "bp",
+  "sp",
+  "dd",
+  "cc",
+  "pc",
+  "nc",
+  "nd"
+];
+function skipTexDimension(parser) {
+  parser.skipSpace();
+  if (parser.peek === "-" || parser.peek === "+") parser.nextToken();
+  while (/^[\d.]$/.test(parser.peek)) parser.nextToken();
+  for (const unit of TEX_UNITS) {
+    if (parser.matchAll([...unit])) return;
+  }
+}
 function parseSingleArg(cmd) {
   return (parser) => {
     const arg = parser.parseGroup();
     return arg === null ? [cmd] : [cmd, arg];
   };
 }
+function parseMathStyleSwitch(mathStyle) {
+  return (parser) => {
+    const body = parser.parseExpression();
+    if (body !== null && !isEmptySequence(body))
+      return ["Annotated", body, { dict: { mathStyle } }];
+    return "Nothing";
+  };
+}
+function parseSizeSwitch(size) {
+  return (parser) => {
+    const body = parser.parseExpression();
+    if (body !== null && !isEmptySequence(body))
+      return ["Annotated", body, { dict: { size } }];
+    return "Nothing";
+  };
+}
 var DEFINITIONS_OTHERS = [
   {
     name: "Overscript",
@@ -9685,80 +9734,71 @@ var DEFINITIONS_OTHERS = [
   },
   {
     latexTrigger: ["\\displaystyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("normal")
   },
   {
     latexTrigger: ["\\textstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("compact")
   },
   {
     latexTrigger: ["\\scriptstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("script")
   },
   {
     latexTrigger: ["\\scriptscriptstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("scriptscript")
   },
   {
     latexTrigger: ["\\color"],
     parse: (parser) => {
-      parser.parseGroup();
+      const color = parser.parseStringGroup();
+      if (color !== null) {
+        const body = parser.parseExpression();
+        if (body !== null && !isEmptySequence(body))
+          return ["Annotated", body, { dict: { color } }];
+      }
       return "Nothing";
     }
   },
   {
     latexTrigger: ["\\tiny"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(1)
   },
   {
     latexTrigger: ["\\scriptsize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(2)
   },
   {
     latexTrigger: ["\\footnotesize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(3)
   },
   {
     latexTrigger: ["\\small"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(4)
   },
   {
     latexTrigger: ["\\normalsize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(5)
   },
   {
     latexTrigger: ["\\large"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(6)
   },
   {
     latexTrigger: ["\\Large"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(7)
   },
   {
     latexTrigger: ["\\LARGE"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(8)
   },
   {
     latexTrigger: ["\\huge"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(9)
   },
   {
     latexTrigger: ["\\Huge"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(10)
   },
   {
     name: "Annotated",
@@ -9770,6 +9810,10 @@ var DEFINITIONS_OTHERS = [
         result = joinLatex(["{\\displaystyle", result, "}"]);
       else if (dict.dict.mathStyle === "compact")
         result = joinLatex(["{\\textstyle", result, "}"]);
+      else if (dict.dict.mathStyle === "script")
+        result = joinLatex(["{\\scriptstyle", result, "}"]);
+      else if (dict.dict.mathStyle === "scriptscript")
+        result = joinLatex(["{\\scriptscriptstyle", result, "}"]);
       const v = dict.dict.size;
       if (v !== null && v >= 1 && v <= 10) {
         result = joinLatex([
@@ -9857,6 +9901,28 @@ var DEFINITIONS_OTHERS = [
     latexTrigger: ["\\enspace"],
     parse: () => ["HorizontalSpacing", 9]
   },
+  {
+    latexTrigger: ["\\hspace"],
+    parse: (parser) => {
+      if (parser.peek === "*") parser.nextToken();
+      parser.parseStringGroup();
+      return ["HorizontalSpacing", 0];
+    }
+  },
+  {
+    latexTrigger: ["\\hskip"],
+    parse: (parser) => {
+      skipTexDimension(parser);
+      return ["HorizontalSpacing", 0];
+    }
+  },
+  {
+    latexTrigger: ["\\kern"],
+    parse: (parser) => {
+      skipTexDimension(parser);
+      return ["HorizontalSpacing", 0];
+    }
+  },
   {
     latexTrigger: ["\\phantom"],
     parse: (parser) => {
@@ -9907,7 +9973,17 @@ var DEFINITIONS_OTHERS = [
     // `["HorizontalSpacing", expr, 'op'|'bin'|rel]` -> indicate a spacing around and expression, i.e. `\mathbin{x}`, etc...
     serialize: (serializer, expr) => {
       if (operand(expr, 2) !== null) {
-        return serializer.serialize(operand(expr, 1));
+        const cls = stringValue(operand(expr, 2));
+        const inner = serializer.serialize(operand(expr, 1));
+        if (cls === "bin") return `\\mathbin{${inner}}`;
+        if (cls === "op") return `\\mathop{${inner}}`;
+        if (cls === "rel") return `\\mathrel{${inner}}`;
+        if (cls === "ord") return `\\mathord{${inner}}`;
+        if (cls === "open") return `\\mathopen{${inner}}`;
+        if (cls === "close") return `\\mathclose{${inner}}`;
+        if (cls === "punct") return `\\mathpunct{${inner}}`;
+        if (cls === "inner") return `\\mathinner{${inner}}`;
+        return inner;
       }
       const v = machineValue(operand(expr, 1));
       if (v === null) return "";
@@ -10298,25 +10374,47 @@ function makeIndexedEntry(entry, onError) {
     result.arguments = entry.arguments;
   return result;
 }
+function serializeTabularBody(serializer, body) {
+  if (!body) return "";
+  if (operator(body) !== "List") return serializer.serialize(body);
+  const rows = operands(body);
+  if (rows.length === 0) return "";
+  if (!rows.every((row) => operator(row) === "List"))
+    return serializer.serialize(body);
+  return rows.map(
+    (row) => operands(row).map((cell) => serializer.serialize(cell)).join(" & ")
+  ).join(" \\\\\n");
+}
 function makeSerializeHandler(entry, latexTrigger, idTrigger) {
   if (typeof entry.serialize === "function") return entry.serialize;
   const kind = entry["kind"] ?? "expression";
   if (kind === "environment") {
     const envName = entry["symbolTrigger"] ?? entry.name ?? "unknown";
-    return (serializer, expr) => joinLatex([
-      `\\begin{${envName}}`,
-      serializer.serialize(operand(expr, 1)),
-      `\\end{${envName}}`
-    ]);
+    return (serializer, expr) => {
+      const body = operand(expr, 1);
+      return joinLatex([
+        `\\begin{${envName}}`,
+        serializeTabularBody(serializer, body),
+        `\\end{${envName}}`
+      ]);
+    };
   }
   if (isMatchfixEntry(entry)) {
     const openDelim = typeof entry.openTrigger === "string" ? DEFAULT_DELIMITER[entry.openTrigger] : tokensToString(entry.openTrigger);
     const closeDelim = typeof entry.closeTrigger === "string" ? DEFAULT_DELIMITER[entry.closeTrigger] : tokensToString(entry.closeTrigger);
-    return (serializer, expr) => joinLatex([
-      openDelim,
-      serializer.serialize(operand(expr, 1)),
-      closeDelim
-    ]);
+    return (serializer, expr) => {
+      const style = serializer.groupStyle(expr, serializer.level + 1);
+      const inner = serializer.serialize(operand(expr, 1));
+      if (style === "scaled")
+        return joinLatex([`\\left${openDelim}`, inner, `\\right${closeDelim}`]);
+      if (style === "big")
+        return joinLatex([
+          `\\Bigl${openDelim}`,
+          inner,
+          `\\Bigr${closeDelim}`
+        ]);
+      return joinLatex([openDelim, inner, closeDelim]);
+    };
   }
   let latex = entry.serialize;
   if (latex === void 0 && latexTrigger) latex = tokensToString(latexTrigger);
@@ -12579,6 +12677,16 @@ function parseNumber(parser, fmt) {
 }
 
 // src/compute-engine/latex-syntax/parse.ts
+var _symbolToUnicode = null;
+function getSymbolToUnicode() {
+  if (!_symbolToUnicode) {
+    _symbolToUnicode = /* @__PURE__ */ new Map();
+    for (const [, latex, codepoint] of SYMBOLS) {
+      _symbolToUnicode.set(latex, String.fromCodePoint(codepoint));
+    }
+  }
+  return _symbolToUnicode;
+}
 var DELIMITER_SHORTHAND2 = {
   "(": ["\\lparen", "("],
   ")": ["\\rparen", ")"],
@@ -13026,6 +13134,35 @@ var _Parser = class __Parser {
       this.nextToken();
       this.skipVisualSpace();
     }
+    if (this.match("\\hspace")) {
+      this.match("*");
+      this.parseStringGroup();
+      this.skipVisualSpace();
+    }
+    if (this.match("\\hskip") || this.match("\\kern")) {
+      this.skipSpace();
+      this.match("-") || this.match("+");
+      while (/^[\d.]$/.test(this.peek)) this.nextToken();
+      for (const unit of [
+        "pt",
+        "em",
+        "mu",
+        "ex",
+        "mm",
+        "cm",
+        "in",
+        "bp",
+        "sp",
+        "dd",
+        "cc",
+        "pc",
+        "nc",
+        "nd"
+      ]) {
+        if (this.matchAll([...unit])) break;
+      }
+      this.skipVisualSpace();
+    }
     this.skipSpace();
   }
   match(token) {
@@ -13363,7 +13500,8 @@ var _Parser = class __Parser {
       } else if (token === "<space>") {
         result += " ";
       } else if (token[0] === "\\") {
-        result += token;
+        const unicode = getSymbolToUnicode().get(token);
+        result += unicode ?? token;
       } else {
         result += token;
       }
@@ -14723,7 +14861,7 @@ var STYLE_MODIFIERS = {
   sansserif: (s) => `\\mathsf{${s}}`,
   monospace: (s) => `\\mathtt{${s}}`
 };
-var Serializer4 = class {
+var Serializer5 = class {
   options;
   dictionary;
   level = -1;
@@ -14738,11 +14876,18 @@ var Serializer4 = class {
   /**
    * Serialize the expression, and if the expression is an operator
    * of precedence less than or equal to prec, wrap it in some parens.
-   * @todo: don't wrap Abs, Floor, Ceil, Delimiter
+   *
+   * Skip wrapping for matchfix operators (Abs, Floor, Ceil, Norm, etc.)
+   * and Delimiter since they already have visible delimiters.
    */
   wrap(expr, prec) {
     if (expr === null || expr === void 0) return "";
     if (prec === void 0) {
+      const name2 = operator(expr);
+      if (name2) {
+        const def = this.dictionary.ids.get(name2);
+        if (def?.kind === "matchfix") return this.serialize(expr);
+      }
       return this.wrapString(
         this.serialize(expr),
         this.options.groupStyle(expr, this.level + 1)
@@ -15036,7 +15181,7 @@ function serializeSymbol(s, style = "auto") {
   return body;
 }
 function serializeLatex(expr, dict, options) {
-  const serializer = new Serializer4(dict, options);
+  const serializer = new Serializer5(dict, options);
   return serializer.serialize(expr);
 }
 
@@ -15163,7 +15308,7 @@ function serialize(expr) {
 }
 
 // src/latex-syntax.ts
-var version = "0.55.4";
+var version = "0.55.6";
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,