sql-format-plus 0.0.1

package/dist/sql-format-plus.es.js

@@ -0,0 +1,2429 @@
+const INDENT_TYPE_TOP_LEVEL = 'top-level';
+const INDENT_TYPE_BLOCK_LEVEL = 'block-level';
+const INDENT_TYPE_KEYWORD_BLOCK = 'keyword-block';
+/**
+ * 管理 SQL 格式化的缩进层级。
+ *
+ * 跟踪嵌套的格式化层级以计算缩进前缀字符串。
+ * 支持三种不同的层级类型：
+ * - `block-level`：由左括号增加
+ * - `top-level`：由顶级保留关键字（例如 SELECT、FROM）增加
+ * - `keyword-block`：由 BEGIN、LOOP 等方言关键字块增加
+ */
+class Indentation {
+    /**
+     * 初始化缩进管理器。
+     *
+     * @param {string} [indent] 缩进字符/字符串（默认为两个空格：'  '）。
+     */
+    constructor(indent) {
+        this.indentTypes = [];
+        this.indent = indent || '  ';
+    }
+    /**
+     * 根据当前处于活动状态的缩进层级生成缩进前缀字符串。
+     *
+     * @returns {string} 累积的缩进空格或制表符。
+     */
+    getIndent() {
+        return this.indent.repeat(this.indentTypes.length);
+    }
+    /**
+     * 增加顶级保留字的缩进层级。
+     */
+    increaseToplevel() {
+        this.indentTypes.push(INDENT_TYPE_TOP_LEVEL);
+    }
+    /**
+     * 增加括号块的缩进层级。
+     */
+    increaseBlockLevel() {
+        this.indentTypes.push(INDENT_TYPE_BLOCK_LEVEL);
+    }
+    /**
+     * 增加关键字块的缩进层级。
+     */
+    increaseKeywordBlock() {
+        this.indentTypes.push(INDENT_TYPE_KEYWORD_BLOCK);
+    }
+    /**
+     * 通过弹出最后一个顶级项来减少顶级缩进层级。
+     */
+    decreaseTopLevel() {
+        if (this.indentTypes[this.indentTypes.length - 1] === INDENT_TYPE_TOP_LEVEL) {
+            this.indentTypes.pop();
+        }
+    }
+    /**
+     * 减少块级缩进。
+     * 弹出所有尾部的顶级缩进，直到移除最近的块级缩进。
+     */
+    decreaseBlockLevel() {
+        while (this.indentTypes[this.indentTypes.length - 1] === INDENT_TYPE_TOP_LEVEL) {
+            this.indentTypes.pop();
+        }
+        if (this.indentTypes[this.indentTypes.length - 1] === INDENT_TYPE_BLOCK_LEVEL) {
+            this.indentTypes.pop();
+        }
+    }
+    /**
+     * 只在栈顶确实是关键字块时减少缩进，避免污染括号层级。
+     */
+    decreaseKeywordBlock() {
+        while (this.indentTypes[this.indentTypes.length - 1] === INDENT_TYPE_TOP_LEVEL) {
+            this.indentTypes.pop();
+        }
+        if (this.indentTypes[this.indentTypes.length - 1] ===
+            INDENT_TYPE_KEYWORD_BLOCK) {
+            this.indentTypes.pop();
+        }
+    }
+    isBlockLevel() {
+        return (this.indentTypes[this.indentTypes.length - 1] === INDENT_TYPE_BLOCK_LEVEL);
+    }
+}
+
+/**
+ * 表示已解析的 SQL Token 类型的常量。
+ */
+const tokenTypes = {
+    WHITESPACE: 'whitespace',
+    WORD: 'word',
+    STRING: 'string',
+    RESERVED: 'reserved',
+    RESERVED_TOPLEVEL: 'reserved-toplevel',
+    RESERVED_NEWLINE: 'reserved-newline',
+    RESERVED_KEYWORD_BLOCK_START: 'reserved-keyword-block-start',
+    RESERVED_KEYWORD_BLOCK_END: 'reserved-keyword-block-end',
+    OPERATOR: 'operator',
+    OPEN_PAREN: 'open-paren',
+    CLOSE_PAREN: 'close-paren',
+    LINE_COMMENT: 'line-comment',
+    BLOCK_COMMENT: 'block-comment',
+    NUMBER: 'number',
+    PLACEHOLDER: 'placeholder',
+};
+
+const INLINE_MAX_LENGTH = 50;
+/**
+ * 内联块的记账器。
+ *
+ * 内联块是短于最大长度（例如 50 个字符）的括号表达式。
+ * 这些块会保持在单行上，以节省空间并提高可读性，而不是在括号后插入换行。
+ */
+class InlineBlock {
+    constructor() {
+        this.level = 0;
+    }
+    /**
+     * 如果可能，开始将括号表达式作为内联块进行跟踪。
+     *
+     * @param {Token[]} tokens 查询中的所有 Token。
+     * @param {number} index 当前左括号 Token 的索引。
+     */
+    beginIfPossible(tokens, index) {
+        if (this.level === 0 && this.isInlineBlock(tokens, index)) {
+            this.level = 1;
+        }
+        else if (this.level > 0) {
+            this.level++;
+        }
+        else {
+            this.level = 0;
+        }
+    }
+    /**
+     * 递减当前处于活动状态的嵌套内联块层级。
+     */
+    end() {
+        this.level--;
+    }
+    /**
+     * 检查是否存在活动的内联块。
+     *
+     * @returns {boolean} 如果在内联块内则返回 true，否则返回 false。
+     */
+    isActive() {
+        return this.level > 0;
+    }
+    /**
+     * 评估当前的括号组是否符合内联块的条件。
+     *
+     * 向前遍历 Token 直至匹配的右括号。
+     * 如果超过最大长度或包含受限 Token（例如注释、换行符、顶级关键字），则取消内联块格式。
+     *
+     * @param {Token[]} tokens 查询中的 Token。
+     * @param {number} index 当前左括号的索引。
+     * @returns {boolean} 如果该组可以进行内联格式化则返回 true。
+     */
+    isInlineBlock(tokens, index) {
+        let length = 0;
+        let level = 0;
+        const openingToken = tokens[index];
+        for (let i = index; i < tokens.length; i++) {
+            const token = tokens[i];
+            length += token.value.length;
+            if (length > INLINE_MAX_LENGTH) {
+                return false;
+            }
+            if (token.type === tokenTypes.OPEN_PAREN) {
+                level++;
+            }
+            else if (this.isClosingToken(token, openingToken)) {
+                level--;
+                if (level === 0) {
+                    return true;
+                }
+            }
+            if (this.isForbiddenToken(token)) {
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * 检查 Token 是否在内联块中被禁用。
+     *
+     * 禁用的 Token 包括注释、顶级/换行保留字或分号。
+     *
+     * @param {Token} token 要检查的 Token。
+     * @returns {boolean} 如果 Token 在内联块中被禁用则返回 true。
+     */
+    isForbiddenToken({ type, value }) {
+        return (type === tokenTypes.RESERVED_TOPLEVEL ||
+            type === tokenTypes.RESERVED_NEWLINE ||
+            type === tokenTypes.RESERVED_KEYWORD_BLOCK_START ||
+            type === tokenTypes.LINE_COMMENT ||
+            type === tokenTypes.BLOCK_COMMENT ||
+            value === ';');
+    }
+    isClosingToken(token, openingToken) {
+        return (token.type === tokenTypes.CLOSE_PAREN ||
+            (/^CASE$/i.test(openingToken.value) &&
+                token.type === tokenTypes.RESERVED_KEYWORD_BLOCK_END));
+    }
+}
+
+/**
+ * 处理 SQL 查询字符串中占位符与参数值的替换。
+ */
+class Params {
+    /**
+     * 初始化参数管理器。
+     *
+     * @param {ParamsMap} [params] 可选的参数映射（数组或键值对对象）。
+     */
+    constructor(params) {
+        this.index = 0;
+        this.params = params;
+    }
+    /**
+     * 获取与给定 Token 对应的参数值。
+     *
+     * 如果未提供 `params`，则返回原始 Token 值。
+     * 对于索引占位符，返回顺序参数或解析索引处的参数值。
+     * 对于命名占位符，返回与解析名称匹配的参数值。
+     *
+     * @param {Token} token 占位符 Token。
+     * @returns {string} 字符串形式的参数值或原始占位符。
+     */
+    get({ key, value }) {
+        if (!this.params) {
+            return value;
+        }
+        let param;
+        if (Array.isArray(this.params)) {
+            param = key ? this.params[Number(key)] : this.params[this.index++];
+        }
+        else if (key) {
+            param = this.params[key];
+        }
+        else {
+            param = this.params[this.index++];
+        }
+        return param === undefined ? value : String(param);
+    }
+}
+
+class OutputBuffer {
+    constructor() {
+        this.chunks = [];
+    }
+    append(value) {
+        if (value) {
+            this.chunks.push(value);
+        }
+    }
+    trimEnd() {
+        while (this.chunks.length > 0) {
+            const lastIndex = this.chunks.length - 1;
+            const chunk = this.chunks[lastIndex];
+            const trimmed = chunk.replace(/\s+$/, '');
+            if (trimmed.length === chunk.length) {
+                return;
+            }
+            if (trimmed.length > 0) {
+                this.chunks[lastIndex] = trimmed;
+                return;
+            }
+            this.chunks.pop();
+        }
+    }
+    addNewline(indent) {
+        this.trimEnd();
+        this.append(`\n${indent}`);
+    }
+    toString() {
+        return this.chunks.join('');
+    }
+}
+class Formatter {
+    constructor(cfg, tokenizer) {
+        this.previousReservedWord = {};
+        this.keywordBlockEndPending = false;
+        this.cfg = cfg || {};
+        this.indentation = new Indentation(this.cfg.indent);
+        this.inlineBlock = new InlineBlock();
+        this.params = new Params(this.cfg.params);
+        this.tokenizer = tokenizer;
+    }
+    format(query) {
+        const tokens = this.tokenizer.tokenize(query);
+        const formattedQuery = this.getFormattedQueryFromTokens(tokens);
+        return formattedQuery.trim();
+    }
+    getFormattedQueryFromTokens(tokens) {
+        const query = new OutputBuffer();
+        tokens.forEach((token, index) => {
+            if (token.type === tokenTypes.WHITESPACE) {
+                return;
+            }
+            if (token.type === tokenTypes.LINE_COMMENT) {
+                this.formatLineComment(token, query);
+            }
+            else if (token.type === tokenTypes.BLOCK_COMMENT) {
+                this.formatBlockComment(token, query);
+            }
+            else if (token.type === tokenTypes.RESERVED_KEYWORD_BLOCK_START) {
+                this.formatKeywordBlockStart(token, query);
+                this.previousReservedWord = token;
+            }
+            else if (token.type === tokenTypes.RESERVED_KEYWORD_BLOCK_END) {
+                this.formatKeywordBlockEnd(token, query);
+                this.previousReservedWord = token;
+            }
+            else if (token.type === tokenTypes.RESERVED_TOPLEVEL) {
+                this.formatToplevelReservedWord(token, query);
+                this.previousReservedWord = token;
+            }
+            else if (token.type === tokenTypes.RESERVED_NEWLINE) {
+                this.formatNewlineReservedWord(token, query);
+                this.previousReservedWord = token;
+            }
+            else if (token.type === tokenTypes.RESERVED) {
+                this.formatWithSpaces(token, query);
+                this.previousReservedWord = token;
+            }
+            else if (token.type === tokenTypes.OPEN_PAREN) {
+                this.formatOpeningParentheses(tokens, index, query);
+            }
+            else if (token.type === tokenTypes.CLOSE_PAREN) {
+                this.formatClosingParentheses(token, query);
+            }
+            else if (token.type === tokenTypes.PLACEHOLDER) {
+                this.formatPlaceholder(token, query);
+            }
+            else if (token.value === ',') {
+                this.formatComma(token, query);
+            }
+            else if (token.value === ':') {
+                this.formatWithSpaceAfter(token, query);
+            }
+            else if (token.value === ';') {
+                this.formatSemicolon(token, query);
+            }
+            else if (token.value === '.') {
+                this.formatWithoutSpaces(token, query);
+            }
+            else {
+                this.formatWithSpaces(token, query);
+            }
+        });
+        return query.toString();
+    }
+    formatLineComment(token, query) {
+        query.append(token.value);
+        this.addNewline(query);
+    }
+    formatBlockComment(token, query) {
+        this.addNewline(query);
+        query.append(this.indentComment(token.value));
+        this.addNewline(query);
+    }
+    indentComment(comment) {
+        return comment.replace(/\n/g, `\n${this.indentation.getIndent()}`);
+    }
+    formatKeywordBlockStart(token, query) {
+        if (/^LOOP$/i.test(token.value) &&
+            /^END$/i.test(this.previousReservedWord.value || '')) {
+            this.formatWithSpaces(token, query);
+            this.keywordBlockEndPending = true;
+            return;
+        }
+        this.indentation.decreaseTopLevel();
+        this.addNewline(query);
+        this.indentation.increaseKeywordBlock();
+        query.append(this.equalizeWhitespace(token.value));
+        this.addNewline(query);
+    }
+    formatKeywordBlockEnd(token, query) {
+        if (this.inlineBlock.isActive() || this.indentation.isBlockLevel()) {
+            this.formatClosingParentheses(token, query);
+            return;
+        }
+        this.indentation.decreaseKeywordBlock();
+        this.addNewline(query);
+        query.append(`${this.equalizeWhitespace(token.value)} `);
+        this.keywordBlockEndPending = true;
+    }
+    formatToplevelReservedWord(token, query) {
+        this.indentation.decreaseTopLevel();
+        this.addNewline(query);
+        this.indentation.increaseToplevel();
+        query.append(this.equalizeWhitespace(token.value));
+        this.addNewline(query);
+    }
+    formatNewlineReservedWord(token, query) {
+        this.addNewline(query);
+        query.append(`${this.equalizeWhitespace(token.value)} `);
+    }
+    equalizeWhitespace(value) {
+        return value.replace(/\s+/g, ' ');
+    }
+    formatOpeningParentheses(tokens, index, query) {
+        const previousToken = tokens[index - 1];
+        if (previousToken &&
+            previousToken.type !== tokenTypes.WHITESPACE &&
+            previousToken.type !== tokenTypes.OPEN_PAREN) {
+            query.trimEnd();
+        }
+        query.append(tokens[index].value);
+        this.inlineBlock.beginIfPossible(tokens, index);
+        if (!this.inlineBlock.isActive()) {
+            this.indentation.increaseBlockLevel();
+            this.addNewline(query);
+        }
+    }
+    formatClosingParentheses(token, query) {
+        if (this.inlineBlock.isActive()) {
+            this.inlineBlock.end();
+            this.formatWithSpaceAfter(token, query);
+            return;
+        }
+        this.indentation.decreaseBlockLevel();
+        this.addNewline(query);
+        this.formatWithSpaces(token, query);
+    }
+    formatPlaceholder(token, query) {
+        query.append(`${this.params.get(token)} `);
+    }
+    formatComma(token, query) {
+        query.trimEnd();
+        query.append(`${token.value} `);
+        if (this.inlineBlock.isActive()) {
+            return;
+        }
+        if (/^LIMIT$/i.test(this.previousReservedWord.value || '')) {
+            return;
+        }
+        this.addNewline(query);
+    }
+    formatWithSpaceAfter(token, query) {
+        query.trimEnd();
+        query.append(`${token.value} `);
+    }
+    formatWithoutSpaces(token, query) {
+        query.trimEnd();
+        query.append(token.value);
+    }
+    formatSemicolon(token, query) {
+        this.formatWithoutSpaces(token, query);
+        if (this.keywordBlockEndPending) {
+            this.addNewline(query);
+            this.keywordBlockEndPending = false;
+        }
+    }
+    formatWithSpaces(token, query) {
+        query.append(`${token.value} `);
+    }
+    addNewline(query) {
+        query.addNewline(this.indentation.getIndent());
+    }
+}
+
+const escapeRegExp = (value) => value.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+class Tokenizer {
+    constructor(cfg) {
+        this.WHITESPACE_REGEX = /(\s+)/y;
+        this.NUMBER_REGEX = /([0-9]+(\.[0-9]+)?|0x[0-9a-fA-F]+|0b[01]+)\b/y;
+        this.SIGNED_NUMBER_REGEX = /(-\s*(?:[0-9]+(\.[0-9]+)?|0x[0-9a-fA-F]+|0b[01]+)\b)/y;
+        this.ASSIGNMENT_REGEX = /(:=)/y;
+        this.OPERATOR_REGEX = /(!=|<>|==|<=|>=|!<|!>|\|\||::|->>|->|~~\*|~~|!~~\*|!~~|~\*|!~\*|!~|.)/y;
+        this.BLOCK_COMMENT_REGEX = /(\/\*[^]*?(?:\*\/|$))/y;
+        this.LINE_COMMENT_REGEX = this.createLineCommentRegex(cfg.lineCommentTypes);
+        this.RESERVED_TOPLEVEL_REGEX = this.createReservedWordRegex(cfg.reservedToplevelWords);
+        this.RESERVED_NEWLINE_REGEX = this.createReservedWordRegex(cfg.reservedNewlineWords);
+        this.RESERVED_PLAIN_REGEX = this.createReservedWordRegex(cfg.reservedWords);
+        this.KEYWORD_BLOCK_START_REGEX = this.createOptionalReservedWordRegex(cfg.keywordBlockStarts);
+        this.KEYWORD_BLOCK_END_REGEX = this.createOptionalReservedWordRegex(cfg.keywordBlockEnds);
+        this.WORD_REGEX = this.createWordRegex(cfg.specialWordChars);
+        this.STRING_REGEX = this.createStringRegex(cfg.stringTypes);
+        this.OPEN_PAREN_REGEX = this.createParenRegex(cfg.openParens);
+        this.CLOSE_PAREN_REGEX = this.createParenRegex(cfg.closeParens);
+        this.INDEXED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(cfg.indexedPlaceholderTypes, '[0-9]*');
+        this.IDENT_NAMED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(cfg.namedPlaceholderTypes, '[a-zA-Z0-9._$]+');
+        this.STRING_NAMED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(cfg.namedPlaceholderTypes, this.createStringPattern(cfg.stringTypes));
+    }
+    tokenize(input) {
+        const tokens = [];
+        let previousSignificantToken;
+        let index = 0;
+        while (index < input.length) {
+            const token = this.getNextToken(input, index, previousSignificantToken);
+            index += token.value.length;
+            tokens.push(token);
+            if (token.type !== tokenTypes.WHITESPACE) {
+                previousSignificantToken = token;
+            }
+        }
+        return tokens;
+    }
+    createLineCommentRegex(lineCommentTypes) {
+        return new RegExp(`((?:${lineCommentTypes.map((c) => escapeRegExp(c)).join('|')}).*?(?:\n|$))`, 'y');
+    }
+    createReservedWordRegex(reservedWords) {
+        const reservedWordsPattern = reservedWords.join('|').replace(/ /g, '\\s+');
+        return new RegExp(`(${reservedWordsPattern})\\b`, 'iy');
+    }
+    createOptionalReservedWordRegex(reservedWords) {
+        if (!reservedWords || reservedWords.length === 0) {
+            return false;
+        }
+        return this.createReservedWordRegex(reservedWords);
+    }
+    createWordRegex(specialChars = []) {
+        return new RegExp(`([\\w${specialChars.map((c) => escapeRegExp(c)).join('')}]+)`, 'y');
+    }
+    createStringRegex(stringTypes) {
+        return new RegExp(`(${this.createStringPattern(stringTypes)})`, 'y');
+    }
+    createStringPattern(stringTypes) {
+        const patterns = {
+            '``': '((`[^`]*($|`))+)',
+            '[]': '((\\[[^\\]]*($|\\]))(\\][^\\]]*($|\\]))*)',
+            '""': '((\\"[^\\"\\\\]*(?:\\\\.[^\\"\\\\]*)*(\\"|$))+)',
+            "''": "(('[^'\\\\]*(?:\\\\.[^'\\\\]*)*('|$))+)",
+            "N''": "((N'[^N'\\\\]*(?:\\\\.[^N'\\\\]*)*('|$))+)",
+        };
+        return stringTypes.map((type) => patterns[type]).join('|');
+    }
+    createParenRegex(parens) {
+        return new RegExp(`(${parens.map((p) => this.escapeParen(p)).join('|')})`, 'iy');
+    }
+    escapeParen(paren) {
+        if (paren.length === 1) {
+            return escapeRegExp(paren);
+        }
+        return `\\b${paren}\\b`;
+    }
+    createPlaceholderRegex(types, pattern) {
+        if (!types || types.length === 0) {
+            return false;
+        }
+        const typesRegex = types.map((type) => escapeRegExp(type)).join('|');
+        return new RegExp(`((?:${typesRegex})(?:${pattern}))`, 'y');
+    }
+    getNextToken(input, index, previousToken) {
+        return (this.getWhitespaceToken(input, index) ||
+            this.getCommentToken(input, index) ||
+            this.getStringToken(input, index) ||
+            this.getOpenParenToken(input, index) ||
+            this.getCloseParenToken(input, index) ||
+            this.getAssignmentToken(input, index) ||
+            this.getPlaceholderToken(input, index) ||
+            this.getNumberToken(input, index, previousToken) ||
+            this.getKeywordBlockToken(input, index) ||
+            this.getReservedWordToken(input, index, previousToken) ||
+            this.getWordToken(input, index) ||
+            this.getOperatorToken(input, index));
+    }
+    getWhitespaceToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.WHITESPACE,
+            regex: this.WHITESPACE_REGEX,
+        });
+    }
+    getCommentToken(input, index) {
+        return (this.getLineCommentToken(input, index) ||
+            this.getBlockCommentToken(input, index));
+    }
+    getLineCommentToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.LINE_COMMENT,
+            regex: this.LINE_COMMENT_REGEX,
+        });
+    }
+    getBlockCommentToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.BLOCK_COMMENT,
+            regex: this.BLOCK_COMMENT_REGEX,
+        });
+    }
+    getStringToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.STRING,
+            regex: this.STRING_REGEX,
+        });
+    }
+    getOpenParenToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.OPEN_PAREN,
+            regex: this.OPEN_PAREN_REGEX,
+        });
+    }
+    getCloseParenToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.CLOSE_PAREN,
+            regex: this.CLOSE_PAREN_REGEX,
+        });
+    }
+    getAssignmentToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.OPERATOR,
+            regex: this.ASSIGNMENT_REGEX,
+        });
+    }
+    getPlaceholderToken(input, index) {
+        return (this.getIdentNamedPlaceholderToken(input, index) ||
+            this.getStringNamedPlaceholderToken(input, index) ||
+            this.getIndexedPlaceholderToken(input, index));
+    }
+    getIdentNamedPlaceholderToken(input, index) {
+        return this.getPlaceholderTokenWithKey({
+            input,
+            index,
+            regex: this.IDENT_NAMED_PLACEHOLDER_REGEX,
+            parseKey: (value) => value.slice(1),
+        });
+    }
+    getStringNamedPlaceholderToken(input, index) {
+        return this.getPlaceholderTokenWithKey({
+            input,
+            index,
+            regex: this.STRING_NAMED_PLACEHOLDER_REGEX,
+            parseKey: (value) => this.getEscapedPlaceholderKey({
+                key: value.slice(2, -1),
+                quoteChar: value.slice(-1),
+            }),
+        });
+    }
+    getIndexedPlaceholderToken(input, index) {
+        return this.getPlaceholderTokenWithKey({
+            input,
+            index,
+            regex: this.INDEXED_PLACEHOLDER_REGEX,
+            parseKey: (value) => value.slice(1),
+        });
+    }
+    getPlaceholderTokenWithKey({ input, index, regex, parseKey, }) {
+        const token = this.getTokenOnFirstMatch({
+            input,
+            index,
+            regex,
+            type: tokenTypes.PLACEHOLDER,
+        });
+        if (token) {
+            token.key = parseKey(token.value);
+        }
+        return token;
+    }
+    getEscapedPlaceholderKey({ key, quoteChar, }) {
+        return key.replace(new RegExp(`${escapeRegExp('\\')}${quoteChar}`, 'g'), quoteChar);
+    }
+    getNumberToken(input, index, previousToken) {
+        const signedNumber = this.canReadSignedNumber(previousToken)
+            ? this.getTokenOnFirstMatch({
+                input,
+                index,
+                type: tokenTypes.NUMBER,
+                regex: this.SIGNED_NUMBER_REGEX,
+            })
+            : undefined;
+        if (signedNumber) {
+            return signedNumber;
+        }
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.NUMBER,
+            regex: this.NUMBER_REGEX,
+        });
+    }
+    canReadSignedNumber(previousToken) {
+        return (!previousToken ||
+            previousToken.type === tokenTypes.OPERATOR ||
+            previousToken.type === tokenTypes.OPEN_PAREN ||
+            previousToken.value === ',');
+    }
+    getOperatorToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.OPERATOR,
+            regex: this.OPERATOR_REGEX,
+        });
+    }
+    getKeywordBlockToken(input, index) {
+        return (this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.RESERVED_KEYWORD_BLOCK_END,
+            regex: this.KEYWORD_BLOCK_END_REGEX,
+        }) ||
+            this.getTokenOnFirstMatch({
+                input,
+                index,
+                type: tokenTypes.RESERVED_KEYWORD_BLOCK_START,
+                regex: this.KEYWORD_BLOCK_START_REGEX,
+            }));
+    }
+    getReservedWordToken(input, index, previousToken) {
+        if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.value) === '.') {
+            return undefined;
+        }
+        return (this.getToplevelReservedToken(input, index) ||
+            this.getNewlineReservedToken(input, index) ||
+            this.getPlainReservedToken(input, index));
+    }
+    getToplevelReservedToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.RESERVED_TOPLEVEL,
+            regex: this.RESERVED_TOPLEVEL_REGEX,
+        });
+    }
+    getNewlineReservedToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.RESERVED_NEWLINE,
+            regex: this.RESERVED_NEWLINE_REGEX,
+        });
+    }
+    getPlainReservedToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.RESERVED,
+            regex: this.RESERVED_PLAIN_REGEX,
+        });
+    }
+    getWordToken(input, index) {
+        return this.getTokenOnFirstMatch({
+            input,
+            index,
+            type: tokenTypes.WORD,
+            regex: this.WORD_REGEX,
+        });
+    }
+    getTokenOnFirstMatch({ input, index, type, regex, }) {
+        if (!regex) {
+            return undefined;
+        }
+        regex.lastIndex = index;
+        const matches = regex.exec(input);
+        if (matches && matches.index === index) {
+            return { type, value: matches[1] };
+        }
+        return undefined;
+    }
+}
+
+const reservedWords$3 = [
+    'ABS',
+    'ACTIVATE',
+    'ALIAS',
+    'ALL',
+    'ALLOCATE',
+    'ALLOW',
+    'ALTER',
+    'ANY',
+    'ARE',
+    'ARRAY',
+    'AS',
+    'ASC',
+    'ASENSITIVE',
+    'ASSOCIATE',
+    'ASUTIME',
+    'ASYMMETRIC',
+    'AT',
+    'ATOMIC',
+    'ATTRIBUTES',
+    'AUDIT',
+    'AUTHORIZATION',
+    'AUX',
+    'AUXILIARY',
+    'AVG',
+    'BEFORE',
+    'BEGIN',
+    'BETWEEN',
+    'BIGINT',
+    'BINARY',
+    'BLOB',
+    'BOOLEAN',
+    'BOTH',
+    'BUFFERPOOL',
+    'BY',
+    'CACHE',
+    'CALL',
+    'CALLED',
+    'CAPTURE',
+    'CARDINALITY',
+    'CASCADED',
+    'CASE',
+    'CAST',
+    'CCSID',
+    'CEIL',
+    'CEILING',
+    'CHAR',
+    'CHARACTER',
+    'CHARACTER_LENGTH',
+    'CHAR_LENGTH',
+    'CHECK',
+    'CLOB',
+    'CLONE',
+    'CLOSE',
+    'CLUSTER',
+    'COALESCE',
+    'COLLATE',
+    'COLLECT',
+    'COLLECTION',
+    'COLLID',
+    'COLUMN',
+    'COMMENT',
+    'COMMIT',
+    'CONCAT',
+    'CONDITION',
+    'CONNECT',
+    'CONNECTION',
+    'CONSTRAINT',
+    'CONTAINS',
+    'CONTINUE',
+    'CONVERT',
+    'CORR',
+    'CORRESPONDING',
+    'COUNT',
+    'COUNT_BIG',
+    'COVAR_POP',
+    'COVAR_SAMP',
+    'CREATE',
+    'CROSS',
+    'CUBE',
+    'CUME_DIST',
+    'CURRENT',
+    'CURRENT_DATE',
+    'CURRENT_DEFAULT_TRANSFORM_GROUP',
+    'CURRENT_LC_CTYPE',
+    'CURRENT_PATH',
+    'CURRENT_ROLE',
+    'CURRENT_SCHEMA',
+    'CURRENT_SERVER',
+    'CURRENT_TIME',
+    'CURRENT_TIMESTAMP',
+    'CURRENT_TIMEZONE',
+    'CURRENT_TRANSFORM_GROUP_FOR_TYPE',
+    'CURRENT_USER',
+    'CURSOR',
+    'CYCLE',
+    'DATA',
+    'DATABASE',
+    'DATAPARTITIONNAME',
+    'DATAPARTITIONNUM',
+    'DATE',
+    'DAY',
+    'DAYS',
+    'DB2GENERAL',
+    'DB2GENRL',
+    'DB2SQL',
+    'DBINFO',
+    'DBPARTITIONNAME',
+    'DBPARTITIONNUM',
+    'DEALLOCATE',
+    'DEC',
+    'DECIMAL',
+    'DECLARE',
+    'DEFAULT',
+    'DEFAULTS',
+    'DEFINITION',
+    'DELETE',
+    'DENSERANK',
+    'DENSE_RANK',
+    'DEREF',
+    'DESCRIBE',
+    'DESCRIPTOR',
+    'DETERMINISTIC',
+    'DIAGNOSTICS',
+    'DISABLE',
+    'DISALLOW',
+    'DISCONNECT',
+    'DISTINCT',
+    'DO',
+    'DOCUMENT',
+    'DOUBLE',
+    'DROP',
+    'DSSIZE',
+    'DYNAMIC',
+    'EACH',
+    'EDITPROC',
+    'ELEMENT',
+    'ELSE',
+    'ELSEIF',
+    'ENABLE',
+    'ENCODING',
+    'ENCRYPTION',
+    'END',
+    'END-EXEC',
+    'ENDING',
+    'ERASE',
+    'ESCAPE',
+    'EVERY',
+    'EXCEPTION',
+    'EXCLUDING',
+    'EXCLUSIVE',
+    'EXEC',
+    'EXECUTE',
+    'EXISTS',
+    'EXIT',
+    'EXP',
+    'EXPLAIN',
+    'EXTENDED',
+    'EXTERNAL',
+    'EXTRACT',
+    'FALSE',
+    'FENCED',
+    'FETCH',
+    'FIELDPROC',
+    'FILE',
+    'FILTER',
+    'FINAL',
+    'FIRST',
+    'FLOAT',
+    'FLOOR',
+    'FOR',
+    'FOREIGN',
+    'FREE',
+    'FULL',
+    'FUNCTION',
+    'FUSION',
+    'GENERAL',
+    'GENERATED',
+    'GET',
+    'GLOBAL',
+    'GOTO',
+    'GRANT',
+    'GRAPHIC',
+    'GROUP',
+    'GROUPING',
+    'HANDLER',
+    'HASH',
+    'HASHED_VALUE',
+    'HINT',
+    'HOLD',
+    'HOUR',
+    'HOURS',
+    'IDENTITY',
+    'IF',
+    'IMMEDIATE',
+    'IN',
+    'INCLUDING',
+    'INCLUSIVE',
+    'INCREMENT',
+    'INDEX',
+    'INDICATOR',
+    'INDICATORS',
+    'INF',
+    'INFINITY',
+    'INHERIT',
+    'INNER',
+    'INOUT',
+    'INSENSITIVE',
+    'INSERT',
+    'INT',
+    'INTEGER',
+    'INTEGRITY',
+    'INTERSECTION',
+    'INTERVAL',
+    'INTO',
+    'IS',
+    'ISOBID',
+    'ISOLATION',
+    'ITERATE',
+    'JAR',
+    'JAVA',
+    'KEEP',
+    'KEY',
+    'LABEL',
+    'LANGUAGE',
+    'LARGE',
+    'LATERAL',
+    'LC_CTYPE',
+    'LEADING',
+    'LEAVE',
+    'LEFT',
+    'LIKE',
+    'LINKTYPE',
+    'LN',
+    'LOCAL',
+    'LOCALDATE',
+    'LOCALE',
+    'LOCALTIME',
+    'LOCALTIMESTAMP',
+    'LOCATOR',
+    'LOCATORS',
+    'LOCK',
+    'LOCKMAX',
+    'LOCKSIZE',
+    'LONG',
+    'LOOP',
+    'LOWER',
+    'MAINTAINED',
+    'MATCH',
+    'MATERIALIZED',
+    'MAX',
+    'MAXVALUE',
+    'MEMBER',
+    'MERGE',
+    'METHOD',
+    'MICROSECOND',
+    'MICROSECONDS',
+    'MIN',
+    'MINUTE',
+    'MINUTES',
+    'MINVALUE',
+    'MOD',
+    'MODE',
+    'MODIFIES',
+    'MODULE',
+    'MONTH',
+    'MONTHS',
+    'MULTISET',
+    'NAN',
+    'NATIONAL',
+    'NATURAL',
+    'NCHAR',
+    'NCLOB',
+    'NEW',
+    'NEW_TABLE',
+    'NEXTVAL',
+    'NO',
+    'NOCACHE',
+    'NOCYCLE',
+    'NODENAME',
+    'NODENUMBER',
+    'NOMAXVALUE',
+    'NOMINVALUE',
+    'NONE',
+    'NOORDER',
+    'NORMALIZE',
+    'NORMALIZED',
+    'NOT',
+    'NULL',
+    'NULLIF',
+    'NULLS',
+    'NUMERIC',
+    'NUMPARTS',
+    'OBID',
+    'OCTET_LENGTH',
+    'OF',
+    'OFFSET',
+    'OLD',
+    'OLD_TABLE',
+    'ON',
+    'ONLY',
+    'OPEN',
+    'OPTIMIZATION',
+    'OPTIMIZE',
+    'OPTION',
+    'ORDER',
+    'OUT',
+    'OUTER',
+    'OVER',
+    'OVERLAPS',
+    'OVERLAY',
+    'OVERRIDING',
+    'PACKAGE',
+    'PADDED',
+    'PAGESIZE',
+    'PARAMETER',
+    'PART',
+    'PARTITION',
+    'PARTITIONED',
+    'PARTITIONING',
+    'PARTITIONS',
+    'PASSWORD',
+    'PATH',
+    'PERCENTILE_CONT',
+    'PERCENTILE_DISC',
+    'PERCENT_RANK',
+    'PIECESIZE',
+    'PLAN',
+    'POSITION',
+    'POWER',
+    'PRECISION',
+    'PREPARE',
+    'PREVVAL',
+    'PRIMARY',
+    'PRIQTY',
+    'PRIVILEGES',
+    'PROCEDURE',
+    'PROGRAM',
+    'PSID',
+    'PUBLIC',
+    'QUERY',
+    'QUERYNO',
+    'RANGE',
+    'RANK',
+    'READ',
+    'READS',
+    'REAL',
+    'RECOVERY',
+    'RECURSIVE',
+    'REF',
+    'REFERENCES',
+    'REFERENCING',
+    'REFRESH',
+    'REGR_AVGX',
+    'REGR_AVGY',
+    'REGR_COUNT',
+    'REGR_INTERCEPT',
+    'REGR_R2',
+    'REGR_SLOPE',
+    'REGR_SXX',
+    'REGR_SXY',
+    'REGR_SYY',
+    'RELEASE',
+    'RENAME',
+    'REPEAT',
+    'RESET',
+    'RESIGNAL',
+    'RESTART',
+    'RESTRICT',
+    'RESULT',
+    'RESULT_SET_LOCATOR',
+    'RETURN',
+    'RETURNS',
+    'REVOKE',
+    'RIGHT',
+    'ROLE',
+    'ROLLBACK',
+    'ROLLUP',
+    'ROUND_CEILING',
+    'ROUND_DOWN',
+    'ROUND_FLOOR',
+    'ROUND_HALF_DOWN',
+    'ROUND_HALF_EVEN',
+    'ROUND_HALF_UP',
+    'ROUND_UP',
+    'ROUTINE',
+    'ROW',
+    'ROWNUMBER',
+    'ROWS',
+    'ROWSET',
+    'ROW_NUMBER',
+    'RRN',
+    'RUN',
+    'SAVEPOINT',
+    'SCHEMA',
+    'SCOPE',
+    'SCRATCHPAD',
+    'SCROLL',
+    'SEARCH',
+    'SECOND',
+    'SECONDS',
+    'SECQTY',
+    'SECURITY',
+    'SENSITIVE',
+    'SEQUENCE',
+    'SESSION',
+    'SESSION_USER',
+    'SIGNAL',
+    'SIMILAR',
+    'SIMPLE',
+    'SMALLINT',
+    'SNAN',
+    'SOME',
+    'SOURCE',
+    'SPECIFIC',
+    'SPECIFICTYPE',
+    'SQL',
+    'SQLEXCEPTION',
+    'SQLID',
+    'SQLSTATE',
+    'SQLWARNING',
+    'SQRT',
+    'STACKED',
+    'STANDARD',
+    'START',
+    'STARTING',
+    'STATEMENT',
+    'STATIC',
+    'STATMENT',
+    'STAY',
+    'STDDEV_POP',
+    'STDDEV_SAMP',
+    'STOGROUP',
+    'STORES',
+    'STYLE',
+    'SUBMULTISET',
+    'SUBSTRING',
+    'SUM',
+    'SUMMARY',
+    'SYMMETRIC',
+    'SYNONYM',
+    'SYSFUN',
+    'SYSIBM',
+    'SYSPROC',
+    'SYSTEM',
+    'SYSTEM_USER',
+    'TABLE',
+    'TABLESAMPLE',
+    'TABLESPACE',
+    'THEN',
+    'TIME',
+    'TIMESTAMP',
+    'TIMEZONE_HOUR',
+    'TIMEZONE_MINUTE',
+    'TO',
+    'TRAILING',
+    'TRANSACTION',
+    'TRANSLATE',
+    'TRANSLATION',
+    'TREAT',
+    'TRIGGER',
+    'TRIM',
+    'TRUE',
+    'TRUNCATE',
+    'TYPE',
+    'UESCAPE',
+    'UNDO',
+    'UNIQUE',
+    'UNKNOWN',
+    'UNNEST',
+    'UNTIL',
+    'UPPER',
+    'USAGE',
+    'USER',
+    'USING',
+    'VALIDPROC',
+    'VALUE',
+    'VARCHAR',
+    'VARIABLE',
+    'VARIANT',
+    'VARYING',
+    'VAR_POP',
+    'VAR_SAMP',
+    'VCAT',
+    'VERSION',
+    'VIEW',
+    'VOLATILE',
+    'VOLUMES',
+    'WHEN',
+    'WHENEVER',
+    'WHILE',
+    'WIDTH_BUCKET',
+    'WINDOW',
+    'WITH',
+    'WITHIN',
+    'WITHOUT',
+    'WLM',
+    'WRITE',
+    'XMLELEMENT',
+    'XMLEXISTS',
+    'XMLNAMESPACES',
+    'YEAR',
+    'YEARS',
+];
+const reservedToplevelWords$3 = [
+    'ADD',
+    'AFTER',
+    'ALTER COLUMN',
+    'ALTER TABLE',
+    'DELETE FROM',
+    'EXCEPT',
+    'FETCH FIRST',
+    'FROM',
+    'GROUP BY',
+    'GO',
+    'HAVING',
+    'INSERT INTO',
+    'INTERSECT',
+    'LIMIT',
+    'ORDER BY',
+    'SELECT',
+    'SET CURRENT SCHEMA',
+    'SET SCHEMA',
+    'SET',
+    'UNION ALL',
+    'UPDATE',
+    'VALUES',
+    'WHERE',
+];
+const reservedNewlineWords$3 = [
+    'AND',
+    'CROSS JOIN',
+    'INNER JOIN',
+    'JOIN',
+    'LEFT JOIN',
+    'LEFT OUTER JOIN',
+    'OR',
+    'OUTER JOIN',
+    'RIGHT JOIN',
+    'RIGHT OUTER JOIN',
+];
+let tokenizer$3;
+/**
+ * IBM DB2 SQL 方言格式化器。
+ */
+class Db2Formatter {
+    /**
+     * 初始化 Db2Formatter。
+     *
+     * @param {FormatOptions} cfg 格式化配置。
+     */
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    /**
+     * 格式化 DB2 查询字符串以提高可读性。
+     *
+     * @param {string} query 原始 DB2 查询字符串。
+     * @returns {string} 格式化后的查询。
+     */
+    format(query) {
+        if (!tokenizer$3) {
+            tokenizer$3 = new Tokenizer({
+                reservedWords: reservedWords$3,
+                reservedToplevelWords: reservedToplevelWords$3,
+                reservedNewlineWords: reservedNewlineWords$3,
+                stringTypes: [`""`, "''", '``', '[]'],
+                openParens: ['('],
+                closeParens: [')'],
+                indexedPlaceholderTypes: ['?'],
+                namedPlaceholderTypes: [':'],
+                lineCommentTypes: ['--'],
+                specialWordChars: ['#', '@'],
+            });
+        }
+        return new Formatter(this.cfg, tokenizer$3).format(query);
+    }
+}
+
+const reservedWords$2 = [
+    'ALL',
+    'ALTER',
+    'ANALYZE',
+    'AND',
+    'ANY',
+    'ARRAY',
+    'AS',
+    'ASC',
+    'BEGIN',
+    'BETWEEN',
+    'BINARY',
+    'BOOLEAN',
+    'BREAK',
+    'BUCKET',
+    'BUILD',
+    'BY',
+    'CALL',
+    'CASE',
+    'CAST',
+    'CLUSTER',
+    'COLLATE',
+    'COLLECTION',
+    'COMMIT',
+    'CONNECT',
+    'CONTINUE',
+    'CORRELATE',
+    'COVER',
+    'CREATE',
+    'DATABASE',
+    'DATASET',
+    'DATASTORE',
+    'DECLARE',
+    'DECREMENT',
+    'DELETE',
+    'DERIVED',
+    'DESC',
+    'DESCRIBE',
+    'DISTINCT',
+    'DO',
+    'DROP',
+    'EACH',
+    'ELEMENT',
+    'ELSE',
+    'END',
+    'EVERY',
+    'EXCEPT',
+    'EXCLUDE',
+    'EXECUTE',
+    'EXISTS',
+    'EXPLAIN',
+    'FALSE',
+    'FETCH',
+    'FIRST',
+    'FLATTEN',
+    'FOR',
+    'FORCE',
+    'FROM',
+    'FUNCTION',
+    'GRANT',
+    'GROUP',
+    'GSI',
+    'HAVING',
+    'IF',
+    'IGNORE',
+    'ILIKE',
+    'IN',
+    'INCLUDE',
+    'INCREMENT',
+    'INDEX',
+    'INFER',
+    'INLINE',
+    'INNER',
+    'INSERT',
+    'INTERSECT',
+    'INTO',
+    'IS',
+    'JOIN',
+    'KEY',
+    'KEYS',
+    'KEYSPACE',
+    'KNOWN',
+    'LAST',
+    'LEFT',
+    'LET',
+    'LETTING',
+    'LIKE',
+    'LIMIT',
+    'LSM',
+    'MAP',
+    'MAPPING',
+    'MATCHED',
+    'MATERIALIZED',
+    'MERGE',
+    'MINUS',
+    'MISSING',
+    'NAMESPACE',
+    'NEST',
+    'NOT',
+    'NULL',
+    'NUMBER',
+    'OBJECT',
+    'OFFSET',
+    'ON',
+    'OPTION',
+    'OR',
+    'ORDER',
+    'OUTER',
+    'OVER',
+    'PARSE',
+    'PARTITION',
+    'PASSWORD',
+    'PATH',
+    'POOL',
+    'PREPARE',
+    'PRIMARY',
+    'PRIVATE',
+    'PRIVILEGE',
+    'PROCEDURE',
+    'PUBLIC',
+    'RAW',
+    'REALM',
+    'REDUCE',
+    'RENAME',
+    'RETURN',
+    'RETURNING',
+    'REVOKE',
+    'RIGHT',
+    'ROLE',
+    'ROLLBACK',
+    'SATISFIES',
+    'SCHEMA',
+    'SELECT',
+    'SELF',
+    'SEMI',
+    'SET',
+    'SHOW',
+    'SOME',
+    'START',
+    'STATISTICS',
+    'STRING',
+    'SYSTEM',
+    'THEN',
+    'TO',
+    'TRANSACTION',
+    'TRIGGER',
+    'TRUE',
+    'TRUNCATE',
+    'UNDER',
+    'UNION',
+    'UNIQUE',
+    'UNKNOWN',
+    'UNNEST',
+    'UNSET',
+    'UPDATE',
+    'UPSERT',
+    'USE',
+    'USER',
+    'USING',
+    'VALIDATE',
+    'VALUE',
+    'VALUED',
+    'VALUES',
+    'VIA',
+    'VIEW',
+    'WHEN',
+    'WHERE',
+    'WHILE',
+    'WITH',
+    'WITHIN',
+    'WORK',
+    'XOR',
+];
+const reservedToplevelWords$2 = [
+    'DELETE FROM',
+    'EXCEPT ALL',
+    'EXCEPT',
+    'EXPLAIN DELETE FROM',
+    'EXPLAIN UPDATE',
+    'EXPLAIN UPSERT',
+    'FROM',
+    'GROUP BY',
+    'HAVING',
+    'INFER',
+    'INSERT INTO',
+    'INTERSECT ALL',
+    'INTERSECT',
+    'LET',
+    'LIMIT',
+    'MERGE',
+    'NEST',
+    'ORDER BY',
+    'PREPARE',
+    'SELECT',
+    'SET CURRENT SCHEMA',
+    'SET SCHEMA',
+    'SET',
+    'UNION ALL',
+    'UNION',
+    'UNNEST',
+    'UPDATE',
+    'UPSERT',
+    'USE KEYS',
+    'VALUES',
+    'WHERE',
+];
+const reservedNewlineWords$2 = [
+    'AND',
+    'INNER JOIN',
+    'JOIN',
+    'LEFT JOIN',
+    'LEFT OUTER JOIN',
+    'OR',
+    'OUTER JOIN',
+    'RIGHT JOIN',
+    'RIGHT OUTER JOIN',
+    'XOR',
+];
+let tokenizer$2;
+/**
+ * Couchbase N1QL 方言格式化器。
+ */
+class N1qlFormatter {
+    /**
+     * 初始化 N1qlFormatter。
+     *
+     * @param {FormatOptions} cfg 格式化配置。
+     */
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    /**
+     * 格式化 N1QL 字符串中的空白以提高可读性。
+     *
+     * @param {string} query 原始 N1QL 查询字符串。
+     * @returns {string} 格式化后的查询。
+     */
+    format(query) {
+        if (!tokenizer$2) {
+            tokenizer$2 = new Tokenizer({
+                reservedWords: reservedWords$2,
+                reservedToplevelWords: reservedToplevelWords$2,
+                reservedNewlineWords: reservedNewlineWords$2,
+                stringTypes: [`""`, "''", '``'],
+                openParens: ['(', '[', '{'],
+                closeParens: [')', ']', '}'],
+                namedPlaceholderTypes: ['$'],
+                lineCommentTypes: ['#', '--'],
+            });
+        }
+        return new Formatter(this.cfg, tokenizer$2).format(query);
+    }
+}
+
+const reservedWords$1 = [
+    'A',
+    'ACCESSIBLE',
+    'AGENT',
+    'AGGREGATE',
+    'ALL',
+    'ALTER',
+    'ANY',
+    'ARRAY',
+    'AS',
+    'ASC',
+    'AT',
+    'ATTRIBUTE',
+    'AUTHID',
+    'AVG',
+    'BETWEEN',
+    'BFILE_BASE',
+    'BINARY_INTEGER',
+    'BINARY',
+    'BLOB_BASE',
+    'BLOCK',
+    'BODY',
+    'BOOLEAN',
+    'BOTH',
+    'BOUND',
+    'BULK',
+    'BY',
+    'BYTE',
+    'C',
+    'CALL',
+    'CALLING',
+    'CASCADE',
+    'CASE',
+    'CHAR_BASE',
+    'CHAR',
+    'CHARACTER',
+    'CHARSET',
+    'CHARSETFORM',
+    'CHARSETID',
+    'CHECK',
+    'CLOB_BASE',
+    'CLONE',
+    'CLOSE',
+    'CLUSTER',
+    'CLUSTERS',
+    'COALESCE',
+    'COLAUTH',
+    'COLLECT',
+    'COLUMNS',
+    'COMMENT',
+    'COMMIT',
+    'COMMITTED',
+    'COMPILED',
+    'COMPRESS',
+    'CONNECT',
+    'CONSTANT',
+    'CONSTRUCTOR',
+    'CONTEXT',
+    'CONTINUE',
+    'CONVERT',
+    'COUNT',
+    'CRASH',
+    'CREATE',
+    'CREDENTIAL',
+    'CURRENT',
+    'CURRVAL',
+    'CURSOR',
+    'CUSTOMDATUM',
+    'DANGLING',
+    'DATA',
+    'DATE_BASE',
+    'DATE',
+    'DAY',
+    'DECIMAL',
+    'DEFAULT',
+    'DEFINE',
+    'DELETE',
+    'DESC',
+    'DETERMINISTIC',
+    'DIRECTORY',
+    'DISTINCT',
+    'DO',
+    'DOUBLE',
+    'DROP',
+    'DURATION',
+    'ELEMENT',
+    'ELSIF',
+    'EMPTY',
+    'ESCAPE',
+    'EXCEPTIONS',
+    'EXCLUSIVE',
+    'EXECUTE',
+    'EXISTS',
+    'EXIT',
+    'EXTENDS',
+    'EXTERNAL',
+    'EXTRACT',
+    'FALSE',
+    'FETCH',
+    'FINAL',
+    'FIRST',
+    'FIXED',
+    'FLOAT',
+    'FOR',
+    'FORALL',
+    'FORCE',
+    'FROM',
+    'FUNCTION',
+    'GENERAL',
+    'GOTO',
+    'GRANT',
+    'GROUP',
+    'HASH',
+    'HEAP',
+    'HIDDEN',
+    'HOUR',
+    'IDENTIFIED',
+    'IF',
+    'IMMEDIATE',
+    'IN',
+    'INCLUDING',
+    'INDEX',
+    'INDEXES',
+    'INDICATOR',
+    'INDICES',
+    'INFINITE',
+    'INSTANTIABLE',
+    'INT',
+    'INTEGER',
+    'INTERFACE',
+    'INTERVAL',
+    'INTO',
+    'INVALIDATE',
+    'IS',
+    'ISOLATION',
+    'JAVA',
+    'LANGUAGE',
+    'LARGE',
+    'LEADING',
+    'LENGTH',
+    'LEVEL',
+    'LIBRARY',
+    'LIKE',
+    'LIKE2',
+    'LIKE4',
+    'LIKEC',
+    'LIMITED',
+    'LOCAL',
+    'LOCK',
+    'LONG',
+    'MAP',
+    'MAX',
+    'MAXLEN',
+    'MEMBER',
+    'MERGE',
+    'MIN',
+    'MINUS',
+    'MINUTE',
+    'MLSLABEL',
+    'MOD',
+    'MODE',
+    'MONTH',
+    'MULTISET',
+    'NAME',
+    'NAN',
+    'NATIONAL',
+    'NATIVE',
+    'NATURAL',
+    'NATURALN',
+    'NCHAR',
+    'NEW',
+    'NEXTVAL',
+    'NOCOMPRESS',
+    'NOCOPY',
+    'NOT',
+    'NOWAIT',
+    'NULL',
+    'NULLIF',
+    'NUMBER_BASE',
+    'NUMBER',
+    'OBJECT',
+    'OCICOLL',
+    'OCIDATE',
+    'OCIDATETIME',
+    'OCIDURATION',
+    'OCIINTERVAL',
+    'OCILOBLOCATOR',
+    'OCINUMBER',
+    'OCIRAW',
+    'OCIREF',
+    'OCIREFCURSOR',
+    'OCIROWID',
+    'OCISTRING',
+    'OCITYPE',
+    'OF',
+    'OLD',
+    'ON',
+    'ONLY',
+    'OPAQUE',
+    'OPEN',
+    'OPERATOR',
+    'OPTION',
+    'ORACLE',
+    'ORADATA',
+    'ORDER',
+    'ORGANIZATION',
+    'ORLANY',
+    'ORLVARY',
+    'OTHERS',
+    'OUT',
+    'OVERLAPS',
+    'OVERRIDING',
+    'PACKAGE',
+    'PARALLEL_ENABLE',
+    'PARAMETER',
+    'PARAMETERS',
+    'PARENT',
+    'PARTITION',
+    'PASCAL',
+    'PCTFREE',
+    'PIPE',
+    'PIPELINED',
+    'PLS_INTEGER',
+    'PLUGGABLE',
+    'POSITIVE',
+    'POSITIVEN',
+    'PRAGMA',
+    'PRECISION',
+    'PRIOR',
+    'PRIVATE',
+    'PROCEDURE',
+    'PUBLIC',
+    'RAISE',
+    'RANGE',
+    'RAW',
+    'READ',
+    'REAL',
+    'RECORD',
+    'REF',
+    'REFERENCE',
+    'RELEASE',
+    'RELIES_ON',
+    'REM',
+    'REMAINDER',
+    'RENAME',
+    'RESOURCE',
+    'RESULT_CACHE',
+    'RESULT',
+    'RETURN',
+    'RETURNING',
+    'REVERSE',
+    'REVOKE',
+    'ROLLBACK',
+    'ROW',
+    'ROWID',
+    'ROWNUM',
+    'ROWTYPE',
+    'SAMPLE',
+    'SAVE',
+    'SAVEPOINT',
+    'SB1',
+    'SB2',
+    'SB4',
+    'SECOND',
+    'SEGMENT',
+    'SELF',
+    'SEPARATE',
+    'SEQUENCE',
+    'SERIALIZABLE',
+    'SHARE',
+    'SHORT',
+    'SIZE_T',
+    'SIZE',
+    'SMALLINT',
+    'SOME',
+    'SPACE',
+    'SPARSE',
+    'SQL',
+    'SQLCODE',
+    'SQLDATA',
+    'SQLERRM',
+    'SQLNAME',
+    'SQLSTATE',
+    'STANDARD',
+    'START',
+    'STATIC',
+    'STDDEV',
+    'STORED',
+    'STRING',
+    'STRUCT',
+    'STYLE',
+    'SUBMULTISET',
+    'SUBPARTITION',
+    'SUBSTITUTABLE',
+    'SUBTYPE',
+    'SUCCESSFUL',
+    'SUM',
+    'SYNONYM',
+    'SYSDATE',
+    'TABAUTH',
+    'TABLE',
+    'TDO',
+    'THE',
+    'THEN',
+    'TIME',
+    'TIMESTAMP',
+    'TIMEZONE_ABBR',
+    'TIMEZONE_HOUR',
+    'TIMEZONE_MINUTE',
+    'TIMEZONE_REGION',
+    'TO',
+    'TRAILING',
+    'TRANSACTION',
+    'TRANSACTIONAL',
+    'TRIGGER',
+    'TRUE',
+    'TRUSTED',
+    'TYPE',
+    'UB1',
+    'UB2',
+    'UB4',
+    'UID',
+    'UNDER',
+    'UNIQUE',
+    'UNPLUG',
+    'UNSIGNED',
+    'UNTRUSTED',
+    'USE',
+    'USER',
+    'USING',
+    'VALIDATE',
+    'VALIST',
+    'VALUE',
+    'VARCHAR',
+    'VARCHAR2',
+    'VARIABLE',
+    'VARIANCE',
+    'VARRAY',
+    'VARYING',
+    'VIEW',
+    'VIEWS',
+    'VOID',
+    'WHENEVER',
+    'WHILE',
+    'WITH',
+    'WORK',
+    'WRAPPED',
+    'WRITE',
+    'YEAR',
+    'ZONE',
+];
+const reservedToplevelWords$1 = [
+    'ADD',
+    'ALTER COLUMN',
+    'ALTER TABLE',
+    'BEGIN',
+    'CONNECT BY',
+    'DECLARE',
+    'DELETE FROM',
+    'DELETE',
+    'EXCEPT',
+    'EXCEPTION',
+    'FETCH FIRST',
+    'FROM',
+    'GROUP BY',
+    'HAVING',
+    'INSERT INTO',
+    'INSERT',
+    'INTERSECT',
+    'LIMIT',
+    'LOOP',
+    'MODIFY',
+    'ORDER BY',
+    'SELECT',
+    'SET CURRENT SCHEMA',
+    'SET SCHEMA',
+    'SET',
+    'START WITH',
+    'UNION ALL',
+    'UNION',
+    'UPDATE',
+    'VALUES',
+    'WHERE',
+];
+const reservedNewlineWords$1 = [
+    'AND',
+    'CROSS APPLY',
+    'CROSS JOIN',
+    'ELSE',
+    'INNER JOIN',
+    'JOIN',
+    'LEFT JOIN',
+    'LEFT OUTER JOIN',
+    'OR',
+    'OUTER APPLY',
+    'OUTER JOIN',
+    'RIGHT JOIN',
+    'RIGHT OUTER JOIN',
+    'WHEN',
+    'XOR',
+];
+let tokenizer$1;
+/**
+ * Oracle PL/SQL 方言格式化器。
+ */
+class PlSqlFormatter {
+    /**
+     * 初始化 PlSqlFormatter。
+     *
+     * @param {FormatOptions} cfg 格式化配置。
+     */
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    /**
+     * 格式化 PL/SQL 字符串中的空白以提高可读性。
+     *
+     * @param {string} query 原始 PL/SQL 查询字符串。
+     * @returns {string} 格式化后的查询。
+     */
+    format(query) {
+        if (!tokenizer$1) {
+            tokenizer$1 = new Tokenizer({
+                reservedWords: reservedWords$1,
+                reservedToplevelWords: reservedToplevelWords$1,
+                reservedNewlineWords: reservedNewlineWords$1,
+                stringTypes: [`""`, "N''", "''", '``'],
+                openParens: ['(', 'CASE'],
+                closeParens: [')'],
+                keywordBlockStarts: ['BEGIN', 'LOOP'],
+                keywordBlockEnds: ['END'],
+                indexedPlaceholderTypes: ['?'],
+                namedPlaceholderTypes: [':'],
+                lineCommentTypes: ['--'],
+                specialWordChars: ['_', '$', '#', '.', '@'],
+            });
+        }
+        return new Formatter(this.cfg, tokenizer$1).format(query);
+    }
+}
+
+const reservedWords = [
+    'ACCESSIBLE',
+    'ACTION',
+    'AGAINST',
+    'AGGREGATE',
+    'ALGORITHM',
+    'ALL',
+    'ALTER',
+    'ANALYSE',
+    'ANALYZE',
+    'AS',
+    'ASC',
+    'AUTOCOMMIT',
+    'AUTO_INCREMENT',
+    'BACKUP',
+    'BEGIN',
+    'BETWEEN',
+    'BINLOG',
+    'BOTH',
+    'CASCADE',
+    'CASE',
+    'CHANGE',
+    'CHANGED',
+    'CHARACTER SET',
+    'CHARSET',
+    'CHECK',
+    'CHECKSUM',
+    'COLLATE',
+    'COLLATION',
+    'COLUMN',
+    'COLUMNS',
+    'COMMENT',
+    'COMMIT',
+    'COMMITTED',
+    'COMPRESSED',
+    'CONCURRENT',
+    'CONSTRAINT',
+    'CONTAINS',
+    'CONVERT',
+    'CREATE',
+    'CROSS',
+    'CURRENT_TIMESTAMP',
+    'DATABASE',
+    'DATABASES',
+    'DAY',
+    'DAY_HOUR',
+    'DAY_MINUTE',
+    'DAY_SECOND',
+    'DEFAULT',
+    'DEFINER',
+    'DELAYED',
+    'DELETE',
+    'DESC',
+    'DESCRIBE',
+    'DETERMINISTIC',
+    'DISTINCT',
+    'DISTINCTROW',
+    'DIV',
+    'DO',
+    'DROP',
+    'DUMPFILE',
+    'DUPLICATE',
+    'DYNAMIC',
+    'ELSE',
+    'ENCLOSED',
+    'END',
+    'ENGINE',
+    'ENGINES',
+    'ENGINE_TYPE',
+    'ESCAPE',
+    'ESCAPED',
+    'EVENTS',
+    'EXEC',
+    'EXECUTE',
+    'EXISTS',
+    'EXPLAIN',
+    'EXTENDED',
+    'FAST',
+    'FETCH',
+    'FIELDS',
+    'FILE',
+    'FIRST',
+    'FIXED',
+    'FLUSH',
+    'FOR',
+    'FORCE',
+    'FOREIGN',
+    'FULL',
+    'FULLTEXT',
+    'FUNCTION',
+    'GLOBAL',
+    'GRANT',
+    'GRANTS',
+    'GROUP_CONCAT',
+    'HEAP',
+    'HIGH_PRIORITY',
+    'HOSTS',
+    'HOUR',
+    'HOUR_MINUTE',
+    'HOUR_SECOND',
+    'IDENTIFIED',
+    'IF',
+    'IFNULL',
+    'IGNORE',
+    'IN',
+    'INDEX',
+    'INDEXES',
+    'INFILE',
+    'INSERT',
+    'INSERT_ID',
+    'INSERT_METHOD',
+    'INTERVAL',
+    'INTO',
+    'INVOKER',
+    'IS',
+    'ISOLATION',
+    'KEY',
+    'KEYS',
+    'KILL',
+    'LAST_INSERT_ID',
+    'LEADING',
+    'LEVEL',
+    'LIKE',
+    'LINEAR',
+    'LINES',
+    'LOAD',
+    'LOCAL',
+    'LOCK',
+    'LOCKS',
+    'LOGS',
+    'LOW_PRIORITY',
+    'MARIA',
+    'MASTER',
+    'MASTER_CONNECT_RETRY',
+    'MASTER_HOST',
+    'MASTER_LOG_FILE',
+    'MATCH',
+    'MAX_CONNECTIONS_PER_HOUR',
+    'MAX_QUERIES_PER_HOUR',
+    'MAX_ROWS',
+    'MAX_UPDATES_PER_HOUR',
+    'MAX_USER_CONNECTIONS',
+    'MEDIUM',
+    'MERGE',
+    'MINUTE',
+    'MINUTE_SECOND',
+    'MIN_ROWS',
+    'MODE',
+    'MODIFY',
+    'MONTH',
+    'MRG_MYISAM',
+    'MYISAM',
+    'NAMES',
+    'NATURAL',
+    'NOT',
+    'NOW()',
+    'NULL',
+    'OFFSET',
+    'ON DELETE',
+    'ON UPDATE',
+    'ON',
+    'ONLY',
+    'OPEN',
+    'OPTIMIZE',
+    'OPTION',
+    'OPTIONALLY',
+    'OUTFILE',
+    'PACK_KEYS',
+    'PAGE',
+    'PARTIAL',
+    'PARTITION',
+    'PARTITIONS',
+    'PASSWORD',
+    'PRIMARY',
+    'PRIVILEGES',
+    'PROCEDURE',
+    'PROCESS',
+    'PROCESSLIST',
+    'PURGE',
+    'QUICK',
+    'RAID0',
+    'RAID_CHUNKS',
+    'RAID_CHUNKSIZE',
+    'RAID_TYPE',
+    'RANGE',
+    'READ',
+    'READ_ONLY',
+    'READ_WRITE',
+    'REFERENCES',
+    'REGEXP',
+    'RELOAD',
+    'RENAME',
+    'REPAIR',
+    'REPEATABLE',
+    'REPLACE',
+    'REPLICATION',
+    'RESET',
+    'RESTORE',
+    'RESTRICT',
+    'RETURN',
+    'RETURNS',
+    'REVOKE',
+    'RLIKE',
+    'ROLLBACK',
+    'ROW',
+    'ROWS',
+    'ROW_FORMAT',
+    'SECOND',
+    'SECURITY',
+    'SEPARATOR',
+    'SERIALIZABLE',
+    'SESSION',
+    'SHARE',
+    'SHOW',
+    'SHUTDOWN',
+    'SLAVE',
+    'SONAME',
+    'SOUNDS',
+    'SQL',
+    'SQL_AUTO_IS_NULL',
+    'SQL_BIG_RESULT',
+    'SQL_BIG_SELECTS',
+    'SQL_BIG_TABLES',
+    'SQL_BUFFER_RESULT',
+    'SQL_CACHE',
+    'SQL_CALC_FOUND_ROWS',
+    'SQL_LOG_BIN',
+    'SQL_LOG_OFF',
+    'SQL_LOG_UPDATE',
+    'SQL_LOW_PRIORITY_UPDATES',
+    'SQL_MAX_JOIN_SIZE',
+    'SQL_NO_CACHE',
+    'SQL_QUOTE_SHOW_CREATE',
+    'SQL_SAFE_UPDATES',
+    'SQL_SELECT_LIMIT',
+    'SQL_SLAVE_SKIP_COUNTER',
+    'SQL_SMALL_RESULT',
+    'SQL_WARNINGS',
+    'START',
+    'STARTING',
+    'STATUS',
+    'STOP',
+    'STORAGE',
+    'STRAIGHT_JOIN',
+    'STRING',
+    'STRIPED',
+    'SUPER',
+    'TABLE',
+    'TABLES',
+    'TEMPORARY',
+    'TERMINATED',
+    'THEN',
+    'TO',
+    'TRAILING',
+    'TRANSACTIONAL',
+    'TRUE',
+    'TRUNCATE',
+    'TYPE',
+    'TYPES',
+    'UNCOMMITTED',
+    'UNIQUE',
+    'UNLOCK',
+    'UNSIGNED',
+    'USAGE',
+    'USE',
+    'USING',
+    'VARIABLES',
+    'VIEW',
+    'WHEN',
+    'WITH',
+    'WORK',
+    'WRITE',
+    'YEAR_MONTH',
+];
+const reservedToplevelWords = [
+    'ADD',
+    'AFTER',
+    'ALTER COLUMN',
+    'ALTER TABLE',
+    'DELETE FROM',
+    'EXCEPT',
+    'FETCH FIRST',
+    'FROM',
+    'GROUP BY',
+    'GO',
+    'HAVING',
+    'INSERT INTO',
+    'INSERT',
+    'INTERSECT',
+    'LIMIT',
+    'MODIFY',
+    'ORDER BY',
+    'SELECT',
+    'SET CURRENT SCHEMA',
+    'SET SCHEMA',
+    'SET',
+    'UNION ALL',
+    'UNION',
+    'UPDATE',
+    'VALUES',
+    'WHERE',
+];
+const reservedNewlineWords = [
+    'AND',
+    'CROSS APPLY',
+    'CROSS JOIN',
+    'ELSE',
+    'INNER JOIN',
+    'JOIN',
+    'LEFT JOIN',
+    'LEFT OUTER JOIN',
+    'OR',
+    'OUTER APPLY',
+    'OUTER JOIN',
+    'RIGHT JOIN',
+    'RIGHT OUTER JOIN',
+    'WHEN',
+    'XOR',
+];
+let tokenizer;
+/**
+ * 标准 SQL 方言格式化器。
+ */
+class StandardSqlFormatter {
+    /**
+     * 初始化 StandardSqlFormatter。
+     *
+     * @param {FormatOptions} cfg 格式化配置。
+     */
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    /**
+     * 格式化标准 SQL 字符串中的空白以提高可读性。
+     *
+     * @param {string} query 原始标准 SQL 查询字符串。
+     * @returns {string} 格式化后的查询。
+     */
+    format(query) {
+        if (!tokenizer) {
+            tokenizer = new Tokenizer({
+                reservedWords,
+                reservedToplevelWords,
+                reservedNewlineWords,
+                stringTypes: [`""`, "N''", "''", '``', '[]'],
+                openParens: ['(', 'CASE'],
+                closeParens: [')', 'END'],
+                indexedPlaceholderTypes: ['?'],
+                namedPlaceholderTypes: ['@', ':'],
+                lineCommentTypes: ['#', '--'],
+            });
+        }
+        return new Formatter(this.cfg, tokenizer).format(query);
+    }
+}
+
+/**
+ * 格式化 SQL 查询字符串以提高其可读性。
+ *
+ * 根据提供的配置选项，分发给标准 SQL 或特定方言的格式化器（db2、n1ql、pl/sql）。
+ *
+ * @param {string} query 要格式化的 SQL 查询字符串。
+ * @param {FormatOptions} [cfg={}] 格式化配置选项。
+ * @returns {string} 格式化后的 SQL 查询。
+ * @throws {Error} 如果配置中指定了不支持的 SQL 方言，则抛出错误。
+ */
+function format(query, cfg = {}) {
+    switch (cfg.language) {
+        case 'db2':
+            return new Db2Formatter(cfg).format(query);
+        case 'n1ql':
+            return new N1qlFormatter(cfg).format(query);
+        case 'pl/sql':
+            return new PlSqlFormatter(cfg).format(query);
+        case 'sql':
+        case undefined:
+            return new StandardSqlFormatter(cfg).format(query);
+        default:
+            throw Error(`Unsupported SQL dialect: ${String(cfg.language)}`);
+    }
+}
+/**
+ * 默认导出，提供 SQL 格式化函数。
+ */
+const sqlFormatter = {
+    format,
+};
+
+export { sqlFormatter as default, format };