From c13eca3a0f670a31b639c364416c2ba7171fa80a Mon Sep 17 00:00:00 2001 From: Piotr Monwid-Olechnowicz Date: Fri, 10 Dec 2021 18:41:39 +0100 Subject: [PATCH 1/7] Fix debounce time (#374) `wait: number` is unused, and instead the timeout ID is passed to `setTimeout`. I guess this wasn't intentional. --- extensions/github1s/src/helpers/func.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extensions/github1s/src/helpers/func.ts b/extensions/github1s/src/helpers/func.ts index d60eeda2e..ca0ffca5d 100644 --- a/extensions/github1s/src/helpers/func.ts +++ b/extensions/github1s/src/helpers/func.ts @@ -49,7 +49,7 @@ export const debounce = any>( let timer = null; return function (...args: Parameters): void { timer && clearTimeout(timer); - timer = setTimeout(() => func.call(this, ...args), timer); + timer = setTimeout(() => func.call(this, ...args), wait); }; }; From 0a2e21cd4ccb0597064942e063f97a52f159fa3c Mon Sep 17 00:00:00 2001 From: Bo Zhang Date: Sun, 19 Dec 2021 03:17:37 +0800 Subject: [PATCH 2/7] Trace error before writing to response (#375) * Trace error before writing to response * Update serve-dist.js * Update serve-dist.js --- scripts/serve-dist.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/scripts/serve-dist.js b/scripts/serve-dist.js index f8b4f9536..55f403e4c 100755 --- a/scripts/serve-dist.js +++ b/scripts/serve-dist.js @@ -14,7 +14,8 @@ const proxyServer = httpProxy.createServer({ changeOrigin: false, }); -const handleProxyError = (error) => { +const handleProxyError = (error, req, res) => { + console.trace(error); res.writeHead(500, { 'Content-Type': 'application/json', }); From ee9f352c6a84d504e857cd7fb04860a2cf0c45cf Mon Sep 17 00:00:00 2001 From: Bo Zhang Date: Thu, 23 Dec 2021 07:40:03 +0800 Subject: [PATCH 3/7] Fix up-to-date check issue in copy-extensions.sh (#376) Previously the script only check if `extensions/emmet/dist/browser` exists, and skip compiling if so. This PR adds an extra `git diff` check, and run compiling if there's any changes in `extensions`. --- vscode-web-github1s/scripts/copy-extensions.sh | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/vscode-web-github1s/scripts/copy-extensions.sh b/vscode-web-github1s/scripts/copy-extensions.sh index c4ede90f9..5e2dec55d 100755 --- a/vscode-web-github1s/scripts/copy-extensions.sh +++ b/vscode-web-github1s/scripts/copy-extensions.sh @@ -3,14 +3,16 @@ set -euo pipefail cd "$(dirname "${0}")/.." APP_ROOT=$(pwd) - function ensureBuiltinExtensitions() { cd "${APP_ROOT}/lib/vscode" - if [ ! -e "extensions/emmet/dist/browser" ] + git diff --exit-code --name-only extensions + if [ $? != 0 ] || [ ! -e "extensions/emmet/dist/browser" ] then echo "compile vscode builtin extensions..." yarn gulp compile-web yarn gulp compile-extension-media + else + echo "vscode builtin extensions is up-to-date, skip compiling." fi } @@ -24,3 +26,4 @@ function main() { } main "$@" + From ea60dac8b9f89dc802ec43d598b4078b2002fcc3 Mon Sep 17 00:00:00 2001 From: Bo Zhang Date: Thu, 23 Dec 2021 09:03:24 +0800 Subject: [PATCH 4/7] Fix copy extensions (#377) * Fix up-to-date check issue in copy-extensions.sh Previously the script only check if `extensions/emmet/dist/browser` exists, and skip compiling if so. This PR adds an extra `git diff` check, and run compiling if there's any changes in `extensions`. * Update copy-extensions.sh --- vscode-web-github1s/scripts/copy-extensions.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vscode-web-github1s/scripts/copy-extensions.sh b/vscode-web-github1s/scripts/copy-extensions.sh index 5e2dec55d..62af24961 100755 --- a/vscode-web-github1s/scripts/copy-extensions.sh +++ b/vscode-web-github1s/scripts/copy-extensions.sh @@ -5,8 +5,8 @@ cd "$(dirname "${0}")/.." APP_ROOT=$(pwd) function ensureBuiltinExtensitions() { cd "${APP_ROOT}/lib/vscode" - git diff --exit-code --name-only extensions - if [ $? != 0 ] || [ ! -e "extensions/emmet/dist/browser" ] + EXTENSIONS_DIRTY=0 && git diff --exit-code --name-only extensions || EXTENSIONS_DIRTY=$? + if [ $EXTENSIONS_DIRTY != 0 ] || [ ! -e "extensions/emmet/dist/browser" ] then echo "compile vscode builtin extensions..." yarn gulp compile-web From 5361a6e81175dfda22cb0f21ed1a2feefdc98175 Mon Sep 17 00:00:00 2001 From: netcon Date: Thu, 30 Dec 2021 00:33:23 +0800 Subject: [PATCH 5/7] fix: prebuilt vscode-anycode to fix the code folding bug (#378) --- extensions/vscode-anycode/README.md | 5 + extensions/vscode-anycode/package.json | 101 + .../prebuilt/anycode.extension.js | 27868 ++++++++++++++++ .../vscode-anycode/prebuilt/anycode.server.js | 15546 +++++++++ .../vscode-anycode/server/tree-sitter-c.wasm | Bin 0 -> 327556 bytes .../server/tree-sitter-c_sharp.wasm | Bin 0 -> 2987883 bytes .../server/tree-sitter-cpp.wasm | Bin 0 -> 1187722 bytes .../vscode-anycode/server/tree-sitter-go.wasm | Bin 0 -> 180028 bytes .../server/tree-sitter-java.wasm | Bin 0 -> 232273 bytes .../server/tree-sitter-php.wasm | Bin 0 -> 352603 bytes .../server/tree-sitter-python.wasm | Bin 0 -> 191411 bytes .../server/tree-sitter-rust.wasm | Bin 0 -> 638448 bytes .../server/tree-sitter-typescript.wasm | Bin 0 -> 1389235 bytes .../server/tree-sitter/tree-sitter.wasm | Bin 0 -> 171876 bytes resources/index-dev-vscode.html | 2 +- resources/index-hash.html | 2 +- resources/index.html | 2 +- 17 files changed, 43523 insertions(+), 3 deletions(-) create mode 100644 extensions/vscode-anycode/README.md create mode 100644 extensions/vscode-anycode/package.json create mode 100644 extensions/vscode-anycode/prebuilt/anycode.extension.js create mode 100644 extensions/vscode-anycode/prebuilt/anycode.server.js create mode 100755 extensions/vscode-anycode/server/tree-sitter-c.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-c_sharp.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-cpp.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-go.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-java.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-php.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-python.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-rust.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter-typescript.wasm create mode 100755 extensions/vscode-anycode/server/tree-sitter/tree-sitter.wasm diff --git a/extensions/vscode-anycode/README.md b/extensions/vscode-anycode/README.md new file mode 100644 index 000000000..c1907d5e6 --- /dev/null +++ b/extensions/vscode-anycode/README.md @@ -0,0 +1,5 @@ +# This is the prebuilt version of [vscode-anycode](https://github.com/microsoft/vscode-anycode) + +## we prebuilt it because of [this bug](https://github.com/conwnet/github1s/issues/373) + +## we will remove this after the latest version of the official extension released diff --git a/extensions/vscode-anycode/package.json b/extensions/vscode-anycode/package.json new file mode 100644 index 000000000..0eb91e388 --- /dev/null +++ b/extensions/vscode-anycode/package.json @@ -0,0 +1,101 @@ +{ + "name": "anycode", + "displayName": "anycode", + "publisher": "ms-vscode", + "description": "", + "version": "0.0.55", + "enabledApiProposals": [ + "languageStatus" + ], + "preview": true, + "repository": { + "url": "https://github.com/microsoft/vscode-anycode" + }, + "engines": { + "vscode": "^1.60.0" + }, + "categories": [ + "Programming Languages" + ], + "activationEvents": [ + "onLanguage:c", + "onLanguage:cpp", + "onLanguage:csharp", + "onLanguage:go", + "onLanguage:java", + "onLanguage:php", + "onLanguage:python", + "onLanguage:rust", + "onLanguage:javascript", + "onLanguage:typescript", + "onCommand:workbench.action.showAllSymbols" + ], + "browser": "./prebuilt/anycode.extension.js", + "contributes": { + "configuration": { + "title": "Anycode", + "properties": { + "anycode.symbolIndexSize": { + "type": "number", + "default": 500, + "minimum": 0, + "markdownDescription": "Size of the index that is used for features like symbol search and go to definition." + }, + "anycode.language.features": { + "markdownDescription": "Control the language features that anycode offers. This can be configured for each supported language: [Learn How to Do That](https://code.visualstudio.com/docs/getstarted/settings#_languagespecific-editor-settings)", + "type": "object", + "scope": "language-overridable", + "additionalProperties": false, + "properties": { + "definitions": { + "type": "boolean", + "description": "Go to Definition based on identifiers and local variables" + }, + "references": { + "type": "boolean", + "description": "Find References based on identifiers and local variables" + }, + "workspaceSymbols": { + "type": "boolean", + "description": "Add symbols to workspace symbol search" + }, + "highlights": { + "type": "boolean", + "description": "Highlight Occurrences of identifiers and local variables" + }, + "outline": { + "type": "boolean", + "description": "Populate Outline, Quick-outline, and Breadcrumbs" + }, + "completions": { + "type": "boolean", + "description": "Completions based on identifiers and symbol names" + }, + "folding": { + "type": "boolean", + "description": "Fold sections of codes to a single line" + }, + "diagnostics": { + "type": "boolean", + "description": "(experimental) Parse errors show as problems" + } + }, + "default": { + "completions": true, + "definitions": true, + "references": true, + "highlights": true, + "outline": true, + "workspaceSymbols": true, + "folding": false, + "diagnostics": false + } + } + } + } + }, + "scripts": { + "compile": "echo done", + "watch": "echo done" + } +} diff --git a/extensions/vscode-anycode/prebuilt/anycode.extension.js b/extensions/vscode-anycode/prebuilt/anycode.extension.js new file mode 100644 index 000000000..ed8d62a61 --- /dev/null +++ b/extensions/vscode-anycode/prebuilt/anycode.extension.js @@ -0,0 +1,27868 @@ +let __create = Object.create; +let __defProp = Object.defineProperty; +let __getOwnPropDesc = Object.getOwnPropertyDescriptor; +let __getOwnPropNames = Object.getOwnPropertyNames; +let __getProtoOf = Object.getPrototypeOf; +let __hasOwnProp = Object.prototype.hasOwnProperty; +let __markAsModule = (target) => + __defProp(target, '__esModule', { value: true }); +let __commonJS = (cb, mod) => + function __require() { + return ( + mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), + mod.exports + ); + }; +let __export = (target, all) => { + __markAsModule(target); + for (let name in all) { + __defProp(target, name, { get: all[name], enumerable: true }); + } +}; +let __reExport = (target, module2, desc) => { + if ( + (module2 && typeof module2 === 'object') || + typeof module2 === 'function' + ) { + for (let key of __getOwnPropNames(module2)) { + if (!__hasOwnProp.call(target, key) && key !== 'default') { + __defProp(target, key, { + get: () => module2[key], + enumerable: + !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable, + }); + } + } + } + return target; +}; +let __toModule = (module2) => { + return __reExport( + __markAsModule( + __defProp( + module2 != null ? __create(__getProtoOf(module2)) : {}, + 'default', + module2 && module2.__esModule && 'default' in module2 + ? { get: () => module2.default, enumerable: true } + : { value: module2, enumerable: true } + ) + ), + module2 + ); +}; + +// client/node_modules/vscode-jsonrpc/lib/common/ral.js +let require_ral = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/ral.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let _ral; + function RAL() { + if (_ral === void 0) { + throw new Error(`No runtime abstraction layer installed`); + } + return _ral; + } + (function (RAL2) { + function install(ral) { + if (ral === void 0) { + throw new Error(`No runtime abstraction layer provided`); + } + _ral = ral; + } + RAL2.install = install; + })(RAL || (RAL = {})); + exports.default = RAL; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/disposable.js +let require_disposable = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/disposable.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Disposable = void 0; + let Disposable3; + (function (Disposable4) { + function create(func) { + return { + dispose: func, + }; + } + Disposable4.create = create; + })((Disposable3 = exports.Disposable || (exports.Disposable = {}))); + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/events.js +let require_events = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/events.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Emitter = exports.Event = void 0; + let ral_1 = require_ral(); + let Event2; + (function (Event3) { + const _disposable = { dispose() {} }; + Event3.None = function () { + return _disposable; + }; + })((Event2 = exports.Event || (exports.Event = {}))); + let CallbackList = class { + add(callback, context = null, bucket) { + if (!this._callbacks) { + this._callbacks = []; + this._contexts = []; + } + this._callbacks.push(callback); + this._contexts.push(context); + if (Array.isArray(bucket)) { + bucket.push({ dispose: () => this.remove(callback, context) }); + } + } + remove(callback, context = null) { + if (!this._callbacks) { + return; + } + let foundCallbackWithDifferentContext = false; + for (let i = 0, len = this._callbacks.length; i < len; i++) { + if (this._callbacks[i] === callback) { + if (this._contexts[i] === context) { + this._callbacks.splice(i, 1); + this._contexts.splice(i, 1); + return; + } else { + foundCallbackWithDifferentContext = true; + } + } + } + if (foundCallbackWithDifferentContext) { + throw new Error( + 'When adding a listener with a context, you should remove it with the same context' + ); + } + } + invoke(...args) { + if (!this._callbacks) { + return []; + } + const ret = [], + callbacks = this._callbacks.slice(0), + contexts = this._contexts.slice(0); + for (let i = 0, len = callbacks.length; i < len; i++) { + try { + ret.push(callbacks[i].apply(contexts[i], args)); + } catch (e) { + (0, ral_1.default)().console.error(e); + } + } + return ret; + } + isEmpty() { + return !this._callbacks || this._callbacks.length === 0; + } + dispose() { + this._callbacks = void 0; + this._contexts = void 0; + } + }; + var Emitter = class { + constructor(_options) { + this._options = _options; + } + get event() { + if (!this._event) { + this._event = (listener, thisArgs, disposables) => { + if (!this._callbacks) { + this._callbacks = new CallbackList(); + } + if ( + this._options && + this._options.onFirstListenerAdd && + this._callbacks.isEmpty() + ) { + this._options.onFirstListenerAdd(this); + } + this._callbacks.add(listener, thisArgs); + const result = { + dispose: () => { + if (!this._callbacks) { + return; + } + this._callbacks.remove(listener, thisArgs); + result.dispose = Emitter._noop; + if ( + this._options && + this._options.onLastListenerRemove && + this._callbacks.isEmpty() + ) { + this._options.onLastListenerRemove(this); + } + }, + }; + if (Array.isArray(disposables)) { + disposables.push(result); + } + return result; + }; + } + return this._event; + } + fire(event) { + if (this._callbacks) { + this._callbacks.invoke.call(this._callbacks, event); + } + } + dispose() { + if (this._callbacks) { + this._callbacks.dispose(); + this._callbacks = void 0; + } + } + }; + exports.Emitter = Emitter; + Emitter._noop = function () {}; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js +let require_messageBuffer = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.AbstractMessageBuffer = void 0; + let CR = 13; + let LF = 10; + let CRLF = '\r\n'; + let AbstractMessageBuffer = class { + constructor(encoding = 'utf-8') { + this._encoding = encoding; + this._chunks = []; + this._totalLength = 0; + } + get encoding() { + return this._encoding; + } + append(chunk) { + const toAppend = + typeof chunk === 'string' + ? this.fromString(chunk, this._encoding) + : chunk; + this._chunks.push(toAppend); + this._totalLength += toAppend.byteLength; + } + tryReadHeaders() { + if (this._chunks.length === 0) { + return void 0; + } + let state = 0; + let chunkIndex = 0; + let offset = 0; + let chunkBytesRead = 0; + row: while (chunkIndex < this._chunks.length) { + const chunk = this._chunks[chunkIndex]; + offset = 0; + while (offset < chunk.length) { + const value = chunk[offset]; + switch (value) { + case CR: + switch (state) { + case 0: + state = 1; + break; + case 2: + state = 3; + break; + default: + state = 0; + } + break; + case LF: + switch (state) { + case 1: + state = 2; + break; + case 3: + state = 4; + offset++; + break row; + default: + state = 0; + } + break; + default: + state = 0; + } + offset++; + } + chunkBytesRead += chunk.byteLength; + chunkIndex++; + } + if (state !== 4) { + return void 0; + } + const buffer = this._read(chunkBytesRead + offset); + const result = new Map(); + const headers = this.toString(buffer, 'ascii').split(CRLF); + if (headers.length < 2) { + return result; + } + for (let i = 0; i < headers.length - 2; i++) { + const header = headers[i]; + const index = header.indexOf(':'); + if (index === -1) { + throw new Error( + 'Message header must separate key and value using :' + ); + } + const key = header.substr(0, index); + const value = header.substr(index + 1).trim(); + result.set(key, value); + } + return result; + } + tryReadBody(length) { + if (this._totalLength < length) { + return void 0; + } + return this._read(length); + } + get numberOfBytes() { + return this._totalLength; + } + _read(byteCount) { + if (byteCount === 0) { + return this.emptyBuffer(); + } + if (byteCount > this._totalLength) { + throw new Error(`Cannot read so many bytes!`); + } + if (this._chunks[0].byteLength === byteCount) { + const chunk = this._chunks[0]; + this._chunks.shift(); + this._totalLength -= byteCount; + return this.asNative(chunk); + } + if (this._chunks[0].byteLength > byteCount) { + const chunk = this._chunks[0]; + const result2 = this.asNative(chunk, byteCount); + this._chunks[0] = chunk.slice(byteCount); + this._totalLength -= byteCount; + return result2; + } + const result = this.allocNative(byteCount); + let resultOffset = 0; + let chunkIndex = 0; + while (byteCount > 0) { + const chunk = this._chunks[chunkIndex]; + if (chunk.byteLength > byteCount) { + const chunkPart = chunk.slice(0, byteCount); + result.set(chunkPart, resultOffset); + resultOffset += byteCount; + this._chunks[chunkIndex] = chunk.slice(byteCount); + this._totalLength -= byteCount; + byteCount -= byteCount; + } else { + result.set(chunk, resultOffset); + resultOffset += chunk.byteLength; + this._chunks.shift(); + this._totalLength -= chunk.byteLength; + byteCount -= chunk.byteLength; + } + } + return result; + } + }; + exports.AbstractMessageBuffer = AbstractMessageBuffer; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/browser/ril.js +let require_ril = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/browser/ril.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let ral_1 = require_ral(); + let disposable_1 = require_disposable(); + let events_1 = require_events(); + let messageBuffer_1 = require_messageBuffer(); + var MessageBuffer = class extends messageBuffer_1.AbstractMessageBuffer { + constructor(encoding = 'utf-8') { + super(encoding); + this.asciiDecoder = new TextDecoder('ascii'); + } + emptyBuffer() { + return MessageBuffer.emptyBuffer; + } + fromString(value, _encoding) { + return new TextEncoder().encode(value); + } + toString(value, encoding) { + if (encoding === 'ascii') { + return this.asciiDecoder.decode(value); + } else { + return new TextDecoder(encoding).decode(value); + } + } + asNative(buffer, length) { + if (length === void 0) { + return buffer; + } else { + return buffer.slice(0, length); + } + } + allocNative(length) { + return new Uint8Array(length); + } + }; + MessageBuffer.emptyBuffer = new Uint8Array(0); + let ReadableStreamWrapper = class { + constructor(socket) { + this.socket = socket; + this._onData = new events_1.Emitter(); + this._messageListener = (event) => { + const blob = event.data; + blob.arrayBuffer().then( + (buffer) => { + this._onData.fire(new Uint8Array(buffer)); + }, + () => { + (0, ral_1.default)().console.error( + `Converting blob to array buffer failed.` + ); + } + ); + }; + this.socket.addEventListener('message', this._messageListener); + } + onClose(listener) { + this.socket.addEventListener('close', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('close', listener) + ); + } + onError(listener) { + this.socket.addEventListener('error', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('error', listener) + ); + } + onEnd(listener) { + this.socket.addEventListener('end', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('end', listener) + ); + } + onData(listener) { + return this._onData.event(listener); + } + }; + let WritableStreamWrapper = class { + constructor(socket) { + this.socket = socket; + } + onClose(listener) { + this.socket.addEventListener('close', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('close', listener) + ); + } + onError(listener) { + this.socket.addEventListener('error', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('error', listener) + ); + } + onEnd(listener) { + this.socket.addEventListener('end', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('end', listener) + ); + } + write(data, encoding) { + if (typeof data === 'string') { + if (encoding !== void 0 && encoding !== 'utf-8') { + throw new Error( + `In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}` + ); + } + this.socket.send(data); + } else { + this.socket.send(data); + } + return Promise.resolve(); + } + end() { + this.socket.close(); + } + }; + let _textEncoder = new TextEncoder(); + let _ril = Object.freeze({ + messageBuffer: Object.freeze({ + create: (encoding) => new MessageBuffer(encoding), + }), + applicationJson: Object.freeze({ + encoder: Object.freeze({ + name: 'application/json', + encode: (msg, options) => { + if (options.charset !== 'utf-8') { + throw new Error( + `In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}` + ); + } + return Promise.resolve( + _textEncoder.encode(JSON.stringify(msg, void 0, 0)) + ); + }, + }), + decoder: Object.freeze({ + name: 'application/json', + decode: (buffer, options) => { + if (!(buffer instanceof Uint8Array)) { + throw new Error( + `In a Browser environments only Uint8Arrays are supported.` + ); + } + return Promise.resolve( + JSON.parse(new TextDecoder(options.charset).decode(buffer)) + ); + }, + }), + }), + stream: Object.freeze({ + asReadableStream: (socket) => new ReadableStreamWrapper(socket), + asWritableStream: (socket) => new WritableStreamWrapper(socket), + }), + console, + timer: Object.freeze({ + setTimeout(callback, ms2, ...args) { + const handle = setTimeout(callback, ms2, ...args); + return { dispose: () => clearTimeout(handle) }; + }, + setImmediate(callback, ...args) { + const handle = setTimeout(callback, 0, ...args); + return { dispose: () => clearTimeout(handle) }; + }, + setInterval(callback, ms2, ...args) { + const handle = setInterval(callback, ms2, ...args); + return { dispose: () => clearInterval(handle) }; + }, + }), + }); + function RIL() { + return _ril; + } + (function (RIL2) { + function install() { + ral_1.default.install(_ril); + } + RIL2.install = install; + })(RIL || (RIL = {})); + exports.default = RIL; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/is.js +let require_is = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/is.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0; + function boolean(value) { + return value === true || value === false; + } + exports.boolean = boolean; + function string(value) { + return typeof value === 'string' || value instanceof String; + } + exports.string = string; + function number(value) { + return typeof value === 'number' || value instanceof Number; + } + exports.number = number; + function error(value) { + return value instanceof Error; + } + exports.error = error; + function func(value) { + return typeof value === 'function'; + } + exports.func = func; + function array(value) { + return Array.isArray(value); + } + exports.array = array; + function stringArray(value) { + return array(value) && value.every((elem) => string(elem)); + } + exports.stringArray = stringArray; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/messages.js +let require_messages = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/messages.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0; + let is2 = require_is(); + let ErrorCodes; + (function (ErrorCodes2) { + ErrorCodes2.ParseError = -32700; + ErrorCodes2.InvalidRequest = -32600; + ErrorCodes2.MethodNotFound = -32601; + ErrorCodes2.InvalidParams = -32602; + ErrorCodes2.InternalError = -32603; + ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099; + ErrorCodes2.serverErrorStart = ErrorCodes2.jsonrpcReservedErrorRangeStart; + ErrorCodes2.MessageWriteError = -32099; + ErrorCodes2.MessageReadError = -32098; + ErrorCodes2.ServerNotInitialized = -32002; + ErrorCodes2.UnknownErrorCode = -32001; + ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3; + ErrorCodes2.serverErrorEnd = ErrorCodes2.jsonrpcReservedErrorRangeEnd; + })((ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}))); + var ResponseError = class extends Error { + constructor(code, message, data) { + super(message); + this.code = is2.number(code) ? code : ErrorCodes.UnknownErrorCode; + this.data = data; + Object.setPrototypeOf(this, ResponseError.prototype); + } + toJson() { + const result = { + code: this.code, + message: this.message, + }; + if (this.data !== void 0) { + result.data = this.data; + } + return result; + } + }; + exports.ResponseError = ResponseError; + var ParameterStructures = class { + constructor(kind) { + this.kind = kind; + } + static is(value) { + return ( + value === ParameterStructures.auto || + value === ParameterStructures.byName || + value === ParameterStructures.byPosition + ); + } + toString() { + return this.kind; + } + }; + exports.ParameterStructures = ParameterStructures; + ParameterStructures.auto = new ParameterStructures('auto'); + ParameterStructures.byPosition = new ParameterStructures('byPosition'); + ParameterStructures.byName = new ParameterStructures('byName'); + let AbstractMessageSignature = class { + constructor(method, numberOfParams) { + this.method = method; + this.numberOfParams = numberOfParams; + } + get parameterStructures() { + return ParameterStructures.auto; + } + }; + exports.AbstractMessageSignature = AbstractMessageSignature; + let RequestType0 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 0); + } + }; + exports.RequestType0 = RequestType0; + let RequestType = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.RequestType = RequestType; + let RequestType1 = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.RequestType1 = RequestType1; + let RequestType2 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 2); + } + }; + exports.RequestType2 = RequestType2; + let RequestType3 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 3); + } + }; + exports.RequestType3 = RequestType3; + let RequestType4 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 4); + } + }; + exports.RequestType4 = RequestType4; + let RequestType5 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 5); + } + }; + exports.RequestType5 = RequestType5; + let RequestType6 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 6); + } + }; + exports.RequestType6 = RequestType6; + let RequestType7 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 7); + } + }; + exports.RequestType7 = RequestType7; + let RequestType8 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 8); + } + }; + exports.RequestType8 = RequestType8; + let RequestType9 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 9); + } + }; + exports.RequestType9 = RequestType9; + let NotificationType = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.NotificationType = NotificationType; + let NotificationType0 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 0); + } + }; + exports.NotificationType0 = NotificationType0; + let NotificationType1 = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.NotificationType1 = NotificationType1; + let NotificationType2 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 2); + } + }; + exports.NotificationType2 = NotificationType2; + let NotificationType3 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 3); + } + }; + exports.NotificationType3 = NotificationType3; + let NotificationType4 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 4); + } + }; + exports.NotificationType4 = NotificationType4; + let NotificationType5 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 5); + } + }; + exports.NotificationType5 = NotificationType5; + let NotificationType6 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 6); + } + }; + exports.NotificationType6 = NotificationType6; + let NotificationType7 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 7); + } + }; + exports.NotificationType7 = NotificationType7; + let NotificationType8 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 8); + } + }; + exports.NotificationType8 = NotificationType8; + let NotificationType9 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 9); + } + }; + exports.NotificationType9 = NotificationType9; + let Message; + (function (Message2) { + function isRequest(message) { + const candidate = message; + return ( + candidate && + is2.string(candidate.method) && + (is2.string(candidate.id) || is2.number(candidate.id)) + ); + } + Message2.isRequest = isRequest; + function isNotification(message) { + const candidate = message; + return ( + candidate && is2.string(candidate.method) && message.id === void 0 + ); + } + Message2.isNotification = isNotification; + function isResponse(message) { + const candidate = message; + return ( + candidate && + (candidate.result !== void 0 || !!candidate.error) && + (is2.string(candidate.id) || + is2.number(candidate.id) || + candidate.id === null) + ); + } + Message2.isResponse = isResponse; + })((Message = exports.Message || (exports.Message = {}))); + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/linkedMap.js +let require_linkedMap = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/linkedMap.js'(exports) { + 'use strict'; + let _a2; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LRUCache = exports.LinkedMap = exports.Touch = void 0; + let Touch; + (function (Touch2) { + Touch2.None = 0; + Touch2.First = 1; + Touch2.AsOld = Touch2.First; + Touch2.Last = 2; + Touch2.AsNew = Touch2.Last; + })((Touch = exports.Touch || (exports.Touch = {}))); + let LinkedMap = class { + constructor() { + this[_a2] = 'LinkedMap'; + this._map = new Map(); + this._head = void 0; + this._tail = void 0; + this._size = 0; + this._state = 0; + } + clear() { + this._map.clear(); + this._head = void 0; + this._tail = void 0; + this._size = 0; + this._state++; + } + isEmpty() { + return !this._head && !this._tail; + } + get size() { + return this._size; + } + get first() { + return this._head?.value; + } + get last() { + return this._tail?.value; + } + has(key) { + return this._map.has(key); + } + get(key, touch = Touch.None) { + const item = this._map.get(key); + if (!item) { + return void 0; + } + if (touch !== Touch.None) { + this.touch(item, touch); + } + return item.value; + } + set(key, value, touch = Touch.None) { + let item = this._map.get(key); + if (item) { + item.value = value; + if (touch !== Touch.None) { + this.touch(item, touch); + } + } else { + item = { key, value, next: void 0, previous: void 0 }; + switch (touch) { + case Touch.None: + this.addItemLast(item); + break; + case Touch.First: + this.addItemFirst(item); + break; + case Touch.Last: + this.addItemLast(item); + break; + default: + this.addItemLast(item); + break; + } + this._map.set(key, item); + this._size++; + } + return this; + } + delete(key) { + return !!this.remove(key); + } + remove(key) { + const item = this._map.get(key); + if (!item) { + return void 0; + } + this._map.delete(key); + this.removeItem(item); + this._size--; + return item.value; + } + shift() { + if (!this._head && !this._tail) { + return void 0; + } + if (!this._head || !this._tail) { + throw new Error('Invalid list'); + } + const item = this._head; + this._map.delete(item.key); + this.removeItem(item); + this._size--; + return item.value; + } + forEach(callbackfn, thisArg) { + const state = this._state; + let current = this._head; + while (current) { + if (thisArg) { + callbackfn.bind(thisArg)(current.value, current.key, this); + } else { + callbackfn(current.value, current.key, this); + } + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + current = current.next; + } + } + keys() { + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]: () => { + return iterator; + }, + next: () => { + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: current.key, done: false }; + current = current.next; + return result; + } else { + return { value: void 0, done: true }; + } + }, + }; + return iterator; + } + values() { + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]: () => { + return iterator; + }, + next: () => { + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: current.value, done: false }; + current = current.next; + return result; + } else { + return { value: void 0, done: true }; + } + }, + }; + return iterator; + } + entries() { + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]: () => { + return iterator; + }, + next: () => { + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { + value: [current.key, current.value], + done: false, + }; + current = current.next; + return result; + } else { + return { value: void 0, done: true }; + } + }, + }; + return iterator; + } + [((_a2 = Symbol.toStringTag), Symbol.iterator)]() { + return this.entries(); + } + trimOld(newSize) { + if (newSize >= this.size) { + return; + } + if (newSize === 0) { + this.clear(); + return; + } + let current = this._head; + let currentSize = this.size; + while (current && currentSize > newSize) { + this._map.delete(current.key); + current = current.next; + currentSize--; + } + this._head = current; + this._size = currentSize; + if (current) { + current.previous = void 0; + } + this._state++; + } + addItemFirst(item) { + if (!this._head && !this._tail) { + this._tail = item; + } else if (!this._head) { + throw new Error('Invalid list'); + } else { + item.next = this._head; + this._head.previous = item; + } + this._head = item; + this._state++; + } + addItemLast(item) { + if (!this._head && !this._tail) { + this._head = item; + } else if (!this._tail) { + throw new Error('Invalid list'); + } else { + item.previous = this._tail; + this._tail.next = item; + } + this._tail = item; + this._state++; + } + removeItem(item) { + if (item === this._head && item === this._tail) { + this._head = void 0; + this._tail = void 0; + } else if (item === this._head) { + if (!item.next) { + throw new Error('Invalid list'); + } + item.next.previous = void 0; + this._head = item.next; + } else if (item === this._tail) { + if (!item.previous) { + throw new Error('Invalid list'); + } + item.previous.next = void 0; + this._tail = item.previous; + } else { + const next = item.next; + const previous = item.previous; + if (!next || !previous) { + throw new Error('Invalid list'); + } + next.previous = previous; + previous.next = next; + } + item.next = void 0; + item.previous = void 0; + this._state++; + } + touch(item, touch) { + if (!this._head || !this._tail) { + throw new Error('Invalid list'); + } + if (touch !== Touch.First && touch !== Touch.Last) { + return; + } + if (touch === Touch.First) { + if (item === this._head) { + return; + } + const next = item.next; + const previous = item.previous; + if (item === this._tail) { + previous.next = void 0; + this._tail = previous; + } else { + next.previous = previous; + previous.next = next; + } + item.previous = void 0; + item.next = this._head; + this._head.previous = item; + this._head = item; + this._state++; + } else if (touch === Touch.Last) { + if (item === this._tail) { + return; + } + const next = item.next; + const previous = item.previous; + if (item === this._head) { + next.previous = void 0; + this._head = next; + } else { + next.previous = previous; + previous.next = next; + } + item.next = void 0; + item.previous = this._tail; + this._tail.next = item; + this._tail = item; + this._state++; + } + } + toJSON() { + const data = []; + this.forEach((value, key) => { + data.push([key, value]); + }); + return data; + } + fromJSON(data) { + this.clear(); + for (const [key, value] of data) { + this.set(key, value); + } + } + }; + exports.LinkedMap = LinkedMap; + let LRUCache = class extends LinkedMap { + constructor(limit, ratio = 1) { + super(); + this._limit = limit; + this._ratio = Math.min(Math.max(0, ratio), 1); + } + get limit() { + return this._limit; + } + set limit(limit) { + this._limit = limit; + this.checkTrim(); + } + get ratio() { + return this._ratio; + } + set ratio(ratio) { + this._ratio = Math.min(Math.max(0, ratio), 1); + this.checkTrim(); + } + get(key, touch = Touch.AsNew) { + return super.get(key, touch); + } + peek(key) { + return super.get(key, Touch.None); + } + set(key, value) { + super.set(key, value, Touch.Last); + this.checkTrim(); + return this; + } + checkTrim() { + if (this.size > this._limit) { + this.trimOld(Math.round(this._limit * this._ratio)); + } + } + }; + exports.LRUCache = LRUCache; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/cancellation.js +let require_cancellation = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/cancellation.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CancellationTokenSource = exports.CancellationToken = void 0; + let ral_1 = require_ral(); + let Is2 = require_is(); + let events_1 = require_events(); + let CancellationToken; + (function (CancellationToken2) { + CancellationToken2.None = Object.freeze({ + isCancellationRequested: false, + onCancellationRequested: events_1.Event.None, + }); + CancellationToken2.Cancelled = Object.freeze({ + isCancellationRequested: true, + onCancellationRequested: events_1.Event.None, + }); + function is2(value) { + const candidate = value; + return ( + candidate && + (candidate === CancellationToken2.None || + candidate === CancellationToken2.Cancelled || + (Is2.boolean(candidate.isCancellationRequested) && + !!candidate.onCancellationRequested)) + ); + } + CancellationToken2.is = is2; + })( + (CancellationToken = + exports.CancellationToken || (exports.CancellationToken = {})) + ); + let shortcutEvent = Object.freeze(function (callback, context) { + const handle = (0, ral_1.default)().timer.setTimeout( + callback.bind(context), + 0 + ); + return { + dispose() { + handle.dispose(); + }, + }; + }); + let MutableToken = class { + constructor() { + this._isCancelled = false; + } + cancel() { + if (!this._isCancelled) { + this._isCancelled = true; + if (this._emitter) { + this._emitter.fire(void 0); + this.dispose(); + } + } + } + get isCancellationRequested() { + return this._isCancelled; + } + get onCancellationRequested() { + if (this._isCancelled) { + return shortcutEvent; + } + if (!this._emitter) { + this._emitter = new events_1.Emitter(); + } + return this._emitter.event; + } + dispose() { + if (this._emitter) { + this._emitter.dispose(); + this._emitter = void 0; + } + } + }; + let CancellationTokenSource = class { + get token() { + if (!this._token) { + this._token = new MutableToken(); + } + return this._token; + } + cancel() { + if (!this._token) { + this._token = CancellationToken.Cancelled; + } else { + this._token.cancel(); + } + } + dispose() { + if (!this._token) { + this._token = CancellationToken.None; + } else if (this._token instanceof MutableToken) { + this._token.dispose(); + } + } + }; + exports.CancellationTokenSource = CancellationTokenSource; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/messageReader.js +let require_messageReader = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/messageReader.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0; + let ral_1 = require_ral(); + let Is2 = require_is(); + let events_1 = require_events(); + let MessageReader; + (function (MessageReader2) { + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.func(candidate.listen) && + Is2.func(candidate.dispose) && + Is2.func(candidate.onError) && + Is2.func(candidate.onClose) && + Is2.func(candidate.onPartialMessage) + ); + } + MessageReader2.is = is2; + })((MessageReader = exports.MessageReader || (exports.MessageReader = {}))); + let AbstractMessageReader = class { + constructor() { + this.errorEmitter = new events_1.Emitter(); + this.closeEmitter = new events_1.Emitter(); + this.partialMessageEmitter = new events_1.Emitter(); + } + dispose() { + this.errorEmitter.dispose(); + this.closeEmitter.dispose(); + } + get onError() { + return this.errorEmitter.event; + } + fireError(error) { + this.errorEmitter.fire(this.asError(error)); + } + get onClose() { + return this.closeEmitter.event; + } + fireClose() { + this.closeEmitter.fire(void 0); + } + get onPartialMessage() { + return this.partialMessageEmitter.event; + } + firePartialMessage(info) { + this.partialMessageEmitter.fire(info); + } + asError(error) { + if (error instanceof Error) { + return error; + } else { + return new Error( + `Reader received error. Reason: ${ + Is2.string(error.message) ? error.message : 'unknown' + }` + ); + } + } + }; + exports.AbstractMessageReader = AbstractMessageReader; + let ResolvedMessageReaderOptions; + (function (ResolvedMessageReaderOptions2) { + function fromOptions(options) { + let charset; + let result; + let contentDecoder; + const contentDecoders = new Map(); + let contentTypeDecoder; + const contentTypeDecoders = new Map(); + if (options === void 0 || typeof options === 'string') { + charset = options ?? 'utf-8'; + } else { + charset = options.charset ?? 'utf-8'; + if (options.contentDecoder !== void 0) { + contentDecoder = options.contentDecoder; + contentDecoders.set(contentDecoder.name, contentDecoder); + } + if (options.contentDecoders !== void 0) { + for (const decoder of options.contentDecoders) { + contentDecoders.set(decoder.name, decoder); + } + } + if (options.contentTypeDecoder !== void 0) { + contentTypeDecoder = options.contentTypeDecoder; + contentTypeDecoders.set( + contentTypeDecoder.name, + contentTypeDecoder + ); + } + if (options.contentTypeDecoders !== void 0) { + for (const decoder of options.contentTypeDecoders) { + contentTypeDecoders.set(decoder.name, decoder); + } + } + } + if (contentTypeDecoder === void 0) { + contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder; + contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder); + } + return { + charset, + contentDecoder, + contentDecoders, + contentTypeDecoder, + contentTypeDecoders, + }; + } + ResolvedMessageReaderOptions2.fromOptions = fromOptions; + })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {})); + let ReadableStreamMessageReader = class extends AbstractMessageReader { + constructor(readable, options) { + super(); + this.readable = readable; + this.options = ResolvedMessageReaderOptions.fromOptions(options); + this.buffer = (0, ral_1.default)().messageBuffer.create( + this.options.charset + ); + this._partialMessageTimeout = 1e4; + this.nextMessageLength = -1; + this.messageToken = 0; + } + set partialMessageTimeout(timeout) { + this._partialMessageTimeout = timeout; + } + get partialMessageTimeout() { + return this._partialMessageTimeout; + } + listen(callback) { + this.nextMessageLength = -1; + this.messageToken = 0; + this.partialMessageTimer = void 0; + this.callback = callback; + const result = this.readable.onData((data) => { + this.onData(data); + }); + this.readable.onError((error) => this.fireError(error)); + this.readable.onClose(() => this.fireClose()); + return result; + } + onData(data) { + this.buffer.append(data); + while (true) { + if (this.nextMessageLength === -1) { + const headers = this.buffer.tryReadHeaders(); + if (!headers) { + return; + } + const contentLength = headers.get('Content-Length'); + if (!contentLength) { + throw new Error('Header must provide a Content-Length property.'); + } + const length = parseInt(contentLength); + if (isNaN(length)) { + throw new Error('Content-Length value must be a number.'); + } + this.nextMessageLength = length; + } + const body = this.buffer.tryReadBody(this.nextMessageLength); + if (body === void 0) { + this.setPartialMessageTimer(); + return; + } + this.clearPartialMessageTimer(); + this.nextMessageLength = -1; + let p; + if (this.options.contentDecoder !== void 0) { + p = this.options.contentDecoder.decode(body); + } else { + p = Promise.resolve(body); + } + p.then( + (value) => { + this.options.contentTypeDecoder.decode(value, this.options).then( + (msg) => { + this.callback(msg); + }, + (error) => { + this.fireError(error); + } + ); + }, + (error) => { + this.fireError(error); + } + ); + } + } + clearPartialMessageTimer() { + if (this.partialMessageTimer) { + this.partialMessageTimer.dispose(); + this.partialMessageTimer = void 0; + } + } + setPartialMessageTimer() { + this.clearPartialMessageTimer(); + if (this._partialMessageTimeout <= 0) { + return; + } + this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout( + (token, timeout) => { + this.partialMessageTimer = void 0; + if (token === this.messageToken) { + this.firePartialMessage({ + messageToken: token, + waitingTime: timeout, + }); + this.setPartialMessageTimer(); + } + }, + this._partialMessageTimeout, + this.messageToken, + this._partialMessageTimeout + ); + } + }; + exports.ReadableStreamMessageReader = ReadableStreamMessageReader; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/semaphore.js +let require_semaphore = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/semaphore.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Semaphore = void 0; + let ral_1 = require_ral(); + let Semaphore = class { + constructor(capacity = 1) { + if (capacity <= 0) { + throw new Error('Capacity must be greater than 0'); + } + this._capacity = capacity; + this._active = 0; + this._waiting = []; + } + lock(thunk) { + return new Promise((resolve, reject) => { + this._waiting.push({ thunk, resolve, reject }); + this.runNext(); + }); + } + get active() { + return this._active; + } + runNext() { + if (this._waiting.length === 0 || this._active === this._capacity) { + return; + } + (0, ral_1.default)().timer.setImmediate(() => this.doRunNext()); + } + doRunNext() { + if (this._waiting.length === 0 || this._active === this._capacity) { + return; + } + const next = this._waiting.shift(); + this._active++; + if (this._active > this._capacity) { + throw new Error(`To many thunks active`); + } + try { + const result = next.thunk(); + if (result instanceof Promise) { + result.then( + (value) => { + this._active--; + next.resolve(value); + this.runNext(); + }, + (err) => { + this._active--; + next.reject(err); + this.runNext(); + } + ); + } else { + this._active--; + next.resolve(result); + this.runNext(); + } + } catch (err) { + this._active--; + next.reject(err); + this.runNext(); + } + } + }; + exports.Semaphore = Semaphore; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/messageWriter.js +let require_messageWriter = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/messageWriter.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0; + let ral_1 = require_ral(); + let Is2 = require_is(); + let semaphore_1 = require_semaphore(); + let events_1 = require_events(); + let ContentLength = 'Content-Length: '; + let CRLF = '\r\n'; + let MessageWriter; + (function (MessageWriter2) { + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.func(candidate.dispose) && + Is2.func(candidate.onClose) && + Is2.func(candidate.onError) && + Is2.func(candidate.write) + ); + } + MessageWriter2.is = is2; + })((MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}))); + let AbstractMessageWriter = class { + constructor() { + this.errorEmitter = new events_1.Emitter(); + this.closeEmitter = new events_1.Emitter(); + } + dispose() { + this.errorEmitter.dispose(); + this.closeEmitter.dispose(); + } + get onError() { + return this.errorEmitter.event; + } + fireError(error, message, count) { + this.errorEmitter.fire([this.asError(error), message, count]); + } + get onClose() { + return this.closeEmitter.event; + } + fireClose() { + this.closeEmitter.fire(void 0); + } + asError(error) { + if (error instanceof Error) { + return error; + } else { + return new Error( + `Writer received error. Reason: ${ + Is2.string(error.message) ? error.message : 'unknown' + }` + ); + } + } + }; + exports.AbstractMessageWriter = AbstractMessageWriter; + let ResolvedMessageWriterOptions; + (function (ResolvedMessageWriterOptions2) { + function fromOptions(options) { + if (options === void 0 || typeof options === 'string') { + return { + charset: options ?? 'utf-8', + contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder, + }; + } else { + return { + charset: options.charset ?? 'utf-8', + contentEncoder: options.contentEncoder, + contentTypeEncoder: + options.contentTypeEncoder ?? + (0, ral_1.default)().applicationJson.encoder, + }; + } + } + ResolvedMessageWriterOptions2.fromOptions = fromOptions; + })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {})); + let WriteableStreamMessageWriter = class extends AbstractMessageWriter { + constructor(writable, options) { + super(); + this.writable = writable; + this.options = ResolvedMessageWriterOptions.fromOptions(options); + this.errorCount = 0; + this.writeSemaphore = new semaphore_1.Semaphore(1); + this.writable.onError((error) => this.fireError(error)); + this.writable.onClose(() => this.fireClose()); + } + async write(msg) { + return this.writeSemaphore.lock(async () => { + const payload = this.options.contentTypeEncoder + .encode(msg, this.options) + .then((buffer) => { + if (this.options.contentEncoder !== void 0) { + return this.options.contentEncoder.encode(buffer); + } else { + return buffer; + } + }); + return payload.then( + (buffer) => { + const headers = []; + headers.push(ContentLength, buffer.byteLength.toString(), CRLF); + headers.push(CRLF); + return this.doWrite(msg, headers, buffer); + }, + (error) => { + this.fireError(error); + throw error; + } + ); + }); + } + async doWrite(msg, headers, data) { + try { + await this.writable.write(headers.join(''), 'ascii'); + return this.writable.write(data); + } catch (error) { + this.handleError(error, msg); + return Promise.reject(error); + } + } + handleError(error, msg) { + this.errorCount++; + this.fireError(error, msg, this.errorCount); + } + end() { + this.writable.end(); + } + }; + exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/connection.js +let require_connection = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/connection.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createMessageConnection = exports.ConnectionOptions = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0; + let ral_1 = require_ral(); + let Is2 = require_is(); + let messages_1 = require_messages(); + let linkedMap_1 = require_linkedMap(); + let events_1 = require_events(); + let cancellation_1 = require_cancellation(); + let CancelNotification; + (function (CancelNotification2) { + CancelNotification2.type = new messages_1.NotificationType( + '$/cancelRequest' + ); + })(CancelNotification || (CancelNotification = {})); + let ProgressToken; + (function (ProgressToken2) { + function is2(value) { + return typeof value === 'string' || typeof value === 'number'; + } + ProgressToken2.is = is2; + })((ProgressToken = exports.ProgressToken || (exports.ProgressToken = {}))); + let ProgressNotification; + (function (ProgressNotification2) { + ProgressNotification2.type = new messages_1.NotificationType( + '$/progress' + ); + })(ProgressNotification || (ProgressNotification = {})); + let ProgressType = class { + constructor() {} + }; + exports.ProgressType = ProgressType; + let StarRequestHandler; + (function (StarRequestHandler2) { + function is2(value) { + return Is2.func(value); + } + StarRequestHandler2.is = is2; + })(StarRequestHandler || (StarRequestHandler = {})); + exports.NullLogger = Object.freeze({ + error: () => {}, + warn: () => {}, + info: () => {}, + log: () => {}, + }); + let Trace; + (function (Trace2) { + Trace2[(Trace2['Off'] = 0)] = 'Off'; + Trace2[(Trace2['Messages'] = 1)] = 'Messages'; + Trace2[(Trace2['Compact'] = 2)] = 'Compact'; + Trace2[(Trace2['Verbose'] = 3)] = 'Verbose'; + })((Trace = exports.Trace || (exports.Trace = {}))); + (function (Trace2) { + function fromString(value) { + if (!Is2.string(value)) { + return Trace2.Off; + } + value = value.toLowerCase(); + switch (value) { + case 'off': + return Trace2.Off; + case 'messages': + return Trace2.Messages; + case 'compact': + return Trace2.Compact; + case 'verbose': + return Trace2.Verbose; + default: + return Trace2.Off; + } + } + Trace2.fromString = fromString; + function toString(value) { + switch (value) { + case Trace2.Off: + return 'off'; + case Trace2.Messages: + return 'messages'; + case Trace2.Compact: + return 'compact'; + case Trace2.Verbose: + return 'verbose'; + default: + return 'off'; + } + } + Trace2.toString = toString; + })((Trace = exports.Trace || (exports.Trace = {}))); + let TraceFormat; + (function (TraceFormat2) { + TraceFormat2['Text'] = 'text'; + TraceFormat2['JSON'] = 'json'; + })((TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}))); + (function (TraceFormat2) { + function fromString(value) { + if (!Is2.string(value)) { + return TraceFormat2.Text; + } + value = value.toLowerCase(); + if (value === 'json') { + return TraceFormat2.JSON; + } else { + return TraceFormat2.Text; + } + } + TraceFormat2.fromString = fromString; + })((TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}))); + let SetTraceNotification; + (function (SetTraceNotification2) { + SetTraceNotification2.type = new messages_1.NotificationType( + '$/setTrace' + ); + })( + (SetTraceNotification = + exports.SetTraceNotification || (exports.SetTraceNotification = {})) + ); + let LogTraceNotification; + (function (LogTraceNotification2) { + LogTraceNotification2.type = new messages_1.NotificationType( + '$/logTrace' + ); + })( + (LogTraceNotification = + exports.LogTraceNotification || (exports.LogTraceNotification = {})) + ); + let ConnectionErrors; + (function (ConnectionErrors2) { + ConnectionErrors2[(ConnectionErrors2['Closed'] = 1)] = 'Closed'; + ConnectionErrors2[(ConnectionErrors2['Disposed'] = 2)] = 'Disposed'; + ConnectionErrors2[(ConnectionErrors2['AlreadyListening'] = 3)] = + 'AlreadyListening'; + })( + (ConnectionErrors = + exports.ConnectionErrors || (exports.ConnectionErrors = {})) + ); + var ConnectionError = class extends Error { + constructor(code, message) { + super(message); + this.code = code; + Object.setPrototypeOf(this, ConnectionError.prototype); + } + }; + exports.ConnectionError = ConnectionError; + let ConnectionStrategy; + (function (ConnectionStrategy2) { + function is2(value) { + const candidate = value; + return candidate && Is2.func(candidate.cancelUndispatched); + } + ConnectionStrategy2.is = is2; + })( + (ConnectionStrategy = + exports.ConnectionStrategy || (exports.ConnectionStrategy = {})) + ); + let CancellationReceiverStrategy; + (function (CancellationReceiverStrategy2) { + CancellationReceiverStrategy2.Message = Object.freeze({ + createCancellationTokenSource(_2) { + return new cancellation_1.CancellationTokenSource(); + }, + }); + function is2(value) { + const candidate = value; + return candidate && Is2.func(candidate.createCancellationTokenSource); + } + CancellationReceiverStrategy2.is = is2; + })( + (CancellationReceiverStrategy = + exports.CancellationReceiverStrategy || + (exports.CancellationReceiverStrategy = {})) + ); + let CancellationSenderStrategy; + (function (CancellationSenderStrategy2) { + CancellationSenderStrategy2.Message = Object.freeze({ + sendCancellation(conn, id) { + return conn.sendNotification(CancelNotification.type, { id }); + }, + cleanup(_2) {}, + }); + function is2(value) { + const candidate = value; + return ( + candidate && + Is2.func(candidate.sendCancellation) && + Is2.func(candidate.cleanup) + ); + } + CancellationSenderStrategy2.is = is2; + })( + (CancellationSenderStrategy = + exports.CancellationSenderStrategy || + (exports.CancellationSenderStrategy = {})) + ); + let CancellationStrategy; + (function (CancellationStrategy2) { + CancellationStrategy2.Message = Object.freeze({ + receiver: CancellationReceiverStrategy.Message, + sender: CancellationSenderStrategy.Message, + }); + function is2(value) { + const candidate = value; + return ( + candidate && + CancellationReceiverStrategy.is(candidate.receiver) && + CancellationSenderStrategy.is(candidate.sender) + ); + } + CancellationStrategy2.is = is2; + })( + (CancellationStrategy = + exports.CancellationStrategy || (exports.CancellationStrategy = {})) + ); + let ConnectionOptions; + (function (ConnectionOptions2) { + function is2(value) { + const candidate = value; + return ( + candidate && + (CancellationStrategy.is(candidate.cancellationStrategy) || + ConnectionStrategy.is(candidate.connectionStrategy)) + ); + } + ConnectionOptions2.is = is2; + })( + (ConnectionOptions = + exports.ConnectionOptions || (exports.ConnectionOptions = {})) + ); + let ConnectionState; + (function (ConnectionState2) { + ConnectionState2[(ConnectionState2['New'] = 1)] = 'New'; + ConnectionState2[(ConnectionState2['Listening'] = 2)] = 'Listening'; + ConnectionState2[(ConnectionState2['Closed'] = 3)] = 'Closed'; + ConnectionState2[(ConnectionState2['Disposed'] = 4)] = 'Disposed'; + })(ConnectionState || (ConnectionState = {})); + function createMessageConnection( + messageReader, + messageWriter, + _logger, + options + ) { + const logger = _logger !== void 0 ? _logger : exports.NullLogger; + let sequenceNumber = 0; + let notificationSequenceNumber = 0; + let unknownResponseSequenceNumber = 0; + const version = '2.0'; + let starRequestHandler = void 0; + const requestHandlers = Object.create(null); + let starNotificationHandler = void 0; + const notificationHandlers = Object.create(null); + const progressHandlers = new Map(); + let timer; + let messageQueue = new linkedMap_1.LinkedMap(); + let responsePromises = Object.create(null); + let knownCanceledRequests = new Set(); + let requestTokens = Object.create(null); + let trace = Trace.Off; + let traceFormat = TraceFormat.Text; + let tracer; + let state = ConnectionState.New; + const errorEmitter = new events_1.Emitter(); + const closeEmitter = new events_1.Emitter(); + const unhandledNotificationEmitter = new events_1.Emitter(); + const unhandledProgressEmitter = new events_1.Emitter(); + const disposeEmitter = new events_1.Emitter(); + const cancellationStrategy = + options && options.cancellationStrategy + ? options.cancellationStrategy + : CancellationStrategy.Message; + function createRequestQueueKey(id) { + if (id === null) { + throw new Error( + `Can't send requests with id null since the response can't be correlated.` + ); + } + return 'req-' + id.toString(); + } + function createResponseQueueKey(id) { + if (id === null) { + return 'res-unknown-' + (++unknownResponseSequenceNumber).toString(); + } else { + return 'res-' + id.toString(); + } + } + function createNotificationQueueKey() { + return 'not-' + (++notificationSequenceNumber).toString(); + } + function addMessageToQueue(queue, message) { + if (messages_1.Message.isRequest(message)) { + queue.set(createRequestQueueKey(message.id), message); + } else if (messages_1.Message.isResponse(message)) { + queue.set(createResponseQueueKey(message.id), message); + } else { + queue.set(createNotificationQueueKey(), message); + } + } + function cancelUndispatched(_message) { + return void 0; + } + function isListening() { + return state === ConnectionState.Listening; + } + function isClosed() { + return state === ConnectionState.Closed; + } + function isDisposed() { + return state === ConnectionState.Disposed; + } + function closeHandler() { + if ( + state === ConnectionState.New || + state === ConnectionState.Listening + ) { + state = ConnectionState.Closed; + closeEmitter.fire(void 0); + } + } + function readErrorHandler(error) { + errorEmitter.fire([error, void 0, void 0]); + } + function writeErrorHandler(data) { + errorEmitter.fire(data); + } + messageReader.onClose(closeHandler); + messageReader.onError(readErrorHandler); + messageWriter.onClose(closeHandler); + messageWriter.onError(writeErrorHandler); + function triggerMessageQueue() { + if (timer || messageQueue.size === 0) { + return; + } + timer = (0, ral_1.default)().timer.setImmediate(() => { + timer = void 0; + processMessageQueue(); + }); + } + function processMessageQueue() { + if (messageQueue.size === 0) { + return; + } + const message = messageQueue.shift(); + try { + if (messages_1.Message.isRequest(message)) { + handleRequest(message); + } else if (messages_1.Message.isNotification(message)) { + handleNotification(message); + } else if (messages_1.Message.isResponse(message)) { + handleResponse(message); + } else { + handleInvalidMessage(message); + } + } finally { + triggerMessageQueue(); + } + } + const callback = (message) => { + try { + if ( + messages_1.Message.isNotification(message) && + message.method === CancelNotification.type.method + ) { + const cancelId = message.params.id; + const key = createRequestQueueKey(cancelId); + const toCancel = messageQueue.get(key); + if (messages_1.Message.isRequest(toCancel)) { + const strategy = options?.connectionStrategy; + const response = + strategy && strategy.cancelUndispatched + ? strategy.cancelUndispatched(toCancel, cancelUndispatched) + : cancelUndispatched(toCancel); + if ( + response && + (response.error !== void 0 || response.result !== void 0) + ) { + messageQueue.delete(key); + response.id = toCancel.id; + traceSendingResponse(response, message.method, Date.now()); + messageWriter + .write(response) + .catch(() => + logger.error( + `Sending response for canceled message failed.` + ) + ); + return; + } + } + const tokenKey = String(cancelId); + const cancellationToken = requestTokens[tokenKey]; + if (cancellationToken !== void 0) { + cancellationToken.cancel(); + traceReceivedNotification(message); + return; + } else { + knownCanceledRequests.add(cancelId); + } + } + addMessageToQueue(messageQueue, message); + } finally { + triggerMessageQueue(); + } + }; + function handleRequest(requestMessage) { + if (isDisposed()) { + return; + } + function reply(resultOrError, method, startTime2) { + const message = { + jsonrpc: version, + id: requestMessage.id, + }; + if (resultOrError instanceof messages_1.ResponseError) { + message.error = resultOrError.toJson(); + } else { + message.result = resultOrError === void 0 ? null : resultOrError; + } + traceSendingResponse(message, method, startTime2); + messageWriter + .write(message) + .catch(() => logger.error(`Sending response failed.`)); + } + function replyError(error, method, startTime2) { + const message = { + jsonrpc: version, + id: requestMessage.id, + error: error.toJson(), + }; + traceSendingResponse(message, method, startTime2); + messageWriter + .write(message) + .catch(() => logger.error(`Sending response failed.`)); + } + function replySuccess(result, method, startTime2) { + if (result === void 0) { + result = null; + } + const message = { + jsonrpc: version, + id: requestMessage.id, + result, + }; + traceSendingResponse(message, method, startTime2); + messageWriter + .write(message) + .catch(() => logger.error(`Sending response failed.`)); + } + traceReceivedRequest(requestMessage); + const element = requestHandlers[requestMessage.method]; + let type; + let requestHandler; + if (element) { + type = element.type; + requestHandler = element.handler; + } + const startTime = Date.now(); + if (requestHandler || starRequestHandler) { + const tokenKey = String(requestMessage.id); + const cancellationSource = cancellationStrategy.receiver.createCancellationTokenSource( + tokenKey + ); + if ( + requestMessage.id !== null && + knownCanceledRequests.has(requestMessage.id) + ) { + cancellationSource.cancel(); + } + requestTokens[tokenKey] = cancellationSource; + try { + let handlerResult; + if (requestHandler) { + if (requestMessage.params === void 0) { + if (type !== void 0 && type.numberOfParams !== 0) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InvalidParams, + `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.` + ), + requestMessage.method, + startTime + ); + return; + } + handlerResult = requestHandler(cancellationSource.token); + } else if (Array.isArray(requestMessage.params)) { + if ( + type !== void 0 && + type.parameterStructures === + messages_1.ParameterStructures.byName + ) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InvalidParams, + `Request ${requestMessage.method} defines parameters by name but received parameters by position` + ), + requestMessage.method, + startTime + ); + return; + } + handlerResult = requestHandler( + ...requestMessage.params, + cancellationSource.token + ); + } else { + if ( + type !== void 0 && + type.parameterStructures === + messages_1.ParameterStructures.byPosition + ) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InvalidParams, + `Request ${requestMessage.method} defines parameters by position but received parameters by name` + ), + requestMessage.method, + startTime + ); + return; + } + handlerResult = requestHandler( + requestMessage.params, + cancellationSource.token + ); + } + } else if (starRequestHandler) { + handlerResult = starRequestHandler( + requestMessage.method, + requestMessage.params, + cancellationSource.token + ); + } + const promise = handlerResult; + if (!handlerResult) { + delete requestTokens[tokenKey]; + replySuccess(handlerResult, requestMessage.method, startTime); + } else if (promise.then) { + promise.then( + (resultOrError) => { + delete requestTokens[tokenKey]; + reply(resultOrError, requestMessage.method, startTime); + }, + (error) => { + delete requestTokens[tokenKey]; + if (error instanceof messages_1.ResponseError) { + replyError(error, requestMessage.method, startTime); + } else if (error && Is2.string(error.message)) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed with message: ${error.message}` + ), + requestMessage.method, + startTime + ); + } else { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed unexpectedly without providing any details.` + ), + requestMessage.method, + startTime + ); + } + } + ); + } else { + delete requestTokens[tokenKey]; + reply(handlerResult, requestMessage.method, startTime); + } + } catch (error) { + delete requestTokens[tokenKey]; + if (error instanceof messages_1.ResponseError) { + reply(error, requestMessage.method, startTime); + } else if (error && Is2.string(error.message)) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed with message: ${error.message}` + ), + requestMessage.method, + startTime + ); + } else { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed unexpectedly without providing any details.` + ), + requestMessage.method, + startTime + ); + } + } + } else { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.MethodNotFound, + `Unhandled method ${requestMessage.method}` + ), + requestMessage.method, + startTime + ); + } + } + function handleResponse(responseMessage) { + if (isDisposed()) { + return; + } + if (responseMessage.id === null) { + if (responseMessage.error) { + logger.error(`Received response message without id: Error is: +${JSON.stringify(responseMessage.error, void 0, 4)}`); + } else { + logger.error( + `Received response message without id. No further error information provided.` + ); + } + } else { + const key = String(responseMessage.id); + const responsePromise = responsePromises[key]; + traceReceivedResponse(responseMessage, responsePromise); + if (responsePromise) { + delete responsePromises[key]; + try { + if (responseMessage.error) { + const error = responseMessage.error; + responsePromise.reject( + new messages_1.ResponseError( + error.code, + error.message, + error.data + ) + ); + } else if (responseMessage.result !== void 0) { + responsePromise.resolve(responseMessage.result); + } else { + throw new Error('Should never happen.'); + } + } catch (error) { + if (error.message) { + logger.error( + `Response handler '${responsePromise.method}' failed with message: ${error.message}` + ); + } else { + logger.error( + `Response handler '${responsePromise.method}' failed unexpectedly.` + ); + } + } + } + } + } + function handleNotification(message) { + if (isDisposed()) { + return; + } + let type = void 0; + let notificationHandler; + if (message.method === CancelNotification.type.method) { + const cancelId = message.params.id; + knownCanceledRequests.delete(cancelId); + traceReceivedNotification(message); + return; + } else { + const element = notificationHandlers[message.method]; + if (element) { + notificationHandler = element.handler; + type = element.type; + } + } + if (notificationHandler || starNotificationHandler) { + try { + traceReceivedNotification(message); + if (notificationHandler) { + if (message.params === void 0) { + if (type !== void 0) { + if ( + type.numberOfParams !== 0 && + type.parameterStructures !== + messages_1.ParameterStructures.byName + ) { + logger.error( + `Notification ${message.method} defines ${type.numberOfParams} params but received none.` + ); + } + } + notificationHandler(); + } else if (Array.isArray(message.params)) { + const params = message.params; + if ( + message.method === ProgressNotification.type.method && + params.length === 2 && + ProgressToken.is(params[0]) + ) { + notificationHandler({ token: params[0], value: params[1] }); + } else { + if (type !== void 0) { + if ( + type.parameterStructures === + messages_1.ParameterStructures.byName + ) { + logger.error( + `Notification ${message.method} defines parameters by name but received parameters by position` + ); + } + if (type.numberOfParams !== message.params.length) { + logger.error( + `Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments` + ); + } + } + notificationHandler(...params); + } + } else { + if ( + type !== void 0 && + type.parameterStructures === + messages_1.ParameterStructures.byPosition + ) { + logger.error( + `Notification ${message.method} defines parameters by position but received parameters by name` + ); + } + notificationHandler(message.params); + } + } else if (starNotificationHandler) { + starNotificationHandler(message.method, message.params); + } + } catch (error) { + if (error.message) { + logger.error( + `Notification handler '${message.method}' failed with message: ${error.message}` + ); + } else { + logger.error( + `Notification handler '${message.method}' failed unexpectedly.` + ); + } + } + } else { + unhandledNotificationEmitter.fire(message); + } + } + function handleInvalidMessage(message) { + if (!message) { + logger.error('Received empty message.'); + return; + } + logger.error(`Received message which is neither a response nor a notification message: +${JSON.stringify(message, null, 4)}`); + const responseMessage = message; + if (Is2.string(responseMessage.id) || Is2.number(responseMessage.id)) { + const key = String(responseMessage.id); + const responseHandler = responsePromises[key]; + if (responseHandler) { + responseHandler.reject( + new Error( + 'The received response has neither a result nor an error property.' + ) + ); + } + } + } + function stringifyTrace(params) { + if (params === void 0 || params === null) { + return void 0; + } + switch (trace) { + case Trace.Verbose: + return JSON.stringify(params, null, 4); + case Trace.Compact: + return JSON.stringify(params); + default: + return void 0; + } + } + function traceSendingRequest(message) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if ( + (trace === Trace.Verbose || trace === Trace.Compact) && + message.params + ) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } + tracer.log( + `Sending request '${message.method} - (${message.id})'.`, + data + ); + } else { + logLSPMessage('send-request', message); + } + } + function traceSendingNotification(message) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.params) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } else { + data = 'No parameters provided.\n\n'; + } + } + tracer.log(`Sending notification '${message.method}'.`, data); + } else { + logLSPMessage('send-notification', message); + } + } + function traceSendingResponse(message, method, startTime) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.error && message.error.data) { + data = `Error data: ${stringifyTrace(message.error.data)} + +`; + } else { + if (message.result) { + data = `Result: ${stringifyTrace(message.result)} + +`; + } else if (message.error === void 0) { + data = 'No result returned.\n\n'; + } + } + } + tracer.log( + `Sending response '${method} - (${ + message.id + })'. Processing request took ${Date.now() - startTime}ms`, + data + ); + } else { + logLSPMessage('send-response', message); + } + } + function traceReceivedRequest(message) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if ( + (trace === Trace.Verbose || trace === Trace.Compact) && + message.params + ) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } + tracer.log( + `Received request '${message.method} - (${message.id})'.`, + data + ); + } else { + logLSPMessage('receive-request', message); + } + } + function traceReceivedNotification(message) { + if ( + trace === Trace.Off || + !tracer || + message.method === LogTraceNotification.type.method + ) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.params) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } else { + data = 'No parameters provided.\n\n'; + } + } + tracer.log(`Received notification '${message.method}'.`, data); + } else { + logLSPMessage('receive-notification', message); + } + } + function traceReceivedResponse(message, responsePromise) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.error && message.error.data) { + data = `Error data: ${stringifyTrace(message.error.data)} + +`; + } else { + if (message.result) { + data = `Result: ${stringifyTrace(message.result)} + +`; + } else if (message.error === void 0) { + data = 'No result returned.\n\n'; + } + } + } + if (responsePromise) { + const error = message.error + ? ` Request failed: ${message.error.message} (${message.error.code}).` + : ''; + tracer.log( + `Received response '${responsePromise.method} - (${ + message.id + })' in ${Date.now() - responsePromise.timerStart}ms.${error}`, + data + ); + } else { + tracer.log( + `Received response ${message.id} without active response promise.`, + data + ); + } + } else { + logLSPMessage('receive-response', message); + } + } + function logLSPMessage(type, message) { + if (!tracer || trace === Trace.Off) { + return; + } + const lspMessage = { + isLSPMessage: true, + type, + message, + timestamp: Date.now(), + }; + tracer.log(lspMessage); + } + function throwIfClosedOrDisposed() { + if (isClosed()) { + throw new ConnectionError( + ConnectionErrors.Closed, + 'Connection is closed.' + ); + } + if (isDisposed()) { + throw new ConnectionError( + ConnectionErrors.Disposed, + 'Connection is disposed.' + ); + } + } + function throwIfListening() { + if (isListening()) { + throw new ConnectionError( + ConnectionErrors.AlreadyListening, + 'Connection is already listening' + ); + } + } + function throwIfNotListening() { + if (!isListening()) { + throw new Error('Call listen() first.'); + } + } + function undefinedToNull(param) { + if (param === void 0) { + return null; + } else { + return param; + } + } + function nullToUndefined(param) { + if (param === null) { + return void 0; + } else { + return param; + } + } + function isNamedParam(param) { + return ( + param !== void 0 && + param !== null && + !Array.isArray(param) && + typeof param === 'object' + ); + } + function computeSingleParam(parameterStructures, param) { + switch (parameterStructures) { + case messages_1.ParameterStructures.auto: + if (isNamedParam(param)) { + return nullToUndefined(param); + } else { + return [undefinedToNull(param)]; + } + case messages_1.ParameterStructures.byName: + if (!isNamedParam(param)) { + throw new Error( + `Received parameters by name but param is not an object literal.` + ); + } + return nullToUndefined(param); + case messages_1.ParameterStructures.byPosition: + return [undefinedToNull(param)]; + default: + throw new Error( + `Unknown parameter structure ${parameterStructures.toString()}` + ); + } + } + function computeMessageParams(type, params) { + let result; + const numberOfParams = type.numberOfParams; + switch (numberOfParams) { + case 0: + result = void 0; + break; + case 1: + result = computeSingleParam(type.parameterStructures, params[0]); + break; + default: + result = []; + for (let i = 0; i < params.length && i < numberOfParams; i++) { + result.push(undefinedToNull(params[i])); + } + if (params.length < numberOfParams) { + for (let i = params.length; i < numberOfParams; i++) { + result.push(null); + } + } + break; + } + return result; + } + const connection = { + sendNotification: (type, ...args) => { + throwIfClosedOrDisposed(); + let method; + let messageParams; + if (Is2.string(type)) { + method = type; + const first = args[0]; + let paramStart = 0; + let parameterStructures = messages_1.ParameterStructures.auto; + if (messages_1.ParameterStructures.is(first)) { + paramStart = 1; + parameterStructures = first; + } + let paramEnd = args.length; + const numberOfParams = paramEnd - paramStart; + switch (numberOfParams) { + case 0: + messageParams = void 0; + break; + case 1: + messageParams = computeSingleParam( + parameterStructures, + args[paramStart] + ); + break; + default: + if ( + parameterStructures === messages_1.ParameterStructures.byName + ) { + throw new Error( + `Received ${numberOfParams} parameters for 'by Name' notification parameter structure.` + ); + } + messageParams = args + .slice(paramStart, paramEnd) + .map((value) => undefinedToNull(value)); + break; + } + } else { + const params = args; + method = type.method; + messageParams = computeMessageParams(type, params); + } + const notificationMessage = { + jsonrpc: version, + method, + params: messageParams, + }; + traceSendingNotification(notificationMessage); + return messageWriter + .write(notificationMessage) + .catch(() => logger.error(`Sending notification failed.`)); + }, + onNotification: (type, handler) => { + throwIfClosedOrDisposed(); + let method; + if (Is2.func(type)) { + starNotificationHandler = type; + } else if (handler) { + if (Is2.string(type)) { + method = type; + notificationHandlers[type] = { type: void 0, handler }; + } else { + method = type.method; + notificationHandlers[type.method] = { type, handler }; + } + } + return { + dispose: () => { + if (method !== void 0) { + delete notificationHandlers[method]; + } else { + starNotificationHandler = void 0; + } + }, + }; + }, + onProgress: (_type, token, handler) => { + if (progressHandlers.has(token)) { + throw new Error( + `Progress handler for token ${token} already registered` + ); + } + progressHandlers.set(token, handler); + return { + dispose: () => { + progressHandlers.delete(token); + }, + }; + }, + sendProgress: (_type, token, value) => { + return connection.sendNotification(ProgressNotification.type, { + token, + value, + }); + }, + onUnhandledProgress: unhandledProgressEmitter.event, + sendRequest: (type, ...args) => { + throwIfClosedOrDisposed(); + throwIfNotListening(); + let method; + let messageParams; + let token = void 0; + if (Is2.string(type)) { + method = type; + const first = args[0]; + const last = args[args.length - 1]; + let paramStart = 0; + let parameterStructures = messages_1.ParameterStructures.auto; + if (messages_1.ParameterStructures.is(first)) { + paramStart = 1; + parameterStructures = first; + } + let paramEnd = args.length; + if (cancellation_1.CancellationToken.is(last)) { + paramEnd = paramEnd - 1; + token = last; + } + const numberOfParams = paramEnd - paramStart; + switch (numberOfParams) { + case 0: + messageParams = void 0; + break; + case 1: + messageParams = computeSingleParam( + parameterStructures, + args[paramStart] + ); + break; + default: + if ( + parameterStructures === messages_1.ParameterStructures.byName + ) { + throw new Error( + `Received ${numberOfParams} parameters for 'by Name' request parameter structure.` + ); + } + messageParams = args + .slice(paramStart, paramEnd) + .map((value) => undefinedToNull(value)); + break; + } + } else { + const params = args; + method = type.method; + messageParams = computeMessageParams(type, params); + const numberOfParams = type.numberOfParams; + token = cancellation_1.CancellationToken.is(params[numberOfParams]) + ? params[numberOfParams] + : void 0; + } + const id = sequenceNumber++; + let disposable; + if (token) { + disposable = token.onCancellationRequested(() => { + const p = cancellationStrategy.sender.sendCancellation( + connection, + id + ); + if (p === void 0) { + logger.log( + `Received no promise from cancellation strategy when cancelling id ${id}` + ); + return Promise.resolve(); + } else { + return p.catch(() => { + logger.log( + `Sending cancellation messages for id ${id} failed` + ); + }); + } + }); + } + const result = new Promise((resolve, reject) => { + const requestMessage = { + jsonrpc: version, + id, + method, + params: messageParams, + }; + const resolveWithCleanup = (r) => { + resolve(r); + cancellationStrategy.sender.cleanup(id); + disposable?.dispose(); + }; + const rejectWithCleanup = (r) => { + reject(r); + cancellationStrategy.sender.cleanup(id); + disposable?.dispose(); + }; + let responsePromise = { + method, + timerStart: Date.now(), + resolve: resolveWithCleanup, + reject: rejectWithCleanup, + }; + traceSendingRequest(requestMessage); + try { + messageWriter + .write(requestMessage) + .catch(() => logger.error(`Sending request failed.`)); + } catch (e) { + responsePromise.reject( + new messages_1.ResponseError( + messages_1.ErrorCodes.MessageWriteError, + e.message ? e.message : 'Unknown reason' + ) + ); + responsePromise = null; + } + if (responsePromise) { + responsePromises[String(id)] = responsePromise; + } + }); + return result; + }, + onRequest: (type, handler) => { + throwIfClosedOrDisposed(); + let method = null; + if (StarRequestHandler.is(type)) { + method = void 0; + starRequestHandler = type; + } else if (Is2.string(type)) { + method = null; + if (handler !== void 0) { + method = type; + requestHandlers[type] = { handler, type: void 0 }; + } + } else { + if (handler !== void 0) { + method = type.method; + requestHandlers[type.method] = { type, handler }; + } + } + return { + dispose: () => { + if (method === null) { + return; + } + if (method !== void 0) { + delete requestHandlers[method]; + } else { + starRequestHandler = void 0; + } + }, + }; + }, + trace: (_value, _tracer, sendNotificationOrTraceOptions) => { + let _sendNotification = false; + let _traceFormat = TraceFormat.Text; + if (sendNotificationOrTraceOptions !== void 0) { + if (Is2.boolean(sendNotificationOrTraceOptions)) { + _sendNotification = sendNotificationOrTraceOptions; + } else { + _sendNotification = + sendNotificationOrTraceOptions.sendNotification || false; + _traceFormat = + sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text; + } + } + trace = _value; + traceFormat = _traceFormat; + if (trace === Trace.Off) { + tracer = void 0; + } else { + tracer = _tracer; + } + if (_sendNotification && !isClosed() && !isDisposed()) { + connection + .sendNotification(SetTraceNotification.type, { + value: Trace.toString(_value), + }) + .catch(() => { + logger.error(`Sending trace notification failed`); + }); + } + }, + onError: errorEmitter.event, + onClose: closeEmitter.event, + onUnhandledNotification: unhandledNotificationEmitter.event, + onDispose: disposeEmitter.event, + end: () => { + messageWriter.end(); + }, + dispose: () => { + if (isDisposed()) { + return; + } + state = ConnectionState.Disposed; + disposeEmitter.fire(void 0); + const error = new Error('Connection got disposed.'); + Object.keys(responsePromises).forEach((key) => { + responsePromises[key].reject(error); + }); + responsePromises = Object.create(null); + requestTokens = Object.create(null); + knownCanceledRequests = new Set(); + messageQueue = new linkedMap_1.LinkedMap(); + if (Is2.func(messageWriter.dispose)) { + messageWriter.dispose(); + } + if (Is2.func(messageReader.dispose)) { + messageReader.dispose(); + } + }, + listen: () => { + throwIfClosedOrDisposed(); + throwIfListening(); + state = ConnectionState.Listening; + messageReader.listen(callback); + }, + inspect: () => { + (0, ral_1.default)().console.log('inspect'); + }, + }; + connection.onNotification(LogTraceNotification.type, (params) => { + if (trace === Trace.Off || !tracer) { + return; + } + const verbose = trace === Trace.Verbose || trace === Trace.Compact; + tracer.log(params.message, verbose ? params.verbose : void 0); + }); + connection.onNotification(ProgressNotification.type, (params) => { + const handler = progressHandlers.get(params.token); + if (handler) { + handler(params.value); + } else { + unhandledProgressEmitter.fire(params); + } + }); + return connection; + } + exports.createMessageConnection = createMessageConnection; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/common/api.js +let require_api = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/common/api.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SetTraceNotification = exports.TraceFormat = exports.Trace = exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0; + exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = void 0; + let messages_1 = require_messages(); + Object.defineProperty(exports, 'Message', { + enumerable: true, + get: function () { + return messages_1.Message; + }, + }); + Object.defineProperty(exports, 'RequestType', { + enumerable: true, + get: function () { + return messages_1.RequestType; + }, + }); + Object.defineProperty(exports, 'RequestType0', { + enumerable: true, + get: function () { + return messages_1.RequestType0; + }, + }); + Object.defineProperty(exports, 'RequestType1', { + enumerable: true, + get: function () { + return messages_1.RequestType1; + }, + }); + Object.defineProperty(exports, 'RequestType2', { + enumerable: true, + get: function () { + return messages_1.RequestType2; + }, + }); + Object.defineProperty(exports, 'RequestType3', { + enumerable: true, + get: function () { + return messages_1.RequestType3; + }, + }); + Object.defineProperty(exports, 'RequestType4', { + enumerable: true, + get: function () { + return messages_1.RequestType4; + }, + }); + Object.defineProperty(exports, 'RequestType5', { + enumerable: true, + get: function () { + return messages_1.RequestType5; + }, + }); + Object.defineProperty(exports, 'RequestType6', { + enumerable: true, + get: function () { + return messages_1.RequestType6; + }, + }); + Object.defineProperty(exports, 'RequestType7', { + enumerable: true, + get: function () { + return messages_1.RequestType7; + }, + }); + Object.defineProperty(exports, 'RequestType8', { + enumerable: true, + get: function () { + return messages_1.RequestType8; + }, + }); + Object.defineProperty(exports, 'RequestType9', { + enumerable: true, + get: function () { + return messages_1.RequestType9; + }, + }); + Object.defineProperty(exports, 'ResponseError', { + enumerable: true, + get: function () { + return messages_1.ResponseError; + }, + }); + Object.defineProperty(exports, 'ErrorCodes', { + enumerable: true, + get: function () { + return messages_1.ErrorCodes; + }, + }); + Object.defineProperty(exports, 'NotificationType', { + enumerable: true, + get: function () { + return messages_1.NotificationType; + }, + }); + Object.defineProperty(exports, 'NotificationType0', { + enumerable: true, + get: function () { + return messages_1.NotificationType0; + }, + }); + Object.defineProperty(exports, 'NotificationType1', { + enumerable: true, + get: function () { + return messages_1.NotificationType1; + }, + }); + Object.defineProperty(exports, 'NotificationType2', { + enumerable: true, + get: function () { + return messages_1.NotificationType2; + }, + }); + Object.defineProperty(exports, 'NotificationType3', { + enumerable: true, + get: function () { + return messages_1.NotificationType3; + }, + }); + Object.defineProperty(exports, 'NotificationType4', { + enumerable: true, + get: function () { + return messages_1.NotificationType4; + }, + }); + Object.defineProperty(exports, 'NotificationType5', { + enumerable: true, + get: function () { + return messages_1.NotificationType5; + }, + }); + Object.defineProperty(exports, 'NotificationType6', { + enumerable: true, + get: function () { + return messages_1.NotificationType6; + }, + }); + Object.defineProperty(exports, 'NotificationType7', { + enumerable: true, + get: function () { + return messages_1.NotificationType7; + }, + }); + Object.defineProperty(exports, 'NotificationType8', { + enumerable: true, + get: function () { + return messages_1.NotificationType8; + }, + }); + Object.defineProperty(exports, 'NotificationType9', { + enumerable: true, + get: function () { + return messages_1.NotificationType9; + }, + }); + Object.defineProperty(exports, 'ParameterStructures', { + enumerable: true, + get: function () { + return messages_1.ParameterStructures; + }, + }); + let linkedMap_1 = require_linkedMap(); + Object.defineProperty(exports, 'LinkedMap', { + enumerable: true, + get: function () { + return linkedMap_1.LinkedMap; + }, + }); + Object.defineProperty(exports, 'LRUCache', { + enumerable: true, + get: function () { + return linkedMap_1.LRUCache; + }, + }); + Object.defineProperty(exports, 'Touch', { + enumerable: true, + get: function () { + return linkedMap_1.Touch; + }, + }); + let disposable_1 = require_disposable(); + Object.defineProperty(exports, 'Disposable', { + enumerable: true, + get: function () { + return disposable_1.Disposable; + }, + }); + let events_1 = require_events(); + Object.defineProperty(exports, 'Event', { + enumerable: true, + get: function () { + return events_1.Event; + }, + }); + Object.defineProperty(exports, 'Emitter', { + enumerable: true, + get: function () { + return events_1.Emitter; + }, + }); + let cancellation_1 = require_cancellation(); + Object.defineProperty(exports, 'CancellationTokenSource', { + enumerable: true, + get: function () { + return cancellation_1.CancellationTokenSource; + }, + }); + Object.defineProperty(exports, 'CancellationToken', { + enumerable: true, + get: function () { + return cancellation_1.CancellationToken; + }, + }); + let messageReader_1 = require_messageReader(); + Object.defineProperty(exports, 'MessageReader', { + enumerable: true, + get: function () { + return messageReader_1.MessageReader; + }, + }); + Object.defineProperty(exports, 'AbstractMessageReader', { + enumerable: true, + get: function () { + return messageReader_1.AbstractMessageReader; + }, + }); + Object.defineProperty(exports, 'ReadableStreamMessageReader', { + enumerable: true, + get: function () { + return messageReader_1.ReadableStreamMessageReader; + }, + }); + let messageWriter_1 = require_messageWriter(); + Object.defineProperty(exports, 'MessageWriter', { + enumerable: true, + get: function () { + return messageWriter_1.MessageWriter; + }, + }); + Object.defineProperty(exports, 'AbstractMessageWriter', { + enumerable: true, + get: function () { + return messageWriter_1.AbstractMessageWriter; + }, + }); + Object.defineProperty(exports, 'WriteableStreamMessageWriter', { + enumerable: true, + get: function () { + return messageWriter_1.WriteableStreamMessageWriter; + }, + }); + let connection_1 = require_connection(); + Object.defineProperty(exports, 'ConnectionStrategy', { + enumerable: true, + get: function () { + return connection_1.ConnectionStrategy; + }, + }); + Object.defineProperty(exports, 'ConnectionOptions', { + enumerable: true, + get: function () { + return connection_1.ConnectionOptions; + }, + }); + Object.defineProperty(exports, 'NullLogger', { + enumerable: true, + get: function () { + return connection_1.NullLogger; + }, + }); + Object.defineProperty(exports, 'createMessageConnection', { + enumerable: true, + get: function () { + return connection_1.createMessageConnection; + }, + }); + Object.defineProperty(exports, 'ProgressToken', { + enumerable: true, + get: function () { + return connection_1.ProgressToken; + }, + }); + Object.defineProperty(exports, 'ProgressType', { + enumerable: true, + get: function () { + return connection_1.ProgressType; + }, + }); + Object.defineProperty(exports, 'Trace', { + enumerable: true, + get: function () { + return connection_1.Trace; + }, + }); + Object.defineProperty(exports, 'TraceFormat', { + enumerable: true, + get: function () { + return connection_1.TraceFormat; + }, + }); + Object.defineProperty(exports, 'SetTraceNotification', { + enumerable: true, + get: function () { + return connection_1.SetTraceNotification; + }, + }); + Object.defineProperty(exports, 'LogTraceNotification', { + enumerable: true, + get: function () { + return connection_1.LogTraceNotification; + }, + }); + Object.defineProperty(exports, 'ConnectionErrors', { + enumerable: true, + get: function () { + return connection_1.ConnectionErrors; + }, + }); + Object.defineProperty(exports, 'ConnectionError', { + enumerable: true, + get: function () { + return connection_1.ConnectionError; + }, + }); + Object.defineProperty(exports, 'CancellationReceiverStrategy', { + enumerable: true, + get: function () { + return connection_1.CancellationReceiverStrategy; + }, + }); + Object.defineProperty(exports, 'CancellationSenderStrategy', { + enumerable: true, + get: function () { + return connection_1.CancellationSenderStrategy; + }, + }); + Object.defineProperty(exports, 'CancellationStrategy', { + enumerable: true, + get: function () { + return connection_1.CancellationStrategy; + }, + }); + let ral_1 = require_ral(); + exports.RAL = ral_1.default; + }, +}); + +// client/node_modules/vscode-jsonrpc/lib/browser/main.js +let require_main = __commonJS({ + 'client/node_modules/vscode-jsonrpc/lib/browser/main.js'(exports) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createMessageConnection = exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0; + let ril_1 = require_ril(); + ril_1.default.install(); + let api_1 = require_api(); + __exportStar(require_api(), exports); + let BrowserMessageReader = class extends api_1.AbstractMessageReader { + constructor(context) { + super(); + this._onData = new api_1.Emitter(); + this._messageListener = (event) => { + this._onData.fire(event.data); + }; + context.addEventListener('error', (event) => this.fireError(event)); + context.onmessage = this._messageListener; + } + listen(callback) { + return this._onData.event(callback); + } + }; + exports.BrowserMessageReader = BrowserMessageReader; + let BrowserMessageWriter = class extends api_1.AbstractMessageWriter { + constructor(context) { + super(); + this.context = context; + this.errorCount = 0; + context.addEventListener('error', (event) => this.fireError(event)); + } + write(msg) { + try { + this.context.postMessage(msg); + return Promise.resolve(); + } catch (error) { + this.handleError(error, msg); + return Promise.reject(error); + } + } + handleError(error, msg) { + this.errorCount++; + this.fireError(error, msg, this.errorCount); + } + end() {} + }; + exports.BrowserMessageWriter = BrowserMessageWriter; + function createMessageConnection(reader, writer, logger, options) { + if (logger === void 0) { + logger = api_1.NullLogger; + } + if (api_1.ConnectionStrategy.is(options)) { + options = { connectionStrategy: options }; + } + return (0, api_1.createMessageConnection)( + reader, + writer, + logger, + options + ); + } + exports.createMessageConnection = createMessageConnection; + }, +}); + +// client/node_modules/vscode-jsonrpc/browser.js +let require_browser = __commonJS({ + 'client/node_modules/vscode-jsonrpc/browser.js'(exports, module2) { + 'use strict'; + module2.exports = require_main(); + }, +}); + +// client/node_modules/vscode-languageserver-types/lib/umd/main.js +let require_main2 = __commonJS({ + 'client/node_modules/vscode-languageserver-types/lib/umd/main.js'( + exports, + module2 + ) { + (function (factory) { + if (typeof module2 === 'object' && typeof module2.exports === 'object') { + let v = factory(require, exports); + if (v !== void 0) { + module2.exports = v; + } + } else if (typeof define === 'function' && define.amd) { + define(['require', 'exports'], factory); + } + })(function (require2, exports2) { + 'use strict'; + Object.defineProperty(exports2, '__esModule', { value: true }); + exports2.TextDocument = exports2.EOL = exports2.InlineValuesContext = exports2.InlineValueEvaluatableExpression = exports2.InlineValueVariableLookup = exports2.InlineValueText = exports2.SemanticTokens = exports2.SemanticTokenModifiers = exports2.SemanticTokenTypes = exports2.SelectionRange = exports2.DocumentLink = exports2.FormattingOptions = exports2.CodeLens = exports2.CodeAction = exports2.CodeActionContext = exports2.CodeActionTriggerKind = exports2.CodeActionKind = exports2.DocumentSymbol = exports2.WorkspaceSymbol = exports2.SymbolInformation = exports2.SymbolTag = exports2.SymbolKind = exports2.DocumentHighlight = exports2.DocumentHighlightKind = exports2.SignatureInformation = exports2.ParameterInformation = exports2.Hover = exports2.MarkedString = exports2.CompletionList = exports2.CompletionItem = exports2.CompletionItemLabelDetails = exports2.InsertTextMode = exports2.InsertReplaceEdit = exports2.CompletionItemTag = exports2.InsertTextFormat = exports2.CompletionItemKind = exports2.MarkupContent = exports2.MarkupKind = exports2.TextDocumentItem = exports2.OptionalVersionedTextDocumentIdentifier = exports2.VersionedTextDocumentIdentifier = exports2.TextDocumentIdentifier = exports2.WorkspaceChange = exports2.WorkspaceEdit = exports2.DeleteFile = exports2.RenameFile = exports2.CreateFile = exports2.TextDocumentEdit = exports2.AnnotatedTextEdit = exports2.ChangeAnnotationIdentifier = exports2.ChangeAnnotation = exports2.TextEdit = exports2.Command = exports2.Diagnostic = exports2.CodeDescription = exports2.DiagnosticTag = exports2.DiagnosticSeverity = exports2.DiagnosticRelatedInformation = exports2.FoldingRange = exports2.FoldingRangeKind = exports2.ColorPresentation = exports2.ColorInformation = exports2.Color = exports2.LocationLink = exports2.Location = exports2.Range = exports2.Position = exports2.uinteger = exports2.integer = void 0; + let integer; + (function (integer2) { + integer2.MIN_VALUE = -2147483648; + integer2.MAX_VALUE = 2147483647; + })((integer = exports2.integer || (exports2.integer = {}))); + let uinteger; + (function (uinteger2) { + uinteger2.MIN_VALUE = 0; + uinteger2.MAX_VALUE = 2147483647; + })((uinteger = exports2.uinteger || (exports2.uinteger = {}))); + let Position; + (function (Position2) { + function create(line, character) { + if (line === Number.MAX_VALUE) { + line = uinteger.MAX_VALUE; + } + if (character === Number.MAX_VALUE) { + character = uinteger.MAX_VALUE; + } + return { line, character }; + } + Position2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Is2.uinteger(candidate.line) && + Is2.uinteger(candidate.character) + ); + } + Position2.is = is2; + })((Position = exports2.Position || (exports2.Position = {}))); + let Range; + (function (Range2) { + function create(one, two, three, four) { + if ( + Is2.uinteger(one) && + Is2.uinteger(two) && + Is2.uinteger(three) && + Is2.uinteger(four) + ) { + return { + start: Position.create(one, two), + end: Position.create(three, four), + }; + } else if (Position.is(one) && Position.is(two)) { + return { start: one, end: two }; + } else { + throw new Error( + 'Range#create called with invalid arguments[' + .concat(one, ', ') + .concat(two, ', ') + .concat(three, ', ') + .concat(four, ']') + ); + } + } + Range2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Position.is(candidate.start) && + Position.is(candidate.end) + ); + } + Range2.is = is2; + })((Range = exports2.Range || (exports2.Range = {}))); + let Location; + (function (Location2) { + function create(uri, range) { + return { uri, range }; + } + Location2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Range.is(candidate.range) && + (Is2.string(candidate.uri) || Is2.undefined(candidate.uri)) + ); + } + Location2.is = is2; + })((Location = exports2.Location || (exports2.Location = {}))); + let LocationLink; + (function (LocationLink2) { + function create( + targetUri, + targetRange, + targetSelectionRange, + originSelectionRange + ) { + return { + targetUri, + targetRange, + targetSelectionRange, + originSelectionRange, + }; + } + LocationLink2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Range.is(candidate.targetRange) && + Is2.string(candidate.targetUri) && + Range.is(candidate.targetSelectionRange) && + (Range.is(candidate.originSelectionRange) || + Is2.undefined(candidate.originSelectionRange)) + ); + } + LocationLink2.is = is2; + })( + (LocationLink = exports2.LocationLink || (exports2.LocationLink = {})) + ); + let Color; + (function (Color2) { + function create(red, green, blue, alpha) { + return { + red, + green, + blue, + alpha, + }; + } + Color2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Is2.numberRange(candidate.red, 0, 1) && + Is2.numberRange(candidate.green, 0, 1) && + Is2.numberRange(candidate.blue, 0, 1) && + Is2.numberRange(candidate.alpha, 0, 1) + ); + } + Color2.is = is2; + })((Color = exports2.Color || (exports2.Color = {}))); + let ColorInformation; + (function (ColorInformation2) { + function create(range, color) { + return { + range, + color, + }; + } + ColorInformation2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Range.is(candidate.range) && + Color.is(candidate.color) + ); + } + ColorInformation2.is = is2; + })( + (ColorInformation = + exports2.ColorInformation || (exports2.ColorInformation = {})) + ); + let ColorPresentation; + (function (ColorPresentation2) { + function create(label, textEdit, additionalTextEdits) { + return { + label, + textEdit, + additionalTextEdits, + }; + } + ColorPresentation2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Is2.string(candidate.label) && + (Is2.undefined(candidate.textEdit) || TextEdit.is(candidate)) && + (Is2.undefined(candidate.additionalTextEdits) || + Is2.typedArray(candidate.additionalTextEdits, TextEdit.is)) + ); + } + ColorPresentation2.is = is2; + })( + (ColorPresentation = + exports2.ColorPresentation || (exports2.ColorPresentation = {})) + ); + let FoldingRangeKind; + (function (FoldingRangeKind2) { + FoldingRangeKind2['Comment'] = 'comment'; + FoldingRangeKind2['Imports'] = 'imports'; + FoldingRangeKind2['Region'] = 'region'; + })( + (FoldingRangeKind = + exports2.FoldingRangeKind || (exports2.FoldingRangeKind = {})) + ); + let FoldingRange; + (function (FoldingRange2) { + function create( + startLine, + endLine, + startCharacter, + endCharacter, + kind + ) { + let result = { + startLine, + endLine, + }; + if (Is2.defined(startCharacter)) { + result.startCharacter = startCharacter; + } + if (Is2.defined(endCharacter)) { + result.endCharacter = endCharacter; + } + if (Is2.defined(kind)) { + result.kind = kind; + } + return result; + } + FoldingRange2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Is2.uinteger(candidate.startLine) && + Is2.uinteger(candidate.startLine) && + (Is2.undefined(candidate.startCharacter) || + Is2.uinteger(candidate.startCharacter)) && + (Is2.undefined(candidate.endCharacter) || + Is2.uinteger(candidate.endCharacter)) && + (Is2.undefined(candidate.kind) || Is2.string(candidate.kind)) + ); + } + FoldingRange2.is = is2; + })( + (FoldingRange = exports2.FoldingRange || (exports2.FoldingRange = {})) + ); + let DiagnosticRelatedInformation; + (function (DiagnosticRelatedInformation2) { + function create(location2, message) { + return { + location: location2, + message, + }; + } + DiagnosticRelatedInformation2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Location.is(candidate.location) && + Is2.string(candidate.message) + ); + } + DiagnosticRelatedInformation2.is = is2; + })( + (DiagnosticRelatedInformation = + exports2.DiagnosticRelatedInformation || + (exports2.DiagnosticRelatedInformation = {})) + ); + let DiagnosticSeverity; + (function (DiagnosticSeverity2) { + DiagnosticSeverity2.Error = 1; + DiagnosticSeverity2.Warning = 2; + DiagnosticSeverity2.Information = 3; + DiagnosticSeverity2.Hint = 4; + })( + (DiagnosticSeverity = + exports2.DiagnosticSeverity || (exports2.DiagnosticSeverity = {})) + ); + let DiagnosticTag; + (function (DiagnosticTag2) { + DiagnosticTag2.Unnecessary = 1; + DiagnosticTag2.Deprecated = 2; + })( + (DiagnosticTag = + exports2.DiagnosticTag || (exports2.DiagnosticTag = {})) + ); + let CodeDescription; + (function (CodeDescription2) { + function is2(value) { + let candidate = value; + return Is2.objectLiteral(candidate) && Is2.string(candidate.href); + } + CodeDescription2.is = is2; + })( + (CodeDescription = + exports2.CodeDescription || (exports2.CodeDescription = {})) + ); + let Diagnostic; + (function (Diagnostic2) { + function create( + range, + message, + severity, + code, + source, + relatedInformation + ) { + let result = { range, message }; + if (Is2.defined(severity)) { + result.severity = severity; + } + if (Is2.defined(code)) { + result.code = code; + } + if (Is2.defined(source)) { + result.source = source; + } + if (Is2.defined(relatedInformation)) { + result.relatedInformation = relatedInformation; + } + return result; + } + Diagnostic2.create = create; + function is2(value) { + let _a2; + let candidate = value; + return ( + Is2.defined(candidate) && + Range.is(candidate.range) && + Is2.string(candidate.message) && + (Is2.number(candidate.severity) || + Is2.undefined(candidate.severity)) && + (Is2.integer(candidate.code) || + Is2.string(candidate.code) || + Is2.undefined(candidate.code)) && + (Is2.undefined(candidate.codeDescription) || + Is2.string( + (_a2 = candidate.codeDescription) === null || _a2 === void 0 + ? void 0 + : _a2.href + )) && + (Is2.string(candidate.source) || Is2.undefined(candidate.source)) && + (Is2.undefined(candidate.relatedInformation) || + Is2.typedArray( + candidate.relatedInformation, + DiagnosticRelatedInformation.is + )) + ); + } + Diagnostic2.is = is2; + })((Diagnostic = exports2.Diagnostic || (exports2.Diagnostic = {}))); + let Command; + (function (Command2) { + function create(title, command) { + let args = []; + for (let _i2 = 2; _i2 < arguments.length; _i2++) { + args[_i2 - 2] = arguments[_i2]; + } + let result = { title, command }; + if (Is2.defined(args) && args.length > 0) { + result.arguments = args; + } + return result; + } + Command2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Is2.string(candidate.title) && + Is2.string(candidate.command) + ); + } + Command2.is = is2; + })((Command = exports2.Command || (exports2.Command = {}))); + let TextEdit; + (function (TextEdit2) { + function replace(range, newText) { + return { range, newText }; + } + TextEdit2.replace = replace; + function insert(position, newText) { + return { range: { start: position, end: position }, newText }; + } + TextEdit2.insert = insert; + function del(range) { + return { range, newText: '' }; + } + TextEdit2.del = del; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Is2.string(candidate.newText) && + Range.is(candidate.range) + ); + } + TextEdit2.is = is2; + })((TextEdit = exports2.TextEdit || (exports2.TextEdit = {}))); + let ChangeAnnotation; + (function (ChangeAnnotation2) { + function create(label, needsConfirmation, description) { + let result = { label }; + if (needsConfirmation !== void 0) { + result.needsConfirmation = needsConfirmation; + } + if (description !== void 0) { + result.description = description; + } + return result; + } + ChangeAnnotation2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Is2.string(candidate.label) && + (Is2.boolean(candidate.needsConfirmation) || + candidate.needsConfirmation === void 0) && + (Is2.string(candidate.description) || + candidate.description === void 0) + ); + } + ChangeAnnotation2.is = is2; + })( + (ChangeAnnotation = + exports2.ChangeAnnotation || (exports2.ChangeAnnotation = {})) + ); + let ChangeAnnotationIdentifier; + (function (ChangeAnnotationIdentifier2) { + function is2(value) { + let candidate = value; + return Is2.string(candidate); + } + ChangeAnnotationIdentifier2.is = is2; + })( + (ChangeAnnotationIdentifier = + exports2.ChangeAnnotationIdentifier || + (exports2.ChangeAnnotationIdentifier = {})) + ); + let AnnotatedTextEdit; + (function (AnnotatedTextEdit2) { + function replace(range, newText, annotation) { + return { range, newText, annotationId: annotation }; + } + AnnotatedTextEdit2.replace = replace; + function insert(position, newText, annotation) { + return { + range: { start: position, end: position }, + newText, + annotationId: annotation, + }; + } + AnnotatedTextEdit2.insert = insert; + function del(range, annotation) { + return { range, newText: '', annotationId: annotation }; + } + AnnotatedTextEdit2.del = del; + function is2(value) { + let candidate = value; + return ( + TextEdit.is(candidate) && + (ChangeAnnotation.is(candidate.annotationId) || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + AnnotatedTextEdit2.is = is2; + })( + (AnnotatedTextEdit = + exports2.AnnotatedTextEdit || (exports2.AnnotatedTextEdit = {})) + ); + let TextDocumentEdit; + (function (TextDocumentEdit2) { + function create(textDocument, edits) { + return { textDocument, edits }; + } + TextDocumentEdit2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + OptionalVersionedTextDocumentIdentifier.is( + candidate.textDocument + ) && + Array.isArray(candidate.edits) + ); + } + TextDocumentEdit2.is = is2; + })( + (TextDocumentEdit = + exports2.TextDocumentEdit || (exports2.TextDocumentEdit = {})) + ); + let CreateFile; + (function (CreateFile2) { + function create(uri, options, annotation) { + let result = { + kind: 'create', + uri, + }; + if ( + options !== void 0 && + (options.overwrite !== void 0 || options.ignoreIfExists !== void 0) + ) { + result.options = options; + } + if (annotation !== void 0) { + result.annotationId = annotation; + } + return result; + } + CreateFile2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate && + candidate.kind === 'create' && + Is2.string(candidate.uri) && + (candidate.options === void 0 || + ((candidate.options.overwrite === void 0 || + Is2.boolean(candidate.options.overwrite)) && + (candidate.options.ignoreIfExists === void 0 || + Is2.boolean(candidate.options.ignoreIfExists)))) && + (candidate.annotationId === void 0 || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + CreateFile2.is = is2; + })((CreateFile = exports2.CreateFile || (exports2.CreateFile = {}))); + let RenameFile; + (function (RenameFile2) { + function create(oldUri, newUri, options, annotation) { + let result = { + kind: 'rename', + oldUri, + newUri, + }; + if ( + options !== void 0 && + (options.overwrite !== void 0 || options.ignoreIfExists !== void 0) + ) { + result.options = options; + } + if (annotation !== void 0) { + result.annotationId = annotation; + } + return result; + } + RenameFile2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate && + candidate.kind === 'rename' && + Is2.string(candidate.oldUri) && + Is2.string(candidate.newUri) && + (candidate.options === void 0 || + ((candidate.options.overwrite === void 0 || + Is2.boolean(candidate.options.overwrite)) && + (candidate.options.ignoreIfExists === void 0 || + Is2.boolean(candidate.options.ignoreIfExists)))) && + (candidate.annotationId === void 0 || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + RenameFile2.is = is2; + })((RenameFile = exports2.RenameFile || (exports2.RenameFile = {}))); + let DeleteFile; + (function (DeleteFile2) { + function create(uri, options, annotation) { + let result = { + kind: 'delete', + uri, + }; + if ( + options !== void 0 && + (options.recursive !== void 0 || + options.ignoreIfNotExists !== void 0) + ) { + result.options = options; + } + if (annotation !== void 0) { + result.annotationId = annotation; + } + return result; + } + DeleteFile2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate && + candidate.kind === 'delete' && + Is2.string(candidate.uri) && + (candidate.options === void 0 || + ((candidate.options.recursive === void 0 || + Is2.boolean(candidate.options.recursive)) && + (candidate.options.ignoreIfNotExists === void 0 || + Is2.boolean(candidate.options.ignoreIfNotExists)))) && + (candidate.annotationId === void 0 || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + DeleteFile2.is = is2; + })((DeleteFile = exports2.DeleteFile || (exports2.DeleteFile = {}))); + let WorkspaceEdit; + (function (WorkspaceEdit2) { + function is2(value) { + let candidate = value; + return ( + candidate && + (candidate.changes !== void 0 || + candidate.documentChanges !== void 0) && + (candidate.documentChanges === void 0 || + candidate.documentChanges.every(function (change) { + if (Is2.string(change.kind)) { + return ( + CreateFile.is(change) || + RenameFile.is(change) || + DeleteFile.is(change) + ); + } else { + return TextDocumentEdit.is(change); + } + })) + ); + } + WorkspaceEdit2.is = is2; + })( + (WorkspaceEdit = + exports2.WorkspaceEdit || (exports2.WorkspaceEdit = {})) + ); + let TextEditChangeImpl = (function () { + function TextEditChangeImpl2(edits, changeAnnotations) { + this.edits = edits; + this.changeAnnotations = changeAnnotations; + } + TextEditChangeImpl2.prototype.insert = function ( + position, + newText, + annotation + ) { + let edit; + let id; + if (annotation === void 0) { + edit = TextEdit.insert(position, newText); + } else if (ChangeAnnotationIdentifier.is(annotation)) { + id = annotation; + edit = AnnotatedTextEdit.insert(position, newText, annotation); + } else { + this.assertChangeAnnotations(this.changeAnnotations); + id = this.changeAnnotations.manage(annotation); + edit = AnnotatedTextEdit.insert(position, newText, id); + } + this.edits.push(edit); + if (id !== void 0) { + return id; + } + }; + TextEditChangeImpl2.prototype.replace = function ( + range, + newText, + annotation + ) { + let edit; + let id; + if (annotation === void 0) { + edit = TextEdit.replace(range, newText); + } else if (ChangeAnnotationIdentifier.is(annotation)) { + id = annotation; + edit = AnnotatedTextEdit.replace(range, newText, annotation); + } else { + this.assertChangeAnnotations(this.changeAnnotations); + id = this.changeAnnotations.manage(annotation); + edit = AnnotatedTextEdit.replace(range, newText, id); + } + this.edits.push(edit); + if (id !== void 0) { + return id; + } + }; + TextEditChangeImpl2.prototype.delete = function (range, annotation) { + let edit; + let id; + if (annotation === void 0) { + edit = TextEdit.del(range); + } else if (ChangeAnnotationIdentifier.is(annotation)) { + id = annotation; + edit = AnnotatedTextEdit.del(range, annotation); + } else { + this.assertChangeAnnotations(this.changeAnnotations); + id = this.changeAnnotations.manage(annotation); + edit = AnnotatedTextEdit.del(range, id); + } + this.edits.push(edit); + if (id !== void 0) { + return id; + } + }; + TextEditChangeImpl2.prototype.add = function (edit) { + this.edits.push(edit); + }; + TextEditChangeImpl2.prototype.all = function () { + return this.edits; + }; + TextEditChangeImpl2.prototype.clear = function () { + this.edits.splice(0, this.edits.length); + }; + TextEditChangeImpl2.prototype.assertChangeAnnotations = function ( + value + ) { + if (value === void 0) { + throw new Error( + 'Text edit change is not configured to manage change annotations.' + ); + } + }; + return TextEditChangeImpl2; + })(); + let ChangeAnnotations = (function () { + function ChangeAnnotations2(annotations) { + this._annotations = + annotations === void 0 ? Object.create(null) : annotations; + this._counter = 0; + this._size = 0; + } + ChangeAnnotations2.prototype.all = function () { + return this._annotations; + }; + Object.defineProperty(ChangeAnnotations2.prototype, 'size', { + get: function () { + return this._size; + }, + enumerable: false, + configurable: true, + }); + ChangeAnnotations2.prototype.manage = function ( + idOrAnnotation, + annotation + ) { + let id; + if (ChangeAnnotationIdentifier.is(idOrAnnotation)) { + id = idOrAnnotation; + } else { + id = this.nextId(); + annotation = idOrAnnotation; + } + if (this._annotations[id] !== void 0) { + throw new Error('Id '.concat(id, ' is already in use.')); + } + if (annotation === void 0) { + throw new Error('No annotation provided for id '.concat(id)); + } + this._annotations[id] = annotation; + this._size++; + return id; + }; + ChangeAnnotations2.prototype.nextId = function () { + this._counter++; + return this._counter.toString(); + }; + return ChangeAnnotations2; + })(); + let WorkspaceChange = (function () { + function WorkspaceChange2(workspaceEdit) { + let _this = this; + this._textEditChanges = Object.create(null); + if (workspaceEdit !== void 0) { + this._workspaceEdit = workspaceEdit; + if (workspaceEdit.documentChanges) { + this._changeAnnotations = new ChangeAnnotations( + workspaceEdit.changeAnnotations + ); + workspaceEdit.changeAnnotations = this._changeAnnotations.all(); + workspaceEdit.documentChanges.forEach(function (change) { + if (TextDocumentEdit.is(change)) { + let textEditChange = new TextEditChangeImpl( + change.edits, + _this._changeAnnotations + ); + _this._textEditChanges[ + change.textDocument.uri + ] = textEditChange; + } + }); + } else if (workspaceEdit.changes) { + Object.keys(workspaceEdit.changes).forEach(function (key) { + let textEditChange = new TextEditChangeImpl( + workspaceEdit.changes[key] + ); + _this._textEditChanges[key] = textEditChange; + }); + } + } else { + this._workspaceEdit = {}; + } + } + Object.defineProperty(WorkspaceChange2.prototype, 'edit', { + get: function () { + this.initDocumentChanges(); + if (this._changeAnnotations !== void 0) { + if (this._changeAnnotations.size === 0) { + this._workspaceEdit.changeAnnotations = void 0; + } else { + this._workspaceEdit.changeAnnotations = this._changeAnnotations.all(); + } + } + return this._workspaceEdit; + }, + enumerable: false, + configurable: true, + }); + WorkspaceChange2.prototype.getTextEditChange = function (key) { + if (OptionalVersionedTextDocumentIdentifier.is(key)) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let textDocument = { uri: key.uri, version: key.version }; + var result = this._textEditChanges[textDocument.uri]; + if (!result) { + var edits = []; + let textDocumentEdit = { + textDocument, + edits, + }; + this._workspaceEdit.documentChanges.push(textDocumentEdit); + result = new TextEditChangeImpl(edits, this._changeAnnotations); + this._textEditChanges[textDocument.uri] = result; + } + return result; + } else { + this.initChanges(); + if (this._workspaceEdit.changes === void 0) { + throw new Error( + 'Workspace edit is not configured for normal text edit changes.' + ); + } + var result = this._textEditChanges[key]; + if (!result) { + var edits = []; + this._workspaceEdit.changes[key] = edits; + result = new TextEditChangeImpl(edits); + this._textEditChanges[key] = result; + } + return result; + } + }; + WorkspaceChange2.prototype.initDocumentChanges = function () { + if ( + this._workspaceEdit.documentChanges === void 0 && + this._workspaceEdit.changes === void 0 + ) { + this._changeAnnotations = new ChangeAnnotations(); + this._workspaceEdit.documentChanges = []; + this._workspaceEdit.changeAnnotations = this._changeAnnotations.all(); + } + }; + WorkspaceChange2.prototype.initChanges = function () { + if ( + this._workspaceEdit.documentChanges === void 0 && + this._workspaceEdit.changes === void 0 + ) { + this._workspaceEdit.changes = Object.create(null); + } + }; + WorkspaceChange2.prototype.createFile = function ( + uri, + optionsOrAnnotation, + options + ) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let annotation; + if ( + ChangeAnnotation.is(optionsOrAnnotation) || + ChangeAnnotationIdentifier.is(optionsOrAnnotation) + ) { + annotation = optionsOrAnnotation; + } else { + options = optionsOrAnnotation; + } + let operation; + let id; + if (annotation === void 0) { + operation = CreateFile.create(uri, options); + } else { + id = ChangeAnnotationIdentifier.is(annotation) + ? annotation + : this._changeAnnotations.manage(annotation); + operation = CreateFile.create(uri, options, id); + } + this._workspaceEdit.documentChanges.push(operation); + if (id !== void 0) { + return id; + } + }; + WorkspaceChange2.prototype.renameFile = function ( + oldUri, + newUri, + optionsOrAnnotation, + options + ) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let annotation; + if ( + ChangeAnnotation.is(optionsOrAnnotation) || + ChangeAnnotationIdentifier.is(optionsOrAnnotation) + ) { + annotation = optionsOrAnnotation; + } else { + options = optionsOrAnnotation; + } + let operation; + let id; + if (annotation === void 0) { + operation = RenameFile.create(oldUri, newUri, options); + } else { + id = ChangeAnnotationIdentifier.is(annotation) + ? annotation + : this._changeAnnotations.manage(annotation); + operation = RenameFile.create(oldUri, newUri, options, id); + } + this._workspaceEdit.documentChanges.push(operation); + if (id !== void 0) { + return id; + } + }; + WorkspaceChange2.prototype.deleteFile = function ( + uri, + optionsOrAnnotation, + options + ) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let annotation; + if ( + ChangeAnnotation.is(optionsOrAnnotation) || + ChangeAnnotationIdentifier.is(optionsOrAnnotation) + ) { + annotation = optionsOrAnnotation; + } else { + options = optionsOrAnnotation; + } + let operation; + let id; + if (annotation === void 0) { + operation = DeleteFile.create(uri, options); + } else { + id = ChangeAnnotationIdentifier.is(annotation) + ? annotation + : this._changeAnnotations.manage(annotation); + operation = DeleteFile.create(uri, options, id); + } + this._workspaceEdit.documentChanges.push(operation); + if (id !== void 0) { + return id; + } + }; + return WorkspaceChange2; + })(); + exports2.WorkspaceChange = WorkspaceChange; + let TextDocumentIdentifier; + (function (TextDocumentIdentifier2) { + function create(uri) { + return { uri }; + } + TextDocumentIdentifier2.create = create; + function is2(value) { + let candidate = value; + return Is2.defined(candidate) && Is2.string(candidate.uri); + } + TextDocumentIdentifier2.is = is2; + })( + (TextDocumentIdentifier = + exports2.TextDocumentIdentifier || + (exports2.TextDocumentIdentifier = {})) + ); + let VersionedTextDocumentIdentifier; + (function (VersionedTextDocumentIdentifier2) { + function create(uri, version) { + return { uri, version }; + } + VersionedTextDocumentIdentifier2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Is2.string(candidate.uri) && + Is2.integer(candidate.version) + ); + } + VersionedTextDocumentIdentifier2.is = is2; + })( + (VersionedTextDocumentIdentifier = + exports2.VersionedTextDocumentIdentifier || + (exports2.VersionedTextDocumentIdentifier = {})) + ); + let OptionalVersionedTextDocumentIdentifier; + (function (OptionalVersionedTextDocumentIdentifier2) { + function create(uri, version) { + return { uri, version }; + } + OptionalVersionedTextDocumentIdentifier2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Is2.string(candidate.uri) && + (candidate.version === null || Is2.integer(candidate.version)) + ); + } + OptionalVersionedTextDocumentIdentifier2.is = is2; + })( + (OptionalVersionedTextDocumentIdentifier = + exports2.OptionalVersionedTextDocumentIdentifier || + (exports2.OptionalVersionedTextDocumentIdentifier = {})) + ); + let TextDocumentItem; + (function (TextDocumentItem2) { + function create(uri, languageId, version, text) { + return { uri, languageId, version, text }; + } + TextDocumentItem2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Is2.string(candidate.uri) && + Is2.string(candidate.languageId) && + Is2.integer(candidate.version) && + Is2.string(candidate.text) + ); + } + TextDocumentItem2.is = is2; + })( + (TextDocumentItem = + exports2.TextDocumentItem || (exports2.TextDocumentItem = {})) + ); + let MarkupKind; + (function (MarkupKind2) { + MarkupKind2.PlainText = 'plaintext'; + MarkupKind2.Markdown = 'markdown'; + })((MarkupKind = exports2.MarkupKind || (exports2.MarkupKind = {}))); + (function (MarkupKind2) { + function is2(value) { + let candidate = value; + return ( + candidate === MarkupKind2.PlainText || + candidate === MarkupKind2.Markdown + ); + } + MarkupKind2.is = is2; + })((MarkupKind = exports2.MarkupKind || (exports2.MarkupKind = {}))); + let MarkupContent; + (function (MarkupContent2) { + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(value) && + MarkupKind.is(candidate.kind) && + Is2.string(candidate.value) + ); + } + MarkupContent2.is = is2; + })( + (MarkupContent = + exports2.MarkupContent || (exports2.MarkupContent = {})) + ); + let CompletionItemKind; + (function (CompletionItemKind2) { + CompletionItemKind2.Text = 1; + CompletionItemKind2.Method = 2; + CompletionItemKind2.Function = 3; + CompletionItemKind2.Constructor = 4; + CompletionItemKind2.Field = 5; + CompletionItemKind2.Variable = 6; + CompletionItemKind2.Class = 7; + CompletionItemKind2.Interface = 8; + CompletionItemKind2.Module = 9; + CompletionItemKind2.Property = 10; + CompletionItemKind2.Unit = 11; + CompletionItemKind2.Value = 12; + CompletionItemKind2.Enum = 13; + CompletionItemKind2.Keyword = 14; + CompletionItemKind2.Snippet = 15; + CompletionItemKind2.Color = 16; + CompletionItemKind2.File = 17; + CompletionItemKind2.Reference = 18; + CompletionItemKind2.Folder = 19; + CompletionItemKind2.EnumMember = 20; + CompletionItemKind2.Constant = 21; + CompletionItemKind2.Struct = 22; + CompletionItemKind2.Event = 23; + CompletionItemKind2.Operator = 24; + CompletionItemKind2.TypeParameter = 25; + })( + (CompletionItemKind = + exports2.CompletionItemKind || (exports2.CompletionItemKind = {})) + ); + let InsertTextFormat; + (function (InsertTextFormat2) { + InsertTextFormat2.PlainText = 1; + InsertTextFormat2.Snippet = 2; + })( + (InsertTextFormat = + exports2.InsertTextFormat || (exports2.InsertTextFormat = {})) + ); + let CompletionItemTag; + (function (CompletionItemTag2) { + CompletionItemTag2.Deprecated = 1; + })( + (CompletionItemTag = + exports2.CompletionItemTag || (exports2.CompletionItemTag = {})) + ); + let InsertReplaceEdit; + (function (InsertReplaceEdit2) { + function create(newText, insert, replace) { + return { newText, insert, replace }; + } + InsertReplaceEdit2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.string(candidate.newText) && + Range.is(candidate.insert) && + Range.is(candidate.replace) + ); + } + InsertReplaceEdit2.is = is2; + })( + (InsertReplaceEdit = + exports2.InsertReplaceEdit || (exports2.InsertReplaceEdit = {})) + ); + let InsertTextMode; + (function (InsertTextMode2) { + InsertTextMode2.asIs = 1; + InsertTextMode2.adjustIndentation = 2; + })( + (InsertTextMode = + exports2.InsertTextMode || (exports2.InsertTextMode = {})) + ); + let CompletionItemLabelDetails; + (function (CompletionItemLabelDetails2) { + function is2(value) { + let candidate = value; + return ( + candidate && + (Is2.string(candidate.detail) || candidate.detail === void 0) && + (Is2.string(candidate.description) || + candidate.description === void 0) + ); + } + CompletionItemLabelDetails2.is = is2; + })( + (CompletionItemLabelDetails = + exports2.CompletionItemLabelDetails || + (exports2.CompletionItemLabelDetails = {})) + ); + let CompletionItem; + (function (CompletionItem2) { + function create(label) { + return { label }; + } + CompletionItem2.create = create; + })( + (CompletionItem = + exports2.CompletionItem || (exports2.CompletionItem = {})) + ); + let CompletionList; + (function (CompletionList2) { + function create(items, isIncomplete) { + return { items: items ? items : [], isIncomplete: !!isIncomplete }; + } + CompletionList2.create = create; + })( + (CompletionList = + exports2.CompletionList || (exports2.CompletionList = {})) + ); + let MarkedString; + (function (MarkedString2) { + function fromPlainText(plainText) { + return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); + } + MarkedString2.fromPlainText = fromPlainText; + function is2(value) { + let candidate = value; + return ( + Is2.string(candidate) || + (Is2.objectLiteral(candidate) && + Is2.string(candidate.language) && + Is2.string(candidate.value)) + ); + } + MarkedString2.is = is2; + })( + (MarkedString = exports2.MarkedString || (exports2.MarkedString = {})) + ); + let Hover; + (function (Hover2) { + function is2(value) { + let candidate = value; + return ( + !!candidate && + Is2.objectLiteral(candidate) && + (MarkupContent.is(candidate.contents) || + MarkedString.is(candidate.contents) || + Is2.typedArray(candidate.contents, MarkedString.is)) && + (value.range === void 0 || Range.is(value.range)) + ); + } + Hover2.is = is2; + })((Hover = exports2.Hover || (exports2.Hover = {}))); + let ParameterInformation; + (function (ParameterInformation2) { + function create(label, documentation) { + return documentation ? { label, documentation } : { label }; + } + ParameterInformation2.create = create; + })( + (ParameterInformation = + exports2.ParameterInformation || (exports2.ParameterInformation = {})) + ); + let SignatureInformation; + (function (SignatureInformation2) { + function create(label, documentation) { + let parameters = []; + for (let _i2 = 2; _i2 < arguments.length; _i2++) { + parameters[_i2 - 2] = arguments[_i2]; + } + let result = { label }; + if (Is2.defined(documentation)) { + result.documentation = documentation; + } + if (Is2.defined(parameters)) { + result.parameters = parameters; + } else { + result.parameters = []; + } + return result; + } + SignatureInformation2.create = create; + })( + (SignatureInformation = + exports2.SignatureInformation || (exports2.SignatureInformation = {})) + ); + let DocumentHighlightKind; + (function (DocumentHighlightKind2) { + DocumentHighlightKind2.Text = 1; + DocumentHighlightKind2.Read = 2; + DocumentHighlightKind2.Write = 3; + })( + (DocumentHighlightKind = + exports2.DocumentHighlightKind || + (exports2.DocumentHighlightKind = {})) + ); + let DocumentHighlight; + (function (DocumentHighlight2) { + function create(range, kind) { + let result = { range }; + if (Is2.number(kind)) { + result.kind = kind; + } + return result; + } + DocumentHighlight2.create = create; + })( + (DocumentHighlight = + exports2.DocumentHighlight || (exports2.DocumentHighlight = {})) + ); + let SymbolKind; + (function (SymbolKind2) { + SymbolKind2.File = 1; + SymbolKind2.Module = 2; + SymbolKind2.Namespace = 3; + SymbolKind2.Package = 4; + SymbolKind2.Class = 5; + SymbolKind2.Method = 6; + SymbolKind2.Property = 7; + SymbolKind2.Field = 8; + SymbolKind2.Constructor = 9; + SymbolKind2.Enum = 10; + SymbolKind2.Interface = 11; + SymbolKind2.Function = 12; + SymbolKind2.Variable = 13; + SymbolKind2.Constant = 14; + SymbolKind2.String = 15; + SymbolKind2.Number = 16; + SymbolKind2.Boolean = 17; + SymbolKind2.Array = 18; + SymbolKind2.Object = 19; + SymbolKind2.Key = 20; + SymbolKind2.Null = 21; + SymbolKind2.EnumMember = 22; + SymbolKind2.Struct = 23; + SymbolKind2.Event = 24; + SymbolKind2.Operator = 25; + SymbolKind2.TypeParameter = 26; + })((SymbolKind = exports2.SymbolKind || (exports2.SymbolKind = {}))); + let SymbolTag; + (function (SymbolTag2) { + SymbolTag2.Deprecated = 1; + })((SymbolTag = exports2.SymbolTag || (exports2.SymbolTag = {}))); + let SymbolInformation; + (function (SymbolInformation2) { + function create(name, kind, range, uri, containerName) { + let result = { + name, + kind, + location: { uri, range }, + }; + if (containerName) { + result.containerName = containerName; + } + return result; + } + SymbolInformation2.create = create; + })( + (SymbolInformation = + exports2.SymbolInformation || (exports2.SymbolInformation = {})) + ); + let WorkspaceSymbol; + (function (WorkspaceSymbol2) { + function create(name, kind, uri, range) { + return range !== void 0 + ? { name, kind, location: { uri, range } } + : { name, kind, location: { uri } }; + } + WorkspaceSymbol2.create = create; + })( + (WorkspaceSymbol = + exports2.WorkspaceSymbol || (exports2.WorkspaceSymbol = {})) + ); + let DocumentSymbol; + (function (DocumentSymbol2) { + function create(name, detail, kind, range, selectionRange, children) { + let result = { + name, + detail, + kind, + range, + selectionRange, + }; + if (children !== void 0) { + result.children = children; + } + return result; + } + DocumentSymbol2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.string(candidate.name) && + Is2.number(candidate.kind) && + Range.is(candidate.range) && + Range.is(candidate.selectionRange) && + (candidate.detail === void 0 || Is2.string(candidate.detail)) && + (candidate.deprecated === void 0 || + Is2.boolean(candidate.deprecated)) && + (candidate.children === void 0 || + Array.isArray(candidate.children)) && + (candidate.tags === void 0 || Array.isArray(candidate.tags)) + ); + } + DocumentSymbol2.is = is2; + })( + (DocumentSymbol = + exports2.DocumentSymbol || (exports2.DocumentSymbol = {})) + ); + let CodeActionKind; + (function (CodeActionKind2) { + CodeActionKind2.Empty = ''; + CodeActionKind2.QuickFix = 'quickfix'; + CodeActionKind2.Refactor = 'refactor'; + CodeActionKind2.RefactorExtract = 'refactor.extract'; + CodeActionKind2.RefactorInline = 'refactor.inline'; + CodeActionKind2.RefactorRewrite = 'refactor.rewrite'; + CodeActionKind2.Source = 'source'; + CodeActionKind2.SourceOrganizeImports = 'source.organizeImports'; + CodeActionKind2.SourceFixAll = 'source.fixAll'; + })( + (CodeActionKind = + exports2.CodeActionKind || (exports2.CodeActionKind = {})) + ); + let CodeActionTriggerKind; + (function (CodeActionTriggerKind2) { + CodeActionTriggerKind2.Invoked = 1; + CodeActionTriggerKind2.Automatic = 2; + })( + (CodeActionTriggerKind = + exports2.CodeActionTriggerKind || + (exports2.CodeActionTriggerKind = {})) + ); + let CodeActionContext; + (function (CodeActionContext2) { + function create(diagnostics, only, triggerKind) { + let result = { diagnostics }; + if (only !== void 0 && only !== null) { + result.only = only; + } + if (triggerKind !== void 0 && triggerKind !== null) { + result.triggerKind = triggerKind; + } + return result; + } + CodeActionContext2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Is2.typedArray(candidate.diagnostics, Diagnostic.is) && + (candidate.only === void 0 || + Is2.typedArray(candidate.only, Is2.string)) && + (candidate.triggerKind === void 0 || + candidate.triggerKind === CodeActionTriggerKind.Invoked || + candidate.triggerKind === CodeActionTriggerKind.Automatic) + ); + } + CodeActionContext2.is = is2; + })( + (CodeActionContext = + exports2.CodeActionContext || (exports2.CodeActionContext = {})) + ); + let CodeAction; + (function (CodeAction2) { + function create(title, kindOrCommandOrEdit, kind) { + let result = { title }; + let checkKind = true; + if (typeof kindOrCommandOrEdit === 'string') { + checkKind = false; + result.kind = kindOrCommandOrEdit; + } else if (Command.is(kindOrCommandOrEdit)) { + result.command = kindOrCommandOrEdit; + } else { + result.edit = kindOrCommandOrEdit; + } + if (checkKind && kind !== void 0) { + result.kind = kind; + } + return result; + } + CodeAction2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.string(candidate.title) && + (candidate.diagnostics === void 0 || + Is2.typedArray(candidate.diagnostics, Diagnostic.is)) && + (candidate.kind === void 0 || Is2.string(candidate.kind)) && + (candidate.edit !== void 0 || candidate.command !== void 0) && + (candidate.command === void 0 || Command.is(candidate.command)) && + (candidate.isPreferred === void 0 || + Is2.boolean(candidate.isPreferred)) && + (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit)) + ); + } + CodeAction2.is = is2; + })((CodeAction = exports2.CodeAction || (exports2.CodeAction = {}))); + let CodeLens; + (function (CodeLens2) { + function create(range, data) { + let result = { range }; + if (Is2.defined(data)) { + result.data = data; + } + return result; + } + CodeLens2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Range.is(candidate.range) && + (Is2.undefined(candidate.command) || Command.is(candidate.command)) + ); + } + CodeLens2.is = is2; + })((CodeLens = exports2.CodeLens || (exports2.CodeLens = {}))); + let FormattingOptions; + (function (FormattingOptions2) { + function create(tabSize, insertSpaces) { + return { tabSize, insertSpaces }; + } + FormattingOptions2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Is2.uinteger(candidate.tabSize) && + Is2.boolean(candidate.insertSpaces) + ); + } + FormattingOptions2.is = is2; + })( + (FormattingOptions = + exports2.FormattingOptions || (exports2.FormattingOptions = {})) + ); + let DocumentLink; + (function (DocumentLink2) { + function create(range, target, data) { + return { range, target, data }; + } + DocumentLink2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.defined(candidate) && + Range.is(candidate.range) && + (Is2.undefined(candidate.target) || Is2.string(candidate.target)) + ); + } + DocumentLink2.is = is2; + })( + (DocumentLink = exports2.DocumentLink || (exports2.DocumentLink = {})) + ); + let SelectionRange; + (function (SelectionRange2) { + function create(range, parent) { + return { range, parent }; + } + SelectionRange2.create = create; + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + Range.is(candidate.range) && + (candidate.parent === void 0 || + SelectionRange2.is(candidate.parent)) + ); + } + SelectionRange2.is = is2; + })( + (SelectionRange = + exports2.SelectionRange || (exports2.SelectionRange = {})) + ); + let SemanticTokenTypes; + (function (SemanticTokenTypes2) { + SemanticTokenTypes2['namespace'] = 'namespace'; + SemanticTokenTypes2['type'] = 'type'; + SemanticTokenTypes2['class'] = 'class'; + SemanticTokenTypes2['enum'] = 'enum'; + SemanticTokenTypes2['interface'] = 'interface'; + SemanticTokenTypes2['struct'] = 'struct'; + SemanticTokenTypes2['typeParameter'] = 'typeParameter'; + SemanticTokenTypes2['parameter'] = 'parameter'; + SemanticTokenTypes2['variable'] = 'variable'; + SemanticTokenTypes2['property'] = 'property'; + SemanticTokenTypes2['enumMember'] = 'enumMember'; + SemanticTokenTypes2['event'] = 'event'; + SemanticTokenTypes2['function'] = 'function'; + SemanticTokenTypes2['method'] = 'method'; + SemanticTokenTypes2['macro'] = 'macro'; + SemanticTokenTypes2['keyword'] = 'keyword'; + SemanticTokenTypes2['modifier'] = 'modifier'; + SemanticTokenTypes2['comment'] = 'comment'; + SemanticTokenTypes2['string'] = 'string'; + SemanticTokenTypes2['number'] = 'number'; + SemanticTokenTypes2['regexp'] = 'regexp'; + SemanticTokenTypes2['operator'] = 'operator'; + SemanticTokenTypes2['decorator'] = 'decorator'; + })( + (SemanticTokenTypes = + exports2.SemanticTokenTypes || (exports2.SemanticTokenTypes = {})) + ); + let SemanticTokenModifiers; + (function (SemanticTokenModifiers2) { + SemanticTokenModifiers2['declaration'] = 'declaration'; + SemanticTokenModifiers2['definition'] = 'definition'; + SemanticTokenModifiers2['readonly'] = 'readonly'; + SemanticTokenModifiers2['static'] = 'static'; + SemanticTokenModifiers2['deprecated'] = 'deprecated'; + SemanticTokenModifiers2['abstract'] = 'abstract'; + SemanticTokenModifiers2['async'] = 'async'; + SemanticTokenModifiers2['modification'] = 'modification'; + SemanticTokenModifiers2['documentation'] = 'documentation'; + SemanticTokenModifiers2['defaultLibrary'] = 'defaultLibrary'; + })( + (SemanticTokenModifiers = + exports2.SemanticTokenModifiers || + (exports2.SemanticTokenModifiers = {})) + ); + let SemanticTokens; + (function (SemanticTokens2) { + function is2(value) { + let candidate = value; + return ( + Is2.objectLiteral(candidate) && + (candidate.resultId === void 0 || + typeof candidate.resultId === 'string') && + Array.isArray(candidate.data) && + (candidate.data.length === 0 || + typeof candidate.data[0] === 'number') + ); + } + SemanticTokens2.is = is2; + })( + (SemanticTokens = + exports2.SemanticTokens || (exports2.SemanticTokens = {})) + ); + let InlineValueText; + (function (InlineValueText2) { + function create(range, text) { + return { range, text }; + } + InlineValueText2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + Range.is(candidate.range) && + Is2.string(candidate.text) + ); + } + InlineValueText2.is = is2; + })( + (InlineValueText = + exports2.InlineValueText || (exports2.InlineValueText = {})) + ); + let InlineValueVariableLookup; + (function (InlineValueVariableLookup2) { + function create(range, variableName, caseSensitiveLookup) { + return { range, variableName, caseSensitiveLookup }; + } + InlineValueVariableLookup2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + Range.is(candidate.range) && + Is2.boolean(candidate.caseSensitiveLookup) && + (Is2.string(candidate.variableName) || + candidate.variableName === void 0) + ); + } + InlineValueVariableLookup2.is = is2; + })( + (InlineValueVariableLookup = + exports2.InlineValueVariableLookup || + (exports2.InlineValueVariableLookup = {})) + ); + let InlineValueEvaluatableExpression; + (function (InlineValueEvaluatableExpression2) { + function create(range, expression) { + return { range, expression }; + } + InlineValueEvaluatableExpression2.create = create; + function is2(value) { + let candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + Range.is(candidate.range) && + (Is2.string(candidate.expression) || + candidate.expression === void 0) + ); + } + InlineValueEvaluatableExpression2.is = is2; + })( + (InlineValueEvaluatableExpression = + exports2.InlineValueEvaluatableExpression || + (exports2.InlineValueEvaluatableExpression = {})) + ); + let InlineValuesContext; + (function (InlineValuesContext2) { + function create(stoppedLocation) { + return { stoppedLocation }; + } + InlineValuesContext2.create = create; + function is2(value) { + let candidate = value; + return Is2.defined(candidate) && Range.is(value.stoppedLocation); + } + InlineValuesContext2.is = is2; + })( + (InlineValuesContext = + exports2.InlineValuesContext || (exports2.InlineValuesContext = {})) + ); + exports2.EOL = ['\n', '\r\n', '\r']; + let TextDocument; + (function (TextDocument2) { + function create(uri, languageId, version, content) { + return new FullTextDocument(uri, languageId, version, content); + } + TextDocument2.create = create; + function is2(value) { + let candidate = value; + return Is2.defined(candidate) && + Is2.string(candidate.uri) && + (Is2.undefined(candidate.languageId) || + Is2.string(candidate.languageId)) && + Is2.uinteger(candidate.lineCount) && + Is2.func(candidate.getText) && + Is2.func(candidate.positionAt) && + Is2.func(candidate.offsetAt) + ? true + : false; + } + TextDocument2.is = is2; + function applyEdits(document2, edits) { + let text = document2.getText(); + let sortedEdits = mergeSort(edits, function (a, b) { + let diff = a.range.start.line - b.range.start.line; + if (diff === 0) { + return a.range.start.character - b.range.start.character; + } + return diff; + }); + let lastModifiedOffset = text.length; + for (let i = sortedEdits.length - 1; i >= 0; i--) { + let e = sortedEdits[i]; + let startOffset = document2.offsetAt(e.range.start); + let endOffset = document2.offsetAt(e.range.end); + if (endOffset <= lastModifiedOffset) { + text = + text.substring(0, startOffset) + + e.newText + + text.substring(endOffset, text.length); + } else { + throw new Error('Overlapping edit'); + } + lastModifiedOffset = startOffset; + } + return text; + } + TextDocument2.applyEdits = applyEdits; + function mergeSort(data, compare) { + if (data.length <= 1) { + return data; + } + let p = (data.length / 2) | 0; + let left = data.slice(0, p); + let right = data.slice(p); + mergeSort(left, compare); + mergeSort(right, compare); + let leftIdx = 0; + let rightIdx = 0; + let i = 0; + while (leftIdx < left.length && rightIdx < right.length) { + let ret = compare(left[leftIdx], right[rightIdx]); + if (ret <= 0) { + data[i++] = left[leftIdx++]; + } else { + data[i++] = right[rightIdx++]; + } + } + while (leftIdx < left.length) { + data[i++] = left[leftIdx++]; + } + while (rightIdx < right.length) { + data[i++] = right[rightIdx++]; + } + return data; + } + })( + (TextDocument = exports2.TextDocument || (exports2.TextDocument = {})) + ); + var FullTextDocument = (function () { + function FullTextDocument2(uri, languageId, version, content) { + this._uri = uri; + this._languageId = languageId; + this._version = version; + this._content = content; + this._lineOffsets = void 0; + } + Object.defineProperty(FullTextDocument2.prototype, 'uri', { + get: function () { + return this._uri; + }, + enumerable: false, + configurable: true, + }); + Object.defineProperty(FullTextDocument2.prototype, 'languageId', { + get: function () { + return this._languageId; + }, + enumerable: false, + configurable: true, + }); + Object.defineProperty(FullTextDocument2.prototype, 'version', { + get: function () { + return this._version; + }, + enumerable: false, + configurable: true, + }); + FullTextDocument2.prototype.getText = function (range) { + if (range) { + let start = this.offsetAt(range.start); + let end = this.offsetAt(range.end); + return this._content.substring(start, end); + } + return this._content; + }; + FullTextDocument2.prototype.update = function (event, version) { + this._content = event.text; + this._version = version; + this._lineOffsets = void 0; + }; + FullTextDocument2.prototype.getLineOffsets = function () { + if (this._lineOffsets === void 0) { + let lineOffsets = []; + let text = this._content; + let isLineStart = true; + for (let i = 0; i < text.length; i++) { + if (isLineStart) { + lineOffsets.push(i); + isLineStart = false; + } + let ch = text.charAt(i); + isLineStart = ch === '\r' || ch === '\n'; + if ( + ch === '\r' && + i + 1 < text.length && + text.charAt(i + 1) === '\n' + ) { + i++; + } + } + if (isLineStart && text.length > 0) { + lineOffsets.push(text.length); + } + this._lineOffsets = lineOffsets; + } + return this._lineOffsets; + }; + FullTextDocument2.prototype.positionAt = function (offset) { + offset = Math.max(Math.min(offset, this._content.length), 0); + let lineOffsets = this.getLineOffsets(); + let low = 0, + high = lineOffsets.length; + if (high === 0) { + return Position.create(0, offset); + } + while (low < high) { + let mid = Math.floor((low + high) / 2); + if (lineOffsets[mid] > offset) { + high = mid; + } else { + low = mid + 1; + } + } + let line = low - 1; + return Position.create(line, offset - lineOffsets[line]); + }; + FullTextDocument2.prototype.offsetAt = function (position) { + let lineOffsets = this.getLineOffsets(); + if (position.line >= lineOffsets.length) { + return this._content.length; + } else if (position.line < 0) { + return 0; + } + let lineOffset = lineOffsets[position.line]; + let nextLineOffset = + position.line + 1 < lineOffsets.length + ? lineOffsets[position.line + 1] + : this._content.length; + return Math.max( + Math.min(lineOffset + position.character, nextLineOffset), + lineOffset + ); + }; + Object.defineProperty(FullTextDocument2.prototype, 'lineCount', { + get: function () { + return this.getLineOffsets().length; + }, + enumerable: false, + configurable: true, + }); + return FullTextDocument2; + })(); + let Is2; + (function (Is3) { + let toString = Object.prototype.toString; + function defined(value) { + return typeof value !== 'undefined'; + } + Is3.defined = defined; + function undefined2(value) { + return typeof value === 'undefined'; + } + Is3.undefined = undefined2; + function boolean(value) { + return value === true || value === false; + } + Is3.boolean = boolean; + function string(value) { + return toString.call(value) === '[object String]'; + } + Is3.string = string; + function number(value) { + return toString.call(value) === '[object Number]'; + } + Is3.number = number; + function numberRange(value, min, max) { + return ( + toString.call(value) === '[object Number]' && + min <= value && + value <= max + ); + } + Is3.numberRange = numberRange; + function integer2(value) { + return ( + toString.call(value) === '[object Number]' && + -2147483648 <= value && + value <= 2147483647 + ); + } + Is3.integer = integer2; + function uinteger2(value) { + return ( + toString.call(value) === '[object Number]' && + 0 <= value && + value <= 2147483647 + ); + } + Is3.uinteger = uinteger2; + function func(value) { + return toString.call(value) === '[object Function]'; + } + Is3.func = func; + function objectLiteral(value) { + return value !== null && typeof value === 'object'; + } + Is3.objectLiteral = objectLiteral; + function typedArray(value, check) { + return Array.isArray(value) && value.every(check); + } + Is3.typedArray = typedArray; + })(Is2 || (Is2 = {})); + }); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/messages.js +let require_messages2 = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/messages.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = void 0; + let vscode_jsonrpc_1 = require_main(); + let RegistrationType = class { + constructor(method) { + this.method = method; + } + }; + exports.RegistrationType = RegistrationType; + let ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 { + constructor(method) { + super(method); + } + }; + exports.ProtocolRequestType0 = ProtocolRequestType0; + let ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType { + constructor(method) { + super(method, vscode_jsonrpc_1.ParameterStructures.byName); + } + }; + exports.ProtocolRequestType = ProtocolRequestType; + let ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 { + constructor(method) { + super(method); + } + }; + exports.ProtocolNotificationType0 = ProtocolNotificationType0; + let ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType { + constructor(method) { + super(method, vscode_jsonrpc_1.ParameterStructures.byName); + } + }; + exports.ProtocolNotificationType = ProtocolNotificationType; + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js +let require_is2 = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.objectLiteral = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0; + function boolean(value) { + return value === true || value === false; + } + exports.boolean = boolean; + function string(value) { + return typeof value === 'string' || value instanceof String; + } + exports.string = string; + function number(value) { + return typeof value === 'number' || value instanceof Number; + } + exports.number = number; + function error(value) { + return value instanceof Error; + } + exports.error = error; + function func(value) { + return typeof value === 'function'; + } + exports.func = func; + function array(value) { + return Array.isArray(value); + } + exports.array = array; + function stringArray(value) { + return array(value) && value.every((elem) => string(elem)); + } + exports.stringArray = stringArray; + function typedArray(value, check) { + return Array.isArray(value) && value.every(check); + } + exports.typedArray = typedArray; + function objectLiteral(value) { + return value !== null && typeof value === 'object'; + } + exports.objectLiteral = objectLiteral; + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js +let require_protocol_implementation = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ImplementationRequest = void 0; + let messages_1 = require_messages2(); + let ImplementationRequest; + (function (ImplementationRequest2) { + ImplementationRequest2.method = 'textDocument/implementation'; + ImplementationRequest2.type = new messages_1.ProtocolRequestType( + ImplementationRequest2.method + ); + })( + (ImplementationRequest = + exports.ImplementationRequest || (exports.ImplementationRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js +let require_protocol_typeDefinition = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeDefinitionRequest = void 0; + let messages_1 = require_messages2(); + let TypeDefinitionRequest; + (function (TypeDefinitionRequest2) { + TypeDefinitionRequest2.method = 'textDocument/typeDefinition'; + TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType( + TypeDefinitionRequest2.method + ); + })( + (TypeDefinitionRequest = + exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js +let require_protocol_workspaceFolders = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0; + let messages_1 = require_messages2(); + let WorkspaceFoldersRequest; + (function (WorkspaceFoldersRequest2) { + WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0( + 'workspace/workspaceFolders' + ); + })( + (WorkspaceFoldersRequest = + exports.WorkspaceFoldersRequest || + (exports.WorkspaceFoldersRequest = {})) + ); + let DidChangeWorkspaceFoldersNotification; + (function (DidChangeWorkspaceFoldersNotification2) { + DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType( + 'workspace/didChangeWorkspaceFolders' + ); + })( + (DidChangeWorkspaceFoldersNotification = + exports.DidChangeWorkspaceFoldersNotification || + (exports.DidChangeWorkspaceFoldersNotification = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js +let require_protocol_configuration = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ConfigurationRequest = void 0; + let messages_1 = require_messages2(); + let ConfigurationRequest; + (function (ConfigurationRequest2) { + ConfigurationRequest2.type = new messages_1.ProtocolRequestType( + 'workspace/configuration' + ); + })( + (ConfigurationRequest = + exports.ConfigurationRequest || (exports.ConfigurationRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js +let require_protocol_colorProvider = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ColorPresentationRequest = exports.DocumentColorRequest = void 0; + let messages_1 = require_messages2(); + let DocumentColorRequest; + (function (DocumentColorRequest2) { + DocumentColorRequest2.method = 'textDocument/documentColor'; + DocumentColorRequest2.type = new messages_1.ProtocolRequestType( + DocumentColorRequest2.method + ); + })( + (DocumentColorRequest = + exports.DocumentColorRequest || (exports.DocumentColorRequest = {})) + ); + let ColorPresentationRequest; + (function (ColorPresentationRequest2) { + ColorPresentationRequest2.type = new messages_1.ProtocolRequestType( + 'textDocument/colorPresentation' + ); + })( + (ColorPresentationRequest = + exports.ColorPresentationRequest || + (exports.ColorPresentationRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js +let require_protocol_foldingRange = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.FoldingRangeRequest = exports.FoldingRangeKind = void 0; + let messages_1 = require_messages2(); + let FoldingRangeKind; + (function (FoldingRangeKind2) { + FoldingRangeKind2['Comment'] = 'comment'; + FoldingRangeKind2['Imports'] = 'imports'; + FoldingRangeKind2['Region'] = 'region'; + })( + (FoldingRangeKind = + exports.FoldingRangeKind || (exports.FoldingRangeKind = {})) + ); + let FoldingRangeRequest; + (function (FoldingRangeRequest2) { + FoldingRangeRequest2.method = 'textDocument/foldingRange'; + FoldingRangeRequest2.type = new messages_1.ProtocolRequestType( + FoldingRangeRequest2.method + ); + })( + (FoldingRangeRequest = + exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js +let require_protocol_declaration = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DeclarationRequest = void 0; + let messages_1 = require_messages2(); + let DeclarationRequest; + (function (DeclarationRequest2) { + DeclarationRequest2.method = 'textDocument/declaration'; + DeclarationRequest2.type = new messages_1.ProtocolRequestType( + DeclarationRequest2.method + ); + })( + (DeclarationRequest = + exports.DeclarationRequest || (exports.DeclarationRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js +let require_protocol_selectionRange = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SelectionRangeRequest = void 0; + let messages_1 = require_messages2(); + let SelectionRangeRequest; + (function (SelectionRangeRequest2) { + SelectionRangeRequest2.method = 'textDocument/selectionRange'; + SelectionRangeRequest2.type = new messages_1.ProtocolRequestType( + SelectionRangeRequest2.method + ); + })( + (SelectionRangeRequest = + exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js +let require_protocol_progress = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0; + let vscode_jsonrpc_1 = require_main(); + let messages_1 = require_messages2(); + let WorkDoneProgress; + (function (WorkDoneProgress2) { + WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType(); + function is2(value) { + return value === WorkDoneProgress2.type; + } + WorkDoneProgress2.is = is2; + })( + (WorkDoneProgress = + exports.WorkDoneProgress || (exports.WorkDoneProgress = {})) + ); + let WorkDoneProgressCreateRequest; + (function (WorkDoneProgressCreateRequest2) { + WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType( + 'window/workDoneProgress/create' + ); + })( + (WorkDoneProgressCreateRequest = + exports.WorkDoneProgressCreateRequest || + (exports.WorkDoneProgressCreateRequest = {})) + ); + let WorkDoneProgressCancelNotification; + (function (WorkDoneProgressCancelNotification2) { + WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType( + 'window/workDoneProgress/cancel' + ); + })( + (WorkDoneProgressCancelNotification = + exports.WorkDoneProgressCancelNotification || + (exports.WorkDoneProgressCancelNotification = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js +let require_protocol_callHierarchy = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0; + let messages_1 = require_messages2(); + let CallHierarchyPrepareRequest; + (function (CallHierarchyPrepareRequest2) { + CallHierarchyPrepareRequest2.method = 'textDocument/prepareCallHierarchy'; + CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType( + CallHierarchyPrepareRequest2.method + ); + })( + (CallHierarchyPrepareRequest = + exports.CallHierarchyPrepareRequest || + (exports.CallHierarchyPrepareRequest = {})) + ); + let CallHierarchyIncomingCallsRequest; + (function (CallHierarchyIncomingCallsRequest2) { + CallHierarchyIncomingCallsRequest2.method = 'callHierarchy/incomingCalls'; + CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType( + CallHierarchyIncomingCallsRequest2.method + ); + })( + (CallHierarchyIncomingCallsRequest = + exports.CallHierarchyIncomingCallsRequest || + (exports.CallHierarchyIncomingCallsRequest = {})) + ); + let CallHierarchyOutgoingCallsRequest; + (function (CallHierarchyOutgoingCallsRequest2) { + CallHierarchyOutgoingCallsRequest2.method = 'callHierarchy/outgoingCalls'; + CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType( + CallHierarchyOutgoingCallsRequest2.method + ); + })( + (CallHierarchyOutgoingCallsRequest = + exports.CallHierarchyOutgoingCallsRequest || + (exports.CallHierarchyOutgoingCallsRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js +let require_protocol_semanticTokens = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = void 0; + let messages_1 = require_messages2(); + let TokenFormat; + (function (TokenFormat2) { + TokenFormat2.Relative = 'relative'; + })((TokenFormat = exports.TokenFormat || (exports.TokenFormat = {}))); + let SemanticTokensRegistrationType; + (function (SemanticTokensRegistrationType2) { + SemanticTokensRegistrationType2.method = 'textDocument/semanticTokens'; + SemanticTokensRegistrationType2.type = new messages_1.RegistrationType( + SemanticTokensRegistrationType2.method + ); + })( + (SemanticTokensRegistrationType = + exports.SemanticTokensRegistrationType || + (exports.SemanticTokensRegistrationType = {})) + ); + let SemanticTokensRequest; + (function (SemanticTokensRequest2) { + SemanticTokensRequest2.method = 'textDocument/semanticTokens/full'; + SemanticTokensRequest2.type = new messages_1.ProtocolRequestType( + SemanticTokensRequest2.method + ); + })( + (SemanticTokensRequest = + exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {})) + ); + let SemanticTokensDeltaRequest; + (function (SemanticTokensDeltaRequest2) { + SemanticTokensDeltaRequest2.method = + 'textDocument/semanticTokens/full/delta'; + SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType( + SemanticTokensDeltaRequest2.method + ); + })( + (SemanticTokensDeltaRequest = + exports.SemanticTokensDeltaRequest || + (exports.SemanticTokensDeltaRequest = {})) + ); + let SemanticTokensRangeRequest; + (function (SemanticTokensRangeRequest2) { + SemanticTokensRangeRequest2.method = 'textDocument/semanticTokens/range'; + SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType( + SemanticTokensRangeRequest2.method + ); + })( + (SemanticTokensRangeRequest = + exports.SemanticTokensRangeRequest || + (exports.SemanticTokensRangeRequest = {})) + ); + let SemanticTokensRefreshRequest; + (function (SemanticTokensRefreshRequest2) { + SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`; + SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0( + SemanticTokensRefreshRequest2.method + ); + })( + (SemanticTokensRefreshRequest = + exports.SemanticTokensRefreshRequest || + (exports.SemanticTokensRefreshRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js +let require_protocol_showDocument = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ShowDocumentRequest = void 0; + let messages_1 = require_messages2(); + let ShowDocumentRequest; + (function (ShowDocumentRequest2) { + ShowDocumentRequest2.method = 'window/showDocument'; + ShowDocumentRequest2.type = new messages_1.ProtocolRequestType( + ShowDocumentRequest2.method + ); + })( + (ShowDocumentRequest = + exports.ShowDocumentRequest || (exports.ShowDocumentRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js +let require_protocol_linkedEditingRange = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LinkedEditingRangeRequest = void 0; + let messages_1 = require_messages2(); + let LinkedEditingRangeRequest; + (function (LinkedEditingRangeRequest2) { + LinkedEditingRangeRequest2.method = 'textDocument/linkedEditingRange'; + LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType( + LinkedEditingRangeRequest2.method + ); + })( + (LinkedEditingRangeRequest = + exports.LinkedEditingRangeRequest || + (exports.LinkedEditingRangeRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js +let require_protocol_fileOperations = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0; + let messages_1 = require_messages2(); + let FileOperationPatternKind; + (function (FileOperationPatternKind2) { + FileOperationPatternKind2.file = 'file'; + FileOperationPatternKind2.folder = 'folder'; + })( + (FileOperationPatternKind = + exports.FileOperationPatternKind || + (exports.FileOperationPatternKind = {})) + ); + let WillCreateFilesRequest; + (function (WillCreateFilesRequest2) { + WillCreateFilesRequest2.method = 'workspace/willCreateFiles'; + WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType( + WillCreateFilesRequest2.method + ); + })( + (WillCreateFilesRequest = + exports.WillCreateFilesRequest || (exports.WillCreateFilesRequest = {})) + ); + let DidCreateFilesNotification; + (function (DidCreateFilesNotification2) { + DidCreateFilesNotification2.method = 'workspace/didCreateFiles'; + DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType( + DidCreateFilesNotification2.method + ); + })( + (DidCreateFilesNotification = + exports.DidCreateFilesNotification || + (exports.DidCreateFilesNotification = {})) + ); + let WillRenameFilesRequest; + (function (WillRenameFilesRequest2) { + WillRenameFilesRequest2.method = 'workspace/willRenameFiles'; + WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType( + WillRenameFilesRequest2.method + ); + })( + (WillRenameFilesRequest = + exports.WillRenameFilesRequest || (exports.WillRenameFilesRequest = {})) + ); + let DidRenameFilesNotification; + (function (DidRenameFilesNotification2) { + DidRenameFilesNotification2.method = 'workspace/didRenameFiles'; + DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType( + DidRenameFilesNotification2.method + ); + })( + (DidRenameFilesNotification = + exports.DidRenameFilesNotification || + (exports.DidRenameFilesNotification = {})) + ); + let DidDeleteFilesNotification; + (function (DidDeleteFilesNotification2) { + DidDeleteFilesNotification2.method = 'workspace/didDeleteFiles'; + DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType( + DidDeleteFilesNotification2.method + ); + })( + (DidDeleteFilesNotification = + exports.DidDeleteFilesNotification || + (exports.DidDeleteFilesNotification = {})) + ); + let WillDeleteFilesRequest; + (function (WillDeleteFilesRequest2) { + WillDeleteFilesRequest2.method = 'workspace/willDeleteFiles'; + WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType( + WillDeleteFilesRequest2.method + ); + })( + (WillDeleteFilesRequest = + exports.WillDeleteFilesRequest || (exports.WillDeleteFilesRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js +let require_protocol_moniker = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0; + let messages_1 = require_messages2(); + let UniquenessLevel; + (function (UniquenessLevel2) { + UniquenessLevel2['document'] = 'document'; + UniquenessLevel2['project'] = 'project'; + UniquenessLevel2['group'] = 'group'; + UniquenessLevel2['scheme'] = 'scheme'; + UniquenessLevel2['global'] = 'global'; + })( + (UniquenessLevel = + exports.UniquenessLevel || (exports.UniquenessLevel = {})) + ); + let MonikerKind; + (function (MonikerKind2) { + MonikerKind2['import'] = 'import'; + MonikerKind2['export'] = 'export'; + MonikerKind2['local'] = 'local'; + })((MonikerKind = exports.MonikerKind || (exports.MonikerKind = {}))); + let MonikerRequest; + (function (MonikerRequest2) { + MonikerRequest2.method = 'textDocument/moniker'; + MonikerRequest2.type = new messages_1.ProtocolRequestType( + MonikerRequest2.method + ); + })( + (MonikerRequest = exports.MonikerRequest || (exports.MonikerRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/protocol.js +let require_protocol = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/protocol.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = exports.WorkspaceSymbolResolveRequest = exports.WorkspaceSymbolRequest = exports.CodeActionResolveRequest = exports.CodeActionRequest = exports.DocumentSymbolRequest = exports.DocumentHighlightRequest = exports.ReferencesRequest = exports.DefinitionRequest = exports.SignatureHelpRequest = exports.SignatureHelpTriggerKind = exports.HoverRequest = exports.CompletionResolveRequest = exports.CompletionRequest = exports.CompletionTriggerKind = exports.PublishDiagnosticsNotification = exports.WatchKind = exports.FileChangeType = exports.DidChangeWatchedFilesNotification = exports.WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentNotification = exports.TextDocumentSaveReason = exports.DidSaveTextDocumentNotification = exports.DidCloseTextDocumentNotification = exports.DidChangeTextDocumentNotification = exports.TextDocumentContentChangeEvent = exports.DidOpenTextDocumentNotification = exports.TextDocumentSyncKind = exports.TelemetryEventNotification = exports.LogMessageNotification = exports.ShowMessageRequest = exports.ShowMessageNotification = exports.MessageType = exports.DidChangeConfigurationNotification = exports.ExitNotification = exports.ShutdownRequest = exports.InitializedNotification = exports.InitializeError = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.DocumentFilter = void 0; + exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.WillRenameFilesRequest = exports.DidRenameFilesNotification = exports.WillCreateFilesRequest = exports.DidCreateFilesNotification = exports.FileOperationPatternKind = exports.LinkedEditingRangeRequest = exports.ShowDocumentRequest = exports.SemanticTokensRegistrationType = exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.TokenFormat = exports.CallHierarchyPrepareRequest = exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = exports.SelectionRangeRequest = exports.DeclarationRequest = exports.FoldingRangeRequest = exports.ColorPresentationRequest = exports.DocumentColorRequest = exports.ConfigurationRequest = exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = exports.TypeDefinitionRequest = exports.ImplementationRequest = exports.ApplyWorkspaceEditRequest = exports.ExecuteCommandRequest = exports.PrepareRenameRequest = exports.RenameRequest = exports.PrepareSupportDefaultBehavior = exports.DocumentOnTypeFormattingRequest = exports.DocumentRangeFormattingRequest = exports.DocumentFormattingRequest = exports.DocumentLinkResolveRequest = exports.DocumentLinkRequest = void 0; + let messages_1 = require_messages2(); + let Is2 = require_is2(); + let protocol_implementation_1 = require_protocol_implementation(); + Object.defineProperty(exports, 'ImplementationRequest', { + enumerable: true, + get: function () { + return protocol_implementation_1.ImplementationRequest; + }, + }); + let protocol_typeDefinition_1 = require_protocol_typeDefinition(); + Object.defineProperty(exports, 'TypeDefinitionRequest', { + enumerable: true, + get: function () { + return protocol_typeDefinition_1.TypeDefinitionRequest; + }, + }); + let protocol_workspaceFolders_1 = require_protocol_workspaceFolders(); + Object.defineProperty(exports, 'WorkspaceFoldersRequest', { + enumerable: true, + get: function () { + return protocol_workspaceFolders_1.WorkspaceFoldersRequest; + }, + }); + Object.defineProperty(exports, 'DidChangeWorkspaceFoldersNotification', { + enumerable: true, + get: function () { + return protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification; + }, + }); + let protocol_configuration_1 = require_protocol_configuration(); + Object.defineProperty(exports, 'ConfigurationRequest', { + enumerable: true, + get: function () { + return protocol_configuration_1.ConfigurationRequest; + }, + }); + let protocol_colorProvider_1 = require_protocol_colorProvider(); + Object.defineProperty(exports, 'DocumentColorRequest', { + enumerable: true, + get: function () { + return protocol_colorProvider_1.DocumentColorRequest; + }, + }); + Object.defineProperty(exports, 'ColorPresentationRequest', { + enumerable: true, + get: function () { + return protocol_colorProvider_1.ColorPresentationRequest; + }, + }); + let protocol_foldingRange_1 = require_protocol_foldingRange(); + Object.defineProperty(exports, 'FoldingRangeRequest', { + enumerable: true, + get: function () { + return protocol_foldingRange_1.FoldingRangeRequest; + }, + }); + let protocol_declaration_1 = require_protocol_declaration(); + Object.defineProperty(exports, 'DeclarationRequest', { + enumerable: true, + get: function () { + return protocol_declaration_1.DeclarationRequest; + }, + }); + let protocol_selectionRange_1 = require_protocol_selectionRange(); + Object.defineProperty(exports, 'SelectionRangeRequest', { + enumerable: true, + get: function () { + return protocol_selectionRange_1.SelectionRangeRequest; + }, + }); + let protocol_progress_1 = require_protocol_progress(); + Object.defineProperty(exports, 'WorkDoneProgress', { + enumerable: true, + get: function () { + return protocol_progress_1.WorkDoneProgress; + }, + }); + Object.defineProperty(exports, 'WorkDoneProgressCreateRequest', { + enumerable: true, + get: function () { + return protocol_progress_1.WorkDoneProgressCreateRequest; + }, + }); + Object.defineProperty(exports, 'WorkDoneProgressCancelNotification', { + enumerable: true, + get: function () { + return protocol_progress_1.WorkDoneProgressCancelNotification; + }, + }); + let protocol_callHierarchy_1 = require_protocol_callHierarchy(); + Object.defineProperty(exports, 'CallHierarchyIncomingCallsRequest', { + enumerable: true, + get: function () { + return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest; + }, + }); + Object.defineProperty(exports, 'CallHierarchyOutgoingCallsRequest', { + enumerable: true, + get: function () { + return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest; + }, + }); + Object.defineProperty(exports, 'CallHierarchyPrepareRequest', { + enumerable: true, + get: function () { + return protocol_callHierarchy_1.CallHierarchyPrepareRequest; + }, + }); + let protocol_semanticTokens_1 = require_protocol_semanticTokens(); + Object.defineProperty(exports, 'TokenFormat', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.TokenFormat; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensDeltaRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensDeltaRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRangeRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRangeRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRefreshRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRefreshRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRegistrationType', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRegistrationType; + }, + }); + let protocol_showDocument_1 = require_protocol_showDocument(); + Object.defineProperty(exports, 'ShowDocumentRequest', { + enumerable: true, + get: function () { + return protocol_showDocument_1.ShowDocumentRequest; + }, + }); + let protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange(); + Object.defineProperty(exports, 'LinkedEditingRangeRequest', { + enumerable: true, + get: function () { + return protocol_linkedEditingRange_1.LinkedEditingRangeRequest; + }, + }); + let protocol_fileOperations_1 = require_protocol_fileOperations(); + Object.defineProperty(exports, 'FileOperationPatternKind', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.FileOperationPatternKind; + }, + }); + Object.defineProperty(exports, 'DidCreateFilesNotification', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.DidCreateFilesNotification; + }, + }); + Object.defineProperty(exports, 'WillCreateFilesRequest', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.WillCreateFilesRequest; + }, + }); + Object.defineProperty(exports, 'DidRenameFilesNotification', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.DidRenameFilesNotification; + }, + }); + Object.defineProperty(exports, 'WillRenameFilesRequest', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.WillRenameFilesRequest; + }, + }); + Object.defineProperty(exports, 'DidDeleteFilesNotification', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.DidDeleteFilesNotification; + }, + }); + Object.defineProperty(exports, 'WillDeleteFilesRequest', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.WillDeleteFilesRequest; + }, + }); + let protocol_moniker_1 = require_protocol_moniker(); + Object.defineProperty(exports, 'UniquenessLevel', { + enumerable: true, + get: function () { + return protocol_moniker_1.UniquenessLevel; + }, + }); + Object.defineProperty(exports, 'MonikerKind', { + enumerable: true, + get: function () { + return protocol_moniker_1.MonikerKind; + }, + }); + Object.defineProperty(exports, 'MonikerRequest', { + enumerable: true, + get: function () { + return protocol_moniker_1.MonikerRequest; + }, + }); + let DocumentFilter; + (function (DocumentFilter2) { + function is2(value) { + const candidate = value; + return ( + Is2.string(candidate.language) || + Is2.string(candidate.scheme) || + Is2.string(candidate.pattern) + ); + } + DocumentFilter2.is = is2; + })( + (DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {})) + ); + let DocumentSelector; + (function (DocumentSelector2) { + function is2(value) { + if (!Array.isArray(value)) { + return false; + } + for (let elem of value) { + if (!Is2.string(elem) && !DocumentFilter.is(elem)) { + return false; + } + } + return true; + } + DocumentSelector2.is = is2; + })( + (DocumentSelector = + exports.DocumentSelector || (exports.DocumentSelector = {})) + ); + let RegistrationRequest; + (function (RegistrationRequest2) { + RegistrationRequest2.type = new messages_1.ProtocolRequestType( + 'client/registerCapability' + ); + })( + (RegistrationRequest = + exports.RegistrationRequest || (exports.RegistrationRequest = {})) + ); + let UnregistrationRequest; + (function (UnregistrationRequest2) { + UnregistrationRequest2.type = new messages_1.ProtocolRequestType( + 'client/unregisterCapability' + ); + })( + (UnregistrationRequest = + exports.UnregistrationRequest || (exports.UnregistrationRequest = {})) + ); + let ResourceOperationKind; + (function (ResourceOperationKind2) { + ResourceOperationKind2.Create = 'create'; + ResourceOperationKind2.Rename = 'rename'; + ResourceOperationKind2.Delete = 'delete'; + })( + (ResourceOperationKind = + exports.ResourceOperationKind || (exports.ResourceOperationKind = {})) + ); + let FailureHandlingKind; + (function (FailureHandlingKind2) { + FailureHandlingKind2.Abort = 'abort'; + FailureHandlingKind2.Transactional = 'transactional'; + FailureHandlingKind2.TextOnlyTransactional = 'textOnlyTransactional'; + FailureHandlingKind2.Undo = 'undo'; + })( + (FailureHandlingKind = + exports.FailureHandlingKind || (exports.FailureHandlingKind = {})) + ); + let StaticRegistrationOptions; + (function (StaticRegistrationOptions2) { + function hasId(value) { + const candidate = value; + return candidate && Is2.string(candidate.id) && candidate.id.length > 0; + } + StaticRegistrationOptions2.hasId = hasId; + })( + (StaticRegistrationOptions = + exports.StaticRegistrationOptions || + (exports.StaticRegistrationOptions = {})) + ); + let TextDocumentRegistrationOptions; + (function (TextDocumentRegistrationOptions2) { + function is2(value) { + const candidate = value; + return ( + candidate && + (candidate.documentSelector === null || + DocumentSelector.is(candidate.documentSelector)) + ); + } + TextDocumentRegistrationOptions2.is = is2; + })( + (TextDocumentRegistrationOptions = + exports.TextDocumentRegistrationOptions || + (exports.TextDocumentRegistrationOptions = {})) + ); + let WorkDoneProgressOptions; + (function (WorkDoneProgressOptions2) { + function is2(value) { + const candidate = value; + return ( + Is2.objectLiteral(candidate) && + (candidate.workDoneProgress === void 0 || + Is2.boolean(candidate.workDoneProgress)) + ); + } + WorkDoneProgressOptions2.is = is2; + function hasWorkDoneProgress(value) { + const candidate = value; + return candidate && Is2.boolean(candidate.workDoneProgress); + } + WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress; + })( + (WorkDoneProgressOptions = + exports.WorkDoneProgressOptions || + (exports.WorkDoneProgressOptions = {})) + ); + let InitializeRequest; + (function (InitializeRequest2) { + InitializeRequest2.type = new messages_1.ProtocolRequestType( + 'initialize' + ); + })( + (InitializeRequest = + exports.InitializeRequest || (exports.InitializeRequest = {})) + ); + let InitializeError; + (function (InitializeError2) { + InitializeError2.unknownProtocolVersion = 1; + })( + (InitializeError = + exports.InitializeError || (exports.InitializeError = {})) + ); + let InitializedNotification; + (function (InitializedNotification2) { + InitializedNotification2.type = new messages_1.ProtocolNotificationType( + 'initialized' + ); + })( + (InitializedNotification = + exports.InitializedNotification || + (exports.InitializedNotification = {})) + ); + let ShutdownRequest; + (function (ShutdownRequest2) { + ShutdownRequest2.type = new messages_1.ProtocolRequestType0('shutdown'); + })( + (ShutdownRequest = + exports.ShutdownRequest || (exports.ShutdownRequest = {})) + ); + let ExitNotification; + (function (ExitNotification2) { + ExitNotification2.type = new messages_1.ProtocolNotificationType0('exit'); + })( + (ExitNotification = + exports.ExitNotification || (exports.ExitNotification = {})) + ); + let DidChangeConfigurationNotification; + (function (DidChangeConfigurationNotification2) { + DidChangeConfigurationNotification2.type = new messages_1.ProtocolNotificationType( + 'workspace/didChangeConfiguration' + ); + })( + (DidChangeConfigurationNotification = + exports.DidChangeConfigurationNotification || + (exports.DidChangeConfigurationNotification = {})) + ); + let MessageType; + (function (MessageType2) { + MessageType2.Error = 1; + MessageType2.Warning = 2; + MessageType2.Info = 3; + MessageType2.Log = 4; + })((MessageType = exports.MessageType || (exports.MessageType = {}))); + let ShowMessageNotification; + (function (ShowMessageNotification2) { + ShowMessageNotification2.type = new messages_1.ProtocolNotificationType( + 'window/showMessage' + ); + })( + (ShowMessageNotification = + exports.ShowMessageNotification || + (exports.ShowMessageNotification = {})) + ); + let ShowMessageRequest; + (function (ShowMessageRequest2) { + ShowMessageRequest2.type = new messages_1.ProtocolRequestType( + 'window/showMessageRequest' + ); + })( + (ShowMessageRequest = + exports.ShowMessageRequest || (exports.ShowMessageRequest = {})) + ); + let LogMessageNotification; + (function (LogMessageNotification2) { + LogMessageNotification2.type = new messages_1.ProtocolNotificationType( + 'window/logMessage' + ); + })( + (LogMessageNotification = + exports.LogMessageNotification || (exports.LogMessageNotification = {})) + ); + let TelemetryEventNotification; + (function (TelemetryEventNotification2) { + TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType( + 'telemetry/event' + ); + })( + (TelemetryEventNotification = + exports.TelemetryEventNotification || + (exports.TelemetryEventNotification = {})) + ); + let TextDocumentSyncKind; + (function (TextDocumentSyncKind2) { + TextDocumentSyncKind2.None = 0; + TextDocumentSyncKind2.Full = 1; + TextDocumentSyncKind2.Incremental = 2; + })( + (TextDocumentSyncKind = + exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {})) + ); + let DidOpenTextDocumentNotification; + (function (DidOpenTextDocumentNotification2) { + DidOpenTextDocumentNotification2.method = 'textDocument/didOpen'; + DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidOpenTextDocumentNotification2.method + ); + })( + (DidOpenTextDocumentNotification = + exports.DidOpenTextDocumentNotification || + (exports.DidOpenTextDocumentNotification = {})) + ); + let TextDocumentContentChangeEvent; + (function (TextDocumentContentChangeEvent2) { + function isIncremental(event) { + let candidate = event; + return ( + candidate !== void 0 && + candidate !== null && + typeof candidate.text === 'string' && + candidate.range !== void 0 && + (candidate.rangeLength === void 0 || + typeof candidate.rangeLength === 'number') + ); + } + TextDocumentContentChangeEvent2.isIncremental = isIncremental; + function isFull(event) { + let candidate = event; + return ( + candidate !== void 0 && + candidate !== null && + typeof candidate.text === 'string' && + candidate.range === void 0 && + candidate.rangeLength === void 0 + ); + } + TextDocumentContentChangeEvent2.isFull = isFull; + })( + (TextDocumentContentChangeEvent = + exports.TextDocumentContentChangeEvent || + (exports.TextDocumentContentChangeEvent = {})) + ); + let DidChangeTextDocumentNotification; + (function (DidChangeTextDocumentNotification2) { + DidChangeTextDocumentNotification2.method = 'textDocument/didChange'; + DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidChangeTextDocumentNotification2.method + ); + })( + (DidChangeTextDocumentNotification = + exports.DidChangeTextDocumentNotification || + (exports.DidChangeTextDocumentNotification = {})) + ); + let DidCloseTextDocumentNotification; + (function (DidCloseTextDocumentNotification2) { + DidCloseTextDocumentNotification2.method = 'textDocument/didClose'; + DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidCloseTextDocumentNotification2.method + ); + })( + (DidCloseTextDocumentNotification = + exports.DidCloseTextDocumentNotification || + (exports.DidCloseTextDocumentNotification = {})) + ); + let DidSaveTextDocumentNotification; + (function (DidSaveTextDocumentNotification2) { + DidSaveTextDocumentNotification2.method = 'textDocument/didSave'; + DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidSaveTextDocumentNotification2.method + ); + })( + (DidSaveTextDocumentNotification = + exports.DidSaveTextDocumentNotification || + (exports.DidSaveTextDocumentNotification = {})) + ); + let TextDocumentSaveReason; + (function (TextDocumentSaveReason2) { + TextDocumentSaveReason2.Manual = 1; + TextDocumentSaveReason2.AfterDelay = 2; + TextDocumentSaveReason2.FocusOut = 3; + })( + (TextDocumentSaveReason = + exports.TextDocumentSaveReason || (exports.TextDocumentSaveReason = {})) + ); + let WillSaveTextDocumentNotification; + (function (WillSaveTextDocumentNotification2) { + WillSaveTextDocumentNotification2.method = 'textDocument/willSave'; + WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + WillSaveTextDocumentNotification2.method + ); + })( + (WillSaveTextDocumentNotification = + exports.WillSaveTextDocumentNotification || + (exports.WillSaveTextDocumentNotification = {})) + ); + let WillSaveTextDocumentWaitUntilRequest; + (function (WillSaveTextDocumentWaitUntilRequest2) { + WillSaveTextDocumentWaitUntilRequest2.method = + 'textDocument/willSaveWaitUntil'; + WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType( + WillSaveTextDocumentWaitUntilRequest2.method + ); + })( + (WillSaveTextDocumentWaitUntilRequest = + exports.WillSaveTextDocumentWaitUntilRequest || + (exports.WillSaveTextDocumentWaitUntilRequest = {})) + ); + let DidChangeWatchedFilesNotification; + (function (DidChangeWatchedFilesNotification2) { + DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType( + 'workspace/didChangeWatchedFiles' + ); + })( + (DidChangeWatchedFilesNotification = + exports.DidChangeWatchedFilesNotification || + (exports.DidChangeWatchedFilesNotification = {})) + ); + let FileChangeType; + (function (FileChangeType2) { + FileChangeType2.Created = 1; + FileChangeType2.Changed = 2; + FileChangeType2.Deleted = 3; + })( + (FileChangeType = exports.FileChangeType || (exports.FileChangeType = {})) + ); + let WatchKind; + (function (WatchKind2) { + WatchKind2.Create = 1; + WatchKind2.Change = 2; + WatchKind2.Delete = 4; + })((WatchKind = exports.WatchKind || (exports.WatchKind = {}))); + let PublishDiagnosticsNotification; + (function (PublishDiagnosticsNotification2) { + PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType( + 'textDocument/publishDiagnostics' + ); + })( + (PublishDiagnosticsNotification = + exports.PublishDiagnosticsNotification || + (exports.PublishDiagnosticsNotification = {})) + ); + let CompletionTriggerKind; + (function (CompletionTriggerKind2) { + CompletionTriggerKind2.Invoked = 1; + CompletionTriggerKind2.TriggerCharacter = 2; + CompletionTriggerKind2.TriggerForIncompleteCompletions = 3; + })( + (CompletionTriggerKind = + exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {})) + ); + let CompletionRequest; + (function (CompletionRequest2) { + CompletionRequest2.method = 'textDocument/completion'; + CompletionRequest2.type = new messages_1.ProtocolRequestType( + CompletionRequest2.method + ); + })( + (CompletionRequest = + exports.CompletionRequest || (exports.CompletionRequest = {})) + ); + let CompletionResolveRequest; + (function (CompletionResolveRequest2) { + CompletionResolveRequest2.method = 'completionItem/resolve'; + CompletionResolveRequest2.type = new messages_1.ProtocolRequestType( + CompletionResolveRequest2.method + ); + })( + (CompletionResolveRequest = + exports.CompletionResolveRequest || + (exports.CompletionResolveRequest = {})) + ); + let HoverRequest; + (function (HoverRequest2) { + HoverRequest2.method = 'textDocument/hover'; + HoverRequest2.type = new messages_1.ProtocolRequestType( + HoverRequest2.method + ); + })((HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}))); + let SignatureHelpTriggerKind; + (function (SignatureHelpTriggerKind2) { + SignatureHelpTriggerKind2.Invoked = 1; + SignatureHelpTriggerKind2.TriggerCharacter = 2; + SignatureHelpTriggerKind2.ContentChange = 3; + })( + (SignatureHelpTriggerKind = + exports.SignatureHelpTriggerKind || + (exports.SignatureHelpTriggerKind = {})) + ); + let SignatureHelpRequest; + (function (SignatureHelpRequest2) { + SignatureHelpRequest2.method = 'textDocument/signatureHelp'; + SignatureHelpRequest2.type = new messages_1.ProtocolRequestType( + SignatureHelpRequest2.method + ); + })( + (SignatureHelpRequest = + exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {})) + ); + let DefinitionRequest; + (function (DefinitionRequest2) { + DefinitionRequest2.method = 'textDocument/definition'; + DefinitionRequest2.type = new messages_1.ProtocolRequestType( + DefinitionRequest2.method + ); + })( + (DefinitionRequest = + exports.DefinitionRequest || (exports.DefinitionRequest = {})) + ); + let ReferencesRequest; + (function (ReferencesRequest2) { + ReferencesRequest2.method = 'textDocument/references'; + ReferencesRequest2.type = new messages_1.ProtocolRequestType( + ReferencesRequest2.method + ); + })( + (ReferencesRequest = + exports.ReferencesRequest || (exports.ReferencesRequest = {})) + ); + let DocumentHighlightRequest; + (function (DocumentHighlightRequest2) { + DocumentHighlightRequest2.method = 'textDocument/documentHighlight'; + DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType( + DocumentHighlightRequest2.method + ); + })( + (DocumentHighlightRequest = + exports.DocumentHighlightRequest || + (exports.DocumentHighlightRequest = {})) + ); + let DocumentSymbolRequest; + (function (DocumentSymbolRequest2) { + DocumentSymbolRequest2.method = 'textDocument/documentSymbol'; + DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType( + DocumentSymbolRequest2.method + ); + })( + (DocumentSymbolRequest = + exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {})) + ); + let CodeActionRequest; + (function (CodeActionRequest2) { + CodeActionRequest2.method = 'textDocument/codeAction'; + CodeActionRequest2.type = new messages_1.ProtocolRequestType( + CodeActionRequest2.method + ); + })( + (CodeActionRequest = + exports.CodeActionRequest || (exports.CodeActionRequest = {})) + ); + let CodeActionResolveRequest; + (function (CodeActionResolveRequest2) { + CodeActionResolveRequest2.method = 'codeAction/resolve'; + CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType( + CodeActionResolveRequest2.method + ); + })( + (CodeActionResolveRequest = + exports.CodeActionResolveRequest || + (exports.CodeActionResolveRequest = {})) + ); + let WorkspaceSymbolRequest; + (function (WorkspaceSymbolRequest2) { + WorkspaceSymbolRequest2.method = 'workspace/symbol'; + WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType( + WorkspaceSymbolRequest2.method + ); + })( + (WorkspaceSymbolRequest = + exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {})) + ); + let WorkspaceSymbolResolveRequest; + (function (WorkspaceSymbolResolveRequest2) { + WorkspaceSymbolResolveRequest2.method = 'workspaceSymbol/resolve'; + WorkspaceSymbolResolveRequest2.type = new messages_1.ProtocolRequestType( + WorkspaceSymbolResolveRequest2.method + ); + })( + (WorkspaceSymbolResolveRequest = + exports.WorkspaceSymbolResolveRequest || + (exports.WorkspaceSymbolResolveRequest = {})) + ); + let CodeLensRequest; + (function (CodeLensRequest2) { + CodeLensRequest2.method = 'textDocument/codeLens'; + CodeLensRequest2.type = new messages_1.ProtocolRequestType( + CodeLensRequest2.method + ); + })( + (CodeLensRequest = + exports.CodeLensRequest || (exports.CodeLensRequest = {})) + ); + let CodeLensResolveRequest; + (function (CodeLensResolveRequest2) { + CodeLensResolveRequest2.method = 'codeLens/resolve'; + CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType( + CodeLensResolveRequest2.method + ); + })( + (CodeLensResolveRequest = + exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {})) + ); + let CodeLensRefreshRequest; + (function (CodeLensRefreshRequest2) { + CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`; + CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0( + CodeLensRefreshRequest2.method + ); + })( + (CodeLensRefreshRequest = + exports.CodeLensRefreshRequest || (exports.CodeLensRefreshRequest = {})) + ); + let DocumentLinkRequest; + (function (DocumentLinkRequest2) { + DocumentLinkRequest2.method = 'textDocument/documentLink'; + DocumentLinkRequest2.type = new messages_1.ProtocolRequestType( + DocumentLinkRequest2.method + ); + })( + (DocumentLinkRequest = + exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {})) + ); + let DocumentLinkResolveRequest; + (function (DocumentLinkResolveRequest2) { + DocumentLinkResolveRequest2.method = 'documentLink/resolve'; + DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType( + DocumentLinkResolveRequest2.method + ); + })( + (DocumentLinkResolveRequest = + exports.DocumentLinkResolveRequest || + (exports.DocumentLinkResolveRequest = {})) + ); + let DocumentFormattingRequest; + (function (DocumentFormattingRequest2) { + DocumentFormattingRequest2.method = 'textDocument/formatting'; + DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType( + DocumentFormattingRequest2.method + ); + })( + (DocumentFormattingRequest = + exports.DocumentFormattingRequest || + (exports.DocumentFormattingRequest = {})) + ); + let DocumentRangeFormattingRequest; + (function (DocumentRangeFormattingRequest2) { + DocumentRangeFormattingRequest2.method = 'textDocument/rangeFormatting'; + DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType( + DocumentRangeFormattingRequest2.method + ); + })( + (DocumentRangeFormattingRequest = + exports.DocumentRangeFormattingRequest || + (exports.DocumentRangeFormattingRequest = {})) + ); + let DocumentOnTypeFormattingRequest; + (function (DocumentOnTypeFormattingRequest2) { + DocumentOnTypeFormattingRequest2.method = 'textDocument/onTypeFormatting'; + DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType( + DocumentOnTypeFormattingRequest2.method + ); + })( + (DocumentOnTypeFormattingRequest = + exports.DocumentOnTypeFormattingRequest || + (exports.DocumentOnTypeFormattingRequest = {})) + ); + let PrepareSupportDefaultBehavior; + (function (PrepareSupportDefaultBehavior2) { + PrepareSupportDefaultBehavior2.Identifier = 1; + })( + (PrepareSupportDefaultBehavior = + exports.PrepareSupportDefaultBehavior || + (exports.PrepareSupportDefaultBehavior = {})) + ); + let RenameRequest; + (function (RenameRequest2) { + RenameRequest2.method = 'textDocument/rename'; + RenameRequest2.type = new messages_1.ProtocolRequestType( + RenameRequest2.method + ); + })((RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}))); + let PrepareRenameRequest; + (function (PrepareRenameRequest2) { + PrepareRenameRequest2.method = 'textDocument/prepareRename'; + PrepareRenameRequest2.type = new messages_1.ProtocolRequestType( + PrepareRenameRequest2.method + ); + })( + (PrepareRenameRequest = + exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {})) + ); + let ExecuteCommandRequest; + (function (ExecuteCommandRequest2) { + ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType( + 'workspace/executeCommand' + ); + })( + (ExecuteCommandRequest = + exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {})) + ); + let ApplyWorkspaceEditRequest; + (function (ApplyWorkspaceEditRequest2) { + ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType( + 'workspace/applyEdit' + ); + })( + (ApplyWorkspaceEditRequest = + exports.ApplyWorkspaceEditRequest || + (exports.ApplyWorkspaceEditRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/connection.js +let require_connection2 = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/connection.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createProtocolConnection = void 0; + let vscode_jsonrpc_1 = require_main(); + function createProtocolConnection(input, output, logger, options) { + if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) { + options = { connectionStrategy: options }; + } + return (0, vscode_jsonrpc_1.createMessageConnection)( + input, + output, + logger, + options + ); + } + exports.createProtocolConnection = createProtocolConnection; + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/proposed.diagnostic.js +let require_proposed_diagnostic = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/proposed.diagnostic.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = void 0; + let vscode_jsonrpc_1 = require_main(); + let Is2 = require_is2(); + let messages_1 = require_messages2(); + let DiagnosticServerCancellationData; + (function (DiagnosticServerCancellationData2) { + function is2(value) { + const candidate = value; + return candidate && Is2.boolean(candidate.retriggerRequest); + } + DiagnosticServerCancellationData2.is = is2; + })( + (DiagnosticServerCancellationData = + exports.DiagnosticServerCancellationData || + (exports.DiagnosticServerCancellationData = {})) + ); + let DocumentDiagnosticReportKind; + (function (DocumentDiagnosticReportKind2) { + DocumentDiagnosticReportKind2['full'] = 'full'; + DocumentDiagnosticReportKind2['unChanged'] = 'unChanged'; + })( + (DocumentDiagnosticReportKind = + exports.DocumentDiagnosticReportKind || + (exports.DocumentDiagnosticReportKind = {})) + ); + let DocumentDiagnosticRequest; + (function (DocumentDiagnosticRequest2) { + DocumentDiagnosticRequest2.method = 'textDocument/diagnostic'; + DocumentDiagnosticRequest2.type = new messages_1.ProtocolRequestType( + DocumentDiagnosticRequest2.method + ); + DocumentDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType(); + })( + (DocumentDiagnosticRequest = + exports.DocumentDiagnosticRequest || + (exports.DocumentDiagnosticRequest = {})) + ); + let WorkspaceDiagnosticRequest; + (function (WorkspaceDiagnosticRequest2) { + WorkspaceDiagnosticRequest2.method = 'workspace/diagnostic'; + WorkspaceDiagnosticRequest2.type = new messages_1.ProtocolRequestType( + WorkspaceDiagnosticRequest2.method + ); + WorkspaceDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType(); + })( + (WorkspaceDiagnosticRequest = + exports.WorkspaceDiagnosticRequest || + (exports.WorkspaceDiagnosticRequest = {})) + ); + let DiagnosticRefreshRequest; + (function (DiagnosticRefreshRequest2) { + DiagnosticRefreshRequest2.method = `workspace/diagnostic/refresh`; + DiagnosticRefreshRequest2.type = new messages_1.ProtocolRequestType0( + DiagnosticRefreshRequest2.method + ); + })( + (DiagnosticRefreshRequest = + exports.DiagnosticRefreshRequest || + (exports.DiagnosticRefreshRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/proposed.typeHierarchy.js +let require_proposed_typeHierarchy = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/proposed.typeHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeHierarchySubtypesRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchyPrepareRequest = void 0; + let messages_1 = require_messages2(); + let TypeHierarchyPrepareRequest; + (function (TypeHierarchyPrepareRequest2) { + TypeHierarchyPrepareRequest2.method = 'textDocument/prepareTypeHierarchy'; + TypeHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType( + TypeHierarchyPrepareRequest2.method + ); + })( + (TypeHierarchyPrepareRequest = + exports.TypeHierarchyPrepareRequest || + (exports.TypeHierarchyPrepareRequest = {})) + ); + let TypeHierarchySupertypesRequest; + (function (TypeHierarchySupertypesRequest2) { + TypeHierarchySupertypesRequest2.method = 'typeHierarchy/supertypes'; + TypeHierarchySupertypesRequest2.type = new messages_1.ProtocolRequestType( + TypeHierarchySupertypesRequest2.method + ); + })( + (TypeHierarchySupertypesRequest = + exports.TypeHierarchySupertypesRequest || + (exports.TypeHierarchySupertypesRequest = {})) + ); + let TypeHierarchySubtypesRequest; + (function (TypeHierarchySubtypesRequest2) { + TypeHierarchySubtypesRequest2.method = 'typeHierarchy/subtypes'; + TypeHierarchySubtypesRequest2.type = new messages_1.ProtocolRequestType( + TypeHierarchySubtypesRequest2.method + ); + })( + (TypeHierarchySubtypesRequest = + exports.TypeHierarchySubtypesRequest || + (exports.TypeHierarchySubtypesRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/proposed.inlineValue.js +let require_proposed_inlineValue = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/proposed.inlineValue.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.InlineValuesRefreshRequest = exports.InlineValuesRequest = void 0; + let messages_1 = require_messages2(); + let InlineValuesRequest; + (function (InlineValuesRequest2) { + InlineValuesRequest2.method = 'textDocument/inlineValues'; + InlineValuesRequest2.type = new messages_1.ProtocolRequestType( + InlineValuesRequest2.method + ); + })( + (InlineValuesRequest = + exports.InlineValuesRequest || (exports.InlineValuesRequest = {})) + ); + let InlineValuesRefreshRequest; + (function (InlineValuesRefreshRequest2) { + InlineValuesRefreshRequest2.method = `workspace/inlineValues/refresh`; + InlineValuesRefreshRequest2.type = new messages_1.ProtocolRequestType0( + InlineValuesRefreshRequest2.method + ); + })( + (InlineValuesRefreshRequest = + exports.InlineValuesRefreshRequest || + (exports.InlineValuesRefreshRequest = {})) + ); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/common/api.js +let require_api2 = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/common/api.js'( + exports + ) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Proposed = exports.LSPErrorCodes = exports.createProtocolConnection = void 0; + __exportStar(require_main(), exports); + __exportStar(require_main2(), exports); + __exportStar(require_messages2(), exports); + __exportStar(require_protocol(), exports); + let connection_1 = require_connection2(); + Object.defineProperty(exports, 'createProtocolConnection', { + enumerable: true, + get: function () { + return connection_1.createProtocolConnection; + }, + }); + let LSPErrorCodes; + (function (LSPErrorCodes2) { + LSPErrorCodes2.lspReservedErrorRangeStart = -32899; + LSPErrorCodes2.RequestFailed = -32803; + LSPErrorCodes2.ServerCancelled = -32802; + LSPErrorCodes2.ContentModified = -32801; + LSPErrorCodes2.RequestCancelled = -32800; + LSPErrorCodes2.lspReservedErrorRangeEnd = -32800; + })((LSPErrorCodes = exports.LSPErrorCodes || (exports.LSPErrorCodes = {}))); + let diag = require_proposed_diagnostic(); + let typeh = require_proposed_typeHierarchy(); + let iv = require_proposed_inlineValue(); + let Proposed; + (function (Proposed2) { + Proposed2.DiagnosticServerCancellationData = + diag.DiagnosticServerCancellationData; + Proposed2.DocumentDiagnosticReportKind = + diag.DocumentDiagnosticReportKind; + Proposed2.DocumentDiagnosticRequest = diag.DocumentDiagnosticRequest; + Proposed2.WorkspaceDiagnosticRequest = diag.WorkspaceDiagnosticRequest; + Proposed2.DiagnosticRefreshRequest = diag.DiagnosticRefreshRequest; + Proposed2.TypeHierarchyPrepareRequest = typeh.TypeHierarchyPrepareRequest; + Proposed2.TypeHierarchySupertypesRequest = + typeh.TypeHierarchySupertypesRequest; + Proposed2.TypeHierarchySubtypesRequest = + typeh.TypeHierarchySubtypesRequest; + Proposed2.InlineValuesRequest = iv.InlineValuesRequest; + Proposed2.InlineValuesRefreshRequest = iv.InlineValuesRefreshRequest; + })((Proposed = exports.Proposed || (exports.Proposed = {}))); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/lib/browser/main.js +let require_main3 = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/lib/browser/main.js'( + exports + ) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createProtocolConnection = void 0; + let browser_1 = require_browser(); + __exportStar(require_browser(), exports); + __exportStar(require_api2(), exports); + function createProtocolConnection(reader, writer, logger, options) { + return (0, browser_1.createMessageConnection)( + reader, + writer, + logger, + options + ); + } + exports.createProtocolConnection = createProtocolConnection; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/configuration.js +let require_configuration = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/configuration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.toJSONObject = exports.ConfigurationFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let ConfigurationFeature = class { + constructor(_client) { + this._client = _client; + } + fillClientCapabilities(capabilities) { + capabilities.workspace = capabilities.workspace || {}; + capabilities.workspace.configuration = true; + } + initialize() { + let client = this._client; + client.onRequest( + vscode_languageserver_protocol_1.ConfigurationRequest.type, + (params, token) => { + let configuration = (params2) => { + let result = []; + for (let item of params2.items) { + let resource = + item.scopeUri !== void 0 && item.scopeUri !== null + ? this._client.protocol2CodeConverter.asUri(item.scopeUri) + : void 0; + result.push( + this.getConfiguration( + resource, + item.section !== null ? item.section : void 0 + ) + ); + } + return result; + }; + let middleware = client.clientOptions.middleware.workspace; + return middleware && middleware.configuration + ? middleware.configuration(params, token, configuration) + : configuration(params, token); + } + ); + } + getConfiguration(resource, section) { + let result = null; + if (section) { + let index = section.lastIndexOf('.'); + if (index === -1) { + result = toJSONObject( + vscode_1.workspace.getConfiguration(void 0, resource).get(section) + ); + } else { + let config = vscode_1.workspace.getConfiguration( + section.substr(0, index), + resource + ); + if (config) { + result = toJSONObject(config.get(section.substr(index + 1))); + } + } + } else { + let config = vscode_1.workspace.getConfiguration(void 0, resource); + result = {}; + for (let key of Object.keys(config)) { + if (config.has(key)) { + result[key] = toJSONObject(config.get(key)); + } + } + } + if (result === void 0) { + result = null; + } + return result; + } + dispose() {} + }; + exports.ConfigurationFeature = ConfigurationFeature; + function toJSONObject(obj) { + if (obj) { + if (Array.isArray(obj)) { + return obj.map(toJSONObject); + } else if (typeof obj === 'object') { + const res = Object.create(null); + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + res[key] = toJSONObject(obj[key]); + } + } + return res; + } + } + return obj; + } + exports.toJSONObject = toJSONObject; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/utils/is.js +let require_is3 = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/utils/is.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.asPromise = exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0; + function boolean(value) { + return value === true || value === false; + } + exports.boolean = boolean; + function string(value) { + return typeof value === 'string' || value instanceof String; + } + exports.string = string; + function number(value) { + return typeof value === 'number' || value instanceof Number; + } + exports.number = number; + function error(value) { + return value instanceof Error; + } + exports.error = error; + function func(value) { + return typeof value === 'function'; + } + exports.func = func; + function array(value) { + return Array.isArray(value); + } + exports.array = array; + function stringArray(value) { + return array(value) && value.every((elem) => string(elem)); + } + exports.stringArray = stringArray; + function typedArray(value, check) { + return Array.isArray(value) && value.every(check); + } + exports.typedArray = typedArray; + function thenable(value) { + return value && func(value.then); + } + exports.thenable = thenable; + function asPromise(value) { + if (value instanceof Promise) { + return value; + } else if (thenable(value)) { + return new Promise((resolve, reject) => { + value.then( + (resolved) => resolve(resolved), + (error2) => reject(error2) + ); + }); + } else { + return Promise.resolve(value); + } + } + exports.asPromise = asPromise; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolCompletionItem.js +let require_protocolCompletionItem = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolCompletionItem.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let code = require('vscode'); + let ProtocolCompletionItem = class extends code.CompletionItem { + constructor(label) { + super(label); + } + }; + exports.default = ProtocolCompletionItem; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolCodeLens.js +let require_protocolCodeLens = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolCodeLens.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let code = require('vscode'); + let ProtocolCodeLens = class extends code.CodeLens { + constructor(range) { + super(range); + } + }; + exports.default = ProtocolCodeLens; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolDocumentLink.js +let require_protocolDocumentLink = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolDocumentLink.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let code = require('vscode'); + let ProtocolDocumentLink = class extends code.DocumentLink { + constructor(range, target) { + super(range, target); + } + }; + exports.default = ProtocolDocumentLink; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolCodeAction.js +let require_protocolCodeAction = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolCodeAction.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let vscode3 = require('vscode'); + let ProtocolCodeAction = class extends vscode3.CodeAction { + constructor(title, data) { + super(title); + this.data = data; + } + }; + exports.default = ProtocolCodeAction; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js +let require_protocolDiagnostic = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProtocolDiagnostic = exports.DiagnosticCode = void 0; + let vscode3 = require('vscode'); + let Is2 = require_is3(); + let DiagnosticCode; + (function (DiagnosticCode2) { + function is2(value) { + const candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + (Is2.number(candidate.value) || Is2.string(candidate.value)) && + Is2.string(candidate.target) + ); + } + DiagnosticCode2.is = is2; + })( + (DiagnosticCode = exports.DiagnosticCode || (exports.DiagnosticCode = {})) + ); + let ProtocolDiagnostic = class extends vscode3.Diagnostic { + constructor(range, message, severity, data) { + super(range, message, severity); + this.data = data; + this.hasDiagnosticCode = false; + } + }; + exports.ProtocolDiagnostic = ProtocolDiagnostic; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.js +let require_protocolCallHierarchyItem = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let code = require('vscode'); + let ProtocolCallHierarchyItem = class extends code.CallHierarchyItem { + constructor(kind, name, detail, uri, range, selectionRange, data) { + super(kind, name, detail, uri, range, selectionRange); + if (data !== void 0) { + this.data = data; + } + } + }; + exports.default = ProtocolCallHierarchyItem; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.js +let require_protocolTypeHierarchyItem = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let code = require('vscode'); + let ProtocolTypeHierarchyItem = class extends code.TypeHierarchyItem { + constructor(kind, name, detail, uri, range, selectionRange, data) { + super(kind, name, detail, uri, range, selectionRange); + if (data !== void 0) { + this.data = data; + } + } + }; + exports.default = ProtocolTypeHierarchyItem; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.js +let require_protocolWorkspaceSymbol = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let code = require('vscode'); + let WorkspaceSymbol = class extends code.SymbolInformation { + constructor(name, kind, containerName, locationOrUri, data) { + const hasRange = !(locationOrUri instanceof code.Uri); + super( + name, + kind, + containerName, + hasRange + ? locationOrUri + : new code.Location(locationOrUri, new code.Range(0, 0, 0, 0)) + ); + this.hasRange = hasRange; + if (data !== void 0) { + this.data = data; + } + } + }; + exports.default = WorkspaceSymbol; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/codeConverter.js +let require_codeConverter = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/codeConverter.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createConverter = void 0; + let code = require('vscode'); + let proto = require_main3(); + let Is2 = require_is3(); + let protocolCompletionItem_1 = require_protocolCompletionItem(); + let protocolCodeLens_1 = require_protocolCodeLens(); + let protocolDocumentLink_1 = require_protocolDocumentLink(); + let protocolCodeAction_1 = require_protocolCodeAction(); + let protocolDiagnostic_1 = require_protocolDiagnostic(); + let protocolCallHierarchyItem_1 = require_protocolCallHierarchyItem(); + let vscode_languageserver_protocol_1 = require_main3(); + let protocolTypeHierarchyItem_1 = require_protocolTypeHierarchyItem(); + let protocolWorkspaceSymbol_1 = require_protocolWorkspaceSymbol(); + let InsertReplaceRange; + (function (InsertReplaceRange2) { + function is2(value) { + const candidate = value; + return candidate && !!candidate.inserting && !!candidate.replacing; + } + InsertReplaceRange2.is = is2; + })(InsertReplaceRange || (InsertReplaceRange = {})); + function createConverter(uriConverter) { + const nullConverter = (value) => value.toString(); + const _uriConverter = uriConverter || nullConverter; + function asUri(value) { + return _uriConverter(value); + } + function asTextDocumentIdentifier(textDocument) { + return { + uri: _uriConverter(textDocument.uri), + }; + } + function asVersionedTextDocumentIdentifier(textDocument) { + return { + uri: _uriConverter(textDocument.uri), + version: textDocument.version, + }; + } + function asOpenTextDocumentParams(textDocument) { + return { + textDocument: { + uri: _uriConverter(textDocument.uri), + languageId: textDocument.languageId, + version: textDocument.version, + text: textDocument.getText(), + }, + }; + } + function isTextDocumentChangeEvent(value) { + let candidate = value; + return !!candidate.document && !!candidate.contentChanges; + } + function isTextDocument(value) { + let candidate = value; + return !!candidate.uri && !!candidate.version; + } + function asChangeTextDocumentParams(arg) { + if (isTextDocument(arg)) { + let result = { + textDocument: { + uri: _uriConverter(arg.uri), + version: arg.version, + }, + contentChanges: [{ text: arg.getText() }], + }; + return result; + } else if (isTextDocumentChangeEvent(arg)) { + let document2 = arg.document; + let result = { + textDocument: { + uri: _uriConverter(document2.uri), + version: document2.version, + }, + contentChanges: arg.contentChanges.map((change) => { + let range = change.range; + return { + range: { + start: { + line: range.start.line, + character: range.start.character, + }, + end: { line: range.end.line, character: range.end.character }, + }, + rangeLength: change.rangeLength, + text: change.text, + }; + }), + }; + return result; + } else { + throw Error('Unsupported text document change parameter'); + } + } + function asCloseTextDocumentParams(textDocument) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + }; + } + function asSaveTextDocumentParams(textDocument, includeContent = false) { + let result = { + textDocument: asTextDocumentIdentifier(textDocument), + }; + if (includeContent) { + result.text = textDocument.getText(); + } + return result; + } + function asTextDocumentSaveReason(reason) { + switch (reason) { + case code.TextDocumentSaveReason.Manual: + return proto.TextDocumentSaveReason.Manual; + case code.TextDocumentSaveReason.AfterDelay: + return proto.TextDocumentSaveReason.AfterDelay; + case code.TextDocumentSaveReason.FocusOut: + return proto.TextDocumentSaveReason.FocusOut; + } + return proto.TextDocumentSaveReason.Manual; + } + function asWillSaveTextDocumentParams(event) { + return { + textDocument: asTextDocumentIdentifier(event.document), + reason: asTextDocumentSaveReason(event.reason), + }; + } + function asDidCreateFilesParams(event) { + return { + files: event.files.map((fileUri) => ({ + uri: _uriConverter(fileUri), + })), + }; + } + function asDidRenameFilesParams(event) { + return { + files: event.files.map((file) => ({ + oldUri: _uriConverter(file.oldUri), + newUri: _uriConverter(file.newUri), + })), + }; + } + function asDidDeleteFilesParams(event) { + return { + files: event.files.map((fileUri) => ({ + uri: _uriConverter(fileUri), + })), + }; + } + function asWillCreateFilesParams(event) { + return { + files: event.files.map((fileUri) => ({ + uri: _uriConverter(fileUri), + })), + }; + } + function asWillRenameFilesParams(event) { + return { + files: event.files.map((file) => ({ + oldUri: _uriConverter(file.oldUri), + newUri: _uriConverter(file.newUri), + })), + }; + } + function asWillDeleteFilesParams(event) { + return { + files: event.files.map((fileUri) => ({ + uri: _uriConverter(fileUri), + })), + }; + } + function asTextDocumentPositionParams(textDocument, position) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + position: asWorkerPosition(position), + }; + } + function asCompletionTriggerKind(triggerKind) { + switch (triggerKind) { + case code.CompletionTriggerKind.TriggerCharacter: + return proto.CompletionTriggerKind.TriggerCharacter; + case code.CompletionTriggerKind.TriggerForIncompleteCompletions: + return proto.CompletionTriggerKind.TriggerForIncompleteCompletions; + default: + return proto.CompletionTriggerKind.Invoked; + } + } + function asCompletionParams(textDocument, position, context) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + position: asWorkerPosition(position), + context: { + triggerKind: asCompletionTriggerKind(context.triggerKind), + triggerCharacter: context.triggerCharacter, + }, + }; + } + function asSignatureHelpTriggerKind(triggerKind) { + switch (triggerKind) { + case code.SignatureHelpTriggerKind.Invoke: + return proto.SignatureHelpTriggerKind.Invoked; + case code.SignatureHelpTriggerKind.TriggerCharacter: + return proto.SignatureHelpTriggerKind.TriggerCharacter; + case code.SignatureHelpTriggerKind.ContentChange: + return proto.SignatureHelpTriggerKind.ContentChange; + } + } + function asParameterInformation(value) { + return { + label: value.label, + }; + } + function asParameterInformations(values) { + return values.map(asParameterInformation); + } + function asSignatureInformation(value) { + return { + label: value.label, + parameters: asParameterInformations(value.parameters), + }; + } + function asSignatureInformations(values) { + return values.map(asSignatureInformation); + } + function asSignatureHelp(value) { + if (value === void 0) { + return value; + } + return { + signatures: asSignatureInformations(value.signatures), + activeSignature: value.activeSignature, + activeParameter: value.activeParameter, + }; + } + function asSignatureHelpParams(textDocument, position, context) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + position: asWorkerPosition(position), + context: { + isRetrigger: context.isRetrigger, + triggerCharacter: context.triggerCharacter, + triggerKind: asSignatureHelpTriggerKind(context.triggerKind), + activeSignatureHelp: asSignatureHelp(context.activeSignatureHelp), + }, + }; + } + function asWorkerPosition(position) { + return { line: position.line, character: position.character }; + } + function asPosition(value) { + if (value === void 0 || value === null) { + return value; + } + return { + line: + value.line > vscode_languageserver_protocol_1.uinteger.MAX_VALUE + ? vscode_languageserver_protocol_1.uinteger.MAX_VALUE + : value.line, + character: + value.character > + vscode_languageserver_protocol_1.uinteger.MAX_VALUE + ? vscode_languageserver_protocol_1.uinteger.MAX_VALUE + : value.character, + }; + } + function asPositions(value) { + let result = []; + for (let elem of value) { + result.push(asPosition(elem)); + } + return result; + } + function asRange(value) { + if (value === void 0 || value === null) { + return value; + } + return { start: asPosition(value.start), end: asPosition(value.end) }; + } + function asLocation(value) { + if (value === void 0 || value === null) { + return value; + } + return proto.Location.create(asUri(value.uri), asRange(value.range)); + } + function asDiagnosticSeverity(value) { + switch (value) { + case code.DiagnosticSeverity.Error: + return proto.DiagnosticSeverity.Error; + case code.DiagnosticSeverity.Warning: + return proto.DiagnosticSeverity.Warning; + case code.DiagnosticSeverity.Information: + return proto.DiagnosticSeverity.Information; + case code.DiagnosticSeverity.Hint: + return proto.DiagnosticSeverity.Hint; + } + } + function asDiagnosticTags(tags) { + if (!tags) { + return void 0; + } + let result = []; + for (let tag of tags) { + let converted = asDiagnosticTag(tag); + if (converted !== void 0) { + result.push(converted); + } + } + return result.length > 0 ? result : void 0; + } + function asDiagnosticTag(tag) { + switch (tag) { + case code.DiagnosticTag.Unnecessary: + return proto.DiagnosticTag.Unnecessary; + case code.DiagnosticTag.Deprecated: + return proto.DiagnosticTag.Deprecated; + default: + return void 0; + } + } + function asRelatedInformation(item) { + return { + message: item.message, + location: asLocation(item.location), + }; + } + function asRelatedInformations(items) { + return items.map(asRelatedInformation); + } + function asDiagnosticCode(value) { + if (value === void 0 || value === null) { + return void 0; + } + if (Is2.number(value) || Is2.string(value)) { + return value; + } + return { value: value.value, target: asUri(value.target) }; + } + function asDiagnostic(item) { + const result = proto.Diagnostic.create( + asRange(item.range), + item.message + ); + const protocolDiagnostic = + item instanceof protocolDiagnostic_1.ProtocolDiagnostic + ? item + : void 0; + if ( + protocolDiagnostic !== void 0 && + protocolDiagnostic.data !== void 0 + ) { + result.data = protocolDiagnostic.data; + } + const code2 = asDiagnosticCode(item.code); + if (protocolDiagnostic_1.DiagnosticCode.is(code2)) { + if ( + protocolDiagnostic !== void 0 && + protocolDiagnostic.hasDiagnosticCode + ) { + result.code = code2; + } else { + result.code = code2.value; + result.codeDescription = { href: code2.target }; + } + } else { + result.code = code2; + } + if (Is2.number(item.severity)) { + result.severity = asDiagnosticSeverity(item.severity); + } + if (Array.isArray(item.tags)) { + result.tags = asDiagnosticTags(item.tags); + } + if (item.relatedInformation) { + result.relatedInformation = asRelatedInformations( + item.relatedInformation + ); + } + if (item.source) { + result.source = item.source; + } + return result; + } + function asDiagnostics(items) { + if (items === void 0 || items === null) { + return items; + } + return items.map(asDiagnostic); + } + function asDocumentation(format, documentation) { + switch (format) { + case '$string': + return documentation; + case proto.MarkupKind.PlainText: + return { kind: format, value: documentation }; + case proto.MarkupKind.Markdown: + return { kind: format, value: documentation.value }; + default: + return `Unsupported Markup content received. Kind is: ${format}`; + } + } + function asCompletionItemTag(tag) { + switch (tag) { + case code.CompletionItemTag.Deprecated: + return proto.CompletionItemTag.Deprecated; + } + return void 0; + } + function asCompletionItemTags(tags) { + if (tags === void 0) { + return tags; + } + const result = []; + for (let tag of tags) { + const converted = asCompletionItemTag(tag); + if (converted !== void 0) { + result.push(converted); + } + } + return result; + } + function asCompletionItemKind(value, original) { + if (original !== void 0) { + return original; + } + return value + 1; + } + function asCompletionItem(item, labelDetailsSupport = false) { + let label; + let labelDetails; + if (Is2.string(item.label)) { + label = item.label; + } else { + label = item.label.label; + if ( + labelDetailsSupport && + (item.label.detail !== void 0 || item.label.description !== void 0) + ) { + labelDetails = { + detail: item.label.detail, + description: item.label.description, + }; + } + } + let result = { label }; + if (labelDetails !== void 0) { + result.labelDetails = labelDetails; + } + let protocolItem = + item instanceof protocolCompletionItem_1.default ? item : void 0; + if (item.detail) { + result.detail = item.detail; + } + if (item.documentation) { + if (!protocolItem || protocolItem.documentationFormat === '$string') { + result.documentation = item.documentation; + } else { + result.documentation = asDocumentation( + protocolItem.documentationFormat, + item.documentation + ); + } + } + if (item.filterText) { + result.filterText = item.filterText; + } + fillPrimaryInsertText(result, item); + if (Is2.number(item.kind)) { + result.kind = asCompletionItemKind( + item.kind, + protocolItem && protocolItem.originalItemKind + ); + } + if (item.sortText) { + result.sortText = item.sortText; + } + if (item.additionalTextEdits) { + result.additionalTextEdits = asTextEdits(item.additionalTextEdits); + } + if (item.commitCharacters) { + result.commitCharacters = item.commitCharacters.slice(); + } + if (item.command) { + result.command = asCommand(item.command); + } + if (item.preselect === true || item.preselect === false) { + result.preselect = item.preselect; + } + const tags = asCompletionItemTags(item.tags); + if (protocolItem) { + if (protocolItem.data !== void 0) { + result.data = protocolItem.data; + } + if ( + protocolItem.deprecated === true || + protocolItem.deprecated === false + ) { + if ( + protocolItem.deprecated === true && + tags !== void 0 && + tags.length > 0 + ) { + const index = tags.indexOf(code.CompletionItemTag.Deprecated); + if (index !== -1) { + tags.splice(index, 1); + } + } + result.deprecated = protocolItem.deprecated; + } + if (protocolItem.insertTextMode !== void 0) { + result.insertTextMode = protocolItem.insertTextMode; + } + } + if (tags !== void 0 && tags.length > 0) { + result.tags = tags; + } + if (result.insertTextMode === void 0 && item.keepWhitespace === true) { + result.insertTextMode = + vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation; + } + return result; + } + function fillPrimaryInsertText(target, source) { + let format = proto.InsertTextFormat.PlainText; + let text = void 0; + let range = void 0; + if (source.textEdit) { + text = source.textEdit.newText; + range = source.textEdit.range; + } else if (source.insertText instanceof code.SnippetString) { + format = proto.InsertTextFormat.Snippet; + text = source.insertText.value; + } else { + text = source.insertText; + } + if (source.range) { + range = source.range; + } + target.insertTextFormat = format; + if (source.fromEdit && text !== void 0 && range !== void 0) { + target.textEdit = asCompletionTextEdit(text, range); + } else { + target.insertText = text; + } + } + function asCompletionTextEdit(newText, range) { + if (InsertReplaceRange.is(range)) { + return proto.InsertReplaceEdit.create( + newText, + asRange(range.inserting), + asRange(range.replacing) + ); + } else { + return { newText, range: asRange(range) }; + } + } + function asTextEdit(edit) { + return { range: asRange(edit.range), newText: edit.newText }; + } + function asTextEdits(edits) { + if (edits === void 0 || edits === null) { + return edits; + } + return edits.map(asTextEdit); + } + function asSymbolKind(item) { + if (item <= code.SymbolKind.TypeParameter) { + return item + 1; + } + return proto.SymbolKind.Property; + } + function asSymbolTag(item) { + return item; + } + function asSymbolTags(items) { + return items.map(asSymbolTag); + } + function asReferenceParams(textDocument, position, options) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + position: asWorkerPosition(position), + context: { includeDeclaration: options.includeDeclaration }, + }; + } + function asCodeAction(item) { + let result = proto.CodeAction.create(item.title); + if ( + item instanceof protocolCodeAction_1.default && + item.data !== void 0 + ) { + result.data = item.data; + } + if (item.kind !== void 0) { + result.kind = asCodeActionKind(item.kind); + } + if (item.diagnostics !== void 0) { + result.diagnostics = asDiagnostics(item.diagnostics); + } + if (item.edit !== void 0) { + throw new Error( + `VS Code code actions can only be converted to a protocol code action without an edit.` + ); + } + if (item.command !== void 0) { + result.command = asCommand(item.command); + } + if (item.isPreferred !== void 0) { + result.isPreferred = item.isPreferred; + } + if (item.disabled !== void 0) { + result.disabled = { reason: item.disabled.reason }; + } + return result; + } + function asCodeActionContext(context) { + if (context === void 0 || context === null) { + return context; + } + let only; + if (context.only && Is2.string(context.only.value)) { + only = [context.only.value]; + } + return proto.CodeActionContext.create( + asDiagnostics(context.diagnostics), + only, + asCodeActionTriggerKind(context.triggerKind) + ); + } + function asCodeActionTriggerKind(kind) { + switch (kind) { + case code.CodeActionTriggerKind.Invoke: + return proto.CodeActionTriggerKind.Invoked; + case code.CodeActionTriggerKind.Automatic: + return proto.CodeActionTriggerKind.Automatic; + default: + return void 0; + } + } + function asCodeActionKind(item) { + if (item === void 0 || item === null) { + return void 0; + } + return item.value; + } + function asInlineValuesContext(context) { + if (context === void 0 || context === null) { + return context; + } + return proto.InlineValuesContext.create(context.stoppedLocation); + } + function asCommand(item) { + let result = proto.Command.create(item.title, item.command); + if (item.arguments) { + result.arguments = item.arguments; + } + return result; + } + function asCodeLens(item) { + let result = proto.CodeLens.create(asRange(item.range)); + if (item.command) { + result.command = asCommand(item.command); + } + if (item instanceof protocolCodeLens_1.default) { + if (item.data) { + result.data = item.data; + } + } + return result; + } + function asFormattingOptions(options, fileOptions) { + const result = { + tabSize: options.tabSize, + insertSpaces: options.insertSpaces, + }; + if (fileOptions.trimTrailingWhitespace) { + result.trimTrailingWhitespace = true; + } + if (fileOptions.trimFinalNewlines) { + result.trimFinalNewlines = true; + } + if (fileOptions.insertFinalNewline) { + result.insertFinalNewline = true; + } + return result; + } + function asDocumentSymbolParams(textDocument) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + }; + } + function asCodeLensParams(textDocument) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + }; + } + function asDocumentLink(item) { + let result = proto.DocumentLink.create(asRange(item.range)); + if (item.target) { + result.target = asUri(item.target); + } + if (item.tooltip !== void 0) { + result.tooltip = item.tooltip; + } + let protocolItem = + item instanceof protocolDocumentLink_1.default ? item : void 0; + if (protocolItem && protocolItem.data) { + result.data = protocolItem.data; + } + return result; + } + function asDocumentLinkParams(textDocument) { + return { + textDocument: asTextDocumentIdentifier(textDocument), + }; + } + function asCallHierarchyItem(value) { + const result = { + name: value.name, + kind: asSymbolKind(value.kind), + uri: asUri(value.uri), + range: asRange(value.range), + selectionRange: asRange(value.selectionRange), + }; + if (value.detail !== void 0 && value.detail.length > 0) { + result.detail = value.detail; + } + if (value.tags !== void 0) { + result.tags = asSymbolTags(value.tags); + } + if ( + value instanceof protocolCallHierarchyItem_1.default && + value.data !== void 0 + ) { + result.data = value.data; + } + return result; + } + function asTypeHierarchyItem(value) { + const result = { + name: value.name, + kind: asSymbolKind(value.kind), + uri: asUri(value.uri), + range: asRange(value.range), + selectionRange: asRange(value.selectionRange), + }; + if (value.detail !== void 0 && value.detail.length > 0) { + result.detail = value.detail; + } + if (value.tags !== void 0) { + result.tags = asSymbolTags(value.tags); + } + if ( + value instanceof protocolTypeHierarchyItem_1.default && + value.data !== void 0 + ) { + result.data = value.data; + } + return result; + } + function asWorkspaceSymbol(item) { + const result = + item instanceof protocolWorkspaceSymbol_1.default + ? { + name: item.name, + kind: asSymbolKind(item.kind), + location: item.hasRange + ? asLocation(item.location) + : { uri: _uriConverter(item.location.uri) }, + data: item.data, + } + : { + name: item.name, + kind: asSymbolKind(item.kind), + location: asLocation(item.location), + }; + if (item.tags !== void 0) { + result.tags = asSymbolTags(item.tags); + } + if (item.containerName !== '') { + result.containerName = item.containerName; + } + return result; + } + return { + asUri, + asTextDocumentIdentifier, + asVersionedTextDocumentIdentifier, + asOpenTextDocumentParams, + asChangeTextDocumentParams, + asCloseTextDocumentParams, + asSaveTextDocumentParams, + asWillSaveTextDocumentParams, + asDidCreateFilesParams, + asDidRenameFilesParams, + asDidDeleteFilesParams, + asWillCreateFilesParams, + asWillRenameFilesParams, + asWillDeleteFilesParams, + asTextDocumentPositionParams, + asCompletionParams, + asSignatureHelpParams, + asWorkerPosition, + asRange, + asPosition, + asPositions, + asLocation, + asDiagnosticSeverity, + asDiagnosticTag, + asDiagnostic, + asDiagnostics, + asCompletionItem, + asTextEdit, + asSymbolKind, + asSymbolTag, + asSymbolTags, + asReferenceParams, + asCodeAction, + asCodeActionContext, + asInlineValuesContext, + asCommand, + asCodeLens, + asFormattingOptions, + asDocumentSymbolParams, + asCodeLensParams, + asDocumentLink, + asDocumentLinkParams, + asCallHierarchyItem, + asTypeHierarchyItem, + asWorkspaceSymbol, + }; + } + exports.createConverter = createConverter; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/protocolConverter.js +let require_protocolConverter = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/protocolConverter.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createConverter = void 0; + let code = require('vscode'); + let ls2 = require_main3(); + let Is2 = require_is3(); + let protocolCompletionItem_1 = require_protocolCompletionItem(); + let protocolCodeLens_1 = require_protocolCodeLens(); + let protocolDocumentLink_1 = require_protocolDocumentLink(); + let protocolCodeAction_1 = require_protocolCodeAction(); + let protocolDiagnostic_1 = require_protocolDiagnostic(); + let protocolCallHierarchyItem_1 = require_protocolCallHierarchyItem(); + let vscode_languageserver_protocol_1 = require_main3(); + let protocolTypeHierarchyItem_1 = require_protocolTypeHierarchyItem(); + let protocolWorkspaceSymbol_1 = require_protocolWorkspaceSymbol(); + let CodeBlock; + (function (CodeBlock2) { + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.string(candidate.language) && + Is2.string(candidate.value) + ); + } + CodeBlock2.is = is2; + })(CodeBlock || (CodeBlock = {})); + function createConverter(uriConverter, trustMarkdown, supportHtml) { + const nullConverter = (value) => code.Uri.parse(value); + const _uriConverter = uriConverter || nullConverter; + function asUri(value) { + return _uriConverter(value); + } + function asDiagnostics(diagnostics) { + return diagnostics.map(asDiagnostic); + } + function asDiagnostic(diagnostic) { + let result = new protocolDiagnostic_1.ProtocolDiagnostic( + asRange(diagnostic.range), + diagnostic.message, + asDiagnosticSeverity(diagnostic.severity), + diagnostic.data + ); + if (diagnostic.code !== void 0) { + if (ls2.CodeDescription.is(diagnostic.codeDescription)) { + result.code = { + value: diagnostic.code, + target: asUri(diagnostic.codeDescription.href), + }; + } else if (protocolDiagnostic_1.DiagnosticCode.is(diagnostic.code)) { + result.hasDiagnosticCode = true; + result.code = { + value: diagnostic.code.value, + target: asUri(diagnostic.code.target), + }; + } else { + result.code = diagnostic.code; + } + } + if (diagnostic.source) { + result.source = diagnostic.source; + } + if (diagnostic.relatedInformation) { + result.relatedInformation = asRelatedInformation( + diagnostic.relatedInformation + ); + } + if (Array.isArray(diagnostic.tags)) { + result.tags = asDiagnosticTags(diagnostic.tags); + } + return result; + } + function asRelatedInformation(relatedInformation) { + return relatedInformation.map(asDiagnosticRelatedInformation); + } + function asDiagnosticRelatedInformation(information) { + return new code.DiagnosticRelatedInformation( + asLocation(information.location), + information.message + ); + } + function asDiagnosticTags(tags) { + if (!tags) { + return void 0; + } + let result = []; + for (let tag of tags) { + let converted = asDiagnosticTag(tag); + if (converted !== void 0) { + result.push(converted); + } + } + return result.length > 0 ? result : void 0; + } + function asDiagnosticTag(tag) { + switch (tag) { + case ls2.DiagnosticTag.Unnecessary: + return code.DiagnosticTag.Unnecessary; + case ls2.DiagnosticTag.Deprecated: + return code.DiagnosticTag.Deprecated; + default: + return void 0; + } + } + function asPosition(value) { + if (!value) { + return void 0; + } + return new code.Position(value.line, value.character); + } + function asRange(value) { + if (!value) { + return void 0; + } + return new code.Range(asPosition(value.start), asPosition(value.end)); + } + function asRanges(value) { + return value.map((value2) => asRange(value2)); + } + function asDiagnosticSeverity(value) { + if (value === void 0 || value === null) { + return code.DiagnosticSeverity.Error; + } + switch (value) { + case ls2.DiagnosticSeverity.Error: + return code.DiagnosticSeverity.Error; + case ls2.DiagnosticSeverity.Warning: + return code.DiagnosticSeverity.Warning; + case ls2.DiagnosticSeverity.Information: + return code.DiagnosticSeverity.Information; + case ls2.DiagnosticSeverity.Hint: + return code.DiagnosticSeverity.Hint; + } + return code.DiagnosticSeverity.Error; + } + function asHoverContent(value) { + if (Is2.string(value)) { + return asMarkdownString(value); + } else if (CodeBlock.is(value)) { + let result = asMarkdownString(); + return result.appendCodeblock(value.value, value.language); + } else if (Array.isArray(value)) { + let result = []; + for (let element of value) { + let item = asMarkdownString(); + if (CodeBlock.is(element)) { + item.appendCodeblock(element.value, element.language); + } else { + item.appendMarkdown(element); + } + result.push(item); + } + return result; + } else { + let result; + switch (value.kind) { + case ls2.MarkupKind.Markdown: + return asMarkdownString(value.value); + case ls2.MarkupKind.PlainText: + result = asMarkdownString(); + result.appendText(value.value); + return result; + default: + result = asMarkdownString(); + result.appendText( + `Unsupported Markup content received. Kind is: ${value.kind}` + ); + return result; + } + } + } + function asDocumentation(value) { + if (Is2.string(value)) { + return value; + } else { + switch (value.kind) { + case ls2.MarkupKind.Markdown: + return asMarkdownString(value.value); + case ls2.MarkupKind.PlainText: + return value.value; + default: + return `Unsupported Markup content received. Kind is: ${value.kind}`; + } + } + } + function asMarkdownString(value) { + const result = new code.MarkdownString(value); + result.isTrusted = trustMarkdown; + result.supportHtml = supportHtml; + return result; + } + function asHover(hover) { + if (!hover) { + return void 0; + } + return new code.Hover( + asHoverContent(hover.contents), + asRange(hover.range) + ); + } + function asCompletionResult(result, allCommitCharacters) { + if (!result) { + return void 0; + } + if (Array.isArray(result)) { + let items = result; + return items.map((item) => + asCompletionItem(item, allCommitCharacters) + ); + } + const list = result; + const rangeDefaults = list.itemDefaults?.editRange; + const [range, inserting, replacing] = ls2.Range.is(rangeDefaults) + ? [asRange(rangeDefaults), void 0, void 0] + : rangeDefaults !== void 0 + ? [ + void 0, + asRange(rangeDefaults.insert), + asRange(rangeDefaults.replace), + ] + : [void 0, void 0, void 0]; + const commitCharacterDefaults = + list.itemDefaults?.commitCharacters ?? allCommitCharacters; + return new code.CompletionList( + list.items.map((item) => { + const result2 = asCompletionItem( + item, + commitCharacterDefaults, + list.itemDefaults?.insertTextMode, + list.itemDefaults?.insertTextFormat + ); + if (result2.range === void 0) { + if (range !== void 0) { + result2.range = range; + } else if (inserting !== void 0 && replacing !== void 0) { + result2.range = { inserting, replacing }; + } + } + return result2; + }), + list.isIncomplete + ); + } + function asCompletionItemKind(value) { + if ( + ls2.CompletionItemKind.Text <= value && + value <= ls2.CompletionItemKind.TypeParameter + ) { + return [value - 1, void 0]; + } + return [code.CompletionItemKind.Text, value]; + } + function asCompletionItemTag(tag) { + switch (tag) { + case ls2.CompletionItemTag.Deprecated: + return code.CompletionItemTag.Deprecated; + } + return void 0; + } + function asCompletionItemTags(tags) { + if (tags === void 0 || tags === null) { + return []; + } + const result = []; + for (const tag of tags) { + const converted = asCompletionItemTag(tag); + if (converted !== void 0) { + result.push(converted); + } + } + return result; + } + function asCompletionItem( + item, + defaultCommitCharacters, + defaultInsertTextMode, + defaultInsertTextFormat + ) { + const tags = asCompletionItemTags(item.tags); + const label = asCompletionItemLabel(item); + const result = new protocolCompletionItem_1.default(label); + if (item.detail) { + result.detail = item.detail; + } + if (item.documentation) { + result.documentation = asDocumentation(item.documentation); + result.documentationFormat = Is2.string(item.documentation) + ? '$string' + : item.documentation.kind; + } + if (item.filterText) { + result.filterText = item.filterText; + } + const insertText = asCompletionInsertText( + item, + defaultInsertTextFormat + ); + if (insertText) { + result.insertText = insertText.text; + result.range = insertText.range; + result.fromEdit = insertText.fromEdit; + } + if (Is2.number(item.kind)) { + let [itemKind, original] = asCompletionItemKind(item.kind); + result.kind = itemKind; + if (original) { + result.originalItemKind = original; + } + } + if (item.sortText) { + result.sortText = item.sortText; + } + if (item.additionalTextEdits) { + result.additionalTextEdits = asTextEdits(item.additionalTextEdits); + } + const commitCharacters = + item.commitCharacters !== void 0 + ? Is2.stringArray(item.commitCharacters) + ? item.commitCharacters + : void 0 + : defaultCommitCharacters; + if (commitCharacters) { + result.commitCharacters = commitCharacters.slice(); + } + if (item.command) { + result.command = asCommand(item.command); + } + if (item.deprecated === true || item.deprecated === false) { + result.deprecated = item.deprecated; + if (item.deprecated === true) { + tags.push(code.CompletionItemTag.Deprecated); + } + } + if (item.preselect === true || item.preselect === false) { + result.preselect = item.preselect; + } + if (item.data !== void 0) { + result.data = item.data; + } + if (tags.length > 0) { + result.tags = tags; + } + const insertTextMode = item.insertTextMode ?? defaultInsertTextMode; + if (insertTextMode !== void 0) { + result.insertTextMode = insertTextMode; + if ( + insertTextMode === + vscode_languageserver_protocol_1.InsertTextMode.asIs + ) { + result.keepWhitespace = true; + } + } + return result; + } + function asCompletionItemLabel(item) { + if ( + vscode_languageserver_protocol_1.CompletionItemLabelDetails.is( + item.labelDetails + ) + ) { + return { + label: item.label, + detail: item.labelDetails.detail, + description: item.labelDetails.description, + }; + } else { + return item.label; + } + } + function asCompletionInsertText(item, defaultInsertTextFormat) { + const insertTextFormat = + item.insertTextFormat ?? defaultInsertTextFormat; + if (item.textEdit) { + if (insertTextFormat === ls2.InsertTextFormat.Snippet) { + return { + text: new code.SnippetString(item.textEdit.newText), + range: asCompletionRange(item.textEdit), + fromEdit: true, + }; + } else { + return { + text: item.textEdit.newText, + range: asCompletionRange(item.textEdit), + fromEdit: true, + }; + } + } else if (item.insertText) { + if (insertTextFormat === ls2.InsertTextFormat.Snippet) { + return { + text: new code.SnippetString(item.insertText), + fromEdit: false, + }; + } else { + return { text: item.insertText, fromEdit: false }; + } + } else { + return void 0; + } + } + function asCompletionRange(value) { + if (ls2.InsertReplaceEdit.is(value)) { + return { + inserting: asRange(value.insert), + replacing: asRange(value.replace), + }; + } else { + return asRange(value.range); + } + } + function asTextEdit(edit) { + if (!edit) { + return void 0; + } + return new code.TextEdit(asRange(edit.range), edit.newText); + } + function asTextEdits(items) { + if (!items) { + return void 0; + } + return items.map(asTextEdit); + } + function asSignatureHelp(item) { + if (!item) { + return void 0; + } + let result = new code.SignatureHelp(); + if (Is2.number(item.activeSignature)) { + result.activeSignature = item.activeSignature; + } else { + result.activeSignature = 0; + } + if (Is2.number(item.activeParameter)) { + result.activeParameter = item.activeParameter; + } else { + result.activeParameter = 0; + } + if (item.signatures) { + result.signatures = asSignatureInformations(item.signatures); + } + return result; + } + function asSignatureInformations(items) { + return items.map(asSignatureInformation); + } + function asSignatureInformation(item) { + let result = new code.SignatureInformation(item.label); + if (item.documentation !== void 0) { + result.documentation = asDocumentation(item.documentation); + } + if (item.parameters !== void 0) { + result.parameters = asParameterInformations(item.parameters); + } + if (item.activeParameter !== void 0) { + result.activeParameter = item.activeParameter; + } + { + return result; + } + } + function asParameterInformations(item) { + return item.map(asParameterInformation); + } + function asParameterInformation(item) { + let result = new code.ParameterInformation(item.label); + if (item.documentation) { + result.documentation = asDocumentation(item.documentation); + } + return result; + } + function asLocation(item) { + if (!item) { + return void 0; + } + return new code.Location(_uriConverter(item.uri), asRange(item.range)); + } + function asDeclarationResult(item) { + if (!item) { + return void 0; + } + return asLocationResult(item); + } + function asDefinitionResult(item) { + if (!item) { + return void 0; + } + return asLocationResult(item); + } + function asLocationLink(item) { + if (!item) { + return void 0; + } + let result = { + targetUri: _uriConverter(item.targetUri), + targetRange: asRange(item.targetRange), + originSelectionRange: asRange(item.originSelectionRange), + targetSelectionRange: asRange(item.targetSelectionRange), + }; + if (!result.targetSelectionRange) { + throw new Error(`targetSelectionRange must not be undefined or null`); + } + return result; + } + function asLocationResult(item) { + if (!item) { + return void 0; + } + if (Is2.array(item)) { + if (item.length === 0) { + return []; + } else if (ls2.LocationLink.is(item[0])) { + let links = item; + return links.map((link) => asLocationLink(link)); + } else { + let locations = item; + return locations.map((location2) => asLocation(location2)); + } + } else if (ls2.LocationLink.is(item)) { + return [asLocationLink(item)]; + } else { + return asLocation(item); + } + } + function asReferences(values) { + if (!values) { + return void 0; + } + return values.map((location2) => asLocation(location2)); + } + function asDocumentHighlights(values) { + if (!values) { + return void 0; + } + return values.map(asDocumentHighlight); + } + function asDocumentHighlight(item) { + let result = new code.DocumentHighlight(asRange(item.range)); + if (Is2.number(item.kind)) { + result.kind = asDocumentHighlightKind(item.kind); + } + return result; + } + function asDocumentHighlightKind(item) { + switch (item) { + case ls2.DocumentHighlightKind.Text: + return code.DocumentHighlightKind.Text; + case ls2.DocumentHighlightKind.Read: + return code.DocumentHighlightKind.Read; + case ls2.DocumentHighlightKind.Write: + return code.DocumentHighlightKind.Write; + } + return code.DocumentHighlightKind.Text; + } + function asSymbolInformations(values) { + if (!values) { + return void 0; + } + return values.map((information) => asSymbolInformation(information)); + } + function asSymbolKind(item) { + if (item <= ls2.SymbolKind.TypeParameter) { + return item - 1; + } + return code.SymbolKind.Property; + } + function asSymbolTag(value) { + switch (value) { + case ls2.SymbolTag.Deprecated: + return code.SymbolTag.Deprecated; + default: + return void 0; + } + } + function asSymbolTags(items) { + if (items === void 0 || items === null) { + return void 0; + } + const result = []; + for (const item of items) { + const converted = asSymbolTag(item); + if (converted !== void 0) { + result.push(converted); + } + } + return result.length === 0 ? void 0 : result; + } + function asSymbolInformation(item) { + const data = item.data; + const location2 = item.location; + const result = + location2.range === void 0 || data !== void 0 + ? new protocolWorkspaceSymbol_1.default( + item.name, + asSymbolKind(item.kind), + item.containerName ?? '', + location2.range === void 0 + ? _uriConverter(location2.uri) + : new code.Location( + _uriConverter(item.location.uri), + asRange(location2.range) + ), + data + ) + : new code.SymbolInformation( + item.name, + asSymbolKind(item.kind), + item.containerName ?? '', + new code.Location( + _uriConverter(item.location.uri), + asRange(location2.range) + ) + ); + fillTags(result, item); + return result; + } + function asDocumentSymbols(values) { + if (values === void 0 || values === null) { + return void 0; + } + return values.map(asDocumentSymbol); + } + function asDocumentSymbol(value) { + let result = new code.DocumentSymbol( + value.name, + value.detail || '', + asSymbolKind(value.kind), + asRange(value.range), + asRange(value.selectionRange) + ); + fillTags(result, value); + if (value.children !== void 0 && value.children.length > 0) { + let children = []; + for (let child of value.children) { + children.push(asDocumentSymbol(child)); + } + result.children = children; + } + return result; + } + function fillTags(result, value) { + result.tags = asSymbolTags(value.tags); + if (value.deprecated) { + if (!result.tags) { + result.tags = [code.SymbolTag.Deprecated]; + } else { + if (!result.tags.includes(code.SymbolTag.Deprecated)) { + result.tags = result.tags.concat(code.SymbolTag.Deprecated); + } + } + } + } + function asCommand(item) { + let result = { title: item.title, command: item.command }; + if (item.arguments) { + result.arguments = item.arguments; + } + return result; + } + function asCommands(items) { + if (!items) { + return void 0; + } + return items.map(asCommand); + } + const kindMapping = new Map(); + kindMapping.set(ls2.CodeActionKind.Empty, code.CodeActionKind.Empty); + kindMapping.set( + ls2.CodeActionKind.QuickFix, + code.CodeActionKind.QuickFix + ); + kindMapping.set( + ls2.CodeActionKind.Refactor, + code.CodeActionKind.Refactor + ); + kindMapping.set( + ls2.CodeActionKind.RefactorExtract, + code.CodeActionKind.RefactorExtract + ); + kindMapping.set( + ls2.CodeActionKind.RefactorInline, + code.CodeActionKind.RefactorInline + ); + kindMapping.set( + ls2.CodeActionKind.RefactorRewrite, + code.CodeActionKind.RefactorRewrite + ); + kindMapping.set(ls2.CodeActionKind.Source, code.CodeActionKind.Source); + kindMapping.set( + ls2.CodeActionKind.SourceOrganizeImports, + code.CodeActionKind.SourceOrganizeImports + ); + function asCodeActionKind(item) { + if (item === void 0 || item === null) { + return void 0; + } + let result = kindMapping.get(item); + if (result) { + return result; + } + let parts = item.split('.'); + result = code.CodeActionKind.Empty; + for (let part of parts) { + result = result.append(part); + } + return result; + } + function asCodeActionKinds(items) { + if (items === void 0 || items === null) { + return void 0; + } + return items.map((kind) => asCodeActionKind(kind)); + } + function asCodeAction(item) { + if (item === void 0 || item === null) { + return void 0; + } + let result = new protocolCodeAction_1.default(item.title, item.data); + if (item.kind !== void 0) { + result.kind = asCodeActionKind(item.kind); + } + if (item.diagnostics !== void 0) { + result.diagnostics = asDiagnostics(item.diagnostics); + } + if (item.edit !== void 0) { + result.edit = asWorkspaceEdit(item.edit); + } + if (item.command !== void 0) { + result.command = asCommand(item.command); + } + if (item.isPreferred !== void 0) { + result.isPreferred = item.isPreferred; + } + if (item.disabled !== void 0) { + result.disabled = { reason: item.disabled.reason }; + } + return result; + } + function asCodeLens(item) { + if (!item) { + return void 0; + } + let result = new protocolCodeLens_1.default(asRange(item.range)); + if (item.command) { + result.command = asCommand(item.command); + } + if (item.data !== void 0 && item.data !== null) { + result.data = item.data; + } + return result; + } + function asCodeLenses(items) { + if (!items) { + return void 0; + } + return items.map((codeLens) => asCodeLens(codeLens)); + } + function asWorkspaceEdit(item) { + if (!item) { + return void 0; + } + const sharedMetadata = new Map(); + if (item.changeAnnotations !== void 0) { + for (const key of Object.keys(item.changeAnnotations)) { + const metaData = asWorkspaceEditEntryMetadata( + item.changeAnnotations[key] + ); + sharedMetadata.set(key, metaData); + } + } + const asMetadata = (annotation) => { + if (annotation === void 0) { + return void 0; + } else { + return sharedMetadata.get(annotation); + } + }; + const result = new code.WorkspaceEdit(); + if (item.documentChanges) { + for (const change of item.documentChanges) { + if (ls2.CreateFile.is(change)) { + result.createFile( + _uriConverter(change.uri), + change.options, + asMetadata(change.annotationId) + ); + } else if (ls2.RenameFile.is(change)) { + result.renameFile( + _uriConverter(change.oldUri), + _uriConverter(change.newUri), + change.options, + asMetadata(change.annotationId) + ); + } else if (ls2.DeleteFile.is(change)) { + result.deleteFile( + _uriConverter(change.uri), + change.options, + asMetadata(change.annotationId) + ); + } else if (ls2.TextDocumentEdit.is(change)) { + const uri = _uriConverter(change.textDocument.uri); + for (const edit of change.edits) { + if ( + vscode_languageserver_protocol_1.AnnotatedTextEdit.is(edit) + ) { + result.replace( + uri, + asRange(edit.range), + edit.newText, + asMetadata(edit.annotationId) + ); + } else { + result.replace(uri, asRange(edit.range), edit.newText); + } + } + } else { + throw new Error(`Unknown workspace edit change received: +${JSON.stringify(change, void 0, 4)}`); + } + } + } else if (item.changes) { + Object.keys(item.changes).forEach((key) => { + result.set(_uriConverter(key), asTextEdits(item.changes[key])); + }); + } + return result; + } + function asWorkspaceEditEntryMetadata(annotation) { + if (annotation === void 0) { + return void 0; + } + return { + label: annotation.label, + needsConfirmation: !!annotation.needsConfirmation, + description: annotation.description, + }; + } + function asDocumentLink(item) { + let range = asRange(item.range); + let target = item.target ? asUri(item.target) : void 0; + let link = new protocolDocumentLink_1.default(range, target); + if (item.tooltip !== void 0) { + link.tooltip = item.tooltip; + } + if (item.data !== void 0 && item.data !== null) { + link.data = item.data; + } + return link; + } + function asDocumentLinks(items) { + if (!items) { + return void 0; + } + return items.map(asDocumentLink); + } + function asColor(color) { + return new code.Color(color.red, color.green, color.blue, color.alpha); + } + function asColorInformation(ci2) { + return new code.ColorInformation( + asRange(ci2.range), + asColor(ci2.color) + ); + } + function asColorInformations(colorInformation) { + if (Array.isArray(colorInformation)) { + return colorInformation.map(asColorInformation); + } + return void 0; + } + function asColorPresentation(cp) { + let presentation = new code.ColorPresentation(cp.label); + presentation.additionalTextEdits = asTextEdits(cp.additionalTextEdits); + if (cp.textEdit) { + presentation.textEdit = asTextEdit(cp.textEdit); + } + return presentation; + } + function asColorPresentations(colorPresentations) { + if (Array.isArray(colorPresentations)) { + return colorPresentations.map(asColorPresentation); + } + return void 0; + } + function asFoldingRangeKind(kind) { + if (kind) { + switch (kind) { + case ls2.FoldingRangeKind.Comment: + return code.FoldingRangeKind.Comment; + case ls2.FoldingRangeKind.Imports: + return code.FoldingRangeKind.Imports; + case ls2.FoldingRangeKind.Region: + return code.FoldingRangeKind.Region; + } + } + return void 0; + } + function asFoldingRange(r) { + return new code.FoldingRange( + r.startLine, + r.endLine, + asFoldingRangeKind(r.kind) + ); + } + function asFoldingRanges(foldingRanges) { + if (Array.isArray(foldingRanges)) { + return foldingRanges.map(asFoldingRange); + } + return void 0; + } + function asSelectionRange(selectionRange) { + return new code.SelectionRange( + asRange(selectionRange.range), + selectionRange.parent + ? asSelectionRange(selectionRange.parent) + : void 0 + ); + } + function asSelectionRanges(selectionRanges) { + if (!Array.isArray(selectionRanges)) { + return []; + } + let result = []; + for (let range of selectionRanges) { + result.push(asSelectionRange(range)); + } + return result; + } + function asInlineValue(inlineValue) { + if (ls2.InlineValueText.is(inlineValue)) { + return new code.InlineValueText( + asRange(inlineValue.range), + inlineValue.text + ); + } else if (ls2.InlineValueVariableLookup.is(inlineValue)) { + return new code.InlineValueVariableLookup( + asRange(inlineValue.range), + inlineValue.variableName, + inlineValue.caseSensitiveLookup + ); + } else { + return new code.InlineValueEvaluatableExpression( + asRange(inlineValue.range), + inlineValue.expression + ); + } + } + function asInlineValues(inlineValues) { + if (!Array.isArray(inlineValues)) { + return []; + } + const result = []; + for (const inlineValue of inlineValues) { + result.push(asInlineValue(inlineValue)); + } + return result; + } + function asCallHierarchyItem(item) { + if (item === null) { + return void 0; + } + const result = new protocolCallHierarchyItem_1.default( + asSymbolKind(item.kind), + item.name, + item.detail || '', + asUri(item.uri), + asRange(item.range), + asRange(item.selectionRange), + item.data + ); + if (item.tags !== void 0) { + result.tags = asSymbolTags(item.tags); + } + return result; + } + function asCallHierarchyItems(items) { + if (items === null) { + return void 0; + } + return items.map((item) => asCallHierarchyItem(item)); + } + function asCallHierarchyIncomingCall(item) { + return new code.CallHierarchyIncomingCall( + asCallHierarchyItem(item.from), + asRanges(item.fromRanges) + ); + } + function asCallHierarchyIncomingCalls(items) { + if (items === null) { + return void 0; + } + return items.map((item) => asCallHierarchyIncomingCall(item)); + } + function asCallHierarchyOutgoingCall(item) { + return new code.CallHierarchyOutgoingCall( + asCallHierarchyItem(item.to), + asRanges(item.fromRanges) + ); + } + function asCallHierarchyOutgoingCalls(items) { + if (items === null) { + return void 0; + } + return items.map((item) => asCallHierarchyOutgoingCall(item)); + } + function asSemanticTokens(value) { + if (value === void 0 || value === null) { + return void 0; + } + return new code.SemanticTokens( + new Uint32Array(value.data), + value.resultId + ); + } + function asSemanticTokensEdit(value) { + return new code.SemanticTokensEdit( + value.start, + value.deleteCount, + value.data !== void 0 ? new Uint32Array(value.data) : void 0 + ); + } + function asSemanticTokensEdits(value) { + if (value === void 0 || value === null) { + return void 0; + } + return new code.SemanticTokensEdits( + value.edits.map(asSemanticTokensEdit), + value.resultId + ); + } + function asSemanticTokensLegend(value) { + return value; + } + function asLinkedEditingRanges(value) { + if (value === null || value === void 0) { + return void 0; + } + return new code.LinkedEditingRanges( + asRanges(value.ranges), + asRegularExpression(value.wordPattern) + ); + } + function asRegularExpression(value) { + if (value === null || value === void 0) { + return void 0; + } + return new RegExp(value); + } + function asTypeHierarchyItem(item) { + if (item === null) { + return void 0; + } + let result = new protocolTypeHierarchyItem_1.default( + asSymbolKind(item.kind), + item.name, + item.detail || '', + asUri(item.uri), + asRange(item.range), + asRange(item.selectionRange), + item.data + ); + if (item.tags !== void 0) { + result.tags = asSymbolTags(item.tags); + } + return result; + } + function asTypeHierarchyItems(items) { + if (items === null) { + return void 0; + } + return items.map((item) => asTypeHierarchyItem(item)); + } + return { + asUri, + asDiagnostics, + asDiagnostic, + asRange, + asRanges, + asPosition, + asDiagnosticSeverity, + asDiagnosticTag, + asHover, + asCompletionResult, + asCompletionItem, + asTextEdit, + asTextEdits, + asSignatureHelp, + asSignatureInformations, + asSignatureInformation, + asParameterInformations, + asParameterInformation, + asDeclarationResult, + asDefinitionResult, + asLocation, + asReferences, + asDocumentHighlights, + asDocumentHighlight, + asDocumentHighlightKind, + asSymbolKind, + asSymbolTag, + asSymbolTags, + asSymbolInformations, + asSymbolInformation, + asDocumentSymbols, + asDocumentSymbol, + asCommand, + asCommands, + asCodeAction, + asCodeActionKind, + asCodeActionKinds, + asCodeLens, + asCodeLenses, + asWorkspaceEdit, + asDocumentLink, + asDocumentLinks, + asFoldingRangeKind, + asFoldingRange, + asFoldingRanges, + asColor, + asColorInformation, + asColorInformations, + asColorPresentation, + asColorPresentations, + asSelectionRange, + asSelectionRanges, + asInlineValue, + asInlineValues, + asSemanticTokensLegend, + asSemanticTokens, + asSemanticTokensEdit, + asSemanticTokensEdits, + asCallHierarchyItem, + asCallHierarchyItems, + asCallHierarchyIncomingCall, + asCallHierarchyIncomingCalls, + asCallHierarchyOutgoingCall, + asCallHierarchyOutgoingCalls, + asLinkedEditingRanges, + asTypeHierarchyItem, + asTypeHierarchyItems, + }; + } + exports.createConverter = createConverter; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/utils/async.js +let require_async = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/utils/async.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Delayer = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let Delayer = class { + constructor(defaultDelay) { + this.defaultDelay = defaultDelay; + this.timeout = void 0; + this.completionPromise = void 0; + this.onSuccess = void 0; + this.task = void 0; + } + trigger(task, delay = this.defaultDelay) { + this.task = task; + if (delay >= 0) { + this.cancelTimeout(); + } + if (!this.completionPromise) { + this.completionPromise = new Promise((resolve) => { + this.onSuccess = resolve; + }).then(() => { + this.completionPromise = void 0; + this.onSuccess = void 0; + let result = this.task(); + this.task = void 0; + return result; + }); + } + if (delay >= 0 || this.timeout === void 0) { + this.timeout = (0, + vscode_languageserver_protocol_1.RAL)().timer.setTimeout( + () => { + this.timeout = void 0; + this.onSuccess(void 0); + }, + delay >= 0 ? delay : this.defaultDelay + ); + } + return this.completionPromise; + } + forceDelivery() { + if (!this.completionPromise) { + return void 0; + } + this.cancelTimeout(); + let result = this.task(); + this.completionPromise = void 0; + this.onSuccess = void 0; + this.task = void 0; + return result; + } + isTriggered() { + return this.timeout !== void 0; + } + cancel() { + this.cancelTimeout(); + this.completionPromise = void 0; + } + cancelTimeout() { + if (this.timeout !== void 0) { + this.timeout.dispose(); + this.timeout = void 0; + } + } + }; + exports.Delayer = Delayer; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/utils/uuid.js +let require_uuid = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/utils/uuid.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0; + let ValueUUID = class { + constructor(_value) { + this._value = _value; + } + asHex() { + return this._value; + } + equals(other) { + return this.asHex() === other.asHex(); + } + }; + var V4UUID = class extends ValueUUID { + constructor() { + super( + [ + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + '4', + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + V4UUID._oneOf(V4UUID._timeHighBits), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + ].join('') + ); + } + static _oneOf(array) { + return array[Math.floor(array.length * Math.random())]; + } + static _randomHex() { + return V4UUID._oneOf(V4UUID._chars); + } + }; + V4UUID._chars = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '6', + '7', + '8', + '9', + 'a', + 'b', + 'c', + 'd', + 'e', + 'f', + ]; + V4UUID._timeHighBits = ['8', '9', 'a', 'b']; + exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000'); + function v4() { + return new V4UUID(); + } + exports.v4 = v4; + let _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; + function isUUID(value) { + return _UUIDPattern.test(value); + } + exports.isUUID = isUUID; + function parse(value) { + if (!isUUID(value)) { + throw new Error('invalid uuid'); + } + return new ValueUUID(value); + } + exports.parse = parse; + function generateUuid() { + return v4().asHex(); + } + exports.generateUuid = generateUuid; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/progressPart.js +let require_progressPart = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/progressPart.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProgressPart = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let Is2 = require_is3(); + let ProgressPart = class { + constructor(_client, _token, done) { + this._client = _client; + this._token = _token; + this._reported = 0; + this._infinite = false; + this._lspProgressDisposable = this._client.onProgress( + vscode_languageserver_protocol_1.WorkDoneProgress.type, + this._token, + (value) => { + switch (value.kind) { + case 'begin': + this.begin(value); + break; + case 'report': + this.report(value); + break; + case 'end': + this.done(); + done && done(this); + break; + } + } + ); + } + begin(params) { + this._infinite = params.percentage === void 0; + if (this._lspProgressDisposable === void 0) { + return; + } + void vscode_1.window.withProgress( + { + location: vscode_1.ProgressLocation.Window, + cancellable: params.cancellable, + title: params.title, + }, + async (progress, cancellationToken) => { + if (this._lspProgressDisposable === void 0) { + return; + } + this._progress = progress; + this._cancellationToken = cancellationToken; + this._tokenDisposable = this._cancellationToken.onCancellationRequested( + () => { + this._client.sendNotification( + vscode_languageserver_protocol_1 + .WorkDoneProgressCancelNotification.type, + { token: this._token } + ); + } + ); + this.report(params); + return new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); + } + ); + } + report(params) { + if (this._infinite && Is2.string(params.message)) { + this._progress !== void 0 && + this._progress.report({ message: params.message }); + } else if (Is2.number(params.percentage)) { + const percentage = Math.max(0, Math.min(params.percentage, 100)); + const delta = Math.max(0, percentage - this._reported); + this._reported += delta; + this._progress !== void 0 && + this._progress.report({ + message: params.message, + increment: delta, + }); + } + } + cancel() { + this.cleanup(); + if (this._reject !== void 0) { + this._reject(); + this._resolve = void 0; + this._reject = void 0; + } + } + done() { + this.cleanup(); + if (this._resolve !== void 0) { + this._resolve(); + this._resolve = void 0; + this._reject = void 0; + } + } + cleanup() { + if (this._lspProgressDisposable !== void 0) { + this._lspProgressDisposable.dispose(); + this._lspProgressDisposable = void 0; + } + if (this._tokenDisposable !== void 0) { + this._tokenDisposable.dispose(); + this._tokenDisposable = void 0; + } + this._progress = void 0; + this._cancellationToken = void 0; + } + }; + exports.ProgressPart = ProgressPart; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/client.js +let require_client = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/client.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.BaseLanguageClient = exports.LSPCancellationError = exports.MessageTransports = exports.TextDocumentFeature = exports.State = exports.RevealOutputChannelOn = exports.DiagnosticPullMode = exports.CloseAction = exports.ErrorAction = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let configuration_1 = require_configuration(); + let c2p = require_codeConverter(); + let p2c = require_protocolConverter(); + let Is2 = require_is3(); + let async_1 = require_async(); + let UUID = require_uuid(); + let progressPart_1 = require_progressPart(); + let ConsoleLogger = class { + error(message) { + (0, vscode_languageserver_protocol_1.RAL)().console.error(message); + } + warn(message) { + (0, vscode_languageserver_protocol_1.RAL)().console.warn(message); + } + info(message) { + (0, vscode_languageserver_protocol_1.RAL)().console.info(message); + } + log(message) { + (0, vscode_languageserver_protocol_1.RAL)().console.log(message); + } + }; + function createConnection( + input, + output, + errorHandler, + closeHandler, + options + ) { + let logger = new ConsoleLogger(); + let connection = (0, + vscode_languageserver_protocol_1.createProtocolConnection)( + input, + output, + logger, + options + ); + connection.onError((data) => { + errorHandler(data[0], data[1], data[2]); + }); + connection.onClose(closeHandler); + let result = { + listen: () => connection.listen(), + sendRequest: (type, ...params) => + connection.sendRequest(type, ...params), + onRequest: (type, handler) => connection.onRequest(type, handler), + sendNotification: (type, params) => + connection.sendNotification(type, params), + onNotification: (type, handler) => + connection.onNotification(type, handler), + onProgress: connection.onProgress, + sendProgress: connection.sendProgress, + trace: (value, tracer, sendNotificationOrTraceOptions) => { + const defaultTraceOptions = { + sendNotification: false, + traceFormat: vscode_languageserver_protocol_1.TraceFormat.Text, + }; + if (sendNotificationOrTraceOptions === void 0) { + connection.trace(value, tracer, defaultTraceOptions); + } else if (Is2.boolean(sendNotificationOrTraceOptions)) { + connection.trace(value, tracer, sendNotificationOrTraceOptions); + } else { + connection.trace(value, tracer, sendNotificationOrTraceOptions); + } + }, + initialize: (params) => + connection.sendRequest( + vscode_languageserver_protocol_1.InitializeRequest.type, + params + ), + shutdown: () => + connection.sendRequest( + vscode_languageserver_protocol_1.ShutdownRequest.type, + void 0 + ), + exit: () => + connection.sendNotification( + vscode_languageserver_protocol_1.ExitNotification.type + ), + onLogMessage: (handler) => + connection.onNotification( + vscode_languageserver_protocol_1.LogMessageNotification.type, + handler + ), + onShowMessage: (handler) => + connection.onNotification( + vscode_languageserver_protocol_1.ShowMessageNotification.type, + handler + ), + onTelemetry: (handler) => + connection.onNotification( + vscode_languageserver_protocol_1.TelemetryEventNotification.type, + handler + ), + didChangeConfiguration: (params) => + connection.sendNotification( + vscode_languageserver_protocol_1.DidChangeConfigurationNotification + .type, + params + ), + didChangeWatchedFiles: (params) => + connection.sendNotification( + vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification + .type, + params + ), + didOpenTextDocument: (params) => + connection.sendNotification( + vscode_languageserver_protocol_1.DidOpenTextDocumentNotification + .type, + params + ), + didChangeTextDocument: (params) => + connection.sendNotification( + vscode_languageserver_protocol_1.DidChangeTextDocumentNotification + .type, + params + ), + didCloseTextDocument: (params) => + connection.sendNotification( + vscode_languageserver_protocol_1.DidCloseTextDocumentNotification + .type, + params + ), + didSaveTextDocument: (params) => + connection.sendNotification( + vscode_languageserver_protocol_1.DidSaveTextDocumentNotification + .type, + params + ), + onDiagnostics: (handler) => + connection.onNotification( + vscode_languageserver_protocol_1.PublishDiagnosticsNotification + .type, + handler + ), + end: () => connection.end(), + dispose: () => connection.dispose(), + }; + return result; + } + let ErrorAction; + (function (ErrorAction2) { + ErrorAction2[(ErrorAction2['Continue'] = 1)] = 'Continue'; + ErrorAction2[(ErrorAction2['Shutdown'] = 2)] = 'Shutdown'; + })((ErrorAction = exports.ErrorAction || (exports.ErrorAction = {}))); + let CloseAction; + (function (CloseAction2) { + CloseAction2[(CloseAction2['DoNotRestart'] = 1)] = 'DoNotRestart'; + CloseAction2[(CloseAction2['Restart'] = 2)] = 'Restart'; + })((CloseAction = exports.CloseAction || (exports.CloseAction = {}))); + let DefaultErrorHandler = class { + constructor(client, maxRestartCount) { + this.client = client; + this.maxRestartCount = maxRestartCount; + this.restarts = []; + } + error(_error, _message, count) { + if (count && count <= 3) { + return { action: ErrorAction.Continue }; + } + return { action: ErrorAction.Shutdown }; + } + closed() { + this.restarts.push(Date.now()); + if (this.restarts.length <= this.maxRestartCount) { + return { action: CloseAction.Restart }; + } else { + let diff = this.restarts[this.restarts.length - 1] - this.restarts[0]; + if (diff <= 3 * 60 * 1e3) { + return { + action: CloseAction.DoNotRestart, + message: `The ${this.client.name} server crashed ${ + this.maxRestartCount + 1 + } times in the last 3 minutes. The server will not be restarted. The output for more information.`, + }; + } else { + this.restarts.shift(); + return { action: CloseAction.Restart }; + } + } + } + }; + let DiagnosticPullMode; + (function (DiagnosticPullMode2) { + DiagnosticPullMode2['onType'] = 'onType'; + DiagnosticPullMode2['onSave'] = 'onSave'; + })( + (DiagnosticPullMode = + exports.DiagnosticPullMode || (exports.DiagnosticPullMode = {})) + ); + let RevealOutputChannelOn2; + (function (RevealOutputChannelOn3) { + RevealOutputChannelOn3[(RevealOutputChannelOn3['Info'] = 1)] = 'Info'; + RevealOutputChannelOn3[(RevealOutputChannelOn3['Warn'] = 2)] = 'Warn'; + RevealOutputChannelOn3[(RevealOutputChannelOn3['Error'] = 3)] = 'Error'; + RevealOutputChannelOn3[(RevealOutputChannelOn3['Never'] = 4)] = 'Never'; + })( + (RevealOutputChannelOn2 = + exports.RevealOutputChannelOn || (exports.RevealOutputChannelOn = {})) + ); + let State; + (function (State2) { + State2[(State2['Stopped'] = 1)] = 'Stopped'; + State2[(State2['Starting'] = 3)] = 'Starting'; + State2[(State2['Running'] = 2)] = 'Running'; + })((State = exports.State || (exports.State = {}))); + let ClientState; + (function (ClientState2) { + ClientState2[(ClientState2['Initial'] = 0)] = 'Initial'; + ClientState2[(ClientState2['Starting'] = 1)] = 'Starting'; + ClientState2[(ClientState2['StartFailed'] = 2)] = 'StartFailed'; + ClientState2[(ClientState2['Running'] = 3)] = 'Running'; + ClientState2[(ClientState2['Stopping'] = 4)] = 'Stopping'; + ClientState2[(ClientState2['Stopped'] = 5)] = 'Stopped'; + })(ClientState || (ClientState = {})); + let SupportedSymbolKinds = [ + vscode_languageserver_protocol_1.SymbolKind.File, + vscode_languageserver_protocol_1.SymbolKind.Module, + vscode_languageserver_protocol_1.SymbolKind.Namespace, + vscode_languageserver_protocol_1.SymbolKind.Package, + vscode_languageserver_protocol_1.SymbolKind.Class, + vscode_languageserver_protocol_1.SymbolKind.Method, + vscode_languageserver_protocol_1.SymbolKind.Property, + vscode_languageserver_protocol_1.SymbolKind.Field, + vscode_languageserver_protocol_1.SymbolKind.Constructor, + vscode_languageserver_protocol_1.SymbolKind.Enum, + vscode_languageserver_protocol_1.SymbolKind.Interface, + vscode_languageserver_protocol_1.SymbolKind.Function, + vscode_languageserver_protocol_1.SymbolKind.Variable, + vscode_languageserver_protocol_1.SymbolKind.Constant, + vscode_languageserver_protocol_1.SymbolKind.String, + vscode_languageserver_protocol_1.SymbolKind.Number, + vscode_languageserver_protocol_1.SymbolKind.Boolean, + vscode_languageserver_protocol_1.SymbolKind.Array, + vscode_languageserver_protocol_1.SymbolKind.Object, + vscode_languageserver_protocol_1.SymbolKind.Key, + vscode_languageserver_protocol_1.SymbolKind.Null, + vscode_languageserver_protocol_1.SymbolKind.EnumMember, + vscode_languageserver_protocol_1.SymbolKind.Struct, + vscode_languageserver_protocol_1.SymbolKind.Event, + vscode_languageserver_protocol_1.SymbolKind.Operator, + vscode_languageserver_protocol_1.SymbolKind.TypeParameter, + ]; + let SupportedCompletionItemKinds = [ + vscode_languageserver_protocol_1.CompletionItemKind.Text, + vscode_languageserver_protocol_1.CompletionItemKind.Method, + vscode_languageserver_protocol_1.CompletionItemKind.Function, + vscode_languageserver_protocol_1.CompletionItemKind.Constructor, + vscode_languageserver_protocol_1.CompletionItemKind.Field, + vscode_languageserver_protocol_1.CompletionItemKind.Variable, + vscode_languageserver_protocol_1.CompletionItemKind.Class, + vscode_languageserver_protocol_1.CompletionItemKind.Interface, + vscode_languageserver_protocol_1.CompletionItemKind.Module, + vscode_languageserver_protocol_1.CompletionItemKind.Property, + vscode_languageserver_protocol_1.CompletionItemKind.Unit, + vscode_languageserver_protocol_1.CompletionItemKind.Value, + vscode_languageserver_protocol_1.CompletionItemKind.Enum, + vscode_languageserver_protocol_1.CompletionItemKind.Keyword, + vscode_languageserver_protocol_1.CompletionItemKind.Snippet, + vscode_languageserver_protocol_1.CompletionItemKind.Color, + vscode_languageserver_protocol_1.CompletionItemKind.File, + vscode_languageserver_protocol_1.CompletionItemKind.Reference, + vscode_languageserver_protocol_1.CompletionItemKind.Folder, + vscode_languageserver_protocol_1.CompletionItemKind.EnumMember, + vscode_languageserver_protocol_1.CompletionItemKind.Constant, + vscode_languageserver_protocol_1.CompletionItemKind.Struct, + vscode_languageserver_protocol_1.CompletionItemKind.Event, + vscode_languageserver_protocol_1.CompletionItemKind.Operator, + vscode_languageserver_protocol_1.CompletionItemKind.TypeParameter, + ]; + let SupportedSymbolTags = [ + vscode_languageserver_protocol_1.SymbolTag.Deprecated, + ]; + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let FileFormattingOptions; + (function (FileFormattingOptions2) { + function fromConfiguration(document2) { + const filesConfig = vscode_1.workspace.getConfiguration( + 'files', + document2 + ); + return { + trimTrailingWhitespace: filesConfig.get('trimTrailingWhitespace'), + trimFinalNewlines: filesConfig.get('trimFinalNewlines'), + insertFinalNewline: filesConfig.get('insertFinalNewline'), + }; + } + FileFormattingOptions2.fromConfiguration = fromConfiguration; + })(FileFormattingOptions || (FileFormattingOptions = {})); + let DynamicFeature; + (function (DynamicFeature2) { + function is2(value) { + let candidate = value; + return ( + candidate && + Is2.func(candidate.register) && + Is2.func(candidate.unregister) && + Is2.func(candidate.dispose) && + candidate.registrationType !== void 0 + ); + } + DynamicFeature2.is = is2; + })(DynamicFeature || (DynamicFeature = {})); + let DocumentNotifications = class { + constructor( + _client, + _event, + _type, + _middleware, + _createParams, + _selectorFilter + ) { + this._client = _client; + this._event = _event; + this._type = _type; + this._middleware = _middleware; + this._createParams = _createParams; + this._selectorFilter = _selectorFilter; + this._selectors = new Map(); + this._onNotificationSent = new vscode_1.EventEmitter(); + } + static textDocumentFilter(selectors, textDocument) { + for (const selector of selectors) { + if (vscode_1.languages.match(selector, textDocument)) { + return true; + } + } + return false; + } + register(data) { + if (!data.registerOptions.documentSelector) { + return; + } + if (!this._listener) { + this._listener = this._event((data2) => { + this.callback(data2).catch((error) => { + this._client.error( + `Sending document notification ${this._type.method} failed.`, + error + ); + }); + }); + } + this._selectors.set(data.id, data.registerOptions.documentSelector); + } + async callback(data) { + const doSend = async (data2) => { + const params = this._createParams(data2); + await this._client.sendNotification(this._type, params).catch(); + this.notificationSent(data2, this._type, params); + }; + if ( + !this._selectorFilter || + this._selectorFilter(this._selectors.values(), data) + ) { + return this._middleware + ? this._middleware(data, (data2) => doSend(data2)) + : doSend(data); + } + } + get onNotificationSent() { + return this._onNotificationSent.event; + } + notificationSent(data, type, params) { + this._onNotificationSent.fire({ original: data, type, params }); + } + unregister(id) { + this._selectors.delete(id); + if (this._selectors.size === 0 && this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + dispose() { + this._selectors.clear(); + this._onNotificationSent.dispose(); + if (this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + getProvider(document2) { + for (const selector of this._selectors.values()) { + if (vscode_1.languages.match(selector, document2)) { + return { + send: (data) => { + return this.callback(data); + }, + }; + } + } + return void 0; + } + }; + let DidOpenTextDocumentFeature = class extends DocumentNotifications { + constructor(client, _syncedDocuments) { + super( + client, + vscode_1.workspace.onDidOpenTextDocument, + vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, + client.clientOptions.middleware.didOpen, + (textDocument) => + client.code2ProtocolConverter.asOpenTextDocumentParams( + textDocument + ), + DocumentNotifications.textDocumentFilter + ); + this._syncedDocuments = _syncedDocuments; + } + get openDocuments() { + return this._syncedDocuments.values(); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'synchronization' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; + if ( + documentSelector && + textDocumentSyncOptions && + textDocumentSyncOptions.openClose + ) { + this.register({ + id: UUID.generateUuid(), + registerOptions: { documentSelector }, + }); + } + } + get registrationType() { + return vscode_languageserver_protocol_1.DidOpenTextDocumentNotification + .type; + } + register(data) { + super.register(data); + if (!data.registerOptions.documentSelector) { + return; + } + let documentSelector = data.registerOptions.documentSelector; + vscode_1.workspace.textDocuments.forEach((textDocument) => { + let uri = textDocument.uri.toString(); + if (this._syncedDocuments.has(uri)) { + return; + } + if (vscode_1.languages.match(documentSelector, textDocument)) { + let middleware = this._client.clientOptions.middleware; + let didOpen = (textDocument2) => { + return this._client.sendNotification( + this._type, + this._createParams(textDocument2) + ); + }; + (middleware.didOpen + ? middleware.didOpen(textDocument, didOpen) + : didOpen(textDocument) + ).catch((error) => { + this._client.error( + `Sending document notification ${this._type.method} failed`, + error + ); + }); + this._syncedDocuments.set(uri, textDocument); + } + }); + } + notificationSent(textDocument, type, params) { + super.notificationSent(textDocument, type, params); + this._syncedDocuments.set(textDocument.uri.toString(), textDocument); + } + }; + let DidCloseTextDocumentFeature = class extends DocumentNotifications { + constructor(client, _syncedDocuments) { + super( + client, + vscode_1.workspace.onDidCloseTextDocument, + vscode_languageserver_protocol_1.DidCloseTextDocumentNotification + .type, + client.clientOptions.middleware.didClose, + (textDocument) => + client.code2ProtocolConverter.asCloseTextDocumentParams( + textDocument + ), + DocumentNotifications.textDocumentFilter + ); + this._syncedDocuments = _syncedDocuments; + } + get registrationType() { + return vscode_languageserver_protocol_1.DidCloseTextDocumentNotification + .type; + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'synchronization' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; + if ( + documentSelector && + textDocumentSyncOptions && + textDocumentSyncOptions.openClose + ) { + this.register({ + id: UUID.generateUuid(), + registerOptions: { documentSelector }, + }); + } + } + notificationSent(textDocument, type, params) { + super.notificationSent(textDocument, type, params); + this._syncedDocuments.delete(textDocument.uri.toString()); + } + unregister(id) { + let selector = this._selectors.get(id); + super.unregister(id); + let selectors = this._selectors.values(); + this._syncedDocuments.forEach((textDocument) => { + if ( + vscode_1.languages.match(selector, textDocument) && + !this._selectorFilter(selectors, textDocument) + ) { + let middleware = this._client.clientOptions.middleware; + let didClose = (textDocument2) => { + return this._client.sendNotification( + this._type, + this._createParams(textDocument2) + ); + }; + this._syncedDocuments.delete(textDocument.uri.toString()); + (middleware.didClose + ? middleware.didClose(textDocument, didClose) + : didClose(textDocument) + ).catch((error) => { + this._client.error( + `Sending document notification ${this._type.method} failed`, + error + ); + }); + } + }); + } + }; + let DidChangeTextDocumentFeature = class { + constructor(_client) { + this._client = _client; + this._changeData = new Map(); + this._forcingDelivery = false; + this._onNotificationSent = new vscode_1.EventEmitter(); + } + get registrationType() { + return vscode_languageserver_protocol_1 + .DidChangeTextDocumentNotification.type; + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'synchronization' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; + if ( + documentSelector && + textDocumentSyncOptions && + textDocumentSyncOptions.change !== void 0 && + textDocumentSyncOptions.change !== + vscode_languageserver_protocol_1.TextDocumentSyncKind.None + ) { + this.register({ + id: UUID.generateUuid(), + registerOptions: Object.assign( + {}, + { documentSelector }, + { syncKind: textDocumentSyncOptions.change } + ), + }); + } + } + register(data) { + if (!data.registerOptions.documentSelector) { + return; + } + if (!this._listener) { + this._listener = vscode_1.workspace.onDidChangeTextDocument( + this.callback, + this + ); + } + this._changeData.set(data.id, { + documentSelector: data.registerOptions.documentSelector, + syncKind: data.registerOptions.syncKind, + }); + } + async callback(event) { + if (event.contentChanges.length === 0) { + return; + } + const promises = []; + for (const changeData of this._changeData.values()) { + if ( + vscode_1.languages.match( + changeData.documentSelector, + event.document + ) + ) { + const middleware = this._client.clientOptions.middleware; + if ( + changeData.syncKind === + vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental + ) { + const didChange = async (event2) => { + const params = this._client.code2ProtocolConverter.asChangeTextDocumentParams( + event2 + ); + await this._client.sendNotification( + vscode_languageserver_protocol_1 + .DidChangeTextDocumentNotification.type, + params + ); + this.notificationSent( + event2, + vscode_languageserver_protocol_1 + .DidChangeTextDocumentNotification.type, + params + ); + }; + promises.push( + middleware.didChange + ? middleware.didChange(event, (event2) => didChange(event2)) + : didChange(event) + ); + } else if ( + changeData.syncKind === + vscode_languageserver_protocol_1.TextDocumentSyncKind.Full + ) { + const didChange = async (event2) => { + const doSend = async (event3) => { + const params = this._client.code2ProtocolConverter.asChangeTextDocumentParams( + event3.document + ); + await this._client.sendNotification( + vscode_languageserver_protocol_1 + .DidChangeTextDocumentNotification.type, + params + ); + this.notificationSent( + event3, + vscode_languageserver_protocol_1 + .DidChangeTextDocumentNotification.type, + params + ); + }; + if (this._changeDelayer) { + if ( + this._changeDelayer.uri !== event2.document.uri.toString() + ) { + this.forceDelivery(); + this._changeDelayer.uri = event2.document.uri.toString(); + } + return this._changeDelayer.delayer.trigger(() => + doSend(event2) + ); + } else { + this._changeDelayer = { + uri: event2.document.uri.toString(), + delayer: new async_1.Delayer(200), + }; + return this._changeDelayer.delayer.trigger( + () => doSend(event2), + -1 + ); + } + }; + promises.push( + middleware.didChange + ? middleware.didChange(event, (event2) => didChange(event2)) + : didChange(event) + ); + } + } + } + return Promise.all(promises).then(void 0, (error) => { + this._client.error( + `Sending document notification ${vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type.method} failed`, + error + ); + throw error; + }); + } + get onNotificationSent() { + return this._onNotificationSent.event; + } + notificationSent(changeEvent, type, params) { + this._onNotificationSent.fire({ original: changeEvent, type, params }); + } + unregister(id) { + this._changeData.delete(id); + if (this._changeData.size === 0 && this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + dispose() { + this._changeDelayer = void 0; + this._forcingDelivery = false; + this._changeData.clear(); + if (this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + forceDelivery() { + if (this._forcingDelivery || !this._changeDelayer) { + return; + } + try { + this._forcingDelivery = true; + this._changeDelayer.delayer.forceDelivery(); + } finally { + this._forcingDelivery = false; + } + } + getProvider(document2) { + for (const changeData of this._changeData.values()) { + if ( + vscode_1.languages.match(changeData.documentSelector, document2) + ) { + return { + send: (event) => { + return this.callback(event); + }, + }; + } + } + return void 0; + } + }; + let WillSaveFeature = class extends DocumentNotifications { + constructor(client) { + super( + client, + vscode_1.workspace.onWillSaveTextDocument, + vscode_languageserver_protocol_1.WillSaveTextDocumentNotification + .type, + client.clientOptions.middleware.willSave, + (willSaveEvent) => + client.code2ProtocolConverter.asWillSaveTextDocumentParams( + willSaveEvent + ), + (selectors, willSaveEvent) => + DocumentNotifications.textDocumentFilter( + selectors, + willSaveEvent.document + ) + ); + } + get registrationType() { + return vscode_languageserver_protocol_1.WillSaveTextDocumentNotification + .type; + } + fillClientCapabilities(capabilities) { + let value = ensure( + ensure(capabilities, 'textDocument'), + 'synchronization' + ); + value.willSave = true; + } + initialize(capabilities, documentSelector) { + let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; + if ( + documentSelector && + textDocumentSyncOptions && + textDocumentSyncOptions.willSave + ) { + this.register({ + id: UUID.generateUuid(), + registerOptions: { documentSelector }, + }); + } + } + }; + let WillSaveWaitUntilFeature = class { + constructor(_client) { + this._client = _client; + this._selectors = new Map(); + } + get registrationType() { + return vscode_languageserver_protocol_1 + .WillSaveTextDocumentWaitUntilRequest.type; + } + fillClientCapabilities(capabilities) { + let value = ensure( + ensure(capabilities, 'textDocument'), + 'synchronization' + ); + value.willSaveWaitUntil = true; + } + initialize(capabilities, documentSelector) { + let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; + if ( + documentSelector && + textDocumentSyncOptions && + textDocumentSyncOptions.willSaveWaitUntil + ) { + this.register({ + id: UUID.generateUuid(), + registerOptions: { documentSelector }, + }); + } + } + register(data) { + if (!data.registerOptions.documentSelector) { + return; + } + if (!this._listener) { + this._listener = vscode_1.workspace.onWillSaveTextDocument( + this.callback, + this + ); + } + this._selectors.set(data.id, data.registerOptions.documentSelector); + } + callback(event) { + if ( + DocumentNotifications.textDocumentFilter( + this._selectors.values(), + event.document + ) + ) { + let middleware = this._client.clientOptions.middleware; + let willSaveWaitUntil = (event2) => { + return this._client + .sendRequest( + vscode_languageserver_protocol_1 + .WillSaveTextDocumentWaitUntilRequest.type, + this._client.code2ProtocolConverter.asWillSaveTextDocumentParams( + event2 + ) + ) + .then((edits) => { + let vEdits = this._client.protocol2CodeConverter.asTextEdits( + edits + ); + return vEdits === void 0 ? [] : vEdits; + }); + }; + event.waitUntil( + middleware.willSaveWaitUntil + ? middleware.willSaveWaitUntil(event, willSaveWaitUntil) + : willSaveWaitUntil(event) + ); + } + } + unregister(id) { + this._selectors.delete(id); + if (this._selectors.size === 0 && this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + dispose() { + this._selectors.clear(); + if (this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + }; + let DidSaveTextDocumentFeature = class extends DocumentNotifications { + constructor(client) { + super( + client, + vscode_1.workspace.onDidSaveTextDocument, + vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, + client.clientOptions.middleware.didSave, + (textDocument) => + client.code2ProtocolConverter.asSaveTextDocumentParams( + textDocument, + this._includeText + ), + DocumentNotifications.textDocumentFilter + ); + this._includeText = false; + } + get registrationType() { + return vscode_languageserver_protocol_1.DidSaveTextDocumentNotification + .type; + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'synchronization' + ).didSave = true; + } + initialize(capabilities, documentSelector) { + const textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; + if ( + documentSelector && + textDocumentSyncOptions && + textDocumentSyncOptions.save + ) { + const saveOptions = + typeof textDocumentSyncOptions.save === 'boolean' + ? { includeText: false } + : { includeText: !!textDocumentSyncOptions.save.includeText }; + this.register({ + id: UUID.generateUuid(), + registerOptions: Object.assign( + {}, + { documentSelector }, + saveOptions + ), + }); + } + } + register(data) { + this._includeText = !!data.registerOptions.includeText; + super.register(data); + } + }; + let FileSystemWatcherFeature = class { + constructor(_client, _notifyFileEvent) { + this._client = _client; + this._notifyFileEvent = _notifyFileEvent; + this._watchers = new Map(); + } + get registrationType() { + return vscode_languageserver_protocol_1 + .DidChangeWatchedFilesNotification.type; + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'workspace'), + 'didChangeWatchedFiles' + ).dynamicRegistration = true; + } + initialize(_capabilities, _documentSelector) {} + register(data) { + if (!Array.isArray(data.registerOptions.watchers)) { + return; + } + let disposables = []; + for (let watcher of data.registerOptions.watchers) { + if (!Is2.string(watcher.globPattern)) { + continue; + } + let watchCreate = true, + watchChange = true, + watchDelete = true; + if (watcher.kind !== void 0 && watcher.kind !== null) { + watchCreate = + (watcher.kind & + vscode_languageserver_protocol_1.WatchKind.Create) !== + 0; + watchChange = + (watcher.kind & + vscode_languageserver_protocol_1.WatchKind.Change) !== + 0; + watchDelete = + (watcher.kind & + vscode_languageserver_protocol_1.WatchKind.Delete) !== + 0; + } + let fileSystemWatcher = vscode_1.workspace.createFileSystemWatcher( + watcher.globPattern, + !watchCreate, + !watchChange, + !watchDelete + ); + this.hookListeners( + fileSystemWatcher, + watchCreate, + watchChange, + watchDelete + ); + disposables.push(fileSystemWatcher); + } + this._watchers.set(data.id, disposables); + } + registerRaw(id, fileSystemWatchers) { + let disposables = []; + for (let fileSystemWatcher of fileSystemWatchers) { + this.hookListeners(fileSystemWatcher, true, true, true, disposables); + } + this._watchers.set(id, disposables); + } + hookListeners( + fileSystemWatcher, + watchCreate, + watchChange, + watchDelete, + listeners + ) { + if (watchCreate) { + fileSystemWatcher.onDidCreate( + (resource) => + this._notifyFileEvent({ + uri: this._client.code2ProtocolConverter.asUri(resource), + type: vscode_languageserver_protocol_1.FileChangeType.Created, + }), + null, + listeners + ); + } + if (watchChange) { + fileSystemWatcher.onDidChange( + (resource) => + this._notifyFileEvent({ + uri: this._client.code2ProtocolConverter.asUri(resource), + type: vscode_languageserver_protocol_1.FileChangeType.Changed, + }), + null, + listeners + ); + } + if (watchDelete) { + fileSystemWatcher.onDidDelete( + (resource) => + this._notifyFileEvent({ + uri: this._client.code2ProtocolConverter.asUri(resource), + type: vscode_languageserver_protocol_1.FileChangeType.Deleted, + }), + null, + listeners + ); + } + } + unregister(id) { + let disposables = this._watchers.get(id); + if (disposables) { + for (let disposable of disposables) { + disposable.dispose(); + } + } + } + dispose() { + this._watchers.forEach((disposables) => { + for (let disposable of disposables) { + disposable.dispose(); + } + }); + this._watchers.clear(); + } + }; + let TextDocumentFeature = class { + constructor(_client, _registrationType) { + this._client = _client; + this._registrationType = _registrationType; + this._registrations = new Map(); + } + get registrationType() { + return this._registrationType; + } + register(data) { + if (!data.registerOptions.documentSelector) { + return; + } + let registration = this.registerLanguageProvider( + data.registerOptions, + data.id + ); + this._registrations.set(data.id, { + disposable: registration[0], + data, + provider: registration[1], + }); + } + unregister(id) { + let registration = this._registrations.get(id); + if (registration !== void 0) { + registration.disposable.dispose(); + } + } + dispose() { + this._registrations.forEach((value) => { + value.disposable.dispose(); + }); + this._registrations.clear(); + } + getRegistration(documentSelector, capability) { + if (!capability) { + return [void 0, void 0]; + } else if ( + vscode_languageserver_protocol_1.TextDocumentRegistrationOptions.is( + capability + ) + ) { + const id = vscode_languageserver_protocol_1.StaticRegistrationOptions.hasId( + capability + ) + ? capability.id + : UUID.generateUuid(); + const selector = capability.documentSelector || documentSelector; + if (selector) { + return [ + id, + Object.assign({}, capability, { documentSelector: selector }), + ]; + } + } else if ( + (Is2.boolean(capability) && capability === true) || + vscode_languageserver_protocol_1.WorkDoneProgressOptions.is( + capability + ) + ) { + if (!documentSelector) { + return [void 0, void 0]; + } + let options = + Is2.boolean(capability) && capability === true + ? { documentSelector } + : Object.assign({}, capability, { documentSelector }); + return [UUID.generateUuid(), options]; + } + return [void 0, void 0]; + } + getRegistrationOptions(documentSelector, capability) { + if (!documentSelector || !capability) { + return void 0; + } + return Is2.boolean(capability) && capability === true + ? { documentSelector } + : Object.assign({}, capability, { documentSelector }); + } + getProvider(textDocument) { + for (const registration of this._registrations.values()) { + let selector = registration.data.registerOptions.documentSelector; + if ( + selector !== null && + vscode_1.languages.match(selector, textDocument) + ) { + return registration.provider; + } + } + return void 0; + } + getAllProviders() { + const result = []; + for (const item of this._registrations.values()) { + result.push(item.provider); + } + return result; + } + }; + exports.TextDocumentFeature = TextDocumentFeature; + let WorkspaceFeature = class { + constructor(_client, _registrationType) { + this._client = _client; + this._registrationType = _registrationType; + this._registrations = new Map(); + } + get registrationType() { + return this._registrationType; + } + register(data) { + const registration = this.registerLanguageProvider( + data.registerOptions + ); + this._registrations.set(data.id, { + disposable: registration[0], + provider: registration[1], + }); + } + unregister(id) { + let registration = this._registrations.get(id); + if (registration !== void 0) { + registration.disposable.dispose(); + } + } + dispose() { + this._registrations.forEach((registration) => { + registration.disposable.dispose(); + }); + this._registrations.clear(); + } + getProviders() { + const result = []; + for (const registration of this._registrations.values()) { + result.push(registration.provider); + } + return result; + } + }; + let CompletionItemFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.CompletionRequest.type); + this.labelDetailsSupport = new Map(); + } + fillClientCapabilities(capabilities) { + let completion = ensure( + ensure(capabilities, 'textDocument'), + 'completion' + ); + completion.dynamicRegistration = true; + completion.contextSupport = true; + completion.completionItem = { + snippetSupport: true, + commitCharactersSupport: true, + documentationFormat: [ + vscode_languageserver_protocol_1.MarkupKind.Markdown, + vscode_languageserver_protocol_1.MarkupKind.PlainText, + ], + deprecatedSupport: true, + preselectSupport: true, + tagSupport: { + valueSet: [ + vscode_languageserver_protocol_1.CompletionItemTag.Deprecated, + ], + }, + insertReplaceSupport: true, + resolveSupport: { + properties: ['documentation', 'detail', 'additionalTextEdits'], + }, + insertTextModeSupport: { + valueSet: [ + vscode_languageserver_protocol_1.InsertTextMode.asIs, + vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation, + ], + }, + labelDetailsSupport: true, + }; + completion.insertTextMode = + vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation; + completion.completionItemKind = { + valueSet: SupportedCompletionItemKinds, + }; + completion.completionList = { + itemDefaults: [ + 'commitCharacters', + 'editRange', + 'insertTextFormat', + 'insertTextMode', + ], + }; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.completionProvider + ); + if (!options) { + return; + } + this.register({ + id: UUID.generateUuid(), + registerOptions: options, + }); + } + registerLanguageProvider(options, id) { + this.labelDetailsSupport.set( + id, + !!options.completionItem?.labelDetailsSupport + ); + const triggerCharacters = options.triggerCharacters ?? []; + const defaultCommitCharacters = options.allCommitCharacters; + const provider = { + provideCompletionItems: (document2, position, token, context) => { + const client = this._client; + const middleware = this._client.clientOptions.middleware; + const provideCompletionItems = ( + document3, + position2, + context2, + token2 + ) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.CompletionRequest.type, + client.code2ProtocolConverter.asCompletionParams( + document3, + position2, + context2 + ), + token2 + ) + .then( + (result) => + client.protocol2CodeConverter.asCompletionResult( + result, + defaultCommitCharacters + ), + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.CompletionRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideCompletionItem + ? middleware.provideCompletionItem( + document2, + position, + context, + token, + provideCompletionItems + ) + : provideCompletionItems(document2, position, context, token); + }, + resolveCompletionItem: options.resolveProvider + ? (item, token) => { + const client = this._client; + const middleware = this._client.clientOptions.middleware; + const resolveCompletionItem = (item2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.CompletionResolveRequest + .type, + client.code2ProtocolConverter.asCompletionItem( + item2, + !!this.labelDetailsSupport.get(id) + ), + token2 + ) + .then( + client.protocol2CodeConverter.asCompletionItem, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .CompletionResolveRequest.type, + token2, + error, + item2 + ); + } + ); + }; + return middleware.resolveCompletionItem + ? middleware.resolveCompletionItem( + item, + token, + resolveCompletionItem + ) + : resolveCompletionItem(item, token); + } + : void 0, + }; + return [ + vscode_1.languages.registerCompletionItemProvider( + options.documentSelector, + provider, + ...triggerCharacters + ), + provider, + ]; + } + }; + let HoverFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.HoverRequest.type); + } + fillClientCapabilities(capabilities) { + const hoverCapability = ensure( + ensure(capabilities, 'textDocument'), + 'hover' + ); + hoverCapability.dynamicRegistration = true; + hoverCapability.contentFormat = [ + vscode_languageserver_protocol_1.MarkupKind.Markdown, + vscode_languageserver_protocol_1.MarkupKind.PlainText, + ]; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.hoverProvider + ); + if (!options) { + return; + } + this.register({ + id: UUID.generateUuid(), + registerOptions: options, + }); + } + registerLanguageProvider(options) { + const provider = { + provideHover: (document2, position, token) => { + const client = this._client; + const provideHover = (document3, position2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.HoverRequest.type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then(client.protocol2CodeConverter.asHover, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.HoverRequest.type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideHover + ? middleware.provideHover( + document2, + position, + token, + provideHover + ) + : provideHover(document2, position, token); + }, + }; + return [ + vscode_1.languages.registerHoverProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let SignatureHelpFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.SignatureHelpRequest.type + ); + } + fillClientCapabilities(capabilities) { + let config = ensure( + ensure(capabilities, 'textDocument'), + 'signatureHelp' + ); + config.dynamicRegistration = true; + config.signatureInformation = { + documentationFormat: [ + vscode_languageserver_protocol_1.MarkupKind.Markdown, + vscode_languageserver_protocol_1.MarkupKind.PlainText, + ], + }; + config.signatureInformation.parameterInformation = { + labelOffsetSupport: true, + }; + config.signatureInformation.activeParameterSupport = true; + config.contextSupport = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.signatureHelpProvider + ); + if (!options) { + return; + } + this.register({ + id: UUID.generateUuid(), + registerOptions: options, + }); + } + registerLanguageProvider(options) { + const provider = { + provideSignatureHelp: (document2, position, token, context) => { + const client = this._client; + const providerSignatureHelp = ( + document3, + position2, + context2, + token2 + ) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.SignatureHelpRequest.type, + client.code2ProtocolConverter.asSignatureHelpParams( + document3, + position2, + context2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asSignatureHelp, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.SignatureHelpRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideSignatureHelp + ? middleware.provideSignatureHelp( + document2, + position, + context, + token, + providerSignatureHelp + ) + : providerSignatureHelp(document2, position, context, token); + }, + }; + let disposable; + if (options.retriggerCharacters === void 0) { + const triggerCharacters = options.triggerCharacters || []; + disposable = vscode_1.languages.registerSignatureHelpProvider( + options.documentSelector, + provider, + ...triggerCharacters + ); + } else { + const metaData = { + triggerCharacters: options.triggerCharacters || [], + retriggerCharacters: options.retriggerCharacters || [], + }; + disposable = vscode_1.languages.registerSignatureHelpProvider( + options.documentSelector, + provider, + metaData + ); + } + return [disposable, provider]; + } + }; + let DefinitionFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.DefinitionRequest.type); + } + fillClientCapabilities(capabilities) { + let definitionSupport = ensure( + ensure(capabilities, 'textDocument'), + 'definition' + ); + definitionSupport.dynamicRegistration = true; + definitionSupport.linkSupport = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.definitionProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDefinition: (document2, position, token) => { + const client = this._client; + const provideDefinition = (document3, position2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.DefinitionRequest.type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asDefinitionResult, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.DefinitionRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDefinition + ? middleware.provideDefinition( + document2, + position, + token, + provideDefinition + ) + : provideDefinition(document2, position, token); + }, + }; + return [ + vscode_1.languages.registerDefinitionProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let ReferencesFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.ReferencesRequest.type); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'references' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.referencesProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideReferences: (document2, position, options2, token) => { + const client = this._client; + const _providerReferences = ( + document3, + position2, + options3, + token2 + ) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.ReferencesRequest.type, + client.code2ProtocolConverter.asReferenceParams( + document3, + position2, + options3 + ), + token2 + ) + .then(client.protocol2CodeConverter.asReferences, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.ReferencesRequest.type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideReferences + ? middleware.provideReferences( + document2, + position, + options2, + token, + _providerReferences + ) + : _providerReferences(document2, position, options2, token); + }, + }; + return [ + vscode_1.languages.registerReferenceProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let DocumentHighlightFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentHighlightRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'documentHighlight' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.documentHighlightProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDocumentHighlights: (document2, position, token) => { + const client = this._client; + const _provideDocumentHighlights = ( + document3, + position2, + token2 + ) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.DocumentHighlightRequest + .type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asDocumentHighlights, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.DocumentHighlightRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDocumentHighlights + ? middleware.provideDocumentHighlights( + document2, + position, + token, + _provideDocumentHighlights + ) + : _provideDocumentHighlights(document2, position, token); + }, + }; + return [ + vscode_1.languages.registerDocumentHighlightProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let DocumentSymbolFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentSymbolRequest.type + ); + } + fillClientCapabilities(capabilities) { + let symbolCapabilities = ensure( + ensure(capabilities, 'textDocument'), + 'documentSymbol' + ); + symbolCapabilities.dynamicRegistration = true; + symbolCapabilities.symbolKind = { + valueSet: SupportedSymbolKinds, + }; + symbolCapabilities.hierarchicalDocumentSymbolSupport = true; + symbolCapabilities.tagSupport = { + valueSet: SupportedSymbolTags, + }; + symbolCapabilities.labelSupport = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.documentSymbolProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDocumentSymbols: (document2, token) => { + const client = this._client; + const _provideDocumentSymbols = (document3, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.DocumentSymbolRequest.type, + client.code2ProtocolConverter.asDocumentSymbolParams( + document3 + ), + token2 + ) + .then( + (data) => { + if (data === null) { + return void 0; + } + if (data.length === 0) { + return []; + } else { + let element = data[0]; + if ( + vscode_languageserver_protocol_1.DocumentSymbol.is( + element + ) + ) { + return client.protocol2CodeConverter.asDocumentSymbols( + data + ); + } else { + return client.protocol2CodeConverter.asSymbolInformations( + data + ); + } + } + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.DocumentSymbolRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDocumentSymbols + ? middleware.provideDocumentSymbols( + document2, + token, + _provideDocumentSymbols + ) + : _provideDocumentSymbols(document2, token); + }, + }; + const metaData = + options.label !== void 0 ? { label: options.label } : void 0; + return [ + vscode_1.languages.registerDocumentSymbolProvider( + options.documentSelector, + provider, + metaData + ), + provider, + ]; + } + }; + let WorkspaceSymbolFeature = class extends WorkspaceFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type + ); + } + fillClientCapabilities(capabilities) { + let symbolCapabilities = ensure( + ensure(capabilities, 'workspace'), + 'symbol' + ); + symbolCapabilities.dynamicRegistration = true; + symbolCapabilities.symbolKind = { + valueSet: SupportedSymbolKinds, + }; + symbolCapabilities.tagSupport = { + valueSet: SupportedSymbolTags, + }; + symbolCapabilities.resolveSupport = { properties: ['location.range'] }; + } + initialize(capabilities) { + if (!capabilities.workspaceSymbolProvider) { + return; + } + this.register({ + id: UUID.generateUuid(), + registerOptions: + capabilities.workspaceSymbolProvider === true + ? { workDoneProgress: false } + : capabilities.workspaceSymbolProvider, + }); + } + registerLanguageProvider(options) { + const provider = { + provideWorkspaceSymbols: (query, token) => { + const client = this._client; + const provideWorkspaceSymbols = (query2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, + { query: query2 }, + token2 + ) + .then( + client.protocol2CodeConverter.asSymbolInformations, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.WorkspaceSymbolRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideWorkspaceSymbols + ? middleware.provideWorkspaceSymbols( + query, + token, + provideWorkspaceSymbols + ) + : provideWorkspaceSymbols(query, token); + }, + resolveWorkspaceSymbol: + options.resolveProvider === true + ? (item, token) => { + const client = this._client; + const resolveWorkspaceSymbol = (item2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1 + .WorkspaceSymbolResolveRequest.type, + client.code2ProtocolConverter.asWorkspaceSymbol(item2), + token2 + ) + .then( + client.protocol2CodeConverter.asSymbolInformation, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .WorkspaceSymbolResolveRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.resolveWorkspaceSymbol + ? middleware.resolveWorkspaceSymbol( + item, + token, + resolveWorkspaceSymbol + ) + : resolveWorkspaceSymbol(item, token); + } + : void 0, + }; + return [ + vscode_1.languages.registerWorkspaceSymbolProvider(provider), + provider, + ]; + } + }; + let CodeActionFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.CodeActionRequest.type); + } + fillClientCapabilities(capabilities) { + const cap = ensure(ensure(capabilities, 'textDocument'), 'codeAction'); + cap.dynamicRegistration = true; + cap.isPreferredSupport = true; + cap.disabledSupport = true; + cap.dataSupport = true; + cap.resolveSupport = { + properties: ['edit'], + }; + cap.codeActionLiteralSupport = { + codeActionKind: { + valueSet: [ + vscode_languageserver_protocol_1.CodeActionKind.Empty, + vscode_languageserver_protocol_1.CodeActionKind.QuickFix, + vscode_languageserver_protocol_1.CodeActionKind.Refactor, + vscode_languageserver_protocol_1.CodeActionKind.RefactorExtract, + vscode_languageserver_protocol_1.CodeActionKind.RefactorInline, + vscode_languageserver_protocol_1.CodeActionKind.RefactorRewrite, + vscode_languageserver_protocol_1.CodeActionKind.Source, + vscode_languageserver_protocol_1.CodeActionKind + .SourceOrganizeImports, + ], + }, + }; + cap.honorsChangeAnnotations = false; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.codeActionProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideCodeActions: (document2, range, context, token) => { + const client = this._client; + const _provideCodeActions = ( + document3, + range2, + context2, + token2 + ) => { + const params = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + range: client.code2ProtocolConverter.asRange(range2), + context: client.code2ProtocolConverter.asCodeActionContext( + context2 + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.CodeActionRequest.type, + params, + token2 + ) + .then( + (values) => { + if (values === null) { + return void 0; + } + const result = []; + for (let item of values) { + if (vscode_languageserver_protocol_1.Command.is(item)) { + result.push( + client.protocol2CodeConverter.asCommand(item) + ); + } else { + result.push( + client.protocol2CodeConverter.asCodeAction(item) + ); + } + } + return result; + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.CodeActionRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideCodeActions + ? middleware.provideCodeActions( + document2, + range, + context, + token, + _provideCodeActions + ) + : _provideCodeActions(document2, range, context, token); + }, + resolveCodeAction: options.resolveProvider + ? (item, token) => { + const client = this._client; + const middleware = this._client.clientOptions.middleware; + const resolveCodeAction = (item2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.CodeActionResolveRequest + .type, + client.code2ProtocolConverter.asCodeAction(item2), + token2 + ) + .then( + client.protocol2CodeConverter.asCodeAction, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .CodeActionResolveRequest.type, + token2, + error, + item2 + ); + } + ); + }; + return middleware.resolveCodeAction + ? middleware.resolveCodeAction(item, token, resolveCodeAction) + : resolveCodeAction(item, token); + } + : void 0, + }; + return [ + vscode_1.languages.registerCodeActionsProvider( + options.documentSelector, + provider, + options.codeActionKinds + ? { + providedCodeActionKinds: this._client.protocol2CodeConverter.asCodeActionKinds( + options.codeActionKinds + ), + } + : void 0 + ), + provider, + ]; + } + }; + let CodeLensFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.CodeLensRequest.type); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'codeLens' + ).dynamicRegistration = true; + ensure( + ensure(capabilities, 'workspace'), + 'codeLens' + ).refreshSupport = true; + } + initialize(capabilities, documentSelector) { + const client = this._client; + client.onRequest( + vscode_languageserver_protocol_1.CodeLensRefreshRequest.type, + async () => { + for (const provider of this.getAllProviders()) { + provider.onDidChangeCodeLensEmitter.fire(); + } + } + ); + const options = this.getRegistrationOptions( + documentSelector, + capabilities.codeLensProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const eventEmitter = new vscode_1.EventEmitter(); + const provider = { + onDidChangeCodeLenses: eventEmitter.event, + provideCodeLenses: (document2, token) => { + const client = this._client; + const provideCodeLenses = (document3, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.CodeLensRequest.type, + client.code2ProtocolConverter.asCodeLensParams(document3), + token2 + ) + .then(client.protocol2CodeConverter.asCodeLenses, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.CodeLensRequest.type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideCodeLenses + ? middleware.provideCodeLenses( + document2, + token, + provideCodeLenses + ) + : provideCodeLenses(document2, token); + }, + resolveCodeLens: options.resolveProvider + ? (codeLens, token) => { + const client = this._client; + const resolveCodeLens = (codeLens2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.CodeLensResolveRequest + .type, + client.code2ProtocolConverter.asCodeLens(codeLens2), + token2 + ) + .then(client.protocol2CodeConverter.asCodeLens, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.CodeLensResolveRequest + .type, + token2, + error, + codeLens2 + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.resolveCodeLens + ? middleware.resolveCodeLens(codeLens, token, resolveCodeLens) + : resolveCodeLens(codeLens, token); + } + : void 0, + }; + return [ + vscode_1.languages.registerCodeLensProvider( + options.documentSelector, + provider + ), + { provider, onDidChangeCodeLensEmitter: eventEmitter }, + ]; + } + }; + let DocumentFormattingFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentFormattingRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'formatting' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.documentFormattingProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDocumentFormattingEdits: (document2, options2, token) => { + const client = this._client; + const provideDocumentFormattingEdits = ( + document3, + options3, + token2 + ) => { + const params = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + options: client.code2ProtocolConverter.asFormattingOptions( + options3, + FileFormattingOptions.fromConfiguration(document3) + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.DocumentFormattingRequest + .type, + params, + token2 + ) + .then(client.protocol2CodeConverter.asTextEdits, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.DocumentFormattingRequest + .type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDocumentFormattingEdits + ? middleware.provideDocumentFormattingEdits( + document2, + options2, + token, + provideDocumentFormattingEdits + ) + : provideDocumentFormattingEdits(document2, options2, token); + }, + }; + return [ + vscode_1.languages.registerDocumentFormattingEditProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let DocumentRangeFormattingFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'rangeFormatting' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.documentRangeFormattingProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDocumentRangeFormattingEdits: ( + document2, + range, + options2, + token + ) => { + const client = this._client; + const provideDocumentRangeFormattingEdits = ( + document3, + range2, + options3, + token2 + ) => { + const params = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + range: client.code2ProtocolConverter.asRange(range2), + options: client.code2ProtocolConverter.asFormattingOptions( + options3, + FileFormattingOptions.fromConfiguration(document3) + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1 + .DocumentRangeFormattingRequest.type, + params, + token2 + ) + .then(client.protocol2CodeConverter.asTextEdits, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .DocumentRangeFormattingRequest.type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDocumentRangeFormattingEdits + ? middleware.provideDocumentRangeFormattingEdits( + document2, + range, + options2, + token, + provideDocumentRangeFormattingEdits + ) + : provideDocumentRangeFormattingEdits( + document2, + range, + options2, + token + ); + }, + }; + return [ + vscode_1.languages.registerDocumentRangeFormattingEditProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let DocumentOnTypeFormattingFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'onTypeFormatting' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.documentOnTypeFormattingProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideOnTypeFormattingEdits: ( + document2, + position, + ch, + options2, + token + ) => { + const client = this._client; + const provideOnTypeFormattingEdits = ( + document3, + position2, + ch2, + options3, + token2 + ) => { + let params = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + position: client.code2ProtocolConverter.asPosition(position2), + ch: ch2, + options: client.code2ProtocolConverter.asFormattingOptions( + options3, + FileFormattingOptions.fromConfiguration(document3) + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1 + .DocumentOnTypeFormattingRequest.type, + params, + token2 + ) + .then(client.protocol2CodeConverter.asTextEdits, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .DocumentOnTypeFormattingRequest.type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideOnTypeFormattingEdits + ? middleware.provideOnTypeFormattingEdits( + document2, + position, + ch, + options2, + token, + provideOnTypeFormattingEdits + ) + : provideOnTypeFormattingEdits( + document2, + position, + ch, + options2, + token + ); + }, + }; + const moreTriggerCharacter = options.moreTriggerCharacter || []; + return [ + vscode_1.languages.registerOnTypeFormattingEditProvider( + options.documentSelector, + provider, + options.firstTriggerCharacter, + ...moreTriggerCharacter + ), + provider, + ]; + } + }; + let RenameFeature = class extends TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.RenameRequest.type); + } + fillClientCapabilities(capabilities) { + let rename = ensure(ensure(capabilities, 'textDocument'), 'rename'); + rename.dynamicRegistration = true; + rename.prepareSupport = true; + rename.prepareSupportDefaultBehavior = + vscode_languageserver_protocol_1.PrepareSupportDefaultBehavior.Identifier; + rename.honorsChangeAnnotations = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.renameProvider + ); + if (!options) { + return; + } + if (Is2.boolean(capabilities.renameProvider)) { + options.prepareProvider = false; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideRenameEdits: (document2, position, newName, token) => { + const client = this._client; + const provideRenameEdits = ( + document3, + position2, + newName2, + token2 + ) => { + let params = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + position: client.code2ProtocolConverter.asPosition(position2), + newName: newName2, + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.RenameRequest.type, + params, + token2 + ) + .then( + client.protocol2CodeConverter.asWorkspaceEdit, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.RenameRequest.type, + token2, + error, + null, + false + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideRenameEdits + ? middleware.provideRenameEdits( + document2, + position, + newName, + token, + provideRenameEdits + ) + : provideRenameEdits(document2, position, newName, token); + }, + prepareRename: options.prepareProvider + ? (document2, position, token) => { + const client = this._client; + const prepareRename = (document3, position2, token2) => { + let params = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + position: client.code2ProtocolConverter.asPosition( + position2 + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.PrepareRenameRequest + .type, + params, + token2 + ) + .then( + (result) => { + if (vscode_languageserver_protocol_1.Range.is(result)) { + return client.protocol2CodeConverter.asRange(result); + } else if (this.isDefaultBehavior(result)) { + return result.defaultBehavior === true + ? null + : Promise.reject( + new Error(`The element can't be renamed.`) + ); + } else if ( + result && + vscode_languageserver_protocol_1.Range.is( + result.range + ) + ) { + return { + range: client.protocol2CodeConverter.asRange( + result.range + ), + placeholder: result.placeholder, + }; + } + return Promise.reject( + new Error(`The element can't be renamed.`) + ); + }, + (error) => { + if (typeof error.message === 'string') { + throw new Error(error.message); + } else { + throw new Error(`The element can't be renamed.`); + } + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.prepareRename + ? middleware.prepareRename( + document2, + position, + token, + prepareRename + ) + : prepareRename(document2, position, token); + } + : void 0, + }; + return [ + vscode_1.languages.registerRenameProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + isDefaultBehavior(value) { + const candidate = value; + return candidate && Is2.boolean(candidate.defaultBehavior); + } + }; + let DocumentLinkFeature = class extends TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentLinkRequest.type + ); + } + fillClientCapabilities(capabilities) { + const documentLinkCapabilities = ensure( + ensure(capabilities, 'textDocument'), + 'documentLink' + ); + documentLinkCapabilities.dynamicRegistration = true; + documentLinkCapabilities.tooltipSupport = true; + } + initialize(capabilities, documentSelector) { + const options = this.getRegistrationOptions( + documentSelector, + capabilities.documentLinkProvider + ); + if (!options) { + return; + } + this.register({ id: UUID.generateUuid(), registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDocumentLinks: (document2, token) => { + const client = this._client; + const provideDocumentLinks = (document3, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.DocumentLinkRequest.type, + client.code2ProtocolConverter.asDocumentLinkParams(document3), + token2 + ) + .then( + client.protocol2CodeConverter.asDocumentLinks, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.DocumentLinkRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDocumentLinks + ? middleware.provideDocumentLinks( + document2, + token, + provideDocumentLinks + ) + : provideDocumentLinks(document2, token); + }, + resolveDocumentLink: options.resolveProvider + ? (link, token) => { + const client = this._client; + let resolveDocumentLink = (link2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1 + .DocumentLinkResolveRequest.type, + client.code2ProtocolConverter.asDocumentLink(link2), + token2 + ) + .then( + client.protocol2CodeConverter.asDocumentLink, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .DocumentLinkResolveRequest.type, + token2, + error, + link2 + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.resolveDocumentLink + ? middleware.resolveDocumentLink( + link, + token, + resolveDocumentLink + ) + : resolveDocumentLink(link, token); + } + : void 0, + }; + return [ + vscode_1.languages.registerDocumentLinkProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + let ConfigurationFeature = class { + constructor(_client) { + this._client = _client; + this._listeners = new Map(); + } + get registrationType() { + return vscode_languageserver_protocol_1 + .DidChangeConfigurationNotification.type; + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'workspace'), + 'didChangeConfiguration' + ).dynamicRegistration = true; + } + initialize() { + let section = this._client.clientOptions.synchronize + .configurationSection; + if (section !== void 0) { + this.register({ + id: UUID.generateUuid(), + registerOptions: { + section, + }, + }); + } + } + register(data) { + let disposable = vscode_1.workspace.onDidChangeConfiguration( + (event) => { + this.onDidChangeConfiguration(data.registerOptions.section, event); + } + ); + this._listeners.set(data.id, disposable); + if (data.registerOptions.section !== void 0) { + this.onDidChangeConfiguration(data.registerOptions.section, void 0); + } + } + unregister(id) { + let disposable = this._listeners.get(id); + if (disposable) { + this._listeners.delete(id); + disposable.dispose(); + } + } + dispose() { + for (const disposable of this._listeners.values()) { + disposable.dispose(); + } + this._listeners.clear(); + } + onDidChangeConfiguration(configurationSection, event) { + let sections; + if (Is2.string(configurationSection)) { + sections = [configurationSection]; + } else { + sections = configurationSection; + } + if (sections !== void 0 && event !== void 0) { + let affected = sections.some((section) => + event.affectsConfiguration(section) + ); + if (!affected) { + return; + } + } + const didChangeConfiguration = async (sections2) => { + if (sections2 === void 0) { + return this._client.sendNotification( + vscode_languageserver_protocol_1 + .DidChangeConfigurationNotification.type, + { settings: null } + ); + } else { + return this._client.sendNotification( + vscode_languageserver_protocol_1 + .DidChangeConfigurationNotification.type, + { settings: this.extractSettingsInformation(sections2) } + ); + } + }; + let middleware = this.getMiddleware(); + (middleware + ? middleware(sections, didChangeConfiguration) + : didChangeConfiguration(sections) + ).catch((error) => { + this._client.error( + `Sending notification ${vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type.method} failed`, + error + ); + }); + } + extractSettingsInformation(keys) { + function ensurePath(config, path) { + let current = config; + for (let i = 0; i < path.length - 1; i++) { + let obj = current[path[i]]; + if (!obj) { + obj = Object.create(null); + current[path[i]] = obj; + } + current = obj; + } + return current; + } + let resource = this._client.clientOptions.workspaceFolder + ? this._client.clientOptions.workspaceFolder.uri + : void 0; + let result = Object.create(null); + for (let i = 0; i < keys.length; i++) { + let key = keys[i]; + let index = key.indexOf('.'); + let config = null; + if (index >= 0) { + config = vscode_1.workspace + .getConfiguration(key.substr(0, index), resource) + .get(key.substr(index + 1)); + } else { + config = vscode_1.workspace + .getConfiguration(void 0, resource) + .get(key); + } + if (config) { + let path = keys[i].split('.'); + ensurePath(result, path)[path[path.length - 1]] = (0, + configuration_1.toJSONObject)(config); + } + } + return result; + } + getMiddleware() { + let middleware = this._client.clientOptions.middleware; + if ( + middleware.workspace && + middleware.workspace.didChangeConfiguration + ) { + return middleware.workspace.didChangeConfiguration; + } else { + return void 0; + } + } + }; + let ExecuteCommandFeature = class { + constructor(_client) { + this._client = _client; + this._commands = new Map(); + } + get registrationType() { + return vscode_languageserver_protocol_1.ExecuteCommandRequest.type; + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'workspace'), + 'executeCommand' + ).dynamicRegistration = true; + } + initialize(capabilities) { + if (!capabilities.executeCommandProvider) { + return; + } + this.register({ + id: UUID.generateUuid(), + registerOptions: Object.assign( + {}, + capabilities.executeCommandProvider + ), + }); + } + register(data) { + const client = this._client; + const middleware = client.clientOptions.middleware; + const executeCommand = (command, args) => { + let params = { + command, + arguments: args, + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.ExecuteCommandRequest.type, + params + ) + .then(void 0, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.ExecuteCommandRequest.type, + void 0, + error, + void 0 + ); + }); + }; + if (data.registerOptions.commands) { + const disposables = []; + for (const command of data.registerOptions.commands) { + disposables.push( + vscode_1.commands.registerCommand(command, (...args) => { + return middleware.executeCommand + ? middleware.executeCommand(command, args, executeCommand) + : executeCommand(command, args); + }) + ); + } + this._commands.set(data.id, disposables); + } + } + unregister(id) { + let disposables = this._commands.get(id); + if (disposables) { + disposables.forEach((disposable) => disposable.dispose()); + } + } + dispose() { + this._commands.forEach((value) => { + value.forEach((disposable) => disposable.dispose()); + }); + this._commands.clear(); + } + }; + let MessageTransports; + (function (MessageTransports2) { + function is2(value) { + let candidate = value; + return ( + candidate && + vscode_languageserver_protocol_1.MessageReader.is(value.reader) && + vscode_languageserver_protocol_1.MessageWriter.is(value.writer) + ); + } + MessageTransports2.is = is2; + })( + (MessageTransports = + exports.MessageTransports || (exports.MessageTransports = {})) + ); + let OnReady = class { + constructor(_resolve, _reject) { + this._resolve = _resolve; + this._reject = _reject; + this._used = false; + } + get isUsed() { + return this._used; + } + resolve() { + this._used = true; + this._resolve(); + } + reject(error) { + this._used = true; + this._reject(error); + } + }; + let LSPCancellationError = class extends vscode_1.CancellationError { + constructor(data) { + super(); + this.data = data; + } + }; + exports.LSPCancellationError = LSPCancellationError; + var BaseLanguageClient = class { + constructor(id, name, clientOptions) { + this._traceFormat = vscode_languageserver_protocol_1.TraceFormat.Text; + this._features = []; + this._dynamicFeatures = new Map(); + this._id = id; + this._name = name; + clientOptions = clientOptions || {}; + const markdown = { isTrusted: false, supportHtml: false }; + if (clientOptions.markdown !== void 0) { + markdown.isTrusted = clientOptions.markdown.isTrusted === true; + markdown.supportHtml = clientOptions.markdown.supportHtml === true; + } + this._clientOptions = { + documentSelector: clientOptions.documentSelector ?? [], + synchronize: clientOptions.synchronize ?? {}, + diagnosticCollectionName: clientOptions.diagnosticCollectionName, + outputChannelName: clientOptions.outputChannelName ?? this._name, + revealOutputChannelOn: + clientOptions.revealOutputChannelOn ?? RevealOutputChannelOn2.Error, + stdioEncoding: clientOptions.stdioEncoding ?? 'utf8', + initializationOptions: clientOptions.initializationOptions, + initializationFailedHandler: + clientOptions.initializationFailedHandler, + progressOnInitialization: !!clientOptions.progressOnInitialization, + errorHandler: + clientOptions.errorHandler ?? + this.createDefaultErrorHandler( + clientOptions.connectionOptions?.maxRestartCount + ), + middleware: clientOptions.middleware ?? {}, + uriConverters: clientOptions.uriConverters, + workspaceFolder: clientOptions.workspaceFolder, + connectionOptions: clientOptions.connectionOptions, + markdown, + diagnosticPullOptions: clientOptions.diagnosticPullOptions ?? { + onChange: true, + onSave: false, + }, + }; + this._clientOptions.synchronize = this._clientOptions.synchronize || {}; + this._state = ClientState.Initial; + this._connectionPromise = void 0; + this._resolvedConnection = void 0; + this._initializeResult = void 0; + if (clientOptions.outputChannel) { + this._outputChannel = clientOptions.outputChannel; + this._disposeOutputChannel = false; + } else { + this._outputChannel = void 0; + this._disposeOutputChannel = true; + } + this._traceOutputChannel = clientOptions.traceOutputChannel; + this._listeners = void 0; + this._providers = void 0; + this._diagnostics = void 0; + this._fileEvents = []; + this._fileEventDelayer = new async_1.Delayer(250); + this._onReady = new Promise((resolve, reject) => { + this._onReadyCallbacks = new OnReady(resolve, reject); + }); + this._onStop = void 0; + this._telemetryEmitter = new vscode_languageserver_protocol_1.Emitter(); + this._stateChangeEmitter = new vscode_languageserver_protocol_1.Emitter(); + this._trace = vscode_languageserver_protocol_1.Trace.Off; + this._tracer = { + log: (messageOrDataObject, data) => { + if (Is2.string(messageOrDataObject)) { + this.logTrace(messageOrDataObject, data); + } else { + this.logObjectTrace(messageOrDataObject); + } + }, + }; + this._c2p = c2p.createConverter( + clientOptions.uriConverters + ? clientOptions.uriConverters.code2Protocol + : void 0 + ); + this._p2c = p2c.createConverter( + clientOptions.uriConverters + ? clientOptions.uriConverters.protocol2Code + : void 0, + this._clientOptions.markdown.isTrusted, + this._clientOptions.markdown.supportHtml + ); + this._syncedDocuments = new Map(); + this.registerBuiltinFeatures(); + } + get state() { + return this._state; + } + set state(value) { + let oldState = this.getPublicState(); + this._state = value; + let newState = this.getPublicState(); + if (newState !== oldState) { + this._stateChangeEmitter.fire({ oldState, newState }); + } + } + getPublicState() { + if (this.state === ClientState.Running) { + return State.Running; + } else if (this.state === ClientState.Starting) { + return State.Starting; + } else { + return State.Stopped; + } + } + get initializeResult() { + return this._initializeResult; + } + sendRequest(type, ...params) { + if (!this.isConnectionActive()) { + throw new Error( + `Language client is not ready yet when handling ${ + Is2.string(type) ? type : type.method + }` + ); + } + this.forceDocumentSync(); + try { + return this._resolvedConnection.sendRequest(type, ...params); + } catch (error) { + this.error( + `Sending request ${Is2.string(type) ? type : type.method} failed.`, + error + ); + throw error; + } + } + onRequest(type, handler) { + if (!this.isConnectionActive()) { + throw new Error( + `Language client is not ready yet when handling ${ + Is2.string(type) ? type : type.method + }` + ); + } + try { + return this._resolvedConnection.onRequest(type, handler); + } catch (error) { + this.error( + `Registering request handler ${ + Is2.string(type) ? type : type.method + } failed.`, + error + ); + throw error; + } + } + sendNotification(type, params) { + if (!this.isConnectionActive()) { + throw new Error( + `Language client is not ready yet when handling ${ + Is2.string(type) ? type : type.method + }` + ); + } + this.forceDocumentSync(); + try { + return this._resolvedConnection.sendNotification(type, params); + } catch (error) { + this.error( + `Sending notification ${ + Is2.string(type) ? type : type.method + } failed.`, + error + ); + throw error; + } + } + onNotification(type, handler) { + if (!this.isConnectionActive()) { + throw new Error( + `Language client is not ready yet when handling ${ + Is2.string(type) ? type : type.method + }` + ); + } + try { + return this._resolvedConnection.onNotification(type, handler); + } catch (error) { + this.error( + `Registering notification handler ${ + Is2.string(type) ? type : type.method + } failed.`, + error + ); + throw error; + } + } + onProgress(type, token, handler) { + if (!this.isConnectionActive()) { + throw new Error( + 'Language client is not ready yet when trying to send progress' + ); + } + try { + if (vscode_languageserver_protocol_1.WorkDoneProgress.is(type)) { + const handleWorkDoneProgress = this._clientOptions.middleware + .handleWorkDoneProgress; + if (handleWorkDoneProgress !== void 0) { + return this._resolvedConnection.onProgress( + type, + token, + (params) => { + handleWorkDoneProgress(token, params, () => handler(params)); + } + ); + } + } + return this._resolvedConnection.onProgress(type, token, handler); + } catch (error) { + this.error( + `Registering progress handler for token ${token} failed.`, + error + ); + throw error; + } + } + sendProgress(type, token, value) { + if (!this.isConnectionActive()) { + throw new Error( + 'Language client is not ready yet when trying to send progress' + ); + } + this.forceDocumentSync(); + return this._resolvedConnection + .sendProgress(type, token, value) + .then(void 0, (error) => { + this.error(`Sending progress for token ${token} failed.`, error); + throw error; + }); + } + get name() { + return this._name; + } + get clientOptions() { + return this._clientOptions; + } + get protocol2CodeConverter() { + return this._p2c; + } + get code2ProtocolConverter() { + return this._c2p; + } + get onTelemetry() { + return this._telemetryEmitter.event; + } + get onDidChangeState() { + return this._stateChangeEmitter.event; + } + get outputChannel() { + if (!this._outputChannel) { + this._outputChannel = vscode_1.window.createOutputChannel( + this._clientOptions.outputChannelName + ? this._clientOptions.outputChannelName + : this._name + ); + } + return this._outputChannel; + } + get traceOutputChannel() { + if (this._traceOutputChannel) { + return this._traceOutputChannel; + } + return this.outputChannel; + } + get diagnostics() { + return this._diagnostics; + } + createDefaultErrorHandler(maxRestartCount) { + if (maxRestartCount !== void 0 && maxRestartCount < 0) { + throw new Error(`Invalid maxRestartCount: ${maxRestartCount}`); + } + return new DefaultErrorHandler(this, maxRestartCount ?? 4); + } + set trace(value) { + this._trace = value; + this.onReady().then( + () => { + this.resolveConnection().then( + (connection) => { + connection.trace(this._trace, this._tracer, { + sendNotification: false, + traceFormat: this._traceFormat, + }); + }, + () => this.info(`Setting trace value failed`, void 0, false) + ); + }, + () => {} + ); + } + data2String(data) { + if (data instanceof vscode_languageserver_protocol_1.ResponseError) { + const responseError = data; + return ` Message: ${responseError.message} + Code: ${responseError.code} ${ + responseError.data ? '\n' + responseError.data.toString() : '' + }`; + } + if (data instanceof Error) { + if (Is2.string(data.stack)) { + return data.stack; + } + return data.message; + } + if (Is2.string(data)) { + return data; + } + return data.toString(); + } + info(message, data, showNotification = true) { + this.outputChannel.appendLine( + `[Info - ${new Date().toLocaleTimeString()}] ${message}` + ); + if (data !== null && data !== void 0) { + this.outputChannel.appendLine(this.data2String(data)); + } + if ( + showNotification && + this._clientOptions.revealOutputChannelOn <= + RevealOutputChannelOn2.Info + ) { + this.showNotificationMessage( + vscode_languageserver_protocol_1.MessageType.Info, + message + ); + } + } + warn(message, data, showNotification = true) { + this.outputChannel.appendLine( + `[Warn - ${new Date().toLocaleTimeString()}] ${message}` + ); + if (data !== null && data !== void 0) { + this.outputChannel.appendLine(this.data2String(data)); + } + if ( + showNotification && + this._clientOptions.revealOutputChannelOn <= + RevealOutputChannelOn2.Warn + ) { + this.showNotificationMessage( + vscode_languageserver_protocol_1.MessageType.Warning, + message + ); + } + } + error(message, data, showNotification = true) { + this.outputChannel.appendLine( + `[Error - ${new Date().toLocaleTimeString()}] ${message}` + ); + if (data !== null && data !== void 0) { + this.outputChannel.appendLine(this.data2String(data)); + } + if ( + showNotification === 'force' || + (showNotification && + this._clientOptions.revealOutputChannelOn <= + RevealOutputChannelOn2.Error) + ) { + this.showNotificationMessage( + vscode_languageserver_protocol_1.MessageType.Error, + message + ); + } + } + showNotificationMessage(type, message) { + message = + message ?? + 'A request has failed. See the output for more information.'; + const messageFunc = + type === vscode_languageserver_protocol_1.MessageType.Error + ? vscode_1.window.showErrorMessage + : type === vscode_languageserver_protocol_1.MessageType.Warning + ? vscode_1.window.showWarningMessage + : vscode_1.window.showInformationMessage; + void messageFunc(message, 'Go to output').then((selection) => { + if (selection !== void 0) { + this.outputChannel.show(true); + } + }); + } + logTrace(message, data) { + this.traceOutputChannel.appendLine( + `[Trace - ${new Date().toLocaleTimeString()}] ${message}` + ); + if (data) { + this.traceOutputChannel.appendLine(this.data2String(data)); + } + } + logObjectTrace(data) { + if (data.isLSPMessage && data.type) { + this.traceOutputChannel.append( + `[LSP - ${new Date().toLocaleTimeString()}] ` + ); + } else { + this.traceOutputChannel.append( + `[Trace - ${new Date().toLocaleTimeString()}] ` + ); + } + if (data) { + this.traceOutputChannel.appendLine(`${JSON.stringify(data)}`); + } + } + needsStart() { + return ( + this.state === ClientState.Initial || + this.state === ClientState.Stopping || + this.state === ClientState.Stopped + ); + } + needsStop() { + return ( + this.state === ClientState.Starting || + this.state === ClientState.Running + ); + } + onReady() { + return this._onReady; + } + isConnectionActive() { + return this.state === ClientState.Running && !!this._resolvedConnection; + } + start() { + if (this._onReadyCallbacks.isUsed) { + this._onReady = new Promise((resolve, reject) => { + this._onReadyCallbacks = new OnReady(resolve, reject); + }); + } + this._listeners = []; + this._providers = []; + if (!this._diagnostics) { + this._diagnostics = this._clientOptions.diagnosticCollectionName + ? vscode_1.languages.createDiagnosticCollection( + this._clientOptions.diagnosticCollectionName + ) + : vscode_1.languages.createDiagnosticCollection(); + } + this.state = ClientState.Starting; + this.resolveConnection() + .then((connection) => { + connection.onLogMessage((message) => { + switch (message.type) { + case vscode_languageserver_protocol_1.MessageType.Error: + this.error(message.message, void 0, false); + break; + case vscode_languageserver_protocol_1.MessageType.Warning: + this.warn(message.message, void 0, false); + break; + case vscode_languageserver_protocol_1.MessageType.Info: + this.info(message.message, void 0, false); + break; + default: + this.outputChannel.appendLine(message.message); + } + }); + connection.onShowMessage((message) => { + switch (message.type) { + case vscode_languageserver_protocol_1.MessageType.Error: + void vscode_1.window.showErrorMessage(message.message); + break; + case vscode_languageserver_protocol_1.MessageType.Warning: + void vscode_1.window.showWarningMessage(message.message); + break; + case vscode_languageserver_protocol_1.MessageType.Info: + void vscode_1.window.showInformationMessage(message.message); + break; + default: + void vscode_1.window.showInformationMessage(message.message); + } + }); + connection.onRequest( + vscode_languageserver_protocol_1.ShowMessageRequest.type, + (params) => { + let messageFunc; + switch (params.type) { + case vscode_languageserver_protocol_1.MessageType.Error: + messageFunc = vscode_1.window.showErrorMessage; + break; + case vscode_languageserver_protocol_1.MessageType.Warning: + messageFunc = vscode_1.window.showWarningMessage; + break; + case vscode_languageserver_protocol_1.MessageType.Info: + messageFunc = vscode_1.window.showInformationMessage; + break; + default: + messageFunc = vscode_1.window.showInformationMessage; + } + let actions = params.actions || []; + return messageFunc(params.message, ...actions); + } + ); + connection.onTelemetry((data) => { + this._telemetryEmitter.fire(data); + }); + connection.onRequest( + vscode_languageserver_protocol_1.ShowDocumentRequest.type, + async (params) => { + const showDocument = async (params2) => { + const uri = this.protocol2CodeConverter.asUri(params2.uri); + try { + if (params2.external === true) { + const success = await vscode_1.env.openExternal(uri); + return { success }; + } else { + const options = {}; + if (params2.selection !== void 0) { + options.selection = this.protocol2CodeConverter.asRange( + params2.selection + ); + } + if ( + params2.takeFocus === void 0 || + params2.takeFocus === false + ) { + options.preserveFocus = true; + } else if (params2.takeFocus === true) { + options.preserveFocus = false; + } + await vscode_1.window.showTextDocument(uri, options); + return { success: true }; + } + } catch (error) { + return { success: true }; + } + }; + const middleware = this._clientOptions.middleware.window + ?.showDocument; + if (middleware !== void 0) { + return middleware(params, showDocument); + } else { + return showDocument(params); + } + } + ); + connection.listen(); + return this.initialize(connection); + }) + .catch((error) => { + this.state = ClientState.StartFailed; + this._onReadyCallbacks.reject(error); + this.error( + `${this._name} client: couldn't create connection to server`, + error, + 'force' + ); + }); + return new vscode_1.Disposable(() => { + if (this.needsStop()) { + this.stop().catch((error) => { + this.error(`Stopping server failed.`, error, false); + }); + } + }); + } + resolveConnection() { + if (!this._connectionPromise) { + this._connectionPromise = this.createConnection(); + } + return this._connectionPromise; + } + initialize(connection) { + this.refreshTrace(connection, false); + const initOption = this._clientOptions.initializationOptions; + const [rootPath, workspaceFolders] = + this._clientOptions.workspaceFolder !== void 0 + ? [ + this._clientOptions.workspaceFolder.uri.fsPath, + [ + { + uri: this._c2p.asUri( + this._clientOptions.workspaceFolder.uri + ), + name: this._clientOptions.workspaceFolder.name, + }, + ], + ] + : [this._clientGetRootPath(), null]; + const initParams = { + processId: null, + clientInfo: { + name: vscode_1.env.appName, + version: vscode_1.version, + }, + locale: this.getLocale(), + rootPath: rootPath ? rootPath : null, + rootUri: rootPath + ? this._c2p.asUri(vscode_1.Uri.file(rootPath)) + : null, + capabilities: this.computeClientCapabilities(), + initializationOptions: Is2.func(initOption) + ? initOption() + : initOption, + trace: vscode_languageserver_protocol_1.Trace.toString(this._trace), + workspaceFolders, + }; + this.fillInitializeParams(initParams); + if (this._clientOptions.progressOnInitialization) { + const token = UUID.generateUuid(); + const part = new progressPart_1.ProgressPart(connection, token); + initParams.workDoneToken = token; + return this.doInitialize(connection, initParams).then( + (result) => { + part.done(); + return result; + }, + (error) => { + part.cancel(); + throw error; + } + ); + } else { + return this.doInitialize(connection, initParams); + } + } + doInitialize(connection, initParams) { + return connection + .initialize(initParams) + .then((result) => { + this._resolvedConnection = connection; + this._initializeResult = result; + this.state = ClientState.Running; + let textDocumentSyncOptions = void 0; + if (Is2.number(result.capabilities.textDocumentSync)) { + if ( + result.capabilities.textDocumentSync === + vscode_languageserver_protocol_1.TextDocumentSyncKind.None + ) { + textDocumentSyncOptions = { + openClose: false, + change: + vscode_languageserver_protocol_1.TextDocumentSyncKind.None, + save: void 0, + }; + } else { + textDocumentSyncOptions = { + openClose: true, + change: result.capabilities.textDocumentSync, + save: { + includeText: false, + }, + }; + } + } else if ( + result.capabilities.textDocumentSync !== void 0 && + result.capabilities.textDocumentSync !== null + ) { + textDocumentSyncOptions = result.capabilities.textDocumentSync; + } + this._capabilities = Object.assign({}, result.capabilities, { + resolvedTextDocumentSync: textDocumentSyncOptions, + }); + connection.onDiagnostics((params) => + this.handleDiagnostics(params) + ); + connection.onRequest( + vscode_languageserver_protocol_1.RegistrationRequest.type, + (params) => this.handleRegistrationRequest(params) + ); + connection.onRequest('client/registerFeature', (params) => + this.handleRegistrationRequest(params) + ); + connection.onRequest( + vscode_languageserver_protocol_1.UnregistrationRequest.type, + (params) => this.handleUnregistrationRequest(params) + ); + connection.onRequest('client/unregisterFeature', (params) => + this.handleUnregistrationRequest(params) + ); + connection.onRequest( + vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, + (params) => this.handleApplyWorkspaceEdit(params) + ); + return connection + .sendNotification( + vscode_languageserver_protocol_1.InitializedNotification.type, + {} + ) + .then(() => { + this.hookFileEvents(connection); + this.hookConfigurationChanged(connection); + this.initializeFeatures(connection); + this._onReadyCallbacks.resolve(); + return result; + }); + }) + .then(void 0, (error) => { + if (this._clientOptions.initializationFailedHandler) { + if (this._clientOptions.initializationFailedHandler(error)) { + void this.initialize(connection); + } else { + void this.stop(); + this._onReadyCallbacks.reject(error); + } + } else if ( + error instanceof vscode_languageserver_protocol_1.ResponseError && + error.data && + error.data.retry + ) { + void vscode_1.window + .showErrorMessage(error.message, { + title: 'Retry', + id: 'retry', + }) + .then((item) => { + if (item && item.id === 'retry') { + void this.initialize(connection); + } else { + void this.stop(); + this._onReadyCallbacks.reject(error); + } + }); + } else { + if (error && error.message) { + void vscode_1.window.showErrorMessage(error.message); + } + this.error('Server initialization failed.', error); + void this.stop(); + this._onReadyCallbacks.reject(error); + } + throw error; + }); + } + _clientGetRootPath() { + let folders = vscode_1.workspace.workspaceFolders; + if (!folders || folders.length === 0) { + return void 0; + } + let folder = folders[0]; + if (folder.uri.scheme === 'file') { + return folder.uri.fsPath; + } + return void 0; + } + async stop(timeout = 2e3) { + await this.onReady(); + this._initializeResult = void 0; + if (!this._connectionPromise) { + this.state = ClientState.Stopped; + return Promise.resolve(); + } + if (this.state === ClientState.Stopping && this._onStop) { + return this._onStop; + } + this.state = ClientState.Stopping; + this.cleanUp(false); + const tp = new Promise((c) => { + (0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout( + c, + timeout + ); + }); + const shutdown = this.resolveConnection().then((connection) => { + return connection.shutdown().then(() => { + return connection.exit().then(() => { + return connection; + }); + }); + }); + return (this._onStop = Promise.race([tp, shutdown]) + .then( + (connection) => { + if (connection !== void 0) { + connection.end(); + connection.dispose(); + } else { + this.error(`Stopping server timed out`, void 0, false); + throw new Error(`Stopping the server timed out`); + } + }, + (error) => { + this.error(`Stopping server failed`, error, false); + throw error; + } + ) + .finally(() => { + this.state = ClientState.Stopped; + this.cleanUpChannel(); + this._onStop = void 0; + this._connectionPromise = void 0; + this._resolvedConnection = void 0; + })); + } + cleanUp(channel = true, diagnostics = true) { + if (this._listeners) { + this._listeners.forEach((listener) => listener.dispose()); + this._listeners = void 0; + } + if (this._providers) { + this._providers.forEach((provider) => provider.dispose()); + this._providers = void 0; + } + if (this._syncedDocuments) { + this._syncedDocuments.clear(); + } + for (const feature of this._features.values()) { + feature.dispose(); + } + if (channel) { + this.cleanUpChannel(); + } + if (diagnostics && this._diagnostics) { + this._diagnostics.dispose(); + this._diagnostics = void 0; + } + } + cleanUpChannel() { + if (this._outputChannel && this._disposeOutputChannel) { + this._outputChannel.dispose(); + this._outputChannel = void 0; + } + } + notifyFileEvent(event) { + const client = this; + async function didChangeWatchedFile(event2) { + client._fileEvents.push(event2); + return client._fileEventDelayer.trigger(async () => { + await client.onReady(); + const connection = await client.resolveConnection(); + let promise = Promise.resolve(); + if (client.isConnectionActive()) { + client.forceDocumentSync(); + promise = connection.didChangeWatchedFiles({ + changes: client._fileEvents, + }); + } + client._fileEvents = []; + return promise; + }); + } + const workSpaceMiddleware = this.clientOptions.middleware?.workspace; + (workSpaceMiddleware?.didChangeWatchedFile + ? workSpaceMiddleware.didChangeWatchedFile( + event, + didChangeWatchedFile + ) + : didChangeWatchedFile(event) + ).catch((error) => { + client.error(`Notify file events failed.`, error); + }); + } + forceDocumentSync() { + if (this._didChangeTextDocumentFeature === void 0) { + this._didChangeTextDocumentFeature = this._dynamicFeatures.get( + vscode_languageserver_protocol_1.DidChangeTextDocumentNotification + .type.method + ); + } + this._didChangeTextDocumentFeature.forceDelivery(); + } + handleDiagnostics(params) { + if (!this._diagnostics) { + return; + } + let uri = this._p2c.asUri(params.uri); + let diagnostics = this._p2c.asDiagnostics(params.diagnostics); + let middleware = this.clientOptions.middleware; + if (middleware.handleDiagnostics) { + middleware.handleDiagnostics(uri, diagnostics, (uri2, diagnostics2) => + this.setDiagnostics(uri2, diagnostics2) + ); + } else { + this.setDiagnostics(uri, diagnostics); + } + } + setDiagnostics(uri, diagnostics) { + if (!this._diagnostics) { + return; + } + this._diagnostics.set(uri, diagnostics); + } + createConnection() { + let errorHandler = (error, message, count) => { + this.handleConnectionError(error, message, count); + }; + let closeHandler = () => { + this.handleConnectionClosed(); + }; + return this.createMessageTransports( + this._clientOptions.stdioEncoding || 'utf8' + ).then((transports) => { + return createConnection( + transports.reader, + transports.writer, + errorHandler, + closeHandler, + this._clientOptions.connectionOptions + ); + }); + } + handleConnectionClosed() { + if (this.state === ClientState.Stopped) { + return; + } + try { + if (this._resolvedConnection) { + this._resolvedConnection.dispose(); + } + } catch (error) {} + let handlerResult = { action: CloseAction.DoNotRestart }; + if (this.state !== ClientState.Stopping) { + try { + handlerResult = this._clientOptions.errorHandler.closed(); + } catch (error) {} + } + this._connectionPromise = void 0; + this._resolvedConnection = void 0; + if (handlerResult.action === CloseAction.DoNotRestart) { + this.error( + handlerResult.message ?? + 'Connection to server got closed. Server will not be restarted.', + void 0, + 'force' + ); + if (this.state === ClientState.Starting) { + this._onReadyCallbacks.reject( + new Error( + `Connection to server got closed. Server will not be restarted.` + ) + ); + this.state = ClientState.StartFailed; + } else { + this.state = ClientState.Stopped; + } + this.cleanUp(false, true); + } else if (handlerResult.action === CloseAction.Restart) { + this.info( + handlerResult.message ?? + 'Connection to server got closed. Server will restart.' + ); + this.cleanUp(false, false); + this.state = ClientState.Initial; + this.start(); + } + } + handleConnectionError(error, message, count) { + const handlerResult = this._clientOptions.errorHandler.error( + error, + message, + count + ); + if (handlerResult.action === ErrorAction.Shutdown) { + this.error( + handlerResult.message ?? + `Client ${this._name}: connection to server is erroring. Shutting down server.`, + void 0, + 'force' + ); + this.stop().catch((error2) => { + this.error(`Stopping server failed`, error2, false); + }); + } + } + hookConfigurationChanged(connection) { + vscode_1.workspace.onDidChangeConfiguration(() => { + this.refreshTrace(connection, true); + }); + } + refreshTrace(connection, sendNotification = false) { + const config = vscode_1.workspace.getConfiguration(this._id); + let trace = vscode_languageserver_protocol_1.Trace.Off; + let traceFormat = vscode_languageserver_protocol_1.TraceFormat.Text; + if (config) { + const traceConfig = config.get('trace.server', 'off'); + if (typeof traceConfig === 'string') { + trace = vscode_languageserver_protocol_1.Trace.fromString( + traceConfig + ); + } else { + trace = vscode_languageserver_protocol_1.Trace.fromString( + config.get('trace.server.verbosity', 'off') + ); + traceFormat = vscode_languageserver_protocol_1.TraceFormat.fromString( + config.get('trace.server.format', 'text') + ); + } + } + this._trace = trace; + this._traceFormat = traceFormat; + connection.trace(this._trace, this._tracer, { + sendNotification, + traceFormat: this._traceFormat, + }); + } + hookFileEvents(_connection) { + let fileEvents = this._clientOptions.synchronize.fileEvents; + if (!fileEvents) { + return; + } + let watchers; + if (Is2.array(fileEvents)) { + watchers = fileEvents; + } else { + watchers = [fileEvents]; + } + if (!watchers) { + return; + } + this._dynamicFeatures + .get( + vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification + .type.method + ) + .registerRaw(UUID.generateUuid(), watchers); + } + registerFeatures(features) { + for (let feature of features) { + this.registerFeature(feature); + } + } + registerFeature(feature) { + this._features.push(feature); + if (DynamicFeature.is(feature)) { + const registrationType = feature.registrationType; + this._dynamicFeatures.set(registrationType.method, feature); + } + } + getFeature(request) { + return this._dynamicFeatures.get(request); + } + registerBuiltinFeatures() { + this.registerFeature(new ConfigurationFeature(this)); + this.registerFeature( + new DidOpenTextDocumentFeature(this, this._syncedDocuments) + ); + this.registerFeature(new DidChangeTextDocumentFeature(this)); + this.registerFeature(new WillSaveFeature(this)); + this.registerFeature(new WillSaveWaitUntilFeature(this)); + this.registerFeature(new DidSaveTextDocumentFeature(this)); + this.registerFeature( + new DidCloseTextDocumentFeature(this, this._syncedDocuments) + ); + this.registerFeature( + new FileSystemWatcherFeature(this, (event) => + this.notifyFileEvent(event) + ) + ); + this.registerFeature(new CompletionItemFeature(this)); + this.registerFeature(new HoverFeature(this)); + this.registerFeature(new SignatureHelpFeature(this)); + this.registerFeature(new DefinitionFeature(this)); + this.registerFeature(new ReferencesFeature(this)); + this.registerFeature(new DocumentHighlightFeature(this)); + this.registerFeature(new DocumentSymbolFeature(this)); + this.registerFeature(new WorkspaceSymbolFeature(this)); + this.registerFeature(new CodeActionFeature(this)); + this.registerFeature(new CodeLensFeature(this)); + this.registerFeature(new DocumentFormattingFeature(this)); + this.registerFeature(new DocumentRangeFormattingFeature(this)); + this.registerFeature(new DocumentOnTypeFormattingFeature(this)); + this.registerFeature(new RenameFeature(this)); + this.registerFeature(new DocumentLinkFeature(this)); + this.registerFeature(new ExecuteCommandFeature(this)); + } + fillInitializeParams(params) { + for (let feature of this._features) { + if (Is2.func(feature.fillInitializeParams)) { + feature.fillInitializeParams(params); + } + } + } + computeClientCapabilities() { + const result = {}; + ensure(result, 'workspace').applyEdit = true; + const workspaceEdit = ensure( + ensure(result, 'workspace'), + 'workspaceEdit' + ); + workspaceEdit.documentChanges = true; + workspaceEdit.resourceOperations = [ + vscode_languageserver_protocol_1.ResourceOperationKind.Create, + vscode_languageserver_protocol_1.ResourceOperationKind.Rename, + vscode_languageserver_protocol_1.ResourceOperationKind.Delete, + ]; + workspaceEdit.failureHandling = + vscode_languageserver_protocol_1.FailureHandlingKind.TextOnlyTransactional; + workspaceEdit.normalizesLineEndings = true; + workspaceEdit.changeAnnotationSupport = { + groupsOnLabel: true, + }; + const diagnostics = ensure( + ensure(result, 'textDocument'), + 'publishDiagnostics' + ); + diagnostics.relatedInformation = true; + diagnostics.versionSupport = false; + diagnostics.tagSupport = { + valueSet: [ + vscode_languageserver_protocol_1.DiagnosticTag.Unnecessary, + vscode_languageserver_protocol_1.DiagnosticTag.Deprecated, + ], + }; + diagnostics.codeDescriptionSupport = true; + diagnostics.dataSupport = true; + const windowCapabilities = ensure(result, 'window'); + const showMessage = ensure(windowCapabilities, 'showMessage'); + showMessage.messageActionItem = { additionalPropertiesSupport: true }; + const showDocument = ensure(windowCapabilities, 'showDocument'); + showDocument.support = true; + const generalCapabilities = ensure(result, 'general'); + generalCapabilities.staleRequestSupport = { + cancel: true, + retryOnContentModified: Array.from( + BaseLanguageClient.RequestsToCancelOnContentModified + ), + }; + generalCapabilities.regularExpressions = { + engine: 'ECMAScript', + version: 'ES2020', + }; + generalCapabilities.markdown = { + parser: 'marked', + version: '1.1.0', + }; + if (this._clientOptions.markdown.supportHtml) { + generalCapabilities.markdown.allowedTags = [ + 'ul', + 'li', + 'p', + 'code', + 'blockquote', + 'ol', + 'h1', + 'h2', + 'h3', + 'h4', + 'h5', + 'h6', + 'hr', + 'em', + 'pre', + 'table', + 'thead', + 'tbody', + 'tr', + 'th', + 'td', + 'div', + 'del', + 'a', + 'strong', + 'br', + 'img', + 'span', + ]; + } + for (let feature of this._features) { + feature.fillClientCapabilities(result); + } + return result; + } + initializeFeatures(_connection) { + let documentSelector = this._clientOptions.documentSelector; + for (let feature of this._features) { + feature.initialize(this._capabilities, documentSelector); + } + } + handleRegistrationRequest(params) { + return new Promise((resolve, reject) => { + for (const registration of params.registrations) { + const feature = this._dynamicFeatures.get(registration.method); + if (feature === void 0) { + reject( + new Error( + `No feature implementation for ${registration.method} found. Registration failed.` + ) + ); + return; + } + const options = registration.registerOptions ?? {}; + options.documentSelector = + options.documentSelector ?? this._clientOptions.documentSelector; + const data = { + id: registration.id, + registerOptions: options, + }; + try { + feature.register(data); + } catch (err) { + reject(err); + return; + } + } + resolve(); + }); + } + handleUnregistrationRequest(params) { + return new Promise((resolve, reject) => { + for (let unregistration of params.unregisterations) { + const feature = this._dynamicFeatures.get(unregistration.method); + if (!feature) { + reject( + new Error( + `No feature implementation for ${unregistration.method} found. Unregistration failed.` + ) + ); + return; + } + feature.unregister(unregistration.id); + } + resolve(); + }); + } + handleApplyWorkspaceEdit(params) { + let workspaceEdit = params.edit; + let openTextDocuments = new Map(); + vscode_1.workspace.textDocuments.forEach((document2) => + openTextDocuments.set(document2.uri.toString(), document2) + ); + let versionMismatch = false; + if (workspaceEdit.documentChanges) { + for (const change of workspaceEdit.documentChanges) { + if ( + vscode_languageserver_protocol_1.TextDocumentEdit.is(change) && + change.textDocument.version && + change.textDocument.version >= 0 + ) { + let textDocument = openTextDocuments.get(change.textDocument.uri); + if ( + textDocument && + textDocument.version !== change.textDocument.version + ) { + versionMismatch = true; + break; + } + } + } + } + if (versionMismatch) { + return Promise.resolve({ applied: false }); + } + return Is2.asPromise( + vscode_1.workspace + .applyEdit(this._p2c.asWorkspaceEdit(params.edit)) + .then((value) => { + return { applied: value }; + }) + ); + } + handleFailedRequest( + type, + token, + error, + defaultValue, + showNotification = true + ) { + if (error instanceof vscode_languageserver_protocol_1.ResponseError) { + if ( + error.code === + vscode_languageserver_protocol_1.LSPErrorCodes.RequestCancelled || + error.code === + vscode_languageserver_protocol_1.LSPErrorCodes.ServerCancelled + ) { + if (token !== void 0 && token.isCancellationRequested) { + return defaultValue; + } else { + if (error.data !== void 0) { + throw new LSPCancellationError(error.data); + } else { + throw new vscode_1.CancellationError(); + } + } + } else if ( + error.code === + vscode_languageserver_protocol_1.LSPErrorCodes.ContentModified + ) { + if ( + BaseLanguageClient.RequestsToCancelOnContentModified.has( + type.method + ) + ) { + throw new vscode_1.CancellationError(); + } else { + return defaultValue; + } + } + } + this.error(`Request ${type.method} failed.`, error, showNotification); + throw error; + } + }; + exports.BaseLanguageClient = BaseLanguageClient; + BaseLanguageClient.RequestsToCancelOnContentModified = new Set([ + vscode_languageserver_protocol_1.SemanticTokensRequest.method, + vscode_languageserver_protocol_1.SemanticTokensRangeRequest.method, + vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.method, + ]); + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/colorProvider.js +let require_colorProvider = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/colorProvider.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ColorProviderFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let ColorProviderFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.DocumentColorRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'colorProvider' + ).dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + let [id, options] = this.getRegistration( + documentSelector, + capabilities.colorProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideColorPresentations: (color, context, token) => { + const client = this._client; + const provideColorPresentations = (color2, context2, token2) => { + const requestParams = { + color: color2, + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + context2.document + ), + range: client.code2ProtocolConverter.asRange(context2.range), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.ColorPresentationRequest + .type, + requestParams, + token2 + ) + .then(this.asColorPresentations.bind(this), (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.ColorPresentationRequest + .type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideColorPresentations + ? middleware.provideColorPresentations( + color, + context, + token, + provideColorPresentations + ) + : provideColorPresentations(color, context, token); + }, + provideDocumentColors: (document2, token) => { + const client = this._client; + const provideDocumentColors = (document3, token2) => { + const requestParams = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.DocumentColorRequest.type, + requestParams, + token2 + ) + .then(this.asColorInformations.bind(this), (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.ColorPresentationRequest + .type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDocumentColors + ? middleware.provideDocumentColors( + document2, + token, + provideDocumentColors + ) + : provideDocumentColors(document2, token); + }, + }; + return [ + vscode_1.languages.registerColorProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + asColor(color) { + return new vscode_1.Color( + color.red, + color.green, + color.blue, + color.alpha + ); + } + asColorInformations(colorInformation) { + if (Array.isArray(colorInformation)) { + return colorInformation.map((ci2) => { + return new vscode_1.ColorInformation( + this._client.protocol2CodeConverter.asRange(ci2.range), + this.asColor(ci2.color) + ); + }); + } + return []; + } + asColorPresentations(colorPresentations) { + if (Array.isArray(colorPresentations)) { + return colorPresentations.map((cp) => { + let presentation = new vscode_1.ColorPresentation(cp.label); + presentation.additionalTextEdits = this._client.protocol2CodeConverter.asTextEdits( + cp.additionalTextEdits + ); + presentation.textEdit = this._client.protocol2CodeConverter.asTextEdit( + cp.textEdit + ); + return presentation; + }); + } + return []; + } + }; + exports.ColorProviderFeature = ColorProviderFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/implementation.js +let require_implementation = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/implementation.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ImplementationFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let ImplementationFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.ImplementationRequest.type + ); + } + fillClientCapabilities(capabilities) { + let implementationSupport = ensure( + ensure(capabilities, 'textDocument'), + 'implementation' + ); + implementationSupport.dynamicRegistration = true; + implementationSupport.linkSupport = true; + } + initialize(capabilities, documentSelector) { + let [id, options] = this.getRegistration( + documentSelector, + capabilities.implementationProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideImplementation: (document2, position, token) => { + const client = this._client; + const provideImplementation = (document3, position2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.ImplementationRequest.type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asDefinitionResult, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.ImplementationRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideImplementation + ? middleware.provideImplementation( + document2, + position, + token, + provideImplementation + ) + : provideImplementation(document2, position, token); + }, + }; + return [ + vscode_1.languages.registerImplementationProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.ImplementationFeature = ImplementationFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/typeDefinition.js +let require_typeDefinition = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/typeDefinition.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeDefinitionFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let TypeDefinitionFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.TypeDefinitionRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'typeDefinition' + ).dynamicRegistration = true; + let typeDefinitionSupport = ensure( + ensure(capabilities, 'textDocument'), + 'typeDefinition' + ); + typeDefinitionSupport.dynamicRegistration = true; + typeDefinitionSupport.linkSupport = true; + } + initialize(capabilities, documentSelector) { + let [id, options] = this.getRegistration( + documentSelector, + capabilities.typeDefinitionProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideTypeDefinition: (document2, position, token) => { + const client = this._client; + const provideTypeDefinition = (document3, position2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.TypeDefinitionRequest.type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asDefinitionResult, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.TypeDefinitionRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideTypeDefinition + ? middleware.provideTypeDefinition( + document2, + position, + token, + provideTypeDefinition + ) + : provideTypeDefinition(document2, position, token); + }, + }; + return [ + vscode_1.languages.registerTypeDefinitionProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.TypeDefinitionFeature = TypeDefinitionFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/workspaceFolders.js +let require_workspaceFolders = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/workspaceFolders.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WorkspaceFoldersFeature = exports.arrayDiff = void 0; + let UUID = require_uuid(); + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + function access(target, key) { + if (target === void 0) { + return void 0; + } + return target[key]; + } + function arrayDiff(left, right) { + return left.filter((element) => right.indexOf(element) < 0); + } + exports.arrayDiff = arrayDiff; + let WorkspaceFoldersFeature = class { + constructor(_client) { + this._client = _client; + this._listeners = new Map(); + } + get registrationType() { + return vscode_languageserver_protocol_1 + .DidChangeWorkspaceFoldersNotification.type; + } + fillInitializeParams(params) { + const folders = vscode_1.workspace.workspaceFolders; + this.initializeWithFolders(folders); + if (folders === void 0) { + params.workspaceFolders = null; + } else { + params.workspaceFolders = folders.map((folder) => + this.asProtocol(folder) + ); + } + } + initializeWithFolders(currentWorkspaceFolders) { + this._initialFolders = currentWorkspaceFolders; + } + fillClientCapabilities(capabilities) { + capabilities.workspace = capabilities.workspace || {}; + capabilities.workspace.workspaceFolders = true; + } + initialize(capabilities) { + const client = this._client; + client.onRequest( + vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type, + (token) => { + const workspaceFolders = () => { + const folders = vscode_1.workspace.workspaceFolders; + if (folders === void 0) { + return null; + } + const result = folders.map((folder) => { + return this.asProtocol(folder); + }); + return result; + }; + const middleware = client.clientOptions.middleware.workspace; + return middleware && middleware.workspaceFolders + ? middleware.workspaceFolders(token, workspaceFolders) + : workspaceFolders(token); + } + ); + const value = access( + access(access(capabilities, 'workspace'), 'workspaceFolders'), + 'changeNotifications' + ); + let id; + if (typeof value === 'string') { + id = value; + } else if (value === true) { + id = UUID.generateUuid(); + } + if (id) { + this.register({ id, registerOptions: void 0 }); + } + } + sendInitialEvent(currentWorkspaceFolders) { + let promise; + if (this._initialFolders && currentWorkspaceFolders) { + const removed = arrayDiff( + this._initialFolders, + currentWorkspaceFolders + ); + const added = arrayDiff( + currentWorkspaceFolders, + this._initialFolders + ); + if (added.length > 0 || removed.length > 0) { + promise = this.doSendEvent(added, removed); + } + } else if (this._initialFolders) { + promise = this.doSendEvent([], this._initialFolders); + } else if (currentWorkspaceFolders) { + promise = this.doSendEvent(currentWorkspaceFolders, []); + } + if (promise !== void 0) { + promise.catch((error) => { + this._client.error( + `Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, + error + ); + }); + } + } + doSendEvent(addedFolders, removedFolders) { + let params = { + event: { + added: addedFolders.map((folder) => this.asProtocol(folder)), + removed: removedFolders.map((folder) => this.asProtocol(folder)), + }, + }; + return this._client.sendNotification( + vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification + .type, + params + ); + } + register(data) { + let id = data.id; + let client = this._client; + let disposable = vscode_1.workspace.onDidChangeWorkspaceFolders( + (event) => { + let didChangeWorkspaceFolders = (event2) => { + return this.doSendEvent(event2.added, event2.removed); + }; + let middleware = client.clientOptions.middleware.workspace; + const promise = + middleware && middleware.didChangeWorkspaceFolders + ? middleware.didChangeWorkspaceFolders( + event, + didChangeWorkspaceFolders + ) + : didChangeWorkspaceFolders(event); + promise.catch((error) => { + this._client.error( + `Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, + error + ); + }); + } + ); + this._listeners.set(id, disposable); + this.sendInitialEvent(vscode_1.workspace.workspaceFolders); + } + unregister(id) { + let disposable = this._listeners.get(id); + if (disposable === void 0) { + return; + } + this._listeners.delete(id); + disposable.dispose(); + } + dispose() { + for (let disposable of this._listeners.values()) { + disposable.dispose(); + } + this._listeners.clear(); + } + asProtocol(workspaceFolder) { + if (workspaceFolder === void 0) { + return null; + } + return { + uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri), + name: workspaceFolder.name, + }; + } + }; + exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/foldingRange.js +let require_foldingRange = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/foldingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.FoldingRangeFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + var FoldingRangeFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.FoldingRangeRequest.type + ); + } + fillClientCapabilities(capabilities) { + let capability = ensure( + ensure(capabilities, 'textDocument'), + 'foldingRange' + ); + capability.dynamicRegistration = true; + capability.rangeLimit = 5e3; + capability.lineFoldingOnly = true; + } + initialize(capabilities, documentSelector) { + let [id, options] = this.getRegistration( + documentSelector, + capabilities.foldingRangeProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideFoldingRanges: (document2, context, token) => { + const client = this._client; + const provideFoldingRanges = (document3, _2, token2) => { + const requestParams = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.FoldingRangeRequest.type, + requestParams, + token2 + ) + .then(FoldingRangeFeature.asFoldingRanges, (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.FoldingRangeRequest.type, + token2, + error, + null + ); + }); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideFoldingRanges + ? middleware.provideFoldingRanges( + document2, + context, + token, + provideFoldingRanges + ) + : provideFoldingRanges(document2, context, token); + }, + }; + return [ + vscode_1.languages.registerFoldingRangeProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + static asFoldingRangeKind(kind) { + if (kind) { + switch (kind) { + case vscode_languageserver_protocol_1.FoldingRangeKind.Comment: + return vscode_1.FoldingRangeKind.Comment; + case vscode_languageserver_protocol_1.FoldingRangeKind.Imports: + return vscode_1.FoldingRangeKind.Imports; + case vscode_languageserver_protocol_1.FoldingRangeKind.Region: + return vscode_1.FoldingRangeKind.Region; + } + } + return void 0; + } + static asFoldingRanges(foldingRanges) { + if (Array.isArray(foldingRanges)) { + return foldingRanges.map((r) => { + return new vscode_1.FoldingRange( + r.startLine, + r.endLine, + FoldingRangeFeature.asFoldingRangeKind(r.kind) + ); + }); + } + return []; + } + }; + exports.FoldingRangeFeature = FoldingRangeFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/declaration.js +let require_declaration = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/declaration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DeclarationFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let DeclarationFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super(client, vscode_languageserver_protocol_1.DeclarationRequest.type); + } + fillClientCapabilities(capabilities) { + const declarationSupport = ensure( + ensure(capabilities, 'textDocument'), + 'declaration' + ); + declarationSupport.dynamicRegistration = true; + declarationSupport.linkSupport = true; + } + initialize(capabilities, documentSelector) { + const [id, options] = this.getRegistration( + documentSelector, + capabilities.declarationProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideDeclaration: (document2, position, token) => { + const client = this._client; + const provideDeclaration = (document3, position2, token2) => { + return client + .sendRequest( + vscode_languageserver_protocol_1.DeclarationRequest.type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asDeclarationResult, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.DeclarationRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideDeclaration + ? middleware.provideDeclaration( + document2, + position, + token, + provideDeclaration + ) + : provideDeclaration(document2, position, token); + }, + }; + return [ + vscode_1.languages.registerDeclarationProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.DeclarationFeature = DeclarationFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/selectionRange.js +let require_selectionRange = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/selectionRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SelectionRangeFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = Object.create(null); + } + return target[key]; + } + let SelectionRangeFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.SelectionRangeRequest.type + ); + } + fillClientCapabilities(capabilities) { + const capability = ensure( + ensure(capabilities, 'textDocument'), + 'selectionRange' + ); + capability.dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const [id, options] = this.getRegistration( + documentSelector, + capabilities.selectionRangeProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideSelectionRanges: (document2, positions, token) => { + const client = this._client; + const provideSelectionRanges = (document3, positions2, token2) => { + const requestParams = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + positions: client.code2ProtocolConverter.asPositions( + positions2 + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.SelectionRangeRequest.type, + requestParams, + token2 + ) + .then( + (ranges) => + client.protocol2CodeConverter.asSelectionRanges(ranges), + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.SelectionRangeRequest + .type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideSelectionRanges + ? middleware.provideSelectionRanges( + document2, + positions, + token, + provideSelectionRanges + ) + : provideSelectionRanges(document2, positions, token); + }, + }; + return [ + vscode_1.languages.registerSelectionRangeProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.SelectionRangeFeature = SelectionRangeFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/progress.js +let require_progress = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/progress.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProgressFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let progressPart_1 = require_progressPart(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = Object.create(null); + } + return target[key]; + } + let ProgressFeature = class { + constructor(_client) { + this._client = _client; + this.activeParts = new Set(); + } + fillClientCapabilities(capabilities) { + ensure(capabilities, 'window').workDoneProgress = true; + } + initialize() { + const client = this._client; + const deleteHandler = (part) => { + this.activeParts.delete(part); + }; + const createHandler = (params) => { + this.activeParts.add( + new progressPart_1.ProgressPart( + this._client, + params.token, + deleteHandler + ) + ); + }; + client.onRequest( + vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, + createHandler + ); + } + dispose() { + for (const part of this.activeParts) { + part.done(); + } + this.activeParts.clear(); + } + }; + exports.ProgressFeature = ProgressFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/callHierarchy.js +let require_callHierarchy = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/callHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CallHierarchyFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let CallHierarchyProvider = class { + constructor(client) { + this.client = client; + this.middleware = client.clientOptions.middleware; + } + prepareCallHierarchy(document2, position, token) { + const client = this.client; + const middleware = this.middleware; + const prepareCallHierarchy = (document3, position2, token2) => { + const params = client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ); + return client + .sendRequest( + vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, + params, + token2 + ) + .then( + (result) => { + return client.protocol2CodeConverter.asCallHierarchyItems( + result + ); + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.CallHierarchyPrepareRequest + .type, + token2, + error, + null + ); + } + ); + }; + return middleware.prepareCallHierarchy + ? middleware.prepareCallHierarchy( + document2, + position, + token, + prepareCallHierarchy + ) + : prepareCallHierarchy(document2, position, token); + } + provideCallHierarchyIncomingCalls(item, token) { + const client = this.client; + const middleware = this.middleware; + const provideCallHierarchyIncomingCalls = (item2, token2) => { + const params = { + item: client.code2ProtocolConverter.asCallHierarchyItem(item2), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest + .type, + params, + token2 + ) + .then( + (result) => { + return client.protocol2CodeConverter.asCallHierarchyIncomingCalls( + result + ); + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .CallHierarchyIncomingCallsRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideCallHierarchyIncomingCalls + ? middleware.provideCallHierarchyIncomingCalls( + item, + token, + provideCallHierarchyIncomingCalls + ) + : provideCallHierarchyIncomingCalls(item, token); + } + provideCallHierarchyOutgoingCalls(item, token) { + const client = this.client; + const middleware = this.middleware; + const provideCallHierarchyOutgoingCalls = (item2, token2) => { + const params = { + item: client.code2ProtocolConverter.asCallHierarchyItem(item2), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest + .type, + params, + token2 + ) + .then( + (result) => { + return client.protocol2CodeConverter.asCallHierarchyOutgoingCalls( + result + ); + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1 + .CallHierarchyOutgoingCallsRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideCallHierarchyOutgoingCalls + ? middleware.provideCallHierarchyOutgoingCalls( + item, + token, + provideCallHierarchyOutgoingCalls + ) + : provideCallHierarchyOutgoingCalls(item, token); + } + }; + let CallHierarchyFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type + ); + } + fillClientCapabilities(cap) { + const capabilities = cap; + const capability = ensure( + ensure(capabilities, 'textDocument'), + 'callHierarchy' + ); + capability.dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const [id, options] = this.getRegistration( + documentSelector, + capabilities.callHierarchyProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const client = this._client; + const provider = new CallHierarchyProvider(client); + return [ + vscode_1.languages.registerCallHierarchyProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.CallHierarchyFeature = CallHierarchyFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/semanticTokens.js +let require_semanticTokens = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/semanticTokens.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SemanticTokensFeature = void 0; + let vscode3 = require('vscode'); + let client_1 = require_client(); + let vscode_languageserver_protocol_1 = require_main3(); + let Is2 = require_is3(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let SemanticTokensFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.SemanticTokensRegistrationType.type + ); + } + fillClientCapabilities(capabilities) { + const capability = ensure( + ensure(capabilities, 'textDocument'), + 'semanticTokens' + ); + capability.dynamicRegistration = true; + capability.tokenTypes = [ + vscode_languageserver_protocol_1.SemanticTokenTypes.namespace, + vscode_languageserver_protocol_1.SemanticTokenTypes.type, + vscode_languageserver_protocol_1.SemanticTokenTypes.class, + vscode_languageserver_protocol_1.SemanticTokenTypes.enum, + vscode_languageserver_protocol_1.SemanticTokenTypes.interface, + vscode_languageserver_protocol_1.SemanticTokenTypes.struct, + vscode_languageserver_protocol_1.SemanticTokenTypes.typeParameter, + vscode_languageserver_protocol_1.SemanticTokenTypes.parameter, + vscode_languageserver_protocol_1.SemanticTokenTypes.variable, + vscode_languageserver_protocol_1.SemanticTokenTypes.property, + vscode_languageserver_protocol_1.SemanticTokenTypes.enumMember, + vscode_languageserver_protocol_1.SemanticTokenTypes.event, + vscode_languageserver_protocol_1.SemanticTokenTypes.function, + vscode_languageserver_protocol_1.SemanticTokenTypes.method, + vscode_languageserver_protocol_1.SemanticTokenTypes.macro, + vscode_languageserver_protocol_1.SemanticTokenTypes.keyword, + vscode_languageserver_protocol_1.SemanticTokenTypes.modifier, + vscode_languageserver_protocol_1.SemanticTokenTypes.comment, + vscode_languageserver_protocol_1.SemanticTokenTypes.string, + vscode_languageserver_protocol_1.SemanticTokenTypes.number, + vscode_languageserver_protocol_1.SemanticTokenTypes.regexp, + vscode_languageserver_protocol_1.SemanticTokenTypes.operator, + vscode_languageserver_protocol_1.SemanticTokenTypes.decorator, + ]; + capability.tokenModifiers = [ + vscode_languageserver_protocol_1.SemanticTokenModifiers.declaration, + vscode_languageserver_protocol_1.SemanticTokenModifiers.definition, + vscode_languageserver_protocol_1.SemanticTokenModifiers.readonly, + vscode_languageserver_protocol_1.SemanticTokenModifiers.static, + vscode_languageserver_protocol_1.SemanticTokenModifiers.deprecated, + vscode_languageserver_protocol_1.SemanticTokenModifiers.abstract, + vscode_languageserver_protocol_1.SemanticTokenModifiers.async, + vscode_languageserver_protocol_1.SemanticTokenModifiers.modification, + vscode_languageserver_protocol_1.SemanticTokenModifiers.documentation, + vscode_languageserver_protocol_1.SemanticTokenModifiers + .defaultLibrary, + ]; + capability.formats = [ + vscode_languageserver_protocol_1.TokenFormat.Relative, + ]; + capability.requests = { + range: true, + full: { + delta: true, + }, + }; + capability.multilineTokenSupport = false; + capability.overlappingTokenSupport = false; + capability.serverCancelSupport = true; + capability.augmentsSyntaxTokens = true; + ensure( + ensure(capabilities, 'workspace'), + 'semanticTokens' + ).refreshSupport = true; + } + initialize(capabilities, documentSelector) { + const client = this._client; + client.onRequest( + vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type, + async () => { + for (const provider of this.getAllProviders()) { + provider.onDidChangeSemanticTokensEmitter.fire(); + } + } + ); + const [id, options] = this.getRegistration( + documentSelector, + capabilities.semanticTokensProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const fullProvider = Is2.boolean(options.full) + ? options.full + : options.full !== void 0; + const hasEditProvider = + options.full !== void 0 && + typeof options.full !== 'boolean' && + options.full.delta === true; + const eventEmitter = new vscode3.EventEmitter(); + const documentProvider = fullProvider + ? { + onDidChangeSemanticTokens: eventEmitter.event, + provideDocumentSemanticTokens: (document2, token) => { + const client2 = this._client; + const middleware = client2.clientOptions.middleware; + const provideDocumentSemanticTokens = (document3, token2) => { + const params = { + textDocument: client2.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + }; + return client2 + .sendRequest( + vscode_languageserver_protocol_1.SemanticTokensRequest + .type, + params, + token2 + ) + .then( + (result) => { + return client2.protocol2CodeConverter.asSemanticTokens( + result + ); + }, + (error) => { + return client2.handleFailedRequest( + vscode_languageserver_protocol_1.SemanticTokensRequest + .type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideDocumentSemanticTokens + ? middleware.provideDocumentSemanticTokens( + document2, + token, + provideDocumentSemanticTokens + ) + : provideDocumentSemanticTokens(document2, token); + }, + provideDocumentSemanticTokensEdits: hasEditProvider + ? (document2, previousResultId, token) => { + const client2 = this._client; + const middleware = client2.clientOptions.middleware; + const provideDocumentSemanticTokensEdits = ( + document3, + previousResultId2, + token2 + ) => { + const params = { + textDocument: client2.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + previousResultId: previousResultId2, + }; + return client2 + .sendRequest( + vscode_languageserver_protocol_1 + .SemanticTokensDeltaRequest.type, + params, + token2 + ) + .then( + (result) => { + if ( + vscode_languageserver_protocol_1.SemanticTokens.is( + result + ) + ) { + return client2.protocol2CodeConverter.asSemanticTokens( + result + ); + } else { + return client2.protocol2CodeConverter.asSemanticTokensEdits( + result + ); + } + }, + (error) => { + return client2.handleFailedRequest( + vscode_languageserver_protocol_1 + .SemanticTokensDeltaRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideDocumentSemanticTokensEdits + ? middleware.provideDocumentSemanticTokensEdits( + document2, + previousResultId, + token, + provideDocumentSemanticTokensEdits + ) + : provideDocumentSemanticTokensEdits( + document2, + previousResultId, + token + ); + } + : void 0, + } + : void 0; + const hasRangeProvider = options.range === true; + const rangeProvider = hasRangeProvider + ? { + provideDocumentRangeSemanticTokens: (document2, range, token) => { + const client2 = this._client; + const middleware = client2.clientOptions.middleware; + const provideDocumentRangeSemanticTokens = ( + document3, + range2, + token2 + ) => { + const params = { + textDocument: client2.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + range: client2.code2ProtocolConverter.asRange(range2), + }; + return client2 + .sendRequest( + vscode_languageserver_protocol_1 + .SemanticTokensRangeRequest.type, + params, + token2 + ) + .then( + (result) => { + return client2.protocol2CodeConverter.asSemanticTokens( + result + ); + }, + (error) => { + return client2.handleFailedRequest( + vscode_languageserver_protocol_1 + .SemanticTokensRangeRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideDocumentRangeSemanticTokens + ? middleware.provideDocumentRangeSemanticTokens( + document2, + range, + token, + provideDocumentRangeSemanticTokens + ) + : provideDocumentRangeSemanticTokens(document2, range, token); + }, + } + : void 0; + const disposables = []; + const client = this._client; + const legend = client.protocol2CodeConverter.asSemanticTokensLegend( + options.legend + ); + if (documentProvider !== void 0) { + disposables.push( + vscode3.languages.registerDocumentSemanticTokensProvider( + options.documentSelector, + documentProvider, + legend + ) + ); + } + if (rangeProvider !== void 0) { + disposables.push( + vscode3.languages.registerDocumentRangeSemanticTokensProvider( + options.documentSelector, + rangeProvider, + legend + ) + ); + } + return [ + new vscode3.Disposable(() => + disposables.forEach((item) => item.dispose()) + ), + { + range: rangeProvider, + full: documentProvider, + onDidChangeSemanticTokensEmitter: eventEmitter, + }, + ]; + } + }; + exports.SemanticTokensFeature = SemanticTokensFeature; + }, +}); + +// client/node_modules/concat-map/index.js +let require_concat_map = __commonJS({ + 'client/node_modules/concat-map/index.js'(exports, module2) { + module2.exports = function (xs2, fn2) { + let res = []; + for (let i = 0; i < xs2.length; i++) { + let x2 = fn2(xs2[i], i); + if (isArray(x2)) { + res.push.apply(res, x2); + } else { + res.push(x2); + } + } + return res; + }; + var isArray = + Array.isArray || + function (xs2) { + return Object.prototype.toString.call(xs2) === '[object Array]'; + }; + }, +}); + +// client/node_modules/balanced-match/index.js +let require_balanced_match = __commonJS({ + 'client/node_modules/balanced-match/index.js'(exports, module2) { + 'use strict'; + module2.exports = balanced; + function balanced(a, b, str) { + if (a instanceof RegExp) { + a = maybeMatch(a, str); + } + if (b instanceof RegExp) { + b = maybeMatch(b, str); + } + let r = range(a, b, str); + return ( + r && { + start: r[0], + end: r[1], + pre: str.slice(0, r[0]), + body: str.slice(r[0] + a.length, r[1]), + post: str.slice(r[1] + b.length), + } + ); + } + function maybeMatch(reg, str) { + let m = str.match(reg); + return m ? m[0] : null; + } + balanced.range = range; + function range(a, b, str) { + let begs, beg, left, right, result; + let ai2 = str.indexOf(a); + let bi2 = str.indexOf(b, ai2 + 1); + let i = ai2; + if (ai2 >= 0 && bi2 > 0) { + if (a === b) { + return [ai2, bi2]; + } + begs = []; + left = str.length; + while (i >= 0 && !result) { + if (i == ai2) { + begs.push(i); + ai2 = str.indexOf(a, i + 1); + } else if (begs.length == 1) { + result = [begs.pop(), bi2]; + } else { + beg = begs.pop(); + if (beg < left) { + left = beg; + right = bi2; + } + bi2 = str.indexOf(b, i + 1); + } + i = ai2 < bi2 && ai2 >= 0 ? ai2 : bi2; + } + if (begs.length) { + result = [left, right]; + } + } + return result; + } + }, +}); + +// client/node_modules/brace-expansion/index.js +let require_brace_expansion = __commonJS({ + 'client/node_modules/brace-expansion/index.js'(exports, module2) { + let concatMap = require_concat_map(); + let balanced = require_balanced_match(); + module2.exports = expandTop; + let escSlash = '\0SLASH' + Math.random() + '\0'; + let escOpen = '\0OPEN' + Math.random() + '\0'; + let escClose = '\0CLOSE' + Math.random() + '\0'; + let escComma = '\0COMMA' + Math.random() + '\0'; + let escPeriod = '\0PERIOD' + Math.random() + '\0'; + function numeric(str) { + return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0); + } + function escapeBraces(str) { + return str + .split('\\\\') + .join(escSlash) + .split('\\{') + .join(escOpen) + .split('\\}') + .join(escClose) + .split('\\,') + .join(escComma) + .split('\\.') + .join(escPeriod); + } + function unescapeBraces(str) { + return str + .split(escSlash) + .join('\\') + .split(escOpen) + .join('{') + .split(escClose) + .join('}') + .split(escComma) + .join(',') + .split(escPeriod) + .join('.'); + } + function parseCommaParts(str) { + if (!str) { + return ['']; + } + let parts = []; + let m = balanced('{', '}', str); + if (!m) { + return str.split(','); + } + let pre = m.pre; + let body = m.body; + let post = m.post; + let p = pre.split(','); + p[p.length - 1] += '{' + body + '}'; + let postParts = parseCommaParts(post); + if (post.length) { + p[p.length - 1] += postParts.shift(); + p.push.apply(p, postParts); + } + parts.push.apply(parts, p); + return parts; + } + function expandTop(str) { + if (!str) { + return []; + } + if (str.substr(0, 2) === '{}') { + str = '\\{\\}' + str.substr(2); + } + return expand(escapeBraces(str), true).map(unescapeBraces); + } + function embrace(str) { + return '{' + str + '}'; + } + function isPadded(el2) { + return /^-?0\d/.test(el2); + } + function lte(i, y) { + return i <= y; + } + function gte(i, y) { + return i >= y; + } + function expand(str, isTop) { + let expansions = []; + let m = balanced('{', '}', str); + if (!m || /\$$/.test(m.pre)) { + return [str]; + } + let isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); + let isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); + let isSequence = isNumericSequence || isAlphaSequence; + let isOptions = m.body.indexOf(',') >= 0; + if (!isSequence && !isOptions) { + if (m.post.match(/,.*\}/)) { + str = m.pre + '{' + m.body + escClose + m.post; + return expand(str); + } + return [str]; + } + let n; + if (isSequence) { + n = m.body.split(/\.\./); + } else { + n = parseCommaParts(m.body); + if (n.length === 1) { + n = expand(n[0], false).map(embrace); + if (n.length === 1) { + var post = m.post.length ? expand(m.post, false) : ['']; + return post.map(function (p) { + return m.pre + n[0] + p; + }); + } + } + } + let pre = m.pre; + var post = m.post.length ? expand(m.post, false) : ['']; + let N; + if (isSequence) { + let x2 = numeric(n[0]); + let y = numeric(n[1]); + let width = Math.max(n[0].length, n[1].length); + let incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1; + let test = lte; + let reverse = y < x2; + if (reverse) { + incr *= -1; + test = gte; + } + let pad = n.some(isPadded); + N = []; + for (let i = x2; test(i, y); i += incr) { + var c; + if (isAlphaSequence) { + c = String.fromCharCode(i); + if (c === '\\') { + c = ''; + } + } else { + c = String(i); + if (pad) { + let need = width - c.length; + if (need > 0) { + let z = new Array(need + 1).join('0'); + if (i < 0) { + c = '-' + z + c.slice(1); + } else { + c = z + c; + } + } + } + } + N.push(c); + } + } else { + N = concatMap(n, function (el2) { + return expand(el2, false); + }); + } + for (let j2 = 0; j2 < N.length; j2++) { + for (let k = 0; k < post.length; k++) { + let expansion = pre + N[j2] + post[k]; + if (!isTop || isSequence || expansion) { + expansions.push(expansion); + } + } + } + return expansions; + } + }, +}); + +// client/node_modules/minimatch/minimatch.js +let require_minimatch = __commonJS({ + 'client/node_modules/minimatch/minimatch.js'(exports, module2) { + module2.exports = minimatch; + minimatch.Minimatch = Minimatch; + let path = { sep: '/' }; + try { + path = require('path'); + } catch (er2) {} + let GLOBSTAR = (minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}); + let expand = require_brace_expansion(); + let plTypes = { + '!': { open: '(?:(?!(?:', close: '))[^/]*?)' }, + '?': { open: '(?:', close: ')?' }, + '+': { open: '(?:', close: ')+' }, + '*': { open: '(?:', close: ')*' }, + '@': { open: '(?:', close: ')' }, + }; + let qmark = '[^/]'; + let star = qmark + '*?'; + let twoStarDot = '(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?'; + let twoStarNoDot = '(?:(?!(?:\\/|^)\\.).)*?'; + let reSpecials = charSet('().*{}+?[]^$\\!'); + function charSet(s) { + return s.split('').reduce(function (set, c) { + set[c] = true; + return set; + }, {}); + } + let slashSplit = /\/+/; + minimatch.filter = filter; + function filter(pattern, options) { + options = options || {}; + return function (p, i, list) { + return minimatch(p, pattern, options); + }; + } + function ext(a, b) { + a = a || {}; + b = b || {}; + let t = {}; + Object.keys(b).forEach(function (k) { + t[k] = b[k]; + }); + Object.keys(a).forEach(function (k) { + t[k] = a[k]; + }); + return t; + } + minimatch.defaults = function (def) { + if (!def || !Object.keys(def).length) { + return minimatch; + } + let orig = minimatch; + let m = function minimatch2(p, pattern, options) { + return orig.minimatch(p, pattern, ext(def, options)); + }; + m.Minimatch = function Minimatch2(pattern, options) { + return new orig.Minimatch(pattern, ext(def, options)); + }; + return m; + }; + Minimatch.defaults = function (def) { + if (!def || !Object.keys(def).length) { + return Minimatch; + } + return minimatch.defaults(def).Minimatch; + }; + function minimatch(p, pattern, options) { + if (typeof pattern !== 'string') { + throw new TypeError('glob pattern string required'); + } + if (!options) { + options = {}; + } + if (!options.nocomment && pattern.charAt(0) === '#') { + return false; + } + if (pattern.trim() === '') { + return p === ''; + } + return new Minimatch(pattern, options).match(p); + } + function Minimatch(pattern, options) { + if (!(this instanceof Minimatch)) { + return new Minimatch(pattern, options); + } + if (typeof pattern !== 'string') { + throw new TypeError('glob pattern string required'); + } + if (!options) { + options = {}; + } + pattern = pattern.trim(); + if (path.sep !== '/') { + pattern = pattern.split(path.sep).join('/'); + } + this.options = options; + this.set = []; + this.pattern = pattern; + this.regexp = null; + this.negate = false; + this.comment = false; + this.empty = false; + this.make(); + } + Minimatch.prototype.debug = function () {}; + Minimatch.prototype.make = make; + function make() { + if (this._made) { + return; + } + let pattern = this.pattern; + let options = this.options; + if (!options.nocomment && pattern.charAt(0) === '#') { + this.comment = true; + return; + } + if (!pattern) { + this.empty = true; + return; + } + this.parseNegate(); + let set = (this.globSet = this.braceExpand()); + if (options.debug) { + this.debug = console.error; + } + this.debug(this.pattern, set); + set = this.globParts = set.map(function (s) { + return s.split(slashSplit); + }); + this.debug(this.pattern, set); + set = set.map(function (s, si2, set2) { + return s.map(this.parse, this); + }, this); + this.debug(this.pattern, set); + set = set.filter(function (s) { + return s.indexOf(false) === -1; + }); + this.debug(this.pattern, set); + this.set = set; + } + Minimatch.prototype.parseNegate = parseNegate; + function parseNegate() { + let pattern = this.pattern; + let negate = false; + let options = this.options; + let negateOffset = 0; + if (options.nonegate) { + return; + } + for ( + let i = 0, l = pattern.length; + i < l && pattern.charAt(i) === '!'; + i++ + ) { + negate = !negate; + negateOffset++; + } + if (negateOffset) { + this.pattern = pattern.substr(negateOffset); + } + this.negate = negate; + } + minimatch.braceExpand = function (pattern, options) { + return braceExpand(pattern, options); + }; + Minimatch.prototype.braceExpand = braceExpand; + function braceExpand(pattern, options) { + if (!options) { + if (this instanceof Minimatch) { + options = this.options; + } else { + options = {}; + } + } + pattern = typeof pattern === 'undefined' ? this.pattern : pattern; + if (typeof pattern === 'undefined') { + throw new TypeError('undefined pattern'); + } + if (options.nobrace || !pattern.match(/\{.*\}/)) { + return [pattern]; + } + return expand(pattern); + } + Minimatch.prototype.parse = parse; + let SUBPARSE = {}; + function parse(pattern, isSub) { + if (pattern.length > 1024 * 64) { + throw new TypeError('pattern is too long'); + } + let options = this.options; + if (!options.noglobstar && pattern === '**') { + return GLOBSTAR; + } + if (pattern === '') { + return ''; + } + let re2 = ''; + let hasMagic = !!options.nocase; + let escaping = false; + let patternListStack = []; + let negativeLists = []; + let stateChar; + let inClass = false; + let reClassStart = -1; + let classStart = -1; + let patternStart = + pattern.charAt(0) === '.' + ? '' + : options.dot + ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))' + : '(?!\\.)'; + let self2 = this; + function clearStateChar() { + if (stateChar) { + switch (stateChar) { + case '*': + re2 += star; + hasMagic = true; + break; + case '?': + re2 += qmark; + hasMagic = true; + break; + default: + re2 += '\\' + stateChar; + break; + } + self2.debug('clearStateChar %j %j', stateChar, re2); + stateChar = false; + } + } + for ( + var i = 0, len = pattern.length, c; + i < len && (c = pattern.charAt(i)); + i++ + ) { + this.debug('%s %s %s %j', pattern, i, re2, c); + if (escaping && reSpecials[c]) { + re2 += '\\' + c; + escaping = false; + continue; + } + switch (c) { + case '/': + return false; + case '\\': + clearStateChar(); + escaping = true; + continue; + case '?': + case '*': + case '+': + case '@': + case '!': + this.debug('%s %s %s %j <-- stateChar', pattern, i, re2, c); + if (inClass) { + this.debug(' in class'); + if (c === '!' && i === classStart + 1) { + c = '^'; + } + re2 += c; + continue; + } + self2.debug('call clearStateChar %j', stateChar); + clearStateChar(); + stateChar = c; + if (options.noext) { + clearStateChar(); + } + continue; + case '(': + if (inClass) { + re2 += '('; + continue; + } + if (!stateChar) { + re2 += '\\('; + continue; + } + patternListStack.push({ + type: stateChar, + start: i - 1, + reStart: re2.length, + open: plTypes[stateChar].open, + close: plTypes[stateChar].close, + }); + re2 += stateChar === '!' ? '(?:(?!(?:' : '(?:'; + this.debug('plType %j %j', stateChar, re2); + stateChar = false; + continue; + case ')': + if (inClass || !patternListStack.length) { + re2 += '\\)'; + continue; + } + clearStateChar(); + hasMagic = true; + var pl2 = patternListStack.pop(); + re2 += pl2.close; + if (pl2.type === '!') { + negativeLists.push(pl2); + } + pl2.reEnd = re2.length; + continue; + case '|': + if (inClass || !patternListStack.length || escaping) { + re2 += '\\|'; + escaping = false; + continue; + } + clearStateChar(); + re2 += '|'; + continue; + case '[': + clearStateChar(); + if (inClass) { + re2 += '\\' + c; + continue; + } + inClass = true; + classStart = i; + reClassStart = re2.length; + re2 += c; + continue; + case ']': + if (i === classStart + 1 || !inClass) { + re2 += '\\' + c; + escaping = false; + continue; + } + if (inClass) { + var cs2 = pattern.substring(classStart + 1, i); + try { + RegExp('[' + cs2 + ']'); + } catch (er2) { + var sp = this.parse(cs2, SUBPARSE); + re2 = re2.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'; + hasMagic = hasMagic || sp[1]; + inClass = false; + continue; + } + } + hasMagic = true; + inClass = false; + re2 += c; + continue; + default: + clearStateChar(); + if (escaping) { + escaping = false; + } else if (reSpecials[c] && !(c === '^' && inClass)) { + re2 += '\\'; + } + re2 += c; + } + } + if (inClass) { + cs2 = pattern.substr(classStart + 1); + sp = this.parse(cs2, SUBPARSE); + re2 = re2.substr(0, reClassStart) + '\\[' + sp[0]; + hasMagic = hasMagic || sp[1]; + } + for (pl2 = patternListStack.pop(); pl2; pl2 = patternListStack.pop()) { + let tail = re2.slice(pl2.reStart + pl2.open.length); + this.debug('setting tail', re2, pl2); + tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_2, $1, $2) { + if (!$2) { + $2 = '\\'; + } + return $1 + $1 + $2 + '|'; + }); + this.debug('tail=%j\n %s', tail, tail, pl2, re2); + let t = + pl2.type === '*' ? star : pl2.type === '?' ? qmark : '\\' + pl2.type; + hasMagic = true; + re2 = re2.slice(0, pl2.reStart) + t + '\\(' + tail; + } + clearStateChar(); + if (escaping) { + re2 += '\\\\'; + } + let addPatternStart = false; + switch (re2.charAt(0)) { + case '.': + case '[': + case '(': + addPatternStart = true; + } + for (let n = negativeLists.length - 1; n > -1; n--) { + let nl2 = negativeLists[n]; + let nlBefore = re2.slice(0, nl2.reStart); + let nlFirst = re2.slice(nl2.reStart, nl2.reEnd - 8); + let nlLast = re2.slice(nl2.reEnd - 8, nl2.reEnd); + let nlAfter = re2.slice(nl2.reEnd); + nlLast += nlAfter; + let openParensBefore = nlBefore.split('(').length - 1; + let cleanAfter = nlAfter; + for (i = 0; i < openParensBefore; i++) { + cleanAfter = cleanAfter.replace(/\)[+*?]?/, ''); + } + nlAfter = cleanAfter; + let dollar = ''; + if (nlAfter === '' && isSub !== SUBPARSE) { + dollar = '$'; + } + let newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast; + re2 = newRe; + } + if (re2 !== '' && hasMagic) { + re2 = '(?=.)' + re2; + } + if (addPatternStart) { + re2 = patternStart + re2; + } + if (isSub === SUBPARSE) { + return [re2, hasMagic]; + } + if (!hasMagic) { + return globUnescape(pattern); + } + let flags = options.nocase ? 'i' : ''; + try { + var regExp = new RegExp('^' + re2 + '$', flags); + } catch (er2) { + return new RegExp('$.'); + } + regExp._glob = pattern; + regExp._src = re2; + return regExp; + } + minimatch.makeRe = function (pattern, options) { + return new Minimatch(pattern, options || {}).makeRe(); + }; + Minimatch.prototype.makeRe = makeRe; + function makeRe() { + if (this.regexp || this.regexp === false) { + return this.regexp; + } + let set = this.set; + if (!set.length) { + this.regexp = false; + return this.regexp; + } + let options = this.options; + let twoStar = options.noglobstar + ? star + : options.dot + ? twoStarDot + : twoStarNoDot; + let flags = options.nocase ? 'i' : ''; + let re2 = set + .map(function (pattern) { + return pattern + .map(function (p) { + return p === GLOBSTAR + ? twoStar + : typeof p === 'string' + ? regExpEscape(p) + : p._src; + }) + .join('\\/'); + }) + .join('|'); + re2 = '^(?:' + re2 + ')$'; + if (this.negate) { + re2 = '^(?!' + re2 + ').*$'; + } + try { + this.regexp = new RegExp(re2, flags); + } catch (ex) { + this.regexp = false; + } + return this.regexp; + } + minimatch.match = function (list, pattern, options) { + options = options || {}; + let mm = new Minimatch(pattern, options); + list = list.filter(function (f) { + return mm.match(f); + }); + if (mm.options.nonull && !list.length) { + list.push(pattern); + } + return list; + }; + Minimatch.prototype.match = match; + function match(f, partial) { + this.debug('match', f, this.pattern); + if (this.comment) { + return false; + } + if (this.empty) { + return f === ''; + } + if (f === '/' && partial) { + return true; + } + let options = this.options; + if (path.sep !== '/') { + f = f.split(path.sep).join('/'); + } + f = f.split(slashSplit); + this.debug(this.pattern, 'split', f); + let set = this.set; + this.debug(this.pattern, 'set', set); + let filename; + let i; + for (i = f.length - 1; i >= 0; i--) { + filename = f[i]; + if (filename) { + break; + } + } + for (i = 0; i < set.length; i++) { + let pattern = set[i]; + let file = f; + if (options.matchBase && pattern.length === 1) { + file = [filename]; + } + let hit = this.matchOne(file, pattern, partial); + if (hit) { + if (options.flipNegate) { + return true; + } + return !this.negate; + } + } + if (options.flipNegate) { + return false; + } + return this.negate; + } + Minimatch.prototype.matchOne = function (file, pattern, partial) { + let options = this.options; + this.debug('matchOne', { this: this, file, pattern }); + this.debug('matchOne', file.length, pattern.length); + for ( + var fi2 = 0, pi2 = 0, fl2 = file.length, pl2 = pattern.length; + fi2 < fl2 && pi2 < pl2; + fi2++, pi2++ + ) { + this.debug('matchOne loop'); + let p = pattern[pi2]; + let f = file[fi2]; + this.debug(pattern, p, f); + if (p === false) { + return false; + } + if (p === GLOBSTAR) { + this.debug('GLOBSTAR', [pattern, p, f]); + let fr2 = fi2; + let pr2 = pi2 + 1; + if (pr2 === pl2) { + this.debug('** at the end'); + for (; fi2 < fl2; fi2++) { + if ( + file[fi2] === '.' || + file[fi2] === '..' || + (!options.dot && file[fi2].charAt(0) === '.') + ) { + return false; + } + } + return true; + } + while (fr2 < fl2) { + let swallowee = file[fr2]; + this.debug('\nglobstar while', file, fr2, pattern, pr2, swallowee); + if (this.matchOne(file.slice(fr2), pattern.slice(pr2), partial)) { + this.debug('globstar found match!', fr2, fl2, swallowee); + return true; + } else { + if ( + swallowee === '.' || + swallowee === '..' || + (!options.dot && swallowee.charAt(0) === '.') + ) { + this.debug('dot detected!', file, fr2, pattern, pr2); + break; + } + this.debug('globstar swallow a segment, and continue'); + fr2++; + } + } + if (partial) { + this.debug('\n>>> no match, partial?', file, fr2, pattern, pr2); + if (fr2 === fl2) { + return true; + } + } + return false; + } + var hit; + if (typeof p === 'string') { + if (options.nocase) { + hit = f.toLowerCase() === p.toLowerCase(); + } else { + hit = f === p; + } + this.debug('string match', p, f, hit); + } else { + hit = f.match(p); + this.debug('pattern match', p, f, hit); + } + if (!hit) { + return false; + } + } + if (fi2 === fl2 && pi2 === pl2) { + return true; + } else if (fi2 === fl2) { + return partial; + } else if (pi2 === pl2) { + let emptyFileEnd = fi2 === fl2 - 1 && file[fi2] === ''; + return emptyFileEnd; + } + throw new Error('wtf?'); + }; + function globUnescape(s) { + return s.replace(/\\(.)/g, '$1'); + } + function regExpEscape(s) { + return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&'); + } + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/fileOperations.js +let require_fileOperations = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/fileOperations.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WillDeleteFilesFeature = exports.WillRenameFilesFeature = exports.WillCreateFilesFeature = exports.DidDeleteFilesFeature = exports.DidRenameFilesFeature = exports.DidCreateFilesFeature = void 0; + let code = require('vscode'); + let minimatch = require_minimatch(); + let proto = require_main3(); + let UUID = require_uuid(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + function access(target, key) { + return target[key]; + } + function assign(target, key, value) { + target[key] = value; + } + var FileOperationFeature = class { + constructor( + client, + event, + registrationType, + clientCapability, + serverCapability + ) { + this._filters = new Map(); + this._client = client; + this._event = event; + this._registrationType = registrationType; + this._clientCapability = clientCapability; + this._serverCapability = serverCapability; + } + get registrationType() { + return this._registrationType; + } + fillClientCapabilities(capabilities) { + const value = ensure( + ensure(capabilities, 'workspace'), + 'fileOperations' + ); + assign(value, 'dynamicRegistration', true); + assign(value, this._clientCapability, true); + } + initialize(capabilities) { + const options = capabilities.workspace?.fileOperations; + const capability = + options !== void 0 ? access(options, this._serverCapability) : void 0; + if (capability?.filters !== void 0) { + try { + this.register({ + id: UUID.generateUuid(), + registerOptions: { filters: capability.filters }, + }); + } catch (e) { + this._client.warn( + `Ignoring invalid glob pattern for ${this._serverCapability} registration: ${e}` + ); + } + } + } + register(data) { + if (!this._listener) { + this._listener = this._event(this.send, this); + } + const minimatchFilter = data.registerOptions.filters.map((filter) => { + const matcher = new minimatch.Minimatch( + filter.pattern.glob, + FileOperationFeature.asMinimatchOptions(filter.pattern.options) + ); + if (!matcher.makeRe()) { + throw new Error(`Invalid pattern ${filter.pattern.glob}!`); + } + return { + scheme: filter.scheme, + matcher, + kind: filter.pattern.matches, + }; + }); + this._filters.set(data.id, minimatchFilter); + } + unregister(id) { + this._filters.delete(id); + if (this._filters.size === 0 && this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + dispose() { + this._filters.clear(); + if (this._listener) { + this._listener.dispose(); + this._listener = void 0; + } + } + getFileType(uri) { + return FileOperationFeature.getFileType(uri); + } + async filter(event, prop) { + const fileMatches = await Promise.all( + event.files.map(async (item) => { + const uri = prop(item); + const path = uri.fsPath.replace(/\\/g, '/'); + for (const filters of this._filters.values()) { + for (const filter of filters) { + if (filter.scheme !== void 0 && filter.scheme !== uri.scheme) { + continue; + } + if (filter.matcher.match(path)) { + if (filter.kind === void 0) { + return true; + } + const fileType = await this.getFileType(uri); + if (fileType === void 0) { + this._client.error( + `Failed to determine file type for ${uri.toString()}.` + ); + return true; + } + if ( + (fileType === code.FileType.File && + filter.kind === proto.FileOperationPatternKind.file) || + (fileType === code.FileType.Directory && + filter.kind === proto.FileOperationPatternKind.folder) + ) { + return true; + } + } else if ( + filter.kind === proto.FileOperationPatternKind.folder + ) { + const fileType = await FileOperationFeature.getFileType(uri); + if ( + fileType === code.FileType.Directory && + filter.matcher.match(`${path}/`) + ) { + return true; + } + } + } + } + return false; + }) + ); + const files = event.files.filter((_2, index) => fileMatches[index]); + return { ...event, files }; + } + static async getFileType(uri) { + try { + return (await code.workspace.fs.stat(uri)).type; + } catch (e) { + return void 0; + } + } + static asMinimatchOptions(options) { + if (options === void 0) { + return void 0; + } + if (options.ignoreCase === true) { + return { nocase: true }; + } + return void 0; + } + }; + let NotificationFileOperationFeature = class extends FileOperationFeature { + constructor( + client, + event, + notificationType, + clientCapability, + serverCapability, + accessUri, + createParams + ) { + super( + client, + event, + notificationType, + clientCapability, + serverCapability + ); + this._notificationType = notificationType; + this._accessUri = accessUri; + this._createParams = createParams; + } + async send(originalEvent) { + const filteredEvent = await this.filter(originalEvent, this._accessUri); + if (filteredEvent.files.length) { + const next = async (event) => { + return this._client.sendNotification( + this._notificationType, + this._createParams(event) + ); + }; + return this.doSend(filteredEvent, next); + } + } + }; + let CachingNotificationFileOperationFeature = class extends NotificationFileOperationFeature { + constructor() { + super(...arguments); + this._fsPathFileTypes = new Map(); + } + async getFileType(uri) { + const fsPath = uri.fsPath; + if (this._fsPathFileTypes.has(fsPath)) { + return this._fsPathFileTypes.get(fsPath); + } + const type = await FileOperationFeature.getFileType(uri); + if (type) { + this._fsPathFileTypes.set(fsPath, type); + } + return type; + } + async cacheFileTypes(event, prop) { + await this.filter(event, prop); + } + clearFileTypeCache() { + this._fsPathFileTypes.clear(); + } + unregister(id) { + super.unregister(id); + if (this._filters.size === 0 && this._willListener) { + this._willListener.dispose(); + this._willListener = void 0; + } + } + dispose() { + super.dispose(); + if (this._willListener) { + this._willListener.dispose(); + this._willListener = void 0; + } + } + }; + let DidCreateFilesFeature = class extends NotificationFileOperationFeature { + constructor(client) { + super( + client, + code.workspace.onDidCreateFiles, + proto.DidCreateFilesNotification.type, + 'didCreate', + 'didCreate', + (i) => i, + client.code2ProtocolConverter.asDidCreateFilesParams + ); + } + doSend(event, next) { + const middleware = this._client.clientOptions.middleware?.workspace; + return middleware?.didCreateFiles + ? middleware.didCreateFiles(event, next) + : next(event); + } + }; + exports.DidCreateFilesFeature = DidCreateFilesFeature; + let DidRenameFilesFeature = class extends CachingNotificationFileOperationFeature { + constructor(client) { + super( + client, + code.workspace.onDidRenameFiles, + proto.DidRenameFilesNotification.type, + 'didRename', + 'didRename', + (i) => i.oldUri, + client.code2ProtocolConverter.asDidRenameFilesParams + ); + } + register(data) { + if (!this._willListener) { + this._willListener = code.workspace.onWillRenameFiles( + this.willRename, + this + ); + } + super.register(data); + } + willRename(e) { + e.waitUntil(this.cacheFileTypes(e, (i) => i.oldUri)); + } + doSend(event, next) { + this.clearFileTypeCache(); + const middleware = this._client.clientOptions.middleware?.workspace; + return middleware?.didRenameFiles + ? middleware.didRenameFiles(event, next) + : next(event); + } + }; + exports.DidRenameFilesFeature = DidRenameFilesFeature; + let DidDeleteFilesFeature = class extends CachingNotificationFileOperationFeature { + constructor(client) { + super( + client, + code.workspace.onDidDeleteFiles, + proto.DidDeleteFilesNotification.type, + 'didDelete', + 'didDelete', + (i) => i, + client.code2ProtocolConverter.asDidDeleteFilesParams + ); + } + register(data) { + if (!this._willListener) { + this._willListener = code.workspace.onWillDeleteFiles( + this.willDelete, + this + ); + } + super.register(data); + } + willDelete(e) { + e.waitUntil(this.cacheFileTypes(e, (i) => i)); + } + doSend(event, next) { + this.clearFileTypeCache(); + const middleware = this._client.clientOptions.middleware?.workspace; + return middleware?.didDeleteFiles + ? middleware.didDeleteFiles(event, next) + : next(event); + } + }; + exports.DidDeleteFilesFeature = DidDeleteFilesFeature; + let RequestFileOperationFeature = class extends FileOperationFeature { + constructor( + client, + event, + requestType, + clientCapability, + serverCapability, + accessUri, + createParams + ) { + super(client, event, requestType, clientCapability, serverCapability); + this._requestType = requestType; + this._accessUri = accessUri; + this._createParams = createParams; + } + async send(originalEvent) { + const waitUntil = this.waitUntil(originalEvent); + originalEvent.waitUntil(waitUntil); + } + async waitUntil(originalEvent) { + const filteredEvent = await this.filter(originalEvent, this._accessUri); + if (filteredEvent.files.length) { + const next = (event) => { + return this._client + .sendRequest(this._requestType, this._createParams(event)) + .then(this._client.protocol2CodeConverter.asWorkspaceEdit); + }; + return this.doSend(filteredEvent, next); + } else { + return void 0; + } + } + }; + let WillCreateFilesFeature = class extends RequestFileOperationFeature { + constructor(client) { + super( + client, + code.workspace.onWillCreateFiles, + proto.WillCreateFilesRequest.type, + 'willCreate', + 'willCreate', + (i) => i, + client.code2ProtocolConverter.asWillCreateFilesParams + ); + } + doSend(event, next) { + const middleware = this._client.clientOptions.middleware?.workspace; + return middleware?.willCreateFiles + ? middleware.willCreateFiles(event, next) + : next(event); + } + }; + exports.WillCreateFilesFeature = WillCreateFilesFeature; + let WillRenameFilesFeature = class extends RequestFileOperationFeature { + constructor(client) { + super( + client, + code.workspace.onWillRenameFiles, + proto.WillRenameFilesRequest.type, + 'willRename', + 'willRename', + (i) => i.oldUri, + client.code2ProtocolConverter.asWillRenameFilesParams + ); + } + doSend(event, next) { + const middleware = this._client.clientOptions.middleware?.workspace; + return middleware?.willRenameFiles + ? middleware.willRenameFiles(event, next) + : next(event); + } + }; + exports.WillRenameFilesFeature = WillRenameFilesFeature; + let WillDeleteFilesFeature = class extends RequestFileOperationFeature { + constructor(client) { + super( + client, + code.workspace.onWillDeleteFiles, + proto.WillDeleteFilesRequest.type, + 'willDelete', + 'willDelete', + (i) => i, + client.code2ProtocolConverter.asWillDeleteFilesParams + ); + } + doSend(event, next) { + const middleware = this._client.clientOptions.middleware?.workspace; + return middleware?.willDeleteFiles + ? middleware.willDeleteFiles(event, next) + : next(event); + } + }; + exports.WillDeleteFilesFeature = WillDeleteFilesFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/linkedEditingRange.js +let require_linkedEditingRange = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/linkedEditingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LinkedEditingFeature = void 0; + let code = require('vscode'); + let proto = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let LinkedEditingFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super(client, proto.LinkedEditingRangeRequest.type); + } + fillClientCapabilities(capabilities) { + const linkedEditingSupport = ensure( + ensure(capabilities, 'textDocument'), + 'linkedEditingRange' + ); + linkedEditingSupport.dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + let [id, options] = this.getRegistration( + documentSelector, + capabilities.linkedEditingRangeProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const provider = { + provideLinkedEditingRanges: (document2, position, token) => { + const client = this._client; + const provideLinkedEditing = (document3, position2, token2) => { + return client + .sendRequest( + proto.LinkedEditingRangeRequest.type, + client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ), + token2 + ) + .then( + client.protocol2CodeConverter.asLinkedEditingRanges, + (error) => { + return client.handleFailedRequest( + proto.LinkedEditingRangeRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideLinkedEditingRange + ? middleware.provideLinkedEditingRange( + document2, + position, + token, + provideLinkedEditing + ) + : provideLinkedEditing(document2, position, token); + }, + }; + return [ + code.languages.registerLinkedEditingRangeProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.LinkedEditingFeature = LinkedEditingFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/proposed.diagnostic.js +let require_proposed_diagnostic2 = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/proposed.diagnostic.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DiagnosticFeature = exports.vsdiag = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let uuid_1 = require_uuid(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let vsdiag; + (function (vsdiag2) { + let DocumentDiagnosticReportKind; + (function (DocumentDiagnosticReportKind2) { + DocumentDiagnosticReportKind2['full'] = 'full'; + DocumentDiagnosticReportKind2['unChanged'] = 'unChanged'; + })( + (DocumentDiagnosticReportKind = + vsdiag2.DocumentDiagnosticReportKind || + (vsdiag2.DocumentDiagnosticReportKind = {})) + ); + })((vsdiag = exports.vsdiag || (exports.vsdiag = {}))); + let RequestStateKind; + (function (RequestStateKind2) { + RequestStateKind2['active'] = 'open'; + RequestStateKind2['reschedule'] = 'reschedule'; + RequestStateKind2['outDated'] = 'drop'; + })(RequestStateKind || (RequestStateKind = {})); + let EditorTracker = class { + constructor() { + this.open = new Set(); + const openTabsHandler = () => { + this.open.clear(); + if (vscode_1.window.tabs !== void 0) { + for (const tab of vscode_1.window.tabs) { + if (tab.resource !== void 0) { + this.open.add(tab.resource.toString()); + } + } + } else if (vscode_1.window.openEditors !== void 0) { + for (const info of vscode_1.window.openEditors) { + if (info.resource !== void 0) { + this.open.add(info.resource.toString()); + } + } + } + }; + openTabsHandler(); + if (vscode_1.window.onDidChangeTabs !== void 0) { + this.disposable = vscode_1.window.onDidChangeTabs(openTabsHandler); + } else if (vscode_1.window.onDidChangeOpenEditors !== void 0) { + this.disposable = vscode_1.window.onDidChangeOpenEditors( + openTabsHandler + ); + } else { + this.disposable = { dispose: () => {} }; + } + } + dispose() { + this.disposable.dispose(); + } + isActive(textDocument) { + return vscode_1.window.activeTextEditor?.document === textDocument; + } + isVisible(textDocument) { + return this.open.has(textDocument.uri.toString()); + } + }; + let PullState; + (function (PullState2) { + PullState2[(PullState2['document'] = 1)] = 'document'; + PullState2[(PullState2['workspace'] = 2)] = 'workspace'; + })(PullState || (PullState = {})); + let DocumentPullStateTracker = class { + constructor() { + this.documentPullStates = new Map(); + this.workspacePullStates = new Map(); + } + track(kind, document2, arg1) { + const states = + kind === PullState.document + ? this.documentPullStates + : this.workspacePullStates; + const [key, uri, version] = + typeof document2 === 'string' + ? [document2, vscode_1.Uri.parse(document2), arg1] + : [document2.uri.toString(), document2.uri, document2.version]; + let state = states.get(key); + if (state === void 0) { + state = { document: uri, pulledVersion: version, resultId: void 0 }; + states.set(key, state); + } + return state; + } + update(kind, document2, arg1, arg2) { + const states = + kind === PullState.document + ? this.documentPullStates + : this.workspacePullStates; + const [key, uri, version, resultId] = + typeof document2 === 'string' + ? [document2, vscode_1.Uri.parse(document2), arg1, arg2] + : [ + document2.uri.toString(), + document2.uri, + document2.version, + arg1, + ]; + let state = states.get(key); + if (state === void 0) { + state = { document: uri, pulledVersion: version, resultId }; + states.set(key, state); + } else { + state.pulledVersion = version; + state.resultId = resultId; + } + } + unTrack(kind, textDocument) { + const states = + kind === PullState.document + ? this.documentPullStates + : this.workspacePullStates; + states.delete(textDocument.uri.toString()); + } + tracks(kind, document2) { + const key = + typeof document2 === 'string' ? document2 : document2.uri.toString(); + const states = + kind === PullState.document + ? this.documentPullStates + : this.workspacePullStates; + return states.has(key); + } + getResultId(kind, textDocument) { + const states = + kind === PullState.document + ? this.documentPullStates + : this.workspacePullStates; + return states.get(textDocument.uri.toString())?.resultId; + } + getAllResultIds() { + const result = []; + for (let [uri, value] of this.workspacePullStates) { + if (this.documentPullStates.has(uri)) { + value = this.documentPullStates.get(uri); + } + if (value.resultId !== void 0) { + result.push({ uri, value: value.resultId }); + } + } + return result; + } + }; + let DiagnosticRequestor = class { + constructor(client, editorTracker, options) { + this.client = client; + this.editorTracker = editorTracker; + this.options = options; + this.isDisposed = false; + this.onDidChangeDiagnosticsEmitter = new vscode_1.EventEmitter(); + this.provider = this.createProvider(); + this.diagnostics = vscode_1.languages.createDiagnosticCollection( + options.identifier + ); + this.openRequests = new Map(); + this.documentStates = new DocumentPullStateTracker(); + this.workspaceErrorCounter = 0; + } + knows(kind, textDocument) { + return this.documentStates.tracks(kind, textDocument); + } + pull(textDocument, cb) { + this.pullAsync(textDocument).then( + () => { + if (cb) { + cb(); + } + }, + (error) => { + this.client.error( + `Document pull failed for text document ${textDocument.uri.toString()}`, + error, + false + ); + } + ); + } + async pullAsync(textDocument) { + const key = textDocument.uri.toString(); + const version = textDocument.version; + const currentRequestState = this.openRequests.get(key); + const documentState = this.documentStates.track( + PullState.document, + textDocument + ); + if (currentRequestState === void 0) { + const tokenSource = new vscode_1.CancellationTokenSource(); + this.openRequests.set(key, { + state: RequestStateKind.active, + version, + textDocument, + tokenSource, + }); + let report; + let afterState; + try { + report = (await this.provider.provideDiagnostics( + textDocument, + documentState.resultId, + tokenSource.token + )) ?? { kind: vsdiag.DocumentDiagnosticReportKind.full, items: [] }; + } catch (error) { + if ( + error instanceof client_1.LSPCancellationError && + vscode_languageserver_protocol_1.Proposed.DiagnosticServerCancellationData.is( + error.data + ) && + error.data.retriggerRequest === false + ) { + afterState = { state: RequestStateKind.outDated, textDocument }; + } + if ( + afterState === void 0 && + error instanceof vscode_1.CancellationError + ) { + afterState = { state: RequestStateKind.reschedule, textDocument }; + } else { + throw error; + } + } + afterState = afterState ?? this.openRequests.get(key); + if (afterState === void 0) { + this.client.error( + `Lost request state in diagnostic pull model. Clearing diagnostics for ${key}` + ); + this.diagnostics.delete(textDocument.uri); + return; + } + this.openRequests.delete(key); + if (!this.editorTracker.isVisible(textDocument)) { + this.documentStates.unTrack(PullState.document, textDocument); + return; + } + if (afterState.state === RequestStateKind.outDated) { + return; + } + if (report !== void 0) { + if (report.kind === vsdiag.DocumentDiagnosticReportKind.full) { + this.diagnostics.set(textDocument.uri, report.items); + } + documentState.pulledVersion = version; + documentState.resultId = report.resultId; + } + if (afterState.state === RequestStateKind.reschedule) { + this.pull(textDocument); + } + } else { + if (currentRequestState.state === RequestStateKind.active) { + currentRequestState.tokenSource.cancel(); + this.openRequests.set(key, { + state: RequestStateKind.reschedule, + textDocument: currentRequestState.textDocument, + }); + } else if (currentRequestState.state === RequestStateKind.outDated) { + this.openRequests.set(key, { + state: RequestStateKind.reschedule, + textDocument: currentRequestState.textDocument, + }); + } + } + } + cleanupPull(textDocument) { + const key = textDocument.uri.toString(); + const request = this.openRequests.get(key); + if ( + this.options.workspaceDiagnostics || + this.options.interFileDependencies + ) { + if (request !== void 0) { + this.openRequests.set(key, { + state: RequestStateKind.reschedule, + textDocument, + }); + } else { + this.pull(textDocument); + } + } else { + if (request !== void 0) { + if (request.state === RequestStateKind.active) { + request.tokenSource.cancel(); + } + this.openRequests.set(key, { + state: RequestStateKind.outDated, + textDocument, + }); + } + this.diagnostics.delete(textDocument.uri); + } + } + pullWorkspace() { + this.pullWorkspaceAsync().then( + () => { + this.workspaceTimeout = (0, + vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => { + this.pullWorkspace(); + }, 2e3); + }, + (error) => { + if ( + !(error instanceof client_1.LSPCancellationError) && + !vscode_languageserver_protocol_1.Proposed.DiagnosticServerCancellationData.is( + error.data + ) + ) { + this.client.error( + `Workspace diagnostic pull failed.`, + error, + false + ); + this.workspaceErrorCounter++; + } + if (this.workspaceErrorCounter <= 5) { + this.workspaceTimeout = (0, + vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => { + this.pullWorkspace(); + }, 2e3); + } + } + ); + } + async pullWorkspaceAsync() { + if (!this.provider.provideWorkspaceDiagnostics) { + return; + } + if (this.workspaceCancellation !== void 0) { + this.workspaceCancellation.cancel(); + this.workspaceCancellation = void 0; + } + this.workspaceCancellation = new vscode_1.CancellationTokenSource(); + const previousResultIds = this.documentStates + .getAllResultIds() + .map((item) => { + return { + uri: this.client.protocol2CodeConverter.asUri(item.uri), + value: item.value, + }; + }); + await this.provider.provideWorkspaceDiagnostics( + previousResultIds, + this.workspaceCancellation.token, + (chunk) => { + if (!chunk || this.isDisposed) { + return; + } + for (const item of chunk.items) { + if (item.kind === vsdiag.DocumentDiagnosticReportKind.full) { + if ( + !this.documentStates.tracks( + PullState.document, + item.uri.toString() + ) + ) { + this.diagnostics.set(item.uri, item.items); + } + } + this.documentStates.update( + PullState.workspace, + item.uri.toString(), + item.version ?? void 0, + item.resultId + ); + } + } + ); + } + createProvider() { + const result = { + onDidChangeDiagnostics: this.onDidChangeDiagnosticsEmitter.event, + provideDiagnostics: (textDocument, previousResultId, token) => { + const provideDiagnostics = ( + textDocument2, + previousResultId2, + token2 + ) => { + const params = { + identifier: this.options.identifier, + textDocument: { + uri: this.client.code2ProtocolConverter.asUri( + textDocument2.uri + ), + }, + previousResultId: previousResultId2, + }; + return this.client + .sendRequest( + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticRequest.type, + params, + token2 + ) + .then( + (result2) => { + if ( + result2 === void 0 || + result2 === null || + this.isDisposed + ) { + return { + kind: vsdiag.DocumentDiagnosticReportKind.full, + items: [], + }; + } + if ( + result2.kind === + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticReportKind.full + ) { + return { + kind: vsdiag.DocumentDiagnosticReportKind.full, + resultId: result2.resultId, + items: this.client.protocol2CodeConverter.asDiagnostics( + result2.items + ), + }; + } else { + return { + kind: vsdiag.DocumentDiagnosticReportKind.unChanged, + resultId: result2.resultId, + }; + } + }, + (error) => { + return this.client.handleFailedRequest( + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticRequest.type, + token2, + error, + { + kind: vsdiag.DocumentDiagnosticReportKind.full, + items: [], + } + ); + } + ); + }; + const middleware = this.client.clientOptions.middleware; + return middleware.provideDiagnostics + ? middleware.provideDiagnostics( + textDocument, + previousResultId, + token, + provideDiagnostics + ) + : provideDiagnostics(textDocument, previousResultId, token); + }, + }; + if (this.options.workspaceDiagnostics) { + result.provideWorkspaceDiagnostics = ( + resultIds, + token, + resultReporter + ) => { + const convertReport = (report) => { + if ( + report.kind === + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticReportKind.full + ) { + return { + kind: vsdiag.DocumentDiagnosticReportKind.full, + uri: this.client.protocol2CodeConverter.asUri(report.uri), + resultId: report.resultId, + version: report.version, + items: this.client.protocol2CodeConverter.asDiagnostics( + report.items + ), + }; + } else { + return { + kind: vsdiag.DocumentDiagnosticReportKind.unChanged, + uri: this.client.protocol2CodeConverter.asUri(report.uri), + resultId: report.resultId, + version: report.version, + }; + } + }; + const convertPreviousResultIds = (resultIds2) => { + const converted = []; + for (const item of resultIds2) { + converted.push({ + uri: this.client.code2ProtocolConverter.asUri(item.uri), + value: item.value, + }); + } + return converted; + }; + const provideDiagnostics = (resultIds2, token2) => { + const partialResultToken = (0, uuid_1.generateUuid)(); + const disposable = this.client.onProgress( + vscode_languageserver_protocol_1.Proposed + .WorkspaceDiagnosticRequest.partialResult, + partialResultToken, + (partialResult) => { + if (partialResult === void 0 || partialResult === null) { + resultReporter(null); + return; + } + const converted = { + items: [], + }; + for (const item of partialResult.items) { + converted.items.push(convertReport(item)); + } + resultReporter(converted); + } + ); + const params = { + identifier: this.options.identifier, + previousResultIds: convertPreviousResultIds(resultIds2), + partialResultToken, + }; + return this.client + .sendRequest( + vscode_languageserver_protocol_1.Proposed + .WorkspaceDiagnosticRequest.type, + params, + token2 + ) + .then( + (result2) => { + const converted = { + items: [], + }; + for (const item of result2.items) { + converted.items.push(convertReport(item)); + } + disposable.dispose(); + resultReporter(converted); + return { items: [] }; + }, + (error) => { + disposable.dispose(); + return this.client.handleFailedRequest( + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticRequest.type, + token2, + error, + { items: [] } + ); + } + ); + }; + const middleware = this.client.clientOptions.middleware; + return middleware.provideWorkspaceDiagnostics + ? middleware.provideWorkspaceDiagnostics( + resultIds, + token, + resultReporter, + provideDiagnostics + ) + : provideDiagnostics(resultIds, token, resultReporter); + }; + } + return result; + } + dispose() { + this.isDisposed = true; + this.workspaceCancellation?.cancel(); + this.workspaceTimeout?.dispose(); + for (const [key, request] of this.openRequests) { + if (request.state === RequestStateKind.active) { + request.tokenSource.cancel(); + } + this.openRequests.set(key, { + state: RequestStateKind.outDated, + textDocument: request.textDocument, + }); + } + } + }; + let BackgroundScheduler = class { + constructor(diagnosticRequestor) { + this.diagnosticRequestor = diagnosticRequestor; + this.documents = new vscode_languageserver_protocol_1.LinkedMap(); + } + add(textDocument) { + const key = textDocument.uri.toString(); + if (this.documents.has(key)) { + return; + } + this.documents.set( + textDocument.uri.toString(), + textDocument, + vscode_languageserver_protocol_1.Touch.Last + ); + this.trigger(); + } + remove(textDocument) { + const key = textDocument.uri.toString(); + if (this.documents.has(key)) { + this.documents.delete(key); + this.diagnosticRequestor.pull(textDocument); + } + if (this.documents.size === 0) { + this.stop(); + } else if (textDocument === this.endDocument) { + this.endDocument = this.documents.last; + } + } + trigger() { + if (this.intervalHandle !== void 0) { + this.endDocument = this.documents.last; + return; + } + this.endDocument = this.documents.last; + this.intervalHandle = (0, + vscode_languageserver_protocol_1.RAL)().timer.setInterval(() => { + const document2 = this.documents.first; + if (document2 !== void 0) { + this.diagnosticRequestor.pull(document2); + this.documents.set( + document2.uri.toString(), + document2, + vscode_languageserver_protocol_1.Touch.Last + ); + if (document2 === this.endDocument) { + this.stop(); + } + } + }, 200); + } + dispose() { + this.stop(); + this.documents.clear(); + } + stop() { + this.intervalHandle?.dispose(); + this.intervalHandle = void 0; + this.endDocument = void 0; + } + }; + let DiagnosticFeatureProviderImpl = class { + constructor(client, editorTracker, options) { + const diagnosticPullOptions = client.clientOptions + .diagnosticPullOptions ?? { onChange: true, onSave: false }; + const documentSelector = options.documentSelector; + const disposables = []; + const matches = (textDocument) => { + return ( + vscode_1.languages.match(documentSelector, textDocument) > 0 && + editorTracker.isVisible(textDocument) + ); + }; + this.diagnosticRequestor = new DiagnosticRequestor( + client, + editorTracker, + options + ); + this.backgroundScheduler = new BackgroundScheduler( + this.diagnosticRequestor + ); + const addToBackgroundIfNeeded = (textDocument) => { + if ( + !matches(textDocument) || + !options.interFileDependencies || + this.activeTextDocument === textDocument + ) { + return; + } + this.backgroundScheduler.add(textDocument); + }; + this.activeTextDocument = vscode_1.window.activeTextEditor?.document; + vscode_1.window.onDidChangeActiveTextEditor((editor) => { + const oldActive = this.activeTextDocument; + this.activeTextDocument = editor?.document; + if (oldActive !== void 0) { + addToBackgroundIfNeeded(oldActive); + } + if (this.activeTextDocument !== void 0) { + this.backgroundScheduler.remove(this.activeTextDocument); + } + }); + const openFeature = client.getFeature( + vscode_languageserver_protocol_1.DidOpenTextDocumentNotification + .method + ); + disposables.push( + openFeature.onNotificationSent((event) => { + const textDocument = event.original; + if (matches(textDocument)) { + this.diagnosticRequestor.pull(textDocument, () => { + addToBackgroundIfNeeded(textDocument); + }); + } + }) + ); + for (const textDocument of vscode_1.workspace.textDocuments) { + if (matches(textDocument)) { + this.diagnosticRequestor.pull(textDocument, () => { + addToBackgroundIfNeeded(textDocument); + }); + } + } + if (diagnosticPullOptions.onChange) { + const changeFeature = client.getFeature( + vscode_languageserver_protocol_1.DidChangeTextDocumentNotification + .method + ); + disposables.push( + changeFeature.onNotificationSent(async (event) => { + const textDocument = event.original.document; + if ( + (diagnosticPullOptions.filter === void 0 || + !diagnosticPullOptions.filter( + textDocument, + client_1.DiagnosticPullMode.onType + )) && + this.diagnosticRequestor.knows( + PullState.document, + textDocument + ) && + event.original.contentChanges.length > 0 + ) { + this.diagnosticRequestor.pull(textDocument, () => { + this.backgroundScheduler.trigger(); + }); + } + }) + ); + } + if (diagnosticPullOptions.onSave) { + const saveFeature = client.getFeature( + vscode_languageserver_protocol_1.DidSaveTextDocumentNotification + .method + ); + disposables.push( + saveFeature.onNotificationSent((event) => { + const textDocument = event.original; + if ( + (diagnosticPullOptions.filter === void 0 || + !diagnosticPullOptions.filter( + textDocument, + client_1.DiagnosticPullMode.onSave + )) && + this.diagnosticRequestor.knows(PullState.document, textDocument) + ) { + this.diagnosticRequestor.pull(event.original, () => { + this.backgroundScheduler.trigger(); + }); + } + }) + ); + } + const closeFeature = client.getFeature( + vscode_languageserver_protocol_1.DidCloseTextDocumentNotification + .method + ); + disposables.push( + closeFeature.onNotificationSent((event) => { + const textDocument = event.original; + this.diagnosticRequestor.cleanupPull(textDocument); + this.backgroundScheduler.remove(textDocument); + }) + ); + this.diagnosticRequestor.onDidChangeDiagnosticsEmitter.event(() => { + for (const textDocument of vscode_1.workspace.textDocuments) { + if (matches(textDocument)) { + this.diagnosticRequestor.pull(textDocument); + } + } + }); + if ( + options.workspaceDiagnostics === true && + options.identifier !== 'da348dc5-c30a-4515-9d98-31ff3be38d14' + ) { + this.diagnosticRequestor.pullWorkspace(); + } + this.disposable = vscode_1.Disposable.from( + ...disposables, + this.backgroundScheduler, + this.diagnosticRequestor + ); + } + get onDidChangeDiagnosticsEmitter() { + return this.diagnosticRequestor.onDidChangeDiagnosticsEmitter; + } + get diagnostics() { + return this.diagnosticRequestor.provider; + } + }; + let DiagnosticFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.Proposed.DocumentDiagnosticRequest + .type + ); + this.editorTracker = new EditorTracker(); + } + fillClientCapabilities(capabilities) { + let capability = ensure( + ensure(capabilities, 'textDocument'), + 'diagnostic' + ); + capability.dynamicRegistration = true; + capability.relatedDocumentSupport = false; + } + initialize(capabilities, documentSelector) { + const client = this._client; + client.onRequest( + vscode_languageserver_protocol_1.Proposed.DiagnosticRefreshRequest + .type, + async () => { + for (const provider of this.getAllProviders()) { + provider.onDidChangeDiagnosticsEmitter.fire(); + } + } + ); + let [id, options] = this.getRegistration( + documentSelector, + capabilities.diagnosticProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + dispose() { + this.editorTracker.dispose(); + super.dispose(); + } + registerLanguageProvider(options) { + const provider = new DiagnosticFeatureProviderImpl( + this._client, + this.editorTracker, + options + ); + return [provider.disposable, provider]; + } + }; + exports.DiagnosticFeature = DiagnosticFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/proposed.typeHierarchy.js +let require_proposed_typeHierarchy2 = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/proposed.typeHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeHierarchyFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = {}; + } + return target[key]; + } + let TypeHierarchyProvider = class { + constructor(client) { + this.client = client; + this.middleware = client.clientOptions.middleware; + } + prepareTypeHierarchy(document2, position, token) { + const client = this.client; + const middleware = this.middleware; + const prepareTypeHierarchy = (document3, position2, token2) => { + const params = client.code2ProtocolConverter.asTextDocumentPositionParams( + document3, + position2 + ); + return client + .sendRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchyPrepareRequest.type, + params, + token2 + ) + .then( + (result) => { + return client.protocol2CodeConverter.asTypeHierarchyItems( + result + ); + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchyPrepareRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.prepareTypeHierarchy + ? middleware.prepareTypeHierarchy( + document2, + position, + token, + prepareTypeHierarchy + ) + : prepareTypeHierarchy(document2, position, token); + } + provideTypeHierarchySupertypes(item, token) { + const client = this.client; + const middleware = this.middleware; + const provideTypeHierarchySupertypes = (item2, token2) => { + const params = { + item: client.code2ProtocolConverter.asTypeHierarchyItem(item2), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchySupertypesRequest.type, + params, + token2 + ) + .then( + (result) => { + return client.protocol2CodeConverter.asTypeHierarchyItems( + result + ); + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchySupertypesRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideTypeHierarchySupertypes + ? middleware.provideTypeHierarchySupertypes( + item, + token, + provideTypeHierarchySupertypes + ) + : provideTypeHierarchySupertypes(item, token); + } + provideTypeHierarchySubtypes(item, token) { + const client = this.client; + const middleware = this.middleware; + const provideTypeHierarchySubtypes = (item2, token2) => { + const params = { + item: client.code2ProtocolConverter.asTypeHierarchyItem(item2), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchySubtypesRequest.type, + params, + token2 + ) + .then( + (result) => { + return client.protocol2CodeConverter.asTypeHierarchyItems( + result + ); + }, + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchySubtypesRequest.type, + token2, + error, + null + ); + } + ); + }; + return middleware.provideTypeHierarchySubtypes + ? middleware.provideTypeHierarchySubtypes( + item, + token, + provideTypeHierarchySubtypes + ) + : provideTypeHierarchySubtypes(item, token); + } + }; + let TypeHierarchyFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.Proposed.TypeHierarchyPrepareRequest + .type + ); + } + fillClientCapabilities(cap) { + const capabilities = cap; + const capability = ensure( + ensure(capabilities, 'textDocument'), + 'typeHierarchy' + ); + capability.dynamicRegistration = true; + } + initialize(capabilities, documentSelector) { + const [id, options] = this.getRegistration( + documentSelector, + capabilities.typeHierarchyProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const client = this._client; + const provider = new TypeHierarchyProvider(client); + return [ + vscode_1.languages.registerTypeHierarchyProvider( + options.documentSelector, + provider + ), + provider, + ]; + } + }; + exports.TypeHierarchyFeature = TypeHierarchyFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/proposed.inlineValues.js +let require_proposed_inlineValues = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/proposed.inlineValues.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.InlineValueFeature = void 0; + let vscode_1 = require('vscode'); + let vscode_languageserver_protocol_1 = require_main3(); + let client_1 = require_client(); + function ensure(target, key) { + if (target[key] === void 0) { + target[key] = Object.create(null); + } + return target[key]; + } + let InlineValueFeature = class extends client_1.TextDocumentFeature { + constructor(client) { + super( + client, + vscode_languageserver_protocol_1.Proposed.InlineValuesRequest.type + ); + } + fillClientCapabilities(capabilities) { + ensure( + ensure(capabilities, 'textDocument'), + 'inlineValues' + ).dynamicRegistration = true; + ensure( + ensure(capabilities, 'workspace'), + 'codeLens' + ).refreshSupport = true; + } + initialize(capabilities, documentSelector) { + this._client.onRequest( + vscode_languageserver_protocol_1.Proposed.InlineValuesRefreshRequest + .type, + async () => { + for (const provider of this.getAllProviders()) { + provider.onDidChangeInlineValues.fire(); + } + } + ); + const [id, options] = this.getRegistration( + documentSelector, + capabilities.inlineValuesProvider + ); + if (!id || !options) { + return; + } + this.register({ id, registerOptions: options }); + } + registerLanguageProvider(options) { + const eventEmitter = new vscode_1.EventEmitter(); + const provider = { + onDidChangeInlineValues: eventEmitter.event, + provideInlineValues: (document2, viewPort, context, token) => { + const client = this._client; + const provideInlineValues = ( + document3, + viewPort2, + context2, + token2 + ) => { + const requestParams = { + textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier( + document3 + ), + viewPort: client.code2ProtocolConverter.asRange(viewPort2), + context: client.code2ProtocolConverter.asInlineValuesContext( + context2 + ), + }; + return client + .sendRequest( + vscode_languageserver_protocol_1.Proposed.InlineValuesRequest + .type, + requestParams, + token2 + ) + .then( + (values) => + client.protocol2CodeConverter.asInlineValues(values), + (error) => { + return client.handleFailedRequest( + vscode_languageserver_protocol_1.Proposed + .InlineValuesRequest.type, + token2, + error, + null + ); + } + ); + }; + const middleware = client.clientOptions.middleware; + return middleware.provideInlineValues + ? middleware.provideInlineValues( + document2, + viewPort, + context, + token, + provideInlineValues + ) + : provideInlineValues(document2, viewPort, context, token); + }, + }; + return [ + vscode_1.languages.registerInlineValuesProvider( + options.documentSelector, + provider + ), + { provider, onDidChangeInlineValues: eventEmitter }, + ]; + } + }; + exports.InlineValueFeature = InlineValueFeature; + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/commonClient.js +let require_commonClient = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/commonClient.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProposedFeatures = exports.CommonLanguageClient = void 0; + let client_1 = require_client(); + let colorProvider_1 = require_colorProvider(); + let configuration_1 = require_configuration(); + let implementation_1 = require_implementation(); + let typeDefinition_1 = require_typeDefinition(); + let workspaceFolders_1 = require_workspaceFolders(); + let foldingRange_1 = require_foldingRange(); + let declaration_1 = require_declaration(); + let selectionRange_1 = require_selectionRange(); + let progress_1 = require_progress(); + let callHierarchy_1 = require_callHierarchy(); + let semanticTokens_1 = require_semanticTokens(); + let fileOperations_1 = require_fileOperations(); + let linkedEditingRange_1 = require_linkedEditingRange(); + let CommonLanguageClient = class extends client_1.BaseLanguageClient { + constructor(id, name, clientOptions) { + super(id, name, clientOptions); + } + registerProposedFeatures() { + this.registerFeatures(ProposedFeatures.createAll(this)); + } + registerBuiltinFeatures() { + super.registerBuiltinFeatures(); + this.registerFeature(new configuration_1.ConfigurationFeature(this)); + this.registerFeature(new typeDefinition_1.TypeDefinitionFeature(this)); + this.registerFeature(new implementation_1.ImplementationFeature(this)); + this.registerFeature(new colorProvider_1.ColorProviderFeature(this)); + if (this.clientOptions.workspaceFolder === void 0) { + this.registerFeature( + new workspaceFolders_1.WorkspaceFoldersFeature(this) + ); + } + this.registerFeature(new foldingRange_1.FoldingRangeFeature(this)); + this.registerFeature(new declaration_1.DeclarationFeature(this)); + this.registerFeature(new selectionRange_1.SelectionRangeFeature(this)); + this.registerFeature(new progress_1.ProgressFeature(this)); + this.registerFeature(new callHierarchy_1.CallHierarchyFeature(this)); + this.registerFeature(new semanticTokens_1.SemanticTokensFeature(this)); + this.registerFeature( + new linkedEditingRange_1.LinkedEditingFeature(this) + ); + this.registerFeature(new fileOperations_1.DidCreateFilesFeature(this)); + this.registerFeature(new fileOperations_1.DidRenameFilesFeature(this)); + this.registerFeature(new fileOperations_1.DidDeleteFilesFeature(this)); + this.registerFeature(new fileOperations_1.WillCreateFilesFeature(this)); + this.registerFeature(new fileOperations_1.WillRenameFilesFeature(this)); + this.registerFeature(new fileOperations_1.WillDeleteFilesFeature(this)); + } + }; + exports.CommonLanguageClient = CommonLanguageClient; + let pd = require_proposed_diagnostic2(); + let pt = require_proposed_typeHierarchy2(); + let iv = require_proposed_inlineValues(); + let ProposedFeatures; + (function (ProposedFeatures2) { + function createAll(_client) { + let result = [ + new pd.DiagnosticFeature(_client), + new pt.TypeHierarchyFeature(_client), + new iv.InlineValueFeature(_client), + ]; + return result; + } + ProposedFeatures2.createAll = createAll; + })( + (ProposedFeatures = + exports.ProposedFeatures || (exports.ProposedFeatures = {})) + ); + }, +}); + +// client/node_modules/vscode-languageclient/lib/common/api.js +let require_api3 = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/common/api.js'(exports) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + __exportStar(require_main3(), exports); + __exportStar(require_client(), exports); + __exportStar(require_commonClient(), exports); + }, +}); + +// client/node_modules/vscode-languageserver-protocol/browser.js +let require_browser2 = __commonJS({ + 'client/node_modules/vscode-languageserver-protocol/browser.js'( + exports, + module2 + ) { + 'use strict'; + module2.exports = require_main3(); + }, +}); + +// client/node_modules/vscode-languageclient/lib/browser/main.js +let require_main4 = __commonJS({ + 'client/node_modules/vscode-languageclient/lib/browser/main.js'(exports) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LanguageClient = void 0; + let api_1 = require_api3(); + let browser_1 = require_browser2(); + __exportStar(require_browser2(), exports); + __exportStar(require_api3(), exports); + let LanguageClient2 = class extends api_1.CommonLanguageClient { + constructor(id, name, clientOptions, worker) { + super(id, name, clientOptions); + this.worker = worker; + } + createMessageTransports(_encoding) { + const reader = new browser_1.BrowserMessageReader(this.worker); + const writer = new browser_1.BrowserMessageWriter(this.worker); + return Promise.resolve({ reader, writer }); + } + getLocale() { + return 'en'; + } + }; + exports.LanguageClient = LanguageClient2; + }, +}); + +// client/node_modules/vscode-languageclient/browser.js +let require_browser3 = __commonJS({ + 'client/node_modules/vscode-languageclient/browser.js'(exports, module2) { + 'use strict'; + module2.exports = require_main4(); + }, +}); + +// client/src/main.ts +__export(exports, { + activate: () => activate, +}); +let vscode2 = __toModule(require('vscode')); +let import_vscode_languageclient = __toModule(require_main4()); +let import_browser = __toModule(require_browser3()); + +// client/src/supportedLanguages.ts +let vscode = __toModule(require('vscode')); +let LanguageInfo = class { + constructor(languageId, wasmUri, suffixes) { + this.languageId = languageId; + this.wasmUri = wasmUri; + this.suffixes = suffixes; + } +}; +let SupportedLanguages = class { + constructor(context) { + this._overrideConfigurations = new Map([ + [ + 'python', + { + extension: 'ms-python.python', + config: { + completions: false, + definitions: true, + diagnostics: false, + folding: false, + highlights: false, + outline: false, + references: false, + workspaceSymbols: true, + }, + }, + ], + [ + 'typescript', + { + extension: 'vscode.typescript-language-features', + config: { + completions: false, + definitions: true, + diagnostics: false, + folding: false, + highlights: false, + outline: false, + references: false, + workspaceSymbols: true, + }, + }, + ], + ]); + this._onDidChange = new vscode.EventEmitter(); + this.onDidChange = this._onDidChange.event; + this._all = [ + new LanguageInfo( + 'c', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-c.wasm' + ).toString(), + ['c', 'i'] + ), + new LanguageInfo( + 'cpp', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-cpp.wasm' + ).toString(), + [ + 'cpp', + 'cc', + 'cxx', + 'c++', + 'hpp', + 'hh', + 'hxx', + 'h++', + 'h', + 'ii', + 'ino', + 'inl', + 'ipp', + 'ixx', + 'hpp.in', + 'h.in', + ] + ), + new LanguageInfo( + 'csharp', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-c_sharp.wasm' + ).toString(), + ['cs'] + ), + new LanguageInfo( + 'go', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-go.wasm' + ).toString(), + ['go'] + ), + new LanguageInfo( + 'java', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-java.wasm' + ).toString(), + ['java'] + ), + new LanguageInfo( + 'php', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-php.wasm' + ).toString(), + ['php', 'php4', 'php5', 'phtml', 'ctp'] + ), + new LanguageInfo( + 'python', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-python.wasm' + ).toString(), + ['py', 'rpy', 'pyw', 'cpy', 'gyp', 'gypi', 'pyi', 'ipy'] + ), + new LanguageInfo( + 'rust', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-rust.wasm' + ).toString(), + ['rs'] + ), + new LanguageInfo( + 'typescript', + vscode.Uri.joinPath( + context.extensionUri, + './server/tree-sitter-typescript.wasm' + ).toString(), + ['ts', 'tsx', 'js', 'jsx'] + ), + ]; + this._disposable = vscode.Disposable.from( + vscode.extensions.onDidChange(this._reset, this), + vscode.workspace.onDidChangeConfiguration((e) => { + if (e.affectsConfiguration('anycode.language')) { + this._reset(); + } + }) + ); + } + dispose() { + this._onDidChange.dispose(); + this._disposable.dispose(); + } + _reset() { + this._tuples = void 0; + this._onDidChange.fire(this); + } + getSupportedLanguages() { + if (!this._tuples) { + this._tuples = new Map(); + for (let info of this._all) { + const config = vscode.workspace.getConfiguration('anycode', { + languageId: info.languageId, + }); + let overrideConfig; + const overrideInfo = this._overrideConfigurations.get(info.languageId); + if ( + overrideInfo && + vscode.extensions.getExtension(overrideInfo.extension) + ) { + overrideConfig = overrideInfo.config; + } + const featureConfig = { + ...config.get(`language.features`), + ...overrideConfig, + }; + const empty = Object.keys(featureConfig).every( + (key) => !featureConfig[key] + ); + if (empty) { + continue; + } + this._tuples.set(info, featureConfig); + } + } + return this._tuples; + } + getSupportedLanguagesAsSelector() { + return Array.from(this.getSupportedLanguages().keys()).map( + (info) => info.languageId + ); + } +}; + +// client/node_modules/vscode-extension-telemetry/lib/telemetryReporter.web.min.js +let ue = __toModule(require('vscode')); +let import_vscode = __toModule(require('vscode')); +let po = Object.defineProperty; +let vu = (t) => po(t, '__esModule', { value: true }); +let C = (t, e) => () => (t && (e = t((t = 0))), e); +let hu = (t, e) => { + vu(t); + for (let r in e) { + po(t, r, { get: e[r], enumerable: true }); + } +}; +let go; +let vo = C(() => { + go = { + Unknown: 0, + NonRetryableStatus: 1, + InvalidEvent: 2, + SizeLimitExceeded: 3, + KillSwitch: 4, + QueueFull: 5, + }; +}); +let mt; +let Xe; +let Oe; +let Ie; +let zr; +let gt; +let Sr; +let Cr; +let Ln; +let Un; +let rr; +let _n = C(() => { + (mt = 'function'), + (Xe = 'object'), + (Oe = 'undefined'), + (Ie = 'prototype'), + (zr = 'hasOwnProperty'), + (gt = Object), + (Sr = gt[Ie]), + (Cr = gt.assign), + (Ln = gt.create), + (Un = gt.defineProperty), + (rr = Sr[zr]); +}); +function ot() { + return typeof globalThis !== Oe && globalThis + ? globalThis + : typeof self !== Oe && self + ? self + : typeof window !== Oe && window + ? window + : typeof global !== Oe && global + ? global + : null; +} +function Ir(t) { + throw new TypeError(t); +} +function Dt(t) { + let e = Ln; + if (e) { + return e(t); + } + if (t == null) { + return {}; + } + let r = typeof t; + r !== Xe && r !== mt && Ir('Object prototype may only be an Object:' + t); + function n() {} + return (n[Ie] = t), new n(); +} +let Di = C(() => { + _n(); +}); +function H(t, e) { + typeof e !== mt && + e !== null && + Ir('Class extends value ' + String(e) + ' is not a constructor or null'), + Ai(t, e); + function r() { + this.constructor = t; + } + t[Ie] = e === null ? Dt(e) : ((r[Ie] = e[Ie]), new r()); +} +let Rl; +let Ml; +let Su; +let yt; +let Ai; +let ho = C(() => { + _n(); + Di(); + (Rl = (ot() || {}).Symbol), + (Ml = (ot() || {}).Reflect), + (Su = function (t) { + for (var e, r = 1, n = arguments.length; r < n; r++) { + e = arguments[r]; + for (let i in e) { + Sr[zr].call(e, i) && (t[i] = e[i]); + } + } + return t; + }), + (yt = Cr || Su), + (Ai = function (t, e) { + return ( + (Ai = + gt.setPrototypeOf || + ({ __proto__: [] } instanceof Array && + function (r, n) { + r.__proto__ = n; + }) || + function (r, n) { + for (let i in n) { + n[zr](i) && (r[i] = n[i]); + } + }), + Ai(t, e) + ); + }); +}); +let xo = C(() => {}); +let ne = C(() => { + _n(); + Di(); + ho(); + xo(); +}); +function jt(t, e) { + return t && zn[At].hasOwnProperty.call(t, e); +} +function To(t) { + return t && (t === zn[At] || t === Array[At]); +} +function Ri(t) { + return To(t) || t === Function[At]; +} +function nr(t) { + if (t) { + if (Vr) { + return Vr(t); + } + let e = t[Iu] || t[At] || (t[On] ? t[On][At] : null); + if (e) { + return e; + } + } + return null; +} +function Bn(t, e) { + let r = [], + n = zn.getOwnPropertyNames; + if (n) { + r = n(t); + } else { + for (let i in t) { + typeof i === 'string' && jt(t, i) && r.push(i); + } + } + if (r && r.length > 0) { + for (let a = 0; a < r.length; a++) { + e(r[a]); + } + } +} +function Mi(t, e, r) { + return e !== On && typeof t[e] === Hn && (r || jt(t, e)); +} +function Vn(t) { + throw new TypeError('DynamicProto: ' + t); +} +function Tu(t) { + let e = {}; + return ( + Bn(t, function (r) { + !e[r] && Mi(t, r, false) && (e[r] = t[r]); + }), + e + ); +} +function Li(t, e) { + for (let r = t.length - 1; r >= 0; r--) { + if (t[r] === e) { + return true; + } + } + return false; +} +function Eu(t, e, r, n) { + function i(s, u, l) { + let f = u[l]; + if (f[Ni] && n) { + let m = s[jn] || {}; + m[Br] !== false && (f = (m[u[Tr]] || {})[l] || f); + } + return function () { + return f.apply(s, arguments); + }; + } + let a = {}; + Bn(r, function (s) { + a[s] = i(e, r, s); + }); + for (var o = nr(t), c = []; o && !Ri(o) && !Li(c, o); ) { + Bn(o, function (s) { + !a[s] && Mi(o, s, !Vr) && (a[s] = i(e, o, s)); + }), + c.push(o), + (o = nr(o)); + } + return a; +} +function wu(t, e, r, n) { + let i = null; + if (t && jt(r, Tr)) { + let a = t[jn] || {}; + if ( + ((i = (a[r[Tr]] || {})[e]), + i || Vn('Missing [' + e + '] ' + Hn), + !i[Fi] && a[Br] !== false) + ) { + for ( + var o = !jt(t, e), c = nr(t), s = []; + o && c && !Ri(c) && !Li(s, c); + + ) { + let u = c[e]; + if (u) { + o = u === n; + break; + } + s.push(c), (c = nr(c)); + } + try { + o && (t[e] = i), (i[Fi] = 1); + } catch (l) { + a[Br] = false; + } + } + } + return i; +} +function Pu(t, e, r) { + let n = e[t]; + return ( + n === r && (n = nr(e)[t]), + typeof n !== Hn && Vn('[' + t + '] is not a ' + Hn), + n + ); +} +function bu(t, e, r, n, i) { + function a(s, u) { + var l = function () { + let f = wu(this, u, s, l) || Pu(u, s, l); + return f.apply(this, arguments); + }; + return (l[Ni] = 1), l; + } + if (!To(t)) { + let o = (r[jn] = r[jn] || {}), + c = (o[e] = o[e] || {}); + o[Br] !== false && (o[Br] = !!i), + Bn(r, function (s) { + Mi(r, s, false) && + r[s] !== n[s] && + ((c[s] = r[s]), + delete r[s], + (!jt(t, s) || (t[s] && !t[s][Ni])) && (t[s] = a(t, s))); + }); + } +} +function Du(t, e) { + if (Vr) { + for (let r = [], n = nr(e); n && !Ri(n) && !Li(r, n); ) { + if (n === t) { + return true; + } + r.push(n), (n = nr(n)); + } + } + return false; +} +function Ui(t, e) { + return jt(t, At) ? t.name || e || So : ((t || {})[On] || {}).name || e || So; +} +function _i(t, e, r, n) { + jt(t, At) || Vn('theClass is an invalid class definition.'); + let i = t[At]; + Du(i, e) || + Vn('[' + Ui(t) + '] is not in class hierarchy of [' + Ui(e) + ']'); + let a = null; + jt(i, Tr) + ? (a = i[Tr]) + : ((a = Cu + Ui(t, '_') + '$' + Io), Io++, (i[Tr] = a)); + let o = _i[yo], + c = !!o[ki]; + c && n && n[ki] !== void 0 && (c = !!n[ki]); + let s = Tu(e), + u = Eu(i, e, s, c); + r(e, u); + let l = !!Vr && !!o[Co]; + l && n && (l = !!n[Co]), bu(i, a, e, s, l !== false); +} +let On; +let At; +let Hn; +let jn; +let Ni; +let Tr; +let Cu; +let Fi; +let Br; +let yo; +let So; +let Iu; +let ki; +let Co; +let zn; +let Vr; +let Io; +let Au; +let W; +let Te = C(() => { + (On = 'constructor'), + (At = 'prototype'), + (Hn = 'function'), + (jn = '_dynInstFuncs'), + (Ni = '_isDynProxy'), + (Tr = '_dynClass'), + (Cu = '_dynCls$'), + (Fi = '_dynInstChk'), + (Br = Fi), + (yo = '_dfOpts'), + (So = '_unknown_'), + (Iu = '__proto__'), + (ki = 'useBaseInst'), + (Co = 'setInstFuncs'), + (zn = Object), + (Vr = zn.getPrototypeOf), + (Io = 0); + Au = { setInstFuncs: true, useBaseInst: true }; + _i[yo] = Au; + W = _i; +}); +let S; +let h; +let qr = C(() => { + (function (t) { + (t[(t.CRITICAL = 1)] = 'CRITICAL'), (t[(t.WARNING = 2)] = 'WARNING'); + })(S || (S = {})); + h = { + BrowserDoesNotSupportLocalStorage: 0, + BrowserCannotReadLocalStorage: 1, + BrowserCannotReadSessionStorage: 2, + BrowserCannotWriteLocalStorage: 3, + BrowserCannotWriteSessionStorage: 4, + BrowserFailedRemovalFromLocalStorage: 5, + BrowserFailedRemovalFromSessionStorage: 6, + CannotSendEmptyTelemetry: 7, + ClientPerformanceMathError: 8, + ErrorParsingAISessionCookie: 9, + ErrorPVCalc: 10, + ExceptionWhileLoggingError: 11, + FailedAddingTelemetryToBuffer: 12, + FailedMonitorAjaxAbort: 13, + FailedMonitorAjaxDur: 14, + FailedMonitorAjaxOpen: 15, + FailedMonitorAjaxRSC: 16, + FailedMonitorAjaxSend: 17, + FailedMonitorAjaxGetCorrelationHeader: 18, + FailedToAddHandlerForOnBeforeUnload: 19, + FailedToSendQueuedTelemetry: 20, + FailedToReportDataLoss: 21, + FlushFailed: 22, + MessageLimitPerPVExceeded: 23, + MissingRequiredFieldSpecification: 24, + NavigationTimingNotSupported: 25, + OnError: 26, + SessionRenewalDateIsZero: 27, + SenderNotInitialized: 28, + StartTrackEventFailed: 29, + StopTrackEventFailed: 30, + StartTrackFailed: 31, + StopTrackFailed: 32, + TelemetrySampledAndNotSent: 33, + TrackEventFailed: 34, + TrackExceptionFailed: 35, + TrackMetricFailed: 36, + TrackPVFailed: 37, + TrackPVFailedCalc: 38, + TrackTraceFailed: 39, + TransmissionFailed: 40, + FailedToSetStorageBuffer: 41, + FailedToRestoreStorageBuffer: 42, + InvalidBackendResponse: 43, + FailedToFixDepricatedValues: 44, + InvalidDurationValue: 45, + TelemetryEnvelopeInvalid: 46, + CreateEnvelopeError: 47, + CannotSerializeObject: 48, + CannotSerializeObjectNonSerializable: 49, + CircularReferenceDetected: 50, + ClearAuthContextFailed: 51, + ExceptionTruncated: 52, + IllegalCharsInName: 53, + ItemNotInArray: 54, + MaxAjaxPerPVExceeded: 55, + MessageTruncated: 56, + NameTooLong: 57, + SampleRateOutOfRange: 58, + SetAuthContextFailed: 59, + SetAuthContextFailedAccountName: 60, + StringValueTooLong: 61, + StartCalledMoreThanOnce: 62, + StopCalledWithoutStart: 63, + TelemetryInitializerFailed: 64, + TrackArgumentsNotSpecified: 65, + UrlTooLong: 66, + SessionStorageBufferFull: 67, + CannotAccessCookie: 68, + IdTooLong: 69, + InvalidEvent: 70, + FailedMonitorAjaxSetRequestHeader: 71, + SendBrowserInfoOnUserInit: 72, + PluginException: 73, + NotificationException: 74, + SnippetScriptLoadFailure: 99, + InvalidInstrumentationKey: 100, + CannotParseAiBlobValue: 101, + InvalidContentBlob: 102, + TrackPageActionEventFailed: 103, + }; +}); +function Oi(t) { + return Sr.toString.call(t); +} +function Hi(t, e) { + return typeof t === e; +} +function pe(t) { + return t === void 0 || typeof t === Oe; +} +function x(t) { + return t === null || pe(t); +} +function ji(t) { + return !x(t); +} +function Er(t, e) { + return t && rr.call(t, e); +} +function st(t) { + return typeof t === Xe; +} +function j(t) { + return typeof t === mt; +} +function zt(t, e, r, n) { + n === void 0 && (n = false); + let i = false; + if (!x(t)) { + try { + x(t[Po]) + ? x(t[wo]) || (t[wo](Eo + e, r), (i = true)) + : (t[Po](e, r, n), (i = true)); + } catch (a) {} + } + return i; +} +function qn(t, e, r, n) { + if ((n === void 0 && (n = false), !x(t))) { + try { + x(t[Do]) ? x(t[bo]) || t[bo](Eo + e, r) : t[Do](e, r, n); + } catch (i) {} + } +} +function zi(t) { + let e = t, + r = /([^\w\d_$])/g; + return r.test(t) && (e = t.replace(r, '_')), e; +} +function Q(t, e) { + if (t) { + for (let r in t) { + rr.call(t, r) && e.call(t, r, t[r]); + } + } +} +function Bi(t, e) { + if (t && e) { + let r = e.length, + n = t.length; + if (t === e) { + return true; + } + if (n >= r) { + for (let i = n - 1, a = r - 1; a >= 0; a--) { + if (t[i] != e[a]) { + return false; + } + i--; + } + return true; + } + } + return false; +} +function Ee(t, e) { + return t && e ? t.indexOf(e) !== -1 : false; +} +function wr(t) { + return Oi(t) === '[object Date]'; +} +function Re(t) { + return Oi(t) === '[object Array]'; +} +function Bt(t) { + return Oi(t) === '[object Error]'; +} +function _(t) { + return typeof t === 'string'; +} +function ir(t) { + return typeof t === 'number'; +} +function Gr(t) { + return typeof t === 'boolean'; +} +function Me(t) { + if (wr(t)) { + let e = function (r) { + let n = String(r); + return n.length === 1 && (n = '0' + n), n; + }; + return ( + t.getUTCFullYear() + + '-' + + e(t.getUTCMonth() + 1) + + '-' + + e(t.getUTCDate()) + + 'T' + + e(t.getUTCHours()) + + ':' + + e(t.getUTCMinutes()) + + ':' + + e(t.getUTCSeconds()) + + '.' + + String((t.getUTCMilliseconds() / 1e3).toFixed(3)).slice(2, 5) + + 'Z' + ); + } +} +function R(t, e, r) { + for ( + let n = t.length, i = 0; + i < n && !(i in t && e.call(r || t, t[i], i, t) === -1); + i++ + ) {} +} +function Nt(t, e, r) { + for ( + let n = t.length, i = r || 0, a = Math.max(i >= 0 ? i : n - Math.abs(i), 0); + a < n; + a++ + ) { + if (a in t && t[a] === e) { + return a; + } + } + return -1; +} +function Vt(t, e, r) { + for (var n = t.length, i = r || t, a = new Array(n), o = 0; o < n; o++) { + o in t && (a[o] = e.call(i, t[o], t)); + } + return a; +} +function Kr(t, e, r) { + let n = t.length, + i = 0, + a; + if (arguments.length >= 3) { + a = arguments[2]; + } else { + for (; i < n && !(i in t); ) { + i++; + } + a = t[i++]; + } + for (; i < n; ) { + i in t && (a = e(a, t[i], i, t)), i++; + } + return a; +} +function oe(t) { + return typeof t !== 'string' ? t : t.replace(/^\s+|\s+$/g, ''); +} +function Qe(t) { + let e = typeof t; + e !== mt && (e !== Xe || t === null) && Ir('objKeys called on non-object'); + let r = []; + for (let n in t) { + t && rr.call(t, n) && r.push(n); + } + if (Nu) { + for (let i = Vi.length, a = 0; a < i; a++) { + t && rr.call(t, Vi[a]) && r.push(Vi[a]); + } + } + return r; +} +function St(t, e, r, n) { + if (Ao) { + try { + let i = { enumerable: true, configurable: true }; + return r && (i.get = r), n && (i.set = n), Ao(t, e, i), true; + } catch (a) {} + } + return false; +} +function de() { + let t = Date; + return t.now ? t.now() : new t().getTime(); +} +function G(t) { + return Bt(t) ? t.name : ''; +} +function K(t, e, r, n, i) { + let a = r; + return ( + t && + ((a = t[e]), + a !== r && (!i || i(a)) && (!n || n(r)) && ((a = r), (t[e] = a))), + a + ); +} +function ge(t, e, r) { + let n; + return ( + t + ? ((n = t[e]), !n && x(n) && ((n = pe(r) ? {} : r), (t[e] = n))) + : (n = pe(r) ? {} : r), + n + ); +} +function Gn(t) { + return !t; +} +function Pr(t) { + return !!t; +} +function Ae(t) { + throw new Error(t); +} +function Wr(t, e, r) { + if (t && e && t !== e && st(t) && st(e)) { + let n = function (a) { + if (_(a)) { + let o = e[a]; + j(o) + ? (!r || r(a, true, e, t)) && + (t[a] = (function (c) { + return function () { + let s = arguments; + return e[c].apply(e, s); + }; + })(a)) + : (!r || r(a, false, e, t)) && + (Er(t, a) && delete t[a], + St( + t, + a, + function () { + return e[a]; + }, + function (c) { + e[a] = c; + } + ) || (t[a] = o)); + } + }; + for (let i in e) { + n(i); + } + } + return t; +} +function qi(t) { + return (function () { + function e() { + let r = this; + t && + Q(t, function (n, i) { + r[n] = i; + }); + } + return e; + })(); +} +function Kn(t) { + return t && (t = gt(Cr ? Cr({}, t) : t)), t; +} +let Eo; +let wo; +let Po; +let bo; +let Do; +let Ao; +let of; +let sf; +let Nu; +let Vi; +let Le = C(() => { + ne(); + (Eo = 'on'), + (wo = 'attachEvent'), + (Po = 'addEventListener'), + (bo = 'detachEvent'), + (Do = 'removeEventListener'), + (Ao = Un), + (of = gt.freeze), + (sf = gt.seal); + (Nu = !{ toString: null }.propertyIsEnumerable('toString')), + (Vi = [ + 'toString', + 'toLocaleString', + 'valueOf', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'constructor', + ]); +}); +function we(t) { + let e = ot(); + return e && e[t] ? e[t] : t === No && ar() ? window : null; +} +function ar() { + return Boolean(typeof window === Xe && window); +} +function Ct() { + return ar() ? window : we(No); +} +function Wn() { + return Boolean(typeof document === Xe && document); +} +function Ne() { + return Wn() ? document : we(Fu); +} +function ko() { + return Boolean(typeof navigator === Xe && navigator); +} +function Ue() { + return ko() ? navigator : we(ku); +} +function Ro() { + return Boolean(typeof history === Xe && history); +} +function Xi() { + return Ro() ? history : we(Ru); +} +function et(t) { + if (t && ju) { + let e = we('__mockLocation'); + if (e) { + return e; + } + } + return typeof location === Xe && location ? location : we(Mu); +} +function Yi() { + return typeof console !== Oe ? console : we(Lu); +} +function Ye() { + return we(Uu); +} +function vt() { + return Boolean((typeof JSON === Xe && JSON) || we(Fo) !== null); +} +function Pe() { + return vt() ? JSON || we(Fo) : null; +} +function $i() { + return we(_u); +} +function Zi() { + return we(Ou); +} +function Qi() { + let t = Ue(); + return t && t.product ? t.product === Hu : false; +} +function qt() { + let t = Ue(); + if (t && (t.userAgent !== Ji || Wi === null)) { + Ji = t.userAgent; + let e = (Ji || '').toLowerCase(); + Wi = Ee(e, Gi) || Ee(e, Ki); + } + return Wi; +} +function or(t) { + if ((t === void 0 && (t = null), !t)) { + let e = Ue() || {}; + t = e ? (e.userAgent || '').toLowerCase() : ''; + } + let r = (t || '').toLowerCase(); + if (Ee(r, Gi)) { + return parseInt(r.split(Gi)[1]); + } + if (Ee(r, Ki)) { + let n = parseInt(r.split(Ki)[1]); + if (n) { + return n + 4; + } + } + return null; +} +function O(t) { + let e = Object[Ie].toString.call(t), + r = ''; + return ( + e === '[object Error]' + ? (r = + "{ stack: '" + + t.stack + + "', message: '" + + t.message + + "', name: '" + + t.name + + "'") + : vt() && (r = Pe().stringify(t)), + e + r + ); +} +let No; +let Fu; +let ku; +let Ru; +let Mu; +let Lu; +let Uu; +let Fo; +let _u; +let Ou; +let Hu; +let Gi; +let Ki; +let Wi; +let Ji; +let ju; +let br = C(() => { + ne(); + Le(); + ('use strict'); + (No = 'window'), + (Fu = 'document'), + (ku = 'navigator'), + (Ru = 'history'), + (Mu = 'location'), + (Lu = 'console'), + (Uu = 'performance'), + (Fo = 'JSON'), + (_u = 'crypto'), + (Ou = 'msCrypto'), + (Hu = 'ReactNative'), + (Gi = 'msie'), + (Ki = 'trident/'), + (Wi = null), + (Ji = null), + (ju = false); +}); +function Mo(t) { + return t ? '"' + t.replace(/\"/g, '') + '"' : ''; +} +function kt(t, e) { + return (t || {}).logger || new Jn(e); +} +let zu; +let Bu; +let Vu; +let Ft; +let Jn; +let Xn = C(() => { + qr(); + br(); + Te(); + Le(); + ('use strict'); + (zu = 'AI (Internal): '), (Bu = 'AI: '), (Vu = 'AITR_'); + Ft = (function () { + function t(e, r, n, i) { + n === void 0 && (n = false); + let a = this; + (a.messageId = e), (a.message = (n ? Bu : zu) + e); + let o = ''; + vt() && (o = Pe().stringify(i)); + let c = (r ? ' message:' + Mo(r) : '') + (i ? ' props:' + Mo(o) : ''); + a.message += c; + } + return (t.dataType = 'MessageData'), t; + })(); + Jn = (function () { + function t(e) { + (this.identifier = 'DiagnosticLogger'), (this.queue = []); + let r = 0, + n = {}; + W(t, this, function (i) { + x(e) && (e = {}), + (i.consoleLoggingLevel = function () { + return a('loggingLevelConsole', 0); + }), + (i.telemetryLoggingLevel = function () { + return a('loggingLevelTelemetry', 1); + }), + (i.maxInternalMessageLimit = function () { + return a('maxMessageLimit', 25); + }), + (i.enableDebugExceptions = function () { + return a('enableDebugExceptions', false); + }), + (i.throwInternal = function (c, s, u, l, f) { + f === void 0 && (f = false); + let m = new Ft(s, u, f, l); + if (i.enableDebugExceptions()) { + throw m; + } + if (!pe(m.message)) { + let I = i.consoleLoggingLevel(); + if (f) { + let E = +m.messageId; + !n[E] && + I >= S.WARNING && + (i.warnToConsole(m.message), (n[E] = true)); + } else { + I >= S.WARNING && i.warnToConsole(m.message); + } + i.logInternalMessage(c, m); + } + }), + (i.warnToConsole = function (c) { + let s = Yi(); + if (s) { + let u = 'log'; + s.warn && (u = 'warn'), j(s[u]) && s[u](c); + } + }), + (i.resetInternalMessageCount = function () { + (r = 0), (n = {}); + }), + (i.logInternalMessage = function (c, s) { + if (!o()) { + let u = true, + l = Vu + s.messageId; + if ( + (n[l] ? (u = false) : (n[l] = true), + u && + (c <= i.telemetryLoggingLevel() && (i.queue.push(s), r++), + r === i.maxInternalMessageLimit())) + ) { + let f = + 'Internal events throttle limit per PageView reached for this app.', + m = new Ft(h.MessageLimitPerPVExceeded, f, false); + i.queue.push(m), i.warnToConsole(f); + } + } + }); + function a(c, s) { + let u = e[c]; + return x(u) ? s : u; + } + function o() { + return r >= i.maxInternalMessageLimit(); + } + }); + } + return t; + })(); +}); +function ct(t, e, r, n, i) { + if (t) { + let a = t; + if ((j(a.getPerfMgr) && (a = a.getPerfMgr()), a)) { + let o = void 0, + c = a.getCtx(ea); + try { + if (((o = a.create(e(), n, i)), o)) { + if ( + c && + o.setCtx && + (o.setCtx(sr.ParentContextKey, c), c.getCtx && c.setCtx) + ) { + let s = c.getCtx(sr.ChildrenContextKey); + s || ((s = []), c.setCtx(sr.ChildrenContextKey, s)), s.push(o); + } + return a.setCtx(ea, o), r(o); + } + } catch (u) { + o && o.setCtx && o.setCtx('exception', u); + } finally { + o && a.fire(o), a.setCtx(ea, c); + } + } + } + return r(); +} +let Dr; +let sr; +let Jr; +let ea; +let Xr = C(() => { + Te(); + Le(); + (Dr = 'ctx'), + (sr = (function () { + function t(e, r, n) { + let i = this, + a = false; + if ( + ((i.start = de()), + (i.name = e), + (i.isAsync = n), + (i.isChildEvt = function () { + return false; + }), + j(r)) + ) { + let o; + a = St(i, 'payload', function () { + return !o && j(r) && ((o = r()), (r = null)), o; + }); + } + (i.getCtx = function (c) { + return c + ? c === t.ParentContextKey || c === t.ChildrenContextKey + ? i[c] + : (i[Dr] || {})[c] + : null; + }), + (i.setCtx = function (c, s) { + if (c) { + if (c === t.ParentContextKey) { + i[c] || + (i.isChildEvt = function () { + return true; + }), + (i[c] = s); + } else if (c === t.ChildrenContextKey) { + i[c] = s; + } else { + let u = (i[Dr] = i[Dr] || {}); + u[c] = s; + } + } + }), + (i.complete = function () { + let c = 0, + s = i.getCtx(t.ChildrenContextKey); + if (Re(s)) { + for (let u = 0; u < s.length; u++) { + let l = s[u]; + l && (c += l.time); + } + } + (i.time = de() - i.start), + (i.exTime = i.time - c), + (i.complete = function () {}), + !a && j(r) && (i.payload = r()); + }); + } + return ( + (t.ParentContextKey = 'parent'), (t.ChildrenContextKey = 'childEvts'), t + ); + })()), + (Jr = (function () { + function t(e) { + (this.ctx = {}), + W(t, this, function (r) { + (r.create = function (n, i, a) { + return new sr(n, i, a); + }), + (r.fire = function (n) { + n && (n.complete(), e && e.perfEvent(n)); + }), + (r.setCtx = function (n, i) { + if (n) { + let a = (r[Dr] = r[Dr] || {}); + a[n] = i; + } + }), + (r.getCtx = function (n) { + return (r[Dr] || {})[n]; + }); + }); + } + return t; + })()), + (ea = 'CoreUtils.doPerf'); +}); +let Lo; +let Uo = C(() => { + Xr(); + qr(); + Le(); + ('use strict'); + Lo = (function () { + function t(e, r) { + let n = this, + i = null, + a = j(e.processTelemetry), + o = j(e.setNextPlugin); + (n._hasRun = false), + (n.getPlugin = function () { + return e; + }), + (n.getNext = function () { + return i; + }), + (n.setNext = function (c) { + i = c; + }), + (n.processTelemetry = function (c, s) { + s || (s = r); + let u = e ? e.identifier : 'TelemetryPluginChain'; + ct( + s ? s.core() : null, + function () { + return u + ':processTelemetry'; + }, + function () { + if (e && a) { + n._hasRun = true; + try { + s.setNext(i), + o && e.setNextPlugin(i), + i && (i._hasRun = false), + e.processTelemetry(c, s); + } catch (f) { + let l = i && i._hasRun; + (!i || !l) && + s + .diagLog() + .throwInternal( + S.CRITICAL, + h.PluginException, + 'Plugin [' + + e.identifier + + '] failed during processTelemetry - ' + + f + ), + i && !l && i.processTelemetry(c, s); + } + } else { + i && ((n._hasRun = true), i.processTelemetry(c, s)); + } + }, + function () { + return { item: c }; + }, + !c.sync + ); + }); + } + return t; + })(); +}); +function ta(t, e) { + let r = []; + if (t && t.length > 0) { + for (let n = null, i = 0; i < t.length; i++) { + let a = t[i]; + if (a && j(a.processTelemetry)) { + let o = new Lo(a, e); + r.push(o), n && n.setNext(o), (n = o); + } + } + } + return r.length > 0 ? r[0] : null; +} +function qu(t, e, r) { + let n = [], + i = !r; + if (t) { + for (; t; ) { + let a = t.getPlugin(); + (i || a === r) && ((i = true), n.push(a)), (t = t.getNext()); + } + } + return i || n.push(r), ta(n, e); +} +function Gu(t, e, r) { + let n = t, + i = false; + return ( + r && + t && + ((n = []), + R(t, function (a) { + (i || a === r) && ((i = true), n.push(a)); + })), + r && !i && (n || (n = []), n.push(r)), + ta(n, e) + ); +} +let Rt; +let Yn = C(() => { + Xn(); + Uo(); + Le(); + ('use strict'); + Rt = (function () { + function t(e, r, n, i) { + let a = this, + o = null; + i !== null && + (e && j(e.getPlugin) + ? (o = qu(e, a, i || e.getPlugin())) + : i + ? (o = Gu(e, a, i)) + : pe(i) && (o = ta(e, a))), + (a.core = function () { + return n; + }), + (a.diagLog = function () { + return kt(n, r); + }), + (a.getCfg = function () { + return r; + }), + (a.getExtCfg = function (c, s) { + s === void 0 && (s = {}); + let u; + if (r) { + let l = r.extensionConfig; + l && c && (u = l[c]); + } + return u || s; + }), + (a.getConfig = function (c, s, u) { + u === void 0 && (u = false); + let l, + f = a.getExtCfg(c, null); + return ( + f && !x(f[s]) ? (l = f[s]) : r && !x(r[s]) && (l = r[s]), + x(l) ? u : l + ); + }), + (a.hasNext = function () { + return o != null; + }), + (a.getNext = function () { + return o; + }), + (a.setNext = function (c) { + o = c; + }), + (a.processNext = function (c) { + let s = o; + s && ((o = s.getNext()), s.processTelemetry(c, a)); + }), + (a.createNew = function (c, s) { + return c === void 0 && (c = null), new t(c || o, r, n, s); + }); + } + return t; + })(); +}); +let _o; +let $n; +let ra = C(() => { + (_o = 'iKey'), ($n = 'extensionConfig'); +}); +let Zn; +let tt; +let na = C(() => { + Yn(); + Le(); + ra(); + ('use strict'); + (Zn = 'getPlugin'), + (tt = (function () { + function t() { + let e = this, + r = false, + n = null, + i = null; + (e.core = null), + (e.diagLog = function (a) { + return e._getTelCtx(a).diagLog(); + }), + (e.isInitialized = function () { + return r; + }), + (e.setInitialized = function (a) { + r = a; + }), + (e.setNextPlugin = function (a) { + i = a; + }), + (e.processNext = function (a, o) { + o + ? o.processNext(a) + : i && j(i.processTelemetry) && i.processTelemetry(a, null); + }), + (e._getTelCtx = function (a) { + a === void 0 && (a = null); + let o = a; + if (!o) { + let c = n || new Rt(null, {}, e.core); + i && i[Zn] + ? (o = c.createNew(null, i[Zn])) + : (o = c.createNew(null, i)); + } + return o; + }), + (e._baseTelInit = function (a, o, c, s) { + a && K(a, $n, [], null, x), + !s && o && (s = o.getProcessTelContext().getNext()); + let u = i; + i && i[Zn] && (u = i[Zn]()), + (e.core = o), + (n = new Rt(s, a, o, u)), + (r = true); + }); + } + return ( + (t.prototype.initialize = function (e, r, n, i) { + this._baseTelInit(e, r, n, i); + }), + t + ); + })()); +}); +function Yr(t, e) { + for (var r = [], n = null, i = t.getNext(); i; ) { + let a = i.getPlugin(); + a && + (n && j(n[Ho]) && j(a[ia]) && n[Ho](a), + (!j(a[jo]) || !a[jo]()) && r.push(a), + (n = a), + (i = i.getNext())); + } + R(r, function (o) { + o.initialize(t.getCfg(), t.core(), e, t.getNext()); + }); +} +function aa(t) { + return t.sort(function (e, r) { + let n = 0, + i = j(r[ia]); + return j(e[ia]) ? (n = i ? e[Oo] - r[Oo] : 1) : i && (n = -1), n; + }); +} +let ia; +let Oo; +let Ho; +let jo; +let oa = C(() => { + Le(); + ('use strict'); + (ia = 'processTelemetry'), + (Oo = 'priority'), + (Ho = 'setNextPlugin'), + (jo = 'isInitialized'); +}); +let sa; +let Ku; +let zo; +let Bo = C(() => { + ne(); + Te(); + na(); + Yn(); + oa(); + Le(); + ('use strict'); + (sa = 500), + (Ku = 'Channel has invalid priority'), + (zo = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + (r.identifier = 'ChannelControllerPlugin'), (r.priority = sa); + let n; + W(e, r, function (c, s) { + (c.setNextPlugin = function (u) {}), + (c.processTelemetry = function (u, l) { + n && + R(n, function (f) { + if (f.length > 0) { + let m = r._getTelCtx(l).createNew(f); + m.processNext(u); + } + }); + }), + (c.getChannelControls = function () { + return n; + }), + (c.initialize = function (u, l, f) { + c.isInitialized() || + (s.initialize(u, l, f), + o((u || {}).channels, f), + R(n, function (m) { + return Yr(new Rt(m, u, l), f); + })); + }); + }); + function i(c) { + R(c, function (s) { + s.priority < sa && Ae(Ku + s.identifier); + }); + } + function a(c) { + c && + c.length > 0 && + ((c = c.sort(function (s, u) { + return s.priority - u.priority; + })), + i(c), + n.push(c)); + } + function o(c, s) { + if ( + ((n = []), + c && + R(c, function (l) { + return a(l); + }), + s) + ) { + let u = []; + R(s, function (l) { + l.priority > sa && u.push(l); + }), + a(u); + } + } + return r; + } + return ( + (e._staticInit = (function () { + let r = e.prototype; + St(r, 'ChannelControls', r.getChannelControls), + St(r, 'channelQueue', r.getChannelControls); + })()), + e + ); + })(tt)); +}); +function pa(t, e) { + let r = ur[Gt] || ei[Gt]; + return r || ((r = ur[Gt] = ur(t, e)), (ei[Gt] = r)), r; +} +function ti(t) { + return t ? t.isEnabled() : true; +} +function Wu(t) { + let e = (t.cookieCfg = t.cookieCfg || {}); + if ( + (K(e, 'domain', t.cookieDomain, ji, x), + K(e, 'path', t.cookiePath || '/', null, x), + x(e[la])) + ) { + let r = void 0; + pe(t[Go]) || (r = !t[Go]), pe(t[Ko]) || (r = !t[Ko]), (e[la] = r); + } + return e; +} +function cr(t, e) { + let r; + if (t) { + r = t.getCookieMgr(); + } else if (e) { + let n = e.cookieCfg; + n[Gt] ? (r = n[Gt]) : (r = ur(e)); + } + return r || (r = pa(e, (t || {}).logger)), r; +} +function ur(t, e) { + var r = Wu(t || ei), + n = r.path || '/', + i = r.domain, + a = r[la] !== false, + o = { + isEnabled: function () { + let c = a && da(e), + s = ei[Gt]; + return c && s && o !== s && (c = ti(s)), c; + }, + setEnabled: function (c) { + a = c !== false; + }, + set: function (c, s, u, l, f) { + if (ti(o)) { + let m = {}, + I = oe(s || ht), + E = I.indexOf(';'); + if ( + (E !== -1 && + ((I = oe(s.substring(0, E))), (m = Xo(s.substring(E + 1)))), + K(m, 'domain', l || i, Pr, pe), + !x(u)) + ) { + let b = qt(); + if (pe(m[ua])) { + let p = de(), + v = p + u * 1e3; + if (v > 0) { + let y = new Date(); + y.setTime(v), + K(m, ua, Yo(y, b ? Vo : qo) || Yo(y, b ? Vo : qo) || ht, Pr); + } + } + b || K(m, 'max-age', ht + u, null, pe); + } + let w = et(); + w && + w.protocol === 'https:' && + (K(m, 'secure', null, null, pe), + fa === null && (fa = !ri((Ue() || {}).userAgent)), + fa && K(m, 'SameSite', 'None', null, pe)), + K(m, 'path', f || n, null, pe); + let L = r.setCookie || Zo; + L(c, $o(I, m)); + } + }, + get: function (c) { + let s = ht; + return ti(o) && (s = (r.getCookie || Ju)(c)), s; + }, + del: function (c, s) { + ti(o) && o.purge(c, s); + }, + purge: function (c, s) { + if (da(e)) { + let u = + ((f = {}), + (f.path = s || '/'), + (f[ua] = 'Thu, 01 Jan 1970 00:00:01 GMT'), + f); + qt() || (u['max-age'] = '0'); + let l = r.delCookie || Zo; + l(c, $o(ht, u)); + } + let f; + }, + }; + return (o[Gt] = o), o; +} +function da(t) { + if (Qn === null) { + Qn = false; + try { + let e = $r || {}; + Qn = e[ca] !== void 0; + } catch (r) { + t && + t.throwInternal( + S.WARNING, + h.CannotAccessCookie, + 'Cannot access document.cookie - ' + G(r), + { exception: O(r) } + ); + } + } + return Qn; +} +function Xo(t) { + let e = {}; + if (t && t.length) { + let r = oe(t).split(';'); + R(r, function (n) { + if (((n = oe(n || ht)), n)) { + let i = n.indexOf('='); + i === -1 + ? (e[n] = null) + : (e[oe(n.substring(0, i))] = oe(n.substring(i + 1))); + } + }); + } + return e; +} +function Yo(t, e) { + return j(t[e]) ? t[e]() : null; +} +function $o(t, e) { + let r = t || ht; + return ( + Q(e, function (n, i) { + r += '; ' + n + (x(i) ? ht : '=' + i); + }), + r + ); +} +function Ju(t) { + let e = ht; + if ($r) { + let r = $r[ca] || ht; + Wo !== r && ((Jo = Xo(r)), (Wo = r)), (e = oe(Jo[t] || ht)); + } + return e; +} +function Zo(t, e) { + $r && ($r[ca] = t + '=' + e); +} +function ri(t) { + return _(t) + ? !!( + Ee(t, 'CPU iPhone OS 12') || + Ee(t, 'iPad; CPU OS 12') || + (Ee(t, 'Macintosh; Intel Mac OS X 10_14') && + Ee(t, 'Version/') && + Ee(t, 'Safari')) || + (Ee(t, 'Macintosh; Intel Mac OS X 10_14') && + Bi(t, 'AppleWebKit/605.1.15 (KHTML, like Gecko)')) || + Ee(t, 'Chrome/5') || + Ee(t, 'Chrome/6') || + (Ee(t, 'UnrealEngine') && !Ee(t, 'Chrome')) || + Ee(t, 'UCBrowser/12') || + Ee(t, 'UCBrowser/11') + ) + : false; +} +let Vo; +let qo; +let ca; +let ua; +let la; +let Go; +let Ko; +let Gt; +let ht; +let Qn; +let fa; +let Wo; +let $r; +let Jo; +let ei; +let ni = C(() => { + qr(); + br(); + Le(); + (Vo = 'toGMTString'), + (qo = 'toUTCString'), + (ca = 'cookie'), + (ua = 'expires'), + (la = 'enabled'), + (Go = 'isCookieUseDisabled'), + (Ko = 'disableCookiesUsage'), + (Gt = '_ckMgr'), + (ht = ''), + (Qn = null), + (fa = null), + (Wo = null), + ($r = Ne()), + (Jo = {}), + (ei = {}); +}); +let Xu; +let Qo; +let Zr; +let ma = C(() => { + ne(); + Te(); + Bo(); + Yn(); + oa(); + Xr(); + ni(); + Le(); + ra(); + ('use strict'); + (Xu = 'Extensions must provide callback to initialize'), + (Qo = '_notificationManager'), + (Zr = (function () { + function t() { + let e = false, + r, + n, + i, + a, + o; + W(t, this, function (c) { + (c._extensions = new Array()), + (n = new zo()), + (c.logger = Dt({ + throwInternal: function (s, u, l, f, m) { + m === void 0 && (m = false); + }, + warnToConsole: function (s) {}, + resetInternalMessageCount: function () {}, + })), + (r = []), + (c.isInitialized = function () { + return e; + }), + (c.initialize = function (s, u, l, f) { + c.isInitialized() && + Ae('Core should not be initialized more than once'), + (!s || x(s.instrumentationKey)) && + Ae('Please provide instrumentation key'), + (i = f), + (c[Qo] = f), + (c.config = s || {}), + (s.extensions = x(s.extensions) ? [] : s.extensions); + let m = ge(s, $n); + (m.NotificationManager = f), l && (c.logger = l); + let I = []; + I.push.apply(I, u.concat(s.extensions)), (I = aa(I)); + let E = [], + b = [], + p = {}; + R(I, function (v) { + (x(v) || x(v.initialize)) && Ae(Xu); + let y = v.priority, + w = v.identifier; + v && + y && + (x(p[y]) + ? (p[y] = w) + : l.warnToConsole( + 'Two extensions have same priority #' + + y + + ' - ' + + p[y] + + ', ' + + w + )), + !y || y < n.priority ? E.push(v) : b.push(v); + }), + I.push(n), + E.push(n), + (I = aa(I)), + (c._extensions = I), + Yr(new Rt([n], s, c), I), + Yr(new Rt(E, s, c), I), + (c._extensions = E), + c.getTransmissionControls().length === 0 && + Ae('No channels available'), + (e = true), + c.releaseQueue(); + }), + (c.getTransmissionControls = function () { + return n.getChannelControls(); + }), + (c.track = function (s) { + K(s, _o, c.config.instrumentationKey, null, Gn), + K(s, 'time', Me(new Date()), null, Gn), + K(s, 'ver', '4.0', null, x), + c.isInitialized() + ? c.getProcessTelContext().processNext(s) + : r.push(s); + }), + (c.getProcessTelContext = function () { + let s = c._extensions, + u = s; + return ( + (!s || s.length === 0) && (u = [n]), new Rt(u, c.config, c) + ); + }), + (c.getNotifyMgr = function () { + return ( + i || + ((i = Dt({ + addNotificationListener: function (s) {}, + removeNotificationListener: function (s) {}, + eventsSent: function (s) {}, + eventsDiscarded: function (s, u) {}, + eventsSendRequest: function (s, u) {}, + })), + (c[Qo] = i)), + i + ); + }), + (c.getCookieMgr = function () { + return o || (o = ur(c.config, c.logger)), o; + }), + (c.setCookieMgr = function (s) { + o = s; + }), + (c.getPerfMgr = function () { + return ( + a || + (c.config && + c.config.enablePerfMgr && + (a = new Jr(c.getNotifyMgr()))), + a + ); + }), + (c.setPerfMgr = function (s) { + a = s; + }), + (c.eventCnt = function () { + return r.length; + }), + (c.releaseQueue = function () { + r.length > 0 && + (R(r, function (s) { + c.getProcessTelContext().processNext(s); + }), + (r = [])); + }); + }); + } + return t; + })()); +}); +let Qr; +let ga = C(() => { + Te(); + Le(); + Qr = (function () { + function t(e) { + this.listeners = []; + let r = !!(e || {}).perfEvtsSendAll; + W(t, this, function (n) { + (n.addNotificationListener = function (i) { + n.listeners.push(i); + }), + (n.removeNotificationListener = function (i) { + for (let a = Nt(n.listeners, i); a > -1; ) { + n.listeners.splice(a, 1), (a = Nt(n.listeners, i)); + } + }), + (n.eventsSent = function (i) { + R(n.listeners, function (a) { + a && + a.eventsSent && + setTimeout(function () { + return a.eventsSent(i); + }, 0); + }); + }), + (n.eventsDiscarded = function (i, a) { + R(n.listeners, function (o) { + o && + o.eventsDiscarded && + setTimeout(function () { + return o.eventsDiscarded(i, a); + }, 0); + }); + }), + (n.eventsSendRequest = function (i, a) { + R(n.listeners, function (o) { + if (o && o.eventsSendRequest) { + if (a) { + setTimeout(function () { + return o.eventsSendRequest(i, a); + }, 0); + } else { + try { + o.eventsSendRequest(i, a); + } catch (c) {} + } + } + }); + }), + (n.perfEvent = function (i) { + i && + (r || !i.isChildEvt()) && + R(n.listeners, function (a) { + if (a && a.perfEvent) { + if (i.isAsync) { + setTimeout(function () { + return a.perfEvent(i); + }, 0); + } else { + try { + a.perfEvent(i); + } catch (o) {} + } + } + }); + }); + }); + } + return t; + })(); +}); +let en; +let es = C(() => { + ne(); + ma(); + vo(); + ga(); + Xr(); + Xn(); + Te(); + Le(); + en = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + return ( + W(e, r, function (n, i) { + (n.initialize = function (c, s, u, l) { + i.initialize(c, s, u || new Jn(c), l || new Qr(c)); + }), + (n.track = function (c) { + ct( + n.getPerfMgr(), + function () { + return 'AppInsightsCore:track'; + }, + function () { + c === null && (o(c), Ae('Invalid telemetry item')), + a(c), + i.track(c); + }, + function () { + return { item: c }; + }, + !c.sync + ); + }), + (n.addNotificationListener = function (c) { + let s = n.getNotifyMgr(); + s && s.addNotificationListener(c); + }), + (n.removeNotificationListener = function (c) { + let s = n.getNotifyMgr(); + s && s.removeNotificationListener(c); + }), + (n.pollInternalLogs = function (c) { + let s = n.config.diagnosticLogInterval; + return ( + (!s || !(s > 0)) && (s = 1e4), + setInterval(function () { + let u = n.logger ? n.logger.queue : []; + R(u, function (l) { + let f = { + name: c || 'InternalMessageId: ' + l.messageId, + iKey: n.config.instrumentationKey, + time: Me(new Date()), + baseType: Ft.dataType, + baseData: { message: l.message }, + }; + n.track(f); + }), + (u.length = 0); + }, s) + ); + }); + function a(c) { + if (x(c.name)) { + throw (o(c), Error('telemetry name required')); + } + } + function o(c) { + let s = n.getNotifyMgr(); + s && s.eventsDiscarded([c], go.InvalidEvent); + } + }), + r + ); + } + return e; + })(Zr); +}); +function ns(t) { + t < 0 && (t >>>= 0), + (tn = (123456789 + t) & Kt), + (rn = (987654321 - t) & Kt), + (rs = true); +} +function is() { + try { + let t = de() & 2147483647; + ns(((Math.random() * ts) ^ t) + t); + } catch (e) {} +} +function ii(t) { + return t > 0 ? Math.floor((It() / Kt) * (t + 1)) >>> 0 : 0; +} +function It(t) { + let e, + r = $i() || Zi(); + return ( + r && r.getRandomValues + ? (e = r.getRandomValues(new Uint32Array(1))[0] & Kt) + : qt() + ? (rs || is(), (e = ai() & Kt)) + : (e = Math.floor((ts * Math.random()) | 0)), + t || (e >>>= 0), + e + ); +} +function va(t) { + t ? ns(t) : is(); +} +function ai(t) { + (rn = (36969 * (rn & 65535) + (rn >> 16)) & Kt), + (tn = (18e3 * (tn & 65535) + (tn >> 16)) & Kt); + let e = ((((rn << 16) + (tn & 65535)) >>> 0) & Kt) | 0; + return t || (e >>>= 0), e; +} +let ts; +let Kt; +let rs; +let tn; +let rn; +let ha = C(() => { + br(); + Le(); + (ts = 4294967296), + (Kt = 4294967295), + (rs = false), + (tn = 123456789), + (rn = 987654321); +}); +function Mt(t, e) { + let r = false, + n = Ct(); + n && ((r = zt(n, t, e)), (r = zt(n.body, t, e) || r)); + let i = Ne(); + return i && (r = Jt.Attach(i, t, e) || r), r; +} +function as() { + function t() { + return ii(15); + } + return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(Yu, function (e) { + let r = t() | 0, + n = e === 'x' ? r : (r & 3) | 8; + return n.toString(16); + }); +} +function os() { + let t = Ye(); + return t && t.now ? t.now() : de(); +} +function Wt(t) { + t === void 0 && (t = 22); + for ( + var e = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', + r = It() >>> 0, + n = 0, + i = ''; + i.length < t; + + ) { + n++, + (i += e.charAt(r & 63)), + (r >>>= 6), + n === 5 && ((r = (((It() << 2) & 4294967295) | (r & 3)) >>> 0), (n = 0)); + } + return i; +} +function He() { + for ( + var t = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', + 'a', + 'b', + 'c', + 'd', + 'e', + 'f', + ], + e = '', + r, + n = 0; + n < 4; + n++ + ) { + (r = It()), + (e += + t[r & 15] + + t[(r >> 4) & 15] + + t[(r >> 8) & 15] + + t[(r >> 12) & 15] + + t[(r >> 16) & 15] + + t[(r >> 20) & 15] + + t[(r >> 24) & 15] + + t[(r >> 28) & 15]); + } + let i = t[(8 + (It() & 3)) | 0]; + return ( + e.substr(0, 8) + + e.substr(9, 4) + + '4' + + e.substr(13, 3) + + i + + e.substr(16, 3) + + e.substr(19, 12) + ); +} +function Xt(t, e) { + let r = pa(t, e), + n = on._canUseCookies; + return ( + nn === null && + ((nn = []), + (an = n), + St( + on, + '_canUseCookies', + function () { + return an; + }, + function (i) { + (an = i), + R(nn, function (a) { + a.setEnabled(i); + }); + } + )), + Nt(nn, r) === -1 && nn.push(r), + Gr(n) && r.setEnabled(n), + Gr(an) && r.setEnabled(an), + r + ); +} +function oi() { + Xt().setEnabled(false); +} +function xa(t) { + return Xt(null, t).isEnabled(); +} +function ya(t, e) { + return Xt(null, t).get(e); +} +function Sa(t, e, r, n) { + Xt(null, t).set(e, r, null, n); +} +function Ca(t, e) { + return Xt(null, t).del(e); +} +let nn; +let an; +let on; +let Yu; +let Jt; +let ss = C(() => { + ne(); + ni(); + br(); + Le(); + ha(); + ('use strict'); + nn = null; + (on = { + _canUseCookies: void 0, + isTypeof: Hi, + isUndefined: pe, + isNullOrUndefined: x, + hasOwnProperty: Er, + isFunction: j, + isObject: st, + isDate: wr, + isArray: Re, + isError: Bt, + isString: _, + isNumber: ir, + isBoolean: Gr, + toISOString: Me, + arrForEach: R, + arrIndexOf: Nt, + arrMap: Vt, + arrReduce: Kr, + strTrim: oe, + objCreate: Dt, + objKeys: Qe, + objDefineAccessors: St, + addEventHandler: Mt, + dateNow: de, + isIE: qt, + disableCookies: oi, + newGuid: as, + perfNow: os, + newId: Wt, + randomValue: ii, + random32: It, + mwcRandomSeed: va, + mwcRandom32: ai, + generateW3CId: He, + }), + (Yu = /[xy]/g), + (Jt = { Attach: zt, AttachEvent: zt, Detach: qn, DetachEvent: qn }); +}); +function Ia(t, e) { + if (t) { + for (let r = 0; r < t.length && !e(t[r], r); r++) {} + } +} +function Ta(t, e, r, n, i) { + i >= 0 && + i <= 2 && + Ia(t, function (a, o) { + let c = a.cbks, + s = c[us[i]]; + if (s) { + e.ctx = function () { + let f = (n[o] = n[o] || {}); + return f; + }; + try { + s.apply(e.inst, r); + } catch (f) { + let u = e.err; + try { + let l = c[us[2]]; + l && ((e.err = f), l.apply(e.inst, r)); + } catch (m) { + } finally { + e.err = u; + } + } + } + }); +} +function Qu(t) { + return function () { + let e = this, + r = arguments, + n = t.h, + i = { name: t.n, inst: e, ctx: null, set: s }, + a = [], + o = c([i], r); + function c(l, f) { + return ( + Ia(f, function (m) { + l.push(m); + }), + l + ); + } + function s(l, f) { + (r = c([], r)), (r[l] = f), (o = c([i], r)); + } + Ta(n, i, o, a, 0); + let u = t.f; + try { + i.rslt = u.apply(e, r); + } catch (l) { + throw ((i.err = l), Ta(n, i, o, a, 3), l); + } + return Ta(n, i, o, a, 1), i.rslt; + }; +} +function el(t) { + if (t) { + if (ls) { + return ls(t); + } + let e = t[$u] || t[Ie] || t[Zu]; + if (e) { + return e; + } + } + return null; +} +function fs(t, e, r) { + let n = null; + return t && (Er(t, e) ? (n = t) : r && (n = fs(el(t), e, false))), n; +} +function Ea(t, e, r) { + return t ? sn(t[Ie], e, r, false) : null; +} +function sn(t, e, r, n) { + if ((n === void 0 && (n = true), t && e && r)) { + let i = fs(t, e, n); + if (i) { + let a = i[e]; + if (typeof a === mt) { + let o = a[cs]; + if (!o) { + o = { i: 0, n: e, f: a, h: [] }; + let c = Qu(o); + (c[cs] = o), (i[e] = c); + } + let s = { + id: o.i, + cbks: r, + rm: function () { + let u = this.id; + Ia(o.h, function (l, f) { + if (l.id === u) { + return o.h.splice(f, 1), 1; + } + }); + }, + }; + return o.i++, o.h.push(s), s; + } + } + } + return null; +} +let cs; +let us; +let $u; +let Zu; +let ls; +let ps = C(() => { + ne(); + Le(); + (cs = '_aiHooks'), + (us = ['req', 'rsp', 'hkErr', 'fnErr']), + ($u = '__proto__'), + (Zu = 'constructor'); + ls = Object.getPrototypeOf; +}); +let J = C(() => { + es(); + ma(); + na(); + ha(); + ss(); + Le(); + br(); + ne(); + ga(); + Xr(); + Xn(); + qr(); + ps(); + ni(); +}); +let te; +let wa = C(() => { + te = { + requestContextHeader: 'Request-Context', + requestContextTargetKey: 'appId', + requestContextAppIdFormat: 'appId=cid-v1:', + requestIdHeader: 'Request-Id', + traceParentHeader: 'traceparent', + traceStateHeader: 'tracestate', + sdkContextHeader: 'Sdk-Context', + sdkContextHeaderAppIdRequest: 'appId', + requestContextHeaderLowerCase: 'request-context', + }; +}); +function si(t, e, r) { + let n = e.length, + i = Pa(t, e); + if (i.length !== n) { + for (var a = 0, o = i; r[o] !== void 0; ) { + a++, (o = i.substring(0, 150 - 3) + ba(a)); + } + i = o; + } + return i; +} +function Pa(t, e) { + let r; + return ( + e && + ((e = oe(e.toString())), + e.length > 150 && + ((r = e.substring(0, 150)), + t.throwInternal( + S.WARNING, + h.NameTooLong, + 'name is too long. It has been truncated to ' + 150 + ' characters.', + { name: e }, + true + ))), + r || e + ); +} +function ae(t, e, r) { + r === void 0 && (r = 1024); + let n; + return ( + e && + ((r = r || 1024), + (e = oe(e)), + e.toString().length > r && + ((n = e.toString().substring(0, r)), + t.throwInternal( + S.WARNING, + h.StringValueTooLong, + 'string value is too long. It has been truncated to ' + + r + + ' characters.', + { value: e }, + true + ))), + n || e + ); +} +function Tt(t, e) { + return li(t, e, 2048, h.UrlTooLong); +} +function Ar(t, e) { + let r; + return ( + e && + e.length > 32768 && + ((r = e.substring(0, 32768)), + t.throwInternal( + S.WARNING, + h.MessageTruncated, + 'message is too long, it has been truncated to ' + + 32768 + + ' characters.', + { message: e }, + true + )), + r || e + ); +} +function ci(t, e) { + let r; + if (e) { + let n = '' + e; + n.length > 32768 && + ((r = n.substring(0, 32768)), + t.throwInternal( + S.WARNING, + h.ExceptionTruncated, + 'exception is too long, it has been truncated to ' + + 32768 + + ' characters.', + { exception: e }, + true + )); + } + return r || e; +} +function je(t, e) { + if (e) { + let r = {}; + Q(e, function (n, i) { + if (st(i) && vt()) { + try { + i = Pe().stringify(i); + } catch (a) { + t.throwInternal( + S.WARNING, + h.CannotSerializeObjectNonSerializable, + 'custom property is not valid', + { exception: a }, + true + ); + } + } + (i = ae(t, i, 8192)), (n = si(t, n, r)), (r[n] = i); + }), + (e = r); + } + return e; +} +function ze(t, e) { + if (e) { + let r = {}; + Q(e, function (n, i) { + (n = si(t, n, r)), (r[n] = i); + }), + (e = r); + } + return e; +} +function ui(t, e) { + return e && li(t, e, 128, h.IdTooLong).toString(); +} +function li(t, e, r, n) { + let i; + return ( + e && + ((e = oe(e)), + e.length > r && + ((i = e.substring(0, r)), + t.throwInternal( + S.WARNING, + n, + 'input is too long, it has been truncated to ' + r + ' characters.', + { data: e }, + true + ))), + i || e + ); +} +function ba(t) { + let e = '00' + t; + return e.substr(e.length - 3); +} +let Da; +let ut = C(() => { + J(); + Da = { + MAX_NAME_LENGTH: 150, + MAX_ID_LENGTH: 128, + MAX_PROPERTY_LENGTH: 8192, + MAX_STRING_LENGTH: 1024, + MAX_URL_LENGTH: 2048, + MAX_MESSAGE_LENGTH: 32768, + MAX_EXCEPTION_LENGTH: 32768, + sanitizeKeyAndAddUniqueness: si, + sanitizeKey: Pa, + sanitizeString: ae, + sanitizeUrl: Tt, + sanitizeMessage: Ar, + sanitizeException: ci, + sanitizeProperties: je, + sanitizeMeasurements: ze, + sanitizeId: ui, + sanitizeInput: li, + padNumber: ba, + trim: oe, + }; +}); +function Lt(t) { + let e = null; + if (j(Event)) { + e = new Event(t); + } else { + let r = Ne(); + r && + r.createEvent && + ((e = r.createEvent('Event')), e.initEvent(t, true, true)); + } + return e; +} +let Aa = C(() => { + J(); +}); +function ee(t, e) { + return ( + e === void 0 && (e = false), + t == null ? e : t.toString().toLowerCase() === 'true' + ); +} +function Ge(t) { + (isNaN(t) || t < 0) && (t = 0), (t = Math.round(t)); + let e = '' + (t % 1e3), + r = '' + (Math.floor(t / 1e3) % 60), + n = '' + (Math.floor(t / (1e3 * 60)) % 60), + i = '' + (Math.floor(t / (1e3 * 60 * 60)) % 24), + a = Math.floor(t / (1e3 * 60 * 60 * 24)); + return ( + (e = e.length === 1 ? '00' + e : e.length === 2 ? '0' + e : e), + (r = r.length < 2 ? '0' + r : r), + (n = n.length < 2 ? '0' + n : n), + (i = i.length < 2 ? '0' + i : i), + (a > 0 ? a + '.' : '') + i + ':' + n + ':' + r + '.' + e + ); +} +function Nr() { + let t = Ue(); + return 'sendBeacon' in t && t.sendBeacon; +} +function cn(t, e) { + let r = null; + return ( + R(t, function (n) { + if (n.identifier === e) { + return (r = n), -1; + } + }), + r + ); +} +function un(t, e, r, n, i) { + return !i && _(t) && (t === 'Script error.' || t === 'Script error'); +} +let ln = C(() => { + J(); +}); +let Et; +let lr; +let Ut; +let Fr; +let fn; +let le; +let lt = C(() => { + (Et = 'Microsoft_ApplicationInsights_BypassAjaxInstrumentation'), + (lr = 'sampleRate'), + (Ut = 'ProcessLegacy'), + (Fr = 'http.method'), + (fn = 'https://dc.services.visualstudio.com'), + (le = 'not_specified'); +}); +let Yt; +let Ke; +let Na = C(() => { + (function (t) { + (t[(t.LocalStorage = 0)] = 'LocalStorage'), + (t[(t.SessionStorage = 1)] = 'SessionStorage'); + })(Yt || (Yt = {})); + (function (t) { + (t[(t.AI = 0)] = 'AI'), + (t[(t.AI_AND_W3C = 1)] = 'AI_AND_W3C'), + (t[(t.W3C = 2)] = 'W3C'); + })(Ke || (Ke = {})); +}); +function Fa() { + return kr() ? fi(Yt.LocalStorage) : null; +} +function fi(t) { + try { + if (x(ot())) { + return null; + } + let e = new Date(), + r = we(t === Yt.LocalStorage ? 'localStorage' : 'sessionStorage'); + r.setItem(e.toString(), e.toString()); + let n = r.getItem(e.toString()) !== e.toString(); + if ((r.removeItem(e.toString()), !n)) { + return r; + } + } catch (i) {} + return null; +} +function ka() { + return wt() ? fi(Yt.SessionStorage) : null; +} +function pn() { + (fr = false), (pr = false); +} +function kr() { + return fr === void 0 && (fr = !!fi(Yt.LocalStorage)), fr; +} +function dn(t, e) { + let r = Fa(); + if (r !== null) { + try { + return r.getItem(e); + } catch (n) { + (fr = false), + t.throwInternal( + S.WARNING, + h.BrowserCannotReadLocalStorage, + 'Browser failed read of local storage. ' + G(n), + { exception: O(n) } + ); + } + } + return null; +} +function mn(t, e, r) { + let n = Fa(); + if (n !== null) { + try { + return n.setItem(e, r), true; + } catch (i) { + (fr = false), + t.throwInternal( + S.WARNING, + h.BrowserCannotWriteLocalStorage, + 'Browser failed write to local storage. ' + G(i), + { exception: O(i) } + ); + } + } + return false; +} +function gn(t, e) { + let r = Fa(); + if (r !== null) { + try { + return r.removeItem(e), true; + } catch (n) { + (fr = false), + t.throwInternal( + S.WARNING, + h.BrowserFailedRemovalFromLocalStorage, + 'Browser failed removal of local storage item. ' + G(n), + { exception: O(n) } + ); + } + } + return false; +} +function wt() { + return pr === void 0 && (pr = !!fi(Yt.SessionStorage)), pr; +} +function Ra() { + let t = []; + return ( + wt() && + Q(we('sessionStorage'), function (e) { + t.push(e); + }), + t + ); +} +function $t(t, e) { + let r = ka(); + if (r !== null) { + try { + return r.getItem(e); + } catch (n) { + (pr = false), + t.throwInternal( + S.WARNING, + h.BrowserCannotReadSessionStorage, + 'Browser failed read of session storage. ' + G(n), + { exception: O(n) } + ); + } + } + return null; +} +function Zt(t, e, r) { + let n = ka(); + if (n !== null) { + try { + return n.setItem(e, r), true; + } catch (i) { + (pr = false), + t.throwInternal( + S.WARNING, + h.BrowserCannotWriteSessionStorage, + 'Browser failed write to session storage. ' + G(i), + { exception: O(i) } + ); + } + } + return false; +} +function vn(t, e) { + let r = ka(); + if (r !== null) { + try { + return r.removeItem(e), true; + } catch (n) { + (pr = false), + t.throwInternal( + S.WARNING, + h.BrowserFailedRemovalFromSessionStorage, + 'Browser failed removal of session storage item. ' + G(n), + { exception: O(n) } + ); + } + } + return false; +} +let fr; +let pr; +let Ma = C(() => { + J(); + Na(); + (fr = void 0), (pr = void 0); +}); +function dr(t) { + let e = ms, + r = tl, + n = r[e]; + return ( + ds.createElement + ? r[e] || (n = r[e] = ds.createElement('a')) + : (n = { host: pi(t, true) }), + (n.href = t), + e++, + e >= r.length && (e = 0), + (ms = e), + n + ); +} +function hn(t) { + let e, + r = dr(t); + return r && (e = r.href), e; +} +function La(t) { + let e, + r = dr(t); + return r && (e = r.pathname), e; +} +function xn(t, e) { + return t ? t.toUpperCase() + ' ' + e : e; +} +function pi(t, e) { + let r = yn(t, e) || ''; + if (r) { + let n = r.match(/(www[0-9]?\.)?(.[^/:]+)(\:[\d]+)?/i); + if (n != null && n.length > 3 && _(n[2]) && n[2].length > 0) { + return n[2] + (n[3] || ''); + } + } + return r; +} +function yn(t, e) { + let r = null; + if (t) { + let n = t.match(/(\w*):\/\/(.[^/:]+)(\:[\d]+)?/i); + if ( + n != null && + n.length > 2 && + _(n[2]) && + n[2].length > 0 && + ((r = n[2] || ''), e && n.length > 2) + ) { + let i = (n[1] || '').toLowerCase(), + a = n[3] || ''; + ((i === 'http' && a === ':80') || (i === 'https' && a === ':443')) && + (a = ''), + (r += a); + } + } + return r; +} +let ds; +let ms; +let tl; +let Ua = C(() => { + J(); + (ds = Ne() || {}), (ms = 0), (tl = [null, null, null, null, null]); +}); +function Rr(t) { + return rl.indexOf(t.toLowerCase()) !== -1; +} +function gs(t, e, r, n) { + let i, + a = n, + o = n; + if (e && e.length > 0) { + let c = dr(e); + if (((i = c.host), !a)) { + if (c.pathname != null) { + let s = c.pathname.length === 0 ? '/' : c.pathname; + s.charAt(0) !== '/' && (s = '/' + s), + (o = c.pathname), + (a = ae(t, r ? r + ' ' + s : s)); + } else { + a = ae(t, e); + } + } + } else { + (i = n), (a = n); + } + return { target: i, name: a, data: o }; +} +function mr() { + let t = Ye(); + if (t && t.now && t.timing) { + let e = t.now() + t.timing.navigationStart; + if (e > 0) { + return e; + } + } + return de(); +} +function ve(t, e) { + let r = null; + return t !== 0 && e !== 0 && !x(t) && !x(e) && (r = e - t), r; +} +let rl; +let Sn; +let _a; +let Pt; +let Oa; +let Ha = C(() => { + J(); + wa(); + ut(); + Aa(); + ln(); + lt(); + Ma(); + Ua(); + rl = [ + 'https://dc.services.visualstudio.com/v2/track', + 'https://breeze.aimon.applicationinsights.io/v2/track', + 'https://dc-int.services.visualstudio.com/v2/track', + ]; + (Sn = { + NotSpecified: le, + createDomEvent: Lt, + disableStorage: pn, + isInternalApplicationInsightsEndpoint: Rr, + canUseLocalStorage: kr, + getStorage: dn, + setStorage: mn, + removeStorage: gn, + canUseSessionStorage: wt, + getSessionStorageKeys: Ra, + getSessionStorage: $t, + setSessionStorage: Zt, + removeSessionStorage: vn, + disableCookies: oi, + canUseCookies: xa, + disallowsSameSiteNone: ri, + setCookie: Sa, + stringToBoolOrDefault: ee, + getCookie: ya, + deleteCookie: Ca, + trim: oe, + newId: Wt, + random32: function () { + return It(true); + }, + generateW3CId: He, + isArray: Re, + isError: Bt, + isDate: wr, + toISOStringForIE8: Me, + getIEVersion: or, + msToTimeSpan: Ge, + isCrossOriginError: un, + dump: O, + getExceptionName: G, + addEventHandler: zt, + IsBeaconApiSupported: Nr, + getExtension: cn, + }), + (_a = { + parseUrl: dr, + getAbsoluteUrl: hn, + getPathName: La, + getCompleteUrl: xn, + parseHost: pi, + parseFullHost: yn, + }), + (Pt = { + correlationIdPrefix: 'cid-v1:', + canIncludeCorrelationHeader: function (t, e, r) { + if (!e || (t && t.disableCorrelationHeaders)) { + return false; + } + if (t && t.correlationHeaderExcludePatterns) { + for (var n = 0; n < t.correlationHeaderExcludePatterns.length; n++) { + if (t.correlationHeaderExcludePatterns[n].test(e)) { + return false; + } + } + } + let i = dr(e).host.toLowerCase(); + if ( + (i && + (i.indexOf(':443') !== -1 || i.indexOf(':80') !== -1) && + (i = (yn(e, true) || '').toLowerCase()), + (!t || !t.enableCorsCorrelation) && i && i !== r) + ) { + return false; + } + let a = t && t.correlationHeaderDomains; + if (a) { + let o; + if ( + (R(a, function (u) { + let l = new RegExp( + u + .toLowerCase() + .replace(/\\/g, '\\\\') + .replace(/\./g, '\\.') + .replace(/\*/g, '.*') + ); + o = o || l.test(i); + }), + !o) + ) { + return false; + } + } + let c = t && t.correlationHeaderExcludedDomains; + if (!c || c.length === 0) { + return true; + } + for (var n = 0; n < c.length; n++) { + let s = new RegExp( + c[n] + .toLowerCase() + .replace(/\\/g, '\\\\') + .replace(/\./g, '\\.') + .replace(/\*/g, '.*') + ); + if (s.test(i)) { + return false; + } + } + return i && i.length > 0; + }, + getCorrelationContext: function (t) { + if (t) { + let e = Pt.getCorrelationContextValue(t, te.requestContextTargetKey); + if (e && e !== Pt.correlationIdPrefix) { + return e; + } + } + }, + getCorrelationContextValue: function (t, e) { + if (t) { + for (let r = t.split(','), n = 0; n < r.length; ++n) { + let i = r[n].split('='); + if (i.length === 2 && i[0] === e) { + return i[1]; + } + } + } + }, + }); + Oa = { Now: mr, GetDuration: ve }; +}); +function di(t) { + if (!t) { + return {}; + } + let e = t.split(nl), + r = Kr( + e, + function (i, a) { + let o = a.split(il); + if (o.length === 2) { + let c = o[0].toLowerCase(), + s = o[1]; + i[c] = s; + } + return i; + }, + {} + ); + if (Qe(r).length > 0) { + if (r.endpointsuffix) { + let n = r.location ? r.location + '.' : ''; + r.ingestionendpoint = + r.ingestionendpoint || 'https://' + n + 'dc.' + r.endpointsuffix; + } + r.ingestionendpoint = r.ingestionendpoint || fn; + } + return r; +} +let nl; +let il; +let ja; +let vs = C(() => { + lt(); + J(); + (nl = ';'), (il = '='); + ja = { parse: di }; +}); +let Cn; +let za = C(() => { + Cn = (function () { + function t() {} + return t; + })(); +}); +let In; +let Ba = C(() => { + ne(); + za(); + In = (function (t) { + H(e, t); + function e() { + return t.call(this) || this; + } + return e; + })(Cn); +}); +let hs; +let xs = C(() => { + hs = (function () { + function t() { + (this.ver = 1), (this.sampleRate = 100), (this.tags = {}); + } + return t; + })(); +}); +let Tn; +let ys = C(() => { + ne(); + xs(); + ut(); + J(); + lt(); + Tn = (function (t) { + H(e, t); + function e(r, n, i) { + let a = t.call(this) || this; + return ( + (a.name = ae(r, i) || le), + (a.data = n), + (a.time = Me(new Date())), + (a.aiDataContract = { + time: 1, + iKey: 1, + name: 1, + sampleRate: function () { + return a.sampleRate === 100 ? 4 : 1; + }, + tags: 1, + data: 1, + }), + a + ); + } + return e; + })(hs); +}); +let mi; +let Va = C(() => { + mi = (function () { + function t() { + (this.ver = 2), (this.properties = {}), (this.measurements = {}); + } + return t; + })(); +}); +let Be; +let Ss = C(() => { + ne(); + Va(); + ut(); + lt(); + Be = (function (t) { + H(e, t); + function e(r, n, i, a) { + let o = t.call(this) || this; + return ( + (o.aiDataContract = { + ver: 1, + name: 1, + properties: 0, + measurements: 0, + }), + (o.name = ae(r, n) || le), + (o.properties = je(r, i)), + (o.measurements = ze(r, a)), + o + ); + } + return ( + (e.envelopeType = 'Microsoft.ApplicationInsights.{0}.Event'), + (e.dataType = 'EventData'), + e + ); + })(mi); +}); +let Cs; +let Is = C(() => { + Cs = (function () { + function t() {} + return t; + })(); +}); +let Ts; +let Es = C(() => { + Ts = (function () { + function t() { + (this.ver = 2), + (this.exceptions = []), + (this.properties = {}), + (this.measurements = {}); + } + return t; + })(); +}); +let ws; +let Ps = C(() => { + ws = (function () { + function t() { + (this.hasFullStack = true), (this.parsedStack = []); + } + return t; + })(); +}); +function Ka(t, e) { + let r = t; + return ( + r && + !_(r) && + (JSON && JSON.stringify + ? ((r = JSON.stringify(t)), + e && + (!r || r === '{}') && + (j(t.toString) ? (r = t.toString()) : (r = '' + t))) + : (r = '' + t + ' - (Missing JSON.stringify)')), + r || '' + ); +} +function As(t, e) { + let r = t; + return ( + t && + ((r = t[Ga] || t[Ds] || ''), + r && !_(r) && (r = Ka(r, true)), + t.filename && + (r = + r + + ' @' + + (t.filename || '') + + ':' + + (t.lineno || '?') + + ':' + + (t.colno || '?'))), + e && + e !== 'String' && + e !== 'Object' && + e !== 'Error' && + (r || '').indexOf(e) === -1 && + (r = e + ': ' + r), + r || '' + ); +} +function ol(t) { + return st(t) ? 'hasFullStack' in t && 'typeName' in t : false; +} +function sl(t) { + return st(t) ? 'ver' in t && 'exceptions' in t && 'properties' in t : false; +} +function Ns(t) { + return t && t.src && _(t.src) && t.obj && Re(t.obj); +} +function Lr(t) { + let e = t || ''; + _(e) || (_(e[ft]) ? (e = e[ft]) : (e = '' + e)); + let r = e.split(` +`); + return { src: e, obj: r }; +} +function cl(t) { + for ( + var e = [], + r = t.split(` +`), + n = 0; + n < r.length; + n++ + ) { + let i = r[n]; + r[n + 1] && ((i += '@' + r[n + 1]), n++), e.push(i); + } + return { src: t, obj: e }; +} +function Fs(t) { + let e = null; + if (t) { + try { + if (t[ft]) { + e = Lr(t[ft]); + } else if (t[Mr] && t[Mr][ft]) { + e = Lr(t[Mr][ft]); + } else if (t.exception && t.exception[ft]) { + e = Lr(t.exception[ft]); + } else if (Ns(t)) { + e = t; + } else if (Ns(t[qa])) { + e = t[qa]; + } else if (window.opera && t[Ga]) { + e = cl(t.message); + } else if (_(t)) { + e = Lr(t); + } else { + let r = t[Ga] || t[Ds] || ''; + _(t[bs]) && + (r && + (r += ` +`), + (r += ' from ' + t[bs])), + r && (e = Lr(r)); + } + } catch (n) { + e = Lr(n); + } + } + return e || { src: '', obj: null }; +} +function ul(t) { + let e = ''; + return ( + t && + (t.obj + ? R(t.obj, function (r) { + e += + r + + ` +`; + }) + : (e = t.src || '')), + e + ); +} +function ll(t) { + let e, + r = t.obj; + if (r && r.length > 0) { + e = []; + let n = 0, + i = 0; + R(r, function (E) { + let b = E.toString(); + if (Ja.regex.test(b)) { + let p = new Ja(b, n++); + (i += p.sizeInBytes), e.push(p); + } + }); + let a = 32 * 1024; + if (i > a) { + for (let o = 0, c = e.length - 1, s = 0, u = o, l = c; o < c; ) { + let f = e[o].sizeInBytes, + m = e[c].sizeInBytes; + if (((s += f + m), s > a)) { + let I = l - u + 1; + e.splice(u, I); + break; + } + (u = o), (l = c), o++, c--; + } + } + } + return e; +} +function gi(t) { + let e = ''; + if (t && ((e = t.typeName || t.name || ''), !e)) { + try { + let r = /function (.{1,200})\(/, + n = r.exec(t.constructor.toString()); + e = n && n.length > 1 ? n[1] : ''; + } catch (i) {} + } + return e; +} +function Wa(t) { + if (t) { + try { + if (!_(t)) { + let e = gi(t), + r = Ka(t, false); + return ( + (!r || r === '{}') && + (t[Mr] && ((t = t[Mr]), (e = gi(t))), (r = Ka(t, true))), + r.indexOf(e) !== 0 && e !== 'String' ? e + ':' + r : r + ); + } + } catch (n) {} + } + return '' + (t || ''); +} +let al; +let Mr; +let ft; +let qa; +let bs; +let Ga; +let Ds; +let he; +let ks; +let Ja; +let Rs = C(() => { + ne(); + Is(); + Es(); + Ps(); + ut(); + J(); + lt(); + (al = ''), + (Mr = 'error'), + (ft = 'stack'), + (qa = 'stackDetails'), + (bs = 'errorSrc'), + (Ga = 'message'), + (Ds = 'description'); + (he = (function (t) { + H(e, t); + function e(r, n, i, a, o, c) { + let s = t.call(this) || this; + return ( + (s.aiDataContract = { + ver: 1, + exceptions: 1, + severityLevel: 0, + properties: 0, + measurements: 0, + }), + sl(n) + ? ((s.exceptions = n.exceptions), + (s.properties = n.properties), + (s.measurements = n.measurements), + n.severityLevel && (s.severityLevel = n.severityLevel), + n.id && (s.id = n.id), + n.problemGroup && (s.problemGroup = n.problemGroup), + (s.ver = 2), + x(n.isManual) || (s.isManual = n.isManual)) + : (i || (i = {}), + (s.exceptions = [new ks(r, n, i)]), + (s.properties = je(r, i)), + (s.measurements = ze(r, a)), + o && (s.severityLevel = o), + c && (s.id = c)), + s + ); + } + return ( + (e.CreateAutoException = function (r, n, i, a, o, c, s, u) { + let l = gi(o || c || r); + return { + message: As(r, l), + url: n, + lineNumber: i, + columnNumber: a, + error: Wa(o || c || r), + evt: Wa(c || r), + typeName: l, + stackDetails: Fs(s || o || c), + errorSrc: u, + }; + }), + (e.CreateFromInterface = function (r, n, i, a) { + let o = + n.exceptions && + Vt(n.exceptions, function (s) { + return ks.CreateFromInterface(r, s); + }), + c = new e(r, yt({}, n, { exceptions: o }), i, a); + return c; + }), + (e.prototype.toInterface = function () { + let r = this, + n = r.exceptions, + i = r.properties, + a = r.measurements, + o = r.severityLevel, + c = r.ver, + s = r.problemGroup, + u = r.id, + l = r.isManual, + f = + (n instanceof Array && + Vt(n, function (m) { + return m.toInterface(); + })) || + void 0; + return { + ver: '4.0', + exceptions: f, + severityLevel: o, + properties: i, + measurements: a, + problemGroup: s, + id: u, + isManual: l, + }; + }), + (e.CreateSimpleException = function (r, n, i, a, o, c) { + return { + exceptions: [ + { hasFullStack: true, message: r, stack: o, typeName: n }, + ], + }; + }), + (e.envelopeType = 'Microsoft.ApplicationInsights.{0}.Exception'), + (e.dataType = 'ExceptionData'), + (e.formatError = Wa), + e + ); + })(Ts)), + (ks = (function (t) { + H(e, t); + function e(r, n, i) { + let a = t.call(this) || this; + if ( + ((a.aiDataContract = { + id: 0, + outerId: 0, + typeName: 1, + message: 1, + hasFullStack: 0, + stack: 0, + parsedStack: 2, + }), + ol(n)) + ) { + (a.typeName = n.typeName), + (a.message = n.message), + (a[ft] = n[ft]), + (a.parsedStack = n.parsedStack), + (a.hasFullStack = n.hasFullStack); + } else { + let o = n, + c = o && o.evt; + Bt(o) || (o = o[Mr] || c || o), + (a.typeName = ae(r, gi(o)) || le), + (a.message = Ar(r, As(n || o, a.typeName)) || le); + let s = n[qa] || Fs(n); + (a.parsedStack = ll(s)), + (a[ft] = ci(r, ul(s))), + (a.hasFullStack = Re(a.parsedStack) && a.parsedStack.length > 0), + i && (i.typeName = i.typeName || a.typeName); + } + return a; + } + return ( + (e.prototype.toInterface = function () { + let r = + this.parsedStack instanceof Array && + Vt(this.parsedStack, function (i) { + return i.toInterface(); + }), + n = { + id: this.id, + outerId: this.outerId, + typeName: this.typeName, + message: this.message, + hasFullStack: this.hasFullStack, + stack: this[ft], + parsedStack: r || void 0, + }; + return n; + }), + (e.CreateFromInterface = function (r, n) { + let i = + (n.parsedStack instanceof Array && + Vt(n.parsedStack, function (o) { + return Ja.CreateFromInterface(o); + })) || + n.parsedStack, + a = new e(r, yt({}, n, { parsedStack: i })); + return a; + }), + e + ); + })(ws)), + (Ja = (function (t) { + H(e, t); + function e(r, n) { + let i = t.call(this) || this; + if ( + ((i.sizeInBytes = 0), + (i.aiDataContract = { + level: 1, + method: 1, + assembly: 0, + fileName: 0, + line: 0, + }), + typeof r === 'string') + ) { + let a = r; + (i.level = n), + (i.method = al), + (i.assembly = oe(a)), + (i.fileName = ''), + (i.line = 0); + let o = a.match(e.regex); + o && + o.length >= 5 && + ((i.method = oe(o[2]) || i.method), + (i.fileName = oe(o[4])), + (i.line = parseInt(o[5]) || 0)); + } else { + (i.level = r.level), + (i.method = r.method), + (i.assembly = r.assembly), + (i.fileName = r.fileName), + (i.line = r.line), + (i.sizeInBytes = 0); + } + return ( + (i.sizeInBytes += i.method.length), + (i.sizeInBytes += i.fileName.length), + (i.sizeInBytes += i.assembly.length), + (i.sizeInBytes += e.baseSize), + (i.sizeInBytes += i.level.toString().length), + (i.sizeInBytes += i.line.toString().length), + i + ); + } + return ( + (e.CreateFromInterface = function (r) { + return new e(r, null); + }), + (e.prototype.toInterface = function () { + return { + level: this.level, + method: this.method, + assembly: this.assembly, + fileName: this.fileName, + line: this.line, + }; + }), + (e.regex = /^([\s]+at)?[\s]{0,50}([^\@\()]+?)[\s]{0,50}(\@|\()([^\(\n]+):([0-9]+):([0-9]+)(\)?)$/), + (e.baseSize = 58), + e + ); + })(Cs)); +}); +let Ms; +let Ls = C(() => { + Ms = (function () { + function t() { + (this.ver = 2), + (this.metrics = []), + (this.properties = {}), + (this.measurements = {}); + } + return t; + })(); +}); +let vi; +let Us = C(() => { + (function (t) { + (t[(t.Measurement = 0)] = 'Measurement'), + (t[(t.Aggregation = 1)] = 'Aggregation'); + })(vi || (vi = {})); +}); +let _s; +let Os = C(() => { + Us(); + _s = (function () { + function t() { + this.kind = vi.Measurement; + } + return t; + })(); +}); +let Hs; +let js = C(() => { + ne(); + Os(); + Hs = (function (t) { + H(e, t); + function e() { + let r = (t !== null && t.apply(this, arguments)) || this; + return ( + (r.aiDataContract = { + name: 1, + kind: 0, + value: 1, + count: 0, + min: 0, + max: 0, + stdDev: 0, + }), + r + ); + } + return e; + })(_s); +}); +let Ve; +let zs = C(() => { + ne(); + Ls(); + ut(); + js(); + lt(); + Ve = (function (t) { + H(e, t); + function e(r, n, i, a, o, c, s, u) { + let l = t.call(this) || this; + l.aiDataContract = { ver: 1, metrics: 1, properties: 0 }; + let f = new Hs(); + return ( + (f.count = a > 0 ? a : void 0), + (f.max = isNaN(c) || c === null ? void 0 : c), + (f.min = isNaN(o) || o === null ? void 0 : o), + (f.name = ae(r, n) || le), + (f.value = i), + (l.metrics = [f]), + (l.properties = je(r, s)), + (l.measurements = ze(r, u)), + l + ); + } + return ( + (e.envelopeType = 'Microsoft.ApplicationInsights.{0}.Metric'), + (e.dataType = 'MetricData'), + e + ); + })(Ms); +}); +let gr; +let hi = C(() => { + ne(); + Va(); + gr = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + return (r.ver = 2), (r.properties = {}), (r.measurements = {}), r; + } + return e; + })(mi); +}); +let Fe; +let Bs = C(() => { + ne(); + hi(); + ut(); + ln(); + lt(); + Fe = (function (t) { + H(e, t); + function e(r, n, i, a, o, c, s) { + let u = t.call(this) || this; + return ( + (u.aiDataContract = { + ver: 1, + name: 0, + url: 0, + duration: 0, + properties: 0, + measurements: 0, + id: 0, + }), + (u.id = ui(r, s)), + (u.url = Tt(r, i)), + (u.name = ae(r, n) || le), + isNaN(a) || (u.duration = Ge(a)), + (u.properties = je(r, o)), + (u.measurements = ze(r, c)), + u + ); + } + return ( + (e.envelopeType = 'Microsoft.ApplicationInsights.{0}.Pageview'), + (e.dataType = 'PageviewData'), + e + ); + })(gr); +}); +let Vs; +let qs = C(() => { + Vs = (function () { + function t() { + (this.ver = 2), + (this.success = true), + (this.properties = {}), + (this.measurements = {}); + } + return t; + })(); +}); +let qe; +let Gs = C(() => { + ne(); + ut(); + Ha(); + qs(); + ln(); + qe = (function (t) { + H(e, t); + function e(r, n, i, a, o, c, s, u, l, f, m, I) { + l === void 0 && (l = 'Ajax'); + let E = t.call(this) || this; + (E.aiDataContract = { + id: 1, + ver: 1, + name: 0, + resultCode: 0, + duration: 0, + success: 0, + data: 0, + target: 0, + type: 0, + properties: 0, + measurements: 0, + kind: 0, + value: 0, + count: 0, + min: 0, + max: 0, + stdDev: 0, + dependencyKind: 0, + dependencySource: 0, + commandName: 0, + dependencyTypeName: 0, + }), + (E.id = n), + (E.duration = Ge(o)), + (E.success = c), + (E.resultCode = s + ''), + (E.type = ae(r, l)); + let b = gs(r, i, u, a); + return ( + (E.data = Tt(r, a) || b.data), + (E.target = ae(r, b.target)), + f && (E.target = E.target + ' | ' + f), + (E.name = ae(r, b.name)), + (E.properties = je(r, m)), + (E.measurements = ze(r, I)), + E + ); + } + return ( + (e.envelopeType = 'Microsoft.ApplicationInsights.{0}.RemoteDependency'), + (e.dataType = 'RemoteDependencyData'), + e + ); + })(Vs); +}); +let Ks; +let Ws = C(() => { + Ks = (function () { + function t() { + (this.ver = 2), (this.properties = {}), (this.measurements = {}); + } + return t; + })(); +}); +let $e; +let Js = C(() => { + ne(); + Ws(); + ut(); + lt(); + $e = (function (t) { + H(e, t); + function e(r, n, i, a, o) { + let c = t.call(this) || this; + return ( + (c.aiDataContract = { + ver: 1, + message: 1, + severityLevel: 0, + properties: 0, + }), + (n = n || le), + (c.message = Ar(r, n)), + (c.properties = je(r, a)), + (c.measurements = ze(r, o)), + i && (c.severityLevel = i), + c + ); + } + return ( + (e.envelopeType = 'Microsoft.ApplicationInsights.{0}.Message'), + (e.dataType = 'MessageData'), + e + ); + })(Ks); +}); +let Xs; +let Ys = C(() => { + ne(); + hi(); + Xs = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + return (r.ver = 2), (r.properties = {}), (r.measurements = {}), r; + } + return e; + })(gr); +}); +let Ze; +let $s = C(() => { + ne(); + Ys(); + ut(); + lt(); + Ze = (function (t) { + H(e, t); + function e(r, n, i, a, o, c, s) { + let u = t.call(this) || this; + return ( + (u.aiDataContract = { + ver: 1, + name: 0, + url: 0, + duration: 0, + perfTotal: 0, + networkConnect: 0, + sentRequest: 0, + receivedResponse: 0, + domProcessing: 0, + properties: 0, + measurements: 0, + }), + (u.url = Tt(r, i)), + (u.name = ae(r, n) || le), + (u.properties = je(r, o)), + (u.measurements = ze(r, c)), + s && + ((u.domProcessing = s.domProcessing), + (u.duration = s.duration), + (u.networkConnect = s.networkConnect), + (u.perfTotal = s.perfTotal), + (u.receivedResponse = s.receivedResponse), + (u.sentRequest = s.sentRequest)), + u + ); + } + return ( + (e.envelopeType = + 'Microsoft.ApplicationInsights.{0}.PageviewPerformance'), + (e.dataType = 'PageviewPerformanceData'), + e + ); + })(Xs); +}); +let xt; +let Zs = C(() => { + ne(); + Ba(); + xt = (function (t) { + H(e, t); + function e(r, n) { + let i = t.call(this) || this; + return ( + (i.aiDataContract = { baseType: 1, baseData: 1 }), + (i.baseType = r), + (i.baseData = n), + i + ); + } + return e; + })(In); +}); +let _t; +let Qs = C(() => { + (function (t) { + (t[(t.Verbose = 0)] = 'Verbose'), + (t[(t.Information = 1)] = 'Information'), + (t[(t.Warning = 2)] = 'Warning'), + (t[(t.Error = 3)] = 'Error'), + (t[(t.Critical = 4)] = 'Critical'); + })(_t || (_t = {})); +}); +let Xa; +let ec = C(() => { + J(); + Xa = (function () { + function t() {} + return ( + (t.getConfig = function (e, r, n, i) { + i === void 0 && (i = false); + let a; + return ( + n && + e.extensionConfig && + e.extensionConfig[n] && + !x(e.extensionConfig[n][r]) + ? (a = e.extensionConfig[n][r]) + : (a = e[r]), + x(a) ? i : a + ); + }), + t + ); + })(); +}); +function Qt(t) { + let e = 'ai.' + t + '.'; + return function (r) { + return e + r; + }; +} +let En; +let be; +let xi; +let Ur; +let Ya; +let er; +let vr; +let wn; +let hr; +let $a = C(() => { + ne(); + J(); + (En = Qt('application')), + (be = Qt('device')), + (xi = Qt('location')), + (Ur = Qt('operation')), + (Ya = Qt('session')), + (er = Qt('user')), + (vr = Qt('cloud')), + (wn = Qt('internal')), + (hr = (function (t) { + H(e, t); + function e() { + return t.call(this) || this; + } + return e; + })( + qi({ + applicationVersion: En('ver'), + applicationBuild: En('build'), + applicationTypeId: En('typeId'), + applicationId: En('applicationId'), + applicationLayer: En('layer'), + deviceId: be('id'), + deviceIp: be('ip'), + deviceLanguage: be('language'), + deviceLocale: be('locale'), + deviceModel: be('model'), + deviceFriendlyName: be('friendlyName'), + deviceNetwork: be('network'), + deviceNetworkName: be('networkName'), + deviceOEMName: be('oemName'), + deviceOS: be('os'), + deviceOSVersion: be('osVersion'), + deviceRoleInstance: be('roleInstance'), + deviceRoleName: be('roleName'), + deviceScreenResolution: be('screenResolution'), + deviceType: be('type'), + deviceMachineName: be('machineName'), + deviceVMName: be('vmName'), + deviceBrowser: be('browser'), + deviceBrowserVersion: be('browserVersion'), + locationIp: xi('ip'), + locationCountry: xi('country'), + locationProvince: xi('province'), + locationCity: xi('city'), + operationId: Ur('id'), + operationName: Ur('name'), + operationParentId: Ur('parentId'), + operationRootId: Ur('rootId'), + operationSyntheticSource: Ur('syntheticSource'), + operationCorrelationVector: Ur('correlationVector'), + sessionId: Ya('id'), + sessionIsFirst: Ya('isFirst'), + sessionIsNew: Ya('isNew'), + userAccountAcquisitionDate: er('accountAcquisitionDate'), + userAccountId: er('accountId'), + userAgent: er('userAgent'), + userId: er('id'), + userStoreRegion: er('storeRegion'), + userAuthUserId: er('authUserId'), + userAnonymousUserAcquisitionDate: er('anonUserAcquisitionDate'), + userAuthenticatedUserAcquisitionDate: er('authUserAcquisitionDate'), + cloudName: vr('name'), + cloudRole: vr('role'), + cloudRoleVer: vr('roleVer'), + cloudRoleInstance: vr('roleInstance'), + cloudEnvironment: vr('environment'), + cloudLocation: vr('location'), + cloudDeploymentUnit: vr('deploymentUnit'), + internalNodeName: wn('nodeName'), + internalSdkVersion: wn('sdkVersion'), + internalAgentVersion: wn('agentVersion'), + internalSnippet: wn('snippet'), + internalSdkSrc: wn('sdkSrc'), + }) + )); +}); +let rt; +let tc = C(() => { + ut(); + J(); + lt(); + rt = (function () { + function t() {} + return ( + (t.create = function (e, r, n, i, a, o) { + if (((n = ae(i, n) || le), x(e) || x(r) || x(n))) { + throw Error("Input doesn't contain all required fields"); + } + let c = { + name: n, + time: Me(new Date()), + iKey: '', + ext: o || {}, + tags: [], + data: {}, + baseType: r, + baseData: e, + }; + return ( + x(a) || + Q(a, function (s, u) { + c.data[s] = u; + }), + c + ); + }), + t + ); + })(); +}); +let _e; +let re; +let rc = C(() => { + $a(); + (_e = { + UserExt: 'user', + DeviceExt: 'device', + TraceExt: 'trace', + WebExt: 'web', + AppExt: 'app', + OSExt: 'os', + SessionExt: 'ses', + SDKExt: 'sdk', + }), + (re = new hr()); +}); +let Ot; +let _r; +let yi; +let xe = C(() => { + Ha(); + vs(); + wa(); + lt(); + Ba(); + za(); + ys(); + Ss(); + Rs(); + zs(); + Bs(); + hi(); + Gs(); + Js(); + $s(); + Zs(); + Qs(); + ec(); + $a(); + ut(); + tc(); + rc(); + Na(); + ln(); + Aa(); + Ma(); + Ua(); + (Ot = 'AppInsightsPropertiesPlugin'), + (_r = 'AppInsightsChannelPlugin'), + (yi = 'ApplicationInsightsAnalytics'); +}); +let nc; +let ic = C(() => { + xe(); + J(); + Te(); + nc = (function () { + function t(e, r, n, i) { + W(t, this, function (a) { + let o = null, + c = [], + s = false, + u; + n && (u = n.logger); + function l() { + n && + R(n.getTransmissionControls(), function (m) { + R(m, function (I) { + return I.flush(true); + }); + }); + } + function f(m) { + c.push(m), + o || + (o = setInterval(function () { + let I = c.slice(0), + E = false; + (c = []), + R(I, function (b) { + b() ? (E = true) : c.push(b); + }), + c.length === 0 && (clearInterval(o), (o = null)), + E && l(); + }, 100)); + } + a.trackPageView = function (m, I) { + let E = m.name; + if (x(E) || typeof E !== 'string') { + let b = Ne(); + E = m.name = (b && b.title) || ''; + } + let p = m.uri; + if (x(p) || typeof p !== 'string') { + let v = et(); + p = m.uri = (v && v.href) || ''; + } + if (!i.isPerformanceTimingSupported()) { + e.sendPageViewInternal(m, I), + l(), + u.throwInternal( + S.WARNING, + h.NavigationTimingNotSupported, + 'trackPageView: navigation timing API used for calculation of page duration is not supported in this browser. This page view will be collected without duration and timing info.' + ); + return; + } + let y = false, + w, + L = i.getPerformanceTiming().navigationStart; + L > 0 && + ((w = ve(L, +new Date())), + i.shouldCollectDuration(w) || (w = void 0)); + let F; + !x(I) && !x(I.duration) && (F = I.duration), + (r || !isNaN(F)) && + (isNaN(F) && (I || (I = {}), (I.duration = w)), + e.sendPageViewInternal(m, I), + l(), + (y = true)); + let Y = 6e4; + I || (I = {}), + f(function () { + let Se = false; + try { + if (i.isPerformanceTimingDataReady()) { + Se = true; + let X = { name: E, uri: p }; + i.populatePageViewPerformanceEvent(X), + !X.isValid && !y + ? ((I.duration = w), e.sendPageViewInternal(m, I)) + : (y || + ((I.duration = X.durationMs), + e.sendPageViewInternal(m, I)), + s || + (e.sendPageViewPerformanceInternal(X, I), + (s = true))); + } else { + L > 0 && + ve(L, +new Date()) > Y && + ((Se = true), + y || ((I.duration = Y), e.sendPageViewInternal(m, I))); + } + } catch (me) { + u.throwInternal( + S.CRITICAL, + h.TrackPVFailedCalc, + 'trackPageView failed on page load calculation: ' + G(me), + { exception: O(me) } + ); + } + return Se; + }); + }; + }); + } + return t; + })(); +}); +let ac; +let fl; +let oc = C(() => { + xe(); + J(); + (ac = (function () { + function t(e, r) { + (this.prevPageVisitDataKeyName = 'prevPageVisitData'), + (this.pageVisitTimeTrackingHandler = r), + (this._logger = e); + } + return ( + (t.prototype.trackPreviousPageVisit = function (e, r) { + try { + let n = this.restartPageVisitTimer(e, r); + n && + this.pageVisitTimeTrackingHandler( + n.pageName, + n.pageUrl, + n.pageVisitTime + ); + } catch (i) { + this._logger.warnToConsole( + 'Auto track page visit time failed, metric will not be collected: ' + + O(i) + ); + } + }), + (t.prototype.restartPageVisitTimer = function (e, r) { + try { + let n = this.stopPageVisitTimer(); + return this.startPageVisitTimer(e, r), n; + } catch (i) { + return ( + this._logger.warnToConsole('Call to restart failed: ' + O(i)), null + ); + } + }), + (t.prototype.startPageVisitTimer = function (e, r) { + try { + if (wt()) { + $t(this._logger, this.prevPageVisitDataKeyName) != null && + Ae( + 'Cannot call startPageVisit consecutively without first calling stopPageVisit' + ); + let n = new fl(e, r), + i = Pe().stringify(n); + Zt(this._logger, this.prevPageVisitDataKeyName, i); + } + } catch (a) { + this._logger.warnToConsole('Call to start failed: ' + O(a)); + } + }), + (t.prototype.stopPageVisitTimer = function () { + try { + if (wt()) { + let e = de(), + r = $t(this._logger, this.prevPageVisitDataKeyName); + if (r && vt()) { + let n = Pe().parse(r); + return ( + (n.pageVisitTime = e - n.pageVisitStartTime), + vn(this._logger, this.prevPageVisitDataKeyName), + n + ); + } else { + return null; + } + } + return null; + } catch (i) { + return ( + this._logger.warnToConsole('Stop page visit timer failed: ' + O(i)), + null + ); + } + }), + t + ); + })()), + (fl = (function () { + function t(e, r) { + (this.pageVisitStartTime = de()), + (this.pageName = e), + (this.pageUrl = r); + } + return t; + })()); +}); +let sc; +let cc = C(() => { + xe(); + J(); + sc = (function () { + function t(e) { + (this.MAX_DURATION_ALLOWED = 36e5), e && (this._logger = e.logger); + } + return ( + (t.prototype.populatePageViewPerformanceEvent = function (e) { + e.isValid = false; + let r = this.getPerformanceNavigationTiming(), + n = this.getPerformanceTiming(), + i = 0, + a = 0, + o = 0, + c = 0, + s = 0; + (r || n) && + (r + ? ((i = r.duration), + (a = + r.startTime === 0 + ? r.connectEnd + : ve(r.startTime, r.connectEnd)), + (o = ve(r.requestStart, r.responseStart)), + (c = ve(r.responseStart, r.responseEnd)), + (s = ve(r.responseEnd, r.loadEventEnd))) + : ((i = ve(n.navigationStart, n.loadEventEnd)), + (a = ve(n.navigationStart, n.connectEnd)), + (o = ve(n.requestStart, n.responseStart)), + (c = ve(n.responseStart, n.responseEnd)), + (s = ve(n.responseEnd, n.loadEventEnd))), + i === 0 + ? this._logger.throwInternal( + S.WARNING, + h.ErrorPVCalc, + 'error calculating page view performance.', + { total: i, network: a, request: o, response: c, dom: s } + ) + : this.shouldCollectDuration(i, a, o, c, s) + ? i < Math.floor(a) + Math.floor(o) + Math.floor(c) + Math.floor(s) + ? this._logger.throwInternal( + S.WARNING, + h.ClientPerformanceMathError, + 'client performance math error.', + { total: i, network: a, request: o, response: c, dom: s } + ) + : ((e.durationMs = i), + (e.perfTotal = e.duration = Ge(i)), + (e.networkConnect = Ge(a)), + (e.sentRequest = Ge(o)), + (e.receivedResponse = Ge(c)), + (e.domProcessing = Ge(s)), + (e.isValid = true)) + : this._logger.throwInternal( + S.WARNING, + h.InvalidDurationValue, + "Invalid page load duration value. Browser perf data won't be sent.", + { total: i, network: a, request: o, response: c, dom: s } + )); + }), + (t.prototype.getPerformanceTiming = function () { + return this.isPerformanceTimingSupported() ? Ye().timing : null; + }), + (t.prototype.getPerformanceNavigationTiming = function () { + return this.isPerformanceNavigationTimingSupported() + ? Ye().getEntriesByType('navigation')[0] + : null; + }), + (t.prototype.isPerformanceNavigationTimingSupported = function () { + let e = Ye(); + return ( + e && e.getEntriesByType && e.getEntriesByType('navigation').length > 0 + ); + }), + (t.prototype.isPerformanceTimingSupported = function () { + let e = Ye(); + return e && e.timing; + }), + (t.prototype.isPerformanceTimingDataReady = function () { + let e = Ye(), + r = e ? e.timing : 0; + return ( + r && + r.domainLookupStart > 0 && + r.navigationStart > 0 && + r.responseStart > 0 && + r.requestStart > 0 && + r.loadEventEnd > 0 && + r.responseEnd > 0 && + r.connectEnd > 0 && + r.domLoading > 0 + ); + }), + (t.prototype.shouldCollectDuration = function () { + for (var e = [], r = 0; r < arguments.length; r++) { + e[r] = arguments[r]; + } + let n = Ue() || {}, + i = [ + 'googlebot', + 'adsbot-google', + 'apis-google', + 'mediapartners-google', + ], + a = n.userAgent, + o = false; + if (a) { + for (var c = 0; c < i.length; c++) { + o = o || a.toLowerCase().indexOf(i[c]) !== -1; + } + } + if (o) { + return false; + } + for (var c = 0; c < e.length; c++) { + if (e[c] < 0 || e[c] >= this.MAX_DURATION_ALLOWED) { + return false; + } + } + return true; + }), + t + ); + })(); +}); +function Pn(t, e) { + t && t.dispatchEvent && e && t.dispatchEvent(e); +} +let uc; +let Za; +let bn; +let lc; +let fc = C(() => { + ne(); + xe(); + J(); + ic(); + oc(); + cc(); + Te(); + (uc = 'duration'), (Za = 'event'); + (bn = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + (r.identifier = yi), (r.priority = 180), (r.autoRoutePVDelay = 500); + let n, + i, + a, + o = 0, + c, + s; + return ( + W(e, r, function (u, l) { + let f = et(true); + (c = (f && f.href) || ''), + (u.getCookieMgr = function () { + return cr(u.core); + }), + (u.processTelemetry = function (p, v) { + ct( + u.core, + function () { + return u.identifier + ':processTelemetry'; + }, + function () { + let y = false, + w = u._telemetryInitializers.length; + v = u._getTelCtx(v); + for (let L = 0; L < w; ++L) { + let F = u._telemetryInitializers[L]; + if (F) { + try { + if (F.apply(null, [p]) === false) { + y = true; + break; + } + } catch (Y) { + v.diagLog().throwInternal( + S.CRITICAL, + h.TelemetryInitializerFailed, + 'One of telemetry initializers failed, telemetry item will not be sent: ' + + G(Y), + { exception: O(Y) }, + true + ); + } + } + } + y || u.processNext(p, v); + }, + function () { + return { item: p }; + }, + !p.sync + ); + }), + (u.trackEvent = function (p, v) { + try { + let y = rt.create( + p, + Be.dataType, + Be.envelopeType, + u.diagLog(), + v + ); + u.core.track(y); + } catch (w) { + u.diagLog().throwInternal( + S.WARNING, + h.TrackTraceFailed, + 'trackTrace failed, trace will not be collected: ' + G(w), + { exception: O(w) } + ); + } + }), + (u.startTrackEvent = function (p) { + try { + n.start(p); + } catch (v) { + u.diagLog().throwInternal( + S.CRITICAL, + h.StartTrackEventFailed, + 'startTrackEvent failed, event will not be collected: ' + + G(v), + { exception: O(v) } + ); + } + }), + (u.stopTrackEvent = function (p, v, y) { + try { + n.stop(p, void 0, v); + } catch (w) { + u.diagLog().throwInternal( + S.CRITICAL, + h.StopTrackEventFailed, + 'stopTrackEvent failed, event will not be collected: ' + G(w), + { exception: O(w) } + ); + } + }), + (u.trackTrace = function (p, v) { + try { + let y = rt.create( + p, + $e.dataType, + $e.envelopeType, + u.diagLog(), + v + ); + u.core.track(y); + } catch (w) { + u.diagLog().throwInternal( + S.WARNING, + h.TrackTraceFailed, + 'trackTrace failed, trace will not be collected: ' + G(w), + { exception: O(w) } + ); + } + }), + (u.trackMetric = function (p, v) { + try { + let y = rt.create( + p, + Ve.dataType, + Ve.envelopeType, + u.diagLog(), + v + ); + u.core.track(y); + } catch (w) { + u.diagLog().throwInternal( + S.CRITICAL, + h.TrackMetricFailed, + 'trackMetric failed, metric will not be collected: ' + G(w), + { exception: O(w) } + ); + } + }), + (u.trackPageView = function (p, v) { + try { + let y = p || {}; + u._pageViewManager.trackPageView( + y, + yt({}, y.properties, y.measurements, v) + ), + u.config.autoTrackPageVisitTime && + u._pageVisitTimeManager.trackPreviousPageVisit( + y.name, + y.uri + ); + } catch (w) { + u.diagLog().throwInternal( + S.CRITICAL, + h.TrackPVFailed, + 'trackPageView failed, page view will not be collected: ' + + G(w), + { exception: O(w) } + ); + } + }), + (u.sendPageViewInternal = function (p, v, y) { + let w = Ne(); + w && (p.refUri = p.refUri === void 0 ? w.referrer : p.refUri); + let L = rt.create( + p, + Fe.dataType, + Fe.envelopeType, + u.diagLog(), + v, + y + ); + u.core.track(L), (o = 0); + }), + (u.sendPageViewPerformanceInternal = function (p, v, y) { + let w = rt.create( + p, + Ze.dataType, + Ze.envelopeType, + u.diagLog(), + v, + y + ); + u.core.track(w); + }), + (u.trackPageViewPerformance = function (p, v) { + try { + u._pageViewPerformanceManager.populatePageViewPerformanceEvent( + p + ), + u.sendPageViewPerformanceInternal(p, v); + } catch (y) { + u.diagLog().throwInternal( + S.CRITICAL, + h.TrackPVFailed, + 'trackPageViewPerformance failed, page view will not be collected: ' + + G(y), + { exception: O(y) } + ); + } + }), + (u.startTrackPage = function (p) { + try { + if (typeof p !== 'string') { + let v = Ne(); + p = (v && v.title) || ''; + } + i.start(p); + } catch (y) { + u.diagLog().throwInternal( + S.CRITICAL, + h.StartTrackFailed, + 'startTrackPage failed, page view may not be collected: ' + + G(y), + { exception: O(y) } + ); + } + }), + (u.stopTrackPage = function (p, v, y, w) { + try { + if (typeof p !== 'string') { + let L = Ne(); + p = (L && L.title) || ''; + } + if (typeof v !== 'string') { + let F = et(); + v = (F && F.href) || ''; + } + i.stop(p, v, y, w), + u.config.autoTrackPageVisitTime && + u._pageVisitTimeManager.trackPreviousPageVisit(p, v); + } catch (Y) { + u.diagLog().throwInternal( + S.CRITICAL, + h.StopTrackFailed, + 'stopTrackPage failed, page view will not be collected: ' + + G(Y), + { exception: O(Y) } + ); + } + }), + (u.sendExceptionInternal = function (p, v, y) { + let w = p.exception || p.error || new Error(le), + L = new he( + u.diagLog(), + w, + p.properties || v, + p.measurements, + p.severityLevel, + p.id + ).toInterface(), + F = rt.create( + L, + he.dataType, + he.envelopeType, + u.diagLog(), + v, + y + ); + u.core.track(F); + }), + (u.trackException = function (p, v) { + try { + u.sendExceptionInternal(p, v); + } catch (y) { + u.diagLog().throwInternal( + S.CRITICAL, + h.TrackExceptionFailed, + 'trackException failed, exception will not be collected: ' + + G(y), + { exception: O(y) } + ); + } + }), + (u._onerror = function (p) { + let v = p && p.error, + y = p && p.evt; + try { + if (!y) { + let w = Ct(); + w && (y = w[Za]); + } + let L = (p && p.url) || (Ne() || {}).URL, + F = + p.errorSrc || + 'window.onerror@' + + L + + ':' + + (p.lineNumber || 0) + + ':' + + (p.columnNumber || 0), + Y = { + errorSrc: F, + url: L, + lineNumber: p.lineNumber || 0, + columnNumber: p.columnNumber || 0, + message: p.message, + }; + un(p.message, p.url, p.lineNumber, p.columnNumber, p.error) + ? b( + he.CreateAutoException( + "Script error: The browser's same-origin policy prevents us from getting the details of this exception. Consider using the 'crossorigin' attribute.", + L, + p.lineNumber || 0, + p.columnNumber || 0, + v, + y, + null, + F + ), + Y + ) + : (p.errorSrc || (p.errorSrc = F), + u.trackException( + { exception: p, severityLevel: _t.Error }, + Y + )); + } catch (X) { + let Se = v ? v.name + ', ' + v.message : 'null'; + u.diagLog().throwInternal( + S.CRITICAL, + h.ExceptionWhileLoggingError, + '_onError threw exception while logging error, error will not be collected: ' + + G(X), + { exception: O(X), errorString: Se } + ); + } + }), + (u.addTelemetryInitializer = function (p) { + u._telemetryInitializers.push(p); + }), + (u.initialize = function (p, v, y, w) { + if (!u.isInitialized()) { + if (x(v)) { + throw Error('Error initializing'); + } + l.initialize(p, v, y, w), u.setInitialized(false); + let L = u._getTelCtx(), + F = u.identifier; + u.config = L.getExtCfg(F); + let Y = e.getDefaultConfig(p); + Y !== void 0 && + Q(Y, function (D, z) { + (u.config[D] = L.getConfig(F, D, z)), + u.config[D] === void 0 && (u.config[D] = z); + }), + u.config.isStorageUseDisabled && pn(); + let Se = { + instrumentationKey: function () { + return p.instrumentationKey; + }, + accountId: function () { + return u.config.accountId || p.accountId; + }, + sessionRenewalMs: function () { + return u.config.sessionRenewalMs || p.sessionRenewalMs; + }, + sessionExpirationMs: function () { + return ( + u.config.sessionExpirationMs || p.sessionExpirationMs + ); + }, + sampleRate: function () { + return u.config.samplingPercentage || p.samplingPercentage; + }, + sdkExtension: function () { + return u.config.sdkExtension || p.sdkExtension; + }, + isBrowserLinkTrackingEnabled: function () { + return ( + u.config.isBrowserLinkTrackingEnabled || + p.isBrowserLinkTrackingEnabled + ); + }, + appId: function () { + return u.config.appId || p.appId; + }, + }; + (u._pageViewPerformanceManager = new sc(u.core)), + (u._pageViewManager = new nc( + r, + u.config.overridePageViewDuration, + u.core, + u._pageViewPerformanceManager + )), + (u._pageVisitTimeManager = new ac( + u.diagLog(), + function (D, z, U) { + return m(D, z, U); + } + )), + (u._telemetryInitializers = u._telemetryInitializers || []), + I(Se), + (n = new lc(u.diagLog(), 'trackEvent')), + (n.action = function (D, z, U, q) { + q || (q = {}), + (q[uc] = U.toString()), + u.trackEvent({ name: D, properties: q }); + }), + (i = new lc(u.diagLog(), 'trackPageView')), + (i.action = function (D, z, U, q, $) { + x(q) && (q = {}), (q[uc] = U.toString()); + let ie = { + name: D, + uri: z, + properties: q, + measurements: $, + }; + u.sendPageViewInternal(ie, q); + }); + let X = Ct(), + me = Xi(), + De = et(true), + pt = r; + if ( + u.config.disableExceptionTracking === false && + !u.config.autoExceptionInstrumented && + X + ) { + let at = 'onerror', + dt = X[at]; + (X.onerror = function (D, z, U, q, $) { + let ie = X[Za], + Ht = dt && dt(D, z, U, q, $); + return ( + Ht !== true && + pt._onerror(he.CreateAutoException(D, z, U, q, $, ie)), + Ht + ); + }), + (u.config.autoExceptionInstrumented = true); + } + if ( + u.config.disableExceptionTracking === false && + u.config.enableUnhandledPromiseRejectionTracking === true && + !u.config.autoUnhandledPromiseInstrumented && + X + ) { + let d = 'onunhandledrejection', + T = X[d]; + (X[d] = function (D) { + let z = X[Za], + U = T && T.call(X, D); + return ( + U !== true && + pt._onerror( + he.CreateAutoException( + D.reason.toString(), + De ? De.href : '', + 0, + 0, + D, + z + ) + ), + U + ); + }), + (u.config.autoUnhandledPromiseInstrumented = true); + } + if ( + u.config.enableAutoRouteTracking === true && + me && + j(me.pushState) && + j(me.replaceState) && + X && + typeof Event !== 'undefined' + ) { + let A = r; + R(y, function (D) { + D.identifier === Ot && (a = D); + }), + (me.pushState = (function (D) { + return function () { + let U = D.apply(this, arguments); + return ( + Pn(X, Lt(A.config.namePrefix + 'pushState')), + Pn(X, Lt(A.config.namePrefix + 'locationchange')), + U + ); + }; + })(me.pushState)), + (me.replaceState = (function (D) { + return function () { + let U = D.apply(this, arguments); + return ( + Pn(X, Lt(A.config.namePrefix + 'replaceState')), + Pn(X, Lt(A.config.namePrefix + 'locationchange')), + U + ); + }; + })(me.replaceState)), + X.addEventListener && + (X.addEventListener( + A.config.namePrefix + 'popstate', + function () { + Pn(X, Lt(A.config.namePrefix + 'locationchange')); + } + ), + X.addEventListener( + A.config.namePrefix + 'locationchange', + function () { + if (a && a.context && a.context.telemetryTrace) { + a.context.telemetryTrace.traceID = He(); + let D = '_unknown_'; + De && + De.pathname && + (D = De.pathname + (De.hash || '')), + (a.context.telemetryTrace.name = D); + } + s && (c = s), + (s = (De && De.href) || ''), + setTimeout( + function (z) { + A.trackPageView({ + refUri: z, + properties: { duration: 0 }, + }); + }.bind(r, c), + A.autoRoutePVDelay + ); + } + )); + } + u.setInitialized(true); + } + }); + function m(p, v, y) { + let w = { PageName: p, PageUrl: v }; + u.trackMetric( + { + name: 'PageVisitTime', + average: y, + max: y, + min: y, + sampleCount: 1, + }, + w + ); + } + function I(p) { + if (!p.isBrowserLinkTrackingEnabled()) { + let v = ['/browserLinkSignalR/', '/__browserLink/'], + y = function (w) { + if (w.baseType === qe.dataType) { + let L = w.baseData; + if (L) { + for (let F = 0; F < v.length; F++) { + if (L.target && L.target.indexOf(v[F]) >= 0) { + return false; + } + } + } + } + return true; + }; + E(y); + } + } + function E(p) { + u._telemetryInitializers.push(p); + } + function b(p, v) { + let y = rt.create(p, he.dataType, he.envelopeType, u.diagLog(), v); + u.core.track(y); + } + }), + r + ); + } + return ( + (e.getDefaultConfig = function (r) { + return ( + r || (r = {}), + (r.sessionRenewalMs = 30 * 60 * 1e3), + (r.sessionExpirationMs = 24 * 60 * 60 * 1e3), + (r.disableExceptionTracking = ee(r.disableExceptionTracking)), + (r.autoTrackPageVisitTime = ee(r.autoTrackPageVisitTime)), + (r.overridePageViewDuration = ee(r.overridePageViewDuration)), + (r.enableUnhandledPromiseRejectionTracking = ee( + r.enableUnhandledPromiseRejectionTracking + )), + (isNaN(r.samplingPercentage) || + r.samplingPercentage <= 0 || + r.samplingPercentage >= 100) && + (r.samplingPercentage = 100), + (r.isStorageUseDisabled = ee(r.isStorageUseDisabled)), + (r.isBrowserLinkTrackingEnabled = ee(r.isBrowserLinkTrackingEnabled)), + (r.enableAutoRouteTracking = ee(r.enableAutoRouteTracking)), + (r.namePrefix = r.namePrefix || ''), + (r.enableDebug = ee(r.enableDebug)), + (r.disableFlushOnBeforeUnload = ee(r.disableFlushOnBeforeUnload)), + (r.disableFlushOnUnload = ee( + r.disableFlushOnUnload, + r.disableFlushOnBeforeUnload + )), + r + ); + }), + (e.Version = '2.6.4'), + e + ); + })(tt)), + (lc = (function () { + function t(e, r) { + let n = this, + i = {}; + (n.start = function (a) { + typeof i[a] !== 'undefined' && + e.throwInternal( + S.WARNING, + h.StartCalledMoreThanOnce, + 'start was called more than once for this event without calling stop.', + { name: a, key: a }, + true + ), + (i[a] = +new Date()); + }), + (n.stop = function (a, o, c, s) { + let u = i[a]; + if (isNaN(u)) { + e.throwInternal( + S.WARNING, + h.StopCalledWithoutStart, + 'stop was called without a corresponding start.', + { name: a, key: a }, + true + ); + } else { + let l = +new Date(), + f = ve(u, l); + n.action(a, o, f, c, s); + } + delete i[a], (i[a] = void 0); + }); + } + return t; + })()); +}); +let Qa = C(() => { + fc(); +}); +let pc; +let dc; +let mc = C(() => { + xe(); + J(); + Te(); + (pc = (function () { + function t(e) { + let r = []; + W(t, this, function (n) { + (n.enqueue = function (i) { + r.push(i); + }), + (n.count = function () { + return r.length; + }), + (n.clear = function () { + r.length = 0; + }), + (n.getItems = function () { + return r.slice(0); + }), + (n.batchPayloads = function (i) { + if (i && i.length > 0) { + let a = e.emitLineDelimitedJson() + ? i.join(` +`) + : '[' + i.join(',') + ']'; + return a; + } + return null; + }), + (n.markAsSent = function (i) { + n.clear(); + }), + (n.clearSent = function (i) {}); + }); + } + return t; + })()), + (dc = (function () { + function t(e, r) { + let n = false, + i; + W(t, this, function (a) { + let o = u(t.BUFFER_KEY), + c = u(t.SENT_BUFFER_KEY); + (i = o.concat(c)), + i.length > t.MAX_BUFFER_SIZE && (i.length = t.MAX_BUFFER_SIZE), + l(t.SENT_BUFFER_KEY, []), + l(t.BUFFER_KEY, i), + (a.enqueue = function (f) { + if (i.length >= t.MAX_BUFFER_SIZE) { + n || + (e.throwInternal( + S.WARNING, + h.SessionStorageBufferFull, + 'Maximum buffer size reached: ' + i.length, + true + ), + (n = true)); + return; + } + i.push(f), l(t.BUFFER_KEY, i); + }), + (a.count = function () { + return i.length; + }), + (a.clear = function () { + (i = []), + l(t.BUFFER_KEY, []), + l(t.SENT_BUFFER_KEY, []), + (n = false); + }), + (a.getItems = function () { + return i.slice(0); + }), + (a.batchPayloads = function (f) { + if (f && f.length > 0) { + let m = r.emitLineDelimitedJson() + ? f.join(` +`) + : '[' + f.join(',') + ']'; + return m; + } + return null; + }), + (a.markAsSent = function (f) { + (i = s(f, i)), l(t.BUFFER_KEY, i); + let m = u(t.SENT_BUFFER_KEY); + m instanceof Array && + f instanceof Array && + ((m = m.concat(f)), + m.length > t.MAX_BUFFER_SIZE && + (e.throwInternal( + S.CRITICAL, + h.SessionStorageBufferFull, + 'Sent buffer reached its maximum size: ' + m.length, + true + ), + (m.length = t.MAX_BUFFER_SIZE)), + l(t.SENT_BUFFER_KEY, m)); + }), + (a.clearSent = function (f) { + let m = u(t.SENT_BUFFER_KEY); + (m = s(f, m)), l(t.SENT_BUFFER_KEY, m); + }); + function s(f, m) { + let I = []; + return ( + R(m, function (E) { + !j(E) && Nt(f, E) === -1 && I.push(E); + }), + I + ); + } + function u(f) { + let m = f; + try { + m = r.namePrefix && r.namePrefix() ? r.namePrefix() + '_' + m : m; + let I = $t(e, m); + if (I) { + let E = Pe().parse(I); + if ((_(E) && (E = Pe().parse(E)), E && Re(E))) { + return E; + } + } + } catch (b) { + e.throwInternal( + S.CRITICAL, + h.FailedToRestoreStorageBuffer, + ' storage key: ' + m + ', ' + G(b), + { exception: O(b) } + ); + } + return []; + } + function l(f, m) { + let I = f; + try { + I = r.namePrefix && r.namePrefix() ? r.namePrefix() + '_' + I : I; + let E = JSON.stringify(m); + Zt(e, I, E); + } catch (b) { + Zt(e, I, JSON.stringify([])), + e.throwInternal( + S.WARNING, + h.FailedToSetStorageBuffer, + ' storage key: ' + I + ', ' + G(b) + '. Buffer cleared', + { exception: O(b) } + ); + } + } + }); + } + return ( + (t.BUFFER_KEY = 'AI_buffer'), + (t.SENT_BUFFER_KEY = 'AI_sentBuffer'), + (t.MAX_BUFFER_SIZE = 2e3), + t + ); + })()); +}); +function ye(t, e, r) { + return K(t, e, r, Pr); +} +let eo; +let se; +let ke; +let gc; +let fe; +let vc; +let to; +let hc; +let xc; +let yc; +let Sc; +let Cc; +let Ic = C(() => { + ne(); + xe(); + J(); + (eo = 'baseType'), (se = 'baseData'), (ke = 'properties'), (gc = 'true'); + (fe = (function () { + function t() {} + return ( + (t.extractPropsAndMeasurements = function (e, r, n) { + x(e) || + Q(e, function (i, a) { + ir(a) + ? (n[i] = a) + : _(a) + ? (r[i] = a) + : vt() && (r[i] = Pe().stringify(a)); + }); + }), + (t.createEnvelope = function (e, r, n, i) { + let a = new Tn(e, i, r); + ye(a, 'sampleRate', n[lr]), + (n[se] || {}).startTime && (a.time = Me(n[se].startTime)), + (a.iKey = n.iKey); + let o = n.iKey.replace(/-/g, ''); + return ( + (a.name = a.name.replace('{0}', o)), + t.extractPartAExtensions(n, a), + (n.tags = n.tags || []), + Kn(a) + ); + }), + (t.extractPartAExtensions = function (e, r) { + let n = (r.tags = r.tags || {}), + i = (e.ext = e.ext || {}), + a = (e.tags = e.tags || []), + o = i.user; + o && + (ye(n, re.userAuthUserId, o.authId), + ye(n, re.userId, o.id || o.localId)); + let c = i.app; + c && ye(n, re.sessionId, c.sesId); + let s = i.device; + s && + (ye(n, re.deviceId, s.id || s.localId), + ye(n, re.deviceType, s.deviceClass), + ye(n, re.deviceIp, s.ip), + ye(n, re.deviceModel, s.model), + ye(n, re.deviceType, s.deviceType)); + let u = e.ext.web; + if (u) { + ye(n, re.deviceLanguage, u.browserLang), + ye(n, re.deviceBrowserVersion, u.browserVer), + ye(n, re.deviceBrowser, u.browser); + let l = (r.data = r.data || {}), + f = (l[se] = l[se] || {}), + m = (f[ke] = f[ke] || {}); + ye(m, 'domain', u.domain), + ye(m, 'isManual', u.isManual ? gc : null), + ye(m, 'screenRes', u.screenRes), + ye(m, 'userConsent', u.userConsent ? gc : null); + } + let I = i.os; + I && ye(n, re.deviceOS, I.name); + let E = i.trace; + E && + (ye(n, re.operationParentId, E.parentID), + ye(n, re.operationName, E.name), + ye(n, re.operationId, E.traceID)); + for (var b = {}, p = a.length - 1; p >= 0; p--) { + let v = a[p]; + Q(v, function (w, L) { + b[w] = L; + }), + a.splice(p, 1); + } + Q(a, function (w, L) { + b[w] = L; + }); + let y = yt({}, n, b); + y[re.internalSdkVersion] || + (y[re.internalSdkVersion] = 'javascript:' + t.Version), + (r.tags = Kn(y)); + }), + (t.prototype.Init = function (e, r) { + (this._logger = e), + x(r[se]) && + this._logger.throwInternal( + S.CRITICAL, + h.TelemetryEnvelopeInvalid, + 'telemetryItem.baseData cannot be null.' + ); + }), + (t.Version = '2.6.4'), + t + ); + })()), + (vc = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = n[se].measurements || {}, + a = n[se][ke] || {}; + fe.extractPropsAndMeasurements(n.data, a, i); + let o = n[se]; + if (x(o)) { + return r.warnToConsole('Invalid input for dependency data'), null; + } + let c = o[ke] && o[ke][Fr] ? o[ke][Fr] : 'GET', + s = new qe( + r, + o.id, + o.target, + o.name, + o.duration, + o.success, + o.responseCode, + c, + o.type, + o.correlationContext, + a, + i + ), + u = new xt(qe.dataType, s); + return fe.createEnvelope(r, qe.envelopeType, n, u); + }), + (e.DependencyEnvelopeCreator = new e()), + e + ); + })(fe)), + (to = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = {}, + a = {}; + n[eo] !== Be.dataType && (i.baseTypeSource = n[eo]), + n[eo] === Be.dataType + ? ((i = n[se][ke] || {}), (a = n[se].measurements || {})) + : n[se] && fe.extractPropsAndMeasurements(n[se], i, a), + fe.extractPropsAndMeasurements(n.data, i, a); + let o = n[se].name, + c = new Be(r, o, i, a), + s = new xt(Be.dataType, c); + return fe.createEnvelope(r, Be.envelopeType, n, s); + }), + (e.EventEnvelopeCreator = new e()), + e + ); + })(fe)), + (hc = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = n[se].measurements || {}, + a = n[se][ke] || {}; + fe.extractPropsAndMeasurements(n.data, a, i); + let o = n[se], + c = he.CreateFromInterface(r, o, a, i), + s = new xt(he.dataType, c); + return fe.createEnvelope(r, he.envelopeType, n, s); + }), + (e.ExceptionEnvelopeCreator = new e()), + e + ); + })(fe)), + (xc = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = n[se], + a = i[ke] || {}, + o = i.measurements || {}; + fe.extractPropsAndMeasurements(n.data, a, o); + let c = new Ve( + r, + i.name, + i.average, + i.sampleCount, + i.min, + i.max, + a, + o + ), + s = new xt(Ve.dataType, c); + return fe.createEnvelope(r, Ve.envelopeType, n, s); + }), + (e.MetricEnvelopeCreator = new e()), + e + ); + })(fe)), + (yc = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = 'duration', + a, + o = n[se]; + !x(o) && !x(o[ke]) && !x(o[ke][i]) + ? ((a = o[ke][i]), delete o[ke][i]) + : !x(n.data) && + !x(n.data[i]) && + ((a = n.data[i]), delete n.data[i]); + let c = n[se], + s; + ((n.ext || {}).trace || {}).traceID && (s = n.ext.trace.traceID); + let u = c.id || s, + l = c.name, + f = c.uri, + m = c[ke] || {}, + I = c.measurements || {}; + if ( + (x(c.refUri) || (m.refUri = c.refUri), + x(c.pageType) || (m.pageType = c.pageType), + x(c.isLoggedIn) || (m.isLoggedIn = c.isLoggedIn.toString()), + !x(c[ke])) + ) { + let E = c[ke]; + Q(E, function (v, y) { + m[v] = y; + }); + } + fe.extractPropsAndMeasurements(n.data, m, I); + let b = new Fe(r, l, f, a, m, I, u), + p = new xt(Fe.dataType, b); + return fe.createEnvelope(r, Fe.envelopeType, n, p); + }), + (e.PageViewEnvelopeCreator = new e()), + e + ); + })(fe)), + (Sc = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = n[se], + a = i.name, + o = i.uri || i.url, + c = i[ke] || {}, + s = i.measurements || {}; + fe.extractPropsAndMeasurements(n.data, c, s); + let u = new Ze(r, a, o, void 0, c, s, i), + l = new xt(Ze.dataType, u); + return fe.createEnvelope(r, Ze.envelopeType, n, l); + }), + (e.PageViewPerformanceEnvelopeCreator = new e()), + e + ); + })(fe)), + (Cc = (function (t) { + H(e, t); + function e() { + return (t !== null && t.apply(this, arguments)) || this; + } + return ( + (e.prototype.Create = function (r, n) { + t.prototype.Init.call(this, r, n); + let i = n[se].message, + a = n[se].severityLevel, + o = n[se][ke] || {}, + c = n[se].measurements || {}; + fe.extractPropsAndMeasurements(n.data, o, c); + let s = new $e(r, i, a, o, c), + u = new xt($e.dataType, s); + return fe.createEnvelope(r, $e.envelopeType, n, u); + }), + (e.TraceEnvelopeCreator = new e()), + e + ); + })(fe)); +}); +let Tc; +let Ec = C(() => { + J(); + Te(); + Tc = (function () { + function t(e) { + W(t, this, function (r) { + r.serialize = function (o) { + let c = n(o, 'root'); + try { + return Pe().stringify(c); + } catch (s) { + e.throwInternal( + S.CRITICAL, + h.CannotSerializeObject, + s && j(s.toString) ? s.toString() : 'Error serializing object', + null, + true + ); + } + }; + function n(o, c) { + let s = '__aiCircularRefCheck', + u = {}; + if (!o) { + return ( + e.throwInternal( + S.CRITICAL, + h.CannotSerializeObject, + 'cannot serialize object because it is null or undefined', + { name: c }, + true + ), + u + ); + } + if (o[s]) { + return ( + e.throwInternal( + S.WARNING, + h.CircularReferenceDetected, + 'Circular reference detected while serializing object', + { name: c }, + true + ), + u + ); + } + if (!o.aiDataContract) { + if (c === 'measurements') { + u = a(o, 'number', c); + } else if (c === 'properties') { + u = a(o, 'string', c); + } else if (c === 'tags') { + u = a(o, 'string', c); + } else if (Re(o)) { + u = i(o, c); + } else { + e.throwInternal( + S.WARNING, + h.CannotSerializeObjectNonSerializable, + 'Attempting to serialize an object which does not implement ISerializable', + { name: c }, + true + ); + try { + Pe().stringify(o), (u = o); + } catch (l) { + e.throwInternal( + S.CRITICAL, + h.CannotSerializeObject, + l && j(l.toString) + ? l.toString() + : 'Error serializing object', + null, + true + ); + } + } + return u; + } + return ( + (o[s] = true), + Q(o.aiDataContract, function (l, f) { + let m = j(f) ? f() & 1 : f & 1, + I = j(f) ? f() & 4 : f & 4, + E = f & 2, + b = o[l] !== void 0, + p = st(o[l]) && o[l] !== null; + if (m && !b && !E) { + e.throwInternal( + S.CRITICAL, + h.MissingRequiredFieldSpecification, + 'Missing required field specification. The field is required but not present on source', + { field: l, name: c } + ); + } else if (!I) { + let v = void 0; + p ? (E ? (v = i(o[l], l)) : (v = n(o[l], l))) : (v = o[l]), + v !== void 0 && (u[l] = v); + } + }), + delete o[s], + u + ); + } + function i(o, c) { + let s; + if (o) { + if (!Re(o)) { + e.throwInternal( + S.CRITICAL, + h.ItemNotInArray, + `This field was specified as an array in the contract but the item is not an array.\r +`, + { name: c }, + true + ); + } else { + s = []; + for (let u = 0; u < o.length; u++) { + let l = o[u], + f = n(l, c + '[' + u + ']'); + s.push(f); + } + } + } + return s; + } + function a(o, c, s) { + let u; + return ( + o && + ((u = {}), + Q(o, function (l, f) { + if (c === 'string') { + f === void 0 + ? (u[l] = 'undefined') + : f === null + ? (u[l] = 'null') + : f.toString + ? (u[l] = f.toString()) + : (u[l] = 'invalid field: toString() is not defined.'); + } else if (c === 'number') { + if (f === void 0) { + u[l] = 'undefined'; + } else if (f === null) { + u[l] = 'null'; + } else { + let m = parseFloat(f); + isNaN(m) ? (u[l] = 'NaN') : (u[l] = m); + } + } else { + (u[l] = 'invalid field: ' + s + ' is of unknown type.'), + e.throwInternal(S.CRITICAL, u[l], null, true); + } + })), + u + ); + } + }); + } + return t; + })(); +}); +let pl; +let ro; +let wc = C(() => { + J(); + Te(); + (pl = (function () { + function t() { + let e = Ct(), + r = Ne(), + n = false, + i = true; + W(t, this, function (a) { + try { + if ( + (e && + Jt.Attach(e, 'online', s) && + (Jt.Attach(e, 'offline', u), (n = true)), + r) + ) { + let o = r.body || r; + pe(o.ononline) || ((o.ononline = s), (o.onoffline = u), (n = true)); + } + if (n) { + let c = Ue(); + c && !x(c.onLine) && (i = c.onLine); + } + } catch (l) { + n = false; + } + (a.isListening = n), + (a.isOnline = function () { + let l = true, + f = Ue(); + return n ? (l = i) : f && !x(f.onLine) && (l = f.onLine), l; + }), + (a.isOffline = function () { + return !a.isOnline(); + }); + function s() { + i = true; + } + function u() { + i = false; + } + }); + } + return (t.Offline = new t()), t; + })()), + (ro = pl.Offline); +}); +let Pc; +let bc = C(() => { + Pc = (function () { + function t() {} + return ( + (t.prototype.getHashCodeScore = function (e) { + let r = this.getHashCode(e) / t.INT_MAX_VALUE; + return r * 100; + }), + (t.prototype.getHashCode = function (e) { + if (e === '') { + return 0; + } + for (; e.length < t.MIN_INPUT_LENGTH; ) { + e = e.concat(e); + } + for (var r = 5381, n = 0; n < e.length; ++n) { + (r = (r << 5) + r + e.charCodeAt(n)), (r = r & r); + } + return Math.abs(r); + }), + (t.INT_MAX_VALUE = 2147483647), + (t.MIN_INPUT_LENGTH = 8), + t + ); + })(); +}); +let Dc; +let Ac = C(() => { + bc(); + xe(); + Dc = (function () { + function t() { + (this.hashCodeGeneragor = new Pc()), (this.keys = new hr()); + } + return ( + (t.prototype.getSamplingScore = function (e) { + let r = 0; + return ( + e.tags && e.tags[this.keys.userId] + ? (r = this.hashCodeGeneragor.getHashCodeScore( + e.tags[this.keys.userId] + )) + : e.ext && e.ext.user && e.ext.user.id + ? (r = this.hashCodeGeneragor.getHashCodeScore(e.ext.user.id)) + : e.tags && e.tags[this.keys.operationId] + ? (r = this.hashCodeGeneragor.getHashCodeScore( + e.tags[this.keys.operationId] + )) + : e.ext && e.ext.telemetryTrace && e.ext.telemetryTrace.traceID + ? (r = this.hashCodeGeneragor.getHashCodeScore( + e.ext.telemetryTrace.traceID + )) + : (r = Math.random() * 100), + r + ); + }), + t + ); + })(); +}); +let Nc; +let Fc = C(() => { + Ac(); + xe(); + J(); + Nc = (function () { + function t(e, r) { + (this.INT_MAX_VALUE = 2147483647), + (this._logger = r || kt(null)), + (e > 100 || e < 0) && + (this._logger.throwInternal( + S.WARNING, + h.SampleRateOutOfRange, + 'Sampling rate is out of range (0..100). Sampling will be disabled, you may be sending too much data which may affect your AI service level.', + { samplingRate: e }, + true + ), + (e = 100)), + (this.sampleRate = e), + (this.samplingScoreGenerator = new Dc()); + } + return ( + (t.prototype.isSampledIn = function (e) { + let r = this.sampleRate, + n = false; + return r == null || r >= 100 || e.baseType === Ve.dataType + ? true + : ((n = this.samplingScoreGenerator.getSamplingScore(e) < r), n); + }), + t + ); + })(); +}); +function Si(t) { + try { + return t.responseText; + } catch (e) {} + return null; +} +let Dn; +let kc = C(() => { + ne(); + mc(); + Ic(); + Ec(); + xe(); + J(); + wc(); + Fc(); + Te(); + Dn = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + (r.priority = 1001), + (r.identifier = _r), + (r._XMLHttpRequestSupported = false); + let n, + i, + a, + o, + c, + s, + u = {}; + return ( + W(e, r, function (l, f) { + function m() { + Ae('Method not implemented.'); + } + (l.pause = m), + (l.resume = m), + (l.flush = function () { + try { + l.triggerSend(true, null, 1); + } catch (d) { + l.diagLog().throwInternal( + S.CRITICAL, + h.FlushFailed, + 'flush failed, telemetry will not be collected: ' + G(d), + { exception: O(d) } + ); + } + }), + (l.onunloadFlush = function () { + if ( + (l._senderConfig.onunloadDisableBeacon() === false || + l._senderConfig.isBeaconApiDisabled() === false) && + Nr() + ) { + try { + l.triggerSend(true, p, 2); + } catch (d) { + l.diagLog().throwInternal( + S.CRITICAL, + h.FailedToSendQueuedTelemetry, + 'failed to flush with beacon sender on page unload, telemetry will not be collected: ' + + G(d), + { exception: O(d) } + ); + } + } else { + l.flush(); + } + }), + (l.teardown = m), + (l.addHeader = function (d, T) { + u[d] = T; + }), + (l.initialize = function (d, T, A, D) { + f.initialize(d, T, A, D); + let z = l._getTelCtx(), + U = l.identifier; + (c = new Tc(T.logger)), + (n = 0), + (i = null), + (a = 0), + (l._sender = null), + (s = 0); + let q = e._getDefaultAppInsightsChannelConfig(); + if ( + ((l._senderConfig = e._getEmptyAppInsightsChannelConfig()), + Q(q, function (g, P) { + l._senderConfig[g] = function () { + return z.getConfig(U, g, P()); + }; + }), + (l._buffer = + l._senderConfig.enableSessionStorageBuffer() && wt() + ? new dc(l.diagLog(), l._senderConfig) + : new pc(l._senderConfig)), + (l._sample = new Nc( + l._senderConfig.samplingPercentage(), + l.diagLog() + )), + dt(d) || + l + .diagLog() + .throwInternal( + S.CRITICAL, + h.InvalidInstrumentationKey, + 'Invalid Instrumentation key ' + d.instrumentationKey + ), + !Rr(l._senderConfig.endpointUrl()) && + l._senderConfig.customHeaders() && + l._senderConfig.customHeaders().length > 0 && + R(l._senderConfig.customHeaders(), function (g) { + r.addHeader(g.header, g.value); + }), + !l._senderConfig.isBeaconApiDisabled() && Nr()) + ) { + l._sender = p; + } else { + let $ = we('XMLHttpRequest'); + if ($) { + let ie = new $(); + 'withCredentials' in ie + ? ((l._sender = v), (l._XMLHttpRequestSupported = true)) + : typeof XDomainRequest !== Oe && (l._sender = me); + } else { + let Ht = we('fetch'); + Ht && (l._sender = y); + } + } + }), + (l.processTelemetry = function (d, T) { + T = l._getTelCtx(T); + try { + if (l._senderConfig.disableTelemetry()) { + return; + } + if (!d) { + T.diagLog().throwInternal( + S.CRITICAL, + h.CannotSendEmptyTelemetry, + 'Cannot send empty telemetry' + ); + return; + } + if (d.baseData && !d.baseType) { + T.diagLog().throwInternal( + S.CRITICAL, + h.InvalidEvent, + 'Cannot send telemetry without baseData and baseType' + ); + return; + } + if ((d.baseType || (d.baseType = 'EventData'), !l._sender)) { + T.diagLog().throwInternal( + S.CRITICAL, + h.SenderNotInitialized, + 'Sender was not initialized' + ); + return; + } + if (I(d)) { + d[lr] = l._sample.sampleRate; + } else { + T.diagLog().throwInternal( + S.WARNING, + h.TelemetrySampledAndNotSent, + 'Telemetry item was sampled out and not sent', + { SampleRate: l._sample.sampleRate } + ); + return; + } + let A = e.constructEnvelope( + d, + l._senderConfig.instrumentationKey(), + T.diagLog() + ); + if (!A) { + T.diagLog().throwInternal( + S.CRITICAL, + h.CreateEnvelopeError, + 'Unable to create an AppInsights envelope' + ); + return; + } + let D = false; + if ( + (d.tags && + d.tags[Ut] && + (R(d.tags[Ut], function ($) { + try { + $ && + $(A) === false && + ((D = true), + T.diagLog().warnToConsole( + 'Telemetry processor check returns false' + )); + } catch (ie) { + T.diagLog().throwInternal( + S.CRITICAL, + h.TelemetryInitializerFailed, + 'One of telemetry initializers failed, telemetry item will not be sent: ' + + G(ie), + { exception: O(ie) }, + true + ); + } + }), + delete d.tags[Ut]), + D) + ) { + return; + } + let z = c.serialize(A), + U = l._buffer.getItems(), + q = l._buffer.batchPayloads(U); + q && + q.length + z.length > l._senderConfig.maxBatchSizeInBytes() && + l.triggerSend(true, null, 10), + l._buffer.enqueue(z), + Y(); + } catch ($) { + T.diagLog().throwInternal( + S.WARNING, + h.FailedAddingTelemetryToBuffer, + "Failed adding telemetry to the sender's buffer, some telemetry will be lost: " + + G($), + { exception: O($) } + ); + } + l.processNext(d, T); + }), + (l._xhrReadyStateChange = function (d, T, A) { + d.readyState === 4 && + E(d.status, T, d.responseURL, A, X(d), Si(d) || d.response); + }), + (l.triggerSend = function (d, T, A) { + d === void 0 && (d = true); + try { + if (l._senderConfig.disableTelemetry()) { + l._buffer.clear(); + } else { + if (l._buffer.count() > 0) { + let D = l._buffer.getItems(); + at(A || 0, d), T ? T.call(r, D, d) : l._sender(D, d); + } + a = +new Date(); + } + clearTimeout(o), (o = null), (i = null); + } catch (U) { + let z = or(); + (!z || z > 9) && + l + .diagLog() + .throwInternal( + S.CRITICAL, + h.TransmissionFailed, + 'Telemetry transmission failed, some telemetry will be lost: ' + + G(U), + { exception: O(U) } + ); + } + }), + (l._onError = function (d, T, A) { + l + .diagLog() + .throwInternal( + S.WARNING, + h.OnError, + 'Failed to send telemetry.', + { message: T } + ), + l._buffer.clearSent(d); + }), + (l._onPartialSuccess = function (d, T) { + for ( + var A = [], D = [], z = T.errors.reverse(), U = 0, q = z; + U < q.length; + U++ + ) { + let $ = q[U], + ie = d.splice($.index, 1)[0]; + Se($.statusCode) ? D.push(ie) : A.push(ie); + } + d.length > 0 && l._onSuccess(d, T.itemsAccepted), + A.length > 0 && + l._onError( + A, + X( + null, + [ + 'partial success', + T.itemsAccepted, + 'of', + T.itemsReceived, + ].join(' ') + ) + ), + D.length > 0 && + (L(D), + l + .diagLog() + .throwInternal( + S.WARNING, + h.TransmissionFailed, + 'Partial success. Delivered: ' + + d.length + + ', Failed: ' + + A.length + + '. Will retry to send ' + + D.length + + ' our of ' + + T.itemsReceived + + ' items' + )); + }), + (l._onSuccess = function (d, T) { + l._buffer.clearSent(d); + }), + (l._xdrOnLoad = function (d, T) { + let A = Si(d); + if (d && (A + '' == '200' || A === '')) { + (n = 0), l._onSuccess(T, 0); + } else { + let D = w(A); + D && + D.itemsReceived && + D.itemsReceived > D.itemsAccepted && + !l._senderConfig.isRetryDisabled() + ? l._onPartialSuccess(T, D) + : l._onError(T, De(d)); + } + }); + function I(d) { + return l._sample.isSampledIn(d); + } + function E(d, T, A, D, z, U) { + let q = null; + if ( + (l._appId || ((q = w(U)), q && q.appId && (l._appId = q.appId)), + (d < 200 || d >= 300) && d !== 0) + ) { + if ((d === 301 || d === 307 || d === 308) && !b(A)) { + l._onError(T, z); + return; + } + !l._senderConfig.isRetryDisabled() && Se(d) + ? (L(T), + l + .diagLog() + .throwInternal( + S.WARNING, + h.TransmissionFailed, + '. Response code ' + + d + + '. Will retry to send ' + + T.length + + ' items.' + )) + : l._onError(T, z); + } else if (ro.isOffline()) { + if (!l._senderConfig.isRetryDisabled()) { + let $ = 10; + L(T, $), + l + .diagLog() + .throwInternal( + S.WARNING, + h.TransmissionFailed, + '. Offline - Response Code: ' + + d + + '. Offline status: ' + + ro.isOffline() + + '. Will retry to send ' + + T.length + + ' items.' + ); + } + } else { + b(A), + d === 206 + ? (q || (q = w(U)), + q && !l._senderConfig.isRetryDisabled() + ? l._onPartialSuccess(T, q) + : l._onError(T, z)) + : ((n = 0), l._onSuccess(T, D)); + } + } + function b(d) { + return s >= 10 + ? false + : !x(d) && d !== '' && d !== l._senderConfig.endpointUrl() + ? ((l._senderConfig.endpointUrl = function () { + return d; + }), + ++s, + true) + : false; + } + function p(d, T) { + let A = l._senderConfig.endpointUrl(), + D = l._buffer.batchPayloads(d), + z = new Blob([D], { type: 'text/plain;charset=UTF-8' }), + U = Ue().sendBeacon(A, z); + U + ? (l._buffer.markAsSent(d), l._onSuccess(d, d.length)) + : (v(d, true), + l + .diagLog() + .throwInternal( + S.WARNING, + h.TransmissionFailed, + '. Failed to send telemetry with Beacon API, retried with xhrSender.' + )); + } + function v(d, T) { + let A = new XMLHttpRequest(), + D = l._senderConfig.endpointUrl(); + try { + A[Et] = true; + } catch (U) {} + A.open('POST', D, T), + A.setRequestHeader('Content-type', 'application/json'), + Rr(D) && + A.setRequestHeader( + te.sdkContextHeader, + te.sdkContextHeaderAppIdRequest + ), + R(Qe(u), function (U) { + A.setRequestHeader(U, u[U]); + }), + (A.onreadystatechange = function () { + return l._xhrReadyStateChange(A, d, d.length); + }), + (A.onerror = function (U) { + return l._onError(d, X(A), U); + }); + let z = l._buffer.batchPayloads(d); + A.send(z), l._buffer.markAsSent(d); + } + function y(d, T) { + let A = l._senderConfig.endpointUrl(), + D = l._buffer.batchPayloads(d), + z = new Blob([D], { type: 'text/plain;charset=UTF-8' }), + U = new Headers(); + Rr(A) && + U.append(te.sdkContextHeader, te.sdkContextHeaderAppIdRequest), + R(Qe(u), function (ie) { + U.append(ie, u[ie]); + }); + let q = { method: 'POST', headers: U, body: z }, + $ = new Request(A, q); + fetch($) + .then(function (ie) { + if (ie.ok) { + ie.text().then(function (Ht) { + E(ie.status, d, ie.url, d.length, ie.statusText, Ht); + }), + l._buffer.markAsSent(d); + } else { + throw Error(ie.statusText); + } + }) + .catch(function (ie) { + l._onError(d, ie.message); + }); + } + function w(d) { + try { + if (d && d !== '') { + let T = Pe().parse(d); + if ( + T && + T.itemsReceived && + T.itemsReceived >= T.itemsAccepted && + T.itemsReceived - T.itemsAccepted === T.errors.length + ) { + return T; + } + } + } catch (A) { + l.diagLog().throwInternal( + S.CRITICAL, + h.InvalidBackendResponse, + 'Cannot parse the response. ' + G(A), + { response: d } + ); + } + return null; + } + function L(d, T) { + if ((T === void 0 && (T = 1), !(!d || d.length === 0))) { + l._buffer.clearSent(d), n++; + for (let A = 0, D = d; A < D.length; A++) { + let z = D[A]; + l._buffer.enqueue(z); + } + F(T), Y(); + } + } + function F(d) { + let T = 10, + A; + if (n <= 1) { + A = T; + } else { + let D = (Math.pow(2, n) - 1) / 2, + z = Math.floor(Math.random() * D * T) + 1; + (z = d * z), (A = Math.max(Math.min(z, 3600), T)); + } + let U = de() + A * 1e3; + i = U; + } + function Y() { + if (!o) { + let d = i ? Math.max(0, i - de()) : 0, + T = Math.max(l._senderConfig.maxBatchInterval(), d); + o = setTimeout(function () { + l.triggerSend(true, null, 1); + }, T); + } + } + function Se(d) { + return d === 408 || d === 429 || d === 500 || d === 503; + } + function X(d, T) { + return d + ? 'XMLHttpRequest,Status:' + d.status + ',Response:' + Si(d) || + d.response || + '' + : T; + } + function me(d, T) { + let A = Ct(), + D = new XDomainRequest(); + (D.onload = function () { + return l._xdrOnLoad(D, d); + }), + (D.onerror = function ($) { + return l._onError(d, De(D), $); + }); + let z = (A && A.location && A.location.protocol) || ''; + if (l._senderConfig.endpointUrl().lastIndexOf(z, 0) !== 0) { + l + .diagLog() + .throwInternal( + S.WARNING, + h.TransmissionFailed, + ". Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol." + ), + l._buffer.clear(); + return; + } + let U = l._senderConfig.endpointUrl().replace(/^(https?:)/, ''); + D.open('POST', U); + let q = l._buffer.batchPayloads(d); + D.send(q), l._buffer.markAsSent(d); + } + function De(d, T) { + return d ? 'XDomainRequest,Response:' + Si(d) || '' : T; + } + function pt() { + let d = 'getNotifyMgr'; + return l.core[d] ? l.core[d]() : l.core._notificationManager; + } + function at(d, T) { + let A = pt(); + if (A && A.eventsSendRequest) { + try { + A.eventsSendRequest(d, T); + } catch (D) { + l.diagLog().throwInternal( + S.CRITICAL, + h.NotificationException, + 'send request notification failed: ' + G(D), + { exception: O(D) } + ); + } + } + } + function dt(d) { + let T = x(d.disableInstrumentationKeyValidation) + ? false + : d.disableInstrumentationKeyValidation; + if (T) { + return true; + } + let A = + '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', + D = new RegExp(A); + return D.test(d.instrumentationKey); + } + }), + r + ); + } + return ( + (e.constructEnvelope = function (r, n, i) { + let a; + switch ( + (n !== r.iKey && !x(n) ? (a = yt({}, r, { iKey: n })) : (a = r), + a.baseType) + ) { + case Be.dataType: + return to.EventEnvelopeCreator.Create(i, a); + case $e.dataType: + return Cc.TraceEnvelopeCreator.Create(i, a); + case Fe.dataType: + return yc.PageViewEnvelopeCreator.Create(i, a); + case Ze.dataType: + return Sc.PageViewPerformanceEnvelopeCreator.Create(i, a); + case he.dataType: + return hc.ExceptionEnvelopeCreator.Create(i, a); + case Ve.dataType: + return xc.MetricEnvelopeCreator.Create(i, a); + case qe.dataType: + return vc.DependencyEnvelopeCreator.Create(i, a); + default: + return to.EventEnvelopeCreator.Create(i, a); + } + }), + (e._getDefaultAppInsightsChannelConfig = function () { + return { + endpointUrl: function () { + return 'https://dc.services.visualstudio.com/v2/track'; + }, + emitLineDelimitedJson: function () { + return false; + }, + maxBatchInterval: function () { + return 15e3; + }, + maxBatchSizeInBytes: function () { + return 102400; + }, + disableTelemetry: function () { + return false; + }, + enableSessionStorageBuffer: function () { + return true; + }, + isRetryDisabled: function () { + return false; + }, + isBeaconApiDisabled: function () { + return true; + }, + onunloadDisableBeacon: function () { + return false; + }, + instrumentationKey: function () {}, + namePrefix: function () {}, + samplingPercentage: function () { + return 100; + }, + customHeaders: function () {}, + }; + }), + (e._getEmptyAppInsightsChannelConfig = function () { + return { + endpointUrl: void 0, + emitLineDelimitedJson: void 0, + maxBatchInterval: void 0, + maxBatchSizeInBytes: void 0, + disableTelemetry: void 0, + enableSessionStorageBuffer: void 0, + isRetryDisabled: void 0, + isBeaconApiDisabled: void 0, + onunloadDisableBeacon: void 0, + instrumentationKey: void 0, + namePrefix: void 0, + samplingPercentage: void 0, + customHeaders: void 0, + }; + }), + e + ); + })(tt); +}); +let no = C(() => { + kc(); +}); +let dl; +let io; +let Rc; +let Mc = C(() => { + Te(); + xe(); + J(); + (dl = 'ai_session'), + (io = (function () { + function t() {} + return t; + })()), + (Rc = (function () { + function t(e, r) { + let n = this, + i, + a, + o = kt(r), + c = cr(r); + W(t, n, function (s) { + e || (e = {}), + j(e.sessionExpirationMs) || + (e.sessionExpirationMs = function () { + return t.acquisitionSpan; + }), + j(e.sessionRenewalMs) || + (e.sessionRenewalMs = function () { + return t.renewalSpan; + }), + (s.config = e); + let u = + s.config.sessionCookiePostfix && s.config.sessionCookiePostfix() + ? s.config.sessionCookiePostfix() + : s.config.namePrefix && s.config.namePrefix() + ? s.config.namePrefix() + : ''; + (i = function () { + return dl + u; + }), + (s.automaticSession = new io()), + (s.update = function () { + let b = de(), + p = false, + v = s.automaticSession; + v.id || (p = !l(v, b)); + let y = s.config.sessionExpirationMs(); + if (!p && y > 0) { + let w = s.config.sessionRenewalMs(), + L = b - v.acquisitionDate, + F = b - v.renewalDate; + (p = L < 0 || F < 0), (p = p || L > y), (p = p || F > w); + } + p ? m(b) : (!a || b - a > t.cookieUpdateInterval) && I(v, b); + }), + (s.backup = function () { + let b = s.automaticSession; + E(b.id, b.acquisitionDate, b.renewalDate); + }); + function l(b, p) { + let v = false, + y = c.get(i()); + if (y && j(y.split)) { + v = f(b, y); + } else { + let w = dn(o, i()); + w && (v = f(b, w)); + } + return v || !!b.id; + } + function f(b, p) { + let v = false, + y = ', session will be reset', + w = p.split('|'); + if (w.length >= 2) { + try { + let L = +w[1] || 0, + F = +w[2] || 0; + isNaN(L) || L <= 0 + ? o.throwInternal( + S.WARNING, + h.SessionRenewalDateIsZero, + 'AI session acquisition date is 0' + y + ) + : isNaN(F) || F <= 0 + ? o.throwInternal( + S.WARNING, + h.SessionRenewalDateIsZero, + 'AI session renewal date is 0' + y + ) + : w[0] && + ((b.id = w[0]), + (b.acquisitionDate = L), + (b.renewalDate = F), + (v = true)); + } catch (Y) { + o.throwInternal( + S.CRITICAL, + h.ErrorParsingAISessionCookie, + 'Error parsing ai_session value [' + + (p || '') + + ']' + + y + + ' - ' + + G(Y), + { exception: O(Y) } + ); + } + } + return v; + } + function m(b) { + let p = s.config || {}, + v = (p.getNewId ? p.getNewId() : null) || Wt; + (s.automaticSession.id = v(p.idLength ? p.idLength() : 22)), + (s.automaticSession.acquisitionDate = b), + I(s.automaticSession, b), + kr() || + o.throwInternal( + S.WARNING, + h.BrowserDoesNotSupportLocalStorage, + 'Browser does not support local storage. Session durations will be inaccurate.' + ); + } + function I(b, p) { + let v = b.acquisitionDate; + b.renewalDate = p; + let y = s.config, + w = y.sessionRenewalMs(), + L = v + y.sessionExpirationMs() - p, + F = [b.id, v, p], + Y = 0; + L < w ? (Y = L / 1e3) : (Y = w / 1e3); + let Se = y.cookieDomain ? y.cookieDomain() : null; + c.set(i(), F.join('|'), y.sessionExpirationMs() > 0 ? Y : null, Se), + (a = p); + } + function E(b, p, v) { + mn(o, i(), [b, p, v].join('|')); + } + }); + } + return ( + (t.acquisitionSpan = 864e5), + (t.renewalSpan = 18e5), + (t.cookieUpdateInterval = 6e4), + t + ); + })()); +}); +let Lc; +let Uc = C(() => { + Lc = (function () { + function t() {} + return t; + })(); +}); +let _c; +let Oc = C(() => { + _c = (function () { + function t() { + (this.id = 'browser'), (this.deviceClass = 'Browser'); + } + return t; + })(); +}); +let ml; +let Hc; +let jc = C(() => { + (ml = '2.6.4'), + (Hc = (function () { + function t(e) { + this.sdkVersion = + (e.sdkExtension && e.sdkExtension() ? e.sdkExtension() + '_' : '') + + 'javascript:' + + ml; + } + return t; + })()); +}); +function zc(t) { + return !(typeof t !== 'string' || !t || t.match(/,|;|=| |\|/)); +} +let Bc; +let Vc = C(() => { + Te(); + xe(); + J(); + Bc = (function () { + function t(e, r) { + this.isNewUser = false; + let n = kt(r), + i = cr(r), + a; + W(t, this, function (o) { + o.config = e; + let c = + o.config.userCookiePostfix && o.config.userCookiePostfix() + ? o.config.userCookiePostfix() + : ''; + a = function () { + return t.userCookieName + c; + }; + let s = i.get(a()); + if (s) { + o.isNewUser = false; + let u = s.split(t.cookieSeparator); + u.length > 0 && (o.id = u[0]); + } + if (!o.id) { + let l = e || {}, + f = (l.getNewId ? l.getNewId() : null) || Wt; + o.id = f(l.idLength ? e.idLength() : 22); + let m = 31536e3, + I = Me(new Date()); + (o.accountAcquisitionDate = I), (o.isNewUser = true); + let E = [o.id, I]; + i.set(a(), E.join(t.cookieSeparator), m); + let b = + e.namePrefix && e.namePrefix() + ? e.namePrefix() + 'ai_session' + : 'ai_session'; + gn(n, b); + } + o.accountId = e.accountId ? e.accountId() : void 0; + let p = i.get(t.authUserCookieName); + if (p) { + p = decodeURI(p); + let v = p.split(t.cookieSeparator); + v[0] && (o.authenticatedId = v[0]), + v.length > 1 && v[1] && (o.accountId = v[1]); + } + (o.setAuthenticatedUserContext = function (y, w, L) { + L === void 0 && (L = false); + let F = !zc(y) || (w && !zc(w)); + if (F) { + n.throwInternal( + S.WARNING, + h.SetAuthContextFailedAccountName, + 'Setting auth user context failed. User auth/account id should be of type string, and not contain commas, semi-colons, equal signs, spaces, or vertical-bars.', + true + ); + return; + } + o.authenticatedId = y; + let Y = o.authenticatedId; + w && + ((o.accountId = w), + (Y = [o.authenticatedId, o.accountId].join(t.cookieSeparator))), + L && i.set(t.authUserCookieName, encodeURI(Y)); + }), + (o.clearAuthenticatedUserContext = function () { + (o.authenticatedId = null), + (o.accountId = null), + i.del(t.authUserCookieName); + }); + }); + } + return ( + (t.cookieSeparator = '|'), + (t.userCookieName = 'ai_user'), + (t.authUserCookieName = 'ai_authUser'), + t + ); + })(); +}); +let qc; +let Gc = C(() => { + qc = (function () { + function t() {} + return t; + })(); +}); +let Kc; +let Wc = C(() => { + xe(); + J(); + Kc = (function () { + function t(e, r, n, i) { + let a = this; + (a.traceID = e || He()), (a.parentID = r), (a.name = n); + let o = et(); + !n && o && o.pathname && (a.name = o.pathname), (a.name = ae(i, a.name)); + } + return t; + })(); +}); +function Or(t, e) { + t && t[e] && Qe(t[e]).length === 0 && delete t[e]; +} +let Ci; +let Ii; +let Jc; +let Xc = C(() => { + Te(); + J(); + Mc(); + xe(); + Uc(); + Oc(); + jc(); + Vc(); + Gc(); + Wc(); + (Ci = 'ext'), (Ii = 'tags'); + Jc = (function () { + function t(e, r) { + let n = this, + i = e.logger; + (this.appId = function () { + return null; + }), + W(t, this, function (a) { + (a.application = new Lc()), + (a.internal = new Hc(r)), + ar() && + ((a.sessionManager = new Rc(r, e)), + (a.device = new _c()), + (a.location = new qc()), + (a.user = new Bc(r, e)), + (a.telemetryTrace = new Kc(void 0, void 0, void 0, i)), + (a.session = new io())), + (a.applySessionContext = function (o, c) { + let s = a.session, + u = a.sessionManager; + s && _(s.id) + ? K(ge(o.ext, _e.AppExt), 'sesId', s.id) + : u && + u.automaticSession && + K(ge(o.ext, _e.AppExt), 'sesId', u.automaticSession.id, _); + }), + (a.applyOperatingSystemContxt = function (o, c) { + K(o.ext, _e.OSExt, a.os); + }), + (a.applyApplicationContext = function (o, c) { + let s = a.application; + if (s) { + let u = ge(o, Ii); + K(u, re.applicationVersion, s.ver, _), + K(u, re.applicationBuild, s.build, _); + } + }), + (a.applyDeviceContext = function (o, c) { + let s = a.device; + if (s) { + let u = ge(ge(o, Ci), _e.DeviceExt); + K(u, 'localId', s.id, _), + K(u, 'ip', s.ip, _), + K(u, 'model', s.model, _), + K(u, 'deviceClass', s.deviceClass, _); + } + }), + (a.applyInternalContext = function (o, c) { + let s = a.internal; + if (s) { + let u = ge(o, Ii); + K(u, re.internalAgentVersion, s.agentVersion, _), + K(u, re.internalSdkVersion, s.sdkVersion, _), + (o.baseType === Ft.dataType || o.baseType === Fe.dataType) && + (K(u, re.internalSnippet, s.snippetVer, _), + K(u, re.internalSdkSrc, s.sdkSrc, _)); + } + }), + (a.applyLocationContext = function (o, c) { + let s = n.location; + s && K(ge(o, Ii, []), re.locationIp, s.ip, _); + }), + (a.applyOperationContext = function (o, c) { + let s = a.telemetryTrace; + if (s) { + let u = ge(ge(o, Ci), _e.TraceExt, { + traceID: void 0, + parentID: void 0, + }); + K(u, 'traceID', s.traceID, _), + K(u, 'name', s.name, _), + K(u, 'parentID', s.parentID, _); + } + }), + (a.applyWebContext = function (o, c) { + let s = n.web; + s && K(ge(o, Ci), _e.WebExt, s); + }), + (a.applyUserContext = function (o, c) { + let s = a.user; + if (s) { + let u = ge(o, Ii, []); + K(u, re.userAccountId, s.accountId, _); + let l = ge(ge(o, Ci), _e.UserExt); + K(l, 'id', s.id, _), K(l, 'authId', s.authenticatedId, _); + } + }), + (a.cleanUp = function (o, c) { + let s = o.ext; + s && + (Or(s, _e.DeviceExt), + Or(s, _e.UserExt), + Or(s, _e.WebExt), + Or(s, _e.OSExt), + Or(s, _e.AppExt), + Or(s, _e.TraceExt)); + }); + }); + } + return t; + })(); +}); +let gl; +let An; +let Yc = C(() => { + ne(); + Te(); + J(); + Xc(); + xe(); + (gl = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + (r.priority = 110), (r.identifier = Ot); + let n, i; + return ( + W(e, r, function (a, o) { + (a.initialize = function (s, u, l, f) { + o.initialize(s, u, l, f); + let m = a._getTelCtx(), + I = a.identifier, + E = e.getDefaultConfig(); + (i = i || {}), + Q(E, function (b, p) { + i[b] = function () { + return m.getConfig(I, b, p()); + }; + }), + (a.context = new Jc(u, i)), + (n = cn(l, _r)), + (a.context.appId = function () { + return n ? n._appId : null; + }), + (a._extConfig = i); + }), + (a.processTelemetry = function (s, u) { + if (!x(s)) { + (u = a._getTelCtx(u)), + s.name === Fe.envelopeType && + u.diagLog().resetInternalMessageCount(); + let l = a.context || {}; + if ( + (l.session && + typeof a.context.session.id !== 'string' && + l.sessionManager && + l.sessionManager.update(), + c(s, u), + l.user && l.user.isNewUser) + ) { + l.user.isNewUser = false; + let f = new Ft( + h.SendBrowserInfoOnUserInit, + (Ue() || {}).userAgent || '' + ); + u.diagLog().logInternalMessage(S.CRITICAL, f); + } + a.processNext(s, u); + } + }); + function c(s, u) { + ge(s, 'tags', []), ge(s, 'ext', {}); + let l = a.context; + l.applySessionContext(s, u), + l.applyApplicationContext(s, u), + l.applyDeviceContext(s, u), + l.applyOperationContext(s, u), + l.applyUserContext(s, u), + l.applyOperatingSystemContxt(s, u), + l.applyWebContext(s, u), + l.applyLocationContext(s, u), + l.applyInternalContext(s, u), + l.cleanUp(s, u); + } + }), + r + ); + } + return ( + (e.getDefaultConfig = function () { + let r = { + instrumentationKey: function () {}, + accountId: function () { + return null; + }, + sessionRenewalMs: function () { + return 30 * 60 * 1e3; + }, + samplingPercentage: function () { + return 100; + }, + sessionExpirationMs: function () { + return 24 * 60 * 60 * 1e3; + }, + cookieDomain: function () { + return null; + }, + sdkExtension: function () { + return null; + }, + isBrowserLinkTrackingEnabled: function () { + return false; + }, + appId: function () { + return null; + }, + namePrefix: function () {}, + sessionCookiePostfix: function () {}, + userCookiePostfix: function () {}, + idLength: function () { + return 22; + }, + getNewId: function () { + return null; + }, + }; + return r; + }), + e + ); + })(tt)), + (An = gl); +}); +let ao = C(() => { + Yc(); +}); +function $c(t, e, r) { + let n = 0, + i = t[e], + a = t[r]; + return i && a && (n = ve(i, a)), n; +} +function xr(t, e, r, n, i) { + let a = 0, + o = $c(r, n, i); + return o && (a = tr(t, e, Ge(o))), a; +} +function tr(t, e, r) { + let n = 'ajaxPerf', + i = 0; + if (t && e && r) { + let a = (t[n] = t[n] || {}); + (a[e] = r), (i = 1); + } + return i; +} +function vl(t, e) { + let r = t.perfTiming, + n = e[nt] || {}, + i = 0, + a = 'name', + o = 'Start', + c = 'End', + s = 'domainLookup', + u = 'connect', + l = 'redirect', + f = 'request', + m = 'response', + I = 'duration', + E = 'startTime', + b = s + o, + p = s + c, + v = u + o, + y = u + c, + w = f + o, + L = f + c, + F = m + o, + Y = m + c, + Se = l + o, + X = (l = c), + me = 'transferSize', + De = 'encodedBodySize', + pt = 'decodedBodySize', + at = 'serverTiming'; + if (r) { + (i |= xr(n, l, r, Se, X)), + (i |= xr(n, s, r, b, p)), + (i |= xr(n, u, r, v, y)), + (i |= xr(n, f, r, w, L)), + (i |= xr(n, m, r, F, Y)), + (i |= xr(n, 'networkConnect', r, E, y)), + (i |= xr(n, 'sentRequest', r, w, Y)); + let dt = r[I]; + dt || (dt = $c(r, E, Y) || 0), + (i |= tr(n, I, dt)), + (i |= tr(n, 'perfTotal', dt)); + let d = r[at]; + if (d) { + let T = {}; + R(d, function (A, D) { + let z = zi(A[a] || '' + D), + U = T[z] || {}; + Q(A, function (q, $) { + ((q !== a && _($)) || ir($)) && + (U[q] && ($ = U[q] + ';' + $), ($ || !_($)) && (U[q] = $)); + }), + (T[z] = U); + }), + (i |= tr(n, at, T)); + } + (i |= tr(n, me, r[me])), (i |= tr(n, De, r[De])), (i |= tr(n, pt, r[pt])); + } else { + t.perfMark && (i |= tr(n, 'missing', t.perfAttempts)); + } + i && (e[nt] = n); +} +let nt; +let hl; +let oo; +let Zc = C(() => { + xe(); + J(); + Te(); + nt = 'properties'; + (hl = (function () { + function t() { + let e = this; + (e.openDone = false), + (e.setRequestHeaderDone = false), + (e.sendDone = false), + (e.abortDone = false), + (e.stateChangeAttached = false); + } + return t; + })()), + (oo = (function () { + function t(e, r, n) { + let i = this, + a = n, + o = 'responseText'; + (i.perfMark = null), + (i.completed = false), + (i.requestHeadersSize = null), + (i.requestHeaders = null), + (i.responseReceivingDuration = null), + (i.callbackDuration = null), + (i.ajaxTotalDuration = null), + (i.aborted = 0), + (i.pageUrl = null), + (i.requestUrl = null), + (i.requestSize = 0), + (i.method = null), + (i.status = null), + (i.requestSentTime = null), + (i.responseStartedTime = null), + (i.responseFinishedTime = null), + (i.callbackFinishedTime = null), + (i.endTime = null), + (i.xhrMonitoringState = new hl()), + (i.clientFailure = 0), + (i.traceID = e), + (i.spanID = r), + W(t, i, function (c) { + (c.getAbsoluteUrl = function () { + return c.requestUrl ? hn(c.requestUrl) : null; + }), + (c.getPathName = function () { + return c.requestUrl ? Tt(a, xn(c.method, c.requestUrl)) : null; + }), + (c.CreateTrackItem = function (s, u, l) { + if ( + ((c.ajaxTotalDuration = + Math.round( + ve(c.requestSentTime, c.responseFinishedTime) * 1e3 + ) / 1e3), + c.ajaxTotalDuration < 0) + ) { + return null; + } + let f = + ((b = { + id: '|' + c.traceID + '.' + c.spanID, + target: c.getAbsoluteUrl(), + name: c.getPathName(), + type: s, + startTime: null, + duration: c.ajaxTotalDuration, + success: +c.status >= 200 && +c.status < 400, + responseCode: +c.status, + method: c.method, + }), + (b[nt] = { HttpMethod: c.method }), + b); + if ( + (c.requestSentTime && + ((f.startTime = new Date()), + f.startTime.setTime(c.requestSentTime)), + vl(c, f), + u && + Qe(c.requestHeaders).length > 0 && + ((f[nt] = f[nt] || {}), + (f[nt].requestHeaders = c.requestHeaders)), + l) + ) { + let m = l(); + if (m) { + let I = m.correlationContext; + if ( + (I && (f.correlationContext = I), + m.headerMap && + Qe(m.headerMap).length > 0 && + ((f[nt] = f[nt] || {}), + (f[nt].responseHeaders = m.headerMap)), + c.status >= 400) + ) { + let E = m.type; + (f[nt] = f[nt] || {}), + (E === '' || E === 'text') && + (f[nt][o] = m[o] + ? m.statusText + ' - ' + m[o] + : m.statusText), + E === 'json' && + (f[nt][o] = m.response + ? m.statusText + ' - ' + JSON.stringify(m.response) + : m.statusText); + } + } + } + return f; + let b; + }); + }); + } + return t; + })()); +}); +let mh; +let Qc = C(() => { + J(); + J(); + mh = (function () { + function t() {} + return ( + (t.GetLength = function (e) { + let r = 0; + if (!x(e)) { + let n = ''; + try { + n = e.toString(); + } catch (i) {} + (r = n.length), (r = isNaN(r) ? 0 : r); + } + return r; + }), + t + ); + })(); +}); +let so; +let eu = C(() => { + J(); + so = (function () { + function t(e, r) { + let n = this; + (n.traceFlag = t.DEFAULT_TRACE_FLAG), + (n.version = t.DEFAULT_VERSION), + e && t.isValidTraceId(e) ? (n.traceId = e) : (n.traceId = He()), + r && t.isValidSpanId(r) + ? (n.spanId = r) + : (n.spanId = He().substr(0, 16)); + } + return ( + (t.isValidTraceId = function (e) { + return ( + e.match(/^[0-9a-f]{32}$/) && e !== '00000000000000000000000000000000' + ); + }), + (t.isValidSpanId = function (e) { + return e.match(/^[0-9a-f]{16}$/) && e !== '0000000000000000'; + }), + (t.prototype.toString = function () { + let e = this; + return e.version + '-' + e.traceId + '-' + e.spanId + '-' + e.traceFlag; + }), + (t.DEFAULT_TRACE_FLAG = '01'), + (t.DEFAULT_VERSION = '00'), + t + ); + })(); +}); +function xl() { + let t = ot(); + return !t || x(t.Request) || x(t.Request[Ie]) || x(t[Fn]) ? null : t[Fn]; +} +function yl(t) { + let e = false; + if (typeof XMLHttpRequest !== Oe && !x(XMLHttpRequest)) { + let r = XMLHttpRequest[Ie]; + e = !x(r) && !x(r.open) && !x(r.send) && !x(r.abort); + } + let n = or(); + if ((n && n < 9 && (e = false), e)) { + try { + let i = new XMLHttpRequest(); + i[it] = {}; + let a = XMLHttpRequest[Ie].open; + XMLHttpRequest[Ie].open = a; + } catch (o) { + (e = false), + kn( + t, + h.FailedMonitorAjaxOpen, + 'Failed to enable XMLHttpRequest monitoring, extension is not supported', + { exception: O(o) } + ); + } + } + return e; +} +function Ti(t) { + let e = ''; + try { + !x(t) && + !x(t[it]) && + !x(t[it].requestUrl) && + (e += "(url: '" + t[it].requestUrl + "')"); + } catch (r) {} + return e; +} +function kn(t, e, r, n, i) { + t[Nn]()[ru](S.CRITICAL, e, r, n, i); +} +function Ei(t, e, r, n, i) { + t[Nn]()[ru](S.WARNING, e, r, n, i); +} +function Rn(t, e, r) { + return function (n) { + kn(t, e, r, { ajaxDiagnosticsMessage: Ti(n.inst), exception: O(n.err) }); + }; +} +function Hr(t, e) { + return t && e ? t.indexOf(e) : -1; +} +let tu; +let Nn; +let it; +let ru; +let Fn; +let nu; +let Mn; +let iu = C(() => { + ne(); + xe(); + J(); + Zc(); + Qc(); + eu(); + Te(); + (tu = 'ai.ajxmn.'), + (Nn = 'diagLog'), + (it = 'ajaxData'), + (ru = 'throwInternal'), + (Fn = 'fetch'), + (nu = 0); + Mn = (function (t) { + H(e, t); + function e() { + let r = t.call(this) || this; + (r.identifier = e.identifier), (r.priority = 120); + let n = 'trackDependencyDataInternal', + i = et(), + a = false, + o = false, + c = i && i.host && i.host.toLowerCase(), + s = e.getEmptyConfig(), + u = false, + l = 0, + f, + m, + I, + E, + b = false, + p = 0, + v = false, + y = [], + w = {}, + L; + return ( + W(e, r, function (F, Y) { + (F.initialize = function (g, P, N, k) { + if (!F.isInitialized()) { + Y.initialize(g, P, N, k); + let M = F._getTelCtx(), + V = e.getDefaultConfig(); + Q(V, function (We, yr) { + s[We] = M.getConfig(e.identifier, We, yr); + }); + let B = s.distributedTracingMode; + if ( + ((u = s.enableRequestHeaderTracking), + (b = s.enableAjaxPerfTracking), + (p = s.maxAjaxCallsPerView), + (v = s.enableResponseHeaderTracking), + (L = s.excludeRequestFromAutoTrackingPatterns), + (I = B === Ke.AI || B === Ke.AI_AND_W3C), + (m = B === Ke.AI_AND_W3C || B === Ke.W3C), + b) + ) { + let Z = g.instrumentationKey || 'unkwn'; + Z.length > 5 + ? (E = tu + Z.substring(Z.length - 5) + '.') + : (E = tu + Z + '.'); + } + if ( + (s.disableAjaxTracking === false && De(), + X(), + N.length > 0 && N) + ) { + for (var ce = void 0, Ce = 0; !ce && Ce < N.length; ) { + N[Ce] && N[Ce].identifier === Ot && (ce = N[Ce]), Ce++; + } + ce && (f = ce.context); + } + } + }), + (F.teardown = function () { + R(y, function (g) { + g.rm(); + }), + (y = []), + (a = false), + (o = false), + F.setInitialized(false); + }), + (F.trackDependencyData = function (g, P) { + F[n](g, P); + }), + (F.includeCorrelationHeaders = function (g, P, N, k) { + let M = F._currentWindowHost || c; + if (P) { + if (Pt.canIncludeCorrelationHeader(s, g.getAbsoluteUrl(), M)) { + if ( + (N || (N = {}), + (N.headers = new Headers( + N.headers || (P instanceof Request ? P.headers || {} : {}) + )), + I) + ) { + var V = '|' + g.traceID + '.' + g.spanID; + N.headers.set(te.requestIdHeader, V), + u && (g.requestHeaders[te.requestIdHeader] = V); + } + var B = s.appId || (f && f.appId()); + if ( + (B && + (N.headers.set( + te.requestContextHeader, + te.requestContextAppIdFormat + B + ), + u && + (g.requestHeaders[te.requestContextHeader] = + te.requestContextAppIdFormat + B)), + m) + ) { + var Z = new so(g.traceID, g.spanID); + N.headers.set(te.traceParentHeader, Z.toString()), + u && + (g.requestHeaders[te.traceParentHeader] = Z.toString()); + } + } + return N; + } else if (k) { + if (Pt.canIncludeCorrelationHeader(s, g.getAbsoluteUrl(), M)) { + if (I) { + var V = '|' + g.traceID + '.' + g.spanID; + k.setRequestHeader(te.requestIdHeader, V), + u && (g.requestHeaders[te.requestIdHeader] = V); + } + var B = s.appId || (f && f.appId()); + if ( + (B && + (k.setRequestHeader( + te.requestContextHeader, + te.requestContextAppIdFormat + B + ), + u && + (g.requestHeaders[te.requestContextHeader] = + te.requestContextAppIdFormat + B)), + m) + ) { + var Z = new so(g.traceID, g.spanID); + k.setRequestHeader(te.traceParentHeader, Z.toString()), + u && + (g.requestHeaders[te.traceParentHeader] = Z.toString()); + } + } + return k; + } + }), + (F[n] = function (g, P, N) { + if (p === -1 || l < p) { + (s.distributedTracingMode === Ke.W3C || + s.distributedTracingMode === Ke.AI_AND_W3C) && + typeof g.id === 'string' && + g.id[g.id.length - 1] !== '.' && + (g.id += '.'), + x(g.startTime) && (g.startTime = new Date()); + let k = rt.create( + g, + qe.dataType, + qe.envelopeType, + F[Nn](), + P, + N + ); + F.core.track(k); + } else { + l === p && + kn( + F, + h.MaxAjaxPerPVExceeded, + 'Maximum ajax per page view limit reached, ajax monitoring is paused until the next trackPageView(). In order to increase the limit set the maxAjaxCallsPerView configuration parameter.', + true + ); + } + ++l; + }); + function Se(g) { + let P = true; + return ( + (g || s.ignoreHeaders) && + R(s.ignoreHeaders, function (N) { + if (N.toLowerCase() === g.toLowerCase()) { + return (P = false), -1; + } + }), + P + ); + } + function X() { + let g = xl(); + if (!!g) { + let P = ot(), + N = g.polyfill; + s.disableFetchTracking === false + ? (y.push( + sn(P, Fn, { + req: function (k, M, V) { + let B; + if (a && !pt(null, M, V) && !(N && o)) { + let Z = k.ctx(); + B = q(M, V); + let ce = F.includeCorrelationHeaders(B, M, V); + ce !== V && k.set(1, ce), (Z.data = B); + } + }, + rsp: function (k, M) { + let V = k.ctx().data; + V && + (k.rslt = k.rslt + .then(function (B) { + return ( + ie(k, (B || {}).status, B, V, function () { + let Z = { + statusText: B.statusText, + headerMap: null, + correlationContext: Ht(B), + }; + if (v) { + let ce = {}; + B.headers.forEach(function (Ce, We) { + Se(We) && (ce[We] = Ce); + }), + (Z.headerMap = ce); + } + return Z; + }), + B + ); + }) + .catch(function (B) { + throw ( + (ie(k, 0, M, V, null, { error: B.message }), B) + ); + })); + }, + hkErr: Rn( + F, + h.FailedMonitorAjaxOpen, + 'Failed to monitor Window.fetch, monitoring data for this fetch call may be incorrect.' + ), + }) + ), + (a = true)) + : N && + y.push( + sn(P, Fn, { + req: function (k, M, V) { + pt(null, M, V); + }, + }) + ), + N && (P[Fn].polyfill = N); + } + } + function me(g, P, N) { + y.push(Ea(g, P, N)); + } + function De() { + yl(F) && + !o && + (me(XMLHttpRequest, 'open', { + req: function (g, P, N, k) { + let M = g.inst, + V = M[it]; + !pt(M, N) && + at(M, true) && + (!V || !V.xhrMonitoringState.openDone) && + dt(M, P, N, k); + }, + hkErr: Rn( + F, + h.FailedMonitorAjaxOpen, + 'Failed to monitor XMLHttpRequest.open, monitoring data for this ajax call may be incorrect.' + ), + }), + me(XMLHttpRequest, 'send', { + req: function (g, P) { + let N = g.inst, + k = N[it]; + at(N) && + !k.xhrMonitoringState.sendDone && + (z('xhr', k), + (k.requestSentTime = mr()), + F.includeCorrelationHeaders(k, void 0, void 0, N), + (k.xhrMonitoringState.sendDone = true)); + }, + hkErr: Rn( + F, + h.FailedMonitorAjaxSend, + 'Failed to monitor XMLHttpRequest, monitoring data for this ajax call may be incorrect.' + ), + }), + me(XMLHttpRequest, 'abort', { + req: function (g) { + let P = g.inst, + N = P[it]; + at(P) && + !N.xhrMonitoringState.abortDone && + ((N.aborted = 1), (N.xhrMonitoringState.abortDone = true)); + }, + hkErr: Rn( + F, + h.FailedMonitorAjaxAbort, + 'Failed to monitor XMLHttpRequest.abort, monitoring data for this ajax call may be incorrect.' + ), + }), + u && + me(XMLHttpRequest, 'setRequestHeader', { + req: function (g, P, N) { + let k = g.inst; + at(k) && Se(P) && (k[it].requestHeaders[P] = N); + }, + hkErr: Rn( + F, + h.FailedMonitorAjaxSetRequestHeader, + 'Failed to monitor XMLHttpRequest.setRequestHeader, monitoring data for this ajax call may be incorrect.' + ), + }), + (o = true)); + } + function pt(g, P, N) { + let k = false, + M = ((_(P) ? P : (P || {}).url || '') || '').toLowerCase(); + if ( + (R(L, function (Z) { + let ce = Z; + _(Z) && (ce = new RegExp(Z)), k || (k = ce.test(M)); + }), + k) + ) { + return k; + } + let V = Hr(M, '?'), + B = Hr(M, '#'); + return ( + (V === -1 || (B !== -1 && B < V)) && (V = B), + V !== -1 && (M = M.substring(0, V)), + x(g) + ? x(P) || + (k = + (typeof P === 'object' ? P[Et] === true : false) || + (N ? N[Et] === true : false)) + : (k = g[Et] === true || M[Et] === true), + k ? w[M] || (w[M] = 1) : w[M] && (k = true), + k + ); + } + function at(g, P) { + let N = true, + k = o; + return x(g) || (N = P === true || !x(g[it])), k && N; + } + function dt(g, P, N, k) { + let M = (f && f.telemetryTrace && f.telemetryTrace.traceID) || He(), + V = He().substr(0, 16), + B = new oo(M, V, F[Nn]()); + (B.method = P), + (B.requestUrl = N), + (B.xhrMonitoringState.openDone = true), + (B.requestHeaders = {}), + (B.async = k), + (g[it] = B), + d(g); + } + function d(g) { + g[it].xhrMonitoringState.stateChangeAttached = Jt.Attach( + g, + 'readystatechange', + function () { + try { + g && g.readyState === 4 && at(g) && A(g); + } catch (N) { + let P = O(N); + (!P || Hr(P.toLowerCase(), 'c00c023f') === -1) && + kn( + F, + h.FailedMonitorAjaxRSC, + "Failed to monitor XMLHttpRequest 'readystatechange' event handler, monitoring data for this ajax call may be incorrect.", + { ajaxDiagnosticsMessage: Ti(g), exception: P } + ); + } + } + ); + } + function T(g) { + try { + let P = g.responseType; + if (P === '' || P === 'text') { + return g.responseText; + } + } catch (N) {} + return null; + } + function A(g) { + let P = g[it]; + (P.responseFinishedTime = mr()), (P.status = g.status); + function N(k, M) { + let V = M || {}; + (V.ajaxDiagnosticsMessage = Ti(g)), + k && (V.exception = O(k)), + Ei( + F, + h.FailedMonitorAjaxDur, + "Failed to calculate the duration of the ajax call, monitoring data for this ajax call won't be sent.", + V + ); + } + U( + 'xmlhttprequest', + P, + function () { + try { + let k = P.CreateTrackItem('Ajax', u, function () { + let M = { + statusText: g.statusText, + headerMap: null, + correlationContext: D(g), + type: g.responseType, + responseText: T(g), + response: g.response, + }; + if (v) { + let V = g.getAllResponseHeaders(); + if (V) { + let B = oe(V).split(/[\r\n]+/), + Z = {}; + R(B, function (ce) { + let Ce = ce.split(': '), + We = Ce.shift(), + yr = Ce.join(': '); + Se(We) && (Z[We] = yr); + }), + (M.headerMap = Z); + } + } + return M; + }); + k + ? F[n](k) + : N(null, { + requestSentTime: P.requestSentTime, + responseFinishedTime: P.responseFinishedTime, + }); + } finally { + try { + g[it] = null; + } catch (M) {} + } + }, + function (k) { + N(k, null); + } + ); + } + function D(g) { + try { + let P = g.getAllResponseHeaders(); + if (P !== null) { + let N = Hr(P.toLowerCase(), te.requestContextHeaderLowerCase); + if (N !== -1) { + let k = g.getResponseHeader(te.requestContextHeader); + return Pt.getCorrelationContext(k); + } + } + } catch (M) { + Ei( + F, + h.FailedMonitorAjaxGetCorrelationHeader, + 'Failed to get Request-Context correlation header as it may be not included in the response or not accessible.', + { ajaxDiagnosticsMessage: Ti(g), exception: O(M) } + ); + } + } + function z(g, P) { + if (P.requestUrl && E && b) { + let N = Ye(); + if (N && j(N.mark)) { + nu++; + let k = E + g + '#' + nu; + N.mark(k); + let M = N.getEntriesByName(k); + M && M.length === 1 && (P.perfMark = M[0]); + } + } + } + function U(g, P, N, k) { + let M = P.perfMark, + V = Ye(), + B = s.maxAjaxPerfLookupAttempts, + Z = s.ajaxPerfLookupDelay, + ce = P.requestUrl, + Ce = 0; + (function We() { + try { + if (V && M) { + Ce++; + for ( + let yr = null, fo = V.getEntries(), Pi = fo.length - 1; + Pi >= 0; + Pi-- + ) { + let bt = fo[Pi]; + if (bt) { + if (bt.entryType === 'resource') { + bt.initiatorType === g && + (Hr(bt.name, ce) !== -1 || Hr(ce, bt.name) !== -1) && + (yr = bt); + } else if ( + bt.entryType === 'mark' && + bt.name === M.name + ) { + P.perfTiming = yr; + break; + } + if (bt.startTime < M.startTime - 1e3) { + break; + } + } + } + } + !M || P.perfTiming || Ce >= B || P.async === false + ? (M && j(V.clearMarks) && V.clearMarks(M.name), + (P.perfAttempts = Ce), + N()) + : setTimeout(We, Z); + } catch (gu) { + k(gu); + } + })(); + } + function q(g, P) { + let N = (f && f.telemetryTrace && f.telemetryTrace.traceID) || He(), + k = He().substr(0, 16), + M = new oo(N, k, F[Nn]()); + (M.requestSentTime = mr()), + g instanceof Request + ? (M.requestUrl = g ? g.url : '') + : (M.requestUrl = g); + let V = 'GET'; + P && P.method + ? (V = P.method) + : g && g instanceof Request && (V = g.method), + (M.method = V); + let B = {}; + if (u) { + let Z = new Headers( + (P ? P.headers : 0) || + (g instanceof Request ? g.headers || {} : {}) + ); + Z.forEach(function (ce, Ce) { + Se(Ce) && (B[Ce] = ce); + }); + } + return (M.requestHeaders = B), z('fetch', M), M; + } + function $(g) { + let P = ''; + try { + x(g) || + (typeof g === 'string' + ? (P += "(url: '" + g + "')") + : (P += "(url: '" + g.url + "')")); + } catch (N) { + kn( + F, + h.FailedMonitorAjaxOpen, + 'Failed to grab failed fetch diagnostics message', + { exception: O(N) } + ); + } + return P; + } + function ie(g, P, N, k, M, V) { + if (!k) { + return; + } + function B(Z, ce, Ce) { + let We = Ce || {}; + (We.fetchDiagnosticsMessage = $(N)), + ce && (We.exception = O(ce)), + Ei( + F, + Z, + "Failed to calculate the duration of the fetch call, monitoring data for this fetch call won't be sent.", + We + ); + } + (k.responseFinishedTime = mr()), + (k.status = P), + U( + 'fetch', + k, + function () { + let Z = k.CreateTrackItem('Fetch', u, M); + Z + ? F[n](Z) + : B(h.FailedMonitorAjaxDur, null, { + requestSentTime: k.requestSentTime, + responseFinishedTime: k.responseFinishedTime, + }); + }, + function (Z) { + B(h.FailedMonitorAjaxGetCorrelationHeader, Z, null); + } + ); + } + function Ht(g) { + if (g && g.headers) { + try { + let P = g.headers.get(te.requestContextHeader); + return Pt.getCorrelationContext(P); + } catch (N) { + Ei( + F, + h.FailedMonitorAjaxGetCorrelationHeader, + 'Failed to get Request-Context correlation header as it may be not included in the response or not accessible.', + { fetchDiagnosticsMessage: $(g), exception: O(N) } + ); + } + } + } + }), + r + ); + } + return ( + (e.getDefaultConfig = function () { + let r = { + maxAjaxCallsPerView: 500, + disableAjaxTracking: false, + disableFetchTracking: true, + excludeRequestFromAutoTrackingPatterns: void 0, + disableCorrelationHeaders: false, + distributedTracingMode: Ke.AI_AND_W3C, + correlationHeaderExcludedDomains: [ + '*.blob.core.windows.net', + '*.blob.core.chinacloudapi.cn', + '*.blob.core.cloudapi.de', + '*.blob.core.usgovcloudapi.net', + ], + correlationHeaderDomains: void 0, + correlationHeaderExcludePatterns: void 0, + appId: void 0, + enableCorsCorrelation: false, + enableRequestHeaderTracking: false, + enableResponseHeaderTracking: false, + enableAjaxErrorStatusText: false, + enableAjaxPerfTracking: false, + maxAjaxPerfLookupAttempts: 3, + ajaxPerfLookupDelay: 25, + ignoreHeaders: ['Authorization', 'X-API-Key', 'WWW-Authenticate'], + }; + return r; + }), + (e.getEmptyConfig = function () { + let r = this.getDefaultConfig(); + return ( + Q(r, function (n) { + r[n] = void 0; + }), + r + ); + }), + (e.prototype.processTelemetry = function (r, n) { + this.processNext(r, n); + }), + (e.identifier = 'AjaxDependencyPlugin'), + e + ); + })(tt); +}); +let co = C(() => { + iu(); +}); +let uo; +let au; +let Sl; +let ou; +let wi; +let lo = C(() => { + J(); + Qa(); + no(); + ao(); + co(); + xe(); + (au = [ + 'snippet', + 'dependencies', + 'properties', + '_snippetVersion', + 'appInsightsNew', + 'getSKUDefaults', + ]), + (Sl = { Default: 0, Required: 1, Array: 2, Hidden: 4 }), + (ou = { + __proto__: null, + PropertiesPluginIdentifier: Ot, + BreezeChannelIdentifier: _r, + AnalyticsPluginIdentifier: yi, + Util: Sn, + CorrelationIdHelper: Pt, + UrlHelper: _a, + DateTimeUtils: Oa, + ConnectionStringParser: ja, + FieldType: Sl, + RequestHeaders: te, + DisabledPropertyName: Et, + ProcessLegacy: Ut, + SampleRate: lr, + HttpMethod: Fr, + DEFAULT_BREEZE_ENDPOINT: fn, + AIData: In, + AIBase: Cn, + Envelope: Tn, + Event: Be, + Exception: he, + Metric: Ve, + PageView: Fe, + PageViewData: gr, + RemoteDependencyData: qe, + Trace: $e, + PageViewPerformance: Ze, + Data: xt, + SeverityLevel: _t, + ConfigurationManager: Xa, + ContextTagKeys: hr, + DataSanitizer: Da, + TelemetryItemCreator: rt, + CtxTagKeys: re, + Extensions: _e, + DistributedTracingModes: Ke, + }), + (wi = (function () { + function t(e) { + let r = this; + (r._snippetVersion = '' + (e.sv || e.version || '')), + (e.queue = e.queue || []), + (e.version = e.version || 2); + let n = e.config || {}; + if (n.connectionString) { + let i = di(n.connectionString), + a = i.ingestionendpoint; + (n.endpointUrl = a ? a + '/v2/track' : n.endpointUrl), + (n.instrumentationKey = + i.instrumentationkey || n.instrumentationKey); + } + (r.appInsights = new bn()), + (r.properties = new An()), + (r.dependencies = new Mn()), + (r.core = new en()), + (r._sender = new Dn()), + (r.snippet = e), + (r.config = n), + r.getSKUDefaults(); + } + return ( + (t.prototype.getCookieMgr = function () { + return this.appInsights.getCookieMgr(); + }), + (t.prototype.trackEvent = function (e, r) { + this.appInsights.trackEvent(e, r); + }), + (t.prototype.trackPageView = function (e) { + let r = e || {}; + this.appInsights.trackPageView(r); + }), + (t.prototype.trackPageViewPerformance = function (e) { + let r = e || {}; + this.appInsights.trackPageViewPerformance(r); + }), + (t.prototype.trackException = function (e) { + e && !e.exception && e.error && (e.exception = e.error), + this.appInsights.trackException(e); + }), + (t.prototype._onerror = function (e) { + this.appInsights._onerror(e); + }), + (t.prototype.trackTrace = function (e, r) { + this.appInsights.trackTrace(e, r); + }), + (t.prototype.trackMetric = function (e, r) { + this.appInsights.trackMetric(e, r); + }), + (t.prototype.startTrackPage = function (e) { + this.appInsights.startTrackPage(e); + }), + (t.prototype.stopTrackPage = function (e, r, n, i) { + this.appInsights.stopTrackPage(e, r, n, i); + }), + (t.prototype.startTrackEvent = function (e) { + this.appInsights.startTrackEvent(e); + }), + (t.prototype.stopTrackEvent = function (e, r, n) { + this.appInsights.stopTrackEvent(e, r, n); + }), + (t.prototype.addTelemetryInitializer = function (e) { + return this.appInsights.addTelemetryInitializer(e); + }), + (t.prototype.setAuthenticatedUserContext = function (e, r, n) { + n === void 0 && (n = false), + this.properties.context.user.setAuthenticatedUserContext(e, r, n); + }), + (t.prototype.clearAuthenticatedUserContext = function () { + this.properties.context.user.clearAuthenticatedUserContext(); + }), + (t.prototype.trackDependencyData = function (e) { + this.dependencies.trackDependencyData(e); + }), + (t.prototype.flush = function (e) { + let r = this; + e === void 0 && (e = true), + ct( + this.core, + function () { + return 'AISKU.flush'; + }, + function () { + R(r.core.getTransmissionControls(), function (n) { + R(n, function (i) { + i.flush(e); + }); + }); + }, + null, + e + ); + }), + (t.prototype.onunloadFlush = function (e) { + e === void 0 && (e = true), + R(this.core.getTransmissionControls(), function (r) { + R(r, function (n) { + n.onunloadFlush ? n.onunloadFlush() : n.flush(e); + }); + }); + }), + (t.prototype.loadAppInsights = function (e, r, n) { + let i = this; + e === void 0 && (e = false); + let a = this; + function o(c) { + if (c) { + let s = ''; + x(a._snippetVersion) || (s += a._snippetVersion), + e && (s += '.lg'), + a.context && + a.context.internal && + (a.context.internal.snippetVer = s || '-'), + Q(a, function (u, l) { + _(u) && + !j(l) && + u && + u[0] !== '_' && + au.indexOf(u) === -1 && + (c[u] = l); + }); + } + } + return ( + e && + a.config.extensions && + a.config.extensions.length > 0 && + Ae('Extensions not allowed in legacy mode'), + ct( + a.core, + function () { + return 'AISKU.loadAppInsights'; + }, + function () { + let c = []; + c.push(a._sender), + c.push(a.properties), + c.push(a.dependencies), + c.push(a.appInsights), + a.core.initialize(a.config, c, r, n), + (a.context = a.properties.context), + uo && a.context && (a.context.internal.sdkSrc = uo), + o(a.snippet), + a.emptyQueue(), + a.pollInternalLogs(), + a.addHousekeepingBeforeUnload(i); + } + ), + a + ); + }), + (t.prototype.updateSnippetDefinitions = function (e) { + Wr(e, this, function (r) { + return r && au.indexOf(r) === -1; + }); + }), + (t.prototype.emptyQueue = function () { + let e = this; + try { + if (Re(e.snippet.queue)) { + for (let r = e.snippet.queue.length, n = 0; n < r; n++) { + let i = e.snippet.queue[n]; + i(); + } + (e.snippet.queue = void 0), delete e.snippet.queue; + } + } catch (o) { + let a = {}; + o && j(o.toString) && (a.exception = o.toString()); + } + }), + (t.prototype.pollInternalLogs = function () { + this.core.pollInternalLogs(); + }), + (t.prototype.addHousekeepingBeforeUnload = function (e) { + if (ar() || Wn()) { + let r = function () { + e.onunloadFlush(false), + R(e.appInsights.core._extensions, function (i) { + if (i.identifier === Ot) { + return ( + i && + i.context && + i.context._sessionManager && + i.context._sessionManager.backup(), + -1 + ); + } + }); + }; + if (!e.appInsights.config.disableFlushOnBeforeUnload) { + let n = Mt('beforeunload', r); + (n = Mt('unload', r) || n), + (n = Mt('pagehide', r) || n), + (n = Mt('visibilitychange', r) || n), + !n && + !Qi() && + e.appInsights.core.logger.throwInternal( + S.CRITICAL, + h.FailedToAddHandlerForOnBeforeUnload, + 'Could not add handler for beforeunload and pagehide' + ); + } + e.appInsights.config.disableFlushOnUnload || + (Mt('pagehide', r), Mt('visibilitychange', r)); + } + }), + (t.prototype.getSender = function () { + return this._sender; + }), + (t.prototype.getSKUDefaults = function () { + let e = this; + e.config.diagnosticLogInterval = + e.config.diagnosticLogInterval && e.config.diagnosticLogInterval > 0 + ? e.config.diagnosticLogInterval + : 1e4; + }), + t + ); + })()); + (function () { + let t = null, + e = false, + r = ['://js.monitor.azure.com/', '://az416426.vo.msecnd.net/']; + try { + let n = (document || {}).currentScript; + n && (t = n.src); + } catch (c) {} + if (t) { + try { + let i = t.toLowerCase(); + if (i) { + for (let a = '', o = 0; o < r.length; o++) { + if (i.indexOf(r[o]) !== -1) { + (a = 'cdn' + (o + 1)), + i.indexOf('/scripts/') === -1 && + (i.indexOf('/next/') !== -1 + ? (a += '-next') + : i.indexOf('/beta/') !== -1 && (a += '-beta')), + (uo = a + (e ? '.mod' : '')); + break; + } + } + } + } catch (c) {} + } + })(); +}); +let Cl; +let su; +let cu = C(() => { + xe(); + J(); + (Cl = [ + 'snippet', + 'getDefaultConfig', + '_hasLegacyInitializers', + '_queue', + '_processLegacyInitializers', + ]), + (su = (function () { + function t(e, r) { + (this._hasLegacyInitializers = false), + (this._queue = []), + (this.config = t.getDefaultConfig(e.config)), + (this.appInsightsNew = r), + (this.context = { + addTelemetryInitializer: this.addTelemetryInitializers.bind(this), + }); + } + return ( + (t.getDefaultConfig = function (e) { + return ( + e || (e = {}), + (e.endpointUrl = + e.endpointUrl || 'https://dc.services.visualstudio.com/v2/track'), + (e.sessionRenewalMs = 30 * 60 * 1e3), + (e.sessionExpirationMs = 24 * 60 * 60 * 1e3), + (e.maxBatchSizeInBytes = + e.maxBatchSizeInBytes > 0 ? e.maxBatchSizeInBytes : 102400), + (e.maxBatchInterval = isNaN(e.maxBatchInterval) + ? 15e3 + : e.maxBatchInterval), + (e.enableDebug = ee(e.enableDebug)), + (e.disableExceptionTracking = ee(e.disableExceptionTracking)), + (e.disableTelemetry = ee(e.disableTelemetry)), + (e.verboseLogging = ee(e.verboseLogging)), + (e.emitLineDelimitedJson = ee(e.emitLineDelimitedJson)), + (e.diagnosticLogInterval = e.diagnosticLogInterval || 1e4), + (e.autoTrackPageVisitTime = ee(e.autoTrackPageVisitTime)), + (isNaN(e.samplingPercentage) || + e.samplingPercentage <= 0 || + e.samplingPercentage >= 100) && + (e.samplingPercentage = 100), + (e.disableAjaxTracking = ee(e.disableAjaxTracking)), + (e.maxAjaxCallsPerView = isNaN(e.maxAjaxCallsPerView) + ? 500 + : e.maxAjaxCallsPerView), + (e.isBeaconApiDisabled = ee(e.isBeaconApiDisabled, true)), + (e.disableCorrelationHeaders = ee(e.disableCorrelationHeaders)), + (e.correlationHeaderExcludedDomains = e.correlationHeaderExcludedDomains || [ + '*.blob.core.windows.net', + '*.blob.core.chinacloudapi.cn', + '*.blob.core.cloudapi.de', + '*.blob.core.usgovcloudapi.net', + ]), + (e.disableFlushOnBeforeUnload = ee(e.disableFlushOnBeforeUnload)), + (e.disableFlushOnUnload = ee( + e.disableFlushOnUnload, + e.disableFlushOnBeforeUnload + )), + (e.enableSessionStorageBuffer = ee( + e.enableSessionStorageBuffer, + true + )), + (e.isRetryDisabled = ee(e.isRetryDisabled)), + (e.isCookieUseDisabled = ee(e.isCookieUseDisabled)), + (e.isStorageUseDisabled = ee(e.isStorageUseDisabled)), + (e.isBrowserLinkTrackingEnabled = ee( + e.isBrowserLinkTrackingEnabled + )), + (e.enableCorsCorrelation = ee(e.enableCorsCorrelation)), + e + ); + }), + (t.prototype.addTelemetryInitializers = function (e) { + let r = this; + this._hasLegacyInitializers || + (this.appInsightsNew.addTelemetryInitializer(function (n) { + r._processLegacyInitializers(n); + }), + (this._hasLegacyInitializers = true)), + this._queue.push(e); + }), + (t.prototype.getCookieMgr = function () { + return this.appInsightsNew.getCookieMgr(); + }), + (t.prototype.startTrackPage = function (e) { + this.appInsightsNew.startTrackPage(e); + }), + (t.prototype.stopTrackPage = function (e, r, n, i) { + this.appInsightsNew.stopTrackPage(e, r, n); + }), + (t.prototype.trackPageView = function (e, r, n, i, a) { + let o = { name: e, uri: r, properties: n, measurements: i }; + this.appInsightsNew.trackPageView(o); + }), + (t.prototype.trackEvent = function (e, r, n) { + this.appInsightsNew.trackEvent({ name: e }); + }), + (t.prototype.trackDependency = function (e, r, n, i, a, o, c) { + this.appInsightsNew.trackDependencyData({ + id: e, + target: n, + type: i, + duration: a, + properties: { HttpMethod: r }, + success: o, + responseCode: c, + }); + }), + (t.prototype.trackException = function (e, r, n, i, a) { + this.appInsightsNew.trackException({ exception: e }); + }), + (t.prototype.trackMetric = function (e, r, n, i, a, o) { + this.appInsightsNew.trackMetric({ + name: e, + average: r, + sampleCount: n, + min: i, + max: a, + }); + }), + (t.prototype.trackTrace = function (e, r, n) { + this.appInsightsNew.trackTrace({ message: e, severityLevel: n }); + }), + (t.prototype.flush = function (e) { + this.appInsightsNew.flush(e); + }), + (t.prototype.setAuthenticatedUserContext = function (e, r, n) { + this.appInsightsNew.context.user.setAuthenticatedUserContext(e, r, n); + }), + (t.prototype.clearAuthenticatedUserContext = function () { + this.appInsightsNew.context.user.clearAuthenticatedUserContext(); + }), + (t.prototype._onerror = function (e, r, n, i, a) { + this.appInsightsNew._onerror({ + message: e, + url: r, + lineNumber: n, + columnNumber: i, + error: a, + }); + }), + (t.prototype.startTrackEvent = function (e) { + this.appInsightsNew.startTrackEvent(e); + }), + (t.prototype.stopTrackEvent = function (e, r, n) { + this.appInsightsNew.stopTrackEvent(e, r, n); + }), + (t.prototype.downloadAndSetup = function (e) { + Ae('downloadAndSetup not implemented in web SKU'); + }), + (t.prototype.updateSnippetDefinitions = function (e) { + Wr(e, this, function (r) { + return r && Cl.indexOf(r) === -1; + }); + }), + (t.prototype.loadAppInsights = function () { + let e = this; + if (this.config.iKey) { + let r = this.trackPageView; + this.trackPageView = function (a, o, c) { + r.apply(e, [null, a, o, c]); + }; + } + let n = 'logPageView'; + typeof this.snippet[n] === 'function' && + (this[n] = function (a, o, c) { + e.trackPageView(null, a, o, c); + }); + let i = 'logEvent'; + return ( + typeof this.snippet[i] === 'function' && + (this[i] = function (a, o, c) { + e.trackEvent(a, o, c); + }), + this + ); + }), + (t.prototype._processLegacyInitializers = function (e) { + return (e.tags[Ut] = this._queue), e; + }), + t + ); + })()); +}); +let uu; +let lu = C(() => { + cu(); + lo(); + J(); + uu = (function () { + function t() {} + return ( + (t.getAppInsights = function (e, r) { + let n = new wi(e), + i = r !== 2; + if ((Xt(), r === 2)) { + return n.updateSnippetDefinitions(e), n.loadAppInsights(i), n; + } + let a = new su(e, n); + return a.updateSnippetDefinitions(e), n.loadAppInsights(i), a; + }), + t + ); + })(); +}); +let fu = {}; +hu(fu, { + AppInsightsCore: () => en, + ApplicationAnalytics: () => bn, + ApplicationInsights: () => wi, + ApplicationInsightsContainer: () => uu, + BaseCore: () => Zr, + BaseTelemetryPlugin: () => tt, + CoreUtils: () => on, + DependenciesPlugin: () => Mn, + DistributedTracingModes: () => Ke, + Event: () => Be, + Exception: () => he, + LoggingSeverity: () => S, + Metric: () => Ve, + NotificationManager: () => Qr, + PageView: () => Fe, + PageViewPerformance: () => Ze, + PerfEvent: () => sr, + PerfManager: () => Jr, + PropertiesPlugin: () => An, + RemoteDependencyData: () => qe, + Sender: () => Dn, + SeverityLevel: () => _t, + Telemetry: () => ou, + Trace: () => $e, + Util: () => Sn, + _InternalMessageId: () => h, + doPerf: () => ct, +}); +let pu = C(() => { + lo(); + lu(); + J(); + xe(); + no(); + Qa(); + ao(); + co(); +}); +let Je; +(function (n) { + (n.ON = 'on'), (n.ERROR = 'error'), (n.OFF = 'off'); +})(Je || (Je = {})); +function jr() { + let t = 'telemetry', + e = 'enableTelemetry'; + return import_vscode.env.isTelemetryEnabled !== void 0 + ? import_vscode.env.isTelemetryEnabled + ? Je.ON + : Je.OFF + : import_vscode.workspace.getConfiguration(t).get(e) + ? Je.ON + : Je.OFF; +} +let bi = class { + constructor(e, r, n, i, a) { + this.extensionId = e; + this.extensionVersion = r; + this.telemetryAppender = n; + this.osShim = i; + this.firstParty = false; + this.userOptIn = false; + this.errorOptIn = false; + this.disposables = []; + (this.firstParty = !!a), + this.updateUserOptStatus(), + ue.env.onDidChangeTelemetryEnabled !== void 0 + ? (this.disposables.push( + ue.env.onDidChangeTelemetryEnabled(() => this.updateUserOptStatus()) + ), + this.disposables.push( + ue.workspace.onDidChangeConfiguration(() => + this.updateUserOptStatus() + ) + )) + : this.disposables.push( + ue.workspace.onDidChangeConfiguration(() => + this.updateUserOptStatus() + ) + ); + } + updateUserOptStatus() { + let e = jr(); + (this.userOptIn = e === Je.ON), + (this.errorOptIn = e === Je.ERROR || e === Je.ON), + (this.userOptIn || this.errorOptIn) && + this.telemetryAppender.instantiateAppender(); + } + cleanRemoteName(e) { + if (!e) { + return 'none'; + } + let r = 'other'; + return ( + ['ssh-remote', 'dev-container', 'attached-container', 'wsl'].forEach( + (n) => { + e.indexOf(`${n}+`) === 0 && (r = n); + } + ), + r + ); + } + get extension() { + return ( + this._extension === void 0 && + (this._extension = ue.extensions.getExtension(this.extensionId)), + this._extension + ); + } + cloneAndChange(e, r) { + if (e === null || typeof e !== 'object' || typeof r !== 'function') { + return e; + } + let n = {}; + for (let i in e) { + n[i] = r(i, e[i]); + } + return n; + } + shouldSendErrorTelemetry() { + return this.errorOptIn === false + ? false + : this.firstParty + ? this.cleanRemoteName(ue.env.remoteName) !== 'other' + ? true + : !( + this.extension === void 0 || + this.extension.extensionKind === ue.ExtensionKind.Workspace || + ue.env.uiKind === ue.UIKind.Web + ) + : true; + } + getCommonProperties() { + let e = Object.create(null); + if ( + ((e['common.os'] = this.osShim.platform), + (e['common.platformversion'] = (this.osShim.release || '').replace( + /^(\d+)(\.\d+)?(\.\d+)?(.*)/, + '$1$2$3' + )), + (e['common.extname'] = this.extensionId), + (e['common.extversion'] = this.extensionVersion), + ue && ue.env) + ) { + switch ( + ((e['common.vscodemachineid'] = ue.env.machineId), + (e['common.vscodesessionid'] = ue.env.sessionId), + (e['common.vscodeversion'] = ue.version), + (e['common.isnewappinstall'] = ue.env.isNewAppInstall + ? ue.env.isNewAppInstall.toString() + : 'false'), + (e['common.product'] = ue.env.appHost), + ue.env.uiKind) + ) { + case ue.UIKind.Web: + e['common.uikind'] = 'web'; + break; + case ue.UIKind.Desktop: + e['common.uikind'] = 'desktop'; + break; + default: + e['common.uikind'] = 'unknown'; + } + e['common.remotename'] = this.cleanRemoteName(ue.env.remoteName); + } + return e; + } + anonymizeFilePaths(e, r) { + let n; + if (e == null) { + return ''; + } + let i = []; + ue.env.appRoot !== '' && + i.push( + new RegExp(ue.env.appRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi') + ), + this.extension && + i.push( + new RegExp( + this.extension.extensionPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), + 'gi' + ) + ); + let a = e; + if (r) { + let o = []; + for (let l of i) { + for (; (n = l.exec(e)) && n; ) { + o.push([n.index, l.lastIndex]); + } + } + let c = /^[\\/]?(node_modules|node_modules\.asar)[\\/]/, + s = /(file:\/\/)?([a-zA-Z]:(\\\\|\\|\/)|(\\\\|\\|\/))?([\w-._]+(\\\\|\\|\/))+[\w-._]*/g, + u = 0; + for (a = ''; (n = s.exec(e)) && n; ) { + n[0] && + !c.test(n[0]) && + o.every(([l, f]) => n.index < l || n.index >= f) && + ((a += e.substring(u, n.index) + ''), + (u = s.lastIndex)); + } + u < e.length && (a += e.substr(u)); + } + for (let o of i) { + a = a.replace(o, ''); + } + return a; + } + removePropertiesWithPossibleUserInfo(e) { + if (typeof e !== 'object') { + return; + } + let r = Object.create(null); + for (let n of Object.keys(e)) { + let i = e[n]; + if (!i) { + continue; + } + let a = /@[a-zA-Z0-9-.]+/; + /\S*(key|token|sig|password|passwd|pwd)[="':\s]+\S*/.test(i.toLowerCase()) + ? (r[n] = '') + : a.test(i) + ? (r[n] = '') + : (r[n] = i); + } + return r; + } + sendTelemetryEvent(e, r, n) { + if (this.userOptIn && e !== '') { + r = { ...r, ...this.getCommonProperties() }; + let i = this.cloneAndChange(r, (a, o) => + this.anonymizeFilePaths(o, this.firstParty) + ); + this.telemetryAppender.logEvent(`${this.extensionId}/${e}`, { + properties: this.removePropertiesWithPossibleUserInfo(i), + measurements: n, + }); + } + } + sendTelemetryErrorEvent(e, r, n, i) { + if (this.errorOptIn && e !== '') { + r = { ...r, ...this.getCommonProperties() }; + let a = this.cloneAndChange(r, (o, c) => + this.shouldSendErrorTelemetry() + ? this.anonymizeFilePaths(c, this.firstParty) + : i === void 0 || i.indexOf(o) !== -1 + ? 'REDACTED' + : this.anonymizeFilePaths(c, this.firstParty) + ); + this.telemetryAppender.logEvent(`${this.extensionId}/${e}`, { + properties: this.removePropertiesWithPossibleUserInfo(a), + measurements: n, + }); + } + } + sendTelemetryException(e, r, n) { + if (this.shouldSendErrorTelemetry() && this.errorOptIn && e) { + r = { ...r, ...this.getCommonProperties() }; + let i = this.cloneAndChange(r, (a, o) => + this.anonymizeFilePaths(o, this.firstParty) + ); + e.stack && (e.stack = this.anonymizeFilePaths(e.stack, this.firstParty)), + this.telemetryAppender.logException(e, { + properties: this.removePropertiesWithPossibleUserInfo(i), + measurements: n, + }); + } + } + dispose() { + return ( + this.telemetryAppender.flush(), + Promise.all(this.disposables.map((e) => e.dispose())) + ); + } +}; +let du = class { + constructor(e) { + this._key = e; + this._isInstantiated = false; + jr() !== Je.OFF && this.instantiateAppender(); + } + logEvent(e, r) { + !this._aiClient || + this._aiClient.trackEvent( + { name: e }, + { ...r.properties, ...r.measurements } + ); + } + logException(e, r) { + !this._aiClient || + this._aiClient.trackException({ + exception: e, + properties: { ...r.properties, ...r.measurements }, + }); + } + flush() { + return ( + this._aiClient && (this._aiClient.flush(), (this._aiClient = void 0)), + Promise.resolve(void 0) + ); + } + instantiateAppender() { + this._isInstantiated || + Promise.resolve() + .then(() => (pu(), fu)) + .then((e) => { + let r; + this._key && + this._key.indexOf('AIF-') === 0 && + (r = 'https://vortex.data.microsoft.com/collect/v1'), + (this._aiClient = new e.ApplicationInsights({ + config: { + instrumentationKey: this._key, + endpointUrl: r, + disableAjaxTracking: true, + disableExceptionTracking: true, + disableFetchTracking: true, + disableCorrelationHeaders: true, + disableCookiesUsage: true, + autoTrackPageVisitTime: false, + emitLineDelimitedJson: true, + disableInstrumentationKeyValidation: true, + }, + })), + this._aiClient.loadAppInsights(); + let n = jr(); + r && + (n === Je.ON || n === Je.ERROR) && + fetch(r).catch(() => (this._aiClient = void 0)), + (this._isInstantiated = true); + }); + } +}; +let mu = class extends bi { + constructor(e, r, n, i) { + let a = new du(n); + n && n.indexOf('AIF-') === 0 && (i = true); + super(e, r, a, { release: navigator.appVersion, platform: 'web' }, i); + } +}; + +// client/src/main.ts +function activate(context) { + const telemetry = new mu( + context.extension.id, + context.extension.packageJSON['version'], + context.extension.packageJSON['aiKey'] + ); + const supportedLanguages = new SupportedLanguages(context); + let serverHandles = []; + startServer(); + function startServer() { + serverHandles.push(_startServer(context, supportedLanguages, telemetry)); + } + async function stopServers() { + const oldHandles = serverHandles.slice(0); + serverHandles = []; + const result = await Promise.allSettled(oldHandles); + for (const item of result) { + if (item.status === 'fulfilled') { + item.value.dispose(); + } + } + } + context.subscriptions.push(supportedLanguages); + context.subscriptions.push( + supportedLanguages.onDidChange(() => { + stopServers(); + startServer(); + }) + ); + context.subscriptions.push(new vscode2.Disposable(stopServers)); +} +async function _showStatusAndInfo( + context, + supportedLanguages, + showCommandHint +) { + const disposables = []; + const _mementoKey = 'didShowMessage'; + const didShowExplainer = context.globalState.get(_mementoKey, false); + disposables.push( + vscode2.commands.registerCommand('anycode.resetDidShowMessage', () => + context.globalState.update(_mementoKey, false) + ) + ); + const statusItem = vscode2.languages.createLanguageStatusItem( + 'info', + supportedLanguages.getSupportedLanguagesAsSelector() + ); + disposables.push(statusItem); + statusItem.severity = vscode2.LanguageStatusSeverity.Warning; + statusItem.text = `Partial Mode`; + if (showCommandHint) { + statusItem.detail = + 'Language support for this file is inaccurate. $(lightbulb-autofix) Did not index all files because search [indexing is disabled](command:remoteHub.enableIndexing).'; + } else { + statusItem.detail = 'Language support for this file is inaccurate.'; + } + statusItem.command = { + title: 'Learn More', + command: 'vscode.open', + arguments: [vscode2.Uri.parse('https://aka.ms/vscode-anycode')], + }; + if (!didShowExplainer) { + async function showMessage() { + await vscode2.window.showInformationMessage( + 'Language support is inaccurate in this context, results may be imprecise and incomplete.' + ); + } + const provideFyi = async () => { + registrations.dispose(); + context.globalState.update(_mementoKey, true); + context.globalState.setKeysForSync([_mementoKey]); + showMessage(); + return void 0; + }; + const selector = supportedLanguages.getSupportedLanguagesAsSelector(); + const registrations = vscode2.Disposable.from( + vscode2.languages.registerDefinitionProvider(selector, { + provideDefinition: provideFyi, + }), + vscode2.languages.registerReferenceProvider(selector, { + provideReferences: provideFyi, + }) + ); + disposables.push(registrations); + } + return vscode2.Disposable.from(...disposables); +} +async function _startServer(context, supportedLanguages, telemetry) { + const disposables = []; + function _sendFeatureTelementry(name, language) { + telemetry.sendTelemetryEvent('feature', { name, language }); + } + const databaseName = context.workspaceState.get( + 'dbName', + `anycode_${Math.random().toString(32).slice(2)}` + ); + context.workspaceState.update('dbName', databaseName); + const clientOptions = { + outputChannelName: 'anycode', + revealOutputChannelOn: + import_vscode_languageclient.RevealOutputChannelOn.Never, + documentSelector: supportedLanguages.getSupportedLanguagesAsSelector(), + synchronize: {}, + initializationOptions: { + treeSitterWasmUri: vscode2.Uri.joinPath( + context.extensionUri, + './server/tree-sitter/tree-sitter.wasm' + ).toString(), + supportedLanguages: supportedLanguages.getSupportedLanguages(), + databaseName, + }, + middleware: { + provideWorkspaceSymbols(query, token, next) { + _sendFeatureTelementry('workspaceSymbols', ''); + return next(query, token); + }, + provideDefinition(document2, position, token, next) { + _sendFeatureTelementry('definition', document2.languageId); + return next(document2, position, token); + }, + provideReferences(document2, position, options, token, next) { + _sendFeatureTelementry('references', document2.languageId); + return next(document2, position, options, token); + }, + provideDocumentHighlights(document2, position, token, next) { + _sendFeatureTelementry('documentHighlights', document2.languageId); + return next(document2, position, token); + }, + provideCompletionItem(document2, position, context2, token, next) { + _sendFeatureTelementry('completions', document2.languageId); + return next(document2, position, context2, token); + }, + }, + }; + const serverMain = vscode2.Uri.joinPath( + context.extensionUri, + 'prebuilt/anycode.server.js' + ); + const worker = new Worker(serverMain.toString()); + const client = new import_browser.LanguageClient( + 'anycode', + 'anycode', + clientOptions, + worker + ); + disposables.push(client.start()); + disposables.push(new vscode2.Disposable(() => worker.terminate())); + await client.onReady(); + const findAndSearchSuffixes = []; + for (const [info, config] of supportedLanguages.getSupportedLanguages()) { + if (config.workspaceSymbols || config.references || config.definitions) { + findAndSearchSuffixes.push(info.suffixes); + } + } + const langPattern = `**/*.{${findAndSearchSuffixes.join(',')}}`; + const watcher = vscode2.workspace.createFileSystemWatcher(langPattern); + disposables.push(watcher); + const exclude = `{${[ + ...Object.keys( + vscode2.workspace.getConfiguration('search', null).get('exclude') ?? {} + ), + ...Object.keys( + vscode2.workspace.getConfiguration('files', null).get('exclude') ?? {} + ), + ].join(',')}}`; + let size = Math.max( + 0, + vscode2.workspace.getConfiguration('anycode').get('symbolIndexSize', 500) + ); + const init = Promise.resolve( + vscode2.workspace.findFiles(langPattern, exclude).then(async (all) => { + let hasWorkspaceContents = 0; + if (all.length > 50) { + if (await _canInitWithoutLimits()) { + size = Number.MAX_SAFE_INTEGER; + hasWorkspaceContents = 1; + } + } + const uris = all.slice(0, size); + console.info( + `USING ${uris.length} of ${all.length} files for ${langPattern}` + ); + const t1 = performance.now(); + await client.sendRequest('queue/init', uris.map(String)); + telemetry.sendTelemetryEvent('init', void 0, { + numOfFiles: all.length, + indexSize: uris.length, + hasWorkspaceContents, + duration: performance.now() - t1, + }); + disposables.push( + await _showStatusAndInfo( + context, + supportedLanguages, + !hasWorkspaceContents && _isRemoteHubWorkspace() + ) + ); + }) + ); + const initCancel = new Promise((resolve) => + disposables.push(new vscode2.Disposable(resolve)) + ); + vscode2.window.withProgress( + { location: vscode2.ProgressLocation.Window, title: 'Building Index...' }, + () => Promise.race([init, initCancel]) + ); + disposables.push( + watcher.onDidCreate((uri) => { + client.sendNotification('queue/add', uri.toString()); + }) + ); + disposables.push( + watcher.onDidDelete((uri) => { + client.sendNotification('queue/remove', uri.toString()); + client.sendNotification('file-cache/remove', uri.toString()); + }) + ); + disposables.push( + watcher.onDidChange((uri) => { + client.sendNotification('queue/add', uri.toString()); + client.sendNotification('file-cache/remove', uri.toString()); + }) + ); + client.onRequest('file/read', async (raw) => { + const uri = vscode2.Uri.parse(raw); + if (uri.scheme === 'vscode-notebook-cell') { + try { + const doc = await vscode2.workspace.openTextDocument(uri); + return new TextEncoder().encode(doc.getText()); + } catch (err) { + console.warn(err); + return new Uint8Array(); + } + } + if (vscode2.workspace.fs.isWritableFileSystem(uri.scheme) === void 0) { + return new Uint8Array(); + } + let data; + try { + const stat = await vscode2.workspace.fs.stat(uri); + if (stat.size > 1024 ** 2) { + console.warn( + `IGNORING "${uri.toString()}" because it is too large (${ + stat.size + }bytes)` + ); + data = new Uint8Array(); + } else { + data = await vscode2.workspace.fs.readFile(uri); + } + return data; + } catch (err) { + console.warn(err); + return new Uint8Array(); + } + }); + const persistUri = + context.storageUri && + vscode2.Uri.joinPath(context.storageUri, 'anycode.db'); + client.onRequest('persisted/read', async () => { + if (!persistUri) { + return new Uint8Array(); + } + try { + return await vscode2.workspace.fs.readFile(persistUri); + } catch { + return new Uint8Array(); + } + }); + client.onRequest('persisted/write', async (data) => { + if (persistUri) { + await vscode2.workspace.fs.writeFile(persistUri, data); + } + }); + return vscode2.Disposable.from(...disposables); +} +function _isRemoteHubWorkspace() { + if ( + !vscode2.extensions.getExtension('GitHub.remoteHub') && + !vscode2.extensions.getExtension('GitHub.remoteHub-insiders') + ) { + return false; + } + return ( + vscode2.workspace.workspaceFolders?.every( + (folder) => folder.uri.scheme === 'vscode-vfs' + ) ?? false + ); +} +async function _canInitWithoutLimits() { + if (!vscode2.workspace.workspaceFolders) { + return false; + } + const remoteFolders = vscode2.workspace.workspaceFolders.filter( + (folder) => folder.uri.scheme === 'vscode-vfs' + ); + if (remoteFolders.length === 0) { + return true; + } + const remoteHub = + vscode2.extensions.getExtension('GitHub.remoteHub') ?? + vscode2.extensions.getExtension('GitHub.remoteHub-insiders'); + const remoteHubApi = await remoteHub?.activate(); + if (typeof remoteHubApi?.loadWorkspaceContents !== 'function') { + return false; + } + for (const folder of remoteFolders) { + if (!(await remoteHubApi.loadWorkspaceContents(folder.uri))) { + return false; + } + } + return true; +} +/*! + * Microsoft Dynamic Proto Utility, 1.1.4 + * Copyright (c) Microsoft and contributors. All rights reserved. + */ diff --git a/extensions/vscode-anycode/prebuilt/anycode.server.js b/extensions/vscode-anycode/prebuilt/anycode.server.js new file mode 100644 index 000000000..f7a02bf9c --- /dev/null +++ b/extensions/vscode-anycode/prebuilt/anycode.server.js @@ -0,0 +1,15546 @@ +(() => { + let __create = Object.create; + let __defProp = Object.defineProperty; + let __getOwnPropDesc = Object.getOwnPropertyDescriptor; + let __getOwnPropNames = Object.getOwnPropertyNames; + let __getProtoOf = Object.getPrototypeOf; + let __hasOwnProp = Object.prototype.hasOwnProperty; + let __markAsModule = (target) => + __defProp(target, '__esModule', { value: true }); + let __require = /* @__PURE__ */ ((x) => + typeof require !== 'undefined' + ? require + : typeof Proxy !== 'undefined' + ? new Proxy(x, { + get: (a, b) => (typeof require !== 'undefined' ? require : a)[b], + }) + : x)(function (x) { + if (typeof require !== 'undefined') { + return require.apply(this, arguments); + } + throw new Error('Dynamic require of "' + x + '" is not supported'); + }); + let __commonJS = (cb, mod10) => + function __require2() { + return ( + mod10 || + (0, cb[Object.keys(cb)[0]])((mod10 = { exports: {} }).exports, mod10), + mod10.exports + ); + }; + let __reExport = (target, module, desc) => { + if ( + (module && typeof module === 'object') || + typeof module === 'function' + ) { + for (let key of __getOwnPropNames(module)) { + if (!__hasOwnProp.call(target, key) && key !== 'default') { + __defProp(target, key, { + get: () => module[key], + enumerable: + !(desc = __getOwnPropDesc(module, key)) || desc.enumerable, + }); + } + } + } + return target; + }; + let __toModule = (module) => { + return __reExport( + __markAsModule( + __defProp( + module != null ? __create(__getProtoOf(module)) : {}, + 'default', + module && module.__esModule && 'default' in module + ? { get: () => module.default, enumerable: true } + : { value: module, enumerable: true } + ) + ), + module + ); + }; + + // server/node_modules/vscode-jsonrpc/lib/common/ral.js + let require_ral = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/ral.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let _ral; + function RAL() { + if (_ral === void 0) { + throw new Error(`No runtime abstraction layer installed`); + } + return _ral; + } + (function (RAL2) { + function install(ral) { + if (ral === void 0) { + throw new Error(`No runtime abstraction layer provided`); + } + _ral = ral; + } + RAL2.install = install; + })(RAL || (RAL = {})); + exports.default = RAL; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/disposable.js + let require_disposable = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/disposable.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Disposable = void 0; + let Disposable; + (function (Disposable2) { + function create(func) { + return { + dispose: func, + }; + } + Disposable2.create = create; + })((Disposable = exports.Disposable || (exports.Disposable = {}))); + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/events.js + let require_events = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/events.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Emitter = exports.Event = void 0; + let ral_1 = require_ral(); + let Event; + (function (Event2) { + const _disposable = { dispose() {} }; + Event2.None = function () { + return _disposable; + }; + })((Event = exports.Event || (exports.Event = {}))); + let CallbackList = class { + add(callback, context = null, bucket) { + if (!this._callbacks) { + this._callbacks = []; + this._contexts = []; + } + this._callbacks.push(callback); + this._contexts.push(context); + if (Array.isArray(bucket)) { + bucket.push({ dispose: () => this.remove(callback, context) }); + } + } + remove(callback, context = null) { + if (!this._callbacks) { + return; + } + let foundCallbackWithDifferentContext = false; + for (let i = 0, len = this._callbacks.length; i < len; i++) { + if (this._callbacks[i] === callback) { + if (this._contexts[i] === context) { + this._callbacks.splice(i, 1); + this._contexts.splice(i, 1); + return; + } else { + foundCallbackWithDifferentContext = true; + } + } + } + if (foundCallbackWithDifferentContext) { + throw new Error( + 'When adding a listener with a context, you should remove it with the same context' + ); + } + } + invoke(...args) { + if (!this._callbacks) { + return []; + } + const ret = [], + callbacks = this._callbacks.slice(0), + contexts = this._contexts.slice(0); + for (let i = 0, len = callbacks.length; i < len; i++) { + try { + ret.push(callbacks[i].apply(contexts[i], args)); + } catch (e) { + (0, ral_1.default)().console.error(e); + } + } + return ret; + } + isEmpty() { + return !this._callbacks || this._callbacks.length === 0; + } + dispose() { + this._callbacks = void 0; + this._contexts = void 0; + } + }; + var Emitter2 = class { + constructor(_options) { + this._options = _options; + } + get event() { + if (!this._event) { + this._event = (listener, thisArgs, disposables) => { + if (!this._callbacks) { + this._callbacks = new CallbackList(); + } + if ( + this._options && + this._options.onFirstListenerAdd && + this._callbacks.isEmpty() + ) { + this._options.onFirstListenerAdd(this); + } + this._callbacks.add(listener, thisArgs); + const result = { + dispose: () => { + if (!this._callbacks) { + return; + } + this._callbacks.remove(listener, thisArgs); + result.dispose = Emitter2._noop; + if ( + this._options && + this._options.onLastListenerRemove && + this._callbacks.isEmpty() + ) { + this._options.onLastListenerRemove(this); + } + }, + }; + if (Array.isArray(disposables)) { + disposables.push(result); + } + return result; + }; + } + return this._event; + } + fire(event) { + if (this._callbacks) { + this._callbacks.invoke.call(this._callbacks, event); + } + } + dispose() { + if (this._callbacks) { + this._callbacks.dispose(); + this._callbacks = void 0; + } + } + }; + exports.Emitter = Emitter2; + Emitter2._noop = function () {}; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js + let require_messageBuffer = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.AbstractMessageBuffer = void 0; + let CR = 13; + let LF = 10; + let CRLF = '\r\n'; + let AbstractMessageBuffer = class { + constructor(encoding = 'utf-8') { + this._encoding = encoding; + this._chunks = []; + this._totalLength = 0; + } + get encoding() { + return this._encoding; + } + append(chunk) { + const toAppend = + typeof chunk === 'string' + ? this.fromString(chunk, this._encoding) + : chunk; + this._chunks.push(toAppend); + this._totalLength += toAppend.byteLength; + } + tryReadHeaders() { + if (this._chunks.length === 0) { + return void 0; + } + let state = 0; + let chunkIndex = 0; + let offset = 0; + let chunkBytesRead = 0; + row: while (chunkIndex < this._chunks.length) { + const chunk = this._chunks[chunkIndex]; + offset = 0; + while (offset < chunk.length) { + const value = chunk[offset]; + switch (value) { + case CR: + switch (state) { + case 0: + state = 1; + break; + case 2: + state = 3; + break; + default: + state = 0; + } + break; + case LF: + switch (state) { + case 1: + state = 2; + break; + case 3: + state = 4; + offset++; + break row; + default: + state = 0; + } + break; + default: + state = 0; + } + offset++; + } + chunkBytesRead += chunk.byteLength; + chunkIndex++; + } + if (state !== 4) { + return void 0; + } + const buffer = this._read(chunkBytesRead + offset); + const result = new Map(); + const headers = this.toString(buffer, 'ascii').split(CRLF); + if (headers.length < 2) { + return result; + } + for (let i = 0; i < headers.length - 2; i++) { + const header = headers[i]; + const index = header.indexOf(':'); + if (index === -1) { + throw new Error( + 'Message header must separate key and value using :' + ); + } + const key = header.substr(0, index); + const value = header.substr(index + 1).trim(); + result.set(key, value); + } + return result; + } + tryReadBody(length) { + if (this._totalLength < length) { + return void 0; + } + return this._read(length); + } + get numberOfBytes() { + return this._totalLength; + } + _read(byteCount) { + if (byteCount === 0) { + return this.emptyBuffer(); + } + if (byteCount > this._totalLength) { + throw new Error(`Cannot read so many bytes!`); + } + if (this._chunks[0].byteLength === byteCount) { + const chunk = this._chunks[0]; + this._chunks.shift(); + this._totalLength -= byteCount; + return this.asNative(chunk); + } + if (this._chunks[0].byteLength > byteCount) { + const chunk = this._chunks[0]; + const result2 = this.asNative(chunk, byteCount); + this._chunks[0] = chunk.slice(byteCount); + this._totalLength -= byteCount; + return result2; + } + const result = this.allocNative(byteCount); + let resultOffset = 0; + let chunkIndex = 0; + while (byteCount > 0) { + const chunk = this._chunks[chunkIndex]; + if (chunk.byteLength > byteCount) { + const chunkPart = chunk.slice(0, byteCount); + result.set(chunkPart, resultOffset); + resultOffset += byteCount; + this._chunks[chunkIndex] = chunk.slice(byteCount); + this._totalLength -= byteCount; + byteCount -= byteCount; + } else { + result.set(chunk, resultOffset); + resultOffset += chunk.byteLength; + this._chunks.shift(); + this._totalLength -= chunk.byteLength; + byteCount -= chunk.byteLength; + } + } + return result; + } + }; + exports.AbstractMessageBuffer = AbstractMessageBuffer; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/browser/ril.js + let require_ril = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/browser/ril.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + let ral_1 = require_ral(); + let disposable_1 = require_disposable(); + let events_1 = require_events(); + let messageBuffer_1 = require_messageBuffer(); + var MessageBuffer = class extends messageBuffer_1.AbstractMessageBuffer { + constructor(encoding = 'utf-8') { + super(encoding); + this.asciiDecoder = new TextDecoder('ascii'); + } + emptyBuffer() { + return MessageBuffer.emptyBuffer; + } + fromString(value, _encoding) { + return new TextEncoder().encode(value); + } + toString(value, encoding) { + if (encoding === 'ascii') { + return this.asciiDecoder.decode(value); + } else { + return new TextDecoder(encoding).decode(value); + } + } + asNative(buffer, length) { + if (length === void 0) { + return buffer; + } else { + return buffer.slice(0, length); + } + } + allocNative(length) { + return new Uint8Array(length); + } + }; + MessageBuffer.emptyBuffer = new Uint8Array(0); + let ReadableStreamWrapper = class { + constructor(socket) { + this.socket = socket; + this._onData = new events_1.Emitter(); + this._messageListener = (event) => { + const blob = event.data; + blob.arrayBuffer().then( + (buffer) => { + this._onData.fire(new Uint8Array(buffer)); + }, + () => { + (0, ral_1.default)().console.error( + `Converting blob to array buffer failed.` + ); + } + ); + }; + this.socket.addEventListener('message', this._messageListener); + } + onClose(listener) { + this.socket.addEventListener('close', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('close', listener) + ); + } + onError(listener) { + this.socket.addEventListener('error', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('error', listener) + ); + } + onEnd(listener) { + this.socket.addEventListener('end', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('end', listener) + ); + } + onData(listener) { + return this._onData.event(listener); + } + }; + let WritableStreamWrapper = class { + constructor(socket) { + this.socket = socket; + } + onClose(listener) { + this.socket.addEventListener('close', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('close', listener) + ); + } + onError(listener) { + this.socket.addEventListener('error', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('error', listener) + ); + } + onEnd(listener) { + this.socket.addEventListener('end', listener); + return disposable_1.Disposable.create(() => + this.socket.removeEventListener('end', listener) + ); + } + write(data, encoding) { + if (typeof data === 'string') { + if (encoding !== void 0 && encoding !== 'utf-8') { + throw new Error( + `In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}` + ); + } + this.socket.send(data); + } else { + this.socket.send(data); + } + return Promise.resolve(); + } + end() { + this.socket.close(); + } + }; + let _textEncoder = new TextEncoder(); + let _ril = Object.freeze({ + messageBuffer: Object.freeze({ + create: (encoding) => new MessageBuffer(encoding), + }), + applicationJson: Object.freeze({ + encoder: Object.freeze({ + name: 'application/json', + encode: (msg, options) => { + if (options.charset !== 'utf-8') { + throw new Error( + `In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}` + ); + } + return Promise.resolve( + _textEncoder.encode(JSON.stringify(msg, void 0, 0)) + ); + }, + }), + decoder: Object.freeze({ + name: 'application/json', + decode: (buffer, options) => { + if (!(buffer instanceof Uint8Array)) { + throw new Error( + `In a Browser environments only Uint8Arrays are supported.` + ); + } + return Promise.resolve( + JSON.parse(new TextDecoder(options.charset).decode(buffer)) + ); + }, + }), + }), + stream: Object.freeze({ + asReadableStream: (socket) => new ReadableStreamWrapper(socket), + asWritableStream: (socket) => new WritableStreamWrapper(socket), + }), + console, + timer: Object.freeze({ + setTimeout(callback, ms, ...args) { + const handle = setTimeout(callback, ms, ...args); + return { dispose: () => clearTimeout(handle) }; + }, + setImmediate(callback, ...args) { + const handle = setTimeout(callback, 0, ...args); + return { dispose: () => clearTimeout(handle) }; + }, + setInterval(callback, ms, ...args) { + const handle = setInterval(callback, ms, ...args); + return { dispose: () => clearInterval(handle) }; + }, + }), + }); + function RIL() { + return _ril; + } + (function (RIL2) { + function install() { + ral_1.default.install(_ril); + } + RIL2.install = install; + })(RIL || (RIL = {})); + exports.default = RIL; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/is.js + let require_is = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/is.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0; + function boolean(value) { + return value === true || value === false; + } + exports.boolean = boolean; + function string(value) { + return typeof value === 'string' || value instanceof String; + } + exports.string = string; + function number(value) { + return typeof value === 'number' || value instanceof Number; + } + exports.number = number; + function error(value) { + return value instanceof Error; + } + exports.error = error; + function func(value) { + return typeof value === 'function'; + } + exports.func = func; + function array(value) { + return Array.isArray(value); + } + exports.array = array; + function stringArray(value) { + return array(value) && value.every((elem) => string(elem)); + } + exports.stringArray = stringArray; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/messages.js + let require_messages = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/messages.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0; + let is = require_is(); + let ErrorCodes; + (function (ErrorCodes2) { + ErrorCodes2.ParseError = -32700; + ErrorCodes2.InvalidRequest = -32600; + ErrorCodes2.MethodNotFound = -32601; + ErrorCodes2.InvalidParams = -32602; + ErrorCodes2.InternalError = -32603; + ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099; + ErrorCodes2.serverErrorStart = + ErrorCodes2.jsonrpcReservedErrorRangeStart; + ErrorCodes2.MessageWriteError = -32099; + ErrorCodes2.MessageReadError = -32098; + ErrorCodes2.ServerNotInitialized = -32002; + ErrorCodes2.UnknownErrorCode = -32001; + ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3; + ErrorCodes2.serverErrorEnd = ErrorCodes2.jsonrpcReservedErrorRangeEnd; + })((ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}))); + var ResponseError = class extends Error { + constructor(code, message, data) { + super(message); + this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode; + this.data = data; + Object.setPrototypeOf(this, ResponseError.prototype); + } + toJson() { + const result = { + code: this.code, + message: this.message, + }; + if (this.data !== void 0) { + result.data = this.data; + } + return result; + } + }; + exports.ResponseError = ResponseError; + var ParameterStructures = class { + constructor(kind) { + this.kind = kind; + } + static is(value) { + return ( + value === ParameterStructures.auto || + value === ParameterStructures.byName || + value === ParameterStructures.byPosition + ); + } + toString() { + return this.kind; + } + }; + exports.ParameterStructures = ParameterStructures; + ParameterStructures.auto = new ParameterStructures('auto'); + ParameterStructures.byPosition = new ParameterStructures('byPosition'); + ParameterStructures.byName = new ParameterStructures('byName'); + let AbstractMessageSignature = class { + constructor(method, numberOfParams) { + this.method = method; + this.numberOfParams = numberOfParams; + } + get parameterStructures() { + return ParameterStructures.auto; + } + }; + exports.AbstractMessageSignature = AbstractMessageSignature; + let RequestType0 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 0); + } + }; + exports.RequestType0 = RequestType0; + let RequestType = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.RequestType = RequestType; + let RequestType1 = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.RequestType1 = RequestType1; + let RequestType2 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 2); + } + }; + exports.RequestType2 = RequestType2; + let RequestType3 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 3); + } + }; + exports.RequestType3 = RequestType3; + let RequestType4 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 4); + } + }; + exports.RequestType4 = RequestType4; + let RequestType5 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 5); + } + }; + exports.RequestType5 = RequestType5; + let RequestType6 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 6); + } + }; + exports.RequestType6 = RequestType6; + let RequestType7 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 7); + } + }; + exports.RequestType7 = RequestType7; + let RequestType8 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 8); + } + }; + exports.RequestType8 = RequestType8; + let RequestType9 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 9); + } + }; + exports.RequestType9 = RequestType9; + let NotificationType = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.NotificationType = NotificationType; + let NotificationType0 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 0); + } + }; + exports.NotificationType0 = NotificationType0; + let NotificationType1 = class extends AbstractMessageSignature { + constructor(method, _parameterStructures = ParameterStructures.auto) { + super(method, 1); + this._parameterStructures = _parameterStructures; + } + get parameterStructures() { + return this._parameterStructures; + } + }; + exports.NotificationType1 = NotificationType1; + let NotificationType2 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 2); + } + }; + exports.NotificationType2 = NotificationType2; + let NotificationType3 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 3); + } + }; + exports.NotificationType3 = NotificationType3; + let NotificationType4 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 4); + } + }; + exports.NotificationType4 = NotificationType4; + let NotificationType5 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 5); + } + }; + exports.NotificationType5 = NotificationType5; + let NotificationType6 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 6); + } + }; + exports.NotificationType6 = NotificationType6; + let NotificationType7 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 7); + } + }; + exports.NotificationType7 = NotificationType7; + let NotificationType8 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 8); + } + }; + exports.NotificationType8 = NotificationType8; + let NotificationType9 = class extends AbstractMessageSignature { + constructor(method) { + super(method, 9); + } + }; + exports.NotificationType9 = NotificationType9; + let Message; + (function (Message2) { + function isRequest(message) { + const candidate = message; + return ( + candidate && + is.string(candidate.method) && + (is.string(candidate.id) || is.number(candidate.id)) + ); + } + Message2.isRequest = isRequest; + function isNotification(message) { + const candidate = message; + return ( + candidate && is.string(candidate.method) && message.id === void 0 + ); + } + Message2.isNotification = isNotification; + function isResponse(message) { + const candidate = message; + return ( + candidate && + (candidate.result !== void 0 || !!candidate.error) && + (is.string(candidate.id) || + is.number(candidate.id) || + candidate.id === null) + ); + } + Message2.isResponse = isResponse; + })((Message = exports.Message || (exports.Message = {}))); + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/linkedMap.js + let require_linkedMap = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/linkedMap.js'(exports) { + 'use strict'; + let _a; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LRUCache = exports.LinkedMap = exports.Touch = void 0; + let Touch; + (function (Touch2) { + Touch2.None = 0; + Touch2.First = 1; + Touch2.AsOld = Touch2.First; + Touch2.Last = 2; + Touch2.AsNew = Touch2.Last; + })((Touch = exports.Touch || (exports.Touch = {}))); + let LinkedMap = class { + constructor() { + this[_a] = 'LinkedMap'; + this._map = new Map(); + this._head = void 0; + this._tail = void 0; + this._size = 0; + this._state = 0; + } + clear() { + this._map.clear(); + this._head = void 0; + this._tail = void 0; + this._size = 0; + this._state++; + } + isEmpty() { + return !this._head && !this._tail; + } + get size() { + return this._size; + } + get first() { + return this._head?.value; + } + get last() { + return this._tail?.value; + } + has(key) { + return this._map.has(key); + } + get(key, touch = Touch.None) { + const item = this._map.get(key); + if (!item) { + return void 0; + } + if (touch !== Touch.None) { + this.touch(item, touch); + } + return item.value; + } + set(key, value, touch = Touch.None) { + let item = this._map.get(key); + if (item) { + item.value = value; + if (touch !== Touch.None) { + this.touch(item, touch); + } + } else { + item = { key, value, next: void 0, previous: void 0 }; + switch (touch) { + case Touch.None: + this.addItemLast(item); + break; + case Touch.First: + this.addItemFirst(item); + break; + case Touch.Last: + this.addItemLast(item); + break; + default: + this.addItemLast(item); + break; + } + this._map.set(key, item); + this._size++; + } + return this; + } + delete(key) { + return !!this.remove(key); + } + remove(key) { + const item = this._map.get(key); + if (!item) { + return void 0; + } + this._map.delete(key); + this.removeItem(item); + this._size--; + return item.value; + } + shift() { + if (!this._head && !this._tail) { + return void 0; + } + if (!this._head || !this._tail) { + throw new Error('Invalid list'); + } + const item = this._head; + this._map.delete(item.key); + this.removeItem(item); + this._size--; + return item.value; + } + forEach(callbackfn, thisArg) { + const state = this._state; + let current = this._head; + while (current) { + if (thisArg) { + callbackfn.bind(thisArg)(current.value, current.key, this); + } else { + callbackfn(current.value, current.key, this); + } + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + current = current.next; + } + } + keys() { + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]: () => { + return iterator; + }, + next: () => { + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: current.key, done: false }; + current = current.next; + return result; + } else { + return { value: void 0, done: true }; + } + }, + }; + return iterator; + } + values() { + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]: () => { + return iterator; + }, + next: () => { + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: current.value, done: false }; + current = current.next; + return result; + } else { + return { value: void 0, done: true }; + } + }, + }; + return iterator; + } + entries() { + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]: () => { + return iterator; + }, + next: () => { + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { + value: [current.key, current.value], + done: false, + }; + current = current.next; + return result; + } else { + return { value: void 0, done: true }; + } + }, + }; + return iterator; + } + [((_a = Symbol.toStringTag), Symbol.iterator)]() { + return this.entries(); + } + trimOld(newSize) { + if (newSize >= this.size) { + return; + } + if (newSize === 0) { + this.clear(); + return; + } + let current = this._head; + let currentSize = this.size; + while (current && currentSize > newSize) { + this._map.delete(current.key); + current = current.next; + currentSize--; + } + this._head = current; + this._size = currentSize; + if (current) { + current.previous = void 0; + } + this._state++; + } + addItemFirst(item) { + if (!this._head && !this._tail) { + this._tail = item; + } else if (!this._head) { + throw new Error('Invalid list'); + } else { + item.next = this._head; + this._head.previous = item; + } + this._head = item; + this._state++; + } + addItemLast(item) { + if (!this._head && !this._tail) { + this._head = item; + } else if (!this._tail) { + throw new Error('Invalid list'); + } else { + item.previous = this._tail; + this._tail.next = item; + } + this._tail = item; + this._state++; + } + removeItem(item) { + if (item === this._head && item === this._tail) { + this._head = void 0; + this._tail = void 0; + } else if (item === this._head) { + if (!item.next) { + throw new Error('Invalid list'); + } + item.next.previous = void 0; + this._head = item.next; + } else if (item === this._tail) { + if (!item.previous) { + throw new Error('Invalid list'); + } + item.previous.next = void 0; + this._tail = item.previous; + } else { + const next = item.next; + const previous = item.previous; + if (!next || !previous) { + throw new Error('Invalid list'); + } + next.previous = previous; + previous.next = next; + } + item.next = void 0; + item.previous = void 0; + this._state++; + } + touch(item, touch) { + if (!this._head || !this._tail) { + throw new Error('Invalid list'); + } + if (touch !== Touch.First && touch !== Touch.Last) { + return; + } + if (touch === Touch.First) { + if (item === this._head) { + return; + } + const next = item.next; + const previous = item.previous; + if (item === this._tail) { + previous.next = void 0; + this._tail = previous; + } else { + next.previous = previous; + previous.next = next; + } + item.previous = void 0; + item.next = this._head; + this._head.previous = item; + this._head = item; + this._state++; + } else if (touch === Touch.Last) { + if (item === this._tail) { + return; + } + const next = item.next; + const previous = item.previous; + if (item === this._head) { + next.previous = void 0; + this._head = next; + } else { + next.previous = previous; + previous.next = next; + } + item.next = void 0; + item.previous = this._tail; + this._tail.next = item; + this._tail = item; + this._state++; + } + } + toJSON() { + const data = []; + this.forEach((value, key) => { + data.push([key, value]); + }); + return data; + } + fromJSON(data) { + this.clear(); + for (const [key, value] of data) { + this.set(key, value); + } + } + }; + exports.LinkedMap = LinkedMap; + let LRUCache = class extends LinkedMap { + constructor(limit, ratio = 1) { + super(); + this._limit = limit; + this._ratio = Math.min(Math.max(0, ratio), 1); + } + get limit() { + return this._limit; + } + set limit(limit) { + this._limit = limit; + this.checkTrim(); + } + get ratio() { + return this._ratio; + } + set ratio(ratio) { + this._ratio = Math.min(Math.max(0, ratio), 1); + this.checkTrim(); + } + get(key, touch = Touch.AsNew) { + return super.get(key, touch); + } + peek(key) { + return super.get(key, Touch.None); + } + set(key, value) { + super.set(key, value, Touch.Last); + this.checkTrim(); + return this; + } + checkTrim() { + if (this.size > this._limit) { + this.trimOld(Math.round(this._limit * this._ratio)); + } + } + }; + exports.LRUCache = LRUCache; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/cancellation.js + let require_cancellation = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/cancellation.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CancellationTokenSource = exports.CancellationToken = void 0; + let ral_1 = require_ral(); + let Is = require_is(); + let events_1 = require_events(); + let CancellationToken; + (function (CancellationToken2) { + CancellationToken2.None = Object.freeze({ + isCancellationRequested: false, + onCancellationRequested: events_1.Event.None, + }); + CancellationToken2.Cancelled = Object.freeze({ + isCancellationRequested: true, + onCancellationRequested: events_1.Event.None, + }); + function is(value) { + const candidate = value; + return ( + candidate && + (candidate === CancellationToken2.None || + candidate === CancellationToken2.Cancelled || + (Is.boolean(candidate.isCancellationRequested) && + !!candidate.onCancellationRequested)) + ); + } + CancellationToken2.is = is; + })( + (CancellationToken = + exports.CancellationToken || (exports.CancellationToken = {})) + ); + let shortcutEvent = Object.freeze(function (callback, context) { + const handle = (0, ral_1.default)().timer.setTimeout( + callback.bind(context), + 0 + ); + return { + dispose() { + handle.dispose(); + }, + }; + }); + let MutableToken = class { + constructor() { + this._isCancelled = false; + } + cancel() { + if (!this._isCancelled) { + this._isCancelled = true; + if (this._emitter) { + this._emitter.fire(void 0); + this.dispose(); + } + } + } + get isCancellationRequested() { + return this._isCancelled; + } + get onCancellationRequested() { + if (this._isCancelled) { + return shortcutEvent; + } + if (!this._emitter) { + this._emitter = new events_1.Emitter(); + } + return this._emitter.event; + } + dispose() { + if (this._emitter) { + this._emitter.dispose(); + this._emitter = void 0; + } + } + }; + let CancellationTokenSource3 = class { + get token() { + if (!this._token) { + this._token = new MutableToken(); + } + return this._token; + } + cancel() { + if (!this._token) { + this._token = CancellationToken.Cancelled; + } else { + this._token.cancel(); + } + } + dispose() { + if (!this._token) { + this._token = CancellationToken.None; + } else if (this._token instanceof MutableToken) { + this._token.dispose(); + } + } + }; + exports.CancellationTokenSource = CancellationTokenSource3; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/messageReader.js + let require_messageReader = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/messageReader.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0; + let ral_1 = require_ral(); + let Is = require_is(); + let events_1 = require_events(); + let MessageReader; + (function (MessageReader2) { + function is(value) { + let candidate = value; + return ( + candidate && + Is.func(candidate.listen) && + Is.func(candidate.dispose) && + Is.func(candidate.onError) && + Is.func(candidate.onClose) && + Is.func(candidate.onPartialMessage) + ); + } + MessageReader2.is = is; + })( + (MessageReader = exports.MessageReader || (exports.MessageReader = {})) + ); + let AbstractMessageReader = class { + constructor() { + this.errorEmitter = new events_1.Emitter(); + this.closeEmitter = new events_1.Emitter(); + this.partialMessageEmitter = new events_1.Emitter(); + } + dispose() { + this.errorEmitter.dispose(); + this.closeEmitter.dispose(); + } + get onError() { + return this.errorEmitter.event; + } + fireError(error) { + this.errorEmitter.fire(this.asError(error)); + } + get onClose() { + return this.closeEmitter.event; + } + fireClose() { + this.closeEmitter.fire(void 0); + } + get onPartialMessage() { + return this.partialMessageEmitter.event; + } + firePartialMessage(info) { + this.partialMessageEmitter.fire(info); + } + asError(error) { + if (error instanceof Error) { + return error; + } else { + return new Error( + `Reader received error. Reason: ${ + Is.string(error.message) ? error.message : 'unknown' + }` + ); + } + } + }; + exports.AbstractMessageReader = AbstractMessageReader; + let ResolvedMessageReaderOptions; + (function (ResolvedMessageReaderOptions2) { + function fromOptions(options) { + let charset; + let result; + let contentDecoder; + const contentDecoders = new Map(); + let contentTypeDecoder; + const contentTypeDecoders = new Map(); + if (options === void 0 || typeof options === 'string') { + charset = options ?? 'utf-8'; + } else { + charset = options.charset ?? 'utf-8'; + if (options.contentDecoder !== void 0) { + contentDecoder = options.contentDecoder; + contentDecoders.set(contentDecoder.name, contentDecoder); + } + if (options.contentDecoders !== void 0) { + for (const decoder of options.contentDecoders) { + contentDecoders.set(decoder.name, decoder); + } + } + if (options.contentTypeDecoder !== void 0) { + contentTypeDecoder = options.contentTypeDecoder; + contentTypeDecoders.set( + contentTypeDecoder.name, + contentTypeDecoder + ); + } + if (options.contentTypeDecoders !== void 0) { + for (const decoder of options.contentTypeDecoders) { + contentTypeDecoders.set(decoder.name, decoder); + } + } + } + if (contentTypeDecoder === void 0) { + contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder; + contentTypeDecoders.set( + contentTypeDecoder.name, + contentTypeDecoder + ); + } + return { + charset, + contentDecoder, + contentDecoders, + contentTypeDecoder, + contentTypeDecoders, + }; + } + ResolvedMessageReaderOptions2.fromOptions = fromOptions; + })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {})); + let ReadableStreamMessageReader = class extends AbstractMessageReader { + constructor(readable, options) { + super(); + this.readable = readable; + this.options = ResolvedMessageReaderOptions.fromOptions(options); + this.buffer = (0, ral_1.default)().messageBuffer.create( + this.options.charset + ); + this._partialMessageTimeout = 1e4; + this.nextMessageLength = -1; + this.messageToken = 0; + } + set partialMessageTimeout(timeout) { + this._partialMessageTimeout = timeout; + } + get partialMessageTimeout() { + return this._partialMessageTimeout; + } + listen(callback) { + this.nextMessageLength = -1; + this.messageToken = 0; + this.partialMessageTimer = void 0; + this.callback = callback; + const result = this.readable.onData((data) => { + this.onData(data); + }); + this.readable.onError((error) => this.fireError(error)); + this.readable.onClose(() => this.fireClose()); + return result; + } + onData(data) { + this.buffer.append(data); + while (true) { + if (this.nextMessageLength === -1) { + const headers = this.buffer.tryReadHeaders(); + if (!headers) { + return; + } + const contentLength = headers.get('Content-Length'); + if (!contentLength) { + throw new Error( + 'Header must provide a Content-Length property.' + ); + } + const length = parseInt(contentLength); + if (isNaN(length)) { + throw new Error('Content-Length value must be a number.'); + } + this.nextMessageLength = length; + } + const body = this.buffer.tryReadBody(this.nextMessageLength); + if (body === void 0) { + this.setPartialMessageTimer(); + return; + } + this.clearPartialMessageTimer(); + this.nextMessageLength = -1; + let p; + if (this.options.contentDecoder !== void 0) { + p = this.options.contentDecoder.decode(body); + } else { + p = Promise.resolve(body); + } + p.then( + (value) => { + this.options.contentTypeDecoder + .decode(value, this.options) + .then( + (msg) => { + this.callback(msg); + }, + (error) => { + this.fireError(error); + } + ); + }, + (error) => { + this.fireError(error); + } + ); + } + } + clearPartialMessageTimer() { + if (this.partialMessageTimer) { + this.partialMessageTimer.dispose(); + this.partialMessageTimer = void 0; + } + } + setPartialMessageTimer() { + this.clearPartialMessageTimer(); + if (this._partialMessageTimeout <= 0) { + return; + } + this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout( + (token, timeout) => { + this.partialMessageTimer = void 0; + if (token === this.messageToken) { + this.firePartialMessage({ + messageToken: token, + waitingTime: timeout, + }); + this.setPartialMessageTimer(); + } + }, + this._partialMessageTimeout, + this.messageToken, + this._partialMessageTimeout + ); + } + }; + exports.ReadableStreamMessageReader = ReadableStreamMessageReader; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/semaphore.js + let require_semaphore = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/semaphore.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Semaphore = void 0; + let ral_1 = require_ral(); + let Semaphore = class { + constructor(capacity = 1) { + if (capacity <= 0) { + throw new Error('Capacity must be greater than 0'); + } + this._capacity = capacity; + this._active = 0; + this._waiting = []; + } + lock(thunk) { + return new Promise((resolve, reject) => { + this._waiting.push({ thunk, resolve, reject }); + this.runNext(); + }); + } + get active() { + return this._active; + } + runNext() { + if (this._waiting.length === 0 || this._active === this._capacity) { + return; + } + (0, ral_1.default)().timer.setImmediate(() => this.doRunNext()); + } + doRunNext() { + if (this._waiting.length === 0 || this._active === this._capacity) { + return; + } + const next = this._waiting.shift(); + this._active++; + if (this._active > this._capacity) { + throw new Error(`To many thunks active`); + } + try { + const result = next.thunk(); + if (result instanceof Promise) { + result.then( + (value) => { + this._active--; + next.resolve(value); + this.runNext(); + }, + (err) => { + this._active--; + next.reject(err); + this.runNext(); + } + ); + } else { + this._active--; + next.resolve(result); + this.runNext(); + } + } catch (err) { + this._active--; + next.reject(err); + this.runNext(); + } + } + }; + exports.Semaphore = Semaphore; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/messageWriter.js + let require_messageWriter = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/messageWriter.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0; + let ral_1 = require_ral(); + let Is = require_is(); + let semaphore_1 = require_semaphore(); + let events_1 = require_events(); + let ContentLength = 'Content-Length: '; + let CRLF = '\r\n'; + let MessageWriter; + (function (MessageWriter2) { + function is(value) { + let candidate = value; + return ( + candidate && + Is.func(candidate.dispose) && + Is.func(candidate.onClose) && + Is.func(candidate.onError) && + Is.func(candidate.write) + ); + } + MessageWriter2.is = is; + })( + (MessageWriter = exports.MessageWriter || (exports.MessageWriter = {})) + ); + let AbstractMessageWriter = class { + constructor() { + this.errorEmitter = new events_1.Emitter(); + this.closeEmitter = new events_1.Emitter(); + } + dispose() { + this.errorEmitter.dispose(); + this.closeEmitter.dispose(); + } + get onError() { + return this.errorEmitter.event; + } + fireError(error, message, count) { + this.errorEmitter.fire([this.asError(error), message, count]); + } + get onClose() { + return this.closeEmitter.event; + } + fireClose() { + this.closeEmitter.fire(void 0); + } + asError(error) { + if (error instanceof Error) { + return error; + } else { + return new Error( + `Writer received error. Reason: ${ + Is.string(error.message) ? error.message : 'unknown' + }` + ); + } + } + }; + exports.AbstractMessageWriter = AbstractMessageWriter; + let ResolvedMessageWriterOptions; + (function (ResolvedMessageWriterOptions2) { + function fromOptions(options) { + if (options === void 0 || typeof options === 'string') { + return { + charset: options ?? 'utf-8', + contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder, + }; + } else { + return { + charset: options.charset ?? 'utf-8', + contentEncoder: options.contentEncoder, + contentTypeEncoder: + options.contentTypeEncoder ?? + (0, ral_1.default)().applicationJson.encoder, + }; + } + } + ResolvedMessageWriterOptions2.fromOptions = fromOptions; + })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {})); + let WriteableStreamMessageWriter = class extends AbstractMessageWriter { + constructor(writable, options) { + super(); + this.writable = writable; + this.options = ResolvedMessageWriterOptions.fromOptions(options); + this.errorCount = 0; + this.writeSemaphore = new semaphore_1.Semaphore(1); + this.writable.onError((error) => this.fireError(error)); + this.writable.onClose(() => this.fireClose()); + } + async write(msg) { + return this.writeSemaphore.lock(async () => { + const payload = this.options.contentTypeEncoder + .encode(msg, this.options) + .then((buffer) => { + if (this.options.contentEncoder !== void 0) { + return this.options.contentEncoder.encode(buffer); + } else { + return buffer; + } + }); + return payload.then( + (buffer) => { + const headers = []; + headers.push(ContentLength, buffer.byteLength.toString(), CRLF); + headers.push(CRLF); + return this.doWrite(msg, headers, buffer); + }, + (error) => { + this.fireError(error); + throw error; + } + ); + }); + } + async doWrite(msg, headers, data) { + try { + await this.writable.write(headers.join(''), 'ascii'); + return this.writable.write(data); + } catch (error) { + this.handleError(error, msg); + return Promise.reject(error); + } + } + handleError(error, msg) { + this.errorCount++; + this.fireError(error, msg, this.errorCount); + } + end() { + this.writable.end(); + } + }; + exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/connection.js + let require_connection = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/connection.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createMessageConnection = exports.ConnectionOptions = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0; + let ral_1 = require_ral(); + let Is = require_is(); + let messages_1 = require_messages(); + let linkedMap_1 = require_linkedMap(); + let events_1 = require_events(); + let cancellation_1 = require_cancellation(); + let CancelNotification; + (function (CancelNotification2) { + CancelNotification2.type = new messages_1.NotificationType( + '$/cancelRequest' + ); + })(CancelNotification || (CancelNotification = {})); + let ProgressToken; + (function (ProgressToken2) { + function is(value) { + return typeof value === 'string' || typeof value === 'number'; + } + ProgressToken2.is = is; + })( + (ProgressToken = exports.ProgressToken || (exports.ProgressToken = {})) + ); + let ProgressNotification; + (function (ProgressNotification2) { + ProgressNotification2.type = new messages_1.NotificationType( + '$/progress' + ); + })(ProgressNotification || (ProgressNotification = {})); + let ProgressType = class { + constructor() {} + }; + exports.ProgressType = ProgressType; + let StarRequestHandler; + (function (StarRequestHandler2) { + function is(value) { + return Is.func(value); + } + StarRequestHandler2.is = is; + })(StarRequestHandler || (StarRequestHandler = {})); + exports.NullLogger = Object.freeze({ + error: () => {}, + warn: () => {}, + info: () => {}, + log: () => {}, + }); + let Trace; + (function (Trace2) { + Trace2[(Trace2['Off'] = 0)] = 'Off'; + Trace2[(Trace2['Messages'] = 1)] = 'Messages'; + Trace2[(Trace2['Compact'] = 2)] = 'Compact'; + Trace2[(Trace2['Verbose'] = 3)] = 'Verbose'; + })((Trace = exports.Trace || (exports.Trace = {}))); + (function (Trace2) { + function fromString(value) { + if (!Is.string(value)) { + return Trace2.Off; + } + value = value.toLowerCase(); + switch (value) { + case 'off': + return Trace2.Off; + case 'messages': + return Trace2.Messages; + case 'compact': + return Trace2.Compact; + case 'verbose': + return Trace2.Verbose; + default: + return Trace2.Off; + } + } + Trace2.fromString = fromString; + function toString(value) { + switch (value) { + case Trace2.Off: + return 'off'; + case Trace2.Messages: + return 'messages'; + case Trace2.Compact: + return 'compact'; + case Trace2.Verbose: + return 'verbose'; + default: + return 'off'; + } + } + Trace2.toString = toString; + })((Trace = exports.Trace || (exports.Trace = {}))); + let TraceFormat; + (function (TraceFormat2) { + TraceFormat2['Text'] = 'text'; + TraceFormat2['JSON'] = 'json'; + })((TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}))); + (function (TraceFormat2) { + function fromString(value) { + if (!Is.string(value)) { + return TraceFormat2.Text; + } + value = value.toLowerCase(); + if (value === 'json') { + return TraceFormat2.JSON; + } else { + return TraceFormat2.Text; + } + } + TraceFormat2.fromString = fromString; + })((TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}))); + let SetTraceNotification; + (function (SetTraceNotification2) { + SetTraceNotification2.type = new messages_1.NotificationType( + '$/setTrace' + ); + })( + (SetTraceNotification = + exports.SetTraceNotification || (exports.SetTraceNotification = {})) + ); + let LogTraceNotification; + (function (LogTraceNotification2) { + LogTraceNotification2.type = new messages_1.NotificationType( + '$/logTrace' + ); + })( + (LogTraceNotification = + exports.LogTraceNotification || (exports.LogTraceNotification = {})) + ); + let ConnectionErrors; + (function (ConnectionErrors2) { + ConnectionErrors2[(ConnectionErrors2['Closed'] = 1)] = 'Closed'; + ConnectionErrors2[(ConnectionErrors2['Disposed'] = 2)] = 'Disposed'; + ConnectionErrors2[(ConnectionErrors2['AlreadyListening'] = 3)] = + 'AlreadyListening'; + })( + (ConnectionErrors = + exports.ConnectionErrors || (exports.ConnectionErrors = {})) + ); + var ConnectionError = class extends Error { + constructor(code, message) { + super(message); + this.code = code; + Object.setPrototypeOf(this, ConnectionError.prototype); + } + }; + exports.ConnectionError = ConnectionError; + let ConnectionStrategy; + (function (ConnectionStrategy2) { + function is(value) { + const candidate = value; + return candidate && Is.func(candidate.cancelUndispatched); + } + ConnectionStrategy2.is = is; + })( + (ConnectionStrategy = + exports.ConnectionStrategy || (exports.ConnectionStrategy = {})) + ); + let CancellationReceiverStrategy; + (function (CancellationReceiverStrategy2) { + CancellationReceiverStrategy2.Message = Object.freeze({ + createCancellationTokenSource(_) { + return new cancellation_1.CancellationTokenSource(); + }, + }); + function is(value) { + const candidate = value; + return candidate && Is.func(candidate.createCancellationTokenSource); + } + CancellationReceiverStrategy2.is = is; + })( + (CancellationReceiverStrategy = + exports.CancellationReceiverStrategy || + (exports.CancellationReceiverStrategy = {})) + ); + let CancellationSenderStrategy; + (function (CancellationSenderStrategy2) { + CancellationSenderStrategy2.Message = Object.freeze({ + sendCancellation(conn, id) { + return conn.sendNotification(CancelNotification.type, { id }); + }, + cleanup(_) {}, + }); + function is(value) { + const candidate = value; + return ( + candidate && + Is.func(candidate.sendCancellation) && + Is.func(candidate.cleanup) + ); + } + CancellationSenderStrategy2.is = is; + })( + (CancellationSenderStrategy = + exports.CancellationSenderStrategy || + (exports.CancellationSenderStrategy = {})) + ); + let CancellationStrategy; + (function (CancellationStrategy2) { + CancellationStrategy2.Message = Object.freeze({ + receiver: CancellationReceiverStrategy.Message, + sender: CancellationSenderStrategy.Message, + }); + function is(value) { + const candidate = value; + return ( + candidate && + CancellationReceiverStrategy.is(candidate.receiver) && + CancellationSenderStrategy.is(candidate.sender) + ); + } + CancellationStrategy2.is = is; + })( + (CancellationStrategy = + exports.CancellationStrategy || (exports.CancellationStrategy = {})) + ); + let ConnectionOptions; + (function (ConnectionOptions2) { + function is(value) { + const candidate = value; + return ( + candidate && + (CancellationStrategy.is(candidate.cancellationStrategy) || + ConnectionStrategy.is(candidate.connectionStrategy)) + ); + } + ConnectionOptions2.is = is; + })( + (ConnectionOptions = + exports.ConnectionOptions || (exports.ConnectionOptions = {})) + ); + let ConnectionState; + (function (ConnectionState2) { + ConnectionState2[(ConnectionState2['New'] = 1)] = 'New'; + ConnectionState2[(ConnectionState2['Listening'] = 2)] = 'Listening'; + ConnectionState2[(ConnectionState2['Closed'] = 3)] = 'Closed'; + ConnectionState2[(ConnectionState2['Disposed'] = 4)] = 'Disposed'; + })(ConnectionState || (ConnectionState = {})); + function createMessageConnection( + messageReader2, + messageWriter2, + _logger, + options + ) { + const logger = _logger !== void 0 ? _logger : exports.NullLogger; + let sequenceNumber = 0; + let notificationSequenceNumber = 0; + let unknownResponseSequenceNumber = 0; + const version = '2.0'; + let starRequestHandler = void 0; + const requestHandlers = Object.create(null); + let starNotificationHandler = void 0; + const notificationHandlers = Object.create(null); + const progressHandlers = new Map(); + let timer; + let messageQueue = new linkedMap_1.LinkedMap(); + let responsePromises = Object.create(null); + let knownCanceledRequests = new Set(); + let requestTokens = Object.create(null); + let trace = Trace.Off; + let traceFormat = TraceFormat.Text; + let tracer; + let state = ConnectionState.New; + const errorEmitter = new events_1.Emitter(); + const closeEmitter = new events_1.Emitter(); + const unhandledNotificationEmitter = new events_1.Emitter(); + const unhandledProgressEmitter = new events_1.Emitter(); + const disposeEmitter = new events_1.Emitter(); + const cancellationStrategy = + options && options.cancellationStrategy + ? options.cancellationStrategy + : CancellationStrategy.Message; + function createRequestQueueKey(id) { + if (id === null) { + throw new Error( + `Can't send requests with id null since the response can't be correlated.` + ); + } + return 'req-' + id.toString(); + } + function createResponseQueueKey(id) { + if (id === null) { + return ( + 'res-unknown-' + (++unknownResponseSequenceNumber).toString() + ); + } else { + return 'res-' + id.toString(); + } + } + function createNotificationQueueKey() { + return 'not-' + (++notificationSequenceNumber).toString(); + } + function addMessageToQueue(queue, message) { + if (messages_1.Message.isRequest(message)) { + queue.set(createRequestQueueKey(message.id), message); + } else if (messages_1.Message.isResponse(message)) { + queue.set(createResponseQueueKey(message.id), message); + } else { + queue.set(createNotificationQueueKey(), message); + } + } + function cancelUndispatched(_message) { + return void 0; + } + function isListening() { + return state === ConnectionState.Listening; + } + function isClosed() { + return state === ConnectionState.Closed; + } + function isDisposed() { + return state === ConnectionState.Disposed; + } + function closeHandler() { + if ( + state === ConnectionState.New || + state === ConnectionState.Listening + ) { + state = ConnectionState.Closed; + closeEmitter.fire(void 0); + } + } + function readErrorHandler(error) { + errorEmitter.fire([error, void 0, void 0]); + } + function writeErrorHandler(data) { + errorEmitter.fire(data); + } + messageReader2.onClose(closeHandler); + messageReader2.onError(readErrorHandler); + messageWriter2.onClose(closeHandler); + messageWriter2.onError(writeErrorHandler); + function triggerMessageQueue() { + if (timer || messageQueue.size === 0) { + return; + } + timer = (0, ral_1.default)().timer.setImmediate(() => { + timer = void 0; + processMessageQueue(); + }); + } + function processMessageQueue() { + if (messageQueue.size === 0) { + return; + } + const message = messageQueue.shift(); + try { + if (messages_1.Message.isRequest(message)) { + handleRequest(message); + } else if (messages_1.Message.isNotification(message)) { + handleNotification(message); + } else if (messages_1.Message.isResponse(message)) { + handleResponse(message); + } else { + handleInvalidMessage(message); + } + } finally { + triggerMessageQueue(); + } + } + const callback = (message) => { + try { + if ( + messages_1.Message.isNotification(message) && + message.method === CancelNotification.type.method + ) { + const cancelId = message.params.id; + const key = createRequestQueueKey(cancelId); + const toCancel = messageQueue.get(key); + if (messages_1.Message.isRequest(toCancel)) { + const strategy = options?.connectionStrategy; + const response = + strategy && strategy.cancelUndispatched + ? strategy.cancelUndispatched(toCancel, cancelUndispatched) + : cancelUndispatched(toCancel); + if ( + response && + (response.error !== void 0 || response.result !== void 0) + ) { + messageQueue.delete(key); + response.id = toCancel.id; + traceSendingResponse(response, message.method, Date.now()); + messageWriter2 + .write(response) + .catch(() => + logger.error( + `Sending response for canceled message failed.` + ) + ); + return; + } + } + const tokenKey = String(cancelId); + const cancellationToken = requestTokens[tokenKey]; + if (cancellationToken !== void 0) { + cancellationToken.cancel(); + traceReceivedNotification(message); + return; + } else { + knownCanceledRequests.add(cancelId); + } + } + addMessageToQueue(messageQueue, message); + } finally { + triggerMessageQueue(); + } + }; + function handleRequest(requestMessage) { + if (isDisposed()) { + return; + } + function reply(resultOrError, method, startTime2) { + const message = { + jsonrpc: version, + id: requestMessage.id, + }; + if (resultOrError instanceof messages_1.ResponseError) { + message.error = resultOrError.toJson(); + } else { + message.result = resultOrError === void 0 ? null : resultOrError; + } + traceSendingResponse(message, method, startTime2); + messageWriter2 + .write(message) + .catch(() => logger.error(`Sending response failed.`)); + } + function replyError(error, method, startTime2) { + const message = { + jsonrpc: version, + id: requestMessage.id, + error: error.toJson(), + }; + traceSendingResponse(message, method, startTime2); + messageWriter2 + .write(message) + .catch(() => logger.error(`Sending response failed.`)); + } + function replySuccess(result, method, startTime2) { + if (result === void 0) { + result = null; + } + const message = { + jsonrpc: version, + id: requestMessage.id, + result, + }; + traceSendingResponse(message, method, startTime2); + messageWriter2 + .write(message) + .catch(() => logger.error(`Sending response failed.`)); + } + traceReceivedRequest(requestMessage); + const element = requestHandlers[requestMessage.method]; + let type; + let requestHandler; + if (element) { + type = element.type; + requestHandler = element.handler; + } + const startTime = Date.now(); + if (requestHandler || starRequestHandler) { + const tokenKey = String(requestMessage.id); + const cancellationSource = cancellationStrategy.receiver.createCancellationTokenSource( + tokenKey + ); + if ( + requestMessage.id !== null && + knownCanceledRequests.has(requestMessage.id) + ) { + cancellationSource.cancel(); + } + requestTokens[tokenKey] = cancellationSource; + try { + let handlerResult; + if (requestHandler) { + if (requestMessage.params === void 0) { + if (type !== void 0 && type.numberOfParams !== 0) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InvalidParams, + `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.` + ), + requestMessage.method, + startTime + ); + return; + } + handlerResult = requestHandler(cancellationSource.token); + } else if (Array.isArray(requestMessage.params)) { + if ( + type !== void 0 && + type.parameterStructures === + messages_1.ParameterStructures.byName + ) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InvalidParams, + `Request ${requestMessage.method} defines parameters by name but received parameters by position` + ), + requestMessage.method, + startTime + ); + return; + } + handlerResult = requestHandler( + ...requestMessage.params, + cancellationSource.token + ); + } else { + if ( + type !== void 0 && + type.parameterStructures === + messages_1.ParameterStructures.byPosition + ) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InvalidParams, + `Request ${requestMessage.method} defines parameters by position but received parameters by name` + ), + requestMessage.method, + startTime + ); + return; + } + handlerResult = requestHandler( + requestMessage.params, + cancellationSource.token + ); + } + } else if (starRequestHandler) { + handlerResult = starRequestHandler( + requestMessage.method, + requestMessage.params, + cancellationSource.token + ); + } + const promise = handlerResult; + if (!handlerResult) { + delete requestTokens[tokenKey]; + replySuccess(handlerResult, requestMessage.method, startTime); + } else if (promise.then) { + promise.then( + (resultOrError) => { + delete requestTokens[tokenKey]; + reply(resultOrError, requestMessage.method, startTime); + }, + (error) => { + delete requestTokens[tokenKey]; + if (error instanceof messages_1.ResponseError) { + replyError(error, requestMessage.method, startTime); + } else if (error && Is.string(error.message)) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed with message: ${error.message}` + ), + requestMessage.method, + startTime + ); + } else { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed unexpectedly without providing any details.` + ), + requestMessage.method, + startTime + ); + } + } + ); + } else { + delete requestTokens[tokenKey]; + reply(handlerResult, requestMessage.method, startTime); + } + } catch (error) { + delete requestTokens[tokenKey]; + if (error instanceof messages_1.ResponseError) { + reply(error, requestMessage.method, startTime); + } else if (error && Is.string(error.message)) { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed with message: ${error.message}` + ), + requestMessage.method, + startTime + ); + } else { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.InternalError, + `Request ${requestMessage.method} failed unexpectedly without providing any details.` + ), + requestMessage.method, + startTime + ); + } + } + } else { + replyError( + new messages_1.ResponseError( + messages_1.ErrorCodes.MethodNotFound, + `Unhandled method ${requestMessage.method}` + ), + requestMessage.method, + startTime + ); + } + } + function handleResponse(responseMessage) { + if (isDisposed()) { + return; + } + if (responseMessage.id === null) { + if (responseMessage.error) { + logger.error(`Received response message without id: Error is: +${JSON.stringify(responseMessage.error, void 0, 4)}`); + } else { + logger.error( + `Received response message without id. No further error information provided.` + ); + } + } else { + const key = String(responseMessage.id); + const responsePromise = responsePromises[key]; + traceReceivedResponse(responseMessage, responsePromise); + if (responsePromise) { + delete responsePromises[key]; + try { + if (responseMessage.error) { + const error = responseMessage.error; + responsePromise.reject( + new messages_1.ResponseError( + error.code, + error.message, + error.data + ) + ); + } else if (responseMessage.result !== void 0) { + responsePromise.resolve(responseMessage.result); + } else { + throw new Error('Should never happen.'); + } + } catch (error) { + if (error.message) { + logger.error( + `Response handler '${responsePromise.method}' failed with message: ${error.message}` + ); + } else { + logger.error( + `Response handler '${responsePromise.method}' failed unexpectedly.` + ); + } + } + } + } + } + function handleNotification(message) { + if (isDisposed()) { + return; + } + let type = void 0; + let notificationHandler; + if (message.method === CancelNotification.type.method) { + const cancelId = message.params.id; + knownCanceledRequests.delete(cancelId); + traceReceivedNotification(message); + return; + } else { + const element = notificationHandlers[message.method]; + if (element) { + notificationHandler = element.handler; + type = element.type; + } + } + if (notificationHandler || starNotificationHandler) { + try { + traceReceivedNotification(message); + if (notificationHandler) { + if (message.params === void 0) { + if (type !== void 0) { + if ( + type.numberOfParams !== 0 && + type.parameterStructures !== + messages_1.ParameterStructures.byName + ) { + logger.error( + `Notification ${message.method} defines ${type.numberOfParams} params but received none.` + ); + } + } + notificationHandler(); + } else if (Array.isArray(message.params)) { + const params = message.params; + if ( + message.method === ProgressNotification.type.method && + params.length === 2 && + ProgressToken.is(params[0]) + ) { + notificationHandler({ token: params[0], value: params[1] }); + } else { + if (type !== void 0) { + if ( + type.parameterStructures === + messages_1.ParameterStructures.byName + ) { + logger.error( + `Notification ${message.method} defines parameters by name but received parameters by position` + ); + } + if (type.numberOfParams !== message.params.length) { + logger.error( + `Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments` + ); + } + } + notificationHandler(...params); + } + } else { + if ( + type !== void 0 && + type.parameterStructures === + messages_1.ParameterStructures.byPosition + ) { + logger.error( + `Notification ${message.method} defines parameters by position but received parameters by name` + ); + } + notificationHandler(message.params); + } + } else if (starNotificationHandler) { + starNotificationHandler(message.method, message.params); + } + } catch (error) { + if (error.message) { + logger.error( + `Notification handler '${message.method}' failed with message: ${error.message}` + ); + } else { + logger.error( + `Notification handler '${message.method}' failed unexpectedly.` + ); + } + } + } else { + unhandledNotificationEmitter.fire(message); + } + } + function handleInvalidMessage(message) { + if (!message) { + logger.error('Received empty message.'); + return; + } + logger.error(`Received message which is neither a response nor a notification message: +${JSON.stringify(message, null, 4)}`); + const responseMessage = message; + if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) { + const key = String(responseMessage.id); + const responseHandler = responsePromises[key]; + if (responseHandler) { + responseHandler.reject( + new Error( + 'The received response has neither a result nor an error property.' + ) + ); + } + } + } + function stringifyTrace(params) { + if (params === void 0 || params === null) { + return void 0; + } + switch (trace) { + case Trace.Verbose: + return JSON.stringify(params, null, 4); + case Trace.Compact: + return JSON.stringify(params); + default: + return void 0; + } + } + function traceSendingRequest(message) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if ( + (trace === Trace.Verbose || trace === Trace.Compact) && + message.params + ) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } + tracer.log( + `Sending request '${message.method} - (${message.id})'.`, + data + ); + } else { + logLSPMessage('send-request', message); + } + } + function traceSendingNotification(message) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.params) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } else { + data = 'No parameters provided.\n\n'; + } + } + tracer.log(`Sending notification '${message.method}'.`, data); + } else { + logLSPMessage('send-notification', message); + } + } + function traceSendingResponse(message, method, startTime) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.error && message.error.data) { + data = `Error data: ${stringifyTrace(message.error.data)} + +`; + } else { + if (message.result) { + data = `Result: ${stringifyTrace(message.result)} + +`; + } else if (message.error === void 0) { + data = 'No result returned.\n\n'; + } + } + } + tracer.log( + `Sending response '${method} - (${ + message.id + })'. Processing request took ${Date.now() - startTime}ms`, + data + ); + } else { + logLSPMessage('send-response', message); + } + } + function traceReceivedRequest(message) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if ( + (trace === Trace.Verbose || trace === Trace.Compact) && + message.params + ) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } + tracer.log( + `Received request '${message.method} - (${message.id})'.`, + data + ); + } else { + logLSPMessage('receive-request', message); + } + } + function traceReceivedNotification(message) { + if ( + trace === Trace.Off || + !tracer || + message.method === LogTraceNotification.type.method + ) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.params) { + data = `Params: ${stringifyTrace(message.params)} + +`; + } else { + data = 'No parameters provided.\n\n'; + } + } + tracer.log(`Received notification '${message.method}'.`, data); + } else { + logLSPMessage('receive-notification', message); + } + } + function traceReceivedResponse(message, responsePromise) { + if (trace === Trace.Off || !tracer) { + return; + } + if (traceFormat === TraceFormat.Text) { + let data = void 0; + if (trace === Trace.Verbose || trace === Trace.Compact) { + if (message.error && message.error.data) { + data = `Error data: ${stringifyTrace(message.error.data)} + +`; + } else { + if (message.result) { + data = `Result: ${stringifyTrace(message.result)} + +`; + } else if (message.error === void 0) { + data = 'No result returned.\n\n'; + } + } + } + if (responsePromise) { + const error = message.error + ? ` Request failed: ${message.error.message} (${message.error.code}).` + : ''; + tracer.log( + `Received response '${responsePromise.method} - (${ + message.id + })' in ${Date.now() - responsePromise.timerStart}ms.${error}`, + data + ); + } else { + tracer.log( + `Received response ${message.id} without active response promise.`, + data + ); + } + } else { + logLSPMessage('receive-response', message); + } + } + function logLSPMessage(type, message) { + if (!tracer || trace === Trace.Off) { + return; + } + const lspMessage = { + isLSPMessage: true, + type, + message, + timestamp: Date.now(), + }; + tracer.log(lspMessage); + } + function throwIfClosedOrDisposed() { + if (isClosed()) { + throw new ConnectionError( + ConnectionErrors.Closed, + 'Connection is closed.' + ); + } + if (isDisposed()) { + throw new ConnectionError( + ConnectionErrors.Disposed, + 'Connection is disposed.' + ); + } + } + function throwIfListening() { + if (isListening()) { + throw new ConnectionError( + ConnectionErrors.AlreadyListening, + 'Connection is already listening' + ); + } + } + function throwIfNotListening() { + if (!isListening()) { + throw new Error('Call listen() first.'); + } + } + function undefinedToNull(param) { + if (param === void 0) { + return null; + } else { + return param; + } + } + function nullToUndefined(param) { + if (param === null) { + return void 0; + } else { + return param; + } + } + function isNamedParam(param) { + return ( + param !== void 0 && + param !== null && + !Array.isArray(param) && + typeof param === 'object' + ); + } + function computeSingleParam(parameterStructures, param) { + switch (parameterStructures) { + case messages_1.ParameterStructures.auto: + if (isNamedParam(param)) { + return nullToUndefined(param); + } else { + return [undefinedToNull(param)]; + } + case messages_1.ParameterStructures.byName: + if (!isNamedParam(param)) { + throw new Error( + `Received parameters by name but param is not an object literal.` + ); + } + return nullToUndefined(param); + case messages_1.ParameterStructures.byPosition: + return [undefinedToNull(param)]; + default: + throw new Error( + `Unknown parameter structure ${parameterStructures.toString()}` + ); + } + } + function computeMessageParams(type, params) { + let result; + const numberOfParams = type.numberOfParams; + switch (numberOfParams) { + case 0: + result = void 0; + break; + case 1: + result = computeSingleParam(type.parameterStructures, params[0]); + break; + default: + result = []; + for (let i = 0; i < params.length && i < numberOfParams; i++) { + result.push(undefinedToNull(params[i])); + } + if (params.length < numberOfParams) { + for (let i = params.length; i < numberOfParams; i++) { + result.push(null); + } + } + break; + } + return result; + } + const connection2 = { + sendNotification: (type, ...args) => { + throwIfClosedOrDisposed(); + let method; + let messageParams; + if (Is.string(type)) { + method = type; + const first = args[0]; + let paramStart = 0; + let parameterStructures = messages_1.ParameterStructures.auto; + if (messages_1.ParameterStructures.is(first)) { + paramStart = 1; + parameterStructures = first; + } + let paramEnd = args.length; + const numberOfParams = paramEnd - paramStart; + switch (numberOfParams) { + case 0: + messageParams = void 0; + break; + case 1: + messageParams = computeSingleParam( + parameterStructures, + args[paramStart] + ); + break; + default: + if ( + parameterStructures === + messages_1.ParameterStructures.byName + ) { + throw new Error( + `Received ${numberOfParams} parameters for 'by Name' notification parameter structure.` + ); + } + messageParams = args + .slice(paramStart, paramEnd) + .map((value) => undefinedToNull(value)); + break; + } + } else { + const params = args; + method = type.method; + messageParams = computeMessageParams(type, params); + } + const notificationMessage = { + jsonrpc: version, + method, + params: messageParams, + }; + traceSendingNotification(notificationMessage); + return messageWriter2 + .write(notificationMessage) + .catch(() => logger.error(`Sending notification failed.`)); + }, + onNotification: (type, handler) => { + throwIfClosedOrDisposed(); + let method; + if (Is.func(type)) { + starNotificationHandler = type; + } else if (handler) { + if (Is.string(type)) { + method = type; + notificationHandlers[type] = { type: void 0, handler }; + } else { + method = type.method; + notificationHandlers[type.method] = { type, handler }; + } + } + return { + dispose: () => { + if (method !== void 0) { + delete notificationHandlers[method]; + } else { + starNotificationHandler = void 0; + } + }, + }; + }, + onProgress: (_type, token, handler) => { + if (progressHandlers.has(token)) { + throw new Error( + `Progress handler for token ${token} already registered` + ); + } + progressHandlers.set(token, handler); + return { + dispose: () => { + progressHandlers.delete(token); + }, + }; + }, + sendProgress: (_type, token, value) => { + return connection2.sendNotification(ProgressNotification.type, { + token, + value, + }); + }, + onUnhandledProgress: unhandledProgressEmitter.event, + sendRequest: (type, ...args) => { + throwIfClosedOrDisposed(); + throwIfNotListening(); + let method; + let messageParams; + let token = void 0; + if (Is.string(type)) { + method = type; + const first = args[0]; + const last = args[args.length - 1]; + let paramStart = 0; + let parameterStructures = messages_1.ParameterStructures.auto; + if (messages_1.ParameterStructures.is(first)) { + paramStart = 1; + parameterStructures = first; + } + let paramEnd = args.length; + if (cancellation_1.CancellationToken.is(last)) { + paramEnd = paramEnd - 1; + token = last; + } + const numberOfParams = paramEnd - paramStart; + switch (numberOfParams) { + case 0: + messageParams = void 0; + break; + case 1: + messageParams = computeSingleParam( + parameterStructures, + args[paramStart] + ); + break; + default: + if ( + parameterStructures === + messages_1.ParameterStructures.byName + ) { + throw new Error( + `Received ${numberOfParams} parameters for 'by Name' request parameter structure.` + ); + } + messageParams = args + .slice(paramStart, paramEnd) + .map((value) => undefinedToNull(value)); + break; + } + } else { + const params = args; + method = type.method; + messageParams = computeMessageParams(type, params); + const numberOfParams = type.numberOfParams; + token = cancellation_1.CancellationToken.is( + params[numberOfParams] + ) + ? params[numberOfParams] + : void 0; + } + const id = sequenceNumber++; + let disposable; + if (token) { + disposable = token.onCancellationRequested(() => { + const p = cancellationStrategy.sender.sendCancellation( + connection2, + id + ); + if (p === void 0) { + logger.log( + `Received no promise from cancellation strategy when cancelling id ${id}` + ); + return Promise.resolve(); + } else { + return p.catch(() => { + logger.log( + `Sending cancellation messages for id ${id} failed` + ); + }); + } + }); + } + const result = new Promise((resolve, reject) => { + const requestMessage = { + jsonrpc: version, + id, + method, + params: messageParams, + }; + const resolveWithCleanup = (r) => { + resolve(r); + cancellationStrategy.sender.cleanup(id); + disposable?.dispose(); + }; + const rejectWithCleanup = (r) => { + reject(r); + cancellationStrategy.sender.cleanup(id); + disposable?.dispose(); + }; + let responsePromise = { + method, + timerStart: Date.now(), + resolve: resolveWithCleanup, + reject: rejectWithCleanup, + }; + traceSendingRequest(requestMessage); + try { + messageWriter2 + .write(requestMessage) + .catch(() => logger.error(`Sending request failed.`)); + } catch (e) { + responsePromise.reject( + new messages_1.ResponseError( + messages_1.ErrorCodes.MessageWriteError, + e.message ? e.message : 'Unknown reason' + ) + ); + responsePromise = null; + } + if (responsePromise) { + responsePromises[String(id)] = responsePromise; + } + }); + return result; + }, + onRequest: (type, handler) => { + throwIfClosedOrDisposed(); + let method = null; + if (StarRequestHandler.is(type)) { + method = void 0; + starRequestHandler = type; + } else if (Is.string(type)) { + method = null; + if (handler !== void 0) { + method = type; + requestHandlers[type] = { handler, type: void 0 }; + } + } else { + if (handler !== void 0) { + method = type.method; + requestHandlers[type.method] = { type, handler }; + } + } + return { + dispose: () => { + if (method === null) { + return; + } + if (method !== void 0) { + delete requestHandlers[method]; + } else { + starRequestHandler = void 0; + } + }, + }; + }, + trace: (_value, _tracer, sendNotificationOrTraceOptions) => { + let _sendNotification = false; + let _traceFormat = TraceFormat.Text; + if (sendNotificationOrTraceOptions !== void 0) { + if (Is.boolean(sendNotificationOrTraceOptions)) { + _sendNotification = sendNotificationOrTraceOptions; + } else { + _sendNotification = + sendNotificationOrTraceOptions.sendNotification || false; + _traceFormat = + sendNotificationOrTraceOptions.traceFormat || + TraceFormat.Text; + } + } + trace = _value; + traceFormat = _traceFormat; + if (trace === Trace.Off) { + tracer = void 0; + } else { + tracer = _tracer; + } + if (_sendNotification && !isClosed() && !isDisposed()) { + connection2 + .sendNotification(SetTraceNotification.type, { + value: Trace.toString(_value), + }) + .catch(() => { + logger.error(`Sending trace notification failed`); + }); + } + }, + onError: errorEmitter.event, + onClose: closeEmitter.event, + onUnhandledNotification: unhandledNotificationEmitter.event, + onDispose: disposeEmitter.event, + end: () => { + messageWriter2.end(); + }, + dispose: () => { + if (isDisposed()) { + return; + } + state = ConnectionState.Disposed; + disposeEmitter.fire(void 0); + const error = new Error('Connection got disposed.'); + Object.keys(responsePromises).forEach((key) => { + responsePromises[key].reject(error); + }); + responsePromises = Object.create(null); + requestTokens = Object.create(null); + knownCanceledRequests = new Set(); + messageQueue = new linkedMap_1.LinkedMap(); + if (Is.func(messageWriter2.dispose)) { + messageWriter2.dispose(); + } + if (Is.func(messageReader2.dispose)) { + messageReader2.dispose(); + } + }, + listen: () => { + throwIfClosedOrDisposed(); + throwIfListening(); + state = ConnectionState.Listening; + messageReader2.listen(callback); + }, + inspect: () => { + (0, ral_1.default)().console.log('inspect'); + }, + }; + connection2.onNotification(LogTraceNotification.type, (params) => { + if (trace === Trace.Off || !tracer) { + return; + } + const verbose = trace === Trace.Verbose || trace === Trace.Compact; + tracer.log(params.message, verbose ? params.verbose : void 0); + }); + connection2.onNotification(ProgressNotification.type, (params) => { + const handler = progressHandlers.get(params.token); + if (handler) { + handler(params.value); + } else { + unhandledProgressEmitter.fire(params); + } + }); + return connection2; + } + exports.createMessageConnection = createMessageConnection; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/common/api.js + let require_api = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/common/api.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SetTraceNotification = exports.TraceFormat = exports.Trace = exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0; + exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = void 0; + let messages_1 = require_messages(); + Object.defineProperty(exports, 'Message', { + enumerable: true, + get: function () { + return messages_1.Message; + }, + }); + Object.defineProperty(exports, 'RequestType', { + enumerable: true, + get: function () { + return messages_1.RequestType; + }, + }); + Object.defineProperty(exports, 'RequestType0', { + enumerable: true, + get: function () { + return messages_1.RequestType0; + }, + }); + Object.defineProperty(exports, 'RequestType1', { + enumerable: true, + get: function () { + return messages_1.RequestType1; + }, + }); + Object.defineProperty(exports, 'RequestType2', { + enumerable: true, + get: function () { + return messages_1.RequestType2; + }, + }); + Object.defineProperty(exports, 'RequestType3', { + enumerable: true, + get: function () { + return messages_1.RequestType3; + }, + }); + Object.defineProperty(exports, 'RequestType4', { + enumerable: true, + get: function () { + return messages_1.RequestType4; + }, + }); + Object.defineProperty(exports, 'RequestType5', { + enumerable: true, + get: function () { + return messages_1.RequestType5; + }, + }); + Object.defineProperty(exports, 'RequestType6', { + enumerable: true, + get: function () { + return messages_1.RequestType6; + }, + }); + Object.defineProperty(exports, 'RequestType7', { + enumerable: true, + get: function () { + return messages_1.RequestType7; + }, + }); + Object.defineProperty(exports, 'RequestType8', { + enumerable: true, + get: function () { + return messages_1.RequestType8; + }, + }); + Object.defineProperty(exports, 'RequestType9', { + enumerable: true, + get: function () { + return messages_1.RequestType9; + }, + }); + Object.defineProperty(exports, 'ResponseError', { + enumerable: true, + get: function () { + return messages_1.ResponseError; + }, + }); + Object.defineProperty(exports, 'ErrorCodes', { + enumerable: true, + get: function () { + return messages_1.ErrorCodes; + }, + }); + Object.defineProperty(exports, 'NotificationType', { + enumerable: true, + get: function () { + return messages_1.NotificationType; + }, + }); + Object.defineProperty(exports, 'NotificationType0', { + enumerable: true, + get: function () { + return messages_1.NotificationType0; + }, + }); + Object.defineProperty(exports, 'NotificationType1', { + enumerable: true, + get: function () { + return messages_1.NotificationType1; + }, + }); + Object.defineProperty(exports, 'NotificationType2', { + enumerable: true, + get: function () { + return messages_1.NotificationType2; + }, + }); + Object.defineProperty(exports, 'NotificationType3', { + enumerable: true, + get: function () { + return messages_1.NotificationType3; + }, + }); + Object.defineProperty(exports, 'NotificationType4', { + enumerable: true, + get: function () { + return messages_1.NotificationType4; + }, + }); + Object.defineProperty(exports, 'NotificationType5', { + enumerable: true, + get: function () { + return messages_1.NotificationType5; + }, + }); + Object.defineProperty(exports, 'NotificationType6', { + enumerable: true, + get: function () { + return messages_1.NotificationType6; + }, + }); + Object.defineProperty(exports, 'NotificationType7', { + enumerable: true, + get: function () { + return messages_1.NotificationType7; + }, + }); + Object.defineProperty(exports, 'NotificationType8', { + enumerable: true, + get: function () { + return messages_1.NotificationType8; + }, + }); + Object.defineProperty(exports, 'NotificationType9', { + enumerable: true, + get: function () { + return messages_1.NotificationType9; + }, + }); + Object.defineProperty(exports, 'ParameterStructures', { + enumerable: true, + get: function () { + return messages_1.ParameterStructures; + }, + }); + let linkedMap_1 = require_linkedMap(); + Object.defineProperty(exports, 'LinkedMap', { + enumerable: true, + get: function () { + return linkedMap_1.LinkedMap; + }, + }); + Object.defineProperty(exports, 'LRUCache', { + enumerable: true, + get: function () { + return linkedMap_1.LRUCache; + }, + }); + Object.defineProperty(exports, 'Touch', { + enumerable: true, + get: function () { + return linkedMap_1.Touch; + }, + }); + let disposable_1 = require_disposable(); + Object.defineProperty(exports, 'Disposable', { + enumerable: true, + get: function () { + return disposable_1.Disposable; + }, + }); + let events_1 = require_events(); + Object.defineProperty(exports, 'Event', { + enumerable: true, + get: function () { + return events_1.Event; + }, + }); + Object.defineProperty(exports, 'Emitter', { + enumerable: true, + get: function () { + return events_1.Emitter; + }, + }); + let cancellation_1 = require_cancellation(); + Object.defineProperty(exports, 'CancellationTokenSource', { + enumerable: true, + get: function () { + return cancellation_1.CancellationTokenSource; + }, + }); + Object.defineProperty(exports, 'CancellationToken', { + enumerable: true, + get: function () { + return cancellation_1.CancellationToken; + }, + }); + let messageReader_1 = require_messageReader(); + Object.defineProperty(exports, 'MessageReader', { + enumerable: true, + get: function () { + return messageReader_1.MessageReader; + }, + }); + Object.defineProperty(exports, 'AbstractMessageReader', { + enumerable: true, + get: function () { + return messageReader_1.AbstractMessageReader; + }, + }); + Object.defineProperty(exports, 'ReadableStreamMessageReader', { + enumerable: true, + get: function () { + return messageReader_1.ReadableStreamMessageReader; + }, + }); + let messageWriter_1 = require_messageWriter(); + Object.defineProperty(exports, 'MessageWriter', { + enumerable: true, + get: function () { + return messageWriter_1.MessageWriter; + }, + }); + Object.defineProperty(exports, 'AbstractMessageWriter', { + enumerable: true, + get: function () { + return messageWriter_1.AbstractMessageWriter; + }, + }); + Object.defineProperty(exports, 'WriteableStreamMessageWriter', { + enumerable: true, + get: function () { + return messageWriter_1.WriteableStreamMessageWriter; + }, + }); + let connection_1 = require_connection(); + Object.defineProperty(exports, 'ConnectionStrategy', { + enumerable: true, + get: function () { + return connection_1.ConnectionStrategy; + }, + }); + Object.defineProperty(exports, 'ConnectionOptions', { + enumerable: true, + get: function () { + return connection_1.ConnectionOptions; + }, + }); + Object.defineProperty(exports, 'NullLogger', { + enumerable: true, + get: function () { + return connection_1.NullLogger; + }, + }); + Object.defineProperty(exports, 'createMessageConnection', { + enumerable: true, + get: function () { + return connection_1.createMessageConnection; + }, + }); + Object.defineProperty(exports, 'ProgressToken', { + enumerable: true, + get: function () { + return connection_1.ProgressToken; + }, + }); + Object.defineProperty(exports, 'ProgressType', { + enumerable: true, + get: function () { + return connection_1.ProgressType; + }, + }); + Object.defineProperty(exports, 'Trace', { + enumerable: true, + get: function () { + return connection_1.Trace; + }, + }); + Object.defineProperty(exports, 'TraceFormat', { + enumerable: true, + get: function () { + return connection_1.TraceFormat; + }, + }); + Object.defineProperty(exports, 'SetTraceNotification', { + enumerable: true, + get: function () { + return connection_1.SetTraceNotification; + }, + }); + Object.defineProperty(exports, 'LogTraceNotification', { + enumerable: true, + get: function () { + return connection_1.LogTraceNotification; + }, + }); + Object.defineProperty(exports, 'ConnectionErrors', { + enumerable: true, + get: function () { + return connection_1.ConnectionErrors; + }, + }); + Object.defineProperty(exports, 'ConnectionError', { + enumerable: true, + get: function () { + return connection_1.ConnectionError; + }, + }); + Object.defineProperty(exports, 'CancellationReceiverStrategy', { + enumerable: true, + get: function () { + return connection_1.CancellationReceiverStrategy; + }, + }); + Object.defineProperty(exports, 'CancellationSenderStrategy', { + enumerable: true, + get: function () { + return connection_1.CancellationSenderStrategy; + }, + }); + Object.defineProperty(exports, 'CancellationStrategy', { + enumerable: true, + get: function () { + return connection_1.CancellationStrategy; + }, + }); + let ral_1 = require_ral(); + exports.RAL = ral_1.default; + }, + }); + + // server/node_modules/vscode-jsonrpc/lib/browser/main.js + let require_main = __commonJS({ + 'server/node_modules/vscode-jsonrpc/lib/browser/main.js'(exports) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createMessageConnection = exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0; + let ril_1 = require_ril(); + ril_1.default.install(); + let api_1 = require_api(); + __exportStar(require_api(), exports); + let BrowserMessageReader2 = class extends api_1.AbstractMessageReader { + constructor(context) { + super(); + this._onData = new api_1.Emitter(); + this._messageListener = (event) => { + this._onData.fire(event.data); + }; + context.addEventListener('error', (event) => this.fireError(event)); + context.onmessage = this._messageListener; + } + listen(callback) { + return this._onData.event(callback); + } + }; + exports.BrowserMessageReader = BrowserMessageReader2; + let BrowserMessageWriter2 = class extends api_1.AbstractMessageWriter { + constructor(context) { + super(); + this.context = context; + this.errorCount = 0; + context.addEventListener('error', (event) => this.fireError(event)); + } + write(msg) { + try { + this.context.postMessage(msg); + return Promise.resolve(); + } catch (error) { + this.handleError(error, msg); + return Promise.reject(error); + } + } + handleError(error, msg) { + this.errorCount++; + this.fireError(error, msg, this.errorCount); + } + end() {} + }; + exports.BrowserMessageWriter = BrowserMessageWriter2; + function createMessageConnection(reader, writer, logger, options) { + if (logger === void 0) { + logger = api_1.NullLogger; + } + if (api_1.ConnectionStrategy.is(options)) { + options = { connectionStrategy: options }; + } + return (0, api_1.createMessageConnection)( + reader, + writer, + logger, + options + ); + } + exports.createMessageConnection = createMessageConnection; + }, + }); + + // server/node_modules/vscode-jsonrpc/browser.js + let require_browser = __commonJS({ + 'server/node_modules/vscode-jsonrpc/browser.js'(exports, module) { + 'use strict'; + module.exports = require_main(); + }, + }); + + // server/node_modules/vscode-languageserver-types/lib/umd/main.js + let require_main2 = __commonJS({ + 'server/node_modules/vscode-languageserver-types/lib/umd/main.js'( + exports, + module + ) { + (function (factory) { + if (typeof module === 'object' && typeof module.exports === 'object') { + let v = factory(__require, exports); + if (v !== void 0) { + module.exports = v; + } + } else if (typeof define === 'function' && define.amd) { + define(['require', 'exports'], factory); + } + })(function (require2, exports2) { + 'use strict'; + Object.defineProperty(exports2, '__esModule', { value: true }); + exports2.TextDocument = exports2.EOL = exports2.InlineValuesContext = exports2.InlineValueEvaluatableExpression = exports2.InlineValueVariableLookup = exports2.InlineValueText = exports2.SemanticTokens = exports2.SemanticTokenModifiers = exports2.SemanticTokenTypes = exports2.SelectionRange = exports2.DocumentLink = exports2.FormattingOptions = exports2.CodeLens = exports2.CodeAction = exports2.CodeActionContext = exports2.CodeActionTriggerKind = exports2.CodeActionKind = exports2.DocumentSymbol = exports2.WorkspaceSymbol = exports2.SymbolInformation = exports2.SymbolTag = exports2.SymbolKind = exports2.DocumentHighlight = exports2.DocumentHighlightKind = exports2.SignatureInformation = exports2.ParameterInformation = exports2.Hover = exports2.MarkedString = exports2.CompletionList = exports2.CompletionItem = exports2.CompletionItemLabelDetails = exports2.InsertTextMode = exports2.InsertReplaceEdit = exports2.CompletionItemTag = exports2.InsertTextFormat = exports2.CompletionItemKind = exports2.MarkupContent = exports2.MarkupKind = exports2.TextDocumentItem = exports2.OptionalVersionedTextDocumentIdentifier = exports2.VersionedTextDocumentIdentifier = exports2.TextDocumentIdentifier = exports2.WorkspaceChange = exports2.WorkspaceEdit = exports2.DeleteFile = exports2.RenameFile = exports2.CreateFile = exports2.TextDocumentEdit = exports2.AnnotatedTextEdit = exports2.ChangeAnnotationIdentifier = exports2.ChangeAnnotation = exports2.TextEdit = exports2.Command = exports2.Diagnostic = exports2.CodeDescription = exports2.DiagnosticTag = exports2.DiagnosticSeverity = exports2.DiagnosticRelatedInformation = exports2.FoldingRange = exports2.FoldingRangeKind = exports2.ColorPresentation = exports2.ColorInformation = exports2.Color = exports2.LocationLink = exports2.Location = exports2.Range = exports2.Position = exports2.uinteger = exports2.integer = void 0; + let integer; + (function (integer2) { + integer2.MIN_VALUE = -2147483648; + integer2.MAX_VALUE = 2147483647; + })((integer = exports2.integer || (exports2.integer = {}))); + let uinteger; + (function (uinteger2) { + uinteger2.MIN_VALUE = 0; + uinteger2.MAX_VALUE = 2147483647; + })((uinteger = exports2.uinteger || (exports2.uinteger = {}))); + let Position; + (function (Position2) { + function create(line, character) { + if (line === Number.MAX_VALUE) { + line = uinteger.MAX_VALUE; + } + if (character === Number.MAX_VALUE) { + character = uinteger.MAX_VALUE; + } + return { line, character }; + } + Position2.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Is.uinteger(candidate.line) && + Is.uinteger(candidate.character) + ); + } + Position2.is = is; + })((Position = exports2.Position || (exports2.Position = {}))); + let Range4; + (function (Range5) { + function create(one, two, three, four) { + if ( + Is.uinteger(one) && + Is.uinteger(two) && + Is.uinteger(three) && + Is.uinteger(four) + ) { + return { + start: Position.create(one, two), + end: Position.create(three, four), + }; + } else if (Position.is(one) && Position.is(two)) { + return { start: one, end: two }; + } else { + throw new Error( + 'Range#create called with invalid arguments[' + .concat(one, ', ') + .concat(two, ', ') + .concat(three, ', ') + .concat(four, ']') + ); + } + } + Range5.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Position.is(candidate.start) && + Position.is(candidate.end) + ); + } + Range5.is = is; + })((Range4 = exports2.Range || (exports2.Range = {}))); + let Location4; + (function (Location5) { + function create(uri, range) { + return { uri, range }; + } + Location5.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Range4.is(candidate.range) && + (Is.string(candidate.uri) || Is.undefined(candidate.uri)) + ); + } + Location5.is = is; + })((Location4 = exports2.Location || (exports2.Location = {}))); + let LocationLink; + (function (LocationLink2) { + function create( + targetUri, + targetRange, + targetSelectionRange, + originSelectionRange + ) { + return { + targetUri, + targetRange, + targetSelectionRange, + originSelectionRange, + }; + } + LocationLink2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Range4.is(candidate.targetRange) && + Is.string(candidate.targetUri) && + Range4.is(candidate.targetSelectionRange) && + (Range4.is(candidate.originSelectionRange) || + Is.undefined(candidate.originSelectionRange)) + ); + } + LocationLink2.is = is; + })( + (LocationLink = exports2.LocationLink || (exports2.LocationLink = {})) + ); + let Color; + (function (Color2) { + function create(red, green, blue, alpha) { + return { + red, + green, + blue, + alpha, + }; + } + Color2.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Is.numberRange(candidate.red, 0, 1) && + Is.numberRange(candidate.green, 0, 1) && + Is.numberRange(candidate.blue, 0, 1) && + Is.numberRange(candidate.alpha, 0, 1) + ); + } + Color2.is = is; + })((Color = exports2.Color || (exports2.Color = {}))); + let ColorInformation; + (function (ColorInformation2) { + function create(range, color) { + return { + range, + color, + }; + } + ColorInformation2.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Range4.is(candidate.range) && + Color.is(candidate.color) + ); + } + ColorInformation2.is = is; + })( + (ColorInformation = + exports2.ColorInformation || (exports2.ColorInformation = {})) + ); + let ColorPresentation; + (function (ColorPresentation2) { + function create(label, textEdit, additionalTextEdits) { + return { + label, + textEdit, + additionalTextEdits, + }; + } + ColorPresentation2.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Is.string(candidate.label) && + (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && + (Is.undefined(candidate.additionalTextEdits) || + Is.typedArray(candidate.additionalTextEdits, TextEdit.is)) + ); + } + ColorPresentation2.is = is; + })( + (ColorPresentation = + exports2.ColorPresentation || (exports2.ColorPresentation = {})) + ); + let FoldingRangeKind; + (function (FoldingRangeKind2) { + FoldingRangeKind2['Comment'] = 'comment'; + FoldingRangeKind2['Imports'] = 'imports'; + FoldingRangeKind2['Region'] = 'region'; + })( + (FoldingRangeKind = + exports2.FoldingRangeKind || (exports2.FoldingRangeKind = {})) + ); + let FoldingRange2; + (function (FoldingRange3) { + function create( + startLine, + endLine, + startCharacter, + endCharacter, + kind + ) { + let result = { + startLine, + endLine, + }; + if (Is.defined(startCharacter)) { + result.startCharacter = startCharacter; + } + if (Is.defined(endCharacter)) { + result.endCharacter = endCharacter; + } + if (Is.defined(kind)) { + result.kind = kind; + } + return result; + } + FoldingRange3.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Is.uinteger(candidate.startLine) && + Is.uinteger(candidate.startLine) && + (Is.undefined(candidate.startCharacter) || + Is.uinteger(candidate.startCharacter)) && + (Is.undefined(candidate.endCharacter) || + Is.uinteger(candidate.endCharacter)) && + (Is.undefined(candidate.kind) || Is.string(candidate.kind)) + ); + } + FoldingRange3.is = is; + })( + (FoldingRange2 = + exports2.FoldingRange || (exports2.FoldingRange = {})) + ); + let DiagnosticRelatedInformation; + (function (DiagnosticRelatedInformation2) { + function create(location, message) { + return { + location, + message, + }; + } + DiagnosticRelatedInformation2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Location4.is(candidate.location) && + Is.string(candidate.message) + ); + } + DiagnosticRelatedInformation2.is = is; + })( + (DiagnosticRelatedInformation = + exports2.DiagnosticRelatedInformation || + (exports2.DiagnosticRelatedInformation = {})) + ); + let DiagnosticSeverity2; + (function (DiagnosticSeverity3) { + DiagnosticSeverity3.Error = 1; + DiagnosticSeverity3.Warning = 2; + DiagnosticSeverity3.Information = 3; + DiagnosticSeverity3.Hint = 4; + })( + (DiagnosticSeverity2 = + exports2.DiagnosticSeverity || (exports2.DiagnosticSeverity = {})) + ); + let DiagnosticTag; + (function (DiagnosticTag2) { + DiagnosticTag2.Unnecessary = 1; + DiagnosticTag2.Deprecated = 2; + })( + (DiagnosticTag = + exports2.DiagnosticTag || (exports2.DiagnosticTag = {})) + ); + let CodeDescription; + (function (CodeDescription2) { + function is(value) { + let candidate = value; + return Is.objectLiteral(candidate) && Is.string(candidate.href); + } + CodeDescription2.is = is; + })( + (CodeDescription = + exports2.CodeDescription || (exports2.CodeDescription = {})) + ); + let Diagnostic2; + (function (Diagnostic3) { + function create( + range, + message, + severity, + code, + source, + relatedInformation + ) { + let result = { range, message }; + if (Is.defined(severity)) { + result.severity = severity; + } + if (Is.defined(code)) { + result.code = code; + } + if (Is.defined(source)) { + result.source = source; + } + if (Is.defined(relatedInformation)) { + result.relatedInformation = relatedInformation; + } + return result; + } + Diagnostic3.create = create; + function is(value) { + let _a; + let candidate = value; + return ( + Is.defined(candidate) && + Range4.is(candidate.range) && + Is.string(candidate.message) && + (Is.number(candidate.severity) || + Is.undefined(candidate.severity)) && + (Is.integer(candidate.code) || + Is.string(candidate.code) || + Is.undefined(candidate.code)) && + (Is.undefined(candidate.codeDescription) || + Is.string( + (_a = candidate.codeDescription) === null || _a === void 0 + ? void 0 + : _a.href + )) && + (Is.string(candidate.source) || Is.undefined(candidate.source)) && + (Is.undefined(candidate.relatedInformation) || + Is.typedArray( + candidate.relatedInformation, + DiagnosticRelatedInformation.is + )) + ); + } + Diagnostic3.is = is; + })((Diagnostic2 = exports2.Diagnostic || (exports2.Diagnostic = {}))); + let Command; + (function (Command2) { + function create(title, command) { + let args = []; + for (let _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + let result = { title, command }; + if (Is.defined(args) && args.length > 0) { + result.arguments = args; + } + return result; + } + Command2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Is.string(candidate.title) && + Is.string(candidate.command) + ); + } + Command2.is = is; + })((Command = exports2.Command || (exports2.Command = {}))); + let TextEdit; + (function (TextEdit2) { + function replace(range, newText) { + return { range, newText }; + } + TextEdit2.replace = replace; + function insert(position, newText) { + return { range: { start: position, end: position }, newText }; + } + TextEdit2.insert = insert; + function del(range) { + return { range, newText: '' }; + } + TextEdit2.del = del; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Is.string(candidate.newText) && + Range4.is(candidate.range) + ); + } + TextEdit2.is = is; + })((TextEdit = exports2.TextEdit || (exports2.TextEdit = {}))); + let ChangeAnnotation; + (function (ChangeAnnotation2) { + function create(label, needsConfirmation, description) { + let result = { label }; + if (needsConfirmation !== void 0) { + result.needsConfirmation = needsConfirmation; + } + if (description !== void 0) { + result.description = description; + } + return result; + } + ChangeAnnotation2.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Is.string(candidate.label) && + (Is.boolean(candidate.needsConfirmation) || + candidate.needsConfirmation === void 0) && + (Is.string(candidate.description) || + candidate.description === void 0) + ); + } + ChangeAnnotation2.is = is; + })( + (ChangeAnnotation = + exports2.ChangeAnnotation || (exports2.ChangeAnnotation = {})) + ); + let ChangeAnnotationIdentifier; + (function (ChangeAnnotationIdentifier2) { + function is(value) { + let candidate = value; + return Is.string(candidate); + } + ChangeAnnotationIdentifier2.is = is; + })( + (ChangeAnnotationIdentifier = + exports2.ChangeAnnotationIdentifier || + (exports2.ChangeAnnotationIdentifier = {})) + ); + let AnnotatedTextEdit; + (function (AnnotatedTextEdit2) { + function replace(range, newText, annotation) { + return { range, newText, annotationId: annotation }; + } + AnnotatedTextEdit2.replace = replace; + function insert(position, newText, annotation) { + return { + range: { start: position, end: position }, + newText, + annotationId: annotation, + }; + } + AnnotatedTextEdit2.insert = insert; + function del(range, annotation) { + return { range, newText: '', annotationId: annotation }; + } + AnnotatedTextEdit2.del = del; + function is(value) { + let candidate = value; + return ( + TextEdit.is(candidate) && + (ChangeAnnotation.is(candidate.annotationId) || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + AnnotatedTextEdit2.is = is; + })( + (AnnotatedTextEdit = + exports2.AnnotatedTextEdit || (exports2.AnnotatedTextEdit = {})) + ); + let TextDocumentEdit; + (function (TextDocumentEdit2) { + function create(textDocument, edits) { + return { textDocument, edits }; + } + TextDocumentEdit2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + OptionalVersionedTextDocumentIdentifier.is( + candidate.textDocument + ) && + Array.isArray(candidate.edits) + ); + } + TextDocumentEdit2.is = is; + })( + (TextDocumentEdit = + exports2.TextDocumentEdit || (exports2.TextDocumentEdit = {})) + ); + let CreateFile; + (function (CreateFile2) { + function create(uri, options, annotation) { + let result = { + kind: 'create', + uri, + }; + if ( + options !== void 0 && + (options.overwrite !== void 0 || + options.ignoreIfExists !== void 0) + ) { + result.options = options; + } + if (annotation !== void 0) { + result.annotationId = annotation; + } + return result; + } + CreateFile2.create = create; + function is(value) { + let candidate = value; + return ( + candidate && + candidate.kind === 'create' && + Is.string(candidate.uri) && + (candidate.options === void 0 || + ((candidate.options.overwrite === void 0 || + Is.boolean(candidate.options.overwrite)) && + (candidate.options.ignoreIfExists === void 0 || + Is.boolean(candidate.options.ignoreIfExists)))) && + (candidate.annotationId === void 0 || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + CreateFile2.is = is; + })((CreateFile = exports2.CreateFile || (exports2.CreateFile = {}))); + let RenameFile; + (function (RenameFile2) { + function create(oldUri, newUri, options, annotation) { + let result = { + kind: 'rename', + oldUri, + newUri, + }; + if ( + options !== void 0 && + (options.overwrite !== void 0 || + options.ignoreIfExists !== void 0) + ) { + result.options = options; + } + if (annotation !== void 0) { + result.annotationId = annotation; + } + return result; + } + RenameFile2.create = create; + function is(value) { + let candidate = value; + return ( + candidate && + candidate.kind === 'rename' && + Is.string(candidate.oldUri) && + Is.string(candidate.newUri) && + (candidate.options === void 0 || + ((candidate.options.overwrite === void 0 || + Is.boolean(candidate.options.overwrite)) && + (candidate.options.ignoreIfExists === void 0 || + Is.boolean(candidate.options.ignoreIfExists)))) && + (candidate.annotationId === void 0 || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + RenameFile2.is = is; + })((RenameFile = exports2.RenameFile || (exports2.RenameFile = {}))); + let DeleteFile; + (function (DeleteFile2) { + function create(uri, options, annotation) { + let result = { + kind: 'delete', + uri, + }; + if ( + options !== void 0 && + (options.recursive !== void 0 || + options.ignoreIfNotExists !== void 0) + ) { + result.options = options; + } + if (annotation !== void 0) { + result.annotationId = annotation; + } + return result; + } + DeleteFile2.create = create; + function is(value) { + let candidate = value; + return ( + candidate && + candidate.kind === 'delete' && + Is.string(candidate.uri) && + (candidate.options === void 0 || + ((candidate.options.recursive === void 0 || + Is.boolean(candidate.options.recursive)) && + (candidate.options.ignoreIfNotExists === void 0 || + Is.boolean(candidate.options.ignoreIfNotExists)))) && + (candidate.annotationId === void 0 || + ChangeAnnotationIdentifier.is(candidate.annotationId)) + ); + } + DeleteFile2.is = is; + })((DeleteFile = exports2.DeleteFile || (exports2.DeleteFile = {}))); + let WorkspaceEdit; + (function (WorkspaceEdit2) { + function is(value) { + let candidate = value; + return ( + candidate && + (candidate.changes !== void 0 || + candidate.documentChanges !== void 0) && + (candidate.documentChanges === void 0 || + candidate.documentChanges.every(function (change) { + if (Is.string(change.kind)) { + return ( + CreateFile.is(change) || + RenameFile.is(change) || + DeleteFile.is(change) + ); + } else { + return TextDocumentEdit.is(change); + } + })) + ); + } + WorkspaceEdit2.is = is; + })( + (WorkspaceEdit = + exports2.WorkspaceEdit || (exports2.WorkspaceEdit = {})) + ); + let TextEditChangeImpl = (function () { + function TextEditChangeImpl2(edits, changeAnnotations) { + this.edits = edits; + this.changeAnnotations = changeAnnotations; + } + TextEditChangeImpl2.prototype.insert = function ( + position, + newText, + annotation + ) { + let edit; + let id; + if (annotation === void 0) { + edit = TextEdit.insert(position, newText); + } else if (ChangeAnnotationIdentifier.is(annotation)) { + id = annotation; + edit = AnnotatedTextEdit.insert(position, newText, annotation); + } else { + this.assertChangeAnnotations(this.changeAnnotations); + id = this.changeAnnotations.manage(annotation); + edit = AnnotatedTextEdit.insert(position, newText, id); + } + this.edits.push(edit); + if (id !== void 0) { + return id; + } + }; + TextEditChangeImpl2.prototype.replace = function ( + range, + newText, + annotation + ) { + let edit; + let id; + if (annotation === void 0) { + edit = TextEdit.replace(range, newText); + } else if (ChangeAnnotationIdentifier.is(annotation)) { + id = annotation; + edit = AnnotatedTextEdit.replace(range, newText, annotation); + } else { + this.assertChangeAnnotations(this.changeAnnotations); + id = this.changeAnnotations.manage(annotation); + edit = AnnotatedTextEdit.replace(range, newText, id); + } + this.edits.push(edit); + if (id !== void 0) { + return id; + } + }; + TextEditChangeImpl2.prototype.delete = function (range, annotation) { + let edit; + let id; + if (annotation === void 0) { + edit = TextEdit.del(range); + } else if (ChangeAnnotationIdentifier.is(annotation)) { + id = annotation; + edit = AnnotatedTextEdit.del(range, annotation); + } else { + this.assertChangeAnnotations(this.changeAnnotations); + id = this.changeAnnotations.manage(annotation); + edit = AnnotatedTextEdit.del(range, id); + } + this.edits.push(edit); + if (id !== void 0) { + return id; + } + }; + TextEditChangeImpl2.prototype.add = function (edit) { + this.edits.push(edit); + }; + TextEditChangeImpl2.prototype.all = function () { + return this.edits; + }; + TextEditChangeImpl2.prototype.clear = function () { + this.edits.splice(0, this.edits.length); + }; + TextEditChangeImpl2.prototype.assertChangeAnnotations = function ( + value + ) { + if (value === void 0) { + throw new Error( + 'Text edit change is not configured to manage change annotations.' + ); + } + }; + return TextEditChangeImpl2; + })(); + let ChangeAnnotations = (function () { + function ChangeAnnotations2(annotations) { + this._annotations = + annotations === void 0 ? Object.create(null) : annotations; + this._counter = 0; + this._size = 0; + } + ChangeAnnotations2.prototype.all = function () { + return this._annotations; + }; + Object.defineProperty(ChangeAnnotations2.prototype, 'size', { + get: function () { + return this._size; + }, + enumerable: false, + configurable: true, + }); + ChangeAnnotations2.prototype.manage = function ( + idOrAnnotation, + annotation + ) { + let id; + if (ChangeAnnotationIdentifier.is(idOrAnnotation)) { + id = idOrAnnotation; + } else { + id = this.nextId(); + annotation = idOrAnnotation; + } + if (this._annotations[id] !== void 0) { + throw new Error('Id '.concat(id, ' is already in use.')); + } + if (annotation === void 0) { + throw new Error('No annotation provided for id '.concat(id)); + } + this._annotations[id] = annotation; + this._size++; + return id; + }; + ChangeAnnotations2.prototype.nextId = function () { + this._counter++; + return this._counter.toString(); + }; + return ChangeAnnotations2; + })(); + let WorkspaceChange = (function () { + function WorkspaceChange2(workspaceEdit) { + let _this = this; + this._textEditChanges = Object.create(null); + if (workspaceEdit !== void 0) { + this._workspaceEdit = workspaceEdit; + if (workspaceEdit.documentChanges) { + this._changeAnnotations = new ChangeAnnotations( + workspaceEdit.changeAnnotations + ); + workspaceEdit.changeAnnotations = this._changeAnnotations.all(); + workspaceEdit.documentChanges.forEach(function (change) { + if (TextDocumentEdit.is(change)) { + let textEditChange = new TextEditChangeImpl( + change.edits, + _this._changeAnnotations + ); + _this._textEditChanges[ + change.textDocument.uri + ] = textEditChange; + } + }); + } else if (workspaceEdit.changes) { + Object.keys(workspaceEdit.changes).forEach(function (key) { + let textEditChange = new TextEditChangeImpl( + workspaceEdit.changes[key] + ); + _this._textEditChanges[key] = textEditChange; + }); + } + } else { + this._workspaceEdit = {}; + } + } + Object.defineProperty(WorkspaceChange2.prototype, 'edit', { + get: function () { + this.initDocumentChanges(); + if (this._changeAnnotations !== void 0) { + if (this._changeAnnotations.size === 0) { + this._workspaceEdit.changeAnnotations = void 0; + } else { + this._workspaceEdit.changeAnnotations = this._changeAnnotations.all(); + } + } + return this._workspaceEdit; + }, + enumerable: false, + configurable: true, + }); + WorkspaceChange2.prototype.getTextEditChange = function (key) { + if (OptionalVersionedTextDocumentIdentifier.is(key)) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let textDocument = { uri: key.uri, version: key.version }; + var result = this._textEditChanges[textDocument.uri]; + if (!result) { + var edits = []; + let textDocumentEdit = { + textDocument, + edits, + }; + this._workspaceEdit.documentChanges.push(textDocumentEdit); + result = new TextEditChangeImpl(edits, this._changeAnnotations); + this._textEditChanges[textDocument.uri] = result; + } + return result; + } else { + this.initChanges(); + if (this._workspaceEdit.changes === void 0) { + throw new Error( + 'Workspace edit is not configured for normal text edit changes.' + ); + } + var result = this._textEditChanges[key]; + if (!result) { + var edits = []; + this._workspaceEdit.changes[key] = edits; + result = new TextEditChangeImpl(edits); + this._textEditChanges[key] = result; + } + return result; + } + }; + WorkspaceChange2.prototype.initDocumentChanges = function () { + if ( + this._workspaceEdit.documentChanges === void 0 && + this._workspaceEdit.changes === void 0 + ) { + this._changeAnnotations = new ChangeAnnotations(); + this._workspaceEdit.documentChanges = []; + this._workspaceEdit.changeAnnotations = this._changeAnnotations.all(); + } + }; + WorkspaceChange2.prototype.initChanges = function () { + if ( + this._workspaceEdit.documentChanges === void 0 && + this._workspaceEdit.changes === void 0 + ) { + this._workspaceEdit.changes = Object.create(null); + } + }; + WorkspaceChange2.prototype.createFile = function ( + uri, + optionsOrAnnotation, + options + ) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let annotation; + if ( + ChangeAnnotation.is(optionsOrAnnotation) || + ChangeAnnotationIdentifier.is(optionsOrAnnotation) + ) { + annotation = optionsOrAnnotation; + } else { + options = optionsOrAnnotation; + } + let operation; + let id; + if (annotation === void 0) { + operation = CreateFile.create(uri, options); + } else { + id = ChangeAnnotationIdentifier.is(annotation) + ? annotation + : this._changeAnnotations.manage(annotation); + operation = CreateFile.create(uri, options, id); + } + this._workspaceEdit.documentChanges.push(operation); + if (id !== void 0) { + return id; + } + }; + WorkspaceChange2.prototype.renameFile = function ( + oldUri, + newUri, + optionsOrAnnotation, + options + ) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let annotation; + if ( + ChangeAnnotation.is(optionsOrAnnotation) || + ChangeAnnotationIdentifier.is(optionsOrAnnotation) + ) { + annotation = optionsOrAnnotation; + } else { + options = optionsOrAnnotation; + } + let operation; + let id; + if (annotation === void 0) { + operation = RenameFile.create(oldUri, newUri, options); + } else { + id = ChangeAnnotationIdentifier.is(annotation) + ? annotation + : this._changeAnnotations.manage(annotation); + operation = RenameFile.create(oldUri, newUri, options, id); + } + this._workspaceEdit.documentChanges.push(operation); + if (id !== void 0) { + return id; + } + }; + WorkspaceChange2.prototype.deleteFile = function ( + uri, + optionsOrAnnotation, + options + ) { + this.initDocumentChanges(); + if (this._workspaceEdit.documentChanges === void 0) { + throw new Error( + 'Workspace edit is not configured for document changes.' + ); + } + let annotation; + if ( + ChangeAnnotation.is(optionsOrAnnotation) || + ChangeAnnotationIdentifier.is(optionsOrAnnotation) + ) { + annotation = optionsOrAnnotation; + } else { + options = optionsOrAnnotation; + } + let operation; + let id; + if (annotation === void 0) { + operation = DeleteFile.create(uri, options); + } else { + id = ChangeAnnotationIdentifier.is(annotation) + ? annotation + : this._changeAnnotations.manage(annotation); + operation = DeleteFile.create(uri, options, id); + } + this._workspaceEdit.documentChanges.push(operation); + if (id !== void 0) { + return id; + } + }; + return WorkspaceChange2; + })(); + exports2.WorkspaceChange = WorkspaceChange; + let TextDocumentIdentifier; + (function (TextDocumentIdentifier2) { + function create(uri) { + return { uri }; + } + TextDocumentIdentifier2.create = create; + function is(value) { + let candidate = value; + return Is.defined(candidate) && Is.string(candidate.uri); + } + TextDocumentIdentifier2.is = is; + })( + (TextDocumentIdentifier = + exports2.TextDocumentIdentifier || + (exports2.TextDocumentIdentifier = {})) + ); + let VersionedTextDocumentIdentifier; + (function (VersionedTextDocumentIdentifier2) { + function create(uri, version) { + return { uri, version }; + } + VersionedTextDocumentIdentifier2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Is.string(candidate.uri) && + Is.integer(candidate.version) + ); + } + VersionedTextDocumentIdentifier2.is = is; + })( + (VersionedTextDocumentIdentifier = + exports2.VersionedTextDocumentIdentifier || + (exports2.VersionedTextDocumentIdentifier = {})) + ); + let OptionalVersionedTextDocumentIdentifier; + (function (OptionalVersionedTextDocumentIdentifier2) { + function create(uri, version) { + return { uri, version }; + } + OptionalVersionedTextDocumentIdentifier2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Is.string(candidate.uri) && + (candidate.version === null || Is.integer(candidate.version)) + ); + } + OptionalVersionedTextDocumentIdentifier2.is = is; + })( + (OptionalVersionedTextDocumentIdentifier = + exports2.OptionalVersionedTextDocumentIdentifier || + (exports2.OptionalVersionedTextDocumentIdentifier = {})) + ); + let TextDocumentItem; + (function (TextDocumentItem2) { + function create(uri, languageId, version, text) { + return { uri, languageId, version, text }; + } + TextDocumentItem2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Is.string(candidate.uri) && + Is.string(candidate.languageId) && + Is.integer(candidate.version) && + Is.string(candidate.text) + ); + } + TextDocumentItem2.is = is; + })( + (TextDocumentItem = + exports2.TextDocumentItem || (exports2.TextDocumentItem = {})) + ); + let MarkupKind; + (function (MarkupKind2) { + MarkupKind2.PlainText = 'plaintext'; + MarkupKind2.Markdown = 'markdown'; + })((MarkupKind = exports2.MarkupKind || (exports2.MarkupKind = {}))); + (function (MarkupKind2) { + function is(value) { + let candidate = value; + return ( + candidate === MarkupKind2.PlainText || + candidate === MarkupKind2.Markdown + ); + } + MarkupKind2.is = is; + })((MarkupKind = exports2.MarkupKind || (exports2.MarkupKind = {}))); + let MarkupContent; + (function (MarkupContent2) { + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(value) && + MarkupKind.is(candidate.kind) && + Is.string(candidate.value) + ); + } + MarkupContent2.is = is; + })( + (MarkupContent = + exports2.MarkupContent || (exports2.MarkupContent = {})) + ); + let CompletionItemKind2; + (function (CompletionItemKind3) { + CompletionItemKind3.Text = 1; + CompletionItemKind3.Method = 2; + CompletionItemKind3.Function = 3; + CompletionItemKind3.Constructor = 4; + CompletionItemKind3.Field = 5; + CompletionItemKind3.Variable = 6; + CompletionItemKind3.Class = 7; + CompletionItemKind3.Interface = 8; + CompletionItemKind3.Module = 9; + CompletionItemKind3.Property = 10; + CompletionItemKind3.Unit = 11; + CompletionItemKind3.Value = 12; + CompletionItemKind3.Enum = 13; + CompletionItemKind3.Keyword = 14; + CompletionItemKind3.Snippet = 15; + CompletionItemKind3.Color = 16; + CompletionItemKind3.File = 17; + CompletionItemKind3.Reference = 18; + CompletionItemKind3.Folder = 19; + CompletionItemKind3.EnumMember = 20; + CompletionItemKind3.Constant = 21; + CompletionItemKind3.Struct = 22; + CompletionItemKind3.Event = 23; + CompletionItemKind3.Operator = 24; + CompletionItemKind3.TypeParameter = 25; + })( + (CompletionItemKind2 = + exports2.CompletionItemKind || (exports2.CompletionItemKind = {})) + ); + let InsertTextFormat; + (function (InsertTextFormat2) { + InsertTextFormat2.PlainText = 1; + InsertTextFormat2.Snippet = 2; + })( + (InsertTextFormat = + exports2.InsertTextFormat || (exports2.InsertTextFormat = {})) + ); + let CompletionItemTag; + (function (CompletionItemTag2) { + CompletionItemTag2.Deprecated = 1; + })( + (CompletionItemTag = + exports2.CompletionItemTag || (exports2.CompletionItemTag = {})) + ); + let InsertReplaceEdit; + (function (InsertReplaceEdit2) { + function create(newText, insert, replace) { + return { newText, insert, replace }; + } + InsertReplaceEdit2.create = create; + function is(value) { + let candidate = value; + return ( + candidate && + Is.string(candidate.newText) && + Range4.is(candidate.insert) && + Range4.is(candidate.replace) + ); + } + InsertReplaceEdit2.is = is; + })( + (InsertReplaceEdit = + exports2.InsertReplaceEdit || (exports2.InsertReplaceEdit = {})) + ); + let InsertTextMode; + (function (InsertTextMode2) { + InsertTextMode2.asIs = 1; + InsertTextMode2.adjustIndentation = 2; + })( + (InsertTextMode = + exports2.InsertTextMode || (exports2.InsertTextMode = {})) + ); + let CompletionItemLabelDetails; + (function (CompletionItemLabelDetails2) { + function is(value) { + let candidate = value; + return ( + candidate && + (Is.string(candidate.detail) || candidate.detail === void 0) && + (Is.string(candidate.description) || + candidate.description === void 0) + ); + } + CompletionItemLabelDetails2.is = is; + })( + (CompletionItemLabelDetails = + exports2.CompletionItemLabelDetails || + (exports2.CompletionItemLabelDetails = {})) + ); + let CompletionItem; + (function (CompletionItem2) { + function create(label) { + return { label }; + } + CompletionItem2.create = create; + })( + (CompletionItem = + exports2.CompletionItem || (exports2.CompletionItem = {})) + ); + let CompletionList; + (function (CompletionList2) { + function create(items, isIncomplete) { + return { items: items ? items : [], isIncomplete: !!isIncomplete }; + } + CompletionList2.create = create; + })( + (CompletionList = + exports2.CompletionList || (exports2.CompletionList = {})) + ); + let MarkedString; + (function (MarkedString2) { + function fromPlainText(plainText) { + return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); + } + MarkedString2.fromPlainText = fromPlainText; + function is(value) { + let candidate = value; + return ( + Is.string(candidate) || + (Is.objectLiteral(candidate) && + Is.string(candidate.language) && + Is.string(candidate.value)) + ); + } + MarkedString2.is = is; + })( + (MarkedString = exports2.MarkedString || (exports2.MarkedString = {})) + ); + let Hover; + (function (Hover2) { + function is(value) { + let candidate = value; + return ( + !!candidate && + Is.objectLiteral(candidate) && + (MarkupContent.is(candidate.contents) || + MarkedString.is(candidate.contents) || + Is.typedArray(candidate.contents, MarkedString.is)) && + (value.range === void 0 || Range4.is(value.range)) + ); + } + Hover2.is = is; + })((Hover = exports2.Hover || (exports2.Hover = {}))); + let ParameterInformation; + (function (ParameterInformation2) { + function create(label, documentation) { + return documentation ? { label, documentation } : { label }; + } + ParameterInformation2.create = create; + })( + (ParameterInformation = + exports2.ParameterInformation || + (exports2.ParameterInformation = {})) + ); + let SignatureInformation; + (function (SignatureInformation2) { + function create(label, documentation) { + let parameters = []; + for (let _i = 2; _i < arguments.length; _i++) { + parameters[_i - 2] = arguments[_i]; + } + let result = { label }; + if (Is.defined(documentation)) { + result.documentation = documentation; + } + if (Is.defined(parameters)) { + result.parameters = parameters; + } else { + result.parameters = []; + } + return result; + } + SignatureInformation2.create = create; + })( + (SignatureInformation = + exports2.SignatureInformation || + (exports2.SignatureInformation = {})) + ); + let DocumentHighlightKind2; + (function (DocumentHighlightKind3) { + DocumentHighlightKind3.Text = 1; + DocumentHighlightKind3.Read = 2; + DocumentHighlightKind3.Write = 3; + })( + (DocumentHighlightKind2 = + exports2.DocumentHighlightKind || + (exports2.DocumentHighlightKind = {})) + ); + let DocumentHighlight2; + (function (DocumentHighlight3) { + function create(range, kind) { + let result = { range }; + if (Is.number(kind)) { + result.kind = kind; + } + return result; + } + DocumentHighlight3.create = create; + })( + (DocumentHighlight2 = + exports2.DocumentHighlight || (exports2.DocumentHighlight = {})) + ); + let SymbolKind4; + (function (SymbolKind5) { + SymbolKind5.File = 1; + SymbolKind5.Module = 2; + SymbolKind5.Namespace = 3; + SymbolKind5.Package = 4; + SymbolKind5.Class = 5; + SymbolKind5.Method = 6; + SymbolKind5.Property = 7; + SymbolKind5.Field = 8; + SymbolKind5.Constructor = 9; + SymbolKind5.Enum = 10; + SymbolKind5.Interface = 11; + SymbolKind5.Function = 12; + SymbolKind5.Variable = 13; + SymbolKind5.Constant = 14; + SymbolKind5.String = 15; + SymbolKind5.Number = 16; + SymbolKind5.Boolean = 17; + SymbolKind5.Array = 18; + SymbolKind5.Object = 19; + SymbolKind5.Key = 20; + SymbolKind5.Null = 21; + SymbolKind5.EnumMember = 22; + SymbolKind5.Struct = 23; + SymbolKind5.Event = 24; + SymbolKind5.Operator = 25; + SymbolKind5.TypeParameter = 26; + })((SymbolKind4 = exports2.SymbolKind || (exports2.SymbolKind = {}))); + let SymbolTag; + (function (SymbolTag2) { + SymbolTag2.Deprecated = 1; + })((SymbolTag = exports2.SymbolTag || (exports2.SymbolTag = {}))); + let SymbolInformation3; + (function (SymbolInformation4) { + function create(name, kind, range, uri, containerName) { + let result = { + name, + kind, + location: { uri, range }, + }; + if (containerName) { + result.containerName = containerName; + } + return result; + } + SymbolInformation4.create = create; + })( + (SymbolInformation3 = + exports2.SymbolInformation || (exports2.SymbolInformation = {})) + ); + let WorkspaceSymbol3; + (function (WorkspaceSymbol4) { + function create(name, kind, uri, range) { + return range !== void 0 + ? { name, kind, location: { uri, range } } + : { name, kind, location: { uri } }; + } + WorkspaceSymbol4.create = create; + })( + (WorkspaceSymbol3 = + exports2.WorkspaceSymbol || (exports2.WorkspaceSymbol = {})) + ); + let DocumentSymbol2; + (function (DocumentSymbol3) { + function create(name, detail, kind, range, selectionRange, children) { + let result = { + name, + detail, + kind, + range, + selectionRange, + }; + if (children !== void 0) { + result.children = children; + } + return result; + } + DocumentSymbol3.create = create; + function is(value) { + let candidate = value; + return ( + candidate && + Is.string(candidate.name) && + Is.number(candidate.kind) && + Range4.is(candidate.range) && + Range4.is(candidate.selectionRange) && + (candidate.detail === void 0 || Is.string(candidate.detail)) && + (candidate.deprecated === void 0 || + Is.boolean(candidate.deprecated)) && + (candidate.children === void 0 || + Array.isArray(candidate.children)) && + (candidate.tags === void 0 || Array.isArray(candidate.tags)) + ); + } + DocumentSymbol3.is = is; + })( + (DocumentSymbol2 = + exports2.DocumentSymbol || (exports2.DocumentSymbol = {})) + ); + let CodeActionKind; + (function (CodeActionKind2) { + CodeActionKind2.Empty = ''; + CodeActionKind2.QuickFix = 'quickfix'; + CodeActionKind2.Refactor = 'refactor'; + CodeActionKind2.RefactorExtract = 'refactor.extract'; + CodeActionKind2.RefactorInline = 'refactor.inline'; + CodeActionKind2.RefactorRewrite = 'refactor.rewrite'; + CodeActionKind2.Source = 'source'; + CodeActionKind2.SourceOrganizeImports = 'source.organizeImports'; + CodeActionKind2.SourceFixAll = 'source.fixAll'; + })( + (CodeActionKind = + exports2.CodeActionKind || (exports2.CodeActionKind = {})) + ); + let CodeActionTriggerKind; + (function (CodeActionTriggerKind2) { + CodeActionTriggerKind2.Invoked = 1; + CodeActionTriggerKind2.Automatic = 2; + })( + (CodeActionTriggerKind = + exports2.CodeActionTriggerKind || + (exports2.CodeActionTriggerKind = {})) + ); + let CodeActionContext; + (function (CodeActionContext2) { + function create(diagnostics, only, triggerKind) { + let result = { diagnostics }; + if (only !== void 0 && only !== null) { + result.only = only; + } + if (triggerKind !== void 0 && triggerKind !== null) { + result.triggerKind = triggerKind; + } + return result; + } + CodeActionContext2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Is.typedArray(candidate.diagnostics, Diagnostic2.is) && + (candidate.only === void 0 || + Is.typedArray(candidate.only, Is.string)) && + (candidate.triggerKind === void 0 || + candidate.triggerKind === CodeActionTriggerKind.Invoked || + candidate.triggerKind === CodeActionTriggerKind.Automatic) + ); + } + CodeActionContext2.is = is; + })( + (CodeActionContext = + exports2.CodeActionContext || (exports2.CodeActionContext = {})) + ); + let CodeAction; + (function (CodeAction2) { + function create(title, kindOrCommandOrEdit, kind) { + let result = { title }; + let checkKind = true; + if (typeof kindOrCommandOrEdit === 'string') { + checkKind = false; + result.kind = kindOrCommandOrEdit; + } else if (Command.is(kindOrCommandOrEdit)) { + result.command = kindOrCommandOrEdit; + } else { + result.edit = kindOrCommandOrEdit; + } + if (checkKind && kind !== void 0) { + result.kind = kind; + } + return result; + } + CodeAction2.create = create; + function is(value) { + let candidate = value; + return ( + candidate && + Is.string(candidate.title) && + (candidate.diagnostics === void 0 || + Is.typedArray(candidate.diagnostics, Diagnostic2.is)) && + (candidate.kind === void 0 || Is.string(candidate.kind)) && + (candidate.edit !== void 0 || candidate.command !== void 0) && + (candidate.command === void 0 || Command.is(candidate.command)) && + (candidate.isPreferred === void 0 || + Is.boolean(candidate.isPreferred)) && + (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit)) + ); + } + CodeAction2.is = is; + })((CodeAction = exports2.CodeAction || (exports2.CodeAction = {}))); + let CodeLens; + (function (CodeLens2) { + function create(range, data) { + let result = { range }; + if (Is.defined(data)) { + result.data = data; + } + return result; + } + CodeLens2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Range4.is(candidate.range) && + (Is.undefined(candidate.command) || Command.is(candidate.command)) + ); + } + CodeLens2.is = is; + })((CodeLens = exports2.CodeLens || (exports2.CodeLens = {}))); + let FormattingOptions; + (function (FormattingOptions2) { + function create(tabSize, insertSpaces) { + return { tabSize, insertSpaces }; + } + FormattingOptions2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Is.uinteger(candidate.tabSize) && + Is.boolean(candidate.insertSpaces) + ); + } + FormattingOptions2.is = is; + })( + (FormattingOptions = + exports2.FormattingOptions || (exports2.FormattingOptions = {})) + ); + let DocumentLink; + (function (DocumentLink2) { + function create(range, target, data) { + return { range, target, data }; + } + DocumentLink2.create = create; + function is(value) { + let candidate = value; + return ( + Is.defined(candidate) && + Range4.is(candidate.range) && + (Is.undefined(candidate.target) || Is.string(candidate.target)) + ); + } + DocumentLink2.is = is; + })( + (DocumentLink = exports2.DocumentLink || (exports2.DocumentLink = {})) + ); + let SelectionRange2; + (function (SelectionRange3) { + function create(range, parent) { + return { range, parent }; + } + SelectionRange3.create = create; + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + Range4.is(candidate.range) && + (candidate.parent === void 0 || + SelectionRange3.is(candidate.parent)) + ); + } + SelectionRange3.is = is; + })( + (SelectionRange2 = + exports2.SelectionRange || (exports2.SelectionRange = {})) + ); + let SemanticTokenTypes; + (function (SemanticTokenTypes2) { + SemanticTokenTypes2['namespace'] = 'namespace'; + SemanticTokenTypes2['type'] = 'type'; + SemanticTokenTypes2['class'] = 'class'; + SemanticTokenTypes2['enum'] = 'enum'; + SemanticTokenTypes2['interface'] = 'interface'; + SemanticTokenTypes2['struct'] = 'struct'; + SemanticTokenTypes2['typeParameter'] = 'typeParameter'; + SemanticTokenTypes2['parameter'] = 'parameter'; + SemanticTokenTypes2['variable'] = 'variable'; + SemanticTokenTypes2['property'] = 'property'; + SemanticTokenTypes2['enumMember'] = 'enumMember'; + SemanticTokenTypes2['event'] = 'event'; + SemanticTokenTypes2['function'] = 'function'; + SemanticTokenTypes2['method'] = 'method'; + SemanticTokenTypes2['macro'] = 'macro'; + SemanticTokenTypes2['keyword'] = 'keyword'; + SemanticTokenTypes2['modifier'] = 'modifier'; + SemanticTokenTypes2['comment'] = 'comment'; + SemanticTokenTypes2['string'] = 'string'; + SemanticTokenTypes2['number'] = 'number'; + SemanticTokenTypes2['regexp'] = 'regexp'; + SemanticTokenTypes2['operator'] = 'operator'; + SemanticTokenTypes2['decorator'] = 'decorator'; + })( + (SemanticTokenTypes = + exports2.SemanticTokenTypes || (exports2.SemanticTokenTypes = {})) + ); + let SemanticTokenModifiers; + (function (SemanticTokenModifiers2) { + SemanticTokenModifiers2['declaration'] = 'declaration'; + SemanticTokenModifiers2['definition'] = 'definition'; + SemanticTokenModifiers2['readonly'] = 'readonly'; + SemanticTokenModifiers2['static'] = 'static'; + SemanticTokenModifiers2['deprecated'] = 'deprecated'; + SemanticTokenModifiers2['abstract'] = 'abstract'; + SemanticTokenModifiers2['async'] = 'async'; + SemanticTokenModifiers2['modification'] = 'modification'; + SemanticTokenModifiers2['documentation'] = 'documentation'; + SemanticTokenModifiers2['defaultLibrary'] = 'defaultLibrary'; + })( + (SemanticTokenModifiers = + exports2.SemanticTokenModifiers || + (exports2.SemanticTokenModifiers = {})) + ); + let SemanticTokens; + (function (SemanticTokens2) { + function is(value) { + let candidate = value; + return ( + Is.objectLiteral(candidate) && + (candidate.resultId === void 0 || + typeof candidate.resultId === 'string') && + Array.isArray(candidate.data) && + (candidate.data.length === 0 || + typeof candidate.data[0] === 'number') + ); + } + SemanticTokens2.is = is; + })( + (SemanticTokens = + exports2.SemanticTokens || (exports2.SemanticTokens = {})) + ); + let InlineValueText; + (function (InlineValueText2) { + function create(range, text) { + return { range, text }; + } + InlineValueText2.create = create; + function is(value) { + let candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + Range4.is(candidate.range) && + Is.string(candidate.text) + ); + } + InlineValueText2.is = is; + })( + (InlineValueText = + exports2.InlineValueText || (exports2.InlineValueText = {})) + ); + let InlineValueVariableLookup; + (function (InlineValueVariableLookup2) { + function create(range, variableName, caseSensitiveLookup) { + return { range, variableName, caseSensitiveLookup }; + } + InlineValueVariableLookup2.create = create; + function is(value) { + let candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + Range4.is(candidate.range) && + Is.boolean(candidate.caseSensitiveLookup) && + (Is.string(candidate.variableName) || + candidate.variableName === void 0) + ); + } + InlineValueVariableLookup2.is = is; + })( + (InlineValueVariableLookup = + exports2.InlineValueVariableLookup || + (exports2.InlineValueVariableLookup = {})) + ); + let InlineValueEvaluatableExpression; + (function (InlineValueEvaluatableExpression2) { + function create(range, expression) { + return { range, expression }; + } + InlineValueEvaluatableExpression2.create = create; + function is(value) { + let candidate = value; + return ( + candidate !== void 0 && + candidate !== null && + Range4.is(candidate.range) && + (Is.string(candidate.expression) || + candidate.expression === void 0) + ); + } + InlineValueEvaluatableExpression2.is = is; + })( + (InlineValueEvaluatableExpression = + exports2.InlineValueEvaluatableExpression || + (exports2.InlineValueEvaluatableExpression = {})) + ); + let InlineValuesContext; + (function (InlineValuesContext2) { + function create(stoppedLocation) { + return { stoppedLocation }; + } + InlineValuesContext2.create = create; + function is(value) { + let candidate = value; + return Is.defined(candidate) && Range4.is(value.stoppedLocation); + } + InlineValuesContext2.is = is; + })( + (InlineValuesContext = + exports2.InlineValuesContext || (exports2.InlineValuesContext = {})) + ); + exports2.EOL = ['\n', '\r\n', '\r']; + let TextDocument2; + (function (TextDocument3) { + function create(uri, languageId, version, content) { + return new FullTextDocument2(uri, languageId, version, content); + } + TextDocument3.create = create; + function is(value) { + let candidate = value; + return Is.defined(candidate) && + Is.string(candidate.uri) && + (Is.undefined(candidate.languageId) || + Is.string(candidate.languageId)) && + Is.uinteger(candidate.lineCount) && + Is.func(candidate.getText) && + Is.func(candidate.positionAt) && + Is.func(candidate.offsetAt) + ? true + : false; + } + TextDocument3.is = is; + function applyEdits(document2, edits) { + let text = document2.getText(); + let sortedEdits = mergeSort2(edits, function (a, b) { + let diff = a.range.start.line - b.range.start.line; + if (diff === 0) { + return a.range.start.character - b.range.start.character; + } + return diff; + }); + let lastModifiedOffset = text.length; + for (let i = sortedEdits.length - 1; i >= 0; i--) { + let e = sortedEdits[i]; + let startOffset = document2.offsetAt(e.range.start); + let endOffset = document2.offsetAt(e.range.end); + if (endOffset <= lastModifiedOffset) { + text = + text.substring(0, startOffset) + + e.newText + + text.substring(endOffset, text.length); + } else { + throw new Error('Overlapping edit'); + } + lastModifiedOffset = startOffset; + } + return text; + } + TextDocument3.applyEdits = applyEdits; + function mergeSort2(data, compare) { + if (data.length <= 1) { + return data; + } + let p = (data.length / 2) | 0; + let left = data.slice(0, p); + let right = data.slice(p); + mergeSort2(left, compare); + mergeSort2(right, compare); + let leftIdx = 0; + let rightIdx = 0; + let i = 0; + while (leftIdx < left.length && rightIdx < right.length) { + let ret = compare(left[leftIdx], right[rightIdx]); + if (ret <= 0) { + data[i++] = left[leftIdx++]; + } else { + data[i++] = right[rightIdx++]; + } + } + while (leftIdx < left.length) { + data[i++] = left[leftIdx++]; + } + while (rightIdx < right.length) { + data[i++] = right[rightIdx++]; + } + return data; + } + })( + (TextDocument2 = + exports2.TextDocument || (exports2.TextDocument = {})) + ); + var FullTextDocument2 = (function () { + function FullTextDocument3(uri, languageId, version, content) { + this._uri = uri; + this._languageId = languageId; + this._version = version; + this._content = content; + this._lineOffsets = void 0; + } + Object.defineProperty(FullTextDocument3.prototype, 'uri', { + get: function () { + return this._uri; + }, + enumerable: false, + configurable: true, + }); + Object.defineProperty(FullTextDocument3.prototype, 'languageId', { + get: function () { + return this._languageId; + }, + enumerable: false, + configurable: true, + }); + Object.defineProperty(FullTextDocument3.prototype, 'version', { + get: function () { + return this._version; + }, + enumerable: false, + configurable: true, + }); + FullTextDocument3.prototype.getText = function (range) { + if (range) { + let start = this.offsetAt(range.start); + let end = this.offsetAt(range.end); + return this._content.substring(start, end); + } + return this._content; + }; + FullTextDocument3.prototype.update = function (event, version) { + this._content = event.text; + this._version = version; + this._lineOffsets = void 0; + }; + FullTextDocument3.prototype.getLineOffsets = function () { + if (this._lineOffsets === void 0) { + let lineOffsets = []; + let text = this._content; + let isLineStart = true; + for (let i = 0; i < text.length; i++) { + if (isLineStart) { + lineOffsets.push(i); + isLineStart = false; + } + let ch = text.charAt(i); + isLineStart = ch === '\r' || ch === '\n'; + if ( + ch === '\r' && + i + 1 < text.length && + text.charAt(i + 1) === '\n' + ) { + i++; + } + } + if (isLineStart && text.length > 0) { + lineOffsets.push(text.length); + } + this._lineOffsets = lineOffsets; + } + return this._lineOffsets; + }; + FullTextDocument3.prototype.positionAt = function (offset) { + offset = Math.max(Math.min(offset, this._content.length), 0); + let lineOffsets = this.getLineOffsets(); + let low = 0, + high = lineOffsets.length; + if (high === 0) { + return Position.create(0, offset); + } + while (low < high) { + let mid = Math.floor((low + high) / 2); + if (lineOffsets[mid] > offset) { + high = mid; + } else { + low = mid + 1; + } + } + let line = low - 1; + return Position.create(line, offset - lineOffsets[line]); + }; + FullTextDocument3.prototype.offsetAt = function (position) { + let lineOffsets = this.getLineOffsets(); + if (position.line >= lineOffsets.length) { + return this._content.length; + } else if (position.line < 0) { + return 0; + } + let lineOffset = lineOffsets[position.line]; + let nextLineOffset = + position.line + 1 < lineOffsets.length + ? lineOffsets[position.line + 1] + : this._content.length; + return Math.max( + Math.min(lineOffset + position.character, nextLineOffset), + lineOffset + ); + }; + Object.defineProperty(FullTextDocument3.prototype, 'lineCount', { + get: function () { + return this.getLineOffsets().length; + }, + enumerable: false, + configurable: true, + }); + return FullTextDocument3; + })(); + let Is; + (function (Is2) { + let toString = Object.prototype.toString; + function defined(value) { + return typeof value !== 'undefined'; + } + Is2.defined = defined; + function undefined2(value) { + return typeof value === 'undefined'; + } + Is2.undefined = undefined2; + function boolean(value) { + return value === true || value === false; + } + Is2.boolean = boolean; + function string(value) { + return toString.call(value) === '[object String]'; + } + Is2.string = string; + function number(value) { + return toString.call(value) === '[object Number]'; + } + Is2.number = number; + function numberRange(value, min, max) { + return ( + toString.call(value) === '[object Number]' && + min <= value && + value <= max + ); + } + Is2.numberRange = numberRange; + function integer2(value) { + return ( + toString.call(value) === '[object Number]' && + -2147483648 <= value && + value <= 2147483647 + ); + } + Is2.integer = integer2; + function uinteger2(value) { + return ( + toString.call(value) === '[object Number]' && + 0 <= value && + value <= 2147483647 + ); + } + Is2.uinteger = uinteger2; + function func(value) { + return toString.call(value) === '[object Function]'; + } + Is2.func = func; + function objectLiteral(value) { + return value !== null && typeof value === 'object'; + } + Is2.objectLiteral = objectLiteral; + function typedArray(value, check) { + return Array.isArray(value) && value.every(check); + } + Is2.typedArray = typedArray; + })(Is || (Is = {})); + }); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/messages.js + let require_messages2 = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/messages.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = void 0; + let vscode_jsonrpc_1 = require_main(); + let RegistrationType = class { + constructor(method) { + this.method = method; + } + }; + exports.RegistrationType = RegistrationType; + let ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 { + constructor(method) { + super(method); + } + }; + exports.ProtocolRequestType0 = ProtocolRequestType0; + let ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType { + constructor(method) { + super(method, vscode_jsonrpc_1.ParameterStructures.byName); + } + }; + exports.ProtocolRequestType = ProtocolRequestType; + let ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 { + constructor(method) { + super(method); + } + }; + exports.ProtocolNotificationType0 = ProtocolNotificationType0; + let ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType { + constructor(method) { + super(method, vscode_jsonrpc_1.ParameterStructures.byName); + } + }; + exports.ProtocolNotificationType = ProtocolNotificationType; + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js + let require_is2 = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.objectLiteral = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0; + function boolean(value) { + return value === true || value === false; + } + exports.boolean = boolean; + function string(value) { + return typeof value === 'string' || value instanceof String; + } + exports.string = string; + function number(value) { + return typeof value === 'number' || value instanceof Number; + } + exports.number = number; + function error(value) { + return value instanceof Error; + } + exports.error = error; + function func(value) { + return typeof value === 'function'; + } + exports.func = func; + function array(value) { + return Array.isArray(value); + } + exports.array = array; + function stringArray(value) { + return array(value) && value.every((elem) => string(elem)); + } + exports.stringArray = stringArray; + function typedArray(value, check) { + return Array.isArray(value) && value.every(check); + } + exports.typedArray = typedArray; + function objectLiteral(value) { + return value !== null && typeof value === 'object'; + } + exports.objectLiteral = objectLiteral; + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js + let require_protocol_implementation = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ImplementationRequest = void 0; + let messages_1 = require_messages2(); + let ImplementationRequest; + (function (ImplementationRequest2) { + ImplementationRequest2.method = 'textDocument/implementation'; + ImplementationRequest2.type = new messages_1.ProtocolRequestType( + ImplementationRequest2.method + ); + })( + (ImplementationRequest = + exports.ImplementationRequest || (exports.ImplementationRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js + let require_protocol_typeDefinition = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeDefinitionRequest = void 0; + let messages_1 = require_messages2(); + let TypeDefinitionRequest; + (function (TypeDefinitionRequest2) { + TypeDefinitionRequest2.method = 'textDocument/typeDefinition'; + TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType( + TypeDefinitionRequest2.method + ); + })( + (TypeDefinitionRequest = + exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js + let require_protocol_workspaceFolders = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0; + let messages_1 = require_messages2(); + let WorkspaceFoldersRequest; + (function (WorkspaceFoldersRequest2) { + WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0( + 'workspace/workspaceFolders' + ); + })( + (WorkspaceFoldersRequest = + exports.WorkspaceFoldersRequest || + (exports.WorkspaceFoldersRequest = {})) + ); + let DidChangeWorkspaceFoldersNotification; + (function (DidChangeWorkspaceFoldersNotification2) { + DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType( + 'workspace/didChangeWorkspaceFolders' + ); + })( + (DidChangeWorkspaceFoldersNotification = + exports.DidChangeWorkspaceFoldersNotification || + (exports.DidChangeWorkspaceFoldersNotification = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js + let require_protocol_configuration = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ConfigurationRequest = void 0; + let messages_1 = require_messages2(); + let ConfigurationRequest; + (function (ConfigurationRequest2) { + ConfigurationRequest2.type = new messages_1.ProtocolRequestType( + 'workspace/configuration' + ); + })( + (ConfigurationRequest = + exports.ConfigurationRequest || (exports.ConfigurationRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js + let require_protocol_colorProvider = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ColorPresentationRequest = exports.DocumentColorRequest = void 0; + let messages_1 = require_messages2(); + let DocumentColorRequest; + (function (DocumentColorRequest2) { + DocumentColorRequest2.method = 'textDocument/documentColor'; + DocumentColorRequest2.type = new messages_1.ProtocolRequestType( + DocumentColorRequest2.method + ); + })( + (DocumentColorRequest = + exports.DocumentColorRequest || (exports.DocumentColorRequest = {})) + ); + let ColorPresentationRequest; + (function (ColorPresentationRequest2) { + ColorPresentationRequest2.type = new messages_1.ProtocolRequestType( + 'textDocument/colorPresentation' + ); + })( + (ColorPresentationRequest = + exports.ColorPresentationRequest || + (exports.ColorPresentationRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js + let require_protocol_foldingRange = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.FoldingRangeRequest = exports.FoldingRangeKind = void 0; + let messages_1 = require_messages2(); + let FoldingRangeKind; + (function (FoldingRangeKind2) { + FoldingRangeKind2['Comment'] = 'comment'; + FoldingRangeKind2['Imports'] = 'imports'; + FoldingRangeKind2['Region'] = 'region'; + })( + (FoldingRangeKind = + exports.FoldingRangeKind || (exports.FoldingRangeKind = {})) + ); + let FoldingRangeRequest2; + (function (FoldingRangeRequest3) { + FoldingRangeRequest3.method = 'textDocument/foldingRange'; + FoldingRangeRequest3.type = new messages_1.ProtocolRequestType( + FoldingRangeRequest3.method + ); + })( + (FoldingRangeRequest2 = + exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js + let require_protocol_declaration = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DeclarationRequest = void 0; + let messages_1 = require_messages2(); + let DeclarationRequest; + (function (DeclarationRequest2) { + DeclarationRequest2.method = 'textDocument/declaration'; + DeclarationRequest2.type = new messages_1.ProtocolRequestType( + DeclarationRequest2.method + ); + })( + (DeclarationRequest = + exports.DeclarationRequest || (exports.DeclarationRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js + let require_protocol_selectionRange = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SelectionRangeRequest = void 0; + let messages_1 = require_messages2(); + let SelectionRangeRequest2; + (function (SelectionRangeRequest3) { + SelectionRangeRequest3.method = 'textDocument/selectionRange'; + SelectionRangeRequest3.type = new messages_1.ProtocolRequestType( + SelectionRangeRequest3.method + ); + })( + (SelectionRangeRequest2 = + exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js + let require_protocol_progress = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0; + let vscode_jsonrpc_1 = require_main(); + let messages_1 = require_messages2(); + let WorkDoneProgress; + (function (WorkDoneProgress2) { + WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType(); + function is(value) { + return value === WorkDoneProgress2.type; + } + WorkDoneProgress2.is = is; + })( + (WorkDoneProgress = + exports.WorkDoneProgress || (exports.WorkDoneProgress = {})) + ); + let WorkDoneProgressCreateRequest; + (function (WorkDoneProgressCreateRequest2) { + WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType( + 'window/workDoneProgress/create' + ); + })( + (WorkDoneProgressCreateRequest = + exports.WorkDoneProgressCreateRequest || + (exports.WorkDoneProgressCreateRequest = {})) + ); + let WorkDoneProgressCancelNotification; + (function (WorkDoneProgressCancelNotification2) { + WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType( + 'window/workDoneProgress/cancel' + ); + })( + (WorkDoneProgressCancelNotification = + exports.WorkDoneProgressCancelNotification || + (exports.WorkDoneProgressCancelNotification = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js + let require_protocol_callHierarchy = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0; + let messages_1 = require_messages2(); + let CallHierarchyPrepareRequest; + (function (CallHierarchyPrepareRequest2) { + CallHierarchyPrepareRequest2.method = + 'textDocument/prepareCallHierarchy'; + CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType( + CallHierarchyPrepareRequest2.method + ); + })( + (CallHierarchyPrepareRequest = + exports.CallHierarchyPrepareRequest || + (exports.CallHierarchyPrepareRequest = {})) + ); + let CallHierarchyIncomingCallsRequest; + (function (CallHierarchyIncomingCallsRequest2) { + CallHierarchyIncomingCallsRequest2.method = + 'callHierarchy/incomingCalls'; + CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType( + CallHierarchyIncomingCallsRequest2.method + ); + })( + (CallHierarchyIncomingCallsRequest = + exports.CallHierarchyIncomingCallsRequest || + (exports.CallHierarchyIncomingCallsRequest = {})) + ); + let CallHierarchyOutgoingCallsRequest; + (function (CallHierarchyOutgoingCallsRequest2) { + CallHierarchyOutgoingCallsRequest2.method = + 'callHierarchy/outgoingCalls'; + CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType( + CallHierarchyOutgoingCallsRequest2.method + ); + })( + (CallHierarchyOutgoingCallsRequest = + exports.CallHierarchyOutgoingCallsRequest || + (exports.CallHierarchyOutgoingCallsRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js + let require_protocol_semanticTokens = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = void 0; + let messages_1 = require_messages2(); + let TokenFormat; + (function (TokenFormat2) { + TokenFormat2.Relative = 'relative'; + })((TokenFormat = exports.TokenFormat || (exports.TokenFormat = {}))); + let SemanticTokensRegistrationType; + (function (SemanticTokensRegistrationType2) { + SemanticTokensRegistrationType2.method = 'textDocument/semanticTokens'; + SemanticTokensRegistrationType2.type = new messages_1.RegistrationType( + SemanticTokensRegistrationType2.method + ); + })( + (SemanticTokensRegistrationType = + exports.SemanticTokensRegistrationType || + (exports.SemanticTokensRegistrationType = {})) + ); + let SemanticTokensRequest; + (function (SemanticTokensRequest2) { + SemanticTokensRequest2.method = 'textDocument/semanticTokens/full'; + SemanticTokensRequest2.type = new messages_1.ProtocolRequestType( + SemanticTokensRequest2.method + ); + })( + (SemanticTokensRequest = + exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {})) + ); + let SemanticTokensDeltaRequest; + (function (SemanticTokensDeltaRequest2) { + SemanticTokensDeltaRequest2.method = + 'textDocument/semanticTokens/full/delta'; + SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType( + SemanticTokensDeltaRequest2.method + ); + })( + (SemanticTokensDeltaRequest = + exports.SemanticTokensDeltaRequest || + (exports.SemanticTokensDeltaRequest = {})) + ); + let SemanticTokensRangeRequest; + (function (SemanticTokensRangeRequest2) { + SemanticTokensRangeRequest2.method = + 'textDocument/semanticTokens/range'; + SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType( + SemanticTokensRangeRequest2.method + ); + })( + (SemanticTokensRangeRequest = + exports.SemanticTokensRangeRequest || + (exports.SemanticTokensRangeRequest = {})) + ); + let SemanticTokensRefreshRequest; + (function (SemanticTokensRefreshRequest2) { + SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`; + SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0( + SemanticTokensRefreshRequest2.method + ); + })( + (SemanticTokensRefreshRequest = + exports.SemanticTokensRefreshRequest || + (exports.SemanticTokensRefreshRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js + let require_protocol_showDocument = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ShowDocumentRequest = void 0; + let messages_1 = require_messages2(); + let ShowDocumentRequest; + (function (ShowDocumentRequest2) { + ShowDocumentRequest2.method = 'window/showDocument'; + ShowDocumentRequest2.type = new messages_1.ProtocolRequestType( + ShowDocumentRequest2.method + ); + })( + (ShowDocumentRequest = + exports.ShowDocumentRequest || (exports.ShowDocumentRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js + let require_protocol_linkedEditingRange = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LinkedEditingRangeRequest = void 0; + let messages_1 = require_messages2(); + let LinkedEditingRangeRequest; + (function (LinkedEditingRangeRequest2) { + LinkedEditingRangeRequest2.method = 'textDocument/linkedEditingRange'; + LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType( + LinkedEditingRangeRequest2.method + ); + })( + (LinkedEditingRangeRequest = + exports.LinkedEditingRangeRequest || + (exports.LinkedEditingRangeRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js + let require_protocol_fileOperations = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0; + let messages_1 = require_messages2(); + let FileOperationPatternKind; + (function (FileOperationPatternKind2) { + FileOperationPatternKind2.file = 'file'; + FileOperationPatternKind2.folder = 'folder'; + })( + (FileOperationPatternKind = + exports.FileOperationPatternKind || + (exports.FileOperationPatternKind = {})) + ); + let WillCreateFilesRequest; + (function (WillCreateFilesRequest2) { + WillCreateFilesRequest2.method = 'workspace/willCreateFiles'; + WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType( + WillCreateFilesRequest2.method + ); + })( + (WillCreateFilesRequest = + exports.WillCreateFilesRequest || + (exports.WillCreateFilesRequest = {})) + ); + let DidCreateFilesNotification; + (function (DidCreateFilesNotification2) { + DidCreateFilesNotification2.method = 'workspace/didCreateFiles'; + DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType( + DidCreateFilesNotification2.method + ); + })( + (DidCreateFilesNotification = + exports.DidCreateFilesNotification || + (exports.DidCreateFilesNotification = {})) + ); + let WillRenameFilesRequest; + (function (WillRenameFilesRequest2) { + WillRenameFilesRequest2.method = 'workspace/willRenameFiles'; + WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType( + WillRenameFilesRequest2.method + ); + })( + (WillRenameFilesRequest = + exports.WillRenameFilesRequest || + (exports.WillRenameFilesRequest = {})) + ); + let DidRenameFilesNotification; + (function (DidRenameFilesNotification2) { + DidRenameFilesNotification2.method = 'workspace/didRenameFiles'; + DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType( + DidRenameFilesNotification2.method + ); + })( + (DidRenameFilesNotification = + exports.DidRenameFilesNotification || + (exports.DidRenameFilesNotification = {})) + ); + let DidDeleteFilesNotification; + (function (DidDeleteFilesNotification2) { + DidDeleteFilesNotification2.method = 'workspace/didDeleteFiles'; + DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType( + DidDeleteFilesNotification2.method + ); + })( + (DidDeleteFilesNotification = + exports.DidDeleteFilesNotification || + (exports.DidDeleteFilesNotification = {})) + ); + let WillDeleteFilesRequest; + (function (WillDeleteFilesRequest2) { + WillDeleteFilesRequest2.method = 'workspace/willDeleteFiles'; + WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType( + WillDeleteFilesRequest2.method + ); + })( + (WillDeleteFilesRequest = + exports.WillDeleteFilesRequest || + (exports.WillDeleteFilesRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js + let require_protocol_moniker = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0; + let messages_1 = require_messages2(); + let UniquenessLevel; + (function (UniquenessLevel2) { + UniquenessLevel2['document'] = 'document'; + UniquenessLevel2['project'] = 'project'; + UniquenessLevel2['group'] = 'group'; + UniquenessLevel2['scheme'] = 'scheme'; + UniquenessLevel2['global'] = 'global'; + })( + (UniquenessLevel = + exports.UniquenessLevel || (exports.UniquenessLevel = {})) + ); + let MonikerKind; + (function (MonikerKind2) { + MonikerKind2['import'] = 'import'; + MonikerKind2['export'] = 'export'; + MonikerKind2['local'] = 'local'; + })((MonikerKind = exports.MonikerKind || (exports.MonikerKind = {}))); + let MonikerRequest; + (function (MonikerRequest2) { + MonikerRequest2.method = 'textDocument/moniker'; + MonikerRequest2.type = new messages_1.ProtocolRequestType( + MonikerRequest2.method + ); + })( + (MonikerRequest = + exports.MonikerRequest || (exports.MonikerRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.js + let require_protocol = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/protocol.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = exports.WorkspaceSymbolResolveRequest = exports.WorkspaceSymbolRequest = exports.CodeActionResolveRequest = exports.CodeActionRequest = exports.DocumentSymbolRequest = exports.DocumentHighlightRequest = exports.ReferencesRequest = exports.DefinitionRequest = exports.SignatureHelpRequest = exports.SignatureHelpTriggerKind = exports.HoverRequest = exports.CompletionResolveRequest = exports.CompletionRequest = exports.CompletionTriggerKind = exports.PublishDiagnosticsNotification = exports.WatchKind = exports.FileChangeType = exports.DidChangeWatchedFilesNotification = exports.WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentNotification = exports.TextDocumentSaveReason = exports.DidSaveTextDocumentNotification = exports.DidCloseTextDocumentNotification = exports.DidChangeTextDocumentNotification = exports.TextDocumentContentChangeEvent = exports.DidOpenTextDocumentNotification = exports.TextDocumentSyncKind = exports.TelemetryEventNotification = exports.LogMessageNotification = exports.ShowMessageRequest = exports.ShowMessageNotification = exports.MessageType = exports.DidChangeConfigurationNotification = exports.ExitNotification = exports.ShutdownRequest = exports.InitializedNotification = exports.InitializeError = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.DocumentFilter = void 0; + exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.WillRenameFilesRequest = exports.DidRenameFilesNotification = exports.WillCreateFilesRequest = exports.DidCreateFilesNotification = exports.FileOperationPatternKind = exports.LinkedEditingRangeRequest = exports.ShowDocumentRequest = exports.SemanticTokensRegistrationType = exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.TokenFormat = exports.CallHierarchyPrepareRequest = exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = exports.SelectionRangeRequest = exports.DeclarationRequest = exports.FoldingRangeRequest = exports.ColorPresentationRequest = exports.DocumentColorRequest = exports.ConfigurationRequest = exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = exports.TypeDefinitionRequest = exports.ImplementationRequest = exports.ApplyWorkspaceEditRequest = exports.ExecuteCommandRequest = exports.PrepareRenameRequest = exports.RenameRequest = exports.PrepareSupportDefaultBehavior = exports.DocumentOnTypeFormattingRequest = exports.DocumentRangeFormattingRequest = exports.DocumentFormattingRequest = exports.DocumentLinkResolveRequest = exports.DocumentLinkRequest = void 0; + let messages_1 = require_messages2(); + let Is = require_is2(); + let protocol_implementation_1 = require_protocol_implementation(); + Object.defineProperty(exports, 'ImplementationRequest', { + enumerable: true, + get: function () { + return protocol_implementation_1.ImplementationRequest; + }, + }); + let protocol_typeDefinition_1 = require_protocol_typeDefinition(); + Object.defineProperty(exports, 'TypeDefinitionRequest', { + enumerable: true, + get: function () { + return protocol_typeDefinition_1.TypeDefinitionRequest; + }, + }); + let protocol_workspaceFolders_1 = require_protocol_workspaceFolders(); + Object.defineProperty(exports, 'WorkspaceFoldersRequest', { + enumerable: true, + get: function () { + return protocol_workspaceFolders_1.WorkspaceFoldersRequest; + }, + }); + Object.defineProperty(exports, 'DidChangeWorkspaceFoldersNotification', { + enumerable: true, + get: function () { + return protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification; + }, + }); + let protocol_configuration_1 = require_protocol_configuration(); + Object.defineProperty(exports, 'ConfigurationRequest', { + enumerable: true, + get: function () { + return protocol_configuration_1.ConfigurationRequest; + }, + }); + let protocol_colorProvider_1 = require_protocol_colorProvider(); + Object.defineProperty(exports, 'DocumentColorRequest', { + enumerable: true, + get: function () { + return protocol_colorProvider_1.DocumentColorRequest; + }, + }); + Object.defineProperty(exports, 'ColorPresentationRequest', { + enumerable: true, + get: function () { + return protocol_colorProvider_1.ColorPresentationRequest; + }, + }); + let protocol_foldingRange_1 = require_protocol_foldingRange(); + Object.defineProperty(exports, 'FoldingRangeRequest', { + enumerable: true, + get: function () { + return protocol_foldingRange_1.FoldingRangeRequest; + }, + }); + let protocol_declaration_1 = require_protocol_declaration(); + Object.defineProperty(exports, 'DeclarationRequest', { + enumerable: true, + get: function () { + return protocol_declaration_1.DeclarationRequest; + }, + }); + let protocol_selectionRange_1 = require_protocol_selectionRange(); + Object.defineProperty(exports, 'SelectionRangeRequest', { + enumerable: true, + get: function () { + return protocol_selectionRange_1.SelectionRangeRequest; + }, + }); + let protocol_progress_1 = require_protocol_progress(); + Object.defineProperty(exports, 'WorkDoneProgress', { + enumerable: true, + get: function () { + return protocol_progress_1.WorkDoneProgress; + }, + }); + Object.defineProperty(exports, 'WorkDoneProgressCreateRequest', { + enumerable: true, + get: function () { + return protocol_progress_1.WorkDoneProgressCreateRequest; + }, + }); + Object.defineProperty(exports, 'WorkDoneProgressCancelNotification', { + enumerable: true, + get: function () { + return protocol_progress_1.WorkDoneProgressCancelNotification; + }, + }); + let protocol_callHierarchy_1 = require_protocol_callHierarchy(); + Object.defineProperty(exports, 'CallHierarchyIncomingCallsRequest', { + enumerable: true, + get: function () { + return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest; + }, + }); + Object.defineProperty(exports, 'CallHierarchyOutgoingCallsRequest', { + enumerable: true, + get: function () { + return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest; + }, + }); + Object.defineProperty(exports, 'CallHierarchyPrepareRequest', { + enumerable: true, + get: function () { + return protocol_callHierarchy_1.CallHierarchyPrepareRequest; + }, + }); + let protocol_semanticTokens_1 = require_protocol_semanticTokens(); + Object.defineProperty(exports, 'TokenFormat', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.TokenFormat; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensDeltaRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensDeltaRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRangeRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRangeRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRefreshRequest', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRefreshRequest; + }, + }); + Object.defineProperty(exports, 'SemanticTokensRegistrationType', { + enumerable: true, + get: function () { + return protocol_semanticTokens_1.SemanticTokensRegistrationType; + }, + }); + let protocol_showDocument_1 = require_protocol_showDocument(); + Object.defineProperty(exports, 'ShowDocumentRequest', { + enumerable: true, + get: function () { + return protocol_showDocument_1.ShowDocumentRequest; + }, + }); + let protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange(); + Object.defineProperty(exports, 'LinkedEditingRangeRequest', { + enumerable: true, + get: function () { + return protocol_linkedEditingRange_1.LinkedEditingRangeRequest; + }, + }); + let protocol_fileOperations_1 = require_protocol_fileOperations(); + Object.defineProperty(exports, 'FileOperationPatternKind', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.FileOperationPatternKind; + }, + }); + Object.defineProperty(exports, 'DidCreateFilesNotification', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.DidCreateFilesNotification; + }, + }); + Object.defineProperty(exports, 'WillCreateFilesRequest', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.WillCreateFilesRequest; + }, + }); + Object.defineProperty(exports, 'DidRenameFilesNotification', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.DidRenameFilesNotification; + }, + }); + Object.defineProperty(exports, 'WillRenameFilesRequest', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.WillRenameFilesRequest; + }, + }); + Object.defineProperty(exports, 'DidDeleteFilesNotification', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.DidDeleteFilesNotification; + }, + }); + Object.defineProperty(exports, 'WillDeleteFilesRequest', { + enumerable: true, + get: function () { + return protocol_fileOperations_1.WillDeleteFilesRequest; + }, + }); + let protocol_moniker_1 = require_protocol_moniker(); + Object.defineProperty(exports, 'UniquenessLevel', { + enumerable: true, + get: function () { + return protocol_moniker_1.UniquenessLevel; + }, + }); + Object.defineProperty(exports, 'MonikerKind', { + enumerable: true, + get: function () { + return protocol_moniker_1.MonikerKind; + }, + }); + Object.defineProperty(exports, 'MonikerRequest', { + enumerable: true, + get: function () { + return protocol_moniker_1.MonikerRequest; + }, + }); + let DocumentFilter; + (function (DocumentFilter2) { + function is(value) { + const candidate = value; + return ( + Is.string(candidate.language) || + Is.string(candidate.scheme) || + Is.string(candidate.pattern) + ); + } + DocumentFilter2.is = is; + })( + (DocumentFilter = + exports.DocumentFilter || (exports.DocumentFilter = {})) + ); + let DocumentSelector; + (function (DocumentSelector2) { + function is(value) { + if (!Array.isArray(value)) { + return false; + } + for (let elem of value) { + if (!Is.string(elem) && !DocumentFilter.is(elem)) { + return false; + } + } + return true; + } + DocumentSelector2.is = is; + })( + (DocumentSelector = + exports.DocumentSelector || (exports.DocumentSelector = {})) + ); + let RegistrationRequest; + (function (RegistrationRequest2) { + RegistrationRequest2.type = new messages_1.ProtocolRequestType( + 'client/registerCapability' + ); + })( + (RegistrationRequest = + exports.RegistrationRequest || (exports.RegistrationRequest = {})) + ); + let UnregistrationRequest; + (function (UnregistrationRequest2) { + UnregistrationRequest2.type = new messages_1.ProtocolRequestType( + 'client/unregisterCapability' + ); + })( + (UnregistrationRequest = + exports.UnregistrationRequest || (exports.UnregistrationRequest = {})) + ); + let ResourceOperationKind; + (function (ResourceOperationKind2) { + ResourceOperationKind2.Create = 'create'; + ResourceOperationKind2.Rename = 'rename'; + ResourceOperationKind2.Delete = 'delete'; + })( + (ResourceOperationKind = + exports.ResourceOperationKind || (exports.ResourceOperationKind = {})) + ); + let FailureHandlingKind; + (function (FailureHandlingKind2) { + FailureHandlingKind2.Abort = 'abort'; + FailureHandlingKind2.Transactional = 'transactional'; + FailureHandlingKind2.TextOnlyTransactional = 'textOnlyTransactional'; + FailureHandlingKind2.Undo = 'undo'; + })( + (FailureHandlingKind = + exports.FailureHandlingKind || (exports.FailureHandlingKind = {})) + ); + let StaticRegistrationOptions; + (function (StaticRegistrationOptions2) { + function hasId(value) { + const candidate = value; + return ( + candidate && Is.string(candidate.id) && candidate.id.length > 0 + ); + } + StaticRegistrationOptions2.hasId = hasId; + })( + (StaticRegistrationOptions = + exports.StaticRegistrationOptions || + (exports.StaticRegistrationOptions = {})) + ); + let TextDocumentRegistrationOptions; + (function (TextDocumentRegistrationOptions2) { + function is(value) { + const candidate = value; + return ( + candidate && + (candidate.documentSelector === null || + DocumentSelector.is(candidate.documentSelector)) + ); + } + TextDocumentRegistrationOptions2.is = is; + })( + (TextDocumentRegistrationOptions = + exports.TextDocumentRegistrationOptions || + (exports.TextDocumentRegistrationOptions = {})) + ); + let WorkDoneProgressOptions; + (function (WorkDoneProgressOptions2) { + function is(value) { + const candidate = value; + return ( + Is.objectLiteral(candidate) && + (candidate.workDoneProgress === void 0 || + Is.boolean(candidate.workDoneProgress)) + ); + } + WorkDoneProgressOptions2.is = is; + function hasWorkDoneProgress(value) { + const candidate = value; + return candidate && Is.boolean(candidate.workDoneProgress); + } + WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress; + })( + (WorkDoneProgressOptions = + exports.WorkDoneProgressOptions || + (exports.WorkDoneProgressOptions = {})) + ); + let InitializeRequest; + (function (InitializeRequest2) { + InitializeRequest2.type = new messages_1.ProtocolRequestType( + 'initialize' + ); + })( + (InitializeRequest = + exports.InitializeRequest || (exports.InitializeRequest = {})) + ); + let InitializeError; + (function (InitializeError2) { + InitializeError2.unknownProtocolVersion = 1; + })( + (InitializeError = + exports.InitializeError || (exports.InitializeError = {})) + ); + let InitializedNotification; + (function (InitializedNotification2) { + InitializedNotification2.type = new messages_1.ProtocolNotificationType( + 'initialized' + ); + })( + (InitializedNotification = + exports.InitializedNotification || + (exports.InitializedNotification = {})) + ); + let ShutdownRequest; + (function (ShutdownRequest2) { + ShutdownRequest2.type = new messages_1.ProtocolRequestType0('shutdown'); + })( + (ShutdownRequest = + exports.ShutdownRequest || (exports.ShutdownRequest = {})) + ); + let ExitNotification; + (function (ExitNotification2) { + ExitNotification2.type = new messages_1.ProtocolNotificationType0( + 'exit' + ); + })( + (ExitNotification = + exports.ExitNotification || (exports.ExitNotification = {})) + ); + let DidChangeConfigurationNotification; + (function (DidChangeConfigurationNotification2) { + DidChangeConfigurationNotification2.type = new messages_1.ProtocolNotificationType( + 'workspace/didChangeConfiguration' + ); + })( + (DidChangeConfigurationNotification = + exports.DidChangeConfigurationNotification || + (exports.DidChangeConfigurationNotification = {})) + ); + let MessageType; + (function (MessageType2) { + MessageType2.Error = 1; + MessageType2.Warning = 2; + MessageType2.Info = 3; + MessageType2.Log = 4; + })((MessageType = exports.MessageType || (exports.MessageType = {}))); + let ShowMessageNotification; + (function (ShowMessageNotification2) { + ShowMessageNotification2.type = new messages_1.ProtocolNotificationType( + 'window/showMessage' + ); + })( + (ShowMessageNotification = + exports.ShowMessageNotification || + (exports.ShowMessageNotification = {})) + ); + let ShowMessageRequest; + (function (ShowMessageRequest2) { + ShowMessageRequest2.type = new messages_1.ProtocolRequestType( + 'window/showMessageRequest' + ); + })( + (ShowMessageRequest = + exports.ShowMessageRequest || (exports.ShowMessageRequest = {})) + ); + let LogMessageNotification; + (function (LogMessageNotification2) { + LogMessageNotification2.type = new messages_1.ProtocolNotificationType( + 'window/logMessage' + ); + })( + (LogMessageNotification = + exports.LogMessageNotification || + (exports.LogMessageNotification = {})) + ); + let TelemetryEventNotification; + (function (TelemetryEventNotification2) { + TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType( + 'telemetry/event' + ); + })( + (TelemetryEventNotification = + exports.TelemetryEventNotification || + (exports.TelemetryEventNotification = {})) + ); + let TextDocumentSyncKind2; + (function (TextDocumentSyncKind3) { + TextDocumentSyncKind3.None = 0; + TextDocumentSyncKind3.Full = 1; + TextDocumentSyncKind3.Incremental = 2; + })( + (TextDocumentSyncKind2 = + exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {})) + ); + let DidOpenTextDocumentNotification; + (function (DidOpenTextDocumentNotification2) { + DidOpenTextDocumentNotification2.method = 'textDocument/didOpen'; + DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidOpenTextDocumentNotification2.method + ); + })( + (DidOpenTextDocumentNotification = + exports.DidOpenTextDocumentNotification || + (exports.DidOpenTextDocumentNotification = {})) + ); + let TextDocumentContentChangeEvent2; + (function (TextDocumentContentChangeEvent3) { + function isIncremental(event) { + let candidate = event; + return ( + candidate !== void 0 && + candidate !== null && + typeof candidate.text === 'string' && + candidate.range !== void 0 && + (candidate.rangeLength === void 0 || + typeof candidate.rangeLength === 'number') + ); + } + TextDocumentContentChangeEvent3.isIncremental = isIncremental; + function isFull(event) { + let candidate = event; + return ( + candidate !== void 0 && + candidate !== null && + typeof candidate.text === 'string' && + candidate.range === void 0 && + candidate.rangeLength === void 0 + ); + } + TextDocumentContentChangeEvent3.isFull = isFull; + })( + (TextDocumentContentChangeEvent2 = + exports.TextDocumentContentChangeEvent || + (exports.TextDocumentContentChangeEvent = {})) + ); + let DidChangeTextDocumentNotification; + (function (DidChangeTextDocumentNotification2) { + DidChangeTextDocumentNotification2.method = 'textDocument/didChange'; + DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidChangeTextDocumentNotification2.method + ); + })( + (DidChangeTextDocumentNotification = + exports.DidChangeTextDocumentNotification || + (exports.DidChangeTextDocumentNotification = {})) + ); + let DidCloseTextDocumentNotification; + (function (DidCloseTextDocumentNotification2) { + DidCloseTextDocumentNotification2.method = 'textDocument/didClose'; + DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidCloseTextDocumentNotification2.method + ); + })( + (DidCloseTextDocumentNotification = + exports.DidCloseTextDocumentNotification || + (exports.DidCloseTextDocumentNotification = {})) + ); + let DidSaveTextDocumentNotification; + (function (DidSaveTextDocumentNotification2) { + DidSaveTextDocumentNotification2.method = 'textDocument/didSave'; + DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + DidSaveTextDocumentNotification2.method + ); + })( + (DidSaveTextDocumentNotification = + exports.DidSaveTextDocumentNotification || + (exports.DidSaveTextDocumentNotification = {})) + ); + let TextDocumentSaveReason; + (function (TextDocumentSaveReason2) { + TextDocumentSaveReason2.Manual = 1; + TextDocumentSaveReason2.AfterDelay = 2; + TextDocumentSaveReason2.FocusOut = 3; + })( + (TextDocumentSaveReason = + exports.TextDocumentSaveReason || + (exports.TextDocumentSaveReason = {})) + ); + let WillSaveTextDocumentNotification; + (function (WillSaveTextDocumentNotification2) { + WillSaveTextDocumentNotification2.method = 'textDocument/willSave'; + WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType( + WillSaveTextDocumentNotification2.method + ); + })( + (WillSaveTextDocumentNotification = + exports.WillSaveTextDocumentNotification || + (exports.WillSaveTextDocumentNotification = {})) + ); + let WillSaveTextDocumentWaitUntilRequest; + (function (WillSaveTextDocumentWaitUntilRequest2) { + WillSaveTextDocumentWaitUntilRequest2.method = + 'textDocument/willSaveWaitUntil'; + WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType( + WillSaveTextDocumentWaitUntilRequest2.method + ); + })( + (WillSaveTextDocumentWaitUntilRequest = + exports.WillSaveTextDocumentWaitUntilRequest || + (exports.WillSaveTextDocumentWaitUntilRequest = {})) + ); + let DidChangeWatchedFilesNotification; + (function (DidChangeWatchedFilesNotification2) { + DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType( + 'workspace/didChangeWatchedFiles' + ); + })( + (DidChangeWatchedFilesNotification = + exports.DidChangeWatchedFilesNotification || + (exports.DidChangeWatchedFilesNotification = {})) + ); + let FileChangeType; + (function (FileChangeType2) { + FileChangeType2.Created = 1; + FileChangeType2.Changed = 2; + FileChangeType2.Deleted = 3; + })( + (FileChangeType = + exports.FileChangeType || (exports.FileChangeType = {})) + ); + let WatchKind; + (function (WatchKind2) { + WatchKind2.Create = 1; + WatchKind2.Change = 2; + WatchKind2.Delete = 4; + })((WatchKind = exports.WatchKind || (exports.WatchKind = {}))); + let PublishDiagnosticsNotification; + (function (PublishDiagnosticsNotification2) { + PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType( + 'textDocument/publishDiagnostics' + ); + })( + (PublishDiagnosticsNotification = + exports.PublishDiagnosticsNotification || + (exports.PublishDiagnosticsNotification = {})) + ); + let CompletionTriggerKind; + (function (CompletionTriggerKind2) { + CompletionTriggerKind2.Invoked = 1; + CompletionTriggerKind2.TriggerCharacter = 2; + CompletionTriggerKind2.TriggerForIncompleteCompletions = 3; + })( + (CompletionTriggerKind = + exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {})) + ); + let CompletionRequest2; + (function (CompletionRequest3) { + CompletionRequest3.method = 'textDocument/completion'; + CompletionRequest3.type = new messages_1.ProtocolRequestType( + CompletionRequest3.method + ); + })( + (CompletionRequest2 = + exports.CompletionRequest || (exports.CompletionRequest = {})) + ); + let CompletionResolveRequest; + (function (CompletionResolveRequest2) { + CompletionResolveRequest2.method = 'completionItem/resolve'; + CompletionResolveRequest2.type = new messages_1.ProtocolRequestType( + CompletionResolveRequest2.method + ); + })( + (CompletionResolveRequest = + exports.CompletionResolveRequest || + (exports.CompletionResolveRequest = {})) + ); + let HoverRequest; + (function (HoverRequest2) { + HoverRequest2.method = 'textDocument/hover'; + HoverRequest2.type = new messages_1.ProtocolRequestType( + HoverRequest2.method + ); + })((HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}))); + let SignatureHelpTriggerKind; + (function (SignatureHelpTriggerKind2) { + SignatureHelpTriggerKind2.Invoked = 1; + SignatureHelpTriggerKind2.TriggerCharacter = 2; + SignatureHelpTriggerKind2.ContentChange = 3; + })( + (SignatureHelpTriggerKind = + exports.SignatureHelpTriggerKind || + (exports.SignatureHelpTriggerKind = {})) + ); + let SignatureHelpRequest; + (function (SignatureHelpRequest2) { + SignatureHelpRequest2.method = 'textDocument/signatureHelp'; + SignatureHelpRequest2.type = new messages_1.ProtocolRequestType( + SignatureHelpRequest2.method + ); + })( + (SignatureHelpRequest = + exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {})) + ); + let DefinitionRequest2; + (function (DefinitionRequest3) { + DefinitionRequest3.method = 'textDocument/definition'; + DefinitionRequest3.type = new messages_1.ProtocolRequestType( + DefinitionRequest3.method + ); + })( + (DefinitionRequest2 = + exports.DefinitionRequest || (exports.DefinitionRequest = {})) + ); + let ReferencesRequest2; + (function (ReferencesRequest3) { + ReferencesRequest3.method = 'textDocument/references'; + ReferencesRequest3.type = new messages_1.ProtocolRequestType( + ReferencesRequest3.method + ); + })( + (ReferencesRequest2 = + exports.ReferencesRequest || (exports.ReferencesRequest = {})) + ); + let DocumentHighlightRequest2; + (function (DocumentHighlightRequest3) { + DocumentHighlightRequest3.method = 'textDocument/documentHighlight'; + DocumentHighlightRequest3.type = new messages_1.ProtocolRequestType( + DocumentHighlightRequest3.method + ); + })( + (DocumentHighlightRequest2 = + exports.DocumentHighlightRequest || + (exports.DocumentHighlightRequest = {})) + ); + let DocumentSymbolRequest2; + (function (DocumentSymbolRequest3) { + DocumentSymbolRequest3.method = 'textDocument/documentSymbol'; + DocumentSymbolRequest3.type = new messages_1.ProtocolRequestType( + DocumentSymbolRequest3.method + ); + })( + (DocumentSymbolRequest2 = + exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {})) + ); + let CodeActionRequest; + (function (CodeActionRequest2) { + CodeActionRequest2.method = 'textDocument/codeAction'; + CodeActionRequest2.type = new messages_1.ProtocolRequestType( + CodeActionRequest2.method + ); + })( + (CodeActionRequest = + exports.CodeActionRequest || (exports.CodeActionRequest = {})) + ); + let CodeActionResolveRequest; + (function (CodeActionResolveRequest2) { + CodeActionResolveRequest2.method = 'codeAction/resolve'; + CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType( + CodeActionResolveRequest2.method + ); + })( + (CodeActionResolveRequest = + exports.CodeActionResolveRequest || + (exports.CodeActionResolveRequest = {})) + ); + let WorkspaceSymbolRequest2; + (function (WorkspaceSymbolRequest3) { + WorkspaceSymbolRequest3.method = 'workspace/symbol'; + WorkspaceSymbolRequest3.type = new messages_1.ProtocolRequestType( + WorkspaceSymbolRequest3.method + ); + })( + (WorkspaceSymbolRequest2 = + exports.WorkspaceSymbolRequest || + (exports.WorkspaceSymbolRequest = {})) + ); + let WorkspaceSymbolResolveRequest2; + (function (WorkspaceSymbolResolveRequest3) { + WorkspaceSymbolResolveRequest3.method = 'workspaceSymbol/resolve'; + WorkspaceSymbolResolveRequest3.type = new messages_1.ProtocolRequestType( + WorkspaceSymbolResolveRequest3.method + ); + })( + (WorkspaceSymbolResolveRequest2 = + exports.WorkspaceSymbolResolveRequest || + (exports.WorkspaceSymbolResolveRequest = {})) + ); + let CodeLensRequest; + (function (CodeLensRequest2) { + CodeLensRequest2.method = 'textDocument/codeLens'; + CodeLensRequest2.type = new messages_1.ProtocolRequestType( + CodeLensRequest2.method + ); + })( + (CodeLensRequest = + exports.CodeLensRequest || (exports.CodeLensRequest = {})) + ); + let CodeLensResolveRequest; + (function (CodeLensResolveRequest2) { + CodeLensResolveRequest2.method = 'codeLens/resolve'; + CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType( + CodeLensResolveRequest2.method + ); + })( + (CodeLensResolveRequest = + exports.CodeLensResolveRequest || + (exports.CodeLensResolveRequest = {})) + ); + let CodeLensRefreshRequest; + (function (CodeLensRefreshRequest2) { + CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`; + CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0( + CodeLensRefreshRequest2.method + ); + })( + (CodeLensRefreshRequest = + exports.CodeLensRefreshRequest || + (exports.CodeLensRefreshRequest = {})) + ); + let DocumentLinkRequest; + (function (DocumentLinkRequest2) { + DocumentLinkRequest2.method = 'textDocument/documentLink'; + DocumentLinkRequest2.type = new messages_1.ProtocolRequestType( + DocumentLinkRequest2.method + ); + })( + (DocumentLinkRequest = + exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {})) + ); + let DocumentLinkResolveRequest; + (function (DocumentLinkResolveRequest2) { + DocumentLinkResolveRequest2.method = 'documentLink/resolve'; + DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType( + DocumentLinkResolveRequest2.method + ); + })( + (DocumentLinkResolveRequest = + exports.DocumentLinkResolveRequest || + (exports.DocumentLinkResolveRequest = {})) + ); + let DocumentFormattingRequest; + (function (DocumentFormattingRequest2) { + DocumentFormattingRequest2.method = 'textDocument/formatting'; + DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType( + DocumentFormattingRequest2.method + ); + })( + (DocumentFormattingRequest = + exports.DocumentFormattingRequest || + (exports.DocumentFormattingRequest = {})) + ); + let DocumentRangeFormattingRequest; + (function (DocumentRangeFormattingRequest2) { + DocumentRangeFormattingRequest2.method = 'textDocument/rangeFormatting'; + DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType( + DocumentRangeFormattingRequest2.method + ); + })( + (DocumentRangeFormattingRequest = + exports.DocumentRangeFormattingRequest || + (exports.DocumentRangeFormattingRequest = {})) + ); + let DocumentOnTypeFormattingRequest; + (function (DocumentOnTypeFormattingRequest2) { + DocumentOnTypeFormattingRequest2.method = + 'textDocument/onTypeFormatting'; + DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType( + DocumentOnTypeFormattingRequest2.method + ); + })( + (DocumentOnTypeFormattingRequest = + exports.DocumentOnTypeFormattingRequest || + (exports.DocumentOnTypeFormattingRequest = {})) + ); + let PrepareSupportDefaultBehavior; + (function (PrepareSupportDefaultBehavior2) { + PrepareSupportDefaultBehavior2.Identifier = 1; + })( + (PrepareSupportDefaultBehavior = + exports.PrepareSupportDefaultBehavior || + (exports.PrepareSupportDefaultBehavior = {})) + ); + let RenameRequest; + (function (RenameRequest2) { + RenameRequest2.method = 'textDocument/rename'; + RenameRequest2.type = new messages_1.ProtocolRequestType( + RenameRequest2.method + ); + })( + (RenameRequest = exports.RenameRequest || (exports.RenameRequest = {})) + ); + let PrepareRenameRequest; + (function (PrepareRenameRequest2) { + PrepareRenameRequest2.method = 'textDocument/prepareRename'; + PrepareRenameRequest2.type = new messages_1.ProtocolRequestType( + PrepareRenameRequest2.method + ); + })( + (PrepareRenameRequest = + exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {})) + ); + let ExecuteCommandRequest; + (function (ExecuteCommandRequest2) { + ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType( + 'workspace/executeCommand' + ); + })( + (ExecuteCommandRequest = + exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {})) + ); + let ApplyWorkspaceEditRequest; + (function (ApplyWorkspaceEditRequest2) { + ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType( + 'workspace/applyEdit' + ); + })( + (ApplyWorkspaceEditRequest = + exports.ApplyWorkspaceEditRequest || + (exports.ApplyWorkspaceEditRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/connection.js + let require_connection2 = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/connection.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createProtocolConnection = void 0; + let vscode_jsonrpc_1 = require_main(); + function createProtocolConnection(input, output, logger, options) { + if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) { + options = { connectionStrategy: options }; + } + return (0, vscode_jsonrpc_1.createMessageConnection)( + input, + output, + logger, + options + ); + } + exports.createProtocolConnection = createProtocolConnection; + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/proposed.diagnostic.js + let require_proposed_diagnostic = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/proposed.diagnostic.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = void 0; + let vscode_jsonrpc_1 = require_main(); + let Is = require_is2(); + let messages_1 = require_messages2(); + let DiagnosticServerCancellationData; + (function (DiagnosticServerCancellationData2) { + function is(value) { + const candidate = value; + return candidate && Is.boolean(candidate.retriggerRequest); + } + DiagnosticServerCancellationData2.is = is; + })( + (DiagnosticServerCancellationData = + exports.DiagnosticServerCancellationData || + (exports.DiagnosticServerCancellationData = {})) + ); + let DocumentDiagnosticReportKind; + (function (DocumentDiagnosticReportKind2) { + DocumentDiagnosticReportKind2['full'] = 'full'; + DocumentDiagnosticReportKind2['unChanged'] = 'unChanged'; + })( + (DocumentDiagnosticReportKind = + exports.DocumentDiagnosticReportKind || + (exports.DocumentDiagnosticReportKind = {})) + ); + let DocumentDiagnosticRequest; + (function (DocumentDiagnosticRequest2) { + DocumentDiagnosticRequest2.method = 'textDocument/diagnostic'; + DocumentDiagnosticRequest2.type = new messages_1.ProtocolRequestType( + DocumentDiagnosticRequest2.method + ); + DocumentDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType(); + })( + (DocumentDiagnosticRequest = + exports.DocumentDiagnosticRequest || + (exports.DocumentDiagnosticRequest = {})) + ); + let WorkspaceDiagnosticRequest; + (function (WorkspaceDiagnosticRequest2) { + WorkspaceDiagnosticRequest2.method = 'workspace/diagnostic'; + WorkspaceDiagnosticRequest2.type = new messages_1.ProtocolRequestType( + WorkspaceDiagnosticRequest2.method + ); + WorkspaceDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType(); + })( + (WorkspaceDiagnosticRequest = + exports.WorkspaceDiagnosticRequest || + (exports.WorkspaceDiagnosticRequest = {})) + ); + let DiagnosticRefreshRequest; + (function (DiagnosticRefreshRequest2) { + DiagnosticRefreshRequest2.method = `workspace/diagnostic/refresh`; + DiagnosticRefreshRequest2.type = new messages_1.ProtocolRequestType0( + DiagnosticRefreshRequest2.method + ); + })( + (DiagnosticRefreshRequest = + exports.DiagnosticRefreshRequest || + (exports.DiagnosticRefreshRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/proposed.typeHierarchy.js + let require_proposed_typeHierarchy = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/proposed.typeHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeHierarchySubtypesRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchyPrepareRequest = void 0; + let messages_1 = require_messages2(); + let TypeHierarchyPrepareRequest; + (function (TypeHierarchyPrepareRequest2) { + TypeHierarchyPrepareRequest2.method = + 'textDocument/prepareTypeHierarchy'; + TypeHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType( + TypeHierarchyPrepareRequest2.method + ); + })( + (TypeHierarchyPrepareRequest = + exports.TypeHierarchyPrepareRequest || + (exports.TypeHierarchyPrepareRequest = {})) + ); + let TypeHierarchySupertypesRequest; + (function (TypeHierarchySupertypesRequest2) { + TypeHierarchySupertypesRequest2.method = 'typeHierarchy/supertypes'; + TypeHierarchySupertypesRequest2.type = new messages_1.ProtocolRequestType( + TypeHierarchySupertypesRequest2.method + ); + })( + (TypeHierarchySupertypesRequest = + exports.TypeHierarchySupertypesRequest || + (exports.TypeHierarchySupertypesRequest = {})) + ); + let TypeHierarchySubtypesRequest; + (function (TypeHierarchySubtypesRequest2) { + TypeHierarchySubtypesRequest2.method = 'typeHierarchy/subtypes'; + TypeHierarchySubtypesRequest2.type = new messages_1.ProtocolRequestType( + TypeHierarchySubtypesRequest2.method + ); + })( + (TypeHierarchySubtypesRequest = + exports.TypeHierarchySubtypesRequest || + (exports.TypeHierarchySubtypesRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/proposed.inlineValue.js + let require_proposed_inlineValue = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/proposed.inlineValue.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.InlineValuesRefreshRequest = exports.InlineValuesRequest = void 0; + let messages_1 = require_messages2(); + let InlineValuesRequest; + (function (InlineValuesRequest2) { + InlineValuesRequest2.method = 'textDocument/inlineValues'; + InlineValuesRequest2.type = new messages_1.ProtocolRequestType( + InlineValuesRequest2.method + ); + })( + (InlineValuesRequest = + exports.InlineValuesRequest || (exports.InlineValuesRequest = {})) + ); + let InlineValuesRefreshRequest; + (function (InlineValuesRefreshRequest2) { + InlineValuesRefreshRequest2.method = `workspace/inlineValues/refresh`; + InlineValuesRefreshRequest2.type = new messages_1.ProtocolRequestType0( + InlineValuesRefreshRequest2.method + ); + })( + (InlineValuesRefreshRequest = + exports.InlineValuesRefreshRequest || + (exports.InlineValuesRefreshRequest = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/common/api.js + let require_api2 = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/common/api.js'( + exports + ) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.Proposed = exports.LSPErrorCodes = exports.createProtocolConnection = void 0; + __exportStar(require_main(), exports); + __exportStar(require_main2(), exports); + __exportStar(require_messages2(), exports); + __exportStar(require_protocol(), exports); + let connection_1 = require_connection2(); + Object.defineProperty(exports, 'createProtocolConnection', { + enumerable: true, + get: function () { + return connection_1.createProtocolConnection; + }, + }); + let LSPErrorCodes; + (function (LSPErrorCodes2) { + LSPErrorCodes2.lspReservedErrorRangeStart = -32899; + LSPErrorCodes2.RequestFailed = -32803; + LSPErrorCodes2.ServerCancelled = -32802; + LSPErrorCodes2.ContentModified = -32801; + LSPErrorCodes2.RequestCancelled = -32800; + LSPErrorCodes2.lspReservedErrorRangeEnd = -32800; + })( + (LSPErrorCodes = exports.LSPErrorCodes || (exports.LSPErrorCodes = {})) + ); + let diag = require_proposed_diagnostic(); + let typeh = require_proposed_typeHierarchy(); + let iv = require_proposed_inlineValue(); + let Proposed; + (function (Proposed2) { + Proposed2.DiagnosticServerCancellationData = + diag.DiagnosticServerCancellationData; + Proposed2.DocumentDiagnosticReportKind = + diag.DocumentDiagnosticReportKind; + Proposed2.DocumentDiagnosticRequest = diag.DocumentDiagnosticRequest; + Proposed2.WorkspaceDiagnosticRequest = diag.WorkspaceDiagnosticRequest; + Proposed2.DiagnosticRefreshRequest = diag.DiagnosticRefreshRequest; + Proposed2.TypeHierarchyPrepareRequest = + typeh.TypeHierarchyPrepareRequest; + Proposed2.TypeHierarchySupertypesRequest = + typeh.TypeHierarchySupertypesRequest; + Proposed2.TypeHierarchySubtypesRequest = + typeh.TypeHierarchySubtypesRequest; + Proposed2.InlineValuesRequest = iv.InlineValuesRequest; + Proposed2.InlineValuesRefreshRequest = iv.InlineValuesRefreshRequest; + })((Proposed = exports.Proposed || (exports.Proposed = {}))); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/lib/browser/main.js + let require_main3 = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/lib/browser/main.js'( + exports + ) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createProtocolConnection = void 0; + let browser_1 = require_browser(); + __exportStar(require_browser(), exports); + __exportStar(require_api2(), exports); + function createProtocolConnection(reader, writer, logger, options) { + return (0, browser_1.createMessageConnection)( + reader, + writer, + logger, + options + ); + } + exports.createProtocolConnection = createProtocolConnection; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/utils/is.js + let require_is3 = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/utils/is.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0; + function boolean(value) { + return value === true || value === false; + } + exports.boolean = boolean; + function string(value) { + return typeof value === 'string' || value instanceof String; + } + exports.string = string; + function number(value) { + return typeof value === 'number' || value instanceof Number; + } + exports.number = number; + function error(value) { + return value instanceof Error; + } + exports.error = error; + function func(value) { + return typeof value === 'function'; + } + exports.func = func; + function array(value) { + return Array.isArray(value); + } + exports.array = array; + function stringArray(value) { + return array(value) && value.every((elem) => string(elem)); + } + exports.stringArray = stringArray; + function typedArray(value, check) { + return Array.isArray(value) && value.every(check); + } + exports.typedArray = typedArray; + function thenable(value) { + return value && func(value.then); + } + exports.thenable = thenable; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/utils/uuid.js + let require_uuid = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/utils/uuid.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0; + let ValueUUID = class { + constructor(_value) { + this._value = _value; + } + asHex() { + return this._value; + } + equals(other) { + return this.asHex() === other.asHex(); + } + }; + var V4UUID = class extends ValueUUID { + constructor() { + super( + [ + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + '4', + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + V4UUID._oneOf(V4UUID._timeHighBits), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + '-', + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + V4UUID._randomHex(), + ].join('') + ); + } + static _oneOf(array) { + return array[Math.floor(array.length * Math.random())]; + } + static _randomHex() { + return V4UUID._oneOf(V4UUID._chars); + } + }; + V4UUID._chars = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '6', + '7', + '8', + '9', + 'a', + 'b', + 'c', + 'd', + 'e', + 'f', + ]; + V4UUID._timeHighBits = ['8', '9', 'a', 'b']; + exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000'); + function v4() { + return new V4UUID(); + } + exports.v4 = v4; + let _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; + function isUUID(value) { + return _UUIDPattern.test(value); + } + exports.isUUID = isUUID; + function parse(value) { + if (!isUUID(value)) { + throw new Error('invalid uuid'); + } + return new ValueUUID(value); + } + exports.parse = parse; + function generateUuid() { + return v4().asHex(); + } + exports.generateUuid = generateUuid; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/progress.js + let require_progress = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/progress.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.attachPartialResult = exports.ProgressFeature = exports.attachWorkDone = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let uuid_1 = require_uuid(); + var WorkDoneProgressReporterImpl = class { + constructor(_connection, _token) { + this._connection = _connection; + this._token = _token; + WorkDoneProgressReporterImpl.Instances.set(this._token, this); + } + begin(title, percentage, message, cancellable) { + let param = { + kind: 'begin', + title, + percentage, + message, + cancellable, + }; + this._connection.sendProgress( + vscode_languageserver_protocol_1.WorkDoneProgress.type, + this._token, + param + ); + } + report(arg0, arg1) { + let param = { + kind: 'report', + }; + if (typeof arg0 === 'number') { + param.percentage = arg0; + if (arg1 !== void 0) { + param.message = arg1; + } + } else { + param.message = arg0; + } + this._connection.sendProgress( + vscode_languageserver_protocol_1.WorkDoneProgress.type, + this._token, + param + ); + } + done() { + WorkDoneProgressReporterImpl.Instances.delete(this._token); + this._connection.sendProgress( + vscode_languageserver_protocol_1.WorkDoneProgress.type, + this._token, + { kind: 'end' } + ); + } + }; + WorkDoneProgressReporterImpl.Instances = new Map(); + let WorkDoneProgressServerReporterImpl = class extends WorkDoneProgressReporterImpl { + constructor(connection2, token) { + super(connection2, token); + this._source = new vscode_languageserver_protocol_1.CancellationTokenSource(); + } + get token() { + return this._source.token; + } + done() { + this._source.dispose(); + super.done(); + } + cancel() { + this._source.cancel(); + } + }; + let NullProgressReporter = class { + constructor() {} + begin() {} + report() {} + done() {} + }; + let NullProgressServerReporter = class extends NullProgressReporter { + constructor() { + super(); + this._source = new vscode_languageserver_protocol_1.CancellationTokenSource(); + } + get token() { + return this._source.token; + } + done() { + this._source.dispose(); + } + cancel() { + this._source.cancel(); + } + }; + function attachWorkDone(connection2, params) { + if (params === void 0 || params.workDoneToken === void 0) { + return new NullProgressReporter(); + } + const token = params.workDoneToken; + delete params.workDoneToken; + return new WorkDoneProgressReporterImpl(connection2, token); + } + exports.attachWorkDone = attachWorkDone; + let ProgressFeature = (Base) => { + return class extends Base { + constructor() { + super(); + this._progressSupported = false; + } + initialize(capabilities) { + super.initialize(capabilities); + if (capabilities?.window?.workDoneProgress === true) { + this._progressSupported = true; + this.connection.onNotification( + vscode_languageserver_protocol_1 + .WorkDoneProgressCancelNotification.type, + (params) => { + let progress = WorkDoneProgressReporterImpl.Instances.get( + params.token + ); + if ( + progress instanceof WorkDoneProgressServerReporterImpl || + progress instanceof NullProgressServerReporter + ) { + progress.cancel(); + } + } + ); + } + } + attachWorkDoneProgress(token) { + if (token === void 0) { + return new NullProgressReporter(); + } else { + return new WorkDoneProgressReporterImpl(this.connection, token); + } + } + createWorkDoneProgress() { + if (this._progressSupported) { + const token = (0, uuid_1.generateUuid)(); + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest + .type, + { token } + ) + .then(() => { + const result = new WorkDoneProgressServerReporterImpl( + this.connection, + token + ); + return result; + }); + } else { + return Promise.resolve(new NullProgressServerReporter()); + } + } + }; + }; + exports.ProgressFeature = ProgressFeature; + let ResultProgress; + (function (ResultProgress2) { + ResultProgress2.type = new vscode_languageserver_protocol_1.ProgressType(); + })(ResultProgress || (ResultProgress = {})); + let ResultProgressReporterImpl = class { + constructor(_connection, _token) { + this._connection = _connection; + this._token = _token; + } + report(data) { + this._connection.sendProgress(ResultProgress.type, this._token, data); + } + }; + function attachPartialResult(connection2, params) { + if (params === void 0 || params.partialResultToken === void 0) { + return void 0; + } + const token = params.partialResultToken; + delete params.partialResultToken; + return new ResultProgressReporterImpl(connection2, token); + } + exports.attachPartialResult = attachPartialResult; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/configuration.js + let require_configuration = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/configuration.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ConfigurationFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let Is = require_is3(); + let ConfigurationFeature = (Base) => { + return class extends Base { + getConfiguration(arg) { + if (!arg) { + return this._getConfiguration({}); + } else if (Is.string(arg)) { + return this._getConfiguration({ section: arg }); + } else { + return this._getConfiguration(arg); + } + } + _getConfiguration(arg) { + let params = { + items: Array.isArray(arg) ? arg : [arg], + }; + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.ConfigurationRequest.type, + params + ) + .then((result) => { + if (Array.isArray(result)) { + return Array.isArray(arg) ? result : result[0]; + } else { + return Array.isArray(arg) ? [] : null; + } + }); + } + }; + }; + exports.ConfigurationFeature = ConfigurationFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/workspaceFolders.js + let require_workspaceFolders = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/workspaceFolders.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.WorkspaceFoldersFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let WorkspaceFoldersFeature = (Base) => { + return class extends Base { + constructor() { + super(); + this._notificationIsAutoRegistered = false; + } + initialize(capabilities) { + super.initialize(capabilities); + let workspaceCapabilities = capabilities.workspace; + if ( + workspaceCapabilities && + workspaceCapabilities.workspaceFolders + ) { + this._onDidChangeWorkspaceFolders = new vscode_languageserver_protocol_1.Emitter(); + this.connection.onNotification( + vscode_languageserver_protocol_1 + .DidChangeWorkspaceFoldersNotification.type, + (params) => { + this._onDidChangeWorkspaceFolders.fire(params.event); + } + ); + } + } + fillServerCapabilities(capabilities) { + super.fillServerCapabilities(capabilities); + const changeNotifications = + capabilities.workspace?.workspaceFolders?.changeNotifications; + this._notificationIsAutoRegistered = + changeNotifications === true || + typeof changeNotifications === 'string'; + } + getWorkspaceFolders() { + return this.connection.sendRequest( + vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type + ); + } + get onDidChangeWorkspaceFolders() { + if (!this._onDidChangeWorkspaceFolders) { + throw new Error( + "Client doesn't support sending workspace folder change events." + ); + } + if (!this._notificationIsAutoRegistered && !this._unregistration) { + this._unregistration = this.connection.client.register( + vscode_languageserver_protocol_1 + .DidChangeWorkspaceFoldersNotification.type + ); + } + return this._onDidChangeWorkspaceFolders.event; + } + }; + }; + exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/callHierarchy.js + let require_callHierarchy = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/callHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.CallHierarchyFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let CallHierarchyFeature = (Base) => { + return class extends Base { + get callHierarchy() { + return { + onPrepare: (handler) => { + this.connection.onRequest( + vscode_languageserver_protocol_1.CallHierarchyPrepareRequest + .type, + (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + void 0 + ); + } + ); + }, + onIncomingCalls: (handler) => { + const type = + vscode_languageserver_protocol_1 + .CallHierarchyIncomingCallsRequest.type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + onOutgoingCalls: (handler) => { + const type = + vscode_languageserver_protocol_1 + .CallHierarchyOutgoingCallsRequest.type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + }; + } + }; + }; + exports.CallHierarchyFeature = CallHierarchyFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/semanticTokens.js + let require_semanticTokens = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/semanticTokens.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.SemanticTokensBuilder = exports.SemanticTokensDiff = exports.SemanticTokensFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let SemanticTokensFeature = (Base) => { + return class extends Base { + get semanticTokens() { + return { + refresh: () => { + return this.connection.sendRequest( + vscode_languageserver_protocol_1.SemanticTokensRefreshRequest + .type + ); + }, + on: (handler) => { + const type = + vscode_languageserver_protocol_1.SemanticTokensRequest.type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + onDelta: (handler) => { + const type = + vscode_languageserver_protocol_1.SemanticTokensDeltaRequest + .type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + onRange: (handler) => { + const type = + vscode_languageserver_protocol_1.SemanticTokensRangeRequest + .type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + }; + } + }; + }; + exports.SemanticTokensFeature = SemanticTokensFeature; + let SemanticTokensDiff = class { + constructor(originalSequence, modifiedSequence) { + this.originalSequence = originalSequence; + this.modifiedSequence = modifiedSequence; + } + computeDiff() { + const originalLength = this.originalSequence.length; + const modifiedLength = this.modifiedSequence.length; + let startIndex = 0; + while ( + startIndex < modifiedLength && + startIndex < originalLength && + this.originalSequence[startIndex] === + this.modifiedSequence[startIndex] + ) { + startIndex++; + } + if (startIndex < modifiedLength && startIndex < originalLength) { + let originalEndIndex = originalLength - 1; + let modifiedEndIndex = modifiedLength - 1; + while ( + originalEndIndex >= startIndex && + modifiedEndIndex >= startIndex && + this.originalSequence[originalEndIndex] === + this.modifiedSequence[modifiedEndIndex] + ) { + originalEndIndex--; + modifiedEndIndex--; + } + if ( + originalEndIndex < startIndex || + modifiedEndIndex < startIndex + ) { + originalEndIndex++; + modifiedEndIndex++; + } + const deleteCount = originalEndIndex - startIndex + 1; + const newData = this.modifiedSequence.slice( + startIndex, + modifiedEndIndex + 1 + ); + if ( + newData.length === 1 && + newData[0] === this.originalSequence[originalEndIndex] + ) { + return [{ start: startIndex, deleteCount: deleteCount - 1 }]; + } else { + return [{ start: startIndex, deleteCount, data: newData }]; + } + } else if (startIndex < modifiedLength) { + return [ + { + start: startIndex, + deleteCount: 0, + data: this.modifiedSequence.slice(startIndex), + }, + ]; + } else if (startIndex < originalLength) { + return [ + { start: startIndex, deleteCount: originalLength - startIndex }, + ]; + } else { + return []; + } + } + }; + exports.SemanticTokensDiff = SemanticTokensDiff; + let SemanticTokensBuilder = class { + constructor() { + this._prevData = void 0; + this.initialize(); + } + initialize() { + this._id = Date.now(); + this._prevLine = 0; + this._prevChar = 0; + this._data = []; + this._dataLen = 0; + } + push(line, char, length, tokenType, tokenModifiers) { + let pushLine = line; + let pushChar = char; + if (this._dataLen > 0) { + pushLine -= this._prevLine; + if (pushLine === 0) { + pushChar -= this._prevChar; + } + } + this._data[this._dataLen++] = pushLine; + this._data[this._dataLen++] = pushChar; + this._data[this._dataLen++] = length; + this._data[this._dataLen++] = tokenType; + this._data[this._dataLen++] = tokenModifiers; + this._prevLine = line; + this._prevChar = char; + } + get id() { + return this._id.toString(); + } + previousResult(id) { + if (this.id === id) { + this._prevData = this._data; + } + this.initialize(); + } + build() { + this._prevData = void 0; + return { + resultId: this.id, + data: this._data, + }; + } + canBuildEdits() { + return this._prevData !== void 0; + } + buildEdits() { + if (this._prevData !== void 0) { + return { + resultId: this.id, + edits: new SemanticTokensDiff( + this._prevData, + this._data + ).computeDiff(), + }; + } else { + return this.build(); + } + } + }; + exports.SemanticTokensBuilder = SemanticTokensBuilder; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/showDocument.js + let require_showDocument = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/showDocument.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ShowDocumentFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let ShowDocumentFeature = (Base) => { + return class extends Base { + showDocument(params) { + return this.connection.sendRequest( + vscode_languageserver_protocol_1.ShowDocumentRequest.type, + params + ); + } + }; + }; + exports.ShowDocumentFeature = ShowDocumentFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/fileOperations.js + let require_fileOperations = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/fileOperations.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.FileOperationsFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let FileOperationsFeature = (Base) => { + return class extends Base { + onDidCreateFiles(handler) { + this.connection.onNotification( + vscode_languageserver_protocol_1.DidCreateFilesNotification.type, + (params) => { + handler(params); + } + ); + } + onDidRenameFiles(handler) { + this.connection.onNotification( + vscode_languageserver_protocol_1.DidRenameFilesNotification.type, + (params) => { + handler(params); + } + ); + } + onDidDeleteFiles(handler) { + this.connection.onNotification( + vscode_languageserver_protocol_1.DidDeleteFilesNotification.type, + (params) => { + handler(params); + } + ); + } + onWillCreateFiles(handler) { + return this.connection.onRequest( + vscode_languageserver_protocol_1.WillCreateFilesRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ); + } + onWillRenameFiles(handler) { + return this.connection.onRequest( + vscode_languageserver_protocol_1.WillRenameFilesRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ); + } + onWillDeleteFiles(handler) { + return this.connection.onRequest( + vscode_languageserver_protocol_1.WillDeleteFilesRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ); + } + }; + }; + exports.FileOperationsFeature = FileOperationsFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/linkedEditingRange.js + let require_linkedEditingRange = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/linkedEditingRange.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.LinkedEditingRangeFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let LinkedEditingRangeFeature = (Base) => { + return class extends Base { + onLinkedEditingRange(handler) { + this.connection.onRequest( + vscode_languageserver_protocol_1.LinkedEditingRangeRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + void 0 + ); + } + ); + } + }; + }; + exports.LinkedEditingRangeFeature = LinkedEditingRangeFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/moniker.js + let require_moniker = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/moniker.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.MonikerFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let MonikerFeature = (Base) => { + return class extends Base { + get moniker() { + return { + on: (handler) => { + const type = + vscode_languageserver_protocol_1.MonikerRequest.type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + }; + } + }; + }; + exports.MonikerFeature = MonikerFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/server.js + let require_server = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/server.js'(exports) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createConnection = exports.combineFeatures = exports.combineLanguagesFeatures = exports.combineWorkspaceFeatures = exports.combineWindowFeatures = exports.combineClientFeatures = exports.combineTracerFeatures = exports.combineTelemetryFeatures = exports.combineConsoleFeatures = exports._LanguagesImpl = exports.BulkUnregistration = exports.BulkRegistration = exports.ErrorMessageTracker = exports.TextDocuments = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let Is = require_is3(); + let UUID = require_uuid(); + let progress_1 = require_progress(); + let configuration_1 = require_configuration(); + let workspaceFolders_1 = require_workspaceFolders(); + let callHierarchy_1 = require_callHierarchy(); + let semanticTokens_1 = require_semanticTokens(); + let showDocument_1 = require_showDocument(); + let fileOperations_1 = require_fileOperations(); + let linkedEditingRange_1 = require_linkedEditingRange(); + let moniker_1 = require_moniker(); + function null2Undefined(value) { + if (value === null) { + return void 0; + } + return value; + } + let TextDocuments2 = class { + constructor(configuration) { + this._documents = Object.create(null); + this._configuration = configuration; + this._onDidChangeContent = new vscode_languageserver_protocol_1.Emitter(); + this._onDidOpen = new vscode_languageserver_protocol_1.Emitter(); + this._onDidClose = new vscode_languageserver_protocol_1.Emitter(); + this._onDidSave = new vscode_languageserver_protocol_1.Emitter(); + this._onWillSave = new vscode_languageserver_protocol_1.Emitter(); + } + get onDidChangeContent() { + return this._onDidChangeContent.event; + } + get onDidOpen() { + return this._onDidOpen.event; + } + get onWillSave() { + return this._onWillSave.event; + } + onWillSaveWaitUntil(handler) { + this._willSaveWaitUntil = handler; + } + get onDidSave() { + return this._onDidSave.event; + } + get onDidClose() { + return this._onDidClose.event; + } + get(uri) { + return this._documents[uri]; + } + all() { + return Object.keys(this._documents).map( + (key) => this._documents[key] + ); + } + keys() { + return Object.keys(this._documents); + } + listen(connection2) { + connection2.__textDocumentSync = + vscode_languageserver_protocol_1.TextDocumentSyncKind.Full; + connection2.onDidOpenTextDocument((event) => { + let td = event.textDocument; + let document2 = this._configuration.create( + td.uri, + td.languageId, + td.version, + td.text + ); + this._documents[td.uri] = document2; + let toFire = Object.freeze({ document: document2 }); + this._onDidOpen.fire(toFire); + this._onDidChangeContent.fire(toFire); + }); + connection2.onDidChangeTextDocument((event) => { + let td = event.textDocument; + let changes = event.contentChanges; + if (changes.length === 0) { + return; + } + let document2 = this._documents[td.uri]; + const { version } = td; + if (version === null || version === void 0) { + throw new Error( + `Received document change event for ${td.uri} without valid version identifier` + ); + } + document2 = this._configuration.update(document2, changes, version); + this._documents[td.uri] = document2; + this._onDidChangeContent.fire( + Object.freeze({ document: document2 }) + ); + }); + connection2.onDidCloseTextDocument((event) => { + let document2 = this._documents[event.textDocument.uri]; + if (document2) { + delete this._documents[event.textDocument.uri]; + this._onDidClose.fire(Object.freeze({ document: document2 })); + } + }); + connection2.onWillSaveTextDocument((event) => { + let document2 = this._documents[event.textDocument.uri]; + if (document2) { + this._onWillSave.fire( + Object.freeze({ document: document2, reason: event.reason }) + ); + } + }); + connection2.onWillSaveTextDocumentWaitUntil((event, token) => { + let document2 = this._documents[event.textDocument.uri]; + if (document2 && this._willSaveWaitUntil) { + return this._willSaveWaitUntil( + Object.freeze({ document: document2, reason: event.reason }), + token + ); + } else { + return []; + } + }); + connection2.onDidSaveTextDocument((event) => { + let document2 = this._documents[event.textDocument.uri]; + if (document2) { + this._onDidSave.fire(Object.freeze({ document: document2 })); + } + }); + } + }; + exports.TextDocuments = TextDocuments2; + let ErrorMessageTracker = class { + constructor() { + this._messages = Object.create(null); + } + add(message) { + let count = this._messages[message]; + if (!count) { + count = 0; + } + count++; + this._messages[message] = count; + } + sendErrors(connection2) { + Object.keys(this._messages).forEach((message) => { + connection2.window.showErrorMessage(message); + }); + } + }; + exports.ErrorMessageTracker = ErrorMessageTracker; + let RemoteConsoleImpl = class { + constructor() {} + rawAttach(connection2) { + this._rawConnection = connection2; + } + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + fillServerCapabilities(_capabilities) {} + initialize(_capabilities) {} + error(message) { + this.send( + vscode_languageserver_protocol_1.MessageType.Error, + message + ); + } + warn(message) { + this.send( + vscode_languageserver_protocol_1.MessageType.Warning, + message + ); + } + info(message) { + this.send(vscode_languageserver_protocol_1.MessageType.Info, message); + } + log(message) { + this.send(vscode_languageserver_protocol_1.MessageType.Log, message); + } + send(type, message) { + if (this._rawConnection) { + this._rawConnection + .sendNotification( + vscode_languageserver_protocol_1.LogMessageNotification.type, + { type, message } + ) + .catch(() => { + (0, vscode_languageserver_protocol_1.RAL)().console.error( + `Sending log message failed` + ); + }); + } + } + }; + let _RemoteWindowImpl = class { + constructor() {} + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + initialize(_capabilities) {} + fillServerCapabilities(_capabilities) {} + showErrorMessage(message, ...actions) { + let params = { + type: vscode_languageserver_protocol_1.MessageType.Error, + message, + actions, + }; + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.ShowMessageRequest.type, + params + ) + .then(null2Undefined); + } + showWarningMessage(message, ...actions) { + let params = { + type: vscode_languageserver_protocol_1.MessageType.Warning, + message, + actions, + }; + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.ShowMessageRequest.type, + params + ) + .then(null2Undefined); + } + showInformationMessage(message, ...actions) { + let params = { + type: vscode_languageserver_protocol_1.MessageType.Info, + message, + actions, + }; + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.ShowMessageRequest.type, + params + ) + .then(null2Undefined); + } + }; + let RemoteWindowImpl = (0, showDocument_1.ShowDocumentFeature)( + (0, progress_1.ProgressFeature)(_RemoteWindowImpl) + ); + let BulkRegistration; + (function (BulkRegistration2) { + function create() { + return new BulkRegistrationImpl(); + } + BulkRegistration2.create = create; + })( + (BulkRegistration = + exports.BulkRegistration || (exports.BulkRegistration = {})) + ); + var BulkRegistrationImpl = class { + constructor() { + this._registrations = []; + this._registered = new Set(); + } + add(type, registerOptions) { + const method = Is.string(type) ? type : type.method; + if (this._registered.has(method)) { + throw new Error(`${method} is already added to this registration`); + } + const id = UUID.generateUuid(); + this._registrations.push({ + id, + method, + registerOptions: registerOptions || {}, + }); + this._registered.add(method); + } + asRegistrationParams() { + return { + registrations: this._registrations, + }; + } + }; + let BulkUnregistration; + (function (BulkUnregistration2) { + function create() { + return new BulkUnregistrationImpl(void 0, []); + } + BulkUnregistration2.create = create; + })( + (BulkUnregistration = + exports.BulkUnregistration || (exports.BulkUnregistration = {})) + ); + var BulkUnregistrationImpl = class { + constructor(_connection, unregistrations) { + this._connection = _connection; + this._unregistrations = new Map(); + unregistrations.forEach((unregistration) => { + this._unregistrations.set(unregistration.method, unregistration); + }); + } + get isAttached() { + return !!this._connection; + } + attach(connection2) { + this._connection = connection2; + } + add(unregistration) { + this._unregistrations.set(unregistration.method, unregistration); + } + dispose() { + let unregistrations = []; + for (let unregistration of this._unregistrations.values()) { + unregistrations.push(unregistration); + } + let params = { + unregisterations: unregistrations, + }; + this._connection + .sendRequest( + vscode_languageserver_protocol_1.UnregistrationRequest.type, + params + ) + .catch(() => { + this._connection.console.info(`Bulk unregistration failed.`); + }); + } + disposeSingle(arg) { + const method = Is.string(arg) ? arg : arg.method; + const unregistration = this._unregistrations.get(method); + if (!unregistration) { + return false; + } + let params = { + unregisterations: [unregistration], + }; + this._connection + .sendRequest( + vscode_languageserver_protocol_1.UnregistrationRequest.type, + params + ) + .then( + () => { + this._unregistrations.delete(method); + }, + (_error) => { + this._connection.console.info( + `Un-registering request handler for ${unregistration.id} failed.` + ); + } + ); + return true; + } + }; + let RemoteClientImpl = class { + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + initialize(_capabilities) {} + fillServerCapabilities(_capabilities) {} + register(typeOrRegistrations, registerOptionsOrType, registerOptions) { + if (typeOrRegistrations instanceof BulkRegistrationImpl) { + return this.registerMany(typeOrRegistrations); + } else if (typeOrRegistrations instanceof BulkUnregistrationImpl) { + return this.registerSingle1( + typeOrRegistrations, + registerOptionsOrType, + registerOptions + ); + } else { + return this.registerSingle2( + typeOrRegistrations, + registerOptionsOrType + ); + } + } + registerSingle1(unregistration, type, registerOptions) { + const method = Is.string(type) ? type : type.method; + const id = UUID.generateUuid(); + let params = { + registrations: [ + { id, method, registerOptions: registerOptions || {} }, + ], + }; + if (!unregistration.isAttached) { + unregistration.attach(this.connection); + } + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.RegistrationRequest.type, + params + ) + .then( + (_result) => { + unregistration.add({ id, method }); + return unregistration; + }, + (_error) => { + this.connection.console.info( + `Registering request handler for ${method} failed.` + ); + return Promise.reject(_error); + } + ); + } + registerSingle2(type, registerOptions) { + const method = Is.string(type) ? type : type.method; + const id = UUID.generateUuid(); + let params = { + registrations: [ + { id, method, registerOptions: registerOptions || {} }, + ], + }; + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.RegistrationRequest.type, + params + ) + .then( + (_result) => { + return vscode_languageserver_protocol_1.Disposable.create( + () => { + this.unregisterSingle(id, method).catch(() => { + this.connection.console.info( + `Un-registering capability with id ${id} failed.` + ); + }); + } + ); + }, + (_error) => { + this.connection.console.info( + `Registering request handler for ${method} failed.` + ); + return Promise.reject(_error); + } + ); + } + unregisterSingle(id, method) { + let params = { + unregisterations: [{ id, method }], + }; + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.UnregistrationRequest.type, + params + ) + .catch(() => { + this.connection.console.info( + `Un-registering request handler for ${id} failed.` + ); + }); + } + registerMany(registrations) { + let params = registrations.asRegistrationParams(); + return this.connection + .sendRequest( + vscode_languageserver_protocol_1.RegistrationRequest.type, + params + ) + .then( + () => { + return new BulkUnregistrationImpl( + this._connection, + params.registrations.map((registration) => { + return { id: registration.id, method: registration.method }; + }) + ); + }, + (_error) => { + this.connection.console.info(`Bulk registration failed.`); + return Promise.reject(_error); + } + ); + } + }; + let _RemoteWorkspaceImpl = class { + constructor() {} + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + initialize(_capabilities) {} + fillServerCapabilities(_capabilities) {} + applyEdit(paramOrEdit) { + function isApplyWorkspaceEditParams(value) { + return value && !!value.edit; + } + let params = isApplyWorkspaceEditParams(paramOrEdit) + ? paramOrEdit + : { edit: paramOrEdit }; + return this.connection.sendRequest( + vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, + params + ); + } + }; + let RemoteWorkspaceImpl = (0, fileOperations_1.FileOperationsFeature)( + (0, workspaceFolders_1.WorkspaceFoldersFeature)( + (0, configuration_1.ConfigurationFeature)(_RemoteWorkspaceImpl) + ) + ); + let TracerImpl = class { + constructor() { + this._trace = vscode_languageserver_protocol_1.Trace.Off; + } + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + initialize(_capabilities) {} + fillServerCapabilities(_capabilities) {} + set trace(value) { + this._trace = value; + } + log(message, verbose) { + if (this._trace === vscode_languageserver_protocol_1.Trace.Off) { + return; + } + this.connection.sendNotification( + vscode_languageserver_protocol_1.LogTraceNotification.type, + { + message, + verbose: + this._trace === vscode_languageserver_protocol_1.Trace.Verbose + ? verbose + : void 0, + } + ); + } + }; + let TelemetryImpl = class { + constructor() {} + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + initialize(_capabilities) {} + fillServerCapabilities(_capabilities) {} + logEvent(data) { + this.connection.sendNotification( + vscode_languageserver_protocol_1.TelemetryEventNotification.type, + data + ); + } + }; + let _LanguagesImpl = class { + constructor() {} + attach(connection2) { + this._connection = connection2; + } + get connection() { + if (!this._connection) { + throw new Error('Remote is not attached to a connection yet.'); + } + return this._connection; + } + initialize(_capabilities) {} + fillServerCapabilities(_capabilities) {} + attachWorkDoneProgress(params) { + return (0, progress_1.attachWorkDone)(this.connection, params); + } + attachPartialResultProgress(_type, params) { + return (0, progress_1.attachPartialResult)(this.connection, params); + } + }; + exports._LanguagesImpl = _LanguagesImpl; + let LanguagesImpl = (0, moniker_1.MonikerFeature)( + (0, linkedEditingRange_1.LinkedEditingRangeFeature)( + (0, semanticTokens_1.SemanticTokensFeature)( + (0, callHierarchy_1.CallHierarchyFeature)(_LanguagesImpl) + ) + ) + ); + function combineConsoleFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineConsoleFeatures = combineConsoleFeatures; + function combineTelemetryFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineTelemetryFeatures = combineTelemetryFeatures; + function combineTracerFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineTracerFeatures = combineTracerFeatures; + function combineClientFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineClientFeatures = combineClientFeatures; + function combineWindowFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineWindowFeatures = combineWindowFeatures; + function combineWorkspaceFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineWorkspaceFeatures = combineWorkspaceFeatures; + function combineLanguagesFeatures(one, two) { + return function (Base) { + return two(one(Base)); + }; + } + exports.combineLanguagesFeatures = combineLanguagesFeatures; + function combineFeatures(one, two) { + function combine(one2, two2, func) { + if (one2 && two2) { + return func(one2, two2); + } else if (one2) { + return one2; + } else { + return two2; + } + } + let result = { + __brand: 'features', + console: combine(one.console, two.console, combineConsoleFeatures), + tracer: combine(one.tracer, two.tracer, combineTracerFeatures), + telemetry: combine( + one.telemetry, + two.telemetry, + combineTelemetryFeatures + ), + client: combine(one.client, two.client, combineClientFeatures), + window: combine(one.window, two.window, combineWindowFeatures), + workspace: combine( + one.workspace, + two.workspace, + combineWorkspaceFeatures + ), + }; + return result; + } + exports.combineFeatures = combineFeatures; + function createConnection2(connectionFactory, watchDog, factories) { + const logger = + factories && factories.console + ? new (factories.console(RemoteConsoleImpl))() + : new RemoteConsoleImpl(); + const connection2 = connectionFactory(logger); + logger.rawAttach(connection2); + const tracer = + factories && factories.tracer + ? new (factories.tracer(TracerImpl))() + : new TracerImpl(); + const telemetry = + factories && factories.telemetry + ? new (factories.telemetry(TelemetryImpl))() + : new TelemetryImpl(); + const client = + factories && factories.client + ? new (factories.client(RemoteClientImpl))() + : new RemoteClientImpl(); + const remoteWindow = + factories && factories.window + ? new (factories.window(RemoteWindowImpl))() + : new RemoteWindowImpl(); + const workspace = + factories && factories.workspace + ? new (factories.workspace(RemoteWorkspaceImpl))() + : new RemoteWorkspaceImpl(); + const languages = + factories && factories.languages + ? new (factories.languages(LanguagesImpl))() + : new LanguagesImpl(); + const allRemotes = [ + logger, + tracer, + telemetry, + client, + remoteWindow, + workspace, + languages, + ]; + function asPromise(value) { + if (value instanceof Promise) { + return value; + } else if (Is.thenable(value)) { + return new Promise((resolve, reject) => { + value.then( + (resolved) => resolve(resolved), + (error) => reject(error) + ); + }); + } else { + return Promise.resolve(value); + } + } + let shutdownHandler = void 0; + let initializeHandler = void 0; + let exitHandler = void 0; + let protocolConnection = { + listen: () => connection2.listen(), + sendRequest: (type, ...params) => + connection2.sendRequest( + Is.string(type) ? type : type.method, + ...params + ), + onRequest: (type, handler) => connection2.onRequest(type, handler), + sendNotification: (type, param) => { + const method = Is.string(type) ? type : type.method; + if (arguments.length === 1) { + return connection2.sendNotification(method); + } else { + return connection2.sendNotification(method, param); + } + }, + onNotification: (type, handler) => + connection2.onNotification(type, handler), + onProgress: connection2.onProgress, + sendProgress: connection2.sendProgress, + onInitialize: (handler) => (initializeHandler = handler), + onInitialized: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.InitializedNotification.type, + handler + ), + onShutdown: (handler) => (shutdownHandler = handler), + onExit: (handler) => (exitHandler = handler), + get console() { + return logger; + }, + get telemetry() { + return telemetry; + }, + get tracer() { + return tracer; + }, + get client() { + return client; + }, + get window() { + return remoteWindow; + }, + get workspace() { + return workspace; + }, + get languages() { + return languages; + }, + onDidChangeConfiguration: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1 + .DidChangeConfigurationNotification.type, + handler + ), + onDidChangeWatchedFiles: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification + .type, + handler + ), + __textDocumentSync: void 0, + onDidOpenTextDocument: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.DidOpenTextDocumentNotification + .type, + handler + ), + onDidChangeTextDocument: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.DidChangeTextDocumentNotification + .type, + handler + ), + onDidCloseTextDocument: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.DidCloseTextDocumentNotification + .type, + handler + ), + onWillSaveTextDocument: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.WillSaveTextDocumentNotification + .type, + handler + ), + onWillSaveTextDocumentWaitUntil: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1 + .WillSaveTextDocumentWaitUntilRequest.type, + handler + ), + onDidSaveTextDocument: (handler) => + connection2.onNotification( + vscode_languageserver_protocol_1.DidSaveTextDocumentNotification + .type, + handler + ), + sendDiagnostics: (params) => + connection2.sendNotification( + vscode_languageserver_protocol_1.PublishDiagnosticsNotification + .type, + params + ), + onHover: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.HoverRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + } + ), + onCompletion: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.CompletionRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onCompletionResolve: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.CompletionResolveRequest.type, + handler + ), + onSignatureHelp: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.SignatureHelpRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + } + ), + onDeclaration: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DeclarationRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onDefinition: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DefinitionRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onTypeDefinition: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.TypeDefinitionRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onImplementation: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.ImplementationRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onReferences: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.ReferencesRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onDocumentHighlight: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentHighlightRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onDocumentSymbol: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentSymbolRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onWorkspaceSymbol: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onWorkspaceSymbolResolve: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest + .type, + handler + ), + onCodeAction: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.CodeActionRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onCodeActionResolve: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.CodeActionResolveRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ), + onCodeLens: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.CodeLensRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onCodeLensResolve: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.CodeLensResolveRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ), + onDocumentFormatting: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentFormattingRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + } + ), + onDocumentRangeFormatting: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentRangeFormattingRequest + .type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + } + ), + onDocumentOnTypeFormatting: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest + .type, + (params, cancel) => { + return handler(params, cancel); + } + ), + onRenameRequest: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.RenameRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + } + ), + onPrepareRename: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.PrepareRenameRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ), + onDocumentLinks: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentLinkRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onDocumentLinkResolve: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, + (params, cancel) => { + return handler(params, cancel); + } + ), + onDocumentColor: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.DocumentColorRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onColorPresentation: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.ColorPresentationRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onFoldingRanges: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.FoldingRangeRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onSelectionRanges: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.SelectionRangeRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + (0, progress_1.attachPartialResult)(connection2, params) + ); + } + ), + onExecuteCommand: (handler) => + connection2.onRequest( + vscode_languageserver_protocol_1.ExecuteCommandRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + } + ), + dispose: () => connection2.dispose(), + }; + for (let remote of allRemotes) { + remote.attach(protocolConnection); + } + connection2.onRequest( + vscode_languageserver_protocol_1.InitializeRequest.type, + (params) => { + watchDog.initialize(params); + if (Is.string(params.trace)) { + tracer.trace = vscode_languageserver_protocol_1.Trace.fromString( + params.trace + ); + } + for (let remote of allRemotes) { + remote.initialize(params.capabilities); + } + if (initializeHandler) { + let result = initializeHandler( + params, + new vscode_languageserver_protocol_1.CancellationTokenSource() + .token, + (0, progress_1.attachWorkDone)(connection2, params), + void 0 + ); + return asPromise(result).then((value) => { + if ( + value instanceof + vscode_languageserver_protocol_1.ResponseError + ) { + return value; + } + let result2 = value; + if (!result2) { + result2 = { capabilities: {} }; + } + let capabilities = result2.capabilities; + if (!capabilities) { + capabilities = {}; + result2.capabilities = capabilities; + } + if ( + capabilities.textDocumentSync === void 0 || + capabilities.textDocumentSync === null + ) { + capabilities.textDocumentSync = Is.number( + protocolConnection.__textDocumentSync + ) + ? protocolConnection.__textDocumentSync + : vscode_languageserver_protocol_1.TextDocumentSyncKind + .None; + } else if ( + !Is.number(capabilities.textDocumentSync) && + !Is.number(capabilities.textDocumentSync.change) + ) { + capabilities.textDocumentSync.change = Is.number( + protocolConnection.__textDocumentSync + ) + ? protocolConnection.__textDocumentSync + : vscode_languageserver_protocol_1.TextDocumentSyncKind + .None; + } + for (let remote of allRemotes) { + remote.fillServerCapabilities(capabilities); + } + return result2; + }); + } else { + let result = { + capabilities: { + textDocumentSync: + vscode_languageserver_protocol_1.TextDocumentSyncKind.None, + }, + }; + for (let remote of allRemotes) { + remote.fillServerCapabilities(result.capabilities); + } + return result; + } + } + ); + connection2.onRequest( + vscode_languageserver_protocol_1.ShutdownRequest.type, + () => { + watchDog.shutdownReceived = true; + if (shutdownHandler) { + return shutdownHandler( + new vscode_languageserver_protocol_1.CancellationTokenSource() + .token + ); + } else { + return void 0; + } + } + ); + connection2.onNotification( + vscode_languageserver_protocol_1.ExitNotification.type, + () => { + try { + if (exitHandler) { + exitHandler(); + } + } finally { + if (watchDog.shutdownReceived) { + watchDog.exit(0); + } else { + watchDog.exit(1); + } + } + } + ); + connection2.onNotification( + vscode_languageserver_protocol_1.SetTraceNotification.type, + (params) => { + tracer.trace = vscode_languageserver_protocol_1.Trace.fromString( + params.value + ); + } + ); + return protocolConnection; + } + exports.createConnection = createConnection2; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/proposed.diagnostic.js + let require_proposed_diagnostic2 = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/proposed.diagnostic.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.DiagnosticFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let DiagnosticFeature = (Base) => { + return class extends Base { + get diagnostics() { + return { + refresh: () => { + return this.connection.sendRequest( + vscode_languageserver_protocol_1.Proposed + .DiagnosticRefreshRequest.type + ); + }, + on: (handler) => { + this.connection.onRequest( + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress( + vscode_languageserver_protocol_1.Proposed + .DocumentDiagnosticRequest.partialResult, + params + ) + ); + } + ); + }, + onWorkspace: (handler) => { + this.connection.onRequest( + vscode_languageserver_protocol_1.Proposed + .WorkspaceDiagnosticRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress( + vscode_languageserver_protocol_1.Proposed + .WorkspaceDiagnosticRequest.partialResult, + params + ) + ); + } + ); + }, + }; + } + }; + }; + exports.DiagnosticFeature = DiagnosticFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/proposed.typeHierarchy.js + let require_proposed_typeHierarchy2 = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/proposed.typeHierarchy.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.TypeHierarchyFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let TypeHierarchyFeature = (Base) => { + return class extends Base { + get typeHierarchy() { + return { + onPrepare: (handler) => { + this.connection.onRequest( + vscode_languageserver_protocol_1.Proposed + .TypeHierarchyPrepareRequest.type, + (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + void 0 + ); + } + ); + }, + onSupertypes: (handler) => { + const type = + vscode_languageserver_protocol_1.Proposed + .TypeHierarchySupertypesRequest.type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + onSubtypes: (handler) => { + const type = + vscode_languageserver_protocol_1.Proposed + .TypeHierarchySubtypesRequest.type; + this.connection.onRequest(type, (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params), + this.attachPartialResultProgress(type, params) + ); + }); + }, + }; + } + }; + }; + exports.TypeHierarchyFeature = TypeHierarchyFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/proposed.inlineValues.js + let require_proposed_inlineValues = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/proposed.inlineValues.js'( + exports + ) { + 'use strict'; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.InlineValuesFeature = void 0; + let vscode_languageserver_protocol_1 = require_main3(); + let InlineValuesFeature = (Base) => { + return class extends Base { + get inlineValues() { + return { + on: (handler) => { + this.connection.onRequest( + vscode_languageserver_protocol_1.Proposed.InlineValuesRequest + .type, + (params, cancel) => { + return handler( + params, + cancel, + this.attachWorkDoneProgress(params) + ); + } + ); + }, + }; + } + }; + }; + exports.InlineValuesFeature = InlineValuesFeature; + }, + }); + + // server/node_modules/vscode-languageserver/lib/common/api.js + let require_api3 = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/common/api.js'(exports) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.ProposedFeatures = exports.SemanticTokensBuilder = void 0; + let server_1 = require_server(); + let semanticTokens_1 = require_semanticTokens(); + Object.defineProperty(exports, 'SemanticTokensBuilder', { + enumerable: true, + get: function () { + return semanticTokens_1.SemanticTokensBuilder; + }, + }); + __exportStar(require_main3(), exports); + __exportStar(require_server(), exports); + let proposed_diagnostic_1 = require_proposed_diagnostic2(); + let proposed_typeHierarchy_1 = require_proposed_typeHierarchy2(); + let proposed_inlineValues_1 = require_proposed_inlineValues(); + let ProposedFeatures; + (function (ProposedFeatures2) { + ProposedFeatures2.all = { + __brand: 'features', + languages: (0, server_1.combineLanguagesFeatures)( + proposed_inlineValues_1.InlineValuesFeature, + (0, server_1.combineLanguagesFeatures)( + proposed_typeHierarchy_1.TypeHierarchyFeature, + proposed_diagnostic_1.DiagnosticFeature + ) + ), + }; + })( + (ProposedFeatures = + exports.ProposedFeatures || (exports.ProposedFeatures = {})) + ); + }, + }); + + // server/node_modules/vscode-languageserver-protocol/browser.js + let require_browser2 = __commonJS({ + 'server/node_modules/vscode-languageserver-protocol/browser.js'( + exports, + module + ) { + 'use strict'; + module.exports = require_main3(); + }, + }); + + // server/node_modules/vscode-languageserver/lib/browser/main.js + let require_main4 = __commonJS({ + 'server/node_modules/vscode-languageserver/lib/browser/main.js'(exports) { + 'use strict'; + let __createBinding = + (exports && exports.__createBinding) || + (Object.create + ? function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + Object.defineProperty(o, k2, { + enumerable: true, + get: function () { + return m[k]; + }, + }); + } + : function (o, m, k, k2) { + if (k2 === void 0) { + k2 = k; + } + o[k2] = m[k]; + }); + let __exportStar = + (exports && exports.__exportStar) || + function (m, exports2) { + for (let p in m) { + if ( + p !== 'default' && + !Object.prototype.hasOwnProperty.call(exports2, p) + ) { + __createBinding(exports2, m, p); + } + } + }; + Object.defineProperty(exports, '__esModule', { value: true }); + exports.createConnection = void 0; + let api_1 = require_api3(); + __exportStar(require_browser2(), exports); + __exportStar(require_api3(), exports); + let _shutdownReceived = false; + let watchDog = { + initialize: (_params) => {}, + get shutdownReceived() { + return _shutdownReceived; + }, + set shutdownReceived(value) { + _shutdownReceived = value; + }, + exit: (_code) => {}, + }; + function createConnection2(arg1, arg2, arg3, arg4) { + let factories; + let reader; + let writer; + let options; + if (arg1 !== void 0 && arg1.__brand === 'features') { + factories = arg1; + arg1 = arg2; + arg2 = arg3; + arg3 = arg4; + } + if ( + api_1.ConnectionStrategy.is(arg1) || + api_1.ConnectionOptions.is(arg1) + ) { + options = arg1; + } else { + reader = arg1; + writer = arg2; + options = arg3; + } + const connectionFactory = (logger) => { + return (0, api_1.createProtocolConnection)( + reader, + writer, + logger, + options + ); + }; + return (0, api_1.createConnection)( + connectionFactory, + watchDog, + factories + ); + } + exports.createConnection = createConnection2; + }, + }); + + // server/node_modules/vscode-languageserver/browser.js + let require_browser3 = __commonJS({ + 'server/node_modules/vscode-languageserver/browser.js'(exports, module) { + 'use strict'; + module.exports = require_main4(); + }, + }); + + // server/tree-sitter/tree-sitter.js + let require_tree_sitter = __commonJS({ + 'server/tree-sitter/tree-sitter.js'(exports, module) { + var Module = Module !== void 0 ? Module : {}; + let TreeSitter = (function () { + let e; + class Parser4 { + constructor() { + this.initialize(); + } + initialize() { + throw new Error( + 'cannot construct a Parser before calling `init()`' + ); + } + static init(t) { + return ( + e || + ((Module = Object.assign({}, Module, t)), + (e = new Promise((e2) => { + let t2, + r = {}; + for (t2 in Module) { + Module.hasOwnProperty(t2) && (r[t2] = Module[t2]); + } + let n, + s, + o = [], + _ = './this.program', + a = function (e3, t3) { + throw t3; + }, + u = false, + i = false; + (u = typeof window === 'object'), + (i = typeof importScripts === 'function'), + (n = + typeof process === 'object' && + typeof process.versions === 'object' && + typeof process.versions.node === 'string'), + (s = !u && !n && !i); + let l, + d, + c, + m, + f, + p = ''; + n + ? ((p = i + ? __require('path').dirname(p) + '/' + : __dirname + '/'), + (l = function (e3, t3) { + return ( + m || (m = __require('fs')), + f || (f = __require('path')), + (e3 = f.normalize(e3)), + m.readFileSync(e3, t3 ? null : 'utf8') + ); + }), + (c = function (e3) { + let t3 = l(e3, true); + return ( + t3.buffer || (t3 = new Uint8Array(t3)), P(t3.buffer), t3 + ); + }), + process.argv.length > 1 && + (_ = process.argv[1].replace(/\\/g, '/')), + (o = process.argv.slice(2)), + typeof module !== 'undefined' && (module.exports = Module), + (a = function (e3) { + process.exit(e3); + }), + (Module.inspect = function () { + return '[Emscripten Module object]'; + })) + : s + ? (typeof read !== 'undefined' && + (l = function (e3) { + return read(e3); + }), + (c = function (e3) { + let t3; + return typeof readbuffer === 'function' + ? new Uint8Array(readbuffer(e3)) + : (P(typeof (t3 = read(e3, 'binary')) === 'object'), + t3); + }), + typeof scriptArgs !== 'undefined' + ? (o = scriptArgs) + : arguments !== void 0 && (o = arguments), + typeof quit === 'function' && + (a = function (e3) { + quit(e3); + }), + typeof print !== 'undefined' && + (typeof console === 'undefined' && (console = {}), + (console.log = print), + (console.warn = console.error = + typeof printErr !== 'undefined' ? printErr : print))) + : (u || i) && + (i + ? (p = self.location.href) + : typeof document !== 'undefined' && + document.currentScript && + (p = document.currentScript.src), + (p = + p.indexOf('blob:') !== 0 + ? p.substr(0, p.lastIndexOf('/') + 1) + : ''), + (l = function (e3) { + let t3 = new XMLHttpRequest(); + return ( + t3.open('GET', e3, false), + t3.send(null), + t3.responseText + ); + }), + i && + (c = function (e3) { + let t3 = new XMLHttpRequest(); + return ( + t3.open('GET', e3, false), + (t3.responseType = 'arraybuffer'), + t3.send(null), + new Uint8Array(t3.response) + ); + }), + (d = function (e3, t3, r2) { + let n2 = new XMLHttpRequest(); + n2.open('GET', e3, true), + (n2.responseType = 'arraybuffer'), + (n2.onload = function () { + n2.status == 200 || (n2.status == 0 && n2.response) + ? t3(n2.response) + : r2(); + }), + (n2.onerror = r2), + n2.send(null); + })); + Module.print || console.log.bind(console); + let h = Module.printErr || console.warn.bind(console); + for (t2 in r) { + r.hasOwnProperty(t2) && (Module[t2] = r[t2]); + } + (r = null), + Module.arguments && (o = Module.arguments), + Module.thisProgram && (_ = Module.thisProgram), + Module.quit && (a = Module.quit); + let g = 16; + let w, + y = []; + function M(e3, t3) { + if (!w) { + w = new WeakMap(); + for (let r2 = 0; r2 < B.length; r2++) { + let n2 = B.get(r2); + n2 && w.set(n2, r2); + } + } + if (w.has(e3)) { + return w.get(e3); + } + let s2 = (function () { + if (y.length) { + return y.pop(); + } + try { + B.grow(1); + } catch (e4) { + if (!(e4 instanceof RangeError)) { + throw e4; + } + throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.'; + } + return B.length - 1; + })(); + try { + B.set(s2, e3); + } catch (r3) { + if (!(r3 instanceof TypeError)) { + throw r3; + } + let o2 = (function (e4, t4) { + if (typeof WebAssembly.Function === 'function') { + for ( + var r4 = { i: 'i32', j: 'i64', f: 'f32', d: 'f64' }, + n3 = { + parameters: [], + results: t4[0] == 'v' ? [] : [r4[t4[0]]], + }, + s3 = 1; + s3 < t4.length; + ++s3 + ) { + n3.parameters.push(r4[t4[s3]]); + } + return new WebAssembly.Function(n3, e4); + } + let o3 = [1, 0, 1, 96], + _2 = t4.slice(0, 1), + a2 = t4.slice(1), + u2 = { i: 127, j: 126, f: 125, d: 124 }; + for (o3.push(a2.length), s3 = 0; s3 < a2.length; ++s3) { + o3.push(u2[a2[s3]]); + } + _2 == 'v' ? o3.push(0) : (o3 = o3.concat([1, u2[_2]])), + (o3[1] = o3.length - 2); + let i2 = new Uint8Array( + [0, 97, 115, 109, 1, 0, 0, 0].concat(o3, [ + 2, + 7, + 1, + 1, + 101, + 1, + 102, + 0, + 0, + 7, + 5, + 1, + 1, + 102, + 0, + 0, + ]) + ), + l2 = new WebAssembly.Module(i2); + return new WebAssembly.Instance(l2, { e: { f: e4 } }) + .exports.f; + })(e3, t3); + B.set(s2, o2); + } + return w.set(e3, s2), s2; + } + let b, + v = function (e3) { + e3; + }, + E = Module.dynamicLibraries || []; + Module.wasmBinary && (b = Module.wasmBinary); + let I, + A = Module.noExitRuntime || true; + function S(e3, t3, r2, n2) { + switch ( + ((r2 = r2 || 'i8').charAt(r2.length - 1) === '*' && + (r2 = 'i32'), + r2) + ) { + case 'i1': + case 'i8': + q[e3 >> 0] = t3; + break; + case 'i16': + T[e3 >> 1] = t3; + break; + case 'i32': + L[e3 >> 2] = t3; + break; + case 'i64': + (ae = [ + t3 >>> 0, + ((_e = t3), + +Math.abs(_e) >= 1 + ? _e > 0 + ? (0 | + Math.min( + +Math.floor(_e / 4294967296), + 4294967295 + )) >>> + 0 + : ~~+Math.ceil( + (_e - +(~~_e >>> 0)) / 4294967296 + ) >>> 0 + : 0), + ]), + (L[e3 >> 2] = ae[0]), + (L[(e3 + 4) >> 2] = ae[1]); + break; + case 'float': + W[e3 >> 2] = t3; + break; + case 'double': + O[e3 >> 3] = t3; + break; + default: + se('invalid type for setValue: ' + r2); + } + } + function x(e3, t3, r2) { + switch ( + ((t3 = t3 || 'i8').charAt(t3.length - 1) === '*' && + (t3 = 'i32'), + t3) + ) { + case 'i1': + case 'i8': + return q[e3 >> 0]; + case 'i16': + return T[e3 >> 1]; + case 'i32': + case 'i64': + return L[e3 >> 2]; + case 'float': + return W[e3 >> 2]; + case 'double': + return O[e3 >> 3]; + default: + se('invalid type for getValue: ' + t3); + } + return null; + } + typeof WebAssembly !== 'object' && + se('no native wasm support detected'); + let N = false; + function P(e3, t3) { + e3 || se('Assertion failed: ' + t3); + } + let k = 1; + let C, + q, + R, + T, + L, + W, + O, + Z = + typeof TextDecoder !== 'undefined' + ? new TextDecoder('utf8') + : void 0; + function F(e3, t3, r2) { + for (var n2 = t3 + r2, s2 = t3; e3[s2] && !(s2 >= n2); ) { + ++s2; + } + if (s2 - t3 > 16 && e3.subarray && Z) { + return Z.decode(e3.subarray(t3, s2)); + } + for (var o2 = ''; t3 < s2; ) { + let _2 = e3[t3++]; + if (128 & _2) { + let a2 = 63 & e3[t3++]; + if ((224 & _2) != 192) { + let u2 = 63 & e3[t3++]; + if ( + (_2 = + (240 & _2) == 224 + ? ((15 & _2) << 12) | (a2 << 6) | u2 + : ((7 & _2) << 18) | + (a2 << 12) | + (u2 << 6) | + (63 & e3[t3++])) < 65536 + ) { + o2 += String.fromCharCode(_2); + } else { + let i2 = _2 - 65536; + o2 += String.fromCharCode( + 55296 | (i2 >> 10), + 56320 | (1023 & i2) + ); + } + } else { + o2 += String.fromCharCode(((31 & _2) << 6) | a2); + } + } else { + o2 += String.fromCharCode(_2); + } + } + return o2; + } + function $(e3, t3) { + return e3 ? F(R, e3, t3) : ''; + } + function j(e3, t3, r2, n2) { + if (!(n2 > 0)) { + return 0; + } + for ( + var s2 = r2, o2 = r2 + n2 - 1, _2 = 0; + _2 < e3.length; + ++_2 + ) { + let a2 = e3.charCodeAt(_2); + if (a2 >= 55296 && a2 <= 57343) { + a2 = + (65536 + ((1023 & a2) << 10)) | + (1023 & e3.charCodeAt(++_2)); + } + if (a2 <= 127) { + if (r2 >= o2) { + break; + } + t3[r2++] = a2; + } else if (a2 <= 2047) { + if (r2 + 1 >= o2) { + break; + } + (t3[r2++] = 192 | (a2 >> 6)), + (t3[r2++] = 128 | (63 & a2)); + } else if (a2 <= 65535) { + if (r2 + 2 >= o2) { + break; + } + (t3[r2++] = 224 | (a2 >> 12)), + (t3[r2++] = 128 | ((a2 >> 6) & 63)), + (t3[r2++] = 128 | (63 & a2)); + } else { + if (r2 + 3 >= o2) { + break; + } + (t3[r2++] = 240 | (a2 >> 18)), + (t3[r2++] = 128 | ((a2 >> 12) & 63)), + (t3[r2++] = 128 | ((a2 >> 6) & 63)), + (t3[r2++] = 128 | (63 & a2)); + } + } + return (t3[r2] = 0), r2 - s2; + } + function U(e3, t3, r2) { + return j(e3, R, t3, r2); + } + function D(e3) { + for (var t3 = 0, r2 = 0; r2 < e3.length; ++r2) { + let n2 = e3.charCodeAt(r2); + n2 >= 55296 && + n2 <= 57343 && + (n2 = + (65536 + ((1023 & n2) << 10)) | + (1023 & e3.charCodeAt(++r2))), + n2 <= 127 + ? ++t3 + : (t3 += n2 <= 2047 ? 2 : n2 <= 65535 ? 3 : 4); + } + return t3; + } + function z(e3) { + let t3 = D(e3) + 1, + r2 = De(t3); + return j(e3, q, r2, t3), r2; + } + function G(e3) { + (C = e3), + (Module.HEAP8 = q = new Int8Array(e3)), + (Module.HEAP16 = T = new Int16Array(e3)), + (Module.HEAP32 = L = new Int32Array(e3)), + (Module.HEAPU8 = R = new Uint8Array(e3)), + (Module.HEAPU16 = new Uint16Array(e3)), + (Module.HEAPU32 = new Uint32Array(e3)), + (Module.HEAPF32 = W = new Float32Array(e3)), + (Module.HEAPF64 = O = new Float64Array(e3)); + } + let H = Module.INITIAL_MEMORY || 33554432; + (I = Module.wasmMemory + ? Module.wasmMemory + : new WebAssembly.Memory({ + initial: H / 65536, + maximum: 32768, + })) && (C = I.buffer), + (H = C.byteLength), + G(C); + var B = new WebAssembly.Table({ + initial: 13, + element: 'anyfunc', + }), + K = [], + V = [], + X = [], + Q = [], + J = false; + let Y = 0, + ee = null, + te = null; + function re(e3) { + Y++, + Module.monitorRunDependencies && + Module.monitorRunDependencies(Y); + } + function ne(e3) { + if ( + (Y--, + Module.monitorRunDependencies && + Module.monitorRunDependencies(Y), + Y == 0 && + (ee !== null && (clearInterval(ee), (ee = null)), te)) + ) { + let t3 = te; + (te = null), t3(); + } + } + function se(e3) { + throw ( + (Module.onAbort && Module.onAbort(e3), + h((e3 += '')), + (N = true), + 1, + (e3 = + 'abort(' + + e3 + + '). Build with -s ASSERTIONS=1 for more info.'), + new WebAssembly.RuntimeError(e3)) + ); + } + (Module.preloadedImages = {}), + (Module.preloadedAudios = {}), + (Module.preloadedWasm = {}); + let oe, + _e, + ae, + ue = 'data:application/octet-stream;base64,'; + function ie(e3) { + return e3.startsWith(ue); + } + function le(e3) { + return e3.startsWith('file://'); + } + function de(e3) { + try { + if (e3 == oe && b) { + return new Uint8Array(b); + } + if (c) { + return c(e3); + } + throw 'both async and sync fetching of the wasm failed'; + } catch (e4) { + se(e4); + } + } + ie((oe = 'tree-sitter.wasm')) || + (oe = (function (e3) { + return Module.locateFile + ? Module.locateFile(e3, p) + : p + e3; + })(oe)); + let ce = {}, + me = { + get: function (e3, t3) { + return ( + ce[t3] || + (ce[t3] = new WebAssembly.Global({ + value: 'i32', + mutable: true, + })), + ce[t3] + ); + }, + }; + function fe(e3) { + for (; e3.length > 0; ) { + let t3 = e3.shift(); + if (typeof t3 !== 'function') { + let r2 = t3.func; + typeof r2 === 'number' + ? t3.arg === void 0 + ? B.get(r2)() + : B.get(r2)(t3.arg) + : r2(t3.arg === void 0 ? null : t3.arg); + } else { + t3(Module); + } + } + } + function pe(e3) { + let t3 = 0; + function r2() { + for (var r3 = 0, n3 = 1; ; ) { + let s3 = e3[t3++]; + if (((r3 += (127 & s3) * n3), (n3 *= 128), !(128 & s3))) { + break; + } + } + return r3; + } + if (e3 instanceof WebAssembly.Module) { + let n2 = WebAssembly.Module.customSections(e3, 'dylink'); + P(n2.length != 0, 'need dylink section'), + (e3 = new Int8Array(n2[0])); + } else { + P( + new Uint32Array( + new Uint8Array(e3.subarray(0, 24)).buffer + )[0] == 1836278016, + 'need to see wasm magic number' + ), + P(e3[8] === 0, 'need the dylink section to be first'), + (t3 = 9), + r2(), + P(e3[t3] === 6), + P(e3[++t3] === 'd'.charCodeAt(0)), + P(e3[++t3] === 'y'.charCodeAt(0)), + P(e3[++t3] === 'l'.charCodeAt(0)), + P(e3[++t3] === 'i'.charCodeAt(0)), + P(e3[++t3] === 'n'.charCodeAt(0)), + P(e3[++t3] === 'k'.charCodeAt(0)), + t3++; + } + let s2 = {}; + (s2.memorySize = r2()), + (s2.memoryAlign = r2()), + (s2.tableSize = r2()), + (s2.tableAlign = r2()); + let o2 = r2(); + s2.neededDynlibs = []; + for (let _2 = 0; _2 < o2; ++_2) { + let a2 = r2(), + u2 = e3.subarray(t3, t3 + a2); + t3 += a2; + let i2 = F(u2, 0); + s2.neededDynlibs.push(i2); + } + return s2; + } + let he = 0; + function ge() { + return A || he > 0; + } + function we(e3) { + return e3.indexOf('dynCall_') == 0 || + ['stackAlloc', 'stackSave', 'stackRestore'].includes(e3) + ? e3 + : '_' + e3; + } + function ye(e3, t3) { + for (let r2 in e3) { + if (e3.hasOwnProperty(r2)) { + Ze.hasOwnProperty(r2) || (Ze[r2] = e3[r2]); + let n2 = we(r2); + Module.hasOwnProperty(n2) || (Module[n2] = e3[r2]); + } + } + } + let Me = { nextHandle: 1, loadedLibs: {}, loadedLibNames: {} }; + function be(e3, t3, r2) { + return e3.includes('j') + ? (function (e4, t4, r3) { + let n2 = Module['dynCall_' + e4]; + return r3 && r3.length + ? n2.apply(null, [t4].concat(r3)) + : n2.call(null, t4); + })(e3, t3, r2) + : B.get(t3).apply(null, r2); + } + let ve = 5250816; + function Ee(e3) { + return [ + '__cpp_exception', + '__wasm_apply_data_relocs', + '__dso_handle', + '__set_stack_limits', + ].includes(e3); + } + function Ie(e3, t3) { + let r2 = {}; + for (let n2 in e3) { + let s2 = e3[n2]; + typeof s2 === 'object' && (s2 = s2.value), + typeof s2 === 'number' && (s2 += t3), + (r2[n2] = s2); + } + return ( + (function (e4) { + for (let t4 in e4) { + if (!Ee(t4)) { + let r3 = false, + n3 = e4[t4]; + t4.startsWith('orig$') && + ((t4 = t4.split('$')[1]), (r3 = true)), + ce[t4] || + (ce[t4] = new WebAssembly.Global({ + value: 'i32', + mutable: true, + })), + (r3 || ce[t4].value == 0) && + (typeof n3 === 'function' + ? (ce[t4].value = M(n3)) + : typeof n3 === 'number' + ? (ce[t4].value = n3) + : h( + 'unhandled export type for `' + + t4 + + '`: ' + + typeof n3 + )); + } + } + })(r2), + r2 + ); + } + function Ae(e3, t3) { + let r2, n2; + return ( + t3 && (r2 = Ze['orig$' + e3]), + r2 || (r2 = Ze[e3]), + r2 || (r2 = Module[we(e3)]), + !r2 && + e3.startsWith('invoke_') && + ((n2 = e3.split('_')[1]), + (r2 = function () { + let e4 = je(); + try { + return be( + n2, + arguments[0], + Array.prototype.slice.call(arguments, 1) + ); + } catch (t4) { + if ((Ue(e4), t4 !== t4 + 0 && t4 !== 'longjmp')) { + throw t4; + } + ze(1, 0); + } + })), + r2 + ); + } + function Se(e3, t3) { + let r2 = pe(e3); + function n2() { + let n3 = Math.pow(2, r2.memoryAlign); + n3 = Math.max(n3, g); + let s2, + o2, + _2, + a2 = + ((s2 = (function (e4) { + if (J) { + return Fe(e4); + } + let t4 = ve, + r3 = (t4 + e4 + 15) & -16; + return (ve = r3), (ce.__heap_base.value = r3), t4; + })(r2.memorySize + n3)), + (o2 = n3) || (o2 = g), + Math.ceil(s2 / o2) * o2), + u2 = B.length; + B.grow(r2.tableSize); + for (var i2 = a2; i2 < a2 + r2.memorySize; i2++) { + q[i2] = 0; + } + for (i2 = u2; i2 < u2 + r2.tableSize; i2++) { + B.set(i2, null); + } + let l2 = new Proxy( + {}, + { + get: function (e4, t4) { + switch (t4) { + case '__memory_base': + return a2; + case '__table_base': + return u2; + } + if (t4 in Ze) { + return Ze[t4]; + } + let r3; + t4 in e4 || + (e4[t4] = function () { + return ( + r3 || + (r3 = (function (e5) { + let t5 = Ae(e5, false); + return t5 || (t5 = _2[e5]), t5; + })(t4)), + r3.apply(null, arguments) + ); + }); + return e4[t4]; + }, + } + ), + d2 = { + 'GOT.mem': new Proxy({}, me), + 'GOT.func': new Proxy({}, me), + env: l2, + wasi_snapshot_preview1: l2, + }; + function c2(e4) { + for (let n4 = 0; n4 < r2.tableSize; n4++) { + let s3 = B.get(u2 + n4); + s3 && w.set(s3, u2 + n4); + } + (_2 = Ie(e4.exports, a2)), t3.allowUndefined || Ne(); + let o3 = _2.__wasm_call_ctors; + return ( + o3 || (o3 = _2.__post_instantiate), + o3 && (J ? o3() : V.push(o3)), + _2 + ); + } + if (t3.loadAsync) { + if (e3 instanceof WebAssembly.Module) { + var m2 = new WebAssembly.Instance(e3, d2); + return Promise.resolve(c2(m2)); + } + return WebAssembly.instantiate(e3, d2).then(function ( + e4 + ) { + return c2(e4.instance); + }); + } + let f2 = + e3 instanceof WebAssembly.Module + ? e3 + : new WebAssembly.Module(e3); + return c2((m2 = new WebAssembly.Instance(f2, d2))); + } + return t3.loadAsync + ? r2.neededDynlibs + .reduce(function (e4, r3) { + return e4.then(function () { + return xe(r3, t3); + }); + }, Promise.resolve()) + .then(function () { + return n2(); + }) + : (r2.neededDynlibs.forEach(function (e4) { + xe(e4, t3); + }), + n2()); + } + function xe(e3, t3) { + e3 != '__main__' || + Me.loadedLibNames[e3] || + ((Me.loadedLibs[-1] = { + refcount: 1 / 0, + name: '__main__', + module: Module.asm, + global: true, + }), + (Me.loadedLibNames.__main__ = -1)), + (t3 = t3 || { global: true, nodelete: true }); + let r2, + n2 = Me.loadedLibNames[e3]; + if (n2) { + return ( + (r2 = Me.loadedLibs[n2]), + t3.global && + !r2.global && + ((r2.global = true), + r2.module !== 'loading' && ye(r2.module)), + t3.nodelete && + r2.refcount !== 1 / 0 && + (r2.refcount = 1 / 0), + r2.refcount++, + t3.loadAsync ? Promise.resolve(n2) : n2 + ); + } + function s2(e4) { + if (t3.fs) { + let r3 = t3.fs.readFile(e4, { encoding: 'binary' }); + return ( + r3 instanceof Uint8Array || (r3 = new Uint8Array(r3)), + t3.loadAsync ? Promise.resolve(r3) : r3 + ); + } + return t3.loadAsync + ? ((n3 = e4), + fetch(n3, { credentials: 'same-origin' }) + .then(function (e5) { + if (!e5.ok) { + throw ( + "failed to load binary file at '" + n3 + "'" + ); + } + return e5.arrayBuffer(); + }) + .then(function (e5) { + return new Uint8Array(e5); + })) + : c(e4); + let n3; + } + function o2() { + if ( + Module.preloadedWasm !== void 0 && + Module.preloadedWasm[e3] !== void 0 + ) { + let r3 = Module.preloadedWasm[e3]; + return t3.loadAsync ? Promise.resolve(r3) : r3; + } + return t3.loadAsync + ? s2(e3).then(function (e4) { + return Se(e4, t3); + }) + : Se(s2(e3), t3); + } + function _2(e4) { + r2.global && ye(e4), (r2.module = e4); + } + return ( + (n2 = Me.nextHandle++), + (r2 = { + refcount: t3.nodelete ? 1 / 0 : 1, + name: e3, + module: 'loading', + global: t3.global, + }), + (Me.loadedLibNames[e3] = n2), + (Me.loadedLibs[n2] = r2), + t3.loadAsync + ? o2().then(function (e4) { + return _2(e4), n2; + }) + : (_2(o2()), n2) + ); + } + function Ne() { + for (let e3 in ce) { + if (ce[e3].value == 0) { + let t3 = Ae(e3, true); + typeof t3 === 'function' + ? (ce[e3].value = M(t3, t3.sig)) + : typeof t3 === 'number' + ? (ce[e3].value = t3) + : P( + false, + 'bad export type for `' + e3 + '`: ' + typeof t3 + ); + } + } + } + Module.___heap_base = ve; + let Pe, + ke = new WebAssembly.Global( + { value: 'i32', mutable: true }, + 5250816 + ); + function Ce() { + se(); + } + (Module._abort = Ce), + (Ce.sig = 'v'), + (Pe = n + ? function () { + let e3 = process.hrtime(); + return 1e3 * e3[0] + e3[1] / 1e6; + } + : typeof dateNow !== 'undefined' + ? dateNow + : function () { + return performance.now(); + }); + let qe = true; + function Re(e3, t3) { + let r2, n2; + if (e3 === 0) { + r2 = Date.now(); + } else { + if ((e3 !== 1 && e3 !== 4) || !qe) { + return (n2 = 28), (L[$e() >> 2] = n2), -1; + } + r2 = Pe(); + } + return ( + (L[t3 >> 2] = (r2 / 1e3) | 0), + (L[(t3 + 4) >> 2] = ((r2 % 1e3) * 1e3 * 1e3) | 0), + 0 + ); + } + function Te(e3) { + try { + return ( + I.grow((e3 - C.byteLength + 65535) >>> 16), G(I.buffer), 1 + ); + } catch (e4) {} + } + function Le(e3) { + Ke(e3); + } + function We(e3) { + v(e3); + } + (Re.sig = 'iii'), (Le.sig = 'vi'), (We.sig = 'vi'); + var Oe, + Ze = { + __heap_base: ve, + __indirect_function_table: B, + __memory_base: 1024, + __stack_pointer: ke, + __table_base: 1, + abort: Ce, + clock_gettime: Re, + emscripten_memcpy_big: function (e3, t3, r2) { + R.copyWithin(e3, t3, t3 + r2); + }, + emscripten_resize_heap: function (e3) { + let t3, + r2, + n2 = R.length; + if ((e3 >>>= 0) > 2147483648) { + return false; + } + for (let s2 = 1; s2 <= 4; s2 *= 2) { + let o2 = n2 * (1 + 0.2 / s2); + if ( + ((o2 = Math.min(o2, e3 + 100663296)), + Te( + Math.min( + 2147483648, + ((t3 = Math.max(e3, o2)) % (r2 = 65536) > 0 && + (t3 += r2 - (t3 % r2)), + t3) + ) + )) + ) { + return true; + } + } + return false; + }, + exit: Le, + memory: I, + setTempRet0: We, + tree_sitter_log_callback: function (e3, t3) { + if (dt) { + const r2 = $(t3); + dt(r2, e3 !== 0); + } + }, + tree_sitter_parse_callback: function (e3, t3, r2, n2, s2) { + let o2 = lt(t3, { row: r2, column: n2 }); + typeof o2 === 'string' + ? (S(s2, o2.length, 'i32'), + (function (e4, t4, r3) { + if ((r3 === void 0 && (r3 = 2147483647), r3 < 2)) { + return 0; + } + for ( + let n3 = + (r3 -= 2) < 2 * e4.length + ? r3 / 2 + : e4.length, + s3 = 0; + s3 < n3; + ++s3 + ) { + let o3 = e4.charCodeAt(s3); + (T[t4 >> 1] = o3), (t4 += 2); + } + T[t4 >> 1] = 0; + })(o2, e3, 10240)) + : S(s2, 0, 'i32'); + }, + }, + Fe = + ((function () { + let e3 = { + env: Ze, + wasi_snapshot_preview1: Ze, + 'GOT.mem': new Proxy(Ze, me), + 'GOT.func': new Proxy(Ze, me), + }; + function t3(e4, t4) { + let r3 = e4.exports; + (r3 = Ie(r3, 1024)), (Module.asm = r3); + let n3, + s2 = pe(t4); + s2.neededDynlibs && (E = s2.neededDynlibs.concat(E)), + ye(r3), + (n3 = Module.asm.__wasm_call_ctors), + V.unshift(n3), + ne(); + } + function r2(e4) { + t3(e4.instance, e4.module); + } + function n2(t4) { + return (function () { + if (!b && (u || i)) { + if (typeof fetch === 'function' && !le(oe)) { + return fetch(oe, { credentials: 'same-origin' }) + .then(function (e4) { + if (!e4.ok) { + throw ( + "failed to load wasm binary file at '" + + oe + + "'" + ); + } + return e4.arrayBuffer(); + }) + .catch(function () { + return de(oe); + }); + } + if (d) { + return new Promise(function (e4, t5) { + d( + oe, + function (t6) { + e4(new Uint8Array(t6)); + }, + t5 + ); + }); + } + } + return Promise.resolve().then(function () { + return de(oe); + }); + })() + .then(function (t5) { + return WebAssembly.instantiate(t5, e3); + }) + .then(t4, function (e4) { + h('failed to asynchronously prepare wasm: ' + e4), + se(e4); + }); + } + if ((re(), Module.instantiateWasm)) { + try { + return Module.instantiateWasm(e3, t3); + } catch (e4) { + return ( + h( + 'Module.instantiateWasm callback failed with error: ' + + e4 + ), + false + ); + } + } + b || + typeof WebAssembly.instantiateStreaming !== 'function' || + ie(oe) || + le(oe) || + typeof fetch !== 'function' + ? n2(r2) + : fetch(oe, { credentials: 'same-origin' }).then( + function (t4) { + return WebAssembly.instantiateStreaming( + t4, + e3 + ).then(r2, function (e4) { + return ( + h('wasm streaming compile failed: ' + e4), + h( + 'falling back to ArrayBuffer instantiation' + ), + n2(r2) + ); + }); + } + ); + })(), + (Module.___wasm_call_ctors = function () { + return (Module.___wasm_call_ctors = + Module.asm.__wasm_call_ctors).apply(null, arguments); + }), + (Module._malloc = function () { + return (Fe = Module._malloc = Module.asm.malloc).apply( + null, + arguments + ); + })), + $e = + ((Module._ts_language_symbol_count = function () { + return (Module._ts_language_symbol_count = + Module.asm.ts_language_symbol_count).apply( + null, + arguments + ); + }), + (Module._ts_language_version = function () { + return (Module._ts_language_version = + Module.asm.ts_language_version).apply(null, arguments); + }), + (Module._ts_language_field_count = function () { + return (Module._ts_language_field_count = + Module.asm.ts_language_field_count).apply( + null, + arguments + ); + }), + (Module._ts_language_symbol_name = function () { + return (Module._ts_language_symbol_name = + Module.asm.ts_language_symbol_name).apply( + null, + arguments + ); + }), + (Module._ts_language_symbol_for_name = function () { + return (Module._ts_language_symbol_for_name = + Module.asm.ts_language_symbol_for_name).apply( + null, + arguments + ); + }), + (Module._ts_language_symbol_type = function () { + return (Module._ts_language_symbol_type = + Module.asm.ts_language_symbol_type).apply( + null, + arguments + ); + }), + (Module._ts_language_field_name_for_id = function () { + return (Module._ts_language_field_name_for_id = + Module.asm.ts_language_field_name_for_id).apply( + null, + arguments + ); + }), + (Module._memcpy = function () { + return (Module._memcpy = Module.asm.memcpy).apply( + null, + arguments + ); + }), + (Module._free = function () { + return (Module._free = Module.asm.free).apply( + null, + arguments + ); + }), + (Module._calloc = function () { + return (Module._calloc = Module.asm.calloc).apply( + null, + arguments + ); + }), + (Module._ts_parser_delete = function () { + return (Module._ts_parser_delete = + Module.asm.ts_parser_delete).apply(null, arguments); + }), + (Module._ts_parser_reset = function () { + return (Module._ts_parser_reset = + Module.asm.ts_parser_reset).apply(null, arguments); + }), + (Module._ts_parser_set_language = function () { + return (Module._ts_parser_set_language = + Module.asm.ts_parser_set_language).apply( + null, + arguments + ); + }), + (Module._ts_parser_timeout_micros = function () { + return (Module._ts_parser_timeout_micros = + Module.asm.ts_parser_timeout_micros).apply( + null, + arguments + ); + }), + (Module._ts_parser_set_timeout_micros = function () { + return (Module._ts_parser_set_timeout_micros = + Module.asm.ts_parser_set_timeout_micros).apply( + null, + arguments + ); + }), + (Module._memcmp = function () { + return (Module._memcmp = Module.asm.memcmp).apply( + null, + arguments + ); + }), + (Module._ts_query_new = function () { + return (Module._ts_query_new = + Module.asm.ts_query_new).apply(null, arguments); + }), + (Module._ts_query_delete = function () { + return (Module._ts_query_delete = + Module.asm.ts_query_delete).apply(null, arguments); + }), + (Module._iswspace = function () { + return (Module._iswspace = Module.asm.iswspace).apply( + null, + arguments + ); + }), + (Module._iswalnum = function () { + return (Module._iswalnum = Module.asm.iswalnum).apply( + null, + arguments + ); + }), + (Module._ts_query_pattern_count = function () { + return (Module._ts_query_pattern_count = + Module.asm.ts_query_pattern_count).apply( + null, + arguments + ); + }), + (Module._ts_query_capture_count = function () { + return (Module._ts_query_capture_count = + Module.asm.ts_query_capture_count).apply( + null, + arguments + ); + }), + (Module._ts_query_string_count = function () { + return (Module._ts_query_string_count = + Module.asm.ts_query_string_count).apply( + null, + arguments + ); + }), + (Module._ts_query_capture_name_for_id = function () { + return (Module._ts_query_capture_name_for_id = + Module.asm.ts_query_capture_name_for_id).apply( + null, + arguments + ); + }), + (Module._ts_query_string_value_for_id = function () { + return (Module._ts_query_string_value_for_id = + Module.asm.ts_query_string_value_for_id).apply( + null, + arguments + ); + }), + (Module._ts_query_predicates_for_pattern = function () { + return (Module._ts_query_predicates_for_pattern = + Module.asm.ts_query_predicates_for_pattern).apply( + null, + arguments + ); + }), + (Module._ts_tree_copy = function () { + return (Module._ts_tree_copy = + Module.asm.ts_tree_copy).apply(null, arguments); + }), + (Module._ts_tree_delete = function () { + return (Module._ts_tree_delete = + Module.asm.ts_tree_delete).apply(null, arguments); + }), + (Module._ts_init = function () { + return (Module._ts_init = Module.asm.ts_init).apply( + null, + arguments + ); + }), + (Module._ts_parser_new_wasm = function () { + return (Module._ts_parser_new_wasm = + Module.asm.ts_parser_new_wasm).apply(null, arguments); + }), + (Module._ts_parser_enable_logger_wasm = function () { + return (Module._ts_parser_enable_logger_wasm = + Module.asm.ts_parser_enable_logger_wasm).apply( + null, + arguments + ); + }), + (Module._ts_parser_parse_wasm = function () { + return (Module._ts_parser_parse_wasm = + Module.asm.ts_parser_parse_wasm).apply(null, arguments); + }), + (Module._ts_language_type_is_named_wasm = function () { + return (Module._ts_language_type_is_named_wasm = + Module.asm.ts_language_type_is_named_wasm).apply( + null, + arguments + ); + }), + (Module._ts_language_type_is_visible_wasm = function () { + return (Module._ts_language_type_is_visible_wasm = + Module.asm.ts_language_type_is_visible_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_root_node_wasm = function () { + return (Module._ts_tree_root_node_wasm = + Module.asm.ts_tree_root_node_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_edit_wasm = function () { + return (Module._ts_tree_edit_wasm = + Module.asm.ts_tree_edit_wasm).apply(null, arguments); + }), + (Module._ts_tree_get_changed_ranges_wasm = function () { + return (Module._ts_tree_get_changed_ranges_wasm = + Module.asm.ts_tree_get_changed_ranges_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_new_wasm = function () { + return (Module._ts_tree_cursor_new_wasm = + Module.asm.ts_tree_cursor_new_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_delete_wasm = function () { + return (Module._ts_tree_cursor_delete_wasm = + Module.asm.ts_tree_cursor_delete_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_reset_wasm = function () { + return (Module._ts_tree_cursor_reset_wasm = + Module.asm.ts_tree_cursor_reset_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_goto_first_child_wasm = function () { + return (Module._ts_tree_cursor_goto_first_child_wasm = + Module.asm.ts_tree_cursor_goto_first_child_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_goto_next_sibling_wasm = function () { + return (Module._ts_tree_cursor_goto_next_sibling_wasm = + Module.asm.ts_tree_cursor_goto_next_sibling_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_goto_parent_wasm = function () { + return (Module._ts_tree_cursor_goto_parent_wasm = + Module.asm.ts_tree_cursor_goto_parent_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_current_node_type_id_wasm = function () { + return (Module._ts_tree_cursor_current_node_type_id_wasm = + Module.asm.ts_tree_cursor_current_node_type_id_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_current_node_is_named_wasm = function () { + return (Module._ts_tree_cursor_current_node_is_named_wasm = + Module.asm.ts_tree_cursor_current_node_is_named_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_current_node_is_missing_wasm = function () { + return (Module._ts_tree_cursor_current_node_is_missing_wasm = + Module.asm.ts_tree_cursor_current_node_is_missing_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_current_node_id_wasm = function () { + return (Module._ts_tree_cursor_current_node_id_wasm = + Module.asm.ts_tree_cursor_current_node_id_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_start_position_wasm = function () { + return (Module._ts_tree_cursor_start_position_wasm = + Module.asm.ts_tree_cursor_start_position_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_end_position_wasm = function () { + return (Module._ts_tree_cursor_end_position_wasm = + Module.asm.ts_tree_cursor_end_position_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_start_index_wasm = function () { + return (Module._ts_tree_cursor_start_index_wasm = + Module.asm.ts_tree_cursor_start_index_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_end_index_wasm = function () { + return (Module._ts_tree_cursor_end_index_wasm = + Module.asm.ts_tree_cursor_end_index_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_current_field_id_wasm = function () { + return (Module._ts_tree_cursor_current_field_id_wasm = + Module.asm.ts_tree_cursor_current_field_id_wasm).apply( + null, + arguments + ); + }), + (Module._ts_tree_cursor_current_node_wasm = function () { + return (Module._ts_tree_cursor_current_node_wasm = + Module.asm.ts_tree_cursor_current_node_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_symbol_wasm = function () { + return (Module._ts_node_symbol_wasm = + Module.asm.ts_node_symbol_wasm).apply(null, arguments); + }), + (Module._ts_node_child_count_wasm = function () { + return (Module._ts_node_child_count_wasm = + Module.asm.ts_node_child_count_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_named_child_count_wasm = function () { + return (Module._ts_node_named_child_count_wasm = + Module.asm.ts_node_named_child_count_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_child_wasm = function () { + return (Module._ts_node_child_wasm = + Module.asm.ts_node_child_wasm).apply(null, arguments); + }), + (Module._ts_node_named_child_wasm = function () { + return (Module._ts_node_named_child_wasm = + Module.asm.ts_node_named_child_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_child_by_field_id_wasm = function () { + return (Module._ts_node_child_by_field_id_wasm = + Module.asm.ts_node_child_by_field_id_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_next_sibling_wasm = function () { + return (Module._ts_node_next_sibling_wasm = + Module.asm.ts_node_next_sibling_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_prev_sibling_wasm = function () { + return (Module._ts_node_prev_sibling_wasm = + Module.asm.ts_node_prev_sibling_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_next_named_sibling_wasm = function () { + return (Module._ts_node_next_named_sibling_wasm = + Module.asm.ts_node_next_named_sibling_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_prev_named_sibling_wasm = function () { + return (Module._ts_node_prev_named_sibling_wasm = + Module.asm.ts_node_prev_named_sibling_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_parent_wasm = function () { + return (Module._ts_node_parent_wasm = + Module.asm.ts_node_parent_wasm).apply(null, arguments); + }), + (Module._ts_node_descendant_for_index_wasm = function () { + return (Module._ts_node_descendant_for_index_wasm = + Module.asm.ts_node_descendant_for_index_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_named_descendant_for_index_wasm = function () { + return (Module._ts_node_named_descendant_for_index_wasm = + Module.asm.ts_node_named_descendant_for_index_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_descendant_for_position_wasm = function () { + return (Module._ts_node_descendant_for_position_wasm = + Module.asm.ts_node_descendant_for_position_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_named_descendant_for_position_wasm = function () { + return (Module._ts_node_named_descendant_for_position_wasm = + Module.asm.ts_node_named_descendant_for_position_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_start_point_wasm = function () { + return (Module._ts_node_start_point_wasm = + Module.asm.ts_node_start_point_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_end_point_wasm = function () { + return (Module._ts_node_end_point_wasm = + Module.asm.ts_node_end_point_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_start_index_wasm = function () { + return (Module._ts_node_start_index_wasm = + Module.asm.ts_node_start_index_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_end_index_wasm = function () { + return (Module._ts_node_end_index_wasm = + Module.asm.ts_node_end_index_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_to_string_wasm = function () { + return (Module._ts_node_to_string_wasm = + Module.asm.ts_node_to_string_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_children_wasm = function () { + return (Module._ts_node_children_wasm = + Module.asm.ts_node_children_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_named_children_wasm = function () { + return (Module._ts_node_named_children_wasm = + Module.asm.ts_node_named_children_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_descendants_of_type_wasm = function () { + return (Module._ts_node_descendants_of_type_wasm = + Module.asm.ts_node_descendants_of_type_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_is_named_wasm = function () { + return (Module._ts_node_is_named_wasm = + Module.asm.ts_node_is_named_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_has_changes_wasm = function () { + return (Module._ts_node_has_changes_wasm = + Module.asm.ts_node_has_changes_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_has_error_wasm = function () { + return (Module._ts_node_has_error_wasm = + Module.asm.ts_node_has_error_wasm).apply( + null, + arguments + ); + }), + (Module._ts_node_is_missing_wasm = function () { + return (Module._ts_node_is_missing_wasm = + Module.asm.ts_node_is_missing_wasm).apply( + null, + arguments + ); + }), + (Module._ts_query_matches_wasm = function () { + return (Module._ts_query_matches_wasm = + Module.asm.ts_query_matches_wasm).apply( + null, + arguments + ); + }), + (Module._ts_query_captures_wasm = function () { + return (Module._ts_query_captures_wasm = + Module.asm.ts_query_captures_wasm).apply( + null, + arguments + ); + }), + (Module._towupper = function () { + return (Module._towupper = Module.asm.towupper).apply( + null, + arguments + ); + }), + (Module._iswalpha = function () { + return (Module._iswalpha = Module.asm.iswalpha).apply( + null, + arguments + ); + }), + (Module._iswlower = function () { + return (Module._iswlower = Module.asm.iswlower).apply( + null, + arguments + ); + }), + (Module._iswdigit = function () { + return (Module._iswdigit = Module.asm.iswdigit).apply( + null, + arguments + ); + }), + (Module._memchr = function () { + return (Module._memchr = Module.asm.memchr).apply( + null, + arguments + ); + }), + (Module.___errno_location = function () { + return ($e = Module.___errno_location = + Module.asm.__errno_location).apply(null, arguments); + })), + je = + ((Module._strlen = function () { + return (Module._strlen = Module.asm.strlen).apply( + null, + arguments + ); + }), + (Module.stackSave = function () { + return (je = Module.stackSave = + Module.asm.stackSave).apply(null, arguments); + })), + Ue = (Module.stackRestore = function () { + return (Ue = Module.stackRestore = + Module.asm.stackRestore).apply(null, arguments); + }), + De = (Module.stackAlloc = function () { + return (De = Module.stackAlloc = + Module.asm.stackAlloc).apply(null, arguments); + }), + ze = (Module._setThrew = function () { + return (ze = Module._setThrew = Module.asm.setThrew).apply( + null, + arguments + ); + }); + (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev = function () { + return (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev = + Module.asm._ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev).apply( + null, + arguments + ); + }), + (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm = function () { + return (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm = + Module.asm._ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm).apply( + null, + arguments + ); + }), + (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm = function () { + return (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm = + Module.asm._ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm).apply( + null, + arguments + ); + }), + (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm = function () { + return (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm = + Module.asm._ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm).apply( + null, + arguments + ); + }), + (Module.__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm = function () { + return (Module.__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm = + Module.asm._ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm).apply( + null, + arguments + ); + }), + (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc = function () { + return (Module.__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc = + Module.asm._ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc).apply( + null, + arguments + ); + }), + (Module.__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev = function () { + return (Module.__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev = + Module.asm._ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev).apply( + null, + arguments + ); + }), + (Module.__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw = function () { + return (Module.__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw = + Module.asm._ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw).apply( + null, + arguments + ); + }), + (Module.__Znwm = function () { + return (Module.__Znwm = Module.asm._Znwm).apply( + null, + arguments + ); + }), + (Module.__ZdlPv = function () { + return (Module.__ZdlPv = Module.asm._ZdlPv).apply( + null, + arguments + ); + }), + (Module.__ZNKSt3__220__vector_base_commonILb1EE20__throw_length_errorEv = function () { + return (Module.__ZNKSt3__220__vector_base_commonILb1EE20__throw_length_errorEv = + Module.asm._ZNKSt3__220__vector_base_commonILb1EE20__throw_length_errorEv).apply( + null, + arguments + ); + }), + (Module._orig$ts_parser_timeout_micros = function () { + return (Module._orig$ts_parser_timeout_micros = + Module.asm.orig$ts_parser_timeout_micros).apply( + null, + arguments + ); + }), + (Module._orig$ts_parser_set_timeout_micros = function () { + return (Module._orig$ts_parser_set_timeout_micros = + Module.asm.orig$ts_parser_set_timeout_micros).apply( + null, + arguments + ); + }); + function Ge(e3) { + (this.name = 'ExitStatus'), + (this.message = 'Program terminated with exit(' + e3 + ')'), + (this.status = e3); + } + Module.allocate = function (e3, t3) { + let r2; + return ( + (r2 = t3 == k ? De(e3.length) : Fe(e3.length)), + e3.subarray || e3.slice + ? R.set(e3, r2) + : R.set(new Uint8Array(e3), r2), + r2 + ); + }; + te = function e3() { + Oe || Be(), Oe || (te = e3); + }; + let He = false; + function Be(e3) { + function t3() { + Oe || + ((Oe = true), + (Module.calledRun = true), + N || + ((J = true), + fe(V), + fe(X), + Module.onRuntimeInitialized && + Module.onRuntimeInitialized(), + Ve && + (function (e4) { + let t4 = Module._main; + if (t4) { + let r2 = (e4 = e4 || []).length + 1, + n2 = De(4 * (r2 + 1)); + L[n2 >> 2] = z(_); + for (let s2 = 1; s2 < r2; s2++) { + L[(n2 >> 2) + s2] = z(e4[s2 - 1]); + } + L[(n2 >> 2) + r2] = 0; + try { + Ke(t4(r2, n2), true); + } catch (e5) { + if (e5 instanceof Ge) { + return; + } + if (e5 == 'unwind') { + return; + } + let o2 = e5; + e5 && + typeof e5 === 'object' && + e5.stack && + (o2 = [e5, e5.stack]), + h('exception thrown: ' + o2), + a(1, e5); + } finally { + true; + } + } + })(e3), + (function () { + if (Module.postRun) { + for ( + typeof Module.postRun === 'function' && + (Module.postRun = [Module.postRun]); + Module.postRun.length; + + ) { + (e4 = Module.postRun.shift()), Q.unshift(e4); + } + } + let e4; + fe(Q); + })())); + } + (e3 = e3 || o), + Y > 0 || + (!He && + ((function () { + if (E.length) { + if (!c) { + return ( + re(), + void E.reduce(function (e4, t4) { + return e4.then(function () { + return xe(t4, { + loadAsync: true, + global: true, + nodelete: true, + allowUndefined: true, + }); + }); + }, Promise.resolve()).then(function () { + ne(), Ne(); + }) + ); + } + E.forEach(function (e4) { + xe(e4, { + global: true, + nodelete: true, + allowUndefined: true, + }); + }), + Ne(); + } else { + Ne(); + } + })(), + (He = true), + Y > 0)) || + (!(function () { + if (Module.preRun) { + for ( + typeof Module.preRun === 'function' && + (Module.preRun = [Module.preRun]); + Module.preRun.length; + + ) { + (e4 = Module.preRun.shift()), K.unshift(e4); + } + } + let e4; + fe(K); + })(), + Y > 0 || + (Module.setStatus + ? (Module.setStatus('Running...'), + setTimeout(function () { + setTimeout(function () { + Module.setStatus(''); + }, 1), + t3(); + }, 1)) + : t3())); + } + function Ke(e3, t3) { + e3, + (t3 && ge() && e3 === 0) || + (ge() || + (true, Module.onExit && Module.onExit(e3), (N = true)), + a(e3, new Ge(e3))); + } + if (((Module.run = Be), Module.preInit)) { + for ( + typeof Module.preInit === 'function' && + (Module.preInit = [Module.preInit]); + Module.preInit.length > 0; + + ) { + Module.preInit.pop()(); + } + } + var Ve = true; + Module.noInitialRun && (Ve = false), Be(); + const Xe = Module, + Qe = {}, + Je = 4, + Ye = 5 * Je, + et = 2 * Je, + tt = 2 * Je + 2 * et, + rt = { row: 0, column: 0 }, + nt = /[\w-.]*/g, + st = 1, + ot = 2, + _t = /^_?tree_sitter_\w+/; + let at, ut, it, lt, dt; + class ParserImpl { + static init() { + (it = Xe._ts_init()), + (at = x(it, 'i32')), + (ut = x(it + Je, 'i32')); + } + initialize() { + Xe._ts_parser_new_wasm(), + (this[0] = x(it, 'i32')), + (this[1] = x(it + Je, 'i32')); + } + delete() { + Xe._ts_parser_delete(this[0]), + Xe._free(this[1]), + (this[0] = 0), + (this[1] = 0); + } + setLanguage(e3) { + let t3; + if (e3) { + if (e3.constructor !== Language) { + throw new Error('Argument must be a Language'); + } + { + t3 = e3[0]; + const r2 = Xe._ts_language_version(t3); + if (r2 < ut || at < r2) { + throw new Error( + `Incompatible language version ${r2}. Compatibility range ${ut} through ${at}.` + ); + } + } + } else { + (t3 = 0), (e3 = null); + } + return ( + (this.language = e3), + Xe._ts_parser_set_language(this[0], t3), + this + ); + } + getLanguage() { + return this.language; + } + parse(e3, t3, r2) { + if (typeof e3 === 'string') { + lt = (t4, r3, n3) => e3.slice(t4, n3); + } else { + if (typeof e3 !== 'function') { + throw new Error( + 'Argument must be a string or a function' + ); + } + lt = e3; + } + this.logCallback + ? ((dt = this.logCallback), + Xe._ts_parser_enable_logger_wasm(this[0], 1)) + : ((dt = null), + Xe._ts_parser_enable_logger_wasm(this[0], 0)); + let n2 = 0, + s2 = 0; + if (r2 && r2.includedRanges) { + n2 = r2.includedRanges.length; + let e4 = (s2 = Xe._calloc(n2, tt)); + for (let t4 = 0; t4 < n2; t4++) { + vt(e4, r2.includedRanges[t4]), (e4 += tt); + } + } + const o2 = Xe._ts_parser_parse_wasm( + this[0], + this[1], + t3 ? t3[0] : 0, + s2, + n2 + ); + if (!o2) { + throw ( + ((lt = null), (dt = null), new Error('Parsing failed')) + ); + } + const _2 = new Tree(Qe, o2, this.language, lt); + return (lt = null), (dt = null), _2; + } + reset() { + Xe._ts_parser_reset(this[0]); + } + setTimeoutMicros(e3) { + Xe._ts_parser_set_timeout_micros(this[0], e3); + } + getTimeoutMicros() { + return Xe._ts_parser_timeout_micros(this[0]); + } + setLogger(e3) { + if (e3) { + if (typeof e3 !== 'function') { + throw new Error('Logger callback must be a function'); + } + } else { + e3 = null; + } + return (this.logCallback = e3), this; + } + getLogger() { + return this.logCallback; + } + } + class Tree { + constructor(e3, t3, r2, n2) { + ft(e3), + (this[0] = t3), + (this.language = r2), + (this.textCallback = n2); + } + copy() { + const e3 = Xe._ts_tree_copy(this[0]); + return new Tree(Qe, e3, this.language, this.textCallback); + } + delete() { + Xe._ts_tree_delete(this[0]), (this[0] = 0); + } + edit(e3) { + !(function (e4) { + let t3 = it; + Mt(t3, e4.startPosition), + Mt((t3 += et), e4.oldEndPosition), + Mt((t3 += et), e4.newEndPosition), + S((t3 += et), e4.startIndex, 'i32'), + S((t3 += Je), e4.oldEndIndex, 'i32'), + S((t3 += Je), e4.newEndIndex, 'i32'), + (t3 += Je); + })(e3), + Xe._ts_tree_edit_wasm(this[0]); + } + get rootNode() { + return Xe._ts_tree_root_node_wasm(this[0]), gt(this); + } + getLanguage() { + return this.language; + } + walk() { + return this.rootNode.walk(); + } + getChangedRanges(e3) { + if (e3.constructor !== Tree) { + throw new TypeError('Argument must be a Tree'); + } + Xe._ts_tree_get_changed_ranges_wasm(this[0], e3[0]); + const t3 = x(it, 'i32'), + r2 = x(it + Je, 'i32'), + n2 = new Array(t3); + if (t3 > 0) { + let e4 = r2; + for (let r3 = 0; r3 < t3; r3++) { + (n2[r3] = Et(e4)), (e4 += tt); + } + Xe._free(r2); + } + return n2; + } + } + class Node2 { + constructor(e3, t3) { + ft(e3), (this.tree = t3); + } + get typeId() { + return ht(this), Xe._ts_node_symbol_wasm(this.tree[0]); + } + get type() { + return this.tree.language.types[this.typeId] || 'ERROR'; + } + get endPosition() { + return ( + ht(this), Xe._ts_node_end_point_wasm(this.tree[0]), bt(it) + ); + } + get endIndex() { + return ht(this), Xe._ts_node_end_index_wasm(this.tree[0]); + } + get text() { + return ct(this.tree, this.startIndex, this.endIndex); + } + isNamed() { + return ( + ht(this), Xe._ts_node_is_named_wasm(this.tree[0]) === 1 + ); + } + hasError() { + return ( + ht(this), Xe._ts_node_has_error_wasm(this.tree[0]) === 1 + ); + } + hasChanges() { + return ( + ht(this), Xe._ts_node_has_changes_wasm(this.tree[0]) === 1 + ); + } + isMissing() { + return ( + ht(this), Xe._ts_node_is_missing_wasm(this.tree[0]) === 1 + ); + } + equals(e3) { + return this.id === e3.id; + } + child(e3) { + return ( + ht(this), + Xe._ts_node_child_wasm(this.tree[0], e3), + gt(this.tree) + ); + } + namedChild(e3) { + return ( + ht(this), + Xe._ts_node_named_child_wasm(this.tree[0], e3), + gt(this.tree) + ); + } + childForFieldId(e3) { + return ( + ht(this), + Xe._ts_node_child_by_field_id_wasm(this.tree[0], e3), + gt(this.tree) + ); + } + childForFieldName(e3) { + const t3 = this.tree.language.fields.indexOf(e3); + if (t3 !== -1) { + return this.childForFieldId(t3); + } + } + get childCount() { + return ht(this), Xe._ts_node_child_count_wasm(this.tree[0]); + } + get namedChildCount() { + return ( + ht(this), Xe._ts_node_named_child_count_wasm(this.tree[0]) + ); + } + get firstChild() { + return this.child(0); + } + get firstNamedChild() { + return this.namedChild(0); + } + get lastChild() { + return this.child(this.childCount - 1); + } + get lastNamedChild() { + return this.namedChild(this.namedChildCount - 1); + } + get children() { + if (!this._children) { + ht(this), Xe._ts_node_children_wasm(this.tree[0]); + const e3 = x(it, 'i32'), + t3 = x(it + Je, 'i32'); + if (((this._children = new Array(e3)), e3 > 0)) { + let r2 = t3; + for (let t4 = 0; t4 < e3; t4++) { + (this._children[t4] = gt(this.tree, r2)), (r2 += Ye); + } + Xe._free(t3); + } + } + return this._children; + } + get namedChildren() { + if (!this._namedChildren) { + ht(this), Xe._ts_node_named_children_wasm(this.tree[0]); + const e3 = x(it, 'i32'), + t3 = x(it + Je, 'i32'); + if (((this._namedChildren = new Array(e3)), e3 > 0)) { + let r2 = t3; + for (let t4 = 0; t4 < e3; t4++) { + (this._namedChildren[t4] = gt(this.tree, r2)), + (r2 += Ye); + } + Xe._free(t3); + } + } + return this._namedChildren; + } + descendantsOfType(e3, t3, r2) { + Array.isArray(e3) || (e3 = [e3]), + t3 || (t3 = rt), + r2 || (r2 = rt); + const n2 = [], + s2 = this.tree.language.types; + for (let t4 = 0, r3 = s2.length; t4 < r3; t4++) { + e3.includes(s2[t4]) && n2.push(t4); + } + const o2 = Xe._malloc(Je * n2.length); + for (let e4 = 0, t4 = n2.length; e4 < t4; e4++) { + S(o2 + e4 * Je, n2[e4], 'i32'); + } + ht(this), + Xe._ts_node_descendants_of_type_wasm( + this.tree[0], + o2, + n2.length, + t3.row, + t3.column, + r2.row, + r2.column + ); + const _2 = x(it, 'i32'), + a2 = x(it + Je, 'i32'), + u2 = new Array(_2); + if (_2 > 0) { + let e4 = a2; + for (let t4 = 0; t4 < _2; t4++) { + (u2[t4] = gt(this.tree, e4)), (e4 += Ye); + } + } + return Xe._free(a2), Xe._free(o2), u2; + } + get nextSibling() { + return ( + ht(this), + Xe._ts_node_next_sibling_wasm(this.tree[0]), + gt(this.tree) + ); + } + get previousSibling() { + return ( + ht(this), + Xe._ts_node_prev_sibling_wasm(this.tree[0]), + gt(this.tree) + ); + } + get nextNamedSibling() { + return ( + ht(this), + Xe._ts_node_next_named_sibling_wasm(this.tree[0]), + gt(this.tree) + ); + } + get previousNamedSibling() { + return ( + ht(this), + Xe._ts_node_prev_named_sibling_wasm(this.tree[0]), + gt(this.tree) + ); + } + get parent() { + return ( + ht(this), + Xe._ts_node_parent_wasm(this.tree[0]), + gt(this.tree) + ); + } + descendantForIndex(e3, t3 = e3) { + if (typeof e3 !== 'number' || typeof t3 !== 'number') { + throw new Error('Arguments must be numbers'); + } + ht(this); + let r2 = it + Ye; + return ( + S(r2, e3, 'i32'), + S(r2 + Je, t3, 'i32'), + Xe._ts_node_descendant_for_index_wasm(this.tree[0]), + gt(this.tree) + ); + } + namedDescendantForIndex(e3, t3 = e3) { + if (typeof e3 !== 'number' || typeof t3 !== 'number') { + throw new Error('Arguments must be numbers'); + } + ht(this); + let r2 = it + Ye; + return ( + S(r2, e3, 'i32'), + S(r2 + Je, t3, 'i32'), + Xe._ts_node_named_descendant_for_index_wasm(this.tree[0]), + gt(this.tree) + ); + } + descendantForPosition(e3, t3 = e3) { + if (!pt(e3) || !pt(t3)) { + throw new Error( + 'Arguments must be {row, column} objects' + ); + } + ht(this); + let r2 = it + Ye; + return ( + Mt(r2, e3), + Mt(r2 + et, t3), + Xe._ts_node_descendant_for_position_wasm(this.tree[0]), + gt(this.tree) + ); + } + namedDescendantForPosition(e3, t3 = e3) { + if (!pt(e3) || !pt(t3)) { + throw new Error( + 'Arguments must be {row, column} objects' + ); + } + ht(this); + let r2 = it + Ye; + return ( + Mt(r2, e3), + Mt(r2 + et, t3), + Xe._ts_node_named_descendant_for_position_wasm( + this.tree[0] + ), + gt(this.tree) + ); + } + walk() { + return ( + ht(this), + Xe._ts_tree_cursor_new_wasm(this.tree[0]), + new TreeCursor(Qe, this.tree) + ); + } + toString() { + ht(this); + const e3 = Xe._ts_node_to_string_wasm(this.tree[0]), + t3 = (function (e4) { + for (let t4 = ''; ; ) { + let r2 = R[e4++ >> 0]; + if (!r2) { + return t4; + } + t4 += String.fromCharCode(r2); + } + })(e3); + return Xe._free(e3), t3; + } + } + class TreeCursor { + constructor(e3, t3) { + ft(e3), (this.tree = t3), yt(this); + } + delete() { + wt(this), + Xe._ts_tree_cursor_delete_wasm(this.tree[0]), + (this[0] = this[1] = this[2] = 0); + } + reset(e3) { + ht(e3), + wt(this, it + Ye), + Xe._ts_tree_cursor_reset_wasm(this.tree[0]), + yt(this); + } + get nodeType() { + return this.tree.language.types[this.nodeTypeId] || 'ERROR'; + } + get nodeTypeId() { + return ( + wt(this), + Xe._ts_tree_cursor_current_node_type_id_wasm(this.tree[0]) + ); + } + get nodeId() { + return ( + wt(this), + Xe._ts_tree_cursor_current_node_id_wasm(this.tree[0]) + ); + } + get nodeIsNamed() { + return ( + wt(this), + Xe._ts_tree_cursor_current_node_is_named_wasm( + this.tree[0] + ) === 1 + ); + } + get nodeIsMissing() { + return ( + wt(this), + Xe._ts_tree_cursor_current_node_is_missing_wasm( + this.tree[0] + ) === 1 + ); + } + get nodeText() { + wt(this); + const e3 = Xe._ts_tree_cursor_start_index_wasm( + this.tree[0] + ), + t3 = Xe._ts_tree_cursor_end_index_wasm(this.tree[0]); + return ct(this.tree, e3, t3); + } + get startPosition() { + return ( + wt(this), + Xe._ts_tree_cursor_start_position_wasm(this.tree[0]), + bt(it) + ); + } + get endPosition() { + return ( + wt(this), + Xe._ts_tree_cursor_end_position_wasm(this.tree[0]), + bt(it) + ); + } + get startIndex() { + return ( + wt(this), + Xe._ts_tree_cursor_start_index_wasm(this.tree[0]) + ); + } + get endIndex() { + return ( + wt(this), Xe._ts_tree_cursor_end_index_wasm(this.tree[0]) + ); + } + currentNode() { + return ( + wt(this), + Xe._ts_tree_cursor_current_node_wasm(this.tree[0]), + gt(this.tree) + ); + } + currentFieldId() { + return ( + wt(this), + Xe._ts_tree_cursor_current_field_id_wasm(this.tree[0]) + ); + } + currentFieldName() { + return this.tree.language.fields[this.currentFieldId()]; + } + gotoFirstChild() { + wt(this); + const e3 = Xe._ts_tree_cursor_goto_first_child_wasm( + this.tree[0] + ); + return yt(this), e3 === 1; + } + gotoNextSibling() { + wt(this); + const e3 = Xe._ts_tree_cursor_goto_next_sibling_wasm( + this.tree[0] + ); + return yt(this), e3 === 1; + } + gotoParent() { + wt(this); + const e3 = Xe._ts_tree_cursor_goto_parent_wasm( + this.tree[0] + ); + return yt(this), e3 === 1; + } + } + class Language { + constructor(e3, t3) { + ft(e3), + (this[0] = t3), + (this.types = new Array( + Xe._ts_language_symbol_count(this[0]) + )); + for (let e4 = 0, t4 = this.types.length; e4 < t4; e4++) { + Xe._ts_language_symbol_type(this[0], e4) < 2 && + (this.types[e4] = $( + Xe._ts_language_symbol_name(this[0], e4) + )); + } + this.fields = new Array( + Xe._ts_language_field_count(this[0]) + 1 + ); + for (let e4 = 0, t4 = this.fields.length; e4 < t4; e4++) { + const t5 = Xe._ts_language_field_name_for_id(this[0], e4); + this.fields[e4] = t5 !== 0 ? $(t5) : null; + } + } + get version() { + return Xe._ts_language_version(this[0]); + } + get fieldCount() { + return this.fields.length - 1; + } + fieldIdForName(e3) { + const t3 = this.fields.indexOf(e3); + return t3 !== -1 ? t3 : null; + } + fieldNameForId(e3) { + return this.fields[e3] || null; + } + idForNodeType(e3, t3) { + const r2 = D(e3), + n2 = Xe._malloc(r2 + 1); + U(e3, n2, r2 + 1); + const s2 = Xe._ts_language_symbol_for_name( + this[0], + n2, + r2, + t3 + ); + return Xe._free(n2), s2 || null; + } + get nodeTypeCount() { + return Xe._ts_language_symbol_count(this[0]); + } + nodeTypeForId(e3) { + const t3 = Xe._ts_language_symbol_name(this[0], e3); + return t3 ? $(t3) : null; + } + nodeTypeIsNamed(e3) { + return !!Xe._ts_language_type_is_named_wasm(this[0], e3); + } + nodeTypeIsVisible(e3) { + return !!Xe._ts_language_type_is_visible_wasm(this[0], e3); + } + query(e3) { + const t3 = D(e3), + r2 = Xe._malloc(t3 + 1); + U(e3, r2, t3 + 1); + const n2 = Xe._ts_query_new(this[0], r2, t3, it, it + Je); + if (!n2) { + const t4 = x(it + Je, 'i32'), + n3 = $(r2, x(it, 'i32')).length, + s3 = e3.substr(n3, 100).split('\n')[0]; + let o3, + _3 = s3.match(nt)[0]; + switch (t4) { + case 2: + o3 = new RangeError(`Bad node name '${_3}'`); + break; + case 3: + o3 = new RangeError(`Bad field name '${_3}'`); + break; + case 4: + o3 = new RangeError(`Bad capture name @${_3}`); + break; + case 5: + (o3 = new TypeError( + `Bad pattern structure at offset ${n3}: '${s3}'...` + )), + (_3 = ''); + break; + default: + (o3 = new SyntaxError( + `Bad syntax at offset ${n3}: '${s3}'...` + )), + (_3 = ''); + } + throw ( + ((o3.index = n3), + (o3.length = _3.length), + Xe._free(r2), + o3) + ); + } + const s2 = Xe._ts_query_string_count(n2), + o2 = Xe._ts_query_capture_count(n2), + _2 = Xe._ts_query_pattern_count(n2), + a2 = new Array(o2), + u2 = new Array(s2); + for (let e4 = 0; e4 < o2; e4++) { + const t4 = Xe._ts_query_capture_name_for_id(n2, e4, it), + r3 = x(it, 'i32'); + a2[e4] = $(t4, r3); + } + for (let e4 = 0; e4 < s2; e4++) { + const t4 = Xe._ts_query_string_value_for_id(n2, e4, it), + r3 = x(it, 'i32'); + u2[e4] = $(t4, r3); + } + const i2 = new Array(_2), + l2 = new Array(_2), + d2 = new Array(_2), + c2 = new Array(_2), + m2 = new Array(_2); + for (let e4 = 0; e4 < _2; e4++) { + const t4 = Xe._ts_query_predicates_for_pattern( + n2, + e4, + it + ), + r3 = x(it, 'i32'); + (c2[e4] = []), (m2[e4] = []); + const s3 = []; + let o3 = t4; + for (let t5 = 0; t5 < r3; t5++) { + const t6 = x(o3, 'i32'), + r4 = x((o3 += Je), 'i32'); + if (((o3 += Je), t6 === st)) { + s3.push({ type: 'capture', name: a2[r4] }); + } else if (t6 === ot) { + s3.push({ type: 'string', value: u2[r4] }); + } else if (s3.length > 0) { + if (s3[0].type !== 'string') { + throw new Error( + 'Predicates must begin with a literal value' + ); + } + const t7 = s3[0].value; + let r5 = true; + switch (t7) { + case 'not-eq?': + r5 = false; + case 'eq?': + if (s3.length !== 3) { + throw new Error( + `Wrong number of arguments to \`#eq?\` predicate. Expected 2, got ${ + s3.length - 1 + }` + ); + } + if (s3[1].type !== 'capture') { + throw new Error( + `First argument of \`#eq?\` predicate must be a capture. Got "${s3[1].value}"` + ); + } + if (s3[2].type === 'capture') { + const t8 = s3[1].name, + n4 = s3[2].name; + m2[e4].push(function (e5) { + let s4, o5; + for (const r6 of e5) { + r6.name === t8 && (s4 = r6.node), + r6.name === n4 && (o5 = r6.node); + } + return (s4.text === o5.text) === r5; + }); + } else { + const t8 = s3[1].name, + n4 = s3[2].value; + m2[e4].push(function (e5) { + for (const s4 of e5) { + if (s4.name === t8) { + return (s4.node.text === n4) === r5; + } + } + return false; + }); + } + break; + case 'not-match?': + r5 = false; + case 'match?': + if (s3.length !== 3) { + throw new Error( + `Wrong number of arguments to \`#match?\` predicate. Expected 2, got ${ + s3.length - 1 + }.` + ); + } + if (s3[1].type !== 'capture') { + throw new Error( + `First argument of \`#match?\` predicate must be a capture. Got "${s3[1].value}".` + ); + } + if (s3[2].type !== 'string') { + throw new Error( + `Second argument of \`#match?\` predicate must be a string. Got @${s3[2].value}.` + ); + } + const n3 = s3[1].name, + o4 = new RegExp(s3[2].value); + m2[e4].push(function (e5) { + for (const t8 of e5) { + if (t8.name === n3) { + return o4.test(t8.node.text) === r5; + } + } + return false; + }); + break; + case 'set!': + if (s3.length < 2 || s3.length > 3) { + throw new Error( + `Wrong number of arguments to \`#set!\` predicate. Expected 1 or 2. Got ${ + s3.length - 1 + }.` + ); + } + if (s3.some((e5) => e5.type !== 'string')) { + throw new Error( + 'Arguments to `#set!` predicate must be a strings.".' + ); + } + i2[e4] || (i2[e4] = {}), + (i2[e4][s3[1].value] = s3[2] + ? s3[2].value + : null); + break; + case 'is?': + case 'is-not?': + if (s3.length < 2 || s3.length > 3) { + throw new Error( + `Wrong number of arguments to \`#${t7}\` predicate. Expected 1 or 2. Got ${ + s3.length - 1 + }.` + ); + } + if (s3.some((e5) => e5.type !== 'string')) { + throw new Error( + `Arguments to \`#${t7}\` predicate must be a strings.".` + ); + } + const _3 = t7 === 'is?' ? l2 : d2; + _3[e4] || (_3[e4] = {}), + (_3[e4][s3[1].value] = s3[2] + ? s3[2].value + : null); + break; + default: + c2[e4].push({ + operator: t7, + operands: s3.slice(1), + }); + } + s3.length = 0; + } + } + Object.freeze(i2[e4]), + Object.freeze(l2[e4]), + Object.freeze(d2[e4]); + } + return ( + Xe._free(r2), + new Query( + Qe, + n2, + a2, + m2, + c2, + Object.freeze(i2), + Object.freeze(l2), + Object.freeze(d2) + ) + ); + } + static load(e3) { + let t3; + if (e3 instanceof Uint8Array) { + t3 = Promise.resolve(e3); + } else { + const r3 = e3; + if ( + typeof process !== 'undefined' && + process.versions && + process.versions.node + ) { + const e4 = __require('fs'); + t3 = Promise.resolve(e4.readFileSync(r3)); + } else { + t3 = fetch(r3).then((e4) => + e4.arrayBuffer().then((t4) => { + if (e4.ok) { + return new Uint8Array(t4); + } + { + const r4 = new TextDecoder('utf-8').decode(t4); + throw new Error(`Language.load failed with status ${e4.status}. + +${r4}`); + } + }) + ); + } + } + const r2 = + typeof loadSideModule === 'function' + ? loadSideModule + : Se; + return t3 + .then((e4) => r2(e4, { loadAsync: true })) + .then((e4) => { + const t4 = Object.keys(e4), + r3 = t4.find( + (e5) => + _t.test(e5) && !e5.includes('external_scanner_') + ); + r3 || + console.log(`Couldn't find language function in WASM file. Symbols: +${JSON.stringify(t4, null, 2)}`); + const n2 = e4[r3](); + return new Language(Qe, n2); + }); + } + } + class Query { + constructor(e3, t3, r2, n2, s2, o2, _2, a2) { + ft(e3), + (this[0] = t3), + (this.captureNames = r2), + (this.textPredicates = n2), + (this.predicates = s2), + (this.setProperties = o2), + (this.assertedProperties = _2), + (this.refutedProperties = a2), + (this.exceededMatchLimit = false); + } + delete() { + Xe._ts_query_delete(this[0]), (this[0] = 0); + } + matches(e3, t3, r2, n2) { + t3 || (t3 = rt), r2 || (r2 = rt), n2 || (n2 = {}); + let s2 = n2.matchLimit; + if (s2 === void 0) { + s2 = 0; + } else if (typeof s2 !== 'number') { + throw new Error('Arguments must be numbers'); + } + ht(e3), + Xe._ts_query_matches_wasm( + this[0], + e3.tree[0], + t3.row, + t3.column, + r2.row, + r2.column, + s2 + ); + const o2 = x(it, 'i32'), + _2 = x(it + Je, 'i32'), + a2 = x(it + 2 * Je, 'i32'), + u2 = new Array(o2); + this.exceededMatchLimit = !!a2; + let i2 = 0, + l2 = _2; + for (let t4 = 0; t4 < o2; t4++) { + const r3 = x(l2, 'i32'), + n3 = x((l2 += Je), 'i32'); + l2 += Je; + const s3 = new Array(n3); + if ( + ((l2 = mt(this, e3.tree, l2, s3)), + this.textPredicates[r3].every((e4) => e4(s3))) + ) { + u2[i2++] = { pattern: r3, captures: s3 }; + const e4 = this.setProperties[r3]; + e4 && (u2[t4].setProperties = e4); + const n4 = this.assertedProperties[r3]; + n4 && (u2[t4].assertedProperties = n4); + const o3 = this.refutedProperties[r3]; + o3 && (u2[t4].refutedProperties = o3); + } + } + return (u2.length = i2), Xe._free(_2), u2; + } + captures(e3, t3, r2, n2) { + t3 || (t3 = rt), r2 || (r2 = rt), n2 || (n2 = {}); + let s2 = n2.matchLimit; + if (s2 === void 0) { + s2 = 0; + } else if (typeof s2 !== 'number') { + throw new Error('Arguments must be numbers'); + } + ht(e3), + Xe._ts_query_captures_wasm( + this[0], + e3.tree[0], + t3.row, + t3.column, + r2.row, + r2.column, + s2 + ); + const o2 = x(it, 'i32'), + _2 = x(it + Je, 'i32'), + a2 = x(it + 2 * Je, 'i32'), + u2 = []; + this.exceededMatchLimit = !!a2; + const i2 = []; + let l2 = _2; + for (let t4 = 0; t4 < o2; t4++) { + const t5 = x(l2, 'i32'), + r3 = x((l2 += Je), 'i32'), + n3 = x((l2 += Je), 'i32'); + if ( + ((l2 += Je), + (i2.length = r3), + (l2 = mt(this, e3.tree, l2, i2)), + this.textPredicates[t5].every((e4) => e4(i2))) + ) { + const e4 = i2[n3], + r4 = this.setProperties[t5]; + r4 && (e4.setProperties = r4); + const s3 = this.assertedProperties[t5]; + s3 && (e4.assertedProperties = s3); + const o3 = this.refutedProperties[t5]; + o3 && (e4.refutedProperties = o3), u2.push(e4); + } + } + return Xe._free(_2), u2; + } + predicatesForPattern(e3) { + return this.predicates[e3]; + } + didExceedMatchLimit() { + return this.exceededMatchLimit; + } + } + function ct(e3, t3, r2) { + const n2 = r2 - t3; + let s2 = e3.textCallback(t3, null, r2); + for (t3 += s2.length; t3 < r2; ) { + const n3 = e3.textCallback(t3, null, r2); + if (!(n3 && n3.length > 0)) { + break; + } + (t3 += n3.length), (s2 += n3); + } + return t3 > r2 && (s2 = s2.slice(0, n2)), s2; + } + function mt(e3, t3, r2, n2) { + for (let s2 = 0, o2 = n2.length; s2 < o2; s2++) { + const o3 = x(r2, 'i32'), + _2 = gt(t3, (r2 += Je)); + (r2 += Ye), + (n2[s2] = { name: e3.captureNames[o3], node: _2 }); + } + return r2; + } + function ft(e3) { + if (e3 !== Qe) { + throw new Error('Illegal constructor'); + } + } + function pt(e3) { + return ( + e3 && + typeof e3.row === 'number' && + typeof e3.column === 'number' + ); + } + function ht(e3) { + let t3 = it; + S(t3, e3.id, 'i32'), + S((t3 += Je), e3.startIndex, 'i32'), + S((t3 += Je), e3.startPosition.row, 'i32'), + S((t3 += Je), e3.startPosition.column, 'i32'), + S((t3 += Je), e3[0], 'i32'); + } + function gt(e3, t3 = it) { + const r2 = x(t3, 'i32'); + if (r2 === 0) { + return null; + } + const n2 = x((t3 += Je), 'i32'), + s2 = x((t3 += Je), 'i32'), + o2 = x((t3 += Je), 'i32'), + _2 = x((t3 += Je), 'i32'), + a2 = new Node2(Qe, e3); + return ( + (a2.id = r2), + (a2.startIndex = n2), + (a2.startPosition = { row: s2, column: o2 }), + (a2[0] = _2), + a2 + ); + } + function wt(e3, t3 = it) { + S(t3 + 0 * Je, e3[0], 'i32'), + S(t3 + 1 * Je, e3[1], 'i32'), + S(t3 + 2 * Je, e3[2], 'i32'); + } + function yt(e3) { + (e3[0] = x(it + 0 * Je, 'i32')), + (e3[1] = x(it + 1 * Je, 'i32')), + (e3[2] = x(it + 2 * Je, 'i32')); + } + function Mt(e3, t3) { + S(e3, t3.row, 'i32'), S(e3 + Je, t3.column, 'i32'); + } + function bt(e3) { + return { row: x(e3, 'i32'), column: x(e3 + Je, 'i32') }; + } + function vt(e3, t3) { + Mt(e3, t3.startPosition), + Mt((e3 += et), t3.endPosition), + S((e3 += et), t3.startIndex, 'i32'), + S((e3 += Je), t3.endIndex, 'i32'), + (e3 += Je); + } + function Et(e3) { + const t3 = {}; + return ( + (t3.startPosition = bt(e3)), + (e3 += et), + (t3.endPosition = bt(e3)), + (e3 += et), + (t3.startIndex = x(e3, 'i32')), + (e3 += Je), + (t3.endIndex = x(e3, 'i32')), + t3 + ); + } + for (const e3 of Object.getOwnPropertyNames( + ParserImpl.prototype + )) { + Object.defineProperty(Parser4.prototype, e3, { + value: ParserImpl.prototype[e3], + enumerable: false, + writable: false, + }); + } + (Parser4.Language = Language), + (Module.onRuntimeInitialized = () => { + ParserImpl.init(), e2(); + }); + }))) + ); + } + } + return Parser4; + })(); + typeof exports === 'object' && (module.exports = TreeSitter); + }, + }); + + // server/src/main.ts + let import_vscode_languageserver3 = __toModule(require_main4()); + let import_browser = __toModule(require_browser3()); + let import_tree_sitter3 = __toModule(require_tree_sitter()); + + // server/src/documentStore.ts + let lsp = __toModule(require_main4()); + let import_vscode_languageserver = __toModule(require_main4()); + + // server/node_modules/vscode-languageserver-textdocument/lib/esm/main.js + ('use strict'); + let FullTextDocument = (function () { + function FullTextDocument2(uri, languageId, version, content) { + this._uri = uri; + this._languageId = languageId; + this._version = version; + this._content = content; + this._lineOffsets = void 0; + } + Object.defineProperty(FullTextDocument2.prototype, 'uri', { + get: function () { + return this._uri; + }, + enumerable: true, + configurable: true, + }); + Object.defineProperty(FullTextDocument2.prototype, 'languageId', { + get: function () { + return this._languageId; + }, + enumerable: true, + configurable: true, + }); + Object.defineProperty(FullTextDocument2.prototype, 'version', { + get: function () { + return this._version; + }, + enumerable: true, + configurable: true, + }); + FullTextDocument2.prototype.getText = function (range) { + if (range) { + let start = this.offsetAt(range.start); + let end = this.offsetAt(range.end); + return this._content.substring(start, end); + } + return this._content; + }; + FullTextDocument2.prototype.update = function (changes, version) { + for (let _i = 0, changes_1 = changes; _i < changes_1.length; _i++) { + let change = changes_1[_i]; + if (FullTextDocument2.isIncremental(change)) { + let range = getWellformedRange(change.range); + let startOffset = this.offsetAt(range.start); + let endOffset = this.offsetAt(range.end); + this._content = + this._content.substring(0, startOffset) + + change.text + + this._content.substring(endOffset, this._content.length); + let startLine = Math.max(range.start.line, 0); + let endLine = Math.max(range.end.line, 0); + let lineOffsets = this._lineOffsets; + let addedLineOffsets = computeLineOffsets( + change.text, + false, + startOffset + ); + if (endLine - startLine === addedLineOffsets.length) { + for (var i = 0, len = addedLineOffsets.length; i < len; i++) { + lineOffsets[i + startLine + 1] = addedLineOffsets[i]; + } + } else { + if (addedLineOffsets.length < 1e4) { + lineOffsets.splice.apply( + lineOffsets, + [startLine + 1, endLine - startLine].concat(addedLineOffsets) + ); + } else { + this._lineOffsets = lineOffsets = lineOffsets + .slice(0, startLine + 1) + .concat(addedLineOffsets, lineOffsets.slice(endLine + 1)); + } + } + let diff = change.text.length - (endOffset - startOffset); + if (diff !== 0) { + for ( + var i = startLine + 1 + addedLineOffsets.length, + len = lineOffsets.length; + i < len; + i++ + ) { + lineOffsets[i] = lineOffsets[i] + diff; + } + } + } else if (FullTextDocument2.isFull(change)) { + this._content = change.text; + this._lineOffsets = void 0; + } else { + throw new Error('Unknown change event received'); + } + } + this._version = version; + }; + FullTextDocument2.prototype.getLineOffsets = function () { + if (this._lineOffsets === void 0) { + this._lineOffsets = computeLineOffsets(this._content, true); + } + return this._lineOffsets; + }; + FullTextDocument2.prototype.positionAt = function (offset) { + offset = Math.max(Math.min(offset, this._content.length), 0); + let lineOffsets = this.getLineOffsets(); + let low = 0, + high = lineOffsets.length; + if (high === 0) { + return { line: 0, character: offset }; + } + while (low < high) { + let mid = Math.floor((low + high) / 2); + if (lineOffsets[mid] > offset) { + high = mid; + } else { + low = mid + 1; + } + } + let line = low - 1; + return { line, character: offset - lineOffsets[line] }; + }; + FullTextDocument2.prototype.offsetAt = function (position) { + let lineOffsets = this.getLineOffsets(); + if (position.line >= lineOffsets.length) { + return this._content.length; + } else if (position.line < 0) { + return 0; + } + let lineOffset = lineOffsets[position.line]; + let nextLineOffset = + position.line + 1 < lineOffsets.length + ? lineOffsets[position.line + 1] + : this._content.length; + return Math.max( + Math.min(lineOffset + position.character, nextLineOffset), + lineOffset + ); + }; + Object.defineProperty(FullTextDocument2.prototype, 'lineCount', { + get: function () { + return this.getLineOffsets().length; + }, + enumerable: true, + configurable: true, + }); + FullTextDocument2.isIncremental = function (event) { + let candidate = event; + return ( + candidate !== void 0 && + candidate !== null && + typeof candidate.text === 'string' && + candidate.range !== void 0 && + (candidate.rangeLength === void 0 || + typeof candidate.rangeLength === 'number') + ); + }; + FullTextDocument2.isFull = function (event) { + let candidate = event; + return ( + candidate !== void 0 && + candidate !== null && + typeof candidate.text === 'string' && + candidate.range === void 0 && + candidate.rangeLength === void 0 + ); + }; + return FullTextDocument2; + })(); + let TextDocument; + (function (TextDocument2) { + function create(uri, languageId, version, content) { + return new FullTextDocument(uri, languageId, version, content); + } + TextDocument2.create = create; + function update(document2, changes, version) { + if (document2 instanceof FullTextDocument) { + document2.update(changes, version); + return document2; + } else { + throw new Error( + 'TextDocument.update: document must be created by TextDocument.create' + ); + } + } + TextDocument2.update = update; + function applyEdits(document2, edits) { + let text = document2.getText(); + let sortedEdits = mergeSort( + edits.map(getWellformedEdit), + function (a, b) { + let diff = a.range.start.line - b.range.start.line; + if (diff === 0) { + return a.range.start.character - b.range.start.character; + } + return diff; + } + ); + let lastModifiedOffset = 0; + let spans = []; + for ( + let _i = 0, sortedEdits_1 = sortedEdits; + _i < sortedEdits_1.length; + _i++ + ) { + let e = sortedEdits_1[_i]; + let startOffset = document2.offsetAt(e.range.start); + if (startOffset < lastModifiedOffset) { + throw new Error('Overlapping edit'); + } else if (startOffset > lastModifiedOffset) { + spans.push(text.substring(lastModifiedOffset, startOffset)); + } + if (e.newText.length) { + spans.push(e.newText); + } + lastModifiedOffset = document2.offsetAt(e.range.end); + } + spans.push(text.substr(lastModifiedOffset)); + return spans.join(''); + } + TextDocument2.applyEdits = applyEdits; + })(TextDocument || (TextDocument = {})); + function mergeSort(data, compare) { + if (data.length <= 1) { + return data; + } + let p = (data.length / 2) | 0; + let left = data.slice(0, p); + let right = data.slice(p); + mergeSort(left, compare); + mergeSort(right, compare); + let leftIdx = 0; + let rightIdx = 0; + let i = 0; + while (leftIdx < left.length && rightIdx < right.length) { + let ret = compare(left[leftIdx], right[rightIdx]); + if (ret <= 0) { + data[i++] = left[leftIdx++]; + } else { + data[i++] = right[rightIdx++]; + } + } + while (leftIdx < left.length) { + data[i++] = left[leftIdx++]; + } + while (rightIdx < right.length) { + data[i++] = right[rightIdx++]; + } + return data; + } + function computeLineOffsets(text, isAtLineStart, textOffset) { + if (textOffset === void 0) { + textOffset = 0; + } + let result = isAtLineStart ? [textOffset] : []; + for (let i = 0; i < text.length; i++) { + let ch = text.charCodeAt(i); + if (ch === 13 || ch === 10) { + if (ch === 13 && i + 1 < text.length && text.charCodeAt(i + 1) === 10) { + i++; + } + result.push(textOffset + i + 1); + } + } + return result; + } + function getWellformedRange(range) { + let start = range.start; + let end = range.end; + if ( + start.line > end.line || + (start.line === end.line && start.character > end.character) + ) { + return { start: end, end: start }; + } + return range; + } + function getWellformedEdit(textEdit) { + let range = getWellformedRange(textEdit.range); + if (range !== textEdit.range) { + return { newText: textEdit.newText, range }; + } + return textEdit; + } + + // server/src/languages.ts + let import_tree_sitter = __toModule(require_tree_sitter()); + + // server/src/queries/c_sharp/outline.scm + let outline_default = + '\n(class_declaration\n name: (identifier) @class.name\n) @class\n\n(interface_declaration \n name: (identifier) @interface.name\n) @interface\n\n(record_declaration \n name: (identifier) @record.name\n) @record\n\n(record_declaration\n (parameter_list\n (parameter\n name: (identifier) @property.name\n ) @property\n )\n)\n\n(constructor_declaration\n name: (identifier) @constructor.name\n) @constructor\n\n(destructor_declaration\n (identifier) @method.name\n) @method\n\n(indexer_declaration\n (bracketed_parameter_list) @method.name\n) @method\n\n(method_declaration\n name: (identifier) @method.name\n) @method\n\n(property_declaration\n name: (identifier) @property.name\n) @property\n\n(delegate_declaration\n name: (identifier) @function.name\n) @function\n\n(field_declaration\n (variable_declaration\n (variable_declarator\n (identifier) @field.name\n )\n )\n) @field\n\n(event_field_declaration\n (variable_declaration\n (variable_declarator\n (identifier) @event.name\n )\n )\n) @event\n\n(global_attribute_list\n (attribute\n (identifier) @constant.name\n ) @constant\n)\n\n(global_statement\n (local_declaration_statement\n (variable_declaration\n (variable_declarator\n (identifier) @variable.name\n )\n )\n )\n)\n\n(enum_declaration name:\n (identifier) @enum.name\n) @enum\n\n(struct_declaration\n (identifier) @struct.name\n) @struct\n\n(namespace_declaration\n [\n name: (identifier) @module.name\n name: (qualified_name) @module.name\n ]\n) @module\n\n(enum_member_declaration\n (identifier) @enumMember.name\n) @enumMember\n'; + + // server/src/queries/c_sharp/locals.scm + let locals_default = + '(namespace_declaration body: (_) @scope.exports)\n(class_declaration) @scope\n(interface_declaration) @scope\n(constructor_declaration) @scope\n(method_declaration) @scope\n(if_statement [consequence: (_) @scope alternative: (_) @scope]) \n(for_each_statement) @scope\n(for_statement) @scope\n(do_statement) @scope\n(while_statement) @scope\n(using_statement) @scope\n(block) @scope\n\n(class_declaration name: (identifier) @local.escape)\n(interface_declaration name: (identifier) @local.escape)\n(constructor_declaration name: (identifier) @local.escape)\n(method_declaration name: (identifier) @local.escape)\n(parameter name: (identifier) @local)\n(parameter_array (identifier) @local)\n(variable_declarator (identifier) @local)\n(type_parameter (identifier) @local)\n(for_each_statement left: (identifier) @local)\n(query_expression [\n (from_clause . (identifier) @local) \n])\n\n(member_access_expression name: (identifier) @usage.void)\n(identifier) @usage\n'; + + // server/src/queries/c_sharp/comments.scm + let comments_default = '(comment) @comment\n'; + + // server/src/queries/c_sharp/identifiers.scm + let identifiers_default = '(identifier) @identifier\n'; + + // server/src/queries/c_sharp/references.scm + let references_default = + '(object_creation_expression\n type: (identifier) @ref.type)\n(type_parameter_constraints_clause\n target: (identifier) @ref.type)\n(type_constraint\n type: (identifier) @ref.type)\n(variable_declaration\n type: (identifier) @ref.type)\n(member_access_expression \n name: (identifier) @ref)\n(invocation_expression\n function: (identifier) @ref)\n(base_list (_) @ref.type)\n'; + + // server/src/queries/c_sharp/index.ts + let mod = { + outline: outline_default, + locals: locals_default, + comments: comments_default, + identifiers: identifiers_default, + references: references_default, + }; + let c_sharp_default = mod; + + // server/src/queries/c/outline.scm + let outline_default2 = + '(struct_specifier\n name: (type_identifier) @struct.name) @struct\n\n(union_specifier\n name: (type_identifier) @struct.name) @struct\n\n(enum_specifier\n name: (type_identifier) @enum.name) @enum\n\n(enumerator\n name: (identifier) @enumMember.name) @enumMember\n\n(function_definition\n declarator: (function_declarator\n [\n (identifier) @function.name\n (field_identifier) @function.name\n ])) @function\n\n(pointer_declarator\n declarator: (function_declarator\n declarator: (identifier) @function.name) @function)\n\n(declaration\n declarator: (function_declarator\n [\n (identifier) @function.name\n (field_identifier) @function.name\n ]) @function)\n\n(declaration\n type: (primitive_type) \n declarator: (identifier) @variable.name) @variable\n\n(type_definition\n type: (_)\n declarator: (type_identifier) @struct.name) @struct\n\n(linkage_specification\n value: (string_literal) @struct.name) @struct\n\n(field_declaration\n (function_declarator\n [\n (identifier) @function.name\n (field_identifier) @function.name\n ]\n )) @function\n\n\n(field_declaration\n (field_identifier) @field.name) @field\n\n(field_declaration_list\n (field_declaration\n [\n declarator: (field_identifier) @field.name\n (array_declarator\n declarator: (field_identifier) @field.name\n )\n ]\n ) @field)\n'; + + // server/src/queries/c/comments.scm + let comments_default2 = '(comment) @comment\n'; + + // server/src/queries/c/identifiers.scm + let identifiers_default2 = + '\n(identifier) @identifier\n(field_identifier) @identifier\n(type_identifier) @identifier\n'; + + // server/src/queries/c/index.ts + let mod2 = { + outline: outline_default2, + comments: comments_default2, + identifiers: identifiers_default2, + }; + let c_default = mod2; + + // server/src/queries/cpp/outline.scm + let outline_default3 = + '(namespace_definition\n name: (identifier) @module.name) @module\n\n(friend_declaration\n (type_identifier) @variable.name) @variable\n\n(field_declaration\n (function_declarator\n (scoped_identifier) @function.name)) @function\n\n(declaration\n (function_declarator\n [\n (scoped_identifier) @function.name\n (destructor_name) @function.name\n ]) @function)\n\n(class_specifier\n (type_identifier) @class.name) @class\n'; + + // server/src/queries/cpp/comments.scm + let comments_default3 = '(comment) @comment\n'; + + // server/src/queries/cpp/identifiers.scm + let identifiers_default3 = + '(identifier) @identifier\n(field_identifier) @identifier\n(type_identifier) @identifier\n(namespace_identifier) @identifier\n'; + + // server/src/queries/cpp/index.ts + let mod3 = { + outline: `${outline_default2} +${outline_default3}`, + comments: comments_default3, + identifiers: identifiers_default3, + }; + let cpp_default = mod3; + + // server/src/queries/go/outline.scm + let outline_default4 = + '\n(field_declaration (field_identifier) @field @field.name)\n\n(method_spec\n name: (field_identifier) @method.name\n) @method\n\n(type_alias\n name: (type_identifier) @string.name\n) @string\n\n(function_declaration\n name: (identifier) @function.name\n) @function\n\n(method_declaration\n name: (field_identifier) @method.name\n) @method\n\n;; variables defined in the package\n(source_file\n (var_declaration\n (var_spec\n (identifier) @variable.name\n ) @variable\n )\n)\n\n;; lots of type_spec, must be mutually exclusive\n(type_spec \n name: (type_identifier) @interface.name\n type: (interface_type)\n) @interface\n\n(type_spec \n name: (type_identifier) @function.name\n type: (function_type)\n) @function\n\n(type_spec\n name: (type_identifier) @struct.name\n type: (struct_type)\n) @struct\n\n(type_spec\n name: (type_identifier) @struct.name\n type: (map_type)\n) @struct\n\n(type_spec\n name: (type_identifier) @struct.name\n type: (pointer_type)\n) @struct\n\n(type_spec\n name: (type_identifier) @event.name\n type: (channel_type)\n) @event\n\n(type_spec \n name: (type_identifier) @class.name\n type: (type_identifier)\n) @class\n'; + + // server/src/queries/go/locals.scm + let locals_default2 = + '(method_declaration) @scope\n(function_declaration) @scope\n(expression_switch_statement) @scope\n(for_statement) @scope\n(block) @scope\n(type_switch_statement) @scope\n(composite_literal body: (literal_value) @scope)\n\n(const_spec name: (identifier) @local)\n(var_declaration (var_spec (identifier) @local))\n(parameter_declaration (identifier) @local)\n(short_var_declaration left: (expression_list (identifier) @local))\n(range_clause left: (expression_list (identifier) @local))\n(type_switch_statement (expression_list (identifier) @local))\n(function_declaration name: (identifier) @local.escape)\n(method_declaration name: (field_identifier) @local.escape)\n\n(identifier) @usage\n'; + + // server/src/queries/go/comments.scm + let comments_default4 = '(comment) @comment\n'; + + // server/src/queries/go/identifiers.scm + let identifiers_default4 = + '(type_identifier) @identifier.type\n(field_identifier) @identifier.field\n(package_identifier) @identifier\n(identifier) @identifier\n'; + + // server/src/queries/go/folding.scm + let folding_default = '(block) @scope\n'; + + // server/src/queries/go/references.scm + let references_default2 = + '(field_identifier) @ref.field\n(type_identifier) @ref.type\n(call_expression \n (identifier) @ref.call)\n'; + + // server/src/queries/go/index.ts + let mod4 = { + outline: outline_default4, + comments: comments_default4, + locals: locals_default2, + folding: folding_default, + identifiers: identifiers_default4, + references: references_default2, + }; + let go_default = mod4; + + // server/src/queries/java/outline.scm + let outline_default5 = + '\n(class_declaration\n name: (identifier) @class.name\n) @class\n\n(variable_declarator\n name: (identifier) @class.name\n value: (object_creation_expression\n .\n (_)*\n (class_body)\n )\n) @class\n\n(interface_declaration\n name: (identifier) @interface.name\n) @interface\n\n(enum_declaration\n name: (identifier) @enum.name\n) @enum\n\n(enum_constant\n name: (identifier) @enumMember.name\n) @enumMember\n\n(constructor_declaration\n name: (identifier) @constructor.name\n) @constructor\n\n(method_declaration\n name: (identifier) @method.name\n) @method\n\n(field_declaration\n declarator: ((variable_declarator\n name: (identifier) @field.name)\n ) @field\n)\n\n(module_declaration\n [\n (scoped_identifier) @module.name\n (identifier) @module.name\n ]\n) @module\n'; + + // server/src/queries/java/locals.scm + let locals_default3 = + '\n(method_declaration) @scope\n(constructor_declaration) @scope\n[(class_body) (interface_body) (enum_body)] @scope\n(for_statement) @scope\n(if_statement consequence: (_) @scope)\n(if_statement alternative: (_) @scope)\n(while_statement body: (_) @scope)\n(try_statement (block) @scope)\n(catch_clause) @scope\n(block) @scope\n\n(formal_parameter name: (identifier) @local)\n(local_variable_declaration declarator: (variable_declarator name: (identifier) @local))\n(catch_formal_parameter name: (identifier) @local)\n(method_declaration name: (identifier) @local.escape)\n(constructor_declaration name: (identifier) @local.escape)\n\n(field_access field: (identifier) @usage.void)\n(identifier) @usage\n'; + + // server/src/queries/java/comments.scm + let comments_default5 = '(comment) @comment\n'; + + // server/src/queries/java/identifiers.scm + let identifiers_default5 = + '(type_identifier) @identifier\n(identifier) @identifier\n'; + + // server/src/queries/java/folding.scm + let folding_default2 = + '(comment) @comment\n[(class_body) (interface_body) (enum_body)] @scope\n(for_statement) @scope\n(if_statement consequence: (_) @scope)\n(if_statement alternative: (_) @scope)\n(while_statement body: (_) @scope)\n(try_statement (block) @scope)\n(catch_clause) @scope\n(block) @scope\n'; + + // server/src/queries/java/references.scm + let references_default3 = + '(method_invocation\n name: (identifier) @ref.method)\n(interface_type_list\n (type_identifier) @ref.interface)\n(superclass \n (type_identifier) @ref.class)\n(object_creation_expression\n type: (type_identifier) @ref.class)\n (type_identifier) @ref.class.interface.enum\n(field_access\n field: (identifier) @ref.field)\n'; + + // server/src/queries/java/index.ts + let mod5 = { + outline: outline_default5, + locals: locals_default3, + identifiers: identifiers_default5, + comments: comments_default5, + folding: folding_default2, + references: references_default3, + }; + let java_default = mod5; + + // server/src/queries/php/outline.scm + let outline_default6 = + '(class_declaration\n name: (name) @class.name\n) @class\n\n(method_declaration\n name: (name) @method.name\n) @method\n\n(property_element\n (variable_name) @property.name\n) @property\n\n(function_definition\n name: (name) @function.name\n) @function\n\n(trait_declaration\n name: (name) @property.name\n) @property\n'; + + // server/src/queries/php/comments.scm + let comments_default6 = '(comment) @comment\n'; + + // server/src/queries/php/identifiers.scm + let identifiers_default6 = '(name) @identifier\n'; + + // server/src/queries/php/locals.scm + let locals_default4 = + '(method_declaration) @scope\n(function_definition) @scope\n(compound_statement) @scope\n(declaration_list) @scope\n\n(function_definition\n name: (name) @local.escape)\n(method_declaration\n name: (name) @local.escape)\n(assignment_expression\n left: (variable_name) @local)\n(augmented_assignment_expression\n left: (variable_name) @local)\n(static_variable_declaration\n name: (variable_name) @local)\n(simple_parameter\n name: (variable_name) @local)\n\n(variable_name) @usage\n'; + + // server/src/queries/php/references.scm + let references_default4 = + '(object_creation_expression [\n (qualified_name (name) @ref)\n (variable_name (name) @ref)])\n\n(function_call_expression function: [\n (qualified_name (name) @ref)\n (variable_name (name)) @ref])\n\n(member_access_expression name: (name) @ref) \n\n(scoped_call_expression\n name: (name) @ref)\n\n(member_call_expression\n name: (name) @ref)\n'; + + // server/src/queries/php/index.ts + let mod6 = { + outline: outline_default6, + identifiers: identifiers_default6, + comments: comments_default6, + locals: locals_default4, + references: references_default4, + }; + let php_default = mod6; + + // server/src/queries/python/outline.scm + let outline_default7 = + '(class_definition\n name: (identifier) @class.name) @class\n\n(function_definition\n name: (identifier) @function.name) @function\n\n(module\n (expression_statement \n (assignment left: (identifier) @var)))\n'; + + // server/src/queries/python/locals.scm + let locals_default5 = + '(class_definition) @scope\n(function_definition) @scope\n(for_statement) @scope\n\n(parameters (identifier) @local)\n(assignment left: (identifier) @local)\n(function_definition name: (identifier) @local.escape)\n(class_definition name: (identifier) @local.escape)\n(for_statement left: (identifier) @local)\n\n(identifier) @usage\n'; + + // server/src/queries/python/comments.scm + let comments_default7 = '(comment) @comment\n'; + + // server/src/queries/python/identifiers.scm + let identifiers_default7 = '(identifier) @identifier\n'; + + // server/src/queries/python/references.scm + let references_default5 = + '(call function: [\n (identifier) @ref\n (attribute\n attribute: (identifier) @ref)])\n'; + + // server/src/queries/python/index.ts + let mod7 = { + outline: outline_default7, + locals: locals_default5, + identifiers: identifiers_default7, + comments: comments_default7, + references: references_default5, + }; + let python_default = mod7; + + // server/src/queries/rust/outline.scm + let outline_default8 = + '(mod_item\n name: (identifier) @module.name) @module\n\n(function_item\n name: (identifier) @function.name) @function\n\n(union_item\n name: (type_identifier) @struct.name) @struct\n\n(field_declaration\n name: (field_identifier) @field.name) @field\n\n(struct_item\n name: (type_identifier) @struct.name) @struct\n\n(enum_item\n name: (type_identifier) @enum.name) @enum\n\n(enum_variant\n name: (identifier) @enumMember.name) @enumMember\n\n(trait_item\n name: (type_identifier) @interface.name) @interface\n\n(function_signature_item\n name: (identifier) @function.name) @function\n\n(const_item\n name: (identifier) @constant.name) @constant\n\n(static_item\n name: (identifier) @constant.name) @constant\n\n(type_item\n name: (type_identifier) @interface.name) @interface\n\n(impl_item \n . [(generic_type) (type_identifier)] @class.name) @class\n\n(foreign_mod_item\n (extern_modifier (string_literal) @namespace.name)) @namespace\n'; + + // server/src/queries/rust/locals.scm + let locals_default6 = + '(mod_item body: (declaration_list) @scope.exports)\n(for_expression) @scope\n(function_item) @scope\n(block) @scope\n\n(function_item name: (identifier) @local.escape)\n(const_item name: (identifier) @local)\n(static_item name: (identifier) @local)\n(let_declaration pattern: (identifier) @local)\n(parameter pattern: (identifier) @local)\n(for_expression pattern: (identifier) @local)\n(reference_pattern (identifier) @local)\n(tuple_pattern (identifier) @local)\n(self_parameter (self) @local)\n\n(scoped_identifier name: (identifier) @usage.void)\n(identifier) @usage\n(self) @usage\n'; + + // server/src/queries/rust/comments.scm + let comments_default8 = '(line_comment) @comment\n(block_comment) @comment\n'; + + // server/src/queries/rust/identifiers.scm + let identifiers_default8 = + '(scoped_identifier) @identifier\n(type_identifier) @identifier\n(field_identifier) @identifier\n(identifier) @identifier\n'; + + // server/src/queries/rust/folding.scm + let folding_default3 = + '(block_comment) @comment\n(block) @scope\n(_) body: (_) @fold\n'; + + // server/src/queries/rust/references.scm + let references_default6 = + '(field_identifier) @ref.field.method\n(type_identifier) @ref.interface.struct.class\n(call_expression (identifier) @ref.function) \n(scoped_identifier name: (identifier) @ref)\n(macro_invocation macro: (identifier) @ref)\n((macro_invocation (token_tree (identifier) @ref)))\n'; + + // server/src/queries/rust/index.ts + let mod8 = { + outline: outline_default8, + locals: locals_default6, + identifiers: identifiers_default8, + comments: comments_default8, + folding: folding_default3, + references: references_default6, + }; + let rust_default = mod8; + + // server/src/queries/typescript/outline.scm + let outline_default9 = + '(interface_declaration\n name: (type_identifier) @interface.name) @interface\n\n(property_signature\n name: (property_identifier) @field.name) @field\n\n(method_signature\n name: (property_identifier) @method.name) @method\n\n(class_declaration\n name: (type_identifier) @class.name) @class\n\n(new_expression\n constructor: (class\n name: (type_identifier)? @class.name\n body: (class_body)) @class)\n\n(method_definition\n name: [\n (property_identifier) @method.name\n (computed_property_name (string) @method.name)\n ]) @method\n\n(public_field_definition\n name: [\n (property_identifier) @field.name\n (computed_property_name (string) @field.name)\n ]) @field\n\n(enum_declaration\n name: (identifier) @enum.name) @enum\n\n(enum_body [\n (property_identifier) @enumMember\n (enum_assignment (property_identifier) @enumMember)])\n\n(function_declaration\n name: (identifier) @function.name) @function\n\n(function_signature\n name: (identifier) @function.name) @function\n\n(variable_declarator\n name: (identifier) @variable.name) @variable\n\n(module\n name: [(identifier)@module.name (string) @module.name]) @module\n\n(internal_module\n name: (identifier) @module.name) @module\n\n(type_alias_declaration\n name: (type_identifier) @interface.name) @interface\n'; + + // server/src/queries/typescript/comments.scm + let comments_default9 = '(comment) @comment\n'; + + // server/src/queries/typescript/identifiers.scm + let identifiers_default9 = + '(identifier) @identifier\n(property_identifier) @identifier\n(type_identifier) @identifier\n'; + + // server/src/queries/typescript/locals.scm + let locals_default7 = + '(method_definition) @scope\n(function_declaration) @scope\n(function) @scope\n(arrow_function) @scope\n[(class_body) (enum_body)] @scope\n(interface_declaration body: (object_type) @scope)\n(for_statement) @scope\n(if_statement consequence: (_) @scope)\n(if_statement alternative: (_) @scope)\n(while_statement body: (_) @scope)\n(try_statement (statement_block) @scope)\n(catch_clause) @scope\n(statement_block) @scope\n\n(function_declaration name: (identifier) @local.escape)\n(function name: (identifier) @local.escape)\n(required_parameter (identifier) @local)\n(optional_parameter (identifier) @local)\n(catch_clause parameter: (identifier) @local)\n(variable_declarator (identifier) @local)\n(type_parameter (type_identifier) @local)\n\n(enum_declaration name: (identifier) @usage.void)\n(identifier) @usage\n(type_identifier) @usage\n'; + + // server/src/queries/typescript/references.scm + let references_default7 = + '(type_identifier) @ref.class.interface.enum\n(new_expression\n constructor: (identifier) @ref.class)\n(call_expression [\n (identifier) @ref.function\n (member_expression property: (property_identifier) @ref.function)])\n(property_identifier) @ref.field.method\n'; + + // server/src/queries/typescript/index.ts + let mod9 = { + outline: outline_default9, + comments: comments_default9, + identifiers: identifiers_default9, + locals: locals_default7, + references: references_default7, + }; + let typescript_default = mod9; + + // server/src/languages.ts + let _queryModules = new Map([ + ['csharp', c_sharp_default], + ['c', c_default], + ['cpp', cpp_default], + ['go', go_default], + ['java', java_default], + ['php', php_default], + ['python', python_default], + ['rust', rust_default], + ['typescript', typescript_default], + ]); + let Languages = class { + static async init(langConfiguration) { + this._langConfiguration = langConfiguration; + for (const [entry, config] of langConfiguration) { + const lang = await import_tree_sitter.default.Language.load( + entry.wasmUri + ); + this._languageInstances.set(entry.languageId, lang); + this._configurations.set(entry.languageId, config); + } + } + static getLanguage(languageId) { + let result = this._languageInstances.get(languageId); + if (!result) { + console.warn(`UNKNOWN languages: '${languageId}'`); + return void 0; + } + return result; + } + static allAsSelector() { + return [...this._languageInstances.keys()]; + } + static getQuery(languageId, type, strict = false) { + const module = _queryModules.get(languageId); + if (!module) { + return this.getLanguage(languageId).query(''); + } + const source = module[type] ?? ''; + const key = `${languageId}/${type}`; + let query = this._queryInstances.get(key); + if (!query) { + try { + query = this.getLanguage(languageId).query(source); + } catch (e) { + query = this.getLanguage(languageId).query(''); + console.error(languageId, e); + if (strict) { + throw e; + } + } + this._queryInstances.set(key, query); + } + return query; + } + static getSupportedLanguages(feature, types) { + const result = []; + for (let languageId of this._languageInstances.keys()) { + const module = _queryModules.get(languageId); + if (!module) { + console.warn(`${languageId} NOT supported by queries`); + continue; + } + for (let type of types) { + if (module[type] && this._configurations.get(languageId)?.[feature]) { + result.push(languageId); + break; + } + } + } + return result; + } + static getLanguageIdByUri(uri) { + let end = uri.lastIndexOf('?'); + if (end < 0) { + end = uri.lastIndexOf('#'); + } + if (end > 0) { + uri = uri.substring(0, end); + } + const start = uri.lastIndexOf('.'); + const suffix = uri.substring(start + 1); + for (let [info] of this._langConfiguration) { + for (let candidate of info.suffixes) { + if (candidate === suffix) { + return info.languageId; + } + } + } + return `unknown/${uri}`; + } + }; + Languages._languageInstances = new Map(); + Languages._queryInstances = new Map(); + Languages._configurations = new Map(); + + // server/src/util/lruMap.ts + let LRUMap = class extends Map { + constructor(_options) { + super(); + this._options = _options; + } + set(key, value) { + super.set(key, value); + this._checkSize(); + return this; + } + get(key) { + if (!this.has(key)) { + return void 0; + } + const result = super.get(key); + this.delete(key); + this.set(key, result); + return result; + } + _checkSize() { + setTimeout(() => { + const slack = Math.ceil(this._options.size * 0.3); + if (this.size < this._options.size + slack) { + return; + } + const result = Array.from(this.entries()).slice(0, slack); + for (let [key] of result) { + this.delete(key); + } + this._options.dispose(result); + }, 0); + } + }; + + // server/src/documentStore.ts + let DocumentStore = class extends import_vscode_languageserver.TextDocuments { + constructor(_connection) { + super({ + create: TextDocument.create, + update: (doc, changes, version) => { + let result; + let incremental = true; + let event = { document: doc, changes: [] }; + for (const change of changes) { + if (!lsp.TextDocumentContentChangeEvent.isIncremental(change)) { + incremental = false; + break; + } + const rangeOffset = doc.offsetAt(change.range.start); + event.changes.push({ + text: change.text, + range: change.range, + rangeOffset, + rangeLength: + change.rangeLength ?? + doc.offsetAt(change.range.end) - rangeOffset, + }); + } + result = TextDocument.update(doc, changes, version); + if (incremental) { + this._onDidChangeContent2.fire(event); + } + return result; + }, + }); + this._connection = _connection; + this._onDidChangeContent2 = new lsp.Emitter(); + this.onDidChangeContent2 = this._onDidChangeContent2.event; + this._decoder = new TextDecoder(); + this._fileDocuments = new LRUMap({ + size: 200, + dispose: (_entries) => {}, + }); + super.listen(_connection); + _connection.onNotification('file-cache/remove', (uri) => + this._fileDocuments.delete(uri) + ); + } + async retrieve(uri) { + let result = this.get(uri); + if (result) { + return result; + } + let promise = this._fileDocuments.get(uri); + if (!promise) { + promise = this._requestDocument(uri); + this._fileDocuments.set(uri, promise); + } + return promise; + } + async _requestDocument(uri) { + const reply = await this._connection.sendRequest('file/read', uri); + return TextDocument.create( + uri, + Languages.getLanguageIdByUri(uri), + 1, + this._decoder.decode(reply) + ); + } + }; + + // server/src/features/completions.ts + let lsp2 = __toModule(require_main4()); + var _CompletionItemProvider = class { + constructor(_documents, _trees, _symbols) { + this._documents = _documents; + this._trees = _trees; + this._symbols = _symbols; + } + register(connection2) { + connection2.client.register(lsp2.CompletionRequest.type, { + documentSelector: Languages.getSupportedLanguages('completions', [ + 'identifiers', + 'outline', + ]), + }); + connection2.onRequest( + lsp2.CompletionRequest.type, + this.provideCompletionItems.bind(this) + ); + } + async provideCompletionItems(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + const tree = this._trees.getParseTree(document2); + if (!tree) { + return []; + } + const result = new Map(); + const query = Languages.getQuery(document2.languageId, 'identifiers'); + const captures = query.captures(tree.rootNode); + for (let capture of captures) { + const text = capture.node.text; + result.set(text, { label: text }); + } + for (let [name, map] of this._symbols.index) { + for (let [, info] of map) { + if (info.definitions.size > 0) { + const [firstDefinitionKind] = info.definitions; + result.set(name, { + label: name, + kind: _CompletionItemProvider._kindMapping.get( + firstDefinitionKind + ), + }); + break; + } + } + } + return Array.from(result.values()); + } + }; + let CompletionItemProvider = _CompletionItemProvider; + CompletionItemProvider._kindMapping = new Map([ + [lsp2.SymbolKind.Class, lsp2.CompletionItemKind.Class], + [lsp2.SymbolKind.Interface, lsp2.CompletionItemKind.Interface], + [lsp2.SymbolKind.Field, lsp2.CompletionItemKind.Field], + [lsp2.SymbolKind.Property, lsp2.CompletionItemKind.Property], + [lsp2.SymbolKind.Event, lsp2.CompletionItemKind.Event], + [lsp2.SymbolKind.Constructor, lsp2.CompletionItemKind.Constructor], + [lsp2.SymbolKind.Method, lsp2.CompletionItemKind.Method], + [lsp2.SymbolKind.Enum, lsp2.CompletionItemKind.Enum], + [lsp2.SymbolKind.EnumMember, lsp2.CompletionItemKind.EnumMember], + [lsp2.SymbolKind.Function, lsp2.CompletionItemKind.Function], + [lsp2.SymbolKind.Variable, lsp2.CompletionItemKind.Variable], + ]); + + // server/src/features/definitions.ts + let lsp5 = __toModule(require_main4()); + + // server/src/common.ts + let lsp3 = __toModule(require_main4()); + let symbolMapping = new (class { + constructor() { + this._symbolKindMapping = new Map([ + ['file', lsp3.SymbolKind.File], + ['module', lsp3.SymbolKind.Module], + ['namespace', lsp3.SymbolKind.Namespace], + ['package', lsp3.SymbolKind.Package], + ['class', lsp3.SymbolKind.Class], + ['method', lsp3.SymbolKind.Method], + ['property', lsp3.SymbolKind.Property], + ['field', lsp3.SymbolKind.Field], + ['constructor', lsp3.SymbolKind.Constructor], + ['enum', lsp3.SymbolKind.Enum], + ['interface', lsp3.SymbolKind.Interface], + ['function', lsp3.SymbolKind.Function], + ['variable', lsp3.SymbolKind.Variable], + ['constant', lsp3.SymbolKind.Constant], + ['string', lsp3.SymbolKind.String], + ['number', lsp3.SymbolKind.Number], + ['boolean', lsp3.SymbolKind.Boolean], + ['array', lsp3.SymbolKind.Array], + ['object', lsp3.SymbolKind.Object], + ['key', lsp3.SymbolKind.Key], + ['null', lsp3.SymbolKind.Null], + ['enumMember', lsp3.SymbolKind.EnumMember], + ['struct', lsp3.SymbolKind.Struct], + ['event', lsp3.SymbolKind.Event], + ['operator', lsp3.SymbolKind.Operator], + ['typeParameter', lsp3.SymbolKind.TypeParameter], + ]); + } + getSymbolKind(symbolKind, strict) { + const res = this._symbolKindMapping.get(symbolKind); + if (!res && strict) { + return void 0; + } + return res ?? lsp3.SymbolKind.Variable; + } + })(); + function asLspRange(node) { + return lsp3.Range.create( + node.startPosition.row, + node.startPosition.column, + node.endPosition.row, + node.endPosition.column + ); + } + function identifierAtPosition(identQuery, node, position) { + let candidate = nodeAtPosition(node, position, false); + let capture = identQuery.captures(candidate); + if (capture.length === 1) { + return candidate; + } + candidate = nodeAtPosition(node, position, true); + capture = identQuery.captures(candidate); + if (capture.length === 1) { + return candidate; + } + return void 0; + } + function nodeAtPosition(node, position, leftBias = false) { + for (const child of node.children) { + const range = asLspRange(child); + if (isBeforeOrEqual(range.start, position)) { + if (isBefore(position, range.end)) { + return nodeAtPosition(child, position, leftBias); + } + if (leftBias && isBeforeOrEqual(position, range.end)) { + return nodeAtPosition(child, position, leftBias); + } + } + } + return node; + } + function isBeforeOrEqual(a, b) { + if (a.line < b.line) { + return true; + } + if (b.line < a.line) { + return false; + } + return a.character <= b.character; + } + function isBefore(a, b) { + if (a.line < b.line) { + return true; + } + if (b.line < a.line) { + return false; + } + return a.character < b.character; + } + function compareRangeByStart(a, b) { + if (isBefore(a.start, b.start)) { + return -1; + } else if (isBefore(b.start, a.start)) { + return 1; + } + if (isBefore(a.end, b.end)) { + return -1; + } else if (isBefore(b.end, a.end)) { + return 1; + } + return 0; + } + function containsPosition(range, position) { + return ( + isBeforeOrEqual(range.start, position) && + isBeforeOrEqual(position, range.end) + ); + } + function containsRange(range, other) { + return ( + containsPosition(range, other.start) && containsPosition(range, other.end) + ); + } + let StopWatch = class { + constructor() { + this.t1 = performance.now(); + } + reset() { + this.t1 = performance.now(); + } + elapsed() { + return (performance.now() - this.t1).toFixed(2); + } + }; + function isInteresting(uri) { + return !/^(git|github|vsls):/i.test(uri); + } + async function parallel(tasks, degree, token) { + let result = []; + let pos = 0; + while (true) { + if (token.isCancellationRequested) { + throw new Error('cancelled'); + } + const partTasks = tasks.slice(pos, pos + degree); + if (partTasks.length === 0) { + break; + } + const partResult = await Promise.all( + partTasks.map((task) => task(token)) + ); + pos += degree; + result.push(...partResult); + } + return result; + } + + // server/src/features/locals.ts + let lsp4 = __toModule(require_main4()); + var Locals = class { + constructor(document2, root) { + this.document = document2; + this.root = root; + } + static create(document2, trees) { + const root = new Scope( + lsp4.Range.create(0, 0, document2.lineCount, 0), + true + ); + const tree = trees.getParseTree(document2); + if (!tree) { + return new Locals(document2, root); + } + const all = []; + const query = Languages.getQuery(document2.languageId, 'locals'); + const captures = query + .captures(tree.rootNode) + .sort(this._compareCaptures); + const scopeCaptures = captures.filter((capture) => + capture.name.startsWith('scope') + ); + for (let i = 0; i < scopeCaptures.length; i++) { + const capture = scopeCaptures[i]; + const range = asLspRange(capture.node); + all.push(new Scope(range, capture.name.endsWith('.exports'))); + } + this._fillInDefinitionsAndUsages(all, captures); + this._constructTree(root, all); + const info = new Locals(document2, root); + return info; + } + static _fillInDefinitionsAndUsages(bucket, captures) { + for (const capture of captures) { + if (capture.name.startsWith('local')) { + bucket.push( + new Definition( + capture.node.text, + asLspRange(capture.node), + capture.name.endsWith('.escape') + ) + ); + } else if (capture.name.startsWith('usage')) { + bucket.push( + new Usage( + capture.node.text, + asLspRange(capture.node), + capture.name.endsWith('.void') + ) + ); + } + } + } + static _constructTree(root, nodes) { + const stack = []; + for (const thing of nodes.sort(this._compareByRange)) { + while (true) { + let parent = stack.pop() ?? root; + if (containsRange(parent.range, thing.range)) { + if (thing instanceof Definition && thing.escapeToParent) { + (stack[stack.length - 1] ?? root).appendChild(thing); + } else { + parent.appendChild(thing); + } + stack.push(parent); + stack.push(thing); + break; + } + if (parent === root) { + break; + } + } + } + stack.length = 0; + stack.push(root); + while (stack.length > 0) { + let n = stack.pop(); + if (n instanceof Usage && n.isHelper) { + n.remove(); + } else { + stack.push(...n.children()); + } + } + } + static _compareCaptures(a, b) { + return a.node.startIndex - b.node.startIndex; + } + static _compareByRange(a, b) { + return compareRangeByStart(a.range, b.range); + } + debugPrint() { + console.log(this.root.toString()); + } + }; + let NodeType; + (function (NodeType2) { + NodeType2[(NodeType2['Scope'] = 0)] = 'Scope'; + NodeType2[(NodeType2['Definition'] = 1)] = 'Definition'; + NodeType2[(NodeType2['Usage'] = 2)] = 'Usage'; + })(NodeType || (NodeType = {})); + let Node = class { + constructor(range, type) { + this.range = range; + this.type = type; + this._children = []; + } + children() { + return this._children; + } + remove() { + if (!this._parent) { + return false; + } + const idx = this._parent._children.indexOf(this); + if (idx < 0) { + return false; + } + this._parent._children.splice(idx, 1); + return true; + } + appendChild(node) { + this._children.push(node); + node._parent = this; + } + toString() { + return `${this.type}@${this.range.start.line},${this.range.start.character}-${this.range.end.line},${this.range.end.character}`; + } + }; + var Usage = class extends Node { + constructor(name, range, isHelper) { + super(range, 2); + this.name = name; + this.range = range; + this.isHelper = isHelper; + } + appendChild(_node) {} + toString() { + return `use:${this.name}`; + } + get scope() { + return this._parent; + } + }; + var Definition = class extends Node { + constructor(name, range, escapeToParent) { + super(range, 1); + this.name = name; + this.range = range; + this.escapeToParent = escapeToParent; + } + appendChild(_node) {} + toString() { + return `def:${this.name}`; + } + get scope() { + return this._parent; + } + }; + var Scope = class extends Node { + constructor(range, likelyExports) { + super(range, 0); + this.likelyExports = likelyExports; + } + *definitions() { + for (let item of this._children) { + if (item instanceof Definition) { + yield item; + } + } + } + *usages() { + for (let item of this._children) { + if (item instanceof Usage) { + yield item; + } + } + } + *scopes() { + for (let item of this._children) { + if (item instanceof Scope) { + yield item; + } + } + } + _findScope(position) { + for (let scope of this.scopes()) { + if (containsPosition(scope.range, position)) { + return scope._findScope(position); + } + } + return this; + } + findDefinitionOrUsage(position) { + let scope = this._findScope(position); + while (true) { + for (let child of scope._children) { + if ( + (child instanceof Definition || child instanceof Usage) && + containsPosition(child.range, position) + ) { + return child; + } + } + if (scope._parent instanceof Scope) { + scope = scope._parent; + } else { + break; + } + } + } + findDefinitions(text) { + const result = []; + for (let child of this.definitions()) { + if (child.name === text) { + result.push(child); + } + } + if (result.length > 0) { + return result; + } + if (!(this._parent instanceof Scope)) { + return []; + } + return this._parent.findDefinitions(text); + } + findUsages(text) { + const bucket = []; + let scope = this; + while (!scope._defines(text)) { + if (scope._parent instanceof Scope) { + scope = scope._parent; + } else { + break; + } + } + scope._findUsagesDown(text, bucket); + return bucket.flat(); + } + _findUsagesDown(text, bucket) { + const result = []; + for (let child of this.usages()) { + if (child.name === text) { + result.push(child); + } + } + bucket.push(result); + for (let child of this.scopes()) { + if (!child._defines(text)) { + child._findUsagesDown(text, bucket); + } + } + } + _defines(text) { + for (let child of this.definitions()) { + if (child.name === text) { + return true; + } + } + return false; + } + toString(depth = 0) { + let scopes = []; + let parts = []; + this._children.slice(0).forEach((child) => { + if (child instanceof Scope) { + scopes.push(child.toString(depth + 2)); + } else { + parts.push(child.toString()); + } + }); + let indent = ' '.repeat(depth); + let res = `${indent}Scope@${this.range.start.line},${this.range.start.character}-${this.range.end.line},${this.range.end.character}`; + res += ` +${indent + indent}${parts.join(`, `)}`; + res += ` +${indent}${scopes.join(` +${indent}`)}`; + return res; + } + }; + + // server/src/features/definitions.ts + let DefinitionProvider = class { + constructor(_documents, _trees, _symbols) { + this._documents = _documents; + this._trees = _trees; + this._symbols = _symbols; + } + register(connection2) { + connection2.client.register(lsp5.DefinitionRequest.type, { + documentSelector: Languages.getSupportedLanguages('definitions', [ + 'locals', + 'outline', + ]), + }); + connection2.onRequest( + lsp5.DefinitionRequest.type, + this.provideDefinitions.bind(this) + ); + } + async provideDefinitions(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + const info = Locals.create(document2, this._trees); + const anchor = info.root.findDefinitionOrUsage(params.position); + if (anchor) { + const definitions = anchor.scope.findDefinitions(anchor.name); + if (definitions.length > 0) { + return definitions.map((def) => + lsp5.Location.create(document2.uri, def.range) + ); + } + } + const tree = this._trees.getParseTree(document2); + if (!tree) { + return []; + } + const query = Languages.getQuery(document2.languageId, 'identifiers'); + const ident = identifierAtPosition(query, tree.rootNode, params.position) + ?.text; + if (!ident) { + return []; + } + const symbols = await this._symbols.getDefinitions(ident, document2); + return symbols.map((s) => s.location); + } + }; + + // server/src/features/documentHighlights.ts + let lsp6 = __toModule(require_main4()); + let DocumentHighlightsProvider = class { + constructor(_documents, _trees) { + this._documents = _documents; + this._trees = _trees; + } + register(connection2) { + connection2.client.register(lsp6.DocumentHighlightRequest.type, { + documentSelector: Languages.getSupportedLanguages('highlights', [ + 'locals', + 'identifiers', + ]), + }); + connection2.onRequest( + lsp6.DocumentHighlightRequest.type, + this.provideDocumentHighlights.bind(this) + ); + } + async provideDocumentHighlights(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + const info = Locals.create(document2, this._trees); + const anchor = info.root.findDefinitionOrUsage(params.position); + if (!anchor) { + return this._identifierBasedHighlights(document2, params.position); + } + const result = []; + for (let def of anchor.scope.findDefinitions(anchor.name)) { + result.push( + lsp6.DocumentHighlight.create( + def.range, + lsp6.DocumentHighlightKind.Write + ) + ); + } + if (result.length === 0) { + return this._identifierBasedHighlights(document2, params.position); + } + for (let usage of anchor.scope.findUsages(anchor.name)) { + result.push( + lsp6.DocumentHighlight.create( + usage.range, + lsp6.DocumentHighlightKind.Read + ) + ); + } + return result; + } + _identifierBasedHighlights(document2, position) { + const result = []; + const tree = this._trees.getParseTree(document2); + if (!tree) { + return result; + } + const query = Languages.getQuery(document2.languageId, 'identifiers'); + const candidate = identifierAtPosition(query, tree.rootNode, position); + if (!candidate) { + return result; + } + for (let capture of query.captures(tree.rootNode)) { + if (capture.node.text === candidate.text) { + result.push( + lsp6.DocumentHighlight.create( + asLspRange(capture.node), + lsp6.DocumentHighlightKind.Text + ) + ); + } + } + return result; + } + }; + + // server/src/features/documentSymbols.ts + let lsp7 = __toModule(require_main4()); + let DocumentSymbols = class { + constructor(_documents, _trees) { + this._documents = _documents; + this._trees = _trees; + } + register(connection2) { + connection2.client.register(lsp7.DocumentSymbolRequest.type, { + documentSelector: Languages.getSupportedLanguages('outline', [ + 'outline', + ]), + }); + connection2.onRequest( + lsp7.DocumentSymbolRequest.type, + this.provideDocumentSymbols.bind(this) + ); + } + async provideDocumentSymbols(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + return getDocumentSymbols(document2, this._trees, false); + } + }; + function getDocumentSymbols(document2, trees, flat) { + class Node2 { + constructor(capture) { + this.capture = capture; + this.children = []; + this.range = asLspRange(capture.node); + } + } + const tree = trees.getParseTree(document2); + if (!tree) { + return []; + } + const query = Languages.getQuery(document2.languageId, 'outline'); + const captures = query.captures(tree.rootNode); + const roots = []; + const stack = []; + for (const capture of captures) { + const node = new Node2(capture); + let parent = stack.pop(); + while (true) { + if (!parent) { + roots.push(node); + stack.push(node); + break; + } + if (containsRange(parent.range, node.range)) { + parent.children.push(node); + stack.push(parent); + stack.push(node); + break; + } + parent = stack.pop(); + } + } + function build(node, bucket) { + let children = []; + let nameNode; + for (let child of node.children) { + if ( + !nameNode && + child.capture.name.endsWith('.name') && + child.capture.name.startsWith(node.capture.name) + ) { + nameNode = child; + } else { + build(child, children); + } + } + if (!nameNode) { + nameNode = node; + } + const symbol = lsp7.DocumentSymbol.create( + nameNode.capture.node.text, + '', + symbolMapping.getSymbolKind(node.capture.name), + node.range, + nameNode.range + ); + symbol.children = children; + bucket.push(symbol); + } + const result = []; + for (let node of roots) { + build(node, result); + } + if (!flat) { + return result; + } + const flatResult = []; + (function flatten(all) { + for (let item of all) { + flatResult.push(item); + if (item.children) { + flatten(item.children); + } + } + })(result); + return flatResult; + } + + // server/src/features/foldingRanges.ts + let lsp8 = __toModule(require_main4()); + let FoldingRangeProvider = class { + constructor(_documents, _trees) { + this._documents = _documents; + this._trees = _trees; + } + register(connection2) { + connection2.client.register(lsp8.FoldingRangeRequest.type, { + documentSelector: Languages.getSupportedLanguages('folding', [ + 'comments', + 'folding', + ]), + }); + connection2.onRequest( + lsp8.FoldingRangeRequest.type, + this.provideFoldingRanges.bind(this) + ); + } + async provideFoldingRanges(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + const tree = this._trees.getParseTree(document2); + if (!tree) { + return []; + } + const result = []; + const commentQuery = Languages.getQuery(document2.languageId, 'comments'); + const commentCaptures = commentQuery.captures(tree.rootNode); + const foldingQuery = Languages.getQuery(document2.languageId, 'folding'); + const foldingCaptures = foldingQuery.captures(tree.rootNode); + for (const capture of [commentCaptures, foldingCaptures].flat()) { + result.push( + lsp8.FoldingRange.create( + capture.node.startPosition.row, + capture.node.endPosition.row, + capture.node.startPosition.column, + capture.node.endPosition.column, + capture.name + ) + ); + } + return result; + } + }; + + // server/src/features/references.ts + let lsp9 = __toModule(require_main4()); + let ReferencesProvider = class { + constructor(_documents, _trees, _symbols) { + this._documents = _documents; + this._trees = _trees; + this._symbols = _symbols; + } + register(connection2) { + connection2.client.register(lsp9.ReferencesRequest.type, { + documentSelector: Languages.getSupportedLanguages('references', [ + 'locals', + 'identifiers', + 'references', + ]), + }); + connection2.onRequest( + lsp9.ReferencesRequest.type, + this.provideReferences.bind(this) + ); + } + async provideReferences(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + const info = Locals.create(document2, this._trees); + const anchor = info.root.findDefinitionOrUsage(params.position); + if (anchor && !anchor.scope.likelyExports) { + const definitions = anchor.scope.findDefinitions(anchor.name); + if (definitions.length > 0) { + const result = []; + for (let def of definitions) { + if (params.context.includeDeclaration) { + result.push(lsp9.Location.create(document2.uri, def.range)); + } + } + const usages = anchor.scope.findUsages(anchor.name); + for (let usage of usages) { + result.push(lsp9.Location.create(document2.uri, usage.range)); + } + return result; + } + } + return await this._findGlobalReferences( + document2, + params.position, + params.context.includeDeclaration + ); + } + async _findGlobalReferences(document2, position, includeDeclaration) { + const tree = this._trees.getParseTree(document2); + if (!tree) { + return []; + } + const query = Languages.getQuery(document2.languageId, 'identifiers'); + const ident = identifierAtPosition(query, tree.rootNode, position)?.text; + if (!ident) { + return []; + } + const result = []; + let seenAsUsage = false; + let seenAsDef = false; + const usages = await this._symbols.getUsages(ident, document2); + for (let usage of usages) { + seenAsUsage = seenAsUsage || containsPosition(usage.range, position); + result.push(usage); + } + const definitions = await this._symbols.getDefinitions(ident, document2); + for (const { location } of definitions) { + seenAsDef = seenAsDef || containsPosition(location.range, position); + if (includeDeclaration) { + result.push(location); + } + } + if (!seenAsUsage && !seenAsDef) { + return []; + } + return result; + } + }; + function getDocumentUsages(document2, trees) { + const tree = trees.getParseTree(document2); + if (!tree) { + return []; + } + const query = Languages.getQuery(document2.languageId, 'references'); + const captures = query.captures(tree.rootNode); + const result = []; + for (let capture of captures) { + const name = capture.node.text; + const range = asLspRange(capture.node); + result.push({ + name, + range, + kind: lsp9.SymbolKind.File, + }); + } + return result; + } + + // server/src/features/selectionRanges.ts + let lsp10 = __toModule(require_main4()); + let SelectionRangesProvider = class { + constructor(_documents, _trees) { + this._documents = _documents; + this._trees = _trees; + } + register(connection2) { + connection2.client.register(lsp10.SelectionRangeRequest.type, { + documentSelector: Languages.allAsSelector(), + }); + connection2.onRequest( + lsp10.SelectionRangeRequest.type, + this.provideSelectionRanges.bind(this) + ); + } + async provideSelectionRanges(params) { + const document2 = await this._documents.retrieve(params.textDocument.uri); + const tree = this._trees.getParseTree(document2); + if (!tree) { + return []; + } + const result = []; + for (const position of params.positions) { + const stack = []; + const offset = document2.offsetAt(position); + let node = tree.rootNode; + stack.push(node); + while (true) { + let child = node.namedChildren.find((candidate) => { + return ( + candidate.startIndex <= offset && candidate.endIndex > offset + ); + }); + if (child) { + stack.push(child); + node = child; + continue; + } + break; + } + let parent; + for (let node2 of stack) { + let range = lsp10.SelectionRange.create(asLspRange(node2), parent); + parent = range; + } + if (parent) { + result.push(parent); + } + } + return result; + } + }; + + // server/src/features/symbolIndex.ts + let lsp11 = __toModule(require_main4()); + + // server/src/util/trie.ts + let Entry = class { + constructor(key, value) { + this.key = key; + this.value = value; + } + }; + var Trie = class { + constructor(ch, element) { + this.ch = ch; + this.element = element; + this._size = 0; + this._depth = 0; + this._children = new Map(); + } + static create() { + return new Trie('', void 0); + } + get size() { + return this._size; + } + get depth() { + return this._depth; + } + set(str, element) { + let chars = Array.from(str); + let node = this; + for (let pos = 0; pos < chars.length; pos++) { + node._depth = Math.max(chars.length - pos, node._depth); + const ch = chars[pos]; + let child = node._children.get(ch); + if (!child) { + child = new Trie(ch, void 0); + node._children.set(ch, child); + } + node = child; + } + if (!node.element) { + this._size += 1; + node.element = new Entry(str, element); + } else { + node.element.value = element; + } + } + get(str) { + let chars = Array.from(str); + let node = this; + for (let pos = 0; pos < chars.length; pos++) { + const ch = chars[pos]; + let child = node._children.get(ch); + if (!child) { + return void 0; + } + node = child; + } + return node.element?.value; + } + delete(str) { + let chars = Array.from(str); + let node = this; + let path = []; + for (let pos = 0; pos < chars.length; pos++) { + const ch = chars[pos]; + let child = node._children.get(ch); + if (!child) { + return false; + } + path.push([ch, node]); + node = child; + } + if (!node.element) { + return false; + } + node.element = void 0; + this._size -= 1; + while (path.length > 0) { + const [nodeCh, parent] = path.pop(); + if (node._children.size === 0 && !node.element) { + parent._children.delete(nodeCh); + } + node = parent; + if (node._children.size === 0) { + node._depth = 0; + } else { + let newDepth = 0; + for (let child of node._children.values()) { + newDepth = Math.max(newDepth, child.depth); + } + node._depth = 1 + newDepth; + } + } + return true; + } + *query(str) { + const bucket = new Set(); + const cache = new Map(); + const _query = (node, str2, pos, skipped, lastCh) => { + if (bucket.has(node)) { + return; + } + if (skipped > 12) { + return; + } + const map = cache.get(node); + if (map?.get(pos)) { + return; + } + if (map) { + map.set(pos, true); + } else { + cache.set(node, new Map([[pos, true]])); + } + if (pos >= str2.length) { + bucket.add(node); + return; + } + if (str2.length - pos > node._depth) { + return; + } + for (let [ch, child] of node._children) { + if (ch.toLowerCase() === str2[pos].toLowerCase()) { + _query(child, str2, pos + 1, skipped, ch); + } + _query(child, str2, pos, skipped + 1, ch); + } + }; + _query(this, str, 0, 0, this.ch); + for (let item of bucket) { + yield* item; + } + } + *[Symbol.iterator]() { + const stack = [this]; + while (stack.length > 0) { + const node = stack.shift(); + if (node.element) { + yield [node.element.key, node.element.value]; + } + for (let child of node._children.values()) { + stack.push(child); + } + } + } + }; + + // server/src/features/symbolIndex.ts + let Queue = class { + constructor() { + this._queue = new Set(); + } + enqueue(uri) { + if (isInteresting(uri) && !this._queue.has(uri)) { + this._queue.add(uri); + } + } + dequeue(uri) { + this._queue.delete(uri); + } + consume(n) { + if (n === void 0) { + const result2 = Array.from(this._queue.values()); + this._queue.clear(); + return result2; + } + const result = []; + const iter = this._queue.values(); + for (; n > 0; n--) { + const r = iter.next(); + if (r.done) { + break; + } + const uri = r.value; + result.push(uri); + this._queue.delete(uri); + } + return result; + } + }; + let DBPersistedIndex = class { + constructor(_name) { + this._name = _name; + this._version = 1; + this._store = 'fileSymbols'; + this._insertQueue = new Map(); + } + async open() { + if (this._db) { + return; + } + await new Promise((resolve, reject) => { + const request = indexedDB.open(this._name, this._version); + request.onerror = () => reject(request.error); + request.onsuccess = () => { + const db = request.result; + if (!db.objectStoreNames.contains(this._store)) { + console.error( + `Error while opening IndexedDB. Could not find '${this._store}' object store` + ); + return resolve(this._delete(db).then(() => this.open())); + } else { + resolve(void 0); + this._db = db; + } + }; + request.onupgradeneeded = () => { + const db = request.result; + if (db.objectStoreNames.contains(this._store)) { + db.deleteObjectStore(this._store); + } + db.createObjectStore(this._store); + }; + }); + } + async close() { + if (this._db) { + await this._bulkInsert(); + this._db.close(); + } + } + _delete(db) { + return new Promise((resolve, reject) => { + db.close(); + const deleteRequest = indexedDB.deleteDatabase(this._name); + deleteRequest.onerror = () => reject(deleteRequest.error); + deleteRequest.onsuccess = () => resolve(); + }); + } + insert(uri, info) { + const flatInfo = []; + for (let [word, i] of info) { + flatInfo.push(word); + flatInfo.push(i.definitions.size); + flatInfo.push(...i.definitions); + flatInfo.push(...i.usages); + } + this._insertQueue.set(uri, flatInfo); + clearTimeout(this._insertHandle); + this._insertHandle = setTimeout(() => { + this._bulkInsert().catch((err) => { + console.error(err); + }); + }, 50); + } + async _bulkInsert() { + if (this._insertQueue.size === 0) { + return; + } + return new Promise((resolve, reject) => { + if (!this._db) { + return reject(new Error('invalid state')); + } + const t = this._db.transaction(this._store, 'readwrite'); + const toInsert = new Map(this._insertQueue); + this._insertQueue.clear(); + for (let [uri, data] of toInsert) { + t.objectStore(this._store).put(data, uri); + } + t.oncomplete = () => resolve(void 0); + t.onerror = (err) => reject(err); + }); + } + getAll() { + return new Promise((resolve, reject) => { + if (!this._db) { + return reject(new Error('invalid state')); + } + const entries = new Map(); + const t = this._db.transaction(this._store, 'readonly'); + const store = t.objectStore(this._store); + const cursor = store.openCursor(); + cursor.onsuccess = () => { + if (!cursor.result) { + resolve(entries); + return; + } + const info = new Map(); + const flatInfo = cursor.result.value; + for (let i = 0; i < flatInfo.length; ) { + let word = flatInfo[i]; + let defLen = flatInfo[++i]; + let kindStart = ++i; + for ( + ; + i < flatInfo.length && typeof flatInfo[i] === 'number'; + i++ + ) {} + info.set(word, { + definitions: new Set( + flatInfo.slice(kindStart, kindStart + defLen) + ), + usages: new Set(flatInfo.slice(kindStart + defLen, i)), + }); + } + entries.set(String(cursor.result.key), info); + cursor.result.continue(); + }; + cursor.onerror = () => reject(cursor.error); + t.onerror = () => reject(t.error); + }); + } + delete(uris) { + return new Promise((resolve, reject) => { + if (!this._db) { + return reject(new Error('invalid state')); + } + const t = this._db.transaction(this._store, 'readwrite'); + const store = t.objectStore(this._store); + for (const uri of uris) { + const request = store.delete(uri); + request.onerror = (e) => console.error(e); + } + t.oncomplete = () => resolve(void 0); + t.onerror = (err) => reject(err); + }); + } + }; + let Index = class { + constructor() { + this._index = Trie.create(); + this._cleanup = new Map(); + } + get(text) { + return this._index.get(text); + } + query(query) { + return this._index.query(Array.from(query)); + } + [Symbol.iterator]() { + return this._index[Symbol.iterator](); + } + update(uri, value) { + this._cleanup.get(uri)?.(); + for (const [name, kinds] of value) { + const all = this._index.get(name); + if (all) { + all.set(uri, kinds); + } else { + this._index.set(name, new Map([[uri, kinds]])); + } + } + this._cleanup.set(uri, () => { + for (const name of value.keys()) { + const all = this._index.get(name); + if (all) { + if (all.delete(uri) && all.size === 0) { + this._index.delete(name); + } + } + } + }); + } + delete(uri) { + const cleanupFn = this._cleanup.get(uri); + if (cleanupFn) { + cleanupFn(); + this._cleanup.delete(uri); + return true; + } + return false; + } + }; + let SymbolIndex = class { + constructor(_trees, _documents, _persistedIndex) { + this._trees = _trees; + this._documents = _documents; + this._persistedIndex = _persistedIndex; + this.index = new Index(); + this._syncQueue = new Queue(); + this._asyncQueue = new Queue(); + } + addFile(uri) { + this._syncQueue.enqueue(uri); + this._asyncQueue.dequeue(uri); + } + removeFile(uri) { + this._syncQueue.dequeue(uri); + this._asyncQueue.dequeue(uri); + this.index.delete(uri); + } + async update() { + await this._currentUpdate; + this._currentUpdate = this._doUpdate(this._syncQueue.consume()); + return this._currentUpdate; + } + async _doUpdate(uris, silent) { + if (uris.length !== 0) { + const sw = new StopWatch(); + const tasks = uris.map(this._createIndexTask, this); + const stats = await parallel( + tasks, + 50, + new lsp11.CancellationTokenSource().token + ); + let totalRetrieve = 0; + let totalIndex = 0; + for (let stat of stats) { + totalRetrieve += stat.durationRetrieve; + totalIndex += stat.durationIndex; + } + if (!silent) { + console.log(`[index] added ${uris.length} files ${sw.elapsed()}ms + retrieval: ${Math.round(totalRetrieve)}ms + indexing: ${Math.round(totalIndex)}ms`); + } + } + } + _createIndexTask(uri) { + return async () => { + const _t1Retrieve = performance.now(); + const document2 = await this._documents.retrieve(uri); + const durationRetrieve = performance.now() - _t1Retrieve; + this.index.delete(uri); + const _t1Index = performance.now(); + try { + this._doIndex(document2); + } catch (e) { + console.log(`FAILED to index ${uri}`, e); + } + const durationIndex = performance.now() - _t1Index; + return { durationRetrieve, durationIndex }; + }; + } + _doIndex(document2, symbols, usages) { + const symbolInfo = new Map(); + if (!symbols) { + symbols = getDocumentSymbols(document2, this._trees, true); + } + for (const symbol of symbols) { + const all = symbolInfo.get(symbol.name); + if (all) { + all.definitions.add(symbol.kind); + } else { + symbolInfo.set(symbol.name, { + definitions: new Set([symbol.kind]), + usages: new Set(), + }); + } + } + if (!usages) { + usages = getDocumentUsages(document2, this._trees); + } + for (const usage of usages) { + const all = symbolInfo.get(usage.name); + if (all) { + all.usages.add(usage.kind); + } else { + symbolInfo.set(usage.name, { + definitions: new Set(), + usages: new Set([usage.kind]), + }); + } + } + this.index.update(document2.uri, symbolInfo); + this._persistedIndex.insert(document2.uri, symbolInfo); + } + async initFiles(_uris) { + const uris = new Set(_uris); + const sw = new StopWatch(); + console.log(`[index] building index for ${uris.size} files.`); + const persisted = await this._persistedIndex.getAll(); + const obsolete = new Set(); + for (const [uri, data] of persisted) { + if (!uris.delete(uri)) { + obsolete.add(uri); + } else { + this.index.update(uri, data); + this._asyncQueue.enqueue(uri); + } + } + console.log(`[index] added FROM CACHE ${ + persisted.size + } files ${sw.elapsed()}ms + ${uris.size} files still need to be fetched + ${obsolete.size} files are obsolete in cache`); + uris.forEach(this.addFile, this); + await this.update(); + await this._persistedIndex.delete(obsolete); + const asyncUpdate = async () => { + const uris2 = this._asyncQueue.consume(70); + if (uris2.length === 0) { + console.log('[index] ASYNC update is done'); + return; + } + const t1 = performance.now(); + await this._doUpdate(uris2, true); + setTimeout(() => asyncUpdate(), (performance.now() - t1) * 4); + }; + asyncUpdate(); + } + async getDefinitions(ident, source) { + await this.update(); + const result = []; + let sameLanguageOffset = 0; + const all = this.index.get(ident) ?? []; + const work = []; + for (const [uri, value] of all) { + if (value.definitions.size === 0) { + continue; + } + work.push( + this._documents + .retrieve(uri) + .then((document2) => { + const isSameLanguage = source.languageId === document2.languageId; + const symbols = getDocumentSymbols(document2, this._trees, true); + for (const item of symbols) { + if (item.name === ident) { + const info = lsp11.SymbolInformation.create( + item.name, + item.kind, + item.selectionRange, + uri + ); + if (isSameLanguage) { + result.unshift(info); + sameLanguageOffset++; + } else { + result.push(info); + } + } + } + setTimeout(() => { + this._asyncQueue.dequeue(document2.uri); + this._doIndex(document2, symbols); + }); + }) + .catch((err) => { + console.log(err); + }) + ); + } + await Promise.allSettled(work); + return result.slice(0, sameLanguageOffset || void 0); + } + async getUsages(ident, source) { + await this.update(); + const result = []; + const all = this.index.get(ident) ?? []; + const work = []; + let sameLanguageOffset = 0; + for (const [uri, value] of all) { + if (value.usages.size === 0) { + continue; + } + work.push( + this._documents + .retrieve(uri) + .then((document2) => { + const isSameLanguage = source.languageId === document2.languageId; + const usages = getDocumentUsages(document2, this._trees); + for (const item of usages) { + if (item.name === ident) { + const location = lsp11.Location.create(uri, item.range); + if (isSameLanguage) { + result.unshift(location); + sameLanguageOffset++; + } else { + result.push(location); + } + } + } + setTimeout(() => { + this._asyncQueue.dequeue(document2.uri); + this._doIndex(document2, void 0, usages); + }); + }) + .catch((err) => { + console.log(err); + }) + ); + } + await Promise.allSettled(work); + return result.slice(0, sameLanguageOffset || void 0); + } + }; + + // server/src/features/validation.ts + let import_vscode_languageserver2 = __toModule(require_main4()); + let Validation = class { + constructor(_connection, documents, _trees) { + this._connection = _connection; + this._trees = _trees; + this._currentValidation = new Map(); + documents.all().forEach(this._triggerValidation, this); + documents.onDidChangeContent((e) => this._triggerValidation(e.document)); + documents.onDidOpen((e) => this._triggerValidation(e.document)); + documents.onDidClose((e) => { + _connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] }); + }); + } + async _triggerValidation(document2) { + if (!isInteresting(document2.uri)) { + return; + } + const config = await this._connection.workspace.getConfiguration({ + section: 'anycode', + scopeUri: document2.uri, + }); + if (!config.diagnostics) { + return; + } + let cts = this._currentValidation.get(document2); + cts?.cancel(); + cts?.dispose(); + cts = new import_vscode_languageserver2.CancellationTokenSource(); + this._currentValidation.set(document2, cts); + const handle = setTimeout(() => this._createDiagnostics(document2), 500); + cts.token.onCancellationRequested(() => clearTimeout(handle)); + } + async _createDiagnostics(document2) { + const tree = this._trees.getParseTree(document2); + const diagnostics = []; + if (tree) { + const cursor = tree.walk(); + const seen = new Set(); + try { + let visitedChildren = false; + while (true) { + if (cursor.nodeIsMissing && !seen.has(cursor.nodeId)) { + diagnostics.push({ + range: asLspRange(cursor.currentNode()), + message: `Expected '${cursor.nodeType}'`, + severity: + import_vscode_languageserver2.DiagnosticSeverity.Error, + source: 'anycode', + code: 'missing', + }); + seen.add(cursor.nodeId); + } + if (!visitedChildren) { + if (!cursor.gotoFirstChild()) { + visitedChildren = true; + } + } + if (visitedChildren) { + if (cursor.gotoNextSibling()) { + visitedChildren = false; + } else if (cursor.gotoParent()) { + visitedChildren = true; + } else { + break; + } + } + } + } finally { + cursor.delete(); + } + } + this._connection.sendDiagnostics({ uri: document2.uri, diagnostics }); + } + }; + + // server/src/features/workspaceSymbols.ts + let lsp12 = __toModule(require_main4()); + let WorkspaceSymbol2 = class { + constructor(_documents, _trees, _symbols) { + this._documents = _documents; + this._trees = _trees; + this._symbols = _symbols; + } + register(connection2) { + connection2.client.register(lsp12.WorkspaceSymbolRequest.type, { + resolveProvider: true, + }); + connection2.onRequest( + lsp12.WorkspaceSymbolRequest.type, + this.provideWorkspaceSymbols.bind(this) + ); + connection2.onRequest( + lsp12.WorkspaceSymbolResolveRequest.type, + this.resolveWorkspaceSymbol.bind(this) + ); + } + async provideWorkspaceSymbols(params) { + const result = []; + await this._symbols.update(); + const all = this._symbols.index.query(params.query); + out: for (const [name, map] of all) { + for (const [uri, info] of map) { + for (const kind of info.definitions) { + const newLen = result.push( + lsp12.WorkspaceSymbol.create( + name, + kind, + uri, + lsp12.Range.create(0, 0, 0, 0) + ) + ); + if (newLen > 2e4) { + break out; + } + } + } + } + return result; + } + async resolveWorkspaceSymbol(item) { + const document2 = await this._documents.retrieve(item.location.uri); + const symbols = getDocumentSymbols(document2, this._trees, true); + for (let candidate of symbols) { + if (candidate.name === item.name && candidate.kind === item.kind) { + return lsp12.SymbolInformation.create( + item.name, + item.kind, + candidate.selectionRange, + item.location.uri + ); + } + } + return item; + } + }; + + // server/src/trees.ts + let import_tree_sitter2 = __toModule(require_tree_sitter()); + let Entry2 = class { + constructor(version, tree, edits) { + this.version = version; + this.tree = tree; + this.edits = edits; + } + }; + var Trees = class { + constructor(_documents) { + this._documents = _documents; + this._cache = new LRUMap({ + size: 100, + dispose(entries) { + for (let [, value] of entries) { + value.tree.delete(); + } + }, + }); + this._listener = []; + this._parser = new import_tree_sitter2.default(); + this._listener.push( + _documents.onDidChangeContent2((e) => { + const info = this._cache.get(e.document.uri); + if (info) { + info.edits.push(Trees._asEdits(e)); + } + }) + ); + } + dispose() { + this._parser.delete(); + for (let item of this._cache.values()) { + item.tree.delete(); + } + for (let item of this._listener) { + item.dispose(); + } + } + getParseTree(documentOrUri) { + if (typeof documentOrUri === 'string') { + return this._documents + .retrieve(documentOrUri) + .then((doc) => this._parse(doc)); + } else { + return this._parse(documentOrUri); + } + } + _parse(documentOrUri) { + let info = this._cache.get(documentOrUri.uri); + if (info?.version === documentOrUri.version) { + return info.tree; + } + const language = Languages.getLanguage(documentOrUri.languageId); + if (!language) { + return void 0; + } + this._parser.setLanguage(language); + this._parser.setTimeoutMicros(1e3 * 1e3); + try { + const version = documentOrUri.version; + const text = documentOrUri.getText(); + if (!info) { + const tree = this._parser.parse(text); + info = new Entry2(version, tree, []); + this._cache.set(documentOrUri.uri, info); + } else { + const oldTree = info.tree; + const deltas = info.edits.flat(); + deltas.forEach((delta) => oldTree.edit(delta)); + info.edits.length = 0; + info.tree = this._parser.parse(text, oldTree); + info.version = version; + oldTree.delete(); + } + return info.tree; + } catch (e) { + this._cache.delete(documentOrUri.uri); + return void 0; + } + } + static _asEdits(event) { + return event.changes.map((change) => ({ + startPosition: this._asTsPoint(change.range.start), + oldEndPosition: this._asTsPoint(change.range.end), + newEndPosition: this._asTsPoint( + event.document.positionAt(change.rangeOffset + change.text.length) + ), + startIndex: change.rangeOffset, + oldEndIndex: change.rangeOffset + change.rangeLength, + newEndIndex: change.rangeOffset + change.text.length, + })); + } + static _asTsPoint(position) { + const { line: row, character: column } = position; + return { row, column }; + } + }; + + // server/src/main.ts + let messageReader = new import_browser.BrowserMessageReader(self); + let messageWriter = new import_browser.BrowserMessageWriter(self); + let connection = (0, import_browser.createConnection)( + messageReader, + messageWriter + ); + console.log = connection.console.log.bind(connection.console); + console.warn = connection.console.warn.bind(connection.console); + console.error = connection.console.error.bind(connection.console); + let features = []; + connection.onInitialize(async (params) => { + const initData = params.initializationOptions; + const options = { + locateFile() { + return initData.treeSitterWasmUri; + }, + }; + await import_tree_sitter3.default.init(options); + await Languages.init(initData.supportedLanguages); + const documents = new DocumentStore(connection); + const trees = new Trees(documents); + const persistedCache = new DBPersistedIndex(initData.databaseName); + await persistedCache.open(); + connection.onExit(() => persistedCache.close()); + const symbolIndex = new SymbolIndex(trees, documents, persistedCache); + features.push(new WorkspaceSymbol2(documents, trees, symbolIndex)); + features.push(new DefinitionProvider(documents, trees, symbolIndex)); + features.push(new ReferencesProvider(documents, trees, symbolIndex)); + features.push(new CompletionItemProvider(documents, trees, symbolIndex)); + features.push(new DocumentHighlightsProvider(documents, trees)); + features.push(new DocumentSymbols(documents, trees)); + features.push(new SelectionRangesProvider(documents, trees)); + features.push(new FoldingRangeProvider(documents, trees)); + new Validation(connection, documents, trees); + documents.all().forEach((doc) => symbolIndex.addFile(doc.uri)); + documents.onDidOpen((event) => symbolIndex.addFile(event.document.uri)); + documents.onDidChangeContent((event) => + symbolIndex.addFile(event.document.uri) + ); + connection.onNotification('queue/remove', (uri) => + symbolIndex.removeFile(uri) + ); + connection.onNotification('queue/add', (uri) => symbolIndex.addFile(uri)); + connection.onRequest('queue/init', (uris) => { + return symbolIndex.initFiles(uris); + }); + console.log('Tree-sitter, languages, and features are READY'); + return { + capabilities: { + textDocumentSync: + import_vscode_languageserver3.TextDocumentSyncKind.Incremental, + }, + }; + }); + connection.onInitialized(() => { + for (let feature of features) { + feature.register(connection); + } + }); + connection.listen(); +})(); diff --git a/extensions/vscode-anycode/server/tree-sitter-c.wasm b/extensions/vscode-anycode/server/tree-sitter-c.wasm new file mode 100755 index 0000000000000000000000000000000000000000..aa1c6c490ef1507f160657d1721b64022f820879 GIT binary patch literal 327556 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

mS^-gBK{6V-e#QPV2xri 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 literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter-cpp.wasm b/extensions/vscode-anycode/server/tree-sitter-cpp.wasm new file mode 100755 index 0000000000000000000000000000000000000000..25c55a143865db6966bb45aee122f0ef8450c447 GIT binary patch literal 1187722 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�YIJByW$k?5 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 ZUz=b0OZ{u=@LTf!mOQ_vPJe9Q{|D+9%mM%a literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter-java.wasm b/extensions/vscode-anycode/server/tree-sitter-java.wasm new file mode 100755 index 0000000000000000000000000000000000000000..5de1ba3347828be013a94ee4cf2223065d804b3d GIT binary patch literal 232273 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 literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter-php.wasm b/extensions/vscode-anycode/server/tree-sitter-php.wasm new file mode 100755 index 0000000000000000000000000000000000000000..7e01dc7c75ae5ee8a033721bf824cb73b2daaa12 GIT binary patch literal 352603 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

E0h&N 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 J@PFAM{udyozeWH6 literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter-python.wasm b/extensions/vscode-anycode/server/tree-sitter-python.wasm new file mode 100755 index 0000000000000000000000000000000000000000..c90b5047ad8796d3c660e75039d797973bedcffe GIT binary patch literal 191411 zcmeFa31C#!^*?^z%w)361O|k#3P})I!Y;djj2aMJK(yACF(d&3A;BczQY)yasHkXN z(5eMQi%S(Pwb><=qN1XrVr#8+MXT1T)&J+*`_5Zt%fP$={QiG|``$ZuIp^H7 z-Q_JqRm}?w!e5(U&Dr&J4fDTPUKH>V852XN8%qeuSaP~=39fL!rGJTaqSFcgkrzN7 zDyS2{JO-DL@Ag1De{I9!yx7SNXD%RvuM6s$&um^;Rb8vW;DXu()eFz20G9=0C)d>Y}YrFc1+gUXkbQ- zYMbh+>g&#Nu{k)CmSEG-R_Rg;&_{lTy2N624K;O5P*{vb)=~!*OtCm75( z@&bmzhG_Wk-;ZlQ{^bESjDX)~`0!^0@{nEVGx!uhF%|gORP&5{RQ3n_$nhIRsF~*@ zpD*A;UEufo8EwAb9}L2xqZG>j&yX|P#bRf|^kdak_4P3}q-M(B1yxdEUs$6y#*x|* zr?eb%Tx<-`HC9&v-;|ch%F4rr!S0GO))|Ed+BTjB?TFe13tP?x>f(w_xEMYQMvmJ1 z4b7zXn1zd)=fcdL!b+XD9kO)c2uOW8V5QH7^ zH>K$x(9dd;E@Ue=>HR~i?$A*&4(SVZ7v38TW*ObE>SXrZEv6|Z1Rg3Cd z5NYaK5M1WK`=%Wqn|Az=7#%p)!aQnrW7C;cO*Lqz%4cxvkxdBqi)&*|wXRW}sOVQ7S$Q_-j1T`gu^K}_q$7Q)chRX-*cgL5IYvc2~kW#Jvp zQl2scJ~l16*x_bc>eG%pC`P@Huv(^xg<1>^7$_HEcxh~?ja9WU`6*L5053j#A*_J< zAC?g+gcB?H#hU9eg;-eCGM6LyV#ZQo+ff>Z*m%{z&HQLyDyO&5fH4*enVR>A*>z3L zEs$aFOxZuI(GH-rncG{&lGYS=ef zGSiQb9XAZhvb$&5IxG74SSq7-xY#i^{*l%I8f$5)s%vSUl3>o2W2&W_Q(B;9c-!I` z-~pVlw&CzY4zUoXQPi-Zv1Ia6v2G~GTyvC3gJO6y=1Y*!u;Ce1=Me$3AWT+y@L50y zIW#gHlhK9sh+VT5%|;lS(!z3cd7|>)1q;|UhM$&E2S)zb+;)mLG{ ztngPVwImXS94jkn#4rp0(8M~4j47Fo9APy|8JirDazrdPr&d|FJuPwdH%`savaR7! zwku}pO(UBjc{S$uKD>2C6Z&WcQJZfb4_mj9(F>~1!umkj$>v;8eR(0({wPKmGs0vZFrM5OnOlna<=y=4SAu&u8XYgck;yE?}c0)D0WV@BwuGYUPU9lla&v!0PL4jocc>$1n`EemLpLvk5Rb{xLY&yFh@k+&kl6u1HmXu*sl zaY2*IEd>l6-mqu^*4EXr`nm-?7}i&E5P*P>aE67thPbdWg&o?|eg=JT%5W+#LG{8` z#~WBIbY0KG{Q?9ZGyIH*9XBGzW9^a7`pifx^^fA-nXI|Oy(JCwZt}r)rQ~rfAwE|+ z;=8?O9fpZceci0;g$rZxl2kKdktVO QpnR@WoessZ=tO1nbJ!7YKOBx43olQLI~ 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 ZSy?otZz{jMea*3H-s~)UZC*Om{r{)!JTw3R literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter-rust.wasm b/extensions/vscode-anycode/server/tree-sitter-rust.wasm new file mode 100755 index 0000000000000000000000000000000000000000..c858e804745469e23ffafc09166859c02bf975ae GIT binary patch literal 638448 zcmeFa37l3%mM8k%n;Ved$G(a{qAY4D?ptYV-JVvotE+3~y`JvrnR#tHRlYZNR#%ni zOxM=!2PCrZD2ObnqLPS`APBN$g6wOm2*{Qx0-~}c2#Rd^{{OSwOp;8&D*651o8e=L zb0SWhIB_Cw+_?9gI5+X=lm8qf@N1m?^WXmB@n7ceKiWAnOeBJ98~kJNbOQf^r~fg0 z8W8>im`MC%0!hZx%;NvS)8W{RWX5B^{GSaTfAU|R{Pm+hdn^$+`t!&CpU0o7Mj!pf zumAg_il!cUe2u9i^n{#LC>H5O^^TkfBf=i z*F4qhvBw^H^6{shdaTzYz5d6OPd)P3Zvg)C(O*3B1i4HvEl0c+HxjX)j+;Ma*TqiK`O%&bI4c1|M5$_RoWBRd;|8YOab zwuOzFJ@UxEVDumP*`vSs#Unp^>Q}vtFxkw~ze%(Wf4Lq}OA= z_|?yzOk_4}5G1Y+a>G=!M&tWrHOWjg&CH#DL*nX0wExb3!vBSn8vWB9A@Ku(m)&J( zrJ$Al8ybF0i-&YF{Dk1eOTGNG;DzfPPu~Uh%DI4GRG4Em2MAi+%FrQNy51{}5PaPG zj*k(%azkgMAE(vh@(I8LZK#l76d2)DAxy^|oG$pd7%v7MYQ@ZMyNvF-aLoM?1bs@z1U_`gMx$alB0N zP2T<{#n(E%Rq@r1?@)Y@%TuBFByVqz)xX2q+pqX=FF&C8NXIJ`-{}00DZb%)tA9fA zfq90XR{ZUbhNs^Z{muA+;RTAPZ!&y<;x9PAA&QrJdm|J-;rzxZ{;|`KQ+&0TPf+|z z*I%LHUpPKR@iL#-Qx)%XqscS97G7KnpIr-|R|{WQ3oosOFRO*Gs)etsg_qUBH`T(o z*1~tx!YgXwdurkPYvBhJ|H9`-rQ&0KJ{(j0sO#^9;xl}_PAk6I$0NN=#($HKSApVR z`FIRaeC`dV{~?NR@cJVZKXI*+^4d;^UoPq2jZB{!LN*p!1)q_=>B1 z{1xxx^@|n%(&y`J#TR;i=PCZ7*I%gk94{|b{D`-=Oz|C#uTuP!&%bqwAMpN_DL&8J z-=z599wzTr#m76oL-FUGzC!UrAHO|{&v1Od;(dI*IH34YFRxU5hxhN8;uBpzClue} z{XMOCKj)WTF5|z|%L^1A=;Z?xU+(2Y6d&*Hk5Ih7<6{&*>iQX{c--Cu#ou#z3l*R3 z_!PwlIKQciAM*C6D?ZrEixq#~@!5*+^Z7eZ@lPFJsQ60fSE~3P$CoMI+xx#t@%>)D zPVtW&FH^k0={G6Gvpp)bag_pK$zu;$JvksrXsPk12l2 z@e_(~bNsa8I~`B2kn#W2@dCvw93P59+t_KOuCx=?{obwQ~VV#U#0jWFJGs4e{Zi$@kuWKCdKua3in;oB^_~+iALdBQ4zNaX@*72!|?{NC*itlrIixr>c z^3GO#m&-Fx@j{n(q2fi3mnuHe=l?Rr&v^MN#ZS6E*D3zG<7JAkaeR~F@&0+M(ffGr zP<)fiTcP+dFW;m1Nawd-@prxafZ`KepOuR5bNXY3`+n|(;vaeWX~j?b^^jgI<3GUl zTcG#^ryrpBc5i=(;)RZnP<*}PV-)|=>yJ~s!uJCc6hGne7b^aR>wAjg?>IiS7Cv3^ z3C^!r@p0X3J({ifK*#4P{)W>pRJ_Q`OBFxr_%g+h`}nLQ+$=*Zzd={*y#%uU*PRe zQT&MGQx)Is_;kfz_V$Yv|J3E1t@wD?|2)Ot@%4D2)pz<*#XoR-nd0kwyjCeb&f8z7 z_)?d@Oz{OS&nCrJIlfi#_<4MX;-C8cv_kO{uAe=MzvJcm6+i6j(*ebgJ6@^ydrp5$ z@s*CBQ2Z08KdtyPUY=en0FHpSP%Lgd_n&U$hFL3%1ijVjHj!}HBmyc6?l$TFX zyszVhiXZmznWFdk>o|1!l-yL_7zFLL>|Dqi9AI~0G$@e0NFI=)Bo(O!SQ;v>C( z2NWOc^p%Rg<@hnhC%Zf+6rbn#X~j#uKWV%o#QU@TUS6R1a_2Wd@ef^|A&M_{e1zif zdHpepZ}atgoZ@AUPf)zn@hOTQ_Um=3;;;JpGhOjLzTOop90S0f@)w+b`U-t{>cC2g*PM;52O-I!&D;UM|r_DVdAR9 z1DQXH5}h-W*|~X%=&A?t-;TtCy;5Ob(6mt$pdgW($Q9bAiOe6dS`-j%&@4 zs%I*Tg)S;{Snxn9huO&hVl{0PYDc20AB+-tiT3DDUgCkyAxa^A$hy{|QRIa`ZZGVE zeUpBsWV1xV86~2;UeR7CRl3Mw zRz6|$gZ##r3789UE9hT@vCIp}`~rejw

T2N(@Vogqx5r9`wZk>5Bo$jl5dI}*`x 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 z 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μ2gJH;rGY=2Is$hfl1r8>nFomAImvzsouY4`&SMF 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 z z!Anv831!7`i8{EwTzj?laxP}nY{PW19lUP6irBQ6y^3r?dSu+o2ys!YI2Cadzcfo{ zOHC&6adOrSUW)R+Tvi;HsH59!`Cnna+8eb6a%+*iT{Lgg6TepLoTO(q6YGIS756v) z5}b}=X&mtx5j&NTITN9A{=j_AE3Q+tD5g*Wrsnh)&)sJg-Y_TZbf&dESW zA=U$pD(-KtI2}cC#VuQr6la?HyvsIJoc0F03jd5Mj!Anv8x60>nT%wL{@8o}l`D*VD`gzvhb-0u zjVkVMKF8@OiqCOZRwTulrateL4d*!R4Q>_Qt9?*=FBdavwjo1o2d`TnAT}*#A0V5M z9vSyCLR=IpPDR|rFU``~QjdpqTZ8> z88zE5U2F%hTO$yg7PAq^CZtEky^IhS#fnoAH}OlebhgxF5+5gL&ETade@|I)T%rzc z)759FPnU}sHQO*H@HZ5jzBAbvN8TT?mTofx#Mcl+M z&C=OYlSzD>oHc`&qWrU$&*Qj69o*)w&s(267c*+MVY=83Ubp5&Y+B6bMK&QlGVW!B zxF}Yfinxhinx(U)CX@I$Ico+lMfvA0D~?Ol!EOHfg7x`xF{5T1ri<<1b!$Pyrp0VQ zWE0XO<6cIHi(=0 zZhZo=X)*f*vI*&taW5mpMX};k#7+FtES)VinZ(D*Su=Pk%D-?~aa^JfZj03yuP>I1 z88zE5U2F%hTZFC)Z7vEo$3P5jaz)#K*~5Gk7V= zzeHJaT%rzc%hX5Jm&wJ9nr)aawu9HLQHV{8*(hWa(j((uMu>}I#i@v!_@!AoTWT_i zkCU@z@KTh2nX=-zL>=6gt1n+)E*CRuwqd&14qmsGM{HWmmPa-rJu>cPgt#bHoQk-K zUz(+}r6!a3I5}$uFGcy6D=Usm)X{Bp{#Vc^YdFy&wH4uM=M~`5_0Gvahb-0ujVkVM ze$PQiQT#5~Efq;|rm4?+OT#_D+8gXDtQ=JwYpwlvxmK=sP6j#(u^wntaes5g=_raT z?j4g9XPWxF@8pN<@2hHWaI3Itef9dPxtLM24H;rPc->kZv1u_|9odBR$hemg;-Xk_ zD&i)7X_n5GnoQ#3nqpJ1>w+d_4*Q&3Xiy1ZBkRi5%*R8b>n-;URkWEOBjC&a& zE{YYWB5vZBX6bCH$s|5b&YHnXQT{c{a~zkbgWEdw_3G>7Vn)q2Oc&e1>(+XRO^exj z$R?ym#=VRX7sZNG5jXKmvvju9WD*}IXU*WHDE~TT#c_!`xNT7XQhkG5%&6Ih>0� z-TD$@(_;1|WE0XO<6cIHi(S zGitVBy4Vh0w>Cj+TFf>O)h5CY{PW19lUOBhuE~3ZHH_^dSu+o2ys!YI2Cad zzcfo{OHC&6adOrSUW)Q>Q&t?8sDs-M^_}WFv?&T+FE1hUsEE zc-`6!v1u{e4cUbB$hemg;-Xk_D&i)7X_n5GnoQ#3(+jVO^exn$R?ym#=VRX7sZNG5jXKmvvju9 zWD*}IXU*WHDF41?#c_!`xP7O7VEsF}m{GG0)5Ui1x^*C8(_(fYvI*&taW5mpMX};k z#7+FtES)VinZ(D*Su=Pk%Kx3R;a66=aX#J2}%&6Ih>0�-8vMp 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 literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter-typescript.wasm b/extensions/vscode-anycode/server/tree-sitter-typescript.wasm new file mode 100755 index 0000000000000000000000000000000000000000..0ca4303523be5f822e249e23e14ceb5eba434c13 GIT binary patch literal 1389235 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%0D8Gc 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 literal 0 HcmV?d00001 diff --git a/extensions/vscode-anycode/server/tree-sitter/tree-sitter.wasm b/extensions/vscode-anycode/server/tree-sitter/tree-sitter.wasm new file mode 100755 index 0000000000000000000000000000000000000000..7e3058ed3f52eda99c3db77aafd0d0fd61bcefb3 GIT binary patch literal 171876 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%0Dv2w&tA!2NP*! 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 need to enable JavaScript to run this app.

folderUri: { scheme: 'github1s', authority: '', path: '/' }, staticExtensions: [], enableSyncByDefault: false, - additionalBuiltinExtensions: ['ms-vscode.anycode'], + additionalBuiltinExtensions: [], webviewEndpoint: window.location.origin + '/static/vscode/vs/workbench/contrib/webview/browser/pre', diff --git a/resources/index-hash.html b/resources/index-hash.html index bcf3c2e79..ae412149f 100644 --- a/resources/index-hash.html +++ b/resources/index-hash.html @@ -174,7 +174,7 @@

You need to enable JavaScript to run this app.

folderUri: { scheme: 'github1s', authority: '', path: '/' }, staticExtensions: [], enableSyncByDefault: false, - additionalBuiltinExtensions: ['ms-vscode.anycode'], + additionalBuiltinExtensions: [], webviewEndpoint: window.location.origin + '/static/{STATIC_HASH_CODE}/vscode/vs/workbench/contrib/webview/browser/pre', diff --git a/resources/index.html b/resources/index.html index 44842ed96..b3c9f7896 100644 --- a/resources/index.html +++ b/resources/index.html @@ -174,7 +174,7 @@

You need to enable JavaScript to run this app.

folderUri: { scheme: 'github1s', authority: '', path: '/' }, staticExtensions: [], enableSyncByDefault: false, - additionalBuiltinExtensions: ['ms-vscode.anycode'], + additionalBuiltinExtensions: [], webviewEndpoint: window.location.origin + '/static/vscode/vs/workbench/contrib/webview/browser/pre', From 17f2ff0d83607e8278343b9cdd115df8e063836f Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 30 Dec 2021 12:40:41 +0800 Subject: [PATCH 6/7] chore(deps): bump ansi-regex from 5.0.0 to 5.0.1 (#380) Bumps [ansi-regex](https://github.com/chalk/ansi-regex) from 5.0.0 to 5.0.1. - [Release notes](https://github.com/chalk/ansi-regex/releases) - [Commits](https://github.com/chalk/ansi-regex/compare/v5.0.0...v5.0.1) --- updated-dependencies: - dependency-name: ansi-regex dependency-type: indirect ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- yarn.lock | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/yarn.lock b/yarn.lock index 869a99c5b..b52d2b244 100644 --- a/yarn.lock +++ b/yarn.lock @@ -235,9 +235,9 @@ ansi-escapes@^4.3.0: type-fest "^0.11.0" ansi-regex@^5.0.0: - version "5.0.0" - resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75" - integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg== + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== ansi-styles@^3.2.1: version "3.2.1" From 7eae943418545ed9ffe8c67ab0d4247801fb6196 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 30 Dec 2021 12:41:12 +0800 Subject: [PATCH 7/7] chore(deps): bump normalize-url in /api/github-auth-callback (#379) Bumps [normalize-url](https://github.com/sindresorhus/normalize-url) from 4.5.0 to 4.5.1. - [Release notes](https://github.com/sindresorhus/normalize-url/releases) - [Commits](https://github.com/sindresorhus/normalize-url/commits) --- updated-dependencies: - dependency-name: normalize-url dependency-type: indirect ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- api/github-auth-callback/yarn.lock | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/api/github-auth-callback/yarn.lock b/api/github-auth-callback/yarn.lock index b0648e453..a7829e995 100644 --- a/api/github-auth-callback/yarn.lock +++ b/api/github-auth-callback/yarn.lock @@ -157,9 +157,9 @@ mimic-response@^3.1.0: integrity sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ== normalize-url@^4.1.0: - version "4.5.0" - resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-4.5.0.tgz#453354087e6ca96957bd8f5baf753f5982142129" - integrity sha512-2s47yzUxdexf1OhyRi4Em83iQk0aPvwTddtFz4hnSSw9dCEsLEGf6SwIO8ss/19S9iBb5sJaOuTvTGDeZI00BQ== + version "4.5.1" + resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-4.5.1.tgz#0dd90cf1288ee1d1313b87081c9a5932ee48518a" + integrity sha512-9UZCFRHQdNrfTpGg8+1INIg93B6zE0aXMVFkw1WFwvO4SlZywU6aLg5Of0Ap/PgcbSw4LNxvMWXMeugwMCX0AA== once@^1.3.1, once@^1.4.0: version "1.4.0"