smart-lifecycle 0.1.1

package/dist/rendering/expression-parser/host-projector.js

@@ -0,0 +1,97 @@
+import { NodeType } from '../dom/node-types.js';
+export class HostProjector {
+    domAdapter;
+    hostProjectionRegistry;
+    /**
+     * Initializes a new instance of HostProjector.
+     *
+     * @param domAdapter - Adapter for DOM element creation
+     * @param hostProjectionRegistry - Registry for host projection content
+     * @throws Error if domAdapter is null or undefined
+     * @throws Error if hostProjectionRegistry is null or undefined
+     */
+    constructor(domAdapter, hostProjectionRegistry) {
+        this.domAdapter = domAdapter;
+        this.hostProjectionRegistry = hostProjectionRegistry;
+        if (!domAdapter) {
+            throw new Error('Dom adapter is required');
+        }
+        if (!hostProjectionRegistry) {
+            throw new Error('Host projection registry is required');
+        }
+    }
+    /**
+     * Projects captured content into template hosts
+     *
+     * @description
+     * Processes all <smart-host> elements in the template, replacing them with
+     * appropriate projected content based on host names and fallback rules.
+     *
+     * @param element - Template root element containing <smart-host> elements
+     * @param component - Component instance with captured host content
+     *
+     * @example
+     * ```typescript
+     * // Template:
+     * `<div>
+     *   <header><smart-host name="header">Default Header</smart-host></header>
+     *   <main><smart-host>Default Content</smart-host></main>
+     * </div>`
+     *
+     * // Usage:
+     * `<my-component>
+     *   <h1 host="header">Custom Header</h1>
+     *   <p>Custom Content</p>
+     * </my-component>`
+     *
+     * // Result after projection:
+     * `<div>
+     *   <header><h1>Custom Header</h1></header>
+     *   <main><p>Custom Content</p></main>
+     * </div>`
+     * ```
+     */
+    project(element, component) {
+        const hostContent = this.hostProjectionRegistry.get(component);
+        if (!hostContent) {
+            return; // No host content to project
+        }
+        // Find all <smart-host> elements
+        const hosts = element.querySelectorAll('smart-host');
+        if (hosts.length === 0) {
+            return; // No hosts in template
+        }
+        // Parse host content using DOM adapter
+        const tempDiv = this.domAdapter.createElement('div');
+        tempDiv.innerHTML = hostContent;
+        const hostNodes = Array.from(tempDiv.childNodes);
+        hosts.forEach(host => {
+            const hostName = host.getAttribute('name');
+            if (hostName) {
+                // Named host: find matching elements
+                const matchingNodes = hostNodes.filter(node => node.nodeType === NodeType.ELEMENT_NODE &&
+                    node.getAttribute('host') === hostName);
+                if (matchingNodes.length > 0) {
+                    matchingNodes.forEach(node => {
+                        host.parentNode?.insertBefore(node.cloneNode(true), host);
+                    });
+                    host.remove();
+                }
+                // If no matching children, keep host fallback content
+            }
+            else {
+                // Default host: insert all nodes without host attribute (including text nodes)
+                const defaultNodes = hostNodes.filter(node => node.nodeType !== NodeType.ELEMENT_NODE ||
+                    !node.hasAttribute('host'));
+                if (defaultNodes.length > 0) {
+                    defaultNodes.forEach(node => {
+                        host.parentNode?.insertBefore(node.cloneNode(true), host);
+                    });
+                    host.remove();
+                }
+                // If no default children, keep host fallback content
+            }
+        });
+    }
+}
+//# sourceMappingURL=host-projector.js.map

package/dist/rendering/expression-parser/host-projector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-projector.js","sourceRoot":"","sources":["../../../src/rendering/expression-parser/host-projector.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAmChD,MAAM,OAAO,aAAa;IAUL;IACA;IAVnB;;;;;;;OAOG;IACH,YACmB,UAAuB,EACvB,sBAA+C;QAD/C,eAAU,GAAV,UAAU,CAAa;QACvB,2BAAsB,GAAtB,sBAAsB,CAAyB;QAEhE,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,OAAO,CAAC,OAAoB,EAAE,SAAyB;QACrD,MAAM,WAAW,GAAG,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAE/D,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,CAAC,6BAA6B;QACvC,CAAC;QAED,iCAAiC;QACjC,MAAM,KAAK,GAAG,OAAO,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAErD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO,CAAC,uBAAuB;QACjC,CAAC;QAED,uCAAuC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACrD,OAAO,CAAC,SAAS,GAAG,WAAW,CAAC;QAChC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAEjD,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACnB,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YAE3C,IAAI,QAAQ,EAAE,CAAC;gBACb,qCAAqC;gBACrC,MAAM,aAAa,GAAG,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAC5C,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,YAAY;oBACtC,IAAgB,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,QAAQ,CACpD,CAAC;gBAEF,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;wBAC3B,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;oBAC5D,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,MAAM,EAAE,CAAC;gBAChB,CAAC;gBACD,sDAAsD;YACxD,CAAC;iBAAM,CAAC;gBACN,+EAA+E;gBAC/E,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAC3C,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,YAAY;oBACvC,CAAE,IAAgB,CAAC,YAAY,CAAC,MAAM,CAAC,CACxC,CAAC;gBAEF,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC5B,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;wBAC1B,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;oBAC5D,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,MAAM,EAAE,CAAC;gBAChB,CAAC;gBACD,qDAAqD;YACvD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/rendering/expression-parser/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./interfaces.js";
+export * from "./evaluators/index.js";
+export { ExpressionParserService } from "./expression-parser.service.js";
+export { ASTEvaluator } from "./evaluators/ast.evaluator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rendering/expression-parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/index.ts"],"names":[],"mappings":"AAGA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAKhC,cAAc,uBAAuB,CAAC;AAKtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/rendering/expression-parser/index.js

@@ -0,0 +1,15 @@
+// ============================================================================
+// Types and Interfaces
+// ============================================================================
+export * from "./types.js";
+export * from "./interfaces.js";
+// ============================================================================
+// Evaluators (Strategy Pattern implementations)
+// ============================================================================
+export * from "./evaluators/index.js";
+// ============================================================================
+// Services
+// ============================================================================
+export { ExpressionParserService } from "./expression-parser.service.js";
+export { ASTEvaluator } from "./evaluators/ast.evaluator.js";
+//# sourceMappingURL=index.js.map

package/dist/rendering/expression-parser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/rendering/expression-parser/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,uBAAuB;AACvB,+EAA+E;AAC/E,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAEhC,+EAA+E;AAC/E,gDAAgD;AAChD,+EAA+E;AAC/E,cAAc,uBAAuB,CAAC;AAEtC,+EAA+E;AAC/E,WAAW;AACX,+EAA+E;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/rendering/expression-parser/interfaces.d.ts

@@ -0,0 +1,41 @@
+import type { ASTNode, ParsedExpression } from "./types.js";
+/**
+ * Defines the responsibility of evaluating AST nodes within a given scope.
+ * This interface enables dependency inversion for expression evaluation.
+ */
+export interface IEvaluator {
+    /**
+     * Evaluates an AST node within the provided scope.
+     * @param node - The AST node to evaluate
+     * @param scope - The evaluation scope containing variable bindings
+     * @returns The result of evaluating the AST node
+     * @throws Error if evaluation fails or encounters invalid operations
+     *
+     * @example
+     * ```typescript
+     * const evaluator = new ASTEvaluator();
+     * const result = evaluator.evaluate(astNode, { x: 42 });
+     * ```
+     */
+    evaluate(node: ASTNode, scope: Record<string, unknown>): unknown;
+}
+/**
+ * Defines the responsibility of parsing, evaluating, and analyzing expressions.
+ * This interface follows Interface Segregation Principle by providing a unified
+ * contract for expression processing operations used by rendering components.
+ */
+export interface IExpressionParser {
+    /**
+     * Parses an expression string into a structured representation.
+     * @param expression - The expression string to parse
+     * @returns The parsed expression with AST and dependencies
+     * @throws Error if the expression contains syntax errors
+     *
+     * @example
+     * ```typescript
+     * const parsed = parser.parse('user.name + " " + user.age');
+     * ```
+     */
+    parse(expression: string): ParsedExpression;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/rendering/expression-parser/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE5D;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;CAClE;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;OAUG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAAC;CAC7C"}

package/dist/rendering/expression-parser/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interfaces.js.map

package/dist/rendering/expression-parser/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../src/rendering/expression-parser/interfaces.ts"],"names":[],"mappings":""}

package/dist/rendering/expression-parser/parser.d.ts

@@ -0,0 +1,135 @@
+import { type Token, type ASTNode } from "./types.js";
+/**
+ * Implements the responsibility of converting token sequences into Abstract Syntax Trees.
+ * This recursive descent parser handles the complete expression grammar with proper
+ * operator precedence. Follows SRP by focusing solely on parsing logic.
+ */
+export declare class Parser {
+    private static readonly MAX_DEPTH;
+    private tokens;
+    private position;
+    private depth;
+    /**
+     * Initializes a new instance of Parser.
+     *
+     * @param tokens - The token sequence to parse
+     * @throws Error if tokens is null or undefined
+     */
+    constructor(tokens: Token[]);
+    /**
+     * Returns the current token without advancing the position.
+     * @returns The current token
+     * @private
+     */
+    private peek;
+    /**
+     * Returns the current token and advances the position.
+     * @returns The current token
+     * @private
+     */
+    private advance;
+    /**
+     * Expects and consumes a token of the specified type.
+     * @param type - The expected token type
+     * @returns The consumed token
+     * @throws Error if the current token doesn't match the expected type
+     * @private
+     */
+    private expect;
+    /**
+     * Parses the complete expression starting from the top level.
+     * This is the main entry point for parsing.
+     *
+     * @returns The root AST node of the parsed expression
+     * @throws Error if parsing fails due to syntax errors
+     *
+     * @example
+     * ```typescript
+     * const parser = new Parser(tokens);
+     * const ast = parser.parse();
+     * ```
+     */
+    parse(): ASTNode;
+    /**
+     * Parses conditional (ternary) expressions: test ? consequent : alternate.
+     * Has lower precedence than logical operators.
+     *
+     * @returns The parsed conditional or logical OR expression
+     * @private
+     */
+    private parseConditional;
+    /**
+     * Parses logical OR expressions (||).
+     * Left-associative with lower precedence than logical AND.
+     *
+     * @returns The parsed logical OR expression
+     * @private
+     */
+    private parseLogicalOr;
+    /**
+     * Parses logical AND expressions (&&).
+     * Left-associative with higher precedence than logical OR.
+     *
+     * @returns The parsed logical AND expression
+     * @private
+     */
+    private parseLogicalAnd;
+    /**
+     * Parses equality expressions (===, !==).
+     * Left-associative with higher precedence than logical operators.
+     *
+     * @returns The parsed equality expression
+     * @private
+     */
+    private parseEquality;
+    /**
+     * Parses comparison expressions (>, <, >=, <=).
+     * Left-associative with higher precedence than equality operators.
+     *
+     * @returns The parsed comparison expression
+     * @private
+     */
+    private parseComparison;
+    /**
+     * Parses additive expressions (+, -).
+     * Left-associative with higher precedence than comparison operators.
+     *
+     * @returns The parsed additive expression
+     * @private
+     */
+    private parseAdditive;
+    /**
+     * Parses multiplicative expressions (*, /, %).
+     * Left-associative with higher precedence than additive operators.
+     *
+     * @returns The parsed multiplicative expression
+     * @private
+     */
+    private parseMultiplicative;
+    /**
+     * Parses unary expressions (!, -, +).
+     * Right-associative with higher precedence than binary operators.
+     *
+     * @returns The parsed unary expression
+     * @private
+     */
+    private parseUnary;
+    /**
+     * Parses member access and method calls (obj.prop, obj.method()).
+     * Handles both property access and function calls with proper precedence.
+     *
+     * @returns The parsed member/call expression
+     * @private
+     */
+    private parseCallOrMember;
+    /**
+     * Parses primary expressions (literals, identifiers, parenthesized).
+     * These are the highest precedence expressions that don't contain other expressions.
+     *
+     * @returns The parsed primary expression
+     * @throws Error if an unexpected token is encountered
+     * @private
+     */
+    private parsePrimary;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/rendering/expression-parser/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAM;IACvC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,KAAK,CAAa;IAE1B;;;;;OAKG;gBACS,MAAM,EAAE,KAAK,EAAE;IAK3B;;;;OAIG;IACH,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAIf;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;IAUd;;;;;;;;;;;;OAYG;IACI,KAAK,IAAI,OAAO;IAIvB;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IA8BxB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAiBtB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAiBvB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAiBrB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAiBrB;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAqB3B;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAkBlB;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAoDrB"}

package/dist/rendering/expression-parser/parser.js

@@ -0,0 +1,345 @@
+import { TokenType } from "./types.js";
+/**
+ * Implements the responsibility of converting token sequences into Abstract Syntax Trees.
+ * This recursive descent parser handles the complete expression grammar with proper
+ * operator precedence. Follows SRP by focusing solely on parsing logic.
+ */
+export class Parser {
+    static MAX_DEPTH = 32;
+    tokens;
+    position = 0;
+    depth = 0;
+    /**
+     * Initializes a new instance of Parser.
+     *
+     * @param tokens - The token sequence to parse
+     * @throws Error if tokens is null or undefined
+     */
+    constructor(tokens) {
+        if (!tokens)
+            throw new Error("Tokens array is required");
+        this.tokens = tokens;
+    }
+    /**
+     * Returns the current token without advancing the position.
+     * @returns The current token
+     * @private
+     */
+    peek() {
+        return this.tokens[this.position];
+    }
+    /**
+     * Returns the current token and advances the position.
+     * @returns The current token
+     * @private
+     */
+    advance() {
+        return this.tokens[this.position++];
+    }
+    /**
+     * Expects and consumes a token of the specified type.
+     * @param type - The expected token type
+     * @returns The consumed token
+     * @throws Error if the current token doesn't match the expected type
+     * @private
+     */
+    expect(type) {
+        const token = this.peek();
+        if (token.type !== type) {
+            throw new Error(`Expected ${type} but got ${token.type} at position ${token.position}`);
+        }
+        return this.advance();
+    }
+    /**
+     * Parses the complete expression starting from the top level.
+     * This is the main entry point for parsing.
+     *
+     * @returns The root AST node of the parsed expression
+     * @throws Error if parsing fails due to syntax errors
+     *
+     * @example
+     * ```typescript
+     * const parser = new Parser(tokens);
+     * const ast = parser.parse();
+     * ```
+     */
+    parse() {
+        return this.parseConditional();
+    }
+    /**
+     * Parses conditional (ternary) expressions: test ? consequent : alternate.
+     * Has lower precedence than logical operators.
+     *
+     * @returns The parsed conditional or logical OR expression
+     * @private
+     */
+    parseConditional() {
+        let node = this.parseLogicalOr();
+        if (this.peek().type === TokenType.QUESTION) {
+            if (++this.depth > Parser.MAX_DEPTH) {
+                throw new Error(`Expression nesting depth exceeds maximum of ${Parser.MAX_DEPTH}`);
+            }
+            try {
+                this.advance(); // consume '?'
+                const consequent = this.parseLogicalOr();
+                this.expect(TokenType.COLON); // expect ':'
+                const alternate = this.parseConditional(); // right-associative
+                node = {
+                    type: "ConditionalExpression",
+                    test: node,
+                    consequent,
+                    alternate,
+                };
+            }
+            finally {
+                this.depth--;
+            }
+        }
+        return node;
+    }
+    /**
+     * Parses logical OR expressions (||).
+     * Left-associative with lower precedence than logical AND.
+     *
+     * @returns The parsed logical OR expression
+     * @private
+     */
+    parseLogicalOr() {
+        let left = this.parseLogicalAnd();
+        while (this.peek().type === TokenType.OR) {
+            const operator = this.advance().value;
+            const right = this.parseLogicalAnd();
+            left = {
+                type: "BinaryExpression",
+                operator,
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses logical AND expressions (&&).
+     * Left-associative with higher precedence than logical OR.
+     *
+     * @returns The parsed logical AND expression
+     * @private
+     */
+    parseLogicalAnd() {
+        let left = this.parseEquality();
+        while (this.peek().type === TokenType.AND) {
+            const operator = this.advance().value;
+            const right = this.parseEquality();
+            left = {
+                type: "BinaryExpression",
+                operator,
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses equality expressions (===, !==).
+     * Left-associative with higher precedence than logical operators.
+     *
+     * @returns The parsed equality expression
+     * @private
+     */
+    parseEquality() {
+        let left = this.parseComparison();
+        while ([TokenType.EQUAL, TokenType.NOT_EQUAL].includes(this.peek().type)) {
+            const operator = this.advance().value;
+            const right = this.parseComparison();
+            left = {
+                type: "BinaryExpression",
+                operator,
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses comparison expressions (>, <, >=, <=).
+     * Left-associative with higher precedence than equality operators.
+     *
+     * @returns The parsed comparison expression
+     * @private
+     */
+    parseComparison() {
+        let left = this.parseAdditive();
+        while ([TokenType.GT, TokenType.LT, TokenType.GTE, TokenType.LTE].includes(this.peek().type)) {
+            const operator = this.advance().value;
+            const right = this.parseAdditive();
+            left = {
+                type: "BinaryExpression",
+                operator,
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses additive expressions (+, -).
+     * Left-associative with higher precedence than comparison operators.
+     *
+     * @returns The parsed additive expression
+     * @private
+     */
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while ([TokenType.PLUS, TokenType.MINUS].includes(this.peek().type)) {
+            const operator = this.advance().value;
+            const right = this.parseMultiplicative();
+            left = {
+                type: "BinaryExpression",
+                operator,
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses multiplicative expressions (*, /, %).
+     * Left-associative with higher precedence than additive operators.
+     *
+     * @returns The parsed multiplicative expression
+     * @private
+     */
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while ([TokenType.MULTIPLY, TokenType.DIVIDE, TokenType.MODULO].includes(this.peek().type)) {
+            const operator = this.advance().value;
+            const right = this.parseUnary();
+            left = {
+                type: "BinaryExpression",
+                operator,
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses unary expressions (!, -, +).
+     * Right-associative with higher precedence than binary operators.
+     *
+     * @returns The parsed unary expression
+     * @private
+     */
+    parseUnary() {
+        if ([TokenType.NOT, TokenType.MINUS, TokenType.PLUS].includes(this.peek().type)) {
+            const operator = this.advance().value;
+            const argument = this.parseUnary();
+            return {
+                type: "UnaryExpression",
+                operator,
+                argument,
+            };
+        }
+        return this.parseCallOrMember();
+    }
+    /**
+     * Parses member access and method calls (obj.prop, obj.method()).
+     * Handles both property access and function calls with proper precedence.
+     *
+     * @returns The parsed member/call expression
+     * @private
+     */
+    parseCallOrMember() {
+        let expr = this.parsePrimary();
+        let keepParsing = true;
+        while (keepParsing) {
+            const token = this.peek();
+            // Member access: obj.prop or obj?.prop
+            if (token.type === TokenType.DOT ||
+                token.type === TokenType.OPTIONAL_CHAIN) {
+                const optional = token.type === TokenType.OPTIONAL_CHAIN;
+                this.advance();
+                const property = this.expect(TokenType.IDENTIFIER);
+                expr = {
+                    type: "MemberExpression",
+                    object: expr,
+                    property: { type: "Identifier", name: property.value },
+                    optional,
+                };
+                // Check for method call: obj.method()
+                if (this.peek().type === TokenType.LPAREN) {
+                    this.advance(); // consume (
+                    const args = [];
+                    while (this.peek().type !== TokenType.RPAREN) {
+                        args.push(this.parseLogicalOr());
+                        if (this.peek().type === TokenType.COMMA) {
+                            this.advance();
+                        }
+                    }
+                    this.expect(TokenType.RPAREN);
+                    expr = {
+                        type: "CallExpression",
+                        callee: expr,
+                        arguments: args,
+                    };
+                }
+            }
+            else {
+                keepParsing = false;
+            }
+        }
+        return expr;
+    }
+    /**
+     * Parses primary expressions (literals, identifiers, parenthesized).
+     * These are the highest precedence expressions that don't contain other expressions.
+     *
+     * @returns The parsed primary expression
+     * @throws Error if an unexpected token is encountered
+     * @private
+     */
+    parsePrimary() {
+        const token = this.peek();
+        // Number literal
+        if (token.type === TokenType.NUMBER) {
+            this.advance();
+            return {
+                type: "Literal",
+                value: parseFloat(token.value),
+            };
+        }
+        // String literal
+        if (token.type === TokenType.STRING) {
+            this.advance();
+            return {
+                type: "Literal",
+                value: token.value,
+            };
+        }
+        // Identifier
+        if (token.type === TokenType.IDENTIFIER) {
+            this.advance();
+            return {
+                type: "Identifier",
+                name: token.value,
+            };
+        }
+        // Parenthesized expression
+        if (token.type === TokenType.LPAREN) {
+            if (++this.depth > Parser.MAX_DEPTH) {
+                throw new Error(`Expression nesting depth exceeds maximum of ${Parser.MAX_DEPTH}`);
+            }
+            try {
+                this.advance();
+                const expr = this.parseLogicalOr();
+                this.expect(TokenType.RPAREN);
+                return expr;
+            }
+            finally {
+                this.depth--;
+            }
+        }
+        throw new Error(`Unexpected token ${token.type} at position ${token.position}`);
+    }
+}
+//# sourceMappingURL=parser.js.map