@the-trybe/formula-engine 1.0.0

package/dist/parser.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const lexer_1 = require("./lexer");
+const types_1 = require("./types");
+const errors_1 = require("./errors");
+// Operator precedence levels (higher = tighter binding)
+const PRECEDENCE = {
+    LOWEST: 1,
+    TERNARY: 2, // ? :
+    OR: 3, // || OR
+    AND: 4, // && AND
+    EQUALITY: 5, // == !=
+    COMPARISON: 6, // < > <= >=
+    TERM: 7, // + -
+    FACTOR: 8, // * / %
+    POWER: 9, // ^
+    UNARY: 10, // - ! NOT
+    CALL: 11, // function calls
+    MEMBER: 12, // . []
+};
+class Parser {
+    constructor() {
+        this.tokens = [];
+        this.current = 0;
+        this.expression = '';
+    }
+    parse(expression) {
+        this.expression = expression;
+        const lexer = new lexer_1.Lexer(expression);
+        this.tokens = lexer.tokenize();
+        this.current = 0;
+        const ast = this.parseExpression(PRECEDENCE.LOWEST);
+        if (!this.isAtEnd()) {
+            const token = this.peek();
+            throw new errors_1.UnexpectedTokenError(String(token.value), ['end of expression'], token.position);
+        }
+        return ast;
+    }
+    parseExpression(precedence) {
+        let left = this.parsePrefixExpression();
+        while (!this.isAtEnd() && precedence < this.getPrecedence()) {
+            left = this.parseInfixExpression(left);
+        }
+        return left;
+    }
+    parsePrefixExpression() {
+        const token = this.peek();
+        switch (token.type) {
+            case types_1.TokenType.NUMBER:
+                return this.parseNumber();
+            case types_1.TokenType.STRING:
+                return this.parseString();
+            case types_1.TokenType.BOOLEAN:
+                return this.parseBoolean();
+            case types_1.TokenType.NULL:
+                return this.parseNull();
+            case types_1.TokenType.VARIABLE:
+                return this.parseVariable();
+            case types_1.TokenType.CONTEXT_VAR:
+                return this.parseContextVariable();
+            case types_1.TokenType.IDENTIFIER:
+                return this.parseIdentifierOrFunctionCall();
+            case types_1.TokenType.LPAREN:
+                return this.parseGroupedExpression();
+            case types_1.TokenType.LBRACKET:
+                return this.parseArrayLiteral();
+            case types_1.TokenType.MINUS:
+            case types_1.TokenType.NOT:
+                return this.parseUnaryExpression();
+            default:
+                throw new errors_1.UnexpectedTokenError(String(token.value), ['number', 'string', 'boolean', 'null', 'variable', 'identifier', '(', '[', '-', '!'], token.position);
+        }
+    }
+    parseInfixExpression(left) {
+        const token = this.peek();
+        switch (token.type) {
+            case types_1.TokenType.PLUS:
+            case types_1.TokenType.MINUS:
+            case types_1.TokenType.MULTIPLY:
+            case types_1.TokenType.DIVIDE:
+            case types_1.TokenType.MODULO:
+            case types_1.TokenType.POWER:
+            case types_1.TokenType.EQ:
+            case types_1.TokenType.NEQ:
+            case types_1.TokenType.LT:
+            case types_1.TokenType.GT:
+            case types_1.TokenType.LTE:
+            case types_1.TokenType.GTE:
+            case types_1.TokenType.AND:
+            case types_1.TokenType.OR:
+                return this.parseBinaryExpression(left);
+            case types_1.TokenType.QUESTION:
+                return this.parseTernaryExpression(left);
+            case types_1.TokenType.DOT:
+                return this.parseMemberAccess(left);
+            case types_1.TokenType.LBRACKET:
+                return this.parseIndexAccess(left);
+            case types_1.TokenType.LPAREN:
+                // This handles the case where we have an identifier followed by (
+                // But actually this should be handled in parseIdentifierOrFunctionCall
+                return left;
+            default:
+                return left;
+        }
+    }
+    parseNumber() {
+        const token = this.advance();
+        const value = token.value;
+        if (typeof value === 'number') {
+            // It's a float
+            return {
+                type: 'NumberLiteral',
+                value: value,
+            };
+        }
+        else {
+            // It's a decimal (stored as string)
+            return {
+                type: 'DecimalLiteral',
+                value: String(value),
+                raw: String(value),
+            };
+        }
+    }
+    parseString() {
+        const token = this.advance();
+        return {
+            type: 'StringLiteral',
+            value: String(token.value),
+        };
+    }
+    parseBoolean() {
+        const token = this.advance();
+        return {
+            type: 'BooleanLiteral',
+            value: token.value === true,
+        };
+    }
+    parseNull() {
+        this.advance();
+        return {
+            type: 'NullLiteral',
+        };
+    }
+    parseVariable() {
+        const token = this.advance();
+        return {
+            type: 'VariableReference',
+            prefix: '$',
+            name: String(token.value),
+        };
+    }
+    parseContextVariable() {
+        const token = this.advance();
+        return {
+            type: 'VariableReference',
+            prefix: '@',
+            name: String(token.value),
+        };
+    }
+    parseIdentifierOrFunctionCall() {
+        const token = this.advance();
+        const name = String(token.value);
+        // Check if it's a function call
+        if (this.peek().type === types_1.TokenType.LPAREN) {
+            return this.parseFunctionCall(name);
+        }
+        // Otherwise, check for keywords AND/OR/NOT used as standalone identifiers
+        const upperName = name.toUpperCase();
+        if (upperName === 'AND' || upperName === 'OR') {
+            // These should be handled as operators, but if we reach here,
+            // it means they were used in an invalid context
+            throw new errors_1.SyntaxError(`'${name}' cannot be used as an identifier`, token.position, token.line, token.column, this.expression);
+        }
+        // It's a bare identifier - could be a variable without prefix
+        // For now, treat it as an error - require explicit prefix
+        throw new errors_1.SyntaxError(`Unknown identifier '${name}'. Variables must be prefixed with $ or @`, token.position, token.line, token.column, this.expression);
+    }
+    parseFunctionCall(name) {
+        this.advance(); // consume '('
+        const args = [];
+        if (this.peek().type !== types_1.TokenType.RPAREN) {
+            do {
+                if (this.peek().type === types_1.TokenType.COMMA) {
+                    this.advance();
+                }
+                args.push(this.parseExpression(PRECEDENCE.LOWEST));
+            } while (this.peek().type === types_1.TokenType.COMMA);
+        }
+        this.expect(types_1.TokenType.RPAREN, ')');
+        return {
+            type: 'FunctionCall',
+            name: name.toUpperCase(), // Functions are case-insensitive
+            arguments: args,
+        };
+    }
+    parseGroupedExpression() {
+        this.advance(); // consume '('
+        const expr = this.parseExpression(PRECEDENCE.LOWEST);
+        this.expect(types_1.TokenType.RPAREN, ')');
+        return expr;
+    }
+    parseArrayLiteral() {
+        this.advance(); // consume '['
+        const elements = [];
+        if (this.peek().type !== types_1.TokenType.RBRACKET) {
+            do {
+                if (this.peek().type === types_1.TokenType.COMMA) {
+                    this.advance();
+                }
+                elements.push(this.parseExpression(PRECEDENCE.LOWEST));
+            } while (this.peek().type === types_1.TokenType.COMMA);
+        }
+        this.expect(types_1.TokenType.RBRACKET, ']');
+        return {
+            type: 'ArrayLiteral',
+            elements,
+        };
+    }
+    parseUnaryExpression() {
+        const token = this.advance();
+        const operator = this.getOperatorSymbol(token.type);
+        const operand = this.parseExpression(PRECEDENCE.UNARY);
+        return {
+            type: 'UnaryOperation',
+            operator,
+            operand,
+        };
+    }
+    parseBinaryExpression(left) {
+        const token = this.advance();
+        const operator = this.getOperatorSymbol(token.type);
+        const precedence = this.getTokenPrecedence(token.type);
+        // Right associativity for power operator
+        const nextPrecedence = token.type === types_1.TokenType.POWER ? precedence - 1 : precedence;
+        const right = this.parseExpression(nextPrecedence);
+        return {
+            type: 'BinaryOperation',
+            operator,
+            left,
+            right,
+        };
+    }
+    parseTernaryExpression(condition) {
+        this.advance(); // consume '?'
+        const consequent = this.parseExpression(PRECEDENCE.LOWEST);
+        this.expect(types_1.TokenType.COLON, ':');
+        const alternate = this.parseExpression(PRECEDENCE.TERNARY - 1);
+        return {
+            type: 'ConditionalExpression',
+            condition,
+            consequent,
+            alternate,
+        };
+    }
+    parseMemberAccess(object) {
+        this.advance(); // consume '.'
+        const token = this.peek();
+        if (token.type !== types_1.TokenType.IDENTIFIER && token.type !== types_1.TokenType.VARIABLE) {
+            throw new errors_1.UnexpectedTokenError(String(token.value), ['identifier'], token.position);
+        }
+        this.advance();
+        const property = String(token.value);
+        const node = {
+            type: 'MemberAccess',
+            object,
+            property,
+        };
+        // Check for chained access
+        if (this.peek().type === types_1.TokenType.DOT) {
+            return this.parseMemberAccess(node);
+        }
+        if (this.peek().type === types_1.TokenType.LBRACKET) {
+            return this.parseIndexAccess(node);
+        }
+        return node;
+    }
+    parseIndexAccess(object) {
+        this.advance(); // consume '['
+        const index = this.parseExpression(PRECEDENCE.LOWEST);
+        this.expect(types_1.TokenType.RBRACKET, ']');
+        const node = {
+            type: 'IndexAccess',
+            object,
+            index,
+        };
+        // Check for chained access
+        if (this.peek().type === types_1.TokenType.DOT) {
+            return this.parseMemberAccess(node);
+        }
+        if (this.peek().type === types_1.TokenType.LBRACKET) {
+            return this.parseIndexAccess(node);
+        }
+        return node;
+    }
+    getPrecedence() {
+        return this.getTokenPrecedence(this.peek().type);
+    }
+    getTokenPrecedence(type) {
+        switch (type) {
+            case types_1.TokenType.OR:
+                return PRECEDENCE.OR;
+            case types_1.TokenType.AND:
+                return PRECEDENCE.AND;
+            case types_1.TokenType.EQ:
+            case types_1.TokenType.NEQ:
+                return PRECEDENCE.EQUALITY;
+            case types_1.TokenType.LT:
+            case types_1.TokenType.GT:
+            case types_1.TokenType.LTE:
+            case types_1.TokenType.GTE:
+                return PRECEDENCE.COMPARISON;
+            case types_1.TokenType.PLUS:
+            case types_1.TokenType.MINUS:
+                return PRECEDENCE.TERM;
+            case types_1.TokenType.MULTIPLY:
+            case types_1.TokenType.DIVIDE:
+            case types_1.TokenType.MODULO:
+                return PRECEDENCE.FACTOR;
+            case types_1.TokenType.POWER:
+                return PRECEDENCE.POWER;
+            case types_1.TokenType.DOT:
+            case types_1.TokenType.LBRACKET:
+                return PRECEDENCE.MEMBER;
+            case types_1.TokenType.QUESTION:
+                return PRECEDENCE.TERNARY;
+            default:
+                return PRECEDENCE.LOWEST;
+        }
+    }
+    getOperatorSymbol(type) {
+        switch (type) {
+            case types_1.TokenType.PLUS: return '+';
+            case types_1.TokenType.MINUS: return '-';
+            case types_1.TokenType.MULTIPLY: return '*';
+            case types_1.TokenType.DIVIDE: return '/';
+            case types_1.TokenType.MODULO: return '%';
+            case types_1.TokenType.POWER: return '^';
+            case types_1.TokenType.EQ: return '==';
+            case types_1.TokenType.NEQ: return '!=';
+            case types_1.TokenType.LT: return '<';
+            case types_1.TokenType.GT: return '>';
+            case types_1.TokenType.LTE: return '<=';
+            case types_1.TokenType.GTE: return '>=';
+            case types_1.TokenType.AND: return '&&';
+            case types_1.TokenType.OR: return '||';
+            case types_1.TokenType.NOT: return '!';
+            default: return '';
+        }
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.current++;
+        }
+        return this.tokens[this.current - 1];
+    }
+    isAtEnd() {
+        return this.peek().type === types_1.TokenType.EOF;
+    }
+    expect(type, expected) {
+        if (this.peek().type === type) {
+            return this.advance();
+        }
+        throw new errors_1.UnexpectedTokenError(String(this.peek().value), [expected], this.peek().position);
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":";;;AAAA,mCAAgC;AAChC,mCAAoD;AACpD,qCAA6D;AAE7D,wDAAwD;AACxD,MAAM,UAAU,GAAG;IACjB,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC,EAAM,MAAM;IACtB,EAAE,EAAE,CAAC,EAAW,QAAQ;IACxB,GAAG,EAAE,CAAC,EAAU,SAAS;IACzB,QAAQ,EAAE,CAAC,EAAK,QAAQ;IACxB,UAAU,EAAE,CAAC,EAAG,YAAY;IAC5B,IAAI,EAAE,CAAC,EAAS,MAAM;IACtB,MAAM,EAAE,CAAC,EAAO,QAAQ;IACxB,KAAK,EAAE,CAAC,EAAQ,IAAI;IACpB,KAAK,EAAE,EAAE,EAAO,UAAU;IAC1B,IAAI,EAAE,EAAE,EAAQ,iBAAiB;IACjC,MAAM,EAAE,EAAE,EAAM,OAAO;CACxB,CAAC;AAEF,MAAa,MAAM;IAAnB;QACU,WAAM,GAAY,EAAE,CAAC;QACrB,YAAO,GAAW,CAAC,CAAC;QACpB,eAAU,GAAW,EAAE,CAAC;IAyalC,CAAC;IAvaC,KAAK,CAAC,UAAkB;QACtB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,UAAU,CAAC,CAAC;QACpC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QAEjB,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAEpD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;YAC1B,MAAM,IAAI,6BAAoB,CAC5B,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EACnB,CAAC,mBAAmB,CAAC,EACrB,KAAK,CAAC,QAAQ,CACf,CAAC;QACJ,CAAC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,eAAe,CAAC,UAAkB;QACxC,IAAI,IAAI,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAExC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;YAC5D,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,qBAAqB;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAE1B,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,iBAAS,CAAC,MAAM;gBACnB,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;YAC5B,KAAK,iBAAS,CAAC,MAAM;gBACnB,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;YAC5B,KAAK,iBAAS,CAAC,OAAO;gBACpB,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;YAC7B,KAAK,iBAAS,CAAC,IAAI;gBACjB,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;YAC1B,KAAK,iBAAS,CAAC,QAAQ;gBACrB,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC;YAC9B,KAAK,iBAAS,CAAC,WAAW;gBACxB,OAAO,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACrC,KAAK,iBAAS,CAAC,UAAU;gBACvB,OAAO,IAAI,CAAC,6BAA6B,EAAE,CAAC;YAC9C,KAAK,iBAAS,CAAC,MAAM;gBACnB,OAAO,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACvC,KAAK,iBAAS,CAAC,QAAQ;gBACrB,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAClC,KAAK,iBAAS,CAAC,KAAK,CAAC;YACrB,KAAK,iBAAS,CAAC,GAAG;gBAChB,OAAO,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACrC;gBACE,MAAM,IAAI,6BAAoB,CAC5B,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EACnB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EACrF,KAAK,CAAC,QAAQ,CACf,CAAC;QACN,CAAC;IACH,CAAC;IAEO,oBAAoB,CAAC,IAAa;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAE1B,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,iBAAS,CAAC,IAAI,CAAC;YACpB,KAAK,iBAAS,CAAC,KAAK,CAAC;YACrB,KAAK,iBAAS,CAAC,QAAQ,CAAC;YACxB,KAAK,iBAAS,CAAC,MAAM,CAAC;YACtB,KAAK,iBAAS,CAAC,MAAM,CAAC;YACtB,KAAK,iBAAS,CAAC,KAAK,CAAC;YACrB,KAAK,iBAAS,CAAC,EAAE,CAAC;YAClB,KAAK,iBAAS,CAAC,GAAG,CAAC;YACnB,KAAK,iBAAS,CAAC,EAAE,CAAC;YAClB,KAAK,iBAAS,CAAC,EAAE,CAAC;YAClB,KAAK,iBAAS,CAAC,GAAG,CAAC;YACnB,KAAK,iBAAS,CAAC,GAAG,CAAC;YACnB,KAAK,iBAAS,CAAC,GAAG,CAAC;YACnB,KAAK,iBAAS,CAAC,EAAE;gBACf,OAAO,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;YAC1C,KAAK,iBAAS,CAAC,QAAQ;gBACrB,OAAO,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;YAC3C,KAAK,iBAAS,CAAC,GAAG;gBAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACtC,KAAK,iBAAS,CAAC,QAAQ;gBACrB,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YACrC,KAAK,iBAAS,CAAC,MAAM;gBACnB,kEAAkE;gBAClE,uEAAuE;gBACvE,OAAO,IAAI,CAAC;YACd;gBACE,OAAO,IAAI,CAAC;QAChB,CAAC;IACH,CAAC;IAEO,WAAW;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAE1B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,eAAe;YACf,OAAO;gBACL,IAAI,EAAE,eAAe;gBACrB,KAAK,EAAE,KAAK;aACb,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,oCAAoC;YACpC,OAAO;gBACL,IAAI,EAAE,gBAAgB;gBACtB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;gBACpB,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC;aACnB,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,WAAW;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,eAAe;YACrB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;SAC3B,CAAC;IACJ,CAAC;IAEO,YAAY;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,KAAK,EAAE,KAAK,CAAC,KAAK,KAAK,IAAI;SAC5B,CAAC;IACJ,CAAC;IAEO,SAAS;QACf,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,OAAO;YACL,IAAI,EAAE,aAAa;SACpB,CAAC;IACJ,CAAC;IAEO,aAAa;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;SAC1B,CAAC;IACJ,CAAC;IAEO,oBAAoB;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;SAC1B,CAAC;IACJ,CAAC;IAEO,6BAA6B;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEjC,gCAAgC;QAChC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,MAAM,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;QAED,0EAA0E;QAC1E,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACrC,IAAI,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YAC9C,8DAA8D;YAC9D,gDAAgD;YAChD,MAAM,IAAI,oBAAW,CACnB,IAAI,IAAI,mCAAmC,EAC3C,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,IAAI,CAAC,UAAU,CAChB,CAAC;QACJ,CAAC;QAED,8DAA8D;QAC9D,0DAA0D;QAC1D,MAAM,IAAI,oBAAW,CACnB,uBAAuB,IAAI,2CAA2C,EACtE,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,IAAI,CAAC,UAAU,CAChB,CAAC;IACJ,CAAC;IAEO,iBAAiB,CAAC,IAAY;QACpC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,cAAc;QAC9B,MAAM,IAAI,GAAc,EAAE,CAAC;QAE3B,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,MAAM,EAAE,CAAC;YAC1C,GAAG,CAAC;gBACF,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,KAAK,EAAE,CAAC;oBACzC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;YACrD,CAAC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,KAAK,EAAE;QACjD,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,iBAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAEnC,OAAO;YACL,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,iCAAiC;YAC3D,SAAS,EAAE,IAAI;SAChB,CAAC;IACJ,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,cAAc;QAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,iBAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,cAAc;QAC9B,MAAM,QAAQ,GAAc,EAAE,CAAC;QAE/B,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,QAAQ,EAAE,CAAC;YAC5C,GAAG,CAAC;gBACF,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,KAAK,EAAE,CAAC;oBACzC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,CAAC;gBACD,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;YACzD,CAAC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,KAAK,EAAE;QACjD,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,iBAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAErC,OAAO;YACL,IAAI,EAAE,cAAc;YACpB,QAAQ;SACT,CAAC;IACJ,CAAC;IAEO,oBAAoB;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAEvD,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,QAAQ;YACR,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,qBAAqB,CAAC,IAAa;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEvD,yCAAyC;QACzC,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,KAAK,iBAAS,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QACpF,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;QAEnD,OAAO;YACL,IAAI,EAAE,iBAAiB;YACvB,QAAQ;YACR,IAAI;YACJ,KAAK;SACN,CAAC;IACJ,CAAC;IAEO,sBAAsB,CAAC,SAAkB;QAC/C,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,cAAc;QAC9B,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,iBAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;QAE/D,OAAO;YACL,IAAI,EAAE,uBAAuB;YAC7B,SAAS;YACT,UAAU;YACV,SAAS;SACV,CAAC;IACJ,CAAC;IAEO,iBAAiB,CAAC,MAAe;QACvC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,cAAc;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAE1B,IAAI,KAAK,CAAC,IAAI,KAAK,iBAAS,CAAC,UAAU,IAAI,KAAK,CAAC,IAAI,KAAK,iBAAS,CAAC,QAAQ,EAAE,CAAC;YAC7E,MAAM,IAAI,6BAAoB,CAC5B,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EACnB,CAAC,YAAY,CAAC,EACd,KAAK,CAAC,QAAQ,CACf,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAErC,MAAM,IAAI,GAAY;YACpB,IAAI,EAAE,cAAc;YACpB,MAAM;YACN,QAAQ;SACT,CAAC;QAEF,2BAA2B;QAC3B,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,GAAG,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,QAAQ,EAAE,CAAC;YAC5C,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,gBAAgB,CAAC,MAAe;QACtC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,cAAc;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,MAAM,CAAC,iBAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAErC,MAAM,IAAI,GAAY;YACpB,IAAI,EAAE,aAAa;YACnB,MAAM;YACN,KAAK;SACN,CAAC;QAEF,2BAA2B;QAC3B,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,GAAG,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,QAAQ,EAAE,CAAC;YAC5C,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,aAAa;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAEO,kBAAkB,CAAC,IAAe;QACxC,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,iBAAS,CAAC,EAAE;gBACf,OAAO,UAAU,CAAC,EAAE,CAAC;YACvB,KAAK,iBAAS,CAAC,GAAG;gBAChB,OAAO,UAAU,CAAC,GAAG,CAAC;YACxB,KAAK,iBAAS,CAAC,EAAE,CAAC;YAClB,KAAK,iBAAS,CAAC,GAAG;gBAChB,OAAO,UAAU,CAAC,QAAQ,CAAC;YAC7B,KAAK,iBAAS,CAAC,EAAE,CAAC;YAClB,KAAK,iBAAS,CAAC,EAAE,CAAC;YAClB,KAAK,iBAAS,CAAC,GAAG,CAAC;YACnB,KAAK,iBAAS,CAAC,GAAG;gBAChB,OAAO,UAAU,CAAC,UAAU,CAAC;YAC/B,KAAK,iBAAS,CAAC,IAAI,CAAC;YACpB,KAAK,iBAAS,CAAC,KAAK;gBAClB,OAAO,UAAU,CAAC,IAAI,CAAC;YACzB,KAAK,iBAAS,CAAC,QAAQ,CAAC;YACxB,KAAK,iBAAS,CAAC,MAAM,CAAC;YACtB,KAAK,iBAAS,CAAC,MAAM;gBACnB,OAAO,UAAU,CAAC,MAAM,CAAC;YAC3B,KAAK,iBAAS,CAAC,KAAK;gBAClB,OAAO,UAAU,CAAC,KAAK,CAAC;YAC1B,KAAK,iBAAS,CAAC,GAAG,CAAC;YACnB,KAAK,iBAAS,CAAC,QAAQ;gBACrB,OAAO,UAAU,CAAC,MAAM,CAAC;YAC3B,KAAK,iBAAS,CAAC,QAAQ;gBACrB,OAAO,UAAU,CAAC,OAAO,CAAC;YAC5B;gBACE,OAAO,UAAU,CAAC,MAAM,CAAC;QAC7B,CAAC;IACH,CAAC;IAEO,iBAAiB,CAAC,IAAe;QACvC,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,iBAAS,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,CAAC;YAChC,KAAK,iBAAS,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,CAAC;YACjC,KAAK,iBAAS,CAAC,QAAQ,CAAC,CAAC,OAAO,GAAG,CAAC;YACpC,KAAK,iBAAS,CAAC,MAAM,CAAC,CAAC,OAAO,GAAG,CAAC;YAClC,KAAK,iBAAS,CAAC,MAAM,CAAC,CAAC,OAAO,GAAG,CAAC;YAClC,KAAK,iBAAS,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,CAAC;YACjC,KAAK,iBAAS,CAAC,EAAE,CAAC,CAAC,OAAO,IAAI,CAAC;YAC/B,KAAK,iBAAS,CAAC,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;YAChC,KAAK,iBAAS,CAAC,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC;YAC9B,KAAK,iBAAS,CAAC,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC;YAC9B,KAAK,iBAAS,CAAC,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;YAChC,KAAK,iBAAS,CAAC,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;YAChC,KAAK,iBAAS,CAAC,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;YAChC,KAAK,iBAAS,CAAC,EAAE,CAAC,CAAC,OAAO,IAAI,CAAC;YAC/B,KAAK,iBAAS,CAAC,GAAG,CAAC,CAAC,OAAO,GAAG,CAAC;YAC/B,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAEO,IAAI;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAEO,OAAO;QACb,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IACvC,CAAC;IAEO,OAAO;QACb,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,iBAAS,CAAC,GAAG,CAAC;IAC5C,CAAC;IAEO,MAAM,CAAC,IAAe,EAAE,QAAgB;QAC9C,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;QACxB,CAAC;QACD,MAAM,IAAI,6BAAoB,CAC5B,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EACzB,CAAC,QAAQ,CAAC,EACV,IAAI,CAAC,IAAI,EAAE,CAAC,QAAQ,CACrB,CAAC;IACJ,CAAC;CACF;AA5aD,wBA4aC","sourcesContent":["import { Lexer } from './lexer';\nimport { Token, TokenType, ASTNode } from './types';\nimport { SyntaxError, UnexpectedTokenError } from './errors';\n\n// Operator precedence levels (higher = tighter binding)\nconst PRECEDENCE = {\n  LOWEST: 1,\n  TERNARY: 2,     // ? :\n  OR: 3,          // || OR\n  AND: 4,         // && AND\n  EQUALITY: 5,    // == !=\n  COMPARISON: 6,  // < > <= >=\n  TERM: 7,        // + -\n  FACTOR: 8,      // * / %\n  POWER: 9,       // ^\n  UNARY: 10,      // - ! NOT\n  CALL: 11,       // function calls\n  MEMBER: 12,     // . []\n};\n\nexport class Parser {\n  private tokens: Token[] = [];\n  private current: number = 0;\n  private expression: string = '';\n\n  parse(expression: string): ASTNode {\n    this.expression = expression;\n    const lexer = new Lexer(expression);\n    this.tokens = lexer.tokenize();\n    this.current = 0;\n\n    const ast = this.parseExpression(PRECEDENCE.LOWEST);\n\n    if (!this.isAtEnd()) {\n      const token = this.peek();\n      throw new UnexpectedTokenError(\n        String(token.value),\n        ['end of expression'],\n        token.position\n      );\n    }\n\n    return ast;\n  }\n\n  private parseExpression(precedence: number): ASTNode {\n    let left = this.parsePrefixExpression();\n\n    while (!this.isAtEnd() && precedence < this.getPrecedence()) {\n      left = this.parseInfixExpression(left);\n    }\n\n    return left;\n  }\n\n  private parsePrefixExpression(): ASTNode {\n    const token = this.peek();\n\n    switch (token.type) {\n      case TokenType.NUMBER:\n        return this.parseNumber();\n      case TokenType.STRING:\n        return this.parseString();\n      case TokenType.BOOLEAN:\n        return this.parseBoolean();\n      case TokenType.NULL:\n        return this.parseNull();\n      case TokenType.VARIABLE:\n        return this.parseVariable();\n      case TokenType.CONTEXT_VAR:\n        return this.parseContextVariable();\n      case TokenType.IDENTIFIER:\n        return this.parseIdentifierOrFunctionCall();\n      case TokenType.LPAREN:\n        return this.parseGroupedExpression();\n      case TokenType.LBRACKET:\n        return this.parseArrayLiteral();\n      case TokenType.MINUS:\n      case TokenType.NOT:\n        return this.parseUnaryExpression();\n      default:\n        throw new UnexpectedTokenError(\n          String(token.value),\n          ['number', 'string', 'boolean', 'null', 'variable', 'identifier', '(', '[', '-', '!'],\n          token.position\n        );\n    }\n  }\n\n  private parseInfixExpression(left: ASTNode): ASTNode {\n    const token = this.peek();\n\n    switch (token.type) {\n      case TokenType.PLUS:\n      case TokenType.MINUS:\n      case TokenType.MULTIPLY:\n      case TokenType.DIVIDE:\n      case TokenType.MODULO:\n      case TokenType.POWER:\n      case TokenType.EQ:\n      case TokenType.NEQ:\n      case TokenType.LT:\n      case TokenType.GT:\n      case TokenType.LTE:\n      case TokenType.GTE:\n      case TokenType.AND:\n      case TokenType.OR:\n        return this.parseBinaryExpression(left);\n      case TokenType.QUESTION:\n        return this.parseTernaryExpression(left);\n      case TokenType.DOT:\n        return this.parseMemberAccess(left);\n      case TokenType.LBRACKET:\n        return this.parseIndexAccess(left);\n      case TokenType.LPAREN:\n        // This handles the case where we have an identifier followed by (\n        // But actually this should be handled in parseIdentifierOrFunctionCall\n        return left;\n      default:\n        return left;\n    }\n  }\n\n  private parseNumber(): ASTNode {\n    const token = this.advance();\n    const value = token.value;\n\n    if (typeof value === 'number') {\n      // It's a float\n      return {\n        type: 'NumberLiteral',\n        value: value,\n      };\n    } else {\n      // It's a decimal (stored as string)\n      return {\n        type: 'DecimalLiteral',\n        value: String(value),\n        raw: String(value),\n      };\n    }\n  }\n\n  private parseString(): ASTNode {\n    const token = this.advance();\n    return {\n      type: 'StringLiteral',\n      value: String(token.value),\n    };\n  }\n\n  private parseBoolean(): ASTNode {\n    const token = this.advance();\n    return {\n      type: 'BooleanLiteral',\n      value: token.value === true,\n    };\n  }\n\n  private parseNull(): ASTNode {\n    this.advance();\n    return {\n      type: 'NullLiteral',\n    };\n  }\n\n  private parseVariable(): ASTNode {\n    const token = this.advance();\n    return {\n      type: 'VariableReference',\n      prefix: '$',\n      name: String(token.value),\n    };\n  }\n\n  private parseContextVariable(): ASTNode {\n    const token = this.advance();\n    return {\n      type: 'VariableReference',\n      prefix: '@',\n      name: String(token.value),\n    };\n  }\n\n  private parseIdentifierOrFunctionCall(): ASTNode {\n    const token = this.advance();\n    const name = String(token.value);\n\n    // Check if it's a function call\n    if (this.peek().type === TokenType.LPAREN) {\n      return this.parseFunctionCall(name);\n    }\n\n    // Otherwise, check for keywords AND/OR/NOT used as standalone identifiers\n    const upperName = name.toUpperCase();\n    if (upperName === 'AND' || upperName === 'OR') {\n      // These should be handled as operators, but if we reach here,\n      // it means they were used in an invalid context\n      throw new SyntaxError(\n        `'${name}' cannot be used as an identifier`,\n        token.position,\n        token.line,\n        token.column,\n        this.expression\n      );\n    }\n\n    // It's a bare identifier - could be a variable without prefix\n    // For now, treat it as an error - require explicit prefix\n    throw new SyntaxError(\n      `Unknown identifier '${name}'. Variables must be prefixed with $ or @`,\n      token.position,\n      token.line,\n      token.column,\n      this.expression\n    );\n  }\n\n  private parseFunctionCall(name: string): ASTNode {\n    this.advance(); // consume '('\n    const args: ASTNode[] = [];\n\n    if (this.peek().type !== TokenType.RPAREN) {\n      do {\n        if (this.peek().type === TokenType.COMMA) {\n          this.advance();\n        }\n        args.push(this.parseExpression(PRECEDENCE.LOWEST));\n      } while (this.peek().type === TokenType.COMMA);\n    }\n\n    this.expect(TokenType.RPAREN, ')');\n\n    return {\n      type: 'FunctionCall',\n      name: name.toUpperCase(), // Functions are case-insensitive\n      arguments: args,\n    };\n  }\n\n  private parseGroupedExpression(): ASTNode {\n    this.advance(); // consume '('\n    const expr = this.parseExpression(PRECEDENCE.LOWEST);\n    this.expect(TokenType.RPAREN, ')');\n    return expr;\n  }\n\n  private parseArrayLiteral(): ASTNode {\n    this.advance(); // consume '['\n    const elements: ASTNode[] = [];\n\n    if (this.peek().type !== TokenType.RBRACKET) {\n      do {\n        if (this.peek().type === TokenType.COMMA) {\n          this.advance();\n        }\n        elements.push(this.parseExpression(PRECEDENCE.LOWEST));\n      } while (this.peek().type === TokenType.COMMA);\n    }\n\n    this.expect(TokenType.RBRACKET, ']');\n\n    return {\n      type: 'ArrayLiteral',\n      elements,\n    };\n  }\n\n  private parseUnaryExpression(): ASTNode {\n    const token = this.advance();\n    const operator = this.getOperatorSymbol(token.type);\n    const operand = this.parseExpression(PRECEDENCE.UNARY);\n\n    return {\n      type: 'UnaryOperation',\n      operator,\n      operand,\n    };\n  }\n\n  private parseBinaryExpression(left: ASTNode): ASTNode {\n    const token = this.advance();\n    const operator = this.getOperatorSymbol(token.type);\n    const precedence = this.getTokenPrecedence(token.type);\n\n    // Right associativity for power operator\n    const nextPrecedence = token.type === TokenType.POWER ? precedence - 1 : precedence;\n    const right = this.parseExpression(nextPrecedence);\n\n    return {\n      type: 'BinaryOperation',\n      operator,\n      left,\n      right,\n    };\n  }\n\n  private parseTernaryExpression(condition: ASTNode): ASTNode {\n    this.advance(); // consume '?'\n    const consequent = this.parseExpression(PRECEDENCE.LOWEST);\n    this.expect(TokenType.COLON, ':');\n    const alternate = this.parseExpression(PRECEDENCE.TERNARY - 1);\n\n    return {\n      type: 'ConditionalExpression',\n      condition,\n      consequent,\n      alternate,\n    };\n  }\n\n  private parseMemberAccess(object: ASTNode): ASTNode {\n    this.advance(); // consume '.'\n    const token = this.peek();\n\n    if (token.type !== TokenType.IDENTIFIER && token.type !== TokenType.VARIABLE) {\n      throw new UnexpectedTokenError(\n        String(token.value),\n        ['identifier'],\n        token.position\n      );\n    }\n\n    this.advance();\n    const property = String(token.value);\n\n    const node: ASTNode = {\n      type: 'MemberAccess',\n      object,\n      property,\n    };\n\n    // Check for chained access\n    if (this.peek().type === TokenType.DOT) {\n      return this.parseMemberAccess(node);\n    }\n    if (this.peek().type === TokenType.LBRACKET) {\n      return this.parseIndexAccess(node);\n    }\n\n    return node;\n  }\n\n  private parseIndexAccess(object: ASTNode): ASTNode {\n    this.advance(); // consume '['\n    const index = this.parseExpression(PRECEDENCE.LOWEST);\n    this.expect(TokenType.RBRACKET, ']');\n\n    const node: ASTNode = {\n      type: 'IndexAccess',\n      object,\n      index,\n    };\n\n    // Check for chained access\n    if (this.peek().type === TokenType.DOT) {\n      return this.parseMemberAccess(node);\n    }\n    if (this.peek().type === TokenType.LBRACKET) {\n      return this.parseIndexAccess(node);\n    }\n\n    return node;\n  }\n\n  private getPrecedence(): number {\n    return this.getTokenPrecedence(this.peek().type);\n  }\n\n  private getTokenPrecedence(type: TokenType): number {\n    switch (type) {\n      case TokenType.OR:\n        return PRECEDENCE.OR;\n      case TokenType.AND:\n        return PRECEDENCE.AND;\n      case TokenType.EQ:\n      case TokenType.NEQ:\n        return PRECEDENCE.EQUALITY;\n      case TokenType.LT:\n      case TokenType.GT:\n      case TokenType.LTE:\n      case TokenType.GTE:\n        return PRECEDENCE.COMPARISON;\n      case TokenType.PLUS:\n      case TokenType.MINUS:\n        return PRECEDENCE.TERM;\n      case TokenType.MULTIPLY:\n      case TokenType.DIVIDE:\n      case TokenType.MODULO:\n        return PRECEDENCE.FACTOR;\n      case TokenType.POWER:\n        return PRECEDENCE.POWER;\n      case TokenType.DOT:\n      case TokenType.LBRACKET:\n        return PRECEDENCE.MEMBER;\n      case TokenType.QUESTION:\n        return PRECEDENCE.TERNARY;\n      default:\n        return PRECEDENCE.LOWEST;\n    }\n  }\n\n  private getOperatorSymbol(type: TokenType): string {\n    switch (type) {\n      case TokenType.PLUS: return '+';\n      case TokenType.MINUS: return '-';\n      case TokenType.MULTIPLY: return '*';\n      case TokenType.DIVIDE: return '/';\n      case TokenType.MODULO: return '%';\n      case TokenType.POWER: return '^';\n      case TokenType.EQ: return '==';\n      case TokenType.NEQ: return '!=';\n      case TokenType.LT: return '<';\n      case TokenType.GT: return '>';\n      case TokenType.LTE: return '<=';\n      case TokenType.GTE: return '>=';\n      case TokenType.AND: return '&&';\n      case TokenType.OR: return '||';\n      case TokenType.NOT: return '!';\n      default: return '';\n    }\n  }\n\n  private peek(): Token {\n    return this.tokens[this.current];\n  }\n\n  private advance(): Token {\n    if (!this.isAtEnd()) {\n      this.current++;\n    }\n    return this.tokens[this.current - 1];\n  }\n\n  private isAtEnd(): boolean {\n    return this.peek().type === TokenType.EOF;\n  }\n\n  private expect(type: TokenType, expected: string): Token {\n    if (this.peek().type === type) {\n      return this.advance();\n    }\n    throw new UnexpectedTokenError(\n      String(this.peek().value),\n      [expected],\n      this.peek().position\n    );\n  }\n}\n"]}

package/dist/types.d.ts

@@ -0,0 +1,228 @@
+import { Decimal } from 'decimal.js';
+export type ValueType = 'number' | 'decimal' | 'string' | 'boolean' | 'array' | 'object' | 'null' | 'any';
+export type FormulaValue = Decimal | number | string | boolean | null | FormulaValue[] | {
+    [key: string]: FormulaValue;
+};
+export declare enum DecimalRoundingMode {
+    CEIL = "CEIL",
+    FLOOR = "FLOOR",
+    DOWN = "DOWN",
+    UP = "UP",
+    HALF_UP = "HALF_UP",
+    HALF_DOWN = "HALF_DOWN",
+    HALF_EVEN = "HALF_EVEN",
+    HALF_ODD = "HALF_ODD"
+}
+export interface DecimalConfig {
+    precision?: number;
+    roundingMode?: DecimalRoundingMode;
+    divisionScale?: number;
+    preserveTrailingZeros?: boolean;
+    autoConvertFloats?: boolean;
+    maxExponent?: number;
+    minExponent?: number;
+}
+export interface RoundingConfig {
+    mode: 'HALF_UP' | 'HALF_DOWN' | 'FLOOR' | 'CEIL' | 'NONE';
+    precision: number;
+}
+export interface ErrorBehavior {
+    type: 'THROW' | 'NULL' | 'ZERO' | 'DEFAULT' | 'SKIP';
+    defaultValue?: unknown;
+}
+export interface FormulaDefinition {
+    id: string;
+    expression: string;
+    dependencies?: string[];
+    onError?: ErrorBehavior;
+    defaultValue?: unknown;
+    rounding?: RoundingConfig;
+    metadata?: Record<string, unknown>;
+}
+export interface EvaluationContext {
+    variables: Record<string, unknown>;
+    collections?: Record<string, unknown[]>;
+    extra?: Record<string, unknown>;
+}
+export interface OperatorDefinition {
+    symbol: string;
+    precedence: number;
+    associativity: 'left' | 'right';
+    handler: (left: unknown, right: unknown) => unknown;
+}
+export interface SecurityConfig {
+    maxExpressionLength?: number;
+    maxRecursionDepth?: number;
+    maxIterations?: number;
+    maxExecutionTime?: number;
+    allowedFunctions?: string[];
+    blockedFunctions?: string[];
+}
+export interface FormulaEngineConfig {
+    enableCache?: boolean;
+    maxCacheSize?: number;
+    defaultErrorBehavior?: ErrorBehavior;
+    defaultRounding?: RoundingConfig;
+    variablePrefix?: string;
+    contextPrefix?: string;
+    strictMode?: boolean;
+    operators?: OperatorDefinition[];
+    functions?: FunctionDefinition[];
+    decimal?: DecimalConfig;
+    security?: SecurityConfig;
+}
+export interface DecimalLiteral {
+    type: 'DecimalLiteral';
+    value: string;
+    raw: string;
+}
+export interface NumberLiteral {
+    type: 'NumberLiteral';
+    value: number;
+}
+export interface StringLiteral {
+    type: 'StringLiteral';
+    value: string;
+}
+export interface BooleanLiteral {
+    type: 'BooleanLiteral';
+    value: boolean;
+}
+export interface NullLiteral {
+    type: 'NullLiteral';
+}
+export interface ArrayLiteral {
+    type: 'ArrayLiteral';
+    elements: ASTNode[];
+}
+export interface VariableReference {
+    type: 'VariableReference';
+    prefix: '$' | '@';
+    name: string;
+}
+export interface BinaryOperation {
+    type: 'BinaryOperation';
+    operator: string;
+    left: ASTNode;
+    right: ASTNode;
+}
+export interface UnaryOperation {
+    type: 'UnaryOperation';
+    operator: string;
+    operand: ASTNode;
+}
+export interface ConditionalExpression {
+    type: 'ConditionalExpression';
+    condition: ASTNode;
+    consequent: ASTNode;
+    alternate: ASTNode;
+}
+export interface FunctionCall {
+    type: 'FunctionCall';
+    name: string;
+    arguments: ASTNode[];
+}
+export interface MemberAccess {
+    type: 'MemberAccess';
+    object: ASTNode;
+    property: string;
+}
+export interface IndexAccess {
+    type: 'IndexAccess';
+    object: ASTNode;
+    index: ASTNode;
+}
+export type ASTNode = DecimalLiteral | NumberLiteral | StringLiteral | BooleanLiteral | NullLiteral | ArrayLiteral | VariableReference | BinaryOperation | UnaryOperation | ConditionalExpression | FunctionCall | MemberAccess | IndexAccess;
+export interface ArgumentType {
+    name: string;
+    type: ValueType;
+    required: boolean;
+    default?: unknown;
+}
+export type FunctionImplementation = (args: unknown[], context: EvaluationContext, engine: unknown) => unknown;
+export interface FunctionDefinition {
+    name: string;
+    minArgs: number;
+    maxArgs: number;
+    argTypes?: ArgumentType[];
+    returnType: ValueType;
+    implementation: FunctionImplementation;
+    description?: string;
+}
+export interface DependencyGraph {
+    nodes: Set<string>;
+    edges: Map<string, Set<string>>;
+    hasCycles(): boolean;
+    getRoots(): Set<string>;
+    getDependents(nodeId: string): Set<string>;
+    getDependencies(nodeId: string): Set<string>;
+    getTransitiveDependencies(nodeId: string): Set<string>;
+    topologicalSort(): string[];
+}
+export interface EvaluationResult {
+    value: unknown;
+    success: boolean;
+    error?: Error;
+    executionTimeMs: number;
+    accessedVariables: Set<string>;
+}
+export interface EvaluationResultSet {
+    results: Map<string, EvaluationResult>;
+    success: boolean;
+    errors: Error[];
+    totalExecutionTimeMs: number;
+    evaluationOrder: string[];
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: Error[];
+    warnings: string[];
+    dependencyGraph: DependencyGraph;
+    evaluationOrder: string[];
+}
+export interface CacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+}
+export declare enum TokenType {
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    BOOLEAN = "BOOLEAN",
+    NULL = "NULL",
+    IDENTIFIER = "IDENTIFIER",
+    VARIABLE = "VARIABLE",
+    CONTEXT_VAR = "CONTEXT_VAR",
+    PLUS = "PLUS",
+    MINUS = "MINUS",
+    MULTIPLY = "MULTIPLY",
+    DIVIDE = "DIVIDE",
+    MODULO = "MODULO",
+    POWER = "POWER",
+    EQ = "EQ",
+    NEQ = "NEQ",
+    LT = "LT",
+    GT = "GT",
+    LTE = "LTE",
+    GTE = "GTE",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    COMMA = "COMMA",
+    DOT = "DOT",
+    QUESTION = "QUESTION",
+    COLON = "COLON",
+    EOF = "EOF"
+}
+export interface Token {
+    type: TokenType;
+    value: string | number | boolean | null;
+    position: number;
+    line: number;
+    column: number;
+}