redscript-mc 3.0.1 → 3.0.2

package/dist/src/parser/expr-parser.js

@@ -0,0 +1,759 @@
+"use strict";
+/**
+ * ExprParser — expression parsing (binary, unary, postfix, primary).
+ * Extends TypeParser so expression methods can call type methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprParser = void 0;
+const lexer_1 = require("../lexer");
+const type_parser_1 = require("./type-parser");
+const utils_1 = require("./utils");
+// ---------------------------------------------------------------------------
+// Entity type name set
+// ---------------------------------------------------------------------------
+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;
+}
+class ExprParser extends type_parser_1.TypeParser {
+    // -------------------------------------------------------------------------
+    // Expressions (Precedence Climbing)
+    // -------------------------------------------------------------------------
+    parseExpr() {
+        return this.parseAssignment();
+    }
+    parseAssignment() {
+        const left = this.parseBinaryExpr(1);
+        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);
+            }
+            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);
+            }
+            if (left.kind === 'index') {
+                const value = this.parseAssignment();
+                return this.withLoc({ kind: 'index_assign', obj: left.obj, index: left.index, op, value }, this.getLocToken(left) ?? token);
+            }
+        }
+        return left;
+    }
+    parseBinaryExpr(minPrec) {
+        let left = this.parseUnaryExpr();
+        while (true) {
+            const op = this.peek().kind;
+            if (!utils_1.BINARY_OPS.has(op))
+                break;
+            const prec = utils_1.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 = 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}'. Valid types: ${[...ENTITY_TYPE_NAMES].slice(0, 6).join(', ')}, ...`);
+    }
+    isSubtraction() {
+        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) {
+            // Generic call: ident<Type>(args)
+            if (expr.kind === 'ident' && this.check('<')) {
+                const typeArgs = this.tryParseTypeArgs();
+                if (typeArgs !== null && this.check('(')) {
+                    const openParenToken = this.peek();
+                    this.advance(); // consume '('
+                    const args = this.parseArgs();
+                    this.expect(')');
+                    expr = this.withLoc({ kind: 'call', fn: expr.name, args, typeArgs }, this.getLocToken(expr) ?? openParenToken);
+                    continue;
+                }
+            }
+            // 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;
+                }
+                if (expr.kind === 'member') {
+                    if (expr.field === 'unwrap_or') {
+                        const defaultExpr = this.parseExpr();
+                        this.expect(')');
+                        expr = this.withLoc({ kind: 'unwrap_or', opt: expr.obj, default_: defaultExpr }, this.getLocToken(expr) ?? openParenToken);
+                        continue;
+                    }
+                    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;
+                    }
+                    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
+            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;
+            }
+            // Type cast: expr as Type
+            if (this.check('as') && this.isTypeCastAs()) {
+                const asToken = this.advance();
+                const targetType = this.parseType();
+                expr = this.withLoc({ kind: 'type_cast', expr, targetType }, this.getLocToken(expr) ?? asToken);
+                continue;
+            }
+            break;
+        }
+        return expr;
+    }
+    isTypeCastAs() {
+        const next = this.tokens[this.pos + 1];
+        if (!next)
+            return false;
+        const typeStartTokens = new Set(['int', 'bool', 'float', 'fixed', 'string', 'void', 'BlockPos', '(']);
+        if (typeStartTokens.has(next.kind))
+            return true;
+        if (next.kind === 'ident' && (next.value === 'double' || next.value === 'byte' || next.value === 'short' ||
+            next.value === 'long' || next.value === 'selector' || next.value === 'Option'))
+            return true;
+        return false;
+    }
+    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 memberToken = this.expect('ident');
+            if (this.check('(')) {
+                const isNamedArgs = this.peek(1).kind === 'ident' && this.peek(2).kind === ':';
+                if (isNamedArgs) {
+                    this.advance(); // consume '('
+                    const args = [];
+                    while (!this.check(')') && !this.check('eof')) {
+                        const fieldName = this.expect('ident').value;
+                        this.expect(':');
+                        const value = this.parseExpr();
+                        args.push({ name: fieldName, value });
+                        if (!this.match(','))
+                            break;
+                    }
+                    this.expect(')');
+                    return this.withLoc({ kind: 'enum_construct', enumName: typeToken.value, variant: memberToken.value, args }, typeToken);
+                }
+                this.advance(); // consume '('
+                const args = this.parseArgs();
+                this.expect(')');
+                return this.withLoc({ kind: 'static_call', type: typeToken.value, method: memberToken.value, args }, typeToken);
+            }
+            return this.withLoc({ kind: 'path_expr', enumName: typeToken.value, variant: memberToken.value }, typeToken);
+        }
+        if (token.kind === 'ident' && this.peek(1).kind === '=>') {
+            return this.parseSingleParamLambda();
+        }
+        if (token.kind === 'int_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'int_lit', value: parseInt(token.value, 10) }, token);
+        }
+        if (token.kind === 'float_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'float_lit', value: parseFloat(token.value) }, token);
+        }
+        if (token.kind === 'rel_coord') {
+            this.advance();
+            return this.withLoc({ kind: 'rel_coord', value: token.value }, token);
+        }
+        if (token.kind === 'local_coord') {
+            this.advance();
+            return this.withLoc({ kind: 'local_coord', value: token.value }, token);
+        }
+        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);
+        }
+        if (token.kind === 'string_lit') {
+            this.advance();
+            return this.parseStringExpr(token);
+        }
+        if (token.kind === 'f_string') {
+            this.advance();
+            return this.parseFStringExpr(token);
+        }
+        if (token.kind === 'mc_name') {
+            this.advance();
+            return this.withLoc({ kind: 'mc_name', value: token.value.slice(1) }, token);
+        }
+        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);
+        }
+        if (token.kind === 'range_lit') {
+            this.advance();
+            return this.withLoc({ kind: 'range_lit', range: this.parseRangeValue(token.value) }, token);
+        }
+        if (token.kind === 'selector') {
+            this.advance();
+            return this.withLoc({
+                kind: 'selector',
+                raw: token.value,
+                isSingle: computeIsSingle(token.value),
+                sel: this.parseSelectorValue(token.value),
+            }, token);
+        }
+        if (token.kind === 'ident' && this.peek(1).kind === '{' &&
+            this.peek(2).kind === 'ident' && this.peek(3).kind === ':') {
+            this.advance();
+            return this.parseStructLit();
+        }
+        if (token.kind === 'ident' && token.value === 'Some' && this.peek(1).kind === '(') {
+            this.advance();
+            this.advance();
+            const value = this.parseExpr();
+            this.expect(')');
+            return this.withLoc({ kind: 'some_lit', value }, token);
+        }
+        if (token.kind === 'ident' && token.value === 'None') {
+            this.advance();
+            return this.withLoc({ kind: 'none_lit' }, token);
+        }
+        if (token.kind === 'ident') {
+            this.advance();
+            return this.withLoc({ kind: 'ident', name: token.value }, token);
+        }
+        if (token.kind === '(') {
+            if (this.isBlockPosLiteral()) {
+                return this.parseBlockPos();
+            }
+            if (this.isLambdaStart()) {
+                return this.parseLambdaExpr();
+            }
+            this.advance();
+            const first = this.parseExpr();
+            if (this.match(',')) {
+                const elements = [first];
+                if (!this.check(')')) {
+                    do {
+                        elements.push(this.parseExpr());
+                    } while (this.match(','));
+                }
+                this.expect(')');
+                return this.withLoc({ kind: 'tuple_lit', elements }, token);
+            }
+            this.expect(')');
+            return first;
+        }
+        if (token.kind === '{') {
+            return this.parseStructLit();
+        }
+        if (token.kind === '[') {
+            return this.parseArrayLit();
+        }
+        this.error(`Unexpected token '${token.value || token.kind}'. Expected an expression (identifier, literal, '(', '[', or '{')`);
+    }
+    parseLiteralExpr() {
+        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 minus (-). Const values must be numeric or string literals');
+        }
+        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');
+    }
+    // -------------------------------------------------------------------------
+    // Lambda
+    // -------------------------------------------------------------------------
+    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);
+    }
+    // -------------------------------------------------------------------------
+    // String interpolation
+    // -------------------------------------------------------------------------
+    parseStringExpr(token) {
+        // Plain string literals: no interpolation. "${...}" is treated as literal text.
+        // Only f"..." strings (f_string token) support {expr} interpolation.
+        return this.withLoc({ kind: 'str_lit', value: token.value }, 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) {
+        // Lazy import to break circular dependency at runtime — Parser extends ExprParser
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { Parser } = require('./index');
+        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;
+    }
+    // -------------------------------------------------------------------------
+    // Struct / Array / BlockPos literals
+    // -------------------------------------------------------------------------
+    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);
+    }
+    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 === '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();
+        if (token.kind === 'rel_coord') {
+            this.advance();
+            return { kind: 'relative', offset: this.parseCoordOffsetFromValue(token.value.slice(1)) };
+        }
+        if (token.kind === 'local_coord') {
+            this.advance();
+            return { kind: 'local', offset: this.parseCoordOffsetFromValue(token.value.slice(1)) };
+        }
+        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 (also used by stmt-parser)
+    // -------------------------------------------------------------------------
+    parseSelector() {
+        const token = this.expect('selector');
+        return this.parseSelectorValue(token.value);
+    }
+    parseSelectorOrVarSelector() {
+        if (this.check('selector')) {
+            return { selector: this.parseSelector() };
+        }
+        const varToken = this.expect('ident');
+        const varName = varToken.value;
+        if (this.check('[')) {
+            this.advance();
+            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) {
+        const bracketIndex = value.indexOf('[');
+        if (bracketIndex === -1) {
+            return { kind: value };
+        }
+        const kind = value.slice(0, bracketIndex);
+        const paramsStr = value.slice(bracketIndex + 1, -1);
+        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) {
+        const scores = {};
+        const inner = val.slice(1, -1);
+        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) {
+        if (value.startsWith('..=')) {
+            const rest = value.slice(3);
+            if (!rest)
+                return {};
+            return { max: parseInt(rest, 10) };
+        }
+        if (value.startsWith('..')) {
+            const rest = value.slice(2);
+            if (!rest)
+                return {};
+            return { max: parseInt(rest, 10) };
+        }
+        const inclIdx = value.indexOf('..=');
+        if (inclIdx !== -1) {
+            const min = parseInt(value.slice(0, inclIdx), 10);
+            const rest = value.slice(inclIdx + 3);
+            if (!rest)
+                return { min };
+            return { min, max: parseInt(rest, 10) };
+        }
+        const dotIndex = value.indexOf('..');
+        if (dotIndex !== -1) {
+            const min = parseInt(value.slice(0, dotIndex), 10);
+            const rest = value.slice(dotIndex + 2);
+            if (!rest)
+                return { min };
+            return { min, max: parseInt(rest, 10) };
+        }
+        const val = parseInt(value, 10);
+        return { min: val, max: val };
+    }
+    // -------------------------------------------------------------------------
+    // Coord token (used by stmt-parser for execute subcommands)
+    // -------------------------------------------------------------------------
+    parseCoordToken() {
+        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;
+        }
+        return this.error(`Expected coordinate, got ${token.kind}`);
+    }
+    parseBlockId() {
+        let id = this.advance().value;
+        if (this.match(':'))
+            id += ':' + this.advance().value;
+        if (this.check('[')) {
+            id += this.advance().value;
+            while (!this.check(']') && !this.check('eof'))
+                id += this.advance().value;
+            id += this.advance().value;
+        }
+        return id;
+    }
+}
+exports.ExprParser = ExprParser;
+//# sourceMappingURL=expr-parser.js.map