redscript-mc 1.2.29 → 2.0.0

package/dist/src/parser/index.js

@@ -0,0 +1,1687 @@
+"use strict";
+/**
+ * RedScript Parser
+ *
+ * Recursive descent parser that converts tokens into an AST.
+ * Uses precedence climbing for expression parsing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const lexer_1 = require("../lexer");
+const diagnostics_1 = require("../diagnostics");
+// ---------------------------------------------------------------------------
+// Operator Precedence (higher = binds tighter)
+// ---------------------------------------------------------------------------
+const PRECEDENCE = {
+    '||': 1,
+    '&&': 2,
+    '==': 3, '!=': 3,
+    '<': 4, '<=': 4, '>': 4, '>=': 4, 'is': 4,
+    '+': 5, '-': 5,
+    '*': 6, '/': 6, '%': 6,
+};
+const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', 'is', '+', '-', '*', '/', '%']);
+const ENTITY_TYPE_NAMES = new Set([
+    'entity',
+    'Player',
+    'Mob',
+    'HostileMob',
+    'PassiveMob',
+    'Zombie',
+    'Skeleton',
+    'Creeper',
+    'Spider',
+    'Enderman',
+    'Blaze',
+    'Witch',
+    'Slime',
+    'ZombieVillager',
+    'Husk',
+    'Drowned',
+    'Stray',
+    'WitherSkeleton',
+    'CaveSpider',
+    'Pig',
+    'Cow',
+    'Sheep',
+    'Chicken',
+    'Villager',
+    'WanderingTrader',
+    'ArmorStand',
+    'Item',
+    'Arrow',
+]);
+function computeIsSingle(raw) {
+    if (/^@[spr](\[|$)/.test(raw))
+        return true;
+    if (/[\[,\s]limit=1[,\]\s]/.test(raw))
+        return true;
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Parser Class
+// ---------------------------------------------------------------------------
+class Parser {
+    constructor(tokens, source, filePath) {
+        this.pos = 0;
+        /** Set to true once `module library;` is seen — all subsequent fn declarations
+         *  will be marked isLibraryFn=true.  When library sources are parsed via the
+         *  `librarySources` compile option, each source is parsed by its own fresh
+         *  Parser instance, so this flag never bleeds into user code. */
+        this.inLibraryMode = false;
+        this.tokens = tokens;
+        this.sourceLines = source?.split('\n') ?? [];
+        this.filePath = filePath;
+    }
+    // -------------------------------------------------------------------------
+    // Utilities
+    // -------------------------------------------------------------------------
+    peek(offset = 0) {
+        const idx = this.pos + offset;
+        if (idx >= this.tokens.length) {
+            return this.tokens[this.tokens.length - 1]; // eof
+        }
+        return this.tokens[idx];
+    }
+    advance() {
+        const token = this.tokens[this.pos];
+        if (token.kind !== 'eof')
+            this.pos++;
+        return token;
+    }
+    check(kind) {
+        return this.peek().kind === kind;
+    }
+    match(...kinds) {
+        for (const kind of kinds) {
+            if (this.check(kind)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    expect(kind) {
+        const token = this.peek();
+        if (token.kind !== kind) {
+            throw new diagnostics_1.DiagnosticError('ParseError', `Expected '${kind}' but got '${token.kind}'`, { file: this.filePath, line: token.line, col: token.col }, this.sourceLines);
+        }
+        return this.advance();
+    }
+    error(message) {
+        const token = this.peek();
+        throw new diagnostics_1.DiagnosticError('ParseError', message, { file: this.filePath, line: token.line, col: token.col }, this.sourceLines);
+    }
+    withLoc(node, token) {
+        const span = { line: token.line, col: token.col };
+        Object.defineProperty(node, 'span', {
+            value: span,
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+        return node;
+    }
+    getLocToken(node) {
+        const span = node.span;
+        if (!span) {
+            return null;
+        }
+        return { kind: 'eof', value: '', line: span.line, col: span.col };
+    }
+    // -------------------------------------------------------------------------
+    // Program
+    // -------------------------------------------------------------------------
+    parse(defaultNamespace = 'redscript') {
+        let namespace = defaultNamespace;
+        const globals = [];
+        const declarations = [];
+        const structs = [];
+        const implBlocks = [];
+        const enums = [];
+        const consts = [];
+        let isLibrary = false;
+        // Check for namespace declaration
+        if (this.check('namespace')) {
+            this.advance();
+            const name = this.expect('ident');
+            namespace = name.value;
+            this.expect(';');
+        }
+        // Check for module declaration: `module library;`
+        // Library-mode: all functions parsed from this point are marked isLibraryFn=true.
+        // When using the `librarySources` compile option, each library source is parsed
+        // by its own fresh Parser — so this flag never bleeds into user code.
+        if (this.check('module')) {
+            this.advance();
+            const modKind = this.expect('ident');
+            if (modKind.value === 'library') {
+                isLibrary = true;
+                this.inLibraryMode = true;
+            }
+            this.expect(';');
+        }
+        // Parse struct and function declarations
+        while (!this.check('eof')) {
+            if (this.check('let')) {
+                globals.push(this.parseGlobalDecl(true));
+            }
+            else if (this.check('struct')) {
+                structs.push(this.parseStructDecl());
+            }
+            else if (this.check('impl')) {
+                implBlocks.push(this.parseImplBlock());
+            }
+            else if (this.check('enum')) {
+                enums.push(this.parseEnumDecl());
+            }
+            else if (this.check('const')) {
+                consts.push(this.parseConstDecl());
+            }
+            else if (this.check('declare')) {
+                // Declaration-only stub (e.g. from builtins.d.mcrs) — parse and discard
+                this.advance(); // consume 'declare'
+                this.parseDeclareStub();
+            }
+            else {
+                declarations.push(this.parseFnDecl());
+            }
+        }
+        return { namespace, globals, declarations, structs, implBlocks, enums, consts, isLibrary };
+    }
+    // -------------------------------------------------------------------------
+    // Struct Declaration
+    // -------------------------------------------------------------------------
+    parseStructDecl() {
+        const structToken = this.expect('struct');
+        const name = this.expect('ident').value;
+        this.expect('{');
+        const fields = [];
+        while (!this.check('}') && !this.check('eof')) {
+            const fieldName = this.expect('ident').value;
+            this.expect(':');
+            const fieldType = this.parseType();
+            fields.push({ name: fieldName, type: fieldType });
+            // Allow optional comma or semicolon between fields
+            this.match(',');
+        }
+        this.expect('}');
+        return this.withLoc({ name, fields }, structToken);
+    }
+    parseEnumDecl() {
+        const enumToken = this.expect('enum');
+        const name = this.expect('ident').value;
+        this.expect('{');
+        const variants = [];
+        let nextValue = 0;
+        while (!this.check('}') && !this.check('eof')) {
+            const variantToken = this.expect('ident');
+            const variant = { name: variantToken.value };
+            if (this.match('=')) {
+                const valueToken = this.expect('int_lit');
+                variant.value = parseInt(valueToken.value, 10);
+                nextValue = variant.value + 1;
+            }
+            else {
+                variant.value = nextValue++;
+            }
+            variants.push(variant);
+            if (!this.match(',')) {
+                break;
+            }
+        }
+        this.expect('}');
+        return this.withLoc({ name, variants }, enumToken);
+    }
+    parseImplBlock() {
+        const implToken = this.expect('impl');
+        const typeName = this.expect('ident').value;
+        this.expect('{');
+        const methods = [];
+        while (!this.check('}') && !this.check('eof')) {
+            methods.push(this.parseFnDecl(typeName));
+        }
+        this.expect('}');
+        return this.withLoc({ kind: 'impl_block', typeName, methods }, implToken);
+    }
+    parseConstDecl() {
+        const constToken = this.expect('const');
+        const name = this.expect('ident').value;
+        let type;
+        if (this.match(':')) {
+            type = this.parseType();
+        }
+        this.expect('=');
+        const value = this.parseLiteralExpr();
+        this.match(';');
+        // Infer type from value if not provided
+        const inferredType = type ?? (value.kind === 'str_lit' ? { kind: 'named', name: 'string' } :
+            value.kind === 'bool_lit' ? { kind: 'named', name: 'bool' } :
+                value.kind === 'float_lit' ? { kind: 'named', name: 'float' } :
+                    { kind: 'named', name: 'int' });
+        return this.withLoc({ name, type: inferredType, value }, constToken);
+    }
+    parseGlobalDecl(mutable) {
+        const token = this.advance(); // consume 'let'
+        const name = this.expect('ident').value;
+        this.expect(':');
+        const type = this.parseType();
+        this.expect('=');
+        const init = this.parseExpr();
+        this.expect(';');
+        return this.withLoc({ kind: 'global', name, type, init, mutable }, token);
+    }
+    // -------------------------------------------------------------------------
+    // Function Declaration
+    // -------------------------------------------------------------------------
+    parseFnDecl(implTypeName) {
+        const decorators = this.parseDecorators();
+        const fnToken = this.expect('fn');
+        const name = this.expect('ident').value;
+        this.expect('(');
+        const params = this.parseParams(implTypeName);
+        this.expect(')');
+        let returnType = { kind: 'named', name: 'void' };
+        if (this.match('->') || this.match(':')) {
+            returnType = this.parseType();
+        }
+        const body = this.parseBlock();
+        const fn = this.withLoc({ name, params, returnType, decorators, body, isLibraryFn: this.inLibraryMode || undefined }, fnToken);
+        return fn;
+    }
+    /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
+    parseDeclareStub() {
+        this.expect('fn');
+        this.expect('ident'); // name
+        this.expect('(');
+        // consume params until ')'
+        let depth = 1;
+        while (!this.check('eof') && depth > 0) {
+            const t = this.advance();
+            if (t.kind === '(')
+                depth++;
+            else if (t.kind === ')')
+                depth--;
+        }
+        // optional return type annotation `: type` or `-> type`
+        if (this.match(':') || this.match('->')) {
+            this.parseType();
+        }
+        this.match(';'); // consume trailing semicolon
+    }
+    parseDecorators() {
+        const decorators = [];
+        while (this.check('decorator')) {
+            const token = this.advance();
+            const decorator = this.parseDecoratorValue(token.value);
+            decorators.push(decorator);
+        }
+        return decorators;
+    }
+    parseDecoratorValue(value) {
+        // Parse @tick, @on(PlayerDeath), or @on_trigger("name")
+        const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/);
+        if (!match) {
+            this.error(`Invalid decorator: ${value}`);
+        }
+        const name = match[1];
+        const argsStr = match[2];
+        if (!argsStr) {
+            return { name };
+        }
+        const args = {};
+        if (name === 'on') {
+            const eventTypeMatch = argsStr.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
+            if (eventTypeMatch) {
+                args.eventType = eventTypeMatch[1];
+                return { name, args };
+            }
+        }
+        // Handle @on_trigger("name"), @on_advancement("id"), @on_craft("item"), @on_join_team("team")
+        if (name === 'on_trigger' || name === 'on_advancement' || name === 'on_craft' || name === 'on_join_team') {
+            const strMatch = argsStr.match(/^"([^"]*)"$/);
+            if (strMatch) {
+                if (name === 'on_trigger') {
+                    args.trigger = strMatch[1];
+                }
+                else if (name === 'on_advancement') {
+                    args.advancement = strMatch[1];
+                }
+                else if (name === 'on_craft') {
+                    args.item = strMatch[1];
+                }
+                else if (name === 'on_join_team') {
+                    args.team = strMatch[1];
+                }
+                return { name, args };
+            }
+        }
+        // @require_on_load(fn_name) — when this fn is used, fn_name is called from __load.
+        // Accepts bare identifiers (with optional leading _) or quoted strings.
+        if (name === 'require_on_load') {
+            const rawArgs = [];
+            for (const part of argsStr.split(',')) {
+                const trimmed = part.trim();
+                // Bare identifier: @require_on_load(_math_init)
+                const identMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
+                if (identMatch) {
+                    rawArgs.push({ kind: 'string', value: identMatch[1] });
+                }
+                else {
+                    // Quoted string fallback: @require_on_load("_math_init")
+                    const strMatch = trimmed.match(/^"([^"]*)"$/);
+                    if (strMatch) {
+                        rawArgs.push({ kind: 'string', value: strMatch[1] });
+                    }
+                }
+            }
+            return { name, rawArgs };
+        }
+        // Handle key=value format (e.g., rate=20)
+        for (const part of argsStr.split(',')) {
+            const [key, val] = part.split('=').map(s => s.trim());
+            if (key === 'rate') {
+                args.rate = parseInt(val, 10);
+            }
+            else if (key === 'trigger') {
+                args.trigger = val;
+            }
+            else if (key === 'advancement') {
+                args.advancement = val;
+            }
+            else if (key === 'item') {
+                args.item = val;
+            }
+            else if (key === 'team') {
+                args.team = val;
+            }
+        }
+        return { name, args };
+    }
+    parseParams(implTypeName) {
+        const params = [];
+        if (!this.check(')')) {
+            do {
+                const paramToken = this.expect('ident');
+                const name = paramToken.value;
+                let type;
+                if (implTypeName && params.length === 0 && name === 'self' && !this.check(':')) {
+                    type = { kind: 'struct', name: implTypeName };
+                }
+                else {
+                    this.expect(':');
+                    type = this.parseType();
+                }
+                let defaultValue;
+                if (this.match('=')) {
+                    defaultValue = this.parseExpr();
+                }
+                params.push(this.withLoc({ name, type, default: defaultValue }, paramToken));
+            } while (this.match(','));
+        }
+        return params;
+    }
+    parseType() {
+        const token = this.peek();
+        let type;
+        if (token.kind === '(') {
+            return this.parseFunctionType();
+        }
+        if (token.kind === 'int' || token.kind === 'bool' ||
+            token.kind === 'float' || token.kind === 'string' || token.kind === 'void' ||
+            token.kind === 'BlockPos') {
+            this.advance();
+            type = { kind: 'named', name: token.kind };
+        }
+        else if (token.kind === 'ident') {
+            this.advance();
+            if (token.value === 'selector' && this.check('<')) {
+                this.advance(); // consume <
+                const entityType = this.expect('ident').value;
+                this.expect('>');
+                type = { kind: 'selector', entityType };
+            }
+            else if (token.value === 'selector') {
+                type = { kind: 'selector' };
+            }
+            else {
+                type = { kind: 'struct', name: token.value };
+            }
+        }
+        else {
+            this.error(`Expected type, got '${token.kind}'`);
+        }
+        while (this.match('[')) {
+            this.expect(']');
+            type = { kind: 'array', elem: type };
+        }
+        return type;
+    }
+    parseFunctionType() {
+        this.expect('(');
+        const params = [];
+        if (!this.check(')')) {
+            do {
+                params.push(this.parseType());
+            } while (this.match(','));
+        }
+        this.expect(')');
+        this.expect('->');
+        const returnType = this.parseType();
+        return { kind: 'function_type', params, return: returnType };
+    }
+    // -------------------------------------------------------------------------
+    // Block & Statements
+    // -------------------------------------------------------------------------
+    parseBlock() {
+        this.expect('{');
+        const stmts = [];
+        while (!this.check('}') && !this.check('eof')) {
+            stmts.push(this.parseStmt());
+        }
+        this.expect('}');
+        return stmts;
+    }
+    parseStmt() {
+        // Let statement
+        if (this.check('let')) {
+            return this.parseLetStmt();
+        }
+        // Return statement
+        if (this.check('return')) {
+            return this.parseReturnStmt();
+        }
+        // Break statement
+        if (this.check('break')) {
+            const token = this.advance();
+            this.match(';');
+            return this.withLoc({ kind: 'break' }, token);
+        }
+        // Continue statement
+        if (this.check('continue')) {
+            const token = this.advance();
+            this.match(';');
+            return this.withLoc({ kind: 'continue' }, token);
+        }
+        // If statement
+        if (this.check('if')) {
+            return this.parseIfStmt();
+        }
+        // While statement
+        if (this.check('while')) {
+            return this.parseWhileStmt();
+        }
+        // For statement
+        if (this.check('for')) {
+            return this.parseForStmt();
+        }
+        // Foreach statement
+        if (this.check('foreach')) {
+            return this.parseForeachStmt();
+        }
+        if (this.check('match')) {
+            return this.parseMatchStmt();
+        }
+        // As block
+        if (this.check('as')) {
+            return this.parseAsStmt();
+        }
+        // At block
+        if (this.check('at')) {
+            return this.parseAtStmt();
+        }
+        // Execute statement: execute as/at/if/unless/in ... run { }
+        if (this.check('execute')) {
+            return this.parseExecuteStmt();
+        }
+        // Raw command
+        if (this.check('raw_cmd')) {
+            const token = this.advance();
+            const cmd = token.value;
+            this.match(';'); // optional semicolon (raw consumes it)
+            return this.withLoc({ kind: 'raw', cmd }, token);
+        }
+        // Expression statement
+        return this.parseExprStmt();
+    }
+    parseLetStmt() {
+        const letToken = this.expect('let');
+        const name = this.expect('ident').value;
+        let type;
+        if (this.match(':')) {
+            type = this.parseType();
+        }
+        this.expect('=');
+        const init = this.parseExpr();
+        this.expect(';');
+        return this.withLoc({ kind: 'let', name, type, init }, letToken);
+    }
+    parseReturnStmt() {
+        const returnToken = this.expect('return');
+        let value;
+        if (!this.check(';')) {
+            value = this.parseExpr();
+        }
+        this.expect(';');
+        return this.withLoc({ kind: 'return', value }, returnToken);
+    }
+    parseIfStmt() {
+        const ifToken = this.expect('if');
+        this.expect('(');
+        const cond = this.parseExpr();
+        this.expect(')');
+        const then = this.parseBlock();
+        let else_;
+        if (this.match('else')) {
+            if (this.check('if')) {
+                // else if
+                else_ = [this.parseIfStmt()];
+            }
+            else {
+                else_ = this.parseBlock();
+            }
+        }
+        return this.withLoc({ kind: 'if', cond, then, else_ }, ifToken);
+    }
+    parseWhileStmt() {
+        const whileToken = this.expect('while');
+        this.expect('(');
+        const cond = this.parseExpr();
+        this.expect(')');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'while', cond, body }, whileToken);
+    }
+    parseForStmt() {
+        const forToken = this.expect('for');
+        // Check for for-range syntax: for <ident> in <range_lit> { ... }
+        if (this.check('ident') && this.peek(1).kind === 'in') {
+            return this.parseForRangeStmt(forToken);
+        }
+        this.expect('(');
+        // Init: either let statement (without semicolon) or empty
+        let init;
+        if (this.check('let')) {
+            // Parse let without consuming semicolon here (we handle it)
+            const letToken = this.expect('let');
+            const name = this.expect('ident').value;
+            let type;
+            if (this.match(':')) {
+                type = this.parseType();
+            }
+            this.expect('=');
+            const initExpr = this.parseExpr();
+            const initStmt = { kind: 'let', name, type, init: initExpr };
+            init = this.withLoc(initStmt, letToken);
+        }
+        this.expect(';');
+        // Condition
+        const cond = this.parseExpr();
+        this.expect(';');
+        // Step expression
+        const step = this.parseExpr();
+        this.expect(')');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'for', init, cond, step, body }, forToken);
+    }
+    parseForRangeStmt(forToken) {
+        const varName = this.expect('ident').value;
+        this.expect('in');
+        let start;
+        let end;
+        if (this.check('range_lit')) {
+            // Literal range: 0..10, 0..count, 0..=9
+            const rangeToken = this.advance();
+            const range = this.parseRangeValue(rangeToken.value);
+            start = this.withLoc({ kind: 'int_lit', value: range.min ?? 0 }, rangeToken);
+            if (range.max !== null && range.max !== undefined) {
+                // Fully numeric: 0..10
+                end = this.withLoc({ kind: 'int_lit', value: range.max }, rangeToken);
+            }
+            else {
+                // Open-ended: "0.." — parse the end expression from next tokens
+                end = this.parseUnaryExpr();
+            }
+        }
+        else {
+            // Dynamic range: expr..expr (e.g. start..end) — not yet supported
+            // Fall back to: parse as int_lit 0..0 (safe default)
+            start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek());
+            end = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek());
+            this.error('Dynamic range start requires a literal integer (e.g. 0..count)');
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'for_range', varName, start, end, body }, forToken);
+    }
+    parseForeachStmt() {
+        const foreachToken = this.expect('foreach');
+        this.expect('(');
+        const binding = this.expect('ident').value;
+        this.expect('in');
+        const iterable = this.parseExpr();
+        this.expect(')');
+        // Parse optional execute context modifiers (as, at, positioned, rotated, facing, etc.)
+        let executeContext;
+        // Check for execute subcommand keywords
+        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align', 'on', 'summon'];
+        if (this.check('as') || this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
+            // Collect everything until we hit '{'
+            let context = '';
+            while (!this.check('{') && !this.check('eof')) {
+                context += this.advance().value + ' ';
+            }
+            executeContext = context.trim();
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'foreach', binding, iterable, body, executeContext }, foreachToken);
+    }
+    parseMatchStmt() {
+        const matchToken = this.expect('match');
+        this.expect('(');
+        const expr = this.parseExpr();
+        this.expect(')');
+        this.expect('{');
+        const arms = [];
+        while (!this.check('}') && !this.check('eof')) {
+            let pattern;
+            if (this.check('ident') && this.peek().value === '_') {
+                this.advance();
+                pattern = null;
+            }
+            else {
+                pattern = this.parseExpr();
+            }
+            this.expect('=>');
+            const body = this.parseBlock();
+            arms.push({ pattern, body });
+        }
+        this.expect('}');
+        return this.withLoc({ kind: 'match', expr, arms }, matchToken);
+    }
+    parseAsStmt() {
+        const asToken = this.expect('as');
+        const as_sel = this.parseSelector();
+        // Check for combined as/at
+        if (this.match('at')) {
+            const at_sel = this.parseSelector();
+            const body = this.parseBlock();
+            return this.withLoc({ kind: 'as_at', as_sel, at_sel, body }, asToken);
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'as_block', selector: as_sel, body }, asToken);
+    }
+    parseAtStmt() {
+        const atToken = this.expect('at');
+        const selector = this.parseSelector();
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'at_block', selector, body }, atToken);
+    }
+    parseExecuteStmt() {
+        const executeToken = this.expect('execute');
+        const subcommands = [];
+        // Parse subcommands until we hit 'run'
+        while (!this.check('run') && !this.check('eof')) {
+            if (this.match('as')) {
+                const selector = this.parseSelector();
+                subcommands.push({ kind: 'as', selector });
+            }
+            else if (this.match('at')) {
+                const selector = this.parseSelector();
+                subcommands.push({ kind: 'at', selector });
+            }
+            else if (this.checkIdent('positioned')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'positioned_as', selector });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'positioned', x, y, z });
+                }
+            }
+            else if (this.checkIdent('rotated')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'rotated_as', selector });
+                }
+                else {
+                    const yaw = this.parseCoordToken();
+                    const pitch = this.parseCoordToken();
+                    subcommands.push({ kind: 'rotated', yaw, pitch });
+                }
+            }
+            else if (this.checkIdent('facing')) {
+                this.advance();
+                if (this.checkIdent('entity')) {
+                    this.advance();
+                    const selector = this.parseSelector();
+                    const anchor = this.checkIdent('eyes') || this.checkIdent('feet') ? this.advance().value : 'feet';
+                    subcommands.push({ kind: 'facing_entity', selector, anchor });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'facing', x, y, z });
+                }
+            }
+            else if (this.checkIdent('anchored')) {
+                this.advance();
+                const anchor = this.advance().value;
+                subcommands.push({ kind: 'anchored', anchor });
+            }
+            else if (this.checkIdent('align')) {
+                this.advance();
+                const axes = this.advance().value;
+                subcommands.push({ kind: 'align', axes });
+            }
+            else if (this.checkIdent('on')) {
+                this.advance();
+                const relation = this.advance().value;
+                subcommands.push({ kind: 'on', relation });
+            }
+            else if (this.checkIdent('summon')) {
+                this.advance();
+                const entity = this.advance().value;
+                subcommands.push({ kind: 'summon', entity });
+            }
+            else if (this.checkIdent('store')) {
+                this.advance();
+                const storeType = this.advance().value; // 'result' or 'success'
+                if (this.checkIdent('score')) {
+                    this.advance();
+                    const target = this.advance().value;
+                    const targetObj = this.advance().value;
+                    if (storeType === 'result') {
+                        subcommands.push({ kind: 'store_result', target, targetObj });
+                    }
+                    else {
+                        subcommands.push({ kind: 'store_success', target, targetObj });
+                    }
+                }
+                else {
+                    this.error('store currently only supports score target');
+                }
+            }
+            else if (this.match('if')) {
+                this.parseExecuteCondition(subcommands, 'if');
+            }
+            else if (this.match('unless')) {
+                this.parseExecuteCondition(subcommands, 'unless');
+            }
+            else if (this.match('in')) {
+                // Dimension can be namespaced: minecraft:the_nether
+                let dim = this.advance().value;
+                if (this.match(':')) {
+                    dim += ':' + this.advance().value;
+                }
+                subcommands.push({ kind: 'in', dimension: dim });
+            }
+            else {
+                this.error(`Unexpected token in execute statement: ${this.peek().kind} (${this.peek().value})`);
+            }
+        }
+        this.expect('run');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'execute', subcommands, body }, executeToken);
+    }
+    parseExecuteCondition(subcommands, type) {
+        if (this.checkIdent('entity') || this.check('selector')) {
+            if (this.checkIdent('entity'))
+                this.advance();
+            const selectorOrVar = this.parseSelectorOrVarSelector();
+            subcommands.push({ kind: type === 'if' ? 'if_entity' : 'unless_entity', ...selectorOrVar });
+        }
+        else if (this.checkIdent('block')) {
+            this.advance();
+            const x = this.parseCoordToken();
+            const y = this.parseCoordToken();
+            const z = this.parseCoordToken();
+            const block = this.parseBlockId();
+            subcommands.push({ kind: type === 'if' ? 'if_block' : 'unless_block', pos: [x, y, z], block });
+        }
+        else if (this.checkIdent('score')) {
+            this.advance();
+            const target = this.advance().value;
+            const targetObj = this.advance().value;
+            // Check for range or comparison
+            if (this.checkIdent('matches')) {
+                this.advance();
+                const range = this.advance().value;
+                subcommands.push({ kind: type === 'if' ? 'if_score_range' : 'unless_score_range', target, targetObj, range });
+            }
+            else {
+                const op = this.advance().value; // <, <=, =, >=, >
+                const source = this.advance().value;
+                const sourceObj = this.advance().value;
+                subcommands.push({
+                    kind: type === 'if' ? 'if_score' : 'unless_score',
+                    target, targetObj, op, source, sourceObj
+                });
+            }
+        }
+        else {
+            this.error(`Unknown condition type after ${type}`);
+        }
+    }
+    parseCoordToken() {
+        // Handle ~, ^, numbers, relative coords like ~5, ^-3
+        const token = this.peek();
+        if (token.kind === 'rel_coord' || token.kind === 'local_coord' ||
+            token.kind === 'int_lit' || token.kind === 'float_lit' ||
+            token.kind === '-' || token.kind === 'ident') {
+            return this.advance().value;
+        }
+        this.error(`Expected coordinate, got ${token.kind}`);
+        return '~';
+    }
+    parseBlockId() {
+        // Parse block ID like minecraft:stone or stone
+        let id = this.advance().value;
+        if (this.match(':')) {
+            id += ':' + this.advance().value;
+        }
+        // Handle block states [facing=north]
+        if (this.check('[')) {
+            id += this.advance().value; // [
+            while (!this.check(']') && !this.check('eof')) {
+                id += this.advance().value;
+            }
+            id += this.advance().value; // ]
+        }
+        return id;
+    }
+    checkIdent(value) {
+        return this.check('ident') && this.peek().value === value;
+    }
+    parseExprStmt() {
+        const expr = this.parseExpr();
+        this.expect(';');
+        const exprToken = this.getLocToken(expr) ?? this.peek();
+        return this.withLoc({ kind: 'expr', expr }, exprToken);
+    }
+    // -------------------------------------------------------------------------
+    // Expressions (Precedence Climbing)
+    // -------------------------------------------------------------------------
+    parseExpr() {
+        return this.parseAssignment();
+    }
+    parseAssignment() {
+        const left = this.parseBinaryExpr(1);
+        // Check for assignment
+        const token = this.peek();
+        if (token.kind === '=' || token.kind === '+=' || token.kind === '-=' ||
+            token.kind === '*=' || token.kind === '/=' || token.kind === '%=') {
+            const op = this.advance().kind;
+            if (left.kind === 'ident') {
+                const value = this.parseAssignment();
+                return this.withLoc({ kind: 'assign', target: left.name, op, value }, this.getLocToken(left) ?? token);
+            }
+            // Member assignment: p.x = 10, p.x += 5
+            if (left.kind === 'member') {
+                const value = this.parseAssignment();
+                return this.withLoc({ kind: 'member_assign', obj: left.obj, field: left.field, op, value }, this.getLocToken(left) ?? token);
+            }
+        }
+        return left;
+    }
+    parseBinaryExpr(minPrec) {
+        let left = this.parseUnaryExpr();
+        while (true) {
+            const op = this.peek().kind;
+            if (!BINARY_OPS.has(op))
+                break;
+            const prec = PRECEDENCE[op];
+            if (prec < minPrec)
+                break;
+            const opToken = this.advance();
+            if (op === 'is') {
+                const entityType = this.parseEntityTypeName();
+                left = this.withLoc({ kind: 'is_check', expr: left, entityType }, this.getLocToken(left) ?? opToken);
+                continue;
+            }
+            const right = this.parseBinaryExpr(prec + 1); // left associative
+            left = this.withLoc({ kind: 'binary', op: op, left, right }, this.getLocToken(left) ?? opToken);
+        }
+        return left;
+    }
+    parseUnaryExpr() {
+        if (this.match('!')) {
+            const bangToken = this.tokens[this.pos - 1];
+            const operand = this.parseUnaryExpr();
+            return this.withLoc({ kind: 'unary', op: '!', operand }, bangToken);
+        }
+        if (this.check('-') && !this.isSubtraction()) {
+            const minusToken = this.advance();
+            const operand = this.parseUnaryExpr();
+            return this.withLoc({ kind: 'unary', op: '-', operand }, minusToken);
+        }
+        return this.parsePostfixExpr();
+    }
+    parseEntityTypeName() {
+        const token = this.expect('ident');
+        if (ENTITY_TYPE_NAMES.has(token.value)) {
+            return token.value;
+        }
+        this.error(`Unknown entity type '${token.value}'`);
+    }
+    isSubtraction() {
+        // Check if this minus is binary (subtraction) by looking at previous token
+        // If previous was a value (literal, ident, ), ]) it's subtraction
+        if (this.pos === 0)
+            return false;
+        const prev = this.tokens[this.pos - 1];
+        return ['int_lit', 'float_lit', 'ident', ')', ']'].includes(prev.kind);
+    }
+    parsePostfixExpr() {
+        let expr = this.parsePrimaryExpr();
+        while (true) {
+            // Function call
+            if (this.match('(')) {
+                const openParenToken = this.tokens[this.pos - 1];
+                if (expr.kind === 'ident') {
+                    const args = this.parseArgs();
+                    this.expect(')');
+                    expr = this.withLoc({ kind: 'call', fn: expr.name, args }, this.getLocToken(expr) ?? openParenToken);
+                    continue;
+                }
+                // Member call: entity.tag("name") → __entity_tag(entity, "name")
+                // Also handle arr.push(val) and arr.length
+                if (expr.kind === 'member') {
+                    const methodMap = {
+                        'tag': '__entity_tag',
+                        'untag': '__entity_untag',
+                        'has_tag': '__entity_has_tag',
+                        'push': '__array_push',
+                        'pop': '__array_pop',
+                        'add': 'set_add',
+                        'contains': 'set_contains',
+                        'remove': 'set_remove',
+                        'clear': 'set_clear',
+                    };
+                    const internalFn = methodMap[expr.field];
+                    if (internalFn) {
+                        const args = this.parseArgs();
+                        this.expect(')');
+                        expr = this.withLoc({ kind: 'call', fn: internalFn, args: [expr.obj, ...args] }, this.getLocToken(expr) ?? openParenToken);
+                        continue;
+                    }
+                    // Generic method sugar: obj.method(args) → method(obj, args)
+                    const args = this.parseArgs();
+                    this.expect(')');
+                    expr = this.withLoc({ kind: 'call', fn: expr.field, args: [expr.obj, ...args] }, this.getLocToken(expr) ?? openParenToken);
+                    continue;
+                }
+                const args = this.parseArgs();
+                this.expect(')');
+                expr = this.withLoc({ kind: 'invoke', callee: expr, args }, this.getLocToken(expr) ?? openParenToken);
+                continue;
+            }
+            // Array index access: arr[0]
+            if (this.match('[')) {
+                const index = this.parseExpr();
+                this.expect(']');
+                expr = this.withLoc({ kind: 'index', obj: expr, index }, this.getLocToken(expr) ?? this.tokens[this.pos - 1]);
+                continue;
+            }
+            // Member access
+            if (this.match('.')) {
+                const field = this.expect('ident').value;
+                expr = this.withLoc({ kind: 'member', obj: expr, field }, this.getLocToken(expr) ?? this.tokens[this.pos - 1]);
+                continue;
+            }
+            break;
+        }
+        return expr;
+    }
+    parseArgs() {
+        const args = [];
+        if (!this.check(')')) {
+            do {
+                args.push(this.parseExpr());
+            } while (this.match(','));
+        }
+        return args;
+    }
+    parsePrimaryExpr() {
+        const token = this.peek();
+        if (token.kind === 'ident' && this.peek(1).kind === '::') {
+            const typeToken = this.advance();
+            this.expect('::');
+            const methodToken = this.expect('ident');
+            this.expect('(');
+            const args = this.parseArgs();
+            this.expect(')');
+            return this.withLoc({ kind: 'static_call', type: typeToken.value, method: methodToken.value, args }, typeToken);
+        }
+        if (token.kind === 'ident' && this.peek(1).kind === '=>') {
+            return this.parseSingleParamLambda();
+        }
+        // Integer literal
+        if (token.kind === 'int_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'int_lit', value: parseInt(token.value, 10) }, token);
+        }
+        // Float literal
+        if (token.kind === 'float_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'float_lit', value: parseFloat(token.value) }, token);
+        }
+        // Relative coordinate: ~  ~5  ~-3  ~0.5
+        if (token.kind === 'rel_coord') {
+            this.advance();
+            return this.withLoc({ kind: 'rel_coord', value: token.value }, token);
+        }
+        // Local coordinate: ^  ^5  ^-3  ^0.5
+        if (token.kind === 'local_coord') {
+            this.advance();
+            return this.withLoc({ kind: 'local_coord', value: token.value }, token);
+        }
+        // NBT suffix literals
+        if (token.kind === 'byte_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'byte_lit', value: parseInt(token.value.slice(0, -1), 10) }, token);
+        }
+        if (token.kind === 'short_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'short_lit', value: parseInt(token.value.slice(0, -1), 10) }, token);
+        }
+        if (token.kind === 'long_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'long_lit', value: parseInt(token.value.slice(0, -1), 10) }, token);
+        }
+        if (token.kind === 'double_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'double_lit', value: parseFloat(token.value.slice(0, -1)) }, token);
+        }
+        // String literal
+        if (token.kind === 'string_lit') {
+            this.advance();
+            return this.parseStringExpr(token);
+        }
+        if (token.kind === 'f_string') {
+            this.advance();
+            return this.parseFStringExpr(token);
+        }
+        // MC name literal: #health → mc_name node (value = "health", without #)
+        if (token.kind === 'mc_name') {
+            this.advance();
+            return this.withLoc({ kind: 'mc_name', value: token.value.slice(1) }, token);
+        }
+        // Boolean literal
+        if (token.kind === 'true') {
+            this.advance();
+            return this.withLoc({ kind: 'bool_lit', value: true }, token);
+        }
+        if (token.kind === 'false') {
+            this.advance();
+            return this.withLoc({ kind: 'bool_lit', value: false }, token);
+        }
+        // Range literal
+        if (token.kind === 'range_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'range_lit', range: this.parseRangeValue(token.value) }, token);
+        }
+        // Selector
+        if (token.kind === 'selector') {
+            this.advance();
+            return this.withLoc({
+                kind: 'selector',
+                raw: token.value,
+                isSingle: computeIsSingle(token.value),
+                sel: this.parseSelectorValue(token.value),
+            }, token);
+        }
+        // Identifier
+        if (token.kind === 'ident') {
+            this.advance();
+            return this.withLoc({ kind: 'ident', name: token.value }, token);
+        }
+        // Grouped expression
+        if (token.kind === '(') {
+            if (this.isBlockPosLiteral()) {
+                return this.parseBlockPos();
+            }
+            if (this.isLambdaStart()) {
+                return this.parseLambdaExpr();
+            }
+            this.advance();
+            const expr = this.parseExpr();
+            this.expect(')');
+            return expr;
+        }
+        // Struct literal or block: { x: 10, y: 20 }
+        if (token.kind === '{') {
+            return this.parseStructLit();
+        }
+        // Array literal: [1, 2, 3] or []
+        if (token.kind === '[') {
+            return this.parseArrayLit();
+        }
+        this.error(`Unexpected token '${token.kind}'`);
+    }
+    parseLiteralExpr() {
+        // Support negative literals: -5, -3.14
+        if (this.check('-')) {
+            this.advance();
+            const token = this.peek();
+            if (token.kind === 'int_lit') {
+                this.advance();
+                return this.withLoc({ kind: 'int_lit', value: -Number(token.value) }, token);
+            }
+            if (token.kind === 'float_lit') {
+                this.advance();
+                return this.withLoc({ kind: 'float_lit', value: -Number(token.value) }, token);
+            }
+            this.error('Expected number after unary -');
+        }
+        const expr = this.parsePrimaryExpr();
+        if (expr.kind === 'int_lit' ||
+            expr.kind === 'float_lit' ||
+            expr.kind === 'bool_lit' ||
+            expr.kind === 'str_lit') {
+            return expr;
+        }
+        this.error('Const value must be a literal');
+    }
+    parseSingleParamLambda() {
+        const paramToken = this.expect('ident');
+        const params = [{ name: paramToken.value }];
+        this.expect('=>');
+        return this.finishLambdaExpr(params, paramToken);
+    }
+    parseLambdaExpr() {
+        const openParenToken = this.expect('(');
+        const params = [];
+        if (!this.check(')')) {
+            do {
+                const name = this.expect('ident').value;
+                let type;
+                if (this.match(':')) {
+                    type = this.parseType();
+                }
+                params.push({ name, type });
+            } while (this.match(','));
+        }
+        this.expect(')');
+        let returnType;
+        if (this.match('->')) {
+            returnType = this.parseType();
+        }
+        this.expect('=>');
+        return this.finishLambdaExpr(params, openParenToken, returnType);
+    }
+    finishLambdaExpr(params, token, returnType) {
+        const body = this.check('{') ? this.parseBlock() : this.parseExpr();
+        return this.withLoc({ kind: 'lambda', params, returnType, body }, token);
+    }
+    parseStringExpr(token) {
+        if (!token.value.includes('${')) {
+            return this.withLoc({ kind: 'str_lit', value: token.value }, token);
+        }
+        const parts = [];
+        let current = '';
+        let index = 0;
+        while (index < token.value.length) {
+            if (token.value[index] === '$' && token.value[index + 1] === '{') {
+                if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+                index += 2;
+                let depth = 1;
+                let exprSource = '';
+                let inString = false;
+                while (index < token.value.length && depth > 0) {
+                    const char = token.value[index];
+                    if (char === '"' && token.value[index - 1] !== '\\') {
+                        inString = !inString;
+                    }
+                    if (!inString) {
+                        if (char === '{') {
+                            depth++;
+                        }
+                        else if (char === '}') {
+                            depth--;
+                            if (depth === 0) {
+                                index++;
+                                break;
+                            }
+                        }
+                    }
+                    if (depth > 0) {
+                        exprSource += char;
+                    }
+                    index++;
+                }
+                if (depth !== 0) {
+                    this.error('Unterminated string interpolation');
+                }
+                parts.push(this.parseEmbeddedExpr(exprSource));
+                continue;
+            }
+            current += token.value[index];
+            index++;
+        }
+        if (current) {
+            parts.push(current);
+        }
+        return this.withLoc({ kind: 'str_interp', parts }, token);
+    }
+    parseFStringExpr(token) {
+        const parts = [];
+        let current = '';
+        let index = 0;
+        while (index < token.value.length) {
+            if (token.value[index] === '{') {
+                if (current) {
+                    parts.push({ kind: 'text', value: current });
+                    current = '';
+                }
+                index++;
+                let depth = 1;
+                let exprSource = '';
+                let inString = false;
+                while (index < token.value.length && depth > 0) {
+                    const char = token.value[index];
+                    if (char === '"' && token.value[index - 1] !== '\\') {
+                        inString = !inString;
+                    }
+                    if (!inString) {
+                        if (char === '{') {
+                            depth++;
+                        }
+                        else if (char === '}') {
+                            depth--;
+                            if (depth === 0) {
+                                index++;
+                                break;
+                            }
+                        }
+                    }
+                    if (depth > 0) {
+                        exprSource += char;
+                    }
+                    index++;
+                }
+                if (depth !== 0) {
+                    this.error('Unterminated f-string interpolation');
+                }
+                parts.push({ kind: 'expr', expr: this.parseEmbeddedExpr(exprSource) });
+                continue;
+            }
+            current += token.value[index];
+            index++;
+        }
+        if (current) {
+            parts.push({ kind: 'text', value: current });
+        }
+        return this.withLoc({ kind: 'f_string', parts }, token);
+    }
+    parseEmbeddedExpr(source) {
+        const tokens = new lexer_1.Lexer(source, this.filePath).tokenize();
+        const parser = new Parser(tokens, source, this.filePath);
+        const expr = parser.parseExpr();
+        if (!parser.check('eof')) {
+            parser.error(`Unexpected token '${parser.peek().kind}' in string interpolation`);
+        }
+        return expr;
+    }
+    parseStructLit() {
+        const braceToken = this.expect('{');
+        const fields = [];
+        if (!this.check('}')) {
+            do {
+                const name = this.expect('ident').value;
+                this.expect(':');
+                const value = this.parseExpr();
+                fields.push({ name, value });
+            } while (this.match(','));
+        }
+        this.expect('}');
+        return this.withLoc({ kind: 'struct_lit', fields }, braceToken);
+    }
+    parseArrayLit() {
+        const bracketToken = this.expect('[');
+        const elements = [];
+        if (!this.check(']')) {
+            do {
+                elements.push(this.parseExpr());
+            } while (this.match(','));
+        }
+        this.expect(']');
+        return this.withLoc({ kind: 'array_lit', elements }, bracketToken);
+    }
+    isLambdaStart() {
+        if (!this.check('('))
+            return false;
+        let offset = 1;
+        if (this.peek(offset).kind !== ')') {
+            while (true) {
+                if (this.peek(offset).kind !== 'ident') {
+                    return false;
+                }
+                offset += 1;
+                if (this.peek(offset).kind === ':') {
+                    offset += 1;
+                    const consumed = this.typeTokenLength(offset);
+                    if (consumed === 0) {
+                        return false;
+                    }
+                    offset += consumed;
+                }
+                if (this.peek(offset).kind === ',') {
+                    offset += 1;
+                    continue;
+                }
+                break;
+            }
+        }
+        if (this.peek(offset).kind !== ')') {
+            return false;
+        }
+        offset += 1;
+        if (this.peek(offset).kind === '=>') {
+            return true;
+        }
+        if (this.peek(offset).kind === '->') {
+            offset += 1;
+            const consumed = this.typeTokenLength(offset);
+            if (consumed === 0) {
+                return false;
+            }
+            offset += consumed;
+            return this.peek(offset).kind === '=>';
+        }
+        return false;
+    }
+    typeTokenLength(offset) {
+        const token = this.peek(offset);
+        if (token.kind === '(') {
+            let inner = offset + 1;
+            if (this.peek(inner).kind !== ')') {
+                while (true) {
+                    const consumed = this.typeTokenLength(inner);
+                    if (consumed === 0) {
+                        return 0;
+                    }
+                    inner += consumed;
+                    if (this.peek(inner).kind === ',') {
+                        inner += 1;
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if (this.peek(inner).kind !== ')') {
+                return 0;
+            }
+            inner += 1;
+            if (this.peek(inner).kind !== '->') {
+                return 0;
+            }
+            inner += 1;
+            const returnLen = this.typeTokenLength(inner);
+            return returnLen === 0 ? 0 : inner + returnLen - offset;
+        }
+        const isNamedType = token.kind === 'int' ||
+            token.kind === 'bool' ||
+            token.kind === 'float' ||
+            token.kind === 'string' ||
+            token.kind === 'void' ||
+            token.kind === 'BlockPos' ||
+            token.kind === 'ident';
+        if (!isNamedType) {
+            return 0;
+        }
+        let length = 1;
+        while (this.peek(offset + length).kind === '[' && this.peek(offset + length + 1).kind === ']') {
+            length += 2;
+        }
+        return length;
+    }
+    isBlockPosLiteral() {
+        if (!this.check('('))
+            return false;
+        let offset = 1;
+        for (let i = 0; i < 3; i++) {
+            const consumed = this.coordComponentTokenLength(offset);
+            if (consumed === 0)
+                return false;
+            offset += consumed;
+            if (i < 2) {
+                if (this.peek(offset).kind !== ',')
+                    return false;
+                offset += 1;
+            }
+        }
+        return this.peek(offset).kind === ')';
+    }
+    coordComponentTokenLength(offset) {
+        const token = this.peek(offset);
+        if (token.kind === 'int_lit') {
+            return 1;
+        }
+        if (token.kind === '-') {
+            return this.peek(offset + 1).kind === 'int_lit' ? 2 : 0;
+        }
+        // rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) are single tokens now
+        if (token.kind === 'rel_coord' || token.kind === 'local_coord') {
+            return 1;
+        }
+        return 0;
+    }
+    parseBlockPos() {
+        const openParenToken = this.expect('(');
+        const x = this.parseCoordComponent();
+        this.expect(',');
+        const y = this.parseCoordComponent();
+        this.expect(',');
+        const z = this.parseCoordComponent();
+        this.expect(')');
+        return this.withLoc({ kind: 'blockpos', x, y, z }, openParenToken);
+    }
+    parseCoordComponent() {
+        const token = this.peek();
+        // Handle rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) tokens
+        if (token.kind === 'rel_coord') {
+            this.advance();
+            // Parse the offset from the token value (e.g., "~5" -> 5, "~" -> 0, "~-3" -> -3)
+            const offset = this.parseCoordOffsetFromValue(token.value.slice(1));
+            return { kind: 'relative', offset };
+        }
+        if (token.kind === 'local_coord') {
+            this.advance();
+            const offset = this.parseCoordOffsetFromValue(token.value.slice(1));
+            return { kind: 'local', offset };
+        }
+        return { kind: 'absolute', value: this.parseSignedCoordOffset(true) };
+    }
+    parseCoordOffsetFromValue(value) {
+        if (value === '' || value === undefined)
+            return 0;
+        return parseFloat(value);
+    }
+    parseSignedCoordOffset(requireValue = false) {
+        let sign = 1;
+        if (this.match('-')) {
+            sign = -1;
+        }
+        if (this.check('int_lit')) {
+            return sign * parseInt(this.advance().value, 10);
+        }
+        if (requireValue) {
+            this.error('Expected integer coordinate component');
+        }
+        return 0;
+    }
+    // -------------------------------------------------------------------------
+    // Selector Parsing
+    // -------------------------------------------------------------------------
+    parseSelector() {
+        const token = this.expect('selector');
+        return this.parseSelectorValue(token.value);
+    }
+    // Parse either a selector (@a[...]) or a variable with filters (p[...])
+    // Returns { selector } for selectors or { varName, filters } for variables
+    parseSelectorOrVarSelector() {
+        if (this.check('selector')) {
+            return { selector: this.parseSelector() };
+        }
+        // Must be an identifier (variable) possibly with filters
+        const varToken = this.expect('ident');
+        const varName = varToken.value;
+        // Check for optional filters [...]
+        if (this.check('[')) {
+            this.advance(); // consume '['
+            // Collect everything until ']'
+            let filterStr = '';
+            let depth = 1;
+            while (depth > 0 && !this.check('eof')) {
+                if (this.check('['))
+                    depth++;
+                else if (this.check(']'))
+                    depth--;
+                if (depth > 0) {
+                    filterStr += this.peek().value ?? this.peek().kind;
+                    this.advance();
+                }
+            }
+            this.expect(']');
+            const filters = this.parseSelectorFilters(filterStr);
+            return { varName, filters };
+        }
+        return { varName };
+    }
+    parseSelectorValue(value) {
+        // Parse @e[type=zombie, distance=..5]
+        const bracketIndex = value.indexOf('[');
+        if (bracketIndex === -1) {
+            return { kind: value };
+        }
+        const kind = value.slice(0, bracketIndex);
+        const paramsStr = value.slice(bracketIndex + 1, -1); // Remove [ and ]
+        const filters = this.parseSelectorFilters(paramsStr);
+        return { kind, filters };
+    }
+    parseSelectorFilters(paramsStr) {
+        const filters = {};
+        const parts = this.splitSelectorParams(paramsStr);
+        for (const part of parts) {
+            const eqIndex = part.indexOf('=');
+            if (eqIndex === -1)
+                continue;
+            const key = part.slice(0, eqIndex).trim();
+            const val = part.slice(eqIndex + 1).trim();
+            switch (key) {
+                case 'type':
+                    filters.type = val;
+                    break;
+                case 'distance':
+                    filters.distance = this.parseRangeValue(val);
+                    break;
+                case 'tag':
+                    if (val.startsWith('!')) {
+                        filters.notTag = filters.notTag ?? [];
+                        filters.notTag.push(val.slice(1));
+                    }
+                    else {
+                        filters.tag = filters.tag ?? [];
+                        filters.tag.push(val);
+                    }
+                    break;
+                case 'limit':
+                    filters.limit = parseInt(val, 10);
+                    break;
+                case 'sort':
+                    filters.sort = val;
+                    break;
+                case 'nbt':
+                    filters.nbt = val;
+                    break;
+                case 'gamemode':
+                    filters.gamemode = val;
+                    break;
+                case 'scores':
+                    filters.scores = this.parseScoresFilter(val);
+                    break;
+                case 'x':
+                    filters.x = this.parseRangeValue(val);
+                    break;
+                case 'y':
+                    filters.y = this.parseRangeValue(val);
+                    break;
+                case 'z':
+                    filters.z = this.parseRangeValue(val);
+                    break;
+                case 'x_rotation':
+                    filters.x_rotation = this.parseRangeValue(val);
+                    break;
+                case 'y_rotation':
+                    filters.y_rotation = this.parseRangeValue(val);
+                    break;
+            }
+        }
+        return filters;
+    }
+    splitSelectorParams(str) {
+        const parts = [];
+        let current = '';
+        let depth = 0;
+        for (const char of str) {
+            if (char === '{' || char === '[')
+                depth++;
+            else if (char === '}' || char === ']')
+                depth--;
+            else if (char === ',' && depth === 0) {
+                parts.push(current.trim());
+                current = '';
+                continue;
+            }
+            current += char;
+        }
+        if (current.trim()) {
+            parts.push(current.trim());
+        }
+        return parts;
+    }
+    parseScoresFilter(val) {
+        // Parse {kills=1.., deaths=..5}
+        const scores = {};
+        const inner = val.slice(1, -1); // Remove { and }
+        const parts = inner.split(',');
+        for (const part of parts) {
+            const [name, range] = part.split('=').map(s => s.trim());
+            scores[name] = this.parseRangeValue(range);
+        }
+        return scores;
+    }
+    parseRangeValue(value) {
+        // ..5 → { max: 5 }
+        // 1.. → { min: 1 }
+        // 1..10 → { min: 1, max: 10 }
+        // 5 → { min: 5, max: 5 } (exact match)
+        if (value.startsWith('..')) {
+            const max = parseInt(value.slice(2), 10);
+            return { max };
+        }
+        if (value.endsWith('..')) {
+            const min = parseInt(value.slice(0, -2), 10);
+            return { min };
+        }
+        const dotIndex = value.indexOf('..');
+        if (dotIndex !== -1) {
+            const min = parseInt(value.slice(0, dotIndex), 10);
+            const max = parseInt(value.slice(dotIndex + 2), 10);
+            return { min, max };
+        }
+        // Exact value
+        const val = parseInt(value, 10);
+        return { min: val, max: val };
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=index.js.map