@cortex-js/compute-engine 0.57.0 → 0.58.0

package/dist/interval.umd.cjs

@@ -1,4 +1,4 @@
-/** Interval 0.57.0 */
+/** Interval 0.58.0 */
     (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;
@@ -5218,7 +5218,42 @@ var Interval = (() => {
     if (b === "nothing") return a;
     if (isSubtype(a, b)) return b;
     if (isSubtype(b, a)) return a;
-    return superType(a, b);
+    const sup = superType(a, b);
+    if (LOSSY_SUPERTYPE.has(sup)) return unionTypes(a, b);
+    return sup;
+  }
+  var LOSSY_SUPERTYPE = /* @__PURE__ */ new Set([
+    "scalar",
+    "value",
+    "function",
+    "expression",
+    "collection",
+    "indexed_collection",
+    "list",
+    "set",
+    "tuple",
+    "record",
+    "dictionary",
+    "map",
+    "any"
+  ]);
+  function unionTypes(a, b) {
+    const members = [];
+    const push = (t) => {
+      if (typeof t === "object" && t.kind === "union") {
+        for (const m of t.types) push(m);
+        return;
+      }
+      const key = typeof t === "string" ? t : JSON.stringify(t);
+      if (!members.some(
+        (m) => (typeof m === "string" ? m : JSON.stringify(m)) === key
+      ))
+        members.push(t);
+    };
+    push(a);
+    push(b);
+    if (members.length === 1) return members[0];
+    return { kind: "union", types: members };
   }
   function narrow(...types) {
     if (types.length === 0) return "nothing";
@@ -6374,15 +6409,16 @@ var Interval = (() => {
       precedence: ASSIGNMENT_PRECEDENCE,
       parse: parseAssign
     },
-    // General colon operator (type annotation, mapping notation)
-    // Precedence below assignment (260) so `:=` takes priority,
-    // and below arrows (270) so `f: A \to B` parses as `Colon(f, To(A, B))`
+    // General colon operator (type annotation, mapping notation, Desmos piecewise)
+    // Precedence below comparisons (245) so `cond : val` (Desmos compact piecewise)
+    // parses as `Colon(cond, val)`, and below arrows (270) so
+    // `f: A \to B` parses as `Colon(f, To(A, B))`.
     {
       name: "Colon",
       latexTrigger: ":",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       serialize: (serializer, expr) => joinLatex([
         serializer.serialize(operand(expr, 1)),
         "\\colon",
@@ -6393,7 +6429,7 @@ var Interval = (() => {
       latexTrigger: "\\colon",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       parse: "Colon"
     },
     {
@@ -7963,7 +7999,10 @@ var Interval = (() => {
         p.skipVisualSpace();
         const isComma = p.peek === ",";
         p.index = saved;
-        return isComma;
+        if (isComma) return true;
+        if (peekKeyword(p, "where")) return true;
+        if (peekKeyword(p, "with")) return true;
+        return false;
       }
     };
     const elements = [];
@@ -8004,6 +8043,25 @@ var Interval = (() => {
       parser.skipVisualSpace();
     } while (parser.match(","));
     if (bindings.length === 0) return null;
+    const forStart = parser.index;
+    if (matchKeyword(parser, "for")) {
+      const loop = parseForComprehension(parser, lhs, until);
+      if (loop) {
+        const block2 = [];
+        for (const b of bindings) {
+          const normalized = normalizeLocalAssign(b);
+          if (operator(normalized) === "Assign") {
+            block2.push(["Declare", operand(normalized, 1)]);
+            block2.push(normalized);
+          } else {
+            block2.push(normalized);
+          }
+        }
+        block2.push(loop);
+        return ["Block", ...block2];
+      }
+      parser.index = forStart;
+    }
     const block = [];
     for (const b of bindings) {
       const normalized = normalizeLocalAssign(b);
@@ -8217,6 +8275,17 @@ var Interval = (() => {
     const upperExpr = openRight ? ["Open", upper] : upper;
     return ["Interval", lowerExpr, upperExpr];
   }
+  var COMPARISON_HEADS = /* @__PURE__ */ new Set([
+    "Less",
+    "LessEqual",
+    "Greater",
+    "GreaterEqual",
+    "Equal",
+    "NotEqual",
+    "And",
+    "Or",
+    "Not"
+  ]);
   var DEFINITIONS_SETS = [
     //
     // Constants
@@ -8475,18 +8544,58 @@ var Interval = (() => {
       closeTrigger: "}",
       parse: (_parser, body) => {
         if (isEmptySequence(body)) return "EmptySet";
+        if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
+          body = operand(body, 1);
+        }
         const h = operator(body);
-        if (h === "Divides" || h === "Colon") {
+        if (h === "Divides") {
           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);
+        if (h === "Colon") {
+          const lhs = operand(body, 1);
+          const rhs = operand(body, 2);
+          if (lhs !== null && rhs !== null) {
+            const lhsOp = operator(lhs);
+            if (lhsOp !== null && COMPARISON_HEADS.has(lhsOp)) {
+              return ["Which", lhs, rhs];
+            }
+            return ["Set", lhs, ["Condition", rhs]];
+          }
+        }
+        if (h === "Sequence") {
+          const elements = operands(body);
+          const colonElements = elements.filter((el) => operator(el) === "Colon");
+          const allPiecewise = colonElements.length > 0 && colonElements.every((el) => {
+            const lhs = operand(el, 1);
+            const lhsOp = lhs !== null ? operator(lhs) : null;
+            return lhsOp !== null && COMPARISON_HEADS.has(lhsOp);
+          });
+          if (allPiecewise) {
+            const whichOps = [];
+            for (let i = 0; i < elements.length; i++) {
+              const el = elements[i];
+              if (operator(el) === "Colon") {
+                const cond = operand(el, 1);
+                const val = operand(el, 2);
+                if (cond === null || val === null) {
+                  return ["Set", ...elements];
+                }
+                whichOps.push(cond, val);
+              } else {
+                if (i !== elements.length - 1) {
+                  return ["Set", ...elements];
+                }
+                whichOps.push("True", el);
+              }
+            }
+            return ["Which", ...whichOps];
+          }
+          return ["Set", ...elements];
         }
-        if (operator(body) !== "Sequence") return ["Set", body];
-        return ["Set", ...operands(body)];
+        return ["Set", body];
       },
       serialize: (serializer, expr) => {
         if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
@@ -10460,7 +10569,8 @@ var Interval = (() => {
         minPrec: MULTIPLICATION_PRECEDENCE,
         condition: (parser2) => trigCommands[parser2.peek] || (until?.condition?.(parser2) ?? false)
       });
-      const appliedFn = args === null ? fn : typeof fn === "string" ? [fn, ...args] : ["Apply", fn, ...args];
+      const head = fn === "Arctan" && args?.length === 2 ? "Arctan2" : fn;
+      const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
       return sup === null ? appliedFn : ["Power", appliedFn, sup];
     };
   }
@@ -12583,10 +12693,17 @@ var Interval = (() => {
     // The capitalized library entries already exist; these are pure parse
     // aliases so the lowercase names don't land in `unsupported-operator`.
     // ---------------------------------------------------------------------------
+    { latexTrigger: "\\operatorname{count}", parse: "Length" },
     { latexTrigger: "\\operatorname{random}", parse: "Random" },
     { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
     { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
     { latexTrigger: "\\operatorname{join}", parse: "Join" },
+    { latexTrigger: "\\operatorname{range}", parse: "Range" },
+    // Note: `\operatorname{with}` (Desmos's local-binding clause) is intentionally
+    // NOT registered here. Use the math-notation equivalent `\operatorname{where}`
+    // (with `\coloneq` for bindings), or register `with` as a custom dictionary
+    // entry at the integration layer — see the "Desmos-Specific Syntax — Prefer
+    // Custom LaTeX Dictionary" section in COMPUTE_ENGINE.md for a worked example.
     // ---------------------------------------------------------------------------
     // Geometric primitive heads. Registered as known typed heads so consumers
     // can branch on the operator name; CE itself doesn't render them. The
@@ -13865,7 +13982,7 @@ var Interval = (() => {
   };
 
   // src/interval.ts
-  var version = "0.57.0";
+  var version = "0.58.0";
   return __toCommonJS(interval_exports);
 })();
 /*! Bundled license information:

package/dist/latex-syntax.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.57.0 */
+/** Compute Engine 0.58.0 */
 
 // src/math-json/utils.ts
 var MISSING = ["Error", "'missing'"];
@@ -3126,7 +3126,42 @@ function widen2(a, b) {
   if (b === "nothing") return a;
   if (isSubtype(a, b)) return b;
   if (isSubtype(b, a)) return a;
-  return superType(a, b);
+  const sup = superType(a, b);
+  if (LOSSY_SUPERTYPE.has(sup)) return unionTypes(a, b);
+  return sup;
+}
+var LOSSY_SUPERTYPE = /* @__PURE__ */ new Set([
+  "scalar",
+  "value",
+  "function",
+  "expression",
+  "collection",
+  "indexed_collection",
+  "list",
+  "set",
+  "tuple",
+  "record",
+  "dictionary",
+  "map",
+  "any"
+]);
+function unionTypes(a, b) {
+  const members = [];
+  const push = (t) => {
+    if (typeof t === "object" && t.kind === "union") {
+      for (const m of t.types) push(m);
+      return;
+    }
+    const key = typeof t === "string" ? t : JSON.stringify(t);
+    if (!members.some(
+      (m) => (typeof m === "string" ? m : JSON.stringify(m)) === key
+    ))
+      members.push(t);
+  };
+  push(a);
+  push(b);
+  if (members.length === 1) return members[0];
+  return { kind: "union", types: members };
 }
 function narrow(...types) {
   if (types.length === 0) return "nothing";
@@ -4014,15 +4049,16 @@ var DEFINITIONS_CORE = [
     precedence: ASSIGNMENT_PRECEDENCE,
     parse: parseAssign
   },
-  // General colon operator (type annotation, mapping notation)
-  // Precedence below assignment (260) so `:=` takes priority,
-  // and below arrows (270) so `f: A \to B` parses as `Colon(f, To(A, B))`
+  // General colon operator (type annotation, mapping notation, Desmos piecewise)
+  // Precedence below comparisons (245) so `cond : val` (Desmos compact piecewise)
+  // parses as `Colon(cond, val)`, and below arrows (270) so
+  // `f: A \to B` parses as `Colon(f, To(A, B))`.
   {
     name: "Colon",
     latexTrigger: ":",
     kind: "infix",
     associativity: "right",
-    precedence: 250,
+    precedence: 240,
     serialize: (serializer, expr) => joinLatex([
       serializer.serialize(operand(expr, 1)),
       "\\colon",
@@ -4033,7 +4069,7 @@ var DEFINITIONS_CORE = [
     latexTrigger: "\\colon",
     kind: "infix",
     associativity: "right",
-    precedence: 250,
+    precedence: 240,
     parse: "Colon"
   },
   {
@@ -5603,7 +5639,10 @@ function parseForComprehension(parser, lhs, until) {
       p.skipVisualSpace();
       const isComma = p.peek === ",";
       p.index = saved;
-      return isComma;
+      if (isComma) return true;
+      if (peekKeyword(p, "where")) return true;
+      if (peekKeyword(p, "with")) return true;
+      return false;
     }
   };
   const elements = [];
@@ -5644,6 +5683,25 @@ function parseWhereExpression(parser, lhs, until) {
     parser.skipVisualSpace();
   } while (parser.match(","));
   if (bindings.length === 0) return null;
+  const forStart = parser.index;
+  if (matchKeyword(parser, "for")) {
+    const loop = parseForComprehension(parser, lhs, until);
+    if (loop) {
+      const block2 = [];
+      for (const b of bindings) {
+        const normalized = normalizeLocalAssign(b);
+        if (operator(normalized) === "Assign") {
+          block2.push(["Declare", operand(normalized, 1)]);
+          block2.push(normalized);
+        } else {
+          block2.push(normalized);
+        }
+      }
+      block2.push(loop);
+      return ["Block", ...block2];
+    }
+    parser.index = forStart;
+  }
   const block = [];
   for (const b of bindings) {
     const normalized = normalizeLocalAssign(b);
@@ -5857,6 +5915,17 @@ function parseIntervalBody(body, openLeft, openRight) {
   const upperExpr = openRight ? ["Open", upper] : upper;
   return ["Interval", lowerExpr, upperExpr];
 }
+var COMPARISON_HEADS = /* @__PURE__ */ new Set([
+  "Less",
+  "LessEqual",
+  "Greater",
+  "GreaterEqual",
+  "Equal",
+  "NotEqual",
+  "And",
+  "Or",
+  "Not"
+]);
 var DEFINITIONS_SETS = [
   //
   // Constants
@@ -6115,18 +6184,58 @@ var DEFINITIONS_SETS = [
     closeTrigger: "}",
     parse: (_parser, body) => {
       if (isEmptySequence(body)) return "EmptySet";
+      if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
+        body = operand(body, 1);
+      }
       const h = operator(body);
-      if (h === "Divides" || h === "Colon") {
+      if (h === "Divides") {
         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);
+      if (h === "Colon") {
+        const lhs = operand(body, 1);
+        const rhs = operand(body, 2);
+        if (lhs !== null && rhs !== null) {
+          const lhsOp = operator(lhs);
+          if (lhsOp !== null && COMPARISON_HEADS.has(lhsOp)) {
+            return ["Which", lhs, rhs];
+          }
+          return ["Set", lhs, ["Condition", rhs]];
+        }
+      }
+      if (h === "Sequence") {
+        const elements = operands(body);
+        const colonElements = elements.filter((el) => operator(el) === "Colon");
+        const allPiecewise = colonElements.length > 0 && colonElements.every((el) => {
+          const lhs = operand(el, 1);
+          const lhsOp = lhs !== null ? operator(lhs) : null;
+          return lhsOp !== null && COMPARISON_HEADS.has(lhsOp);
+        });
+        if (allPiecewise) {
+          const whichOps = [];
+          for (let i = 0; i < elements.length; i++) {
+            const el = elements[i];
+            if (operator(el) === "Colon") {
+              const cond = operand(el, 1);
+              const val = operand(el, 2);
+              if (cond === null || val === null) {
+                return ["Set", ...elements];
+              }
+              whichOps.push(cond, val);
+            } else {
+              if (i !== elements.length - 1) {
+                return ["Set", ...elements];
+              }
+              whichOps.push("True", el);
+            }
+          }
+          return ["Which", ...whichOps];
+        }
+        return ["Set", ...elements];
       }
-      if (operator(body) !== "Sequence") return ["Set", body];
-      return ["Set", ...operands(body)];
+      return ["Set", body];
     },
     serialize: (serializer, expr) => {
       if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
@@ -8130,7 +8239,8 @@ function parseTrig(op) {
       minPrec: MULTIPLICATION_PRECEDENCE,
       condition: (parser2) => trigCommands[parser2.peek] || (until?.condition?.(parser2) ?? false)
     });
-    const appliedFn = args === null ? fn : typeof fn === "string" ? [fn, ...args] : ["Apply", fn, ...args];
+    const head = fn === "Arctan" && args?.length === 2 ? "Arctan2" : fn;
+    const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
     return sup === null ? appliedFn : ["Power", appliedFn, sup];
   };
 }
@@ -10253,10 +10363,17 @@ var DEFINITIONS_OTHERS = [
   // The capitalized library entries already exist; these are pure parse
   // aliases so the lowercase names don't land in `unsupported-operator`.
   // ---------------------------------------------------------------------------
+  { latexTrigger: "\\operatorname{count}", parse: "Length" },
   { latexTrigger: "\\operatorname{random}", parse: "Random" },
   { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
   { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
   { latexTrigger: "\\operatorname{join}", parse: "Join" },
+  { latexTrigger: "\\operatorname{range}", parse: "Range" },
+  // Note: `\operatorname{with}` (Desmos's local-binding clause) is intentionally
+  // NOT registered here. Use the math-notation equivalent `\operatorname{where}`
+  // (with `\coloneq` for bindings), or register `with` as a custom dictionary
+  // entry at the integration layer — see the "Desmos-Specific Syntax — Prefer
+  // Custom LaTeX Dictionary" section in COMPUTE_ENGINE.md for a worked example.
   // ---------------------------------------------------------------------------
   // Geometric primitive heads. Registered as known typed heads so consumers
   // can branch on the operator name; CE itself doesn't render them. The
@@ -15710,7 +15827,7 @@ function serialize(expr) {
 }
 
 // src/latex-syntax.ts
-var version = "0.57.0";
+var version = "0.58.0";
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,