lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.24.mjs

@@ -1,6 +1,999 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-function r(r) {
-    throw new Error('Could not dynamically require "' + r + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { c as e } from "./Package.internal.8.mjs";
 
-export { r as c };
+var E = {};
+
+var t = {};
+
+var T = {};
+
+var r = {};
+
+var n = {};
+
+(function(e) {
+    e.__esModule = true;
+    var E = /[\\^$.*+?()[\]{}|]/g;
+    var t = RegExp(E.source);
+    function T(e) {
+        return e && t.test(e) ? e.replace(E, "\\$&") : e || "";
+    }
+    e["default"] = T;
+})(n);
+
+var R = {};
+
+(function(e) {
+    e.__esModule = true;
+    e.TokenTypes = void 0;
+    (function(e) {
+        e["WHITESPACE"] = "whitespace";
+        e["WORD"] = "word";
+        e["STRING"] = "string";
+        e["RESERVED"] = "reserved";
+        e["RESERVED_TOP_LEVEL"] = "reserved-top-level";
+        e["RESERVED_TOP_LEVEL_NO_INDENT"] = "reserved-top-level-no-indent";
+        e["RESERVED_NEWLINE"] = "reserved-newline";
+        e["OPERATOR"] = "operator";
+        e["NO_SPACE_OPERATOR"] = "no-space-operator";
+        e["OPEN_PAREN"] = "open-paren";
+        e["CLOSE_PAREN"] = "close-paren";
+        e["LINE_COMMENT"] = "line-comment";
+        e["BLOCK_COMMENT"] = "block-comment";
+        e["NUMBER"] = "number";
+        e["PLACEHOLDER"] = "placeholder";
+        e["SERVERVARIABLE"] = "servervariable";
+    })(e.TokenTypes || (e.TokenTypes = {}));
+})(R);
+
+(function(E) {
+    var t = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var T = t(n);
+    var r = R;
+    var o = function() {
+        function e(e) {
+            this.WHITESPACE_REGEX = /^(\s+)/u;
+            this.NUMBER_REGEX = /^((-\s*)?[0-9]+(\.[0-9]+)?|0x[0-9a-fA-F]+|0b[01]+|([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}))\b/u;
+            this.AMBIGUOS_OPERATOR_REGEX = /^(\?\||\?&)/u;
+            this.OPERATOR_REGEX = /^(!=|<>|>>|<<|==|<=|>=|!<|!>|\|\|\/|\|\/|\|\||~~\*|~~|!~~\*|!~~|~\*|!~\*|!~|:=|=>|&&|@>|<@|#-|@@|@|.)/u;
+            this.NO_SPACE_OPERATOR_REGEX = /^(::|->>|->|#>>|#>)/u;
+            this.BLOCK_COMMENT_REGEX = /^(\/\*[^]*?(?:\*\/|$))/u;
+            this.LINE_COMMENT_REGEX = this.createLineCommentRegex(e.lineCommentTypes);
+            this.RESERVED_TOP_LEVEL_REGEX = this.createReservedWordRegex(e.reservedTopLevelWords);
+            this.RESERVED_TOP_LEVEL_NO_INDENT_REGEX = this.createReservedWordRegex(e.reservedTopLevelWordsNoIndent);
+            this.RESERVED_NEWLINE_REGEX = this.createReservedWordRegex(e.reservedNewlineWords);
+            this.RESERVED_PLAIN_REGEX = this.createReservedWordRegex(e.reservedWords);
+            this.WORD_REGEX = this.createWordRegex(e.specialWordChars);
+            this.STRING_REGEX = this.createStringRegex(e.stringTypes);
+            this.OPEN_PAREN_REGEX = this.createParenRegex(e.openParens);
+            this.CLOSE_PAREN_REGEX = this.createParenRegex(e.closeParens);
+            this.INDEXED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(e.indexedPlaceholderTypes, "[0-9]*");
+            this.IDENT_NAMED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(e.namedPlaceholderTypes, "[a-zA-Z0-9._$]+");
+            this.STRING_NAMED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(e.namedPlaceholderTypes, this.createStringPattern(e.stringTypes));
+        }
+        e.prototype.createLineCommentRegex = function(e) {
+            var E = "((?<!#)>|(?:[^>]))";
+            return new RegExp("^((?:".concat(e.map(function(e) {
+                return (0, T["default"])(e);
+            }).join("|"), ")").concat(E, ".*?(?:\r\n|\r|\n|$))"), "u");
+        };
+        e.prototype.createReservedWordRegex = function(e) {
+            var E = e.join("|").replace(/ /gu, "\\s+");
+            return new RegExp("^(".concat(E, ")\\b"), "iu");
+        };
+        e.prototype.createWordRegex = function(e) {
+            return new RegExp("^([\\p{Alphabetic}\\p{Mark}\\p{Decimal_Number}\\p{Connector_Punctuation}\\p{Join_Control}".concat(e.join(""), "]+)"), "u");
+        };
+        e.prototype.createStringRegex = function(e) {
+            return new RegExp("^(" + this.createStringPattern(e) + ")", "u");
+        };
+        e.prototype.createStringPattern = function(e) {
+            var E = {
+                "``": "((`[^`]*($|`))+)",
+                "[]": "((\\[[^\\]]*($|\\]))(\\][^\\]]*($|\\]))*)",
+                '""': '(("[^"\\\\]*(?:\\\\.[^"\\\\]*)*("|$))+)',
+                "''": "(('[^'\\\\]*(?:\\\\.[^'\\\\]*)*('|$))+)",
+                "N''": "((N'[^N'\\\\]*(?:\\\\.[^N'\\\\]*)*('|$))+)",
+                "E''": "(((E|e)'[^'\\\\]*(?:\\\\.[^'\\\\]*)*('|$))+)"
+            };
+            return e.map(function(e) {
+                return E[e];
+            }).join("|");
+        };
+        e.prototype.createParenRegex = function(e) {
+            var E = this;
+            return new RegExp("^(" + e.map(function(e) {
+                return E.escapeParen(e);
+            }).join("|") + ")", "iu");
+        };
+        e.prototype.escapeParen = function(e) {
+            if (e.length === 1) {
+                return (0, T["default"])(e);
+            } else {
+                return "\\b" + e + "\\b";
+            }
+        };
+        e.prototype.createPlaceholderRegex = function(e, E) {
+            if (!e || e.length === 0) {
+                return null;
+            }
+            var t = e.map(T["default"]).join("|");
+            return new RegExp("^((?:".concat(t, ")(?:").concat(E, "))"), "u");
+        };
+        e.prototype.tokenize = function(e) {
+            if (!e) return [];
+            var E = [];
+            var t;
+            while (e.length) {
+                t = this.getNextToken(e, t);
+                e = e.substring(t.value.length);
+                E.push(t);
+            }
+            return E;
+        };
+        e.prototype.getNextToken = function(e, E) {
+            return this.getWhitespaceToken(e) || this.getCommentToken(e) || this.getStringToken(e) || this.getOpenParenToken(e) || this.getCloseParenToken(e) || this.getAmbiguosOperatorToken(e) || this.getNoSpaceOperatorToken(e) || this.getServerVariableToken(e) || this.getPlaceholderToken(e) || this.getNumberToken(e) || this.getReservedWordToken(e, E) || this.getWordToken(e) || this.getOperatorToken(e);
+        };
+        e.prototype.getWhitespaceToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.WHITESPACE,
+                regex: this.WHITESPACE_REGEX
+            });
+        };
+        e.prototype.getCommentToken = function(e) {
+            return this.getLineCommentToken(e) || this.getBlockCommentToken(e);
+        };
+        e.prototype.getLineCommentToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.LINE_COMMENT,
+                regex: this.LINE_COMMENT_REGEX
+            });
+        };
+        e.prototype.getBlockCommentToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.BLOCK_COMMENT,
+                regex: this.BLOCK_COMMENT_REGEX
+            });
+        };
+        e.prototype.getStringToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.STRING,
+                regex: this.STRING_REGEX
+            });
+        };
+        e.prototype.getOpenParenToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.OPEN_PAREN,
+                regex: this.OPEN_PAREN_REGEX
+            });
+        };
+        e.prototype.getCloseParenToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.CLOSE_PAREN,
+                regex: this.CLOSE_PAREN_REGEX
+            });
+        };
+        e.prototype.getPlaceholderToken = function(e) {
+            return this.getIdentNamedPlaceholderToken(e) || this.getStringNamedPlaceholderToken(e) || this.getIndexedPlaceholderToken(e);
+        };
+        e.prototype.getServerVariableToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.SERVERVARIABLE,
+                regex: /(^@@\w+)/iu
+            });
+        };
+        e.prototype.getIdentNamedPlaceholderToken = function(e) {
+            return this.getPlaceholderTokenWithKey({
+                input: e,
+                regex: this.IDENT_NAMED_PLACEHOLDER_REGEX,
+                parseKey: function(e) {
+                    return e.slice(1);
+                }
+            });
+        };
+        e.prototype.getStringNamedPlaceholderToken = function(e) {
+            var E = this;
+            return this.getPlaceholderTokenWithKey({
+                input: e,
+                regex: this.STRING_NAMED_PLACEHOLDER_REGEX,
+                parseKey: function(e) {
+                    return E.getEscapedPlaceholderKey({
+                        key: e.slice(2, -1),
+                        quoteChar: e.slice(-1)
+                    });
+                }
+            });
+        };
+        e.prototype.getIndexedPlaceholderToken = function(e) {
+            return this.getPlaceholderTokenWithKey({
+                input: e,
+                regex: this.INDEXED_PLACEHOLDER_REGEX,
+                parseKey: function(e) {
+                    return e.slice(1);
+                }
+            });
+        };
+        e.prototype.getPlaceholderTokenWithKey = function(e) {
+            var E = e.input, t = e.regex, T = e.parseKey;
+            var n = this.getTokenOnFirstMatch({
+                input: E,
+                regex: t,
+                type: r.TokenTypes.PLACEHOLDER
+            });
+            if (n) {
+                n.key = T(n.value);
+            }
+            return n;
+        };
+        e.prototype.getEscapedPlaceholderKey = function(e) {
+            var E = e.key, t = e.quoteChar;
+            return E.replace(new RegExp((0, T["default"])("\\" + t), "gu"), t);
+        };
+        e.prototype.getNumberToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.NUMBER,
+                regex: this.NUMBER_REGEX
+            });
+        };
+        e.prototype.getOperatorToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.OPERATOR,
+                regex: this.OPERATOR_REGEX
+            });
+        };
+        e.prototype.getAmbiguosOperatorToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.OPERATOR,
+                regex: this.AMBIGUOS_OPERATOR_REGEX
+            });
+        };
+        e.prototype.getNoSpaceOperatorToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.NO_SPACE_OPERATOR,
+                regex: this.NO_SPACE_OPERATOR_REGEX
+            });
+        };
+        e.prototype.getReservedWordToken = function(e, E) {
+            if (E && E.value && E.value === ".") {
+                return;
+            }
+            return this.getToplevelReservedToken(e) || this.getNewlineReservedToken(e) || this.getTopLevelReservedTokenNoIndent(e) || this.getPlainReservedToken(e);
+        };
+        e.prototype.getToplevelReservedToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.RESERVED_TOP_LEVEL,
+                regex: this.RESERVED_TOP_LEVEL_REGEX
+            });
+        };
+        e.prototype.getNewlineReservedToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.RESERVED_NEWLINE,
+                regex: this.RESERVED_NEWLINE_REGEX
+            });
+        };
+        e.prototype.getPlainReservedToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.RESERVED,
+                regex: this.RESERVED_PLAIN_REGEX
+            });
+        };
+        e.prototype.getTopLevelReservedTokenNoIndent = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT,
+                regex: this.RESERVED_TOP_LEVEL_NO_INDENT_REGEX
+            });
+        };
+        e.prototype.getWordToken = function(e) {
+            return this.getTokenOnFirstMatch({
+                input: e,
+                type: r.TokenTypes.WORD,
+                regex: this.WORD_REGEX
+            });
+        };
+        e.prototype.getTokenOnFirstMatch = function(e) {
+            var E = e.input, t = e.type, T = e.regex;
+            var r = E.match(T);
+            if (r) {
+                return {
+                    type: t,
+                    value: r[1]
+                };
+            }
+        };
+        return e;
+    }();
+    E["default"] = o;
+})(r);
+
+var o = {};
+
+var N = {};
+
+var A = {};
+
+(function(e) {
+    e.__esModule = true;
+    var E = function(e) {
+        if (e === void 0) {
+            e = [];
+        }
+        return e[e.length - 1];
+    };
+    e["default"] = E;
+})(A);
+
+(function(E) {
+    var t = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var T = t(A);
+    var r = "top-level";
+    var n = "block-level";
+    var R = function() {
+        function e(e) {
+            this.indent = e;
+            this.indentTypes = [];
+            this.indent = e || "  ";
+        }
+        e.prototype.getIndent = function() {
+            return new Array(this.indentTypes.length).fill(this.indent).join("");
+        };
+        e.prototype.increaseTopLevel = function() {
+            this.indentTypes.push(r);
+        };
+        e.prototype.increaseBlockLevel = function() {
+            this.indentTypes.push(n);
+        };
+        e.prototype.decreaseTopLevel = function() {
+            if ((0, T["default"])(this.indentTypes) === r) {
+                this.indentTypes.pop();
+            }
+        };
+        e.prototype.decreaseBlockLevel = function() {
+            while (this.indentTypes.length > 0) {
+                var e = this.indentTypes.pop();
+                if (e !== r) {
+                    break;
+                }
+            }
+        };
+        e.prototype.resetIndentation = function() {
+            this.indentTypes = [];
+        };
+        return e;
+    }();
+    E["default"] = R;
+})(N);
+
+var I = {};
+
+(function(e) {
+    e.__esModule = true;
+    var E = R;
+    var t = 50;
+    var T = function() {
+        function e() {
+            this.level = 0;
+        }
+        e.prototype.beginIfPossible = function(e, E) {
+            if (this.level === 0 && this.isInlineBlock(e, E)) {
+                this.level = 1;
+            } else if (this.level > 0) {
+                this.level++;
+            } else {
+                this.level = 0;
+            }
+        };
+        e.prototype.end = function() {
+            this.level--;
+        };
+        e.prototype.isActive = function() {
+            return this.level > 0;
+        };
+        e.prototype.isInlineBlock = function(e, T) {
+            var r = 0;
+            var n = 0;
+            for (var R = T; R < e.length; R++) {
+                var o = e[R];
+                r += o.value.length;
+                if (r > t) {
+                    return false;
+                }
+                if (o.type === E.TokenTypes.OPEN_PAREN) {
+                    n++;
+                } else if (o.type === E.TokenTypes.CLOSE_PAREN) {
+                    n--;
+                    if (n === 0) {
+                        return true;
+                    }
+                }
+                if (this.isForbiddenToken(o)) {
+                    return false;
+                }
+            }
+            return false;
+        };
+        e.prototype.isForbiddenToken = function(e) {
+            var t = e.type, T = e.value;
+            return t === E.TokenTypes.RESERVED_TOP_LEVEL || t === E.TokenTypes.RESERVED_NEWLINE || t === E.TokenTypes.LINE_COMMENT || t === E.TokenTypes.BLOCK_COMMENT || T === ";";
+        };
+        return e;
+    }();
+    e["default"] = T;
+})(I);
+
+var O = {};
+
+(function(e) {
+    e.__esModule = true;
+    var E = function() {
+        function e(e) {
+            this.params = e;
+            this.index = 0;
+            this.params = e;
+        }
+        e.prototype.get = function(e) {
+            var E = e.key, t = e.value;
+            if (!this.params) {
+                return t;
+            }
+            if (E) {
+                return this.params[E];
+            }
+            return this.params[this.index++];
+        };
+        return e;
+    }();
+    e["default"] = E;
+})(O);
+
+(function(E) {
+    var t = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var T = R;
+    var r = t(N);
+    var n = t(I);
+    var o = t(O);
+    var A = [ " ", "\t" ];
+    var i = function(e) {
+        var E = e.length - 1;
+        while (E >= 0 && A.includes(e[E])) {
+            E--;
+        }
+        return e.substring(0, E + 1);
+    };
+    var S = function() {
+        function e(e, E, t) {
+            this.cfg = e;
+            this.tokenizer = E;
+            this.tokenOverride = t;
+            this.tokens = [];
+            this.previousReservedWord = {
+                type: null,
+                value: null
+            };
+            this.previousNonWhiteSpace = {
+                type: null,
+                value: null
+            };
+            this.index = 0;
+            this.indentation = new r["default"](this.cfg.indent);
+            this.inlineBlock = new n["default"];
+            this.params = new o["default"](this.cfg.params);
+        }
+        e.prototype.format = function(e) {
+            this.tokens = this.tokenizer.tokenize(e);
+            var E = this.getFormattedQueryFromTokens();
+            return E.trim();
+        };
+        e.prototype.getFormattedQueryFromTokens = function() {
+            var e = this;
+            var E = "";
+            this.tokens.forEach(function(t, r) {
+                e.index = r;
+                if (e.tokenOverride) t = e.tokenOverride(t, e.previousReservedWord) || t;
+                if (t.type === T.TokenTypes.WHITESPACE) {
+                    E = e.formatWhitespace(t, E);
+                } else if (t.type === T.TokenTypes.LINE_COMMENT) {
+                    E = e.formatLineComment(t, E);
+                } else if (t.type === T.TokenTypes.BLOCK_COMMENT) {
+                    E = e.formatBlockComment(t, E);
+                } else if (t.type === T.TokenTypes.RESERVED_TOP_LEVEL || t.type === T.TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT || t.type === T.TokenTypes.RESERVED_NEWLINE || t.type === T.TokenTypes.RESERVED) {
+                    E = e.formatReserved(t, E);
+                } else if (t.type === T.TokenTypes.OPEN_PAREN) {
+                    E = e.formatOpeningParentheses(t, E);
+                } else if (t.type === T.TokenTypes.CLOSE_PAREN) {
+                    E = e.formatClosingParentheses(t, E);
+                } else if (t.type === T.TokenTypes.NO_SPACE_OPERATOR) {
+                    E = e.formatWithoutSpaces(t, E);
+                } else if (t.type === T.TokenTypes.PLACEHOLDER || t.type === T.TokenTypes.SERVERVARIABLE) {
+                    E = e.formatPlaceholder(t, E);
+                } else if (t.value === ",") {
+                    E = e.formatComma(t, E);
+                } else if (t.value === ":") {
+                    E = e.formatWithSpaceAfter(t, E);
+                } else if (t.value === ".") {
+                    E = e.formatWithoutSpaces(t, E);
+                } else if (t.value === ";") {
+                    E = e.formatQuerySeparator(t, E);
+                } else {
+                    E = e.formatWithSpaces(t, E);
+                }
+                if (t.type !== T.TokenTypes.WHITESPACE) {
+                    e.previousNonWhiteSpace = t;
+                }
+            });
+            return E;
+        };
+        e.prototype.formatWhitespace = function(e, E) {
+            if (this.cfg.linesBetweenQueries === "preserve" && /((\r\n|\n)(\r\n|\n)+)/u.test(e.value) && this.previousToken().value === ";") {
+                return E.replace(/(\n|\r\n)$/u, "") + e.value;
+            }
+            return E;
+        };
+        e.prototype.formatReserved = function(e, E) {
+            if (e.type === T.TokenTypes.RESERVED_NEWLINE && this.previousReservedWord && this.previousReservedWord.value && e.value.toUpperCase() === "AND" && this.previousReservedWord.value.toUpperCase() === "BETWEEN") {
+                e.type = T.TokenTypes.RESERVED;
+            }
+            if (e.type === T.TokenTypes.RESERVED_TOP_LEVEL) {
+                E = this.formatTopLevelReservedWord(e, E);
+            } else if (e.type === T.TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT) {
+                E = this.formatTopLevelReservedWordNoIndent(e, E);
+            } else if (e.type === T.TokenTypes.RESERVED_NEWLINE) {
+                E = this.formatNewlineReservedWord(e, E);
+            } else {
+                E = this.formatWithSpaces(e, E);
+            }
+            this.previousReservedWord = e;
+            return E;
+        };
+        e.prototype.formatLineComment = function(e, E) {
+            return this.addNewline(E + e.value);
+        };
+        e.prototype.formatBlockComment = function(e, E) {
+            return this.addNewline(this.addNewline(E) + this.indentComment(e.value));
+        };
+        e.prototype.indentComment = function(e) {
+            return e.replace(/\n[ \t]*/gu, "\n" + this.indentation.getIndent() + " ");
+        };
+        e.prototype.formatTopLevelReservedWordNoIndent = function(e, E) {
+            this.indentation.decreaseTopLevel();
+            E = this.addNewline(E) + this.equalizeWhitespace(this.formatReservedWord(e.value));
+            return this.addNewline(E);
+        };
+        e.prototype.formatTopLevelReservedWord = function(e, E) {
+            var t = this.previousNonWhiteSpace.value !== "," && ![ "GRANT" ].includes("".concat(this.previousNonWhiteSpace.value).toUpperCase());
+            if (t) {
+                this.indentation.decreaseTopLevel();
+                E = this.addNewline(E);
+            }
+            E = E + this.equalizeWhitespace(this.formatReservedWord(e.value)) + " ";
+            if (t) this.indentation.increaseTopLevel();
+            return E;
+        };
+        e.prototype.formatNewlineReservedWord = function(e, E) {
+            return this.addNewline(E) + this.equalizeWhitespace(this.formatReservedWord(e.value)) + " ";
+        };
+        e.prototype.equalizeWhitespace = function(e) {
+            return e.replace(/\s+/gu, " ");
+        };
+        e.prototype.formatOpeningParentheses = function(e, E) {
+            e.value = this.formatCase(e.value);
+            var t = this.previousToken().type;
+            if (t !== T.TokenTypes.WHITESPACE && t !== T.TokenTypes.OPEN_PAREN && t !== T.TokenTypes.LINE_COMMENT) {
+                E = i(E);
+            }
+            E += e.value;
+            this.inlineBlock.beginIfPossible(this.tokens, this.index);
+            if (!this.inlineBlock.isActive()) {
+                this.indentation.increaseBlockLevel();
+                E = this.addNewline(E);
+            }
+            return E;
+        };
+        e.prototype.formatClosingParentheses = function(e, E) {
+            e.value = this.formatCase(e.value);
+            if (this.inlineBlock.isActive()) {
+                this.inlineBlock.end();
+                return this.formatWithSpaceAfter(e, E);
+            } else {
+                this.indentation.decreaseBlockLevel();
+                return this.formatWithSpaces(e, this.addNewline(E));
+            }
+        };
+        e.prototype.formatPlaceholder = function(e, E) {
+            return E + this.params.get(e) + " ";
+        };
+        e.prototype.formatComma = function(e, E) {
+            E = i(E) + e.value + " ";
+            if (this.inlineBlock.isActive()) {
+                return E;
+            } else if (/^LIMIT$/iu.test(this.previousReservedWord.value)) {
+                return E;
+            } else {
+                return this.addNewline(E);
+            }
+        };
+        e.prototype.formatWithSpaceAfter = function(e, E) {
+            return i(E) + e.value + " ";
+        };
+        e.prototype.formatWithoutSpaces = function(e, E) {
+            return i(E) + e.value;
+        };
+        e.prototype.formatWithSpaces = function(e, E) {
+            var t = e.type === T.TokenTypes.RESERVED ? this.formatReservedWord(e.value) : e.value;
+            return E + t + " ";
+        };
+        e.prototype.formatReservedWord = function(e) {
+            return this.formatCase(e);
+        };
+        e.prototype.formatQuerySeparator = function(e, E) {
+            this.indentation.resetIndentation();
+            var t = "\n";
+            if (this.cfg.linesBetweenQueries !== "preserve") {
+                t = "\n".repeat(this.cfg.linesBetweenQueries || 1);
+            }
+            return i(E) + e.value + t;
+        };
+        e.prototype.addNewline = function(e) {
+            e = i(e);
+            if (!e.endsWith("\n")) e += "\n";
+            return e + this.indentation.getIndent();
+        };
+        e.prototype.previousToken = function() {
+            return this.tokens[this.index - 1] || {
+                type: null,
+                value: null
+            };
+        };
+        e.prototype.formatCase = function(e) {
+            if (this.cfg.reservedWordCase === "upper") return e.toUpperCase();
+            if (this.cfg.reservedWordCase === "lower") return e.toLowerCase();
+            return e;
+        };
+        return e;
+    }();
+    E["default"] = S;
+})(o);
+
+(function(E) {
+    var t = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var T = t(r);
+    var n = t(o);
+    var R = function() {
+        function e(e) {
+            this.cfg = e;
+        }
+        e.prototype.format = function(e) {
+            return new n["default"](this.cfg, this.tokenizer(), this.tokenOverride).format(e);
+        };
+        e.prototype.tokenize = function(e) {
+            return this.tokenizer().tokenize(e);
+        };
+        e.prototype.tokenizer = function() {
+            return new T["default"](this.getTokenizerConfig());
+        };
+        return e;
+    }();
+    E["default"] = R;
+})(T);
+
+(function(E) {
+    var t = e && e.__extends || function() {
+        var e = function(E, t) {
+            e = Object.setPrototypeOf || {
+                __proto__: []
+            } instanceof Array && function(e, E) {
+                e.__proto__ = E;
+            } || function(e, E) {
+                for (var t in E) if (Object.prototype.hasOwnProperty.call(E, t)) e[t] = E[t];
+            };
+            return e(E, t);
+        };
+        return function(E, t) {
+            if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+            e(E, t);
+            function T() {
+                this.constructor = E;
+            }
+            E.prototype = t === null ? Object.create(t) : (T.prototype = t.prototype, new T);
+        };
+    }();
+    var r = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var n = r(T);
+    var R = function(e) {
+        t(E, e);
+        function E() {
+            return e !== null && e.apply(this, arguments) || this;
+        }
+        E.prototype.getTokenizerConfig = function() {
+            return {
+                reservedWords: o,
+                reservedTopLevelWords: N,
+                reservedNewlineWords: I,
+                reservedTopLevelWordsNoIndent: A,
+                stringTypes: [ '""', "''", "``", "[]" ],
+                openParens: [ "(" ],
+                closeParens: [ ")" ],
+                indexedPlaceholderTypes: [ "?" ],
+                namedPlaceholderTypes: [ ":" ],
+                lineCommentTypes: [ "--" ],
+                specialWordChars: [ "#", "@" ]
+            };
+        };
+        return E;
+    }(n["default"]);
+    E["default"] = R;
+    var o = [ "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" ];
+    var N = [ "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", "UPDATE", "VALUES", "WHERE" ];
+    var A = [ "INTERSECT", "INTERSECT ALL", "MINUS", "UNION", "UNION ALL" ];
+    var I = [ "AND", "CROSS JOIN", "INNER JOIN", "JOIN", "LEFT JOIN", "LEFT OUTER JOIN", "OR", "OUTER JOIN", "RIGHT JOIN", "RIGHT OUTER JOIN" ];
+})(t);
+
+var i = {};
+
+(function(E) {
+    var t = e && e.__extends || function() {
+        var e = function(E, t) {
+            e = Object.setPrototypeOf || {
+                __proto__: []
+            } instanceof Array && function(e, E) {
+                e.__proto__ = E;
+            } || function(e, E) {
+                for (var t in E) if (Object.prototype.hasOwnProperty.call(E, t)) e[t] = E[t];
+            };
+            return e(E, t);
+        };
+        return function(E, t) {
+            if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+            e(E, t);
+            function T() {
+                this.constructor = E;
+            }
+            E.prototype = t === null ? Object.create(t) : (T.prototype = t.prototype, new T);
+        };
+    }();
+    var r = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var n = r(T);
+    var R = function(e) {
+        t(E, e);
+        function E() {
+            return e !== null && e.apply(this, arguments) || this;
+        }
+        E.prototype.getTokenizerConfig = function() {
+            return {
+                reservedWords: o,
+                reservedTopLevelWords: N,
+                reservedNewlineWords: I,
+                reservedTopLevelWordsNoIndent: A,
+                stringTypes: [ '""', "''", "``" ],
+                openParens: [ "(", "[", "{" ],
+                closeParens: [ ")", "]", "}" ],
+                namedPlaceholderTypes: [ "$" ],
+                lineCommentTypes: [ "#", "--" ],
+                specialWordChars: []
+            };
+        };
+        return E;
+    }(n["default"]);
+    E["default"] = R;
+    var o = [ "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", "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" ];
+    var N = [ "DELETE FROM", "EXCEPT ALL", "EXCEPT", "EXPLAIN DELETE FROM", "EXPLAIN UPDATE", "EXPLAIN UPSERT", "FROM", "GROUP BY", "HAVING", "INFER", "INSERT INTO", "LET", "LIMIT", "MERGE", "NEST", "ORDER BY", "PREPARE", "SELECT", "SET CURRENT SCHEMA", "SET SCHEMA", "SET", "UNNEST", "UPDATE", "UPSERT", "USE KEYS", "VALUES", "WHERE" ];
+    var A = [ "INTERSECT", "INTERSECT ALL", "MINUS", "UNION", "UNION ALL" ];
+    var I = [ "AND", "INNER JOIN", "JOIN", "LEFT JOIN", "LEFT OUTER JOIN", "OR", "OUTER JOIN", "RIGHT JOIN", "RIGHT OUTER JOIN", "XOR" ];
+})(i);
+
+var S = {};
+
+(function(E) {
+    var t = e && e.__extends || function() {
+        var e = function(E, t) {
+            e = Object.setPrototypeOf || {
+                __proto__: []
+            } instanceof Array && function(e, E) {
+                e.__proto__ = E;
+            } || function(e, E) {
+                for (var t in E) if (Object.prototype.hasOwnProperty.call(E, t)) e[t] = E[t];
+            };
+            return e(E, t);
+        };
+        return function(E, t) {
+            if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+            e(E, t);
+            function T() {
+                this.constructor = E;
+            }
+            E.prototype = t === null ? Object.create(t) : (T.prototype = t.prototype, new T);
+        };
+    }();
+    var r = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var n = r(T);
+    var o = R;
+    var N = function(e) {
+        t(E, e);
+        function E() {
+            var E = e !== null && e.apply(this, arguments) || this;
+            E.tokenOverride = function(e, E) {
+                if (e.type === o.TokenTypes.RESERVED_TOP_LEVEL && E.value && e.value.toUpperCase() === "SET" && E.value.toUpperCase() === "BY") {
+                    e.type = o.TokenTypes.RESERVED;
+                    return e;
+                }
+            };
+            return E;
+        }
+        E.prototype.getTokenizerConfig = function() {
+            return {
+                reservedWords: A,
+                reservedTopLevelWords: I,
+                reservedNewlineWords: i,
+                reservedTopLevelWordsNoIndent: O,
+                stringTypes: [ '""', "N''", "''", "``" ],
+                openParens: [ "(", "CASE" ],
+                closeParens: [ ")", "END" ],
+                indexedPlaceholderTypes: [ "?" ],
+                namedPlaceholderTypes: [ ":" ],
+                lineCommentTypes: [ "--" ],
+                specialWordChars: [ "_", "$", "#", ".", "@" ]
+            };
+        };
+        return E;
+    }(n["default"]);
+    E["default"] = N;
+    var A = [ "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", "BREADTH", "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", "DEPTH", "DESC", "DETERMINISTIC", "DIRECTORY", "DISTINCT", "DO", "DOUBLE", "DROP", "DURATION", "ELEMENT", "ELSIF", "EMPTY", "END", "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", "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", "SEARCH", "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" ];
+    var I = [ "ADD", "ALTER COLUMN", "ALTER TABLE", "BEGIN", "CONNECT BY", "DECLARE", "DELETE FROM", "DELETE", "END", "EXCEPT", "EXCEPTION", "FETCH FIRST", "FROM", "GROUP BY", "HAVING", "INSERT INTO", "INSERT", "LIMIT", "LOOP", "MODIFY", "ORDER BY", "SELECT", "SET CURRENT SCHEMA", "SET SCHEMA", "SET", "START WITH", "UPDATE", "VALUES", "WHERE" ];
+    var O = [ "INTERSECT", "INTERSECT ALL", "MINUS", "UNION", "UNION ALL" ];
+    var i = [ "AND", "CROSS APPLY", "CROSS JOIN", "ELSE", "END", "INNER JOIN", "JOIN", "LEFT JOIN", "LEFT OUTER JOIN", "OR", "OUTER APPLY", "OUTER JOIN", "RIGHT JOIN", "RIGHT OUTER JOIN", "WHEN", "XOR" ];
+})(S);
+
+var L = {};
+
+(function(E) {
+    var t = e && e.__extends || function() {
+        var e = function(E, t) {
+            e = Object.setPrototypeOf || {
+                __proto__: []
+            } instanceof Array && function(e, E) {
+                e.__proto__ = E;
+            } || function(e, E) {
+                for (var t in E) if (Object.prototype.hasOwnProperty.call(E, t)) e[t] = E[t];
+            };
+            return e(E, t);
+        };
+        return function(E, t) {
+            if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+            e(E, t);
+            function T() {
+                this.constructor = E;
+            }
+            E.prototype = t === null ? Object.create(t) : (T.prototype = t.prototype, new T);
+        };
+    }();
+    var r = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    var n = r(T);
+    var R = function(e) {
+        t(E, e);
+        function E() {
+            return e !== null && e.apply(this, arguments) || this;
+        }
+        E.prototype.getTokenizerConfig = function() {
+            return {
+                reservedWords: o,
+                reservedTopLevelWords: N,
+                reservedNewlineWords: I,
+                reservedTopLevelWordsNoIndent: A,
+                stringTypes: [ '""', "N''", "''", "``", "[]", "E''" ],
+                openParens: [ "(", "CASE" ],
+                closeParens: [ ")", "END" ],
+                indexedPlaceholderTypes: [ "?" ],
+                namedPlaceholderTypes: [ "@", ":", "%", "$" ],
+                lineCommentTypes: [ "#", "--" ],
+                specialWordChars: []
+            };
+        };
+        return E;
+    }(n["default"]);
+    E["default"] = R;
+    var o = [ "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", "COUNT", "CREATE", "CROSS", "CURRENT_TIMESTAMP", "DATABASE", "DATABASES", "DAY_HOUR", "DAY_MINUTE", "DAY_SECOND", "DAY", "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", "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", "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", "TRIGGER", "TRUE", "TRUNCATE", "TYPE", "TYPES", "UNCOMMITTED", "UNIQUE", "UNLOCK", "UNSIGNED", "USAGE", "USE", "USING", "VARIABLES", "VIEW", "WHEN", "WITH", "WORK", "WRITE", "YEAR_MONTH" ];
+    var N = [ "ADD", "AFTER", "ALTER COLUMN", "ALTER TABLE", "CREATE OR REPLACE", "DECLARE", "DELETE FROM", "EXCEPT", "FETCH FIRST", "FROM", "GO", "GRANT", "GROUP BY", "HAVING", "INSERT INTO", "INSERT", "LIMIT", "MODIFY", "ORDER BY", "RETURNING", "SELECT", "SET CURRENT SCHEMA", "SET SCHEMA", "SET", "UPDATE", "VALUES", "WHERE" ];
+    var A = [ "INTERSECT ALL", "INTERSECT", "MINUS", "UNION ALL", "UNION" ];
+    var I = [ "AND", "CROSS APPLY", "CROSS JOIN", "ELSE", "INNER JOIN", "FULL JOIN", "FULL OUTER JOIN", "LEFT JOIN", "LEFT OUTER JOIN", "NATURAL JOIN", "OR", "OUTER APPLY", "OUTER JOIN", "RENAME", "RIGHT JOIN", "RIGHT OUTER JOIN", "JOIN", "WHEN", "XOR" ];
+})(L);
+
+(function(E) {
+    var T = e && e.__importDefault || function(e) {
+        return e && e.__esModule ? e : {
+            default: e
+        };
+    };
+    E.__esModule = true;
+    E.tokenize = E.format = void 0;
+    var r = T(t);
+    var n = T(i);
+    var R = T(S);
+    var o = T(L);
+    var N = function(e, E) {
+        if (E === void 0) {
+            E = {};
+        }
+        switch (E.language) {
+          case "db2":
+            return new r["default"](E).format(e);
+
+          case "n1ql":
+            return new n["default"](E).format(e);
+
+          case "pl/sql":
+            return new R["default"](E).format(e);
+
+          case "sql":
+          default:
+            return new o["default"](E).format(e);
+        }
+    };
+    E.format = N;
+    var A = function(e, E) {
+        if (E === void 0) {
+            E = {};
+        }
+        return new o["default"](E).tokenize(e);
+    };
+    E.tokenize = A;
+    E["default"] = {
+        format: E.format,
+        tokenize: E.tokenize
+    };
+})(E);
+
+export { E as s };