@cortex-js/compute-engine 0.55.4 → 0.55.6

package/dist/interval.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 0.55.6 */
 
 // src/compute-engine/interval/util.ts
 function ok(value) {
@@ -6984,10 +6984,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));
@@ -8025,14 +8021,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",
@@ -8119,7 +8119,6 @@ var DEFINITIONS_SETS = [
   // commands like \rbrack a, b \rbrack which are unambiguous.
   {
     name: "Multiple",
-    // @todo: parse
     serialize: serializeSet
   },
   {
@@ -8128,14 +8127,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);
       }
@@ -8143,6 +8156,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(", "),
@@ -8309,23 +8333,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") {
@@ -9443,11 +9450,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)
       ];
     },
@@ -11651,12 +11660,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",
@@ -11896,80 +11945,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",
@@ -11981,6 +12021,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([
@@ -12068,6 +12112,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) => {
@@ -12118,7 +12184,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 "";
@@ -13329,7 +13405,7 @@ var IntervalArithmetic = {
 };
 
 // src/interval.ts
-var version = "0.55.4";
+var version = "0.55.6";
 export {
   IntervalArithmetic,
   _mul,