@cortex-js/compute-engine 0.26.0 → 0.26.3

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.26.0 */
+/** Compute Engine 0.26.3 */
     (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.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -4053,6 +4053,7 @@ Invalid type
   function parseType(s) {
     if (s === void 0) return void 0;
     if (isValidType(s)) return s;
+    if (typeof s !== "string") return void 0;
     if (PRIMITIVE_TYPES.includes(s)) return s;
     const parser = new TypeParser(s);
     return parser.parse();
@@ -4628,6 +4629,7 @@ Invalid type
   var ADDITION_PRECEDENCE = 275;
   var MULTIPLICATION_PRECEDENCE = 390;
   var DIVISION_PRECEDENCE = 600;
+  var EXPONENTIATION_PRECEDENCE = 700;
   var POSTFIX_PRECEDENCE = 810;
   function isExpressionEntry(entry) {
     return !("kind" in entry) || entry.kind === "expression";
@@ -6489,20 +6491,20 @@ Invalid type
     if (def === void 0 || def === null || typeof def !== "object")
       return false;
     if (isBoxedExpression(def)) return false;
-    if ("type" in def || "value" in def || "constant" in def) {
-      if (typeof def.type === "function") {
+    if ("value" in def || "constant" in def || "inferred" in def) {
+      if ("type" in def && typeof def.type === "function") {
         throw new Error(
-          "The type field of a symbol definition should be a type string"
+          "The `type` field of a symbol definition should be of type `string`"
         );
       }
       if ("signature" in def) {
         throw new Error(
-          "Symbol definition cannot have a signature field. Use a type field instead."
+          "Symbol definition cannot have a `signature` field. Use a `type` field instead."
         );
       }
       if ("sgn" in def) {
         throw new Error(
-          "Symbol definition cannot have a sgn field. Use a flags field instead."
+          "Symbol definition cannot have a `sgn` field. Use a `flags.sgn` field instead."
         );
       }
       return true;
@@ -6516,22 +6518,23 @@ Invalid type
     if ("signature" in def || "complexity" in def) {
       if ("constant" in def) {
         throw new Error(
-          "Function definition cannot have a constant field and symbol definition cannot have a signature field."
+          "Function definition cannot have a `constant` field and symbol definition cannot have a `signature` field."
         );
       }
-      if ("type" in def && typeof def.type !== "function") {
-        throw new Error(
-          "The type field of a function definition should be a function"
-        );
-      }
-      if ("sgn" in def && typeof def.sgn !== "function") {
-        throw new Error(
-          "The sgn field of a function definition should be a function"
-        );
-      }
-      return true;
     }
-    return false;
+    if (!("evaluate" in def) && !("signature" in def) && !("sgn" in def) && !("complexity" in def) && !("canonical" in def))
+      return false;
+    if ("type" in def && typeof def.type !== "function") {
+      throw new Error(
+        "The `type` field of a function definition should be a function"
+      );
+    }
+    if ("sgn" in def && typeof def.sgn !== "function") {
+      throw new Error(
+        "The `sgn` field of a function definition should be a function"
+      );
+    }
+    return true;
   }
   function semiCanonical(ce, xs) {
     if (!xs.every((x) => isBoxedExpression(x))) return xs.map((x) => ce.box(x));
@@ -7533,7 +7536,9 @@ Invalid type
     }
     return [value, ""];
   }
-  function numberToString(num) {
+  function numberToString(num, fractionalDigits) {
+    if (typeof fractionalDigits === "number" && typeof num === "number")
+      return num.toFixed(fractionalDigits);
     const numStr = num.toString();
     if (typeof num === "number" && Number.isInteger(num) && numStr.includes("e")) {
       const fixedStr = BigInt(num).toString();
@@ -7565,11 +7570,13 @@ Invalid type
     if (s === "-infinity") return null;
     return bigint(s);
   }
-  function numberToExpression(num) {
+  function numberToExpression(num, fractionalDigits) {
     if (typeof num === "number") {
       if (isNaN(num)) return "NaN";
       if (!Number.isFinite(num))
         return num < 0 ? "NegativeInfinity" : "PositiveInfinity";
+      if (typeof fractionalDigits === "number")
+        return { num: num.toFixed(fractionalDigits) };
       return num;
     }
     if (num >= Number.MIN_SAFE_INTEGER && num <= Number.MAX_SAFE_INTEGER)
@@ -7703,7 +7710,7 @@ Invalid type
       return result.mul(this.bignum(this.radical).sqrt());
     }
     get numerator() {
-      if (this.rational[1] === 1) return this;
+      if (this.rational[1] == 1) return this;
       return this.clone({
         rational: isMachineRational(this.rational) ? [this.rational[0], 1] : [this.rational[0], BigInt(1)],
         radical: this.radical
@@ -7745,10 +7752,10 @@ Invalid type
       return Number.isNaN(this.rational[0]);
     }
     get isPositiveInfinity() {
-      return this.rational[0] === Infinity;
+      return this.rational[0] == Infinity;
     }
     get isNegativeInfinity() {
-      return this.rational[0] === -Infinity;
+      return this.rational[0] == -Infinity;
     }
     get isComplexInfinity() {
       return false;
@@ -7890,7 +7897,7 @@ Invalid type
           exponent = { re: exponent.re, im: exponent.im };
         } else {
           if (exponent instanceof _ExactNumericValue) {
-            if (exponent.radical === 1 && exponent.rational[0] === 1)
+            if (exponent.radical === 1 && exponent.rational[0] == 1)
               return this.root(exponent.rational[0]);
           }
           exponent = exponent.re;
@@ -7972,7 +7979,7 @@ Invalid type
         return this.factory({ im: Math.pow(-this.re, 1 / exponent) });
       if (this.radical > SMALL_INTEGER || this.rational[0] > SMALL_INTEGER || this.rational[0] < -SMALL_INTEGER || this.rational[1] > SMALL_INTEGER)
         return this.factory(this.bignumRe).root(exponent);
-      if (this.rational[1] === 1) {
+      if (this.rational[1] == 1) {
         const root2 = Math.pow(this.rational[0], 1 / exponent);
         if (Number.isInteger(root2)) return this.clone(root2);
       }
@@ -8038,7 +8045,7 @@ Invalid type
     }
     eq(other) {
       if (typeof other === "number")
-        return this.radical === 1 && isInteger(this.rational) && this.rational[0] === other;
+        return this.radical === 1 && isInteger(this.rational) && this.rational[0] == other;
       if (other instanceof _ExactNumericValue) {
         return this.radical === other.radical && this.rational[0] == other.rational[0] && this.rational[1] == other.rational[1];
       }
@@ -8202,7 +8209,7 @@ Invalid type
   // src/compute-engine/boxed-expression/polynomials.ts
   function totalDegree(expr) {
     if (expr.symbol && !expr.isConstant) return 1;
-    if (expr.operator === "Power" && expr.op2.numericValue !== null) {
+    if (expr.operator === "Power" && expr.op2.isNumberLiteral) {
       if (totalDegree(expr.op1) === 0) return 0;
       const deg = asSmallInteger(expr.op2);
       if (deg !== null && deg > 0) return deg;
@@ -8227,7 +8234,7 @@ Invalid type
   }
   function maxDegree(expr) {
     if (expr.symbol && !expr.isConstant) return 1;
-    if (expr.operator === "Power" && expr.op2.numericValue !== null) {
+    if (expr.operator === "Power" && expr.op2.isNumberLiteral) {
       if (maxDegree(expr.op1) === 0) return 0;
       const deg = asSmallInteger(expr.op2);
       if (deg !== null && deg > 0) return deg;
@@ -9536,6 +9543,16 @@ Invalid type
   }
 
   // src/compute-engine/boxed-expression/negate.ts
+  function canonicalNegate(expr) {
+    let sign2 = -1;
+    while (expr.operator === "Negate") {
+      expr = expr.op1;
+      sign2 = -sign2;
+    }
+    if (sign2 === 1) return expr;
+    if (expr.isNumberLiteral) return expr.neg();
+    return expr.engine._fn("Negate", [expr]);
+  }
   function negate(expr) {
     let sign2 = -1;
     while (expr.operator === "Negate") {
@@ -9548,9 +9565,7 @@ Invalid type
     if (expr.operator === "Subtract") return expr.op2.sub(expr.op1);
     if (expr.operator === "Add") return add3(...expr.ops.map((x) => negate(x)));
     if (expr.operator === "Multiply") return negateProduct(ce, expr.ops);
-    if (expr.operator === "Divide") {
-      return negate(expr.op1).div(expr.op2);
-    }
+    if (expr.operator === "Divide") return negate(expr.op1).div(expr.op2);
     return ce._fn("Negate", [expr]);
   }
   function negateProduct(ce, args) {
@@ -9612,7 +9627,10 @@ Invalid type
         if (next.operator === "Sqrt" && next.op1.isNumberLiteral && isSubtype(next.op1.type, "finite_integer")) {
           let radical = next.op1.numericValue;
           if (typeof radical !== "number") radical = radical.re;
-          if (radical >= SMALL_INTEGER) continue;
+          if (radical >= SMALL_INTEGER) {
+            ys.push(x);
+            continue;
+          }
           if (isSubtype(x.type, "finite_rational")) {
             const rational = x.numericValue;
             const [num, den] = typeof rational === "number" ? [rational, 1] : [rational.numerator.re, rational.denominator.re];
@@ -9705,6 +9723,7 @@ Invalid type
   function canonicalDivide(op1, op2) {
     const ce = op1.engine;
     if (!op1.isValid || !op2.isValid) return ce._fn("Divide", [op1, op2]);
+    if (op1.isNaN || op2.isNaN) return ce.NaN;
     if (op2.is(0)) return op1.is(0) ? ce.NaN : ce.ComplexInfinity;
     if (op1.is(0)) return ce.Zero;
     if (op2.is(0) === false) {
@@ -9904,9 +9923,11 @@ Invalid type
             return;
           }
           if (term.isInfinity) {
-            this.coefficient = this.engine._numericValue(
-              term.isNegative ? -Infinity : Infinity
-            );
+            if (isOne(exp2)) {
+              this.coefficient = this.engine._numericValue(
+                term.isNegative ? -Infinity : Infinity
+              );
+            } else this.terms.push({ term, exponent: exp2 });
             return;
           }
           if (isOne(exp2)) {
@@ -10061,8 +10082,15 @@ Invalid type
       const ce = this.engine;
       const coef = this.coefficient;
       if (coef.isZero) return [ce.Zero, ce.One];
-      if (coef.isPositiveInfinity || coef.isNegativeInfinity)
+      if (coef.isPositiveInfinity || coef.isNegativeInfinity) {
+        if (this.terms.length === 0) {
+          return [
+            coef.isPositiveInfinity ? ce.PositiveInfinity : ce.NegativeInfinity,
+            ce.One
+          ];
+        }
         return [ce.NaN, ce.NaN];
+      }
       const isNegativeOne2 = coef.isNegativeOne;
       if (isNegativeOne2) this.coefficient = ce._numericValue(1);
       const xs = this.groupedByDegrees({ mode: "rational" });
@@ -10629,13 +10657,23 @@ Invalid type
           (x) => x.sinh(),
           (x) => x.sinh()
         );
-      case "Tan":
-        return applyAngle(
+      case "Tan": {
+        const result = applyAngle(
           op,
-          Math.tan,
-          (x) => x.toSignificantDigits(ce.precision + 4).tan().toSignificantDigits(ce.precision),
+          (x) => {
+            const y = Math.tan(x);
+            if (y > 1e6 || y < -1e6) return ce.ComplexInfinity;
+            return y;
+          },
+          (x) => {
+            const y = x.tan();
+            if (y.greaterThan(1e6) || y.lessThan(-1e6)) return ce.ComplexInfinity;
+            return y;
+          },
           (x) => x.tan()
         );
+        return result;
+      }
       case "Tanh":
         return applyAngle(
           op,
@@ -10869,9 +10907,11 @@ Invalid type
     if (exp2 === 1) return a;
     if (exp2 === 2) {
       if (a.isNumberLiteral && isSubtype(a.type, "rational")) {
-        const v = a.sqrt();
-        if (typeof v.numericValue === "number") return v;
-        if (v.numericValue.isExact) return v;
+        if (a.re < SMALL_INTEGER) {
+          const v = a.sqrt();
+          if (typeof v.numericValue === "number") return v;
+          if (v.numericValue.isExact) return v;
+        }
       }
       return ce._fn("Sqrt", [a]);
     }
@@ -11639,10 +11679,9 @@ Invalid type
       ce.resetContext();
       let i = 0;
       for (const param of params) ce.assign(param, args[i++]);
-      const result = fn.N() ?? fn.evaluate();
+      const result = fn.evaluate();
       ce.swapScope(context);
-      if (!result.isValid) return void 0;
-      return result;
+      return result.isValid ? result : void 0;
     };
   }
   function apply3(fn, args) {
@@ -13072,7 +13111,7 @@ Invalid type
         sgn: ([x]) => x.isNonNegative ? "positive" : x.isNegative || x.isReal === false ? "unsigned" : void 0,
         canonical: (args, { engine }) => {
           const x = args[0];
-          if (x.numericValue !== null && x.isNegative)
+          if (x.isNumberLiteral && x.isNegative)
             return engine._fn("Factorial", [x.neg()]).neg();
           return engine._fn("Factorial", [x]);
         },
@@ -13439,7 +13478,7 @@ Invalid type
           const [base, exp2] = args;
           return canonicalRoot(base, exp2);
         },
-        evaluate: ([x, n], { numericApproximation }) => x.root(n)
+        evaluate: ([x, n], { numericApproximation }) => root(x, n, { numericApproximation })
       },
       Round: {
         complexity: 1250,
@@ -18155,6 +18194,9 @@ ${e.message}`);
     fractionalPart += lastDigit;
     while (fractionalPart.endsWith("0"))
       fractionalPart = fractionalPart.slice(0, -1);
+    if (typeof options.fractionalDigits === "number") {
+      fractionalPart = fractionalPart.slice(0, options.fractionalDigits);
+    }
     if (exponent)
       return `${wholepart}.${fractionalPart}${exponent.toLowerCase()}`;
     return `${wholepart}.${fractionalPart}`;
@@ -18309,7 +18351,7 @@ ${e.message}`);
           metadata.latex = metadata.latex ?? ce.box({ num: value.toString() }).latex;
         if (metadata.latex !== void 0)
           return { num: value.toString(), latex: metadata.latex };
-        return shorthandAllowed ? numberToExpression(value) : { num: numberToString(value) };
+        return shorthandAllowed ? numberToExpression(value, options.fractionalDigits) : { num: numberToString(value, options.fractionalDigits) };
       }
     }
     let result;
@@ -18471,6 +18513,8 @@ ${e.message}`);
         }
         if (options.fractionalDigits === "auto")
           defaultOptions.fractionalDigits = -this.engine.precision;
+        if (typeof options.fractionalDigits === "number")
+          defaultOptions.fractionalDigits = options.fractionalDigits;
       }
       const opts = {
         ...defaultOptions,
@@ -18527,6 +18571,7 @@ ${e.message}`);
       };
       if (options?.fractionalDigits === "auto")
         effectiveOptions.fractionalDigits = -this.engine.precision;
+      else effectiveOptions.fractionalDigits = options?.fractionalDigits ?? "max";
       if (typeof effectiveOptions.fractionalDigits === "number" && effectiveOptions.fractionalDigits > this.engine.precision)
         effectiveOptions.fractionalDigits = this.engine.precision;
       effectiveOptions = {
@@ -18655,7 +18700,7 @@ ${e.message}`);
       return null;
     }
     get isNumberLiteral() {
-      return this.numericValue !== null;
+      return false;
     }
     get isFunctionExpression() {
       return false;
@@ -18828,6 +18873,9 @@ ${e.message}`);
     simplify(_options) {
       return this;
     }
+    expand() {
+      return expand2(this) ?? this;
+    }
     evaluate(_options) {
       return this.simplify();
     }
@@ -21324,7 +21372,7 @@ ${e.message}`);
     return expr.engine._fn(expr.operator, expr.ops.map(invisibleOperatorForm));
   }
   function numberForm(expr) {
-    if (expr.numericValue !== null) return expr.canonical;
+    if (expr.isNumberLiteral) return expr.canonical;
     if (expr.ops) return expr.engine._fn(expr.operator, expr.ops.map(numberForm));
     return expr;
   }
@@ -21455,10 +21503,10 @@ ${e.message}`);
         if (typeof op1 === "number") return ce.number(-op1, options);
         if (op1 instanceof Decimal) return ce.number(op1.neg(), options);
         const boxedop1 = ce.box(op1, options);
-        ops = [boxedop1];
         const num = boxedop1.numericValue;
         if (num !== null)
           return ce.number(typeof num === "number" ? -num : num.neg(), options);
+        ops = [boxedop1];
       }
     }
     if (options.canonical === true)
@@ -21607,7 +21655,7 @@ ${e.message}`);
     } else return null;
     if (!ops.every((x) => x.isValid)) return ce._fn(name, ops, metadata);
     if (name === "Add") return canonicalAdd(ce, ops);
-    if (name === "Negate") return ops[0].neg();
+    if (name === "Negate") return canonicalNegate(ops[0]);
     if (name === "Multiply") return canonicalMultiply(ce, ops);
     if (name === "Divide") {
       if (ops.length === 2)
@@ -21750,8 +21798,15 @@ ${e.message}`);
     Log: ["Power", ["Multiply", "_", ["Ln", "10"]], -1],
     Sqrt: ["Multiply", ["Power", "_", ["Negate", "Half"]], "Half"],
     Abs: [
-      "Piecewise",
-      ["Tuple", ["Multiply", "_", ["Power", "_", -1]], ["Greater", "_", 0]]
+      "Which",
+      ["Equal", "_", 0],
+      NaN,
+      ["Less", "_", 0],
+      -1,
+      ["Greater", "_", 0],
+      1,
+      "True",
+      ["D", ["Abs", "_"], "_"]
     ],
     // https://proofwiki.org/wiki/Derivative_of_Error_Function
     Erf: [
@@ -21825,7 +21880,7 @@ ${e.message}`);
   function differentiate(expr, v) {
     const ce = expr.engine;
     if (expr.string) return void 0;
-    if (expr.numericValue !== null) return expr.engine.Zero;
+    if (expr.isNumberLiteral) return expr.engine.Zero;
     if (expr.symbol === v) return expr.engine.One;
     if (expr.symbol) return expr.engine.Zero;
     if (!expr.operator) return void 0;
@@ -23435,8 +23490,10 @@ ${e.message}`);
       evaluate: evaluateImplies
     },
     Exists: { signature: "function", hold: true },
+    NotExists: { signature: "function", hold: true },
     ExistsUnique: { signature: "function", hold: true },
     ForAll: { signature: "function", hold: true },
+    NotForAll: { signature: "function", hold: true },
     KroneckerDelta: {
       description: "Return 1 if the arguments are equal, 0 otherwise",
       signature: "(value, ...value) -> integer",
@@ -24606,9 +24663,9 @@ ${e.message}`);
           }
           return ce.number(fArg).div(180).mul(ce.Pi);
         },
-        evaluate: (ops, { engine: ce }) => {
-          if (ce.angularUnit === "deg") return ops[0];
-          return ops[0].mul(ce.Pi.div(180)).evaluate();
+        evaluate: (ops, options) => {
+          if (options.engine.angularUnit === "deg") return ops[0];
+          return ops[0].mul(options.engine.Pi.div(180)).evaluate(options);
         }
       },
       // Hypot: sqrt(x*x + y*y)
@@ -25296,6 +25353,9 @@ Error in definition of "${name}"`,
     get numericValue() {
       return this._value;
     }
+    get isNumberLiteral() {
+      return true;
+    }
     get re() {
       if (typeof this._value === "number") return this._value;
       return this._value.re;
@@ -25419,7 +25479,7 @@ Error in definition of "${name}"`,
       if (typeof this._value === "number") {
         if (this._value === 0 || this._value === 1) return this;
         if (this._value === -1) return this.engine.I;
-        if (this._value > 0 && Number.isInteger(this._value))
+        if (this._value > 0 && Number.isInteger(this._value) && this._value < SMALL_INTEGER)
           return this.engine.number(
             this.engine._numericValue({ radical: this._value })
           );
@@ -25675,12 +25735,10 @@ Error in definition of "${name}"`,
     }
     const n = bigint(s);
     if (n !== null) {
-      if (n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER)
-        return Number(n);
+      if (n >= -SMALL_INTEGER && n <= SMALL_INTEGER) return Number(n);
       return ce._numericValue(n);
     }
-    const b = ce.bignum(s);
-    return isInMachineRange(b) ? b.toNumber() : ce._numericValue(b);
+    return ce._numericValue(ce.bignum(s));
   }
 
   // src/compute-engine/boxed-expression/boxed-symbol.ts
@@ -27039,14 +27097,12 @@ Error in definition of "${name}"`,
       name: "Negate",
       latexTrigger: ["-"],
       kind: "prefix",
-      precedence: ADDITION_PRECEDENCE + 2,
+      precedence: EXPONENTIATION_PRECEDENCE + 1,
       parse: (parser, terminator) => {
         parser.skipSpace();
-        if (/\d/.test(parser.peek)) return null;
-        if (parser.parseNumber() !== null) return null;
         const rhs = parser.parseExpression({
           ...terminator,
-          minPrec: ADDITION_PRECEDENCE + 3
+          minPrec: EXPONENTIATION_PRECEDENCE + 3
         });
         if (rhs === null) return null;
         return ["Negate", rhs];
@@ -27137,7 +27193,7 @@ Error in definition of "${name}"`,
       latexTrigger: ["^"],
       kind: "infix",
       serialize: serializePower
-      // Parsing is done as a special case in `parseExpression`
+      // Parsing is done as a special case in `parseSupsub`
     },
     {
       latexTrigger: "\\prod",
@@ -27861,6 +27917,24 @@ Error in definition of "${name}"`,
       serialize: "\\exists!",
       parse: parseQuantifier("ExistsUnique")
     },
+    {
+      name: "NotForAll",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\forall"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE
+      serialize: "\\lnot\\forall",
+      parse: parseQuantifier("NotForAll")
+    },
+    {
+      name: "NotExists",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\exists"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: "\\lnot\\exists",
+      parse: parseQuantifier("NotExists")
+    },
     {
       name: "KroneckerDelta",
       kind: "prefix",
@@ -27928,14 +28002,11 @@ Error in definition of "${name}"`,
       if (id) {
         parser.skipSpace();
         if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-          const body = parser.parseExpression(terminator);
-          return [kind, id, missingIfEmpty(body)];
-        }
-        if (parser.match("(")) {
-          const body = parser.parseExpression(terminator);
-          if (!parser.match(")")) return null;
-          return [kind, id, missingIfEmpty(body)];
+          const body2 = parser.parseExpression(terminator);
+          return [kind, id, missingIfEmpty(body2)];
         }
+        const body = parser.parseEnclosure();
+        if (body) return [kind, id, missingIfEmpty(body)];
       }
       parser.index = index;
       const condition = parser.parseExpression(terminator);
@@ -32954,7 +33025,7 @@ Error in definition of "${name}"`,
       }
       if ("radical" in value || "rational" in value) {
         if (value.radical !== void 0 && (!Number.isInteger(value.radical) || value.radical >= SMALL_INTEGER)) {
-          return makeNumericValue(value);
+          throw Error("Unexpected value for radical part:" + value.radical);
         }
         if (value.rational) {
           if (isMachineRational(value.rational)) {
@@ -33251,11 +33322,19 @@ Invalid definition for ${id}`, err.message].join("\n|   ") + "\n"
       {
         const type2 = parseType(def);
         if (!isValidType(type2)) {
+          if (typeof def === "object" && "N" in def) {
+            throw Error(
+              [
+                `Invalid argument for "${id}"`,
+                "Use `evaluate` handler instead of `N`"
+              ].join("\n|   ")
+            );
+          }
           throw Error(
             [
               `Invalid argument for "${id}"`,
               def.toString(),
-              `Use a type, a FunctionDefinition or a SymbolDefinition`
+              `Use a type, a \`FunctionDefinition\` or a \`SymbolDefinition\``
             ].join("\n|   ")
           );
         }
@@ -34346,10 +34425,10 @@ ${lineNo.toString().padStart(maxDigits, " ")}`;
   }
 
   // src/compute-engine.ts
-  var version = "0.26.0";
+  var version = "0.26.3";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.26.0"
+    version: "0.26.3"
   };
   return __toCommonJS(compute_engine_exports);
 })();