@cortex-js/compute-engine 0.29.1 → 0.30.1

package/dist/math-json.esm.js

@@ -1,275 +1,4 @@
-/** Compute Engine 0.29.1 */
-
-// src/common/json5.ts
-var JSON5 = class {
-  static parse(input) {
-    const parser = new JSON5Parser(input);
-    const value = parser.parseValue();
-    parser.skipWhitespace();
-    if (!parser.isAtEnd()) {
-      throw parser.error(
-        `Unexpected token '${parser.currentChar()}' after parsing complete value`
-      );
-    }
-    return value;
-  }
-};
-var JSON5Parser = class {
-  constructor(input) {
-    this.index = 0;
-    this.text = input;
-  }
-  parseValue() {
-    this.skipWhitespace();
-    if (this.isAtEnd()) {
-      throw this.error("Unexpected end of input");
-    }
-    const ch = this.currentChar();
-    if (ch === "{") return this.parseObject();
-    if (ch === "[") return this.parseArray();
-    if (ch === '"' || ch === "'") return this.parseString();
-    if (ch === "-" || ch === "+" || ch >= "0" && ch <= "9" || ch === ".")
-      return this.parseNumber();
-    return this.parseIdentifier();
-  }
-  parseObject() {
-    const obj = {};
-    this.expectChar("{");
-    this.skipWhitespace();
-    if (this.currentChar() === "}") {
-      this.index++;
-      return obj;
-    }
-    while (true) {
-      this.skipWhitespace();
-      let key;
-      const ch = this.currentChar();
-      if (ch === '"' || ch === "'") {
-        key = this.parseString();
-      } else {
-        key = this.parseIdentifier();
-      }
-      this.skipWhitespace();
-      this.expectChar(":");
-      this.skipWhitespace();
-      const value = this.parseValue();
-      obj[key] = value;
-      this.skipWhitespace();
-      if (this.currentChar() === ",") {
-        this.index++;
-        this.skipWhitespace();
-        if (this.currentChar() === "}") {
-          this.index++;
-          break;
-        }
-      } else if (this.currentChar() === "}") {
-        this.index++;
-        break;
-      } else {
-        throw this.error(
-          `Expected ',' or '}' in object but found '${this.currentChar()}'`
-        );
-      }
-    }
-    return obj;
-  }
-  parseArray() {
-    const arr = [];
-    this.expectChar("[");
-    this.skipWhitespace();
-    if (this.currentChar() === "]") {
-      this.index++;
-      return arr;
-    }
-    while (true) {
-      this.skipWhitespace();
-      arr.push(this.parseValue());
-      this.skipWhitespace();
-      if (this.currentChar() === ",") {
-        this.index++;
-        this.skipWhitespace();
-        if (this.currentChar() === "]") {
-          this.index++;
-          break;
-        }
-      } else if (this.currentChar() === "]") {
-        this.index++;
-        break;
-      } else {
-        throw this.error(
-          `Expected ',' or ']' in array but found '${this.currentChar()}'`
-        );
-      }
-    }
-    return arr;
-  }
-  parseString() {
-    const quote = this.currentChar();
-    if (quote !== '"' && quote !== "'") {
-      throw this.error(`String should start with a quote, got '${quote}'`);
-    }
-    this.index++;
-    let result = "";
-    while (!this.isAtEnd()) {
-      const ch = this.currentChar();
-      if (ch === quote) {
-        this.index++;
-        return result;
-      }
-      if (ch === "\\") {
-        this.index++;
-        if (this.isAtEnd()) {
-          throw this.error("Unterminated escape sequence in string");
-        }
-        const esc = this.currentChar();
-        switch (esc) {
-          case "b":
-            result += "\b";
-            break;
-          case "f":
-            result += "\f";
-            break;
-          case "n":
-            result += "\n";
-            break;
-          case "r":
-            result += "\r";
-            break;
-          case "t":
-            result += "	";
-            break;
-          case "v":
-            result += "\v";
-            break;
-          case "\\":
-            result += "\\";
-            break;
-          case "'":
-            result += "'";
-            break;
-          case '"':
-            result += '"';
-            break;
-          case "0":
-            result += "\0";
-            break;
-          case "u": {
-            this.index++;
-            const hex = this.text.substr(this.index, 4);
-            if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-              throw this.error(`Invalid Unicode escape sequence: \\u${hex}`);
-            }
-            result += String.fromCharCode(parseInt(hex, 16));
-            this.index += 3;
-            break;
-          }
-          default:
-            result += esc;
-        }
-        this.index++;
-      } else {
-        result += ch;
-        this.index++;
-      }
-    }
-    throw this.error("Unterminated string literal");
-  }
-  parseNumber() {
-    const start = this.index;
-    if (this.text.startsWith("-Infinity", this.index)) {
-      this.index += "-Infinity".length;
-      return -Infinity;
-    }
-    if (this.text.startsWith("+Infinity", this.index)) {
-      this.index += "+Infinity".length;
-      return Infinity;
-    }
-    if (this.text.startsWith("Infinity", this.index)) {
-      this.index += "Infinity".length;
-      return Infinity;
-    }
-    while (!this.isAtEnd() && /[0-9+\-_.eE]/.test(this.currentChar())) {
-      this.index++;
-    }
-    const token = this.text.slice(start, this.index);
-    const normalized = token.replace(/_/g, "");
-    const num = Number(normalized);
-    if (isNaN(num)) {
-      throw this.error(`Invalid number: ${token}`);
-    }
-    return num;
-  }
-  parseIdentifier() {
-    const start = this.index;
-    const firstChar = this.currentChar();
-    if (!/[a-zA-Z$_]/.test(firstChar)) {
-      throw this.error(`Unexpected token '${firstChar}'`);
-    }
-    this.index++;
-    while (!this.isAtEnd()) {
-      const ch = this.currentChar();
-      if (!/[a-zA-Z0-9$_]/.test(ch)) break;
-      this.index++;
-    }
-    const token = this.text.slice(start, this.index);
-    if (token === "true") return true;
-    if (token === "false") return false;
-    if (token === "null") return null;
-    if (token === "Infinity") return Infinity;
-    if (token === "NaN") return NaN;
-    return token;
-  }
-  skipWhitespace() {
-    while (!this.isAtEnd()) {
-      const ch = this.currentChar();
-      if (/\s/.test(ch)) {
-        this.index++;
-        continue;
-      }
-      if (ch === "/") {
-        const next = this.peekChar(1);
-        if (next === "/") {
-          this.index += 2;
-          while (!this.isAtEnd() && this.currentChar() !== "\n") {
-            this.index++;
-          }
-          continue;
-        } else if (next === "*") {
-          this.index += 2;
-          while (!this.isAtEnd() && !(this.currentChar() === "*" && this.peekChar(1) === "/")) {
-            this.index++;
-          }
-          if (this.isAtEnd()) {
-            throw this.error("Unterminated multi-line comment");
-          }
-          this.index += 2;
-          continue;
-        }
-      }
-      break;
-    }
-  }
-  expectChar(expected) {
-    if (this.currentChar() !== expected) {
-      throw this.error(
-        `Expected '${expected}' but found '${this.currentChar()}'`
-      );
-    }
-    this.index++;
-  }
-  currentChar() {
-    return this.text[this.index];
-  }
-  peekChar(offset) {
-    return this.text[this.index + offset];
-  }
-  isAtEnd() {
-    return this.index >= this.text.length;
-  }
-  error(message) {
-    return new Error(`${message} at position ${this.index}`);
-  }
-};
+/** Compute Engine 0.30.1 */
 
 // src/math-json/utils.ts
 function isSymbolObject(expr) {
@@ -278,16 +7,20 @@ function isSymbolObject(expr) {
 function isStringObject(expr) {
   return expr !== null && typeof expr === "object" && "str" in expr;
 }
+function isDictionaryObject(expr) {
+  return expr !== null && typeof expr === "object" && "dict" in expr && typeof expr.dict === "object" && !Array.isArray(expr.dict) && expr.dict !== null;
+}
 function isFunctionObject(expr) {
-  return expr !== null && typeof expr === "object" && "fn" in expr;
+  return expr !== null && typeof expr === "object" && "fn" in expr && Array.isArray(expr.fn) && expr.fn.length > 0 && typeof expr.fn[0] === "string";
 }
 function stringValue(expr) {
   if (expr === null || expr === void 0) return null;
   if (typeof expr === "object" && "str" in expr) return expr.str;
   if (typeof expr !== "string") return null;
-  if (expr.length < 2) return null;
-  if (expr.at(0) !== "'" || expr.at(-1) !== "'") return null;
-  return expr.substring(1, expr.length - 1);
+  if (expr.length >= 2 && expr.at(0) === "'" && expr.at(-1) === "'")
+    return expr.substring(1, expr.length - 1);
+  if (matchesNumber(expr) || matchesSymbol(expr)) return null;
+  return expr;
 }
 function operator(expr) {
   if (Array.isArray(expr)) return expr[0];
@@ -312,16 +45,14 @@ function nops(expr) {
   return 0;
 }
 function symbol(expr) {
-  if (typeof expr === "string") {
-    if (/^[+-]?[0-9\.]/.test(expr)) return null;
-    if (expr.length >= 2 && expr[0] === "'" && expr[expr.length - 1] === "'")
-      return null;
+  if (typeof expr === "string" && matchesSymbol(expr)) {
+    if (expr.length >= 2 && expr.at(0) === "`" && expr.at(-1) === "`")
+      return expr.slice(1, -1);
     return expr;
   }
   if (expr === null || expr === void 0) return null;
-  const s = isSymbolObject(expr) ? expr.sym : expr;
-  if (typeof s !== "string") return null;
-  return s;
+  if (isSymbolObject(expr)) return expr.sym;
+  return null;
 }
 function keyValuePair(expr) {
   const h = operator(expr);
@@ -335,16 +66,7 @@ function keyValuePair(expr) {
 }
 function dictionaryFromExpression(expr) {
   if (expr === null) return null;
-  if (typeof expr === "object" && !("sym" in expr) && !("num" in expr) && !("str" in expr) && !("fn" in expr)) {
-    return expr;
-  }
-  if (typeof expr === "string" && expr[0] === "{" && expr[expr.length - 1] === "}") {
-    try {
-      return JSON5.parse(expr);
-    } catch {
-      return null;
-    }
-  }
+  if (isDictionaryObject(expr)) return expr;
   const kv = keyValuePair(expr);
   if (kv) return { [kv[0]]: kv[1] };
   if (operator(expr) === "Dictionary") {
@@ -371,9 +93,15 @@ function mapArgs(expr, fn) {
   }
   return result;
 }
+function matchesNumber(s) {
+  return /^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(s) || /^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(s);
+}
+function matchesSymbol(s) {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s) || s.length >= 2 && s[0] === "`" && s[s.length - 1] === "`";
+}
 
 // src/math-json.ts
-var version = "0.29.1";
+var version = "0.30.1";
 export {
   dictionaryFromExpression,
   isFunctionObject,