@typed-sql/postgres 2.0.0-rc.1 → 2.1.0-rc.1

package/dist/packages/postgres/src/parser/parser.js

@@ -0,0 +1,2683 @@
+import { SqlToolkitError, TokenCursor } from "@typed-sql/ast/toolkit";
+import { SqlTokenizeError, tokenize } from "./tokenizer.js";
+import { mergeRanges, } from "./types.js";
+export const DEFAULT_MAX_PARSE_DEPTH = 128;
+export class SqlParseError extends Error {
+    code;
+    range;
+    constructor(message, range, code = "TSQ001") {
+        super(message);
+        this.name = "SqlParseError";
+        this.code = code;
+        this.range = range;
+    }
+}
+const precedence = new Map([
+    ["OR", 1],
+    ["AND", 2],
+    ["=", 3],
+    ["!=", 3],
+    ["<>", 3],
+    ["<", 3],
+    ["<=", 3],
+    [">", 3],
+    [">=", 3],
+    ["IS", 3],
+    ["LIKE", 3],
+    ["ILIKE", 3],
+    ["SIMILAR TO", 3],
+    ["~", 3],
+    ["~*", 3],
+    ["!~", 3],
+    ["!~*", 3],
+    ["@>", 3],
+    ["<@", 3],
+    ["?", 3],
+    ["?|", 3],
+    ["?&", 3],
+    ["&&", 3],
+    ["<<", 3],
+    ["<<=", 3],
+    [">>", 3],
+    [">>=", 3],
+    ["&<", 3],
+    ["&>", 3],
+    ["-\u007c-", 3],
+    ["@?", 3],
+    ["@@", 3],
+    ["^@", 3],
+    ["<<|", 3],
+    ["|>>", 3],
+    ["&<|", 3],
+    ["|&>", 3],
+    ["<^", 3],
+    [">^", 3],
+    ["?#", 3],
+    ["?-", 3],
+    ["?|", 3],
+    ["?-|", 3],
+    ["?||", 3],
+    ["~=", 3],
+    ["<->", 4],
+    ["##", 4],
+    ["||", 4],
+    ["&", 4],
+    ["|", 4],
+    ["#", 4],
+    ["->", 4],
+    ["->>", 4],
+    ["#>", 4],
+    ["#>>", 4],
+    ["#-", 4],
+    ["+", 5],
+    ["-", 5],
+    ["*", 6],
+    ["/", 6],
+    ["%", 6],
+    ["^", 7],
+]);
+const typeContinuationWords = new Set([
+    "BIT",
+    "CHARACTER",
+    "DOUBLE",
+    "INTERVAL",
+    "PRECISION",
+    "TIME",
+    "TIMESTAMP",
+    "VARYING",
+    "WITH",
+    "WITHOUT",
+    "ZONE",
+]);
+const intervalFields = new Set(["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"]);
+const intervalFieldRanges = new Map([
+    ["YEAR", new Set(["MONTH"])],
+    ["DAY", new Set(["HOUR", "MINUTE", "SECOND"])],
+    ["HOUR", new Set(["MINUTE", "SECOND"])],
+    ["MINUTE", new Set(["SECOND"])],
+]);
+const simpleTypedLiteralTypes = new Set(["JSON", "JSONB", "JSONPATH"]);
+class Parser {
+    #source;
+    #cursor;
+    #syntax = "postgres";
+    #stopSelectListBeforeJsonFormat = false;
+    constructor(source, options) {
+        this.#source = source;
+        this.#cursor = new TokenCursor(tokenize(source, options), {
+            maxDepth: options.maxDepth ?? DEFAULT_MAX_PARSE_DEPTH,
+        });
+    }
+    parse() {
+        const statement = this.#parseStatement();
+        this.#matchPunctuation(";");
+        this.#expect("eof", "end of query");
+        return statement;
+    }
+    #parseStatement() {
+        return this.#nested(() => {
+            const withClause = this.#current().value === "WITH" ? this.#parseWithClause() : undefined;
+            if (this.#current().value === "SELECT")
+                return this.#parseSelect(withClause);
+            if (withClause === undefined && this.#current().value === "(") {
+                const statement = this.#parseParenthesizedSelect();
+                return this.#parseSelectTail(this.#parseCompoundExpression(statement, 0));
+            }
+            if (this.#current().value === "INSERT")
+                return this.#parseInsert(withClause);
+            if (this.#current().value === "UPDATE")
+                return this.#parseUpdate(withClause);
+            if (this.#current().value === "DELETE")
+                return this.#parseDelete(withClause);
+            if (this.#current().value === "MERGE")
+                return this.#parseMerge(withClause);
+            throw this.#error(`Expected SELECT, INSERT, UPDATE, DELETE, or MERGE, found ${this.#current().text || "end of query"}`, this.#current().range);
+        });
+    }
+    #parseWithClause() {
+        const start = this.#expectKeyword("WITH").range;
+        const recursive = this.#matchKeyword("RECURSIVE");
+        const queries = [];
+        do {
+            const name = this.#parseIdentifier();
+            const columns = [];
+            if (this.#matchPunctuation("(")) {
+                if (!this.#matchPunctuation(")")) {
+                    do
+                        columns.push(this.#parseIdentifier());
+                    while (this.#matchPunctuation(","));
+                    this.#expectPunctuation(")");
+                }
+            }
+            this.#expectKeyword("AS");
+            let materialization;
+            if (this.#matchKeyword("NOT")) {
+                this.#expectKeyword("MATERIALIZED");
+                materialization = "not-materialized";
+            }
+            else if (this.#matchKeyword("MATERIALIZED"))
+                materialization = "materialized";
+            this.#expectPunctuation("(");
+            const statement = this.#parseStatement();
+            const close = this.#expectPunctuation(")");
+            let search;
+            if (this.#matchKeyword("SEARCH")) {
+                const searchStart = this.#previous().range;
+                let order;
+                if (this.#matchKeyword("BREADTH"))
+                    order = "breadth";
+                else if (this.#matchKeyword("DEPTH"))
+                    order = "depth";
+                else
+                    throw this.#error("SEARCH requires BREADTH or DEPTH", this.#current().range);
+                this.#expectKeyword("FIRST");
+                this.#expectKeyword("BY");
+                const by = [];
+                do
+                    by.push(this.#parseIdentifier());
+                while (this.#matchPunctuation(","));
+                this.#expectKeyword("SET");
+                const set = this.#parseIdentifier();
+                search = { order, by, set, range: mergeRanges(searchStart, set.range) };
+            }
+            let cycle;
+            if (this.#matchKeyword("CYCLE")) {
+                const cycleStart = this.#previous().range;
+                const cycleColumns = [];
+                do
+                    cycleColumns.push(this.#parseIdentifier());
+                while (this.#matchPunctuation(","));
+                this.#expectKeyword("SET");
+                const set = this.#parseIdentifier();
+                let markValue;
+                let markDefault;
+                if (this.#matchKeyword("TO")) {
+                    markValue = this.#parseExpression();
+                    this.#expectKeyword("DEFAULT");
+                    markDefault = this.#parseExpression();
+                }
+                this.#expectKeyword("USING");
+                const using = this.#parseIdentifier();
+                cycle = {
+                    columns: cycleColumns,
+                    set,
+                    ...(markValue === undefined ? {} : { markValue }),
+                    ...(markDefault === undefined ? {} : { markDefault }),
+                    using,
+                    range: mergeRanges(cycleStart, using.range),
+                };
+            }
+            queries.push({
+                name,
+                columns,
+                statement,
+                ...(materialization === undefined ? {} : { materialization }),
+                ...(search === undefined ? {} : { search }),
+                ...(cycle === undefined ? {} : { cycle }),
+                range: mergeRanges(name.range, cycle?.range ?? search?.range ?? close.range),
+            });
+        } while (this.#matchPunctuation(","));
+        return { recursive, queries, range: mergeRanges(start, queries.at(-1)?.range ?? start) };
+    }
+    #parseSelect(withClause, minimumCompoundPrecedence = 0) {
+        const start = withClause?.range ?? this.#current().range;
+        this.#expectKeyword("SELECT");
+        let distinct = false;
+        const distinctOn = [];
+        if (this.#matchKeyword("DISTINCT")) {
+            distinct = true;
+            if (this.#matchKeyword("ON")) {
+                this.#expectPunctuation("(");
+                distinctOn.push(...this.#parseExpressionList());
+                this.#expectPunctuation(")");
+            }
+        }
+        else
+            this.#matchKeyword("ALL");
+        const columns = this.#parseSelectList();
+        let from;
+        const joins = [];
+        let where;
+        let groupModifier;
+        const groupBy = [];
+        let having;
+        const windows = [];
+        if (this.#matchKeyword("FROM")) {
+            from = this.#parseTableReference();
+            while (true) {
+                if (this.#matchPunctuation(",")) {
+                    const table = this.#parseTableReference();
+                    joins.push({ kind: "cross", table, range: table.range });
+                }
+                else if (this.#isJoinStart())
+                    joins.push(this.#parseJoin());
+                else
+                    break;
+            }
+        }
+        if (this.#matchKeyword("WHERE"))
+            where = this.#parseExpression();
+        if (this.#matchKeyword("GROUP")) {
+            this.#expectKeyword("BY");
+            if (this.#matchKeyword("ALL"))
+                groupModifier = "all";
+            else if (this.#matchKeyword("DISTINCT"))
+                groupModifier = "distinct";
+            groupBy.push(...this.#parseGroupingList());
+        }
+        if (this.#matchKeyword("HAVING"))
+            having = this.#parseExpression();
+        if (this.#matchKeyword("WINDOW")) {
+            do {
+                const name = this.#parseIdentifier();
+                this.#expectKeyword("AS");
+                const specification = this.#parseWindowSpecification();
+                windows.push({ name, specification, range: mergeRanges(name.range, specification.range) });
+            } while (this.#matchPunctuation(","));
+        }
+        const end = this.#previous().range;
+        const core = {
+            kind: "select",
+            ...(withClause === undefined ? {} : { with: withClause }),
+            distinct,
+            distinctOn,
+            columns,
+            ...(from === undefined ? {} : { from }),
+            joins,
+            ...(where === undefined ? {} : { where }),
+            ...(groupModifier === undefined ? {} : { groupModifier }),
+            groupBy,
+            ...(having === undefined ? {} : { having }),
+            windows,
+            orderBy: [],
+            locking: [],
+            compounds: [],
+            range: mergeRanges(start, end),
+        };
+        const compound = this.#parseCompoundExpression(core, minimumCompoundPrecedence);
+        return minimumCompoundPrecedence === 0 ? this.#parseSelectTail(compound) : compound;
+    }
+    #parseParenthesizedSelect() {
+        const open = this.#expectPunctuation("(");
+        const statement = this.#parseStatement();
+        if (statement.kind !== "select")
+            throw this.#error("A compound query operand must be a SELECT", statement.range);
+        const close = this.#expectPunctuation(")");
+        return { ...statement, range: mergeRanges(open.range, close.range) };
+    }
+    #parseCompoundExpression(initial, minimumPrecedence) {
+        let statement = initial;
+        while (["UNION", "INTERSECT", "EXCEPT"].includes(this.#current().value)) {
+            const precedence = this.#current().value === "INTERSECT" ? 2 : 1;
+            if (precedence < minimumPrecedence)
+                break;
+            const operatorToken = this.#current();
+            this.#advance();
+            const all = this.#matchKeyword("ALL");
+            if (this.#syntax === "sqlite" && all && operatorToken.value !== "UNION") {
+                throw this.#error(`SQLite does not support ${operatorToken.value} ALL`, this.#previous().range);
+            }
+            const right = this.#current().value === "(" ? this.#parseParenthesizedSelect() : this.#parseSelect(undefined, precedence + 1);
+            const compound = {
+                operator: operatorToken.value.toLowerCase(),
+                all,
+                statement: right,
+                range: mergeRanges(operatorToken.range, right.range),
+            };
+            statement = {
+                ...statement,
+                compounds: [...statement.compounds, compound],
+                range: mergeRanges(statement.range, right.range),
+            };
+        }
+        return statement;
+    }
+    #parseSelectTail(statement) {
+        let orderBy = [];
+        let limit;
+        let limitAll = false;
+        let offset;
+        let fetch;
+        const locking = [];
+        if (this.#matchKeyword("ORDER")) {
+            this.#expectKeyword("BY");
+            orderBy = this.#parseOrderByList();
+        }
+        if (this.#matchKeyword("LIMIT")) {
+            if (this.#matchKeyword("ALL"))
+                limitAll = true;
+            else
+                limit = this.#parseExpression();
+            if (this.#syntax !== "postgres" && this.#matchPunctuation(",")) {
+                offset = limit;
+                limit = this.#parseExpression();
+            }
+        }
+        if (this.#matchKeyword("OFFSET")) {
+            offset = this.#parseExpression();
+            this.#matchKeyword("ROW") || this.#matchKeyword("ROWS");
+        }
+        if (this.#matchKeyword("FETCH")) {
+            const fetchStart = this.#previous().range;
+            if (!this.#matchKeyword("FIRST"))
+                this.#expectKeyword("NEXT");
+            const count = ["ROW", "ROWS"].includes(this.#current().value) ? undefined : this.#parseExpression();
+            if (!this.#matchKeyword("ROW"))
+                this.#expectKeyword("ROWS");
+            let withTies = false;
+            if (this.#matchKeyword("WITH")) {
+                this.#expectKeyword("TIES");
+                withTies = true;
+            }
+            else
+                this.#expectKeyword("ONLY");
+            fetch = {
+                ...(count === undefined ? {} : { count }),
+                withTies,
+                range: mergeRanges(fetchStart, this.#previous().range),
+            };
+        }
+        while (this.#current().value === "FOR")
+            locking.push(this.#parseSelectLockingClause());
+        if (this.#current().value === "LOCK") {
+            if (this.#syntax !== "mysql")
+                throw this.#error("LOCK IN SHARE MODE is MySQL syntax", this.#current().range);
+            if (locking.length > 0) {
+                throw this.#error("LOCK IN SHARE MODE cannot follow another MySQL locking clause", this.#current().range);
+            }
+            const lockStart = this.#expectKeyword("LOCK").range;
+            this.#expectKeyword("IN");
+            this.#expectKeyword("SHARE");
+            const lockEnd = this.#expectKeyword("MODE").range;
+            locking.push({ strength: "share", relations: [], range: mergeRanges(lockStart, lockEnd) });
+        }
+        const end = this.#previous().range;
+        return {
+            ...statement,
+            orderBy,
+            ...(limit === undefined ? {} : { limit }),
+            ...(limitAll ? { limitAll: true } : {}),
+            ...(offset === undefined ? {} : { offset }),
+            ...(fetch === undefined ? {} : { fetch }),
+            locking,
+            range: mergeRanges(statement.range, end),
+        };
+    }
+    #parseSelectLockingClause() {
+        const start = this.#expectKeyword("FOR").range;
+        let strength;
+        if (this.#matchKeyword("UPDATE"))
+            strength = "update";
+        else if (this.#matchKeyword("SHARE"))
+            strength = "share";
+        else if (this.#matchKeyword("NO")) {
+            if (this.#syntax !== "postgres")
+                throw this.#error("FOR NO KEY UPDATE is PostgreSQL syntax", start);
+            this.#expectKeyword("KEY");
+            this.#expectKeyword("UPDATE");
+            strength = "no-key-update";
+        }
+        else if (this.#matchKeyword("KEY")) {
+            if (this.#syntax !== "postgres")
+                throw this.#error("FOR KEY SHARE is PostgreSQL syntax", start);
+            this.#expectKeyword("SHARE");
+            strength = "key-share";
+        }
+        else {
+            throw this.#error("Expected UPDATE, NO KEY UPDATE, SHARE, or KEY SHARE after FOR", this.#current().range);
+        }
+        const relations = [];
+        if (this.#matchKeyword("OF")) {
+            do
+                relations.push(this.#parseIdentifier());
+            while (this.#matchPunctuation(","));
+        }
+        let wait;
+        if (this.#matchKeyword("NOWAIT"))
+            wait = "nowait";
+        else if (this.#matchKeyword("SKIP")) {
+            this.#expectKeyword("LOCKED");
+            wait = "skip-locked";
+        }
+        return {
+            strength,
+            relations,
+            ...(wait === undefined ? {} : { wait }),
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseInsert(withClause) {
+        const start = withClause?.range ?? this.#expectKeyword("INSERT").range;
+        if (withClause !== undefined)
+            this.#expectKeyword("INSERT");
+        this.#expectKeyword("INTO");
+        const table = this.#parseNamedTableReference(true);
+        const columns = [];
+        if (this.#matchPunctuation("(")) {
+            if (!this.#matchPunctuation(")")) {
+                do
+                    columns.push(this.#parseIdentifier());
+                while (this.#matchPunctuation(","));
+                this.#expectPunctuation(")");
+            }
+        }
+        let overriding;
+        if (this.#matchKeyword("OVERRIDING")) {
+            if (this.#matchWord("SYSTEM"))
+                overriding = "system";
+            else {
+                this.#expectWord("USER");
+                overriding = "user";
+            }
+            this.#expectWord("VALUE");
+        }
+        let source;
+        if (this.#matchKeyword("DEFAULT")) {
+            const sourceStart = this.#previous().range;
+            const end = this.#expectKeyword("VALUES").range;
+            source = { kind: "default-values", range: mergeRanges(sourceStart, end) };
+        }
+        else if (this.#matchKeyword("VALUES")) {
+            const sourceStart = this.#previous().range;
+            const rows = [];
+            do {
+                this.#expectPunctuation("(");
+                const row = this.#matchPunctuation(")") ? [] : [...this.#parseExpressionList()];
+                const close = this.#previous().value === ")" ? this.#previous() : this.#expectPunctuation(")");
+                rows.push(row);
+                if (close.value !== ")")
+                    throw this.#error("Expected ) after VALUES row", close.range);
+            } while (this.#matchPunctuation(","));
+            source = { kind: "values", rows, range: mergeRanges(sourceStart, this.#previous().range) };
+        }
+        else if (this.#current().value === "SELECT" || this.#current().value === "WITH") {
+            const statement = this.#parseStatement();
+            if (statement.kind !== "select")
+                throw this.#error("INSERT source must be SELECT or VALUES", statement.range);
+            source = statement;
+        }
+        else
+            throw this.#error("Expected VALUES, DEFAULT VALUES, or SELECT after INSERT target", this.#current().range);
+        const conflict = this.#matchKeyword("ON") ? this.#parseInsertConflictClause() : undefined;
+        const { aliases: returningAliases, items: returning } = this.#parseReturning();
+        return {
+            kind: "insert",
+            ...(withClause === undefined ? {} : { with: withClause }),
+            table,
+            columns,
+            ...(overriding === undefined ? {} : { overriding }),
+            source,
+            ...(conflict === undefined ? {} : { conflict }),
+            ...(returningAliases === undefined ? {} : { returningAliases }),
+            returning,
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseUpdate(withClause) {
+        const start = withClause?.range ?? this.#expectKeyword("UPDATE").range;
+        if (withClause !== undefined)
+            this.#expectKeyword("UPDATE");
+        const table = this.#parseNamedTableReference(true);
+        this.#expectKeyword("SET");
+        const assignments = this.#parseUpdateAssignments();
+        let from;
+        const joins = [];
+        if (this.#matchKeyword("FROM")) {
+            from = this.#parseTableReference();
+            while (true) {
+                if (this.#matchPunctuation(",")) {
+                    const table = this.#parseTableReference();
+                    joins.push({ kind: "cross", table, range: table.range });
+                }
+                else if (this.#isJoinStart())
+                    joins.push(this.#parseJoin());
+                else
+                    break;
+            }
+        }
+        let where;
+        let currentOf;
+        if (this.#matchKeyword("WHERE")) {
+            const whereStart = this.#previous().range;
+            if (this.#matchKeyword("CURRENT")) {
+                this.#expectKeyword("OF");
+                const cursor = this.#parseIdentifier(true);
+                currentOf = { cursor, range: mergeRanges(whereStart, cursor.range) };
+            }
+            else
+                where = this.#parseExpression();
+        }
+        const { aliases: returningAliases, items: returning } = this.#parseReturning();
+        return {
+            kind: "update",
+            ...(withClause === undefined ? {} : { with: withClause }),
+            table,
+            assignments,
+            ...(from === undefined ? {} : { from }),
+            joins,
+            ...(where === undefined ? {} : { where }),
+            ...(currentOf === undefined ? {} : { currentOf }),
+            ...(returningAliases === undefined ? {} : { returningAliases }),
+            returning,
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseDelete(withClause) {
+        const start = withClause?.range ?? this.#expectKeyword("DELETE").range;
+        if (withClause !== undefined)
+            this.#expectKeyword("DELETE");
+        this.#expectKeyword("FROM");
+        const table = this.#parseNamedTableReference(true);
+        const using = [];
+        const joins = [];
+        if (this.#matchKeyword("USING")) {
+            using.push(this.#parseTableReference());
+            while (true) {
+                if (this.#matchPunctuation(","))
+                    using.push(this.#parseTableReference());
+                else if (this.#isJoinStart())
+                    joins.push(this.#parseJoin());
+                else
+                    break;
+            }
+        }
+        let where;
+        let currentOf;
+        if (this.#matchKeyword("WHERE")) {
+            const whereStart = this.#previous().range;
+            if (this.#matchKeyword("CURRENT")) {
+                this.#expectKeyword("OF");
+                const cursor = this.#parseIdentifier(true);
+                currentOf = { cursor, range: mergeRanges(whereStart, cursor.range) };
+            }
+            else
+                where = this.#parseExpression();
+        }
+        const { aliases: returningAliases, items: returning } = this.#parseReturning();
+        return {
+            kind: "delete",
+            ...(withClause === undefined ? {} : { with: withClause }),
+            table,
+            using,
+            joins,
+            ...(where === undefined ? {} : { where }),
+            ...(currentOf === undefined ? {} : { currentOf }),
+            ...(returningAliases === undefined ? {} : { returningAliases }),
+            returning,
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseMerge(withClause) {
+        const start = withClause?.range ?? this.#expectKeyword("MERGE").range;
+        if (withClause !== undefined)
+            this.#expectKeyword("MERGE");
+        this.#expectKeyword("INTO");
+        const table = this.#parseNamedTableReference(true);
+        this.#expectKeyword("USING");
+        const source = this.#parseMergeSource();
+        this.#expectKeyword("ON");
+        const on = this.#parseExpression();
+        const clauses = [];
+        while (this.#matchKeyword("WHEN")) {
+            const clauseStart = this.#previous().range;
+            let match;
+            let by;
+            if (this.#matchKeyword("MATCHED"))
+                match = "matched";
+            else {
+                this.#expectKeyword("NOT");
+                this.#expectKeyword("MATCHED");
+                if (this.#matchKeyword("BY")) {
+                    if (this.#matchWord("SOURCE")) {
+                        match = "not-matched-source";
+                        by = "source";
+                    }
+                    else {
+                        this.#expectWord("TARGET");
+                        match = "not-matched-target";
+                        by = "target";
+                    }
+                }
+                else
+                    match = "not-matched-target";
+            }
+            const condition = this.#matchKeyword("AND") ? this.#parseExpression() : undefined;
+            this.#expectKeyword("THEN");
+            let action;
+            if (this.#matchKeyword("DO")) {
+                this.#expectKeyword("NOTHING");
+                action = { kind: "nothing", range: mergeRanges(clauseStart, this.#previous().range) };
+            }
+            else if (this.#matchKeyword("DELETE")) {
+                action = { kind: "delete", range: mergeRanges(clauseStart, this.#previous().range) };
+            }
+            else if (this.#matchKeyword("UPDATE")) {
+                this.#expectKeyword("SET");
+                const assignments = this.#parseUpdateAssignments();
+                action = {
+                    kind: "update",
+                    assignments,
+                    range: mergeRanges(clauseStart, assignments.at(-1)?.range ?? clauseStart),
+                };
+            }
+            else {
+                this.#expectKeyword("INSERT");
+                const columns = [];
+                if (this.#matchPunctuation("(")) {
+                    do
+                        columns.push(this.#parseIdentifier());
+                    while (this.#matchPunctuation(","));
+                    this.#expectPunctuation(")");
+                }
+                let overriding;
+                if (this.#matchKeyword("OVERRIDING")) {
+                    if (this.#matchWord("SYSTEM"))
+                        overriding = "system";
+                    else {
+                        this.#expectWord("USER");
+                        overriding = "user";
+                    }
+                    this.#expectWord("VALUE");
+                }
+                let actionSource;
+                if (this.#matchKeyword("DEFAULT")) {
+                    const sourceStart = this.#previous().range;
+                    const end = this.#expectKeyword("VALUES").range;
+                    actionSource = { kind: "default-values", range: mergeRanges(sourceStart, end) };
+                }
+                else {
+                    const sourceStart = this.#expectKeyword("VALUES").range;
+                    this.#expectPunctuation("(");
+                    const row = this.#matchPunctuation(")") ? [] : [...this.#parseExpressionList()];
+                    const close = this.#previous().value === ")" ? this.#previous() : this.#expectPunctuation(")");
+                    actionSource = { kind: "values", rows: [row], range: mergeRanges(sourceStart, close.range) };
+                }
+                action = {
+                    kind: "insert",
+                    columns,
+                    ...(overriding === undefined ? {} : { overriding }),
+                    source: actionSource,
+                    range: mergeRanges(clauseStart, actionSource.range),
+                };
+            }
+            clauses.push({
+                match,
+                ...(by === undefined ? {} : { by }),
+                ...(condition === undefined ? {} : { condition }),
+                action,
+                range: mergeRanges(clauseStart, action.range),
+            });
+        }
+        if (clauses.length === 0)
+            throw this.#error("MERGE requires at least one WHEN clause", this.#current().range);
+        const { aliases: returningAliases, items: returning } = this.#parseReturning();
+        return {
+            kind: "merge",
+            ...(withClause === undefined ? {} : { with: withClause }),
+            table,
+            source,
+            on,
+            clauses,
+            ...(returningAliases === undefined ? {} : { returningAliases }),
+            returning,
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseInsertConflictClause() {
+        const start = this.#previous().range;
+        this.#expectKeyword("CONFLICT");
+        let target;
+        if (this.#matchKeyword("ON")) {
+            this.#expectKeyword("CONSTRAINT");
+            const constraint = this.#parseIdentifier(true);
+            target = { kind: "constraint", constraint, range: mergeRanges(start, constraint.range) };
+        }
+        else if (this.#matchPunctuation("(")) {
+            const elements = [];
+            do {
+                const elementStart = this.#current().range;
+                let expression = this.#parseExpression();
+                let collation;
+                if (expression.kind === "collate") {
+                    collation = expression.collation;
+                    expression = expression.expression;
+                }
+                else if (this.#matchKeyword("COLLATE"))
+                    collation = this.#parseQualifiedIdentifier();
+                const operatorClass = this.#current().value !== "," && this.#current().value !== ")" ? this.#parseQualifiedIdentifier() : undefined;
+                elements.push({
+                    expression,
+                    ...(collation === undefined ? {} : { collation }),
+                    ...(operatorClass === undefined ? {} : { operatorClass }),
+                    range: mergeRanges(elementStart, operatorClass?.range ?? collation?.range ?? expression.range),
+                });
+            } while (this.#matchPunctuation(","));
+            const close = this.#expectPunctuation(")");
+            const predicate = this.#matchKeyword("WHERE") ? this.#parseExpression() : undefined;
+            target = {
+                kind: "inference",
+                elements,
+                ...(predicate === undefined ? {} : { predicate }),
+                range: mergeRanges(start, predicate?.range ?? close.range),
+            };
+        }
+        this.#expectKeyword("DO");
+        let action;
+        if (this.#matchKeyword("NOTHING")) {
+            action = { kind: "nothing", range: mergeRanges(start, this.#previous().range) };
+        }
+        else {
+            this.#expectKeyword("UPDATE");
+            this.#expectKeyword("SET");
+            const assignments = this.#parseUpdateAssignments();
+            const where = this.#matchKeyword("WHERE") ? this.#parseExpression() : undefined;
+            action = {
+                kind: "update",
+                assignments,
+                ...(where === undefined ? {} : { where }),
+                range: mergeRanges(start, where?.range ?? assignments.at(-1)?.range ?? start),
+            };
+        }
+        return { ...(target === undefined ? {} : { target }), action, range: mergeRanges(start, action.range) };
+    }
+    #parseMergeSource() {
+        const start = this.#current().range;
+        if (this.#current().value !== "(" || this.#peekToken(1).value !== "VALUES")
+            return this.#parseTableReference();
+        this.#expectPunctuation("(");
+        this.#expectKeyword("VALUES");
+        const rows = [];
+        do {
+            this.#expectPunctuation("(");
+            const row = this.#matchPunctuation(")") ? [] : [...this.#parseExpressionList()];
+            if (this.#previous().value !== ")")
+                this.#expectPunctuation(")");
+            rows.push(row);
+        } while (this.#matchPunctuation(","));
+        this.#expectPunctuation(")");
+        let alias;
+        if (this.#matchKeyword("AS"))
+            alias = this.#parseIdentifier(true);
+        else if (this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier")
+            alias = this.#parseIdentifier();
+        const columns = [];
+        if (alias !== undefined && this.#matchPunctuation("(")) {
+            do
+                columns.push(this.#parseIdentifier());
+            while (this.#matchPunctuation(","));
+            this.#expectPunctuation(")");
+        }
+        return {
+            kind: "values",
+            rows,
+            ...(alias === undefined ? {} : { alias }),
+            columns,
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseUpdateAssignments() {
+        const assignments = [];
+        do {
+            if (this.#matchPunctuation("(")) {
+                const start = this.#previous().range;
+                const columns = [];
+                do
+                    columns.push(this.#parseIdentifier());
+                while (this.#matchPunctuation(","));
+                this.#expectPunctuation(")");
+                this.#expectOperator("=");
+                const value = this.#matchKeyword("ROW")
+                    ? (() => {
+                        const rowStart = this.#previous().range;
+                        this.#expectPunctuation("(");
+                        const elements = [...this.#parseExpressionList()];
+                        const close = this.#expectPunctuation(")");
+                        return { kind: "row", elements, range: mergeRanges(rowStart, close.range) };
+                    })()
+                    : this.#parseExpression();
+                assignments.push({ columns, value, range: mergeRanges(start, value.range) });
+            }
+            else {
+                const column = this.#parseIdentifier();
+                this.#expectOperator("=");
+                const value = this.#parseExpression();
+                assignments.push({ column, value, range: mergeRanges(column.range, value.range) });
+            }
+        } while (this.#matchPunctuation(","));
+        return assignments;
+    }
+    #parseReturning() {
+        if (!this.#matchKeyword("RETURNING"))
+            return { items: [] };
+        let aliases;
+        if (this.#matchKeyword("WITH")) {
+            const start = this.#previous().range;
+            this.#expectPunctuation("(");
+            let oldAlias;
+            let newAlias;
+            do {
+                const kind = this.#current().value;
+                if (kind !== "OLD" && kind !== "NEW")
+                    throw this.#error("RETURNING aliases require OLD or NEW", this.#current().range);
+                this.#advance();
+                this.#expectKeyword("AS");
+                const alias = this.#parseIdentifier(true);
+                if (kind === "OLD")
+                    oldAlias = alias;
+                else
+                    newAlias = alias;
+            } while (this.#matchPunctuation(","));
+            const close = this.#expectPunctuation(")");
+            aliases = {
+                ...(oldAlias === undefined ? {} : { old: oldAlias }),
+                ...(newAlias === undefined ? {} : { new: newAlias }),
+                range: mergeRanges(start, close.range),
+            };
+        }
+        return { ...(aliases === undefined ? {} : { aliases }), items: this.#parseSelectList() };
+    }
+    #parseSelectList() {
+        const items = [];
+        do {
+            const expression = this.#parseExpression();
+            let alias;
+            if (this.#matchKeyword("AS"))
+                alias = this.#parseIdentifier();
+            else if ((this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier") &&
+                !this.#isJsonArrayQueryFormatStart())
+                alias = this.#parseIdentifier();
+            items.push({
+                expression,
+                ...(alias === undefined ? {} : { alias }),
+                range: mergeRanges(expression.range, alias?.range ?? expression.range),
+            });
+        } while (this.#matchPunctuation(","));
+        return items;
+    }
+    #parseTableReference() {
+        const lateral = this.#matchKeyword("LATERAL");
+        const start = lateral ? this.#previous().range : this.#current().range;
+        if (this.#matchPunctuation("(")) {
+            if (!this.#isStatementStart()) {
+                throw this.#error("A parenthesized FROM item must be a SELECT subquery", this.#current().range);
+            }
+            const statement = this.#parseStatement();
+            if (statement.kind !== "select")
+                throw this.#error("FROM subquery must be SELECT", statement.range);
+            const close = this.#expectPunctuation(")");
+            let alias;
+            if (this.#matchKeyword("AS"))
+                alias = this.#parseIdentifier(true);
+            else if (!this.#isJsonArrayQueryFormatStart() &&
+                (this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier"))
+                alias = this.#parseIdentifier();
+            const columns = [];
+            if (alias !== undefined && this.#matchPunctuation("(")) {
+                do
+                    columns.push(this.#parseIdentifier());
+                while (this.#matchPunctuation(","));
+                this.#expectPunctuation(")");
+            }
+            return {
+                kind: "subquery",
+                query: statement,
+                ...(alias === undefined ? {} : { alias }),
+                columns,
+                lateral,
+                range: mergeRanges(start, alias === undefined ? close.range : this.#previous().range),
+            };
+        }
+        if (this.#isWord(this.#current(), "JSON_TABLE") && this.#peekToken(1).value === "(") {
+            return this.#parseJsonTableReference(lateral, start);
+        }
+        if (this.#current().value === "ROWS" || this.#isTableFunctionStart()) {
+            return this.#parseFunctionTableReference(lateral, start);
+        }
+        return this.#parseNamedTableReference(true, lateral, start);
+    }
+    #parseJsonTableReference(lateral, start) {
+        this.#expectWord("JSON_TABLE");
+        this.#expectPunctuation("(");
+        const context = this.#parseJsonValueExpression();
+        this.#expectPunctuation(",");
+        const path = this.#parseExpression();
+        const pathName = this.#matchKeyword("AS") ? this.#parseIdentifier(true) : undefined;
+        const passing = this.#parseJsonPassing();
+        this.#expectWord("COLUMNS");
+        this.#expectPunctuation("(");
+        const jsonColumns = this.#parseJsonTableColumns();
+        this.#expectPunctuation(")");
+        const onError = this.#isJsonTableBehaviorStart() ? this.#parseJsonOnErrorBehavior() : undefined;
+        const close = this.#expectPunctuation(")");
+        let alias;
+        if (this.#matchKeyword("AS"))
+            alias = this.#parseIdentifier(true);
+        else if (!this.#isJsonArrayQueryFormatStart() &&
+            (this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier"))
+            alias = this.#parseIdentifier();
+        const columns = [];
+        if (alias !== undefined && this.#matchPunctuation("(")) {
+            do
+                columns.push(this.#parseIdentifier());
+            while (this.#matchPunctuation(","));
+            this.#expectPunctuation(")");
+        }
+        return {
+            kind: "json-table",
+            context,
+            path,
+            ...(pathName === undefined ? {} : { pathName }),
+            passing,
+            jsonColumns,
+            ...(onError === undefined ? {} : { onError }),
+            ...(alias === undefined ? {} : { alias }),
+            columns,
+            lateral,
+            range: mergeRanges(start, alias === undefined ? close.range : this.#previous().range),
+        };
+    }
+    #parseJsonTableColumns() {
+        if (this.#current().value === ")") {
+            throw this.#error("JSON_TABLE COLUMNS requires at least one column", this.#current().range);
+        }
+        const columns = [];
+        do
+            columns.push(this.#parseJsonTableColumn());
+        while (this.#matchPunctuation(","));
+        return columns;
+    }
+    #parseJsonTableColumn() {
+        const start = this.#current();
+        if (this.#matchWord("NESTED")) {
+            this.#matchWord("PATH");
+            const path = this.#parseJsonTablePathLiteral();
+            const pathName = this.#matchKeyword("AS") ? this.#parseIdentifier(true) : undefined;
+            this.#expectWord("COLUMNS");
+            this.#expectPunctuation("(");
+            const columns = this.#parseJsonTableColumns();
+            const close = this.#expectPunctuation(")");
+            return {
+                kind: "nested",
+                path,
+                ...(pathName === undefined ? {} : { pathName }),
+                columns,
+                range: mergeRanges(start.range, close.range),
+            };
+        }
+        const name = this.#parseIdentifier(true);
+        if (this.#matchKeyword("FOR")) {
+            const ordinality = this.#expectWord("ORDINALITY");
+            return { kind: "ordinality", name, range: mergeRanges(start.range, ordinality.range) };
+        }
+        const databaseType = this.#parseTypeName(false, () => this.#isJsonTableColumnClauseStart());
+        if (this.#matchWord("EXISTS")) {
+            const path = this.#matchWord("PATH") ? this.#parseJsonTablePathLiteral() : undefined;
+            const onError = this.#isJsonTableBehaviorStart() ? this.#parseJsonOnErrorBehavior() : undefined;
+            return {
+                kind: "exists",
+                name,
+                databaseType,
+                ...(path === undefined ? {} : { path }),
+                ...(onError === undefined ? {} : { onError }),
+                range: mergeRanges(start.range, onError?.range ?? path?.range ?? databaseType.range),
+            };
+        }
+        const format = this.#parseJsonFormat();
+        const path = this.#matchWord("PATH") ? this.#parseJsonTablePathLiteral() : undefined;
+        const wrapper = this.#parseJsonWrapper();
+        const quotes = this.#parseJsonQuotes();
+        let onEmpty;
+        let onError;
+        if (this.#isJsonTableBehaviorStart()) {
+            const clause = this.#parseJsonBehaviorClause(true);
+            if (clause.target === "empty")
+                onEmpty = clause.behavior;
+            else
+                onError = clause.behavior;
+        }
+        if (onEmpty !== undefined && this.#isJsonTableBehaviorStart()) {
+            const clause = this.#parseJsonBehaviorClause(true);
+            if (clause.target !== "error") {
+                throw this.#error("JSON_TABLE ON EMPTY must precede ON ERROR", clause.behavior.range);
+            }
+            onError = clause.behavior;
+        }
+        return {
+            kind: "value",
+            name,
+            databaseType,
+            ...(format === undefined ? {} : { format }),
+            ...(path === undefined ? {} : { path }),
+            ...(wrapper === undefined ? {} : { wrapper }),
+            ...(quotes === undefined ? {} : { quotes }),
+            ...(onEmpty === undefined ? {} : { onEmpty }),
+            ...(onError === undefined ? {} : { onError }),
+            range: mergeRanges(start.range, onError?.range ?? onEmpty?.range ?? this.#previous().range),
+        };
+    }
+    #parseJsonTablePathLiteral() {
+        const token = this.#expect("string", "JSON_TABLE path string literal");
+        return { kind: "literal", value: token.value, range: token.range };
+    }
+    #isJsonTableColumnClauseStart() {
+        if ([
+            "EXISTS",
+            "FORMAT",
+            "PATH",
+            "KEEP",
+            "OMIT",
+            "DEFAULT",
+            "ERROR",
+            "NULL",
+            "TRUE",
+            "FALSE",
+            "UNKNOWN",
+            "EMPTY",
+        ].some((word) => this.#isWord(this.#current(), word)))
+            return true;
+        if (this.#isWord(this.#current(), "WITHOUT")) {
+            return this.#isWord(this.#peekToken(1), "ARRAY") || this.#isWord(this.#peekToken(1), "WRAPPER");
+        }
+        if (!this.#isWord(this.#current(), "WITH"))
+            return false;
+        return ["CONDITIONAL", "UNCONDITIONAL", "ARRAY", "WRAPPER"].some((word) => this.#isWord(this.#peekToken(1), word));
+    }
+    #isTableFunctionStart() {
+        if (!this.#isIdentifierLike(this.#current()))
+            return false;
+        if (this.#peekToken(1).value === "(")
+            return true;
+        return (this.#peekToken(1).value === "." && this.#isIdentifierLike(this.#peekToken(2)) && this.#peekToken(3).value === "(");
+    }
+    #parseFunctionTableReference(lateral, start) {
+        const functions = [];
+        const rowsFrom = this.#matchKeyword("ROWS");
+        if (rowsFrom) {
+            this.#expectKeyword("FROM");
+            this.#expectPunctuation("(");
+            do
+                functions.push(this.#parseTableFunctionItem(true));
+            while (this.#matchPunctuation(","));
+            this.#expectPunctuation(")");
+        }
+        else
+            functions.push(this.#parseTableFunctionItem(false));
+        const withOrdinality = this.#matchKeyword("WITH");
+        if (withOrdinality)
+            this.#expectKeyword("ORDINALITY");
+        const hasAs = this.#matchKeyword("AS");
+        const alias = !this.#isJsonArrayQueryFormatStart() && this.#isIdentifierLike(this.#current())
+            ? this.#parseIdentifier(true)
+            : undefined;
+        if (hasAs && alias === undefined && this.#current().value !== "(") {
+            throw this.#error("Expected table-function alias or column definition list", this.#current().range);
+        }
+        const columns = this.#matchPunctuation("(") ? this.#parseTableFunctionColumns(false) : [];
+        return {
+            kind: "function",
+            ...(rowsFrom ? { rowsFrom: true } : {}),
+            functions,
+            withOrdinality,
+            ...(alias === undefined ? {} : { alias }),
+            columns,
+            lateral,
+            range: mergeRanges(start, this.#previous().range),
+        };
+    }
+    #parseTableFunctionItem(allowDefinition) {
+        const first = this.#parseIdentifier(true);
+        let schema;
+        let name = first;
+        if (this.#matchPunctuation(".")) {
+            schema = first;
+            name = this.#parseIdentifier(true);
+        }
+        this.#expectPunctuation("(");
+        const expression = this.#parseCall(schema, name);
+        if (expression.kind !== "call")
+            throw this.#error("FROM function must be a routine call", expression.range);
+        let columns = [];
+        if (allowDefinition && this.#current().value === "AS" && this.#peekToken(1).value === "(") {
+            this.#advance();
+            this.#expectPunctuation("(");
+            columns = this.#parseTableFunctionColumns(true);
+        }
+        return { call: expression, columns, range: mergeRanges(first.range, this.#previous().range) };
+    }
+    #parseTableFunctionColumns(requireTypes) {
+        const columns = [];
+        if (!this.#matchPunctuation(")")) {
+            do {
+                const name = this.#parseIdentifier(true);
+                const databaseType = requireTypes || (this.#current().value !== "," && this.#current().value !== ")")
+                    ? this.#parseTypeName(false)
+                    : undefined;
+                columns.push({
+                    name,
+                    ...(databaseType === undefined ? {} : { databaseType }),
+                    range: mergeRanges(name.range, databaseType?.range ?? name.range),
+                });
+            } while (this.#matchPunctuation(","));
+            this.#expectPunctuation(")");
+        }
+        return columns;
+    }
+    #parseNamedTableReference(allowAlias, lateral = false, start = this.#current().range) {
+        const only = this.#matchKeyword("ONLY");
+        const first = this.#parseIdentifier();
+        let schema;
+        let name = first;
+        if (this.#matchPunctuation(".")) {
+            schema = first;
+            name = this.#parseIdentifier();
+        }
+        const includeDescendants = this.#matchOperator("*");
+        let alias;
+        if (allowAlias && this.#matchKeyword("AS"))
+            alias = this.#parseIdentifier(true);
+        else if (allowAlias &&
+            !this.#isJsonArrayQueryFormatStart() &&
+            (this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier"))
+            alias = this.#parseIdentifier();
+        let sample;
+        if (allowAlias && this.#matchKeyword("TABLESAMPLE")) {
+            const sampleStart = this.#previous().range;
+            const method = this.#parseIdentifier(true);
+            this.#expectPunctuation("(");
+            const empty = this.#matchPunctuation(")");
+            const argumentsList = empty ? [] : [...this.#parseExpressionList()];
+            if (!empty)
+                this.#expectPunctuation(")");
+            let repeatable;
+            if (this.#matchKeyword("REPEATABLE")) {
+                this.#expectPunctuation("(");
+                repeatable = this.#parseExpression();
+                this.#expectPunctuation(")");
+            }
+            sample = {
+                method,
+                arguments: argumentsList,
+                ...(repeatable === undefined ? {} : { repeatable }),
+                range: mergeRanges(sampleStart, this.#previous().range),
+            };
+        }
+        return {
+            kind: "table",
+            name,
+            ...(schema === undefined ? {} : { schema }),
+            ...(alias === undefined ? {} : { alias }),
+            lateral,
+            ...(only ? { only: true } : {}),
+            ...(includeDescendants ? { includeDescendants: true } : {}),
+            ...(sample === undefined ? {} : { sample }),
+            range: mergeRanges(start, sample?.range ?? alias?.range ?? name.range),
+        };
+    }
+    #isJoinStart() {
+        return ["JOIN", "INNER", "LEFT", "RIGHT", "FULL", "CROSS"].includes(this.#current().value);
+    }
+    #parseJoin() {
+        const start = this.#current().range;
+        let kind = "inner";
+        if (this.#matchKeyword("INNER"))
+            kind = "inner";
+        else if (this.#matchKeyword("LEFT"))
+            kind = "left";
+        else if (this.#matchKeyword("RIGHT"))
+            kind = "right";
+        else if (this.#matchKeyword("FULL"))
+            kind = "full";
+        else if (this.#matchKeyword("CROSS"))
+            kind = "cross";
+        this.#matchKeyword("OUTER");
+        this.#expectKeyword("JOIN");
+        const table = this.#parseTableReference();
+        if (kind === "cross")
+            return { kind, table, range: mergeRanges(start, table.range) };
+        if (this.#matchKeyword("ON")) {
+            const on = this.#parseExpression();
+            return { kind, table, on, range: mergeRanges(start, on.range) };
+        }
+        if (this.#matchKeyword("USING")) {
+            this.#expectPunctuation("(");
+            const using = [];
+            do
+                using.push(this.#parseIdentifier());
+            while (this.#matchPunctuation(","));
+            const close = this.#expectPunctuation(")");
+            return { kind, table, using, range: mergeRanges(start, close.range) };
+        }
+        throw this.#error("JOIN requires ON or USING", this.#current().range);
+    }
+    #parseExpressionList() {
+        const expressions = [];
+        do
+            expressions.push(this.#parseExpression());
+        while (this.#matchPunctuation(","));
+        return expressions;
+    }
+    #parseGroupingList() {
+        const elements = [];
+        do
+            elements.push(this.#parseGroupingElement());
+        while (this.#matchPunctuation(","));
+        return elements;
+    }
+    #parseGroupingElement() {
+        if (this.#matchPunctuation("(")) {
+            const start = this.#previous().range;
+            if (this.#matchPunctuation(")")) {
+                return { kind: "empty-group", range: mergeRanges(start, this.#previous().range) };
+            }
+            const elements = this.#parseGroupingList();
+            const close = this.#expectPunctuation(")");
+            return { kind: "grouping-set", elements, range: mergeRanges(start, close.range) };
+        }
+        let kind;
+        let start;
+        if (this.#matchKeyword("ROLLUP")) {
+            kind = "rollup";
+            start = this.#previous().range;
+        }
+        else if (this.#matchKeyword("CUBE")) {
+            kind = "cube";
+            start = this.#previous().range;
+        }
+        else if (this.#matchKeyword("GROUPING")) {
+            start = this.#previous().range;
+            this.#expectKeyword("SETS");
+            kind = "grouping-sets";
+        }
+        if (kind !== undefined && start !== undefined) {
+            this.#expectPunctuation("(");
+            const empty = this.#matchPunctuation(")");
+            const elements = empty ? [] : [...this.#parseGroupingList()];
+            const close = empty ? this.#previous() : this.#expectPunctuation(")");
+            return { kind, elements, range: mergeRanges(start, close.range) };
+        }
+        return this.#parseExpression();
+    }
+    #parseOrderByList() {
+        const orderBy = [];
+        do {
+            const expression = this.#parseExpression();
+            const direction = this.#matchKeyword("ASC") ? "asc" : this.#matchKeyword("DESC") ? "desc" : undefined;
+            let using;
+            if (direction === undefined && this.#matchKeyword("USING")) {
+                const operator = this.#expect("operator", "ordering operator");
+                using = operator.value;
+            }
+            let nulls;
+            if (this.#matchKeyword("NULLS")) {
+                if (this.#matchKeyword("FIRST"))
+                    nulls = "first";
+                else {
+                    this.#expectKeyword("LAST");
+                    nulls = "last";
+                }
+            }
+            orderBy.push({
+                expression,
+                ...(direction === undefined ? {} : { direction }),
+                ...(using === undefined ? {} : { using }),
+                ...(nulls === undefined ? {} : { nulls }),
+                range: mergeRanges(expression.range, this.#previous().range),
+            });
+        } while (this.#matchPunctuation(","));
+        return orderBy;
+    }
+    #parseExpression(minimum = 0) {
+        return this.#nested(() => {
+            let left = this.#parseUnary();
+            while (true) {
+                if (this.#current().value === ".") {
+                    left = this.#parseFieldAccess(left);
+                    continue;
+                }
+                if (this.#current().value === "[") {
+                    left = this.#parseSubscript(left);
+                    continue;
+                }
+                if (this.#syntax === "postgres" && this.#matchOperator("::")) {
+                    const databaseType = this.#parseTypeName(false);
+                    left = {
+                        kind: "cast",
+                        expression: left,
+                        databaseType,
+                        syntax: "postgres",
+                        range: mergeRanges(left.range, databaseType.range),
+                    };
+                    continue;
+                }
+                if (this.#syntax === "postgres" && this.#matchKeyword("COLLATE")) {
+                    const collation = this.#parseQualifiedIdentifier();
+                    left = {
+                        kind: "collate",
+                        expression: left,
+                        collation,
+                        range: mergeRanges(left.range, collation.range),
+                    };
+                    continue;
+                }
+                if (this.#syntax === "postgres" && this.#current().value === "AT") {
+                    const strength = 8;
+                    if (strength < minimum)
+                        break;
+                    this.#advance();
+                    if (this.#matchKeyword("TIME")) {
+                        this.#expectKeyword("ZONE");
+                        const zone = this.#parseExpression(strength + 1);
+                        left = {
+                            kind: "at-time-zone",
+                            expression: left,
+                            zone,
+                            local: false,
+                            range: mergeRanges(left.range, zone.range),
+                        };
+                    }
+                    else {
+                        const local = this.#expectKeyword("LOCAL");
+                        left = {
+                            kind: "at-time-zone",
+                            expression: left,
+                            local: true,
+                            range: mergeRanges(left.range, local.range),
+                        };
+                    }
+                    continue;
+                }
+                const negated = this.#current().value === "NOT" &&
+                    ["IN", "BETWEEN", "LIKE", "ILIKE", "SIMILAR"].includes(this.#peekToken(1).value);
+                const special = negated ? this.#peekToken(1).value : this.#current().value;
+                if (special === "IN") {
+                    const strength = 3;
+                    if (strength < minimum)
+                        break;
+                    if (negated)
+                        this.#advance();
+                    this.#advance();
+                    const start = left.range;
+                    this.#expectPunctuation("(");
+                    let values;
+                    if (this.#isStatementStart()) {
+                        const statement = this.#parseStatement();
+                        if (statement.kind !== "select")
+                            throw this.#error("IN subquery must be SELECT", statement.range);
+                        values = statement;
+                    }
+                    else {
+                        if (this.#current().value === ")")
+                            throw this.#error("IN requires at least one value", this.#current().range);
+                        values = this.#parseExpressionList();
+                    }
+                    const close = this.#expectPunctuation(")");
+                    left = { kind: "in", expression: left, values, negated, range: mergeRanges(start, close.range) };
+                    continue;
+                }
+                if (special === "BETWEEN") {
+                    const strength = 3;
+                    if (strength < minimum)
+                        break;
+                    if (negated)
+                        this.#advance();
+                    this.#advance();
+                    const lower = this.#parseExpression(strength + 1);
+                    this.#expectKeyword("AND");
+                    const upper = this.#parseExpression(strength + 1);
+                    left = {
+                        kind: "between",
+                        expression: left,
+                        lower,
+                        upper,
+                        negated,
+                        range: mergeRanges(left.range, upper.range),
+                    };
+                    continue;
+                }
+                let operator = this.#current().value.toUpperCase();
+                if (special === "SIMILAR")
+                    operator = negated ? "NOT SIMILAR TO" : "SIMILAR TO";
+                else if (negated)
+                    operator = `NOT ${special}`;
+                const strength = precedence.get(operator.replace(/^NOT /u, ""));
+                if (strength === undefined || strength < minimum)
+                    break;
+                if (negated)
+                    this.#advance();
+                this.#advance();
+                if (operator.endsWith("SIMILAR TO"))
+                    this.#expectKeyword("TO");
+                if (operator === "IS") {
+                    if (this.#matchKeyword("NOT"))
+                        operator = "IS NOT";
+                    if (this.#matchKeyword("DISTINCT")) {
+                        this.#expectKeyword("FROM");
+                        operator += " DISTINCT FROM";
+                    }
+                }
+                if (this.#syntax === "postgres" && (operator === "IS" || operator === "IS NOT") && this.#matchWord("JSON")) {
+                    let constraint = "value";
+                    if (this.#matchWord("VALUE"))
+                        constraint = "value";
+                    else if (this.#matchWord("SCALAR"))
+                        constraint = "scalar";
+                    else if (this.#matchWord("ARRAY"))
+                        constraint = "array";
+                    else if (this.#matchWord("OBJECT"))
+                        constraint = "object";
+                    const uniqueKeys = this.#parseJsonUniqueKeys();
+                    left = {
+                        kind: "json-is",
+                        expression: left,
+                        constraint,
+                        negated: operator === "IS NOT",
+                        uniqueKeys,
+                        range: mergeRanges(left.range, this.#previous().range),
+                    };
+                    continue;
+                }
+                if (this.#syntax === "postgres" && ["ANY", "SOME", "ALL"].includes(this.#current().value)) {
+                    const quantifier = this.#advance().value.toLowerCase();
+                    this.#expectPunctuation("(");
+                    let right;
+                    if (this.#isStatementStart()) {
+                        const statement = this.#parseStatement();
+                        if (statement.kind !== "select")
+                            throw this.#error(`${quantifier.toUpperCase()} requires a SELECT subquery`, statement.range);
+                        right = statement;
+                    }
+                    else
+                        right = this.#parseExpression();
+                    const close = this.#expectPunctuation(")");
+                    left = {
+                        kind: "quantified-comparison",
+                        left,
+                        operator,
+                        quantifier,
+                        right,
+                        range: mergeRanges(left.range, close.range),
+                    };
+                    continue;
+                }
+                const right = this.#parseExpression(strength + 1);
+                left = { kind: "binary", left, operator, right, range: mergeRanges(left.range, right.range) };
+            }
+            return left;
+        });
+    }
+    #parseUnary() {
+        const token = this.#current();
+        if (this.#matchKeyword("NOT") ||
+            this.#matchOperator("+") ||
+            this.#matchOperator("-") ||
+            this.#matchOperator("~") ||
+            this.#matchOperator("!!") ||
+            this.#matchOperator("@-@") ||
+            this.#matchOperator("@@") ||
+            this.#matchOperator("#") ||
+            this.#matchOperator("?-") ||
+            this.#matchOperator("?|") ||
+            this.#matchOperator("@") ||
+            this.#matchOperator("|/") ||
+            this.#matchOperator("||/")) {
+            const expression = this.#parseUnary();
+            return {
+                kind: "unary",
+                operator: token.value.toUpperCase(),
+                expression,
+                range: mergeRanges(token.range, expression.range),
+            };
+        }
+        if (this.#matchKeyword("EXISTS")) {
+            this.#expectPunctuation("(");
+            const statement = this.#parseStatement();
+            if (statement.kind !== "select")
+                throw this.#error("EXISTS requires a SELECT subquery", statement.range);
+            const close = this.#expectPunctuation(")");
+            return { kind: "exists", query: statement, range: mergeRanges(token.range, close.range) };
+        }
+        let expression = this.#parsePrimary();
+        while (this.#current().value === "[" || this.#current().value === ".") {
+            expression =
+                this.#current().value === "[" ? this.#parseSubscript(expression) : this.#parseFieldAccess(expression);
+        }
+        return expression;
+    }
+    #parseFieldAccess(expression) {
+        this.#expectPunctuation(".");
+        const field = this.#parseIdentifier(true);
+        return { kind: "field-access", expression, field, range: mergeRanges(expression.range, field.range) };
+    }
+    #parseSubscript(expression) {
+        this.#expectPunctuation("[");
+        let index;
+        let lower;
+        let upper;
+        let slice = false;
+        if (this.#matchPunctuation(":")) {
+            slice = true;
+            if (this.#current().value !== "]")
+                upper = this.#parseExpression();
+        }
+        else {
+            if (this.#current().value === "]")
+                throw this.#error("Array subscript cannot be empty", this.#current().range);
+            const first = this.#parseExpression();
+            if (this.#matchPunctuation(":")) {
+                slice = true;
+                lower = first;
+                if (this.#current().value !== "]")
+                    upper = this.#parseExpression();
+            }
+            else
+                index = first;
+        }
+        const close = this.#expectPunctuation("]");
+        return {
+            kind: "subscript",
+            expression,
+            ...(index === undefined ? {} : { index }),
+            ...(lower === undefined ? {} : { lower }),
+            ...(upper === undefined ? {} : { upper }),
+            slice,
+            range: mergeRanges(expression.range, close.range),
+        };
+    }
+    #parsePrimary() {
+        const token = this.#current();
+        if (this.#matchPunctuation("(")) {
+            if (this.#isStatementStart()) {
+                const statement = this.#parseStatement();
+                if (statement.kind !== "select")
+                    throw this.#error("Scalar subquery must be SELECT", statement.range);
+                const close = this.#expectPunctuation(")");
+                return { kind: "subquery", query: statement, range: mergeRanges(token.range, close.range) };
+            }
+            const first = this.#parseExpression();
+            if (this.#matchPunctuation(",")) {
+                const elements = [first];
+                do
+                    elements.push(this.#parseExpression());
+                while (this.#matchPunctuation(","));
+                const close = this.#expectPunctuation(")");
+                return { kind: "row", elements, range: mergeRanges(token.range, close.range) };
+            }
+            this.#expectPunctuation(")");
+            return first;
+        }
+        if (this.#matchKeyword("ARRAY")) {
+            this.#expectPunctuation("[");
+            const elements = this.#matchPunctuation("]") ? [] : [...this.#parseExpressionList()];
+            const close = this.#previous().value === "]" ? this.#previous() : this.#expectPunctuation("]");
+            return { kind: "array", elements, range: mergeRanges(token.range, close.range) };
+        }
+        if (this.#matchKeyword("ROW")) {
+            this.#expectPunctuation("(");
+            const elements = this.#matchPunctuation(")") ? [] : [...this.#parseExpressionList()];
+            const close = this.#previous().value === ")" ? this.#previous() : this.#expectPunctuation(")");
+            return { kind: "row", elements, range: mergeRanges(token.range, close.range) };
+        }
+        if (this.#matchKeyword("CAST"))
+            return this.#parseCast(token.range);
+        if (this.#isIntervalLiteralStart())
+            return this.#parseIntervalLiteral();
+        if (simpleTypedLiteralTypes.has(token.value) && this.#peekToken(1).kind === "string") {
+            return this.#parseSimpleTypedLiteral();
+        }
+        if (this.#isWord(token, "JSON_OBJECTAGG") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonObjectAggregate(token);
+        }
+        if (this.#isWord(token, "JSON_ARRAYAGG") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonArrayAggregate(token);
+        }
+        if (this.#isWord(token, "JSON_OBJECT") &&
+            this.#peekToken(1).value === "(" &&
+            this.#isJsonObjectConstructorStart()) {
+            this.#advance();
+            return this.#parseJsonObject(token);
+        }
+        if (this.#isWord(token, "JSON_ARRAY") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonArray(token);
+        }
+        if (this.#isWord(token, "JSON") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonParse(token);
+        }
+        if (this.#isWord(token, "JSON_SCALAR") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonScalar(token);
+        }
+        if (this.#isWord(token, "JSON_SERIALIZE") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonSerialize(token);
+        }
+        if (this.#isWord(token, "JSON_EXISTS") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonExists(token);
+        }
+        if (this.#isWord(token, "JSON_QUERY") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonQuery(token);
+        }
+        if (this.#isWord(token, "JSON_VALUE") && this.#peekToken(1).value === "(") {
+            this.#advance();
+            return this.#parseJsonValueQuery(token);
+        }
+        if (this.#matchKeyword("CASE"))
+            return this.#parseCase(token.range);
+        if (this.#matchKeyword("NULL"))
+            return { kind: "literal", value: null, range: token.range };
+        if (this.#matchKeyword("TRUE"))
+            return { kind: "literal", value: true, range: token.range };
+        if (this.#matchKeyword("FALSE"))
+            return { kind: "literal", value: false, range: token.range };
+        if (this.#matchKeyword("DEFAULT"))
+            return { kind: "column", column: { name: "DEFAULT", quoted: false, range: token.range }, range: token.range };
+        if (token.kind === "number") {
+            this.#advance();
+            return { kind: "literal", value: Number(token.value), range: token.range };
+        }
+        if (token.kind === "string") {
+            this.#advance();
+            return { kind: "literal", value: token.value, range: token.range };
+        }
+        if (token.kind === "parameter") {
+            this.#advance();
+            return { kind: "parameter", index: Number(token.value), range: token.range };
+        }
+        if (this.#matchOperator("*"))
+            return { kind: "star", range: token.range };
+        if (this.#isIdentifierLike(token)) {
+            const first = this.#parseIdentifier(true);
+            if (this.#matchPunctuation("("))
+                return this.#parseCall(undefined, first);
+            if (this.#matchPunctuation(".")) {
+                if (this.#matchOperator("*"))
+                    return { kind: "star", relation: first, range: mergeRanges(first.range, this.#previous().range) };
+                const second = this.#parseIdentifier(true);
+                if (this.#matchPunctuation("("))
+                    return this.#parseCall(first, second);
+                return { kind: "column", relation: first, column: second, range: mergeRanges(first.range, second.range) };
+            }
+            return { kind: "column", column: first, range: first.range };
+        }
+        throw this.#error(`Expected expression, found ${token.text || "end of query"}`, token.range);
+    }
+    #isJsonObjectConstructorStart() {
+        let nesting = 0;
+        let sawTopLevelToken = false;
+        for (let offset = 1;; offset += 1) {
+            const token = this.#peekToken(offset);
+            if (token.kind === "eof")
+                return false;
+            if (token.value === "(" || token.value === "[") {
+                nesting += 1;
+                continue;
+            }
+            if (token.value === "]") {
+                nesting -= 1;
+                continue;
+            }
+            if (token.value === ")") {
+                if (nesting === 1)
+                    return !sawTopLevelToken;
+                nesting -= 1;
+                continue;
+            }
+            if (nesting !== 1)
+                continue;
+            if (!sawTopLevelToken && this.#isWord(token, "RETURNING"))
+                return true;
+            sawTopLevelToken = true;
+            if (token.value === ":" || this.#isWord(token, "VALUE"))
+                return true;
+            if (token.value === ",")
+                return false;
+        }
+    }
+    #parseJsonObject(start) {
+        this.#expectPunctuation("(");
+        const entries = [];
+        if (this.#current().value !== ")" && !this.#isWord(this.#current(), "RETURNING")) {
+            do {
+                const key = this.#parseExpression();
+                if (!this.#matchWord("VALUE"))
+                    this.#expectPunctuation(":");
+                const value = this.#parseJsonValueExpression();
+                entries.push({ key, value, range: mergeRanges(key.range, value.range) });
+            } while (this.#matchPunctuation(","));
+        }
+        const nullPolicy = this.#parseJsonConstructorNullPolicy("null");
+        const uniqueKeys = this.#parseJsonUniqueKeys();
+        const returning = this.#parseJsonReturning();
+        const close = this.#expectPunctuation(")");
+        return {
+            kind: "json-object",
+            entries,
+            nullPolicy,
+            uniqueKeys,
+            ...(returning === undefined ? {} : { returning }),
+            range: mergeRanges(start.range, close.range),
+        };
+    }
+    #parseJsonArray(start) {
+        this.#expectPunctuation("(");
+        const values = [];
+        let query;
+        let queryFormat;
+        let nullPolicy = "absent";
+        if (this.#isStatementStart()) {
+            const previousStop = this.#stopSelectListBeforeJsonFormat;
+            this.#stopSelectListBeforeJsonFormat = true;
+            let statement;
+            try {
+                statement = this.#parseStatement();
+            }
+            finally {
+                this.#stopSelectListBeforeJsonFormat = previousStop;
+            }
+            if (statement.kind !== "select")
+                throw this.#error("JSON_ARRAY query must be SELECT", statement.range);
+            query = statement;
+            queryFormat = this.#parseJsonFormat();
+        }
+        else if (this.#current().value !== ")" && !this.#isWord(this.#current(), "RETURNING")) {
+            do
+                values.push(this.#parseJsonValueExpression());
+            while (this.#matchPunctuation(","));
+            nullPolicy = this.#parseJsonConstructorNullPolicy("absent");
+        }
+        const returning = this.#parseJsonReturning();
+        const close = this.#expectPunctuation(")");
+        return {
+            kind: "json-array",
+            values,
+            ...(query === undefined ? {} : { query }),
+            ...(queryFormat === undefined ? {} : { queryFormat }),
+            nullPolicy,
+            ...(returning === undefined ? {} : { returning }),
+            range: mergeRanges(start.range, close.range),
+        };
+    }
+    #parseJsonObjectAggregate(start) {
+        this.#expectPunctuation("(");
+        const key = this.#parseExpression();
+        if (!this.#matchWord("VALUE"))
+            this.#expectPunctuation(":");
+        const value = this.#parseJsonValueExpression();
+        const nullPolicy = this.#parseJsonConstructorNullPolicy("null");
+        const uniqueKeys = this.#parseJsonUniqueKeys();
+        const returning = this.#parseJsonReturning();
+        const close = this.#expectPunctuation(")");
+        const suffix = this.#parseAggregateSuffix(close);
+        return {
+            kind: "json-object-aggregate",
+            key,
+            value,
+            nullPolicy,
+            uniqueKeys,
+            ...(returning === undefined ? {} : { returning }),
+            ...suffix,
+            range: mergeRanges(start.range, suffix.end.range),
+        };
+    }
+    #parseJsonArrayAggregate(start) {
+        this.#expectPunctuation("(");
+        const value = this.#parseJsonValueExpression();
+        let orderBy = [];
+        if (this.#matchKeyword("ORDER")) {
+            this.#expectKeyword("BY");
+            orderBy = this.#parseOrderByList();
+        }
+        const nullPolicy = this.#parseJsonConstructorNullPolicy("absent");
+        const returning = this.#parseJsonReturning();
+        const close = this.#expectPunctuation(")");
+        const suffix = this.#parseAggregateSuffix(close);
+        return {
+            kind: "json-array-aggregate",
+            value,
+            orderBy,
+            nullPolicy,
+            ...(returning === undefined ? {} : { returning }),
+            ...suffix,
+            range: mergeRanges(start.range, suffix.end.range),
+        };
+    }
+    #parseAggregateSuffix(close) {
+        let end = close;
+        let filter;
+        if (this.#syntax !== "mysql" && this.#matchKeyword("FILTER")) {
+            this.#expectPunctuation("(");
+            this.#expectKeyword("WHERE");
+            filter = this.#parseExpression();
+            end = this.#expectPunctuation(")");
+        }
+        let over;
+        if (this.#matchKeyword("OVER")) {
+            if (this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier") {
+                over = this.#parseIdentifier();
+            }
+            else {
+                over = this.#parseWindowSpecification();
+            }
+            end = { ...end, range: over.range };
+        }
+        return {
+            ...(filter === undefined ? {} : { filter }),
+            ...(over === undefined ? {} : { over }),
+            end,
+        };
+    }
+    #parseJsonParse(start) {
+        this.#expectPunctuation("(");
+        const value = this.#parseJsonValueExpression();
+        const uniqueKeys = this.#parseJsonUniqueKeys();
+        const close = this.#expectPunctuation(")");
+        return { kind: "json-parse", value, uniqueKeys, range: mergeRanges(start.range, close.range) };
+    }
+    #parseJsonScalar(start) {
+        this.#expectPunctuation("(");
+        const expression = this.#parseExpression();
+        const close = this.#expectPunctuation(")");
+        return { kind: "json-scalar", expression, range: mergeRanges(start.range, close.range) };
+    }
+    #parseJsonSerialize(start) {
+        this.#expectPunctuation("(");
+        const value = this.#parseJsonValueExpression();
+        const returning = this.#parseJsonReturning();
+        const close = this.#expectPunctuation(")");
+        return {
+            kind: "json-serialize",
+            value,
+            ...(returning === undefined ? {} : { returning }),
+            range: mergeRanges(start.range, close.range),
+        };
+    }
+    #parseJsonConstructorNullPolicy(defaultPolicy) {
+        const nullPolicy = this.#isWord(this.#current(), "NULL")
+            ? "null"
+            : this.#isWord(this.#current(), "ABSENT")
+                ? "absent"
+                : undefined;
+        if (nullPolicy === undefined ||
+            !this.#isWord(this.#peekToken(1), "ON") ||
+            !this.#isWord(this.#peekToken(2), "NULL")) {
+            return defaultPolicy;
+        }
+        this.#advance();
+        this.#expectKeyword("ON");
+        this.#expectKeyword("NULL");
+        return nullPolicy;
+    }
+    #parseJsonUniqueKeys() {
+        if ((!this.#isWord(this.#current(), "WITH") && !this.#isWord(this.#current(), "WITHOUT")) ||
+            !this.#isWord(this.#peekToken(1), "UNIQUE")) {
+            return false;
+        }
+        const unique = this.#matchWord("WITH");
+        if (!unique)
+            this.#expectWord("WITHOUT");
+        this.#expectWord("UNIQUE");
+        this.#matchWord("KEYS");
+        return unique;
+    }
+    #parseJsonReturning() {
+        if (!this.#matchKeyword("RETURNING"))
+            return undefined;
+        const start = this.#previous();
+        const databaseType = this.#parseTypeName(false, () => this.#isWord(this.#current(), "FORMAT"));
+        const format = this.#parseJsonFormat();
+        return {
+            databaseType,
+            ...(format === undefined ? {} : { format }),
+            range: mergeRanges(start.range, format?.range ?? databaseType.range),
+        };
+    }
+    #parseJsonExists(start) {
+        this.#expectPunctuation("(");
+        const context = this.#parseJsonValueExpression();
+        this.#expectPunctuation(",");
+        const path = this.#parseExpression();
+        const passing = this.#parseJsonPassing();
+        let onError;
+        if (["TRUE", "FALSE", "UNKNOWN", "ERROR"].some((word) => this.#isWord(this.#current(), word)) &&
+            this.#isWord(this.#peekToken(1), "ON") &&
+            this.#isWord(this.#peekToken(2), "ERROR")) {
+            onError = this.#advance().value.toLowerCase();
+            this.#expectKeyword("ON");
+            this.#expectWord("ERROR");
+        }
+        const close = this.#expectPunctuation(")");
+        return {
+            kind: "json-exists",
+            context,
+            path,
+            passing,
+            ...(onError === undefined ? {} : { onError }),
+            range: mergeRanges(start.range, close.range),
+        };
+    }
+    #parseJsonQuery(start) {
+        this.#expectPunctuation("(");
+        const context = this.#parseJsonValueExpression();
+        this.#expectPunctuation(",");
+        const path = this.#parseExpression();
+        const passing = this.#parseJsonPassing();
+        let returning;
+        if (this.#matchKeyword("RETURNING")) {
+            const returningStart = this.#previous();
+            const databaseType = this.#parseTypeName(false, () => this.#isJsonQueryClauseStart());
+            const format = this.#parseJsonFormat();
+            returning = {
+                databaseType,
+                ...(format === undefined ? {} : { format }),
+                range: mergeRanges(returningStart.range, format?.range ?? databaseType.range),
+            };
+        }
+        const wrapper = this.#parseJsonWrapper();
+        const quotes = this.#parseJsonQuotes();
+        let onEmpty;
+        let onError;
+        if (this.#isJsonQueryBehaviorStart()) {
+            const clause = this.#parseJsonBehaviorClause();
+            if (clause.target === "empty")
+                onEmpty = clause.behavior;
+            else
+                onError = clause.behavior;
+        }
+        if (onEmpty !== undefined && this.#isJsonQueryBehaviorStart()) {
+            const clause = this.#parseJsonBehaviorClause();
+            if (clause.target !== "error") {
+                throw this.#error("JSON_QUERY ON EMPTY must precede ON ERROR", clause.behavior.range);
+            }
+            onError = clause.behavior;
+        }
+        const close = this.#expectPunctuation(")");
+        return {
+            kind: "json-query",
+            context,
+            path,
+            passing,
+            ...(returning === undefined ? {} : { returning }),
+            ...(wrapper === undefined ? {} : { wrapper }),
+            ...(quotes === undefined ? {} : { quotes }),
+            ...(onEmpty === undefined ? {} : { onEmpty }),
+            ...(onError === undefined ? {} : { onError }),
+            range: mergeRanges(start.range, close.range),
+        };
+    }
+    #parseJsonValueQuery(start) {
+        this.#expectPunctuation("(");
+        const context = this.#parseJsonValueExpression();
+        this.#expectPunctuation(",");
+        const path = this.#parseExpression();
+        const passing = this.#parseJsonPassing();
+        let returning;
+        if (this.#matchKeyword("RETURNING")) {
+            const returningStart = this.#previous();
+            const databaseType = this.#parseTypeName(false, () => this.#isJsonQueryClauseStart());
+            const format = this.#parseJsonFormat();
+            returning = {
+                databaseType,
+                ...(format === undefined ? {} : { format }),
+                range: mergeRanges(returningStart.range, format?.range ?? databaseType.range),
+            };
+        }
+        let onEmpty;
+        let onError;
+        if (this.#isJsonQueryBehaviorStart()) {
+            const clause = this.#parseJsonBehaviorClause();
+            if (clause.target === "empty")
+                onEmpty = clause.behavior;
+            else
+                onError = clause.behavior;
+        }
+        if (onEmpty !== undefined && this.#isJsonQueryBehaviorStart()) {
+            const clause = this.#parseJsonBehaviorClause();
+            if (clause.target !== "error") {
+                throw this.#error("JSON_VALUE ON EMPTY must precede ON ERROR", clause.behavior.range);
+            }
+            onError = clause.behavior;
+        }
+        const close = this.#expectPunctuation(")");
+        return {
+            kind: "json-value",
+            context,
+            path,
+            passing,
+            ...(returning === undefined ? {} : { returning }),
+            ...(onEmpty === undefined ? {} : { onEmpty }),
+            ...(onError === undefined ? {} : { onError }),
+            range: mergeRanges(start.range, close.range),
+        };
+    }
+    #parseJsonPassing() {
+        const passing = [];
+        if (!this.#matchWord("PASSING"))
+            return passing;
+        do {
+            const value = this.#parseJsonValueExpression();
+            this.#expectKeyword("AS");
+            const name = this.#parseIdentifier(true);
+            passing.push({ value, name, range: mergeRanges(value.range, name.range) });
+        } while (this.#matchPunctuation(","));
+        return passing;
+    }
+    #parseJsonValueExpression() {
+        const expression = this.#parseExpression();
+        const format = this.#parseJsonFormat();
+        if (format === undefined)
+            return { expression, range: expression.range };
+        return { expression, format, range: mergeRanges(expression.range, format.range) };
+    }
+    #parseJsonFormat() {
+        if (!this.#matchWord("FORMAT"))
+            return undefined;
+        const formatStart = this.#previous();
+        const json = this.#expectWord("JSON");
+        let encoding;
+        let end = json;
+        if (this.#matchWord("ENCODING")) {
+            const token = this.#current();
+            const normalized = token.value.toUpperCase();
+            if (!this.#isIdentifierLike(token) || !["UTF8", "UTF16", "UTF32"].includes(normalized)) {
+                throw this.#error(`Unsupported JSON encoding ${token.text || "end of query"}`, token.range);
+            }
+            this.#advance();
+            encoding = normalized;
+            end = token;
+        }
+        return {
+            ...(encoding === undefined ? {} : { encoding }),
+            range: mergeRanges(formatStart.range, end.range),
+        };
+    }
+    #isJsonQueryBehaviorStart() {
+        return ["DEFAULT", "ERROR", "NULL", "EMPTY"].some((word) => this.#isWord(this.#current(), word));
+    }
+    #isJsonTableBehaviorStart() {
+        return ["DEFAULT", "ERROR", "NULL", "TRUE", "FALSE", "UNKNOWN", "EMPTY"].some((word) => this.#isWord(this.#current(), word));
+    }
+    #parseJsonWrapper() {
+        if (this.#matchWord("WITHOUT")) {
+            this.#matchKeyword("ARRAY");
+            this.#expectWord("WRAPPER");
+            return "without";
+        }
+        if (!this.#matchWord("WITH"))
+            return undefined;
+        const wrapper = this.#matchWord("CONDITIONAL") ? "conditional" : "unconditional";
+        if (wrapper === "unconditional")
+            this.#matchWord("UNCONDITIONAL");
+        this.#matchKeyword("ARRAY");
+        this.#expectWord("WRAPPER");
+        return wrapper;
+    }
+    #parseJsonQuotes() {
+        if (!this.#matchWord("KEEP") && !this.#matchWord("OMIT"))
+            return undefined;
+        const quotes = this.#previous().value.toLowerCase();
+        this.#expectWord("QUOTES");
+        if (this.#matchKeyword("ON")) {
+            this.#expectWord("SCALAR");
+            this.#expectWord("STRING");
+        }
+        return quotes;
+    }
+    #isJsonQueryClauseStart() {
+        if (["FORMAT", "KEEP", "OMIT", "DEFAULT", "ERROR", "NULL", "EMPTY"].some((word) => this.#isWord(this.#current(), word))) {
+            return true;
+        }
+        if (this.#isWord(this.#current(), "WITHOUT")) {
+            return this.#isWord(this.#peekToken(1), "ARRAY") || this.#isWord(this.#peekToken(1), "WRAPPER");
+        }
+        if (!this.#isWord(this.#current(), "WITH"))
+            return false;
+        return ["CONDITIONAL", "UNCONDITIONAL", "ARRAY", "WRAPPER"].some((word) => this.#isWord(this.#peekToken(1), word));
+    }
+    #parseJsonBehaviorClause(allowTruthValues = false) {
+        const start = this.#current();
+        let behavior;
+        if (this.#matchKeyword("DEFAULT")) {
+            const expression = this.#parseExpression();
+            behavior = { kind: "default", expression, range: mergeRanges(start.range, expression.range) };
+        }
+        else if (this.#matchWord("ERROR")) {
+            behavior = { kind: "error", range: start.range };
+        }
+        else if (this.#matchKeyword("NULL")) {
+            behavior = { kind: "null", range: start.range };
+        }
+        else if (allowTruthValues &&
+            (this.#matchKeyword("TRUE") || this.#matchKeyword("FALSE") || this.#matchWord("UNKNOWN"))) {
+            behavior = {
+                kind: this.#previous().value.toLowerCase(),
+                range: start.range,
+            };
+        }
+        else {
+            this.#expectWord("EMPTY");
+            const object = this.#matchWord("OBJECT");
+            if (!object)
+                this.#matchKeyword("ARRAY");
+            behavior = {
+                kind: object ? "empty-object" : "empty-array",
+                range: mergeRanges(start.range, this.#previous().range),
+            };
+        }
+        this.#expectKeyword("ON");
+        if (this.#matchWord("EMPTY"))
+            return { behavior, target: "empty" };
+        this.#expectWord("ERROR");
+        return { behavior, target: "error" };
+    }
+    #parseJsonOnErrorBehavior() {
+        const clause = this.#parseJsonBehaviorClause(true);
+        if (clause.target !== "error") {
+            throw this.#error("JSON_TABLE behavior must target ON ERROR", clause.behavior.range);
+        }
+        return clause.behavior;
+    }
+    #parseCall(schema, name) {
+        const distinct = this.#matchKeyword("DISTINCT");
+        const args = [];
+        const argumentNames = [];
+        let named = false;
+        let variadic = false;
+        let orderBy = [];
+        let close;
+        if (this.#matchPunctuation(")"))
+            close = this.#previous();
+        else {
+            do {
+                if (variadic)
+                    throw this.#error("VARIADIC must be the final function argument", this.#current().range);
+                if (this.#matchKeyword("VARIADIC")) {
+                    if (named)
+                        throw this.#error("VARIADIC cannot follow a named function argument", this.#previous().range);
+                    variadic = true;
+                    argumentNames.push(undefined);
+                    args.push(this.#parseExpression());
+                }
+                else if (this.#isIdentifierLike(this.#current()) &&
+                    this.#peekToken(1).kind === "operator" &&
+                    (this.#peekToken(1).value === "=>" || this.#peekToken(1).value === ":=")) {
+                    const argumentName = this.#parseIdentifier(true);
+                    this.#advance();
+                    named = true;
+                    argumentNames.push(argumentName);
+                    args.push(this.#parseExpression());
+                }
+                else {
+                    if (named) {
+                        throw this.#error("Positional arguments cannot follow named function arguments", this.#current().range);
+                    }
+                    argumentNames.push(undefined);
+                    args.push(this.#parseExpression());
+                }
+                if (!this.#matchPunctuation(","))
+                    break;
+            } while (this.#current().value !== "ORDER");
+            if (this.#matchKeyword("ORDER")) {
+                this.#expectKeyword("BY");
+                orderBy = this.#parseOrderByList();
+            }
+            close = this.#expectPunctuation(")");
+        }
+        let withinGroup = [];
+        if (this.#matchKeyword("WITHIN")) {
+            this.#expectKeyword("GROUP");
+            this.#expectPunctuation("(");
+            this.#expectKeyword("ORDER");
+            this.#expectKeyword("BY");
+            withinGroup = this.#parseOrderByList();
+            close = this.#expectPunctuation(")");
+        }
+        let filter;
+        if (this.#syntax !== "mysql" && this.#matchKeyword("FILTER")) {
+            this.#expectPunctuation("(");
+            this.#expectKeyword("WHERE");
+            filter = this.#parseExpression();
+            close = this.#expectPunctuation(")");
+        }
+        let over;
+        if (this.#matchKeyword("OVER")) {
+            if (this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier")
+                over = this.#parseIdentifier();
+            else
+                over = this.#parseWindowSpecification();
+            close = { ...close, range: over.range };
+        }
+        return {
+            kind: "call",
+            name,
+            ...(schema === undefined ? {} : { schema }),
+            arguments: args,
+            ...(named ? { argumentNames } : {}),
+            ...(variadic ? { variadic: true } : {}),
+            distinct,
+            ...(orderBy.length === 0 ? {} : { orderBy }),
+            ...(withinGroup.length === 0 ? {} : { withinGroup }),
+            ...(filter === undefined ? {} : { filter }),
+            ...(over === undefined ? {} : { over }),
+            range: mergeRanges(schema?.range ?? name.range, close.range),
+        };
+    }
+    #parseWindowSpecification() {
+        const start = this.#expectPunctuation("(").range;
+        const base = this.#current().kind === "identifier" || this.#current().kind === "quoted-identifier"
+            ? this.#parseIdentifier()
+            : undefined;
+        const partitionBy = [];
+        let orderBy = [];
+        if (this.#matchKeyword("PARTITION")) {
+            this.#expectKeyword("BY");
+            partitionBy.push(...this.#parseExpressionList());
+        }
+        if (this.#matchKeyword("ORDER")) {
+            this.#expectKeyword("BY");
+            orderBy = this.#parseOrderByList();
+        }
+        let frame;
+        if (["ROWS", "RANGE", "GROUPS"].includes(this.#current().value)) {
+            const frameStart = this.#advance();
+            const unit = frameStart.value.toLowerCase();
+            let frameBound;
+            let end;
+            if (this.#matchKeyword("BETWEEN")) {
+                frameBound = this.#parseWindowFrameBound();
+                this.#expectKeyword("AND");
+                end = this.#parseWindowFrameBound();
+            }
+            else
+                frameBound = this.#parseWindowFrameBound();
+            let exclusion;
+            if (this.#matchKeyword("EXCLUDE")) {
+                if (this.#matchKeyword("CURRENT")) {
+                    this.#expectKeyword("ROW");
+                    exclusion = "current-row";
+                }
+                else if (this.#matchKeyword("GROUP"))
+                    exclusion = "group";
+                else if (this.#matchKeyword("TIES"))
+                    exclusion = "ties";
+                else {
+                    this.#expectKeyword("NO");
+                    this.#expectKeyword("OTHERS");
+                    exclusion = "no-others";
+                }
+            }
+            frame = {
+                unit,
+                start: frameBound,
+                ...(end === undefined ? {} : { end }),
+                ...(exclusion === undefined ? {} : { exclusion }),
+                range: mergeRanges(frameStart.range, this.#previous().range),
+            };
+        }
+        const close = this.#expectPunctuation(")");
+        return {
+            ...(base === undefined ? {} : { base }),
+            partitionBy,
+            orderBy,
+            ...(frame === undefined ? {} : { frame }),
+            range: mergeRanges(start, close.range),
+        };
+    }
+    #parseWindowFrameBound() {
+        const start = this.#current().range;
+        if (this.#matchKeyword("UNBOUNDED")) {
+            if (this.#matchKeyword("PRECEDING"))
+                return { kind: "unbounded-preceding", range: mergeRanges(start, this.#previous().range) };
+            this.#expectKeyword("FOLLOWING");
+            return { kind: "unbounded-following", range: mergeRanges(start, this.#previous().range) };
+        }
+        if (this.#matchKeyword("CURRENT")) {
+            const end = this.#expectKeyword("ROW").range;
+            return { kind: "current-row", range: mergeRanges(start, end) };
+        }
+        const expression = this.#parseExpression();
+        if (this.#matchKeyword("PRECEDING")) {
+            return { kind: "preceding", expression, range: mergeRanges(start, this.#previous().range) };
+        }
+        this.#expectKeyword("FOLLOWING");
+        return { kind: "following", expression, range: mergeRanges(start, this.#previous().range) };
+    }
+    #parseCast(start) {
+        this.#expectPunctuation("(");
+        const expression = this.#parseExpression();
+        this.#expectKeyword("AS");
+        const databaseType = this.#parseTypeName(true);
+        const close = this.#expectPunctuation(")");
+        return { kind: "cast", expression, databaseType, syntax: "cast", range: mergeRanges(start, close.range) };
+    }
+    #isIntervalLiteralStart() {
+        if (this.#current().value !== "INTERVAL")
+            return false;
+        if (this.#peekToken(1).kind === "string")
+            return true;
+        return (this.#peekToken(1).value === "(" &&
+            this.#peekToken(2).kind === "number" &&
+            this.#peekToken(3).value === ")" &&
+            this.#peekToken(4).kind === "string");
+    }
+    #parseIntervalLiteral() {
+        const start = this.#advance();
+        let typeEnd = start;
+        let typeName = start.text;
+        let prefixPrecision = false;
+        if (this.#current().value === "(") {
+            const precision = this.#parseIntervalPrecision();
+            typeEnd = precision.end;
+            typeName += this.#source.slice(precision.start.range.start, precision.end.range.end);
+            prefixPrecision = true;
+        }
+        const value = this.#expect("string", "interval string literal");
+        let end = value;
+        if (prefixPrecision && intervalFields.has(this.#current().value)) {
+            throw this.#error("Interval fields cannot follow prefix precision", this.#current().range);
+        }
+        if (!prefixPrecision && intervalFields.has(this.#current().value)) {
+            const qualifier = this.#parseIntervalFields();
+            typeEnd = qualifier.end;
+            typeName += ` ${qualifier.text}`;
+            end = qualifier.end;
+            if (this.#current().value === "(") {
+                if (qualifier.endField !== "SECOND") {
+                    throw this.#error("Interval precision requires SECOND as the least significant field", this.#current().range);
+                }
+                const precision = this.#parseIntervalPrecision();
+                typeEnd = precision.end;
+                typeName += this.#source.slice(precision.start.range.start, precision.end.range.end);
+                end = precision.end;
+            }
+        }
+        return {
+            kind: "cast",
+            expression: { kind: "literal", value: value.value, range: value.range },
+            databaseType: { name: typeName, range: mergeRanges(start.range, typeEnd.range) },
+            syntax: "typed-literal",
+            range: mergeRanges(start.range, end.range),
+        };
+    }
+    #parseSimpleTypedLiteral() {
+        const type = this.#advance();
+        const value = this.#expect("string", `${type.value.toLowerCase()} string literal`);
+        return {
+            kind: "cast",
+            expression: { kind: "literal", value: value.value, range: value.range },
+            databaseType: { name: type.text, range: type.range },
+            syntax: "typed-literal",
+            range: mergeRanges(type.range, value.range),
+        };
+    }
+    #parseIntervalFields() {
+        const start = this.#current();
+        if (!intervalFields.has(start.value)) {
+            throw this.#error(`Expected interval field, found ${start.text || "end of query"}`, start.range);
+        }
+        this.#advance();
+        let end = start;
+        let endField = start.value;
+        if (this.#matchWord("TO")) {
+            const target = this.#current();
+            if (!intervalFieldRanges.get(start.value)?.has(target.value)) {
+                throw this.#error(`Invalid interval field range ${start.value} TO ${target.value}`, target.range);
+            }
+            end = this.#advance();
+            endField = end.value;
+        }
+        return {
+            text: this.#source.slice(start.range.start, end.range.end),
+            end,
+            endField,
+        };
+    }
+    #parseIntervalPrecision() {
+        const start = this.#expectPunctuation("(");
+        const precision = this.#expect("number", "interval precision");
+        if (!/^\d+$/u.test(precision.value)) {
+            throw this.#error("Interval precision must be a non-negative integer", precision.range);
+        }
+        return { start, end: this.#expectPunctuation(")") };
+    }
+    #parseTypeName(stopAtClose, stopBefore) {
+        const start = this.#current();
+        if (!this.#isIdentifierLike(start))
+            throw this.#error(`Expected identifier, found ${start.text || "end of query"}`, start.range);
+        this.#advance();
+        let end = start;
+        let schemaSeparatorAllowed = true;
+        if (start.value === "INTERVAL" && this.#current().value !== ".") {
+            let prefixPrecision = false;
+            if (this.#current().value === "(") {
+                end = this.#parseIntervalPrecision().end;
+                prefixPrecision = true;
+            }
+            if (prefixPrecision && intervalFields.has(this.#current().value)) {
+                throw this.#error("Interval fields cannot follow prefix precision", this.#current().range);
+            }
+            if (!prefixPrecision && intervalFields.has(this.#current().value)) {
+                const qualifier = this.#parseIntervalFields();
+                end = qualifier.end;
+                if (this.#current().value === "(") {
+                    if (qualifier.endField !== "SECOND") {
+                        throw this.#error("Interval precision requires SECOND as the least significant field", this.#current().range);
+                    }
+                    end = this.#parseIntervalPrecision().end;
+                }
+            }
+            while (this.#matchPunctuation("["))
+                end = this.#expectPunctuation("]");
+            if (stopAtClose && this.#current().value !== ")") {
+                throw this.#error(`Expected ) after type name, found ${this.#current().text}`, this.#current().range);
+            }
+            return {
+                name: this.#source.slice(start.range.start, end.range.end).trim(),
+                range: mergeRanges(start.range, end.range),
+            };
+        }
+        while (true) {
+            if (stopBefore?.() === true)
+                break;
+            if (schemaSeparatorAllowed && this.#matchPunctuation(".")) {
+                this.#parseIdentifier(true);
+                end = this.#previous();
+                schemaSeparatorAllowed = false;
+                continue;
+            }
+            schemaSeparatorAllowed = false;
+            if (this.#matchPunctuation("(")) {
+                let depth = 1;
+                while (depth > 0) {
+                    const token = this.#current();
+                    if (token.kind === "eof")
+                        throw this.#error("Unterminated type modifier", token.range);
+                    this.#advance();
+                    if (token.value === "(")
+                        depth += 1;
+                    else if (token.value === ")")
+                        depth -= 1;
+                    end = token;
+                }
+                continue;
+            }
+            if (this.#isIdentifierLike(this.#current()) && typeContinuationWords.has(this.#current().value.toUpperCase())) {
+                end = this.#advance();
+                continue;
+            }
+            if (this.#matchPunctuation("[")) {
+                end = this.#expectPunctuation("]");
+                continue;
+            }
+            break;
+        }
+        if (stopAtClose && this.#current().value !== ")")
+            throw this.#error(`Expected ) after type name, found ${this.#current().text}`, this.#current().range);
+        return {
+            name: this.#source.slice(start.range.start, end.range.end).trim(),
+            range: mergeRanges(start.range, end.range),
+        };
+    }
+    #parseCase(start) {
+        const operand = this.#current().value === "WHEN" ? undefined : this.#parseExpression();
+        const branches = [];
+        while (this.#matchKeyword("WHEN")) {
+            const whenStart = this.#previous().range;
+            const when = this.#parseExpression();
+            this.#expectKeyword("THEN");
+            const then = this.#parseExpression();
+            branches.push({ when, then, range: mergeRanges(whenStart, then.range) });
+        }
+        if (branches.length === 0)
+            throw this.#error("CASE requires at least one WHEN branch", this.#current().range);
+        const elseExpression = this.#matchKeyword("ELSE") ? this.#parseExpression() : undefined;
+        const end = this.#expectKeyword("END");
+        return {
+            kind: "case",
+            ...(operand === undefined ? {} : { operand }),
+            branches,
+            ...(elseExpression === undefined ? {} : { elseExpression }),
+            range: mergeRanges(start, end.range),
+        };
+    }
+    #parseIdentifier(allowKeyword = false) {
+        const token = this.#current();
+        if (!this.#isIdentifierLike(token) || (token.kind === "keyword" && !allowKeyword)) {
+            throw this.#error(`Expected identifier, found ${token.text || "end of query"}`, token.range);
+        }
+        this.#advance();
+        return { name: token.value, quoted: token.kind === "quoted-identifier", range: token.range };
+    }
+    #parseQualifiedIdentifier() {
+        const first = this.#parseIdentifier(true);
+        const parts = [first];
+        if (this.#matchPunctuation("."))
+            parts.push(this.#parseIdentifier(true));
+        return { parts, range: mergeRanges(first.range, parts.at(-1).range) };
+    }
+    #isIdentifierLike(token) {
+        return token.kind === "identifier" || token.kind === "quoted-identifier" || token.kind === "keyword";
+    }
+    #isStatementStart() {
+        return ["SELECT", "INSERT", "UPDATE", "DELETE", "MERGE", "WITH"].includes(this.#current().value);
+    }
+    #isJsonArrayQueryFormatStart() {
+        return (this.#stopSelectListBeforeJsonFormat &&
+            this.#isWord(this.#current(), "FORMAT") &&
+            this.#isWord(this.#peekToken(1), "JSON"));
+    }
+    #current() {
+        return this.#cursor.current();
+    }
+    #peekToken(offset) {
+        return this.#cursor.peek(offset);
+    }
+    #previous() {
+        return this.#cursor.previous();
+    }
+    #advance() {
+        return this.#cursor.advance();
+    }
+    #matchKeyword(keyword) {
+        if (this.#current().kind === "keyword" && this.#current().value === keyword) {
+            this.#advance();
+            return true;
+        }
+        return false;
+    }
+    #matchWord(word) {
+        if (this.#isWord(this.#current(), word)) {
+            this.#advance();
+            return true;
+        }
+        return false;
+    }
+    #isWord(token, word) {
+        return token.kind !== "quoted-identifier" && this.#isIdentifierLike(token) && token.value.toUpperCase() === word;
+    }
+    #matchOperator(operator) {
+        if (this.#current().kind === "operator" && this.#current().value === operator) {
+            this.#advance();
+            return true;
+        }
+        return false;
+    }
+    #matchPunctuation(value) {
+        if (this.#current().kind === "punctuation" && this.#current().value === value) {
+            this.#advance();
+            return true;
+        }
+        return false;
+    }
+    #expectKeyword(keyword) {
+        const token = this.#current();
+        if (!this.#matchKeyword(keyword))
+            throw this.#error(`Expected ${keyword}, found ${token.text || "end of query"}`, token.range);
+        return token;
+    }
+    #expectWord(word) {
+        const token = this.#current();
+        if (!this.#matchWord(word))
+            throw this.#error(`Expected ${word}, found ${token.text || "end of query"}`, token.range);
+        return token;
+    }
+    #expectOperator(operator) {
+        const token = this.#current();
+        if (!this.#matchOperator(operator))
+            throw this.#error(`Expected ${operator}, found ${token.text || "end of query"}`, token.range);
+        return token;
+    }
+    #expectPunctuation(value) {
+        const token = this.#current();
+        if (!this.#matchPunctuation(value))
+            throw this.#error(`Expected ${value}, found ${token.text || "end of query"}`, token.range);
+        return token;
+    }
+    #expect(kind, label) {
+        const token = this.#current();
+        if (token.kind !== kind)
+            throw this.#error(`Expected ${label}, found ${token.text || "end of query"}`, token.range);
+        this.#advance();
+        return token;
+    }
+    #nested(fn) {
+        return this.#cursor.nested(fn);
+    }
+    #error(message, range, code = "TSQ001") {
+        return new SqlParseError(message, range, code);
+    }
+}
+function deepFreeze(value, seen = new Set()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const nested of Object.values(value))
+        deepFreeze(nested, seen);
+    return Object.freeze(value);
+}
+function parse(source, options) {
+    try {
+        return deepFreeze(new Parser(source, options).parse());
+    }
+    catch (error) {
+        if (error instanceof SqlTokenizeError)
+            throw new SqlParseError(error.message, error.range, error.code);
+        if (error instanceof SqlToolkitError)
+            throw new SqlParseError(error.message, error.range, error.code);
+        throw error;
+    }
+}
+export function parseStatement(source, options = {}) {
+    return parse(source, options);
+}
+export function parseSelect(source, options = {}) {
+    const statement = parse(source, options);
+    if (statement.kind !== "select")
+        throw new SqlParseError(`Expected SELECT, found ${statement.kind.toUpperCase()}`, statement.range);
+    return statement;
+}
+//# sourceMappingURL=parser.js.map