@ahsankhanamu/json-transformer 0.1.0

package/dist/parser.js

@@ -0,0 +1,1045 @@
+/**
+ * Parser - Recursive Descent Parser
+ * Produces AST from tokens
+ */
+import { TokenType } from './tokens.js';
+import { Lexer } from './lexer.js';
+export class ParseError extends Error {
+    token;
+    expected;
+    constructor(message, token, expected) {
+        super(`Parse error at line ${token.line}, column ${token.column}: ${message}`);
+        this.token = token;
+        this.expected = expected;
+        this.name = 'ParseError';
+    }
+}
+export class Parser {
+    input;
+    tokens = [];
+    current = 0;
+    inPipeObjectContext = false;
+    // Stack of arrow function parameter names (for nested arrows)
+    // When inside an arrow body, .property resolves to param.property
+    arrowParamStack = [];
+    constructor(input) {
+        this.input = input;
+    }
+    parse() {
+        const lexer = new Lexer(this.input);
+        this.tokens = lexer.tokenize();
+        this.current = 0;
+        const statements = [];
+        let expression = null;
+        // Parse statements (let/const bindings)
+        while (!this.isAtEnd() && (this.check(TokenType.LET) || this.check(TokenType.CONST))) {
+            statements.push(this.parseLetBinding());
+        }
+        // Parse final expression
+        if (!this.isAtEnd()) {
+            expression = this.parseExpression();
+        }
+        // Should be at EOF
+        if (!this.isAtEnd()) {
+            throw new ParseError('Unexpected token after expression', this.peek());
+        }
+        return {
+            type: 'Program',
+            statements,
+            expression,
+        };
+    }
+    // ===========================================================================
+    // STATEMENTS
+    // ===========================================================================
+    parseLetBinding() {
+        const constant = this.check(TokenType.CONST);
+        this.advance(); // consume let/const
+        const nameToken = this.consume(TokenType.IDENTIFIER, 'Expected variable name');
+        this.consume(TokenType.ASSIGN, 'Expected "=" after variable name');
+        const value = this.parseExpression();
+        this.consume(TokenType.SEMICOLON, 'Expected ";" after variable declaration');
+        return {
+            type: 'LetBinding',
+            name: nameToken.value,
+            value,
+            constant,
+        };
+    }
+    // ===========================================================================
+    // EXPRESSIONS (by precedence, lowest to highest)
+    // ===========================================================================
+    parseExpression() {
+        return this.parsePipe();
+    }
+    // Pipe: value | transform | transform
+    // Also supports jq-style property access: value | .field | .[0] | .method()
+    // And pipe-to-object/array construction: value | { id: .id } or value | [.id, .name]
+    parsePipe() {
+        let left = this.parseTernary();
+        while (this.match(TokenType.PIPE)) {
+            // Check if next token is DOT - pipe property access syntax (jq-style)
+            if (this.check(TokenType.DOT)) {
+                const right = this.parsePipePropertyAccess();
+                left = { type: 'PipeExpression', left, right };
+            }
+            else if (this.check(TokenType.LBRACKET)) {
+                // Could be index access [0] or array construction [.id, .name]
+                const right = this.parsePipeArrayOrIndex();
+                left = { type: 'PipeExpression', left, right };
+            }
+            else if (this.check(TokenType.LBRACE)) {
+                // Pipe-to-object construction: value | { .field, newKey: .other }
+                const right = this.parsePipeObjectConstruction();
+                left = { type: 'PipeExpression', left, right };
+            }
+            else {
+                const right = this.parseTernary();
+                left = { type: 'PipeExpression', left, right };
+            }
+        }
+        return left;
+    }
+    // Determine if | [...] is array construction or index access
+    // Array construction: | [.id, .name] or | [id, name] (shorthand) or | [expr, expr, ...]
+    // Index access: | [0] or | [expr] (single non-identifier expression)
+    parsePipeArrayOrIndex() {
+        // Peek at what follows [
+        const afterBracket = this.peekNext(); // token after [
+        // If [ is followed by DOT, it's array construction with pipe context refs: [.id, .name]
+        if (afterBracket.type === TokenType.DOT) {
+            return this.parsePipeArrayConstruction();
+        }
+        // If [ is followed by ], it's empty array construction: []
+        if (afterBracket.type === TokenType.RBRACKET) {
+            return this.parsePipeArrayConstruction();
+        }
+        // If [ is followed by SPREAD, it's array construction: [...items]
+        if (afterBracket.type === TokenType.SPREAD) {
+            return this.parsePipeArrayConstruction();
+        }
+        // If [ is followed by identifier, check if comma follows (array) or ] follows (index)
+        // For now, if followed by identifier, treat as array construction (shorthand)
+        if (afterBracket.type === TokenType.IDENTIFIER) {
+            return this.parsePipeArrayConstruction();
+        }
+        // Otherwise (number, string, expression), treat as index access
+        return this.parsePipeIndexAccess();
+    }
+    // Parse pipe-to-object construction: value | { id: .id, name: .name | upper }
+    parsePipeObjectConstruction() {
+        const savedContext = this.inPipeObjectContext;
+        this.inPipeObjectContext = true;
+        this.advance(); // consume {
+        const result = this.parseObjectLiteral();
+        this.inPipeObjectContext = savedContext;
+        return result;
+    }
+    // Parse pipe-to-array construction: value | [.id, .name] or value | [id, name]
+    parsePipeArrayConstruction() {
+        const savedContext = this.inPipeObjectContext;
+        this.inPipeObjectContext = true;
+        this.advance(); // consume [
+        const result = this.parsePipeArrayLiteral();
+        this.inPipeObjectContext = savedContext;
+        return result;
+    }
+    // Parse array literal in pipe context - identifiers become pipe context refs
+    parsePipeArrayLiteral() {
+        const elements = [];
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.match(TokenType.SPREAD)) {
+                // Spread in pipe array context: [...] spreads pipe value, [...expr] spreads expr
+                if (this.check(TokenType.COMMA) || this.check(TokenType.RBRACKET)) {
+                    // Bare spread: [...] spreads the pipe context
+                    elements.push({ type: 'SpreadElement', argument: { type: 'PipeContextRef' } });
+                }
+                else {
+                    const argument = this.parseExpression();
+                    elements.push({ type: 'SpreadElement', argument });
+                }
+            }
+            else if (this.match(TokenType.IDENTIFIER)) {
+                // Shorthand: identifier in pipe array context becomes .identifier
+                const name = this.previous().value;
+                elements.push({
+                    type: 'MemberAccess',
+                    object: { type: 'PipeContextRef' },
+                    property: name,
+                    optional: false,
+                });
+            }
+            else {
+                elements.push(this.parseExpression());
+            }
+            if (!this.check(TokenType.RBRACKET)) {
+                this.consume(TokenType.COMMA, 'Expected "," between elements');
+                // Allow trailing comma
+                if (this.check(TokenType.RBRACKET))
+                    break;
+            }
+        }
+        this.consume(TokenType.RBRACKET, 'Expected "]" after array literal');
+        return { type: 'ArrayLiteral', elements };
+    }
+    // Parse jq-style pipe property access: .field, .[0], .field.subfield, .method()
+    parsePipePropertyAccess() {
+        // Start with PipeContextRef as the base
+        let expr = { type: 'PipeContextRef' };
+        // Must start with DOT
+        while (this.check(TokenType.DOT) || this.check(TokenType.LBRACKET)) {
+            if (this.match(TokenType.DOT)) {
+                // Check for .[index] syntax
+                if (this.check(TokenType.LBRACKET)) {
+                    this.advance(); // consume [
+                    const index = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]"');
+                    expr = {
+                        type: 'IndexAccess',
+                        object: expr,
+                        index,
+                        optional: false,
+                    };
+                }
+                else {
+                    // .field or .method()
+                    const name = this.consume(TokenType.IDENTIFIER, 'Expected property name after "."');
+                    expr = {
+                        type: 'MemberAccess',
+                        object: expr,
+                        property: name.value,
+                        optional: false,
+                    };
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                // [0] or ["key"] without dot prefix
+                const index = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]"');
+                expr = {
+                    type: 'IndexAccess',
+                    object: expr,
+                    index,
+                    optional: false,
+                };
+            }
+            // Handle method calls: .method()
+            if (this.check(TokenType.LPAREN)) {
+                this.advance();
+                const args = [];
+                if (!this.check(TokenType.RPAREN)) {
+                    do {
+                        args.push(this.parseExpression());
+                    } while (this.match(TokenType.COMMA));
+                }
+                this.consume(TokenType.RPAREN, 'Expected ")"');
+                expr = {
+                    type: 'CallExpression',
+                    callee: expr,
+                    arguments: args,
+                };
+            }
+        }
+        return expr;
+    }
+    // Parse pipe index access: | [0] (without dot)
+    parsePipeIndexAccess() {
+        let expr = { type: 'PipeContextRef' };
+        this.advance(); // consume [
+        const index = this.parseExpression();
+        this.consume(TokenType.RBRACKET, 'Expected "]"');
+        expr = {
+            type: 'IndexAccess',
+            object: expr,
+            index,
+            optional: false,
+        };
+        // Allow chaining after: | [0].field or | [0][1]
+        while (this.check(TokenType.DOT) || this.check(TokenType.LBRACKET)) {
+            if (this.match(TokenType.DOT)) {
+                if (this.check(TokenType.LBRACKET)) {
+                    this.advance();
+                    const idx = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]"');
+                    expr = { type: 'IndexAccess', object: expr, index: idx, optional: false };
+                }
+                else {
+                    const name = this.consume(TokenType.IDENTIFIER, 'Expected property name after "."');
+                    expr = {
+                        type: 'MemberAccess',
+                        object: expr,
+                        property: name.value,
+                        optional: false,
+                    };
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                const idx = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]"');
+                expr = { type: 'IndexAccess', object: expr, index: idx, optional: false };
+            }
+            // Handle method calls
+            if (this.check(TokenType.LPAREN)) {
+                this.advance();
+                const args = [];
+                if (!this.check(TokenType.RPAREN)) {
+                    do {
+                        args.push(this.parseExpression());
+                    } while (this.match(TokenType.COMMA));
+                }
+                this.consume(TokenType.RPAREN, 'Expected ")"');
+                expr = { type: 'CallExpression', callee: expr, arguments: args };
+            }
+        }
+        return expr;
+    }
+    // Parse .field access inside pipe object context (DOT already consumed)
+    // Returns PipeContextRef-based expression: .field, .[0], .field.nested
+    parsePipeContextAccess() {
+        let expr = { type: 'PipeContextRef' };
+        // Check for .[index] syntax
+        if (this.check(TokenType.LBRACKET)) {
+            this.advance(); // consume [
+            const index = this.parseExpression();
+            this.consume(TokenType.RBRACKET, 'Expected "]"');
+            expr = { type: 'IndexAccess', object: expr, index, optional: false };
+        }
+        else if (this.check(TokenType.IDENTIFIER)) {
+            // .field
+            const name = this.advance();
+            expr = {
+                type: 'MemberAccess',
+                object: expr,
+                property: name.value,
+                optional: false,
+            };
+        }
+        else {
+            // Just . by itself - return the pipe context
+            return expr;
+        }
+        // Allow chaining: .field.nested, .field[0], .field.method()
+        while (this.check(TokenType.DOT) || this.check(TokenType.LBRACKET)) {
+            if (this.match(TokenType.DOT)) {
+                if (this.check(TokenType.LBRACKET)) {
+                    this.advance();
+                    const idx = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]"');
+                    expr = { type: 'IndexAccess', object: expr, index: idx, optional: false };
+                }
+                else {
+                    const name = this.consume(TokenType.IDENTIFIER, 'Expected property name after "."');
+                    expr = {
+                        type: 'MemberAccess',
+                        object: expr,
+                        property: name.value,
+                        optional: false,
+                    };
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                const idx = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]"');
+                expr = { type: 'IndexAccess', object: expr, index: idx, optional: false };
+            }
+            // Handle method calls: .method()
+            if (this.check(TokenType.LPAREN)) {
+                this.advance();
+                const args = [];
+                if (!this.check(TokenType.RPAREN)) {
+                    do {
+                        args.push(this.parseExpression());
+                    } while (this.match(TokenType.COMMA));
+                }
+                this.consume(TokenType.RPAREN, 'Expected ")"');
+                expr = { type: 'CallExpression', callee: expr, arguments: args };
+            }
+        }
+        return expr;
+    }
+    // Parse .field access inside arrow function body (DOT already consumed)
+    // Returns param-based expression: .field becomes param.field, .[0] becomes param[0]
+    parseArrowContextAccess() {
+        const paramName = this.arrowParamStack[this.arrowParamStack.length - 1];
+        let expr = { type: 'Identifier', name: paramName };
+        // Check for .[index] syntax
+        if (this.check(TokenType.LBRACKET)) {
+            this.advance(); // consume [
+            const index = this.parseExpression();
+            this.consume(TokenType.RBRACKET, 'Expected "]"');
+            expr = { type: 'IndexAccess', object: expr, index, optional: false };
+        }
+        else if (this.check(TokenType.IDENTIFIER)) {
+            // .field
+            const name = this.advance();
+            expr = {
+                type: 'MemberAccess',
+                object: expr,
+                property: name.value,
+                optional: false,
+            };
+        }
+        else {
+            // Just . by itself - return the parameter identifier
+            return expr;
+        }
+        // Allow chaining: .field.nested, .field[0], .field.method()
+        while (this.check(TokenType.DOT) || this.check(TokenType.LBRACKET)) {
+            if (this.match(TokenType.DOT)) {
+                if (this.check(TokenType.LBRACKET)) {
+                    this.advance();
+                    const idx = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]"');
+                    expr = { type: 'IndexAccess', object: expr, index: idx, optional: false };
+                }
+                else {
+                    const name = this.consume(TokenType.IDENTIFIER, 'Expected property name after "."');
+                    expr = {
+                        type: 'MemberAccess',
+                        object: expr,
+                        property: name.value,
+                        optional: false,
+                    };
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                const idx = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]"');
+                expr = { type: 'IndexAccess', object: expr, index: idx, optional: false };
+            }
+            // Handle method calls: .method()
+            if (this.check(TokenType.LPAREN)) {
+                this.advance();
+                const args = [];
+                if (!this.check(TokenType.RPAREN)) {
+                    do {
+                        args.push(this.parseExpression());
+                    } while (this.match(TokenType.COMMA));
+                }
+                this.consume(TokenType.RPAREN, 'Expected ")"');
+                expr = { type: 'CallExpression', callee: expr, arguments: args };
+            }
+        }
+        return expr;
+    }
+    // Ternary: condition ? then : else
+    parseTernary() {
+        const test = this.parseLogicalOr();
+        if (this.match(TokenType.QUESTION)) {
+            const consequent = this.parseExpression();
+            this.consume(TokenType.COLON, 'Expected ":" in ternary expression');
+            const alternate = this.parseTernary();
+            return {
+                type: 'TernaryExpression',
+                test,
+                consequent,
+                alternate,
+            };
+        }
+        return test;
+    }
+    // Logical OR: a || b, a or b
+    parseLogicalOr() {
+        let left = this.parseLogicalAnd();
+        while (this.match(TokenType.OR_OR) || this.match(TokenType.OR)) {
+            const _operator = this.previous().value;
+            const right = this.parseLogicalAnd();
+            left = { type: 'BinaryExpression', operator: '||', left, right };
+        }
+        return left;
+    }
+    // Logical AND: a && b, a and b
+    parseLogicalAnd() {
+        let left = this.parseEquality();
+        while (this.match(TokenType.AND_AND) || this.match(TokenType.AND)) {
+            const _operator = this.previous().value;
+            const right = this.parseEquality();
+            left = { type: 'BinaryExpression', operator: '&&', left, right };
+        }
+        return left;
+    }
+    // Equality: a == b, a != b
+    parseEquality() {
+        let left = this.parseComparison();
+        while (this.match(TokenType.EQ) ||
+            this.match(TokenType.NEQ) ||
+            this.match(TokenType.STRICT_EQ) ||
+            this.match(TokenType.STRICT_NEQ)) {
+            const operator = this.previous().value;
+            const right = this.parseComparison();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        return left;
+    }
+    // Comparison: a < b, a >= b, a in b
+    parseComparison() {
+        let left = this.parseNullCoalesce();
+        while (this.match(TokenType.LT) ||
+            this.match(TokenType.GT) ||
+            this.match(TokenType.LTE) ||
+            this.match(TokenType.GTE) ||
+            this.match(TokenType.IN)) {
+            const operator = this.previous().value;
+            const right = this.parseNullCoalesce();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        return left;
+    }
+    // Null coalescing: a ?? b
+    parseNullCoalesce() {
+        let left = this.parseAdditive();
+        while (this.match(TokenType.QUESTION_QUESTION)) {
+            const right = this.parseAdditive();
+            left = { type: 'NullCoalesce', left, right };
+        }
+        return left;
+    }
+    // Addition/Subtraction/Concatenation: a + b, a - b, a & b
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.match(TokenType.PLUS) ||
+            this.match(TokenType.MINUS) ||
+            this.match(TokenType.AMPERSAND)) {
+            const operator = this.previous().value;
+            const right = this.parseMultiplicative();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        return left;
+    }
+    // Multiplication/Division: a * b, a / b, a % b
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.match(TokenType.STAR) ||
+            this.match(TokenType.SLASH) ||
+            this.match(TokenType.PERCENT)) {
+            const operator = this.previous().value;
+            const right = this.parseUnary();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        return left;
+    }
+    // Unary: !a, -a, +a, not a
+    parseUnary() {
+        if (this.match(TokenType.BANG) ||
+            this.match(TokenType.MINUS) ||
+            this.match(TokenType.PLUS) ||
+            this.match(TokenType.NOT)) {
+            const operator = this.previous().value;
+            const argument = this.parseUnary();
+            return { type: 'UnaryExpression', operator, argument, prefix: true };
+        }
+        return this.parsePostfix();
+    }
+    // Postfix: member access, index, call, etc.
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.match(TokenType.DOT)) {
+                // Special case: [*].{ } for array mapping with object construction
+                if (expr.type === 'SpreadAccess' && this.match(TokenType.LBRACE)) {
+                    const objectLiteral = this.parseObjectLiteral();
+                    expr = { type: 'MapTransform', array: expr.object, template: objectLiteral };
+                }
+                else {
+                    const property = this.consume(TokenType.IDENTIFIER, 'Expected property name after "."');
+                    expr = { type: 'MemberAccess', object: expr, property: property.value, optional: false };
+                }
+            }
+            else if (this.match(TokenType.QUESTION_DOT)) {
+                const property = this.consume(TokenType.IDENTIFIER, 'Expected property name after "?."');
+                expr = { type: 'MemberAccess', object: expr, property: property.value, optional: true };
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                expr = this.parseIndexOrSliceOrFilter(expr, false);
+            }
+            else if (this.match(TokenType.QUESTION_BRACKET)) {
+                expr = this.parseIndexOrSliceOrFilter(expr, true);
+            }
+            else if (this.match(TokenType.LPAREN)) {
+                expr = this.parseCallExpression(expr);
+            }
+            else if (this.match(TokenType.BANG)) {
+                // Non-null assertion
+                expr = { type: 'NonNullAssertion', expression: expr };
+            }
+            else if (this.match(TokenType.AS)) {
+                const typeAnnotation = this.parseTypeAnnotation();
+                expr = { type: 'TypeAssertion', expression: expr, typeAnnotation };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    parseIndexOrSliceOrFilter(object, optional) {
+        // Check for spread: [*]
+        if (this.match(TokenType.STAR)) {
+            this.consume(TokenType.RBRACKET, 'Expected "]" after "*"');
+            return { type: 'SpreadAccess', object };
+        }
+        // Check for empty brackets [] - shorthand for [*]
+        if (this.match(TokenType.RBRACKET)) {
+            return { type: 'SpreadAccess', object };
+        }
+        // Check for filter: [? predicate] or just [predicate] where predicate is boolean
+        if (this.match(TokenType.QUESTION)) {
+            const predicate = this.parseExpression();
+            this.consume(TokenType.RBRACKET, 'Expected "]" after filter predicate');
+            return { type: 'FilterAccess', object, predicate };
+        }
+        // Check for slice: [start:end]
+        let start = null;
+        if (!this.check(TokenType.COLON) && !this.check(TokenType.RBRACKET)) {
+            start = this.parseExpression();
+        }
+        if (this.match(TokenType.COLON)) {
+            let end = null;
+            if (!this.check(TokenType.RBRACKET)) {
+                end = this.parseExpression();
+            }
+            this.consume(TokenType.RBRACKET, 'Expected "]" after slice');
+            return { type: 'SliceAccess', object, sliceStart: start, sliceEnd: end };
+        }
+        // Regular index access
+        this.consume(TokenType.RBRACKET, 'Expected "]" after index');
+        if (!start) {
+            // Safety fallback - shouldn't reach here since [] is handled above
+            return { type: 'SpreadAccess', object };
+        }
+        return { type: 'IndexAccess', object, index: start, optional };
+    }
+    parseCallExpression(callee) {
+        const args = [];
+        if (!this.check(TokenType.RPAREN)) {
+            do {
+                args.push(this.parseExpression());
+            } while (this.match(TokenType.COMMA));
+        }
+        this.consume(TokenType.RPAREN, 'Expected ")" after arguments');
+        return { type: 'CallExpression', callee, arguments: args };
+    }
+    // ===========================================================================
+    // PRIMARY EXPRESSIONS
+    // ===========================================================================
+    parsePrimary() {
+        // Literals
+        if (this.match(TokenType.NUMBER)) {
+            return { type: 'NumberLiteral', value: parseFloat(this.previous().value) };
+        }
+        if (this.match(TokenType.STRING)) {
+            return { type: 'StringLiteral', value: this.previous().value };
+        }
+        if (this.match(TokenType.TEMPLATE_STRING)) {
+            return this.parseTemplateLiteral(this.previous().value);
+        }
+        if (this.match(TokenType.TRUE)) {
+            return { type: 'BooleanLiteral', value: true };
+        }
+        if (this.match(TokenType.FALSE)) {
+            return { type: 'BooleanLiteral', value: false };
+        }
+        if (this.match(TokenType.NULL)) {
+            return { type: 'NullLiteral' };
+        }
+        if (this.match(TokenType.UNDEFINED)) {
+            return { type: 'UndefinedLiteral' };
+        }
+        // Context access
+        if (this.match(TokenType.DOLLAR_DOLLAR)) {
+            this.consume(TokenType.DOT, 'Expected "." after "$$"');
+            const name = this.consume(TokenType.IDENTIFIER, 'Expected binding name');
+            return { type: 'BindingAccess', name: name.value };
+        }
+        if (this.match(TokenType.DOLLAR)) {
+            if (this.match(TokenType.DOT)) {
+                if (this.check(TokenType.IDENTIFIER)) {
+                    const name = this.advance();
+                    return { type: 'RootAccess', path: name.value };
+                }
+            }
+            return { type: 'RootAccess', path: null };
+        }
+        if (this.match(TokenType.CARET)) {
+            if (this.match(TokenType.DOT)) {
+                if (this.check(TokenType.IDENTIFIER)) {
+                    const name = this.advance();
+                    return { type: 'ParentAccess', path: name.value };
+                }
+            }
+            return { type: 'ParentAccess', path: null };
+        }
+        if (this.match(TokenType.DOT)) {
+            // In pipe object context, .field refers to pipe value (PipeContextRef)
+            if (this.inPipeObjectContext) {
+                return this.parsePipeContextAccess();
+            }
+            // In arrow function body, .field refers to the first parameter
+            // e.g., orders.find(o => .price > 10) means o.price > 10
+            if (this.arrowParamStack.length > 0) {
+                return this.parseArrowContextAccess();
+            }
+            // Otherwise, .field refers to current input (CurrentAccess)
+            if (this.check(TokenType.IDENTIFIER)) {
+                const name = this.advance();
+                return { type: 'CurrentAccess', path: name.value };
+            }
+            return { type: 'CurrentAccess', path: null };
+        }
+        // Object literal
+        if (this.match(TokenType.LBRACE)) {
+            return this.parseObjectLiteral();
+        }
+        // Array literal
+        if (this.match(TokenType.LBRACKET)) {
+            return this.parseArrayLiteral();
+        }
+        // If expression
+        if (this.match(TokenType.IF)) {
+            return this.parseIfExpression();
+        }
+        // Parenthesized expression or arrow function
+        if (this.match(TokenType.LPAREN)) {
+            return this.parseParenOrArrow();
+        }
+        // Identifier (or potential arrow function with single param)
+        if (this.match(TokenType.IDENTIFIER)) {
+            const name = this.previous().value;
+            // Check for arrow function: identifier => expr
+            if (this.match(TokenType.ARROW)) {
+                // Push param to stack so .property inside body resolves to param.property
+                this.arrowParamStack.push(name);
+                const body = this.parseExpression();
+                this.arrowParamStack.pop();
+                return {
+                    type: 'ArrowFunction',
+                    params: [{ type: 'Parameter', name }],
+                    body,
+                };
+            }
+            return { type: 'Identifier', name };
+        }
+        throw new ParseError(`Unexpected token: ${this.peek().value}`, this.peek());
+    }
+    parseTemplateLiteral(raw) {
+        const parts = [];
+        let current = '';
+        let i = 0;
+        while (i < raw.length) {
+            if (raw[i] === '$' && raw[i + 1] === '{') {
+                if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+                // Find matching closing brace
+                let braceDepth = 1;
+                const exprStart = i + 2;
+                let j = exprStart;
+                while (j < raw.length && braceDepth > 0) {
+                    if (raw[j] === '{')
+                        braceDepth++;
+                    if (raw[j] === '}')
+                        braceDepth--;
+                    j++;
+                }
+                const exprSource = raw.slice(exprStart, j - 1);
+                const exprParser = new Parser(exprSource);
+                const exprProgram = exprParser.parse();
+                if (exprProgram.expression) {
+                    parts.push(exprProgram.expression);
+                }
+                i = j;
+            }
+            else {
+                current += raw[i];
+                i++;
+            }
+        }
+        if (current) {
+            parts.push(current);
+        }
+        return { type: 'TemplateLiteral', parts };
+    }
+    parseObjectLiteral() {
+        const properties = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            // Spread property: ...expr or just ... (spread pipe context)
+            if (this.match(TokenType.SPREAD)) {
+                // In pipe context, bare ... spreads the pipe value
+                if (this.inPipeObjectContext &&
+                    (this.check(TokenType.COMMA) || this.check(TokenType.RBRACE))) {
+                    properties.push({ type: 'SpreadProperty', argument: { type: 'PipeContextRef' } });
+                }
+                else {
+                    const argument = this.parseExpression();
+                    properties.push({ type: 'SpreadProperty', argument });
+                }
+            }
+            // Computed property: [expr]: value
+            else if (this.match(TokenType.LBRACKET)) {
+                const key = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]" after computed property key');
+                this.consume(TokenType.COLON, 'Expected ":" after computed property key');
+                const value = this.parseExpression();
+                properties.push({ type: 'ComputedProperty', key, value });
+            }
+            // String key or identifier
+            else {
+                let key;
+                if (this.match(TokenType.STRING)) {
+                    key = this.previous().value;
+                }
+                else if (this.match(TokenType.IDENTIFIER)) {
+                    key = this.previous().value;
+                }
+                else {
+                    throw new ParseError('Expected property name', this.peek());
+                }
+                // Shorthand: { foo } means { foo: foo } in normal context
+                // But in pipe context: { foo } means { foo: .foo } (reference pipe value)
+                if (!this.check(TokenType.COLON)) {
+                    if (this.inPipeObjectContext) {
+                        // In pipe context, expand shorthand to reference pipe value
+                        properties.push({
+                            type: 'StandardProperty',
+                            key,
+                            value: {
+                                type: 'MemberAccess',
+                                object: { type: 'PipeContextRef' },
+                                property: key,
+                                optional: false,
+                            },
+                        });
+                    }
+                    else {
+                        properties.push({ type: 'ShorthandProperty', key });
+                    }
+                }
+                else {
+                    this.consume(TokenType.COLON, 'Expected ":" after property key');
+                    const value = this.parseExpression();
+                    properties.push({ type: 'StandardProperty', key, value });
+                }
+            }
+            if (!this.check(TokenType.RBRACE)) {
+                this.consume(TokenType.COMMA, 'Expected "," between properties');
+                // Allow trailing comma
+                if (this.check(TokenType.RBRACE))
+                    break;
+            }
+        }
+        this.consume(TokenType.RBRACE, 'Expected "}" after object literal');
+        return { type: 'ObjectLiteral', properties };
+    }
+    parseArrayLiteral() {
+        const elements = [];
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.match(TokenType.SPREAD)) {
+                const argument = this.parseExpression();
+                elements.push({ type: 'SpreadElement', argument });
+            }
+            else {
+                elements.push(this.parseExpression());
+            }
+            if (!this.check(TokenType.RBRACKET)) {
+                this.consume(TokenType.COMMA, 'Expected "," between elements');
+                // Allow trailing comma
+                if (this.check(TokenType.RBRACKET))
+                    break;
+            }
+        }
+        this.consume(TokenType.RBRACKET, 'Expected "]" after array literal');
+        return { type: 'ArrayLiteral', elements };
+    }
+    parseIfExpression() {
+        const conditions = [];
+        // First condition
+        this.consume(TokenType.LPAREN, 'Expected "(" after "if"');
+        const firstTest = this.parseExpression();
+        this.consume(TokenType.RPAREN, 'Expected ")" after condition');
+        let firstConsequent;
+        if (this.match(TokenType.LBRACE)) {
+            firstConsequent = this.parseBlockExpression();
+        }
+        else {
+            firstConsequent = this.parseExpression();
+        }
+        conditions.push({ type: 'ConditionalBranch', test: firstTest, consequent: firstConsequent });
+        // else if / else
+        let alternate = null;
+        while (this.match(TokenType.ELSE)) {
+            if (this.match(TokenType.IF)) {
+                // else if
+                this.consume(TokenType.LPAREN, 'Expected "(" after "else if"');
+                const test = this.parseExpression();
+                this.consume(TokenType.RPAREN, 'Expected ")" after condition');
+                let consequent;
+                if (this.match(TokenType.LBRACE)) {
+                    consequent = this.parseBlockExpression();
+                }
+                else {
+                    consequent = this.parseExpression();
+                }
+                conditions.push({ type: 'ConditionalBranch', test, consequent });
+            }
+            else {
+                // else
+                if (this.match(TokenType.LBRACE)) {
+                    alternate = this.parseBlockExpression();
+                }
+                else {
+                    alternate = this.parseExpression();
+                }
+                break;
+            }
+        }
+        return { type: 'IfExpression', conditions, alternate };
+    }
+    parseBlockExpression() {
+        // For now, just parse a single expression in the block
+        const expr = this.parseExpression();
+        this.consume(TokenType.RBRACE, 'Expected "}" after block');
+        return expr;
+    }
+    parseParenOrArrow() {
+        // Could be: (expr), (), (a, b) => expr
+        // Empty parens - must be arrow function with no params
+        if (this.match(TokenType.RPAREN)) {
+            this.consume(TokenType.ARROW, 'Expected "=>" after "()"');
+            // No params, so no implicit property access available
+            const body = this.parseExpression();
+            return { type: 'ArrowFunction', params: [], body };
+        }
+        // Parse first expression
+        const first = this.parseExpression();
+        // Check for comma - indicates arrow function params
+        if (this.match(TokenType.COMMA)) {
+            const params = [this.exprToParam(first)];
+            do {
+                const param = this.parseExpression();
+                params.push(this.exprToParam(param));
+            } while (this.match(TokenType.COMMA));
+            this.consume(TokenType.RPAREN, 'Expected ")" after parameters');
+            this.consume(TokenType.ARROW, 'Expected "=>" after parameters');
+            // Push first param to stack so .property inside body resolves to param.property
+            this.arrowParamStack.push(params[0].name);
+            const body = this.parseExpression();
+            this.arrowParamStack.pop();
+            return { type: 'ArrowFunction', params, body };
+        }
+        this.consume(TokenType.RPAREN, 'Expected ")"');
+        // Check for arrow
+        if (this.match(TokenType.ARROW)) {
+            const params = [this.exprToParam(first)];
+            // Push param to stack so .property inside body resolves to param.property
+            this.arrowParamStack.push(params[0].name);
+            const body = this.parseExpression();
+            this.arrowParamStack.pop();
+            return { type: 'ArrowFunction', params, body };
+        }
+        // Just a parenthesized expression
+        return first;
+    }
+    exprToParam(expr) {
+        if (expr.type === 'Identifier') {
+            return { type: 'Parameter', name: expr.name };
+        }
+        throw new ParseError('Expected parameter name', this.peek());
+    }
+    // ===========================================================================
+    // TYPE ANNOTATIONS
+    // ===========================================================================
+    parseTypeAnnotation() {
+        const type = this.parsePrimaryType();
+        // Union type: string | number
+        if (this.check(TokenType.PIPE)) {
+            const types = [type];
+            while (this.match(TokenType.PIPE)) {
+                types.push(this.parsePrimaryType());
+            }
+            return { type: 'UnionType', types };
+        }
+        return type;
+    }
+    parsePrimaryType() {
+        if (this.match(TokenType.IDENTIFIER)) {
+            const name = this.previous().value;
+            // Check for primitive types
+            if (['string', 'number', 'boolean', 'null', 'any'].includes(name)) {
+                const nonNull = this.match(TokenType.BANG);
+                return { type: 'PrimitiveType', name: name, nonNull };
+            }
+            // Array<T>
+            if (name === 'Array' && this.match(TokenType.LT)) {
+                const elementType = this.parseTypeAnnotation();
+                this.consume(TokenType.GT, 'Expected ">" after array element type');
+                return { type: 'ArrayType', elementType };
+            }
+            // Type reference
+            return { type: 'TypeReference', name };
+        }
+        // Object type: { key: type }
+        if (this.match(TokenType.LBRACE)) {
+            const properties = [];
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                const key = this.consume(TokenType.IDENTIFIER, 'Expected property name');
+                const optional = this.match(TokenType.QUESTION);
+                this.consume(TokenType.COLON, 'Expected ":" after property name');
+                const valueType = this.parseTypeAnnotation();
+                properties.push({ type: 'ObjectTypeProperty', key: key.value, valueType, optional });
+                if (!this.check(TokenType.RBRACE)) {
+                    this.consume(TokenType.COMMA, 'Expected "," between type properties');
+                }
+            }
+            this.consume(TokenType.RBRACE, 'Expected "}" after object type');
+            return { type: 'ObjectType', properties };
+        }
+        throw new ParseError('Expected type annotation', this.peek());
+    }
+    // ===========================================================================
+    // HELPER METHODS
+    // ===========================================================================
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    peekNext() {
+        if (this.current + 1 >= this.tokens.length) {
+            return this.tokens[this.tokens.length - 1]; // Return EOF
+        }
+        return this.tokens[this.current + 1];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        throw new ParseError(message, this.peek(), TokenType[type]);
+    }
+}
+export function parse(input) {
+    return new Parser(input).parse();
+}
+//# sourceMappingURL=parser.js.map