leangraph 1.0.0

package/dist/parser.js

@@ -0,0 +1,2711 @@
+// Cypher Parser - Types and Implementation
+const KEYWORDS = new Set([
+    "CREATE",
+    "MATCH",
+    "MERGE",
+    "SET",
+    "DELETE",
+    "DETACH",
+    "RETURN",
+    "WHERE",
+    "AND",
+    "OR",
+    "XOR",
+    "NOT",
+    "IN",
+    "LIMIT",
+    "SKIP",
+    "ORDER",
+    "BY",
+    "ASC",
+    "ASCENDING",
+    "DESC",
+    "DESCENDING",
+    "COUNT",
+    "ON",
+    "TRUE",
+    "FALSE",
+    "NULL",
+    "CONTAINS",
+    "STARTS",
+    "ENDS",
+    "WITH",
+    "AS",
+    "IS",
+    "DISTINCT",
+    "OPTIONAL",
+    "UNWIND",
+    "CASE",
+    "WHEN",
+    "THEN",
+    "ELSE",
+    "END",
+    "EXISTS",
+    "UNION",
+    "ALL",
+    "ANY",
+    "NONE",
+    "SINGLE",
+    "CALL",
+    "YIELD",
+    "REMOVE",
+]);
+class Tokenizer {
+    input;
+    pos = 0;
+    line = 1;
+    column = 1;
+    tokens = [];
+    constructor(input) {
+        this.input = input;
+    }
+    canStartNegativeNumber() {
+        const prev = this.tokens[this.tokens.length - 1];
+        if (!prev)
+            return true;
+        // Allow "-1" to be tokenized as a single NUMBER only where a new expression
+        // can start. Otherwise (e.g., "x-1") it must be DASH + NUMBER.
+        switch (prev.type) {
+            case "LPAREN":
+            case "COMMA":
+            case "LBRACKET":
+            case "LBRACE":
+            case "COLON":
+            case "EQUALS":
+            case "NOT_EQUALS":
+            case "LT":
+            case "LTE":
+            case "GT":
+            case "GTE":
+            case "PLUS":
+            case "DASH":
+            case "STAR":
+            case "SLASH":
+            case "PERCENT":
+            case "CARET":
+            case "PIPE":
+            case "KEYWORD":
+                return true;
+            default:
+                return false;
+        }
+    }
+    tokenize() {
+        while (this.pos < this.input.length) {
+            this.skipTrivia();
+            if (this.pos >= this.input.length)
+                break;
+            const token = this.nextToken();
+            if (token) {
+                this.tokens.push(token);
+            }
+        }
+        this.tokens.push({
+            type: "EOF",
+            value: "",
+            position: this.pos,
+            line: this.line,
+            column: this.column,
+        });
+        return this.tokens;
+    }
+    skipTrivia() {
+        while (this.pos < this.input.length) {
+            this.skipWhitespace();
+            if (this.pos >= this.input.length)
+                return;
+            const char = this.input[this.pos];
+            const next = this.input[this.pos + 1];
+            // Line comment: // ... (until end of line)
+            if (char === "/" && next === "/") {
+                this.pos += 2;
+                this.column += 2;
+                while (this.pos < this.input.length) {
+                    const c = this.input[this.pos];
+                    if (c === "\n" || c === "\r")
+                        break;
+                    this.pos++;
+                    this.column++;
+                }
+                continue;
+            }
+            // Block comment: /* ... */
+            if (char === "/" && next === "*") {
+                const commentStart = this.pos;
+                this.pos += 2;
+                this.column += 2;
+                while (this.pos < this.input.length) {
+                    const c = this.input[this.pos];
+                    const n = this.input[this.pos + 1];
+                    if (c === "*" && n === "/") {
+                        this.pos += 2;
+                        this.column += 2;
+                        break;
+                    }
+                    if (c === "\n") {
+                        this.pos++;
+                        this.line++;
+                        this.column = 1;
+                        continue;
+                    }
+                    if (c === "\r") {
+                        this.pos++;
+                        if (this.input[this.pos] === "\n") {
+                            this.pos++;
+                        }
+                        this.line++;
+                        this.column = 1;
+                        continue;
+                    }
+                    this.pos++;
+                    this.column++;
+                }
+                if (this.pos >= this.input.length && !(this.input[this.pos - 2] === "*" && this.input[this.pos - 1] === "/")) {
+                    throw new Error(`Unterminated block comment at position ${commentStart}`);
+                }
+                continue;
+            }
+            return;
+        }
+    }
+    skipWhitespace() {
+        while (this.pos < this.input.length) {
+            const char = this.input[this.pos];
+            if (char === " " || char === "\t") {
+                this.pos++;
+                this.column++;
+            }
+            else if (char === "\n") {
+                this.pos++;
+                this.line++;
+                this.column = 1;
+            }
+            else if (char === "\r") {
+                this.pos++;
+                if (this.input[this.pos] === "\n") {
+                    this.pos++;
+                }
+                this.line++;
+                this.column = 1;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    nextToken() {
+        const startPos = this.pos;
+        const startLine = this.line;
+        const startColumn = this.column;
+        const char = this.input[this.pos];
+        // Two-character operators
+        if (this.pos + 1 < this.input.length) {
+            const twoChars = this.input.slice(this.pos, this.pos + 2);
+            if (twoChars === "<-") {
+                this.pos += 2;
+                this.column += 2;
+                return { type: "ARROW_LEFT", value: "<-", position: startPos, line: startLine, column: startColumn };
+            }
+            if (twoChars === "->") {
+                this.pos += 2;
+                this.column += 2;
+                return { type: "ARROW_RIGHT", value: "->", position: startPos, line: startLine, column: startColumn };
+            }
+            if (twoChars === "<>") {
+                this.pos += 2;
+                this.column += 2;
+                return { type: "NOT_EQUALS", value: "<>", position: startPos, line: startLine, column: startColumn };
+            }
+            if (twoChars === "<=") {
+                this.pos += 2;
+                this.column += 2;
+                return { type: "LTE", value: "<=", position: startPos, line: startLine, column: startColumn };
+            }
+            if (twoChars === ">=") {
+                this.pos += 2;
+                this.column += 2;
+                return { type: "GTE", value: ">=", position: startPos, line: startLine, column: startColumn };
+            }
+        }
+        // Single character tokens
+        const singleCharTokens = {
+            "(": "LPAREN",
+            ")": "RPAREN",
+            "[": "LBRACKET",
+            "]": "RBRACKET",
+            "{": "LBRACE",
+            "}": "RBRACE",
+            ":": "COLON",
+            ",": "COMMA",
+            ".": "DOT",
+            "-": "DASH",
+            "+": "PLUS",
+            "/": "SLASH",
+            "%": "PERCENT",
+            "^": "CARET",
+            "=": "EQUALS",
+            "<": "LT",
+            ">": "GT",
+            "*": "STAR",
+            "|": "PIPE",
+        };
+        // Number - includes floats starting with . like .5
+        // Check this before single char tokens so ".5" is parsed as number not DOT
+        // But don't match "..3" as ".3" - only match if there's no preceding dot
+        if (this.isDigit(char) ||
+            (char === "-" && this.isDigit(this.input[this.pos + 1]) && this.canStartNegativeNumber()) ||
+            (char === "." && this.isDigit(this.input[this.pos + 1]) && (this.pos === 0 || this.input[this.pos - 1] !== "."))) {
+            return this.readNumber(startPos, startLine, startColumn);
+        }
+        if (singleCharTokens[char]) {
+            this.pos++;
+            this.column++;
+            return { type: singleCharTokens[char], value: char, position: startPos, line: startLine, column: startColumn };
+        }
+        // Parameter
+        if (char === "$") {
+            this.pos++;
+            this.column++;
+            const name = this.readIdentifier();
+            return { type: "PARAMETER", value: name, position: startPos, line: startLine, column: startColumn };
+        }
+        // String
+        if (char === "'" || char === '"') {
+            return this.readString(char, startPos, startLine, startColumn);
+        }
+        // Backtick-delimited identifier (escaped identifier)
+        if (char === "`") {
+            return this.readBacktickIdentifier(startPos, startLine, startColumn);
+        }
+        // Identifier or keyword
+        if (this.isIdentifierStart(char)) {
+            const value = this.readIdentifier();
+            const upperValue = value.toUpperCase();
+            const type = KEYWORDS.has(upperValue) ? "KEYWORD" : "IDENTIFIER";
+            // Keywords store uppercase for matching, but we also preserve original casing for when keywords are used as identifiers
+            return { type, value: type === "KEYWORD" ? upperValue : value, originalValue: value, position: startPos, line: startLine, column: startColumn };
+        }
+        throw new Error(`Unexpected character '${char}' at position ${this.pos}`);
+    }
+    readString(quote, startPos, startLine, startColumn) {
+        this.pos++;
+        this.column++;
+        let value = "";
+        while (this.pos < this.input.length) {
+            const char = this.input[this.pos];
+            if (char === quote) {
+                this.pos++;
+                this.column++;
+                return { type: "STRING", value, position: startPos, line: startLine, column: startColumn };
+            }
+            if (char === "\\") {
+                this.pos++;
+                this.column++;
+                const escaped = this.input[this.pos];
+                if (escaped === "n") {
+                    value += "\n";
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === "t") {
+                    value += "\t";
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === "r") {
+                    value += "\r";
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === "b") {
+                    value += "\b";
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === "f") {
+                    value += "\f";
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === "\\") {
+                    value += "\\";
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === quote) {
+                    value += quote;
+                    this.pos++;
+                    this.column++;
+                }
+                else if (escaped === "u") {
+                    // Unicode escape: \uXXXX (4 hex digits required)
+                    this.pos++;
+                    this.column++;
+                    const hexStart = this.pos;
+                    let hex = "";
+                    for (let i = 0; i < 4; i++) {
+                        if (this.pos >= this.input.length) {
+                            throw new SyntaxError(`Invalid unicode escape sequence: incomplete \\u escape at position ${hexStart - 2}`);
+                        }
+                        const c = this.input[this.pos];
+                        if (!/[0-9a-fA-F]/.test(c)) {
+                            throw new SyntaxError(`Invalid unicode escape sequence: \\u${hex}${c}`);
+                        }
+                        hex += c;
+                        this.pos++;
+                        this.column++;
+                    }
+                    value += String.fromCharCode(parseInt(hex, 16));
+                }
+                else {
+                    value += escaped;
+                    this.pos++;
+                    this.column++;
+                }
+            }
+            else {
+                value += char;
+                this.pos++;
+                this.column++;
+            }
+        }
+        throw new Error(`Unterminated string at position ${startPos}`);
+    }
+    readNumber(startPos, startLine, startColumn) {
+        let value = "";
+        if (this.input[this.pos] === "-") {
+            value += "-";
+            this.pos++;
+            this.column++;
+        }
+        // Handle numbers starting with . like .5
+        if (this.input[this.pos] === ".") {
+            value += "0.";
+            this.pos++;
+            this.column++;
+            while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+                value += this.input[this.pos];
+                this.pos++;
+                this.column++;
+            }
+            // Handle scientific notation for numbers starting with . (e.g., .5e10)
+            if (this.input[this.pos] === "e" || this.input[this.pos] === "E") {
+                const nextChar = this.input[this.pos + 1];
+                if (this.isDigit(nextChar) ||
+                    ((nextChar === "+" || nextChar === "-") && this.isDigit(this.input[this.pos + 2]))) {
+                    value += this.input[this.pos]; // 'e' or 'E'
+                    this.pos++;
+                    this.column++;
+                    if (this.input[this.pos] === "+" || this.input[this.pos] === "-") {
+                        value += this.input[this.pos];
+                        this.pos++;
+                        this.column++;
+                    }
+                    while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+                        value += this.input[this.pos];
+                        this.pos++;
+                        this.column++;
+                    }
+                }
+            }
+            return { type: "NUMBER", value, position: startPos, line: startLine, column: startColumn };
+        }
+        // Check for hexadecimal: 0x or 0X
+        if (this.input[this.pos] === "0" && (this.input[this.pos + 1] === "x" || this.input[this.pos + 1] === "X")) {
+            value += "0x";
+            this.pos += 2;
+            this.column += 2;
+            // Must have at least one hex digit
+            if (!this.isHexDigit(this.input[this.pos])) {
+                throw new SyntaxError(`Invalid hexadecimal integer: incomplete hex literal`);
+            }
+            // Read hex digits
+            while (this.pos < this.input.length && this.isHexDigit(this.input[this.pos])) {
+                value += this.input[this.pos];
+                this.pos++;
+                this.column++;
+            }
+            // Check for invalid characters immediately following (e.g., 0x1g)
+            if (this.pos < this.input.length && this.isIdentifierChar(this.input[this.pos])) {
+                throw new SyntaxError(`Invalid hexadecimal integer: invalid character '${this.input[this.pos]}'`);
+            }
+            return { type: "NUMBER", value, position: startPos, line: startLine, column: startColumn };
+        }
+        while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+            value += this.input[this.pos];
+            this.pos++;
+            this.column++;
+        }
+        // Only read decimal part if . is followed by a digit (not another .)
+        // This prevents "1..2" from being tokenized as "1." + "." + "2"
+        if (this.input[this.pos] === "." && this.isDigit(this.input[this.pos + 1])) {
+            value += ".";
+            this.pos++;
+            this.column++;
+            while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+                value += this.input[this.pos];
+                this.pos++;
+                this.column++;
+            }
+        }
+        // Handle scientific notation (e.g., 1e9, 1E-9, 1.5e+10)
+        if (this.input[this.pos] === "e" || this.input[this.pos] === "E") {
+            const nextChar = this.input[this.pos + 1];
+            // Check if followed by digit, + digit, or - digit
+            if (this.isDigit(nextChar) ||
+                ((nextChar === "+" || nextChar === "-") && this.isDigit(this.input[this.pos + 2]))) {
+                value += this.input[this.pos]; // 'e' or 'E'
+                this.pos++;
+                this.column++;
+                // Handle optional sign
+                if (this.input[this.pos] === "+" || this.input[this.pos] === "-") {
+                    value += this.input[this.pos];
+                    this.pos++;
+                    this.column++;
+                }
+                // Read exponent digits
+                while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+                    value += this.input[this.pos];
+                    this.pos++;
+                    this.column++;
+                }
+            }
+        }
+        return { type: "NUMBER", value, position: startPos, line: startLine, column: startColumn };
+    }
+    isHexDigit(char) {
+        return (char >= "0" && char <= "9") ||
+            (char >= "a" && char <= "f") ||
+            (char >= "A" && char <= "F");
+    }
+    readIdentifier() {
+        let value = "";
+        while (this.pos < this.input.length && this.isIdentifierChar(this.input[this.pos])) {
+            value += this.input[this.pos];
+            this.pos++;
+            this.column++;
+        }
+        return value;
+    }
+    readBacktickIdentifier(startPos, startLine, startColumn) {
+        this.pos++; // consume opening backtick
+        this.column++;
+        let value = "";
+        while (this.pos < this.input.length) {
+            const char = this.input[this.pos];
+            if (char === "`") {
+                // Check for escaped backtick (double backtick)
+                if (this.input[this.pos + 1] === "`") {
+                    value += "`";
+                    this.pos += 2;
+                    this.column += 2;
+                    continue;
+                }
+                // End of identifier
+                this.pos++;
+                this.column++;
+                return { type: "IDENTIFIER", value, position: startPos, line: startLine, column: startColumn };
+            }
+            if (char === "\n") {
+                this.line++;
+                this.column = 0; // Will be incremented below
+            }
+            value += char;
+            this.pos++;
+            this.column++;
+        }
+        throw new Error(`Unterminated backtick identifier at position ${startPos}`);
+    }
+    isDigit(char) {
+        return char >= "0" && char <= "9";
+    }
+    isIdentifierStart(char) {
+        return (char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || char === "_";
+    }
+    isIdentifierChar(char) {
+        return this.isIdentifierStart(char) || this.isDigit(char);
+    }
+}
+// ============================================================================
+// Parser
+// ============================================================================
+// Int64 range constants
+const INT64_MAX = BigInt("9223372036854775807");
+const INT64_MIN = BigInt("-9223372036854775808");
+export class Parser {
+    tokens = [];
+    pos = 0;
+    anonVarCounter = 0;
+    /**
+     * Parse a number string, validating that integers are within int64 range.
+     * Throws SyntaxError for overflow.
+     */
+    parseNumber(numStr) {
+        // Check if it's a hexadecimal integer
+        const isHex = numStr.includes('0x') || numStr.includes('0X');
+        const isNegativeHex = isHex && numStr.startsWith('-');
+        // Check if it has scientific notation (e.g., 1e9, 1.5E-10)
+        const hasExponent = numStr.includes('e') || numStr.includes('E');
+        // Check if it's an integer (no decimal point, no exponent, and not hex, or is hex)
+        if ((!numStr.includes('.') && !hasExponent) || isHex) {
+            try {
+                let bigVal;
+                if (isHex) {
+                    // For hex, we need to parse as unsigned first, then apply sign
+                    const hexPart = isNegativeHex ? numStr.slice(1) : numStr; // Remove leading minus if present
+                    const unsignedVal = BigInt(hexPart);
+                    bigVal = isNegativeHex ? -unsignedVal : unsignedVal;
+                }
+                else {
+                    bigVal = BigInt(numStr);
+                }
+                if (bigVal > INT64_MAX || bigVal < INT64_MIN) {
+                    throw new SyntaxError(`integer is too large: ${numStr}`);
+                }
+                return Number(bigVal);
+            }
+            catch (e) {
+                if (e instanceof SyntaxError)
+                    throw e;
+                // BigInt parsing failed - could be too large even for BigInt
+                throw new SyntaxError(`integer is too large: ${numStr}`);
+            }
+        }
+        const floatVal = parseFloat(numStr);
+        // Check for overflow (Infinity) or underflow to 0 for very small exponents
+        if (!Number.isFinite(floatVal)) {
+            throw new SyntaxError(`floating point number is too large: ${numStr}`);
+        }
+        return floatVal;
+    }
+    parse(input) {
+        try {
+            const tokenizer = new Tokenizer(input);
+            this.tokens = tokenizer.tokenize();
+            this.pos = 0;
+            const query = this.parseQuery();
+            if (query.clauses.length === 0) {
+                return this.error("Empty query");
+            }
+            return { success: true, query };
+        }
+        catch (e) {
+            const currentToken = this.tokens[this.pos] || this.tokens[this.tokens.length - 1];
+            return {
+                success: false,
+                error: {
+                    message: e instanceof Error ? e.message : String(e),
+                    position: currentToken?.position ?? 0,
+                    line: currentToken?.line ?? 1,
+                    column: currentToken?.column ?? 1,
+                },
+            };
+        }
+    }
+    parseQuery() {
+        // Parse clauses until we hit UNION or end
+        const clauses = [];
+        while (!this.isAtEnd() && !this.checkKeyword("UNION")) {
+            const clause = this.parseClause();
+            if (clause) {
+                clauses.push(clause);
+            }
+        }
+        // Check for UNION
+        if (this.checkKeyword("UNION")) {
+            this.advance(); // consume UNION
+            // Check for ALL
+            const all = this.checkKeyword("ALL");
+            if (all) {
+                this.advance();
+            }
+            // Parse the right side of the UNION
+            const rightQuery = this.parseQuery();
+            // Cypher disallows mixing `UNION` and `UNION ALL` within the same query.
+            // Since our grammar nests UNIONs on the right, we only need to compare the
+            // current UNION modifier with the next UNION (if present).
+            if (rightQuery.clauses.length === 1 && rightQuery.clauses[0]?.type === "UNION") {
+                const rightUnion = rightQuery.clauses[0];
+                if (rightUnion.all !== all) {
+                    throw new SyntaxError("InvalidClauseComposition");
+                }
+            }
+            // Create a UNION clause that wraps both queries
+            const unionClause = {
+                type: "UNION",
+                all,
+                left: { clauses },
+                right: rightQuery,
+            };
+            return { clauses: [unionClause] };
+        }
+        return { clauses };
+    }
+    error(message) {
+        const currentToken = this.tokens[this.pos] || this.tokens[this.tokens.length - 1];
+        return {
+            success: false,
+            error: {
+                message,
+                position: currentToken?.position ?? 0,
+                line: currentToken?.line ?? 1,
+                column: currentToken?.column ?? 1,
+            },
+        };
+    }
+    parseClause() {
+        const token = this.peek();
+        if (token.type === "EOF")
+            return null;
+        if (token.type !== "KEYWORD") {
+            throw new Error(`Unexpected token '${token.value}', expected a clause keyword like CREATE, MATCH, MERGE, SET, DELETE, or RETURN`);
+        }
+        switch (token.value) {
+            case "CREATE":
+                return this.parseCreate();
+            case "MATCH":
+                return this.parseMatch(false);
+            case "OPTIONAL":
+                return this.parseOptionalMatch();
+            case "MERGE":
+                return this.parseMerge();
+            case "SET":
+                return this.parseSet();
+            case "DELETE":
+            case "DETACH":
+                return this.parseDelete();
+            case "REMOVE":
+                return this.parseRemove();
+            case "RETURN":
+                return this.parseReturn();
+            case "WITH":
+                return this.parseWith();
+            case "UNWIND":
+                return this.parseUnwind();
+            case "CALL":
+                return this.parseCall();
+            default:
+                throw new Error(`Unexpected keyword '${token.value}'`);
+        }
+    }
+    parseCreate() {
+        this.expect("KEYWORD", "CREATE");
+        const patterns = [];
+        patterns.push(...this.parsePatternChain());
+        while (this.check("COMMA")) {
+            this.advance();
+            patterns.push(...this.parsePatternChain());
+        }
+        // Validate: CREATE requires relationship type and direction
+        for (const pattern of patterns) {
+            if ("edge" in pattern) {
+                // This is a RelationshipPattern
+                if (!pattern.edge.type && !pattern.edge.types) {
+                    throw new Error("A relationship type is required to create a relationship");
+                }
+                if (pattern.edge.direction === "none") {
+                    throw new Error("Only directed relationships are supported in CREATE");
+                }
+                // Multiple relationship types are not allowed in CREATE
+                if (pattern.edge.types && pattern.edge.types.length > 1) {
+                    throw new Error("A single relationship type must be specified for CREATE");
+                }
+                // Variable-length patterns are not allowed in CREATE
+                if (pattern.edge.minHops !== undefined || pattern.edge.maxHops !== undefined) {
+                    throw new Error("Variable length relationship patterns are not supported in CREATE");
+                }
+            }
+        }
+        return { type: "CREATE", patterns };
+    }
+    parseMatch(optional = false) {
+        this.expect("KEYWORD", "MATCH");
+        const patterns = [];
+        const pathExpressions = [];
+        // Parse first pattern or path expression
+        const firstPattern = this.parsePatternOrPath();
+        if ("type" in firstPattern && firstPattern.type === "path") {
+            pathExpressions.push(firstPattern);
+        }
+        else {
+            patterns.push(...(Array.isArray(firstPattern) ? firstPattern : [firstPattern]));
+        }
+        while (this.check("COMMA")) {
+            this.advance();
+            const nextPattern = this.parsePatternOrPath();
+            if ("type" in nextPattern && nextPattern.type === "path") {
+                pathExpressions.push(nextPattern);
+            }
+            else {
+                patterns.push(...(Array.isArray(nextPattern) ? nextPattern : [nextPattern]));
+            }
+        }
+        // Validate: same variable cannot be used as both node and relationship
+        this.validateNoNodeRelationshipVariableConflict(patterns, pathExpressions);
+        let where;
+        if (this.checkKeyword("WHERE")) {
+            this.advance();
+            where = this.parseWhereCondition();
+        }
+        return {
+            type: optional ? "OPTIONAL_MATCH" : "MATCH",
+            patterns,
+            pathExpressions: pathExpressions.length > 0 ? pathExpressions : undefined,
+            where
+        };
+    }
+    /**
+     * Parse either a regular pattern chain or a named path expression.
+     * Syntax: p = (a)-[r]->(b) or just (a)-[r]->(b)
+     */
+    parsePatternOrPath() {
+        // Check for path expression syntax: identifier = pattern
+        if (this.check("IDENTIFIER")) {
+            const savedPos = this.pos;
+            const identifier = this.advance().value;
+            if (this.check("EQUALS")) {
+                // This is a path expression: p = (a)-[r]->(b)
+                this.advance(); // consume "="
+                const patterns = this.parsePatternChain();
+                return {
+                    type: "path",
+                    variable: identifier,
+                    patterns
+                };
+            }
+            else {
+                // Not a path expression, backtrack
+                this.pos = savedPos;
+            }
+        }
+        // Regular pattern chain
+        return this.parsePatternChain();
+    }
+    parseOptionalMatch() {
+        this.expect("KEYWORD", "OPTIONAL");
+        return this.parseMatch(true);
+    }
+    /**
+     * Validate that no variable is used as both a node and a relationship in the same MATCH clause,
+     * and that no relationship variable is used more than once in the same pattern.
+     * These are invalid Cypher syntax.
+     */
+    validateNoNodeRelationshipVariableConflict(patterns, pathExpressions) {
+        const nodeVars = new Set();
+        const relVars = new Set();
+        const seenRelVars = new Set();
+        // Helper to collect variables from patterns
+        const collectFromPatterns = (pats) => {
+            for (const pattern of pats) {
+                if ("edge" in pattern) {
+                    // RelationshipPattern
+                    if (pattern.source.variable)
+                        nodeVars.add(pattern.source.variable);
+                    if (pattern.target.variable)
+                        nodeVars.add(pattern.target.variable);
+                    if (pattern.edge.variable) {
+                        // Check for duplicate relationship variable in the same pattern
+                        if (seenRelVars.has(pattern.edge.variable)) {
+                            throw new Error(`Cannot use the same relationship variable '${pattern.edge.variable}' for multiple patterns`);
+                        }
+                        seenRelVars.add(pattern.edge.variable);
+                        relVars.add(pattern.edge.variable);
+                    }
+                }
+                else {
+                    // NodePattern
+                    if (pattern.variable)
+                        nodeVars.add(pattern.variable);
+                }
+            }
+        };
+        collectFromPatterns(patterns);
+        // Also check path expressions
+        if (pathExpressions) {
+            for (const pathExpr of pathExpressions) {
+                collectFromPatterns(pathExpr.patterns);
+            }
+        }
+        // Check for conflicts
+        for (const v of nodeVars) {
+            if (relVars.has(v)) {
+                throw new Error(`Variable '${v}' already declared as relationship`);
+            }
+        }
+        for (const v of relVars) {
+            if (nodeVars.has(v)) {
+                throw new Error(`Variable '${v}' already declared as node`);
+            }
+        }
+    }
+    parseMerge() {
+        this.expect("KEYWORD", "MERGE");
+        // Parse pattern or path expression (handles p = (a)-[r]->(b) syntax)
+        const patternOrPath = this.parsePatternOrPath();
+        let patterns = [];
+        let pathExpressions;
+        if ("type" in patternOrPath && patternOrPath.type === "path") {
+            pathExpressions = [patternOrPath];
+            // Also add the patterns from the path expression to the patterns array
+            patterns = patternOrPath.patterns;
+        }
+        else {
+            patterns = patternOrPath;
+        }
+        // Validate patterns - variable-length relationships are not allowed in MERGE
+        for (const pattern of patterns) {
+            if ("edge" in pattern) {
+                if (pattern.edge.minHops !== undefined || pattern.edge.maxHops !== undefined) {
+                    throw new Error("Variable length relationship patterns are not supported in MERGE");
+                }
+            }
+        }
+        let onCreateSet;
+        let onMatchSet;
+        while (this.checkKeyword("ON")) {
+            this.advance();
+            if (this.checkKeyword("CREATE")) {
+                this.advance();
+                this.expect("KEYWORD", "SET");
+                onCreateSet = this.parseSetAssignments();
+            }
+            else if (this.checkKeyword("MATCH")) {
+                this.advance();
+                this.expect("KEYWORD", "SET");
+                onMatchSet = this.parseSetAssignments();
+            }
+            else {
+                throw new Error("Expected CREATE or MATCH after ON");
+            }
+        }
+        return { type: "MERGE", patterns, pathExpressions, onCreateSet, onMatchSet };
+    }
+    parseSet() {
+        this.expect("KEYWORD", "SET");
+        const assignments = this.parseSetAssignments();
+        return { type: "SET", assignments };
+    }
+    parseSetAssignments() {
+        const assignments = [];
+        do {
+            if (assignments.length > 0) {
+                this.expect("COMMA");
+            }
+            // Handle parenthesized expression: SET (n).property = value
+            let variable;
+            if (this.check("LPAREN")) {
+                this.advance();
+                variable = this.expectIdentifier();
+                this.expect("RPAREN");
+            }
+            else {
+                variable = this.expectIdentifier();
+            }
+            // Check for label assignment: SET n:Label or SET n :Label (with whitespace)
+            if (this.check("COLON")) {
+                // Label assignment: SET n:Label1:Label2
+                const labels = [];
+                while (this.check("COLON")) {
+                    this.advance(); // consume ":"
+                    labels.push(this.expectLabelOrType());
+                }
+                assignments.push({ variable, labels });
+            }
+            else if (this.check("PLUS")) {
+                // Property merge: SET n += {props}
+                this.advance(); // consume "+"
+                this.expect("EQUALS");
+                const value = this.parseExpression();
+                assignments.push({ variable, value, mergeProps: true });
+            }
+            else if (this.check("EQUALS")) {
+                // Property replace: SET n = {props}
+                this.advance(); // consume "="
+                const value = this.parseExpression();
+                assignments.push({ variable, value, replaceProps: true });
+            }
+            else {
+                // Property assignment: SET n.property = value
+                this.expect("DOT");
+                const property = this.expectIdentifier();
+                this.expect("EQUALS");
+                const value = this.parseExpression();
+                assignments.push({ variable, property, value });
+            }
+        } while (this.check("COMMA"));
+        return assignments;
+    }
+    parseRemove() {
+        this.expect("KEYWORD", "REMOVE");
+        const items = [];
+        do {
+            if (items.length > 0) {
+                this.expect("COMMA");
+            }
+            const variable = this.expectIdentifier();
+            // Check for label removal: REMOVE n:Label or REMOVE n:Label1:Label2
+            if (this.check("COLON")) {
+                const labels = [];
+                while (this.check("COLON")) {
+                    this.advance(); // consume ":"
+                    labels.push(this.expectLabelOrType());
+                }
+                items.push({ variable, labels });
+            }
+            else {
+                // Property removal: REMOVE n.prop
+                this.expect("DOT");
+                const property = this.expectIdentifier();
+                items.push({ variable, property });
+            }
+        } while (this.check("COMMA"));
+        return { type: "REMOVE", items };
+    }
+    parseDelete() {
+        let detach = false;
+        if (this.checkKeyword("DETACH")) {
+            this.advance();
+            detach = true;
+        }
+        this.expect("KEYWORD", "DELETE");
+        const variables = [];
+        const expressions = [];
+        // Parse first delete target (can be simple variable or complex expression)
+        this.parseDeleteTarget(variables, expressions);
+        while (this.check("COMMA")) {
+            this.advance();
+            this.parseDeleteTarget(variables, expressions);
+        }
+        const result = { type: "DELETE", variables, detach };
+        if (expressions.length > 0) {
+            result.expressions = expressions;
+        }
+        return result;
+    }
+    parseDeleteTarget(variables, expressions) {
+        // Check if this is a simple variable or a complex expression
+        // Look ahead to see if it's identifier followed by [ (list access) or . (property access)
+        const token = this.peek();
+        if (token.type === "IDENTIFIER") {
+            const nextToken = this.tokens[this.pos + 1];
+            if (nextToken && (nextToken.type === "LBRACKET" || nextToken.type === "DOT")) {
+                // This is a list access expression like friends[$index]
+                // or a property access expression like nodes.key
+                const expr = this.parseExpression();
+                expressions.push(expr);
+            }
+            else {
+                // Simple variable name
+                variables.push(this.advance().value);
+            }
+        }
+        else {
+            // DELETE requires a variable or variable-based expression (like list[index])
+            // Other expression types (literals, arithmetic, etc.) are not valid DELETE targets
+            throw new Error(`Type mismatch: expected Node or Relationship but was ${token.type === "NUMBER" ? "Integer" : token.type === "STRING" ? "String" : token.value}`);
+        }
+    }
+    parseReturn() {
+        this.expect("KEYWORD", "RETURN");
+        // Check for DISTINCT after RETURN
+        let distinct;
+        if (this.checkKeyword("DISTINCT")) {
+            this.advance();
+            distinct = true;
+        }
+        const items = [];
+        // Check for RETURN * syntax (return all matched variables)
+        if (this.check("STAR")) {
+            this.advance();
+            // Mark with special "*" variable to indicate return all
+            items.push({ expression: { type: "variable", variable: "*" } });
+            // After *, we might have additional items with comma (unlikely but possible)
+            // e.g., RETURN *, count(*) AS cnt - but this is rare
+        }
+        if (items.length === 0 || this.check("COMMA")) {
+            if (items.length > 0) {
+                this.advance(); // consume comma after *
+            }
+            do {
+                if (items.length > 0) {
+                    this.expect("COMMA");
+                }
+                // Use parseReturnExpression to allow comparisons in RETURN items
+                const expression = this.parseReturnExpression();
+                let alias;
+                if (this.checkKeyword("AS")) {
+                    this.advance();
+                    alias = this.expectIdentifierOrKeyword();
+                }
+                items.push({ expression, alias });
+            } while (this.check("COMMA"));
+        }
+        // Parse ORDER BY
+        let orderBy;
+        if (this.checkKeyword("ORDER")) {
+            this.advance();
+            this.expect("KEYWORD", "BY");
+            orderBy = [];
+            do {
+                if (orderBy.length > 0) {
+                    this.expect("COMMA");
+                }
+                const expression = this.parseReturnExpression();
+                let direction = "ASC"; // Default to ASC
+                if (this.checkKeyword("ASC") || this.checkKeyword("ASCENDING")) {
+                    this.advance();
+                }
+                else if (this.checkKeyword("DESC") || this.checkKeyword("DESCENDING")) {
+                    this.advance();
+                    direction = "DESC";
+                }
+                orderBy.push({ expression, direction });
+            } while (this.check("COMMA"));
+        }
+        // Parse SKIP
+        let skip;
+        if (this.checkKeyword("SKIP")) {
+            this.advance();
+            skip = this.parseExpression();
+            // Validate if it's a literal number
+            if (skip.type === "literal" && typeof skip.value === "number") {
+                if (!Number.isInteger(skip.value)) {
+                    throw new Error("SKIP: InvalidArgumentType - expected an integer value");
+                }
+                if (skip.value < 0) {
+                    throw new Error("SKIP: NegativeIntegerArgument - cannot be negative");
+                }
+            }
+        }
+        // Parse LIMIT
+        let limit;
+        if (this.checkKeyword("LIMIT")) {
+            this.advance();
+            limit = this.parseExpression();
+            // Validate if it's a literal number
+            if (limit.type === "literal" && typeof limit.value === "number") {
+                if (!Number.isInteger(limit.value)) {
+                    throw new Error("LIMIT: InvalidArgumentType - expected an integer value");
+                }
+                if (limit.value < 0) {
+                    throw new Error("LIMIT: NegativeIntegerArgument - cannot be negative");
+                }
+            }
+        }
+        return { type: "RETURN", distinct, items, orderBy, skip, limit };
+    }
+    parseWith() {
+        this.expect("KEYWORD", "WITH");
+        // Check for DISTINCT after WITH
+        let distinct;
+        if (this.checkKeyword("DISTINCT")) {
+            this.advance();
+            distinct = true;
+        }
+        const items = [];
+        let star = false;
+        // Check for WITH * syntax (pass through all variables)
+        if (this.check("STAR")) {
+            this.advance();
+            star = true;
+            // After *, we might have additional items with comma
+            // e.g., WITH *, count(n) AS cnt
+            // For now, we'll mark this with a special expression
+            items.push({ expression: { type: "variable", variable: "*" } });
+        }
+        if (!star || this.check("COMMA")) {
+            if (star) {
+                this.advance(); // consume comma after *
+            }
+            do {
+                if (items.length > (star ? 1 : 0)) {
+                    this.expect("COMMA");
+                }
+                const expression = this.parseReturnExpression();
+                let alias;
+                if (this.checkKeyword("AS")) {
+                    this.advance();
+                    alias = this.expectIdentifierOrKeyword();
+                }
+                // In WITH, non-variable expressions must be aliased
+                // e.g., WITH count(*) is invalid, but WITH count(*) AS c is valid
+                // e.g., WITH a.name is invalid, but WITH a.name AS name is valid
+                if (!alias && expression.type !== "variable") {
+                    throw new Error(`Expression in WITH must be aliased (use AS)`);
+                }
+                items.push({ expression, alias });
+            } while (this.check("COMMA"));
+        }
+        // Parse ORDER BY
+        let orderBy;
+        if (this.checkKeyword("ORDER")) {
+            this.advance();
+            this.expect("KEYWORD", "BY");
+            orderBy = [];
+            do {
+                if (orderBy.length > 0) {
+                    this.expect("COMMA");
+                }
+                const expression = this.parseReturnExpression();
+                let direction = "ASC"; // Default to ASC
+                if (this.checkKeyword("ASC") || this.checkKeyword("ASCENDING")) {
+                    this.advance();
+                }
+                else if (this.checkKeyword("DESC") || this.checkKeyword("DESCENDING")) {
+                    this.advance();
+                    direction = "DESC";
+                }
+                orderBy.push({ expression, direction });
+            } while (this.check("COMMA"));
+        }
+        // Parse SKIP
+        let skip;
+        if (this.checkKeyword("SKIP")) {
+            this.advance();
+            skip = this.parseExpression();
+            // Validate if it's a literal number
+            if (skip.type === "literal" && typeof skip.value === "number") {
+                if (!Number.isInteger(skip.value)) {
+                    throw new Error("SKIP: InvalidArgumentType - expected an integer value");
+                }
+                if (skip.value < 0) {
+                    throw new Error("SKIP: NegativeIntegerArgument - cannot be negative");
+                }
+            }
+        }
+        // Parse LIMIT
+        let limit;
+        if (this.checkKeyword("LIMIT")) {
+            this.advance();
+            limit = this.parseExpression();
+            // Validate if it's a literal number
+            if (limit.type === "literal" && typeof limit.value === "number") {
+                if (!Number.isInteger(limit.value)) {
+                    throw new Error("LIMIT: InvalidArgumentType - expected an integer value");
+                }
+                if (limit.value < 0) {
+                    throw new Error("LIMIT: NegativeIntegerArgument - cannot be negative");
+                }
+            }
+        }
+        // Parse optional WHERE clause after WITH items
+        let where;
+        if (this.checkKeyword("WHERE")) {
+            this.advance();
+            where = this.parseWhereCondition();
+        }
+        return { type: "WITH", distinct, items, orderBy, skip, limit, where };
+    }
+    parseUnwind() {
+        this.expect("KEYWORD", "UNWIND");
+        const expression = this.parseUnwindExpression();
+        this.expect("KEYWORD", "AS");
+        const alias = this.expectIdentifier();
+        return { type: "UNWIND", expression, alias };
+    }
+    parseUnwindExpression() {
+        const token = this.peek();
+        // NULL literal - UNWIND null produces empty result
+        if (token.type === "KEYWORD" && token.value.toUpperCase() === "NULL") {
+            this.advance();
+            return { type: "literal", value: null };
+        }
+        // Parenthesized expression like (first + second)
+        if (token.type === "LPAREN") {
+            this.advance();
+            const expr = this.parseExpression();
+            this.expect("RPAREN");
+            return expr;
+        }
+        // Array literal
+        if (token.type === "LBRACKET") {
+            // Use full list literal parsing so elements can be expressions (e.g. [date({year: 1910, ...}), ...])
+            return this.parseListLiteralExpression();
+        }
+        // Parameter
+        if (token.type === "PARAMETER") {
+            this.advance();
+            return { type: "parameter", name: token.value };
+        }
+        // Function call like range(1, 10)
+        if ((token.type === "IDENTIFIER" || token.type === "KEYWORD") && this.tokens[this.pos + 1]?.type === "LPAREN") {
+            return this.parseExpression();
+        }
+        // Variable, property access, or index access (e.g., qrows[p])
+        if (token.type === "IDENTIFIER") {
+            // Use parseExpression to handle postfix operations like property access and indexing
+            return this.parseExpression();
+        }
+        throw new Error(`Expected array, parameter, or variable in UNWIND, got ${token.type} '${token.value}'`);
+    }
+    parseCall() {
+        this.expect("KEYWORD", "CALL");
+        // Parse procedure name (e.g., "db.labels" or "db.relationshipTypes")
+        // Procedure names can have dots, so we parse identifier.identifier...
+        let procedureName = this.expectIdentifier();
+        while (this.check("DOT")) {
+            this.advance();
+            procedureName += "." + this.expectIdentifier();
+        }
+        // Parse arguments in parentheses
+        this.expect("LPAREN");
+        const args = [];
+        if (!this.check("RPAREN")) {
+            do {
+                if (args.length > 0) {
+                    this.expect("COMMA");
+                }
+                args.push(this.parseExpression());
+            } while (this.check("COMMA"));
+        }
+        this.expect("RPAREN");
+        // Parse optional YIELD clause
+        let yields;
+        let where;
+        if (this.checkKeyword("YIELD")) {
+            this.advance();
+            yields = [];
+            // Parse yielded field names (can be identifiers or keywords like 'count')
+            do {
+                if (yields.length > 0) {
+                    this.expect("COMMA");
+                }
+                yields.push(this.expectIdentifierOrKeyword());
+            } while (this.check("COMMA"));
+            // Parse optional WHERE after YIELD
+            if (this.checkKeyword("WHERE")) {
+                this.advance();
+                where = this.parseWhereCondition();
+            }
+        }
+        return { type: "CALL", procedure: procedureName, args, yields, where };
+    }
+    /**
+     * Parse a pattern, which can be a single node or a chain of relationships.
+     * For chained patterns like (a)-[:R1]->(b)-[:R2]->(c), this returns multiple
+     * RelationshipPattern objects via parsePatternChain.
+     */
+    parsePattern() {
+        const firstNode = this.parseNodePattern();
+        // Check for relationship
+        if (this.check("DASH") || this.check("ARROW_LEFT")) {
+            const edge = this.parseEdgePattern();
+            const targetNode = this.parseNodePattern();
+            return {
+                source: firstNode,
+                edge,
+                target: targetNode,
+            };
+        }
+        return firstNode;
+    }
+    /**
+     * Parse a pattern chain, returning an array of patterns.
+     * Handles multi-hop patterns like (a)-[:R1]->(b)-[:R2]->(c).
+     */
+    parsePatternChain() {
+        const patterns = [];
+        const firstNode = this.parseNodePattern();
+        // Check for relationship chain
+        if (!this.check("DASH") && !this.check("ARROW_LEFT")) {
+            // Just a single node
+            return [firstNode];
+        }
+        // Parse first relationship
+        let currentSource = firstNode;
+        while (this.check("DASH") || this.check("ARROW_LEFT")) {
+            const edge = this.parseEdgePattern();
+            const targetNode = this.parseNodePattern();
+            // Check if there's another relationship pattern coming after this one
+            const hasMoreRelationships = this.check("DASH") || this.check("ARROW_LEFT");
+            // If target is anonymous (no variable) AND there's more patterns coming,
+            // assign a synthetic variable for chaining.
+            // This ensures patterns like (:A)<-[:R]-(:B)-[:S]->(:C) share the (:B) node
+            // But don't do this for standalone patterns like CREATE ()-[:R]->()
+            if (!targetNode.variable && hasMoreRelationships) {
+                targetNode.variable = `_anon${this.anonVarCounter++}`;
+            }
+            patterns.push({
+                source: currentSource,
+                edge,
+                target: targetNode,
+            });
+            // For the next hop, the source is a reference to the previous target (variable only, no label)
+            currentSource = { variable: targetNode.variable };
+        }
+        return patterns;
+    }
+    parseNodePattern() {
+        this.expect("LPAREN");
+        const pattern = {};
+        // Variable name
+        if (this.check("IDENTIFIER")) {
+            pattern.variable = this.advance().value;
+        }
+        // Labels (can be multiple: :A:B:C)
+        if (this.check("COLON")) {
+            const labels = [];
+            while (this.check("COLON")) {
+                this.advance(); // consume ":"
+                labels.push(this.expectLabelOrType());
+            }
+            // Store as array if multiple labels, string if single (for backward compatibility)
+            pattern.label = labels.length === 1 ? labels[0] : labels;
+        }
+        // Properties
+        if (this.check("LBRACE")) {
+            pattern.properties = this.parseProperties();
+        }
+        this.expect("RPAREN");
+        return pattern;
+    }
+    parseEdgePattern() {
+        let direction = "none";
+        // Left arrow or dash
+        if (this.check("ARROW_LEFT")) {
+            this.advance();
+            direction = "left";
+        }
+        else {
+            this.expect("DASH");
+        }
+        const edge = { direction };
+        // Edge details in brackets
+        if (this.check("LBRACKET")) {
+            this.advance();
+            // Variable name
+            if (this.check("IDENTIFIER")) {
+                edge.variable = this.advance().value;
+            }
+            // Type (can be identifier or keyword, or multiple types separated by |)
+            if (this.check("COLON")) {
+                this.advance();
+                const firstType = this.expectLabelOrType();
+                // Check for multiple types: [:TYPE1|TYPE2|TYPE3] or [:TYPE1|:TYPE2]
+                if (this.check("PIPE")) {
+                    const types = [firstType];
+                    while (this.check("PIPE")) {
+                        this.advance();
+                        // Some Cypher dialects allow :TYPE after the pipe, consume the optional colon
+                        if (this.check("COLON")) {
+                            this.advance();
+                        }
+                        types.push(this.expectLabelOrType());
+                    }
+                    edge.types = types;
+                }
+                else {
+                    edge.type = firstType;
+                }
+            }
+            // Variable-length pattern: *[min]..[max] or *n or *
+            if (this.check("STAR")) {
+                this.advance();
+                this.parseVariableLengthSpec(edge);
+            }
+            // Properties
+            if (this.check("LBRACE")) {
+                edge.properties = this.parseProperties();
+            }
+            this.expect("RBRACKET");
+        }
+        // Right arrow or dash
+        if (this.check("ARROW_RIGHT")) {
+            this.advance();
+            if (direction === "left") {
+                // <--> pattern means "either direction" (bidirectional), same as --
+                direction = "none";
+            }
+            else {
+                direction = "right";
+            }
+            edge.direction = direction;
+        }
+        else {
+            this.expect("DASH");
+        }
+        return edge;
+    }
+    parseVariableLengthSpec(edge) {
+        // Patterns:
+        // *       -> min=1, max=undefined (any length >= 1)
+        // *2      -> min=2, max=2 (fixed length)
+        // *1..3   -> min=1, max=3 (range)
+        // *2..    -> min=2, max=undefined (min only)
+        // *..3    -> min=1, max=3 (max only)
+        // *0..3   -> min=0, max=3 (can include zero-length)
+        // Check for just * with no numbers or dots
+        if (!this.check("NUMBER") && !this.check("DOT")) {
+            edge.minHops = 1;
+            edge.maxHops = undefined;
+            return;
+        }
+        // Check for ..N pattern (*..3) or just *.. (unbounded from 1)
+        if (this.check("DOT")) {
+            this.advance(); // first dot
+            this.expect("DOT"); // second dot
+            edge.minHops = 1;
+            if (this.check("NUMBER")) {
+                const maxVal = parseInt(this.advance().value, 10);
+                if (maxVal < 0) {
+                    throw new Error("Negative bound in variable-length pattern is not allowed");
+                }
+                edge.maxHops = maxVal;
+            }
+            else {
+                edge.maxHops = undefined; // unbounded
+            }
+            return;
+        }
+        // Parse first number
+        const firstNum = parseInt(this.expect("NUMBER").value, 10);
+        if (firstNum < 0) {
+            throw new Error("Negative bound in variable-length pattern is not allowed");
+        }
+        // Check if this is a range or fixed
+        if (this.check("DOT")) {
+            this.advance(); // first dot
+            // Need to check if next is DOT or if dots were consecutive
+            if (this.check("DOT")) {
+                this.advance(); // second dot
+            }
+            // If we just advanced past a DOT and the tokenizer gave us separate dots,
+            // we need to handle this. Let's check the current token
+            edge.minHops = firstNum;
+            // Check for second number
+            if (this.check("NUMBER")) {
+                const maxVal = parseInt(this.advance().value, 10);
+                if (maxVal < 0) {
+                    throw new Error("Negative bound in variable-length pattern is not allowed");
+                }
+                edge.maxHops = maxVal;
+            }
+            else {
+                edge.maxHops = undefined; // unbounded
+            }
+        }
+        else {
+            // Fixed length
+            edge.minHops = firstNum;
+            edge.maxHops = firstNum;
+        }
+    }
+    parseProperties() {
+        this.expect("LBRACE");
+        const properties = {};
+        if (!this.check("RBRACE")) {
+            do {
+                if (Object.keys(properties).length > 0) {
+                    this.expect("COMMA");
+                }
+                // Property keys can be identifiers OR keywords (like 'id', 'name', 'set', etc.)
+                const key = this.expectIdentifierOrKeyword();
+                this.expect("COLON");
+                const value = this.parsePropertyValue();
+                properties[key] = value;
+            } while (this.check("COMMA"));
+        }
+        this.expect("RBRACE");
+        return properties;
+    }
+    parsePropertyValue() {
+        // Parse the primary property value first
+        let left = this.parsePrimaryPropertyValue();
+        // Check for binary operators: +, -, *, /, %
+        while (this.check("PLUS") || this.check("DASH") || this.check("STAR") || this.check("SLASH") || this.check("PERCENT")) {
+            const opToken = this.advance();
+            let operator;
+            if (opToken.type === "PLUS")
+                operator = "+";
+            else if (opToken.type === "DASH")
+                operator = "-";
+            else if (opToken.type === "STAR")
+                operator = "*";
+            else if (opToken.type === "SLASH")
+                operator = "/";
+            else
+                operator = "%";
+            const right = this.parsePrimaryPropertyValue();
+            left = { type: "binary", operator, left, right };
+        }
+        return left;
+    }
+    parsePrimaryPropertyValue() {
+        const token = this.peek();
+        if (token.type === "STRING") {
+            this.advance();
+            return token.value;
+        }
+        if (token.type === "NUMBER") {
+            this.advance();
+            return this.parseNumber(token.value);
+        }
+        // Handle negative numbers: DASH followed by NUMBER
+        if (token.type === "DASH") {
+            const nextToken = this.tokens[this.pos + 1];
+            if (nextToken && nextToken.type === "NUMBER") {
+                this.advance(); // consume DASH
+                this.advance(); // consume NUMBER
+                return -this.parseNumber(nextToken.value);
+            }
+        }
+        if (token.type === "PARAMETER") {
+            this.advance();
+            return { type: "parameter", name: token.value };
+        }
+        if (token.type === "KEYWORD") {
+            if (token.value === "TRUE") {
+                this.advance();
+                return true;
+            }
+            if (token.value === "FALSE") {
+                this.advance();
+                return false;
+            }
+            if (token.value === "NULL") {
+                this.advance();
+                return null;
+            }
+        }
+        if (token.type === "LBRACKET") {
+            return this.parseArray();
+        }
+        // Map literal (e.g., {year: 1980, month: 10, day: 24}) - used in temporal functions like date({..})
+        if (token.type === "LBRACE") {
+            return this.parseMapPropertyValue();
+        }
+        // Handle variable references (e.g., from UNWIND), property access (e.g., person.bornIn), or function calls (e.g., datetime())
+        if (token.type === "IDENTIFIER") {
+            this.advance();
+            const varName = token.value;
+            // Check for function call: identifier followed by LPAREN
+            if (this.check("LPAREN")) {
+                this.advance(); // consume LPAREN
+                const args = [];
+                // Parse function arguments
+                if (!this.check("RPAREN")) {
+                    do {
+                        if (args.length > 0) {
+                            this.expect("COMMA");
+                        }
+                        args.push(this.parsePropertyValue());
+                    } while (this.check("COMMA"));
+                }
+                this.expect("RPAREN");
+                return { type: "function", name: varName.toUpperCase(), args };
+            }
+            // Check for property access: variable.property
+            if (this.check("DOT")) {
+                this.advance(); // consume DOT
+                const propToken = this.expect("IDENTIFIER");
+                return { type: "property", variable: varName, property: propToken.value };
+            }
+            return { type: "variable", name: varName };
+        }
+        throw new Error(`Expected property value, got ${token.type} '${token.value}'`);
+    }
+    parseMapPropertyValue() {
+        this.expect("LBRACE");
+        const properties = {};
+        if (!this.check("RBRACE")) {
+            do {
+                if (Object.keys(properties).length > 0) {
+                    this.expect("COMMA");
+                }
+                const key = this.expectIdentifierOrKeyword();
+                this.expect("COLON");
+                const value = this.parsePropertyValue();
+                properties[key] = value;
+            } while (this.check("COMMA"));
+        }
+        this.expect("RBRACE");
+        return { type: "map", properties };
+    }
+    parseArray() {
+        this.expect("LBRACKET");
+        const values = [];
+        if (!this.check("RBRACKET")) {
+            do {
+                if (values.length > 0) {
+                    this.expect("COMMA");
+                }
+                values.push(this.parsePropertyValue());
+            } while (this.check("COMMA"));
+        }
+        this.expect("RBRACKET");
+        return values;
+    }
+    parseWhereCondition() {
+        return this.parseOrCondition();
+    }
+    parseOrCondition() {
+        let left = this.parseAndCondition();
+        while (this.checkKeyword("OR")) {
+            this.advance();
+            const right = this.parseAndCondition();
+            left = { type: "or", conditions: [left, right] };
+        }
+        return left;
+    }
+    parseAndCondition() {
+        let left = this.parseNotCondition();
+        while (this.checkKeyword("AND")) {
+            this.advance();
+            const right = this.parseNotCondition();
+            left = { type: "and", conditions: [left, right] };
+        }
+        return left;
+    }
+    parseNotCondition() {
+        if (this.checkKeyword("NOT")) {
+            this.advance();
+            const condition = this.parseNotCondition();
+            return { type: "not", condition };
+        }
+        return this.parsePrimaryCondition();
+    }
+    /**
+     * Detect if we're looking at a pattern (e.g., (a)-[:R]->(b)).
+     * A pattern starts with ( and after the matching ), we expect - or <- (not a keyword like AND, OR, etc).
+     */
+    isPatternStart() {
+        if (!this.check("LPAREN"))
+            return false;
+        // Find the matching closing paren
+        let depth = 0;
+        let pos = this.pos;
+        while (pos < this.tokens.length) {
+            const token = this.tokens[pos];
+            if (token.type === "LPAREN")
+                depth++;
+            else if (token.type === "RPAREN") {
+                depth--;
+                if (depth === 0) {
+                    // Check what comes after the closing paren
+                    const nextPos = pos + 1;
+                    if (nextPos < this.tokens.length) {
+                        const nextToken = this.tokens[nextPos];
+                        // A pattern is followed by - or <- (never a keyword)
+                        return nextToken.type === "DASH" || nextToken.type === "ARROW_LEFT";
+                    }
+                    return false;
+                }
+            }
+            pos++;
+        }
+        return false;
+    }
+    parsePrimaryCondition() {
+        // Handle EXISTS pattern
+        if (this.checkKeyword("EXISTS")) {
+            return this.parseExistsCondition();
+        }
+        // Handle list predicates: ALL, ANY, NONE, SINGLE
+        const listPredicates = ["ALL", "ANY", "NONE", "SINGLE"];
+        if (this.peek().type === "KEYWORD" && listPredicates.includes(this.peek().value)) {
+            const nextToken = this.tokens[this.pos + 1];
+            if (nextToken && nextToken.type === "LPAREN") {
+                return this.parseListPredicateCondition();
+            }
+        }
+        // Handle parenthesized conditions or patterns
+        if (this.check("LPAREN")) {
+            // Lookahead to determine if this is a pattern or a parenthesized condition
+            if (this.isPatternStart()) {
+                // Parse as pattern condition
+                const patterns = this.parsePatternChain();
+                return { type: "patternMatch", patterns };
+            }
+            // Otherwise parse as parenthesized condition
+            this.advance(); // consume (
+            const condition = this.parseOrCondition(); // parse the inner condition
+            this.expect("RPAREN"); // consume )
+            return condition;
+        }
+        return this.parseComparisonCondition();
+    }
+    parseListPredicateCondition() {
+        // Parse list predicate as a condition (for use in WHERE clause)
+        const predicateType = this.advance().value.toUpperCase();
+        this.expect("LPAREN");
+        // Expect variable followed by IN
+        const variable = this.expectIdentifier();
+        this.expect("KEYWORD", "IN");
+        // Parse the source list expression
+        const listExpr = this.parseExpression();
+        // WHERE clause is required for list predicates
+        if (!this.checkKeyword("WHERE")) {
+            throw new Error(`Expected WHERE after list expression in ${predicateType}()`);
+        }
+        this.advance(); // consume WHERE
+        // Parse the filter condition
+        const filterCondition = this.parseListComprehensionCondition(variable);
+        this.expect("RPAREN");
+        return {
+            type: "listPredicate",
+            predicateType,
+            variable,
+            listExpr,
+            filterCondition,
+        };
+    }
+    parseExistsCondition() {
+        this.expect("KEYWORD", "EXISTS");
+        this.expect("LPAREN"); // outer (
+        // Parse the pattern inside EXISTS((pattern))
+        const patterns = this.parsePatternChain();
+        const pattern = patterns.length === 1 ? patterns[0] : patterns[0]; // Use first pattern for now
+        this.expect("RPAREN"); // outer )
+        return { type: "exists", pattern };
+    }
+    parseComparisonCondition() {
+        const left = this.parseExpression();
+        // Check for label predicate: variable:Label or variable:Label1:Label2
+        // After parsing the left expression (which should be a variable), check for COLON
+        if (this.check("COLON") && left.type === "variable") {
+            const variable = left.variable;
+            const labelsList = [];
+            while (this.check("COLON")) {
+                this.advance(); // consume :
+                labelsList.push(this.expectLabelOrType());
+            }
+            // Convert to a comparison that checks labels
+            // Return as a comparison expression that the translator can handle
+            const labelExpr = labelsList.length === 1
+                ? { type: "labelPredicate", variable, label: labelsList[0] }
+                : { type: "labelPredicate", variable, labels: labelsList };
+            // Wrap it in a comparison-like structure for WhereCondition
+            return { type: "comparison", left: labelExpr, operator: "=", right: { type: "literal", value: true } };
+        }
+        // Check for IS NULL / IS NOT NULL
+        if (this.checkKeyword("IS")) {
+            this.advance();
+            if (this.checkKeyword("NOT")) {
+                this.advance();
+                this.expect("KEYWORD", "NULL");
+                return { type: "isNotNull", left };
+            }
+            else {
+                this.expect("KEYWORD", "NULL");
+                return { type: "isNull", left };
+            }
+        }
+        // Check for string operations
+        if (this.checkKeyword("CONTAINS")) {
+            this.advance();
+            const right = this.parseExpression();
+            return { type: "contains", left, right };
+        }
+        if (this.checkKeyword("STARTS")) {
+            this.advance();
+            this.expect("KEYWORD", "WITH");
+            const right = this.parseExpression();
+            return { type: "startsWith", left, right };
+        }
+        if (this.checkKeyword("ENDS")) {
+            this.advance();
+            this.expect("KEYWORD", "WITH");
+            const right = this.parseExpression();
+            return { type: "endsWith", left, right };
+        }
+        // Check for IN operator
+        if (this.checkKeyword("IN")) {
+            this.advance();
+            // IN can be followed by a list literal [...] or a parameter $param
+            const listExpr = this.parseInListExpression();
+            return { type: "in", left, list: listExpr };
+        }
+        // Comparison operators - handle chained comparisons like 1 < n.num < 3
+        const opToken = this.peek();
+        let operator;
+        if (opToken.type === "EQUALS")
+            operator = "=";
+        else if (opToken.type === "NOT_EQUALS")
+            operator = "<>";
+        else if (opToken.type === "LT")
+            operator = "<";
+        else if (opToken.type === "GT")
+            operator = ">";
+        else if (opToken.type === "LTE")
+            operator = "<=";
+        else if (opToken.type === "GTE")
+            operator = ">=";
+        if (operator) {
+            this.advance();
+            const middle = this.parseExpression();
+            const firstComparison = { type: "comparison", left, right: middle, operator };
+            // Check for chained comparison: 1 < n.num < 3 means (1 < n.num AND n.num < 3)
+            const nextOpToken = this.peek();
+            let secondOperator;
+            if (nextOpToken.type === "EQUALS")
+                secondOperator = "=";
+            else if (nextOpToken.type === "NOT_EQUALS")
+                secondOperator = "<>";
+            else if (nextOpToken.type === "LT")
+                secondOperator = "<";
+            else if (nextOpToken.type === "GT")
+                secondOperator = ">";
+            else if (nextOpToken.type === "LTE")
+                secondOperator = "<=";
+            else if (nextOpToken.type === "GTE")
+                secondOperator = ">=";
+            if (secondOperator) {
+                this.advance();
+                const right = this.parseExpression();
+                const secondComparison = { type: "comparison", left: middle, right, operator: secondOperator };
+                // Return the chained comparison as an AND condition
+                return { type: "and", conditions: [firstComparison, secondComparison] };
+            }
+            return firstComparison;
+        }
+        // No comparison operator - treat as standalone boolean expression
+        // This handles cases like: WHERE false, WHERE n.active, WHERE true AND x = 1
+        // Also handles boolean variables like: WHERE result (where result is a boolean)
+        // However, bare variable references like WHERE (n) are invalid - that's checked at translation time
+        return { type: "expression", left };
+    }
+    parseInListExpression() {
+        const token = this.peek();
+        // Array literal [...] - use parseListLiteralExpression which handles both
+        // simple literals and list comprehensions like [x IN list | expr]
+        if (token.type === "LBRACKET") {
+            return this.parseListLiteralExpression();
+        }
+        // Parameter $param
+        if (token.type === "PARAMETER") {
+            this.advance();
+            return { type: "parameter", name: token.value };
+        }
+        // Variable reference
+        if (token.type === "IDENTIFIER") {
+            const variable = this.advance().value;
+            if (this.check("DOT")) {
+                this.advance();
+                const property = this.expectIdentifier();
+                return { type: "property", variable, property };
+            }
+            return { type: "variable", variable };
+        }
+        throw new Error(`Expected array, parameter, or variable in IN clause, got ${token.type} '${token.value}'`);
+    }
+    parseExpression() {
+        return this.parseAdditiveExpression();
+    }
+    // Parse expression that may include comparison and logical operators (for RETURN items)
+    parseReturnExpression() {
+        return this.parseOrExpression();
+    }
+    // Handle OR (lowest precedence for logical operators)
+    parseOrExpression() {
+        let left = this.parseXorExpression();
+        while (this.checkKeyword("OR")) {
+            this.advance();
+            const right = this.parseXorExpression();
+            left = { type: "binary", operator: "OR", left, right };
+        }
+        return left;
+    }
+    // Handle XOR (between OR and AND in precedence)
+    parseXorExpression() {
+        let left = this.parseAndExpression();
+        while (this.checkKeyword("XOR")) {
+            this.advance();
+            const right = this.parseAndExpression();
+            left = { type: "binary", operator: "XOR", left, right };
+        }
+        return left;
+    }
+    // Handle AND (higher precedence than XOR)
+    parseAndExpression() {
+        let left = this.parseNotExpression();
+        while (this.checkKeyword("AND")) {
+            this.advance();
+            const right = this.parseNotExpression();
+            left = { type: "binary", operator: "AND", left, right };
+        }
+        return left;
+    }
+    // Handle NOT (highest precedence for logical operators)
+    parseNotExpression() {
+        if (this.checkKeyword("NOT")) {
+            this.advance();
+            const operand = this.parseNotExpression();
+            return { type: "unary", operator: "NOT", operand };
+        }
+        return this.parseComparisonExpression();
+    }
+    // Handle comparison operators
+    parseComparisonExpression() {
+        let left = this.parseIsNullExpression();
+        // Check for comparison operators
+        const opToken = this.peek();
+        let comparisonOperator;
+        if (opToken.type === "EQUALS")
+            comparisonOperator = "=";
+        else if (opToken.type === "NOT_EQUALS")
+            comparisonOperator = "<>";
+        else if (opToken.type === "LT")
+            comparisonOperator = "<";
+        else if (opToken.type === "GT")
+            comparisonOperator = ">";
+        else if (opToken.type === "LTE")
+            comparisonOperator = "<=";
+        else if (opToken.type === "GTE")
+            comparisonOperator = ">=";
+        if (comparisonOperator) {
+            this.advance();
+            const right = this.parseIsNullExpression();
+            return { type: "comparison", comparisonOperator, left, right };
+        }
+        return left;
+    }
+    // Handle IS NULL / IS NOT NULL
+    parseIsNullExpression() {
+        let left = this.parseAdditiveExpression();
+        // Check for label predicate: variable:Label or variable:Label1:Label2
+        // This handles bare form `a:B` in RETURN expressions (without parentheses)
+        if (this.check("COLON") && left.type === "variable") {
+            const variable = left.variable;
+            const labelsList = [];
+            while (this.check("COLON")) {
+                this.advance(); // consume :
+                labelsList.push(this.expectLabelOrType());
+            }
+            if (labelsList.length === 1) {
+                return { type: "labelPredicate", variable, label: labelsList[0] };
+            }
+            else {
+                return { type: "labelPredicate", variable, labels: labelsList };
+            }
+        }
+        if (this.checkKeyword("IS")) {
+            this.advance();
+            if (this.checkKeyword("NOT")) {
+                this.advance();
+                this.expect("KEYWORD", "NULL");
+                return { type: "comparison", comparisonOperator: "IS NOT NULL", left };
+            }
+            else {
+                this.expect("KEYWORD", "NULL");
+                return { type: "comparison", comparisonOperator: "IS NULL", left };
+            }
+        }
+        // Handle IN operator: value IN list
+        // The list can be a function call like keys(n), array literal, parameter, or variable
+        if (this.checkKeyword("IN")) {
+            this.advance();
+            // Use parseAdditiveExpression to allow function calls, array literals, etc.
+            // but not operators that have lower precedence than IN
+            const list = this.parseAdditiveExpression();
+            return { type: "in", left, list };
+        }
+        // Handle string operators: CONTAINS, STARTS WITH, ENDS WITH
+        if (this.checkKeyword("CONTAINS")) {
+            this.advance();
+            const right = this.parseAdditiveExpression();
+            return { type: "stringOp", stringOperator: "CONTAINS", left, right };
+        }
+        if (this.checkKeyword("STARTS")) {
+            this.advance();
+            this.expect("KEYWORD", "WITH");
+            const right = this.parseAdditiveExpression();
+            return { type: "stringOp", stringOperator: "STARTS WITH", left, right };
+        }
+        if (this.checkKeyword("ENDS")) {
+            this.advance();
+            this.expect("KEYWORD", "WITH");
+            const right = this.parseAdditiveExpression();
+            return { type: "stringOp", stringOperator: "ENDS WITH", left, right };
+        }
+        return left;
+    }
+    // Handle + and - (lower precedence)
+    parseAdditiveExpression() {
+        let left = this.parseMultiplicativeExpression();
+        while (this.check("PLUS") || this.check("DASH")) {
+            const operatorToken = this.advance();
+            const operator = operatorToken.type === "PLUS" ? "+" : "-";
+            const right = this.parseMultiplicativeExpression();
+            left = { type: "binary", operator: operator, left, right };
+        }
+        return left;
+    }
+    // Handle *, /, % (higher precedence than +, -)
+    parseMultiplicativeExpression() {
+        let left = this.parseExponentialExpression();
+        while (this.check("STAR") || this.check("SLASH") || this.check("PERCENT")) {
+            const operatorToken = this.advance();
+            let operator;
+            if (operatorToken.type === "STAR")
+                operator = "*";
+            else if (operatorToken.type === "SLASH")
+                operator = "/";
+            else
+                operator = "%";
+            const right = this.parseExponentialExpression();
+            left = { type: "binary", operator, left, right };
+        }
+        return left;
+    }
+    // Handle ^ (exponentiation - highest precedence among arithmetic operators)
+    parseExponentialExpression() {
+        let left = this.parsePostfixExpression();
+        while (this.check("CARET")) {
+            this.advance(); // consume ^
+            const right = this.parsePostfixExpression();
+            left = { type: "binary", operator: "^", left, right };
+        }
+        return left;
+    }
+    // Handle postfix operations: list indexing like expr[0] or expr[1..3], and chained property access like a.b.c
+    parsePostfixExpression() {
+        let expr = this.parsePrimaryExpression();
+        // Handle list/map indexing: expr[index] or expr[start..end], and chained property access: expr.prop
+        while (this.check("LBRACKET") || this.check("DOT")) {
+            if (this.check("DOT")) {
+                this.advance(); // consume .
+                // Property access - property names can be keywords too
+                const property = this.expectIdentifierOrKeyword();
+                // Check for namespaced function call: namespace.function(args)
+                // e.g., duration.between(), duration.inMonths(), etc.
+                if (this.check("LPAREN")) {
+                    this.advance(); // consume (
+                    // Build the namespaced function name (e.g., "duration.between")
+                    let namespace;
+                    if (expr.type === "variable") {
+                        namespace = expr.variable;
+                    }
+                    else if (expr.type === "propertyAccess") {
+                        // For deeper chains like a.b.c() - build full namespace path
+                        const parts = [];
+                        let current = expr;
+                        while (current.type === "propertyAccess") {
+                            parts.unshift(current.property);
+                            current = current.object;
+                        }
+                        if (current.type === "variable") {
+                            parts.unshift(current.variable);
+                        }
+                        namespace = parts.join(".");
+                    }
+                    else {
+                        // Can't form a namespace from this expression type
+                        throw new Error(`Invalid namespace function call syntax`);
+                    }
+                    // Convert to uppercase for consistency with other functions
+                    const functionName = `${namespace}.${property}`.toUpperCase();
+                    const args = [];
+                    // Check for DISTINCT keyword (for aggregation functions)
+                    let distinct;
+                    if (this.checkKeyword("DISTINCT")) {
+                        this.advance();
+                        distinct = true;
+                    }
+                    if (!this.check("RPAREN")) {
+                        do {
+                            if (args.length > 0) {
+                                this.expect("COMMA");
+                            }
+                            args.push(this.parseReturnExpression());
+                        } while (this.check("COMMA"));
+                    }
+                    this.expect("RPAREN");
+                    expr = { type: "function", functionName, args, distinct };
+                }
+                else {
+                    // Regular property access
+                    expr = { type: "propertyAccess", object: expr, property };
+                }
+            }
+            else {
+                // LBRACKET - parse index or slice
+                this.advance(); // consume [
+                // Check for slice syntax [start..end]
+                if (this.check("DOT")) {
+                    // [..end] - from start (implicit start = 0)
+                    this.advance(); // consume first .
+                    this.expect("DOT"); // consume second .
+                    const endExpr = this.parseSliceBoundExpression();
+                    this.expect("RBRACKET");
+                    // Use SLICE_FROM_START to indicate implicit start
+                    expr = { type: "function", functionName: "SLICE_FROM_START", args: [expr, endExpr] };
+                }
+                else {
+                    // Parse start expression using slice-aware parsing
+                    const indexExpr = this.parseSliceBoundExpression();
+                    if (this.check("DOT")) {
+                        // Check for slice: [start..end] or [start..]
+                        this.advance(); // consume first .
+                        this.expect("DOT"); // consume second .
+                        if (this.check("RBRACKET")) {
+                            // [start..] - to end (implicit end = list length)
+                            this.expect("RBRACKET");
+                            // Use SLICE_TO_END to indicate implicit end
+                            expr = { type: "function", functionName: "SLICE_TO_END", args: [expr, indexExpr] };
+                        }
+                        else {
+                            const endExpr = this.parseSliceBoundExpression();
+                            this.expect("RBRACKET");
+                            // Both bounds are explicit
+                            expr = { type: "function", functionName: "SLICE", args: [expr, indexExpr, endExpr] };
+                        }
+                    }
+                    else {
+                        // Simple index: [index]
+                        this.expect("RBRACKET");
+                        expr = { type: "function", functionName: "INDEX", args: [expr, indexExpr] };
+                    }
+                }
+            }
+        }
+        return expr;
+    }
+    /**
+     * Parse an expression that can be used as a slice bound (start or end).
+     * This is similar to parseExpression but stops at ".." to allow slice syntax.
+     * It uses a modified postfix parser that detects ".." and stops before consuming it.
+     */
+    parseSliceBoundExpression() {
+        return this.parseSliceBoundAdditiveExpression();
+    }
+    parseSliceBoundAdditiveExpression() {
+        let left = this.parseSliceBoundMultiplicativeExpression();
+        while (this.check("PLUS") || this.check("DASH")) {
+            const operatorToken = this.advance();
+            const operator = operatorToken.type === "PLUS" ? "+" : "-";
+            const right = this.parseSliceBoundMultiplicativeExpression();
+            left = { type: "binary", operator: operator, left, right };
+        }
+        return left;
+    }
+    parseSliceBoundMultiplicativeExpression() {
+        let left = this.parseSliceBoundExponentialExpression();
+        while (this.check("STAR") || this.check("SLASH") || this.check("PERCENT")) {
+            const operatorToken = this.advance();
+            let operator;
+            if (operatorToken.type === "STAR")
+                operator = "*";
+            else if (operatorToken.type === "SLASH")
+                operator = "/";
+            else
+                operator = "%";
+            const right = this.parseSliceBoundExponentialExpression();
+            left = { type: "binary", operator, left, right };
+        }
+        return left;
+    }
+    parseSliceBoundExponentialExpression() {
+        let left = this.parseSliceBoundPostfixExpression();
+        while (this.check("CARET")) {
+            this.advance();
+            const right = this.parseSliceBoundPostfixExpression();
+            left = { type: "binary", operator: "^", left, right };
+        }
+        return left;
+    }
+    /**
+     * Parse postfix expression for slice bounds. This version detects ".."
+     * and stops before consuming it, allowing the slice syntax to be parsed correctly.
+     */
+    parseSliceBoundPostfixExpression() {
+        let expr = this.parsePrimaryExpression();
+        // Handle postfix operations, but stop at ".." for slice syntax
+        while (this.check("LBRACKET") || this.check("DOT")) {
+            if (this.check("DOT")) {
+                // Check if this is ".." (slice syntax) - if so, stop here
+                const nextToken = this.tokens[this.pos + 1];
+                if (nextToken && nextToken.type === "DOT") {
+                    // This is ".." - stop parsing, let the caller handle slice
+                    break;
+                }
+                // Single dot - property access
+                this.advance(); // consume .
+                const property = this.expectIdentifierOrKeyword();
+                expr = { type: "propertyAccess", object: expr, property };
+            }
+            else {
+                // LBRACKET - nested index access
+                this.advance(); // consume [
+                if (this.check("DOT")) {
+                    // [..end] - from start (implicit start = 0)
+                    this.advance();
+                    this.expect("DOT");
+                    const endExpr = this.parseSliceBoundExpression();
+                    this.expect("RBRACKET");
+                    expr = { type: "function", functionName: "SLICE_FROM_START", args: [expr, endExpr] };
+                }
+                else {
+                    const indexExpr = this.parseSliceBoundExpression();
+                    if (this.check("DOT")) {
+                        this.advance();
+                        this.expect("DOT");
+                        if (this.check("RBRACKET")) {
+                            // [start..] - to end (implicit end = list length)
+                            this.expect("RBRACKET");
+                            expr = { type: "function", functionName: "SLICE_TO_END", args: [expr, indexExpr] };
+                        }
+                        else {
+                            const endExpr = this.parseSliceBoundExpression();
+                            this.expect("RBRACKET");
+                            expr = { type: "function", functionName: "SLICE", args: [expr, indexExpr, endExpr] };
+                        }
+                    }
+                    else {
+                        this.expect("RBRACKET");
+                        expr = { type: "function", functionName: "INDEX", args: [expr, indexExpr] };
+                    }
+                }
+            }
+        }
+        return expr;
+    }
+    // Parse primary expressions (atoms)
+    parsePrimaryExpression() {
+        const token = this.peek();
+        // List literal [1, 2, 3]
+        if (token.type === "LBRACKET") {
+            return this.parseListLiteralExpression();
+        }
+        // Object literal { key: value, ... }
+        if (token.type === "LBRACE") {
+            return this.parseObjectLiteral();
+        }
+        // Parenthesized expression for grouping or label predicate (n:Label)
+        if (token.type === "LPAREN") {
+            // Check for label predicate: (n:Label) or (n:Label1:Label2)
+            // Look ahead: ( IDENTIFIER COLON ...
+            const nextToken = this.tokens[this.pos + 1];
+            const afterNext = this.tokens[this.pos + 2];
+            if (nextToken?.type === "IDENTIFIER" && afterNext?.type === "COLON") {
+                this.advance(); // consume (
+                const variable = this.advance().value; // consume identifier
+                // Parse one or more labels
+                const labelsList = [];
+                while (this.check("COLON")) {
+                    this.advance(); // consume :
+                    labelsList.push(this.expectLabelOrType());
+                }
+                this.expect("RPAREN");
+                if (labelsList.length === 1) {
+                    return { type: "labelPredicate", variable, label: labelsList[0] };
+                }
+                else {
+                    return { type: "labelPredicate", variable, labels: labelsList };
+                }
+            }
+            // Regular parenthesized expression - use full expression parsing including AND/OR
+            this.advance(); // consume (
+            const expr = this.parseOrExpression();
+            this.expect("RPAREN");
+            return expr;
+        }
+        // CASE expression
+        if (this.checkKeyword("CASE")) {
+            return this.parseCaseExpression();
+        }
+        // Function call: COUNT(x), id(x), count(DISTINCT x), COUNT(*)
+        // Also handles list predicates: ALL(x IN list WHERE cond), ANY(...), NONE(...), SINGLE(...)
+        if (token.type === "KEYWORD" || token.type === "IDENTIFIER") {
+            const nextToken = this.tokens[this.pos + 1];
+            if (nextToken && nextToken.type === "LPAREN") {
+                const functionName = this.advance().value.toUpperCase();
+                this.advance(); // LPAREN
+                // Check if this is a list predicate: ALL, ANY, NONE, SINGLE
+                const listPredicates = ["ALL", "ANY", "NONE", "SINGLE"];
+                if (listPredicates.includes(functionName)) {
+                    // Check for list predicate syntax: PRED(var IN list WHERE cond)
+                    // Lookahead to see if next is identifier followed by IN
+                    if (this.check("IDENTIFIER")) {
+                        const savedPos = this.pos;
+                        const varToken = this.advance();
+                        if (this.checkKeyword("IN")) {
+                            // This is a list predicate
+                            this.advance(); // consume IN
+                            return this.parseListPredicate(functionName, varToken.value);
+                        }
+                        else {
+                            // Not a list predicate syntax, backtrack
+                            this.pos = savedPos;
+                        }
+                    }
+                }
+                const args = [];
+                // Check for DISTINCT keyword after opening paren (for aggregation functions)
+                let distinct;
+                if (this.checkKeyword("DISTINCT")) {
+                    this.advance();
+                    distinct = true;
+                }
+                // Special case: COUNT(*) - handle STAR token as "count all"
+                if (this.check("STAR")) {
+                    this.advance(); // consume STAR
+                    // COUNT(*) has no arguments - the * means "count all rows"
+                    this.expect("RPAREN");
+                    return { type: "function", functionName, args: [], distinct, star: true };
+                }
+                if (!this.check("RPAREN")) {
+                    do {
+                        if (args.length > 0) {
+                            this.expect("COMMA");
+                        }
+                        // Use parseReturnExpression to support comparisons and logical operators in function args
+                        args.push(this.parseReturnExpression());
+                    } while (this.check("COMMA"));
+                }
+                this.expect("RPAREN");
+                return { type: "function", functionName, args, distinct };
+            }
+        }
+        // Parameter
+        if (token.type === "PARAMETER") {
+            this.advance();
+            return { type: "parameter", name: token.value };
+        }
+        // Unary minus for negative numbers
+        if (token.type === "DASH") {
+            this.advance(); // consume the dash
+            const nextToken = this.peek();
+            if (nextToken.type === "NUMBER") {
+                this.advance();
+                return { type: "literal", value: -this.parseNumber(nextToken.value) };
+            }
+            // For more complex expressions, create a unary minus operation
+            const operand = this.parsePrimaryExpression();
+            return { type: "binary", operator: "-", left: { type: "literal", value: 0 }, right: operand };
+        }
+        // Literal values
+        if (token.type === "STRING") {
+            this.advance();
+            return { type: "literal", value: token.value };
+        }
+        if (token.type === "NUMBER") {
+            this.advance();
+            const numberLiteralKind = token.value.includes(".") ? "float" : "integer";
+            return { type: "literal", value: this.parseNumber(token.value), raw: token.value, numberLiteralKind };
+        }
+        if (token.type === "KEYWORD") {
+            if (token.value === "TRUE") {
+                this.advance();
+                return { type: "literal", value: true };
+            }
+            if (token.value === "FALSE") {
+                this.advance();
+                return { type: "literal", value: false };
+            }
+            if (token.value === "NULL") {
+                this.advance();
+                return { type: "literal", value: null };
+            }
+        }
+        // Variable or property access
+        // Allow keywords to be used as variable names when not in keyword position
+        if (token.type === "IDENTIFIER" || (token.type === "KEYWORD" && !["TRUE", "FALSE", "NULL", "CASE"].includes(token.value))) {
+            const tok = this.advance();
+            // Use original casing for keywords used as identifiers
+            const variable = tok.originalValue || tok.value;
+            if (this.check("DOT")) {
+                this.advance();
+                // Property names can also be keywords (like 'count', 'order', etc.)
+                const property = this.expectIdentifierOrKeyword();
+                // Check for namespaced function call: namespace.function(args)
+                // e.g., duration.between(), duration.inMonths(), etc.
+                if (this.check("LPAREN")) {
+                    this.advance(); // consume (
+                    // Convert to uppercase for consistency with other functions
+                    const functionName = `${variable}.${property}`.toUpperCase();
+                    const args = [];
+                    // Check for DISTINCT keyword (for aggregation functions)
+                    let distinct;
+                    if (this.checkKeyword("DISTINCT")) {
+                        this.advance();
+                        distinct = true;
+                    }
+                    if (!this.check("RPAREN")) {
+                        do {
+                            if (args.length > 0) {
+                                this.expect("COMMA");
+                            }
+                            args.push(this.parseReturnExpression());
+                        } while (this.check("COMMA"));
+                    }
+                    this.expect("RPAREN");
+                    return { type: "function", functionName, args, distinct };
+                }
+                return { type: "property", variable, property };
+            }
+            return { type: "variable", variable };
+        }
+        throw new Error(`Expected expression, got ${token.type} '${token.value}'`);
+    }
+    parseCaseExpression() {
+        this.expect("KEYWORD", "CASE");
+        // Check for simple form: CASE expr WHEN val THEN ...
+        // vs searched form: CASE WHEN condition THEN ...
+        let caseExpr;
+        // If the next token is not WHEN, it's a simple form with an expression
+        if (!this.checkKeyword("WHEN")) {
+            caseExpr = this.parseExpression();
+        }
+        const whens = [];
+        // Parse WHEN ... THEN ... clauses
+        while (this.checkKeyword("WHEN")) {
+            this.advance(); // consume WHEN
+            let condition;
+            if (caseExpr) {
+                // Simple form: CASE expr WHEN value THEN ...
+                // The value is compared for equality with caseExpr
+                const whenValue = this.parseExpression();
+                // Create an equality comparison condition
+                condition = {
+                    type: "comparison",
+                    left: caseExpr,
+                    right: whenValue,
+                    operator: "="
+                };
+            }
+            else {
+                // Searched form: CASE WHEN condition THEN ...
+                condition = this.parseWhereCondition();
+            }
+            this.expect("KEYWORD", "THEN");
+            const result = this.parseExpression();
+            whens.push({ condition, result });
+        }
+        // Parse optional ELSE
+        let elseExpr;
+        if (this.checkKeyword("ELSE")) {
+            this.advance();
+            elseExpr = this.parseExpression();
+        }
+        this.expect("KEYWORD", "END");
+        return {
+            type: "case",
+            expression: caseExpr,
+            whens,
+            elseExpr,
+        };
+    }
+    parseObjectLiteral() {
+        this.expect("LBRACE");
+        const properties = [];
+        if (!this.check("RBRACE")) {
+            do {
+                if (properties.length > 0) {
+                    this.expect("COMMA");
+                }
+                // Property keys can be identifiers or keywords
+                const key = this.expectIdentifierOrKeyword();
+                this.expect("COLON");
+                // Use parseReturnExpression to support comparisons like {foo: a.name='Andres'}
+                const value = this.parseReturnExpression();
+                properties.push({ key, value });
+            } while (this.check("COMMA"));
+        }
+        this.expect("RBRACE");
+        return { type: "object", properties };
+    }
+    parseListLiteralExpression() {
+        this.expect("LBRACKET");
+        // Check for pattern comprehension: [(pattern) WHERE cond | expr]
+        // Pattern comprehensions start with a node pattern (parenthesis)
+        if (this.check("LPAREN")) {
+            return this.parsePatternComprehension();
+        }
+        // Check for list comprehension: [x IN list WHERE cond | expr]
+        // Or named path in pattern comprehension: [p = (pattern) | p]
+        // We need to look ahead to see which case this is
+        if (this.check("IDENTIFIER")) {
+            const savedPos = this.pos;
+            const identifier = this.advance().value;
+            if (this.checkKeyword("IN")) {
+                // This is a list comprehension
+                this.advance(); // consume "IN"
+                return this.parseListComprehension(identifier);
+            }
+            else if (this.check("EQUALS")) {
+                // This is a named path in pattern comprehension: [p = (pattern) | p]
+                this.advance(); // consume "="
+                return this.parsePatternComprehension(identifier);
+            }
+            else {
+                // Not a list comprehension or named path, backtrack
+                this.pos = savedPos;
+            }
+        }
+        // Regular list literal - elements can be full expressions (including objects)
+        const elements = [];
+        if (!this.check("RBRACKET")) {
+            do {
+                if (elements.length > 0) {
+                    this.expect("COMMA");
+                }
+                elements.push(this.parseExpression());
+            } while (this.check("COMMA"));
+        }
+        this.expect("RBRACKET");
+        // If all elements are literals, return as literal list
+        // Otherwise wrap in a function-like expression for arrays of expressions
+        const allLiterals = elements.every(e => e.type === "literal");
+        if (allLiterals) {
+            return { type: "literal", value: elements.map(e => e.value) };
+        }
+        // For lists containing expressions, use a special function type
+        return { type: "function", functionName: "LIST", args: elements };
+    }
+    /**
+     * Parse a list comprehension after [variable IN has been consumed.
+     * Full syntax: [variable IN listExpr WHERE filterCondition | mapExpr]
+     * - WHERE and | are both optional
+     */
+    parseListComprehension(variable) {
+        // Parse the source list expression
+        const listExpr = this.parseExpression();
+        // Check for optional WHERE filter
+        let filterCondition;
+        if (this.checkKeyword("WHERE")) {
+            this.advance();
+            filterCondition = this.parseListComprehensionCondition(variable);
+        }
+        // Check for optional map projection (| expr)
+        let mapExpr;
+        if (this.check("PIPE")) {
+            this.advance();
+            mapExpr = this.parseListComprehensionExpression(variable);
+        }
+        this.expect("RBRACKET");
+        return {
+            type: "listComprehension",
+            variable,
+            listExpr,
+            filterCondition,
+            mapExpr,
+        };
+    }
+    /**
+     * Parse a pattern comprehension after [ has been consumed and we see (.
+     * Syntax: [(pattern) WHERE filterCondition | mapExpr]
+     * Or with named path: [p = (pattern) WHERE filterCondition | p]
+     * WHERE and | mapExpr are optional.
+     */
+    parsePatternComprehension(pathVariable) {
+        // Parse the pattern (reuse existing pattern parsing)
+        const patterns = this.parsePatternChain();
+        // Check for optional WHERE filter
+        let filterCondition;
+        if (this.checkKeyword("WHERE")) {
+            this.advance();
+            filterCondition = this.parseOrCondition();
+        }
+        // Check for optional map projection (| expr)
+        let mapExpr;
+        if (this.check("PIPE")) {
+            this.advance();
+            mapExpr = this.parseExpression();
+        }
+        this.expect("RBRACKET");
+        return {
+            type: "patternComprehension",
+            patterns,
+            filterCondition,
+            mapExpr,
+            pathVariable, // Named path variable (e.g., p in [p = (a)-->(b) | p])
+        };
+    }
+    /**
+     * Parse a list predicate after PRED(variable IN has been consumed.
+     * Syntax: ALL/ANY/NONE/SINGLE(variable IN listExpr WHERE filterCondition)
+     * WHERE is required for list predicates.
+     */
+    parseListPredicate(predicateType, variable) {
+        // Parse the source list expression
+        const listExpr = this.parseExpression();
+        // WHERE clause is required for list predicates
+        if (!this.checkKeyword("WHERE")) {
+            throw new Error(`Expected WHERE after list expression in ${predicateType}()`);
+        }
+        this.advance(); // consume WHERE
+        // Parse the filter condition
+        const filterCondition = this.parseListComprehensionCondition(variable);
+        this.expect("RPAREN");
+        return {
+            type: "listPredicate",
+            predicateType,
+            variable,
+            listExpr,
+            filterCondition,
+        };
+    }
+    /**
+     * Parse a condition in a list comprehension, where the variable can be used.
+     * Similar to parseWhereCondition but resolves variable references.
+     */
+    parseListComprehensionCondition(variable) {
+        return this.parseOrCondition();
+    }
+    /**
+     * Parse an expression in a list comprehension map projection.
+     * Similar to parseExpression but the variable is in scope.
+     */
+    parseListComprehensionExpression(variable) {
+        return this.parseExpression();
+    }
+    // Token helpers
+    peek() {
+        return this.tokens[this.pos];
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.pos++;
+        }
+        return this.tokens[this.pos - 1];
+    }
+    isAtEnd() {
+        return this.peek().type === "EOF";
+    }
+    check(type) {
+        return this.peek().type === type;
+    }
+    checkKeyword(keyword) {
+        const token = this.peek();
+        return token.type === "KEYWORD" && token.value === keyword;
+    }
+    expect(type, value) {
+        const token = this.peek();
+        if (token.type !== type || (value !== undefined && token.value !== value)) {
+            throw new Error(`Expected ${type}${value ? ` '${value}'` : ""}, got ${token.type} '${token.value}'`);
+        }
+        return this.advance();
+    }
+    expectIdentifier() {
+        const token = this.peek();
+        if (token.type !== "IDENTIFIER") {
+            throw new Error(`Expected identifier, got ${token.type} '${token.value}'`);
+        }
+        return this.advance().value;
+    }
+    expectIdentifierOrKeyword() {
+        const token = this.peek();
+        if (token.type !== "IDENTIFIER" && token.type !== "KEYWORD") {
+            throw new Error(`Expected identifier or keyword, got ${token.type} '${token.value}'`);
+        }
+        // Keywords preserve their original casing when used as identifiers (e.g., map keys)
+        // originalValue stores the original casing before uppercasing for keyword matching
+        this.advance();
+        return token.originalValue || token.value;
+    }
+    expectLabelOrType() {
+        const token = this.peek();
+        if (token.type !== "IDENTIFIER" && token.type !== "KEYWORD") {
+            throw new Error(`Expected label or type, got ${token.type} '${token.value}'`);
+        }
+        this.advance();
+        // Labels and types preserve their original case from the query
+        // Use originalValue for keywords (which stores the original casing before uppercasing)
+        return token.originalValue || token.value;
+    }
+}
+// Convenience function
+export function parse(input) {
+    return new Parser().parse(input);
+}
+//# sourceMappingURL=parser.js.map