initial commit

node_modules/vscode-languageserver-protocol/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-protocol/README.md

@@ -0,0 +1,16 @@
+# VSCode Language Server - Protocol Module
+
+[![NPM Version](https://img.shields.io/npm/v/vscode-languageserver-protocol.svg)](https://npmjs.org/package/vscode-languageclient)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-languageserver-protocol.svg)](https://npmjs.org/package/vscode-languageclient)
+[![Build Status](https://travis-ci.org/Microsoft/vscode-languageserver-node.svg?branch=master)](https://travis-ci.org/Microsoft/vscode-languageserver-node)
+
+This npm module is a tool independent implementation of the language server protocol and can be used in any type of node application.
+
+See [here](https://github.com/Microsoft/language-server-protocol) for a detailed documentation on the language server protocol.
+
+## 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-protocol/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-protocol/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-protocol/lib/browser/main.d.ts

@@ -0,0 +1,4 @@
+import { MessageReader, MessageWriter, Logger, ConnectionStrategy, ConnectionOptions, ProtocolConnection } from '../common/api';
+export * from 'vscode-jsonrpc/browser';
+export * from '../common/api';
+export declare function createProtocolConnection(reader: MessageReader, writer: MessageWriter, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): ProtocolConnection;

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

@@ -0,0 +1,25 @@
+"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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.createProtocolConnection = void 0;
+const browser_1 = require("vscode-jsonrpc/browser");
+__exportStar(require("vscode-jsonrpc/browser"), exports);
+__exportStar(require("../common/api"), exports);
+function createProtocolConnection(reader, writer, logger, options) {
+    return browser_1.createMessageConnection(reader, writer, logger, options);
+}
+exports.createProtocolConnection = createProtocolConnection;
+//# sourceMappingURL=main.js.map

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

@@ -0,0 +1,26 @@
+import type { integer } from 'vscode-languageserver-types';
+export * from 'vscode-jsonrpc';
+export * from 'vscode-languageserver-types';
+export * from './messages';
+export * from './protocol';
+export { ProtocolConnection, createProtocolConnection } from './connection';
+export declare namespace LSPErrorCodes {
+    /**
+    * This is the start range of LSP reserved error codes.
+    * It doesn't denote a real error code.
+    *
+    * @since 3.16.0
+    */
+    const lspReservedErrorRangeStart: integer;
+    const ContentModified: integer;
+    const RequestCancelled: integer;
+    /**
+    * This is the end range of LSP reserved error codes.
+    * It doesn't denote a real error code.
+    *
+    * @since 3.16.0
+    */
+    const lspReservedErrorRangeEnd: integer;
+}
+export declare namespace Proposed {
+}

node_modules/vscode-languageserver-protocol/lib/common/api.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.
+ * ------------------------------------------------------------------------------------------ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.LSPErrorCodes = exports.createProtocolConnection = void 0;
+__exportStar(require("vscode-jsonrpc"), exports);
+__exportStar(require("vscode-languageserver-types"), exports);
+__exportStar(require("./messages"), exports);
+__exportStar(require("./protocol"), exports);
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "createProtocolConnection", { enumerable: true, get: function () { return connection_1.createProtocolConnection; } });
+var LSPErrorCodes;
+(function (LSPErrorCodes) {
+    /**
+    * This is the start range of LSP reserved error codes.
+    * It doesn't denote a real error code.
+    *
+    * @since 3.16.0
+    */
+    LSPErrorCodes.lspReservedErrorRangeStart = -32899;
+    LSPErrorCodes.ContentModified = -32801;
+    LSPErrorCodes.RequestCancelled = -32800;
+    /**
+    * This is the end range of LSP reserved error codes.
+    * It doesn't denote a real error code.
+    *
+    * @since 3.16.0
+    */
+    LSPErrorCodes.lspReservedErrorRangeEnd = -32800;
+})(LSPErrorCodes = exports.LSPErrorCodes || (exports.LSPErrorCodes = {}));
+//# sourceMappingURL=api.js.map

node_modules/vscode-languageserver-protocol/lib/common/connection.d.ts

@@ -0,0 +1,163 @@
+import { Message, NotificationMessage, CancellationToken, RequestHandler0, RequestHandler, GenericRequestHandler, NotificationHandler0, NotificationHandler, GenericNotificationHandler, ProgressType, Trace, Tracer, TraceOptions, Disposable, Event, MessageReader, MessageWriter, Logger, ConnectionStrategy, ConnectionOptions, RequestType0, RequestType, NotificationType0, NotificationType } from 'vscode-jsonrpc';
+import { ProtocolRequestType, ProtocolRequestType0, ProtocolNotificationType, ProtocolNotificationType0 } from './messages';
+export interface ProtocolConnection {
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param type The type of request to sent.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, token?: CancellationToken): Promise<R>;
+    sendRequest<R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param type The type of request to sent.
+     * @param params The request's parameter.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, params: P, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, E>(type: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R>;
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param method the request's method name.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<R>(method: string, token?: CancellationToken): Promise<R>;
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param method the request's method name.
+     * @param params The request's parameter.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<R>(method: string, param: any, token?: CancellationToken): Promise<R>;
+    /**
+     * Installs a request handler.
+     *
+     * @param type The request type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, handler: RequestHandler0<R, E>): Disposable;
+    onRequest<R, E>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable;
+    /**
+     * Installs a request handler.
+     *
+     * @param type The request type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, handler: RequestHandler<P, R, E>): Disposable;
+    onRequest<P, R, E>(type: RequestType<P, R, E>, handler: RequestHandler<P, R, E>): Disposable;
+    /**
+     * Installs a request handler.
+     *
+     * @param methods The method name to install the handler for.
+     * @param handler The actual handler.
+     */
+    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): Disposable;
+    /**
+     * Sends a notification.
+     *
+     * @param type the notification's type to send.
+     */
+    sendNotification(type: NotificationType0): void;
+    sendNotification<RO>(type: ProtocolNotificationType0<RO>): void;
+    /**
+     * Sends a notification.
+     *
+     * @param type the notification's type to send.
+     * @param params the notification's parameters.
+     */
+    sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params?: P): void;
+    sendNotification<P>(type: NotificationType<P>, params?: P): void;
+    /**
+     * Sends a notification.
+     *
+     * @param method the notification's method name.
+     */
+    sendNotification(method: string): void;
+    /**
+     * Sends a notification.
+     *
+     * @param method the notification's method name.
+     * @param params the notification's parameters.
+     */
+    sendNotification(method: string, params: any): void;
+    /**
+     * Installs a notification handler.
+     *
+     * @param type The notification type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onNotification<RO>(type: ProtocolNotificationType0<RO>, handler: NotificationHandler0): Disposable;
+    onNotification(type: NotificationType0, handler: NotificationHandler0): Disposable;
+    /**
+     * Installs a notification handler.
+     *
+     * @param type The notification type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onNotification<P, RO>(type: ProtocolNotificationType<P, RO>, handler: NotificationHandler<P>): Disposable;
+    onNotification<P>(type: NotificationType<P>, handler: NotificationHandler<P>): Disposable;
+    /**
+     * Installs a notification handler.
+     *
+     * @param methods The method name to install the handler for.
+     * @param handler The actual handler.
+     */
+    onNotification(method: string, handler: GenericNotificationHandler): Disposable;
+    /**
+     * 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): void;
+    /**
+     * Enables tracing mode for the connection.
+     */
+    trace(value: Trace, tracer: Tracer, sendNotification?: boolean): void;
+    trace(value: Trace, tracer: Tracer, traceOptions?: TraceOptions): void;
+    /**
+     * An event emitter firing when an error occurs on the connection.
+     */
+    onError: Event<[Error, Message | undefined, number | undefined]>;
+    /**
+     * An event emitter firing when the connection got closed.
+     */
+    onClose: Event<void>;
+    /**
+     * An event emiiter firing when the connection receives a notification that is not
+     * handled.
+     */
+    onUnhandledNotification: Event<NotificationMessage>;
+    /**
+     * An event emitter firing when the connection got disposed.
+     */
+    onDispose: Event<void>;
+    /**
+     * Ends the connection.
+     */
+    end(): void;
+    /**
+     * Actively disposes the connection.
+     */
+    dispose(): void;
+    /**
+     * Turns the connection into listening mode
+     */
+    listen(): void;
+}
+export declare function createProtocolConnection(input: MessageReader, output: MessageWriter, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): ProtocolConnection;

node_modules/vscode-languageserver-protocol/lib/common/connection.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.createProtocolConnection = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+function createProtocolConnection(input, output, logger, options) {
+    if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
+        options = { connectionStrategy: options };
+    }
+    return vscode_jsonrpc_1.createMessageConnection(input, output, logger, options);
+}
+exports.createProtocolConnection = createProtocolConnection;
+//# sourceMappingURL=connection.js.map

node_modules/vscode-languageserver-protocol/lib/common/messages.d.ts

@@ -0,0 +1,44 @@
+import { RequestType, RequestType0, NotificationType, NotificationType0, ProgressType, _EM } from 'vscode-jsonrpc';
+export declare class RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ____: [RO, _EM] | undefined;
+    readonly method: string;
+    constructor(method: string);
+}
+export declare class ProtocolRequestType0<R, PR, E, RO> extends RequestType0<R, E> implements ProgressType<PR>, RegistrationType<RO> {
+    /**
+     * Clients must not use these properties. They are here to ensure correct typing.
+     * in TypeScript
+     */
+    readonly ___: [PR, RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    readonly _pr: PR | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolRequestType<P, R, PR, E, RO> extends RequestType<P, R, E> implements ProgressType<PR>, RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [PR, RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    readonly _pr: PR | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolNotificationType0<RO> extends NotificationType0 implements RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolNotificationType<P, RO> extends NotificationType<P> implements RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    constructor(method: string);
+}

node_modules/vscode-languageserver-protocol/lib/common/messages.js

@@ -0,0 +1,42 @@
+"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.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+class RegistrationType {
+    constructor(method) {
+        this.method = method;
+    }
+}
+exports.RegistrationType = RegistrationType;
+class ProtocolRequestType0 extends vscode_jsonrpc_1.RequestType0 {
+    constructor(method) {
+        super(method);
+    }
+}
+exports.ProtocolRequestType0 = ProtocolRequestType0;
+class ProtocolRequestType extends vscode_jsonrpc_1.RequestType {
+    constructor(method) {
+        super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+}
+exports.ProtocolRequestType = ProtocolRequestType;
+class ProtocolNotificationType0 extends vscode_jsonrpc_1.NotificationType0 {
+    constructor(method) {
+        super(method);
+    }
+}
+exports.ProtocolNotificationType0 = ProtocolNotificationType0;
+class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType {
+    constructor(method) {
+        super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+}
+exports.ProtocolNotificationType = ProtocolNotificationType;
+// let x: ProtocolNotificationType<number, { value: number}>;
+// let y: ProtocolNotificationType<string, { value: number}>;
+// x = y;
+//# sourceMappingURL=messages.js.map

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

@@ -0,0 +1,83 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * @since 3.16.0
+ */
+export interface CallHierarchyClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * Call hierarchy options used during static registration.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Call hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, CallHierarchyOptions, StaticRegistrationOptions {
+}
+/**
+ * The parameter of a `textDocument/prepareCallHierarchy` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+/**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to a incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0
+ */
+export declare namespace CallHierarchyPrepareRequest {
+    const method: 'textDocument/prepareCallHierarchy';
+    const type: ProtocolRequestType<CallHierarchyPrepareParams, CallHierarchyItem[] | null, never, void, CallHierarchyRegistrationOptions>;
+    type HandlerSignature = RequestHandler<CallHierarchyPrepareParams, CallHierarchyItem[] | null, void>;
+}
+/**
+ * The parameter of a `callHierarchy/incomingCalls` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyIncomingCallsParams extends WorkDoneProgressParams, PartialResultParams {
+    item: CallHierarchyItem;
+}
+/**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+export declare namespace CallHierarchyIncomingCallsRequest {
+    const method: 'callHierarchy/incomingCalls';
+    const type: ProtocolRequestType<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, CallHierarchyIncomingCall[], void, void>;
+    type HandlerSignature = RequestHandler<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, void>;
+}
+/**
+ * The parameter of a `callHierarchy/outgoingCalls` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOutgoingCallsParams extends WorkDoneProgressParams, PartialResultParams {
+    item: CallHierarchyItem;
+}
+/**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+export declare namespace CallHierarchyOutgoingCallsRequest {
+    const method: 'callHierarchy/outgoingCalls';
+    const type: ProtocolRequestType<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, CallHierarchyOutgoingCall[], void, void>;
+    type HandlerSignature = RequestHandler<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, void>;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) TypeFox and others. 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.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to a incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0
+ */
+var CallHierarchyPrepareRequest;
+(function (CallHierarchyPrepareRequest) {
+    CallHierarchyPrepareRequest.method = 'textDocument/prepareCallHierarchy';
+    CallHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest.method);
+})(CallHierarchyPrepareRequest = exports.CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = {}));
+/**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+var CallHierarchyIncomingCallsRequest;
+(function (CallHierarchyIncomingCallsRequest) {
+    CallHierarchyIncomingCallsRequest.method = 'callHierarchy/incomingCalls';
+    CallHierarchyIncomingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest.method);
+})(CallHierarchyIncomingCallsRequest = exports.CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = {}));
+/**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+var CallHierarchyOutgoingCallsRequest;
+(function (CallHierarchyOutgoingCallsRequest) {
+    CallHierarchyOutgoingCallsRequest.method = 'callHierarchy/outgoingCalls';
+    CallHierarchyOutgoingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest.method);
+})(CallHierarchyOutgoingCallsRequest = exports.CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = {}));
+//# sourceMappingURL=protocol.callHierarchy.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.d.ts

@@ -0,0 +1,63 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier, Range, Color, ColorInformation, ColorPresentation } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+export interface DocumentColorClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `DocumentColorRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface DocumentColorOptions extends WorkDoneProgressOptions {
+}
+export interface DocumentColorRegistrationOptions extends TextDocumentRegistrationOptions, StaticRegistrationOptions, DocumentColorOptions {
+}
+/**
+ * Parameters for a [DocumentColorRequest](#DocumentColorRequest).
+ */
+export interface DocumentColorParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type [DocumentColorParams](#DocumentColorParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace DocumentColorRequest {
+    const method: 'textDocument/documentColor';
+    const type: ProtocolRequestType<DocumentColorParams, ColorInformation[], ColorInformation[], void, DocumentColorRegistrationOptions>;
+    type HandlerSignature = RequestHandler<DocumentColorParams, ColorInformation[], void>;
+}
+/**
+ * Parameters for a [ColorPresentationRequest](#ColorPresentationRequest).
+ */
+export interface ColorPresentationParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The color to request presentations for.
+     */
+    color: Color;
+    /**
+     * The range where the color would be inserted. Serves as a context.
+     */
+    range: Range;
+}
+/**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace ColorPresentationRequest {
+    const type: ProtocolRequestType<ColorPresentationParams, ColorPresentation[], ColorPresentation[], void, WorkDoneProgressOptions & TextDocumentRegistrationOptions>;
+    type HandlerSignature = RequestHandler<ColorPresentationParams, ColorPresentation[], void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.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.ColorPresentationRequest = exports.DocumentColorRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type [DocumentColorParams](#DocumentColorParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+var DocumentColorRequest;
+(function (DocumentColorRequest) {
+    DocumentColorRequest.method = 'textDocument/documentColor';
+    DocumentColorRequest.type = new messages_1.ProtocolRequestType(DocumentColorRequest.method);
+})(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {}));
+/**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+var ColorPresentationRequest;
+(function (ColorPresentationRequest) {
+    ColorPresentationRequest.type = new messages_1.ProtocolRequestType('textDocument/colorPresentation');
+})(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {}));
+//# sourceMappingURL=protocol.colorProvider.js.map

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

@@ -0,0 +1,46 @@
+import { RequestHandler, HandlerResult, CancellationToken } from 'vscode-jsonrpc';
+import { ProtocolRequestType } from './messages';
+import { PartialResultParams } from './protocol';
+export interface ConfigurationClientCapabilities {
+    /**
+     * The workspace client capabilities
+     */
+    workspace?: {
+        /**
+         * The client supports `workspace/configuration` requests.
+         *
+         * @since 3.6.0
+         */
+        configuration?: boolean;
+    };
+}
+/**
+ * The 'workspace/configuration' request is sent from the server to the client to fetch a certain
+ * configuration setting.
+ *
+ * This pull model replaces the old push model were the client signaled configuration change via an
+ * event. If the server still needs to react to configuration changes (since the server caches the
+ * result of `workspace/configuration` requests) the server should register for an empty configuration
+ * change event and empty the cache if such an event is received.
+ */
+export declare namespace ConfigurationRequest {
+    const type: ProtocolRequestType<ConfigurationParams & PartialResultParams, any[], never, void, void>;
+    type HandlerSignature = RequestHandler<ConfigurationParams, any[], void>;
+    type MiddlewareSignature = (params: ConfigurationParams, token: CancellationToken, next: HandlerSignature) => HandlerResult<any[], void>;
+}
+export interface ConfigurationItem {
+    /**
+     * The scope to get the configuration section for.
+     */
+    scopeUri?: string;
+    /**
+     * The configuration section asked for.
+     */
+    section?: string;
+}
+/**
+ * The parameters of a configuration request.
+ */
+export interface ConfigurationParams {
+    items: ConfigurationItem[];
+}

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

@@ -0,0 +1,22 @@
+"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.ConfigurationRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * The 'workspace/configuration' request is sent from the server to the client to fetch a certain
+ * configuration setting.
+ *
+ * This pull model replaces the old push model were the client signaled configuration change via an
+ * event. If the server still needs to react to configuration changes (since the server caches the
+ * result of `workspace/configuration` requests) the server should register for an empty configuration
+ * change event and empty the cache if such an event is received.
+ */
+var ConfigurationRequest;
+(function (ConfigurationRequest) {
+    ConfigurationRequest.type = new messages_1.ProtocolRequestType('workspace/configuration');
+})(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {}));
+//# sourceMappingURL=protocol.configuration.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.d.ts

@@ -0,0 +1,37 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Declaration, DeclarationLink, Location, LocationLink } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * @since 3.14.0
+ */
+export interface DeclarationClientCapabilities {
+    /**
+     * Whether declaration supports dynamic registration. If this is set to `true`
+     * the client supports the new `DeclarationRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports additional metadata in the form of declaration links.
+     */
+    linkSupport?: boolean;
+}
+export interface DeclarationOptions extends WorkDoneProgressOptions {
+}
+export interface DeclarationRegistrationOptions extends DeclarationOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+export interface DeclarationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Declaration](#Declaration)
+ * or a typed array of [DeclarationLink](#DeclarationLink) or a Thenable that resolves
+ * to such.
+ */
+export declare namespace DeclarationRequest {
+    const method: 'textDocument/declaration';
+    const type: ProtocolRequestType<DeclarationParams, Location | Location[] | LocationLink[] | null, Location[] | LocationLink[], void, DeclarationRegistrationOptions>;
+    type HandlerSignature = RequestHandler<DeclarationParams, Declaration | DeclarationLink[] | null, void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js

@@ -0,0 +1,23 @@
+"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.DeclarationRequest = void 0;
+const messages_1 = require("./messages");
+// @ts-ignore: to avoid inlining LocatioLink as dynamic import
+let __noDynamicImport;
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Declaration](#Declaration)
+ * or a typed array of [DeclarationLink](#DeclarationLink) or a Thenable that resolves
+ * to such.
+ */
+var DeclarationRequest;
+(function (DeclarationRequest) {
+    DeclarationRequest.method = 'textDocument/declaration';
+    DeclarationRequest.type = new messages_1.ProtocolRequestType(DeclarationRequest.method);
+})(DeclarationRequest = exports.DeclarationRequest || (exports.DeclarationRequest = {}));
+//# sourceMappingURL=protocol.declaration.js.map

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

@@ -0,0 +1,293 @@
+import { NotificationHandler, RequestHandler } from 'vscode-jsonrpc';
+import { WorkspaceEdit } from 'vscode-languageserver-types';
+import { ProtocolNotificationType, ProtocolRequestType } from './messages';
+/**
+ * Options for notifications/requests for user operations on files.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationOptions {
+    /**
+    * The server is interested in didCreateFiles notifications.
+    */
+    didCreate?: FileOperationRegistrationOptions;
+    /**
+    * The server is interested in willCreateFiles requests.
+    */
+    willCreate?: FileOperationRegistrationOptions;
+    /**
+    * The server is interested in didRenameFiles notifications.
+    */
+    didRename?: FileOperationRegistrationOptions;
+    /**
+    * The server is interested in willRenameFiles requests.
+    */
+    willRename?: FileOperationRegistrationOptions;
+    /**
+    * The server is interested in didDeleteFiles file notifications.
+    */
+    didDelete?: FileOperationRegistrationOptions;
+    /**
+    * The server is interested in willDeleteFiles file requests.
+    */
+    willDelete?: FileOperationRegistrationOptions;
+}
+/**
+ * The options to register for file operations.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationRegistrationOptions {
+    /**
+     * The actual filters.
+     */
+    filters: FileOperationFilter[];
+}
+/**
+ * A pattern kind describing if a glob pattern matches a file a folder or
+ * both.
+ *
+ * @since 3.16.0
+ */
+export declare namespace FileOperationPatternKind {
+    /**
+     * The pattern matches a file only.
+     */
+    const file: 'file';
+    /**
+     * The pattern matches a folder only.
+     */
+    const folder: 'folder';
+}
+export declare type FileOperationPatternKind = 'file' | 'folder';
+/**
+ * Matching options for the file operation pattern.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationPatternOptions {
+    /**
+     * The pattern should be matched ignoring casing.
+     */
+    ignoreCase?: boolean;
+}
+/**
+ * A pattern to describe in which file operation requests or notifications
+ * the server is interested in.
+ *
+ * @since 3.16.0
+ */
+interface FileOperationPattern {
+    /**
+     * The glob pattern to match. Glob patterns can have the following syntax:
+     * - `*` to match one or more characters in a path segment
+     * - `?` to match on one character in a path segment
+     * - `**` to match any number of path segments, including none
+     * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+     * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+     * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+     */
+    glob: string;
+    /**
+     * Whether to match files or folders with this pattern.
+     *
+     * Matches both if undefined.
+     */
+    matches?: FileOperationPatternKind;
+    /**
+     * Additional options used during matching.
+     */
+    options?: FileOperationPatternOptions;
+}
+/**
+ * A filter to describe in which file operation requests or notifications
+ * the server is interested in.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationFilter {
+    /**
+     * A Uri like `file` or `untitled`.
+     */
+    scheme?: string;
+    /**
+     * The actual file operation pattern.
+     */
+    pattern: FileOperationPattern;
+}
+/**
+ * Capabilities relating to events from file operations by the user in the client.
+ *
+ * These events do not come from the file system, they come from user operations
+ * like renaming a file in the UI.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationClientCapabilities {
+    /**
+     * Whether the client supports dynamic registration for file requests/notifications.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client has support for sending didCreateFiles notifications.
+     */
+    didCreate?: boolean;
+    /**
+     * The client has support for willCreateFiles requests.
+     */
+    willCreate?: boolean;
+    /**
+     * The client has support for sending didRenameFiles notifications.
+     */
+    didRename?: boolean;
+    /**
+     * The client has support for willRenameFiles requests.
+     */
+    willRename?: boolean;
+    /**
+     * The client has support for sending didDeleteFiles notifications.
+     */
+    didDelete?: boolean;
+    /**
+     * The client has support for willDeleteFiles requests.
+     */
+    willDelete?: boolean;
+}
+/**
+ * The parameters sent in file create requests/notifications.
+ *
+ * @since 3.16.0
+ */
+export interface CreateFilesParams {
+    /**
+     * An array of all files/folders created in this operation.
+     */
+    files: FileCreate[];
+}
+/**
+ * Represents information on a file/folder create.
+ *
+ * @since 3.16.0
+ */
+export interface FileCreate {
+    /**
+     * A file:// URI for the location of the file/folder being created.
+     */
+    uri: string;
+}
+/**
+ * The parameters sent in file rename requests/notifications.
+ *
+ * @since 3.16.0
+ */
+export interface RenameFilesParams {
+    /**
+     * An array of all files/folders renamed in this operation. When a folder is renamed, only
+     * the folder will be included, and not its children.
+     */
+    files: FileRename[];
+}
+/**
+ * Represents information on a file/folder rename.
+ *
+ * @since 3.16.0
+ */
+export interface FileRename {
+    /**
+     * A file:// URI for the original location of the file/folder being renamed.
+     */
+    oldUri: string;
+    /**
+     * A file:// URI for the new location of the file/folder being renamed.
+     */
+    newUri: string;
+}
+/**
+ * The parameters sent in file delete requests/notifications.
+ *
+ * @since 3.16.0
+ */
+export interface DeleteFilesParams {
+    /**
+     * An array of all files/folders deleted in this operation.
+     */
+    files: FileDelete[];
+}
+/**
+ * Represents information on a file/folder delete.
+ *
+ * @since 3.16.0
+ */
+export interface FileDelete {
+    /**
+     * A file:// URI for the location of the file/folder being deleted.
+     */
+    uri: string;
+}
+/**
+ * The will create files request is sent from the client to the server before files are actually
+ * created as long as the creation is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+export declare namespace WillCreateFilesRequest {
+    const method: 'workspace/willCreateFiles';
+    const type: ProtocolRequestType<CreateFilesParams, WorkspaceEdit | null, never, void, FileOperationRegistrationOptions>;
+    type HandlerSignature = RequestHandler<CreateFilesParams, WorkspaceEdit | undefined | null, void>;
+}
+/**
+ * The did create files notification is sent from the client to the server when
+ * files were created from within the client.
+ *
+ * @since 3.16.0
+ */
+export declare namespace DidCreateFilesNotification {
+    const method: 'workspace/didCreateFiles';
+    const type: ProtocolNotificationType<CreateFilesParams, FileOperationRegistrationOptions>;
+    type HandlerSignature = NotificationHandler<CreateFilesParams>;
+}
+/**
+ * The will rename files request is sent from the client to the server before files are actually
+ * renamed as long as the rename is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+export declare namespace WillRenameFilesRequest {
+    const method: 'workspace/willRenameFiles';
+    const type: ProtocolRequestType<RenameFilesParams, WorkspaceEdit | null, never, void, FileOperationRegistrationOptions>;
+    type HandlerSignature = RequestHandler<RenameFilesParams, WorkspaceEdit | undefined | null, void>;
+}
+/**
+ * The did rename files notification is sent from the client to the server when
+ * files were renamed from within the client.
+ *
+ * @since 3.16.0
+ */
+export declare namespace DidRenameFilesNotification {
+    const method: 'workspace/didRenameFiles';
+    const type: ProtocolNotificationType<RenameFilesParams, FileOperationRegistrationOptions>;
+    type HandlerSignature = NotificationHandler<RenameFilesParams>;
+}
+/**
+ * The will delete files request is sent from the client to the server before files are actually
+ * deleted as long as the deletion is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+export declare namespace DidDeleteFilesNotification {
+    const method: 'workspace/didDeleteFiles';
+    const type: ProtocolNotificationType<DeleteFilesParams, FileOperationRegistrationOptions>;
+    type HandlerSignature = NotificationHandler<DeleteFilesParams>;
+}
+/**
+ * The did delete files notification is sent from the client to the server when
+ * files were deleted from within the client.
+ *
+ * @since 3.16.0
+ */
+export declare namespace WillDeleteFilesRequest {
+    const method: 'workspace/willDeleteFiles';
+    const type: ProtocolRequestType<DeleteFilesParams, WorkspaceEdit | null, never, void, FileOperationRegistrationOptions>;
+    type HandlerSignature = RequestHandler<DeleteFilesParams, WorkspaceEdit | undefined | null, void>;
+}
+export {};

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

@@ -0,0 +1,92 @@
+"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.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0;
+const messages_1 = require("./messages");
+/**
+ * A pattern kind describing if a glob pattern matches a file a folder or
+ * both.
+ *
+ * @since 3.16.0
+ */
+var FileOperationPatternKind;
+(function (FileOperationPatternKind) {
+    /**
+     * The pattern matches a file only.
+     */
+    FileOperationPatternKind.file = 'file';
+    /**
+     * The pattern matches a folder only.
+     */
+    FileOperationPatternKind.folder = 'folder';
+})(FileOperationPatternKind = exports.FileOperationPatternKind || (exports.FileOperationPatternKind = {}));
+/**
+ * The will create files request is sent from the client to the server before files are actually
+ * created as long as the creation is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+var WillCreateFilesRequest;
+(function (WillCreateFilesRequest) {
+    WillCreateFilesRequest.method = 'workspace/willCreateFiles';
+    WillCreateFilesRequest.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest.method);
+})(WillCreateFilesRequest = exports.WillCreateFilesRequest || (exports.WillCreateFilesRequest = {}));
+/**
+ * The did create files notification is sent from the client to the server when
+ * files were created from within the client.
+ *
+ * @since 3.16.0
+ */
+var DidCreateFilesNotification;
+(function (DidCreateFilesNotification) {
+    DidCreateFilesNotification.method = 'workspace/didCreateFiles';
+    DidCreateFilesNotification.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification.method);
+})(DidCreateFilesNotification = exports.DidCreateFilesNotification || (exports.DidCreateFilesNotification = {}));
+/**
+ * The will rename files request is sent from the client to the server before files are actually
+ * renamed as long as the rename is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+var WillRenameFilesRequest;
+(function (WillRenameFilesRequest) {
+    WillRenameFilesRequest.method = 'workspace/willRenameFiles';
+    WillRenameFilesRequest.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest.method);
+})(WillRenameFilesRequest = exports.WillRenameFilesRequest || (exports.WillRenameFilesRequest = {}));
+/**
+ * The did rename files notification is sent from the client to the server when
+ * files were renamed from within the client.
+ *
+ * @since 3.16.0
+ */
+var DidRenameFilesNotification;
+(function (DidRenameFilesNotification) {
+    DidRenameFilesNotification.method = 'workspace/didRenameFiles';
+    DidRenameFilesNotification.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification.method);
+})(DidRenameFilesNotification = exports.DidRenameFilesNotification || (exports.DidRenameFilesNotification = {}));
+/**
+ * The will delete files request is sent from the client to the server before files are actually
+ * deleted as long as the deletion is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+var DidDeleteFilesNotification;
+(function (DidDeleteFilesNotification) {
+    DidDeleteFilesNotification.method = 'workspace/didDeleteFiles';
+    DidDeleteFilesNotification.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification.method);
+})(DidDeleteFilesNotification = exports.DidDeleteFilesNotification || (exports.DidDeleteFilesNotification = {}));
+/**
+ * The did delete files notification is sent from the client to the server when
+ * files were deleted from within the client.
+ *
+ * @since 3.16.0
+ */
+var WillDeleteFilesRequest;
+(function (WillDeleteFilesRequest) {
+    WillDeleteFilesRequest.method = 'workspace/willDeleteFiles';
+    WillDeleteFilesRequest.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest.method);
+})(WillDeleteFilesRequest = exports.WillDeleteFilesRequest || (exports.WillDeleteFilesRequest = {}));
+//# sourceMappingURL=protocol.fileOperations.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.d.ts

@@ -0,0 +1,63 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier, uinteger, FoldingRange } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+export interface FoldingRangeClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration for folding range providers. If this is set to `true`
+     * the client supports the new `FoldingRangeRegistrationOptions` return value for the corresponding server
+     * capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The maximum number of folding ranges that the client prefers to receive per document. The value serves as a
+     * hint, servers are free to follow the limit.
+     */
+    rangeLimit?: uinteger;
+    /**
+     * If set, the client signals that it only supports folding complete lines. If set, client will
+     * ignore specified `startCharacter` and `endCharacter` properties in a FoldingRange.
+     */
+    lineFoldingOnly?: boolean;
+}
+export interface FoldingRangeOptions extends WorkDoneProgressOptions {
+}
+export interface FoldingRangeRegistrationOptions extends TextDocumentRegistrationOptions, FoldingRangeOptions, StaticRegistrationOptions {
+}
+/**
+ * Enum of known range kinds
+ */
+export declare enum FoldingRangeKind {
+    /**
+     * Folding range for a comment
+     */
+    Comment = "comment",
+    /**
+     * Folding range for a imports or includes
+     */
+    Imports = "imports",
+    /**
+     * Folding range for a region (e.g. `#region`)
+     */
+    Region = "region"
+}
+/**
+ * Parameters for a [FoldingRangeRequest](#FoldingRangeRequest).
+ */
+export interface FoldingRangeParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * A request to provide folding ranges in a document. The request's
+ * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the
+ * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace FoldingRangeRequest {
+    const method: 'textDocument/foldingRange';
+    const type: ProtocolRequestType<FoldingRangeParams, FoldingRange[] | null, FoldingRange[], any, FoldingRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<FoldingRangeParams, FoldingRange[] | null, void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.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.FoldingRangeRequest = exports.FoldingRangeKind = void 0;
+const messages_1 = require("./messages");
+/**
+ * Enum of known range kinds
+ */
+var FoldingRangeKind;
+(function (FoldingRangeKind) {
+    /**
+     * Folding range for a comment
+     */
+    FoldingRangeKind["Comment"] = "comment";
+    /**
+     * Folding range for a imports or includes
+     */
+    FoldingRangeKind["Imports"] = "imports";
+    /**
+     * Folding range for a region (e.g. `#region`)
+     */
+    FoldingRangeKind["Region"] = "region";
+})(FoldingRangeKind = exports.FoldingRangeKind || (exports.FoldingRangeKind = {}));
+/**
+ * A request to provide folding ranges in a document. The request's
+ * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the
+ * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable
+ * that resolves to such.
+ */
+var FoldingRangeRequest;
+(function (FoldingRangeRequest) {
+    FoldingRangeRequest.method = 'textDocument/foldingRange';
+    FoldingRangeRequest.type = new messages_1.ProtocolRequestType(FoldingRangeRequest.method);
+})(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {}));
+//# sourceMappingURL=protocol.foldingRange.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.d.ts

@@ -0,0 +1,38 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Definition, DefinitionLink, Location, LocationLink } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * @since 3.6.0
+ */
+export interface ImplementationClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `ImplementationRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports additional metadata in the form of definition links.
+     *
+     * @since 3.14.0
+     */
+    linkSupport?: boolean;
+}
+export interface ImplementationOptions extends WorkDoneProgressOptions {
+}
+export interface ImplementationRegistrationOptions extends TextDocumentRegistrationOptions, ImplementationOptions, StaticRegistrationOptions {
+}
+export interface ImplementationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to resolve the implementation locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+export declare namespace ImplementationRequest {
+    const method: 'textDocument/implementation';
+    const type: ProtocolRequestType<ImplementationParams, Location | Location[] | LocationLink[] | null, Location[] | LocationLink[], void, ImplementationRegistrationOptions>;
+    type HandlerSignature = RequestHandler<ImplementationParams, Definition | DefinitionLink[] | null, void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js

@@ -0,0 +1,22 @@
+"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.ImplementationRequest = void 0;
+const messages_1 = require("./messages");
+// @ts-ignore: to avoid inlining LocatioLink as dynamic import
+let __noDynamicImport;
+/**
+ * A request to resolve the implementation locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+var ImplementationRequest;
+(function (ImplementationRequest) {
+    ImplementationRequest.method = 'textDocument/implementation';
+    ImplementationRequest.type = new messages_1.ProtocolRequestType(ImplementationRequest.method);
+})(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {}));
+//# sourceMappingURL=protocol.implementation.js.map

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

@@ -0,0 +1,755 @@
+"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.DocumentLinkRequest = exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = exports.WorkspaceSymbolRequest = exports.CodeActionResolveRequest = exports.CodeActionRequest = exports.DocumentSymbolRequest = exports.DocumentHighlightRequest = exports.ReferencesRequest = exports.DefinitionRequest = exports.SignatureHelpRequest = exports.SignatureHelpTriggerKind = exports.HoverRequest = exports.CompletionResolveRequest = exports.CompletionRequest = exports.CompletionTriggerKind = exports.PublishDiagnosticsNotification = exports.WatchKind = exports.FileChangeType = exports.DidChangeWatchedFilesNotification = exports.WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentNotification = exports.TextDocumentSaveReason = exports.DidSaveTextDocumentNotification = exports.DidCloseTextDocumentNotification = exports.DidChangeTextDocumentNotification = exports.TextDocumentContentChangeEvent = exports.DidOpenTextDocumentNotification = exports.TextDocumentSyncKind = exports.TelemetryEventNotification = exports.LogMessageNotification = exports.ShowMessageRequest = exports.ShowMessageNotification = exports.MessageType = exports.DidChangeConfigurationNotification = exports.ExitNotification = exports.ShutdownRequest = exports.InitializedNotification = exports.InitializeError = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.DocumentFilter = void 0;
+exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.WillRenameFilesRequest = exports.DidRenameFilesNotification = exports.WillCreateFilesRequest = exports.DidCreateFilesNotification = exports.FileOperationPatternKind = exports.LinkedEditingRangeRequest = exports.ShowDocumentRequest = exports.SemanticTokensRegistrationType = exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.TokenFormat = exports.SemanticTokens = exports.SemanticTokenModifiers = exports.SemanticTokenTypes = exports.CallHierarchyPrepareRequest = exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = exports.SelectionRangeRequest = exports.DeclarationRequest = exports.FoldingRangeRequest = exports.ColorPresentationRequest = exports.DocumentColorRequest = exports.ConfigurationRequest = exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = exports.TypeDefinitionRequest = exports.ImplementationRequest = exports.ApplyWorkspaceEditRequest = exports.ExecuteCommandRequest = exports.PrepareRenameRequest = exports.RenameRequest = exports.PrepareSupportDefaultBehavior = exports.DocumentOnTypeFormattingRequest = exports.DocumentRangeFormattingRequest = exports.DocumentFormattingRequest = exports.DocumentLinkResolveRequest = void 0;
+const Is = require("./utils/is");
+const messages_1 = require("./messages");
+const protocol_implementation_1 = require("./protocol.implementation");
+Object.defineProperty(exports, "ImplementationRequest", { enumerable: true, get: function () { return protocol_implementation_1.ImplementationRequest; } });
+const protocol_typeDefinition_1 = require("./protocol.typeDefinition");
+Object.defineProperty(exports, "TypeDefinitionRequest", { enumerable: true, get: function () { return protocol_typeDefinition_1.TypeDefinitionRequest; } });
+const protocol_workspaceFolders_1 = require("./protocol.workspaceFolders");
+Object.defineProperty(exports, "WorkspaceFoldersRequest", { enumerable: true, get: function () { return protocol_workspaceFolders_1.WorkspaceFoldersRequest; } });
+Object.defineProperty(exports, "DidChangeWorkspaceFoldersNotification", { enumerable: true, get: function () { return protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification; } });
+const protocol_configuration_1 = require("./protocol.configuration");
+Object.defineProperty(exports, "ConfigurationRequest", { enumerable: true, get: function () { return protocol_configuration_1.ConfigurationRequest; } });
+const protocol_colorProvider_1 = require("./protocol.colorProvider");
+Object.defineProperty(exports, "DocumentColorRequest", { enumerable: true, get: function () { return protocol_colorProvider_1.DocumentColorRequest; } });
+Object.defineProperty(exports, "ColorPresentationRequest", { enumerable: true, get: function () { return protocol_colorProvider_1.ColorPresentationRequest; } });
+const protocol_foldingRange_1 = require("./protocol.foldingRange");
+Object.defineProperty(exports, "FoldingRangeRequest", { enumerable: true, get: function () { return protocol_foldingRange_1.FoldingRangeRequest; } });
+const protocol_declaration_1 = require("./protocol.declaration");
+Object.defineProperty(exports, "DeclarationRequest", { enumerable: true, get: function () { return protocol_declaration_1.DeclarationRequest; } });
+const protocol_selectionRange_1 = require("./protocol.selectionRange");
+Object.defineProperty(exports, "SelectionRangeRequest", { enumerable: true, get: function () { return protocol_selectionRange_1.SelectionRangeRequest; } });
+const protocol_progress_1 = require("./protocol.progress");
+Object.defineProperty(exports, "WorkDoneProgress", { enumerable: true, get: function () { return protocol_progress_1.WorkDoneProgress; } });
+Object.defineProperty(exports, "WorkDoneProgressCreateRequest", { enumerable: true, get: function () { return protocol_progress_1.WorkDoneProgressCreateRequest; } });
+Object.defineProperty(exports, "WorkDoneProgressCancelNotification", { enumerable: true, get: function () { return protocol_progress_1.WorkDoneProgressCancelNotification; } });
+const protocol_callHierarchy_1 = require("./protocol.callHierarchy");
+Object.defineProperty(exports, "CallHierarchyIncomingCallsRequest", { enumerable: true, get: function () { return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest; } });
+Object.defineProperty(exports, "CallHierarchyOutgoingCallsRequest", { enumerable: true, get: function () { return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest; } });
+Object.defineProperty(exports, "CallHierarchyPrepareRequest", { enumerable: true, get: function () { return protocol_callHierarchy_1.CallHierarchyPrepareRequest; } });
+const protocol_semanticTokens_1 = require("./protocol.semanticTokens");
+Object.defineProperty(exports, "SemanticTokenTypes", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokenTypes; } });
+Object.defineProperty(exports, "SemanticTokenModifiers", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokenModifiers; } });
+Object.defineProperty(exports, "SemanticTokens", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokens; } });
+Object.defineProperty(exports, "TokenFormat", { enumerable: true, get: function () { return protocol_semanticTokens_1.TokenFormat; } });
+Object.defineProperty(exports, "SemanticTokensRequest", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRequest; } });
+Object.defineProperty(exports, "SemanticTokensDeltaRequest", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensDeltaRequest; } });
+Object.defineProperty(exports, "SemanticTokensRangeRequest", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRangeRequest; } });
+Object.defineProperty(exports, "SemanticTokensRefreshRequest", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRefreshRequest; } });
+Object.defineProperty(exports, "SemanticTokensRegistrationType", { enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRegistrationType; } });
+const protocol_showDocument_1 = require("./protocol.showDocument");
+Object.defineProperty(exports, "ShowDocumentRequest", { enumerable: true, get: function () { return protocol_showDocument_1.ShowDocumentRequest; } });
+const protocol_linkedEditingRange_1 = require("./protocol.linkedEditingRange");
+Object.defineProperty(exports, "LinkedEditingRangeRequest", { enumerable: true, get: function () { return protocol_linkedEditingRange_1.LinkedEditingRangeRequest; } });
+const protocol_fileOperations_1 = require("./protocol.fileOperations");
+Object.defineProperty(exports, "FileOperationPatternKind", { enumerable: true, get: function () { return protocol_fileOperations_1.FileOperationPatternKind; } });
+Object.defineProperty(exports, "DidCreateFilesNotification", { enumerable: true, get: function () { return protocol_fileOperations_1.DidCreateFilesNotification; } });
+Object.defineProperty(exports, "WillCreateFilesRequest", { enumerable: true, get: function () { return protocol_fileOperations_1.WillCreateFilesRequest; } });
+Object.defineProperty(exports, "DidRenameFilesNotification", { enumerable: true, get: function () { return protocol_fileOperations_1.DidRenameFilesNotification; } });
+Object.defineProperty(exports, "WillRenameFilesRequest", { enumerable: true, get: function () { return protocol_fileOperations_1.WillRenameFilesRequest; } });
+Object.defineProperty(exports, "DidDeleteFilesNotification", { enumerable: true, get: function () { return protocol_fileOperations_1.DidDeleteFilesNotification; } });
+Object.defineProperty(exports, "WillDeleteFilesRequest", { enumerable: true, get: function () { return protocol_fileOperations_1.WillDeleteFilesRequest; } });
+const protocol_moniker_1 = require("./protocol.moniker");
+Object.defineProperty(exports, "UniquenessLevel", { enumerable: true, get: function () { return protocol_moniker_1.UniquenessLevel; } });
+Object.defineProperty(exports, "MonikerKind", { enumerable: true, get: function () { return protocol_moniker_1.MonikerKind; } });
+Object.defineProperty(exports, "MonikerRequest", { enumerable: true, get: function () { return protocol_moniker_1.MonikerRequest; } });
+// @ts-ignore: to avoid inlining LocationLink as dynamic import
+let __noDynamicImport;
+/**
+ * The DocumentFilter namespace provides helper functions to work with
+ * [DocumentFilter](#DocumentFilter) literals.
+ */
+var DocumentFilter;
+(function (DocumentFilter) {
+    function is(value) {
+        const candidate = value;
+        return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);
+    }
+    DocumentFilter.is = is;
+})(DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {}));
+/**
+ * The DocumentSelector namespace provides helper functions to work with
+ * [DocumentSelector](#DocumentSelector)s.
+ */
+var DocumentSelector;
+(function (DocumentSelector) {
+    function is(value) {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        for (let elem of value) {
+            if (!Is.string(elem) && !DocumentFilter.is(elem)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    DocumentSelector.is = is;
+})(DocumentSelector = exports.DocumentSelector || (exports.DocumentSelector = {}));
+/**
+ * The `client/registerCapability` request is sent from the server to the client to register a new capability
+ * handler on the client side.
+ */
+var RegistrationRequest;
+(function (RegistrationRequest) {
+    RegistrationRequest.type = new messages_1.ProtocolRequestType('client/registerCapability');
+})(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {}));
+/**
+ * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
+ * handler on the client side.
+ */
+var UnregistrationRequest;
+(function (UnregistrationRequest) {
+    UnregistrationRequest.type = new messages_1.ProtocolRequestType('client/unregisterCapability');
+})(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {}));
+var ResourceOperationKind;
+(function (ResourceOperationKind) {
+    /**
+     * Supports creating new files and folders.
+     */
+    ResourceOperationKind.Create = 'create';
+    /**
+     * Supports renaming existing files and folders.
+     */
+    ResourceOperationKind.Rename = 'rename';
+    /**
+     * Supports deleting existing files and folders.
+     */
+    ResourceOperationKind.Delete = 'delete';
+})(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {}));
+var FailureHandlingKind;
+(function (FailureHandlingKind) {
+    /**
+     * Applying the workspace change is simply aborted if one of the changes provided
+     * fails. All operations executed before the failing operation stay executed.
+     */
+    FailureHandlingKind.Abort = 'abort';
+    /**
+     * All operations are executed transactional. That means they either all
+     * succeed or no changes at all are applied to the workspace.
+     */
+    FailureHandlingKind.Transactional = 'transactional';
+    /**
+     * If the workspace edit contains only textual file changes they are executed transactional.
+     * If resource changes (create, rename or delete file) are part of the change the failure
+     * handling strategy is abort.
+     */
+    FailureHandlingKind.TextOnlyTransactional = 'textOnlyTransactional';
+    /**
+     * The client tries to undo the operations already executed. But there is no
+     * guarantee that this is succeeding.
+     */
+    FailureHandlingKind.Undo = 'undo';
+})(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {}));
+/**
+ * The StaticRegistrationOptions namespace provides helper functions to work with
+ * [StaticRegistrationOptions](#StaticRegistrationOptions) literals.
+ */
+var StaticRegistrationOptions;
+(function (StaticRegistrationOptions) {
+    function hasId(value) {
+        const candidate = value;
+        return candidate && Is.string(candidate.id) && candidate.id.length > 0;
+    }
+    StaticRegistrationOptions.hasId = hasId;
+})(StaticRegistrationOptions = exports.StaticRegistrationOptions || (exports.StaticRegistrationOptions = {}));
+/**
+ * The TextDocumentRegistrationOptions namespace provides helper functions to work with
+ * [TextDocumentRegistrationOptions](#TextDocumentRegistrationOptions) literals.
+ */
+var TextDocumentRegistrationOptions;
+(function (TextDocumentRegistrationOptions) {
+    function is(value) {
+        const candidate = value;
+        return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector));
+    }
+    TextDocumentRegistrationOptions.is = is;
+})(TextDocumentRegistrationOptions = exports.TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = {}));
+/**
+ * The WorkDoneProgressOptions namespace provides helper functions to work with
+ * [WorkDoneProgressOptions](#WorkDoneProgressOptions) literals.
+ */
+var WorkDoneProgressOptions;
+(function (WorkDoneProgressOptions) {
+    function is(value) {
+        const candidate = value;
+        return Is.objectLiteral(candidate) && (candidate.workDoneProgress === undefined || Is.boolean(candidate.workDoneProgress));
+    }
+    WorkDoneProgressOptions.is = is;
+    function hasWorkDoneProgress(value) {
+        const candidate = value;
+        return candidate && Is.boolean(candidate.workDoneProgress);
+    }
+    WorkDoneProgressOptions.hasWorkDoneProgress = hasWorkDoneProgress;
+})(WorkDoneProgressOptions = exports.WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = {}));
+/**
+ * The initialize request is sent from the client to the server.
+ * It is sent once as the request after starting up the server.
+ * The requests parameter is of type [InitializeParams](#InitializeParams)
+ * the response if of type [InitializeResult](#InitializeResult) of a Thenable that
+ * resolves to such.
+ */
+var InitializeRequest;
+(function (InitializeRequest) {
+    InitializeRequest.type = new messages_1.ProtocolRequestType('initialize');
+})(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {}));
+/**
+ * Known error codes for an `InitializeError`;
+ */
+var InitializeError;
+(function (InitializeError) {
+    /**
+     * If the protocol version provided by the client can't be handled by the server.
+     * @deprecated This initialize error got replaced by client capabilities. There is
+     * no version handshake in version 3.0x
+     */
+    InitializeError.unknownProtocolVersion = 1;
+})(InitializeError = exports.InitializeError || (exports.InitializeError = {}));
+/**
+ * The initialized notification is sent from the client to the
+ * server after the client is fully initialized and the server
+ * is allowed to send requests from the server to the client.
+ */
+var InitializedNotification;
+(function (InitializedNotification) {
+    InitializedNotification.type = new messages_1.ProtocolNotificationType('initialized');
+})(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {}));
+//---- Shutdown Method ----
+/**
+ * A shutdown request is sent from the client to the server.
+ * It is sent once when the client decides to shutdown the
+ * server. The only notification that is sent after a shutdown request
+ * is the exit event.
+ */
+var ShutdownRequest;
+(function (ShutdownRequest) {
+    ShutdownRequest.type = new messages_1.ProtocolRequestType0('shutdown');
+})(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {}));
+//---- Exit Notification ----
+/**
+ * The exit event is sent from the client to the server to
+ * ask the server to exit its process.
+ */
+var ExitNotification;
+(function (ExitNotification) {
+    ExitNotification.type = new messages_1.ProtocolNotificationType0('exit');
+})(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {}));
+/**
+ * The configuration change notification is sent from the client to the server
+ * when the client's configuration has changed. The notification contains
+ * the changed configuration as defined by the language client.
+ */
+var DidChangeConfigurationNotification;
+(function (DidChangeConfigurationNotification) {
+    DidChangeConfigurationNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeConfiguration');
+})(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {}));
+//---- Message show and log notifications ----
+/**
+ * The message type
+ */
+var MessageType;
+(function (MessageType) {
+    /**
+     * An error message.
+     */
+    MessageType.Error = 1;
+    /**
+     * A warning message.
+     */
+    MessageType.Warning = 2;
+    /**
+     * An information message.
+     */
+    MessageType.Info = 3;
+    /**
+     * A log message.
+     */
+    MessageType.Log = 4;
+})(MessageType = exports.MessageType || (exports.MessageType = {}));
+/**
+ * The show message notification is sent from a server to a client to ask
+ * the client to display a particular message in the user interface.
+ */
+var ShowMessageNotification;
+(function (ShowMessageNotification) {
+    ShowMessageNotification.type = new messages_1.ProtocolNotificationType('window/showMessage');
+})(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {}));
+/**
+ * The show message request is sent from the server to the client to show a message
+ * and a set of options actions to the user.
+ */
+var ShowMessageRequest;
+(function (ShowMessageRequest) {
+    ShowMessageRequest.type = new messages_1.ProtocolRequestType('window/showMessageRequest');
+})(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {}));
+/**
+ * The log message notification is sent from the server to the client to ask
+ * the client to log a particular message.
+ */
+var LogMessageNotification;
+(function (LogMessageNotification) {
+    LogMessageNotification.type = new messages_1.ProtocolNotificationType('window/logMessage');
+})(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {}));
+//---- Telemetry notification
+/**
+ * The telemetry event notification is sent from the server to the client to ask
+ * the client to log telemetry data.
+ */
+var TelemetryEventNotification;
+(function (TelemetryEventNotification) {
+    TelemetryEventNotification.type = new messages_1.ProtocolNotificationType('telemetry/event');
+})(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {}));
+/**
+ * Defines how the host (editor) should sync
+ * document changes to the language server.
+ */
+var TextDocumentSyncKind;
+(function (TextDocumentSyncKind) {
+    /**
+     * Documents should not be synced at all.
+     */
+    TextDocumentSyncKind.None = 0;
+    /**
+     * Documents are synced by always sending the full content
+     * of the document.
+     */
+    TextDocumentSyncKind.Full = 1;
+    /**
+     * Documents are synced by sending the full content on open.
+     * After that only incremental updates to the document are
+     * send.
+     */
+    TextDocumentSyncKind.Incremental = 2;
+})(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {}));
+/**
+ * The document open notification is sent from the client to the server to signal
+ * newly opened text documents. The document's truth is now managed by the client
+ * and the server must not try to read the document's truth using the document's
+ * uri. Open in this sense means it is managed by the client. It doesn't necessarily
+ * mean that its content is presented in an editor. An open notification must not
+ * be sent more than once without a corresponding close notification send before.
+ * This means open and close notification must be balanced and the max open count
+ * is one.
+ */
+var DidOpenTextDocumentNotification;
+(function (DidOpenTextDocumentNotification) {
+    DidOpenTextDocumentNotification.method = 'textDocument/didOpen';
+    DidOpenTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification.method);
+})(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {}));
+var TextDocumentContentChangeEvent;
+(function (TextDocumentContentChangeEvent) {
+    /**
+     * Checks whether the information describes a delta event.
+     */
+    function isIncremental(event) {
+        let candidate = event;
+        return candidate !== undefined && candidate !== null &&
+            typeof candidate.text === 'string' && candidate.range !== undefined &&
+            (candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');
+    }
+    TextDocumentContentChangeEvent.isIncremental = isIncremental;
+    /**
+     * Checks whether the information describes a full replacement event.
+     */
+    function isFull(event) {
+        let candidate = event;
+        return candidate !== undefined && candidate !== null &&
+            typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;
+    }
+    TextDocumentContentChangeEvent.isFull = isFull;
+})(TextDocumentContentChangeEvent = exports.TextDocumentContentChangeEvent || (exports.TextDocumentContentChangeEvent = {}));
+/**
+ * The document change notification is sent from the client to the server to signal
+ * changes to a text document.
+ */
+var DidChangeTextDocumentNotification;
+(function (DidChangeTextDocumentNotification) {
+    DidChangeTextDocumentNotification.method = 'textDocument/didChange';
+    DidChangeTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification.method);
+})(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {}));
+/**
+ * The document close notification is sent from the client to the server when
+ * the document got closed in the client. The document's truth now exists where
+ * the document's uri points to (e.g. if the document's uri is a file uri the
+ * truth now exists on disk). As with the open notification the close notification
+ * is about managing the document's content. Receiving a close notification
+ * doesn't mean that the document was open in an editor before. A close
+ * notification requires a previous open notification to be sent.
+ */
+var DidCloseTextDocumentNotification;
+(function (DidCloseTextDocumentNotification) {
+    DidCloseTextDocumentNotification.method = 'textDocument/didClose';
+    DidCloseTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification.method);
+})(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {}));
+/**
+ * The document save notification is sent from the client to the server when
+ * the document got saved in the client.
+ */
+var DidSaveTextDocumentNotification;
+(function (DidSaveTextDocumentNotification) {
+    DidSaveTextDocumentNotification.method = 'textDocument/didSave';
+    DidSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification.method);
+})(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {}));
+/**
+ * Represents reasons why a text document is saved.
+ */
+var TextDocumentSaveReason;
+(function (TextDocumentSaveReason) {
+    /**
+     * Manually triggered, e.g. by the user pressing save, by starting debugging,
+     * or by an API call.
+     */
+    TextDocumentSaveReason.Manual = 1;
+    /**
+     * Automatic after a delay.
+     */
+    TextDocumentSaveReason.AfterDelay = 2;
+    /**
+     * When the editor lost focus.
+     */
+    TextDocumentSaveReason.FocusOut = 3;
+})(TextDocumentSaveReason = exports.TextDocumentSaveReason || (exports.TextDocumentSaveReason = {}));
+/**
+ * A document will save notification is sent from the client to the server before
+ * the document is actually saved.
+ */
+var WillSaveTextDocumentNotification;
+(function (WillSaveTextDocumentNotification) {
+    WillSaveTextDocumentNotification.method = 'textDocument/willSave';
+    WillSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification.method);
+})(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {}));
+/**
+ * A document will save request is sent from the client to the server before
+ * the document is actually saved. The request can return an array of TextEdits
+ * which will be applied to the text document before it is saved. Please note that
+ * clients might drop results if computing the text edits took too long or if a
+ * server constantly fails on this request. This is done to keep the save fast and
+ * reliable.
+ */
+var WillSaveTextDocumentWaitUntilRequest;
+(function (WillSaveTextDocumentWaitUntilRequest) {
+    WillSaveTextDocumentWaitUntilRequest.method = 'textDocument/willSaveWaitUntil';
+    WillSaveTextDocumentWaitUntilRequest.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest.method);
+})(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {}));
+/**
+ * The watched files notification is sent from the client to the server when
+ * the client detects changes to file watched by the language client.
+ */
+var DidChangeWatchedFilesNotification;
+(function (DidChangeWatchedFilesNotification) {
+    DidChangeWatchedFilesNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWatchedFiles');
+})(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {}));
+/**
+ * The file event type
+ */
+var FileChangeType;
+(function (FileChangeType) {
+    /**
+     * The file got created.
+     */
+    FileChangeType.Created = 1;
+    /**
+     * The file got changed.
+     */
+    FileChangeType.Changed = 2;
+    /**
+     * The file got deleted.
+     */
+    FileChangeType.Deleted = 3;
+})(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {}));
+var WatchKind;
+(function (WatchKind) {
+    /**
+     * Interested in create events.
+     */
+    WatchKind.Create = 1;
+    /**
+     * Interested in change events
+     */
+    WatchKind.Change = 2;
+    /**
+     * Interested in delete events
+     */
+    WatchKind.Delete = 4;
+})(WatchKind = exports.WatchKind || (exports.WatchKind = {}));
+/**
+ * Diagnostics notification are sent from the server to the client to signal
+ * results of validation runs.
+ */
+var PublishDiagnosticsNotification;
+(function (PublishDiagnosticsNotification) {
+    PublishDiagnosticsNotification.type = new messages_1.ProtocolNotificationType('textDocument/publishDiagnostics');
+})(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {}));
+/**
+ * How a completion was triggered
+ */
+var CompletionTriggerKind;
+(function (CompletionTriggerKind) {
+    /**
+     * Completion was triggered by typing an identifier (24x7 code
+     * complete), manual invocation (e.g Ctrl+Space) or via API.
+     */
+    CompletionTriggerKind.Invoked = 1;
+    /**
+     * Completion was triggered by a trigger character specified by
+     * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
+     */
+    CompletionTriggerKind.TriggerCharacter = 2;
+    /**
+     * Completion was re-triggered as current completion list is incomplete
+     */
+    CompletionTriggerKind.TriggerForIncompleteCompletions = 3;
+})(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {}));
+/**
+ * Request to request completion at a given text document position. The request's
+ * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response
+ * is of type [CompletionItem[]](#CompletionItem) or [CompletionList](#CompletionList)
+ * or a Thenable that resolves to such.
+ *
+ * The request can delay the computation of the [`detail`](#CompletionItem.detail)
+ * and [`documentation`](#CompletionItem.documentation) properties to the `completionItem/resolve`
+ * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
+ * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
+ */
+var CompletionRequest;
+(function (CompletionRequest) {
+    CompletionRequest.method = 'textDocument/completion';
+    CompletionRequest.type = new messages_1.ProtocolRequestType(CompletionRequest.method);
+})(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {}));
+/**
+ * Request to resolve additional information for a given completion item.The request's
+ * parameter is of type [CompletionItem](#CompletionItem) the response
+ * is of type [CompletionItem](#CompletionItem) or a Thenable that resolves to such.
+ */
+var CompletionResolveRequest;
+(function (CompletionResolveRequest) {
+    CompletionResolveRequest.method = 'completionItem/resolve';
+    CompletionResolveRequest.type = new messages_1.ProtocolRequestType(CompletionResolveRequest.method);
+})(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {}));
+/**
+ * Request to request hover information at a given text document position. The request's
+ * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response is of
+ * type [Hover](#Hover) or a Thenable that resolves to such.
+ */
+var HoverRequest;
+(function (HoverRequest) {
+    HoverRequest.method = 'textDocument/hover';
+    HoverRequest.type = new messages_1.ProtocolRequestType(HoverRequest.method);
+})(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}));
+/**
+ * How a signature help was triggered.
+ *
+ * @since 3.15.0
+ */
+var SignatureHelpTriggerKind;
+(function (SignatureHelpTriggerKind) {
+    /**
+     * Signature help was invoked manually by the user or by a command.
+     */
+    SignatureHelpTriggerKind.Invoked = 1;
+    /**
+     * Signature help was triggered by a trigger character.
+     */
+    SignatureHelpTriggerKind.TriggerCharacter = 2;
+    /**
+     * Signature help was triggered by the cursor moving or by the document content changing.
+     */
+    SignatureHelpTriggerKind.ContentChange = 3;
+})(SignatureHelpTriggerKind = exports.SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = {}));
+var SignatureHelpRequest;
+(function (SignatureHelpRequest) {
+    SignatureHelpRequest.method = 'textDocument/signatureHelp';
+    SignatureHelpRequest.type = new messages_1.ProtocolRequestType(SignatureHelpRequest.method);
+})(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {}));
+/**
+ * A request to resolve the definition location of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPosition]
+ * (#TextDocumentPosition) the response is of either type [Definition](#Definition)
+ * or a typed array of [DefinitionLink](#DefinitionLink) or a Thenable that resolves
+ * to such.
+ */
+var DefinitionRequest;
+(function (DefinitionRequest) {
+    DefinitionRequest.method = 'textDocument/definition';
+    DefinitionRequest.type = new messages_1.ProtocolRequestType(DefinitionRequest.method);
+})(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {}));
+/**
+ * A request to resolve project-wide references for the symbol denoted
+ * by the given text document position. The request's parameter is of
+ * type [ReferenceParams](#ReferenceParams) the response is of type
+ * [Location[]](#Location) or a Thenable that resolves to such.
+ */
+var ReferencesRequest;
+(function (ReferencesRequest) {
+    ReferencesRequest.method = 'textDocument/references';
+    ReferencesRequest.type = new messages_1.ProtocolRequestType(ReferencesRequest.method);
+})(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {}));
+/**
+ * Request to resolve a [DocumentHighlight](#DocumentHighlight) for a given
+ * text document position. The request's parameter is of type [TextDocumentPosition]
+ * (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]
+ * (#DocumentHighlight) or a Thenable that resolves to such.
+ */
+var DocumentHighlightRequest;
+(function (DocumentHighlightRequest) {
+    DocumentHighlightRequest.method = 'textDocument/documentHighlight';
+    DocumentHighlightRequest.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest.method);
+})(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {}));
+/**
+ * A request to list all symbols found in a given text document. The request's
+ * parameter is of type [TextDocumentIdentifier](#TextDocumentIdentifier) the
+ * response is of type [SymbolInformation[]](#SymbolInformation) or a Thenable
+ * that resolves to such.
+ */
+var DocumentSymbolRequest;
+(function (DocumentSymbolRequest) {
+    DocumentSymbolRequest.method = 'textDocument/documentSymbol';
+    DocumentSymbolRequest.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest.method);
+})(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {}));
+/**
+ * A request to provide commands for the given text document and range.
+ */
+var CodeActionRequest;
+(function (CodeActionRequest) {
+    CodeActionRequest.method = 'textDocument/codeAction';
+    CodeActionRequest.type = new messages_1.ProtocolRequestType(CodeActionRequest.method);
+})(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {}));
+/**
+ * Request to resolve additional information for a given code action.The request's
+ * parameter is of type [CodeAction](#CodeAction) the response
+ * is of type [CodeAction](#CodeAction) or a Thenable that resolves to such.
+ */
+var CodeActionResolveRequest;
+(function (CodeActionResolveRequest) {
+    CodeActionResolveRequest.method = 'codeAction/resolve';
+    CodeActionResolveRequest.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest.method);
+})(CodeActionResolveRequest = exports.CodeActionResolveRequest || (exports.CodeActionResolveRequest = {}));
+/**
+ * A request to list project-wide symbols matching the query string given
+ * by the [WorkspaceSymbolParams](#WorkspaceSymbolParams). The response is
+ * of type [SymbolInformation[]](#SymbolInformation) or a Thenable that
+ * resolves to such.
+ */
+var WorkspaceSymbolRequest;
+(function (WorkspaceSymbolRequest) {
+    WorkspaceSymbolRequest.method = 'workspace/symbol';
+    WorkspaceSymbolRequest.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest.method);
+})(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {}));
+/**
+ * A request to provide code lens for the given text document.
+ */
+var CodeLensRequest;
+(function (CodeLensRequest) {
+    CodeLensRequest.method = 'textDocument/codeLens';
+    CodeLensRequest.type = new messages_1.ProtocolRequestType(CodeLensRequest.method);
+})(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {}));
+/**
+ * A request to resolve a command for a given code lens.
+ */
+var CodeLensResolveRequest;
+(function (CodeLensResolveRequest) {
+    CodeLensResolveRequest.method = 'codeLens/resolve';
+    CodeLensResolveRequest.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest.method);
+})(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {}));
+/**
+ * A request to refresh all code actions
+ *
+ * @since 3.16.0
+ */
+var CodeLensRefreshRequest;
+(function (CodeLensRefreshRequest) {
+    CodeLensRefreshRequest.method = `workspace/codeLens/refresh`;
+    CodeLensRefreshRequest.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest.method);
+})(CodeLensRefreshRequest = exports.CodeLensRefreshRequest || (exports.CodeLensRefreshRequest = {}));
+/**
+ * A request to provide document links
+ */
+var DocumentLinkRequest;
+(function (DocumentLinkRequest) {
+    DocumentLinkRequest.method = 'textDocument/documentLink';
+    DocumentLinkRequest.type = new messages_1.ProtocolRequestType(DocumentLinkRequest.method);
+})(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {}));
+/**
+ * Request to resolve additional information for a given document link. The request's
+ * parameter is of type [DocumentLink](#DocumentLink) the response
+ * is of type [DocumentLink](#DocumentLink) or a Thenable that resolves to such.
+ */
+var DocumentLinkResolveRequest;
+(function (DocumentLinkResolveRequest) {
+    DocumentLinkResolveRequest.method = 'documentLink/resolve';
+    DocumentLinkResolveRequest.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest.method);
+})(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {}));
+/**
+ * A request to to format a whole document.
+ */
+var DocumentFormattingRequest;
+(function (DocumentFormattingRequest) {
+    DocumentFormattingRequest.method = 'textDocument/formatting';
+    DocumentFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest.method);
+})(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {}));
+/**
+ * A request to to format a range in a document.
+ */
+var DocumentRangeFormattingRequest;
+(function (DocumentRangeFormattingRequest) {
+    DocumentRangeFormattingRequest.method = 'textDocument/rangeFormatting';
+    DocumentRangeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest.method);
+})(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {}));
+/**
+ * A request to format a document on type.
+ */
+var DocumentOnTypeFormattingRequest;
+(function (DocumentOnTypeFormattingRequest) {
+    DocumentOnTypeFormattingRequest.method = 'textDocument/onTypeFormatting';
+    DocumentOnTypeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest.method);
+})(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {}));
+//---- Rename ----------------------------------------------
+var PrepareSupportDefaultBehavior;
+(function (PrepareSupportDefaultBehavior) {
+    /**
+     * The client's default behavior is to select the identifier
+     * according the to language's syntax rule.
+     */
+    PrepareSupportDefaultBehavior.Identifier = 1;
+})(PrepareSupportDefaultBehavior = exports.PrepareSupportDefaultBehavior || (exports.PrepareSupportDefaultBehavior = {}));
+/**
+ * A request to rename a symbol.
+ */
+var RenameRequest;
+(function (RenameRequest) {
+    RenameRequest.method = 'textDocument/rename';
+    RenameRequest.type = new messages_1.ProtocolRequestType(RenameRequest.method);
+})(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}));
+/**
+ * A request to test and perform the setup necessary for a rename.
+ *
+ * @since 3.16 - support for default behavior
+ */
+var PrepareRenameRequest;
+(function (PrepareRenameRequest) {
+    PrepareRenameRequest.method = 'textDocument/prepareRename';
+    PrepareRenameRequest.type = new messages_1.ProtocolRequestType(PrepareRenameRequest.method);
+})(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {}));
+/**
+ * A request send from the client to the server to execute a command. The request might return
+ * a workspace edit which the client will apply to the workspace.
+ */
+var ExecuteCommandRequest;
+(function (ExecuteCommandRequest) {
+    ExecuteCommandRequest.type = new messages_1.ProtocolRequestType('workspace/executeCommand');
+})(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {}));
+/**
+ * A request sent from the server to the client to modified certain resources.
+ */
+var ApplyWorkspaceEditRequest;
+(function (ApplyWorkspaceEditRequest) {
+    ApplyWorkspaceEditRequest.type = new messages_1.ProtocolRequestType('workspace/applyEdit');
+})(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {}));
+//# sourceMappingURL=protocol.js.map

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

@@ -0,0 +1,51 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Range } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { StaticRegistrationOptions, TextDocumentPositionParams, TextDocumentRegistrationOptions, WorkDoneProgressOptions, WorkDoneProgressParams } from './protocol';
+/**
+ * Client capabilities for the linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface LinkedEditingRangeParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+export interface LinkedEditingRangeOptions extends WorkDoneProgressOptions {
+}
+export interface LinkedEditingRangeRegistrationOptions extends TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions {
+}
+/**
+ * The result of a linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRanges {
+    /**
+     * A list of ranges that can be edited together. The ranges must have
+     * identical length and contain identical text content. The ranges cannot overlap.
+     */
+    ranges: Range[];
+    /**
+     * An optional word pattern (regular expression) that describes valid contents for
+     * the given ranges. If no pattern is provided, the client configuration's word
+     * pattern will be used.
+     */
+    wordPattern?: string;
+}
+/**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+export declare namespace LinkedEditingRangeRequest {
+    const method: 'textDocument/linkedEditingRange';
+    const type: ProtocolRequestType<LinkedEditingRangeParams, LinkedEditingRanges | null, void, any, LinkedEditingRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<LinkedEditingRangeParams, LinkedEditingRanges | null, void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.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.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedEditingRangeRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+var LinkedEditingRangeRequest;
+(function (LinkedEditingRangeRequest) {
+    LinkedEditingRangeRequest.method = 'textDocument/linkedEditingRange';
+    LinkedEditingRangeRequest.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest.method);
+})(LinkedEditingRangeRequest = exports.LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = {}));
+//# sourceMappingURL=protocol.linkedEditingRange.js.map

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

@@ -0,0 +1,103 @@
+import { ProtocolRequestType } from './messages';
+import { WorkDoneProgressOptions, WorkDoneProgressParams, PartialResultParams, TextDocumentRegistrationOptions, TextDocumentPositionParams } from './protocol';
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+export declare enum UniquenessLevel {
+    /**
+     * The moniker is only unique inside a document
+     */
+    document = "document",
+    /**
+     * The moniker is unique inside a project for which a dump got created
+     */
+    project = "project",
+    /**
+     * The moniker is unique inside the group to which a project belongs
+     */
+    group = "group",
+    /**
+     * The moniker is unique inside the moniker scheme.
+     */
+    scheme = "scheme",
+    /**
+     * The moniker is globally unique
+     */
+    global = "global"
+}
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+export declare enum MonikerKind {
+    /**
+     * The moniker represent a symbol that is imported into a project
+     */
+    import = "import",
+    /**
+     * The moniker represents a symbol that is exported from a project
+     */
+    export = "export",
+    /**
+     * The moniker represents a symbol that is local to a project (e.g. a local
+     * variable of a function, a class not visible outside the project, ...)
+     */
+    local = "local"
+}
+/**
+ * Moniker definition to match LSIF 0.5 moniker definition.
+ *
+ * @since 3.16.0
+ */
+export interface Moniker {
+    /**
+     * The scheme of the moniker. For example tsc or .Net
+     */
+    scheme: string;
+    /**
+     * The identifier of the moniker. The value is opaque in LSIF however
+     * schema owners are allowed to define the structure if they want.
+     */
+    identifier: string;
+    /**
+     * The scope in which the moniker is unique
+     */
+    unique: UniquenessLevel;
+    /**
+     * The moniker kind if known.
+     */
+    kind?: MonikerKind;
+}
+/**
+ * Client capabilities specific to the moniker request.
+ *
+ * @since 3.16.0
+ */
+export interface MonikerClientCapabilities {
+    /**
+     * Whether moniker supports dynamic registration. If this is set to `true`
+     * the client supports the new `MonikerRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface MonikerServerCapabilities {
+}
+export interface MonikerOptions extends WorkDoneProgressOptions {
+}
+export interface MonikerRegistrationOptions extends TextDocumentRegistrationOptions, MonikerOptions {
+}
+export interface MonikerParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type [TextDocumentPositionParams](#TextDocumentPositionParams).
+ * The response is of type [Moniker[]](#Moniker[]) or `null`.
+ */
+export declare namespace MonikerRequest {
+    const method: 'textDocument/moniker';
+    const type: ProtocolRequestType<MonikerParams, Moniker[] | null, Moniker[], void, MonikerRegistrationOptions>;
+}

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

@@ -0,0 +1,68 @@
+"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.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
+const messages_1 = require("./messages");
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+var UniquenessLevel;
+(function (UniquenessLevel) {
+    /**
+     * The moniker is only unique inside a document
+     */
+    UniquenessLevel["document"] = "document";
+    /**
+     * The moniker is unique inside a project for which a dump got created
+     */
+    UniquenessLevel["project"] = "project";
+    /**
+     * The moniker is unique inside the group to which a project belongs
+     */
+    UniquenessLevel["group"] = "group";
+    /**
+     * The moniker is unique inside the moniker scheme.
+     */
+    UniquenessLevel["scheme"] = "scheme";
+    /**
+     * The moniker is globally unique
+     */
+    UniquenessLevel["global"] = "global";
+})(UniquenessLevel = exports.UniquenessLevel || (exports.UniquenessLevel = {}));
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+var MonikerKind;
+(function (MonikerKind) {
+    /**
+     * The moniker represent a symbol that is imported into a project
+     */
+    MonikerKind["import"] = "import";
+    /**
+     * The moniker represents a symbol that is exported from a project
+     */
+    MonikerKind["export"] = "export";
+    /**
+     * The moniker represents a symbol that is local to a project (e.g. a local
+     * variable of a function, a class not visible outside the project, ...)
+     */
+    MonikerKind["local"] = "local";
+})(MonikerKind = exports.MonikerKind || (exports.MonikerKind = {}));
+/**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type [TextDocumentPositionParams](#TextDocumentPositionParams).
+ * The response is of type [Moniker[]](#Moniker[]) or `null`.
+ */
+var MonikerRequest;
+(function (MonikerRequest) {
+    MonikerRequest.method = 'textDocument/moniker';
+    MonikerRequest.type = new messages_1.ProtocolRequestType(MonikerRequest.method);
+})(MonikerRequest = exports.MonikerRequest || (exports.MonikerRequest = {}));
+//# sourceMappingURL=protocol.moniker.js.map

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

@@ -0,0 +1,117 @@
+import { NotificationHandler, RequestHandler, ProgressType, ProgressToken } from 'vscode-jsonrpc';
+import { uinteger } from 'vscode-languageserver-types';
+import { ProtocolRequestType, ProtocolNotificationType } from './messages';
+export interface WorkDoneProgressClientCapabilities {
+    /**
+     * Window specific client capabilities.
+     */
+    window?: {
+        /**
+         * Whether client supports server initiated progress using the
+         * `window/workDoneProgress/create` request.
+         *
+         * Since 3.15.0
+         */
+        workDoneProgress?: boolean;
+    };
+}
+export interface WorkDoneProgressBegin {
+    kind: 'begin';
+    /**
+     * Mandatory title of the progress operation. Used to briefly inform about
+     * the kind of operation being performed.
+     *
+     * Examples: "Indexing" or "Linking dependencies".
+     */
+    title: string;
+    /**
+     * Controls if a cancel button should show to allow the user to cancel the
+     * long running operation. Clients that don't support cancellation are allowed
+     * to ignore the setting.
+     */
+    cancellable?: boolean;
+    /**
+     * Optional, more detailed associated progress message. Contains
+     * complementary information to the `title`.
+     *
+     * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+     * If unset, the previous progress message (if any) is still valid.
+     */
+    message?: string;
+    /**
+     * Optional progress percentage to display (value 100 is considered 100%).
+     * If not provided infinite progress is assumed and clients are allowed
+     * to ignore the `percentage` value in subsequent in report notifications.
+     *
+     * The value should be steadily rising. Clients are free to ignore values
+     * that are not following this rule. The value range is [0, 100].
+     */
+    percentage?: uinteger;
+}
+export interface WorkDoneProgressReport {
+    kind: 'report';
+    /**
+     * Controls enablement state of a cancel button.
+     *
+     * Clients that don't support cancellation or don't support controlling the button's
+     * enablement state are allowed to ignore the property.
+     */
+    cancellable?: boolean;
+    /**
+     * Optional, more detailed associated progress message. Contains
+     * complementary information to the `title`.
+     *
+     * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+     * If unset, the previous progress message (if any) is still valid.
+     */
+    message?: string;
+    /**
+     * Optional progress percentage to display (value 100 is considered 100%).
+     * If not provided infinite progress is assumed and clients are allowed
+     * to ignore the `percentage` value in subsequent in report notifications.
+     *
+     * The value should be steadily rising. Clients are free to ignore values
+     * that are not following this rule. The value range is [0, 100]
+     */
+    percentage?: uinteger;
+}
+export interface WorkDoneProgressEnd {
+    kind: 'end';
+    /**
+     * Optional, a final message indicating to for example indicate the outcome
+     * of the operation.
+     */
+    message?: string;
+}
+export declare namespace WorkDoneProgress {
+    const type: ProgressType<WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd>;
+    function is(value: ProgressType<any>): value is typeof type;
+}
+export interface WorkDoneProgressCreateParams {
+    /**
+     * The token to be used to report progress.
+     */
+    token: ProgressToken;
+}
+/**
+ * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
+ * reporting from the server.
+ */
+export declare namespace WorkDoneProgressCreateRequest {
+    const type: ProtocolRequestType<WorkDoneProgressCreateParams, void, never, void, void>;
+    type HandlerSignature = RequestHandler<WorkDoneProgressCreateParams, void, void>;
+}
+export interface WorkDoneProgressCancelParams {
+    /**
+     * The token to be used to report progress.
+     */
+    token: ProgressToken;
+}
+/**
+ * The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress
+ * initiated on the server side.
+ */
+export declare namespace WorkDoneProgressCancelNotification {
+    const type: ProtocolNotificationType<WorkDoneProgressCancelParams, void>;
+    type HandlerSignature = NotificationHandler<WorkDoneProgressCancelParams>;
+}

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

@@ -0,0 +1,34 @@
+"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.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const messages_1 = require("./messages");
+var WorkDoneProgress;
+(function (WorkDoneProgress) {
+    WorkDoneProgress.type = new vscode_jsonrpc_1.ProgressType();
+    function is(value) {
+        return value === WorkDoneProgress.type;
+    }
+    WorkDoneProgress.is = is;
+})(WorkDoneProgress = exports.WorkDoneProgress || (exports.WorkDoneProgress = {}));
+/**
+ * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
+ * reporting from the server.
+ */
+var WorkDoneProgressCreateRequest;
+(function (WorkDoneProgressCreateRequest) {
+    WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType('window/workDoneProgress/create');
+})(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = {}));
+/**
+ * The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress
+ * initiated on the server side.
+ */
+var WorkDoneProgressCancelNotification;
+(function (WorkDoneProgressCancelNotification) {
+    WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType('window/workDoneProgress/cancel');
+})(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {}));
+//# sourceMappingURL=protocol.progress.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.d.ts

@@ -0,0 +1,40 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier, Position, SelectionRange } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, WorkDoneProgressOptions, StaticRegistrationOptions, WorkDoneProgressParams, PartialResultParams } from './protocol';
+export interface SelectionRangeClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
+     * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server
+     * capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface SelectionRangeOptions extends WorkDoneProgressOptions {
+}
+export interface SelectionRangeRegistrationOptions extends SelectionRangeOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+/**
+ * A parameter literal used in selection range requests.
+ */
+export interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The positions inside the text document.
+     */
+    positions: Position[];
+}
+/**
+ * A request to provide selection ranges in a document. The request's
+ * parameter is of type [SelectionRangeParams](#SelectionRangeParams), the
+ * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace SelectionRangeRequest {
+    const method: 'textDocument/selectionRange';
+    const type: ProtocolRequestType<SelectionRangeParams, SelectionRange[] | null, SelectionRange[], any, SelectionRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<SelectionRangeParams, SelectionRange[] | null, void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js

@@ -0,0 +1,20 @@
+"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.SelectionRangeRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide selection ranges in a document. The request's
+ * parameter is of type [SelectionRangeParams](#SelectionRangeParams), the
+ * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable
+ * that resolves to such.
+ */
+var SelectionRangeRequest;
+(function (SelectionRangeRequest) {
+    SelectionRangeRequest.method = 'textDocument/selectionRange';
+    SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method);
+})(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));
+//# sourceMappingURL=protocol.selectionRange.js.map

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

@@ -0,0 +1,307 @@
+import { TextDocumentIdentifier, Range, uinteger } from 'vscode-languageserver-types';
+import { RequestHandler0, RequestHandler } from 'vscode-jsonrpc';
+import { ProtocolRequestType, ProtocolRequestType0, RegistrationType } from './messages';
+import { PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions } from './protocol';
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0
+ */
+export declare enum SemanticTokenTypes {
+    namespace = "namespace",
+    /**
+     * Represents a generic type. Acts as a fallback for types which can't be mapped to
+     * a specific type like class or enum.
+     */
+    type = "type",
+    class = "class",
+    enum = "enum",
+    interface = "interface",
+    struct = "struct",
+    typeParameter = "typeParameter",
+    parameter = "parameter",
+    variable = "variable",
+    property = "property",
+    enumMember = "enumMember",
+    event = "event",
+    function = "function",
+    method = "method",
+    macro = "macro",
+    keyword = "keyword",
+    modifier = "modifier",
+    comment = "comment",
+    string = "string",
+    number = "number",
+    regexp = "regexp",
+    operator = "operator"
+}
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0
+ */
+export declare enum SemanticTokenModifiers {
+    declaration = "declaration",
+    definition = "definition",
+    readonly = "readonly",
+    static = "static",
+    deprecated = "deprecated",
+    abstract = "abstract",
+    async = "async",
+    modification = "modification",
+    documentation = "documentation",
+    defaultLibrary = "defaultLibrary"
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensLegend {
+    /**
+     * The token types a server uses.
+     */
+    tokenTypes: string[];
+    /**
+     * The token modifiers a server uses.
+     */
+    tokenModifiers: string[];
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokens {
+    /**
+     * An optional result id. If provided and clients support delta updating
+     * the client will include the result id in the next semantic token request.
+     * A server can then instead of computing all semantic tokens again simply
+     * send a delta.
+     */
+    resultId?: string;
+    /**
+     * The actual tokens.
+     */
+    data: uinteger[];
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokens {
+    function is(value: any): value is SemanticTokens;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensPartialResult {
+    data: uinteger[];
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensEdit {
+    /**
+     * The start offset of the edit.
+     */
+    start: uinteger;
+    /**
+     * The count of elements to remove.
+     */
+    deleteCount: uinteger;
+    /**
+     * The elements to insert.
+     */
+    data?: uinteger[];
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDelta {
+    readonly resultId?: string;
+    /**
+     * The semantic token edits to transform a previous result into a new result.
+     */
+    edits: SemanticTokensEdit[];
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDeltaPartialResult {
+    edits: SemanticTokensEdit[];
+}
+export declare namespace TokenFormat {
+    const Relative: 'relative';
+}
+export declare type TokenFormat = 'relative';
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Which requests the client supports and might send to the server
+     * depending on the server's capability. Please note that clients might not
+     * show semantic tokens or degrade some of the user experience if a range
+     * or full request is advertised by the client but not provided by the
+     * server. If for example the client capability `requests.full` and
+     * `request.range` are both set to true but the server only provides a
+     * range provider the client might not render a minimap correctly or might
+     * even decide to not show any semantic tokens at all.
+     */
+    requests: {
+        /**
+         * The client will send the `textDocument/semanticTokens/range` request if
+         * the server provides a corresponding handler.
+         */
+        range?: boolean | {};
+        /**
+         * The client will send the `textDocument/semanticTokens/full` request if
+         * the server provides a corresponding handler.
+         */
+        full?: boolean | {
+            /**
+             * The client will send the `textDocument/semanticTokens/full/delta` request if
+             * the server provides a corresponding handler.
+             */
+            delta?: boolean;
+        };
+    };
+    /**
+     * The token types that the client supports.
+     */
+    tokenTypes: string[];
+    /**
+     * The token modifiers that the client supports.
+     */
+    tokenModifiers: string[];
+    /**
+     * The token formats the clients supports.
+     */
+    formats: TokenFormat[];
+    /**
+     * Whether the client supports tokens that can overlap each other.
+     */
+    overlappingTokenSupport?: boolean;
+    /**
+     * Whether the client supports tokens that can span multiple lines.
+     */
+    multilineTokenSupport?: boolean;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensOptions extends WorkDoneProgressOptions {
+    /**
+     * The legend used by the server
+     */
+    legend: SemanticTokensLegend;
+    /**
+     * Server supports providing semantic tokens for a specific range
+     * of a document.
+     */
+    range?: boolean | {};
+    /**
+     * Server supports providing semantic tokens for a full document.
+     */
+    full?: boolean | {
+        /**
+         * The server supports deltas for full documents.
+         */
+        delta?: boolean;
+    };
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions {
+}
+export declare namespace SemanticTokensRegistrationType {
+    const method: 'textDocument/semanticTokens';
+    const type: RegistrationType<SemanticTokensRegistrationOptions>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensRequest {
+    const method: 'textDocument/semanticTokens/full';
+    const type: ProtocolRequestType<SemanticTokensParams, SemanticTokens | null, SemanticTokensPartialResult, void, SemanticTokensRegistrationOptions>;
+    type HandlerSignature = RequestHandler<SemanticTokensDeltaParams, SemanticTokens | null, void>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDeltaParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The result id of a previous response. The result Id can either point to a full response
+     * or a delta response depending on what was received last.
+     */
+    previousResultId: string;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensDeltaRequest {
+    const method: 'textDocument/semanticTokens/full/delta';
+    const type: ProtocolRequestType<SemanticTokensDeltaParams, SemanticTokens | SemanticTokensDelta | null, SemanticTokensPartialResult | SemanticTokensDeltaPartialResult, void, SemanticTokensRegistrationOptions>;
+    type HandlerSignature = RequestHandler<SemanticTokensDeltaParams, SemanticTokens | SemanticTokensDelta | null, void>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensRangeParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The range the semantic tokens are requested for.
+     */
+    range: Range;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensRangeRequest {
+    const method: 'textDocument/semanticTokens/range';
+    const type: ProtocolRequestType<SemanticTokensRangeParams, SemanticTokens | null, SemanticTokensPartialResult, void, void>;
+    type HandlerSignature = RequestHandler<SemanticTokensRangeParams, SemanticTokens | null, void>;
+}
+export interface SemanticTokensWorkspaceClientCapabilities {
+    /**
+     * Whether the client implementation supports a refresh request sent from
+     * the server to the client.
+     *
+     * Note that this event is global and will force the client to refresh all
+     * semantic tokens currently shown. It should be used with absolute care
+     * and is useful for situation where a server for example detect a project
+     * wide change that requires such a calculation.
+     */
+    refreshSupport?: boolean;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensRefreshRequest {
+    const method: `workspace/semanticTokens/refresh`;
+    const type: ProtocolRequestType0<void, void, void, void>;
+    type HandlerSignature = RequestHandler0<void, void>;
+}

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

@@ -0,0 +1,119 @@
+"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.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = exports.SemanticTokens = exports.SemanticTokenModifiers = exports.SemanticTokenTypes = void 0;
+const messages_1 = require("./messages");
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0
+ */
+var SemanticTokenTypes;
+(function (SemanticTokenTypes) {
+    SemanticTokenTypes["namespace"] = "namespace";
+    /**
+     * Represents a generic type. Acts as a fallback for types which can't be mapped to
+     * a specific type like class or enum.
+     */
+    SemanticTokenTypes["type"] = "type";
+    SemanticTokenTypes["class"] = "class";
+    SemanticTokenTypes["enum"] = "enum";
+    SemanticTokenTypes["interface"] = "interface";
+    SemanticTokenTypes["struct"] = "struct";
+    SemanticTokenTypes["typeParameter"] = "typeParameter";
+    SemanticTokenTypes["parameter"] = "parameter";
+    SemanticTokenTypes["variable"] = "variable";
+    SemanticTokenTypes["property"] = "property";
+    SemanticTokenTypes["enumMember"] = "enumMember";
+    SemanticTokenTypes["event"] = "event";
+    SemanticTokenTypes["function"] = "function";
+    SemanticTokenTypes["method"] = "method";
+    SemanticTokenTypes["macro"] = "macro";
+    SemanticTokenTypes["keyword"] = "keyword";
+    SemanticTokenTypes["modifier"] = "modifier";
+    SemanticTokenTypes["comment"] = "comment";
+    SemanticTokenTypes["string"] = "string";
+    SemanticTokenTypes["number"] = "number";
+    SemanticTokenTypes["regexp"] = "regexp";
+    SemanticTokenTypes["operator"] = "operator";
+})(SemanticTokenTypes = exports.SemanticTokenTypes || (exports.SemanticTokenTypes = {}));
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0
+ */
+var SemanticTokenModifiers;
+(function (SemanticTokenModifiers) {
+    SemanticTokenModifiers["declaration"] = "declaration";
+    SemanticTokenModifiers["definition"] = "definition";
+    SemanticTokenModifiers["readonly"] = "readonly";
+    SemanticTokenModifiers["static"] = "static";
+    SemanticTokenModifiers["deprecated"] = "deprecated";
+    SemanticTokenModifiers["abstract"] = "abstract";
+    SemanticTokenModifiers["async"] = "async";
+    SemanticTokenModifiers["modification"] = "modification";
+    SemanticTokenModifiers["documentation"] = "documentation";
+    SemanticTokenModifiers["defaultLibrary"] = "defaultLibrary";
+})(SemanticTokenModifiers = exports.SemanticTokenModifiers || (exports.SemanticTokenModifiers = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokens;
+(function (SemanticTokens) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&
+            Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');
+    }
+    SemanticTokens.is = is;
+})(SemanticTokens = exports.SemanticTokens || (exports.SemanticTokens = {}));
+//------- 'textDocument/semanticTokens' -----
+var TokenFormat;
+(function (TokenFormat) {
+    TokenFormat.Relative = 'relative';
+})(TokenFormat = exports.TokenFormat || (exports.TokenFormat = {}));
+var SemanticTokensRegistrationType;
+(function (SemanticTokensRegistrationType) {
+    SemanticTokensRegistrationType.method = 'textDocument/semanticTokens';
+    SemanticTokensRegistrationType.type = new messages_1.RegistrationType(SemanticTokensRegistrationType.method);
+})(SemanticTokensRegistrationType = exports.SemanticTokensRegistrationType || (exports.SemanticTokensRegistrationType = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensRequest;
+(function (SemanticTokensRequest) {
+    SemanticTokensRequest.method = 'textDocument/semanticTokens/full';
+    SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method);
+})(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensDeltaRequest;
+(function (SemanticTokensDeltaRequest) {
+    SemanticTokensDeltaRequest.method = 'textDocument/semanticTokens/full/delta';
+    SemanticTokensDeltaRequest.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest.method);
+})(SemanticTokensDeltaRequest = exports.SemanticTokensDeltaRequest || (exports.SemanticTokensDeltaRequest = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensRangeRequest;
+(function (SemanticTokensRangeRequest) {
+    SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range';
+    SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method);
+})(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensRefreshRequest;
+(function (SemanticTokensRefreshRequest) {
+    SemanticTokensRefreshRequest.method = `workspace/semanticTokens/refresh`;
+    SemanticTokensRefreshRequest.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest.method);
+})(SemanticTokensRefreshRequest = exports.SemanticTokensRefreshRequest || (exports.SemanticTokensRefreshRequest = {}));
+//# sourceMappingURL=protocol.semanticTokens.js.map

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

@@ -0,0 +1,71 @@
+import { HandlerResult, RequestHandler } from 'vscode-jsonrpc';
+import { Range, URI } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+/**
+ * Client capabilities for the show document request.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentClientCapabilities {
+    /**
+     * The client has support for the show document
+     * request.
+     */
+    support: boolean;
+}
+/**
+ * Params to show a document.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentParams {
+    /**
+     * The document uri to show.
+     */
+    uri: URI;
+    /**
+     * Indicates to show the resource in an external program.
+     * To show for example `https://code.visualstudio.com/`
+     * in the default WEB browser set `external` to `true`.
+     */
+    external?: boolean;
+    /**
+     * An optional property to indicate whether the editor
+     * showing the document should take focus or not.
+     * Clients might ignore this property if an external
+     * program in started.
+     */
+    takeFocus?: boolean;
+    /**
+     * An optional selection range if the document is a text
+     * document. Clients might ignore the property if an
+     * external program is started or the file is not a text
+     * file.
+     */
+    selection?: Range;
+}
+/**
+ * The result of an show document request.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentResult {
+    /**
+     * A boolean indicating if the show was successful.
+     */
+    success: boolean;
+}
+/**
+ * A request to show a document. This request might open an
+ * external program depending on the value of the URI to open.
+ * For example a request to open `https://code.visualstudio.com/`
+ * will very likely open the URI in a WEB browser.
+ *
+ * @since 3.16.0
+*/
+export declare namespace ShowDocumentRequest {
+    const method: 'window/showDocument';
+    const type: ProtocolRequestType<ShowDocumentParams, ShowDocumentResult, void, void, void>;
+    type HandlerSignature = RequestHandler<ShowDocumentParams, ShowDocumentResult, void>;
+    type MiddlewareSignature = (params: ShowDocumentParams, next: HandlerSignature) => HandlerResult<ShowDocumentResult, void>;
+}

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

@@ -0,0 +1,22 @@
+"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.ShowDocumentRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to show a document. This request might open an
+ * external program depending on the value of the URI to open.
+ * For example a request to open `https://code.visualstudio.com/`
+ * will very likely open the URI in a WEB browser.
+ *
+ * @since 3.16.0
+*/
+var ShowDocumentRequest;
+(function (ShowDocumentRequest) {
+    ShowDocumentRequest.method = 'window/showDocument';
+    ShowDocumentRequest.type = new messages_1.ProtocolRequestType(ShowDocumentRequest.method);
+})(ShowDocumentRequest = exports.ShowDocumentRequest || (exports.ShowDocumentRequest = {}));
+//# sourceMappingURL=protocol.showDocument.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.d.ts

@@ -0,0 +1,38 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Definition, DefinitionLink, LocationLink, Location } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * Since 3.6.0
+ */
+export interface TypeDefinitionClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `TypeDefinitionRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports additional metadata in the form of definition links.
+     *
+     * Since 3.14.0
+     */
+    linkSupport?: boolean;
+}
+export interface TypeDefinitionOptions extends WorkDoneProgressOptions {
+}
+export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions {
+}
+export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+export declare namespace TypeDefinitionRequest {
+    const method: 'textDocument/typeDefinition';
+    const type: ProtocolRequestType<TypeDefinitionParams, Location | Location[] | LocationLink[] | null, Location[] | LocationLink[], void, TypeDefinitionRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TypeDefinitionParams, Definition | DefinitionLink[] | null, void>;
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js

@@ -0,0 +1,22 @@
+"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.TypeDefinitionRequest = void 0;
+const messages_1 = require("./messages");
+// @ts-ignore: to avoid inlining LocatioLink as dynamic import
+let __noDynamicImport;
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+var TypeDefinitionRequest;
+(function (TypeDefinitionRequest) {
+    TypeDefinitionRequest.method = 'textDocument/typeDefinition';
+    TypeDefinitionRequest.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest.method);
+})(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));
+//# sourceMappingURL=protocol.typeDefinition.js.map

node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.d.ts

@@ -0,0 +1,94 @@
+import { RequestHandler0, NotificationHandler, HandlerResult, CancellationToken } from 'vscode-jsonrpc';
+import { ProtocolRequestType0, ProtocolNotificationType } from './messages';
+export interface WorkspaceFoldersInitializeParams {
+    /**
+     * The actual configured workspace folders.
+     */
+    workspaceFolders: WorkspaceFolder[] | null;
+}
+export interface WorkspaceFoldersClientCapabilities {
+    /**
+     * The workspace client capabilities
+     */
+    workspace?: {
+        /**
+         * The client has support for workspace folders
+         *
+         * @since 3.6.0
+         */
+        workspaceFolders?: boolean;
+    };
+}
+export interface WorkspaceFoldersServerCapabilities {
+    /**
+     * The workspace server capabilities
+     */
+    workspace?: {
+        workspaceFolders?: {
+            /**
+             * The Server has support for workspace folders
+             */
+            supported?: boolean;
+            /**
+             * Whether the server wants to receive workspace folder
+             * change notifications.
+             *
+             * If a strings is provided the string is treated as a ID
+             * under which the notification is registered on the client
+             * side. The ID can be used to unregister for these events
+             * using the `client/unregisterCapability` request.
+             */
+            changeNotifications?: string | boolean;
+        };
+    };
+}
+export interface WorkspaceFolder {
+    /**
+     * The associated URI for this workspace folder.
+     */
+    uri: string;
+    /**
+     * The name of the workspace folder. Used to refer to this
+     * workspace folder in the user interface.
+     */
+    name: string;
+}
+/**
+ * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
+ */
+export declare namespace WorkspaceFoldersRequest {
+    const type: ProtocolRequestType0<WorkspaceFolder[] | null, never, void, void>;
+    type HandlerSignature = RequestHandler0<WorkspaceFolder[] | null, void>;
+    type MiddlewareSignature = (token: CancellationToken, next: HandlerSignature) => HandlerResult<WorkspaceFolder[] | null, void>;
+}
+/**
+ * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
+ * folder configuration changes.
+ */
+export declare namespace DidChangeWorkspaceFoldersNotification {
+    const type: ProtocolNotificationType<DidChangeWorkspaceFoldersParams, void>;
+    type HandlerSignature = NotificationHandler<DidChangeWorkspaceFoldersParams>;
+    type MiddlewareSignature = (params: DidChangeWorkspaceFoldersParams, next: HandlerSignature) => void;
+}
+/**
+ * The parameters of a `workspace/didChangeWorkspaceFolders` notification.
+ */
+export interface DidChangeWorkspaceFoldersParams {
+    /**
+     * The actual workspace folder change event.
+     */
+    event: WorkspaceFoldersChangeEvent;
+}
+/**
+ * The workspace folder change event.
+ */
+export interface WorkspaceFoldersChangeEvent {
+    /**
+     * The array of added workspace folders
+     */
+    added: WorkspaceFolder[];
+    /**
+     * The array of the removed workspace folders
+     */
+    removed: WorkspaceFolder[];
+}

node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js

@@ -0,0 +1,24 @@
+"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.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
+ */
+var WorkspaceFoldersRequest;
+(function (WorkspaceFoldersRequest) {
+    WorkspaceFoldersRequest.type = new messages_1.ProtocolRequestType0('workspace/workspaceFolders');
+})(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));
+/**
+ * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
+ * folder configuration changes.
+ */
+var DidChangeWorkspaceFoldersNotification;
+(function (DidChangeWorkspaceFoldersNotification) {
+    DidChangeWorkspaceFoldersNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWorkspaceFolders');
+})(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));
+//# sourceMappingURL=protocol.workspaceFolders.js.map

node_modules/vscode-languageserver-protocol/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 objectLiteral(value: any): value is object;

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

@@ -0,0 +1,47 @@
+/* --------------------------------------------------------------------------------------------
+ * 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.objectLiteral = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
+function boolean(value) {
+    return value === true || value === false;
+}
+exports.boolean = boolean;
+function string(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+exports.string = string;
+function number(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+exports.number = number;
+function error(value) {
+    return value instanceof Error;
+}
+exports.error = error;
+function func(value) {
+    return typeof value === 'function';
+}
+exports.func = func;
+function array(value) {
+    return Array.isArray(value);
+}
+exports.array = array;
+function stringArray(value) {
+    return array(value) && value.every(elem => string(elem));
+}
+exports.stringArray = stringArray;
+function typedArray(value, check) {
+    return Array.isArray(value) && value.every(check);
+}
+exports.typedArray = typedArray;
+function objectLiteral(value) {
+    // Strictly speaking class instances pass this check as well. Since the LSP
+    // doesn't use classes we ignore this for now. If we do we need to add something
+    // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`
+    return value !== null && typeof value === 'object';
+}
+exports.objectLiteral = objectLiteral;
+//# sourceMappingURL=is.js.map

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { MessageReader, MessageWriter, Logger, ConnectionStrategy, ConnectionOptions, ProtocolConnection } from '../common/api';
+export * from 'vscode-jsonrpc/node';
+export * from '../common/api';
+export declare function createProtocolConnection(input: MessageReader, output: MessageWriter, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): ProtocolConnection;
+export declare function createProtocolConnection(input: NodeJS.ReadableStream, output: NodeJS.WritableStream, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): ProtocolConnection;

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

@@ -0,0 +1,25 @@
+"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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.createProtocolConnection = void 0;
+const node_1 = require("vscode-jsonrpc/node");
+__exportStar(require("vscode-jsonrpc/node"), exports);
+__exportStar(require("../common/api"), exports);
+function createProtocolConnection(input, output, logger, options) {
+    return node_1.createMessageConnection(input, output, logger, options);
+}
+exports.createProtocolConnection = createProtocolConnection;
+//# sourceMappingURL=main.js.map

node_modules/vscode-languageserver-protocol/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-protocol/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-protocol/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-protocol/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "vscode-languageserver-protocol",
+	"description": "VSCode Language Server Protocol implementation",
+	"version": "3.16.0",
+	"author": "Microsoft Corporation",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
+		"directory": "protocol"
+	},
+	"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",
+	"dependencies": {
+		"vscode-jsonrpc": "6.0.0",
+		"vscode-languageserver-types": "3.16.0"
+	},
+	"scripts": {
+		"prepublishOnly": "git clean -xfd . && npm install && npm run clean && npm run compile && npm test",
+		"postpublish": "node ../build/npm/post-publish.js",
+		"preversion": "npm test",
+		"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 && node ../node_modules/rimraf/bin.js dist",
+		"test": "npm run test:node && npm run test:browser",
+		"test:node": "node ../node_modules/mocha/bin/_mocha",
+		"test:browser": "npm run webpack:test:silent && node ../build/bin/runBrowserTests.js  http://127.0.0.1:8080/protocol/src/browser/test/",
+		"webpack:test": "cd ../types && npm run compile:esm && cd ../protocol && node ../build/bin/webpack --mode none --config ./src/browser/test/webpack.config.js",
+		"webpack:test:silent": "cd ../types && npm run compile:esm && cd ../protocol && node ../build/bin/webpack --no-stats --mode none --config ./src/browser/test/webpack.config.js"
+	}
+}

node_modules/vscode-languageserver-protocol/thirdpartynotices.txt

@@ -0,0 +1,31 @@
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+For Microsoft vscode-languageclient
+
+This project incorporates material from the project(s) listed below (collectively, “Third Party Code”).
+Microsoft is not the original author of the Third Party Code.  The original copyright notice and license
+under which Microsoft received such Third Party Code are set out below. This Third Party Code is licensed
+to you under their original license terms set forth below.  Microsoft reserves all other rights not expressly
+granted, whether by implication, estoppel or otherwise.
+
+1.       DefinitelyTyped version 0.0.1 (https://github.com/borisyankov/DefinitelyTyped)
+
+This project is licensed under the MIT license.
+Copyrights are respective of each contributor listed at the beginning of each definition file.
+
+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.