redscript-mc 1.0.0

package/dist/parser/index.js

@@ -0,0 +1,1193 @@
+"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,
+    '+': 5, '-': 5,
+    '*': 6, '/': 6, '%': 6,
+};
+const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', '+', '-', '*', '/', '%']);
+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;
+        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 declarations = [];
+        const structs = [];
+        const enums = [];
+        const consts = [];
+        // Check for namespace declaration
+        if (this.check('namespace')) {
+            this.advance();
+            const name = this.expect('ident');
+            namespace = name.value;
+            this.expect(';');
+        }
+        // Parse struct and function declarations
+        while (!this.check('eof')) {
+            if (this.check('struct')) {
+                structs.push(this.parseStructDecl());
+            }
+            else if (this.check('enum')) {
+                enums.push(this.parseEnumDecl());
+            }
+            else if (this.check('const')) {
+                consts.push(this.parseConstDecl());
+            }
+            else {
+                declarations.push(this.parseFnDecl());
+            }
+        }
+        return { namespace, declarations, structs, enums, consts };
+    }
+    // -------------------------------------------------------------------------
+    // 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);
+    }
+    parseConstDecl() {
+        const constToken = this.expect('const');
+        const name = this.expect('ident').value;
+        this.expect(':');
+        const type = this.parseType();
+        this.expect('=');
+        const value = this.parseLiteralExpr();
+        this.match(';');
+        return this.withLoc({ name, type, value }, constToken);
+    }
+    // -------------------------------------------------------------------------
+    // Function Declaration
+    // -------------------------------------------------------------------------
+    parseFnDecl() {
+        const decorators = this.parseDecorators();
+        const fnToken = this.expect('fn');
+        const name = this.expect('ident').value;
+        this.expect('(');
+        const params = this.parseParams();
+        this.expect(')');
+        let returnType = { kind: 'named', name: 'void' };
+        if (this.match('->')) {
+            returnType = this.parseType();
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ name, params, returnType, decorators, body }, fnToken);
+    }
+    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 or @on_trigger("name") or @on_advancement("story/mine_diamond")
+        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 = {};
+        // 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 };
+            }
+        }
+        // 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() {
+        const params = [];
+        if (!this.check(')')) {
+            do {
+                const paramToken = this.expect('ident');
+                const name = paramToken.value;
+                this.expect(':');
+                const 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();
+            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();
+        }
+        // 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');
+        const rangeToken = this.expect('range_lit');
+        const range = this.parseRangeValue(rangeToken.value);
+        const start = this.withLoc({ kind: 'int_lit', value: range.min ?? 0 }, rangeToken);
+        const end = this.withLoc({ kind: 'int_lit', value: range.max ?? 0 }, rangeToken);
+        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(')');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'foreach', binding, iterable, body }, 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.match('if')) {
+                // Expect 'entity' keyword (as ident) or just parse selector directly
+                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
+                    this.advance(); // consume 'entity'
+                }
+                const selector = this.parseSelector();
+                subcommands.push({ kind: 'if_entity', selector });
+            }
+            else if (this.match('unless')) {
+                // Expect 'entity' keyword (as ident) or just parse selector directly  
+                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
+                    this.advance(); // consume 'entity'
+                }
+                const selector = this.parseSelector();
+                subcommands.push({ kind: 'unless_entity', selector });
+            }
+            else if (this.match('in')) {
+                const dim = this.expect('ident').value;
+                subcommands.push({ kind: 'in', dimension: dim });
+            }
+            else {
+                this.error(`Unexpected token in execute statement: ${this.peek().kind}`);
+            }
+        }
+        this.expect('run');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'execute', subcommands, body }, executeToken);
+    }
+    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();
+            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();
+    }
+    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',
+                    };
+                    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;
+                    }
+                    this.error(`Unknown method '${expr.field}'`);
+                }
+                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 === '=>') {
+            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);
+        }
+        // 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);
+        }
+        // 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() {
+        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);
+    }
+    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;
+        }
+        if (token.kind !== '~' && token.kind !== '^') {
+            return 0;
+        }
+        const next = this.peek(offset + 1);
+        if (next.kind === ',' || next.kind === ')') {
+            return 1;
+        }
+        if (next.kind === 'int_lit') {
+            return 2;
+        }
+        if (next.kind === '-' && this.peek(offset + 2).kind === 'int_lit') {
+            return 3;
+        }
+        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();
+        if (token.kind === '~' || token.kind === '^') {
+            this.advance();
+            const offset = this.parseSignedCoordOffset();
+            return token.kind === '~'
+                ? { kind: 'relative', offset }
+                : { kind: 'local', offset };
+        }
+        return { kind: 'absolute', value: this.parseSignedCoordOffset(true) };
+    }
+    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);
+    }
+    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;
+            }
+        }
+        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