sql-format-plus 0.0.1

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

@@ -0,0 +1,2440 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SqlFormatPlus = {}));
+})(this, (function (exports) { 'use strict';
+
+    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,
+    };
+
+    exports.default = sqlFormatter;
+    exports.format = format;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));