@cortex-js/compute-engine 0.55.5 → 0.55.6

package/dist/interval.umd.cjs

@@ -1,4 +1,4 @@
-/** Interval 0.55.5 */
+/** Interval 0.55.6 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Interval = {}));})(this, (function (exports) { 'use strict';
 var Interval = (() => {
   var __defProp = Object.defineProperty;
@@ -7103,10 +7103,6 @@ var Interval = (() => {
     // 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));
@@ -8144,14 +8140,18 @@ var Interval = (() => {
         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",
@@ -8238,7 +8238,6 @@ var Interval = (() => {
     // commands like \rbrack a, b \rbrack which are unambiguous.
     {
       name: "Multiple",
-      // @todo: parse
       serialize: serializeSet
     },
     {
@@ -8247,14 +8246,28 @@ var Interval = (() => {
       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);
         }
@@ -8262,6 +8275,17 @@ var Interval = (() => {
         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(", "),
@@ -8428,23 +8452,6 @@ var Interval = (() => {
     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") {
@@ -9562,11 +9569,13 @@ var Interval = (() => {
         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)
         ];
       },
@@ -11770,12 +11779,52 @@ var Interval = (() => {
   ];
 
   // 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",
@@ -12015,80 +12064,71 @@ var Interval = (() => {
     },
     {
       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",
@@ -12100,6 +12140,10 @@ var Interval = (() => {
           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([
@@ -12187,6 +12231,28 @@ var Interval = (() => {
       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) => {
@@ -12237,7 +12303,17 @@ var Interval = (() => {
       // `["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 "";
@@ -13448,7 +13524,7 @@ var Interval = (() => {
   };
 
   // src/interval.ts
-  var version = "0.55.5";
+  var version = "0.55.6";
   return __toCommonJS(interval_exports);
 })();
 /*! Bundled license information: