orcaq 1.0.20

package/.output/server/node_modules/@opentelemetry/api/build/src/trace/trace_flags.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceFlags = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var TraceFlags;
+(function (TraceFlags) {
+    /** Represents no flag set. */
+    TraceFlags[TraceFlags["NONE"] = 0] = "NONE";
+    /** Bit to represent whether trace is sampled in trace flags. */
+    TraceFlags[TraceFlags["SAMPLED"] = 1] = "SAMPLED";
+})(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {}));
+//# sourceMappingURL=trace_flags.js.map

package/.output/server/node_modules/@opentelemetry/api/build/src/trace-api.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = void 0;
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+const trace_1 = require("./api/trace");
+/** Entrypoint for trace API */
+exports.trace = trace_1.TraceAPI.getInstance();
+//# sourceMappingURL=trace-api.js.map

package/.output/server/node_modules/@opentelemetry/api/build/src/version.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// this is autogenerated file, see scripts/version-update.js
+exports.VERSION = '1.9.0';
+//# sourceMappingURL=version.js.map

package/.output/server/node_modules/@opentelemetry/api/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@opentelemetry/api",
+  "version": "1.9.0",
+  "description": "Public API for OpenTelemetry",
+  "main": "build/src/index.js",
+  "module": "build/esm/index.js",
+  "esnext": "build/esnext/index.js",
+  "types": "build/src/index.d.ts",
+  "browser": {
+    "./src/platform/index.ts": "./src/platform/browser/index.ts",
+    "./build/esm/platform/index.js": "./build/esm/platform/browser/index.js",
+    "./build/esnext/platform/index.js": "./build/esnext/platform/browser/index.js",
+    "./build/src/platform/index.js": "./build/src/platform/browser/index.js"
+  },
+  "exports": {
+    ".": {
+      "module": "./build/esm/index.js",
+      "esnext": "./build/esnext/index.js",
+      "types": "./build/src/index.d.ts",
+      "default": "./build/src/index.js"
+    },
+    "./experimental": {
+      "module": "./build/esm/experimental/index.js",
+      "esnext": "./build/esnext/experimental/index.js",
+      "types": "./build/src/experimental/index.d.ts",
+      "default": "./build/src/experimental/index.js"
+    }
+  },
+  "repository": "open-telemetry/opentelemetry-js",
+  "scripts": {
+    "clean": "tsc --build --clean tsconfig.json tsconfig.esm.json tsconfig.esnext.json",
+    "codecov:browser": "nyc report --reporter=json && codecov -f coverage/*.json -p ../",
+    "codecov:webworker": "nyc report --reporter=json && codecov -f coverage/*.json -p ../",
+    "codecov": "nyc report --reporter=json && codecov -f coverage/*.json -p ../",
+    "precompile": "cross-var lerna run version --scope $npm_package_name --include-dependencies",
+    "compile": "tsc --build tsconfig.json tsconfig.esm.json tsconfig.esnext.json",
+    "docs": "typedoc",
+    "docs:deploy": "gh-pages --dist docs/out",
+    "docs:test": "linkinator docs/out --silent && linkinator docs/*.md *.md --markdown --silent",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "lint": "eslint . --ext .ts",
+    "test:browser": "karma start --single-run",
+    "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts'",
+    "test:eol": "ts-mocha -p tsconfig.json 'test/**/*.test.ts'",
+    "test:webworker": "karma start karma.worker.js --single-run",
+    "cycle-check": "dpdm --exit-code circular:1 src/index.ts",
+    "version": "node ../scripts/version-update.js",
+    "prewatch": "npm run precompile",
+    "watch": "tsc --build --watch tsconfig.json tsconfig.esm.json tsconfig.esnext.json",
+    "peer-api-check": "node ../scripts/peer-api-check.js"
+  },
+  "keywords": [
+    "opentelemetry",
+    "nodejs",
+    "browser",
+    "tracing",
+    "profiling",
+    "stats",
+    "monitoring"
+  ],
+  "author": "OpenTelemetry Authors",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "files": [
+    "build/esm/**/*.js",
+    "build/esm/**/*.js.map",
+    "build/esm/**/*.d.ts",
+    "build/esnext/**/*.js",
+    "build/esnext/**/*.js.map",
+    "build/esnext/**/*.d.ts",
+    "build/src/**/*.js",
+    "build/src/**/*.js.map",
+    "build/src/**/*.d.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/mocha": "10.0.6",
+    "@types/node": "18.6.5",
+    "@types/sinon": "17.0.3",
+    "@types/webpack": "5.28.5",
+    "@types/webpack-env": "1.16.3",
+    "babel-plugin-istanbul": "6.1.1",
+    "codecov": "3.8.3",
+    "cross-var": "1.1.0",
+    "dpdm": "3.13.1",
+    "karma": "6.4.3",
+    "karma-chrome-launcher": "3.1.0",
+    "karma-coverage": "2.2.1",
+    "karma-mocha": "2.0.1",
+    "karma-mocha-webworker": "1.3.0",
+    "karma-spec-reporter": "0.0.36",
+    "karma-webpack": "5.0.1",
+    "lerna": "6.6.2",
+    "memfs": "3.5.3",
+    "mocha": "10.2.0",
+    "nyc": "15.1.0",
+    "sinon": "15.1.2",
+    "ts-loader": "9.5.1",
+    "ts-mocha": "10.0.0",
+    "typescript": "4.4.4",
+    "unionfs": "4.5.4",
+    "webpack": "5.89.0"
+  },
+  "homepage": "https://github.com/open-telemetry/opentelemetry-js/tree/main/api",
+  "sideEffects": false,
+  "gitHead": "c4d3351b6b3f5593c8d7cbfec97b45cea9fe1511"
+}

package/.output/server/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;

package/.output/server/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;

package/.output/server/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;

package/.output/server/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;