@holoscript/core 1.0.0-alpha.2 → 2.0.1

package/src/HoloScriptCodeParser.js

@@ -0,0 +1,1102 @@
+/**
+ * HoloScript Code Parser
+ *
+ * Parses HoloScript code strings into AST nodes that can be executed
+ * by the HoloScriptRuntime.
+ *
+ * Syntax Reference:
+ * - orb <name> { properties }
+ * - function <name>(<params>): <return> { body }
+ * - connect <from> to <to> [as <type>]
+ * - gate <name> { condition, true_path, false_path }
+ * - stream <name> from <source> { transformations }
+ */
+import { logger } from './logger';
+// Security configuration
+const CODE_SECURITY_CONFIG = {
+    maxCodeLength: 50000,
+    maxBlocks: 100,
+    maxNestingDepth: 10,
+    suspiciousKeywords: [
+        'process', 'require', 'eval', 'import', 'constructor',
+        'prototype', '__proto__', 'fs', 'child_process', 'exec', 'spawn',
+    ],
+};
+export class HoloScriptCodeParser {
+    constructor() {
+        this.errors = [];
+        this.warnings = [];
+        this.tokens = [];
+        this.position = 0;
+        // Pre-compute keyword set for O(1) lookup instead of O(n) array search
+        this.keywordSet = 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',
+        ]);
+    }
+    /**
+     * Parse HoloScript code string into AST
+     */
+    parse(code) {
+        this.errors = [];
+        this.warnings = [];
+        this.tokens = [];
+        this.position = 0;
+        // Security: Check code length
+        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: [],
+            };
+        }
+        // Security: Check for suspicious keywords
+        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 {
+            // Tokenize
+            this.tokens = this.tokenize(code);
+            // Parse tokens into AST
+            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];
+            // Skip whitespace (except newlines)
+            if (char === ' ' || char === '\t' || char === '\r') {
+                i++;
+                column++;
+                continue;
+            }
+            // Newline
+            if (char === '\n') {
+                tokens.push({ type: 'newline', value: '\n', line, column });
+                line++;
+                column = 1;
+                i++;
+                continue;
+            }
+            // Comments (skip)
+            if (char === '/' && code[i + 1] === '/') {
+                while (i < code.length && code[i] !== '\n') {
+                    i++;
+                }
+                continue;
+            }
+            // String
+            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++; // Skip closing quote
+                column++;
+                tokens.push({ type: 'string', value: str, line, column: startCol });
+                continue;
+            }
+            // Number
+            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;
+            }
+            // Identifier or keyword
+            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;
+            }
+            // Multi-character operators (must check before single-char)
+            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;
+            // Operators and punctuation
+            const punctuation = ['{', '}', '(', ')', '[', ']', ':', ',', '.', ';', '=', '<', '>', '+', '-', '*', '/', '%', '!', '&', '|', '?'];
+            if (punctuation.includes(char)) {
+                tokens.push({ type: 'punctuation', value: char, line, column });
+                i++;
+                column++;
+                continue;
+            }
+            // Unknown character - skip
+            i++;
+            column++;
+        }
+        return tokens;
+    }
+    /**
+     * Parse program (list of declarations)
+     */
+    parseProgram() {
+        const nodes = [];
+        let blockCount = 0;
+        while (this.position < this.tokens.length) {
+            // Skip newlines
+            while (this.currentToken()?.type === 'newline') {
+                this.advance();
+            }
+            if (this.position >= this.tokens.length)
+                break;
+            // Security: limit blocks
+            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
+                // 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();
+                default:
+                    this.advance();
+                    return null;
+            }
+        }
+        // Skip unrecognized tokens
+        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();
+        // Parse init, condition, update (simplified - collect as strings)
+        let init = '', condition = '', update = '';
+        let depth = 0;
+        // Parse init (until first ;)
+        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();
+        }
+        // Parse condition (until second ;)
+        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();
+        }
+        // Parse update (until ))
+        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();
+        }
+        // Parse body
+        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();
+            }
+        }
+        // Parse 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: '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();
+        // Parse 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: '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;
+        // Check for default import or named imports
+        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 {
+            // Default import
+            defaultImport = this.expectIdentifier() || undefined;
+        }
+        // from "module"
+        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');
+        // Check if exporting a declaration
+        const next = this.currentToken();
+        if (next?.type === 'keyword') {
+            const declaration = this.parseDeclaration();
+            return {
+                type: 'export',
+                declaration: declaration || undefined,
+                position: { x: 0, y: 0, z: 0 },
+            };
+        }
+        // Named exports
+        const exports = [];
+        if (this.check('punctuation', '{')) {
+            this.advance();
+            while (!this.check('punctuation', '}') && this.position < this.tokens.length) {
+                const name = this.expectIdentifier();
+                if (name)
+                    exports.push(name);
+                if (this.check('punctuation', ','))
+                    this.advance();
+            }
+            this.expect('punctuation', '}');
+        }
+        return {
+            type: 'export',
+            exports,
+            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() || undefined;
+        }
+        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() {
+        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) {
+                    // Handle special properties
+                    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;
+        // Parse parameters
+        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', ')');
+        }
+        // Parse return type
+        if (this.check('punctuation', ':')) {
+            this.advance();
+            returnType = this.expectIdentifier() || undefined;
+        }
+        // Parse body
+        const body = [];
+        if (this.check('punctuation', '{')) {
+            this.advance(); // {
+            // Skip body parsing for now - just find closing brace
+            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(); // Gate name (consumed but not currently stored)
+        let condition = '';
+        if (this.check('punctuation', '(')) {
+            this.advance();
+            // Parse condition expression
+            while (!this.check('punctuation', ')') && this.position < this.tokens.length) {
+                const token = this.currentToken();
+                if (token)
+                    condition += token.value + ' ';
+                this.advance();
+            }
+            this.expect('punctuation', ')');
+        }
+        // Parse body if present
+        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';
+        }
+        // Parse body if present
+        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 }; // Flag-style property
+        }
+        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 !== undefined && 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 = {};
+        // Parse inline 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()}`;
+        // Check for ID syntax
+        if (this.currentToken()?.type === 'punctuation' && this.currentToken()?.value === '#') {
+            this.advance();
+            const idToken = this.currentToken();
+            if (idToken) {
+                elementId = idToken.value;
+                this.advance();
+            }
+        }
+        else if (this.currentToken()?.type === 'identifier' && this.currentToken()?.value.startsWith('#')) {
+            elementId = this.currentToken()?.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 }
+        };
+    }
+    skipNewlines() {
+        while (this.currentToken()?.type === 'newline') {
+            this.advance();
+        }
+    }
+}