@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/dist/chunk-723TPVHD.js

@@ -1,1074 +0,0 @@
-import { logger } from './chunk-SATNCODL.js';
-
-// src/HoloScriptCodeParser.ts
-var CODE_SECURITY_CONFIG = {
-  maxCodeLength: 5e4,
-  maxBlocks: 100,
-  suspiciousKeywords: [
-    "process",
-    "require",
-    "eval",
-    "import",
-    "constructor",
-    "prototype",
-    "__proto__",
-    "fs",
-    "child_process",
-    "exec",
-    "spawn"
-  ]
-};
-var HoloScriptCodeParser = class {
-  constructor() {
-    this.errors = [];
-    this.warnings = [];
-    this.tokens = [];
-    this.position = 0;
-  }
-  /**
-   * Parse HoloScript code string into AST
-   */
-  parse(code) {
-    this.errors = [];
-    this.warnings = [];
-    this.tokens = [];
-    this.position = 0;
-    if (code.length > CODE_SECURITY_CONFIG.maxCodeLength) {
-      return {
-        success: false,
-        ast: [],
-        errors: [{ line: 0, column: 0, message: `Code exceeds max length (${CODE_SECURITY_CONFIG.maxCodeLength})` }],
-        warnings: []
-      };
-    }
-    for (const keyword of CODE_SECURITY_CONFIG.suspiciousKeywords) {
-      if (code.toLowerCase().includes(keyword)) {
-        logger.warn("Suspicious keyword detected", { keyword });
-        return {
-          success: false,
-          ast: [],
-          errors: [{ line: 0, column: 0, message: `Suspicious keyword detected: ${keyword}` }],
-          warnings: []
-        };
-      }
-    }
-    try {
-      this.tokens = this.tokenize(code);
-      const ast = this.parseProgram();
-      return {
-        success: this.errors.length === 0,
-        ast,
-        errors: this.errors,
-        warnings: this.warnings
-      };
-    } catch (error) {
-      return {
-        success: false,
-        ast: [],
-        errors: [{ line: 0, column: 0, message: String(error) }],
-        warnings: this.warnings
-      };
-    }
-  }
-  /**
-   * Tokenize code into tokens
-   */
-  tokenize(code) {
-    const tokens = [];
-    let line = 1;
-    let column = 1;
-    let i = 0;
-    const keywords = [
-      "orb",
-      "function",
-      "connect",
-      "to",
-      "as",
-      "gate",
-      "stream",
-      "from",
-      "through",
-      "return",
-      "if",
-      "else",
-      "nexus",
-      "building",
-      "pillar",
-      "foundation",
-      // Phase 2: Loop constructs
-      "for",
-      "while",
-      "forEach",
-      "in",
-      "of",
-      "break",
-      "continue",
-      // Phase 2: Module system
-      "import",
-      "export",
-      "module",
-      "use",
-      // Phase 2: Type system
-      "type",
-      "interface",
-      "extends",
-      "implements",
-      // Phase 2: Async
-      "async",
-      "await",
-      "spawn",
-      "parallel",
-      // Phase 2: Object-oriented
-      "class",
-      "new",
-      "this",
-      "super",
-      "static",
-      "private",
-      "public",
-      // Phase 2: Error handling
-      "try",
-      "catch",
-      "finally",
-      "throw",
-      // Phase 2: Constants
-      "const",
-      "let",
-      "var",
-      // Phase B: Data cells
-      "data_cell",
-      "data_zone",
-      "data_source",
-      "refresh",
-      "position_offset",
-      "props"
-    ];
-    while (i < code.length) {
-      const char = code[i];
-      if (char === " " || char === "	" || char === "\r") {
-        i++;
-        column++;
-        continue;
-      }
-      if (char === "\n") {
-        tokens.push({ type: "newline", value: "\n", line, column });
-        line++;
-        column = 1;
-        i++;
-        continue;
-      }
-      if (char === "/" && code[i + 1] === "/") {
-        while (i < code.length && code[i] !== "\n") {
-          i++;
-        }
-        continue;
-      }
-      if (char === '"' || char === "'") {
-        const quote = char;
-        let str = "";
-        const startCol = column;
-        i++;
-        column++;
-        while (i < code.length && code[i] !== quote) {
-          if (code[i] === "\\" && i + 1 < code.length) {
-            str += code[i + 1];
-            i += 2;
-            column += 2;
-          } else {
-            str += code[i];
-            i++;
-            column++;
-          }
-        }
-        i++;
-        column++;
-        tokens.push({ type: "string", value: str, line, column: startCol });
-        continue;
-      }
-      if (/[0-9]/.test(char) || char === "-" && /[0-9]/.test(code[i + 1])) {
-        let num = "";
-        const startCol = column;
-        while (i < code.length && /[0-9.\-]/.test(code[i])) {
-          num += code[i];
-          i++;
-          column++;
-        }
-        tokens.push({ type: "number", value: num, line, column: startCol });
-        continue;
-      }
-      if (/[a-zA-Z_]/.test(char)) {
-        let ident = "";
-        const startCol = column;
-        while (i < code.length && /[a-zA-Z0-9_]/.test(code[i])) {
-          ident += code[i];
-          i++;
-          column++;
-        }
-        const isKeyword = keywords.includes(ident.toLowerCase());
-        tokens.push({
-          type: isKeyword ? "keyword" : "identifier",
-          value: ident,
-          line,
-          column: startCol
-        });
-        continue;
-      }
-      const multiCharOps = ["===", "!==", "==", "!=", ">=", "<=", "&&", "||", "++", "--", "+=", "-=", "*=", "/=", "%=", "=>", "->"];
-      let foundMultiOp = false;
-      for (const op of multiCharOps) {
-        if (code.substring(i, i + op.length) === op) {
-          tokens.push({ type: "operator", value: op, line, column });
-          i += op.length;
-          column += op.length;
-          foundMultiOp = true;
-          break;
-        }
-      }
-      if (foundMultiOp) continue;
-      const punctuation = ["{", "}", "(", ")", "[", "]", ":", ",", ".", ";", "=", "<", ">", "+", "-", "*", "/", "%", "!", "&", "|", "?"];
-      if (punctuation.includes(char)) {
-        tokens.push({ type: "punctuation", value: char, line, column });
-        i++;
-        column++;
-        continue;
-      }
-      i++;
-      column++;
-    }
-    return tokens;
-  }
-  /**
-   * Parse program (list of declarations)
-   */
-  parseProgram() {
-    const nodes = [];
-    let blockCount = 0;
-    while (this.position < this.tokens.length) {
-      while (this.currentToken()?.type === "newline") {
-        this.advance();
-      }
-      if (this.position >= this.tokens.length) break;
-      blockCount++;
-      if (blockCount > CODE_SECURITY_CONFIG.maxBlocks) {
-        this.errors.push({ line: 0, column: 0, message: "Too many blocks in program" });
-        break;
-      }
-      const node = this.parseDeclaration();
-      if (node) {
-        nodes.push(node);
-      }
-    }
-    return nodes;
-  }
-  /**
-   * Parse a single declaration
-   */
-  parseDeclaration() {
-    const token = this.currentToken();
-    if (!token) return null;
-    if (token.type === "keyword") {
-      switch (token.value.toLowerCase()) {
-        case "orb":
-          return this.parseOrb();
-        case "function":
-          return this.parseFunction();
-        case "connect":
-          return this.parseConnection();
-        case "gate":
-        case "if":
-          return this.parseGate();
-        case "stream":
-          return this.parseStream();
-        case "nexus":
-          return this.parseNexus();
-        case "building":
-        case "class":
-          return this.parseBuilding();
-        // Phase 2: Loop constructs
-        case "for":
-          return this.parseForLoop();
-        case "while":
-          return this.parseWhileLoop();
-        case "foreach":
-          return this.parseForEachLoop();
-        // Phase 2: Module system
-        case "import":
-          return this.parseImport();
-        case "export":
-          return this.parseExport();
-        // Phase 2: Variable declarations
-        case "const":
-        case "let":
-        case "var":
-          return this.parseVariableDeclaration();
-        // Phase B: Data cells
-        case "data_cell":
-          return this.parseDataCell();
-        case "data_zone":
-          return this.parseDataZone();
-        default:
-          this.advance();
-          return null;
-      }
-    }
-    this.advance();
-    return null;
-  }
-  /**
-   * Parse for loop: for (init; condition; update) { body }
-   */
-  parseForLoop() {
-    this.expect("keyword", "for");
-    if (!this.check("punctuation", "(")) {
-      this.errors.push({ line: 0, column: 0, message: "Expected ( after for" });
-      return null;
-    }
-    this.advance();
-    let init = "", condition = "", update = "";
-    let depth = 0;
-    while (this.position < this.tokens.length) {
-      const t = this.currentToken();
-      if (!t) break;
-      if (t.value === ";" && depth === 0) {
-        this.advance();
-        break;
-      }
-      if (t.value === "(") depth++;
-      if (t.value === ")") depth--;
-      init += t.value + " ";
-      this.advance();
-    }
-    depth = 0;
-    while (this.position < this.tokens.length) {
-      const t = this.currentToken();
-      if (!t) break;
-      if (t.value === ";" && depth === 0) {
-        this.advance();
-        break;
-      }
-      if (t.value === "(") depth++;
-      if (t.value === ")") depth--;
-      condition += t.value + " ";
-      this.advance();
-    }
-    depth = 0;
-    while (this.position < this.tokens.length) {
-      const t = this.currentToken();
-      if (!t) break;
-      if (t.value === ")" && depth === 0) {
-        this.advance();
-        break;
-      }
-      if (t.value === "(") depth++;
-      if (t.value === ")") depth--;
-      update += t.value + " ";
-      this.advance();
-    }
-    const body = [];
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let braceDepth = 1;
-      while (braceDepth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) braceDepth++;
-        if (this.check("punctuation", "}")) braceDepth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "for-loop",
-      init: init.trim(),
-      condition: condition.trim(),
-      update: update.trim(),
-      body,
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse while loop: while (condition) { body }
-   */
-  parseWhileLoop() {
-    this.expect("keyword", "while");
-    let condition = "";
-    if (this.check("punctuation", "(")) {
-      this.advance();
-      let depth = 1;
-      while (depth > 0 && this.position < this.tokens.length) {
-        const t = this.currentToken();
-        if (!t) break;
-        if (t.value === "(") depth++;
-        if (t.value === ")") {
-          depth--;
-          if (depth === 0) {
-            this.advance();
-            break;
-          }
-        }
-        condition += t.value + " ";
-        this.advance();
-      }
-    }
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let braceDepth = 1;
-      while (braceDepth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) braceDepth++;
-        if (this.check("punctuation", "}")) braceDepth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "while-loop",
-      condition: condition.trim(),
-      body: [],
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse forEach loop: forEach item in collection { body }
-   */
-  parseForEachLoop() {
-    this.expect("keyword", "forEach");
-    const variable = this.expectIdentifier();
-    this.expect("keyword", "in");
-    const collection = this.expectIdentifier();
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let braceDepth = 1;
-      while (braceDepth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) braceDepth++;
-        if (this.check("punctuation", "}")) braceDepth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "foreach-loop",
-      variable: variable || "item",
-      collection: collection || "items",
-      body: [],
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse import: import { x, y } from "module"
-   */
-  parseImport() {
-    this.expect("keyword", "import");
-    const imports = [];
-    let modulePath = "";
-    let defaultImport;
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
-        const name = this.expectIdentifier();
-        if (name) imports.push(name);
-        if (this.check("punctuation", ",")) this.advance();
-      }
-      this.expect("punctuation", "}");
-    } else {
-      defaultImport = this.expectIdentifier() || void 0;
-    }
-    if (this.check("keyword", "from")) {
-      this.advance();
-      const pathToken = this.currentToken();
-      if (pathToken?.type === "string") {
-        modulePath = pathToken.value;
-        this.advance();
-      }
-    }
-    return {
-      type: "import",
-      imports,
-      defaultImport,
-      modulePath,
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse export: export { x, y } or export function/orb
-   */
-  parseExport() {
-    this.expect("keyword", "export");
-    const next = this.currentToken();
-    if (next?.type === "keyword") {
-      const declaration = this.parseDeclaration();
-      return {
-        type: "export",
-        declaration: declaration || void 0,
-        position: { x: 0, y: 0, z: 0 }
-      };
-    }
-    const exports$1 = [];
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
-        const name = this.expectIdentifier();
-        if (name) exports$1.push(name);
-        if (this.check("punctuation", ",")) this.advance();
-      }
-      this.expect("punctuation", "}");
-    }
-    return {
-      type: "export",
-      exports: exports$1,
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse variable declaration: const/let/var name = value
-   */
-  parseVariableDeclaration() {
-    const kindToken = this.currentToken()?.value.toLowerCase();
-    const kind = kindToken === "let" ? "let" : kindToken === "var" ? "var" : "const";
-    this.advance();
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    let dataType;
-    if (this.check("punctuation", ":")) {
-      this.advance();
-      dataType = this.expectIdentifier() || void 0;
-    }
-    let value;
-    if (this.check("punctuation", "=")) {
-      this.advance();
-      const valueToken = this.currentToken();
-      if (valueToken?.type === "string") {
-        value = valueToken.value;
-        this.advance();
-      } else if (valueToken?.type === "number") {
-        value = parseFloat(valueToken.value);
-        this.advance();
-      } else if (valueToken?.type === "identifier") {
-        if (valueToken.value === "true") value = true;
-        else if (valueToken.value === "false") value = false;
-        else value = valueToken.value;
-        this.advance();
-      } else if (this.check("punctuation", "[")) {
-        value = this.parseArray();
-      } else if (this.check("punctuation", "{")) {
-        value = this.parseObject();
-      }
-    }
-    return {
-      type: "variable-declaration",
-      kind,
-      name,
-      dataType,
-      value,
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse data_cell declaration
-   *
-   * Syntax:
-   * data_cell {
-   *   type: "metric"
-   *   data_source: "/api/cpu"
-   *   refresh: 5s
-   *   position_offset: [0, 1, 0]
-   *   props: {
-   *     label: "CPU Usage"
-   *     style: { color: "#00ffff", glow: 0.5 }
-   *   }
-   * }
-   */
-  parseDataCell() {
-    const startToken = this.currentToken();
-    this.expect("keyword", "data_cell");
-    const node = {
-      type: "data_cell",
-      cellType: "text",
-      props: {},
-      position: { x: 0, y: 0, z: 0 },
-      line: startToken?.line,
-      column: startToken?.column
-    };
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
-        this.skipNewlines();
-        if (this.check("punctuation", "}")) break;
-        const prop = this.parseProperty();
-        if (prop) {
-          switch (prop.key) {
-            case "type":
-              node.cellType = prop.value;
-              break;
-            case "data_source":
-              node.dataSource = String(prop.value);
-              break;
-            case "refresh":
-              const refreshStr = String(prop.value);
-              if (refreshStr.endsWith("ms")) {
-                node.refresh = parseInt(refreshStr.replace("ms", ""), 10) / 1e3;
-              } else if (refreshStr.endsWith("s")) {
-                node.refresh = parseInt(refreshStr.replace("s", ""), 10);
-              } else {
-                node.refresh = parseFloat(refreshStr);
-              }
-              break;
-            case "position_offset":
-              if (Array.isArray(prop.value) && prop.value.length === 3) {
-                node.positionOffset = prop.value.map(Number);
-              }
-              break;
-            case "position":
-              if (Array.isArray(prop.value) && prop.value.length === 3) {
-                node.position = {
-                  x: Number(prop.value[0]),
-                  y: Number(prop.value[1]),
-                  z: Number(prop.value[2])
-                };
-              } else if (typeof prop.value === "object") {
-                node.position = this.parsePosition(prop.value);
-              }
-              break;
-            case "props":
-              if (typeof prop.value === "object" && prop.value !== null) {
-                node.props = { ...node.props, ...prop.value };
-              }
-              break;
-            default:
-              node.props[prop.key] = prop.value;
-          }
-        }
-        this.skipNewlines();
-      }
-      this.expect("punctuation", "}");
-    }
-    return node;
-  }
-  /**
-   * Parse data_zone declaration containing multiple data_cells
-   *
-   * Syntax:
-   * data_zone bridge_metrics {
-   *   position: [0, 2, 0]
-   *   orientation: face_captain
-   *
-   *   data_cell { ... }
-   *   data_cell { ... }
-   * }
-   */
-  parseDataZone() {
-    const startToken = this.currentToken();
-    this.expect("keyword", "data_zone");
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    const node = {
-      type: "data_zone",
-      name,
-      cells: [],
-      position: { x: 0, y: 0, z: 0 },
-      line: startToken?.line,
-      column: startToken?.column
-    };
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
-        this.skipNewlines();
-        if (this.check("punctuation", "}")) break;
-        if (this.check("keyword", "data_cell")) {
-          const cell = this.parseDataCell();
-          if (cell) {
-            node.cells.push(cell);
-          }
-        } else {
-          const prop = this.parseProperty();
-          if (prop) {
-            switch (prop.key) {
-              case "position":
-                if (Array.isArray(prop.value) && prop.value.length === 3) {
-                  node.position = {
-                    x: Number(prop.value[0]),
-                    y: Number(prop.value[1]),
-                    z: Number(prop.value[2])
-                  };
-                } else if (typeof prop.value === "object") {
-                  node.position = this.parsePosition(prop.value);
-                }
-                break;
-              case "orientation":
-                node.orientation = String(prop.value);
-                break;
-            }
-          }
-        }
-        this.skipNewlines();
-      }
-      this.expect("punctuation", "}");
-    }
-    return node;
-  }
-  /**
-   * Parse orb declaration
-   */
-  parseOrb() {
-    this.expect("keyword", "orb");
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    const properties = {};
-    let position;
-    let hologram;
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
-        this.skipNewlines();
-        if (this.check("punctuation", "}")) break;
-        const prop = this.parseProperty();
-        if (prop) {
-          if (prop.key === "position" || prop.key === "at") {
-            position = this.parsePosition(prop.value);
-          } else if (prop.key === "color" || prop.key === "glow" || prop.key === "size") {
-            hologram = hologram || { shape: "orb", color: "#00ffff", size: 1, glow: true, interactive: true };
-            if (prop.key === "color") hologram.color = String(prop.value);
-            if (prop.key === "glow") hologram.glow = Boolean(prop.value);
-            if (prop.key === "size") hologram.size = Number(prop.value);
-          } else {
-            properties[prop.key] = prop.value;
-          }
-        }
-        this.skipNewlines();
-      }
-      this.expect("punctuation", "}");
-    }
-    return {
-      type: "orb",
-      name,
-      position: position || { x: 0, y: 0, z: 0 },
-      hologram: hologram || { shape: "orb", color: "#00ffff", size: 1, glow: true, interactive: true },
-      properties,
-      methods: []
-    };
-  }
-  /**
-   * Parse function declaration
-   */
-  parseFunction() {
-    this.expect("keyword", "function");
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    const parameters = [];
-    let returnType;
-    if (this.check("punctuation", "(")) {
-      this.advance();
-      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
-        const paramName = this.expectIdentifier();
-        if (!paramName) break;
-        let paramType = "any";
-        if (this.check("punctuation", ":")) {
-          this.advance();
-          paramType = this.expectIdentifier() || "any";
-        }
-        parameters.push({
-          type: "parameter",
-          name: paramName,
-          dataType: paramType
-        });
-        if (this.check("punctuation", ",")) {
-          this.advance();
-        }
-      }
-      this.expect("punctuation", ")");
-    }
-    if (this.check("punctuation", ":")) {
-      this.advance();
-      returnType = this.expectIdentifier() || void 0;
-    }
-    const body = [];
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let depth = 1;
-      while (depth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) depth++;
-        if (this.check("punctuation", "}")) depth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "method",
-      name,
-      parameters,
-      body,
-      returnType,
-      position: { x: 0, y: 0, z: 0 },
-      hologram: { shape: "cube", color: "#ff6b35", size: 1.5, glow: true, interactive: true }
-    };
-  }
-  /**
-   * Parse connection
-   */
-  parseConnection() {
-    this.expect("keyword", "connect");
-    const from = this.expectIdentifier();
-    if (!from) return null;
-    this.expect("keyword", "to");
-    const to = this.expectIdentifier();
-    if (!to) return null;
-    let dataType = "any";
-    if (this.check("keyword", "as")) {
-      this.advance();
-      const typeStr = this.currentToken();
-      if (typeStr?.type === "string" || typeStr?.type === "identifier") {
-        dataType = typeStr.value;
-        this.advance();
-      }
-    }
-    return {
-      type: "connection",
-      from,
-      to,
-      dataType,
-      bidirectional: false
-    };
-  }
-  /**
-   * Parse gate (conditional)
-   */
-  parseGate() {
-    this.expect("keyword", "gate");
-    this.expectIdentifier();
-    let condition = "";
-    if (this.check("punctuation", "(")) {
-      this.advance();
-      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
-        const token = this.currentToken();
-        if (token) condition += token.value + " ";
-        this.advance();
-      }
-      this.expect("punctuation", ")");
-    }
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let depth = 1;
-      while (depth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) depth++;
-        if (this.check("punctuation", "}")) depth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "gate",
-      condition: condition.trim(),
-      truePath: [],
-      falsePath: [],
-      position: { x: 0, y: 0, z: 0 },
-      hologram: { shape: "pyramid", color: "#4ecdc4", size: 1, glow: true, interactive: true }
-    };
-  }
-  /**
-   * Parse stream
-   */
-  parseStream() {
-    this.expect("keyword", "stream");
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    let source = "unknown";
-    if (this.check("keyword", "from")) {
-      this.advance();
-      source = this.expectIdentifier() || "unknown";
-    }
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let depth = 1;
-      while (depth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) depth++;
-        if (this.check("punctuation", "}")) depth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "stream",
-      name,
-      source,
-      transformations: [],
-      position: { x: 0, y: 0, z: 0 },
-      hologram: { shape: "cylinder", color: "#45b7d1", size: 2, glow: true, interactive: true }
-    };
-  }
-  /**
-   * Parse nexus (multi-agent hub)
-   */
-  parseNexus() {
-    this.expect("keyword", "nexus");
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let depth = 1;
-      while (depth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) depth++;
-        if (this.check("punctuation", "}")) depth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "nexus",
-      position: { x: 0, y: 0, z: 0 },
-      hologram: { shape: "sphere", color: "#9b59b6", size: 3, glow: true, interactive: true }
-    };
-  }
-  /**
-   * Parse building (class-like)
-   */
-  parseBuilding() {
-    this.expect("keyword", "building");
-    const name = this.expectIdentifier();
-    if (!name) return null;
-    if (this.check("punctuation", "{")) {
-      this.advance();
-      let depth = 1;
-      while (depth > 0 && this.position < this.tokens.length) {
-        if (this.check("punctuation", "{")) depth++;
-        if (this.check("punctuation", "}")) depth--;
-        this.advance();
-      }
-    }
-    return {
-      type: "building",
-      position: { x: 0, y: 0, z: 0 },
-      hologram: { shape: "cube", color: "#e74c3c", size: 4, glow: true, interactive: true }
-    };
-  }
-  /**
-   * Parse a property (key: value)
-   */
-  parseProperty() {
-    const key = this.expectIdentifier();
-    if (!key) return null;
-    if (!this.check("punctuation", ":")) {
-      return { key, value: true };
-    }
-    this.advance();
-    const valueToken = this.currentToken();
-    if (!valueToken) return null;
-    let value;
-    if (valueToken.type === "string") {
-      value = valueToken.value;
-      this.advance();
-    } else if (valueToken.type === "number") {
-      value = parseFloat(valueToken.value);
-      this.advance();
-    } else if (valueToken.type === "identifier") {
-      if (valueToken.value === "true") value = true;
-      else if (valueToken.value === "false") value = false;
-      else value = valueToken.value;
-      this.advance();
-    } else if (this.check("punctuation", "[")) {
-      value = this.parseArray();
-    } else if (this.check("punctuation", "{")) {
-      value = this.parseObject();
-    } else {
-      value = valueToken.value;
-      this.advance();
-    }
-    return { key, value };
-  }
-  /**
-   * Parse array [...]
-   */
-  parseArray() {
-    const arr = [];
-    this.expect("punctuation", "[");
-    while (!this.check("punctuation", "]") && this.position < this.tokens.length) {
-      const token = this.currentToken();
-      if (token?.type === "string" || token?.type === "number" || token?.type === "identifier") {
-        if (token.type === "number") {
-          arr.push(parseFloat(token.value));
-        } else {
-          arr.push(token.value);
-        }
-        this.advance();
-      }
-      if (this.check("punctuation", ",")) {
-        this.advance();
-      }
-    }
-    this.expect("punctuation", "]");
-    return arr;
-  }
-  /**
-   * Parse object {...}
-   */
-  parseObject() {
-    const obj = {};
-    this.expect("punctuation", "{");
-    while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
-      this.skipNewlines();
-      if (this.check("punctuation", "}")) break;
-      const prop = this.parseProperty();
-      if (prop) {
-        obj[prop.key] = prop.value;
-      }
-      this.skipNewlines();
-      if (this.check("punctuation", ",")) {
-        this.advance();
-      }
-    }
-    this.expect("punctuation", "}");
-    return obj;
-  }
-  /**
-   * Parse position from value
-   */
-  parsePosition(value) {
-    if (typeof value === "object" && value !== null) {
-      const v = value;
-      return {
-        x: Number(v.x) || 0,
-        y: Number(v.y) || 0,
-        z: Number(v.z) || 0
-      };
-    }
-    return { x: 0, y: 0, z: 0 };
-  }
-  // Helper methods
-  currentToken() {
-    return this.tokens[this.position];
-  }
-  advance() {
-    return this.tokens[this.position++];
-  }
-  check(type, value) {
-    const token = this.currentToken();
-    if (!token) return false;
-    if (token.type !== type) return false;
-    if (value !== void 0 && token.value.toLowerCase() !== value.toLowerCase()) return false;
-    return true;
-  }
-  expect(type, value) {
-    if (this.check(type, value)) {
-      this.advance();
-      return true;
-    }
-    const token = this.currentToken();
-    this.errors.push({
-      line: token?.line || 0,
-      column: token?.column || 0,
-      message: `Expected ${type}${value ? ` '${value}'` : ""}, got ${token?.type || "EOF"} '${token?.value || ""}'`
-    });
-    return false;
-  }
-  expectIdentifier() {
-    const token = this.currentToken();
-    if (token?.type === "identifier" || token?.type === "keyword") {
-      this.advance();
-      return token.value;
-    }
-    this.errors.push({
-      line: token?.line || 0,
-      column: token?.column || 0,
-      message: `Expected identifier, got ${token?.type || "EOF"}`
-    });
-    return null;
-  }
-  skipNewlines() {
-    while (this.currentToken()?.type === "newline") {
-      this.advance();
-    }
-  }
-};
-
-export { HoloScriptCodeParser };
-//# sourceMappingURL=chunk-723TPVHD.js.map
-//# sourceMappingURL=chunk-723TPVHD.js.map