@holoscript/core 2.0.1 → 2.1.0

package/dist/chunk-U72GEJZT.js

@@ -0,0 +1,1279 @@
+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;
+    this.keywordSet = /* @__PURE__ */ new Set([
+      "orb",
+      "function",
+      "connect",
+      "to",
+      "as",
+      "gate",
+      "stream",
+      "from",
+      "through",
+      "return",
+      "if",
+      "else",
+      "nexus",
+      "building",
+      "pillar",
+      "foundation",
+      "for",
+      "while",
+      "forEach",
+      "in",
+      "of",
+      "break",
+      "continue",
+      "import",
+      "export",
+      "module",
+      "use",
+      "type",
+      "interface",
+      "extends",
+      "implements",
+      "async",
+      "await",
+      "spawn",
+      "parallel",
+      "class",
+      "new",
+      "this",
+      "super",
+      "static",
+      "private",
+      "public",
+      "try",
+      "catch",
+      "finally",
+      "throw",
+      "const",
+      "let",
+      "var",
+      "animate",
+      "modify",
+      "pulse",
+      "move",
+      "show",
+      "hide",
+      "scale",
+      "focus",
+      "environment",
+      "composition",
+      "template",
+      "settings",
+      "chat"
+    ]);
+  }
+  /**
+   * 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;
+    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 = this.keywordSet.has(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":
+        case "object":
+          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
+        // UI Extensions
+        case "ui2d":
+        case "card":
+        case "metric":
+        case "button":
+        case "row":
+        case "col":
+        case "text":
+          return this.parseUIElement();
+        case "const":
+        case "let":
+        case "var":
+          return this.parseVariableDeclaration();
+        // DSL-first commands (Phase 54)
+        case "animate":
+          return this.parseAnimate();
+        case "modify":
+          return this.parseModify();
+        case "scale":
+          return this.parseScale();
+        case "focus":
+          return this.parseFocus();
+        case "environment":
+          return this.parseEnvironment();
+        case "composition":
+          return this.parseComposition();
+        case "template":
+          return this.parseTemplate();
+        case "settings":
+          return this.parseSettings();
+        case "chat":
+          return this.parseChat();
+        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 orb declaration
+   */
+  parseOrb() {
+    const startToken = this.currentToken();
+    if (this.check("keyword", "orb") || this.check("keyword", "object")) {
+      this.advance();
+    } else {
+      this.expect("keyword", "orb");
+    }
+    let name = "";
+    if (this.check("punctuation", "#")) {
+      this.advance();
+      name = this.expectIdentifier() || `orb_${Date.now()}`;
+    } else {
+      name = this.expectIdentifier() || `orb_${Date.now()}`;
+    }
+    const properties = {};
+    const directives = [];
+    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 token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const directive = this.parseDirective();
+          if (directive) directives.push(directive);
+        } else {
+          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: 0.5, 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: 0.5, glow: true, interactive: true },
+      properties,
+      directives,
+      methods: [],
+      line: startToken?.line || 0
+    };
+  }
+  /**
+   * Parse HoloScript+ directive: @name(...) or @name { ... }
+   */
+  parseDirective() {
+    this.expect("punctuation", "@");
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    if (name === "state") {
+      const body = this.parseObject();
+      return { type: "state", body };
+    }
+    if (name.startsWith("on_")) {
+      let body = "";
+      if (this.check("punctuation", "{")) {
+        this.advance();
+        let braceDepth = 1;
+        while (braceDepth > 0 && this.position < this.tokens.length) {
+          const t = this.advance();
+          if (t.value === "{") braceDepth++;
+          if (t.value === "}") braceDepth--;
+          if (braceDepth > 0) body += t.value + " ";
+          else if (braceDepth < 0) break;
+        }
+      } else {
+        const t = this.advance();
+        if (t) body = t.value;
+      }
+      return { type: "lifecycle", hook: name, body };
+    }
+    let config = {};
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const prop = this.parseProperty();
+        if (prop) {
+          config[prop.key] = prop.value;
+        }
+        if (this.check("punctuation", ",")) {
+          this.advance();
+        }
+      }
+      this.expect("punctuation", ")");
+    } else if (this.check("punctuation", "{")) {
+      config = this.parseObject();
+    }
+    return { type: "trait", name, config };
+  }
+  /**
+   * 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 scale block: scale <magnitude> { body }
+   */
+  parseScale() {
+    this.expect("keyword", "scale");
+    const magnitude = this.expectIdentifier() || "standard";
+    const multipliers = {
+      "galactic": 1e6,
+      "macro": 1e3,
+      "standard": 1,
+      "micro": 1e-3,
+      "atomic": 1e-6
+    };
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) body.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "scale",
+      magnitude,
+      multiplier: multipliers[magnitude] || 1,
+      body,
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  /**
+   * Parse focus block: focus <target> { body }
+   */
+  parseFocus() {
+    this.expect("keyword", "focus");
+    const target = this.expectIdentifier() || "origin";
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) body.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "focus",
+      target,
+      body,
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  /**
+   * Parse environment declaration
+   */
+  parseEnvironment() {
+    this.expect("keyword", "environment");
+    const settings = {};
+    while (this.position < this.tokens.length && this.currentToken()?.type !== "newline" && !this.check("punctuation", "}")) {
+      const key = this.expectIdentifier();
+      if (!key) break;
+      settings[key] = this.parseLiteral();
+    }
+    return {
+      type: "environment",
+      settings
+    };
+  }
+  /**
+   * Parse composition block
+   */
+  parseComposition() {
+    this.expect("keyword", "composition");
+    const name = this.expectIdentifier() || "unnamed";
+    const children = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) children.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "composition",
+      name,
+      children
+    };
+  }
+  /**
+   * Parse template declaration
+   */
+  parseTemplate() {
+    this.expect("keyword", "template");
+    const name = this.expectIdentifier() || "template";
+    const params = [];
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const p = this.expectIdentifier();
+        if (p) params.push(p);
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      this.expect("punctuation", ")");
+    }
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) body.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "template",
+      name,
+      parameters: params,
+      body
+    };
+  }
+  /**
+   * 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 literal value (string, number, boolean, array, or object)
+   */
+  parseLiteral() {
+    const token = this.currentToken();
+    if (!token) return null;
+    if (token.type === "string") {
+      this.advance();
+      return token.value;
+    }
+    if (token.type === "number") {
+      this.advance();
+      return parseFloat(token.value);
+    }
+    if (token.type === "identifier") {
+      const val = token.value.toLowerCase();
+      this.advance();
+      if (val === "true") return true;
+      if (val === "false") return false;
+      if (val === "null") return null;
+      return token.value;
+    }
+    if (this.check("punctuation", "[")) {
+      return this.parseArray();
+    }
+    if (this.check("punctuation", "{")) {
+      return this.parseObject();
+    }
+    this.advance();
+    return token.value;
+  }
+  /**
+   * 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 value = this.parseLiteral();
+    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 (Array.isArray(value)) {
+      return {
+        x: Number(value[0]) || 0,
+        y: Number(value[1]) || 0,
+        z: Number(value[2]) || 0
+      };
+    }
+    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;
+  }
+  /**
+   * Parse animate command: animate target property: "..." from: 0 to: 1 duration: 1000
+   */
+  parseAnimate() {
+    this.expect("keyword", "animate");
+    const target = this.expectIdentifier();
+    if (!target) return null;
+    const properties = {};
+    while (this.position < this.tokens.length) {
+      this.skipNewlines();
+      const t = this.currentToken();
+      if (!t || t.type === "newline" || t.type === "keyword" && this.keywordSet.has(t.value.toLowerCase())) break;
+      const prop = this.parseProperty();
+      if (prop) {
+        properties[prop.key] = prop.value;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: "expression-statement",
+      expression: `animate("${target}", ${JSON.stringify(properties)})`,
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  /**
+   * Parse modify command: modify target { prop: value }
+   */
+  parseModify() {
+    this.expect("keyword", "modify");
+    const target = this.expectIdentifier();
+    if (!target) return null;
+    const properties = {};
+    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) {
+          properties[prop.key] = prop.value;
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "expression-statement",
+      expression: `modify("${target}", ${JSON.stringify(properties)})`,
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  /**
+   * Parse UI Element: ui2d dashboard#id { ... }
+   */
+  parseUIElement() {
+    const typeToken = this.currentToken();
+    if (!typeToken) return null;
+    const elementType = typeToken.value;
+    this.advance();
+    let elementId = `${elementType}_${Date.now()}`;
+    const token = this.currentToken();
+    if (token?.type === "punctuation" && token.value === "#") {
+      this.advance();
+      const idToken = this.currentToken();
+      if (idToken) {
+        elementId = idToken.value;
+        this.advance();
+      }
+    } else if (token?.type === "identifier" && token.value.startsWith("#")) {
+      elementId = token.value.slice(1) || elementId;
+      this.advance();
+    }
+    const properties = {};
+    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) {
+          properties[prop.key] = prop.value;
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "ui2d",
+      name: elementType,
+      properties: { id: elementId, ...properties },
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  /**
+   * Parse settings command: settings
+   */
+  parseSettings() {
+    this.expect("keyword", "settings");
+    return {
+      type: "expression-statement",
+      expression: "showSettings()",
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  parseChat() {
+    this.expect("keyword", "chat");
+    return {
+      type: "expression-statement",
+      expression: "openChat()",
+      position: { x: 0, y: 0, z: 0 }
+    };
+  }
+  skipNewlines() {
+    while (this.currentToken()?.type === "newline") {
+      this.advance();
+    }
+  }
+};
+
+export { HoloScriptCodeParser };
+//# sourceMappingURL=chunk-U72GEJZT.js.map
+//# sourceMappingURL=chunk-U72GEJZT.js.map