@holoscript/core 2.0.1 → 2.0.2

package/src/HoloScriptCodeParser.js

@@ -1,1102 +0,0 @@
-/**
- * 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();
-        }
-    }
-}