@enspirit/elo 0.9.0

package/dist/src/parser.js

@@ -0,0 +1,1266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+exports.parse = parse;
+const ast_1 = require("./ast");
+class Lexer {
+    constructor(input) {
+        this.position = 0;
+        this.line = 1;
+        this.column = 1;
+        this.input = input;
+        this.current = input[0] || '';
+    }
+    saveState() {
+        return { position: this.position, current: this.current, line: this.line, column: this.column };
+    }
+    restoreState(state) {
+        this.position = state.position;
+        this.current = state.current;
+        this.line = state.line;
+        this.column = state.column;
+    }
+    advance() {
+        // Track line/column before moving
+        if (this.current === '\n') {
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        this.position++;
+        this.current = this.position < this.input.length ? this.input[this.position] : '';
+    }
+    skipWhitespace() {
+        while (this.current) {
+            // Skip whitespace
+            if (/\s/.test(this.current)) {
+                this.advance();
+                continue;
+            }
+            // Skip comments (# to end of line)
+            if (this.current === '#') {
+                this.skipComment();
+                continue;
+            }
+            break;
+        }
+    }
+    skipComment() {
+        // Skip everything until end of line or end of input
+        while (this.current && this.current !== '\n') {
+            this.advance();
+        }
+        // Skip the newline itself if present
+        if (this.current === '\n') {
+            this.advance();
+        }
+    }
+    readNumber() {
+        let num = '';
+        let hasDot = false;
+        while (this.current && /[0-9.]/.test(this.current)) {
+            // Stop before consuming '.' if it's part of '..' or '...' range operator
+            if (this.current === '.' && this.peek() === '.') {
+                break;
+            }
+            // Only allow one decimal point, and only if followed by a digit
+            if (this.current === '.') {
+                if (hasDot) {
+                    // Already have a decimal point, stop here
+                    break;
+                }
+                // Check if the next char is a digit - if not, this dot starts a new token
+                if (!/[0-9]/.test(this.peek())) {
+                    break;
+                }
+                hasDot = true;
+            }
+            num += this.current;
+            this.advance();
+        }
+        return num;
+    }
+    readIdentifier() {
+        let id = '';
+        while (this.current && /[a-zA-Z_0-9]/.test(this.current)) {
+            id += this.current;
+            this.advance();
+        }
+        return id;
+    }
+    peek() {
+        return this.position + 1 < this.input.length ? this.input[this.position + 1] : '';
+    }
+    readStringContent() {
+        let str = '';
+        while (this.current && this.current !== '"') {
+            str += this.current;
+            this.advance();
+        }
+        return str;
+    }
+    readSingleQuotedString() {
+        let str = '';
+        while (this.current && this.current !== "'") {
+            // Handle escape sequences
+            if (this.current === '\\' && this.peek() === "'") {
+                this.advance(); // skip backslash
+                str += "'";
+                this.advance();
+            }
+            else if (this.current === '\\' && this.peek() === '\\') {
+                this.advance(); // skip first backslash
+                str += '\\';
+                this.advance();
+            }
+            else {
+                str += this.current;
+                this.advance();
+            }
+        }
+        return str;
+    }
+    readDateOrDateTime() {
+        // Read ISO8601 date or datetime: 2024-01-15 or 2024-01-15T10:30:00.123Z
+        let dateStr = '';
+        // Read YYYY-MM-DD part
+        while (this.current && /[0-9\-]/.test(this.current)) {
+            dateStr += this.current;
+            this.advance();
+        }
+        // Check if there's a time part (T)
+        if (this.current === 'T') {
+            dateStr += this.current;
+            this.advance();
+            // Read time part: HH:MM:SS
+            while (this.current && /[0-9:]/.test(this.current)) {
+                dateStr += this.current;
+                this.advance();
+            }
+            // Optional fractional seconds (.123)
+            const frac = this.current;
+            if (frac === '.') {
+                dateStr += frac;
+                this.advance();
+                while (this.current && /[0-9]/.test(this.current)) {
+                    dateStr += this.current;
+                    this.advance();
+                }
+            }
+            // Optional timezone (Z or +/-HH:MM)
+            const cur = this.current;
+            if (cur === 'Z') {
+                dateStr += cur;
+                this.advance();
+            }
+            else if (cur === '+' || cur === '-') {
+                dateStr += cur;
+                this.advance();
+                while (this.current && /[0-9:]/.test(this.current)) {
+                    dateStr += this.current;
+                    this.advance();
+                }
+            }
+        }
+        return dateStr;
+    }
+    readDuration() {
+        // Read ISO8601 duration: P1D, PT1H30M, P1Y2M3DT4H5M6S, P2W, etc.
+        // Date components (Y, M, W, D) come before T
+        // Time components (H, M, S) must come after T
+        let duration = '';
+        duration += this.current; // P
+        this.advance();
+        let seenT = false;
+        // Read date part (Y, M, W, D) and/or time part (T followed by H, M, S)
+        while (this.current && /[0-9YMWDTHMS.]/.test(this.current)) {
+            const char = this.current;
+            // Track when we see T (time separator)
+            if (char === 'T') {
+                seenT = true;
+            }
+            // H and S are only valid after T (time components)
+            // M after T means minutes, M before T means months
+            if ((char === 'H' || char === 'S') && !seenT) {
+                // Invalid: H or S without T prefix - stop reading duration here
+                break;
+            }
+            duration += char;
+            this.advance();
+        }
+        return duration;
+    }
+    nextToken() {
+        this.skipWhitespace();
+        if (!this.current) {
+            return { type: 'EOF', value: '', position: this.position, line: this.line, column: this.column };
+        }
+        const pos = this.position;
+        const line = this.line;
+        const col = this.column;
+        // Numbers
+        if (/[0-9]/.test(this.current)) {
+            return { type: 'NUMBER', value: this.readNumber(), position: pos, line, column: col };
+        }
+        // Date/DateTime literals: D2024-01-15 or D2024-01-15T10:30:00Z
+        if (this.current === 'D') {
+            const nextChar = this.peek();
+            if (/[0-9]/.test(nextChar)) {
+                // Date or DateTime literal starting with D
+                this.advance(); // skip 'D'
+                const dateTimeStr = this.readDateOrDateTime();
+                // Distinguish between DATE and DATETIME based on presence of 'T'
+                if (dateTimeStr.includes('T')) {
+                    return { type: 'DATETIME', value: dateTimeStr, position: pos, line, column: col };
+                }
+                else {
+                    return { type: 'DATE', value: dateTimeStr, position: pos, line, column: col };
+                }
+            }
+        }
+        // ISO8601 Duration: P1D, PT1H30M, P1Y2M3D, etc.
+        if (this.current === 'P') {
+            // Save state in case this isn't actually a duration
+            const savedState = this.saveState();
+            const durationStr = this.readDuration();
+            if (durationStr.length > 1) {
+                return { type: 'DURATION', value: durationStr, position: pos, line, column: col };
+            }
+            // Not a valid duration, restore state and continue to identifier parsing
+            this.restoreState(savedState);
+        }
+        // Single-quoted strings: 'hello world'
+        if (this.current === "'") {
+            this.advance(); // skip opening quote
+            const str = this.readSingleQuotedString();
+            this.advance(); // skip closing quote
+            return { type: 'STRING', value: str, position: pos, line, column: col };
+        }
+        // Identifiers and keywords (true, false, let, in, NOW, TODAY, TOMORROW, YESTERDAY)
+        if (/[a-zA-Z_]/.test(this.current)) {
+            const id = this.readIdentifier();
+            if (id === 'true' || id === 'false') {
+                return { type: 'BOOLEAN', value: id, position: pos, line, column: col };
+            }
+            if (id === 'null') {
+                return { type: 'NULL', value: id, position: pos, line, column: col };
+            }
+            if (id === 'let') {
+                return { type: 'LET', value: id, position: pos, line, column: col };
+            }
+            if (id === 'in') {
+                return { type: 'IN', value: id, position: pos, line, column: col };
+            }
+            if (id === 'if') {
+                return { type: 'IF', value: id, position: pos, line, column: col };
+            }
+            if (id === 'then') {
+                return { type: 'THEN', value: id, position: pos, line, column: col };
+            }
+            if (id === 'else') {
+                return { type: 'ELSE', value: id, position: pos, line, column: col };
+            }
+            if (id === 'and') {
+                return { type: 'AND', value: id, position: pos, line, column: col };
+            }
+            if (id === 'or') {
+                return { type: 'OR', value: id, position: pos, line, column: col };
+            }
+            if (id === 'not') {
+                return { type: 'NOT', value: id, position: pos, line, column: col };
+            }
+            if (id === 'fn') {
+                return { type: 'FN', value: id, position: pos, line, column: col };
+            }
+            // Uppercase identifiers: types, selectors, temporal keywords
+            if (/^[A-Z]/.test(id)) {
+                return { type: 'UPPER_IDENTIFIER', value: id, position: pos, line, column: col };
+            }
+            // Lowercase identifiers: user variables
+            return { type: 'IDENTIFIER', value: id, position: pos, line, column: col };
+        }
+        // Multi-character operators
+        const char = this.current;
+        const next = this.peek();
+        // Two-character operators
+        if (char === '<' && next === '=') {
+            this.advance();
+            this.advance();
+            return { type: 'LTE', value: '<=', position: pos, line, column: col };
+        }
+        if (char === '>' && next === '=') {
+            this.advance();
+            this.advance();
+            return { type: 'GTE', value: '>=', position: pos, line, column: col };
+        }
+        if (char === '=') {
+            if (next === '=') {
+                this.advance();
+                this.advance();
+                return { type: 'EQ', value: '==', position: pos, line, column: col };
+            }
+            // Single = is ASSIGN
+            this.advance();
+            return { type: 'ASSIGN', value: '=', position: pos, line, column: col };
+        }
+        if (char === '!' && next === '=') {
+            this.advance();
+            this.advance();
+            return { type: 'NEQ', value: '!=', position: pos, line, column: col };
+        }
+        if (char === '&' && next === '&') {
+            this.advance();
+            this.advance();
+            return { type: 'AND', value: '&&', position: pos, line, column: col };
+        }
+        if (char === '|') {
+            if (next === '>') {
+                // Pipe operator for chaining: a |> f(b)
+                this.advance();
+                this.advance();
+                return { type: 'PIPE_OP', value: '|>', position: pos, line, column: col };
+            }
+            if (next === '|') {
+                this.advance();
+                this.advance();
+                return { type: 'OR', value: '||', position: pos, line, column: col };
+            }
+            // Single pipe for predicate syntax: fn( x | body )
+            this.advance();
+            return { type: 'PIPE', value: '|', position: pos, line, column: col };
+        }
+        // Arrow for lambda syntax: fn( x ~> body )
+        if (char === '~' && next === '>') {
+            this.advance();
+            this.advance();
+            return { type: 'ARROW', value: '~>', position: pos, line, column: col };
+        }
+        // Range operators: .. (inclusive) and ... (exclusive)
+        if (char === '.' && next === '.') {
+            this.advance();
+            this.advance();
+            if (this.current === '.') {
+                this.advance();
+                return { type: 'RANGE_EXCL', value: '...', position: pos, line, column: col };
+            }
+            return { type: 'RANGE_INCL', value: '..', position: pos, line, column: col };
+        }
+        // Single-character operators
+        this.advance();
+        switch (char) {
+            case '+': return { type: 'PLUS', value: char, position: pos, line, column: col };
+            case '-': return { type: 'MINUS', value: char, position: pos, line, column: col };
+            case '*': return { type: 'STAR', value: char, position: pos, line, column: col };
+            case '/': return { type: 'SLASH', value: char, position: pos, line, column: col };
+            case '%': return { type: 'PERCENT', value: char, position: pos, line, column: col };
+            case '^': return { type: 'CARET', value: char, position: pos, line, column: col };
+            case '(': return { type: 'LPAREN', value: char, position: pos, line, column: col };
+            case ')': return { type: 'RPAREN', value: char, position: pos, line, column: col };
+            case '{': return { type: 'LBRACE', value: char, position: pos, line, column: col };
+            case '}': return { type: 'RBRACE', value: char, position: pos, line, column: col };
+            case '[': return { type: 'LBRACKET', value: char, position: pos, line, column: col };
+            case ']': return { type: 'RBRACKET', value: char, position: pos, line, column: col };
+            case ',': return { type: 'COMMA', value: char, position: pos, line, column: col };
+            case ':': return { type: 'COLON', value: char, position: pos, line, column: col };
+            case '?': return { type: 'QUESTION', value: char, position: pos, line, column: col };
+            case '.':
+                return { type: 'DOT', value: char, position: pos, line, column: col };
+            case '<': return { type: 'LT', value: char, position: pos, line, column: col };
+            case '>': return { type: 'GT', value: char, position: pos, line, column: col };
+            case '!': return { type: 'NOT', value: char, position: pos, line, column: col };
+            default:
+                throw new Error(`Unexpected character '${char}' at line ${line}, column ${col}`);
+        }
+    }
+}
+const DEFAULT_MAX_DEPTH = 100;
+class Parser {
+    constructor(input, options = {}) {
+        this.depth = 0;
+        this.lexer = new Lexer(input);
+        this.currentToken = this.lexer.nextToken();
+        this.maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    }
+    checkDepth() {
+        if (this.depth > this.maxDepth) {
+            throw new Error(`Maximum expression depth exceeded (${this.maxDepth})`);
+        }
+    }
+    saveState() {
+        return {
+            lexerState: this.lexer.saveState(),
+            currentToken: { ...this.currentToken },
+            depth: this.depth
+        };
+    }
+    restoreState(state) {
+        this.lexer.restoreState(state.lexerState);
+        this.currentToken = state.currentToken;
+        this.depth = state.depth;
+    }
+    formatLocation(token) {
+        return `line ${token.line}, column ${token.column}`;
+    }
+    eat(tokenType) {
+        if (this.currentToken.type === tokenType) {
+            this.currentToken = this.lexer.nextToken();
+        }
+        else {
+            throw new Error(`Expected ${tokenType} but got ${this.currentToken.type} at ${this.formatLocation(this.currentToken)}`);
+        }
+    }
+    primary() {
+        const token = this.currentToken;
+        if (token.type === 'NUMBER') {
+            this.eat('NUMBER');
+            return (0, ast_1.literal)(parseFloat(token.value));
+        }
+        if (token.type === 'BOOLEAN') {
+            this.eat('BOOLEAN');
+            return (0, ast_1.literal)(token.value === 'true');
+        }
+        if (token.type === 'NULL') {
+            this.eat('NULL');
+            return (0, ast_1.nullLiteral)();
+        }
+        if (token.type === 'DATE') {
+            this.eat('DATE');
+            return (0, ast_1.dateLiteral)(token.value);
+        }
+        if (token.type === 'DATETIME') {
+            this.eat('DATETIME');
+            return (0, ast_1.dateTimeLiteral)(token.value);
+        }
+        if (token.type === 'DURATION') {
+            this.eat('DURATION');
+            return (0, ast_1.durationLiteral)(token.value);
+        }
+        if (token.type === 'STRING') {
+            this.eat('STRING');
+            return (0, ast_1.stringLiteral)(token.value);
+        }
+        // Uppercase identifiers: temporal keywords, types, selectors
+        if (token.type === 'UPPER_IDENTIFIER') {
+            const name = token.value;
+            this.eat('UPPER_IDENTIFIER');
+            // Check if this is a temporal keyword
+            const temporalKeywords = ['NOW', 'TODAY', 'TOMORROW', 'YESTERDAY',
+                'SOD', 'EOD', 'SOW', 'EOW', 'SOM', 'EOM', 'SOQ', 'EOQ', 'SOY', 'EOY',
+                'BOT', 'EOT'];
+            if (temporalKeywords.includes(name)) {
+                return (0, ast_1.temporalKeyword)(name);
+            }
+            // Check if this is a function call (uppercase functions like Type selectors)
+            if (this.currentToken.type === 'LPAREN') {
+                this.eat('LPAREN');
+                const args = [];
+                const tok = this.currentToken;
+                if (tok.type !== 'RPAREN') {
+                    args.push(this.expr());
+                    while (this.currentToken.type === 'COMMA') {
+                        this.eat('COMMA');
+                        args.push(this.expr());
+                    }
+                }
+                this.eat('RPAREN');
+                return (0, ast_1.functionCall)(name, args);
+            }
+            throw new Error(`Unknown uppercase identifier '${name}' at ${this.formatLocation(token)}`);
+        }
+        // Lowercase identifiers: user variables, function calls
+        if (token.type === 'IDENTIFIER') {
+            const name = token.value;
+            this.eat('IDENTIFIER');
+            // Lambda sugar: x ~> body (single parameter only)
+            // Body parsed at pipe() level to stop before == and other low-precedence operators
+            // Use fn(x ~> body) syntax for bodies containing == comparisons
+            if (this.currentToken.type === 'ARROW') {
+                this.eat('ARROW');
+                const body = this.pipe();
+                return (0, ast_1.lambda)([name], body);
+            }
+            // Check if this is a function call
+            if (this.currentToken.type === 'LPAREN') {
+                this.eat('LPAREN');
+                const args = [];
+                // Parse arguments
+                // After eat(), currentToken changes - use type assertion to tell TypeScript
+                const tok = this.currentToken;
+                if (tok.type !== 'RPAREN') {
+                    args.push(this.expr());
+                    while (this.currentToken.type === 'COMMA') {
+                        this.eat('COMMA');
+                        args.push(this.expr());
+                    }
+                }
+                this.eat('RPAREN');
+                return (0, ast_1.functionCall)(name, args);
+            }
+            // Otherwise, it's a variable
+            return (0, ast_1.variable)(name);
+        }
+        if (token.type === 'LPAREN') {
+            this.eat('LPAREN');
+            const expr = this.expr();
+            this.eat('RPAREN');
+            return expr;
+        }
+        // Handle let expressions (can appear anywhere an expression is expected)
+        if (token.type === 'LET') {
+            return this.letExpr();
+        }
+        // Handle if expressions (can appear anywhere an expression is expected)
+        if (token.type === 'IF') {
+            return this.ifExprParse();
+        }
+        // Handle lambda expressions: fn( x | body ) or fn( x, y | body )
+        if (token.type === 'FN') {
+            return this.lambdaParse();
+        }
+        // Handle object literals: {key: value, ...}
+        if (token.type === 'LBRACE') {
+            return this.objectParse();
+        }
+        // Handle array literals: [expr, expr, ...]
+        if (token.type === 'LBRACKET') {
+            return this.arrayParse();
+        }
+        // Handle datapath literals: .x.y.z
+        if (token.type === 'DOT') {
+            return this.datapathParse();
+        }
+        throw new Error(`Unexpected token ${token.type} at ${this.formatLocation(token)}`);
+    }
+    postfix() {
+        let expr = this.primary();
+        // Handle member access (dot notation) and function application
+        while (this.currentToken.type === 'DOT' || this.currentToken.type === 'LPAREN') {
+            if (this.currentToken.type === 'DOT') {
+                this.eat('DOT');
+                const property = this.currentToken.value;
+                this.eat('IDENTIFIER');
+                expr = (0, ast_1.memberAccess)(expr, property);
+            }
+            else {
+                // Function application: expr(args)
+                this.eat('LPAREN');
+                const args = [];
+                // After eat(), currentToken changes - use type assertion to tell TypeScript
+                if (this.currentToken.type !== 'RPAREN') {
+                    args.push(this.expr());
+                    while (this.currentToken.type === 'COMMA') {
+                        this.eat('COMMA');
+                        args.push(this.expr());
+                    }
+                }
+                this.eat('RPAREN');
+                expr = (0, ast_1.apply)(expr, args);
+            }
+        }
+        return expr;
+    }
+    unary() {
+        if (this.currentToken.type === 'NOT') {
+            this.eat('NOT');
+            return (0, ast_1.unary)('!', this.unary());
+        }
+        if (this.currentToken.type === 'PLUS') {
+            this.eat('PLUS');
+            return (0, ast_1.unary)('+', this.unary());
+        }
+        if (this.currentToken.type === 'MINUS') {
+            this.eat('MINUS');
+            return (0, ast_1.unary)('-', this.unary());
+        }
+        return this.postfix();
+    }
+    power() {
+        let node = this.unary();
+        // Right-associative
+        if (this.currentToken.type === 'CARET') {
+            this.eat('CARET');
+            node = (0, ast_1.binary)('^', node, this.power());
+        }
+        return node;
+    }
+    factor() {
+        let node = this.power();
+        while (['STAR', 'SLASH', 'PERCENT'].includes(this.currentToken.type)) {
+            const token = this.currentToken;
+            if (token.type === 'STAR') {
+                this.eat('STAR');
+                node = (0, ast_1.binary)('*', node, this.power());
+            }
+            else if (token.type === 'SLASH') {
+                this.eat('SLASH');
+                node = (0, ast_1.binary)('/', node, this.power());
+            }
+            else if (token.type === 'PERCENT') {
+                this.eat('PERCENT');
+                node = (0, ast_1.binary)('%', node, this.power());
+            }
+        }
+        return node;
+    }
+    term() {
+        return this.factor();
+    }
+    addition() {
+        let node = this.term();
+        while (['PLUS', 'MINUS'].includes(this.currentToken.type)) {
+            const token = this.currentToken;
+            if (token.type === 'PLUS') {
+                this.eat('PLUS');
+                node = (0, ast_1.binary)('+', node, this.term());
+            }
+            else if (token.type === 'MINUS') {
+                this.eat('MINUS');
+                node = (0, ast_1.binary)('-', node, this.term());
+            }
+        }
+        return node;
+    }
+    comparison() {
+        let node = this.addition();
+        // Handle range membership: expr in expr..expr or expr in expr...expr
+        // Also handles: expr not in expr..expr (negated range membership)
+        // Use speculative parsing - if no range operator found after IN, restore state
+        if (this.currentToken.type === 'IN') {
+            const result = this.tryParseRangeMembership(node, false);
+            if (result !== null) {
+                return result;
+            }
+            // Not a range expression, continue with normal parsing
+        }
+        // Handle "not in" for negated range membership
+        if (this.currentToken.type === 'NOT') {
+            const result = this.tryParseRangeMembership(node, true);
+            if (result !== null) {
+                return result;
+            }
+            // Not a range expression, continue with normal parsing
+        }
+        while (['LT', 'GT', 'LTE', 'GTE'].includes(this.currentToken.type)) {
+            const token = this.currentToken;
+            if (token.type === 'LT') {
+                this.eat('LT');
+                node = (0, ast_1.binary)('<', node, this.addition());
+            }
+            else if (token.type === 'GT') {
+                this.eat('GT');
+                node = (0, ast_1.binary)('>', node, this.addition());
+            }
+            else if (token.type === 'LTE') {
+                this.eat('LTE');
+                node = (0, ast_1.binary)('<=', node, this.addition());
+            }
+            else if (token.type === 'GTE') {
+                this.eat('GTE');
+                node = (0, ast_1.binary)('>=', node, this.addition());
+            }
+        }
+        return node;
+    }
+    equality() {
+        let node = this.comparison();
+        while (['EQ', 'NEQ'].includes(this.currentToken.type)) {
+            const token = this.currentToken;
+            if (token.type === 'EQ') {
+                this.eat('EQ');
+                node = (0, ast_1.binary)('==', node, this.comparison());
+            }
+            else if (token.type === 'NEQ') {
+                this.eat('NEQ');
+                node = (0, ast_1.binary)('!=', node, this.comparison());
+            }
+        }
+        return node;
+    }
+    logical_and() {
+        let node = this.alternative();
+        while (this.currentToken.type === 'AND') {
+            this.eat('AND');
+            node = (0, ast_1.binary)('&&', node, this.alternative());
+        }
+        return node;
+    }
+    /**
+     * Parse alternative expressions: a | b | c
+     * Returns first non-null value, left-to-right evaluation.
+     */
+    alternative() {
+        let node = this.equality();
+        const alternatives = [node];
+        while (this.currentToken.type === 'PIPE') {
+            this.eat('PIPE');
+            alternatives.push(this.equality());
+        }
+        if (alternatives.length === 1) {
+            return node;
+        }
+        return (0, ast_1.alternative)(alternatives);
+    }
+    logical_or() {
+        let node = this.logical_and();
+        while (this.currentToken.type === 'OR') {
+            this.eat('OR');
+            node = (0, ast_1.binary)('||', node, this.logical_and());
+        }
+        return node;
+    }
+    /**
+     * Parse pipe expressions: a |> f(b) |> g(c) or a |> f |> g
+     * Desugars to: g(f(a, b), c) or g(f(a))
+     * Left-associative, lowest precedence (below logical_or)
+     * Parentheses are optional: a |> f is equivalent to a |> f()
+     */
+    pipe() {
+        let node = this.logical_or();
+        while (this.currentToken.type === 'PIPE_OP') {
+            this.eat('PIPE_OP');
+            // Right side must be an identifier (function name) or uppercase (type name)
+            const tok = this.currentToken;
+            if (tok.type !== 'IDENTIFIER' && tok.type !== 'UPPER_IDENTIFIER') {
+                throw new Error(`Expected function name after |> at ${this.formatLocation(tok)}`);
+            }
+            const funcName = tok.value;
+            this.eat(tok.type);
+            const args = [node]; // Left side becomes first argument
+            // Parentheses are optional - if present, parse additional arguments
+            const tok2 = this.currentToken;
+            if (tok2.type === 'LPAREN') {
+                this.eat('LPAREN');
+                // Parse additional arguments
+                if (this.currentToken.type !== 'RPAREN') {
+                    args.push(this.expr());
+                    while (this.currentToken.type === 'COMMA') {
+                        this.eat('COMMA');
+                        args.push(this.expr());
+                    }
+                }
+                this.eat('RPAREN');
+            }
+            node = (0, ast_1.functionCall)(funcName, args);
+        }
+        return node;
+    }
+    /**
+     * Try to parse range membership: expr in expr..expr or expr in expr...expr
+     * Also handles: expr not in expr..expr (when negated is true)
+     * Returns null if this is not a range expression (e.g., it's 'in' from 'let...in')
+     */
+    tryParseRangeMembership(node, negated) {
+        const savedState = this.saveState();
+        // For "not in", consume NOT first, then expect IN
+        if (negated) {
+            this.eat('NOT');
+            if (this.currentToken.type !== 'IN') {
+                this.restoreState(savedState);
+                return null;
+            }
+        }
+        this.eat('IN');
+        const rangeStart = this.addition();
+        let inclusive;
+        if (this.currentToken.type === 'RANGE_INCL') {
+            this.eat('RANGE_INCL');
+            inclusive = true;
+        }
+        else if (this.currentToken.type === 'RANGE_EXCL') {
+            this.eat('RANGE_EXCL');
+            inclusive = false;
+        }
+        else {
+            // No range operator found - this is not a range expression
+            // Restore state and return null
+            this.restoreState(savedState);
+            return null;
+        }
+        const rangeEnd = this.addition();
+        const rangeExpr = this.desugarRangeMembership(node, rangeStart, rangeEnd, inclusive);
+        // Wrap in NOT if negated
+        if (negated) {
+            return (0, ast_1.unary)('!', rangeExpr);
+        }
+        return rangeExpr;
+    }
+    /**
+     * Desugar range membership expression.
+     * `value in start..end` becomes `value >= start and value <= end`
+     * `value in start...end` becomes `value >= start and value < end`
+     *
+     * For complex expressions, wraps in let to avoid multiple evaluation.
+     */
+    desugarRangeMembership(value, start, end, inclusive) {
+        const isSimple = (e) => {
+            return e.type === 'literal' || e.type === 'variable' ||
+                e.type === 'date' || e.type === 'datetime' ||
+                e.type === 'temporal_keyword';
+        };
+        const endOp = inclusive ? '<=' : '<';
+        if (isSimple(value) && isSimple(start) && isSimple(end)) {
+            // Direct expansion for simple expressions
+            return (0, ast_1.binary)('&&', (0, ast_1.binary)('>=', value, start), (0, ast_1.binary)(endOp, value, end));
+        }
+        // Wrap in let to avoid multiple evaluation
+        return (0, ast_1.letExpr)([
+            { name: '_v', value },
+            { name: '_lo', value: start },
+            { name: '_hi', value: end }
+        ], (0, ast_1.binary)('&&', (0, ast_1.binary)('>=', (0, ast_1.variable)('_v'), (0, ast_1.variable)('_lo')), (0, ast_1.binary)(endOp, (0, ast_1.variable)('_v'), (0, ast_1.variable)('_hi'))));
+    }
+    letExpr() {
+        this.eat('LET');
+        // Check if this is a type definition (uppercase identifier)
+        if (this.currentToken.type === 'UPPER_IDENTIFIER') {
+            return this.typeDefExpr();
+        }
+        const bindings = [];
+        // Parse first binding
+        const firstName = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        this.eat('ASSIGN');
+        // Binding values parsed at logical_or level (prevents unparenthesized nested let in bindings)
+        const firstValue = this.logical_or();
+        bindings.push({ name: firstName, value: firstValue });
+        // Parse additional bindings
+        while (this.currentToken.type === 'COMMA') {
+            this.eat('COMMA');
+            const name = this.currentToken.value;
+            this.eat('IDENTIFIER');
+            this.eat('ASSIGN');
+            const value = this.logical_or();
+            bindings.push({ name, value });
+        }
+        this.eat('IN');
+        const body = this.expr(); // Body can be any expression including nested let
+        return (0, ast_1.letExpr)(bindings, body);
+    }
+    /**
+     * Parse a type definition: let Person = { name: String, age: Int } in body
+     * Called after 'let' when we see an UPPER_IDENTIFIER
+     * Supports multiple bindings: let Person = {...}, Persons = [Person] in body
+     */
+    typeDefExpr() {
+        const typeName = this.currentToken.value;
+        this.eat('UPPER_IDENTIFIER');
+        this.eat('ASSIGN');
+        const typeExpr = this.typeExpr();
+        // Check for additional bindings
+        if (this.currentToken.type === 'COMMA') {
+            this.eat('COMMA');
+            // Next binding could be another type def or a value binding
+            // Use type assertion since eat() updates currentToken but TS doesn't track this
+            const nextTokenType = this.currentToken.type;
+            if (nextTokenType === 'UPPER_IDENTIFIER') {
+                // Another type definition - recurse
+                const body = this.typeDefExpr();
+                return (0, ast_1.typeDef)(typeName, typeExpr, body);
+            }
+            else {
+                // Value binding - parse remaining as let bindings
+                const body = this.parseLetBindingsAfterComma();
+                return (0, ast_1.typeDef)(typeName, typeExpr, body);
+            }
+        }
+        this.eat('IN');
+        const body = this.expr();
+        return (0, ast_1.typeDef)(typeName, typeExpr, body);
+    }
+    /**
+     * Parse remaining let bindings after a comma (when mixing type and value bindings)
+     * Returns a LetExpr with the remaining bindings
+     */
+    parseLetBindingsAfterComma() {
+        const bindings = [];
+        // Parse first binding after comma
+        const firstName = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        this.eat('ASSIGN');
+        const firstValue = this.logical_or();
+        bindings.push({ name: firstName, value: firstValue });
+        // Parse additional bindings
+        while (this.currentToken.type === 'COMMA') {
+            this.eat('COMMA');
+            const name = this.currentToken.value;
+            this.eat('IDENTIFIER');
+            this.eat('ASSIGN');
+            const value = this.logical_or();
+            bindings.push({ name, value });
+        }
+        this.eat('IN');
+        const body = this.expr();
+        return (0, ast_1.letExpr)(bindings, body);
+    }
+    /**
+     * Parse a type expression: String, Int|String, Int(i | i > 0), [Int], { prop: TypeExpr, ... }
+     * Handles union types: Int|String|Bool
+     */
+    typeExpr() {
+        const first = this.typeExprPrimary();
+        // Check for union type: Type|Type|...
+        if (this.currentToken.type === 'PIPE') {
+            const types = [first];
+            while (this.currentToken.type === 'PIPE') {
+                this.eat('PIPE');
+                types.push(this.typeExprPrimary());
+            }
+            return (0, ast_1.unionType)(types);
+        }
+        return first;
+    }
+    /**
+     * Parse a primary type expression (without union)
+     */
+    typeExprPrimary() {
+        // Check for '.' (Any type shorthand)
+        if (this.currentToken.type === 'DOT') {
+            this.eat('DOT');
+            return (0, ast_1.typeRef)('Any');
+        }
+        // Check for array type: [TypeExpr]
+        if (this.currentToken.type === 'LBRACKET') {
+            this.eat('LBRACKET');
+            const elementType = this.typeExpr();
+            this.eat('RBRACKET');
+            return (0, ast_1.arrayType)(elementType);
+        }
+        // Check for object schema: { prop: Type, ... }
+        if (this.currentToken.type === 'LBRACE') {
+            return this.typeSchemaExpr();
+        }
+        // Must be a type name (UPPER_IDENTIFIER)
+        if (this.currentToken.type !== 'UPPER_IDENTIFIER') {
+            throw new Error(`Expected type name, '[', or '{' at ${this.formatLocation(this.currentToken)}, got ${this.currentToken.type}`);
+        }
+        const name = this.currentToken.value;
+        this.eat('UPPER_IDENTIFIER');
+        const baseType = (0, ast_1.typeRef)(name);
+        // Check for subtype constraint: Int(i | i > 0)
+        if (this.currentToken.type === 'LPAREN') {
+            return this.subtypeConstraintExpr(baseType);
+        }
+        return baseType;
+    }
+    /**
+     * Parse a subtype constraint: Int(i | i > 0)
+     * Called after the base type has been parsed, when we see '('
+     */
+    subtypeConstraintExpr(baseType) {
+        this.eat('LPAREN');
+        // Parse variable name
+        const varName = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        // Expect '|' separator
+        this.eat('PIPE');
+        // Parse constraint expression
+        const constraint = this.expr();
+        this.eat('RPAREN');
+        return (0, ast_1.subtypeConstraint)(baseType, varName, constraint);
+    }
+    /**
+     * Parse a type schema: { name: String, age: Int, nickname :? String, ... } or { name: String, ...: Int }
+     * extras:
+     * - { x: Int } - closed, no extra attrs allowed
+     * - { x: Int, ... } - ignored, extra attrs allowed but not included
+     * - { x: Int, ...: String } - typed, extra attrs must match type
+     */
+    typeSchemaExpr() {
+        this.eat('LBRACE');
+        const properties = [];
+        let extras = undefined;
+        // Handle empty schema
+        if (this.currentToken.type === 'RBRACE') {
+            this.eat('RBRACE');
+            return (0, ast_1.typeSchema)(properties, extras);
+        }
+        // Handle spread only: { ... } or { ...: Type }
+        if (this.currentToken.type === 'RANGE_EXCL') {
+            this.eat('RANGE_EXCL');
+            if (this.currentToken.type === 'COLON') {
+                this.eat('COLON');
+                extras = this.typeExpr();
+            }
+            else {
+                extras = 'ignored';
+            }
+            this.eat('RBRACE');
+            return (0, ast_1.typeSchema)(properties, extras);
+        }
+        // Parse first property
+        const firstName = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        this.eat('COLON');
+        const firstOptional = this.currentToken.type === 'QUESTION';
+        if (firstOptional)
+            this.eat('QUESTION');
+        const firstType = this.typeExpr();
+        properties.push({ key: firstName, typeExpr: firstType, optional: firstOptional || undefined });
+        // Parse additional properties (commas are optional, like Finitio)
+        while (true) {
+            // Consume optional comma
+            if (this.currentToken.type === 'COMMA') {
+                this.eat('COMMA');
+            }
+            // Check for spread operator: ... or ...: Type
+            if (this.currentToken.type === 'RANGE_EXCL') {
+                this.eat('RANGE_EXCL');
+                if (this.currentToken.type === 'COLON') {
+                    this.eat('COLON');
+                    extras = this.typeExpr();
+                }
+                else {
+                    extras = 'ignored';
+                }
+                break; // spread must be last
+            }
+            // Check for another property (identifier starts next property)
+            if (this.currentToken.type !== 'IDENTIFIER') {
+                break; // no more properties
+            }
+            const name = this.currentToken.value;
+            this.eat('IDENTIFIER');
+            this.eat('COLON');
+            const optional = this.currentToken.type === 'QUESTION';
+            if (optional)
+                this.eat('QUESTION');
+            const propType = this.typeExpr();
+            properties.push({ key: name, typeExpr: propType, optional: optional || undefined });
+        }
+        this.eat('RBRACE');
+        return (0, ast_1.typeSchema)(properties, extras);
+    }
+    ifExprParse() {
+        this.eat('IF');
+        const condition = this.expr();
+        this.eat('THEN');
+        const thenBranch = this.expr();
+        this.eat('ELSE');
+        const elseBranch = this.expr();
+        return (0, ast_1.ifExpr)(condition, thenBranch, elseBranch);
+    }
+    /**
+     * Parse lambda expression: fn( ~> body ) or fn( x ~> body ) or fn( x, y ~> body )
+     */
+    lambdaParse() {
+        this.eat('FN');
+        this.eat('LPAREN');
+        const params = [];
+        // Check for parameterless lambda: fn( ~> body )
+        if (this.currentToken.type !== 'ARROW') {
+            // Parse first parameter
+            const firstName = this.currentToken.value;
+            this.eat('IDENTIFIER');
+            params.push(firstName);
+            // Parse additional parameters
+            while (this.currentToken.type === 'COMMA') {
+                this.eat('COMMA');
+                const name = this.currentToken.value;
+                this.eat('IDENTIFIER');
+                params.push(name);
+            }
+        }
+        this.eat('ARROW');
+        const body = this.expr();
+        this.eat('RPAREN');
+        return (0, ast_1.lambda)(params, body);
+    }
+    /**
+     * Parse object literal: {key: value, key2: value2, ...}
+     */
+    objectParse() {
+        this.eat('LBRACE');
+        const properties = [];
+        // Handle empty object
+        if (this.currentToken.type === 'RBRACE') {
+            this.eat('RBRACE');
+            return (0, ast_1.objectLiteral)(properties);
+        }
+        // Parse first property
+        const firstName = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        this.eat('COLON');
+        const firstValue = this.expr();
+        properties.push({ key: firstName, value: firstValue });
+        // Parse additional properties
+        while (this.currentToken.type === 'COMMA') {
+            this.eat('COMMA');
+            const name = this.currentToken.value;
+            this.eat('IDENTIFIER');
+            this.eat('COLON');
+            const value = this.expr();
+            properties.push({ key: name, value });
+        }
+        this.eat('RBRACE');
+        return (0, ast_1.objectLiteral)(properties);
+    }
+    /**
+     * Parse array literal: [expr, expr, ...]
+     */
+    arrayParse() {
+        this.eat('LBRACKET');
+        const elements = [];
+        // Handle empty array
+        if (this.currentToken.type === 'RBRACKET') {
+            this.eat('RBRACKET');
+            return (0, ast_1.arrayLiteral)(elements);
+        }
+        // Parse first element
+        elements.push(this.expr());
+        // Parse additional elements
+        while (this.currentToken.type === 'COMMA') {
+            this.eat('COMMA');
+            elements.push(this.expr());
+        }
+        this.eat('RBRACKET');
+        return (0, ast_1.arrayLiteral)(elements);
+    }
+    /**
+     * Parse datapath literal: .x.y.z or .items.0.name
+     * Grammar: '.' pathSegment ('.' pathSegment)*
+     * pathSegment: IDENTIFIER | NUMBER
+     *
+     * Note: The lexer may tokenize "0.1" as a single NUMBER token when parsing
+     * consecutive numeric segments. We handle this by splitting such tokens.
+     * The lexer also treats ".0" as a NUMBER token (decimal number starting with dot).
+     */
+    datapathParse() {
+        this.eat('DOT');
+        const segments = [];
+        // Parse first segment (required) - could be IDENTIFIER or NUMBER
+        if (this.currentToken.type === 'IDENTIFIER') {
+            segments.push(this.currentToken.value);
+            this.eat('IDENTIFIER');
+        }
+        else if (this.currentToken.type === 'NUMBER') {
+            // NUMBER token might contain multiple segments (e.g., "0.1" -> [0, 1])
+            const numSegments = this.parseNumericPathSegments();
+            if (numSegments === null || numSegments.length === 0) {
+                throw new Error(`Expected identifier or number after '.' at ${this.formatLocation(this.currentToken)}`);
+            }
+            segments.push(...numSegments);
+        }
+        else {
+            throw new Error(`Expected identifier or number after '.' at ${this.formatLocation(this.currentToken)}`);
+        }
+        // Parse additional segments
+        this.parseAdditionalPathSegments(segments);
+        return (0, ast_1.dataPath)(segments);
+    }
+    /**
+     * Parse additional path segments after the first one
+     */
+    parseAdditionalPathSegments(segments) {
+        while (true) {
+            // Get a fresh reference to avoid TypeScript control flow narrowing issues
+            const token = this.currentToken;
+            if (token.type === 'DOT') {
+                this.eat('DOT');
+                // After a DOT, we expect IDENTIFIER or NUMBER
+                const nextToken = this.currentToken;
+                if (nextToken.type === 'IDENTIFIER') {
+                    segments.push(nextToken.value);
+                    this.eat('IDENTIFIER');
+                }
+                else if (nextToken.type === 'NUMBER') {
+                    const numSegments = this.parseNumericPathSegments();
+                    if (numSegments === null || numSegments.length === 0) {
+                        throw new Error(`Expected identifier or number after '.' at ${this.formatLocation(this.currentToken)}`);
+                    }
+                    segments.push(...numSegments);
+                }
+                else {
+                    throw new Error(`Expected identifier or number after '.' at ${this.formatLocation(this.currentToken)}`);
+                }
+            }
+            else if (token.type === 'NUMBER' && token.value.startsWith('.')) {
+                // Handle NUMBER tokens that start with "." (e.g., ".0" tokenized as decimal)
+                const numValue = token.value;
+                this.eat('NUMBER');
+                // Skip the leading dot and split on remaining dots
+                const withoutLeadingDot = numValue.substring(1);
+                const parts = withoutLeadingDot.split('.');
+                for (const part of parts) {
+                    if (part.length > 0) {
+                        segments.push(parseInt(part, 10));
+                    }
+                }
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Check if current token is a NUMBER that starts with a dot (e.g., ".0")
+     * This happens when the lexer treats ".0" as a decimal number
+     */
+    isDecimalNumberToken() {
+        return this.currentToken.type === 'NUMBER' && this.currentToken.value.startsWith('.');
+    }
+    /**
+     * Parse path segments from a NUMBER token.
+     * A NUMBER token like "0.1" in datapath context should become segments [0, 1].
+     * Returns the array of integer segments, or null if not a valid NUMBER.
+     */
+    parseNumericPathSegments() {
+        if (this.currentToken.type !== 'NUMBER') {
+            return null;
+        }
+        const tokenValue = this.currentToken.value;
+        this.eat('NUMBER');
+        // Split on decimal points to get individual integer segments
+        const parts = tokenValue.split('.');
+        return parts.filter(p => p.length > 0).map(p => parseInt(p, 10));
+    }
+    /**
+     * Parse a single path segment: IDENTIFIER or integer NUMBER
+     * Returns null if current token is not a valid segment.
+     */
+    parsePathSegment() {
+        if (this.currentToken.type === 'IDENTIFIER') {
+            const value = this.currentToken.value;
+            this.eat('IDENTIFIER');
+            return value;
+        }
+        else if (this.currentToken.type === 'NUMBER') {
+            const value = parseInt(this.currentToken.value, 10);
+            this.eat('NUMBER');
+            return value;
+        }
+        return null;
+    }
+    expr() {
+        this.depth++;
+        this.checkDepth();
+        try {
+            // Let and if expressions have lowest precedence
+            if (this.currentToken.type === 'LET') {
+                return this.letExpr();
+            }
+            if (this.currentToken.type === 'IF') {
+                return this.ifExprParse();
+            }
+            return this.pipe();
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    parse() {
+        const result = this.expr();
+        this.eat('EOF');
+        return result;
+    }
+}
+exports.Parser = Parser;
+/**
+ * Parse an arithmetic expression string into an AST
+ */
+function parse(input, options = {}) {
+    const parser = new Parser(input, options);
+    return parser.parse();
+}
+//# sourceMappingURL=parser.js.map