initial commit - far from runnable

node_modules/@sqltools/formatter/lib/core/Formatter.d.ts

@@ -0,0 +1,38 @@
+import { Config, Token } from './types';
+import Tokenizer from './Tokenizer';
+export default class Formatter {
+    cfg: Config;
+    tokenizer: Tokenizer;
+    private tokenOverride?;
+    private tokens;
+    private previousReservedWord;
+    private previousNonWhiteSpace;
+    private indentation;
+    private inlineBlock;
+    private params;
+    private index;
+    constructor(cfg: Config, tokenizer: Tokenizer, tokenOverride?: (token: Token, previousToken?: Token) => Token);
+    format(query: string): string;
+    getFormattedQueryFromTokens(): string;
+    formatWhitespace(token: Token, query: string): string;
+    formatReserved(token: Token, query: string): string;
+    formatLineComment(token: Token, query: string): string;
+    formatBlockComment(token: Token, query: string): string;
+    indentComment(comment: string): string;
+    formatTopLevelReservedWordNoIndent(token: Token, query: string): string;
+    formatTopLevelReservedWord(token: Token, query: string): string;
+    formatNewlineReservedWord(token: Token, query: string): string;
+    equalizeWhitespace(value: string): string;
+    formatOpeningParentheses(token: Token, query: string): string;
+    formatClosingParentheses(token: Token, query: string): string;
+    formatPlaceholder(token: Token, query: string): string;
+    formatComma(token: Token, query: string): string;
+    formatWithSpaceAfter(token: Token, query: string): string;
+    formatWithoutSpaces(token: Token, query: string): string;
+    formatWithSpaces(token: Token, query: string): string;
+    formatReservedWord(value: string): string;
+    formatQuerySeparator(token: Token, query: string): string;
+    addNewline(query: string): string;
+    previousToken(): Token;
+    formatCase(value: string): string;
+}

node_modules/@sqltools/formatter/lib/core/Formatter.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var types_1 = require("./types");
+var Indentation_1 = __importDefault(require("./Indentation"));
+var InlineBlock_1 = __importDefault(require("./InlineBlock"));
+var Params_1 = __importDefault(require("./Params"));
+var spaceChars = [' ', '\t'];
+var trimSpacesEnd = function (str) {
+    var end = str.length - 1;
+    while (end >= 0 && spaceChars.includes(str[end])) {
+        end--;
+    }
+    return str.substring(0, end + 1);
+};
+var Formatter = (function () {
+    function Formatter(cfg, tokenizer, tokenOverride) {
+        this.cfg = cfg;
+        this.tokenizer = tokenizer;
+        this.tokenOverride = tokenOverride;
+        this.tokens = [];
+        this.previousReservedWord = { type: null, value: null };
+        this.previousNonWhiteSpace = { type: null, value: null };
+        this.index = 0;
+        this.indentation = new Indentation_1["default"](this.cfg.indent);
+        this.inlineBlock = new InlineBlock_1["default"]();
+        this.params = new Params_1["default"](this.cfg.params);
+    }
+    Formatter.prototype.format = function (query) {
+        this.tokens = this.tokenizer.tokenize(query);
+        var formattedQuery = this.getFormattedQueryFromTokens();
+        return formattedQuery.trim();
+    };
+    Formatter.prototype.getFormattedQueryFromTokens = function () {
+        var _this = this;
+        var formattedQuery = '';
+        this.tokens.forEach(function (token, index) {
+            _this.index = index;
+            if (_this.tokenOverride)
+                token = _this.tokenOverride(token, _this.previousReservedWord) || token;
+            if (token.type === types_1.TokenTypes.WHITESPACE) {
+                formattedQuery = _this.formatWhitespace(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.LINE_COMMENT) {
+                formattedQuery = _this.formatLineComment(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.BLOCK_COMMENT) {
+                formattedQuery = _this.formatBlockComment(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.RESERVED_TOP_LEVEL
+                || token.type === types_1.TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT
+                || token.type === types_1.TokenTypes.RESERVED_NEWLINE
+                || token.type === types_1.TokenTypes.RESERVED) {
+                formattedQuery = _this.formatReserved(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.OPEN_PAREN) {
+                formattedQuery = _this.formatOpeningParentheses(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.CLOSE_PAREN) {
+                formattedQuery = _this.formatClosingParentheses(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.NO_SPACE_OPERATOR) {
+                formattedQuery = _this.formatWithoutSpaces(token, formattedQuery);
+            }
+            else if (token.type === types_1.TokenTypes.PLACEHOLDER || token.type === types_1.TokenTypes.SERVERVARIABLE) {
+                formattedQuery = _this.formatPlaceholder(token, formattedQuery);
+            }
+            else if (token.value === ',') {
+                formattedQuery = _this.formatComma(token, formattedQuery);
+            }
+            else if (token.value === ':') {
+                formattedQuery = _this.formatWithSpaceAfter(token, formattedQuery);
+            }
+            else if (token.value === '.') {
+                formattedQuery = _this.formatWithoutSpaces(token, formattedQuery);
+            }
+            else if (token.value === ';') {
+                formattedQuery = _this.formatQuerySeparator(token, formattedQuery);
+            }
+            else {
+                formattedQuery = _this.formatWithSpaces(token, formattedQuery);
+            }
+            if (token.type !== types_1.TokenTypes.WHITESPACE) {
+                _this.previousNonWhiteSpace = token;
+            }
+        });
+        return formattedQuery;
+    };
+    Formatter.prototype.formatWhitespace = function (token, query) {
+        if (this.cfg.linesBetweenQueries === 'preserve'
+            && /((\r\n|\n)(\r\n|\n)+)/u.test(token.value)
+            && this.previousToken().value === ';') {
+            return query.replace(/(\n|\r\n)$/u, '') + token.value;
+        }
+        return query;
+    };
+    Formatter.prototype.formatReserved = function (token, query) {
+        if (token.type === types_1.TokenTypes.RESERVED_NEWLINE
+            && this.previousReservedWord
+            && this.previousReservedWord.value
+            && token.value.toUpperCase() === 'AND' &&
+            this.previousReservedWord.value.toUpperCase() === 'BETWEEN') {
+            token.type = types_1.TokenTypes.RESERVED;
+        }
+        if (token.type === types_1.TokenTypes.RESERVED_TOP_LEVEL) {
+            query = this.formatTopLevelReservedWord(token, query);
+        }
+        else if (token.type === types_1.TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT) {
+            query = this.formatTopLevelReservedWordNoIndent(token, query);
+        }
+        else if (token.type === types_1.TokenTypes.RESERVED_NEWLINE) {
+            query = this.formatNewlineReservedWord(token, query);
+        }
+        else {
+            query = this.formatWithSpaces(token, query);
+        }
+        this.previousReservedWord = token;
+        return query;
+    };
+    Formatter.prototype.formatLineComment = function (token, query) {
+        return this.addNewline(query + token.value);
+    };
+    Formatter.prototype.formatBlockComment = function (token, query) {
+        return this.addNewline(this.addNewline(query) + this.indentComment(token.value));
+    };
+    Formatter.prototype.indentComment = function (comment) {
+        return comment.replace(/\n[ \t]*/gu, '\n' + this.indentation.getIndent() + ' ');
+    };
+    Formatter.prototype.formatTopLevelReservedWordNoIndent = function (token, query) {
+        this.indentation.decreaseTopLevel();
+        query = this.addNewline(query) + this.equalizeWhitespace(this.formatReservedWord(token.value));
+        return this.addNewline(query);
+    };
+    Formatter.prototype.formatTopLevelReservedWord = function (token, query) {
+        var shouldChangeTopLevel = (this.previousNonWhiteSpace.value !== ',' && !['GRANT'].includes("".concat(this.previousNonWhiteSpace.value).toUpperCase()));
+        if (shouldChangeTopLevel) {
+            this.indentation.decreaseTopLevel();
+            query = this.addNewline(query);
+        }
+        query = query + this.equalizeWhitespace(this.formatReservedWord(token.value)) + ' ';
+        if (shouldChangeTopLevel)
+            this.indentation.increaseTopLevel();
+        return query;
+    };
+    Formatter.prototype.formatNewlineReservedWord = function (token, query) {
+        return (this.addNewline(query) + this.equalizeWhitespace(this.formatReservedWord(token.value)) + ' ');
+    };
+    Formatter.prototype.equalizeWhitespace = function (value) {
+        return value.replace(/\s+/gu, ' ');
+    };
+    Formatter.prototype.formatOpeningParentheses = function (token, query) {
+        token.value = this.formatCase(token.value);
+        var previousTokenType = this.previousToken().type;
+        if (previousTokenType !== types_1.TokenTypes.WHITESPACE
+            && previousTokenType !== types_1.TokenTypes.OPEN_PAREN
+            && previousTokenType !== types_1.TokenTypes.LINE_COMMENT) {
+            query = trimSpacesEnd(query);
+        }
+        query += token.value;
+        this.inlineBlock.beginIfPossible(this.tokens, this.index);
+        if (!this.inlineBlock.isActive()) {
+            this.indentation.increaseBlockLevel();
+            query = this.addNewline(query);
+        }
+        return query;
+    };
+    Formatter.prototype.formatClosingParentheses = function (token, query) {
+        token.value = this.formatCase(token.value);
+        if (this.inlineBlock.isActive()) {
+            this.inlineBlock.end();
+            return this.formatWithSpaceAfter(token, query);
+        }
+        else {
+            this.indentation.decreaseBlockLevel();
+            return this.formatWithSpaces(token, this.addNewline(query));
+        }
+    };
+    Formatter.prototype.formatPlaceholder = function (token, query) {
+        return query + this.params.get(token) + ' ';
+    };
+    Formatter.prototype.formatComma = function (token, query) {
+        query = trimSpacesEnd(query) + token.value + ' ';
+        if (this.inlineBlock.isActive()) {
+            return query;
+        }
+        else if (/^LIMIT$/iu.test(this.previousReservedWord.value)) {
+            return query;
+        }
+        else {
+            return this.addNewline(query);
+        }
+    };
+    Formatter.prototype.formatWithSpaceAfter = function (token, query) {
+        return trimSpacesEnd(query) + token.value + ' ';
+    };
+    Formatter.prototype.formatWithoutSpaces = function (token, query) {
+        return trimSpacesEnd(query) + token.value;
+    };
+    Formatter.prototype.formatWithSpaces = function (token, query) {
+        var value = token.type === types_1.TokenTypes.RESERVED ? this.formatReservedWord(token.value) : token.value;
+        return query + value + ' ';
+    };
+    Formatter.prototype.formatReservedWord = function (value) {
+        return this.formatCase(value);
+    };
+    Formatter.prototype.formatQuerySeparator = function (token, query) {
+        this.indentation.resetIndentation();
+        var lines = '\n';
+        if (this.cfg.linesBetweenQueries !== 'preserve') {
+            lines = '\n'.repeat(this.cfg.linesBetweenQueries || 1);
+        }
+        return trimSpacesEnd(query) + token.value + lines;
+    };
+    Formatter.prototype.addNewline = function (query) {
+        query = trimSpacesEnd(query);
+        if (!query.endsWith('\n'))
+            query += '\n';
+        return query + this.indentation.getIndent();
+    };
+    Formatter.prototype.previousToken = function () {
+        return this.tokens[this.index - 1] || { type: null, value: null };
+    };
+    Formatter.prototype.formatCase = function (value) {
+        if (this.cfg.reservedWordCase === 'upper')
+            return value.toUpperCase();
+        if (this.cfg.reservedWordCase === 'lower')
+            return value.toLowerCase();
+        return value;
+    };
+    return Formatter;
+}());
+exports["default"] = Formatter;

node_modules/@sqltools/formatter/lib/core/Indentation.d.ts

@@ -0,0 +1,11 @@
+export default class Indentation {
+    indent?: string;
+    indentTypes: any[];
+    constructor(indent?: string);
+    getIndent(): string;
+    increaseTopLevel(): void;
+    increaseBlockLevel(): void;
+    decreaseTopLevel(): void;
+    decreaseBlockLevel(): void;
+    resetIndentation(): void;
+}

node_modules/@sqltools/formatter/lib/core/Indentation.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var last_1 = __importDefault(require("./last"));
+var INDENT_TYPE_TOP_LEVEL = 'top-level';
+var INDENT_TYPE_BLOCK_LEVEL = 'block-level';
+var Indentation = (function () {
+    function Indentation(indent) {
+        this.indent = indent;
+        this.indentTypes = [];
+        this.indent = indent || '  ';
+    }
+    Indentation.prototype.getIndent = function () {
+        return new Array(this.indentTypes.length).fill(this.indent).join('');
+    };
+    Indentation.prototype.increaseTopLevel = function () {
+        this.indentTypes.push(INDENT_TYPE_TOP_LEVEL);
+    };
+    Indentation.prototype.increaseBlockLevel = function () {
+        this.indentTypes.push(INDENT_TYPE_BLOCK_LEVEL);
+    };
+    Indentation.prototype.decreaseTopLevel = function () {
+        if ((0, last_1["default"])(this.indentTypes) === INDENT_TYPE_TOP_LEVEL) {
+            this.indentTypes.pop();
+        }
+    };
+    Indentation.prototype.decreaseBlockLevel = function () {
+        while (this.indentTypes.length > 0) {
+            var type = this.indentTypes.pop();
+            if (type !== INDENT_TYPE_TOP_LEVEL) {
+                break;
+            }
+        }
+    };
+    Indentation.prototype.resetIndentation = function () {
+        this.indentTypes = [];
+    };
+    return Indentation;
+}());
+exports["default"] = Indentation;

node_modules/@sqltools/formatter/lib/core/InlineBlock.d.ts

@@ -0,0 +1,11 @@
+export default class InlineBlock {
+    private level;
+    beginIfPossible(tokens: any, index: any): void;
+    end(): void;
+    isActive(): boolean;
+    isInlineBlock(tokens: any, index: any): boolean;
+    isForbiddenToken({ type, value }: {
+        type: any;
+        value: any;
+    }): boolean;
+}

node_modules/@sqltools/formatter/lib/core/InlineBlock.js

@@ -0,0 +1,60 @@
+"use strict";
+exports.__esModule = true;
+var types_1 = require("./types");
+var INLINE_MAX_LENGTH = 50;
+var InlineBlock = (function () {
+    function InlineBlock() {
+        this.level = 0;
+    }
+    InlineBlock.prototype.beginIfPossible = function (tokens, index) {
+        if (this.level === 0 && this.isInlineBlock(tokens, index)) {
+            this.level = 1;
+        }
+        else if (this.level > 0) {
+            this.level++;
+        }
+        else {
+            this.level = 0;
+        }
+    };
+    InlineBlock.prototype.end = function () {
+        this.level--;
+    };
+    InlineBlock.prototype.isActive = function () {
+        return this.level > 0;
+    };
+    InlineBlock.prototype.isInlineBlock = function (tokens, index) {
+        var length = 0;
+        var level = 0;
+        for (var i = index; i < tokens.length; i++) {
+            var token = tokens[i];
+            length += token.value.length;
+            if (length > INLINE_MAX_LENGTH) {
+                return false;
+            }
+            if (token.type === types_1.TokenTypes.OPEN_PAREN) {
+                level++;
+            }
+            else if (token.type === types_1.TokenTypes.CLOSE_PAREN) {
+                level--;
+                if (level === 0) {
+                    return true;
+                }
+            }
+            if (this.isForbiddenToken(token)) {
+                return false;
+            }
+        }
+        return false;
+    };
+    InlineBlock.prototype.isForbiddenToken = function (_a) {
+        var type = _a.type, value = _a.value;
+        return (type === types_1.TokenTypes.RESERVED_TOP_LEVEL ||
+            type === types_1.TokenTypes.RESERVED_NEWLINE ||
+            type === types_1.TokenTypes.LINE_COMMENT ||
+            type === types_1.TokenTypes.BLOCK_COMMENT ||
+            value === ';');
+    };
+    return InlineBlock;
+}());
+exports["default"] = InlineBlock;

node_modules/@sqltools/formatter/lib/core/Params.d.ts

@@ -0,0 +1,7 @@
+import { Token } from './types';
+export default class Params {
+    params: Object;
+    private index;
+    constructor(params: Object);
+    get({ key, value }: Token): any;
+}

node_modules/@sqltools/formatter/lib/core/Params.js

@@ -0,0 +1,21 @@
+"use strict";
+exports.__esModule = true;
+var Params = (function () {
+    function Params(params) {
+        this.params = params;
+        this.index = 0;
+        this.params = params;
+    }
+    Params.prototype.get = function (_a) {
+        var key = _a.key, value = _a.value;
+        if (!this.params) {
+            return value;
+        }
+        if (key) {
+            return this.params[key];
+        }
+        return this.params[this.index++];
+    };
+    return Params;
+}());
+exports["default"] = Params;

node_modules/@sqltools/formatter/lib/core/Tokenizer.d.ts

@@ -0,0 +1,68 @@
+import { TokenTypes, Token, TokenizerConfig } from './types';
+export default class Tokenizer {
+    WHITESPACE_REGEX: RegExp;
+    NUMBER_REGEX: RegExp;
+    AMBIGUOS_OPERATOR_REGEX: RegExp;
+    OPERATOR_REGEX: RegExp;
+    NO_SPACE_OPERATOR_REGEX: RegExp;
+    BLOCK_COMMENT_REGEX: RegExp;
+    LINE_COMMENT_REGEX: RegExp;
+    RESERVED_TOP_LEVEL_REGEX: RegExp;
+    RESERVED_TOP_LEVEL_NO_INDENT_REGEX: RegExp;
+    RESERVED_NEWLINE_REGEX: RegExp;
+    RESERVED_PLAIN_REGEX: RegExp;
+    WORD_REGEX: RegExp;
+    STRING_REGEX: RegExp;
+    OPEN_PAREN_REGEX: RegExp;
+    CLOSE_PAREN_REGEX: RegExp;
+    INDEXED_PLACEHOLDER_REGEX: RegExp;
+    IDENT_NAMED_PLACEHOLDER_REGEX: RegExp;
+    STRING_NAMED_PLACEHOLDER_REGEX: RegExp;
+    constructor(cfg: TokenizerConfig);
+    createLineCommentRegex(lineCommentTypes: any): RegExp;
+    createReservedWordRegex(reservedWords: any): RegExp;
+    createWordRegex(specialChars: any): RegExp;
+    createStringRegex(stringTypes: any): RegExp;
+    createStringPattern(stringTypes: any): any;
+    createParenRegex(parens: any): RegExp;
+    escapeParen(paren: any): string;
+    createPlaceholderRegex(types: string[], pattern: any): RegExp;
+    tokenize(input: string): Token[];
+    getNextToken(input: string, previousToken?: Token): Token;
+    getWhitespaceToken(input: string): Token;
+    getCommentToken(input: string): Token;
+    getLineCommentToken(input: string): Token;
+    getBlockCommentToken(input: string): Token;
+    getStringToken(input: string): Token;
+    getOpenParenToken(input: string): Token;
+    getCloseParenToken(input: string): Token;
+    getPlaceholderToken(input: string): Token;
+    getServerVariableToken(input: string): Token;
+    getIdentNamedPlaceholderToken(input: string): Token;
+    getStringNamedPlaceholderToken(input: string): Token;
+    getIndexedPlaceholderToken(input: string): Token;
+    getPlaceholderTokenWithKey({ input, regex, parseKey }: {
+        input: any;
+        regex: any;
+        parseKey: any;
+    }): Token;
+    getEscapedPlaceholderKey({ key, quoteChar }: {
+        key: any;
+        quoteChar: any;
+    }): any;
+    getNumberToken(input: string): Token;
+    getOperatorToken(input: string): Token;
+    getAmbiguosOperatorToken(input: string): Token;
+    getNoSpaceOperatorToken(input: string): Token;
+    getReservedWordToken(input: any, previousToken: any): Token;
+    getToplevelReservedToken(input: string): Token;
+    getNewlineReservedToken(input: string): Token;
+    getPlainReservedToken(input: string): Token;
+    getTopLevelReservedTokenNoIndent(input: string): Token;
+    getWordToken(input: string): Token;
+    getTokenOnFirstMatch({ input, type, regex }: {
+        input: string;
+        type: TokenTypes;
+        regex: RegExp;
+    }): Token;
+}

node_modules/@sqltools/formatter/lib/core/Tokenizer.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var escapeRegExp_1 = __importDefault(require("../core/escapeRegExp"));
+var types_1 = require("./types");
+var Tokenizer = (function () {
+    function Tokenizer(cfg) {
+        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(cfg.lineCommentTypes);
+        this.RESERVED_TOP_LEVEL_REGEX = this.createReservedWordRegex(cfg.reservedTopLevelWords);
+        this.RESERVED_TOP_LEVEL_NO_INDENT_REGEX = this.createReservedWordRegex(cfg.reservedTopLevelWordsNoIndent);
+        this.RESERVED_NEWLINE_REGEX = this.createReservedWordRegex(cfg.reservedNewlineWords);
+        this.RESERVED_PLAIN_REGEX = this.createReservedWordRegex(cfg.reservedWords);
+        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));
+    }
+    Tokenizer.prototype.createLineCommentRegex = function (lineCommentTypes) {
+        var unMatchJSONOperators = '((?<!#)>|(?:[^>]))';
+        return new RegExp("^((?:".concat(lineCommentTypes.map(function (c) { return (0, escapeRegExp_1["default"])(c); }).join('|'), ")").concat(unMatchJSONOperators, ".*?(?:\r\n|\r|\n|$))"), 'u');
+    };
+    Tokenizer.prototype.createReservedWordRegex = function (reservedWords) {
+        var reservedWordsPattern = reservedWords.join('|').replace(/ /gu, '\\s+');
+        return new RegExp("^(".concat(reservedWordsPattern, ")\\b"), 'iu');
+    };
+    Tokenizer.prototype.createWordRegex = function (specialChars) {
+        return new RegExp("^([\\p{Alphabetic}\\p{Mark}\\p{Decimal_Number}\\p{Connector_Punctuation}\\p{Join_Control}".concat(specialChars.join(''), "]+)"), 'u');
+    };
+    Tokenizer.prototype.createStringRegex = function (stringTypes) {
+        return new RegExp('^(' + this.createStringPattern(stringTypes) + ')', 'u');
+    };
+    Tokenizer.prototype.createStringPattern = function (stringTypes) {
+        var patterns = {
+            '``': '((`[^`]*($|`))+)',
+            '[]': '((\\[[^\\]]*($|\\]))(\\][^\\]]*($|\\]))*)',
+            '""': '(("[^"\\\\]*(?:\\\\.[^"\\\\]*)*("|$))+)',
+            "''": "(('[^'\\\\]*(?:\\\\.[^'\\\\]*)*('|$))+)",
+            "N''": "((N'[^N'\\\\]*(?:\\\\.[^N'\\\\]*)*('|$))+)",
+            "E''": "(((E|e)'[^'\\\\]*(?:\\\\.[^'\\\\]*)*('|$))+)"
+        };
+        return stringTypes.map(function (t) { return patterns[t]; }).join('|');
+    };
+    Tokenizer.prototype.createParenRegex = function (parens) {
+        var _this = this;
+        return new RegExp('^(' + parens.map(function (p) { return _this.escapeParen(p); }).join('|') + ')', 'iu');
+    };
+    Tokenizer.prototype.escapeParen = function (paren) {
+        if (paren.length === 1) {
+            return (0, escapeRegExp_1["default"])(paren);
+        }
+        else {
+            return '\\b' + paren + '\\b';
+        }
+    };
+    Tokenizer.prototype.createPlaceholderRegex = function (types, pattern) {
+        if (!types || types.length === 0) {
+            return null;
+        }
+        var typesRegex = types.map(escapeRegExp_1["default"]).join('|');
+        return new RegExp("^((?:".concat(typesRegex, ")(?:").concat(pattern, "))"), 'u');
+    };
+    Tokenizer.prototype.tokenize = function (input) {
+        if (!input)
+            return [];
+        var tokens = [];
+        var token;
+        while (input.length) {
+            token = this.getNextToken(input, token);
+            input = input.substring(token.value.length);
+            tokens.push(token);
+        }
+        return tokens;
+    };
+    Tokenizer.prototype.getNextToken = function (input, previousToken) {
+        return (this.getWhitespaceToken(input) ||
+            this.getCommentToken(input) ||
+            this.getStringToken(input) ||
+            this.getOpenParenToken(input) ||
+            this.getCloseParenToken(input) ||
+            this.getAmbiguosOperatorToken(input) ||
+            this.getNoSpaceOperatorToken(input) ||
+            this.getServerVariableToken(input) ||
+            this.getPlaceholderToken(input) ||
+            this.getNumberToken(input) ||
+            this.getReservedWordToken(input, previousToken) ||
+            this.getWordToken(input) ||
+            this.getOperatorToken(input));
+    };
+    Tokenizer.prototype.getWhitespaceToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.WHITESPACE,
+            regex: this.WHITESPACE_REGEX
+        });
+    };
+    Tokenizer.prototype.getCommentToken = function (input) {
+        return this.getLineCommentToken(input) || this.getBlockCommentToken(input);
+    };
+    Tokenizer.prototype.getLineCommentToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.LINE_COMMENT,
+            regex: this.LINE_COMMENT_REGEX
+        });
+    };
+    Tokenizer.prototype.getBlockCommentToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.BLOCK_COMMENT,
+            regex: this.BLOCK_COMMENT_REGEX
+        });
+    };
+    Tokenizer.prototype.getStringToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.STRING,
+            regex: this.STRING_REGEX
+        });
+    };
+    Tokenizer.prototype.getOpenParenToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.OPEN_PAREN,
+            regex: this.OPEN_PAREN_REGEX
+        });
+    };
+    Tokenizer.prototype.getCloseParenToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.CLOSE_PAREN,
+            regex: this.CLOSE_PAREN_REGEX
+        });
+    };
+    Tokenizer.prototype.getPlaceholderToken = function (input) {
+        return (this.getIdentNamedPlaceholderToken(input) ||
+            this.getStringNamedPlaceholderToken(input) ||
+            this.getIndexedPlaceholderToken(input));
+    };
+    Tokenizer.prototype.getServerVariableToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.SERVERVARIABLE,
+            regex: /(^@@\w+)/iu
+        });
+    };
+    Tokenizer.prototype.getIdentNamedPlaceholderToken = function (input) {
+        return this.getPlaceholderTokenWithKey({
+            input: input,
+            regex: this.IDENT_NAMED_PLACEHOLDER_REGEX,
+            parseKey: function (v) { return v.slice(1); }
+        });
+    };
+    Tokenizer.prototype.getStringNamedPlaceholderToken = function (input) {
+        var _this = this;
+        return this.getPlaceholderTokenWithKey({
+            input: input,
+            regex: this.STRING_NAMED_PLACEHOLDER_REGEX,
+            parseKey: function (v) { return _this.getEscapedPlaceholderKey({ key: v.slice(2, -1), quoteChar: v.slice(-1) }); }
+        });
+    };
+    Tokenizer.prototype.getIndexedPlaceholderToken = function (input) {
+        return this.getPlaceholderTokenWithKey({
+            input: input,
+            regex: this.INDEXED_PLACEHOLDER_REGEX,
+            parseKey: function (v) { return v.slice(1); }
+        });
+    };
+    Tokenizer.prototype.getPlaceholderTokenWithKey = function (_a) {
+        var input = _a.input, regex = _a.regex, parseKey = _a.parseKey;
+        var token = this.getTokenOnFirstMatch({ input: input, regex: regex, type: types_1.TokenTypes.PLACEHOLDER });
+        if (token) {
+            token.key = parseKey(token.value);
+        }
+        return token;
+    };
+    Tokenizer.prototype.getEscapedPlaceholderKey = function (_a) {
+        var key = _a.key, quoteChar = _a.quoteChar;
+        return key.replace(new RegExp((0, escapeRegExp_1["default"])('\\' + quoteChar), 'gu'), quoteChar);
+    };
+    Tokenizer.prototype.getNumberToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.NUMBER,
+            regex: this.NUMBER_REGEX
+        });
+    };
+    Tokenizer.prototype.getOperatorToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.OPERATOR,
+            regex: this.OPERATOR_REGEX
+        });
+    };
+    Tokenizer.prototype.getAmbiguosOperatorToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.OPERATOR,
+            regex: this.AMBIGUOS_OPERATOR_REGEX
+        });
+    };
+    Tokenizer.prototype.getNoSpaceOperatorToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.NO_SPACE_OPERATOR,
+            regex: this.NO_SPACE_OPERATOR_REGEX
+        });
+    };
+    Tokenizer.prototype.getReservedWordToken = function (input, previousToken) {
+        if (previousToken && previousToken.value && previousToken.value === '.') {
+            return;
+        }
+        return (this.getToplevelReservedToken(input) ||
+            this.getNewlineReservedToken(input) ||
+            this.getTopLevelReservedTokenNoIndent(input) ||
+            this.getPlainReservedToken(input));
+    };
+    Tokenizer.prototype.getToplevelReservedToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.RESERVED_TOP_LEVEL,
+            regex: this.RESERVED_TOP_LEVEL_REGEX
+        });
+    };
+    Tokenizer.prototype.getNewlineReservedToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.RESERVED_NEWLINE,
+            regex: this.RESERVED_NEWLINE_REGEX
+        });
+    };
+    Tokenizer.prototype.getPlainReservedToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.RESERVED,
+            regex: this.RESERVED_PLAIN_REGEX
+        });
+    };
+    Tokenizer.prototype.getTopLevelReservedTokenNoIndent = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT,
+            regex: this.RESERVED_TOP_LEVEL_NO_INDENT_REGEX
+        });
+    };
+    Tokenizer.prototype.getWordToken = function (input) {
+        return this.getTokenOnFirstMatch({
+            input: input,
+            type: types_1.TokenTypes.WORD,
+            regex: this.WORD_REGEX
+        });
+    };
+    Tokenizer.prototype.getTokenOnFirstMatch = function (_a) {
+        var input = _a.input, type = _a.type, regex = _a.regex;
+        var matches = input.match(regex);
+        if (matches) {
+            return { type: type, value: matches[1] };
+        }
+    };
+    return Tokenizer;
+}());
+exports["default"] = Tokenizer;

node_modules/@sqltools/formatter/lib/core/escapeRegExp.d.ts

@@ -0,0 +1,2 @@
+declare function escapeRegExp(str?: string): string;
+export default escapeRegExp;

node_modules/@sqltools/formatter/lib/core/escapeRegExp.js

@@ -0,0 +1,10 @@
+"use strict";
+exports.__esModule = true;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reHasRegExpChar = RegExp(reRegExpChar.source);
+function escapeRegExp(str) {
+    return (str && reHasRegExpChar.test(str))
+        ? str.replace(reRegExpChar, '\\$&')
+        : (str || '');
+}
+exports["default"] = escapeRegExp;

node_modules/@sqltools/formatter/lib/core/last.d.ts

@@ -0,0 +1,2 @@
+declare const last: (arr?: any[]) => any;
+export default last;

node_modules/@sqltools/formatter/lib/core/last.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+var last = function (arr) {
+    if (arr === void 0) { arr = []; }
+    return arr[arr.length - 1];
+};
+exports["default"] = last;

node_modules/@sqltools/formatter/lib/core/types.d.ts

@@ -0,0 +1,43 @@
+export declare enum TokenTypes {
+    WHITESPACE = "whitespace",
+    WORD = "word",
+    STRING = "string",
+    RESERVED = "reserved",
+    RESERVED_TOP_LEVEL = "reserved-top-level",
+    RESERVED_TOP_LEVEL_NO_INDENT = "reserved-top-level-no-indent",
+    RESERVED_NEWLINE = "reserved-newline",
+    OPERATOR = "operator",
+    NO_SPACE_OPERATOR = "no-space-operator",
+    OPEN_PAREN = "open-paren",
+    CLOSE_PAREN = "close-paren",
+    LINE_COMMENT = "line-comment",
+    BLOCK_COMMENT = "block-comment",
+    NUMBER = "number",
+    PLACEHOLDER = "placeholder",
+    SERVERVARIABLE = "servervariable"
+}
+export interface Config {
+    indent?: string;
+    params?: Object;
+    reservedWordCase?: 'upper' | 'lower';
+    language?: 'sql' | 'db2' | 'n1ql' | 'pl/sql';
+    linesBetweenQueries?: number | 'preserve';
+}
+export interface TokenizerConfig {
+    reservedWords: string[];
+    reservedTopLevelWords: string[];
+    reservedNewlineWords: string[];
+    reservedTopLevelWordsNoIndent: string[];
+    stringTypes: string[];
+    openParens: string[];
+    closeParens: string[];
+    indexedPlaceholderTypes?: string[];
+    namedPlaceholderTypes: string[];
+    lineCommentTypes: string[];
+    specialWordChars: string[];
+}
+export interface Token {
+    type: TokenTypes;
+    value: string;
+    key?: string;
+}

node_modules/@sqltools/formatter/lib/core/types.js

@@ -0,0 +1,22 @@
+"use strict";
+exports.__esModule = true;
+exports.TokenTypes = void 0;
+var TokenTypes;
+(function (TokenTypes) {
+    TokenTypes["WHITESPACE"] = "whitespace";
+    TokenTypes["WORD"] = "word";
+    TokenTypes["STRING"] = "string";
+    TokenTypes["RESERVED"] = "reserved";
+    TokenTypes["RESERVED_TOP_LEVEL"] = "reserved-top-level";
+    TokenTypes["RESERVED_TOP_LEVEL_NO_INDENT"] = "reserved-top-level-no-indent";
+    TokenTypes["RESERVED_NEWLINE"] = "reserved-newline";
+    TokenTypes["OPERATOR"] = "operator";
+    TokenTypes["NO_SPACE_OPERATOR"] = "no-space-operator";
+    TokenTypes["OPEN_PAREN"] = "open-paren";
+    TokenTypes["CLOSE_PAREN"] = "close-paren";
+    TokenTypes["LINE_COMMENT"] = "line-comment";
+    TokenTypes["BLOCK_COMMENT"] = "block-comment";
+    TokenTypes["NUMBER"] = "number";
+    TokenTypes["PLACEHOLDER"] = "placeholder";
+    TokenTypes["SERVERVARIABLE"] = "servervariable";
+})(TokenTypes = exports.TokenTypes || (exports.TokenTypes = {}));

node_modules/@sqltools/formatter/lib/languages/Db2Formatter.d.ts

@@ -0,0 +1,5 @@
+import AbstractFormatter from './utils/abstract';
+import { TokenizerConfig } from '../core/types';
+export default class Db2Formatter extends AbstractFormatter {
+    getTokenizerConfig(): TokenizerConfig;
+}

node_modules/@sqltools/formatter/lib/languages/Db2Formatter.js

@@ -0,0 +1,585 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var abstract_1 = __importDefault(require("./utils/abstract"));
+var Db2Formatter = (function (_super) {
+    __extends(Db2Formatter, _super);
+    function Db2Formatter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Db2Formatter.prototype.getTokenizerConfig = function () {
+        return {
+            reservedWords: reservedWords,
+            reservedTopLevelWords: reservedTopLevelWords,
+            reservedNewlineWords: reservedNewlineWords,
+            reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,
+            stringTypes: ["\"\"", "''", '``', '[]'],
+            openParens: ['('],
+            closeParens: [')'],
+            indexedPlaceholderTypes: ['?'],
+            namedPlaceholderTypes: [':'],
+            lineCommentTypes: ['--'],
+            specialWordChars: ['#', '@']
+        };
+    };
+    return Db2Formatter;
+}(abstract_1["default"]));
+exports["default"] = Db2Formatter;
+var reservedWords = [
+    '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 reservedTopLevelWords = [
+    '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 reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];
+var reservedNewlineWords = [
+    'AND',
+    'CROSS JOIN',
+    'INNER JOIN',
+    'JOIN',
+    'LEFT JOIN',
+    'LEFT OUTER JOIN',
+    'OR',
+    'OUTER JOIN',
+    'RIGHT JOIN',
+    'RIGHT OUTER JOIN'
+];

node_modules/@sqltools/formatter/lib/languages/N1qlFormatter.d.ts

@@ -0,0 +1,5 @@
+import AbstractFormatter from './utils/abstract';
+import { TokenizerConfig } from '../core/types';
+export default class N1qlFormatter extends AbstractFormatter {
+    getTokenizerConfig(): TokenizerConfig;
+}

node_modules/@sqltools/formatter/lib/languages/N1qlFormatter.js

@@ -0,0 +1,257 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var abstract_1 = __importDefault(require("./utils/abstract"));
+var N1qlFormatter = (function (_super) {
+    __extends(N1qlFormatter, _super);
+    function N1qlFormatter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    N1qlFormatter.prototype.getTokenizerConfig = function () {
+        return {
+            reservedWords: reservedWords,
+            reservedTopLevelWords: reservedTopLevelWords,
+            reservedNewlineWords: reservedNewlineWords,
+            reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,
+            stringTypes: ["\"\"", "''", '``'],
+            openParens: ['(', '[', '{'],
+            closeParens: [')', ']', '}'],
+            namedPlaceholderTypes: ['$'],
+            lineCommentTypes: ['#', '--'],
+            specialWordChars: []
+        };
+    };
+    return N1qlFormatter;
+}(abstract_1["default"]));
+exports["default"] = N1qlFormatter;
+var reservedWords = [
+    '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 reservedTopLevelWords = [
+    '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 reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];
+var reservedNewlineWords = [
+    'AND',
+    'INNER JOIN',
+    'JOIN',
+    'LEFT JOIN',
+    'LEFT OUTER JOIN',
+    'OR',
+    'OUTER JOIN',
+    'RIGHT JOIN',
+    'RIGHT OUTER JOIN',
+    'XOR'
+];

node_modules/@sqltools/formatter/lib/languages/PlSqlFormatter.d.ts

@@ -0,0 +1,6 @@
+import AbstractFormatter from './utils/abstract';
+import { Token, TokenizerConfig } from '../core/types';
+export default class PlSqlFormatter extends AbstractFormatter {
+    getTokenizerConfig(): TokenizerConfig;
+    tokenOverride: (token: Token, previousReservedToken: Token) => Token;
+}

node_modules/@sqltools/formatter/lib/languages/PlSqlFormatter.js

@@ -0,0 +1,459 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var abstract_1 = __importDefault(require("./utils/abstract"));
+var types_1 = require("../core/types");
+var PlSqlFormatter = (function (_super) {
+    __extends(PlSqlFormatter, _super);
+    function PlSqlFormatter() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.tokenOverride = function (token, previousReservedToken) {
+            if (token.type === types_1.TokenTypes.RESERVED_TOP_LEVEL &&
+                previousReservedToken.value &&
+                token.value.toUpperCase() === 'SET' &&
+                previousReservedToken.value.toUpperCase() === 'BY') {
+                token.type = types_1.TokenTypes.RESERVED;
+                return token;
+            }
+        };
+        return _this;
+    }
+    PlSqlFormatter.prototype.getTokenizerConfig = function () {
+        return {
+            reservedWords: reservedWords,
+            reservedTopLevelWords: reservedTopLevelWords,
+            reservedNewlineWords: reservedNewlineWords,
+            reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,
+            stringTypes: ["\"\"", "N''", "''", '``'],
+            openParens: ['(', 'CASE'],
+            closeParens: [')', 'END'],
+            indexedPlaceholderTypes: ['?'],
+            namedPlaceholderTypes: [':'],
+            lineCommentTypes: ['--'],
+            specialWordChars: ['_', '$', '#', '.', '@']
+        };
+    };
+    return PlSqlFormatter;
+}(abstract_1["default"]));
+exports["default"] = PlSqlFormatter;
+var reservedWords = [
+    '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 reservedTopLevelWords = [
+    '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 reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];
+var reservedNewlineWords = [
+    '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'
+];

node_modules/@sqltools/formatter/lib/languages/StandardSqlFormatter.d.ts

@@ -0,0 +1,5 @@
+import AbstractFormatter from './utils/abstract';
+import { TokenizerConfig } from '../core/types';
+export default class StandardSqlFormatter extends AbstractFormatter {
+    getTokenizerConfig(): TokenizerConfig;
+}

node_modules/@sqltools/formatter/lib/languages/StandardSqlFormatter.js

@@ -0,0 +1,369 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var abstract_1 = __importDefault(require("./utils/abstract"));
+var StandardSqlFormatter = (function (_super) {
+    __extends(StandardSqlFormatter, _super);
+    function StandardSqlFormatter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StandardSqlFormatter.prototype.getTokenizerConfig = function () {
+        return {
+            reservedWords: reservedWords,
+            reservedTopLevelWords: reservedTopLevelWords,
+            reservedNewlineWords: reservedNewlineWords,
+            reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,
+            stringTypes: ["\"\"", "N''", "''", '``', '[]', "E''"],
+            openParens: ['(', 'CASE'],
+            closeParens: [')', 'END'],
+            indexedPlaceholderTypes: ['?'],
+            namedPlaceholderTypes: ['@', ':', '%', '$'],
+            lineCommentTypes: ['#', '--'],
+            specialWordChars: []
+        };
+    };
+    return StandardSqlFormatter;
+}(abstract_1["default"]));
+exports["default"] = StandardSqlFormatter;
+var 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',
+    '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 reservedTopLevelWords = [
+    '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 reservedTopLevelWordsNoIndent = ['INTERSECT ALL', 'INTERSECT', 'MINUS', 'UNION ALL', 'UNION'];
+var reservedNewlineWords = [
+    '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',
+];

node_modules/@sqltools/formatter/lib/languages/utils/abstract.d.ts

@@ -0,0 +1,11 @@
+import { Config, Token, TokenizerConfig } from '../../core/types';
+import Tokenizer from '../../core/Tokenizer';
+export default abstract class AbstractFormatter {
+    cfg: Config;
+    constructor(cfg: Config);
+    abstract getTokenizerConfig(): TokenizerConfig;
+    format(query: string): string;
+    tokenize(query: string): Token[];
+    tokenizer(): Tokenizer;
+    protected tokenOverride?: (token: Token, previousToken?: Token) => Token;
+}

node_modules/@sqltools/formatter/lib/languages/utils/abstract.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var Tokenizer_1 = __importDefault(require("../../core/Tokenizer"));
+var Formatter_1 = __importDefault(require("../../core/Formatter"));
+var AbstractFormatter = (function () {
+    function AbstractFormatter(cfg) {
+        this.cfg = cfg;
+    }
+    AbstractFormatter.prototype.format = function (query) {
+        return new Formatter_1["default"](this.cfg, this.tokenizer(), this.tokenOverride).format(query);
+    };
+    AbstractFormatter.prototype.tokenize = function (query) {
+        return this.tokenizer().tokenize(query);
+    };
+    AbstractFormatter.prototype.tokenizer = function () {
+        return new Tokenizer_1["default"](this.getTokenizerConfig());
+    };
+    return AbstractFormatter;
+}());
+exports["default"] = AbstractFormatter;

node_modules/@sqltools/formatter/lib/sqlFormatter.d.ts

@@ -0,0 +1,8 @@
+import { Config, Token } from './core/types';
+export declare const format: (query: string, cfg?: Config) => string;
+export declare const tokenize: (query: string, cfg?: Config) => Token[];
+declare const _default: {
+    format: (query: string, cfg?: Config) => string;
+    tokenize: (query: string, cfg?: Config) => Token[];
+};
+export default _default;

node_modules/@sqltools/formatter/lib/sqlFormatter.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.tokenize = exports.format = void 0;
+var Db2Formatter_1 = __importDefault(require("./languages/Db2Formatter"));
+var N1qlFormatter_1 = __importDefault(require("./languages/N1qlFormatter"));
+var PlSqlFormatter_1 = __importDefault(require("./languages/PlSqlFormatter"));
+var StandardSqlFormatter_1 = __importDefault(require("./languages/StandardSqlFormatter"));
+var format = function (query, cfg) {
+    if (cfg === void 0) { cfg = {}; }
+    switch (cfg.language) {
+        case 'db2':
+            return new Db2Formatter_1["default"](cfg).format(query);
+        case 'n1ql':
+            return new N1qlFormatter_1["default"](cfg).format(query);
+        case 'pl/sql':
+            return new PlSqlFormatter_1["default"](cfg).format(query);
+        case 'sql':
+        default:
+            return new StandardSqlFormatter_1["default"](cfg).format(query);
+    }
+};
+exports.format = format;
+var tokenize = function (query, cfg) {
+    if (cfg === void 0) { cfg = {}; }
+    return new StandardSqlFormatter_1["default"](cfg).tokenize(query);
+};
+exports.tokenize = tokenize;
+exports["default"] = {
+    format: exports.format,
+    tokenize: exports.tokenize
+};