🎉 initiate project *astro_rewrite*

node_modules/vscode-languageserver/License.txt

@@ -0,0 +1,11 @@
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/vscode-languageserver/README.md

@@ -0,0 +1,17 @@
+# VSCode Language Server
+
+[![NPM Version](https://img.shields.io/npm/v/vscode-languageserver.svg)](https://npmjs.org/package/vscode-languageserver)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-languageserver.svg)](https://npmjs.org/package/vscode-languageserver)
+[![Build Status](https://travis-ci.org/Microsoft/vscode-languageserver-node.svg?branch=master)](https://travis-ci.org/Microsoft/vscode-languageserver-node)
+
+Npm module to implement a VSCode language server using [Node.js](https://nodejs.org/) as a runtime.
+
+Click [here](https://code.visualstudio.com/docs/extensions/example-language-server) for a detailed document on how to use this npm module
+to implement language servers for [VSCode](https://code.visualstudio.com/).
+
+## History
+
+For the history please see the [main repository](https://github.com/Microsoft/vscode-languageserver-node/blob/master/README.md)
+
+## License
+[MIT](https://github.com/Microsoft/vscode-languageserver-node/blob/master/License.txt)

node_modules/vscode-languageserver/bin/installServerIntoExtension

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+var path = require('path');
+var fs = require('fs');
+var cp = require('child_process');
+
+var extensionDirectory = process.argv[2];
+if (!extensionDirectory) {
+	console.error('No extension directory provided.');
+	process.exit(1);
+}
+extensionDirectory = path.resolve(extensionDirectory);
+if (!fs.existsSync(extensionDirectory)) {
+	console.error('Extension directory ' + extensionDirectory + ' doesn\'t exist on disk.');
+	process.exit(1);
+}
+
+var packageFile = process.argv[3];
+if (!packageFile) {
+	console.error('No package.json file provided.');
+	process.exit(1);
+}
+packageFile = path.resolve(packageFile);
+if (!fs.existsSync(packageFile)) {
+	console.error('Package file ' + packageFile + ' doesn\'t exist on disk.');
+	process.exit(1);
+}
+var tsconfigFile = process.argv[4];
+if (!tsconfigFile) {
+	console.error('No tsconfig.json file provided');
+	process.exit(1);
+}
+tsconfigFile = path.resolve(tsconfigFile);
+if (!fs.existsSync(tsconfigFile)) {
+	console.error('tsconfig file ' + tsconfigFile + ' doesn\'t exist on disk.');
+	process.exit(1);
+}
+
+var extensionServerDirectory = path.join(extensionDirectory, 'server');
+
+var json = require(tsconfigFile);
+var compilerOptions = json.compilerOptions;
+if (compilerOptions) {
+	var outDir = compilerOptions.outDir;
+	if (!outDir || path.join(path.dirname(tsconfigFile), outDir) !== extensionServerDirectory) {
+		console.error('outDir in ' + process.argv[4] + ' must point to ' + extensionServerDirectory + ' but it points to ' + path.join(path.dirname(tsconfigFile), outDir));
+		console.error('Please change outDir in ' + process.argv[4] + ' to ' + path.relative(path.dirname(tsconfigFile), extensionServerDirectory).replace(/\\/g, '/'));
+		process.exit(1);
+	}
+}
+
+if (!fs.existsSync(extensionServerDirectory)) {
+	fs.mkdirSync(extensionServerDirectory);
+}
+
+var dest = path.join(extensionServerDirectory, 'package.json');
+console.log('Copying package.json to extension\'s server location...');
+fs.writeFileSync(dest, fs.readFileSync(packageFile));
+
+var shrinkwrapFile = process.argv[5];
+if (fs.existsSync(shrinkwrapFile)) {
+	const shrinkWrapDest = path.join(extensionServerDirectory, 'npm-shrinkwrap.json');
+	shrinkwrapFile = path.resolve(shrinkwrapFile);
+	console.log('Copying npm-shrinkwrap.json to extension\'s server location...');
+	fs.writeFileSync(shrinkWrapDest, fs.readFileSync(shrinkwrapFile));
+
+}
+
+console.log('The script is deprecated. See https://github.com/microsoft/vscode-extension-samples/tree/master/lsp-sample for an example on how to setup an extension / server project.');
+console.log('');
+console.log('Updating server npm modules into extension\'s server location...');
+cp.execSync('npm update --production --prefix ' + extensionServerDirectory);

node_modules/vscode-languageserver/browser.d.ts

@@ -0,0 +1,6 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+
+export * from './lib/browser/main';

node_modules/vscode-languageserver/browser.js

@@ -0,0 +1,7 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+'use strict';
+
+module.exports = require('./lib/browser/main');

node_modules/vscode-languageserver/lib/browser/main.d.ts

@@ -0,0 +1,20 @@
+import { MessageReader, MessageWriter, ConnectionStrategy, ConnectionOptions, Connection, Features, _Connection, _ } from '../common/api';
+export * from 'vscode-languageserver-protocol/browser';
+export * from '../common/api';
+/**
+ * Creates a new connection.
+ *
+ * @param factories: The factories for proposed features.
+ * @param reader The message reader to read messages from.
+ * @param writer The message writer to write message to.
+ * @param options An optional connection strategy or connection options to control additional settings
+ */
+export declare function createConnection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _>(factories: Features<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages>, reader: MessageReader, writer: MessageWriter, options?: ConnectionStrategy | ConnectionOptions): _Connection<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages>;
+/**
+ * Creates a new connection.
+ *
+ * @param reader The message reader to read messages from.
+ * @param writer The message writer to write message to.
+ * @param options An optional connection strategy or connection options to control additional settings
+ */
+export declare function createConnection(reader: MessageReader, writer: MessageWriter, options?: ConnectionStrategy | ConnectionOptions): Connection;

node_modules/vscode-languageserver/lib/browser/main.js

@@ -0,0 +1,62 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = void 0;
+const api_1 = require("../common/api");
+__exportStar(require("vscode-languageserver-protocol/browser"), exports);
+__exportStar(require("../common/api"), exports);
+let _shutdownReceived = false;
+const watchDog = {
+    initialize: (_params) => {
+    },
+    get shutdownReceived() {
+        return _shutdownReceived;
+    },
+    set shutdownReceived(value) {
+        _shutdownReceived = value;
+    },
+    exit: (_code) => {
+    }
+};
+function createConnection(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 = createConnection;

node_modules/vscode-languageserver/lib/common/api.d.ts

@@ -0,0 +1,15 @@
+import { _, Features, _Connection } from './server';
+import { SemanticTokensBuilder } from './semanticTokens';
+import type { WorkDoneProgressReporter, WorkDoneProgressServerReporter, ResultProgressReporter } from './progress';
+export * from 'vscode-languageserver-protocol/';
+export { WorkDoneProgressReporter, WorkDoneProgressServerReporter, ResultProgressReporter };
+export { SemanticTokensBuilder };
+import { TextDocuments, TextDocumentsConfiguration, TextDocumentChangeEvent, TextDocumentWillSaveEvent } from './textDocuments';
+export { TextDocuments, TextDocumentsConfiguration, TextDocumentChangeEvent, TextDocumentWillSaveEvent };
+import { NotebookDocuments } from './notebook';
+export { NotebookDocuments };
+export * from './server';
+export declare namespace ProposedFeatures {
+    const all: Features<_, _, _, _, _, _, _, _>;
+    type Connection = _Connection<_, _, _, _, _, _, _, _>;
+}

node_modules/vscode-languageserver/lib/common/api.js

@@ -0,0 +1,35 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposedFeatures = exports.NotebookDocuments = exports.TextDocuments = exports.SemanticTokensBuilder = void 0;
+const semanticTokens_1 = require("./semanticTokens");
+Object.defineProperty(exports, "SemanticTokensBuilder", { enumerable: true, get: function () { return semanticTokens_1.SemanticTokensBuilder; } });
+__exportStar(require("vscode-languageserver-protocol/"), exports);
+const textDocuments_1 = require("./textDocuments");
+Object.defineProperty(exports, "TextDocuments", { enumerable: true, get: function () { return textDocuments_1.TextDocuments; } });
+const notebook_1 = require("./notebook");
+Object.defineProperty(exports, "NotebookDocuments", { enumerable: true, get: function () { return notebook_1.NotebookDocuments; } });
+__exportStar(require("./server"), exports);
+var ProposedFeatures;
+(function (ProposedFeatures) {
+    ProposedFeatures.all = {
+        __brand: 'features',
+    };
+})(ProposedFeatures = exports.ProposedFeatures || (exports.ProposedFeatures = {}));

node_modules/vscode-languageserver/lib/common/callHierarchy.d.ts

@@ -0,0 +1,15 @@
+import { CallHierarchyItem, CallHierarchyPrepareParams, CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall, CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the call hierarchy feature
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchy {
+    callHierarchy: {
+        onPrepare(handler: ServerRequestHandler<CallHierarchyPrepareParams, CallHierarchyItem[] | null, never, void>): Disposable;
+        onIncomingCalls(handler: ServerRequestHandler<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, CallHierarchyIncomingCall[], void>): Disposable;
+        onOutgoingCalls(handler: ServerRequestHandler<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, CallHierarchyOutgoingCall[], void>): Disposable;
+    };
+}
+export declare const CallHierarchyFeature: Feature<_Languages, CallHierarchy>;

node_modules/vscode-languageserver/lib/common/callHierarchy.js

@@ -0,0 +1,34 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallHierarchyFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const CallHierarchyFeature = (Base) => {
+    return class extends Base {
+        get callHierarchy() {
+            return {
+                onPrepare: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), undefined);
+                    });
+                },
+                onIncomingCalls: (handler) => {
+                    const type = vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type;
+                    return 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;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.CallHierarchyFeature = CallHierarchyFeature;

node_modules/vscode-languageserver/lib/common/configuration.d.ts

@@ -0,0 +1,9 @@
+import { ConfigurationItem } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWorkspace } from './server';
+export interface Configuration {
+    getConfiguration(): Promise<any>;
+    getConfiguration(section: string): Promise<any>;
+    getConfiguration(item: ConfigurationItem): Promise<any>;
+    getConfiguration(items: ConfigurationItem[]): Promise<any[]>;
+}
+export declare const ConfigurationFeature: Feature<_RemoteWorkspace, Configuration>;

node_modules/vscode-languageserver/lib/common/configuration.js

@@ -0,0 +1,38 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+const 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;

node_modules/vscode-languageserver/lib/common/diagnostic.d.ts

@@ -0,0 +1,29 @@
+import { Disposable, DocumentDiagnosticParams, DocumentDiagnosticReport, DocumentDiagnosticReportPartialResult, DiagnosticServerCancellationData, WorkspaceDiagnosticParams, WorkspaceDiagnosticReport, WorkspaceDiagnosticReportPartialResult } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the linked editing feature
+ *
+ * @since 3.16.0
+ */
+export interface DiagnosticFeatureShape {
+    diagnostics: {
+        /**
+        * Asks the client to refresh all diagnostics provided by this server by
+        * pull for the corresponding documents again.
+        */
+        refresh(): void;
+        /**
+        * Installs a handler for the document diagnostic request.
+        *
+        * @param handler The corresponding handler.
+        */
+        on(handler: ServerRequestHandler<DocumentDiagnosticParams, DocumentDiagnosticReport, DocumentDiagnosticReportPartialResult, DiagnosticServerCancellationData>): Disposable;
+        /**
+         * Installs a handler for the workspace diagnostic request.
+         *
+         * @param handler The corresponding handler.
+         */
+        onWorkspace(handler: ServerRequestHandler<WorkspaceDiagnosticParams, WorkspaceDiagnosticReport, WorkspaceDiagnosticReportPartialResult, DiagnosticServerCancellationData>): Disposable;
+    };
+}
+export declare const DiagnosticFeature: Feature<_Languages, DiagnosticFeatureShape>;

node_modules/vscode-languageserver/lib/common/diagnostic.js

@@ -0,0 +1,30 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const DiagnosticFeature = (Base) => {
+    return class extends Base {
+        get diagnostics() {
+            return {
+                refresh: () => {
+                    return this.connection.sendRequest(vscode_languageserver_protocol_1.DiagnosticRefreshRequest.type);
+                },
+                on: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.partialResult, params));
+                    });
+                },
+                onWorkspace: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.partialResult, params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.DiagnosticFeature = DiagnosticFeature;

node_modules/vscode-languageserver/lib/common/fileOperations.d.ts

@@ -0,0 +1,16 @@
+import { RequestHandler, NotificationHandler, WorkspaceEdit, CreateFilesParams, RenameFilesParams, DeleteFilesParams, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWorkspace } from './server';
+/**
+ * Shape of the file operations feature
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationsFeatureShape {
+    onDidCreateFiles(handler: NotificationHandler<CreateFilesParams>): Disposable;
+    onDidRenameFiles(handler: NotificationHandler<RenameFilesParams>): Disposable;
+    onDidDeleteFiles(handler: NotificationHandler<DeleteFilesParams>): Disposable;
+    onWillCreateFiles(handler: RequestHandler<CreateFilesParams, WorkspaceEdit | null, never>): Disposable;
+    onWillRenameFiles(handler: RequestHandler<RenameFilesParams, WorkspaceEdit | null, never>): Disposable;
+    onWillDeleteFiles(handler: RequestHandler<DeleteFilesParams, WorkspaceEdit | null, never>): Disposable;
+}
+export declare const FileOperationsFeature: Feature<_RemoteWorkspace, FileOperationsFeatureShape>;

node_modules/vscode-languageserver/lib/common/fileOperations.js

@@ -0,0 +1,43 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileOperationsFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const FileOperationsFeature = (Base) => {
+    return class extends Base {
+        onDidCreateFiles(handler) {
+            return this.connection.onNotification(vscode_languageserver_protocol_1.DidCreateFilesNotification.type, (params) => {
+                handler(params);
+            });
+        }
+        onDidRenameFiles(handler) {
+            return this.connection.onNotification(vscode_languageserver_protocol_1.DidRenameFilesNotification.type, (params) => {
+                handler(params);
+            });
+        }
+        onDidDeleteFiles(handler) {
+            return 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;

node_modules/vscode-languageserver/lib/common/inlayHint.d.ts

@@ -0,0 +1,28 @@
+import { InlayHint, InlayHintParams, Disposable, RequestHandler } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the inlay hints feature
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintFeatureShape {
+    inlayHint: {
+        /**
+         * Ask the client to refresh all inlay hints.
+         */
+        refresh(): Promise<void>;
+        /**
+         * Installs a handler for the inlay hints request.
+         *
+         * @param handler The corresponding handler.
+         */
+        on(handler: ServerRequestHandler<InlayHintParams, InlayHint[] | undefined | null, InlayHint[], void>): Disposable;
+        /**
+         * Installs a handler for the inlay hint resolve request.
+         *
+         * @param handler The corresponding handler.
+         */
+        resolve(handler: RequestHandler<InlayHint, InlayHint, void>): Disposable;
+    };
+}
+export declare const InlayHintFeature: Feature<_Languages, InlayHintFeatureShape>;

node_modules/vscode-languageserver/lib/common/inlayHint.js

@@ -0,0 +1,30 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlayHintFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const InlayHintFeature = (Base) => {
+    return class extends Base {
+        get inlayHint() {
+            return {
+                refresh: () => {
+                    return this.connection.sendRequest(vscode_languageserver_protocol_1.InlayHintRefreshRequest.type);
+                },
+                on: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params));
+                    });
+                },
+                resolve: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, (params, cancel) => {
+                        return handler(params, cancel);
+                    });
+                }
+            };
+        }
+    };
+};
+exports.InlayHintFeature = InlayHintFeature;

node_modules/vscode-languageserver/lib/common/inlineValue.d.ts

@@ -0,0 +1,22 @@
+import { InlineValue, Disposable, InlineValueParams } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the inline values feature
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueFeatureShape {
+    inlineValue: {
+        /**
+         * Ask the client to refresh all inline values.
+         */
+        refresh(): Promise<void>;
+        /**
+         * Installs a handler for the inline values request.
+         *
+         * @param handler The corresponding handler.
+         */
+        on(handler: ServerRequestHandler<InlineValueParams, InlineValue[] | undefined | null, InlineValue[], void>): Disposable;
+    };
+}
+export declare const InlineValueFeature: Feature<_Languages, InlineValueFeatureShape>;

node_modules/vscode-languageserver/lib/common/inlineValue.js

@@ -0,0 +1,25 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineValueFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const InlineValueFeature = (Base) => {
+    return class extends Base {
+        get inlineValue() {
+            return {
+                refresh: () => {
+                    return this.connection.sendRequest(vscode_languageserver_protocol_1.InlineValueRefreshRequest.type);
+                },
+                on: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.InlineValueFeature = InlineValueFeature;

node_modules/vscode-languageserver/lib/common/linkedEditingRange.d.ts

@@ -0,0 +1,16 @@
+import { LinkedEditingRangeParams, LinkedEditingRanges, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the linked editing feature
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeFeatureShape {
+    /**
+     * Installs a handler for the linked editing range request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onLinkedEditingRange(handler: ServerRequestHandler<LinkedEditingRangeParams, LinkedEditingRanges | undefined | null, never, never>): Disposable;
+}
+export declare const LinkedEditingRangeFeature: Feature<_Languages, LinkedEditingRangeFeatureShape>;

node_modules/vscode-languageserver/lib/common/linkedEditingRange.js

@@ -0,0 +1,18 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedEditingRangeFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const LinkedEditingRangeFeature = (Base) => {
+    return class extends Base {
+        onLinkedEditingRange(handler) {
+            return this.connection.onRequest(vscode_languageserver_protocol_1.LinkedEditingRangeRequest.type, (params, cancel) => {
+                return handler(params, cancel, this.attachWorkDoneProgress(params), undefined);
+            });
+        }
+    };
+};
+exports.LinkedEditingRangeFeature = LinkedEditingRangeFeature;

node_modules/vscode-languageserver/lib/common/moniker.d.ts

@@ -0,0 +1,13 @@
+import { MonikerParams, Moniker, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the moniker feature
+ *
+ * @since 3.16.0
+ */
+export interface MonikerFeatureShape {
+    moniker: {
+        on(handler: ServerRequestHandler<MonikerParams, Moniker[] | null, Moniker[], void>): Disposable;
+    };
+}
+export declare const MonikerFeature: Feature<_Languages, MonikerFeatureShape>;

node_modules/vscode-languageserver/lib/common/moniker.js

@@ -0,0 +1,23 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonikerFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const MonikerFeature = (Base) => {
+    return class extends Base {
+        get moniker() {
+            return {
+                on: (handler) => {
+                    const type = vscode_languageserver_protocol_1.MonikerRequest.type;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                },
+            };
+        }
+    };
+};
+exports.MonikerFeature = MonikerFeature;

node_modules/vscode-languageserver/lib/common/notebook.d.ts

@@ -0,0 +1,99 @@
+import { NotificationHandler1, Event, DocumentUri, URI, Disposable, DidOpenNotebookDocumentParams, DidChangeNotebookDocumentParams, DidSaveNotebookDocumentParams, DidCloseNotebookDocumentParams, NotebookDocument, NotebookCell, LSPObject } from 'vscode-languageserver-protocol';
+import type { Feature, _Notebooks, Connection } from './server';
+import { TextDocuments, TextDocumentsConfiguration } from './textDocuments';
+/**
+ * Shape of the notebooks feature
+ *
+ * @since 3.17.0
+ */
+export interface NotebookSyncFeatureShape {
+    synchronization: {
+        onDidOpenNotebookDocument(handler: NotificationHandler1<DidOpenNotebookDocumentParams>): Disposable;
+        onDidChangeNotebookDocument(handler: NotificationHandler1<DidChangeNotebookDocumentParams>): Disposable;
+        onDidSaveNotebookDocument(handler: NotificationHandler1<DidSaveNotebookDocumentParams>): Disposable;
+        onDidCloseNotebookDocument(handler: NotificationHandler1<DidCloseNotebookDocumentParams>): Disposable;
+    };
+}
+export declare const NotebookSyncFeature: Feature<_Notebooks, NotebookSyncFeatureShape>;
+export declare type NotebookDocumentChangeEvent = {
+    /**
+     * The notebook document that changed.
+     */
+    notebookDocument: NotebookDocument;
+    /**
+     * The meta data change if any.
+     *
+     * Note: old and new should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: {
+        old: LSPObject | undefined;
+        new: LSPObject | undefined;
+    };
+    /**
+     * The cell changes if any.
+     */
+    cells?: {
+        /**
+         * The cells that got added.
+         */
+        added: NotebookCell[];
+        /**
+         * The cells that got removed.
+         */
+        removed: NotebookCell[];
+        /**
+         * The cells that changed.
+         */
+        changed: {
+            /**
+             * The cell data has changed, excluding its
+             * text content which is reported via
+             * `textContentChanged`.
+             */
+            data: {
+                old: NotebookCell;
+                new: NotebookCell;
+            }[];
+            /**
+             * The text content of a cell has changed.
+             * The actual text is available via the `Notebooks`
+             * text document manager.
+             */
+            textContent: NotebookCell[];
+        };
+    };
+};
+export declare class NotebookDocuments<T extends {
+    uri: DocumentUri;
+}> {
+    private readonly notebookDocuments;
+    private readonly notebookCellMap;
+    private readonly _onDidOpen;
+    private readonly _onDidSave;
+    private readonly _onDidChange;
+    private readonly _onDidClose;
+    private _cellTextDocuments;
+    constructor(configurationOrTextDocuments: TextDocumentsConfiguration<T> | TextDocuments<T>);
+    get cellTextDocuments(): TextDocuments<T>;
+    getCellTextDocument(cell: NotebookCell): T | undefined;
+    getNotebookDocument(uri: URI): NotebookDocument | undefined;
+    getNotebookCell(uri: DocumentUri): NotebookCell | undefined;
+    findNotebookDocumentForCell(cell: DocumentUri | NotebookCell): NotebookDocument | undefined;
+    get onDidOpen(): Event<NotebookDocument>;
+    get onDidSave(): Event<NotebookDocument>;
+    get onDidChange(): Event<NotebookDocumentChangeEvent>;
+    get onDidClose(): Event<NotebookDocument>;
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the notebook documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenNotebookDocument`, `onDidChangeNotebookDocument`, `onDidSaveNotebookDocument`,
+     *  and `onDidCloseNotebookDocument`.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection: Connection): Disposable;
+    private updateCellMap;
+}

node_modules/vscode-languageserver/lib/common/notebook.js

@@ -0,0 +1,252 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotebookDocuments = exports.NotebookSyncFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const textDocuments_1 = require("./textDocuments");
+const NotebookSyncFeature = (Base) => {
+    return class extends Base {
+        get synchronization() {
+            return {
+                onDidOpenNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidOpenNotebookDocumentNotification.type, (params) => {
+                        handler(params);
+                    });
+                },
+                onDidChangeNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeNotebookDocumentNotification.type, (params) => {
+                        handler(params);
+                    });
+                },
+                onDidSaveNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidSaveNotebookDocumentNotification.type, (params) => {
+                        handler(params);
+                    });
+                },
+                onDidCloseNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidCloseNotebookDocumentNotification.type, (params) => {
+                        handler(params);
+                    });
+                }
+            };
+        }
+    };
+};
+exports.NotebookSyncFeature = NotebookSyncFeature;
+class CellTextDocumentConnection {
+    onDidOpenTextDocument(handler) {
+        this.openHandler = handler;
+        return vscode_languageserver_protocol_1.Disposable.create(() => { this.openHandler = undefined; });
+    }
+    openTextDocument(params) {
+        this.openHandler && this.openHandler(params);
+    }
+    onDidChangeTextDocument(handler) {
+        this.changeHandler = handler;
+        return vscode_languageserver_protocol_1.Disposable.create(() => { this.changeHandler = handler; });
+    }
+    changeTextDocument(params) {
+        this.changeHandler && this.changeHandler(params);
+    }
+    onDidCloseTextDocument(handler) {
+        this.closeHandler = handler;
+        return vscode_languageserver_protocol_1.Disposable.create(() => { this.closeHandler = undefined; });
+    }
+    closeTextDocument(params) {
+        this.closeHandler && this.closeHandler(params);
+    }
+    onWillSaveTextDocument() {
+        return CellTextDocumentConnection.NULL_DISPOSE;
+    }
+    onWillSaveTextDocumentWaitUntil() {
+        return CellTextDocumentConnection.NULL_DISPOSE;
+    }
+    onDidSaveTextDocument() {
+        return CellTextDocumentConnection.NULL_DISPOSE;
+    }
+}
+CellTextDocumentConnection.NULL_DISPOSE = Object.freeze({ dispose: () => { } });
+class NotebookDocuments {
+    constructor(configurationOrTextDocuments) {
+        if (configurationOrTextDocuments instanceof textDocuments_1.TextDocuments) {
+            this._cellTextDocuments = configurationOrTextDocuments;
+        }
+        else {
+            this._cellTextDocuments = new textDocuments_1.TextDocuments(configurationOrTextDocuments);
+        }
+        this.notebookDocuments = new Map();
+        this.notebookCellMap = new Map();
+        this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidChange = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
+    }
+    get cellTextDocuments() {
+        return this._cellTextDocuments;
+    }
+    getCellTextDocument(cell) {
+        return this._cellTextDocuments.get(cell.document);
+    }
+    getNotebookDocument(uri) {
+        return this.notebookDocuments.get(uri);
+    }
+    getNotebookCell(uri) {
+        const value = this.notebookCellMap.get(uri);
+        return value && value[0];
+    }
+    findNotebookDocumentForCell(cell) {
+        const key = typeof cell === 'string' ? cell : cell.document;
+        const value = this.notebookCellMap.get(key);
+        return value && value[1];
+    }
+    get onDidOpen() {
+        return this._onDidOpen.event;
+    }
+    get onDidSave() {
+        return this._onDidSave.event;
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    get onDidClose() {
+        return this._onDidClose.event;
+    }
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the notebook documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenNotebookDocument`, `onDidChangeNotebookDocument`, `onDidSaveNotebookDocument`,
+     *  and `onDidCloseNotebookDocument`.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection) {
+        const cellTextDocumentConnection = new CellTextDocumentConnection();
+        const disposables = [];
+        disposables.push(this.cellTextDocuments.listen(cellTextDocumentConnection));
+        disposables.push(connection.notebooks.synchronization.onDidOpenNotebookDocument((params) => {
+            this.notebookDocuments.set(params.notebookDocument.uri, params.notebookDocument);
+            for (const cellTextDocument of params.cellTextDocuments) {
+                cellTextDocumentConnection.openTextDocument({ textDocument: cellTextDocument });
+            }
+            this.updateCellMap(params.notebookDocument);
+            this._onDidOpen.fire(params.notebookDocument);
+        }));
+        disposables.push(connection.notebooks.synchronization.onDidChangeNotebookDocument((params) => {
+            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
+            if (notebookDocument === undefined) {
+                return;
+            }
+            notebookDocument.version = params.notebookDocument.version;
+            const oldMetadata = notebookDocument.metadata;
+            let metadataChanged = false;
+            const change = params.change;
+            if (change.metadata !== undefined) {
+                metadataChanged = true;
+                notebookDocument.metadata = change.metadata;
+            }
+            const opened = [];
+            const closed = [];
+            const data = [];
+            const text = [];
+            if (change.cells !== undefined) {
+                const changedCells = change.cells;
+                if (changedCells.structure !== undefined) {
+                    const array = changedCells.structure.array;
+                    notebookDocument.cells.splice(array.start, array.deleteCount, ...(array.cells !== undefined ? array.cells : []));
+                    // Additional open cell text documents.
+                    if (changedCells.structure.didOpen !== undefined) {
+                        for (const open of changedCells.structure.didOpen) {
+                            cellTextDocumentConnection.openTextDocument({ textDocument: open });
+                            opened.push(open.uri);
+                        }
+                    }
+                    // Additional closed cell test documents.
+                    if (changedCells.structure.didClose) {
+                        for (const close of changedCells.structure.didClose) {
+                            cellTextDocumentConnection.closeTextDocument({ textDocument: close });
+                            closed.push(close.uri);
+                        }
+                    }
+                }
+                if (changedCells.data !== undefined) {
+                    const cellUpdates = new Map(changedCells.data.map(cell => [cell.document, cell]));
+                    for (let i = 0; i <= notebookDocument.cells.length; i++) {
+                        const change = cellUpdates.get(notebookDocument.cells[i].document);
+                        if (change !== undefined) {
+                            const old = notebookDocument.cells.splice(i, 1, change);
+                            data.push({ old: old[0], new: change });
+                            cellUpdates.delete(change.document);
+                            if (cellUpdates.size === 0) {
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (changedCells.textContent !== undefined) {
+                    for (const cellTextDocument of changedCells.textContent) {
+                        cellTextDocumentConnection.changeTextDocument({ textDocument: cellTextDocument.document, contentChanges: cellTextDocument.changes });
+                        text.push(cellTextDocument.document.uri);
+                    }
+                }
+            }
+            // Update internal data structure.
+            this.updateCellMap(notebookDocument);
+            const changeEvent = { notebookDocument };
+            if (metadataChanged) {
+                changeEvent.metadata = { old: oldMetadata, new: notebookDocument.metadata };
+            }
+            const added = [];
+            for (const open of opened) {
+                added.push(this.getNotebookCell(open));
+            }
+            const removed = [];
+            for (const close of closed) {
+                removed.push(this.getNotebookCell(close));
+            }
+            const textContent = [];
+            for (const change of text) {
+                textContent.push(this.getNotebookCell(change));
+            }
+            if (added.length > 0 || removed.length > 0 || data.length > 0 || textContent.length > 0) {
+                changeEvent.cells = { added, removed, changed: { data, textContent } };
+            }
+            if (changeEvent.metadata !== undefined || changeEvent.cells !== undefined) {
+                this._onDidChange.fire(changeEvent);
+            }
+        }));
+        disposables.push(connection.notebooks.synchronization.onDidSaveNotebookDocument((params) => {
+            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
+            if (notebookDocument === undefined) {
+                return;
+            }
+            this._onDidSave.fire(notebookDocument);
+        }));
+        disposables.push(connection.notebooks.synchronization.onDidCloseNotebookDocument((params) => {
+            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
+            if (notebookDocument === undefined) {
+                return;
+            }
+            this._onDidClose.fire(notebookDocument);
+            for (const cellTextDocument of params.cellTextDocuments) {
+                cellTextDocumentConnection.closeTextDocument({ textDocument: cellTextDocument });
+            }
+            this.notebookDocuments.delete(params.notebookDocument.uri);
+            for (const cell of notebookDocument.cells) {
+                this.notebookCellMap.delete(cell.document);
+            }
+        }));
+        return vscode_languageserver_protocol_1.Disposable.create(() => { disposables.forEach(disposable => disposable.dispose()); });
+    }
+    updateCellMap(notebookDocument) {
+        for (const cell of notebookDocument.cells) {
+            this.notebookCellMap.set(cell.document, [cell, notebookDocument]);
+        }
+    }
+}
+exports.NotebookDocuments = NotebookDocuments;

node_modules/vscode-languageserver/lib/common/progress.d.ts

@@ -0,0 +1,25 @@
+import { CancellationToken, ProgressToken, ProgressType, WorkDoneProgressParams, PartialResultParams } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWindow } from './server';
+export interface ProgressContext {
+    sendProgress<P>(type: ProgressType<P>, token: ProgressToken, value: P): void;
+}
+export interface WorkDoneProgressReporter {
+    begin(title: string, percentage?: number, message?: string, cancellable?: boolean): void;
+    report(percentage: number): void;
+    report(message: string): void;
+    report(percentage: number, message: string): void;
+    done(): void;
+}
+export interface WorkDoneProgressServerReporter extends WorkDoneProgressReporter {
+    readonly token: CancellationToken;
+}
+export interface WindowProgress {
+    attachWorkDoneProgress(token: ProgressToken | undefined): WorkDoneProgressReporter;
+    createWorkDoneProgress(): Promise<WorkDoneProgressServerReporter>;
+}
+export declare function attachWorkDone(connection: ProgressContext, params: WorkDoneProgressParams | undefined): WorkDoneProgressReporter;
+export declare const ProgressFeature: Feature<_RemoteWindow, WindowProgress>;
+export interface ResultProgressReporter<R> {
+    report(data: R): void;
+}
+export declare function attachPartialResult<R>(connection: ProgressContext, params: PartialResultParams): ResultProgressReporter<R> | undefined;

node_modules/vscode-languageserver/lib/common/progress.js

@@ -0,0 +1,159 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachPartialResult = exports.ProgressFeature = exports.attachWorkDone = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const uuid_1 = require("./utils/uuid");
+class WorkDoneProgressReporterImpl {
+    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 !== undefined) {
+                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();
+class WorkDoneProgressServerReporterImpl extends WorkDoneProgressReporterImpl {
+    constructor(connection, token) {
+        super(connection, 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();
+    }
+}
+class NullProgressReporter {
+    constructor() {
+    }
+    begin() {
+    }
+    report() {
+    }
+    done() {
+    }
+}
+class NullProgressServerReporter 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(connection, params) {
+    if (params === undefined || params.workDoneToken === undefined) {
+        return new NullProgressReporter();
+    }
+    const token = params.workDoneToken;
+    delete params.workDoneToken;
+    return new WorkDoneProgressReporterImpl(connection, token);
+}
+exports.attachWorkDone = attachWorkDone;
+const 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 === undefined) {
+                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;
+var ResultProgress;
+(function (ResultProgress) {
+    ResultProgress.type = new vscode_languageserver_protocol_1.ProgressType();
+})(ResultProgress || (ResultProgress = {}));
+class ResultProgressReporterImpl {
+    constructor(_connection, _token) {
+        this._connection = _connection;
+        this._token = _token;
+    }
+    report(data) {
+        this._connection.sendProgress(ResultProgress.type, this._token, data);
+    }
+}
+function attachPartialResult(connection, params) {
+    if (params === undefined || params.partialResultToken === undefined) {
+        return undefined;
+    }
+    const token = params.partialResultToken;
+    delete params.partialResultToken;
+    return new ResultProgressReporterImpl(connection, token);
+}
+exports.attachPartialResult = attachPartialResult;

node_modules/vscode-languageserver/lib/common/semanticTokens.d.ts

@@ -0,0 +1,38 @@
+import { SemanticTokens, SemanticTokensPartialResult, SemanticTokensDelta, SemanticTokensDeltaPartialResult, SemanticTokensParams, SemanticTokensDeltaParams, SemanticTokensRangeParams, SemanticTokensEdit, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the semantic token feature
+ *
+ * @since 3.16.0
+ */
+export interface SemanticTokensFeatureShape {
+    semanticTokens: {
+        refresh(): void;
+        on(handler: ServerRequestHandler<SemanticTokensParams, SemanticTokens, SemanticTokensPartialResult, void>): Disposable;
+        onDelta(handler: ServerRequestHandler<SemanticTokensDeltaParams, SemanticTokensDelta | SemanticTokens, SemanticTokensDeltaPartialResult | SemanticTokensPartialResult, void>): Disposable;
+        onRange(handler: ServerRequestHandler<SemanticTokensRangeParams, SemanticTokens, SemanticTokensPartialResult, void>): Disposable;
+    };
+}
+export declare const SemanticTokensFeature: Feature<_Languages, SemanticTokensFeatureShape>;
+export declare class SemanticTokensDiff {
+    private readonly originalSequence;
+    private readonly modifiedSequence;
+    constructor(originalSequence: number[], modifiedSequence: number[]);
+    computeDiff(): SemanticTokensEdit[];
+}
+export declare class SemanticTokensBuilder {
+    private _id;
+    private _prevLine;
+    private _prevChar;
+    private _data;
+    private _dataLen;
+    private _prevData;
+    constructor();
+    private initialize;
+    push(line: number, char: number, length: number, tokenType: number, tokenModifiers: number): void;
+    get id(): string;
+    previousResult(id: string): void;
+    build(): SemanticTokens;
+    canBuildEdits(): boolean;
+    buildEdits(): SemanticTokens | SemanticTokensDelta;
+}

node_modules/vscode-languageserver/lib/common/semanticTokens.js

@@ -0,0 +1,154 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticTokensBuilder = exports.SemanticTokensDiff = exports.SemanticTokensFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const 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;
+                    return 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;
+                    return 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;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.SemanticTokensFeature = SemanticTokensFeature;
+class SemanticTokensDiff {
+    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 one moved behind the start index move them forward again
+            if (originalEndIndex < startIndex || modifiedEndIndex < startIndex) {
+                originalEndIndex++;
+                modifiedEndIndex++;
+            }
+            const deleteCount = originalEndIndex - startIndex + 1;
+            const newData = this.modifiedSequence.slice(startIndex, modifiedEndIndex + 1);
+            // If we moved behind the start index we could have missed a simple delete.
+            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 {
+            // The two arrays are the same.
+            return [];
+        }
+    }
+}
+exports.SemanticTokensDiff = SemanticTokensDiff;
+class SemanticTokensBuilder {
+    constructor() {
+        this._prevData = undefined;
+        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 = undefined;
+        return {
+            resultId: this.id,
+            data: this._data
+        };
+    }
+    canBuildEdits() {
+        return this._prevData !== undefined;
+    }
+    buildEdits() {
+        if (this._prevData !== undefined) {
+            return {
+                resultId: this.id,
+                edits: (new SemanticTokensDiff(this._prevData, this._data)).computeDiff()
+            };
+        }
+        else {
+            return this.build();
+        }
+    }
+}
+exports.SemanticTokensBuilder = SemanticTokensBuilder;

node_modules/vscode-languageserver/lib/common/server.d.ts

@@ -0,0 +1,795 @@
+import { CancellationToken, ProtocolRequestType0, RequestHandler0, ProtocolRequestType, RequestHandler, GenericRequestHandler, StarRequestHandler, HandlerResult, ProtocolNotificationType0, NotificationHandler0, ProtocolNotificationType, NotificationHandler, GenericNotificationHandler, StarNotificationHandler, ProgressType, Disposable, InitializeParams, InitializeResult, InitializeError, InitializedParams, DidChangeConfigurationParams, DidChangeWatchedFilesParams, DidOpenTextDocumentParams, DidChangeTextDocumentParams, DidCloseTextDocumentParams, WillSaveTextDocumentParams, TextEdit, DidSaveTextDocumentParams, PublishDiagnosticsParams, HoverParams, Hover, CompletionParams, CompletionItem, CompletionList, SignatureHelpParams, SignatureHelp, DeclarationParams, Declaration, DeclarationLink, Location, DefinitionParams, Definition, DefinitionLink, TypeDefinitionParams, ImplementationParams, ReferenceParams, DocumentHighlightParams, DocumentHighlight, DocumentSymbolParams, SymbolInformation, DocumentSymbol, WorkspaceSymbolParams, CodeActionParams, Command, CodeAction, CodeLensParams, CodeLens, DocumentFormattingParams, DocumentRangeFormattingParams, DocumentOnTypeFormattingParams, RenameParams, WorkspaceEdit, PrepareRenameParams, Range, DocumentLinkParams, DocumentLink, DocumentColorParams, ColorInformation, ColorPresentationParams, ColorPresentation, FoldingRangeParams, FoldingRange, SelectionRangeParams, SelectionRange, ExecuteCommandParams, MessageActionItem, ClientCapabilities, ServerCapabilities, Logger, ProtocolConnection, MessageSignature, ApplyWorkspaceEditParams, ApplyWorkspaceEditResponse, WorkDoneProgressParams, PartialResultParams, RegistrationType, RequestType0, RequestType, NotificationType0, NotificationType, WorkspaceSymbol } from 'vscode-languageserver-protocol';
+import { WorkDoneProgressReporter, ResultProgressReporter, WindowProgress } from './progress';
+import { Configuration } from './configuration';
+import { WorkspaceFolders } from './workspaceFolder';
+import { CallHierarchy } from './callHierarchy';
+import { SemanticTokensFeatureShape } from './semanticTokens';
+import { ShowDocumentFeatureShape } from './showDocument';
+import { FileOperationsFeatureShape } from './fileOperations';
+import { LinkedEditingRangeFeatureShape } from './linkedEditingRange';
+import { TypeHierarchyFeatureShape } from './typeHierarchy';
+import { InlineValueFeatureShape } from './inlineValue';
+import { InlayHintFeatureShape } from './inlayHint';
+import { DiagnosticFeatureShape } from './diagnostic';
+import { NotebookSyncFeatureShape } from './notebook';
+import { MonikerFeatureShape } from './moniker';
+/**
+ * Helps tracking error message. Equal occurrences of the same
+ * message are only stored once. This class is for example
+ * useful if text documents are validated in a loop and equal
+ * error message should be folded into one.
+ */
+export declare class ErrorMessageTracker {
+    private _messages;
+    constructor();
+    /**
+     * Add a message to the tracker.
+     *
+     * @param message The message to add.
+     */
+    add(message: string): void;
+    /**
+     * Send all tracked messages to the connection's window.
+     *
+     * @param connection The connection established between client and server.
+     */
+    sendErrors(connection: {
+        window: RemoteWindow;
+    }): void;
+}
+export interface FeatureBase {
+    /**
+     * Called to initialize the remote with the given
+     * client capabilities
+     *
+     * @param capabilities The client capabilities
+     */
+    initialize(capabilities: ClientCapabilities): void;
+    /**
+     * Called to fill in the server capabilities this feature implements.
+     *
+     * @param capabilities The server capabilities to fill.
+     */
+    fillServerCapabilities(capabilities: ServerCapabilities): void;
+}
+interface Remote extends FeatureBase {
+    /**
+     * Attach the remote to the given connection.
+     *
+     * @param connection The connection this remote is operating on.
+     */
+    attach(connection: Connection): void;
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+}
+/**
+ * The RemoteConsole interface contains all functions to interact with
+ * the tools / clients console or log system. Internally it used `window/logMessage`
+ * notifications.
+ */
+export interface RemoteConsole extends FeatureBase {
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+    /**
+     * Show an error message.
+     *
+     * @param message The message to show.
+     */
+    error(message: string): void;
+    /**
+     * Show a warning message.
+     *
+     * @param message The message to show.
+     */
+    warn(message: string): void;
+    /**
+     * Show an information message.
+     *
+     * @param message The message to show.
+     */
+    info(message: string): void;
+    /**
+     * Log a message.
+     *
+     * @param message The message to log.
+     */
+    log(message: string): void;
+}
+/**
+ * The RemoteWindow interface contains all functions to interact with
+ * the visual window of VS Code.
+ */
+export interface _RemoteWindow extends FeatureBase {
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+    /**
+     * Shows an error message in the client's user interface. Depending on the client this might
+     * be a modal dialog with a confirmation button or a notification in a notification center
+     *
+     * @param message The message to show.
+     * @param actions Possible additional actions presented in the user interface. The selected action
+     *  will be the value of the resolved promise
+     */
+    showErrorMessage(message: string): void;
+    showErrorMessage<T extends MessageActionItem>(message: string, ...actions: T[]): Promise<T | undefined>;
+    /**
+     * Shows a warning message in the client's user interface. Depending on the client this might
+     * be a modal dialog with a confirmation button or a notification in a notification center
+     *
+     * @param message The message to show.
+     * @param actions Possible additional actions presented in the user interface. The selected action
+     *  will be the value of the resolved promise
+     */
+    showWarningMessage(message: string): void;
+    showWarningMessage<T extends MessageActionItem>(message: string, ...actions: T[]): Promise<T | undefined>;
+    /**
+     * Shows an information message in the client's user interface. Depending on the client this might
+     * be a modal dialog with a confirmation button or a notification in a notification center
+     *
+     * @param message The message to show.
+     * @param actions Possible additional actions presented in the user interface. The selected action
+     *  will be the value of the resolved promise
+     */
+    showInformationMessage(message: string): void;
+    showInformationMessage<T extends MessageActionItem>(message: string, ...actions: T[]): Promise<T | undefined>;
+}
+export declare type RemoteWindow = _RemoteWindow & WindowProgress & ShowDocumentFeatureShape;
+/**
+ * A bulk registration manages n single registration to be able to register
+ * for n notifications or requests using one register request.
+ */
+export interface BulkRegistration {
+    /**
+     * Adds a single registration.
+     * @param type the notification type to register for.
+     * @param registerParams special registration parameters.
+     */
+    add<RO>(type: ProtocolNotificationType0<RO>, registerParams: RO): void;
+    add<P, RO>(type: ProtocolNotificationType<P, RO>, registerParams: RO): void;
+    /**
+     * Adds a single registration.
+     * @param type the request type to register for.
+     * @param registerParams special registration parameters.
+     */
+    add<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, registerParams: RO): void;
+    add<P, PR, R, E, RO>(type: ProtocolRequestType<P, PR, R, E, RO>, registerParams: RO): void;
+    /**
+     * Adds a single registration.
+     * @param type the notification type to register for.
+     * @param registerParams special registration parameters.
+     */
+    add<RO>(type: RegistrationType<RO>, registerParams: RO): void;
+}
+export declare namespace BulkRegistration {
+    /**
+     * Creates a new bulk registration.
+     * @return an empty bulk registration.
+     */
+    function create(): BulkRegistration;
+}
+/**
+ * A `BulkUnregistration` manages n unregistrations.
+ */
+export interface BulkUnregistration extends Disposable {
+    /**
+     * Disposes a single registration. It will be removed from the
+     * `BulkUnregistration`.
+     */
+    disposeSingle(arg: string | MessageSignature): boolean;
+}
+export declare namespace BulkUnregistration {
+    function create(): BulkUnregistration;
+}
+/**
+ * Interface to register and unregister `listeners` on the client / tools side.
+ */
+export interface RemoteClient extends FeatureBase {
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+    /**
+     * Registers a listener for the given request.
+     *
+     * @param type the request type to register for.
+     * @param registerParams special registration parameters.
+     * @return a `Disposable` to unregister the listener again.
+     */
+    register<P, RO>(type: ProtocolNotificationType<P, RO>, registerParams?: RO): Promise<Disposable>;
+    register<RO>(type: ProtocolNotificationType0<RO>, registerParams?: RO): Promise<Disposable>;
+    /**
+     * Registers a listener for the given request.
+     *
+     * @param unregisteration the unregistration to add a corresponding unregister action to.
+     * @param type the request type to register for.
+     * @param registerParams special registration parameters.
+     * @return the updated unregistration.
+     */
+    register<P, RO>(unregisteration: BulkUnregistration, type: ProtocolNotificationType<P, RO>, registerParams?: RO): Promise<Disposable>;
+    register<RO>(unregisteration: BulkUnregistration, type: ProtocolNotificationType0<RO>, registerParams?: RO): Promise<Disposable>;
+    /**
+     * Registers a listener for the given request.
+     *
+     * @param type the request type to register for.
+     * @param registerParams special registration parameters.
+     * @return a `Disposable` to unregister the listener again.
+     */
+    register<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, registerParams?: RO): Promise<Disposable>;
+    register<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, registerParams?: RO): Promise<Disposable>;
+    /**
+     * Registers a listener for the given request.
+     *
+     * @param unregisteration the unregistration to add a corresponding unregister action to.
+     * @param type the request type to register for.
+     * @param registerParams special registration parameters.
+     * @return the updated unregistration.
+     */
+    register<P, R, PR, E, RO>(unregisteration: BulkUnregistration, type: ProtocolRequestType<P, R, PR, E, RO>, registerParams?: RO): Promise<Disposable>;
+    register<R, PR, E, RO>(unregisteration: BulkUnregistration, type: ProtocolRequestType0<R, PR, E, RO>, registerParams?: RO): Promise<Disposable>;
+    /**
+     * Registers a listener for the given registration type.
+     *
+     * @param type the registration type.
+     * @param registerParams special registration parameters.
+     * @return a `Disposable` to unregister the listener again.
+     */
+    register<RO>(type: RegistrationType<RO>, registerParams?: RO): Promise<Disposable>;
+    /**
+     * Registers a listener for the given registration type.
+     *
+     * @param unregisteration the unregistration to add a corresponding unregister action to.
+     * @param type the registration type.
+     * @param registerParams special registration parameters.
+     * @return the updated unregistration.
+     */
+    register<RO>(unregisteration: BulkUnregistration, type: RegistrationType<RO>, registerParams?: RO): Promise<Disposable>;
+    /**
+     * Registers a set of listeners.
+     * @param registrations the bulk registration
+     * @return a `Disposable` to unregister the listeners again.
+     */
+    register(registrations: BulkRegistration): Promise<BulkUnregistration>;
+}
+/**
+ * Represents the workspace managed by the client.
+ */
+export interface _RemoteWorkspace extends FeatureBase {
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+    /**
+     * Applies a `WorkspaceEdit` to the workspace
+     * @param param the workspace edit params.
+     * @return a thenable that resolves to the `ApplyWorkspaceEditResponse`.
+     */
+    applyEdit(paramOrEdit: ApplyWorkspaceEditParams | WorkspaceEdit): Promise<ApplyWorkspaceEditResponse>;
+}
+export declare type RemoteWorkspace = _RemoteWorkspace & Configuration & WorkspaceFolders & FileOperationsFeatureShape;
+/**
+ * Interface to log telemetry events. The events are actually send to the client
+ * and the client needs to feed the event into a proper telemetry system.
+ */
+export interface Telemetry extends FeatureBase {
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+    /**
+     * Log the given data to telemetry.
+     *
+     * @param data The data to log. Must be a JSON serializable object.
+     */
+    logEvent(data: any): void;
+}
+/**
+ * Interface to log traces to the client. The events are sent to the client and the
+ * client needs to log the trace events.
+ */
+export interface RemoteTracer extends FeatureBase {
+    /**
+     * The connection this remote is attached to.
+     */
+    connection: Connection;
+    /**
+     * Log the given data to the trace Log
+     */
+    log(message: string, verbose?: string): void;
+}
+export interface _Languages extends FeatureBase {
+    connection: Connection;
+    attachWorkDoneProgress(params: WorkDoneProgressParams): WorkDoneProgressReporter;
+    attachPartialResultProgress<PR>(type: ProgressType<PR>, params: PartialResultParams): ResultProgressReporter<PR> | undefined;
+}
+export declare class _LanguagesImpl implements Remote, _Languages {
+    private _connection;
+    constructor();
+    attach(connection: Connection): void;
+    get connection(): Connection;
+    initialize(_capabilities: ClientCapabilities): void;
+    fillServerCapabilities(_capabilities: ServerCapabilities): void;
+    attachWorkDoneProgress(params: WorkDoneProgressParams): WorkDoneProgressReporter;
+    attachPartialResultProgress<PR>(_type: ProgressType<PR>, params: PartialResultParams): ResultProgressReporter<PR> | undefined;
+}
+export declare type Languages = _Languages & CallHierarchy & SemanticTokensFeatureShape & LinkedEditingRangeFeatureShape & TypeHierarchyFeatureShape & InlineValueFeatureShape & InlayHintFeatureShape & DiagnosticFeatureShape & MonikerFeatureShape;
+export interface _Notebooks extends FeatureBase {
+    connection: Connection;
+    attachWorkDoneProgress(params: WorkDoneProgressParams): WorkDoneProgressReporter;
+    attachPartialResultProgress<PR>(type: ProgressType<PR>, params: PartialResultParams): ResultProgressReporter<PR> | undefined;
+}
+export declare class _NotebooksImpl implements Remote, _Notebooks {
+    private _connection;
+    constructor();
+    attach(connection: Connection): void;
+    get connection(): Connection;
+    initialize(_capabilities: ClientCapabilities): void;
+    fillServerCapabilities(_capabilities: ServerCapabilities): void;
+    attachWorkDoneProgress(params: WorkDoneProgressParams): WorkDoneProgressReporter;
+    attachPartialResultProgress<PR>(_type: ProgressType<PR>, params: PartialResultParams): ResultProgressReporter<PR> | undefined;
+}
+export declare type Notebooks = _Notebooks & NotebookSyncFeatureShape;
+/**
+ * An empty interface for new proposed API.
+ */
+export interface _ {
+}
+export interface ServerRequestHandler<P, R, PR, E> {
+    (params: P, token: CancellationToken, workDoneProgress: WorkDoneProgressReporter, resultProgress?: ResultProgressReporter<PR>): HandlerResult<R, E>;
+}
+/**
+ * Interface to describe the shape of the server connection.
+ */
+export interface _Connection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _, PNotebooks = _> {
+    /**
+     * Start listening on the input stream for messages to process.
+     */
+    listen(): void;
+    /**
+     * Installs a request handler described by the given {@link RequestType}.
+     *
+     * @param type The {@link RequestType} describing the request.
+     * @param handler The handler to install
+     */
+    onRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, handler: RequestHandler0<R, E>): Disposable;
+    onRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, handler: RequestHandler<P, R, E>): Disposable;
+    onRequest<R, PR, E, RO>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable;
+    onRequest<P, R, E>(type: RequestType<P, R, E>, handler: RequestHandler<P, R, E>): Disposable;
+    /**
+     * Installs a request handler for the given method.
+     *
+     * @param method The method to register a request handler for.
+     * @param handler The handler to install.
+     */
+    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): Disposable;
+    /**
+     * Installs a request handler that is invoked if no specific request handler can be found.
+     *
+     * @param handler a handler that handles all requests.
+     */
+    onRequest(handler: StarRequestHandler): Disposable;
+    /**
+     * Send a request to the client.
+     *
+     * @param type The {@link RequestType} describing the request.
+     * @param params The request's parameters.
+     */
+    sendRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, params: P, token?: CancellationToken): Promise<R>;
+    sendRequest<R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, E>(type: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R>;
+    /**
+     * Send a request to the client.
+     *
+     * @param method The method to invoke on the client.
+     * @param params The request's parameters.
+     */
+    sendRequest<R>(method: string, token?: CancellationToken): Promise<R>;
+    sendRequest<R>(method: string, params: any, token?: CancellationToken): Promise<R>;
+    /**
+     * Installs a notification handler described by the given {@link NotificationType}.
+     *
+     * @param type The {@link NotificationType} describing the notification.
+     * @param handler The handler to install.
+     */
+    onNotification<RO>(type: ProtocolNotificationType0<RO>, handler: NotificationHandler0): Disposable;
+    onNotification<P, RO>(type: ProtocolNotificationType<P, RO>, handler: NotificationHandler<P>): Disposable;
+    onNotification(type: NotificationType0, handler: NotificationHandler0): Disposable;
+    onNotification<P>(type: NotificationType<P>, handler: NotificationHandler<P>): Disposable;
+    /**
+     * Installs a notification handler for the given method.
+     *
+     * @param method The method to register a request handler for.
+     * @param handler The handler to install.
+     */
+    onNotification(method: string, handler: GenericNotificationHandler): Disposable;
+    /**
+     * Installs a notification handler that is invoked if no specific notification handler can be found.
+     *
+     * @param handler a handler that handles all notifications.
+     */
+    onNotification(handler: StarNotificationHandler): Disposable;
+    /**
+     * Send a notification to the client.
+     *
+     * @param type The {@link NotificationType} describing the notification.
+     * @param params The notification's parameters.
+     */
+    sendNotification<RO>(type: ProtocolNotificationType0<RO>): Promise<void>;
+    sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params: P): Promise<void>;
+    sendNotification(type: NotificationType0): Promise<void>;
+    sendNotification<P>(type: NotificationType<P>, params: P): Promise<void>;
+    /**
+     * Send a notification to the client.
+     *
+     * @param method The method to invoke on the client.
+     * @param params The notification's parameters.
+     */
+    sendNotification(method: string, params?: any): Promise<void>;
+    /**
+     * Installs a progress handler for a given token.
+     * @param type the progress type
+     * @param token the token
+     * @param handler the handler
+     */
+    onProgress<P>(type: ProgressType<P>, token: string | number, handler: NotificationHandler<P>): Disposable;
+    /**
+     * Sends progress.
+     * @param type the progress type
+     * @param token the token to use
+     * @param value the progress value
+     */
+    sendProgress<P>(type: ProgressType<P>, token: string | number, value: P): Promise<void>;
+    /**
+     * Installs a handler for the initialize request.
+     *
+     * @param handler The initialize handler.
+     */
+    onInitialize(handler: ServerRequestHandler<InitializeParams, InitializeResult, never, InitializeError>): Disposable;
+    /**
+     * Installs a handler for the initialized notification.
+     *
+     * @param handler The initialized handler.
+     */
+    onInitialized(handler: NotificationHandler<InitializedParams>): Disposable;
+    /**
+     * Installs a handler for the shutdown request.
+     *
+     * @param handler The initialize handler.
+     */
+    onShutdown(handler: RequestHandler0<void, void>): Disposable;
+    /**
+     * Installs a handler for the exit notification.
+     *
+     * @param handler The exit handler.
+     */
+    onExit(handler: NotificationHandler0): Disposable;
+    /**
+     * A property to provide access to console specific features.
+     */
+    console: RemoteConsole & PConsole;
+    /**
+     * A property to provide access to tracer specific features.
+     */
+    tracer: RemoteTracer & PTracer;
+    /**
+     * A property to provide access to telemetry specific features.
+     */
+    telemetry: Telemetry & PTelemetry;
+    /**
+     * A property to provide access to client specific features like registering
+     * for requests or notifications.
+     */
+    client: RemoteClient & PClient;
+    /**
+     * A property to provide access to windows specific features.
+     */
+    window: RemoteWindow & PWindow;
+    /**
+     * A property to provide access to workspace specific features.
+     */
+    workspace: RemoteWorkspace & PWorkspace;
+    /**
+     * A property to provide access to language specific features.
+     */
+    languages: Languages & PLanguages;
+    /**
+     * A property to provide access to notebook specific features.
+     */
+    notebooks: Notebooks & PNotebooks;
+    /**
+     * Installs a handler for the `DidChangeConfiguration` notification.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDidChangeConfiguration(handler: NotificationHandler<DidChangeConfigurationParams>): Disposable;
+    /**
+     * Installs a handler for the `DidChangeWatchedFiles` notification.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDidChangeWatchedFiles(handler: NotificationHandler<DidChangeWatchedFilesParams>): Disposable;
+    /**
+     * Installs a handler for the `DidOpenTextDocument` notification.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDidOpenTextDocument(handler: NotificationHandler<DidOpenTextDocumentParams>): Disposable;
+    /**
+     * Installs a handler for the `DidChangeTextDocument` notification.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDidChangeTextDocument(handler: NotificationHandler<DidChangeTextDocumentParams>): Disposable;
+    /**
+     * Installs a handler for the `DidCloseTextDocument` notification.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDidCloseTextDocument(handler: NotificationHandler<DidCloseTextDocumentParams>): Disposable;
+    /**
+     * Installs a handler for the `WillSaveTextDocument` notification.
+     *
+     * Note that this notification is opt-in. The client will not send it unless
+     * your server has the `textDocumentSync.willSave` capability or you've
+     * dynamically registered for the `textDocument/willSave` method.
+     *
+     * @param handler The corresponding handler.
+     */
+    onWillSaveTextDocument(handler: NotificationHandler<WillSaveTextDocumentParams>): Disposable;
+    /**
+     * Installs a handler for the `WillSaveTextDocumentWaitUntil` request.
+     *
+     * Note that this request is opt-in. The client will not send it unless
+     * your server has the `textDocumentSync.willSaveWaitUntil` capability,
+     * or you've dynamically registered for the `textDocument/willSaveWaitUntil`
+     * method.
+     *
+     * @param handler The corresponding handler.
+     */
+    onWillSaveTextDocumentWaitUntil(handler: RequestHandler<WillSaveTextDocumentParams, TextEdit[] | undefined | null, void>): Disposable;
+    /**
+     * Installs a handler for the `DidSaveTextDocument` notification.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDidSaveTextDocument(handler: NotificationHandler<DidSaveTextDocumentParams>): Disposable;
+    /**
+     * Sends diagnostics computed for a given document to VSCode to render them in the
+     * user interface.
+     *
+     * @param params The diagnostic parameters.
+     */
+    sendDiagnostics(params: PublishDiagnosticsParams): Promise<void>;
+    /**
+     * Installs a handler for the `Hover` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onHover(handler: ServerRequestHandler<HoverParams, Hover | undefined | null, never, void>): Disposable;
+    /**
+     * Installs a handler for the `Completion` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onCompletion(handler: ServerRequestHandler<CompletionParams, CompletionItem[] | CompletionList | undefined | null, CompletionItem[], void>): Disposable;
+    /**
+     * Installs a handler for the `CompletionResolve` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onCompletionResolve(handler: RequestHandler<CompletionItem, CompletionItem, void>): Disposable;
+    /**
+     * Installs a handler for the `SignatureHelp` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onSignatureHelp(handler: ServerRequestHandler<SignatureHelpParams, SignatureHelp | undefined | null, never, void>): Disposable;
+    /**
+     * Installs a handler for the `Declaration` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDeclaration(handler: ServerRequestHandler<DeclarationParams, Declaration | DeclarationLink[] | undefined | null, Location[] | DeclarationLink[], void>): Disposable;
+    /**
+     * Installs a handler for the `Definition` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDefinition(handler: ServerRequestHandler<DefinitionParams, Definition | DefinitionLink[] | undefined | null, Location[] | DefinitionLink[], void>): Disposable;
+    /**
+     * Installs a handler for the `Type Definition` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onTypeDefinition(handler: ServerRequestHandler<TypeDefinitionParams, Definition | DefinitionLink[] | undefined | null, Location[] | DefinitionLink[], void>): Disposable;
+    /**
+     * Installs a handler for the `Implementation` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onImplementation(handler: ServerRequestHandler<ImplementationParams, Definition | DefinitionLink[] | undefined | null, Location[] | DefinitionLink[], void>): Disposable;
+    /**
+     * Installs a handler for the `References` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onReferences(handler: ServerRequestHandler<ReferenceParams, Location[] | undefined | null, Location[], void>): Disposable;
+    /**
+     * Installs a handler for the `DocumentHighlight` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentHighlight(handler: ServerRequestHandler<DocumentHighlightParams, DocumentHighlight[] | undefined | null, DocumentHighlight[], void>): Disposable;
+    /**
+     * Installs a handler for the `DocumentSymbol` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentSymbol(handler: ServerRequestHandler<DocumentSymbolParams, SymbolInformation[] | DocumentSymbol[] | undefined | null, SymbolInformation[] | DocumentSymbol[], void>): Disposable;
+    /**
+     * Installs a handler for the `WorkspaceSymbol` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onWorkspaceSymbol(handler: ServerRequestHandler<WorkspaceSymbolParams, SymbolInformation[] | WorkspaceSymbol[] | undefined | null, SymbolInformation[], void>): Disposable;
+    /**
+     * Installs a handler for the `WorkspaceSymbol` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onWorkspaceSymbolResolve(handler: RequestHandler<WorkspaceSymbol, WorkspaceSymbol, void>): Disposable;
+    /**
+     * Installs a handler for the `CodeAction` request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onCodeAction(handler: ServerRequestHandler<CodeActionParams, (Command | CodeAction)[] | undefined | null, (Command | CodeAction)[], void>): Disposable;
+    /**
+     * Installs a handler for the `CodeAction` resolve request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onCodeActionResolve(handler: RequestHandler<CodeAction, CodeAction, void>): Disposable;
+    /**
+     * Compute a list of {@link CodeLens lenses}. This call should return as fast as possible and if
+     * computing the commands is expensive implementers should only return code lens objects with the
+     * range set and handle the resolve request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onCodeLens(handler: ServerRequestHandler<CodeLensParams, CodeLens[] | undefined | null, CodeLens[], void>): Disposable;
+    /**
+     * This function will be called for each visible code lens, usually when scrolling and after
+     * the onCodeLens has been called.
+     *
+     * @param handler The corresponding handler.
+     */
+    onCodeLensResolve(handler: RequestHandler<CodeLens, CodeLens, void>): Disposable;
+    /**
+     * Installs a handler for the document formatting request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentFormatting(handler: ServerRequestHandler<DocumentFormattingParams, TextEdit[] | undefined | null, never, void>): Disposable;
+    /**
+     * Installs a handler for the document range formatting request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentRangeFormatting(handler: ServerRequestHandler<DocumentRangeFormattingParams, TextEdit[] | undefined | null, never, void>): Disposable;
+    /**
+     * Installs a handler for the document on type formatting request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentOnTypeFormatting(handler: RequestHandler<DocumentOnTypeFormattingParams, TextEdit[] | undefined | null, void>): Disposable;
+    /**
+     * Installs a handler for the rename request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onRenameRequest(handler: ServerRequestHandler<RenameParams, WorkspaceEdit | undefined | null, never, void>): Disposable;
+    /**
+     * Installs a handler for the prepare rename request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onPrepareRename(handler: RequestHandler<PrepareRenameParams, Range | {
+        range: Range;
+        placeholder: string;
+    } | {
+        defaultBehavior: boolean;
+    } | undefined | null, void>): Disposable;
+    /**
+     * Installs a handler for the document links request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentLinks(handler: ServerRequestHandler<DocumentLinkParams, DocumentLink[] | undefined | null, DocumentLink[], void>): Disposable;
+    /**
+     * Installs a handler for the document links resolve request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentLinkResolve(handler: RequestHandler<DocumentLink, DocumentLink | undefined | null, void>): Disposable;
+    /**
+     * Installs a handler for the document color request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onDocumentColor(handler: ServerRequestHandler<DocumentColorParams, ColorInformation[] | undefined | null, ColorInformation[], void>): Disposable;
+    /**
+     * Installs a handler for the document color request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onColorPresentation(handler: ServerRequestHandler<ColorPresentationParams, ColorPresentation[] | undefined | null, ColorPresentation[], void>): Disposable;
+    /**
+     * Installs a handler for the folding ranges request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onFoldingRanges(handler: ServerRequestHandler<FoldingRangeParams, FoldingRange[] | undefined | null, FoldingRange[], void>): Disposable;
+    /**
+     * Installs a handler for the selection ranges request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onSelectionRanges(handler: ServerRequestHandler<SelectionRangeParams, SelectionRange[] | undefined | null, SelectionRange[], void>): Disposable;
+    /**
+     * Installs a handler for the execute command request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onExecuteCommand(handler: ServerRequestHandler<ExecuteCommandParams, any | undefined | null, never, void>): Disposable;
+    /**
+     * Disposes the connection
+     */
+    dispose(): void;
+}
+export interface Connection extends _Connection {
+}
+export interface Feature<B extends FeatureBase, P> {
+    (Base: new () => B): new () => B & P;
+}
+export declare type ConsoleFeature<P> = Feature<RemoteConsole, P>;
+export declare function combineConsoleFeatures<O, T>(one: ConsoleFeature<O>, two: ConsoleFeature<T>): ConsoleFeature<O & T>;
+export declare type TelemetryFeature<P> = Feature<Telemetry, P>;
+export declare function combineTelemetryFeatures<O, T>(one: TelemetryFeature<O>, two: TelemetryFeature<T>): TelemetryFeature<O & T>;
+export declare type TracerFeature<P> = Feature<RemoteTracer, P>;
+export declare function combineTracerFeatures<O, T>(one: TracerFeature<O>, two: TracerFeature<T>): TracerFeature<O & T>;
+export declare type ClientFeature<P> = Feature<RemoteClient, P>;
+export declare function combineClientFeatures<O, T>(one: ClientFeature<O>, two: ClientFeature<T>): ClientFeature<O & T>;
+export declare type WindowFeature<P> = Feature<_RemoteWindow, P>;
+export declare function combineWindowFeatures<O, T>(one: WindowFeature<O>, two: WindowFeature<T>): WindowFeature<O & T>;
+export declare type WorkspaceFeature<P> = Feature<_RemoteWorkspace, P>;
+export declare function combineWorkspaceFeatures<O, T>(one: WorkspaceFeature<O>, two: WorkspaceFeature<T>): WorkspaceFeature<O & T>;
+export declare type LanguagesFeature<P> = Feature<_Languages, P>;
+export declare function combineLanguagesFeatures<O, T>(one: LanguagesFeature<O>, two: LanguagesFeature<T>): LanguagesFeature<O & T>;
+export declare type NotebooksFeature<P> = Feature<_Notebooks, P>;
+export declare function combineNotebooksFeatures<O, T>(one: NotebooksFeature<O>, two: NotebooksFeature<T>): NotebooksFeature<O & T>;
+export interface Features<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _, PNotebooks = _> {
+    __brand: 'features';
+    console?: ConsoleFeature<PConsole>;
+    tracer?: TracerFeature<PTracer>;
+    telemetry?: TelemetryFeature<PTelemetry>;
+    client?: ClientFeature<PClient>;
+    window?: WindowFeature<PWindow>;
+    workspace?: WorkspaceFeature<PWorkspace>;
+    languages?: LanguagesFeature<PLanguages>;
+    notebooks?: NotebooksFeature<PNotebooks>;
+}
+export declare function combineFeatures<OConsole, OTracer, OTelemetry, OClient, OWindow, OWorkspace, OLanguages, ONotebooks, TConsole, TTracer, TTelemetry, TClient, TWindow, TWorkspace, TLanguages, TNotebooks>(one: Features<OConsole, OTracer, OTelemetry, OClient, OWindow, OWorkspace, OLanguages, ONotebooks>, two: Features<TConsole, TTracer, TTelemetry, TClient, TWindow, TWorkspace, TLanguages, TNotebooks>): Features<OConsole & TConsole, OTracer & TTracer, OTelemetry & TTelemetry, OClient & TClient, OWindow & TWindow, OWorkspace & TWorkspace, OLanguages & TLanguages, ONotebooks & TNotebooks>;
+export interface WatchDog {
+    shutdownReceived: boolean;
+    initialize(params: InitializeParams): void;
+    exit(code: number): void;
+}
+export declare function createConnection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _, PNotebooks = _>(connectionFactory: (logger: Logger) => ProtocolConnection, watchDog: WatchDog, factories?: Features<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>): _Connection<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>;
+export {};

node_modules/vscode-languageserver/lib/common/server.js

@@ -0,0 +1,749 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = exports.combineFeatures = exports.combineNotebooksFeatures = exports.combineLanguagesFeatures = exports.combineWorkspaceFeatures = exports.combineWindowFeatures = exports.combineClientFeatures = exports.combineTracerFeatures = exports.combineTelemetryFeatures = exports.combineConsoleFeatures = exports._NotebooksImpl = exports._LanguagesImpl = exports.BulkUnregistration = exports.BulkRegistration = exports.ErrorMessageTracker = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+const UUID = require("./utils/uuid");
+const progress_1 = require("./progress");
+const configuration_1 = require("./configuration");
+const workspaceFolder_1 = require("./workspaceFolder");
+const callHierarchy_1 = require("./callHierarchy");
+const semanticTokens_1 = require("./semanticTokens");
+const showDocument_1 = require("./showDocument");
+const fileOperations_1 = require("./fileOperations");
+const linkedEditingRange_1 = require("./linkedEditingRange");
+const typeHierarchy_1 = require("./typeHierarchy");
+const inlineValue_1 = require("./inlineValue");
+const inlayHint_1 = require("./inlayHint");
+const diagnostic_1 = require("./diagnostic");
+const notebook_1 = require("./notebook");
+const moniker_1 = require("./moniker");
+function null2Undefined(value) {
+    if (value === null) {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Helps tracking error message. Equal occurrences of the same
+ * message are only stored once. This class is for example
+ * useful if text documents are validated in a loop and equal
+ * error message should be folded into one.
+ */
+class ErrorMessageTracker {
+    constructor() {
+        this._messages = Object.create(null);
+    }
+    /**
+     * Add a message to the tracker.
+     *
+     * @param message The message to add.
+     */
+    add(message) {
+        let count = this._messages[message];
+        if (!count) {
+            count = 0;
+        }
+        count++;
+        this._messages[message] = count;
+    }
+    /**
+     * Send all tracked messages to the connection's window.
+     *
+     * @param connection The connection established between client and server.
+     */
+    sendErrors(connection) {
+        Object.keys(this._messages).forEach(message => {
+            connection.window.showErrorMessage(message);
+        });
+    }
+}
+exports.ErrorMessageTracker = ErrorMessageTracker;
+class RemoteConsoleImpl {
+    constructor() {
+    }
+    rawAttach(connection) {
+        this._rawConnection = connection;
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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`);
+            });
+        }
+    }
+}
+class _RemoteWindowImpl {
+    constructor() {
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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);
+    }
+}
+const RemoteWindowImpl = (0, showDocument_1.ShowDocumentFeature)((0, progress_1.ProgressFeature)(_RemoteWindowImpl));
+var BulkRegistration;
+(function (BulkRegistration) {
+    /**
+     * Creates a new bulk registration.
+     * @return an empty bulk registration.
+     */
+    function create() {
+        return new BulkRegistrationImpl();
+    }
+    BulkRegistration.create = create;
+})(BulkRegistration = exports.BulkRegistration || (exports.BulkRegistration = {}));
+class BulkRegistrationImpl {
+    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: id,
+            method: method,
+            registerOptions: registerOptions || {}
+        });
+        this._registered.add(method);
+    }
+    asRegistrationParams() {
+        return {
+            registrations: this._registrations
+        };
+    }
+}
+var BulkUnregistration;
+(function (BulkUnregistration) {
+    function create() {
+        return new BulkUnregistrationImpl(undefined, []);
+    }
+    BulkUnregistration.create = create;
+})(BulkUnregistration = exports.BulkUnregistration || (exports.BulkUnregistration = {}));
+class BulkUnregistrationImpl {
+    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(connection) {
+        this._connection = connection;
+    }
+    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;
+    }
+}
+class RemoteClientImpl {
+    attach(connection) {
+        this._connection = connection;
+    }
+    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: id, method: 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);
+        });
+    }
+}
+class _RemoteWorkspaceImpl {
+    constructor() {
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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);
+    }
+}
+const RemoteWorkspaceImpl = (0, fileOperations_1.FileOperationsFeature)((0, workspaceFolder_1.WorkspaceFoldersFeature)((0, configuration_1.ConfigurationFeature)(_RemoteWorkspaceImpl)));
+class TracerImpl {
+    constructor() {
+        this._trace = vscode_languageserver_protocol_1.Trace.Off;
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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: message,
+            verbose: this._trace === vscode_languageserver_protocol_1.Trace.Verbose ? verbose : undefined
+        }).catch(() => {
+            // Very hard to decide what to do. We tried to send a log
+            // message which failed so we can't simply send another :-(.
+        });
+    }
+}
+class TelemetryImpl {
+    constructor() {
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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).catch(() => {
+            this.connection.console.log(`Sending TelemetryEventNotification failed`);
+        });
+    }
+}
+class _LanguagesImpl {
+    constructor() {
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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;
+const LanguagesImpl = (0, moniker_1.MonikerFeature)((0, diagnostic_1.DiagnosticFeature)((0, inlayHint_1.InlayHintFeature)((0, inlineValue_1.InlineValueFeature)((0, typeHierarchy_1.TypeHierarchyFeature)((0, linkedEditingRange_1.LinkedEditingRangeFeature)((0, semanticTokens_1.SemanticTokensFeature)((0, callHierarchy_1.CallHierarchyFeature)(_LanguagesImpl))))))));
+class _NotebooksImpl {
+    constructor() {
+    }
+    attach(connection) {
+        this._connection = connection;
+    }
+    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._NotebooksImpl = _NotebooksImpl;
+const NotebooksImpl = (0, notebook_1.NotebookSyncFeature)(_NotebooksImpl);
+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 combineNotebooksFeatures(one, two) {
+    return function (Base) {
+        return two(one(Base));
+    };
+}
+exports.combineNotebooksFeatures = combineNotebooksFeatures;
+function combineFeatures(one, two) {
+    function combine(one, two, func) {
+        if (one && two) {
+            return func(one, two);
+        }
+        else if (one) {
+            return one;
+        }
+        else {
+            return two;
+        }
+    }
+    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),
+        languages: combine(one.languages, two.languages, combineLanguagesFeatures),
+        notebooks: combine(one.notebooks, two.notebooks, combineNotebooksFeatures)
+    };
+    return result;
+}
+exports.combineFeatures = combineFeatures;
+function createConnection(connectionFactory, watchDog, factories) {
+    const logger = (factories && factories.console ? new (factories.console(RemoteConsoleImpl))() : new RemoteConsoleImpl());
+    const connection = connectionFactory(logger);
+    logger.rawAttach(connection);
+    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 notebooks = (factories && factories.notebooks ? new (factories.notebooks(NotebooksImpl))() : new NotebooksImpl());
+    const allRemotes = [logger, tracer, telemetry, client, remoteWindow, workspace, languages, notebooks];
+    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 = undefined;
+    let initializeHandler = undefined;
+    let exitHandler = undefined;
+    let protocolConnection = {
+        listen: () => connection.listen(),
+        sendRequest: (type, ...params) => connection.sendRequest(Is.string(type) ? type : type.method, ...params),
+        onRequest: (type, handler) => connection.onRequest(type, handler),
+        sendNotification: (type, param) => {
+            const method = Is.string(type) ? type : type.method;
+            if (arguments.length === 1) {
+                return connection.sendNotification(method);
+            }
+            else {
+                return connection.sendNotification(method, param);
+            }
+        },
+        onNotification: (type, handler) => connection.onNotification(type, handler),
+        onProgress: connection.onProgress,
+        sendProgress: connection.sendProgress,
+        onInitialize: (handler) => {
+            initializeHandler = handler;
+            return {
+                dispose: () => {
+                    initializeHandler = undefined;
+                }
+            };
+        },
+        onInitialized: (handler) => connection.onNotification(vscode_languageserver_protocol_1.InitializedNotification.type, handler),
+        onShutdown: (handler) => {
+            shutdownHandler = handler;
+            return {
+                dispose: () => {
+                    shutdownHandler = undefined;
+                }
+            };
+        },
+        onExit: (handler) => {
+            exitHandler = handler;
+            return {
+                dispose: () => {
+                    exitHandler = undefined;
+                }
+            };
+        },
+        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; },
+        get notebooks() { return notebooks; },
+        onDidChangeConfiguration: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, handler),
+        onDidChangeWatchedFiles: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, handler),
+        __textDocumentSync: undefined,
+        onDidOpenTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, handler),
+        onDidChangeTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, handler),
+        onDidCloseTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, handler),
+        onWillSaveTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, handler),
+        onWillSaveTextDocumentWaitUntil: (handler) => connection.onRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, handler),
+        onDidSaveTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, handler),
+        sendDiagnostics: (params) => connection.sendNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, params),
+        onHover: (handler) => connection.onRequest(vscode_languageserver_protocol_1.HoverRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), undefined);
+        }),
+        onCompletion: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CompletionRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onCompletionResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, handler),
+        onSignatureHelp: (handler) => connection.onRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), undefined);
+        }),
+        onDeclaration: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onDefinition: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onTypeDefinition: (handler) => connection.onRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onImplementation: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onReferences: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onDocumentHighlight: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onDocumentSymbol: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onWorkspaceSymbol: (handler) => connection.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onWorkspaceSymbolResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, handler),
+        onCodeAction: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onCodeActionResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, (params, cancel) => {
+            return handler(params, cancel);
+        }),
+        onCodeLens: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onCodeLensResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, (params, cancel) => {
+            return handler(params, cancel);
+        }),
+        onDocumentFormatting: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), undefined);
+        }),
+        onDocumentRangeFormatting: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), undefined);
+        }),
+        onDocumentOnTypeFormatting: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, (params, cancel) => {
+            return handler(params, cancel);
+        }),
+        onRenameRequest: (handler) => connection.onRequest(vscode_languageserver_protocol_1.RenameRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), undefined);
+        }),
+        onPrepareRename: (handler) => connection.onRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, (params, cancel) => {
+            return handler(params, cancel);
+        }),
+        onDocumentLinks: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onDocumentLinkResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, (params, cancel) => {
+            return handler(params, cancel);
+        }),
+        onDocumentColor: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onColorPresentation: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onFoldingRanges: (handler) => connection.onRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onSelectionRanges: (handler) => connection.onRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), (0, progress_1.attachPartialResult)(connection, params));
+        }),
+        onExecuteCommand: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, (params, cancel) => {
+            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection, params), undefined);
+        }),
+        dispose: () => connection.dispose()
+    };
+    for (let remote of allRemotes) {
+        remote.attach(protocolConnection);
+    }
+    connection.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)(connection, params), undefined);
+            return asPromise(result).then((value) => {
+                if (value instanceof vscode_languageserver_protocol_1.ResponseError) {
+                    return value;
+                }
+                let result = value;
+                if (!result) {
+                    result = { capabilities: {} };
+                }
+                let capabilities = result.capabilities;
+                if (!capabilities) {
+                    capabilities = {};
+                    result.capabilities = capabilities;
+                }
+                if (capabilities.textDocumentSync === undefined || 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 result;
+            });
+        }
+        else {
+            let result = { capabilities: { textDocumentSync: vscode_languageserver_protocol_1.TextDocumentSyncKind.None } };
+            for (let remote of allRemotes) {
+                remote.fillServerCapabilities(result.capabilities);
+            }
+            return result;
+        }
+    });
+    connection.onRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, () => {
+        watchDog.shutdownReceived = true;
+        if (shutdownHandler) {
+            return shutdownHandler(new vscode_languageserver_protocol_1.CancellationTokenSource().token);
+        }
+        else {
+            return undefined;
+        }
+    });
+    connection.onNotification(vscode_languageserver_protocol_1.ExitNotification.type, () => {
+        try {
+            if (exitHandler) {
+                exitHandler();
+            }
+        }
+        finally {
+            if (watchDog.shutdownReceived) {
+                watchDog.exit(0);
+            }
+            else {
+                watchDog.exit(1);
+            }
+        }
+    });
+    connection.onNotification(vscode_languageserver_protocol_1.SetTraceNotification.type, (params) => {
+        tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.value);
+    });
+    return protocolConnection;
+}
+exports.createConnection = createConnection;

node_modules/vscode-languageserver/lib/common/showDocument.d.ts

@@ -0,0 +1,6 @@
+import { ShowDocumentParams, ShowDocumentResult } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWindow } from './server';
+export interface ShowDocumentFeatureShape {
+    showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult>;
+}
+export declare const ShowDocumentFeature: Feature<_RemoteWindow, ShowDocumentFeatureShape>;

node_modules/vscode-languageserver/lib/common/showDocument.js

@@ -0,0 +1,16 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowDocumentFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const ShowDocumentFeature = (Base) => {
+    return class extends Base {
+        showDocument(params) {
+            return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowDocumentRequest.type, params);
+        }
+    };
+};
+exports.ShowDocumentFeature = ShowDocumentFeature;

node_modules/vscode-languageserver/lib/common/textDocuments.d.ts

@@ -0,0 +1,133 @@
+import { NotificationHandler, DidOpenTextDocumentParams, DidChangeTextDocumentParams, DidCloseTextDocumentParams, WillSaveTextDocumentParams, RequestHandler, TextEdit, DidSaveTextDocumentParams, DocumentUri, TextDocumentContentChangeEvent, TextDocumentSaveReason, Event, TextDocumentSyncKind, Disposable } from 'vscode-languageserver-protocol';
+/**
+ * We should use a mapped type to create this from Connection.
+ */
+export interface TextDocumentConnection {
+    onDidOpenTextDocument(handler: NotificationHandler<DidOpenTextDocumentParams>): Disposable;
+    onDidChangeTextDocument(handler: NotificationHandler<DidChangeTextDocumentParams>): Disposable;
+    onDidCloseTextDocument(handler: NotificationHandler<DidCloseTextDocumentParams>): Disposable;
+    onWillSaveTextDocument(handler: NotificationHandler<WillSaveTextDocumentParams>): Disposable;
+    onWillSaveTextDocumentWaitUntil(handler: RequestHandler<WillSaveTextDocumentParams, TextEdit[] | undefined | null, void>): Disposable;
+    onDidSaveTextDocument(handler: NotificationHandler<DidSaveTextDocumentParams>): Disposable;
+}
+export interface ConnectionState {
+    __textDocumentSync: TextDocumentSyncKind | undefined;
+}
+export interface TextDocumentsConfiguration<T extends {
+    uri: DocumentUri;
+}> {
+    create(uri: DocumentUri, languageId: string, version: number, content: string): T;
+    update(document: T, changes: TextDocumentContentChangeEvent[], version: number): T;
+}
+/**
+ * Event to signal changes to a text document.
+ */
+export interface TextDocumentChangeEvent<T> {
+    /**
+     * The document that has changed.
+     */
+    document: T;
+}
+/**
+ * Event to signal that a document will be saved.
+ */
+export interface TextDocumentWillSaveEvent<T> {
+    /**
+     * The document that will be saved
+     */
+    document: T;
+    /**
+     * The reason why save was triggered.
+     */
+    reason: TextDocumentSaveReason;
+}
+/**
+ * A manager for simple text documents. The manager requires at a minimum that
+ * the server registered for the following text document sync events in the
+ * initialize handler or via dynamic registration:
+ *
+ * - open and close events.
+ * - change events.
+ *
+ * Registering for save and will save events is optional.
+ */
+export declare class TextDocuments<T extends {
+    uri: DocumentUri;
+}> {
+    private readonly _configuration;
+    private readonly _syncedDocuments;
+    private readonly _onDidChangeContent;
+    private readonly _onDidOpen;
+    private readonly _onDidClose;
+    private readonly _onDidSave;
+    private readonly _onWillSave;
+    private _willSaveWaitUntil;
+    /**
+     * Create a new text document manager.
+     */
+    constructor(configuration: TextDocumentsConfiguration<T>);
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened.
+     */
+    get onDidOpen(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened or the content changes.
+     */
+    get onDidChangeContent(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * will be saved.
+     */
+    get onWillSave(): Event<TextDocumentWillSaveEvent<T>>;
+    /**
+     * Sets a handler that will be called if a participant wants to provide
+     * edits during a text document save.
+     */
+    onWillSaveWaitUntil(handler: RequestHandler<TextDocumentWillSaveEvent<T>, TextEdit[], void>): void;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been saved.
+     */
+    get onDidSave(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been closed.
+     */
+    get onDidClose(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * Returns the document for the given URI. Returns undefined if
+     * the document is not managed by this instance.
+     *
+     * @param uri The text document's URI to retrieve.
+     * @return the text document or `undefined`.
+     */
+    get(uri: string): T | undefined;
+    /**
+     * Returns all text documents managed by this instance.
+     *
+     * @return all text documents.
+     */
+    all(): T[];
+    /**
+     * Returns the URIs of all text documents managed by this instance.
+     *
+     * @return the URI's of all text documents.
+     */
+    keys(): string[];
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the text documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+     *
+     * Use the corresponding events on the TextDocuments instance instead.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection: TextDocumentConnection): Disposable;
+}

node_modules/vscode-languageserver/lib/common/textDocuments.js

@@ -0,0 +1,172 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextDocuments = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+/**
+ * A manager for simple text documents. The manager requires at a minimum that
+ * the server registered for the following text document sync events in the
+ * initialize handler or via dynamic registration:
+ *
+ * - open and close events.
+ * - change events.
+ *
+ * Registering for save and will save events is optional.
+ */
+class TextDocuments {
+    /**
+     * Create a new text document manager.
+     */
+    constructor(configuration) {
+        this._configuration = configuration;
+        this._syncedDocuments = new Map();
+        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();
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened.
+     */
+    get onDidOpen() {
+        return this._onDidOpen.event;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened or the content changes.
+     */
+    get onDidChangeContent() {
+        return this._onDidChangeContent.event;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * will be saved.
+     */
+    get onWillSave() {
+        return this._onWillSave.event;
+    }
+    /**
+     * Sets a handler that will be called if a participant wants to provide
+     * edits during a text document save.
+     */
+    onWillSaveWaitUntil(handler) {
+        this._willSaveWaitUntil = handler;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been saved.
+     */
+    get onDidSave() {
+        return this._onDidSave.event;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been closed.
+     */
+    get onDidClose() {
+        return this._onDidClose.event;
+    }
+    /**
+     * Returns the document for the given URI. Returns undefined if
+     * the document is not managed by this instance.
+     *
+     * @param uri The text document's URI to retrieve.
+     * @return the text document or `undefined`.
+     */
+    get(uri) {
+        return this._syncedDocuments.get(uri);
+    }
+    /**
+     * Returns all text documents managed by this instance.
+     *
+     * @return all text documents.
+     */
+    all() {
+        return Array.from(this._syncedDocuments.values());
+    }
+    /**
+     * Returns the URIs of all text documents managed by this instance.
+     *
+     * @return the URI's of all text documents.
+     */
+    keys() {
+        return Array.from(this._syncedDocuments.keys());
+    }
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the text documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+     *
+     * Use the corresponding events on the TextDocuments instance instead.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection) {
+        connection.__textDocumentSync = vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental;
+        const disposables = [];
+        disposables.push(connection.onDidOpenTextDocument((event) => {
+            const td = event.textDocument;
+            const document = this._configuration.create(td.uri, td.languageId, td.version, td.text);
+            this._syncedDocuments.set(td.uri, document);
+            const toFire = Object.freeze({ document });
+            this._onDidOpen.fire(toFire);
+            this._onDidChangeContent.fire(toFire);
+        }));
+        disposables.push(connection.onDidChangeTextDocument((event) => {
+            const td = event.textDocument;
+            const changes = event.contentChanges;
+            if (changes.length === 0) {
+                return;
+            }
+            const { version } = td;
+            if (version === null || version === undefined) {
+                throw new Error(`Received document change event for ${td.uri} without valid version identifier`);
+            }
+            let syncedDocument = this._syncedDocuments.get(td.uri);
+            if (syncedDocument !== undefined) {
+                syncedDocument = this._configuration.update(syncedDocument, changes, version);
+                this._syncedDocuments.set(td.uri, syncedDocument);
+                this._onDidChangeContent.fire(Object.freeze({ document: syncedDocument }));
+            }
+        }));
+        disposables.push(connection.onDidCloseTextDocument((event) => {
+            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined) {
+                this._syncedDocuments.delete(event.textDocument.uri);
+                this._onDidClose.fire(Object.freeze({ document: syncedDocument }));
+            }
+        }));
+        disposables.push(connection.onWillSaveTextDocument((event) => {
+            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined) {
+                this._onWillSave.fire(Object.freeze({ document: syncedDocument, reason: event.reason }));
+            }
+        }));
+        disposables.push(connection.onWillSaveTextDocumentWaitUntil((event, token) => {
+            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined && this._willSaveWaitUntil) {
+                return this._willSaveWaitUntil(Object.freeze({ document: syncedDocument, reason: event.reason }), token);
+            }
+            else {
+                return [];
+            }
+        }));
+        disposables.push(connection.onDidSaveTextDocument((event) => {
+            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined) {
+                this._onDidSave.fire(Object.freeze({ document: syncedDocument }));
+            }
+        }));
+        return vscode_languageserver_protocol_1.Disposable.create(() => { disposables.forEach(disposable => disposable.dispose()); });
+    }
+}
+exports.TextDocuments = TextDocuments;

node_modules/vscode-languageserver/lib/common/typeHierarchy.d.ts

@@ -0,0 +1,15 @@
+import { TypeHierarchyItem, Disposable, TypeHierarchyPrepareParams, TypeHierarchySupertypesParams, TypeHierarchySubtypesParams } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the type hierarchy feature
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchyFeatureShape {
+    typeHierarchy: {
+        onPrepare(handler: ServerRequestHandler<TypeHierarchyPrepareParams, TypeHierarchyItem[] | null, never, void>): Disposable;
+        onSupertypes(handler: ServerRequestHandler<TypeHierarchySupertypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void>): Disposable;
+        onSubtypes(handler: ServerRequestHandler<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void>): Disposable;
+    };
+}
+export declare const TypeHierarchyFeature: Feature<_Languages, TypeHierarchyFeatureShape>;

node_modules/vscode-languageserver/lib/common/typeHierarchy.js

@@ -0,0 +1,34 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeHierarchyFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const TypeHierarchyFeature = (Base) => {
+    return class extends Base {
+        get typeHierarchy() {
+            return {
+                onPrepare: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), undefined);
+                    });
+                },
+                onSupertypes: (handler) => {
+                    const type = vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type;
+                    return 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.TypeHierarchySubtypesRequest.type;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.TypeHierarchyFeature = TypeHierarchyFeature;

node_modules/vscode-languageserver/lib/common/utils/is.d.ts

@@ -0,0 +1,9 @@
+export declare function boolean(value: any): value is boolean;
+export declare function string(value: any): value is string;
+export declare function number(value: any): value is number;
+export declare function error(value: any): value is Error;
+export declare function func(value: any): value is Function;
+export declare function array<T>(value: any): value is T[];
+export declare function stringArray(value: any): value is string[];
+export declare function typedArray<T>(value: any, check: (value: any) => boolean): value is T[];
+export declare function thenable<T>(value: any): value is Thenable<T>;

node_modules/vscode-languageserver/lib/common/utils/is.js

@@ -0,0 +1,43 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+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;

node_modules/vscode-languageserver/lib/common/utils/uuid.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Represents a UUID as defined by rfc4122.
+ */
+export interface UUID {
+    /**
+     * @returns the canonical representation in sets of hexadecimal numbers separated by dashes.
+     */
+    asHex(): string;
+    equals(other: UUID): boolean;
+}
+/**
+ * An empty UUID that contains only zeros.
+ */
+export declare const empty: UUID;
+export declare function v4(): UUID;
+export declare function isUUID(value: string): boolean;
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+export declare function parse(value: string): UUID;
+export declare function generateUuid(): string;

node_modules/vscode-languageserver/lib/common/utils/uuid.js

@@ -0,0 +1,97 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0;
+class ValueUUID {
+    constructor(_value) {
+        this._value = _value;
+        // empty
+    }
+    asHex() {
+        return this._value;
+    }
+    equals(other) {
+        return this.asHex() === other.asHex();
+    }
+}
+class V4UUID 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'];
+/**
+ * An empty UUID that contains only zeros.
+ */
+exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000');
+function v4() {
+    return new V4UUID();
+}
+exports.v4 = v4;
+const _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;
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+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;

node_modules/vscode-languageserver/lib/common/workspaceFolder.d.ts

@@ -0,0 +1,7 @@
+import { Event, WorkspaceFolder, WorkspaceFoldersChangeEvent } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWorkspace } from './server';
+export interface WorkspaceFolders {
+    getWorkspaceFolders(): Promise<WorkspaceFolder[] | null>;
+    onDidChangeWorkspaceFolders: Event<WorkspaceFoldersChangeEvent>;
+}
+export declare const WorkspaceFoldersFeature: Feature<_RemoteWorkspace, WorkspaceFolders>;

node_modules/vscode-languageserver/lib/common/workspaceFolder.js

@@ -0,0 +1,44 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceFoldersFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const 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;

node_modules/vscode-languageserver/lib/node/files.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @deprecated Use the `vscode-uri` npm module which provides a more
+ * complete implementation of handling VS Code URIs.
+ */
+export declare function uriToFilePath(uri: string): string | undefined;
+export declare function resolve(moduleName: string, nodePath: string | undefined, cwd: string | undefined, tracer: (message: string, verbose?: string) => void): Promise<string>;
+/**
+ * Resolve the global npm package path.
+ * @deprecated Since this depends on the used package manager and their version the best is that servers
+ * implement this themselves since they know best what kind of package managers to support.
+ * @param tracer the tracer to use
+ */
+export declare function resolveGlobalNodePath(tracer?: (message: string) => void): string | undefined;
+export declare function resolveGlobalYarnPath(tracer?: (message: string) => void): string | undefined;
+export declare namespace FileSystem {
+    function isCaseSensitive(): boolean;
+    function isParent(parent: string, child: string): boolean;
+}
+export declare function resolveModulePath(workspaceRoot: string, moduleName: string, nodePath: string, tracer: (message: string, verbose?: string) => void): Promise<string>;

node_modules/vscode-languageserver/lib/node/files.js

@@ -0,0 +1,262 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModulePath = exports.FileSystem = exports.resolveGlobalYarnPath = exports.resolveGlobalNodePath = exports.resolve = exports.uriToFilePath = void 0;
+const url = require("url");
+const path = require("path");
+const fs = require("fs");
+const child_process_1 = require("child_process");
+/**
+ * @deprecated Use the `vscode-uri` npm module which provides a more
+ * complete implementation of handling VS Code URIs.
+ */
+function uriToFilePath(uri) {
+    let parsed = url.parse(uri);
+    if (parsed.protocol !== 'file:' || !parsed.path) {
+        return undefined;
+    }
+    let segments = parsed.path.split('/');
+    for (var i = 0, len = segments.length; i < len; i++) {
+        segments[i] = decodeURIComponent(segments[i]);
+    }
+    if (process.platform === 'win32' && segments.length > 1) {
+        let first = segments[0];
+        let second = segments[1];
+        // Do we have a drive letter and we started with a / which is the
+        // case if the first segement is empty (see split above)
+        if (first.length === 0 && second.length > 1 && second[1] === ':') {
+            // Remove first slash
+            segments.shift();
+        }
+    }
+    return path.normalize(segments.join('/'));
+}
+exports.uriToFilePath = uriToFilePath;
+function isWindows() {
+    return process.platform === 'win32';
+}
+function resolve(moduleName, nodePath, cwd, tracer) {
+    const nodePathKey = 'NODE_PATH';
+    const app = [
+        'var p = process;',
+        'p.on(\'message\',function(m){',
+        'if(m.c===\'e\'){',
+        'p.exit(0);',
+        '}',
+        'else if(m.c===\'rs\'){',
+        'try{',
+        'var r=require.resolve(m.a);',
+        'p.send({c:\'r\',s:true,r:r});',
+        '}',
+        'catch(err){',
+        'p.send({c:\'r\',s:false});',
+        '}',
+        '}',
+        '});'
+    ].join('');
+    return new Promise((resolve, reject) => {
+        let env = process.env;
+        let newEnv = Object.create(null);
+        Object.keys(env).forEach(key => newEnv[key] = env[key]);
+        if (nodePath && fs.existsSync(nodePath) /* see issue 545 */) {
+            if (newEnv[nodePathKey]) {
+                newEnv[nodePathKey] = nodePath + path.delimiter + newEnv[nodePathKey];
+            }
+            else {
+                newEnv[nodePathKey] = nodePath;
+            }
+            if (tracer) {
+                tracer(`NODE_PATH value is: ${newEnv[nodePathKey]}`);
+            }
+        }
+        newEnv['ELECTRON_RUN_AS_NODE'] = '1';
+        try {
+            let cp = (0, child_process_1.fork)('', [], {
+                cwd: cwd,
+                env: newEnv,
+                execArgv: ['-e', app]
+            });
+            if (cp.pid === void 0) {
+                reject(new Error(`Starting process to resolve node module  ${moduleName} failed`));
+                return;
+            }
+            cp.on('error', (error) => {
+                reject(error);
+            });
+            cp.on('message', (message) => {
+                if (message.c === 'r') {
+                    cp.send({ c: 'e' });
+                    if (message.s) {
+                        resolve(message.r);
+                    }
+                    else {
+                        reject(new Error(`Failed to resolve module: ${moduleName}`));
+                    }
+                }
+            });
+            let message = {
+                c: 'rs',
+                a: moduleName
+            };
+            cp.send(message);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+exports.resolve = resolve;
+/**
+ * Resolve the global npm package path.
+ * @deprecated Since this depends on the used package manager and their version the best is that servers
+ * implement this themselves since they know best what kind of package managers to support.
+ * @param tracer the tracer to use
+ */
+function resolveGlobalNodePath(tracer) {
+    let npmCommand = 'npm';
+    const env = Object.create(null);
+    Object.keys(process.env).forEach(key => env[key] = process.env[key]);
+    env['NO_UPDATE_NOTIFIER'] = 'true';
+    const options = {
+        encoding: 'utf8',
+        env
+    };
+    if (isWindows()) {
+        npmCommand = 'npm.cmd';
+        options.shell = true;
+    }
+    let handler = () => { };
+    try {
+        process.on('SIGPIPE', handler);
+        let stdout = (0, child_process_1.spawnSync)(npmCommand, ['config', 'get', 'prefix'], options).stdout;
+        if (!stdout) {
+            if (tracer) {
+                tracer(`'npm config get prefix' didn't return a value.`);
+            }
+            return undefined;
+        }
+        let prefix = stdout.trim();
+        if (tracer) {
+            tracer(`'npm config get prefix' value is: ${prefix}`);
+        }
+        if (prefix.length > 0) {
+            if (isWindows()) {
+                return path.join(prefix, 'node_modules');
+            }
+            else {
+                return path.join(prefix, 'lib', 'node_modules');
+            }
+        }
+        return undefined;
+    }
+    catch (err) {
+        return undefined;
+    }
+    finally {
+        process.removeListener('SIGPIPE', handler);
+    }
+}
+exports.resolveGlobalNodePath = resolveGlobalNodePath;
+/*
+ * Resolve the global yarn pakage path.
+ * @deprecated Since this depends on the used package manager and their version the best is that servers
+ * implement this themselves since they know best what kind of package managers to support.
+ * @param tracer the tracer to use
+ */
+function resolveGlobalYarnPath(tracer) {
+    let yarnCommand = 'yarn';
+    let options = {
+        encoding: 'utf8'
+    };
+    if (isWindows()) {
+        yarnCommand = 'yarn.cmd';
+        options.shell = true;
+    }
+    let handler = () => { };
+    try {
+        process.on('SIGPIPE', handler);
+        let results = (0, child_process_1.spawnSync)(yarnCommand, ['global', 'dir', '--json'], options);
+        let stdout = results.stdout;
+        if (!stdout) {
+            if (tracer) {
+                tracer(`'yarn global dir' didn't return a value.`);
+                if (results.stderr) {
+                    tracer(results.stderr);
+                }
+            }
+            return undefined;
+        }
+        let lines = stdout.trim().split(/\r?\n/);
+        for (let line of lines) {
+            try {
+                let yarn = JSON.parse(line);
+                if (yarn.type === 'log') {
+                    return path.join(yarn.data, 'node_modules');
+                }
+            }
+            catch (e) {
+                // Do nothing. Ignore the line
+            }
+        }
+        return undefined;
+    }
+    catch (err) {
+        return undefined;
+    }
+    finally {
+        process.removeListener('SIGPIPE', handler);
+    }
+}
+exports.resolveGlobalYarnPath = resolveGlobalYarnPath;
+var FileSystem;
+(function (FileSystem) {
+    let _isCaseSensitive = undefined;
+    function isCaseSensitive() {
+        if (_isCaseSensitive !== void 0) {
+            return _isCaseSensitive;
+        }
+        if (process.platform === 'win32') {
+            _isCaseSensitive = false;
+        }
+        else {
+            // convert current file name to upper case / lower case and check if file exists
+            // (guards against cases when name is already all uppercase or lowercase)
+            _isCaseSensitive = !fs.existsSync(__filename.toUpperCase()) || !fs.existsSync(__filename.toLowerCase());
+        }
+        return _isCaseSensitive;
+    }
+    FileSystem.isCaseSensitive = isCaseSensitive;
+    function isParent(parent, child) {
+        if (isCaseSensitive()) {
+            return path.normalize(child).indexOf(path.normalize(parent)) === 0;
+        }
+        else {
+            return path.normalize(child).toLowerCase().indexOf(path.normalize(parent).toLowerCase()) === 0;
+        }
+    }
+    FileSystem.isParent = isParent;
+})(FileSystem = exports.FileSystem || (exports.FileSystem = {}));
+function resolveModulePath(workspaceRoot, moduleName, nodePath, tracer) {
+    if (nodePath) {
+        if (!path.isAbsolute(nodePath)) {
+            nodePath = path.join(workspaceRoot, nodePath);
+        }
+        return resolve(moduleName, nodePath, nodePath, tracer).then((value) => {
+            if (FileSystem.isParent(nodePath, value)) {
+                return value;
+            }
+            else {
+                return Promise.reject(new Error(`Failed to load ${moduleName} from node path location.`));
+            }
+        }).then(undefined, (_error) => {
+            return resolve(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+        });
+    }
+    else {
+        return resolve(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+    }
+}
+exports.resolveModulePath = resolveModulePath;

node_modules/vscode-languageserver/lib/node/main.d.ts

@@ -0,0 +1,61 @@
+/// <reference path="../../typings/thenable.d.ts" />
+/// <reference types="node" />
+import { Connection, _, _Connection, Features } from '../common/server';
+import * as fm from './files';
+import { ConnectionStrategy, ConnectionOptions, MessageReader, MessageWriter } from 'vscode-languageserver-protocol/node';
+export * from 'vscode-languageserver-protocol/node';
+export * from '../common/api';
+export declare namespace Files {
+    let uriToFilePath: typeof fm.uriToFilePath;
+    let resolveGlobalNodePath: typeof fm.resolveGlobalNodePath;
+    let resolveGlobalYarnPath: typeof fm.resolveGlobalYarnPath;
+    let resolve: typeof fm.resolve;
+    let resolveModulePath: typeof fm.resolveModulePath;
+}
+/**
+ * Creates a new connection based on the processes command line arguments:
+ *
+ * @param options An optional connection strategy or connection options to control additional settings
+ */
+export declare function createConnection(options?: ConnectionStrategy | ConnectionOptions): Connection;
+/**
+ * Creates a new connection using a the given streams.
+ *
+ * @param inputStream The stream to read messages from.
+ * @param outputStream The stream to write messages to.
+ * @param options An optional connection strategy or connection options to control additional settings
+ * @return A {@link Connection connection}
+ */
+export declare function createConnection(inputStream: NodeJS.ReadableStream, outputStream: NodeJS.WritableStream, options?: ConnectionStrategy | ConnectionOptions): Connection;
+/**
+ * Creates a new connection.
+ *
+ * @param reader The message reader to read messages from.
+ * @param writer The message writer to write message to.
+ * @param options An optional connection strategy or connection options to control additional settings
+ */
+export declare function createConnection(reader: MessageReader, writer: MessageWriter, options?: ConnectionStrategy | ConnectionOptions): Connection;
+/**
+ * Creates a new connection based on the processes command line arguments. The new connection surfaces proposed API
+ *
+ * @param factories: the factories to use to implement the proposed API
+ * @param options An optional connection strategy or connection options to control additional settings
+ */
+export declare function createConnection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _, PNotebooks = _>(factories: Features<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>, options?: ConnectionStrategy | ConnectionOptions): _Connection<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>;
+/**
+ * Creates a new connection using a the given streams.
+ *
+ * @param inputStream The stream to read messages from.
+ * @param outputStream The stream to write messages to.
+ * @param options An optional connection strategy or connection options to control additional settings
+ * @return A {@link Connection connection}
+ */
+export declare function createConnection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _, PNotebooks = _>(factories: Features<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>, inputStream: NodeJS.ReadableStream, outputStream: NodeJS.WritableStream, options?: ConnectionStrategy | ConnectionOptions): _Connection<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>;
+/**
+ * Creates a new connection.
+ *
+ * @param reader The message reader to read messages from.
+ * @param writer The message writer to write message to.
+ * @param options An optional connection strategy or connection options to control additional settings
+ */
+export declare function createConnection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PWindow = _, PWorkspace = _, PLanguages = _, PNotebooks = _>(factories: Features<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>, reader: MessageReader, writer: MessageWriter, options?: ConnectionStrategy | ConnectionOptions): _Connection<PConsole, PTracer, PTelemetry, PClient, PWindow, PWorkspace, PLanguages, PNotebooks>;

node_modules/vscode-languageserver/lib/node/main.js

@@ -0,0 +1,211 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+/// <reference path="../../typings/thenable.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = exports.Files = void 0;
+const Is = require("../common/utils/is");
+const server_1 = require("../common/server");
+const fm = require("./files");
+const node_1 = require("vscode-languageserver-protocol/node");
+__exportStar(require("vscode-languageserver-protocol/node"), exports);
+__exportStar(require("../common/api"), exports);
+var Files;
+(function (Files) {
+    Files.uriToFilePath = fm.uriToFilePath;
+    Files.resolveGlobalNodePath = fm.resolveGlobalNodePath;
+    Files.resolveGlobalYarnPath = fm.resolveGlobalYarnPath;
+    Files.resolve = fm.resolve;
+    Files.resolveModulePath = fm.resolveModulePath;
+})(Files = exports.Files || (exports.Files = {}));
+let _protocolConnection;
+function endProtocolConnection() {
+    if (_protocolConnection === undefined) {
+        return;
+    }
+    try {
+        _protocolConnection.end();
+    }
+    catch (_err) {
+        // Ignore. The client process could have already
+        // did and we can't send an end into the connection.
+    }
+}
+let _shutdownReceived = false;
+let exitTimer = undefined;
+function setupExitTimer() {
+    const argName = '--clientProcessId';
+    function runTimer(value) {
+        try {
+            let processId = parseInt(value);
+            if (!isNaN(processId)) {
+                exitTimer = setInterval(() => {
+                    try {
+                        process.kill(processId, 0);
+                    }
+                    catch (ex) {
+                        // Parent process doesn't exist anymore. Exit the server.
+                        endProtocolConnection();
+                        process.exit(_shutdownReceived ? 0 : 1);
+                    }
+                }, 3000);
+            }
+        }
+        catch (e) {
+            // Ignore errors;
+        }
+    }
+    for (let i = 2; i < process.argv.length; i++) {
+        let arg = process.argv[i];
+        if (arg === argName && i + 1 < process.argv.length) {
+            runTimer(process.argv[i + 1]);
+            return;
+        }
+        else {
+            let args = arg.split('=');
+            if (args[0] === argName) {
+                runTimer(args[1]);
+            }
+        }
+    }
+}
+setupExitTimer();
+const watchDog = {
+    initialize: (params) => {
+        const processId = params.processId;
+        if (Is.number(processId) && exitTimer === undefined) {
+            // We received a parent process id. Set up a timer to periodically check
+            // if the parent is still alive.
+            setInterval(() => {
+                try {
+                    process.kill(processId, 0);
+                }
+                catch (ex) {
+                    // Parent process doesn't exist anymore. Exit the server.
+                    process.exit(_shutdownReceived ? 0 : 1);
+                }
+            }, 3000);
+        }
+    },
+    get shutdownReceived() {
+        return _shutdownReceived;
+    },
+    set shutdownReceived(value) {
+        _shutdownReceived = value;
+    },
+    exit: (code) => {
+        endProtocolConnection();
+        process.exit(code);
+    }
+};
+function createConnection(arg1, arg2, arg3, arg4) {
+    let factories;
+    let input;
+    let output;
+    let options;
+    if (arg1 !== void 0 && arg1.__brand === 'features') {
+        factories = arg1;
+        arg1 = arg2;
+        arg2 = arg3;
+        arg3 = arg4;
+    }
+    if (node_1.ConnectionStrategy.is(arg1) || node_1.ConnectionOptions.is(arg1)) {
+        options = arg1;
+    }
+    else {
+        input = arg1;
+        output = arg2;
+        options = arg3;
+    }
+    return _createConnection(input, output, options, factories);
+}
+exports.createConnection = createConnection;
+function _createConnection(input, output, options, factories) {
+    if (!input && !output && process.argv.length > 2) {
+        let port = void 0;
+        let pipeName = void 0;
+        let argv = process.argv.slice(2);
+        for (let i = 0; i < argv.length; i++) {
+            let arg = argv[i];
+            if (arg === '--node-ipc') {
+                input = new node_1.IPCMessageReader(process);
+                output = new node_1.IPCMessageWriter(process);
+                break;
+            }
+            else if (arg === '--stdio') {
+                input = process.stdin;
+                output = process.stdout;
+                break;
+            }
+            else if (arg === '--socket') {
+                port = parseInt(argv[i + 1]);
+                break;
+            }
+            else if (arg === '--pipe') {
+                pipeName = argv[i + 1];
+                break;
+            }
+            else {
+                var args = arg.split('=');
+                if (args[0] === '--socket') {
+                    port = parseInt(args[1]);
+                    break;
+                }
+                else if (args[0] === '--pipe') {
+                    pipeName = args[1];
+                    break;
+                }
+            }
+        }
+        if (port) {
+            let transport = (0, node_1.createServerSocketTransport)(port);
+            input = transport[0];
+            output = transport[1];
+        }
+        else if (pipeName) {
+            let transport = (0, node_1.createServerPipeTransport)(pipeName);
+            input = transport[0];
+            output = transport[1];
+        }
+    }
+    var commandLineMessage = 'Use arguments of createConnection or set command line parameters: \'--node-ipc\', \'--stdio\' or \'--socket={number}\'';
+    if (!input) {
+        throw new Error('Connection input stream is not set. ' + commandLineMessage);
+    }
+    if (!output) {
+        throw new Error('Connection output stream is not set. ' + commandLineMessage);
+    }
+    // Backwards compatibility
+    if (Is.func(input.read) && Is.func(input.on)) {
+        let inputStream = input;
+        inputStream.on('end', () => {
+            endProtocolConnection();
+            process.exit(_shutdownReceived ? 0 : 1);
+        });
+        inputStream.on('close', () => {
+            endProtocolConnection();
+            process.exit(_shutdownReceived ? 0 : 1);
+        });
+    }
+    const connectionFactory = (logger) => {
+        const result = (0, node_1.createProtocolConnection)(input, output, logger, options);
+        return result;
+    };
+    return (0, server_1.createConnection)(connectionFactory, watchDog, factories);
+}

node_modules/vscode-languageserver/lib/node/resolve.d.ts

@@ -0,0 +1,6 @@
+interface Message {
+    command: string;
+    success?: boolean;
+    args?: any;
+    result?: any;
+}

node_modules/vscode-languageserver/lib/node/resolve.js

@@ -0,0 +1,19 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+process.on('message', (message) => {
+    if (message.command === 'exit') {
+        process.exit(0);
+    }
+    else if (message.command === 'resolve') {
+        try {
+            let result = require.resolve(message.args);
+            process.send({ command: 'resolve', success: true, result: result });
+        }
+        catch (err) {
+            process.send({ command: 'resolve', success: false });
+        }
+    }
+});

node_modules/vscode-languageserver/node.cmd

@@ -0,0 +1,5 @@
+@echo off
+REM This file is necessary to ensure that under Windows we don't
+REM run the node.js file in the Windows Script Host when using
+REM node in packakge.json scripts. See also PATHEXT setting
+node.exe %*

node_modules/vscode-languageserver/node.d.ts

@@ -0,0 +1,6 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+
+export * from './lib/node/main';

node_modules/vscode-languageserver/node.js

@@ -0,0 +1,7 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+'use strict';
+
+module.exports = require('./lib/node/main');

node_modules/vscode-languageserver/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "vscode-languageserver",
+	"description": "Language server implementation for node",
+	"version": "8.1.0",
+	"author": "Microsoft Corporation",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
+		"directory": "server"
+	},
+	"bugs": {
+		"url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
+	},
+	"main": "./lib/node/main.js",
+	"browser": {
+		"./lib/node/main.js": "./lib/browser/main.js"
+	},
+	"typings": "./lib/common/api.d.ts",
+	"bin": {
+		"installServerIntoExtension": "./bin/installServerIntoExtension"
+	},
+	"devDependencies": {
+		"vscode-languageserver-textdocument": "1.0.9"
+	},
+	"dependencies": {
+		"vscode-languageserver-protocol": "3.17.3"
+	},
+	"scripts": {
+		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
+		"prepack": "npm run all:publish",
+		"compile": "node ../build/bin/tsc -b ./tsconfig.json",
+		"watch": "node ../build/bin/tsc -b ./tsconfig.watch.json -w",
+		"clean": "node ../node_modules/rimraf/bin.js lib",
+		"lint": "node ../node_modules/eslint/bin/eslint.js --ext ts src",
+		"test": "node ../node_modules/mocha/bin/_mocha",
+		"all": "npm run clean && npm run compile && npm run lint && npm test",
+		"compile:publish": "node ../build/bin/tsc -b ./tsconfig.publish.json",
+		"all:publish": "git clean -xfd . && npm install && npm run compile:publish && npm run lint && npm test",
+		"preversion": "npm test"
+	}
+}

node_modules/vscode-languageserver/thirdpartynotices.txt

@@ -0,0 +1,84 @@
+NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+This software incorporates material from third parties.
+Microsoft makes certain open source code available at https://3rdpartysource.microsoft.com,
+or you may send a check or money order for US $5.00, including the product name,
+the open source component name, platform, and version number, to:
+
+Source Code Compliance Team
+Microsoft Corporation
+One Microsoft Way
+Redmond, WA 98052
+USA
+
+Notwithstanding any other terms, you may reverse engineer this software to the extent
+required to debug changes to any libraries licensed under the GNU Lesser General Public License.
+
+
+---------------------------------------------------------
+
+vscode-jsonrpc - MIT
+https://github.com/Microsoft/vscode-languageserver-node#readme
+
+Copyright (c) Microsoft Corporation.
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+---------------------------------------------------------
+
+---------------------------------------------------------
+
+vscode-languageserver-protocol - MIT
+https://github.com/Microsoft/vscode-languageserver-node#readme
+
+Copyright (c) TypeFox and others.
+Copyright (c) Microsoft Corporation.
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+---------------------------------------------------------
+
+---------------------------------------------------------
+
+vscode-languageserver-types - MIT
+https://github.com/Microsoft/vscode-languageserver-node#readme
+
+Copyright (c) Microsoft Corporation.
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+---------------------------------------------------------

node_modules/vscode-languageserver/typings/thenable.d.ts

@@ -0,0 +1,5 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+interface Thenable<T> extends PromiseLike<T> { }