initial commit

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

@@ -0,0 +1,5 @@
+export * from 'vscode-languageserver-protocol';
+export { Converter as Code2ProtocolConverter } from './codeConverter';
+export { Converter as Protocol2CodeConverter } from './protocolConverter';
+export * from './client';
+export * from './commonClient';

node_modules/vscode-languageclient/lib/common/api.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.
+ * ------------------------------------------------------------------------------------------ */
+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 });
+__exportStar(require("vscode-languageserver-protocol"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./commonClient"), exports);
+//# sourceMappingURL=api.js.map

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

@@ -0,0 +1,37 @@
+import { Disposable, TextDocument, ProviderResult, Position as VPosition, CallHierarchyItem as VCallHierarchyItem, CallHierarchyIncomingCall as VCallHierarchyIncomingCall, CallHierarchyOutgoingCall as VCallHierarchyOutgoingCall, CancellationToken, CallHierarchyProvider as VCallHierarchyProvider } from 'vscode';
+import { ClientCapabilities, ServerCapabilities, DocumentSelector, CallHierarchyOptions, CallHierarchyRegistrationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface PrepareCallHierarchySignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VCallHierarchyItem | VCallHierarchyItem[]>;
+}
+export interface CallHierarchyIncomingCallsSignature {
+    (this: void, item: VCallHierarchyItem, token: CancellationToken): ProviderResult<VCallHierarchyIncomingCall[]>;
+}
+export interface CallHierarchyOutgoingCallsSignature {
+    (this: void, item: VCallHierarchyItem, token: CancellationToken): ProviderResult<VCallHierarchyOutgoingCall[]>;
+}
+/**
+ * Call hierarchy middleware
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyMiddleware {
+    prepareCallHierarchy?: (this: void, document: TextDocument, positions: VPosition, token: CancellationToken, next: PrepareCallHierarchySignature) => ProviderResult<VCallHierarchyItem | VCallHierarchyItem[]>;
+    provideCallHierarchyIncomingCalls?: (this: void, item: VCallHierarchyItem, token: CancellationToken, next: CallHierarchyIncomingCallsSignature) => ProviderResult<VCallHierarchyIncomingCall[]>;
+    provideCallHierarchyOutgoingCalls?: (this: void, item: VCallHierarchyItem, token: CancellationToken, next: CallHierarchyOutgoingCallsSignature) => ProviderResult<VCallHierarchyOutgoingCall[]>;
+}
+declare class CallHierarchyProvider implements VCallHierarchyProvider {
+    private client;
+    private middleware;
+    constructor(client: BaseLanguageClient);
+    prepareCallHierarchy(document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VCallHierarchyItem | VCallHierarchyItem[]>;
+    provideCallHierarchyIncomingCalls(item: VCallHierarchyItem, token: CancellationToken): ProviderResult<VCallHierarchyIncomingCall[]>;
+    provideCallHierarchyOutgoingCalls(item: VCallHierarchyItem, token: CancellationToken): ProviderResult<VCallHierarchyOutgoingCall[]>;
+}
+export declare class CallHierarchyFeature extends TextDocumentFeature<boolean | CallHierarchyOptions, CallHierarchyRegistrationOptions, CallHierarchyProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(cap: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: CallHierarchyRegistrationOptions): [Disposable, CallHierarchyProvider];
+}
+export {};

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

@@ -0,0 +1,95 @@
+"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.CallHierarchyFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class CallHierarchyProvider {
+    constructor(client) {
+        this.client = client;
+        this.middleware = client.clientOptions.middleware;
+    }
+    prepareCallHierarchy(document, position, token) {
+        const client = this.client;
+        const middleware = this.middleware;
+        const prepareCallHierarchy = (document, position, token) => {
+            const params = client.code2ProtocolConverter.asTextDocumentPositionParams(document, position);
+            return client.sendRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, params, token).then((result) => {
+                return client.protocol2CodeConverter.asCallHierarchyItems(result);
+            }, (error) => {
+                return client.handleFailedRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, error, null);
+            });
+        };
+        return middleware.prepareCallHierarchy
+            ? middleware.prepareCallHierarchy(document, position, token, prepareCallHierarchy)
+            : prepareCallHierarchy(document, position, token);
+    }
+    provideCallHierarchyIncomingCalls(item, token) {
+        const client = this.client;
+        const middleware = this.middleware;
+        const provideCallHierarchyIncomingCalls = (item, token) => {
+            const params = {
+                item: client.code2ProtocolConverter.asCallHierarchyItem(item)
+            };
+            return client.sendRequest(vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type, params, token).then((result) => {
+                return client.protocol2CodeConverter.asCallHierarchyIncomingCalls(result);
+            }, (error) => {
+                return client.handleFailedRequest(vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type, error, null);
+            });
+        };
+        return middleware.provideCallHierarchyIncomingCalls
+            ? middleware.provideCallHierarchyIncomingCalls(item, token, provideCallHierarchyIncomingCalls)
+            : provideCallHierarchyIncomingCalls(item, token);
+    }
+    provideCallHierarchyOutgoingCalls(item, token) {
+        const client = this.client;
+        const middleware = this.middleware;
+        const provideCallHierarchyOutgoingCalls = (item, token) => {
+            const params = {
+                item: client.code2ProtocolConverter.asCallHierarchyItem(item)
+            };
+            return client.sendRequest(vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type, params, token).then((result) => {
+                return client.protocol2CodeConverter.asCallHierarchyOutgoingCalls(result);
+            }, (error) => {
+                return client.handleFailedRequest(vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type, error, null);
+            });
+        };
+        return middleware.provideCallHierarchyOutgoingCalls
+            ? middleware.provideCallHierarchyOutgoingCalls(item, token, provideCallHierarchyOutgoingCalls)
+            : provideCallHierarchyOutgoingCalls(item, token);
+    }
+}
+class CallHierarchyFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type);
+    }
+    fillClientCapabilities(cap) {
+        const capabilities = cap;
+        const capability = ensure(ensure(capabilities, 'textDocument'), 'callHierarchy');
+        capability.dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const [id, options] = this.getRegistration(documentSelector, capabilities.callHierarchyProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const client = this._client;
+        const provider = new CallHierarchyProvider(client);
+        return [vscode_1.languages.registerCallHierarchyProvider(options.documentSelector, provider), provider];
+    }
+}
+exports.CallHierarchyFeature = CallHierarchyFeature;
+//# sourceMappingURL=callHierarchy.js.map

node_modules/vscode-languageclient/lib/common/client.d.ts

@@ -0,0 +1,575 @@
+import { TextDocumentChangeEvent, TextDocument, Disposable, OutputChannel, FileSystemWatcher as VFileSystemWatcher, DiagnosticCollection, Diagnostic as VDiagnostic, Uri, ProviderResult, CancellationToken, Position as VPosition, Location as VLocation, Range as VRange, CompletionItem as VCompletionItem, CompletionList as VCompletionList, SignatureHelp as VSignatureHelp, SignatureHelpContext as VSignatureHelpContext, Definition as VDefinition, DefinitionLink as VDefinitionLink, DocumentHighlight as VDocumentHighlight, SymbolInformation as VSymbolInformation, CodeActionContext as VCodeActionContext, Command as VCommand, CodeLens as VCodeLens, FormattingOptions as VFormattingOptions, TextEdit as VTextEdit, WorkspaceEdit as VWorkspaceEdit, Hover as VHover, CodeAction as VCodeAction, DocumentSymbol as VDocumentSymbol, DocumentLink as VDocumentLink, TextDocumentWillSaveEvent, WorkspaceFolder as VWorkspaceFolder, CompletionContext as VCompletionContext, CompletionItemProvider, HoverProvider, SignatureHelpProvider, DefinitionProvider, ReferenceProvider, DocumentHighlightProvider, CodeActionProvider, DocumentSymbolProvider, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider, OnTypeFormattingEditProvider, RenameProvider, DocumentLinkProvider, DocumentColorProvider, DeclarationProvider, FoldingRangeProvider, ImplementationProvider, SelectionRangeProvider, TypeDefinitionProvider, WorkspaceSymbolProvider, CallHierarchyProvider, FileWillCreateEvent, FileWillRenameEvent, FileWillDeleteEvent, FileCreateEvent, FileDeleteEvent, FileRenameEvent, LinkedEditingRangeProvider } from 'vscode';
+import { Message, MessageSignature, ResponseError, RequestType0, RequestType, NotificationType0, NotificationType, ProtocolRequestType, ProtocolRequestType0, RequestHandler, RequestHandler0, GenericRequestHandler, ProtocolNotificationType, ProtocolNotificationType0, NotificationHandler, NotificationHandler0, GenericNotificationHandler, MessageReader, MessageWriter, Trace, Event, ClientCapabilities, TextDocumentRegistrationOptions, InitializeParams, InitializeResult, InitializeError, ServerCapabilities, DocumentSelector, DidOpenTextDocumentNotification, DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, DidSaveTextDocumentNotification, WillSaveTextDocumentNotification, WillSaveTextDocumentWaitUntilRequest, FileEvent, CompletionRequest, HoverRequest, SignatureHelpRequest, DefinitionRequest, ReferencesRequest, DocumentHighlightRequest, DocumentSymbolRequest, WorkspaceSymbolRequest, CodeActionRequest, DocumentFormattingRequest, DocumentRangeFormattingRequest, DocumentOnTypeFormattingRequest, RenameRequest, DocumentLinkRequest, ProgressType, ProgressToken, StaticRegistrationOptions, DocumentColorRequest, DeclarationRequest, FoldingRangeRequest, ImplementationRequest, SelectionRangeRequest, TypeDefinitionRequest, CallHierarchyPrepareRequest, CancellationStrategy, RegistrationType, SemanticTokensRegistrationType, ShowDocumentRequest, FileOperationRegistrationOptions, WillCreateFilesRequest, WillRenameFilesRequest, WillDeleteFilesRequest, DidCreateFilesNotification, DidDeleteFilesNotification, DidRenameFilesNotification, ShowDocumentParams, ShowDocumentResult, LinkedEditingRangeRequest, WorkDoneProgressBegin, WorkDoneProgressEnd, WorkDoneProgressReport } from 'vscode-languageserver-protocol';
+import type { ColorProviderMiddleware } from './colorProvider';
+import type { ImplementationMiddleware } from './implementation';
+import type { TypeDefinitionMiddleware } from './typeDefinition';
+import { ConfigurationWorkspaceMiddleware } from './configuration';
+import type { WorkspaceFolderWorkspaceMiddleware } from './workspaceFolders';
+import type { FoldingRangeProviderMiddleware } from './foldingRange';
+import type { DeclarationMiddleware } from './declaration';
+import type { SelectionRangeProviderMiddleware } from './selectionRange';
+import type { CallHierarchyMiddleware } from './callHierarchy';
+import type { SemanticTokensMiddleware, SemanticTokensProviders } from './semanticTokens';
+import type { FileOperationsMiddleware } from './fileOperations';
+import { LinkedEditingRangeMiddleware } from './linkedEditingRange';
+import * as c2p from './codeConverter';
+import * as p2c from './protocolConverter';
+interface ConnectionOptions {
+    cancellationStrategy: CancellationStrategy;
+    maxRestartCount?: number;
+}
+/**
+ * An action to be performed when the connection is producing errors.
+ */
+export declare enum ErrorAction {
+    /**
+     * Continue running the server.
+     */
+    Continue = 1,
+    /**
+     * Shutdown the server.
+     */
+    Shutdown = 2
+}
+/**
+ * An action to be performed when the connection to a server got closed.
+ */
+export declare enum CloseAction {
+    /**
+     * Don't restart the server. The connection stays closed.
+     */
+    DoNotRestart = 1,
+    /**
+     * Restart the server.
+     */
+    Restart = 2
+}
+/**
+ * A plugable error handler that is invoked when the connection is either
+ * producing errors or got closed.
+ */
+export interface ErrorHandler {
+    /**
+     * An error has occurred while writing or reading from the connection.
+     *
+     * @param error - the error received
+     * @param message - the message to be delivered to the server if know.
+     * @param count - a count indicating how often an error is received. Will
+     *  be reset if a message got successfully send or received.
+     */
+    error(error: Error, message: Message | undefined, count: number | undefined): ErrorAction;
+    /**
+     * The connection to the server got closed.
+     */
+    closed(): CloseAction;
+}
+/**
+ * A handler that is invoked when the initialization of the server failed.
+ */
+export interface InitializationFailedHandler {
+    /**
+     * @param error The error returned from the server
+     * @returns if true is returned the client tries to reinitialize the server.
+     *  Implementors of a handler are responsible to not initialize the server
+     *  infinitely. Return false if initialization should stop and an error
+     *  should be reported.
+     */
+    (error: ResponseError<InitializeError> | Error | any): boolean;
+}
+export interface SynchronizeOptions {
+    /**
+     * The configuration sections to synchronize. Pushing settings from the
+     * client to the server is deprecated in favour of the new pull model
+     * that allows servers to query settings scoped on resources. In this
+     * model the client can only deliver an empty change event since the
+     * actually setting value can vary on the provided resource scope.
+     *
+     * @deprecated Use the new pull model (`workspace/configuration` request)
+     */
+    configurationSection?: string | string[];
+    /**
+     * Asks the client to send file change events to the server. Watchers
+     * operate on workspace folders. The LSP client doesn't support watching
+     * files outside a workspace folder.
+     */
+    fileEvents?: VFileSystemWatcher | VFileSystemWatcher[];
+}
+export declare enum RevealOutputChannelOn {
+    Info = 1,
+    Warn = 2,
+    Error = 3,
+    Never = 4
+}
+export interface HandleDiagnosticsSignature {
+    (this: void, uri: Uri, diagnostics: VDiagnostic[]): void;
+}
+export interface HandleWorkDoneProgressSignature {
+    (this: void, token: ProgressToken, params: WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd): void;
+}
+export interface ProvideCompletionItemsSignature {
+    (this: void, document: TextDocument, position: VPosition, context: VCompletionContext, token: CancellationToken): ProviderResult<VCompletionItem[] | VCompletionList>;
+}
+export interface ResolveCompletionItemSignature {
+    (this: void, item: VCompletionItem, token: CancellationToken): ProviderResult<VCompletionItem>;
+}
+export interface ProvideHoverSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VHover>;
+}
+export interface ProvideSignatureHelpSignature {
+    (this: void, document: TextDocument, position: VPosition, context: VSignatureHelpContext, token: CancellationToken): ProviderResult<VSignatureHelp>;
+}
+export interface ProvideDefinitionSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export interface ProvideReferencesSignature {
+    (this: void, document: TextDocument, position: VPosition, options: {
+        includeDeclaration: boolean;
+    }, token: CancellationToken): ProviderResult<VLocation[]>;
+}
+export interface ProvideDocumentHighlightsSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDocumentHighlight[]>;
+}
+export interface ProvideDocumentSymbolsSignature {
+    (this: void, document: TextDocument, token: CancellationToken): ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;
+}
+export interface ProvideWorkspaceSymbolsSignature {
+    (this: void, query: string, token: CancellationToken): ProviderResult<VSymbolInformation[]>;
+}
+export interface ProvideCodeActionsSignature {
+    (this: void, document: TextDocument, range: VRange, context: VCodeActionContext, token: CancellationToken): ProviderResult<(VCommand | VCodeAction)[]>;
+}
+export interface ResolveCodeActionSignature {
+    (this: void, item: VCodeAction, token: CancellationToken): ProviderResult<VCodeAction>;
+}
+export interface ProvideCodeLensesSignature {
+    (this: void, document: TextDocument, token: CancellationToken): ProviderResult<VCodeLens[]>;
+}
+export interface ResolveCodeLensSignature {
+    (this: void, codeLens: VCodeLens, token: CancellationToken): ProviderResult<VCodeLens>;
+}
+export interface ProvideDocumentFormattingEditsSignature {
+    (this: void, document: TextDocument, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface ProvideDocumentRangeFormattingEditsSignature {
+    (this: void, document: TextDocument, range: VRange, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface ProvideOnTypeFormattingEditsSignature {
+    (this: void, document: TextDocument, position: VPosition, ch: string, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface ProvideRenameEditsSignature {
+    (this: void, document: TextDocument, position: VPosition, newName: string, token: CancellationToken): ProviderResult<VWorkspaceEdit>;
+}
+export interface PrepareRenameSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VRange | {
+        range: VRange;
+        placeholder: string;
+    }>;
+}
+export interface ProvideDocumentLinksSignature {
+    (this: void, document: TextDocument, token: CancellationToken): ProviderResult<VDocumentLink[]>;
+}
+export interface ResolveDocumentLinkSignature {
+    (this: void, link: VDocumentLink, token: CancellationToken): ProviderResult<VDocumentLink>;
+}
+export interface ExecuteCommandSignature {
+    (this: void, command: string, args: any[]): ProviderResult<any>;
+}
+export interface NextSignature<P, R> {
+    (this: void, data: P, next: (data: P) => R): R;
+}
+export interface DidChangeConfigurationSignature {
+    (this: void, sections: string[] | undefined): void;
+}
+export interface DidChangeWatchedFileSignature {
+    (this: void, event: FileEvent): void;
+}
+export interface _WorkspaceMiddleware {
+    didChangeConfiguration?: (this: void, sections: string[] | undefined, next: DidChangeConfigurationSignature) => void;
+    didChangeWatchedFile?: (this: void, event: FileEvent, next: DidChangeWatchedFileSignature) => void;
+}
+export declare type WorkspaceMiddleware = _WorkspaceMiddleware & ConfigurationWorkspaceMiddleware & WorkspaceFolderWorkspaceMiddleware & FileOperationsMiddleware;
+export interface _WindowMiddleware {
+    showDocument?: (this: void, params: ShowDocumentParams, next: ShowDocumentRequest.HandlerSignature) => Promise<ShowDocumentResult>;
+}
+export declare type WindowMiddleware = _WindowMiddleware;
+/**
+ * The Middleware lets extensions intercept the request and notifications send and received
+ * from the server
+ */
+export interface _Middleware {
+    didOpen?: NextSignature<TextDocument, void>;
+    didChange?: NextSignature<TextDocumentChangeEvent, void>;
+    willSave?: NextSignature<TextDocumentWillSaveEvent, void>;
+    willSaveWaitUntil?: NextSignature<TextDocumentWillSaveEvent, Thenable<VTextEdit[]>>;
+    didSave?: NextSignature<TextDocument, void>;
+    didClose?: NextSignature<TextDocument, void>;
+    handleDiagnostics?: (this: void, uri: Uri, diagnostics: VDiagnostic[], next: HandleDiagnosticsSignature) => void;
+    handleWorkDoneProgress?: (this: void, token: ProgressToken, params: WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd, next: HandleWorkDoneProgressSignature) => void;
+    provideCompletionItem?: (this: void, document: TextDocument, position: VPosition, context: VCompletionContext, token: CancellationToken, next: ProvideCompletionItemsSignature) => ProviderResult<VCompletionItem[] | VCompletionList>;
+    resolveCompletionItem?: (this: void, item: VCompletionItem, token: CancellationToken, next: ResolveCompletionItemSignature) => ProviderResult<VCompletionItem>;
+    provideHover?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideHoverSignature) => ProviderResult<VHover>;
+    provideSignatureHelp?: (this: void, document: TextDocument, position: VPosition, context: VSignatureHelpContext, token: CancellationToken, next: ProvideSignatureHelpSignature) => ProviderResult<VSignatureHelp>;
+    provideDefinition?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDefinitionSignature) => ProviderResult<VDefinition | VDefinitionLink[]>;
+    provideReferences?: (this: void, document: TextDocument, position: VPosition, options: {
+        includeDeclaration: boolean;
+    }, token: CancellationToken, next: ProvideReferencesSignature) => ProviderResult<VLocation[]>;
+    provideDocumentHighlights?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDocumentHighlightsSignature) => ProviderResult<VDocumentHighlight[]>;
+    provideDocumentSymbols?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideDocumentSymbolsSignature) => ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;
+    provideWorkspaceSymbols?: (this: void, query: string, token: CancellationToken, next: ProvideWorkspaceSymbolsSignature) => ProviderResult<VSymbolInformation[]>;
+    provideCodeActions?: (this: void, document: TextDocument, range: VRange, context: VCodeActionContext, token: CancellationToken, next: ProvideCodeActionsSignature) => ProviderResult<(VCommand | VCodeAction)[]>;
+    resolveCodeAction?: (this: void, item: VCodeAction, token: CancellationToken, next: ResolveCodeActionSignature) => ProviderResult<VCodeAction>;
+    provideCodeLenses?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideCodeLensesSignature) => ProviderResult<VCodeLens[]>;
+    resolveCodeLens?: (this: void, codeLens: VCodeLens, token: CancellationToken, next: ResolveCodeLensSignature) => ProviderResult<VCodeLens>;
+    provideDocumentFormattingEdits?: (this: void, document: TextDocument, options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+    provideDocumentRangeFormattingEdits?: (this: void, document: TextDocument, range: VRange, options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentRangeFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+    provideOnTypeFormattingEdits?: (this: void, document: TextDocument, position: VPosition, ch: string, options: VFormattingOptions, token: CancellationToken, next: ProvideOnTypeFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+    provideRenameEdits?: (this: void, document: TextDocument, position: VPosition, newName: string, token: CancellationToken, next: ProvideRenameEditsSignature) => ProviderResult<VWorkspaceEdit>;
+    prepareRename?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: PrepareRenameSignature) => ProviderResult<VRange | {
+        range: VRange;
+        placeholder: string;
+    }>;
+    provideDocumentLinks?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideDocumentLinksSignature) => ProviderResult<VDocumentLink[]>;
+    resolveDocumentLink?: (this: void, link: VDocumentLink, token: CancellationToken, next: ResolveDocumentLinkSignature) => ProviderResult<VDocumentLink>;
+    executeCommand?: (this: void, command: string, args: any[], next: ExecuteCommandSignature) => ProviderResult<any>;
+    workspace?: WorkspaceMiddleware;
+    window?: WindowMiddleware;
+}
+export declare type Middleware = _Middleware & TypeDefinitionMiddleware & ImplementationMiddleware & ColorProviderMiddleware & FoldingRangeProviderMiddleware & DeclarationMiddleware & SelectionRangeProviderMiddleware & CallHierarchyMiddleware & SemanticTokensMiddleware & LinkedEditingRangeMiddleware;
+export interface LanguageClientOptions {
+    documentSelector?: DocumentSelector | string[];
+    synchronize?: SynchronizeOptions;
+    diagnosticCollectionName?: string;
+    outputChannel?: OutputChannel;
+    outputChannelName?: string;
+    traceOutputChannel?: OutputChannel;
+    revealOutputChannelOn?: RevealOutputChannelOn;
+    /**
+     * The encoding use to read stdout and stderr. Defaults
+     * to 'utf8' if omitted.
+     */
+    stdioEncoding?: string;
+    initializationOptions?: any | (() => any);
+    initializationFailedHandler?: InitializationFailedHandler;
+    progressOnInitialization?: boolean;
+    errorHandler?: ErrorHandler;
+    middleware?: Middleware;
+    uriConverters?: {
+        code2Protocol: c2p.URIConverter;
+        protocol2Code: p2c.URIConverter;
+    };
+    workspaceFolder?: VWorkspaceFolder;
+    connectionOptions?: ConnectionOptions;
+    markdown?: {
+        isTrusted?: boolean;
+    };
+}
+export declare enum State {
+    Stopped = 1,
+    Starting = 3,
+    Running = 2
+}
+export interface StateChangeEvent {
+    oldState: State;
+    newState: State;
+}
+export interface RegistrationData<T> {
+    id: string;
+    registerOptions: T;
+}
+/**
+ * A static feature. A static feature can't be dynamically activate via the
+ * server. It is wired during the initialize sequence.
+ */
+export interface StaticFeature {
+    /**
+     * Called to fill the initialize params.
+     *
+     * @params the initialize params.
+     */
+    fillInitializeParams?: (params: InitializeParams) => void;
+    /**
+     * Called to fill in the client capabilities this feature implements.
+     *
+     * @param capabilities The client capabilities to fill.
+     */
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    /**
+     * Initialize the feature. This method is called on a feature instance
+     * when the client has successfully received the initialize request from
+     * the server and before the client sends the initialized notification
+     * to the server.
+     *
+     * @param capabilities the server capabilities
+     * @param documentSelector the document selector pass to the client's constructor.
+     *  May be `undefined` if the client was created without a selector.
+     */
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector | undefined): void;
+    /**
+     * Called when the client is stopped to dispose this feature. Usually a feature
+     * un-registers listeners registered hooked up with the VS Code extension host.
+     */
+    dispose(): void;
+}
+export interface DynamicFeature<RO> {
+    /**
+     * Called to fill the initialize params.
+     *
+     * @params the initialize params.
+     */
+    fillInitializeParams?: (params: InitializeParams) => void;
+    /**
+     * Called to fill in the client capabilities this feature implements.
+     *
+     * @param capabilities The client capabilities to fill.
+     */
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    /**
+     * Initialize the feature. This method is called on a feature instance
+     * when the client has successfully received the initialize request from
+     * the server and before the client sends the initialized notification
+     * to the server.
+     *
+     * @param capabilities the server capabilities.
+     * @param documentSelector the document selector pass to the client's constructor.
+     *  May be `undefined` if the client was created without a selector.
+     */
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector | undefined): void;
+    /**
+     * The signature (e.g. method) for which this features support dynamic activation / registration.
+     */
+    registrationType: RegistrationType<RO>;
+    /**
+     * Is called when the server send a register request for the given message.
+     *
+     * @param data additional registration data as defined in the protocol.
+     */
+    register(data: RegistrationData<RO>): void;
+    /**
+     * Is called when the server wants to unregister a feature.
+     *
+     * @param id the id used when registering the feature.
+     */
+    unregister(id: string): void;
+    /**
+     * Called when the client is stopped to dispose this feature. Usually a feature
+     * un-registers listeners registered hooked up with the VS Code extension host.
+     */
+    dispose(): void;
+}
+export interface NotificationFeature<T extends Function> {
+    /**
+     * Triggers the corresponding RPC method.
+     */
+    getProvider(document: TextDocument): {
+        send: T;
+    } | undefined;
+}
+export interface TextDocumentProviderFeature<T> {
+    /**
+     * Triggers the corresponding RPC method.
+     */
+    getProvider(textDocument: TextDocument): T | undefined;
+}
+export declare abstract class TextDocumentFeature<PO, RO extends TextDocumentRegistrationOptions & PO, PR> implements DynamicFeature<RO> {
+    protected _client: BaseLanguageClient;
+    private _registrationType;
+    private _registrations;
+    constructor(_client: BaseLanguageClient, _registrationType: RegistrationType<RO>);
+    get registrationType(): RegistrationType<RO>;
+    abstract fillClientCapabilities(capabilities: ClientCapabilities): void;
+    abstract initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    register(data: RegistrationData<RO>): void;
+    protected abstract registerLanguageProvider(options: RO): [Disposable, PR];
+    unregister(id: string): void;
+    dispose(): void;
+    protected getRegistration(documentSelector: DocumentSelector | undefined, capability: undefined | PO | (RO & StaticRegistrationOptions)): [string | undefined, (RO & {
+        documentSelector: DocumentSelector;
+    }) | undefined];
+    protected getRegistrationOptions(documentSelector: DocumentSelector | undefined, capability: undefined | PO): (RO & {
+        documentSelector: DocumentSelector;
+    }) | undefined;
+    getProvider(textDocument: TextDocument): PR | undefined;
+    protected getAllProviders(): Iterable<PR>;
+}
+export interface WorkspaceProviderFeature<PR> {
+    getProviders(): PR[] | undefined;
+}
+export interface ProvideResolveFeature<T1 extends Function, T2 extends Function> {
+    provide: T1;
+    resolve: T2;
+}
+declare module 'vscode' {
+    interface CodeActionProvider<T extends CodeAction = CodeAction> {
+        resolveCodeAction?(codeAction: T, token: CancellationToken): ProviderResult<T>;
+    }
+}
+export interface MessageTransports {
+    reader: MessageReader;
+    writer: MessageWriter;
+    detached?: boolean;
+}
+export declare namespace MessageTransports {
+    function is(value: any): value is MessageTransports;
+}
+export declare abstract class BaseLanguageClient {
+    private _id;
+    private _name;
+    private _clientOptions;
+    private _state;
+    private _onReady;
+    private _onReadyCallbacks;
+    private _onStop;
+    private _connectionPromise;
+    private _resolvedConnection;
+    private _initializeResult;
+    private _outputChannel;
+    private _disposeOutputChannel;
+    private _traceOutputChannel;
+    private _capabilities;
+    private _listeners;
+    private _providers;
+    private _diagnostics;
+    private _syncedDocuments;
+    private _fileEvents;
+    private _fileEventDelayer;
+    private _telemetryEmitter;
+    private _stateChangeEmitter;
+    private _trace;
+    private _traceFormat;
+    private _tracer;
+    private _c2p;
+    private _p2c;
+    constructor(id: string, name: string, clientOptions: LanguageClientOptions);
+    private get state();
+    private set state(value);
+    private getPublicState;
+    get initializeResult(): InitializeResult | undefined;
+    sendRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, params: P, token?: CancellationToken): Promise<R>;
+    sendRequest<R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, E>(type: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R>;
+    sendRequest<R>(method: string, token?: CancellationToken): Promise<R>;
+    sendRequest<R>(method: string, param: any, token?: CancellationToken): Promise<R>;
+    onRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, handler: RequestHandler0<R, E>): Disposable;
+    onRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, handler: RequestHandler<P, R, E>): Disposable;
+    onRequest<R, E>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable;
+    onRequest<P, R, E>(type: RequestType<P, R, E>, handler: RequestHandler<P, R, E>): Disposable;
+    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): Disposable;
+    sendNotification<RO>(type: ProtocolNotificationType0<RO>): void;
+    sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params?: P): void;
+    sendNotification(type: NotificationType0): void;
+    sendNotification<P>(type: NotificationType<P>, params?: P): void;
+    sendNotification(method: string): void;
+    sendNotification(method: string, params: any): void;
+    onNotification<RO>(type: ProtocolNotificationType0<RO>, handler: NotificationHandler0): Disposable;
+    onNotification<P, RO>(type: ProtocolNotificationType<P, RO>, handler: NotificationHandler<P>): Disposable;
+    onNotification(type: NotificationType0, handler: NotificationHandler0): Disposable;
+    onNotification<P>(type: NotificationType<P>, handler: NotificationHandler<P>): Disposable;
+    onNotification(method: string, handler: GenericNotificationHandler): Disposable;
+    onProgress<P>(type: ProgressType<P>, token: string | number, handler: NotificationHandler<P>): Disposable;
+    sendProgress<P>(type: ProgressType<P>, token: string | number, value: P): void;
+    get clientOptions(): LanguageClientOptions;
+    get protocol2CodeConverter(): p2c.Converter;
+    get code2ProtocolConverter(): c2p.Converter;
+    get onTelemetry(): Event<any>;
+    get onDidChangeState(): Event<StateChangeEvent>;
+    get outputChannel(): OutputChannel;
+    get traceOutputChannel(): OutputChannel;
+    get diagnostics(): DiagnosticCollection | undefined;
+    createDefaultErrorHandler(maxRestartCount?: number): ErrorHandler;
+    set trace(value: Trace);
+    private data2String;
+    info(message: string, data?: any, showNotification?: boolean): void;
+    warn(message: string, data?: any, showNotification?: boolean): void;
+    error(message: string, data?: any, showNotification?: boolean): void;
+    private showNotificationMessage;
+    private logTrace;
+    private logObjectTrace;
+    needsStart(): boolean;
+    needsStop(): boolean;
+    onReady(): Promise<void>;
+    private isConnectionActive;
+    start(): Disposable;
+    private resolveConnection;
+    private initialize;
+    private doInitialize;
+    private _clientGetRootPath;
+    stop(): Promise<void>;
+    private cleanUp;
+    private cleanUpChannel;
+    private notifyFileEvent;
+    private _didChangeTextDocumentFeature;
+    private forceDocumentSync;
+    private handleDiagnostics;
+    private setDiagnostics;
+    protected abstract getLocale(): string;
+    protected abstract createMessageTransports(encoding: string): Promise<MessageTransports>;
+    private createConnection;
+    protected handleConnectionClosed(): void;
+    private handleConnectionError;
+    private hookConfigurationChanged;
+    private refreshTrace;
+    private hookFileEvents;
+    private readonly _features;
+    private readonly _dynamicFeatures;
+    registerFeatures(features: (StaticFeature | DynamicFeature<any>)[]): void;
+    registerFeature(feature: StaticFeature | DynamicFeature<any>): void;
+    getFeature(request: typeof DidOpenTextDocumentNotification.method): DynamicFeature<TextDocumentRegistrationOptions> & NotificationFeature<(textDocument: TextDocument) => void>;
+    getFeature(request: typeof DidChangeTextDocumentNotification.method): DynamicFeature<TextDocumentRegistrationOptions> & NotificationFeature<(textDocument: TextDocument) => void>;
+    getFeature(request: typeof WillSaveTextDocumentNotification.method): DynamicFeature<TextDocumentRegistrationOptions> & NotificationFeature<(textDocument: TextDocument) => void>;
+    getFeature(request: typeof WillSaveTextDocumentWaitUntilRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & NotificationFeature<(textDocument: TextDocument) => ProviderResult<VTextEdit[]>>;
+    getFeature(request: typeof DidSaveTextDocumentNotification.method): DynamicFeature<TextDocumentRegistrationOptions> & NotificationFeature<(textDocument: TextDocument) => void>;
+    getFeature(request: typeof DidCloseTextDocumentNotification.method): DynamicFeature<TextDocumentRegistrationOptions> & NotificationFeature<(textDocument: TextDocument) => void>;
+    getFeature(request: typeof DidCreateFilesNotification.method): DynamicFeature<FileOperationRegistrationOptions> & {
+        send: (event: FileCreateEvent) => Promise<void>;
+    };
+    getFeature(request: typeof DidRenameFilesNotification.method): DynamicFeature<FileOperationRegistrationOptions> & {
+        send: (event: FileRenameEvent) => Promise<void>;
+    };
+    getFeature(request: typeof DidDeleteFilesNotification.method): DynamicFeature<FileOperationRegistrationOptions> & {
+        send: (event: FileDeleteEvent) => Promise<void>;
+    };
+    getFeature(request: typeof WillCreateFilesRequest.method): DynamicFeature<FileOperationRegistrationOptions> & {
+        send: (event: FileWillCreateEvent) => Promise<void>;
+    };
+    getFeature(request: typeof WillRenameFilesRequest.method): DynamicFeature<FileOperationRegistrationOptions> & {
+        send: (event: FileWillRenameEvent) => Promise<void>;
+    };
+    getFeature(request: typeof WillDeleteFilesRequest.method): DynamicFeature<FileOperationRegistrationOptions> & {
+        send: (event: FileWillDeleteEvent) => Promise<void>;
+    };
+    getFeature(request: typeof CompletionRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<CompletionItemProvider>;
+    getFeature(request: typeof HoverRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<HoverProvider>;
+    getFeature(request: typeof SignatureHelpRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<SignatureHelpProvider>;
+    getFeature(request: typeof DefinitionRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DefinitionProvider>;
+    getFeature(request: typeof ReferencesRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<ReferenceProvider>;
+    getFeature(request: typeof DocumentHighlightRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DocumentHighlightProvider>;
+    getFeature(request: typeof CodeActionRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<CodeActionProvider>;
+    getFeature(request: typeof DocumentFormattingRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DocumentFormattingEditProvider>;
+    getFeature(request: typeof DocumentRangeFormattingRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DocumentRangeFormattingEditProvider>;
+    getFeature(request: typeof DocumentOnTypeFormattingRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<OnTypeFormattingEditProvider>;
+    getFeature(request: typeof RenameRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<RenameProvider>;
+    getFeature(request: typeof DocumentSymbolRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DocumentSymbolProvider>;
+    getFeature(request: typeof DocumentLinkRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DocumentLinkProvider>;
+    getFeature(request: typeof DocumentColorRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DocumentColorProvider>;
+    getFeature(request: typeof DeclarationRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<DeclarationProvider>;
+    getFeature(request: typeof FoldingRangeRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<FoldingRangeProvider>;
+    getFeature(request: typeof ImplementationRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<ImplementationProvider>;
+    getFeature(request: typeof SelectionRangeRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<SelectionRangeProvider>;
+    getFeature(request: typeof TypeDefinitionRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<TypeDefinitionProvider>;
+    getFeature(request: typeof CallHierarchyPrepareRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<CallHierarchyProvider>;
+    getFeature(request: typeof SemanticTokensRegistrationType.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<SemanticTokensProviders>;
+    getFeature(request: typeof LinkedEditingRangeRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & TextDocumentProviderFeature<LinkedEditingRangeProvider>;
+    getFeature(request: typeof WorkspaceSymbolRequest.method): DynamicFeature<TextDocumentRegistrationOptions> & WorkspaceProviderFeature<WorkspaceSymbolProvider>;
+    protected registerBuiltinFeatures(): void;
+    protected fillInitializeParams(params: InitializeParams): void;
+    private computeClientCapabilities;
+    private initializeFeatures;
+    private handleRegistrationRequest;
+    private handleUnregistrationRequest;
+    private handleApplyWorkspaceEdit;
+    handleFailedRequest<T>(type: MessageSignature, error: any, defaultValue: T): T;
+    private static Canceled;
+    private makeCancelError;
+}
+export {};

node_modules/vscode-languageclient/lib/common/codeConverter.d.ts

@@ -0,0 +1,68 @@
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+import { CreateFilesParams, DeleteFilesParams, RenameFilesParams } from 'vscode-languageserver-protocol/lib/common/protocol.fileOperations';
+export interface FileFormattingOptions {
+    trimTrailingWhitespace?: boolean;
+    trimFinalNewlines?: boolean;
+    insertFinalNewline?: boolean;
+}
+export interface Converter {
+    asUri(uri: code.Uri): string;
+    asTextDocumentIdentifier(textDocument: code.TextDocument): proto.TextDocumentIdentifier;
+    asVersionedTextDocumentIdentifier(textDocument: code.TextDocument): proto.VersionedTextDocumentIdentifier;
+    asOpenTextDocumentParams(textDocument: code.TextDocument): proto.DidOpenTextDocumentParams;
+    asChangeTextDocumentParams(textDocument: code.TextDocument): proto.DidChangeTextDocumentParams;
+    asChangeTextDocumentParams(event: code.TextDocumentChangeEvent): proto.DidChangeTextDocumentParams;
+    asCloseTextDocumentParams(textDocument: code.TextDocument): proto.DidCloseTextDocumentParams;
+    asSaveTextDocumentParams(textDocument: code.TextDocument, includeContent?: boolean): proto.DidSaveTextDocumentParams;
+    asWillSaveTextDocumentParams(event: code.TextDocumentWillSaveEvent): proto.WillSaveTextDocumentParams;
+    asDidCreateFilesParams(event: code.FileCreateEvent): CreateFilesParams;
+    asDidRenameFilesParams(event: code.FileRenameEvent): RenameFilesParams;
+    asDidDeleteFilesParams(event: code.FileDeleteEvent): DeleteFilesParams;
+    asWillCreateFilesParams(event: code.FileCreateEvent): CreateFilesParams;
+    asWillRenameFilesParams(event: code.FileRenameEvent): RenameFilesParams;
+    asWillDeleteFilesParams(event: code.FileDeleteEvent): DeleteFilesParams;
+    asTextDocumentPositionParams(textDocument: code.TextDocument, position: code.Position): proto.TextDocumentPositionParams;
+    asCompletionParams(textDocument: code.TextDocument, position: code.Position, context: code.CompletionContext): proto.CompletionParams;
+    asSignatureHelpParams(textDocument: code.TextDocument, position: code.Position, context: code.SignatureHelpContext): proto.SignatureHelpParams;
+    asWorkerPosition(position: code.Position): proto.Position;
+    asPosition(value: code.Position): proto.Position;
+    asPosition(value: undefined): undefined;
+    asPosition(value: null): null;
+    asPosition(value: code.Position | undefined | null): proto.Position | undefined | null;
+    asPositions(value: code.Position[]): proto.Position[];
+    asRange(value: code.Range): proto.Range;
+    asRange(value: undefined): undefined;
+    asRange(value: null): null;
+    asRange(value: code.Range | undefined | null): proto.Range | undefined | null;
+    asLocation(value: code.Location): proto.Location;
+    asLocation(value: undefined): undefined;
+    asLocation(value: null): null;
+    asLocation(value: code.Location | undefined | null): proto.Location | undefined | null;
+    asDiagnosticSeverity(value: code.DiagnosticSeverity): number;
+    asDiagnosticTag(value: code.DiagnosticTag): number | undefined;
+    asDiagnostic(item: code.Diagnostic): proto.Diagnostic;
+    asDiagnostics(items: code.Diagnostic[]): proto.Diagnostic[];
+    asCompletionItem(item: code.CompletionItem): proto.CompletionItem;
+    asSymbolKind(item: code.SymbolKind): proto.SymbolKind;
+    asSymbolTag(item: code.SymbolTag): proto.SymbolTag;
+    asSymbolTags(items: ReadonlyArray<code.SymbolTag>): proto.SymbolTag[];
+    asTextEdit(edit: code.TextEdit): proto.TextEdit;
+    asReferenceParams(textDocument: code.TextDocument, position: code.Position, options: {
+        includeDeclaration: boolean;
+    }): proto.ReferenceParams;
+    asCodeAction(item: code.CodeAction): proto.CodeAction;
+    asCodeActionContext(context: code.CodeActionContext): proto.CodeActionContext;
+    asCommand(item: code.Command): proto.Command;
+    asCodeLens(item: code.CodeLens): proto.CodeLens;
+    asFormattingOptions(options: code.FormattingOptions, fileOptions: FileFormattingOptions): proto.FormattingOptions;
+    asDocumentSymbolParams(textDocument: code.TextDocument): proto.DocumentSymbolParams;
+    asCodeLensParams(textDocument: code.TextDocument): proto.CodeLensParams;
+    asDocumentLink(item: code.DocumentLink): proto.DocumentLink;
+    asDocumentLinkParams(textDocument: code.TextDocument): proto.DocumentLinkParams;
+    asCallHierarchyItem(value: code.CallHierarchyItem): proto.CallHierarchyItem;
+}
+export interface URIConverter {
+    (value: code.Uri): string;
+}
+export declare function createConverter(uriConverter?: URIConverter): Converter;

node_modules/vscode-languageclient/lib/common/codeConverter.js

@@ -0,0 +1,703 @@
+"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.createConverter = void 0;
+const code = require("vscode");
+const proto = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+const protocolCompletionItem_1 = require("./protocolCompletionItem");
+const protocolCodeLens_1 = require("./protocolCodeLens");
+const protocolDocumentLink_1 = require("./protocolDocumentLink");
+const protocolCodeAction_1 = require("./protocolCodeAction");
+const protocolDiagnostic_1 = require("./protocolDiagnostic");
+const protocolCallHierarchyItem_1 = require("./protocolCallHierarchyItem");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+var InsertReplaceRange;
+(function (InsertReplaceRange) {
+    function is(value) {
+        const candidate = value;
+        return candidate && !!candidate.inserting && !!candidate.replacing;
+    }
+    InsertReplaceRange.is = is;
+})(InsertReplaceRange || (InsertReplaceRange = {}));
+function createConverter(uriConverter) {
+    const nullConverter = (value) => value.toString();
+    const _uriConverter = uriConverter || nullConverter;
+    function asUri(value) {
+        return _uriConverter(value);
+    }
+    function asTextDocumentIdentifier(textDocument) {
+        return {
+            uri: _uriConverter(textDocument.uri)
+        };
+    }
+    function asVersionedTextDocumentIdentifier(textDocument) {
+        return {
+            uri: _uriConverter(textDocument.uri),
+            version: textDocument.version
+        };
+    }
+    function asOpenTextDocumentParams(textDocument) {
+        return {
+            textDocument: {
+                uri: _uriConverter(textDocument.uri),
+                languageId: textDocument.languageId,
+                version: textDocument.version,
+                text: textDocument.getText()
+            }
+        };
+    }
+    function isTextDocumentChangeEvent(value) {
+        let candidate = value;
+        return !!candidate.document && !!candidate.contentChanges;
+    }
+    function isTextDocument(value) {
+        let candidate = value;
+        return !!candidate.uri && !!candidate.version;
+    }
+    function asChangeTextDocumentParams(arg) {
+        if (isTextDocument(arg)) {
+            let result = {
+                textDocument: {
+                    uri: _uriConverter(arg.uri),
+                    version: arg.version
+                },
+                contentChanges: [{ text: arg.getText() }]
+            };
+            return result;
+        }
+        else if (isTextDocumentChangeEvent(arg)) {
+            let document = arg.document;
+            let result = {
+                textDocument: {
+                    uri: _uriConverter(document.uri),
+                    version: document.version
+                },
+                contentChanges: arg.contentChanges.map((change) => {
+                    let range = change.range;
+                    return {
+                        range: {
+                            start: { line: range.start.line, character: range.start.character },
+                            end: { line: range.end.line, character: range.end.character }
+                        },
+                        rangeLength: change.rangeLength,
+                        text: change.text
+                    };
+                })
+            };
+            return result;
+        }
+        else {
+            throw Error('Unsupported text document change parameter');
+        }
+    }
+    function asCloseTextDocumentParams(textDocument) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument)
+        };
+    }
+    function asSaveTextDocumentParams(textDocument, includeContent = false) {
+        let result = {
+            textDocument: asTextDocumentIdentifier(textDocument)
+        };
+        if (includeContent) {
+            result.text = textDocument.getText();
+        }
+        return result;
+    }
+    function asTextDocumentSaveReason(reason) {
+        switch (reason) {
+            case code.TextDocumentSaveReason.Manual:
+                return proto.TextDocumentSaveReason.Manual;
+            case code.TextDocumentSaveReason.AfterDelay:
+                return proto.TextDocumentSaveReason.AfterDelay;
+            case code.TextDocumentSaveReason.FocusOut:
+                return proto.TextDocumentSaveReason.FocusOut;
+        }
+        return proto.TextDocumentSaveReason.Manual;
+    }
+    function asWillSaveTextDocumentParams(event) {
+        return {
+            textDocument: asTextDocumentIdentifier(event.document),
+            reason: asTextDocumentSaveReason(event.reason)
+        };
+    }
+    function asDidCreateFilesParams(event) {
+        return {
+            files: event.files.map((fileUri) => ({
+                uri: _uriConverter(fileUri),
+            })),
+        };
+    }
+    function asDidRenameFilesParams(event) {
+        return {
+            files: event.files.map((file) => ({
+                oldUri: _uriConverter(file.oldUri),
+                newUri: _uriConverter(file.newUri),
+            })),
+        };
+    }
+    function asDidDeleteFilesParams(event) {
+        return {
+            files: event.files.map((fileUri) => ({
+                uri: _uriConverter(fileUri),
+            })),
+        };
+    }
+    function asWillCreateFilesParams(event) {
+        return {
+            files: event.files.map((fileUri) => ({
+                uri: _uriConverter(fileUri),
+            })),
+        };
+    }
+    function asWillRenameFilesParams(event) {
+        return {
+            files: event.files.map((file) => ({
+                oldUri: _uriConverter(file.oldUri),
+                newUri: _uriConverter(file.newUri),
+            })),
+        };
+    }
+    function asWillDeleteFilesParams(event) {
+        return {
+            files: event.files.map((fileUri) => ({
+                uri: _uriConverter(fileUri),
+            })),
+        };
+    }
+    function asTextDocumentPositionParams(textDocument, position) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument),
+            position: asWorkerPosition(position)
+        };
+    }
+    function asCompletionTriggerKind(triggerKind) {
+        switch (triggerKind) {
+            case code.CompletionTriggerKind.TriggerCharacter:
+                return proto.CompletionTriggerKind.TriggerCharacter;
+            case code.CompletionTriggerKind.TriggerForIncompleteCompletions:
+                return proto.CompletionTriggerKind.TriggerForIncompleteCompletions;
+            default:
+                return proto.CompletionTriggerKind.Invoked;
+        }
+    }
+    function asCompletionParams(textDocument, position, context) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument),
+            position: asWorkerPosition(position),
+            context: {
+                triggerKind: asCompletionTriggerKind(context.triggerKind),
+                triggerCharacter: context.triggerCharacter
+            }
+        };
+    }
+    function asSignatureHelpTriggerKind(triggerKind) {
+        switch (triggerKind) {
+            case code.SignatureHelpTriggerKind.Invoke:
+                return proto.SignatureHelpTriggerKind.Invoked;
+            case code.SignatureHelpTriggerKind.TriggerCharacter:
+                return proto.SignatureHelpTriggerKind.TriggerCharacter;
+            case code.SignatureHelpTriggerKind.ContentChange:
+                return proto.SignatureHelpTriggerKind.ContentChange;
+        }
+    }
+    function asParameterInformation(value) {
+        // We leave the documentation out on purpose since it usually adds no
+        // value for the server.
+        return {
+            label: value.label
+        };
+    }
+    function asParameterInformations(values) {
+        return values.map(asParameterInformation);
+    }
+    function asSignatureInformation(value) {
+        // We leave the documentation out on purpose since it usually adds no
+        // value for the server.
+        return {
+            label: value.label,
+            parameters: asParameterInformations(value.parameters)
+        };
+    }
+    function asSignatureInformations(values) {
+        return values.map(asSignatureInformation);
+    }
+    function asSignatureHelp(value) {
+        if (value === undefined) {
+            return value;
+        }
+        return {
+            signatures: asSignatureInformations(value.signatures),
+            activeSignature: value.activeSignature,
+            activeParameter: value.activeParameter
+        };
+    }
+    function asSignatureHelpParams(textDocument, position, context) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument),
+            position: asWorkerPosition(position),
+            context: {
+                isRetrigger: context.isRetrigger,
+                triggerCharacter: context.triggerCharacter,
+                triggerKind: asSignatureHelpTriggerKind(context.triggerKind),
+                activeSignatureHelp: asSignatureHelp(context.activeSignatureHelp)
+            }
+        };
+    }
+    function asWorkerPosition(position) {
+        return { line: position.line, character: position.character };
+    }
+    function asPosition(value) {
+        if (value === undefined || value === null) {
+            return value;
+        }
+        return { line: value.line, character: value.character };
+    }
+    function asPositions(value) {
+        let result = [];
+        for (let elem of value) {
+            result.push(asPosition(elem));
+        }
+        return result;
+    }
+    function asRange(value) {
+        if (value === undefined || value === null) {
+            return value;
+        }
+        return { start: asPosition(value.start), end: asPosition(value.end) };
+    }
+    function asLocation(value) {
+        if (value === undefined || value === null) {
+            return value;
+        }
+        return proto.Location.create(asUri(value.uri), asRange(value.range));
+    }
+    function asDiagnosticSeverity(value) {
+        switch (value) {
+            case code.DiagnosticSeverity.Error:
+                return proto.DiagnosticSeverity.Error;
+            case code.DiagnosticSeverity.Warning:
+                return proto.DiagnosticSeverity.Warning;
+            case code.DiagnosticSeverity.Information:
+                return proto.DiagnosticSeverity.Information;
+            case code.DiagnosticSeverity.Hint:
+                return proto.DiagnosticSeverity.Hint;
+        }
+    }
+    function asDiagnosticTags(tags) {
+        if (!tags) {
+            return undefined;
+        }
+        let result = [];
+        for (let tag of tags) {
+            let converted = asDiagnosticTag(tag);
+            if (converted !== undefined) {
+                result.push(converted);
+            }
+        }
+        return result.length > 0 ? result : undefined;
+    }
+    function asDiagnosticTag(tag) {
+        switch (tag) {
+            case code.DiagnosticTag.Unnecessary:
+                return proto.DiagnosticTag.Unnecessary;
+            case code.DiagnosticTag.Deprecated:
+                return proto.DiagnosticTag.Deprecated;
+            default:
+                return undefined;
+        }
+    }
+    function asRelatedInformation(item) {
+        return {
+            message: item.message,
+            location: asLocation(item.location)
+        };
+    }
+    function asRelatedInformations(items) {
+        return items.map(asRelatedInformation);
+    }
+    function asDiagnosticCode(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        if (Is.number(value) || Is.string(value)) {
+            return value;
+        }
+        return { value: value.value, target: asUri(value.target) };
+    }
+    function asDiagnostic(item) {
+        const result = proto.Diagnostic.create(asRange(item.range), item.message);
+        const protocolDiagnostic = item instanceof protocolDiagnostic_1.ProtocolDiagnostic ? item : undefined;
+        if (protocolDiagnostic !== undefined && protocolDiagnostic.data !== undefined) {
+            result.data = protocolDiagnostic.data;
+        }
+        const code = asDiagnosticCode(item.code);
+        if (protocolDiagnostic_1.DiagnosticCode.is(code)) {
+            if (protocolDiagnostic !== undefined && protocolDiagnostic.hasDiagnosticCode) {
+                result.code = code;
+            }
+            else {
+                result.code = code.value;
+                result.codeDescription = { href: code.target };
+            }
+        }
+        else {
+            result.code = code;
+        }
+        if (Is.number(item.severity)) {
+            result.severity = asDiagnosticSeverity(item.severity);
+        }
+        if (Array.isArray(item.tags)) {
+            result.tags = asDiagnosticTags(item.tags);
+        }
+        if (item.relatedInformation) {
+            result.relatedInformation = asRelatedInformations(item.relatedInformation);
+        }
+        if (item.source) {
+            result.source = item.source;
+        }
+        return result;
+    }
+    function asDiagnostics(items) {
+        if (items === undefined || items === null) {
+            return items;
+        }
+        return items.map(asDiagnostic);
+    }
+    function asDocumentation(format, documentation) {
+        switch (format) {
+            case '$string':
+                return documentation;
+            case proto.MarkupKind.PlainText:
+                return { kind: format, value: documentation };
+            case proto.MarkupKind.Markdown:
+                return { kind: format, value: documentation.value };
+            default:
+                return `Unsupported Markup content received. Kind is: ${format}`;
+        }
+    }
+    function asCompletionItemTag(tag) {
+        switch (tag) {
+            case code.CompletionItemTag.Deprecated:
+                return proto.CompletionItemTag.Deprecated;
+        }
+        return undefined;
+    }
+    function asCompletionItemTags(tags) {
+        if (tags === undefined) {
+            return tags;
+        }
+        const result = [];
+        for (let tag of tags) {
+            const converted = asCompletionItemTag(tag);
+            if (converted !== undefined) {
+                result.push(converted);
+            }
+        }
+        return result;
+    }
+    function asCompletionItemKind(value, original) {
+        if (original !== undefined) {
+            return original;
+        }
+        return value + 1;
+    }
+    function asCompletionItem(item) {
+        let result = { label: item.label };
+        let protocolItem = item instanceof protocolCompletionItem_1.default ? item : undefined;
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        // We only send items back we created. So this can't be something else than
+        // a string right now.
+        if (item.documentation) {
+            if (!protocolItem || protocolItem.documentationFormat === '$string') {
+                result.documentation = item.documentation;
+            }
+            else {
+                result.documentation = asDocumentation(protocolItem.documentationFormat, item.documentation);
+            }
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        fillPrimaryInsertText(result, item);
+        if (Is.number(item.kind)) {
+            result.kind = asCompletionItemKind(item.kind, protocolItem && protocolItem.originalItemKind);
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = asTextEdits(item.additionalTextEdits);
+        }
+        if (item.commitCharacters) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = asCommand(item.command);
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        const tags = asCompletionItemTags(item.tags);
+        if (protocolItem) {
+            if (protocolItem.data !== undefined) {
+                result.data = protocolItem.data;
+            }
+            if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
+                if (protocolItem.deprecated === true && tags !== undefined && tags.length > 0) {
+                    const index = tags.indexOf(code.CompletionItemTag.Deprecated);
+                    if (index !== -1) {
+                        tags.splice(index, 1);
+                    }
+                }
+                result.deprecated = protocolItem.deprecated;
+            }
+            if (protocolItem.insertTextMode !== undefined) {
+                result.insertTextMode = protocolItem.insertTextMode;
+            }
+        }
+        if (tags !== undefined && tags.length > 0) {
+            result.tags = tags;
+        }
+        if (result.insertTextMode === undefined && item.keepWhitespace === true) {
+            result.insertTextMode = vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation;
+        }
+        return result;
+    }
+    function fillPrimaryInsertText(target, source) {
+        let format = proto.InsertTextFormat.PlainText;
+        let text = undefined;
+        let range = undefined;
+        if (source.textEdit) {
+            text = source.textEdit.newText;
+            range = source.textEdit.range;
+        }
+        else if (source.insertText instanceof code.SnippetString) {
+            format = proto.InsertTextFormat.Snippet;
+            text = source.insertText.value;
+        }
+        else {
+            text = source.insertText;
+        }
+        if (source.range) {
+            range = source.range;
+        }
+        target.insertTextFormat = format;
+        if (source.fromEdit && text !== undefined && range !== undefined) {
+            target.textEdit = asCompletionTextEdit(text, range);
+        }
+        else {
+            target.insertText = text;
+        }
+    }
+    function asCompletionTextEdit(newText, range) {
+        if (InsertReplaceRange.is(range)) {
+            return proto.InsertReplaceEdit.create(newText, asRange(range.inserting), asRange(range.replacing));
+        }
+        else {
+            return { newText, range: asRange(range) };
+        }
+    }
+    function asTextEdit(edit) {
+        return { range: asRange(edit.range), newText: edit.newText };
+    }
+    function asTextEdits(edits) {
+        if (edits === undefined || edits === null) {
+            return edits;
+        }
+        return edits.map(asTextEdit);
+    }
+    function asSymbolKind(item) {
+        if (item <= code.SymbolKind.TypeParameter) {
+            // Symbol kind is one based in the protocol and zero based in code.
+            return (item + 1);
+        }
+        return proto.SymbolKind.Property;
+    }
+    function asSymbolTag(item) {
+        return item;
+    }
+    function asSymbolTags(items) {
+        return items.map(asSymbolTag);
+    }
+    function asReferenceParams(textDocument, position, options) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument),
+            position: asWorkerPosition(position),
+            context: { includeDeclaration: options.includeDeclaration }
+        };
+    }
+    function asCodeAction(item) {
+        let result = proto.CodeAction.create(item.title);
+        if (item instanceof protocolCodeAction_1.default && item.data !== undefined) {
+            result.data = item.data;
+        }
+        if (item.kind !== undefined) {
+            result.kind = asCodeActionKind(item.kind);
+        }
+        if (item.diagnostics !== undefined) {
+            result.diagnostics = asDiagnostics(item.diagnostics);
+        }
+        if (item.edit !== undefined) {
+            throw new Error(`VS Code code actions can only be converted to a protocol code action without an edit.`);
+        }
+        if (item.command !== undefined) {
+            result.command = asCommand(item.command);
+        }
+        if (item.isPreferred !== undefined) {
+            result.isPreferred = item.isPreferred;
+        }
+        if (item.disabled !== undefined) {
+            result.disabled = { reason: item.disabled.reason };
+        }
+        return result;
+    }
+    function asCodeActionContext(context) {
+        if (context === undefined || context === null) {
+            return context;
+        }
+        let only;
+        if (context.only && Is.string(context.only.value)) {
+            only = [context.only.value];
+        }
+        return proto.CodeActionContext.create(asDiagnostics(context.diagnostics), only);
+    }
+    function asCodeActionKind(item) {
+        if (item === undefined || item === null) {
+            return undefined;
+        }
+        return item.value;
+    }
+    function asCommand(item) {
+        let result = proto.Command.create(item.title, item.command);
+        if (item.arguments) {
+            result.arguments = item.arguments;
+        }
+        return result;
+    }
+    function asCodeLens(item) {
+        let result = proto.CodeLens.create(asRange(item.range));
+        if (item.command) {
+            result.command = asCommand(item.command);
+        }
+        if (item instanceof protocolCodeLens_1.default) {
+            if (item.data) {
+                result.data = item.data;
+            }
+        }
+        return result;
+    }
+    function asFormattingOptions(options, fileOptions) {
+        const result = { tabSize: options.tabSize, insertSpaces: options.insertSpaces };
+        if (fileOptions.trimTrailingWhitespace) {
+            result.trimTrailingWhitespace = true;
+        }
+        if (fileOptions.trimFinalNewlines) {
+            result.trimFinalNewlines = true;
+        }
+        if (fileOptions.insertFinalNewline) {
+            result.insertFinalNewline = true;
+        }
+        return result;
+    }
+    function asDocumentSymbolParams(textDocument) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument)
+        };
+    }
+    function asCodeLensParams(textDocument) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument)
+        };
+    }
+    function asDocumentLink(item) {
+        let result = proto.DocumentLink.create(asRange(item.range));
+        if (item.target) {
+            result.target = asUri(item.target);
+        }
+        if (item.tooltip !== undefined) {
+            result.tooltip = item.tooltip;
+        }
+        let protocolItem = item instanceof protocolDocumentLink_1.default ? item : undefined;
+        if (protocolItem && protocolItem.data) {
+            result.data = protocolItem.data;
+        }
+        return result;
+    }
+    function asDocumentLinkParams(textDocument) {
+        return {
+            textDocument: asTextDocumentIdentifier(textDocument)
+        };
+    }
+    function asCallHierarchyItem(value) {
+        const result = {
+            name: value.name,
+            kind: asSymbolKind(value.kind),
+            uri: asUri(value.uri),
+            range: asRange(value.range),
+            selectionRange: asRange(value.selectionRange)
+        };
+        if (value.detail !== undefined && value.detail.length > 0) {
+            result.detail = value.detail;
+        }
+        if (value.tags !== undefined) {
+            result.tags = asSymbolTags(value.tags);
+        }
+        if (value instanceof protocolCallHierarchyItem_1.default && value.data !== undefined) {
+            result.data = value.data;
+        }
+        return result;
+    }
+    return {
+        asUri,
+        asTextDocumentIdentifier,
+        asVersionedTextDocumentIdentifier,
+        asOpenTextDocumentParams,
+        asChangeTextDocumentParams,
+        asCloseTextDocumentParams,
+        asSaveTextDocumentParams,
+        asWillSaveTextDocumentParams,
+        asDidCreateFilesParams,
+        asDidRenameFilesParams,
+        asDidDeleteFilesParams,
+        asWillCreateFilesParams,
+        asWillRenameFilesParams,
+        asWillDeleteFilesParams,
+        asTextDocumentPositionParams,
+        asCompletionParams,
+        asSignatureHelpParams,
+        asWorkerPosition,
+        asRange,
+        asPosition,
+        asPositions,
+        asLocation,
+        asDiagnosticSeverity,
+        asDiagnosticTag,
+        asDiagnostic,
+        asDiagnostics,
+        asCompletionItem,
+        asTextEdit,
+        asSymbolKind,
+        asSymbolTag,
+        asSymbolTags,
+        asReferenceParams,
+        asCodeAction,
+        asCodeActionContext,
+        asCommand,
+        asCodeLens,
+        asFormattingOptions,
+        asDocumentSymbolParams,
+        asCodeLensParams,
+        asDocumentLink,
+        asDocumentLinkParams,
+        asCallHierarchyItem
+    };
+}
+exports.createConverter = createConverter;
+//# sourceMappingURL=codeConverter.js.map

node_modules/vscode-languageclient/lib/common/colorProvider.d.ts

@@ -0,0 +1,28 @@
+import { Disposable, TextDocument, ProviderResult, Range as VRange, Color as VColor, ColorPresentation as VColorPresentation, ColorInformation as VColorInformation, DocumentColorProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, DocumentColorRegistrationOptions, DocumentColorOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideDocumentColorsSignature {
+    (document: TextDocument, token: CancellationToken): ProviderResult<VColorInformation[]>;
+}
+export interface ProvideColorPresentationSignature {
+    (color: VColor, context: {
+        document: TextDocument;
+        range: VRange;
+    }, token: CancellationToken): ProviderResult<VColorPresentation[]>;
+}
+export interface ColorProviderMiddleware {
+    provideDocumentColors?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideDocumentColorsSignature) => ProviderResult<VColorInformation[]>;
+    provideColorPresentations?: (this: void, color: VColor, context: {
+        document: TextDocument;
+        range: VRange;
+    }, token: CancellationToken, next: ProvideColorPresentationSignature) => ProviderResult<VColorPresentation[]>;
+}
+export declare class ColorProviderFeature extends TextDocumentFeature<boolean | DocumentColorOptions, DocumentColorRegistrationOptions, DocumentColorProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DocumentColorRegistrationOptions): [Disposable, DocumentColorProvider];
+    private asColor;
+    private asColorInformations;
+    private asColorPresentations;
+}

node_modules/vscode-languageclient/lib/common/colorProvider.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.ColorProviderFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class ColorProviderFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentColorRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        ensure(ensure(capabilities, 'textDocument'), 'colorProvider').dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.colorProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideColorPresentations: (color, context, token) => {
+                const client = this._client;
+                const provideColorPresentations = (color, context, token) => {
+                    const requestParams = {
+                        color,
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(context.document),
+                        range: client.code2ProtocolConverter.asRange(context.range)
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, requestParams, token).then(this.asColorPresentations.bind(this), (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideColorPresentations
+                    ? middleware.provideColorPresentations(color, context, token, provideColorPresentations)
+                    : provideColorPresentations(color, context, token);
+            },
+            provideDocumentColors: (document, token) => {
+                const client = this._client;
+                const provideDocumentColors = (document, token) => {
+                    const requestParams = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, requestParams, token).then(this.asColorInformations.bind(this), (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideDocumentColors
+                    ? middleware.provideDocumentColors(document, token, provideDocumentColors)
+                    : provideDocumentColors(document, token);
+            }
+        };
+        return [vscode_1.languages.registerColorProvider(options.documentSelector, provider), provider];
+    }
+    asColor(color) {
+        return new vscode_1.Color(color.red, color.green, color.blue, color.alpha);
+    }
+    asColorInformations(colorInformation) {
+        if (Array.isArray(colorInformation)) {
+            return colorInformation.map(ci => {
+                return new vscode_1.ColorInformation(this._client.protocol2CodeConverter.asRange(ci.range), this.asColor(ci.color));
+            });
+        }
+        return [];
+    }
+    asColorPresentations(colorPresentations) {
+        if (Array.isArray(colorPresentations)) {
+            return colorPresentations.map(cp => {
+                let presentation = new vscode_1.ColorPresentation(cp.label);
+                presentation.additionalTextEdits = this._client.protocol2CodeConverter.asTextEdits(cp.additionalTextEdits);
+                presentation.textEdit = this._client.protocol2CodeConverter.asTextEdit(cp.textEdit);
+                return presentation;
+            });
+        }
+        return [];
+    }
+}
+exports.ColorProviderFeature = ColorProviderFeature;
+//# sourceMappingURL=colorProvider.js.map

node_modules/vscode-languageclient/lib/common/commonClient.d.ts

@@ -0,0 +1,9 @@
+import { BaseLanguageClient, LanguageClientOptions, StaticFeature, DynamicFeature } from './client';
+export declare abstract class CommonLanguageClient extends BaseLanguageClient {
+    constructor(id: string, name: string, clientOptions: LanguageClientOptions);
+    registerProposedFeatures(): void;
+    protected registerBuiltinFeatures(): void;
+}
+export declare namespace ProposedFeatures {
+    function createAll(_client: BaseLanguageClient): (StaticFeature | DynamicFeature<any>)[];
+}

node_modules/vscode-languageclient/lib/common/commonClient.js

@@ -0,0 +1,61 @@
+"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.ProposedFeatures = exports.CommonLanguageClient = void 0;
+const client_1 = require("./client");
+const colorProvider_1 = require("./colorProvider");
+const configuration_1 = require("./configuration");
+const implementation_1 = require("./implementation");
+const typeDefinition_1 = require("./typeDefinition");
+const workspaceFolders_1 = require("./workspaceFolders");
+const foldingRange_1 = require("./foldingRange");
+const declaration_1 = require("./declaration");
+const selectionRange_1 = require("./selectionRange");
+const progress_1 = require("./progress");
+const callHierarchy_1 = require("./callHierarchy");
+const semanticTokens_1 = require("./semanticTokens");
+const fileOperations_1 = require("./fileOperations");
+const linkedEditingRange_1 = require("./linkedEditingRange");
+class CommonLanguageClient extends client_1.BaseLanguageClient {
+    constructor(id, name, clientOptions) {
+        super(id, name, clientOptions);
+    }
+    registerProposedFeatures() {
+        this.registerFeatures(ProposedFeatures.createAll(this));
+    }
+    registerBuiltinFeatures() {
+        super.registerBuiltinFeatures();
+        this.registerFeature(new configuration_1.ConfigurationFeature(this));
+        this.registerFeature(new typeDefinition_1.TypeDefinitionFeature(this));
+        this.registerFeature(new implementation_1.ImplementationFeature(this));
+        this.registerFeature(new colorProvider_1.ColorProviderFeature(this));
+        this.registerFeature(new workspaceFolders_1.WorkspaceFoldersFeature(this));
+        this.registerFeature(new foldingRange_1.FoldingRangeFeature(this));
+        this.registerFeature(new declaration_1.DeclarationFeature(this));
+        this.registerFeature(new selectionRange_1.SelectionRangeFeature(this));
+        this.registerFeature(new progress_1.ProgressFeature(this));
+        this.registerFeature(new callHierarchy_1.CallHierarchyFeature(this));
+        this.registerFeature(new semanticTokens_1.SemanticTokensFeature(this));
+        this.registerFeature(new linkedEditingRange_1.LinkedEditingFeature(this));
+        this.registerFeature(new fileOperations_1.DidCreateFilesFeature(this));
+        this.registerFeature(new fileOperations_1.DidRenameFilesFeature(this));
+        this.registerFeature(new fileOperations_1.DidDeleteFilesFeature(this));
+        this.registerFeature(new fileOperations_1.WillCreateFilesFeature(this));
+        this.registerFeature(new fileOperations_1.WillRenameFilesFeature(this));
+        this.registerFeature(new fileOperations_1.WillDeleteFilesFeature(this));
+    }
+}
+exports.CommonLanguageClient = CommonLanguageClient;
+// Exporting proposed protocol.
+var ProposedFeatures;
+(function (ProposedFeatures) {
+    function createAll(_client) {
+        let result = [];
+        return result;
+    }
+    ProposedFeatures.createAll = createAll;
+})(ProposedFeatures = exports.ProposedFeatures || (exports.ProposedFeatures = {}));
+//# sourceMappingURL=commonClient.js.map

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

@@ -0,0 +1,14 @@
+import { StaticFeature, BaseLanguageClient } from './client';
+import { ClientCapabilities, ConfigurationRequest } from 'vscode-languageserver-protocol';
+export interface ConfigurationWorkspaceMiddleware {
+    configuration?: ConfigurationRequest.MiddlewareSignature;
+}
+export declare class ConfigurationFeature implements StaticFeature {
+    private _client;
+    constructor(_client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(): void;
+    private getConfiguration;
+    dispose(): void;
+}
+export declare function toJSONObject(obj: any): any;

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

@@ -0,0 +1,85 @@
+"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.toJSONObject = exports.ConfigurationFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+class ConfigurationFeature {
+    constructor(_client) {
+        this._client = _client;
+    }
+    fillClientCapabilities(capabilities) {
+        capabilities.workspace = capabilities.workspace || {};
+        capabilities.workspace.configuration = true;
+    }
+    initialize() {
+        let client = this._client;
+        client.onRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, (params, token) => {
+            let configuration = (params) => {
+                let result = [];
+                for (let item of params.items) {
+                    let resource = item.scopeUri !== void 0 && item.scopeUri !== null ? this._client.protocol2CodeConverter.asUri(item.scopeUri) : undefined;
+                    result.push(this.getConfiguration(resource, item.section !== null ? item.section : undefined));
+                }
+                return result;
+            };
+            let middleware = client.clientOptions.middleware.workspace;
+            return middleware && middleware.configuration
+                ? middleware.configuration(params, token, configuration)
+                : configuration(params, token);
+        });
+    }
+    getConfiguration(resource, section) {
+        let result = null;
+        if (section) {
+            let index = section.lastIndexOf('.');
+            if (index === -1) {
+                result = toJSONObject(vscode_1.workspace.getConfiguration(undefined, resource).get(section));
+            }
+            else {
+                let config = vscode_1.workspace.getConfiguration(section.substr(0, index), resource);
+                if (config) {
+                    result = toJSONObject(config.get(section.substr(index + 1)));
+                }
+            }
+        }
+        else {
+            let config = vscode_1.workspace.getConfiguration(undefined, resource);
+            result = {};
+            for (let key of Object.keys(config)) {
+                if (config.has(key)) {
+                    result[key] = toJSONObject(config.get(key));
+                }
+            }
+        }
+        if (result === undefined) {
+            result = null;
+        }
+        return result;
+    }
+    dispose() {
+    }
+}
+exports.ConfigurationFeature = ConfigurationFeature;
+function toJSONObject(obj) {
+    if (obj) {
+        if (Array.isArray(obj)) {
+            return obj.map(toJSONObject);
+        }
+        else if (typeof obj === 'object') {
+            const res = Object.create(null);
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    res[key] = toJSONObject(obj[key]);
+                }
+            }
+            return res;
+        }
+    }
+    return obj;
+}
+exports.toJSONObject = toJSONObject;
+//# sourceMappingURL=configuration.js.map

node_modules/vscode-languageclient/lib/common/declaration.d.ts

@@ -0,0 +1,15 @@
+import { Disposable, TextDocument, ProviderResult, Position as VPosition, Declaration as VDeclaration, DeclarationProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, DeclarationRegistrationOptions, DeclarationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideDeclarationSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDeclaration>;
+}
+export interface DeclarationMiddleware {
+    provideDeclaration?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDeclarationSignature) => ProviderResult<VDeclaration>;
+}
+export declare class DeclarationFeature extends TextDocumentFeature<boolean | DeclarationOptions, DeclarationRegistrationOptions, DeclarationProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DeclarationRegistrationOptions): [Disposable, DeclarationProvider];
+}

node_modules/vscode-languageclient/lib/common/declaration.js

@@ -0,0 +1,52 @@
+"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.DeclarationFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class DeclarationFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DeclarationRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const declarationSupport = ensure(ensure(capabilities, 'textDocument'), 'declaration');
+        declarationSupport.dynamicRegistration = true;
+        declarationSupport.linkSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const [id, options] = this.getRegistration(documentSelector, capabilities.declarationProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideDeclaration: (document, position, token) => {
+                const client = this._client;
+                const provideDeclaration = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDeclarationResult, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideDeclaration
+                    ? middleware.provideDeclaration(document, position, token, provideDeclaration)
+                    : provideDeclaration(document, position, token);
+            }
+        };
+        return [vscode_1.languages.registerDeclarationProvider(options.documentSelector, provider), provider];
+    }
+}
+exports.DeclarationFeature = DeclarationFeature;
+//# sourceMappingURL=declaration.js.map

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

@@ -0,0 +1,94 @@
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+import { DynamicFeature, BaseLanguageClient, RegistrationData, NextSignature } from './client';
+/**
+ * File operation middleware
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationsMiddleware {
+    didCreateFiles?: NextSignature<code.FileCreateEvent, void>;
+    willCreateFiles?: NextSignature<code.FileCreateEvent, Thenable<code.WorkspaceEdit | null | undefined>>;
+    didRenameFiles?: NextSignature<code.FileRenameEvent, void>;
+    willRenameFiles?: NextSignature<code.FileRenameEvent, Thenable<code.WorkspaceEdit | null | undefined>>;
+    didDeleteFiles?: NextSignature<code.FileDeleteEvent, void>;
+    willDeleteFiles?: NextSignature<code.FileDeleteEvent, Thenable<code.WorkspaceEdit | null | undefined>>;
+}
+interface Event<I> {
+    readonly files: ReadonlyArray<I>;
+}
+declare abstract class FileOperationFeature<I, E extends Event<I>> implements DynamicFeature<proto.FileOperationRegistrationOptions> {
+    protected _client: BaseLanguageClient;
+    private _event;
+    private _registrationType;
+    private _clientCapability;
+    private _serverCapability;
+    private _listener;
+    private _filters;
+    constructor(client: BaseLanguageClient, event: code.Event<E>, registrationType: proto.RegistrationType<proto.FileOperationRegistrationOptions>, clientCapability: keyof proto.FileOperationClientCapabilities, serverCapability: keyof proto.FileOperationOptions);
+    get registrationType(): proto.RegistrationType<proto.FileOperationRegistrationOptions>;
+    fillClientCapabilities(capabilities: proto.ClientCapabilities): void;
+    initialize(capabilities: proto.ServerCapabilities): void;
+    register(data: RegistrationData<proto.FileOperationRegistrationOptions>): void;
+    abstract send(data: E): Promise<void>;
+    unregister(id: string): void;
+    dispose(): void;
+    protected filter(event: E, prop: (i: I) => code.Uri): Promise<E>;
+    private static getFileType;
+    private static asMinimatchOptions;
+}
+declare abstract class NotificationFileOperationFeature<I, E extends {
+    readonly files: ReadonlyArray<I>;
+}, P> extends FileOperationFeature<I, E> {
+    private _notificationType;
+    private _accessUri;
+    private _createParams;
+    constructor(client: BaseLanguageClient, event: code.Event<E>, notificationType: proto.ProtocolNotificationType<P, proto.FileOperationRegistrationOptions>, clientCapability: keyof proto.FileOperationClientCapabilities, serverCapability: keyof proto.FileOperationOptions, accessUri: (i: I) => code.Uri, createParams: (e: E) => P);
+    send(originalEvent: E): Promise<void>;
+    protected abstract doSend(event: E, next: (event: E) => void): void;
+}
+export declare class DidCreateFilesFeature extends NotificationFileOperationFeature<code.Uri, code.FileCreateEvent, proto.CreateFilesParams> {
+    constructor(client: BaseLanguageClient);
+    protected doSend(event: code.FileCreateEvent, next: (event: code.FileCreateEvent) => void): void;
+}
+export declare class DidRenameFilesFeature extends NotificationFileOperationFeature<{
+    oldUri: code.Uri;
+    newUri: code.Uri;
+}, code.FileRenameEvent, proto.RenameFilesParams> {
+    constructor(client: BaseLanguageClient);
+    protected doSend(event: code.FileRenameEvent, next: (event: code.FileRenameEvent) => void): void;
+}
+export declare class DidDeleteFilesFeature extends NotificationFileOperationFeature<code.Uri, code.FileDeleteEvent, proto.DeleteFilesParams> {
+    constructor(client: BaseLanguageClient);
+    protected doSend(event: code.FileCreateEvent, next: (event: code.FileCreateEvent) => void): void;
+}
+interface RequestEvent<I> {
+    readonly files: ReadonlyArray<I>;
+    waitUntil(thenable: Thenable<code.WorkspaceEdit>): void;
+    waitUntil(thenable: Thenable<any>): void;
+}
+declare abstract class RequestFileOperationFeature<I, E extends RequestEvent<I>, P> extends FileOperationFeature<I, E> {
+    private _requestType;
+    private _accessUri;
+    private _createParams;
+    constructor(client: BaseLanguageClient, event: code.Event<E>, requestType: proto.ProtocolRequestType<P, proto.WorkspaceEdit | null, never, void, proto.FileOperationRegistrationOptions>, clientCapability: keyof proto.FileOperationClientCapabilities, serverCapability: keyof proto.FileOperationOptions, accessUri: (i: I) => code.Uri, createParams: (e: Event<I>) => P);
+    send(originalEvent: E & RequestEvent<I>): Promise<void>;
+    private waitUntil;
+    protected abstract doSend(event: E, next: (event: Event<I>) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export declare class WillCreateFilesFeature extends RequestFileOperationFeature<code.Uri, code.FileWillCreateEvent, proto.CreateFilesParams> {
+    constructor(client: BaseLanguageClient);
+    protected doSend(event: code.FileWillCreateEvent, next: (event: code.FileCreateEvent) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export declare class WillRenameFilesFeature extends RequestFileOperationFeature<{
+    oldUri: code.Uri;
+    newUri: code.Uri;
+}, code.FileWillRenameEvent, proto.RenameFilesParams> {
+    constructor(client: BaseLanguageClient);
+    protected doSend(event: code.FileWillRenameEvent, next: (event: code.FileRenameEvent) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export declare class WillDeleteFilesFeature extends RequestFileOperationFeature<code.Uri, code.FileWillDeleteEvent, proto.DeleteFilesParams> {
+    constructor(client: BaseLanguageClient);
+    protected doSend(event: code.FileWillDeleteEvent, next: (event: code.FileDeleteEvent) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export {};

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

@@ -0,0 +1,264 @@
+"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.WillDeleteFilesFeature = exports.WillRenameFilesFeature = exports.WillCreateFilesFeature = exports.DidDeleteFilesFeature = exports.DidRenameFilesFeature = exports.DidCreateFilesFeature = void 0;
+const code = require("vscode");
+const minimatch = require("minimatch");
+const proto = require("vscode-languageserver-protocol");
+const UUID = require("./utils/uuid");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+function access(target, key) {
+    return target[key];
+}
+function assign(target, key, value) {
+    target[key] = value;
+}
+class FileOperationFeature {
+    constructor(client, event, registrationType, clientCapability, serverCapability) {
+        this._filters = new Map();
+        this._client = client;
+        this._event = event;
+        this._registrationType = registrationType;
+        this._clientCapability = clientCapability;
+        this._serverCapability = serverCapability;
+    }
+    get registrationType() {
+        return this._registrationType;
+    }
+    fillClientCapabilities(capabilities) {
+        const value = ensure(ensure(capabilities, 'workspace'), 'fileOperations');
+        // this happens n times but it is the same value so we tolerate this.
+        assign(value, 'dynamicRegistration', true);
+        assign(value, this._clientCapability, true);
+    }
+    initialize(capabilities) {
+        var _a;
+        const options = (_a = capabilities.workspace) === null || _a === void 0 ? void 0 : _a.fileOperations;
+        const capability = options !== undefined ? access(options, this._serverCapability) : undefined;
+        if ((capability === null || capability === void 0 ? void 0 : capability.filters) !== undefined) {
+            try {
+                this.register({
+                    id: UUID.generateUuid(),
+                    registerOptions: { filters: capability.filters }
+                });
+            }
+            catch (e) {
+                this._client.warn(`Ignoring invalid glob pattern for ${this._serverCapability} registration: ${e}`);
+            }
+        }
+    }
+    register(data) {
+        if (!this._listener) {
+            this._listener = this._event(this.send, this);
+        }
+        const minimatchFilter = data.registerOptions.filters.map((filter) => {
+            const matcher = new minimatch.Minimatch(filter.pattern.glob, FileOperationFeature.asMinimatchOptions(filter.pattern.options));
+            if (!matcher.makeRe()) {
+                throw new Error(`Invalid pattern ${filter.pattern.glob}!`);
+            }
+            return { scheme: filter.scheme, matcher, kind: filter.pattern.matches };
+        });
+        this._filters.set(data.id, minimatchFilter);
+    }
+    unregister(id) {
+        this._filters.delete(id);
+        if (this._filters.size === 0 && this._listener) {
+            this._listener.dispose();
+            this._listener = undefined;
+        }
+    }
+    dispose() {
+        this._filters.clear();
+        if (this._listener) {
+            this._listener.dispose();
+            this._listener = undefined;
+        }
+    }
+    async filter(event, prop) {
+        // (Asynchronously) map each file onto a boolean of whether it matches
+        // any of the globs.
+        const fileMatches = await Promise.all(event.files.map(async (item) => {
+            const uri = prop(item);
+            // Use fsPath to make this consistent with file system watchers but help
+            // minimatch to use '/' instead of `\\` if present.
+            const path = uri.fsPath.replace(/\\/g, '/');
+            for (const filters of this._filters.values()) {
+                for (const filter of filters) {
+                    if (filter.scheme !== undefined && filter.scheme !== uri.scheme) {
+                        continue;
+                    }
+                    if (filter.matcher.match(path)) {
+                        // The pattern matches. If kind is undefined then everything is ok
+                        if (filter.kind === undefined) {
+                            return true;
+                        }
+                        const fileType = await FileOperationFeature.getFileType(uri);
+                        // If we can't determine the file type than we treat it as a match.
+                        // Dropping it would be another alternative.
+                        if (fileType === undefined) {
+                            this._client.error(`Failed to determine file type for ${uri.toString()}.`);
+                            return true;
+                        }
+                        if ((fileType === code.FileType.File && filter.kind === proto.FileOperationPatternKind.file) || (fileType === code.FileType.Directory && filter.kind === proto.FileOperationPatternKind.folder)) {
+                            return true;
+                        }
+                    }
+                    else if (filter.kind === proto.FileOperationPatternKind.folder) {
+                        const fileType = await FileOperationFeature.getFileType(uri);
+                        if (fileType === code.FileType.Directory && filter.matcher.match(`${path}/`)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }));
+        // Filter the files to those that matched.
+        const files = event.files.filter((_, index) => fileMatches[index]);
+        return Object.assign(Object.assign({}, event), { files });
+    }
+    static async getFileType(uri) {
+        try {
+            return (await code.workspace.fs.stat(uri)).type;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    static asMinimatchOptions(options) {
+        if (options === undefined) {
+            return undefined;
+        }
+        if (options.ignoreCase === true) {
+            return { nocase: true };
+        }
+        return undefined;
+    }
+}
+class NotificationFileOperationFeature extends FileOperationFeature {
+    constructor(client, event, notificationType, clientCapability, serverCapability, accessUri, createParams) {
+        super(client, event, notificationType, clientCapability, serverCapability);
+        this._notificationType = notificationType;
+        this._accessUri = accessUri;
+        this._createParams = createParams;
+    }
+    async send(originalEvent) {
+        // Create a copy of the event that has the files filtered to match what the
+        // server wants.
+        const filteredEvent = await this.filter(originalEvent, this._accessUri);
+        if (filteredEvent.files.length) {
+            const next = async (event) => {
+                this._client.sendNotification(this._notificationType, this._createParams(event));
+            };
+            this.doSend(filteredEvent, next);
+        }
+    }
+}
+class DidCreateFilesFeature extends NotificationFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onDidCreateFiles, proto.DidCreateFilesNotification.type, 'didCreate', 'didCreate', (i) => i, client.code2ProtocolConverter.asDidCreateFilesParams);
+    }
+    doSend(event, next) {
+        var _a;
+        const middleware = (_a = this._client.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace;
+        return (middleware === null || middleware === void 0 ? void 0 : middleware.didCreateFiles) ? middleware.didCreateFiles(event, next)
+            : next(event);
+    }
+}
+exports.DidCreateFilesFeature = DidCreateFilesFeature;
+class DidRenameFilesFeature extends NotificationFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onDidRenameFiles, proto.DidRenameFilesNotification.type, 'didRename', 'didRename', (i) => i.oldUri, client.code2ProtocolConverter.asDidRenameFilesParams);
+    }
+    doSend(event, next) {
+        var _a;
+        const middleware = (_a = this._client.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace;
+        return (middleware === null || middleware === void 0 ? void 0 : middleware.didRenameFiles) ? middleware.didRenameFiles(event, next)
+            : next(event);
+    }
+}
+exports.DidRenameFilesFeature = DidRenameFilesFeature;
+class DidDeleteFilesFeature extends NotificationFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onDidDeleteFiles, proto.DidDeleteFilesNotification.type, 'didDelete', 'didDelete', (i) => i, client.code2ProtocolConverter.asDidDeleteFilesParams);
+    }
+    doSend(event, next) {
+        var _a;
+        const middleware = (_a = this._client.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace;
+        return (middleware === null || middleware === void 0 ? void 0 : middleware.didDeleteFiles) ? middleware.didDeleteFiles(event, next)
+            : next(event);
+    }
+}
+exports.DidDeleteFilesFeature = DidDeleteFilesFeature;
+class RequestFileOperationFeature extends FileOperationFeature {
+    constructor(client, event, requestType, clientCapability, serverCapability, accessUri, createParams) {
+        super(client, event, requestType, clientCapability, serverCapability);
+        this._requestType = requestType;
+        this._accessUri = accessUri;
+        this._createParams = createParams;
+    }
+    async send(originalEvent) {
+        const waitUntil = this.waitUntil(originalEvent);
+        originalEvent.waitUntil(waitUntil);
+    }
+    async waitUntil(originalEvent) {
+        // Create a copy of the event that has the files filtered to match what the
+        // server wants.
+        const filteredEvent = await this.filter(originalEvent, this._accessUri);
+        if (filteredEvent.files.length) {
+            const next = (event) => {
+                return this._client.sendRequest(this._requestType, this._createParams(event))
+                    .then(this._client.protocol2CodeConverter.asWorkspaceEdit);
+            };
+            return this.doSend(filteredEvent, next);
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+class WillCreateFilesFeature extends RequestFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onWillCreateFiles, proto.WillCreateFilesRequest.type, 'willCreate', 'willCreate', (i) => i, client.code2ProtocolConverter.asWillCreateFilesParams);
+    }
+    doSend(event, next) {
+        var _a;
+        const middleware = (_a = this._client.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace;
+        return (middleware === null || middleware === void 0 ? void 0 : middleware.willCreateFiles) ? middleware.willCreateFiles(event, next)
+            : next(event);
+    }
+}
+exports.WillCreateFilesFeature = WillCreateFilesFeature;
+class WillRenameFilesFeature extends RequestFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onWillRenameFiles, proto.WillRenameFilesRequest.type, 'willRename', 'willRename', (i) => i.oldUri, client.code2ProtocolConverter.asWillRenameFilesParams);
+    }
+    doSend(event, next) {
+        var _a;
+        const middleware = (_a = this._client.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace;
+        return (middleware === null || middleware === void 0 ? void 0 : middleware.willRenameFiles) ? middleware.willRenameFiles(event, next)
+            : next(event);
+    }
+}
+exports.WillRenameFilesFeature = WillRenameFilesFeature;
+class WillDeleteFilesFeature extends RequestFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onWillDeleteFiles, proto.WillDeleteFilesRequest.type, 'willDelete', 'willDelete', (i) => i, client.code2ProtocolConverter.asWillDeleteFilesParams);
+    }
+    doSend(event, next) {
+        var _a;
+        const middleware = (_a = this._client.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace;
+        return (middleware === null || middleware === void 0 ? void 0 : middleware.willDeleteFiles) ? middleware.willDeleteFiles(event, next)
+            : next(event);
+    }
+}
+exports.WillDeleteFilesFeature = WillDeleteFilesFeature;
+//# sourceMappingURL=fileOperations.js.map

node_modules/vscode-languageclient/lib/common/foldingRange.d.ts

@@ -0,0 +1,17 @@
+import { Disposable, TextDocument, ProviderResult, FoldingRange as VFoldingRange, FoldingContext, FoldingRangeProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, FoldingRangeRegistrationOptions, FoldingRangeOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideFoldingRangeSignature {
+    (this: void, document: TextDocument, context: FoldingContext, token: CancellationToken): ProviderResult<VFoldingRange[]>;
+}
+export interface FoldingRangeProviderMiddleware {
+    provideFoldingRanges?: (this: void, document: TextDocument, context: FoldingContext, token: CancellationToken, next: ProvideFoldingRangeSignature) => ProviderResult<VFoldingRange[]>;
+}
+export declare class FoldingRangeFeature extends TextDocumentFeature<boolean | FoldingRangeOptions, FoldingRangeRegistrationOptions, FoldingRangeProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: FoldingRangeRegistrationOptions): [Disposable, FoldingRangeProvider];
+    private static asFoldingRangeKind;
+    private static asFoldingRanges;
+}

node_modules/vscode-languageclient/lib/common/foldingRange.js

@@ -0,0 +1,77 @@
+"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.FoldingRangeFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class FoldingRangeFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.FoldingRangeRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let capability = ensure(ensure(capabilities, 'textDocument'), 'foldingRange');
+        capability.dynamicRegistration = true;
+        capability.rangeLimit = 5000;
+        capability.lineFoldingOnly = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.foldingRangeProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideFoldingRanges: (document, context, token) => {
+                const client = this._client;
+                const provideFoldingRanges = (document, _, token) => {
+                    const requestParams = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, requestParams, token).then(FoldingRangeFeature.asFoldingRanges, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideFoldingRanges
+                    ? middleware.provideFoldingRanges(document, context, token, provideFoldingRanges)
+                    : provideFoldingRanges(document, context, token);
+            }
+        };
+        return [vscode_1.languages.registerFoldingRangeProvider(options.documentSelector, provider), provider];
+    }
+    static asFoldingRangeKind(kind) {
+        if (kind) {
+            switch (kind) {
+                case vscode_languageserver_protocol_1.FoldingRangeKind.Comment:
+                    return vscode_1.FoldingRangeKind.Comment;
+                case vscode_languageserver_protocol_1.FoldingRangeKind.Imports:
+                    return vscode_1.FoldingRangeKind.Imports;
+                case vscode_languageserver_protocol_1.FoldingRangeKind.Region:
+                    return vscode_1.FoldingRangeKind.Region;
+            }
+        }
+        return void 0;
+    }
+    static asFoldingRanges(foldingRanges) {
+        if (Array.isArray(foldingRanges)) {
+            return foldingRanges.map(r => {
+                return new vscode_1.FoldingRange(r.startLine, r.endLine, FoldingRangeFeature.asFoldingRangeKind(r.kind));
+            });
+        }
+        return [];
+    }
+}
+exports.FoldingRangeFeature = FoldingRangeFeature;
+//# sourceMappingURL=foldingRange.js.map

node_modules/vscode-languageclient/lib/common/implementation.d.ts

@@ -0,0 +1,15 @@
+import { Disposable, TextDocument, ProviderResult, Position as VPosition, Definition as VDefinition, DefinitionLink as VDefinitionLink, ImplementationProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, ImplementationRegistrationOptions, ImplementationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideImplementationSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export interface ImplementationMiddleware {
+    provideImplementation?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideImplementationSignature) => ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export declare class ImplementationFeature extends TextDocumentFeature<boolean | ImplementationOptions, ImplementationRegistrationOptions, ImplementationProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: ImplementationRegistrationOptions): [Disposable, ImplementationProvider];
+}

node_modules/vscode-languageclient/lib/common/implementation.js

@@ -0,0 +1,52 @@
+"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.ImplementationFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class ImplementationFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.ImplementationRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let implementationSupport = ensure(ensure(capabilities, 'textDocument'), 'implementation');
+        implementationSupport.dynamicRegistration = true;
+        implementationSupport.linkSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.implementationProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideImplementation: (document, position, token) => {
+                const client = this._client;
+                const provideImplementation = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDefinitionResult, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideImplementation
+                    ? middleware.provideImplementation(document, position, token, provideImplementation)
+                    : provideImplementation(document, position, token);
+            }
+        };
+        return [vscode_1.languages.registerImplementationProvider(options.documentSelector, provider), provider];
+    }
+}
+exports.ImplementationFeature = ImplementationFeature;
+//# sourceMappingURL=implementation.js.map

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

@@ -0,0 +1,21 @@
+/// <reference path="../../typings/vscode-proposed.d.ts" />
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideLinkedEditingRangeSignature {
+    (this: void, document: code.TextDocument, position: code.Position, token: code.CancellationToken): code.ProviderResult<code.LinkedEditingRanges>;
+}
+/**
+ * Linked editing middleware
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeMiddleware {
+    provideLinkedEditingRange?: (this: void, document: code.TextDocument, position: code.Position, token: code.CancellationToken, next: ProvideLinkedEditingRangeSignature) => code.ProviderResult<code.LinkedEditingRanges>;
+}
+export declare class LinkedEditingFeature extends TextDocumentFeature<boolean | proto.LinkedEditingRangeOptions, proto.LinkedEditingRangeRegistrationOptions, code.LinkedEditingRangeProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: proto.ClientCapabilities): void;
+    initialize(capabilities: proto.ServerCapabilities, documentSelector: proto.DocumentSelector): void;
+    protected registerLanguageProvider(options: proto.LinkedEditingRangeRegistrationOptions): [code.Disposable, code.LinkedEditingRangeProvider];
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+/// <reference path="../../typings/vscode-proposed.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedEditingFeature = void 0;
+const code = require("vscode");
+const proto = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class LinkedEditingFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, proto.LinkedEditingRangeRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const linkedEditingSupport = ensure(ensure(capabilities, 'textDocument'), 'linkedEditingRange');
+        linkedEditingSupport.dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.linkedEditingRangeProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideLinkedEditingRanges: (document, position, token) => {
+                const client = this._client;
+                const provideLinkedEditing = (document, position, token) => {
+                    return client.sendRequest(proto.LinkedEditingRangeRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asLinkedEditingRanges, (error) => {
+                        return client.handleFailedRequest(proto.LinkedEditingRangeRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideLinkedEditingRange
+                    ? middleware.provideLinkedEditingRange(document, position, token, provideLinkedEditing)
+                    : provideLinkedEditing(document, position, token);
+            }
+        };
+        return [code.languages.registerLinkedEditingRangeProvider(options.documentSelector, provider), provider];
+    }
+}
+exports.LinkedEditingFeature = LinkedEditingFeature;
+//# sourceMappingURL=linkedEditingRange.js.map

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

@@ -0,0 +1,10 @@
+import { ClientCapabilities } from 'vscode-languageserver-protocol';
+import { BaseLanguageClient, StaticFeature } from './client';
+export declare class ProgressFeature implements StaticFeature {
+    private _client;
+    private activeParts;
+    constructor(_client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(): void;
+    dispose(): void;
+}

node_modules/vscode-languageclient/lib/common/progress.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.ProgressFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const progressPart_1 = require("./progressPart");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = Object.create(null);
+    }
+    return target[key];
+}
+class ProgressFeature {
+    constructor(_client) {
+        this._client = _client;
+        this.activeParts = new Set();
+    }
+    fillClientCapabilities(capabilities) {
+        ensure(capabilities, 'window').workDoneProgress = true;
+    }
+    initialize() {
+        const client = this._client;
+        const deleteHandler = (part) => {
+            this.activeParts.delete(part);
+        };
+        const createHandler = (params) => {
+            this.activeParts.add(new progressPart_1.ProgressPart(this._client, params.token, deleteHandler));
+        };
+        client.onRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, createHandler);
+    }
+    dispose() {
+        for (const part of this.activeParts) {
+            part.done();
+        }
+        this.activeParts.clear();
+    }
+}
+exports.ProgressFeature = ProgressFeature;
+//# sourceMappingURL=progress.js.map

node_modules/vscode-languageclient/lib/common/progressPart.d.ts

@@ -0,0 +1,22 @@
+import { Disposable } from 'vscode';
+import { ProgressToken, ProgressType, NotificationHandler, ProtocolNotificationType } from 'vscode-languageserver-protocol';
+export interface ProgressContext {
+    onProgress<P>(type: ProgressType<P>, token: string | number, handler: NotificationHandler<P>): Disposable;
+    sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params?: P): void;
+}
+export declare class ProgressPart {
+    private _client;
+    private _token;
+    private _infinite;
+    private _reported;
+    private _progress;
+    private _cancellationToken;
+    private _disposable;
+    private _resolve;
+    private _reject;
+    constructor(_client: ProgressContext, _token: ProgressToken, done?: (part: ProgressPart) => void);
+    private begin;
+    private report;
+    cancel(): void;
+    done(): void;
+}

node_modules/vscode-languageclient/lib/common/progressPart.js

@@ -0,0 +1,82 @@
+"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.ProgressPart = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+class ProgressPart {
+    constructor(_client, _token, done) {
+        this._client = _client;
+        this._token = _token;
+        this._reported = 0;
+        this._disposable = this._client.onProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, (value) => {
+            switch (value.kind) {
+                case 'begin':
+                    this.begin(value);
+                    break;
+                case 'report':
+                    this.report(value);
+                    break;
+                case 'end':
+                    this.done();
+                    done && done(this);
+                    break;
+            }
+        });
+    }
+    begin(params) {
+        // Since we don't use commands this will be a silent window progress with a hidden notification.
+        vscode_1.window.withProgress({ location: vscode_1.ProgressLocation.Window, cancellable: params.cancellable, title: params.title }, async (progress, cancellationToken) => {
+            this._progress = progress;
+            this._infinite = params.percentage === undefined;
+            this._cancellationToken = cancellationToken;
+            this._cancellationToken.onCancellationRequested(() => {
+                this._client.sendNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, { token: this._token });
+            });
+            this.report(params);
+            return new Promise((resolve, reject) => {
+                this._resolve = resolve;
+                this._reject = reject;
+            });
+        });
+    }
+    report(params) {
+        if (this._infinite && Is.string(params.message)) {
+            this._progress.report({ message: params.message });
+        }
+        else if (Is.number(params.percentage)) {
+            let percentage = Math.max(0, Math.min(params.percentage, 100));
+            let delta = Math.max(0, percentage - this._reported);
+            this._progress.report({ message: params.message, increment: delta });
+            this._reported += delta;
+        }
+    }
+    cancel() {
+        if (this._disposable) {
+            this._disposable.dispose();
+            this._disposable = undefined;
+        }
+        if (this._reject) {
+            this._reject();
+            this._resolve = undefined;
+            this._reject = undefined;
+        }
+    }
+    done() {
+        if (this._disposable) {
+            this._disposable.dispose();
+            this._disposable = undefined;
+        }
+        if (this._resolve) {
+            this._resolve();
+            this._resolve = undefined;
+            this._reject = undefined;
+        }
+    }
+}
+exports.ProgressPart = ProgressPart;
+//# sourceMappingURL=progressPart.js.map

node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.d.ts

@@ -0,0 +1,5 @@
+import * as code from 'vscode';
+export default class ProtocolCallHierarchyItem extends code.CallHierarchyItem {
+    data?: unknown;
+    constructor(kind: code.SymbolKind, name: string, detail: string, uri: code.Uri, range: code.Range, selectionRange: code.Range, data?: unknown);
+}

node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.js

@@ -0,0 +1,17 @@
+"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 });
+const code = require("vscode");
+class ProtocolCallHierarchyItem extends code.CallHierarchyItem {
+    constructor(kind, name, detail, uri, range, selectionRange, data) {
+        super(kind, name, detail, uri, range, selectionRange);
+        if (data !== undefined) {
+            this.data = data;
+        }
+    }
+}
+exports.default = ProtocolCallHierarchyItem;
+//# sourceMappingURL=protocolCallHierarchyItem.js.map

node_modules/vscode-languageclient/lib/common/protocolCodeAction.d.ts

@@ -0,0 +1,5 @@
+import * as vscode from 'vscode';
+export default class ProtocolCodeAction extends vscode.CodeAction {
+    readonly data: unknown | undefined;
+    constructor(title: string, data: unknown | undefined);
+}

node_modules/vscode-languageclient/lib/common/protocolCodeAction.js

@@ -0,0 +1,15 @@
+"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 });
+const vscode = require("vscode");
+class ProtocolCodeAction extends vscode.CodeAction {
+    constructor(title, data) {
+        super(title);
+        this.data = data;
+    }
+}
+exports.default = ProtocolCodeAction;
+//# sourceMappingURL=protocolCodeAction.js.map

node_modules/vscode-languageclient/lib/common/protocolCodeLens.d.ts

@@ -0,0 +1,5 @@
+import * as code from 'vscode';
+export default class ProtocolCodeLens extends code.CodeLens {
+    data: any;
+    constructor(range: code.Range);
+}

node_modules/vscode-languageclient/lib/common/protocolCodeLens.js

@@ -0,0 +1,14 @@
+"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 });
+const code = require("vscode");
+class ProtocolCodeLens extends code.CodeLens {
+    constructor(range) {
+        super(range);
+    }
+}
+exports.default = ProtocolCodeLens;
+//# sourceMappingURL=protocolCodeLens.js.map

node_modules/vscode-languageclient/lib/common/protocolCompletionItem.d.ts

@@ -0,0 +1,11 @@
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+export default class ProtocolCompletionItem extends code.CompletionItem {
+    data: any;
+    fromEdit: boolean | undefined;
+    documentationFormat: string | undefined;
+    originalItemKind: proto.CompletionItemKind | undefined;
+    deprecated: boolean | undefined;
+    insertTextMode: proto.InsertTextMode | undefined;
+    constructor(label: string);
+}

node_modules/vscode-languageclient/lib/common/protocolCompletionItem.js

@@ -0,0 +1,14 @@
+"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 });
+const code = require("vscode");
+class ProtocolCompletionItem extends code.CompletionItem {
+    constructor(label) {
+        super(label);
+    }
+}
+exports.default = ProtocolCompletionItem;
+//# sourceMappingURL=protocolCompletionItem.js.map

node_modules/vscode-languageclient/lib/common/protocolConverter.d.ts

@@ -0,0 +1,152 @@
+/// <reference path="../../typings/vscode-proposed.d.ts" />
+import * as code from 'vscode';
+import * as ls from 'vscode-languageserver-protocol';
+import ProtocolCompletionItem from './protocolCompletionItem';
+export interface Converter {
+    asUri(value: string): code.Uri;
+    asDiagnostic(diagnostic: ls.Diagnostic): code.Diagnostic;
+    asDiagnostics(diagnostics: ls.Diagnostic[]): code.Diagnostic[];
+    asPosition(value: undefined | null): undefined;
+    asPosition(value: ls.Position): code.Position;
+    asPosition(value: ls.Position | undefined | null): code.Position | undefined;
+    asRange(value: undefined | null): undefined;
+    asRange(value: ls.Range): code.Range;
+    asRange(value: ls.Range | undefined | null): code.Range | undefined;
+    asRanges(values: ls.Range[]): code.Range[];
+    asDiagnosticSeverity(value: number | undefined | null): code.DiagnosticSeverity;
+    asDiagnosticTag(tag: ls.DiagnosticTag): code.DiagnosticTag | undefined;
+    asHover(hover: ls.Hover): code.Hover;
+    asHover(hover: undefined | null): undefined;
+    asHover(hover: ls.Hover | undefined | null): code.Hover | undefined;
+    asCompletionResult(result: ls.CompletionList): code.CompletionList;
+    asCompletionResult(result: ls.CompletionItem[]): code.CompletionItem[];
+    asCompletionResult(result: undefined | null): undefined;
+    asCompletionResult(result: ls.CompletionItem[] | ls.CompletionList | undefined | null): code.CompletionItem[] | code.CompletionList | undefined;
+    asCompletionItem(item: ls.CompletionItem): ProtocolCompletionItem;
+    asTextEdit(edit: undefined | null): undefined;
+    asTextEdit(edit: ls.TextEdit): code.TextEdit;
+    asTextEdit(edit: ls.TextEdit | undefined | null): code.TextEdit | undefined;
+    asTextEdits(items: ls.TextEdit[]): code.TextEdit[];
+    asTextEdits(items: undefined | null): undefined;
+    asTextEdits(items: ls.TextEdit[] | undefined | null): code.TextEdit[] | undefined;
+    asSignatureHelp(item: undefined | null): undefined;
+    asSignatureHelp(item: ls.SignatureHelp): code.SignatureHelp;
+    asSignatureHelp(item: ls.SignatureHelp | undefined | null): code.SignatureHelp | undefined;
+    asSignatureInformation(item: ls.SignatureInformation): code.SignatureInformation;
+    asSignatureInformations(items: ls.SignatureInformation[]): code.SignatureInformation[];
+    asParameterInformation(item: ls.ParameterInformation): code.ParameterInformation;
+    asParameterInformations(item: ls.ParameterInformation[]): code.ParameterInformation[];
+    asLocation(item: ls.Location): code.Location;
+    asLocation(item: undefined | null): undefined;
+    asLocation(item: ls.Location | undefined | null): code.Location | undefined;
+    asDeclarationResult(item: ls.Declaration): code.Location | code.Location[];
+    asDeclarationResult(item: ls.DeclarationLink[]): code.LocationLink[];
+    asDeclarationResult(item: undefined | null): undefined;
+    asDeclarationResult(item: ls.Declaration | ls.DeclarationLink[] | undefined | null): code.Declaration | undefined;
+    asDefinitionResult(item: ls.Definition): code.Definition;
+    asDefinitionResult(item: ls.DefinitionLink[]): code.DefinitionLink[];
+    asDefinitionResult(item: undefined | null): undefined;
+    asDefinitionResult(item: ls.Definition | ls.DefinitionLink[] | undefined | null): code.Definition | code.DefinitionLink[] | undefined;
+    asReferences(values: ls.Location[]): code.Location[];
+    asReferences(values: undefined | null): code.Location[] | undefined;
+    asReferences(values: ls.Location[] | undefined | null): code.Location[] | undefined;
+    asDocumentHighlightKind(item: number): code.DocumentHighlightKind;
+    asDocumentHighlight(item: ls.DocumentHighlight): code.DocumentHighlight;
+    asDocumentHighlights(values: ls.DocumentHighlight[]): code.DocumentHighlight[];
+    asDocumentHighlights(values: undefined | null): undefined;
+    asDocumentHighlights(values: ls.DocumentHighlight[] | undefined | null): code.DocumentHighlight[] | undefined;
+    asSymbolKind(item: ls.SymbolKind): code.SymbolKind;
+    asSymbolTag(item: ls.SymbolTag): code.SymbolTag | undefined;
+    asSymbolTags(items: undefined | null): undefined;
+    asSymbolTags(items: ReadonlyArray<ls.SymbolTag>): code.SymbolTag[];
+    asSymbolTags(items: ReadonlyArray<ls.SymbolTag> | undefined | null): code.SymbolTag[] | undefined;
+    asSymbolInformation(item: ls.SymbolInformation, uri?: code.Uri): code.SymbolInformation;
+    asSymbolInformations(values: ls.SymbolInformation[], uri?: code.Uri): code.SymbolInformation[];
+    asSymbolInformations(values: undefined | null, uri?: code.Uri): undefined;
+    asSymbolInformations(values: ls.SymbolInformation[] | undefined | null, uri?: code.Uri): code.SymbolInformation[] | undefined;
+    asDocumentSymbol(value: ls.DocumentSymbol): code.DocumentSymbol;
+    asDocumentSymbols(value: undefined | null): undefined;
+    asDocumentSymbols(value: ls.DocumentSymbol[]): code.DocumentSymbol[];
+    asDocumentSymbols(value: ls.DocumentSymbol[] | undefined | null): code.DocumentSymbol[] | undefined;
+    asCommand(item: ls.Command): code.Command;
+    asCommands(items: ls.Command[]): code.Command[];
+    asCommands(items: undefined | null): undefined;
+    asCommands(items: ls.Command[] | undefined | null): code.Command[] | undefined;
+    asCodeAction(item: ls.CodeAction): code.CodeAction;
+    asCodeAction(item: undefined | null): undefined;
+    asCodeAction(item: ls.CodeAction | undefined | null): code.CodeAction | undefined;
+    asCodeActionKind(item: null | undefined): undefined;
+    asCodeActionKind(item: ls.CodeActionKind): code.CodeActionKind;
+    asCodeActionKind(item: ls.CodeActionKind | null | undefined): code.CodeActionKind | undefined;
+    asCodeActionKinds(item: null | undefined): undefined;
+    asCodeActionKinds(items: ls.CodeActionKind[]): code.CodeActionKind[];
+    asCodeActionKinds(item: ls.CodeActionKind[] | null | undefined): code.CodeActionKind[] | undefined;
+    asCodeLens(item: ls.CodeLens): code.CodeLens;
+    asCodeLens(item: undefined | null): undefined;
+    asCodeLens(item: ls.CodeLens | undefined | null): code.CodeLens | undefined;
+    asCodeLenses(items: ls.CodeLens[]): code.CodeLens[];
+    asCodeLenses(items: undefined | null): undefined;
+    asCodeLenses(items: ls.CodeLens[] | undefined | null): code.CodeLens[] | undefined;
+    asWorkspaceEdit(item: ls.WorkspaceEdit): code.WorkspaceEdit;
+    asWorkspaceEdit(item: undefined | null): undefined;
+    asWorkspaceEdit(item: ls.WorkspaceEdit | undefined | null): code.WorkspaceEdit | undefined;
+    asDocumentLink(item: ls.DocumentLink): code.DocumentLink;
+    asDocumentLinks(items: ls.DocumentLink[]): code.DocumentLink[];
+    asDocumentLinks(items: undefined | null): undefined;
+    asDocumentLinks(items: ls.DocumentLink[] | undefined | null): code.DocumentLink[] | undefined;
+    asColor(color: ls.Color): code.Color;
+    asColorInformation(ci: ls.ColorInformation): code.ColorInformation;
+    asColorInformations(colorPresentations: ls.ColorInformation[]): code.ColorInformation[];
+    asColorInformations(colorPresentations: undefined | null): undefined;
+    asColorInformations(colorInformation: ls.ColorInformation[] | undefined | null): code.ColorInformation[];
+    asColorPresentation(cp: ls.ColorPresentation): code.ColorPresentation;
+    asColorPresentations(colorPresentations: ls.ColorPresentation[]): code.ColorPresentation[];
+    asColorPresentations(colorPresentations: undefined | null): undefined;
+    asColorPresentations(colorPresentations: ls.ColorPresentation[] | undefined | null): undefined;
+    asFoldingRangeKind(kind: string | undefined): code.FoldingRangeKind | undefined;
+    asFoldingRange(r: ls.FoldingRange): code.FoldingRange;
+    asFoldingRanges(foldingRanges: ls.FoldingRange[]): code.FoldingRange[];
+    asFoldingRanges(foldingRanges: undefined | null): undefined;
+    asFoldingRanges(foldingRanges: ls.FoldingRange[] | undefined | null): code.FoldingRange[] | undefined;
+    asFoldingRanges(foldingRanges: ls.FoldingRange[] | undefined | null): code.FoldingRange[] | undefined;
+    asSelectionRange(selectionRange: ls.SelectionRange): code.SelectionRange;
+    asSelectionRanges(selectionRanges: ls.SelectionRange[]): code.SelectionRange[];
+    asSelectionRanges(selectionRanges: undefined | null): undefined;
+    asSelectionRanges(selectionRanges: ls.SelectionRange[] | undefined | null): code.SelectionRange[] | undefined;
+    asSelectionRanges(selectionRanges: ls.SelectionRange[] | undefined | null): code.SelectionRange[] | undefined;
+    asSemanticTokensLegend(value: ls.SemanticTokensLegend): code.SemanticTokensLegend;
+    asSemanticTokens(value: ls.SemanticTokens): code.SemanticTokens;
+    asSemanticTokens(value: undefined | null): undefined;
+    asSemanticTokens(value: ls.SemanticTokens | undefined | null): code.SemanticTokens | undefined;
+    asSemanticTokens(value: ls.SemanticTokens | undefined | null): code.SemanticTokens | undefined;
+    asSemanticTokensEdit(value: ls.SemanticTokensEdit): code.SemanticTokensEdit;
+    asSemanticTokensEdits(value: ls.SemanticTokensDelta): code.SemanticTokensEdits;
+    asSemanticTokensEdits(value: undefined | null): undefined;
+    asSemanticTokensEdits(value: ls.SemanticTokensDelta | undefined | null): code.SemanticTokensEdits | undefined;
+    asSemanticTokensEdits(value: ls.SemanticTokensDelta | undefined | null): code.SemanticTokensEdits | undefined;
+    asCallHierarchyItem(item: null): undefined;
+    asCallHierarchyItem(item: ls.CallHierarchyItem): code.CallHierarchyItem;
+    asCallHierarchyItem(item: ls.CallHierarchyItem | null): code.CallHierarchyItem | undefined;
+    asCallHierarchyItem(item: ls.CallHierarchyItem | null): code.CallHierarchyItem | undefined;
+    asCallHierarchyItems(items: null): undefined;
+    asCallHierarchyItems(items: ls.CallHierarchyItem[]): code.CallHierarchyItem[];
+    asCallHierarchyItems(items: ls.CallHierarchyItem[] | null): code.CallHierarchyItem[] | undefined;
+    asCallHierarchyItems(items: ls.CallHierarchyItem[] | null): code.CallHierarchyItem[] | undefined;
+    asCallHierarchyIncomingCall(item: ls.CallHierarchyIncomingCall): code.CallHierarchyIncomingCall;
+    asCallHierarchyIncomingCalls(items: null): undefined;
+    asCallHierarchyIncomingCalls(items: ReadonlyArray<ls.CallHierarchyIncomingCall>): code.CallHierarchyIncomingCall[];
+    asCallHierarchyIncomingCalls(items: ReadonlyArray<ls.CallHierarchyIncomingCall> | null): code.CallHierarchyIncomingCall[] | undefined;
+    asCallHierarchyIncomingCalls(items: ReadonlyArray<ls.CallHierarchyIncomingCall> | null): code.CallHierarchyIncomingCall[] | undefined;
+    asCallHierarchyOutgoingCall(item: ls.CallHierarchyOutgoingCall): code.CallHierarchyOutgoingCall;
+    asCallHierarchyOutgoingCalls(items: null): undefined;
+    asCallHierarchyOutgoingCalls(items: ReadonlyArray<ls.CallHierarchyOutgoingCall>): code.CallHierarchyOutgoingCall[];
+    asCallHierarchyOutgoingCalls(items: ReadonlyArray<ls.CallHierarchyOutgoingCall> | null): code.CallHierarchyOutgoingCall[] | undefined;
+    asCallHierarchyOutgoingCalls(items: ReadonlyArray<ls.CallHierarchyOutgoingCall> | null): code.CallHierarchyOutgoingCall[] | undefined;
+    asLinkedEditingRanges(value: null | undefined): undefined;
+    asLinkedEditingRanges(value: ls.LinkedEditingRanges): code.LinkedEditingRanges;
+    asLinkedEditingRanges(value: ls.LinkedEditingRanges | null | undefined): code.LinkedEditingRanges | undefined;
+}
+export interface URIConverter {
+    (value: string): code.Uri;
+}
+export declare function createConverter(uriConverter: URIConverter | undefined, trustMarkdown: boolean | undefined): Converter;

node_modules/vscode-languageclient/lib/common/protocolConverter.js

@@ -0,0 +1,904 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+/// <reference path="../../typings/vscode-proposed.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConverter = void 0;
+const code = require("vscode");
+const ls = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+const protocolCompletionItem_1 = require("./protocolCompletionItem");
+const protocolCodeLens_1 = require("./protocolCodeLens");
+const protocolDocumentLink_1 = require("./protocolDocumentLink");
+const protocolCodeAction_1 = require("./protocolCodeAction");
+const protocolDiagnostic_1 = require("./protocolDiagnostic");
+const protocolCallHierarchyItem_1 = require("./protocolCallHierarchyItem");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+var CodeBlock;
+(function (CodeBlock) {
+    function is(value) {
+        let candidate = value;
+        return candidate && Is.string(candidate.language) && Is.string(candidate.value);
+    }
+    CodeBlock.is = is;
+})(CodeBlock || (CodeBlock = {}));
+function createConverter(uriConverter, trustMarkdown) {
+    const nullConverter = (value) => code.Uri.parse(value);
+    const _uriConverter = uriConverter || nullConverter;
+    function asUri(value) {
+        return _uriConverter(value);
+    }
+    function asDiagnostics(diagnostics) {
+        return diagnostics.map(asDiagnostic);
+    }
+    function asDiagnostic(diagnostic) {
+        let result = new protocolDiagnostic_1.ProtocolDiagnostic(asRange(diagnostic.range), diagnostic.message, asDiagnosticSeverity(diagnostic.severity), diagnostic.data);
+        if (diagnostic.code !== undefined) {
+            if (ls.CodeDescription.is(diagnostic.codeDescription)) {
+                result.code = {
+                    value: diagnostic.code,
+                    target: asUri(diagnostic.codeDescription.href)
+                };
+            }
+            else if (protocolDiagnostic_1.DiagnosticCode.is(diagnostic.code)) {
+                result.hasDiagnosticCode = true;
+                result.code = {
+                    value: diagnostic.code.value,
+                    target: asUri(diagnostic.code.target)
+                };
+            }
+            else {
+                result.code = diagnostic.code;
+            }
+        }
+        if (diagnostic.source) {
+            result.source = diagnostic.source;
+        }
+        if (diagnostic.relatedInformation) {
+            result.relatedInformation = asRelatedInformation(diagnostic.relatedInformation);
+        }
+        if (Array.isArray(diagnostic.tags)) {
+            result.tags = asDiagnosticTags(diagnostic.tags);
+        }
+        return result;
+    }
+    function asRelatedInformation(relatedInformation) {
+        return relatedInformation.map(asDiagnosticRelatedInformation);
+    }
+    function asDiagnosticRelatedInformation(information) {
+        return new code.DiagnosticRelatedInformation(asLocation(information.location), information.message);
+    }
+    function asDiagnosticTags(tags) {
+        if (!tags) {
+            return undefined;
+        }
+        let result = [];
+        for (let tag of tags) {
+            let converted = asDiagnosticTag(tag);
+            if (converted !== undefined) {
+                result.push(converted);
+            }
+        }
+        return result.length > 0 ? result : undefined;
+    }
+    function asDiagnosticTag(tag) {
+        switch (tag) {
+            case ls.DiagnosticTag.Unnecessary:
+                return code.DiagnosticTag.Unnecessary;
+            case ls.DiagnosticTag.Deprecated:
+                return code.DiagnosticTag.Deprecated;
+            default:
+                return undefined;
+        }
+    }
+    function asPosition(value) {
+        if (!value) {
+            return undefined;
+        }
+        return new code.Position(value.line, value.character);
+    }
+    function asRange(value) {
+        if (!value) {
+            return undefined;
+        }
+        return new code.Range(asPosition(value.start), asPosition(value.end));
+    }
+    function asRanges(value) {
+        return value.map(value => asRange(value));
+    }
+    function asDiagnosticSeverity(value) {
+        if (value === undefined || value === null) {
+            return code.DiagnosticSeverity.Error;
+        }
+        switch (value) {
+            case ls.DiagnosticSeverity.Error:
+                return code.DiagnosticSeverity.Error;
+            case ls.DiagnosticSeverity.Warning:
+                return code.DiagnosticSeverity.Warning;
+            case ls.DiagnosticSeverity.Information:
+                return code.DiagnosticSeverity.Information;
+            case ls.DiagnosticSeverity.Hint:
+                return code.DiagnosticSeverity.Hint;
+        }
+        return code.DiagnosticSeverity.Error;
+    }
+    function asHoverContent(value) {
+        if (Is.string(value)) {
+            return asMarkdownString(value);
+        }
+        else if (CodeBlock.is(value)) {
+            let result = asMarkdownString();
+            return result.appendCodeblock(value.value, value.language);
+        }
+        else if (Array.isArray(value)) {
+            let result = [];
+            for (let element of value) {
+                let item = asMarkdownString();
+                if (CodeBlock.is(element)) {
+                    item.appendCodeblock(element.value, element.language);
+                }
+                else {
+                    item.appendMarkdown(element);
+                }
+                result.push(item);
+            }
+            return result;
+        }
+        else {
+            let result;
+            switch (value.kind) {
+                case ls.MarkupKind.Markdown:
+                    return asMarkdownString(value.value);
+                case ls.MarkupKind.PlainText:
+                    result = asMarkdownString();
+                    result.appendText(value.value);
+                    return result;
+                default:
+                    result = asMarkdownString();
+                    result.appendText(`Unsupported Markup content received. Kind is: ${value.kind}`);
+                    return result;
+            }
+        }
+    }
+    function asDocumentation(value) {
+        if (Is.string(value)) {
+            return value;
+        }
+        else {
+            switch (value.kind) {
+                case ls.MarkupKind.Markdown:
+                    return asMarkdownString(value.value);
+                case ls.MarkupKind.PlainText:
+                    return value.value;
+                default:
+                    return `Unsupported Markup content received. Kind is: ${value.kind}`;
+            }
+        }
+    }
+    function asMarkdownString(value) {
+        const result = new code.MarkdownString(value);
+        if (trustMarkdown === true) {
+            result.isTrusted = trustMarkdown;
+        }
+        return result;
+    }
+    function asHover(hover) {
+        if (!hover) {
+            return undefined;
+        }
+        return new code.Hover(asHoverContent(hover.contents), asRange(hover.range));
+    }
+    function asCompletionResult(result) {
+        if (!result) {
+            return undefined;
+        }
+        if (Array.isArray(result)) {
+            let items = result;
+            return items.map(asCompletionItem);
+        }
+        let list = result;
+        return new code.CompletionList(list.items.map(asCompletionItem), list.isIncomplete);
+    }
+    function asCompletionItemKind(value) {
+        // Protocol item kind is 1 based, codes item kind is zero based.
+        if (ls.CompletionItemKind.Text <= value && value <= ls.CompletionItemKind.TypeParameter) {
+            return [value - 1, undefined];
+        }
+        return [code.CompletionItemKind.Text, value];
+    }
+    function asCompletionItemTag(tag) {
+        switch (tag) {
+            case ls.CompletionItemTag.Deprecated:
+                return code.CompletionItemTag.Deprecated;
+        }
+        return undefined;
+    }
+    function asCompletionItemTags(tags) {
+        if (tags === undefined || tags === null) {
+            return [];
+        }
+        const result = [];
+        for (let tag of tags) {
+            const converted = asCompletionItemTag(tag);
+            if (converted !== undefined) {
+                result.push(converted);
+            }
+        }
+        return result;
+    }
+    function asCompletionItem(item) {
+        let tags = asCompletionItemTags(item.tags);
+        let result = new protocolCompletionItem_1.default(item.label);
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            result.documentation = asDocumentation(item.documentation);
+            result.documentationFormat = Is.string(item.documentation) ? '$string' : item.documentation.kind;
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        let insertText = asCompletionInsertText(item);
+        if (insertText) {
+            result.insertText = insertText.text;
+            result.range = insertText.range;
+            result.fromEdit = insertText.fromEdit;
+        }
+        if (Is.number(item.kind)) {
+            let [itemKind, original] = asCompletionItemKind(item.kind);
+            result.kind = itemKind;
+            if (original) {
+                result.originalItemKind = original;
+            }
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = asTextEdits(item.additionalTextEdits);
+        }
+        if (Is.stringArray(item.commitCharacters)) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = asCommand(item.command);
+        }
+        if (item.deprecated === true || item.deprecated === false) {
+            result.deprecated = item.deprecated;
+            if (item.deprecated === true) {
+                tags.push(code.CompletionItemTag.Deprecated);
+            }
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        if (item.data !== undefined) {
+            result.data = item.data;
+        }
+        if (tags.length > 0) {
+            result.tags = tags;
+        }
+        if (item.insertTextMode !== undefined) {
+            result.insertTextMode = item.insertTextMode;
+            if (item.insertTextMode === vscode_languageserver_protocol_1.InsertTextMode.asIs) {
+                result.keepWhitespace = true;
+            }
+        }
+        return result;
+    }
+    function asCompletionInsertText(item) {
+        if (item.textEdit) {
+            if (item.insertTextFormat === ls.InsertTextFormat.Snippet) {
+                return { text: new code.SnippetString(item.textEdit.newText), range: asCompletionRange(item.textEdit), fromEdit: true };
+            }
+            else {
+                return { text: item.textEdit.newText, range: asCompletionRange(item.textEdit), fromEdit: true };
+            }
+        }
+        else if (item.insertText) {
+            if (item.insertTextFormat === ls.InsertTextFormat.Snippet) {
+                return { text: new code.SnippetString(item.insertText), fromEdit: false };
+            }
+            else {
+                return { text: item.insertText, fromEdit: false };
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    function asCompletionRange(value) {
+        if (ls.InsertReplaceEdit.is(value)) {
+            return { inserting: asRange(value.insert), replacing: asRange(value.replace) };
+        }
+        else {
+            return asRange(value.range);
+        }
+    }
+    function asTextEdit(edit) {
+        if (!edit) {
+            return undefined;
+        }
+        return new code.TextEdit(asRange(edit.range), edit.newText);
+    }
+    function asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map(asTextEdit);
+    }
+    function asSignatureHelp(item) {
+        if (!item) {
+            return undefined;
+        }
+        let result = new code.SignatureHelp();
+        if (Is.number(item.activeSignature)) {
+            result.activeSignature = item.activeSignature;
+        }
+        else {
+            // activeSignature was optional in the past
+            result.activeSignature = 0;
+        }
+        if (Is.number(item.activeParameter)) {
+            result.activeParameter = item.activeParameter;
+        }
+        else {
+            // activeParameter was optional in the past
+            result.activeParameter = 0;
+        }
+        if (item.signatures) {
+            result.signatures = asSignatureInformations(item.signatures);
+        }
+        return result;
+    }
+    function asSignatureInformations(items) {
+        return items.map(asSignatureInformation);
+    }
+    function asSignatureInformation(item) {
+        let result = new code.SignatureInformation(item.label);
+        if (item.documentation !== undefined) {
+            result.documentation = asDocumentation(item.documentation);
+        }
+        if (item.parameters !== undefined) {
+            result.parameters = asParameterInformations(item.parameters);
+        }
+        if (item.activeParameter !== undefined) {
+            result.activeParameter = item.activeParameter;
+        }
+        {
+            return result;
+        }
+    }
+    function asParameterInformations(item) {
+        return item.map(asParameterInformation);
+    }
+    function asParameterInformation(item) {
+        let result = new code.ParameterInformation(item.label);
+        if (item.documentation) {
+            result.documentation = asDocumentation(item.documentation);
+        }
+        return result;
+    }
+    function asLocation(item) {
+        if (!item) {
+            return undefined;
+        }
+        return new code.Location(_uriConverter(item.uri), asRange(item.range));
+    }
+    function asDeclarationResult(item) {
+        if (!item) {
+            return undefined;
+        }
+        return asLocationResult(item);
+    }
+    function asDefinitionResult(item) {
+        if (!item) {
+            return undefined;
+        }
+        return asLocationResult(item);
+    }
+    function asLocationLink(item) {
+        if (!item) {
+            return undefined;
+        }
+        let result = {
+            targetUri: _uriConverter(item.targetUri),
+            targetRange: asRange(item.targetRange),
+            originSelectionRange: asRange(item.originSelectionRange),
+            targetSelectionRange: asRange(item.targetSelectionRange)
+        };
+        if (!result.targetSelectionRange) {
+            throw new Error(`targetSelectionRange must not be undefined or null`);
+        }
+        return result;
+    }
+    function asLocationResult(item) {
+        if (!item) {
+            return undefined;
+        }
+        if (Is.array(item)) {
+            if (item.length === 0) {
+                return [];
+            }
+            else if (ls.LocationLink.is(item[0])) {
+                let links = item;
+                return links.map((link) => asLocationLink(link));
+            }
+            else {
+                let locations = item;
+                return locations.map((location) => asLocation(location));
+            }
+        }
+        else if (ls.LocationLink.is(item)) {
+            return [asLocationLink(item)];
+        }
+        else {
+            return asLocation(item);
+        }
+    }
+    function asReferences(values) {
+        if (!values) {
+            return undefined;
+        }
+        return values.map(location => asLocation(location));
+    }
+    function asDocumentHighlights(values) {
+        if (!values) {
+            return undefined;
+        }
+        return values.map(asDocumentHighlight);
+    }
+    function asDocumentHighlight(item) {
+        let result = new code.DocumentHighlight(asRange(item.range));
+        if (Is.number(item.kind)) {
+            result.kind = asDocumentHighlightKind(item.kind);
+        }
+        return result;
+    }
+    function asDocumentHighlightKind(item) {
+        switch (item) {
+            case ls.DocumentHighlightKind.Text:
+                return code.DocumentHighlightKind.Text;
+            case ls.DocumentHighlightKind.Read:
+                return code.DocumentHighlightKind.Read;
+            case ls.DocumentHighlightKind.Write:
+                return code.DocumentHighlightKind.Write;
+        }
+        return code.DocumentHighlightKind.Text;
+    }
+    function asSymbolInformations(values, uri) {
+        if (!values) {
+            return undefined;
+        }
+        return values.map(information => asSymbolInformation(information, uri));
+    }
+    function asSymbolKind(item) {
+        if (item <= ls.SymbolKind.TypeParameter) {
+            // Symbol kind is one based in the protocol and zero based in code.
+            return item - 1;
+        }
+        return code.SymbolKind.Property;
+    }
+    function asSymbolTag(value) {
+        switch (value) {
+            case ls.SymbolTag.Deprecated:
+                return code.SymbolTag.Deprecated;
+            default:
+                return undefined;
+        }
+    }
+    function asSymbolTags(items) {
+        if (items === undefined || items === null) {
+            return undefined;
+        }
+        const result = [];
+        for (const item of items) {
+            const converted = asSymbolTag(item);
+            if (converted !== undefined) {
+                result.push(converted);
+            }
+        }
+        return result.length === 0 ? undefined : result;
+    }
+    function asSymbolInformation(item, uri) {
+        // Symbol kind is one based in the protocol and zero based in code.
+        let result = new code.SymbolInformation(item.name, asSymbolKind(item.kind), asRange(item.location.range), item.location.uri ? _uriConverter(item.location.uri) : uri);
+        fillTags(result, item);
+        if (item.containerName) {
+            result.containerName = item.containerName;
+        }
+        return result;
+    }
+    function asDocumentSymbols(values) {
+        if (values === undefined || values === null) {
+            return undefined;
+        }
+        return values.map(asDocumentSymbol);
+    }
+    function asDocumentSymbol(value) {
+        let result = new code.DocumentSymbol(value.name, value.detail || '', asSymbolKind(value.kind), asRange(value.range), asRange(value.selectionRange));
+        fillTags(result, value);
+        if (value.children !== undefined && value.children.length > 0) {
+            let children = [];
+            for (let child of value.children) {
+                children.push(asDocumentSymbol(child));
+            }
+            result.children = children;
+        }
+        return result;
+    }
+    function fillTags(result, value) {
+        result.tags = asSymbolTags(value.tags);
+        if (value.deprecated) {
+            if (!result.tags) {
+                result.tags = [code.SymbolTag.Deprecated];
+            }
+            else {
+                if (!result.tags.includes(code.SymbolTag.Deprecated)) {
+                    result.tags = result.tags.concat(code.SymbolTag.Deprecated);
+                }
+            }
+        }
+    }
+    function asCommand(item) {
+        let result = { title: item.title, command: item.command };
+        if (item.arguments) {
+            result.arguments = item.arguments;
+        }
+        return result;
+    }
+    function asCommands(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map(asCommand);
+    }
+    const kindMapping = new Map();
+    kindMapping.set(ls.CodeActionKind.Empty, code.CodeActionKind.Empty);
+    kindMapping.set(ls.CodeActionKind.QuickFix, code.CodeActionKind.QuickFix);
+    kindMapping.set(ls.CodeActionKind.Refactor, code.CodeActionKind.Refactor);
+    kindMapping.set(ls.CodeActionKind.RefactorExtract, code.CodeActionKind.RefactorExtract);
+    kindMapping.set(ls.CodeActionKind.RefactorInline, code.CodeActionKind.RefactorInline);
+    kindMapping.set(ls.CodeActionKind.RefactorRewrite, code.CodeActionKind.RefactorRewrite);
+    kindMapping.set(ls.CodeActionKind.Source, code.CodeActionKind.Source);
+    kindMapping.set(ls.CodeActionKind.SourceOrganizeImports, code.CodeActionKind.SourceOrganizeImports);
+    function asCodeActionKind(item) {
+        if (item === undefined || item === null) {
+            return undefined;
+        }
+        let result = kindMapping.get(item);
+        if (result) {
+            return result;
+        }
+        let parts = item.split('.');
+        result = code.CodeActionKind.Empty;
+        for (let part of parts) {
+            result = result.append(part);
+        }
+        return result;
+    }
+    function asCodeActionKinds(items) {
+        if (items === undefined || items === null) {
+            return undefined;
+        }
+        return items.map(kind => asCodeActionKind(kind));
+    }
+    function asCodeAction(item) {
+        if (item === undefined || item === null) {
+            return undefined;
+        }
+        let result = new protocolCodeAction_1.default(item.title, item.data);
+        if (item.kind !== undefined) {
+            result.kind = asCodeActionKind(item.kind);
+        }
+        if (item.diagnostics !== undefined) {
+            result.diagnostics = asDiagnostics(item.diagnostics);
+        }
+        if (item.edit !== undefined) {
+            result.edit = asWorkspaceEdit(item.edit);
+        }
+        if (item.command !== undefined) {
+            result.command = asCommand(item.command);
+        }
+        if (item.isPreferred !== undefined) {
+            result.isPreferred = item.isPreferred;
+        }
+        if (item.disabled !== undefined) {
+            result.disabled = { reason: item.disabled.reason };
+        }
+        return result;
+    }
+    function asCodeLens(item) {
+        if (!item) {
+            return undefined;
+        }
+        let result = new protocolCodeLens_1.default(asRange(item.range));
+        if (item.command) {
+            result.command = asCommand(item.command);
+        }
+        if (item.data !== undefined && item.data !== null) {
+            result.data = item.data;
+        }
+        return result;
+    }
+    function asCodeLenses(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map((codeLens) => asCodeLens(codeLens));
+    }
+    function asWorkspaceEdit(item) {
+        if (!item) {
+            return undefined;
+        }
+        const sharedMetadata = new Map();
+        if (item.changeAnnotations !== undefined) {
+            for (const key of Object.keys(item.changeAnnotations)) {
+                const metaData = asWorkspaceEditEntryMetadata(item.changeAnnotations[key]);
+                sharedMetadata.set(key, metaData);
+            }
+        }
+        const asMetadata = (annotation) => {
+            if (annotation === undefined) {
+                return undefined;
+            }
+            else {
+                return sharedMetadata.get(annotation);
+            }
+        };
+        const result = new code.WorkspaceEdit();
+        if (item.documentChanges) {
+            for (const change of item.documentChanges) {
+                if (ls.CreateFile.is(change)) {
+                    result.createFile(_uriConverter(change.uri), change.options, asMetadata(change.annotationId));
+                }
+                else if (ls.RenameFile.is(change)) {
+                    result.renameFile(_uriConverter(change.oldUri), _uriConverter(change.newUri), change.options, asMetadata(change.annotationId));
+                }
+                else if (ls.DeleteFile.is(change)) {
+                    result.deleteFile(_uriConverter(change.uri), change.options, asMetadata(change.annotationId));
+                }
+                else if (ls.TextDocumentEdit.is(change)) {
+                    const uri = _uriConverter(change.textDocument.uri);
+                    for (const edit of change.edits) {
+                        if (vscode_languageserver_protocol_1.AnnotatedTextEdit.is(edit)) {
+                            result.replace(uri, asRange(edit.range), edit.newText, asMetadata(edit.annotationId));
+                        }
+                        else {
+                            result.replace(uri, asRange(edit.range), edit.newText);
+                        }
+                    }
+                }
+                else {
+                    throw new Error(`Unknown workspace edit change received:\n${JSON.stringify(change, undefined, 4)}`);
+                }
+            }
+        }
+        else if (item.changes) {
+            Object.keys(item.changes).forEach(key => {
+                result.set(_uriConverter(key), asTextEdits(item.changes[key]));
+            });
+        }
+        return result;
+    }
+    function asWorkspaceEditEntryMetadata(annotation) {
+        if (annotation === undefined) {
+            return undefined;
+        }
+        return { label: annotation.label, needsConfirmation: !!annotation.needsConfirmation, description: annotation.description };
+    }
+    function asDocumentLink(item) {
+        let range = asRange(item.range);
+        let target = item.target ? asUri(item.target) : undefined;
+        // target must be optional in DocumentLink
+        let link = new protocolDocumentLink_1.default(range, target);
+        if (item.tooltip !== undefined) {
+            link.tooltip = item.tooltip;
+        }
+        if (item.data !== undefined && item.data !== null) {
+            link.data = item.data;
+        }
+        return link;
+    }
+    function asDocumentLinks(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map(asDocumentLink);
+    }
+    function asColor(color) {
+        return new code.Color(color.red, color.green, color.blue, color.alpha);
+    }
+    function asColorInformation(ci) {
+        return new code.ColorInformation(asRange(ci.range), asColor(ci.color));
+    }
+    function asColorInformations(colorInformation) {
+        if (Array.isArray(colorInformation)) {
+            return colorInformation.map(asColorInformation);
+        }
+        return undefined;
+    }
+    function asColorPresentation(cp) {
+        let presentation = new code.ColorPresentation(cp.label);
+        presentation.additionalTextEdits = asTextEdits(cp.additionalTextEdits);
+        if (cp.textEdit) {
+            presentation.textEdit = asTextEdit(cp.textEdit);
+        }
+        return presentation;
+    }
+    function asColorPresentations(colorPresentations) {
+        if (Array.isArray(colorPresentations)) {
+            return colorPresentations.map(asColorPresentation);
+        }
+        return undefined;
+    }
+    function asFoldingRangeKind(kind) {
+        if (kind) {
+            switch (kind) {
+                case ls.FoldingRangeKind.Comment:
+                    return code.FoldingRangeKind.Comment;
+                case ls.FoldingRangeKind.Imports:
+                    return code.FoldingRangeKind.Imports;
+                case ls.FoldingRangeKind.Region:
+                    return code.FoldingRangeKind.Region;
+            }
+        }
+        return undefined;
+    }
+    function asFoldingRange(r) {
+        return new code.FoldingRange(r.startLine, r.endLine, asFoldingRangeKind(r.kind));
+    }
+    function asFoldingRanges(foldingRanges) {
+        if (Array.isArray(foldingRanges)) {
+            return foldingRanges.map(asFoldingRange);
+        }
+        return undefined;
+    }
+    function asSelectionRange(selectionRange) {
+        return new code.SelectionRange(asRange(selectionRange.range), selectionRange.parent ? asSelectionRange(selectionRange.parent) : undefined);
+    }
+    function asSelectionRanges(selectionRanges) {
+        if (!Array.isArray(selectionRanges)) {
+            return [];
+        }
+        let result = [];
+        for (let range of selectionRanges) {
+            result.push(asSelectionRange(range));
+        }
+        return result;
+    }
+    function asCallHierarchyItem(item) {
+        if (item === null) {
+            return undefined;
+        }
+        let result = new protocolCallHierarchyItem_1.default(asSymbolKind(item.kind), item.name, item.detail || '', asUri(item.uri), asRange(item.range), asRange(item.selectionRange), item.data);
+        if (item.tags !== undefined) {
+            result.tags = asSymbolTags(item.tags);
+        }
+        return result;
+    }
+    function asCallHierarchyItems(items) {
+        if (items === null) {
+            return undefined;
+        }
+        return items.map(item => asCallHierarchyItem(item));
+    }
+    function asCallHierarchyIncomingCall(item) {
+        return new code.CallHierarchyIncomingCall(asCallHierarchyItem(item.from), asRanges(item.fromRanges));
+    }
+    function asCallHierarchyIncomingCalls(items) {
+        if (items === null) {
+            return undefined;
+        }
+        return items.map(item => asCallHierarchyIncomingCall(item));
+    }
+    function asCallHierarchyOutgoingCall(item) {
+        return new code.CallHierarchyOutgoingCall(asCallHierarchyItem(item.to), asRanges(item.fromRanges));
+    }
+    function asCallHierarchyOutgoingCalls(items) {
+        if (items === null) {
+            return undefined;
+        }
+        return items.map(item => asCallHierarchyOutgoingCall(item));
+    }
+    function asSemanticTokens(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        return new code.SemanticTokens(new Uint32Array(value.data), value.resultId);
+    }
+    function asSemanticTokensEdit(value) {
+        return new code.SemanticTokensEdit(value.start, value.deleteCount, value.data !== undefined ? new Uint32Array(value.data) : undefined);
+    }
+    function asSemanticTokensEdits(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        return new code.SemanticTokensEdits(value.edits.map(asSemanticTokensEdit), value.resultId);
+    }
+    function asSemanticTokensLegend(value) {
+        return value;
+    }
+    function asLinkedEditingRanges(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        return new code.LinkedEditingRanges(asRanges(value.ranges), asRegularExpression(value.wordPattern));
+    }
+    function asRegularExpression(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        return new RegExp(value);
+    }
+    return {
+        asUri,
+        asDiagnostics,
+        asDiagnostic,
+        asRange,
+        asRanges,
+        asPosition,
+        asDiagnosticSeverity,
+        asDiagnosticTag,
+        asHover,
+        asCompletionResult,
+        asCompletionItem,
+        asTextEdit,
+        asTextEdits,
+        asSignatureHelp,
+        asSignatureInformations,
+        asSignatureInformation,
+        asParameterInformations,
+        asParameterInformation,
+        asDeclarationResult,
+        asDefinitionResult,
+        asLocation,
+        asReferences,
+        asDocumentHighlights,
+        asDocumentHighlight,
+        asDocumentHighlightKind,
+        asSymbolKind,
+        asSymbolTag,
+        asSymbolTags,
+        asSymbolInformations,
+        asSymbolInformation,
+        asDocumentSymbols,
+        asDocumentSymbol,
+        asCommand,
+        asCommands,
+        asCodeAction,
+        asCodeActionKind,
+        asCodeActionKinds,
+        asCodeLens,
+        asCodeLenses,
+        asWorkspaceEdit,
+        asDocumentLink,
+        asDocumentLinks,
+        asFoldingRangeKind,
+        asFoldingRange,
+        asFoldingRanges,
+        asColor,
+        asColorInformation,
+        asColorInformations,
+        asColorPresentation,
+        asColorPresentations,
+        asSelectionRange,
+        asSelectionRanges,
+        asSemanticTokensLegend,
+        asSemanticTokens,
+        asSemanticTokensEdit,
+        asSemanticTokensEdits,
+        asCallHierarchyItem,
+        asCallHierarchyItems,
+        asCallHierarchyIncomingCall,
+        asCallHierarchyIncomingCalls,
+        asCallHierarchyOutgoingCall,
+        asCallHierarchyOutgoingCalls,
+        asLinkedEditingRanges: asLinkedEditingRanges
+    };
+}
+exports.createConverter = createConverter;
+//# sourceMappingURL=protocolConverter.js.map

node_modules/vscode-languageclient/lib/common/protocolDiagnostic.d.ts

@@ -0,0 +1,17 @@
+import * as vscode from 'vscode';
+/**
+ * We keep this for a while to not break servers which adopted
+ * proposed API.
+ */
+export interface DiagnosticCode {
+    value: string | number;
+    target: string;
+}
+export declare namespace DiagnosticCode {
+    function is(value: string | number | DiagnosticCode | undefined | null): value is DiagnosticCode;
+}
+export declare class ProtocolDiagnostic extends vscode.Diagnostic {
+    readonly data: unknown | undefined;
+    hasDiagnosticCode: boolean;
+    constructor(range: vscode.Range, message: string, severity: vscode.DiagnosticSeverity, data: unknown | undefined);
+}

node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js

@@ -0,0 +1,26 @@
+"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.ProtocolDiagnostic = exports.DiagnosticCode = void 0;
+const vscode = require("vscode");
+const Is = require("./utils/is");
+var DiagnosticCode;
+(function (DiagnosticCode) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && candidate !== null && (Is.number(candidate.value) || Is.string(candidate.value)) && Is.string(candidate.target);
+    }
+    DiagnosticCode.is = is;
+})(DiagnosticCode = exports.DiagnosticCode || (exports.DiagnosticCode = {}));
+class ProtocolDiagnostic extends vscode.Diagnostic {
+    constructor(range, message, severity, data) {
+        super(range, message, severity);
+        this.data = data;
+        this.hasDiagnosticCode = false;
+    }
+}
+exports.ProtocolDiagnostic = ProtocolDiagnostic;
+//# sourceMappingURL=protocolDiagnostic.js.map

node_modules/vscode-languageclient/lib/common/protocolDocumentLink.d.ts

@@ -0,0 +1,5 @@
+import * as code from 'vscode';
+export default class ProtocolDocumentLink extends code.DocumentLink {
+    data: any;
+    constructor(range: code.Range, target?: code.Uri | undefined);
+}

node_modules/vscode-languageclient/lib/common/protocolDocumentLink.js

@@ -0,0 +1,14 @@
+"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 });
+const code = require("vscode");
+class ProtocolDocumentLink extends code.DocumentLink {
+    constructor(range, target) {
+        super(range, target);
+    }
+}
+exports.default = ProtocolDocumentLink;
+//# sourceMappingURL=protocolDocumentLink.js.map

node_modules/vscode-languageclient/lib/common/selectionRange.d.ts

@@ -0,0 +1,15 @@
+import { Disposable, TextDocument, ProviderResult, Position as VPosition, SelectionRange as VSelectionRange, SelectionRangeProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, SelectionRangeOptions, SelectionRangeRegistrationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideSelectionRangeSignature {
+    (this: void, document: TextDocument, positions: VPosition[], token: CancellationToken): ProviderResult<VSelectionRange[]>;
+}
+export interface SelectionRangeProviderMiddleware {
+    provideSelectionRanges?: (this: void, document: TextDocument, positions: VPosition[], token: CancellationToken, next: ProvideSelectionRangeSignature) => ProviderResult<VSelectionRange[]>;
+}
+export declare class SelectionRangeFeature extends TextDocumentFeature<boolean | SelectionRangeOptions, SelectionRangeRegistrationOptions, SelectionRangeProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: SelectionRangeRegistrationOptions): [Disposable, SelectionRangeProvider];
+}

node_modules/vscode-languageclient/lib/common/selectionRange.js

@@ -0,0 +1,55 @@
+"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.SelectionRangeFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = Object.create(null);
+    }
+    return target[key];
+}
+class SelectionRangeFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.SelectionRangeRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let capability = ensure(ensure(capabilities, 'textDocument'), 'selectionRange');
+        capability.dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.selectionRangeProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideSelectionRanges: (document, positions, token) => {
+                const client = this._client;
+                const provideSelectionRanges = (document, positions, token) => {
+                    const requestParams = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        positions: client.code2ProtocolConverter.asPositions(positions)
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, requestParams, token).then((ranges) => client.protocol2CodeConverter.asSelectionRanges(ranges), (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideSelectionRanges
+                    ? middleware.provideSelectionRanges(document, positions, token, provideSelectionRanges)
+                    : provideSelectionRanges(document, positions, token);
+            }
+        };
+        return [vscode_1.languages.registerSelectionRangeProvider(options.documentSelector, provider), provider];
+    }
+}
+exports.SelectionRangeFeature = SelectionRangeFeature;
+//# sourceMappingURL=selectionRange.js.map

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

@@ -0,0 +1,33 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient, TextDocumentFeature } from './client';
+import { ClientCapabilities, ServerCapabilities, DocumentSelector, SemanticTokensOptions, SemanticTokensRegistrationOptions } from 'vscode-languageserver-protocol';
+export interface DocumentSemanticsTokensSignature {
+    (this: void, document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SemanticTokens>;
+}
+export interface DocumentSemanticsTokensEditsSignature {
+    (this: void, document: vscode.TextDocument, previousResultId: string, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens>;
+}
+export interface DocumentRangeSemanticTokensSignature {
+    (this: void, document: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SemanticTokens>;
+}
+/**
+ * The semantic token middleware
+ *
+ * @since 3.16.0
+ */
+export interface SemanticTokensMiddleware {
+    provideDocumentSemanticTokens?: (this: void, document: vscode.TextDocument, token: vscode.CancellationToken, next: DocumentSemanticsTokensSignature) => vscode.ProviderResult<vscode.SemanticTokens>;
+    provideDocumentSemanticTokensEdits?: (this: void, document: vscode.TextDocument, previousResultId: string, token: vscode.CancellationToken, next: DocumentSemanticsTokensEditsSignature) => vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens>;
+    provideDocumentRangeSemanticTokens?: (this: void, document: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken, next: DocumentRangeSemanticTokensSignature) => vscode.ProviderResult<vscode.SemanticTokens>;
+}
+export interface SemanticTokensProviders {
+    range?: vscode.DocumentRangeSemanticTokensProvider;
+    full?: vscode.DocumentSemanticTokensProvider;
+    onDidChangeSemanticTokensEmitter: vscode.EventEmitter<void>;
+}
+export declare class SemanticTokensFeature extends TextDocumentFeature<boolean | SemanticTokensOptions, SemanticTokensRegistrationOptions, SemanticTokensProviders> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: SemanticTokensRegistrationOptions): [vscode.Disposable, SemanticTokensProviders];
+}

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

@@ -0,0 +1,172 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticTokensFeature = void 0;
+const vscode = require("vscode");
+const client_1 = require("./client");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class SemanticTokensFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.SemanticTokensRegistrationType.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const capability = ensure(ensure(capabilities, 'textDocument'), 'semanticTokens');
+        capability.dynamicRegistration = true;
+        capability.tokenTypes = [
+            vscode_languageserver_protocol_1.SemanticTokenTypes.namespace,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.type,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.class,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.enum,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.interface,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.struct,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.typeParameter,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.parameter,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.variable,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.property,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.enumMember,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.event,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.function,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.method,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.macro,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.keyword,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.modifier,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.comment,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.string,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.number,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.regexp,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.operator
+        ];
+        capability.tokenModifiers = [
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.declaration,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.definition,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.readonly,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.static,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.deprecated,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.abstract,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.async,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.modification,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.documentation,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.defaultLibrary
+        ];
+        capability.formats = [vscode_languageserver_protocol_1.TokenFormat.Relative];
+        capability.requests = {
+            range: true,
+            full: {
+                delta: true
+            }
+        };
+        capability.multilineTokenSupport = false;
+        capability.overlappingTokenSupport = false;
+        ensure(ensure(capabilities, 'workspace'), 'semanticTokens').refreshSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const client = this._client;
+        client.onRequest(vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type, async () => {
+            for (const provider of this.getAllProviders()) {
+                provider.onDidChangeSemanticTokensEmitter.fire();
+            }
+        });
+        const [id, options] = this.getRegistration(documentSelector, capabilities.semanticTokensProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const fullProvider = Is.boolean(options.full) ? options.full : options.full !== undefined;
+        const hasEditProvider = options.full !== undefined && typeof options.full !== 'boolean' && options.full.delta === true;
+        const eventEmitter = new vscode.EventEmitter();
+        const documentProvider = fullProvider
+            ? {
+                onDidChangeSemanticTokens: eventEmitter.event,
+                provideDocumentSemanticTokens: (document, token) => {
+                    const client = this._client;
+                    const middleware = client.clientOptions.middleware;
+                    const provideDocumentSemanticTokens = (document, token) => {
+                        const params = {
+                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+                        };
+                        return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, params, token).then((result) => {
+                            return client.protocol2CodeConverter.asSemanticTokens(result);
+                        }, (error) => {
+                            return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, error, null);
+                        });
+                    };
+                    return middleware.provideDocumentSemanticTokens
+                        ? middleware.provideDocumentSemanticTokens(document, token, provideDocumentSemanticTokens)
+                        : provideDocumentSemanticTokens(document, token);
+                },
+                provideDocumentSemanticTokensEdits: hasEditProvider
+                    ? (document, previousResultId, token) => {
+                        const client = this._client;
+                        const middleware = client.clientOptions.middleware;
+                        const provideDocumentSemanticTokensEdits = (document, previousResultId, token) => {
+                            const params = {
+                                textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                                previousResultId
+                            };
+                            return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, params, token).then((result) => {
+                                if (vscode_languageserver_protocol_1.SemanticTokens.is(result)) {
+                                    return client.protocol2CodeConverter.asSemanticTokens(result);
+                                }
+                                else {
+                                    return client.protocol2CodeConverter.asSemanticTokensEdits(result);
+                                }
+                            }, (error) => {
+                                return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, error, null);
+                            });
+                        };
+                        return middleware.provideDocumentSemanticTokensEdits
+                            ? middleware.provideDocumentSemanticTokensEdits(document, previousResultId, token, provideDocumentSemanticTokensEdits)
+                            : provideDocumentSemanticTokensEdits(document, previousResultId, token);
+                    }
+                    : undefined
+            }
+            : undefined;
+        const hasRangeProvider = options.range === true;
+        const rangeProvider = hasRangeProvider
+            ? {
+                provideDocumentRangeSemanticTokens: (document, range, token) => {
+                    const client = this._client;
+                    const middleware = client.clientOptions.middleware;
+                    const provideDocumentRangeSemanticTokens = (document, range, token) => {
+                        const params = {
+                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                            range: client.code2ProtocolConverter.asRange(range)
+                        };
+                        return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, params, token).then((result) => {
+                            return client.protocol2CodeConverter.asSemanticTokens(result);
+                        }, (error) => {
+                            return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, error, null);
+                        });
+                    };
+                    return middleware.provideDocumentRangeSemanticTokens
+                        ? middleware.provideDocumentRangeSemanticTokens(document, range, token, provideDocumentRangeSemanticTokens)
+                        : provideDocumentRangeSemanticTokens(document, range, token);
+                }
+            }
+            : undefined;
+        const disposables = [];
+        const client = this._client;
+        const legend = client.protocol2CodeConverter.asSemanticTokensLegend(options.legend);
+        if (documentProvider !== undefined) {
+            disposables.push(vscode.languages.registerDocumentSemanticTokensProvider(options.documentSelector, documentProvider, legend));
+        }
+        if (rangeProvider !== undefined) {
+            disposables.push(vscode.languages.registerDocumentRangeSemanticTokensProvider(options.documentSelector, rangeProvider, legend));
+        }
+        return [new vscode.Disposable(() => disposables.forEach(item => item.dispose())), { range: rangeProvider, full: documentProvider, onDidChangeSemanticTokensEmitter: eventEmitter }];
+    }
+}
+exports.SemanticTokensFeature = SemanticTokensFeature;
+//# sourceMappingURL=semanticTokens.js.map

node_modules/vscode-languageclient/lib/common/typeDefinition.d.ts

@@ -0,0 +1,15 @@
+import { Disposable, TextDocument, ProviderResult, Position as VPosition, Definition as VDefinition, DefinitionLink as VDefinitionLink, TypeDefinitionProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, TypeDefinitionRegistrationOptions, TypeDefinitionOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentFeature, BaseLanguageClient } from './client';
+export interface ProvideTypeDefinitionSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export interface TypeDefinitionMiddleware {
+    provideTypeDefinition?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideTypeDefinitionSignature) => ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export declare class TypeDefinitionFeature extends TextDocumentFeature<boolean | TypeDefinitionOptions, TypeDefinitionRegistrationOptions, TypeDefinitionProvider> {
+    constructor(client: BaseLanguageClient);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: TypeDefinitionRegistrationOptions): [Disposable, TypeDefinitionProvider];
+}

node_modules/vscode-languageclient/lib/common/typeDefinition.js

@@ -0,0 +1,53 @@
+"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.TypeDefinitionFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const client_1 = require("./client");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+class TypeDefinitionFeature extends client_1.TextDocumentFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.TypeDefinitionRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        ensure(ensure(capabilities, 'textDocument'), 'typeDefinition').dynamicRegistration = true;
+        let typeDefinitionSupport = ensure(ensure(capabilities, 'textDocument'), 'typeDefinition');
+        typeDefinitionSupport.dynamicRegistration = true;
+        typeDefinitionSupport.linkSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.typeDefinitionProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideTypeDefinition: (document, position, token) => {
+                const client = this._client;
+                const provideTypeDefinition = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDefinitionResult, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, error, null);
+                    });
+                };
+                const middleware = client.clientOptions.middleware;
+                return middleware.provideTypeDefinition
+                    ? middleware.provideTypeDefinition(document, position, token, provideTypeDefinition)
+                    : provideTypeDefinition(document, position, token);
+            }
+        };
+        return [vscode_1.languages.registerTypeDefinitionProvider(options.documentSelector, provider), provider];
+    }
+}
+exports.TypeDefinitionFeature = TypeDefinitionFeature;
+//# sourceMappingURL=typeDefinition.js.map

node_modules/vscode-languageclient/lib/common/utils/async.d.ts

@@ -0,0 +1,16 @@
+export interface ITask<T> {
+    (): T;
+}
+export declare class Delayer<T> {
+    defaultDelay: number;
+    private timeout;
+    private completionPromise;
+    private onSuccess;
+    private task;
+    constructor(defaultDelay: number);
+    trigger(task: ITask<T>, delay?: number): Promise<T>;
+    forceDelivery(): T | undefined;
+    isTriggered(): boolean;
+    cancel(): void;
+    private cancelTimeout;
+}

node_modules/vscode-languageclient/lib/common/utils/async.js

@@ -0,0 +1,67 @@
+"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.Delayer = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+class Delayer {
+    constructor(defaultDelay) {
+        this.defaultDelay = defaultDelay;
+        this.timeout = undefined;
+        this.completionPromise = undefined;
+        this.onSuccess = undefined;
+        this.task = undefined;
+    }
+    trigger(task, delay = this.defaultDelay) {
+        this.task = task;
+        if (delay >= 0) {
+            this.cancelTimeout();
+        }
+        if (!this.completionPromise) {
+            this.completionPromise = new Promise((resolve) => {
+                this.onSuccess = resolve;
+            }).then(() => {
+                this.completionPromise = undefined;
+                this.onSuccess = undefined;
+                var result = this.task();
+                this.task = undefined;
+                return result;
+            });
+        }
+        if (delay >= 0 || this.timeout === void 0) {
+            this.timeout = vscode_languageserver_protocol_1.RAL().timer.setTimeout(() => {
+                this.timeout = undefined;
+                this.onSuccess(undefined);
+            }, delay >= 0 ? delay : this.defaultDelay);
+        }
+        return this.completionPromise;
+    }
+    forceDelivery() {
+        if (!this.completionPromise) {
+            return undefined;
+        }
+        this.cancelTimeout();
+        let result = this.task();
+        this.completionPromise = undefined;
+        this.onSuccess = undefined;
+        this.task = undefined;
+        return result;
+    }
+    isTriggered() {
+        return this.timeout !== void 0;
+    }
+    cancel() {
+        this.cancelTimeout();
+        this.completionPromise = undefined;
+    }
+    cancelTimeout() {
+        if (this.timeout !== void 0) {
+            vscode_languageserver_protocol_1.RAL().timer.clearTimeout(this.timeout);
+            this.timeout = undefined;
+        }
+    }
+}
+exports.Delayer = Delayer;
+//# sourceMappingURL=async.js.map

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

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

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

@@ -0,0 +1,58 @@
+"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.asPromise = exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
+function boolean(value) {
+    return value === true || value === false;
+}
+exports.boolean = boolean;
+function string(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+exports.string = string;
+function number(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+exports.number = number;
+function error(value) {
+    return value instanceof Error;
+}
+exports.error = error;
+function func(value) {
+    return typeof value === 'function';
+}
+exports.func = func;
+function array(value) {
+    return Array.isArray(value);
+}
+exports.array = array;
+function stringArray(value) {
+    return array(value) && value.every(elem => string(elem));
+}
+exports.stringArray = stringArray;
+function typedArray(value, check) {
+    return Array.isArray(value) && value.every(check);
+}
+exports.typedArray = typedArray;
+function thenable(value) {
+    return value && func(value.then);
+}
+exports.thenable = thenable;
+function asPromise(value) {
+    if (value instanceof Promise) {
+        return value;
+    }
+    else if (thenable(value)) {
+        return new Promise((resolve, reject) => {
+            value.then((resolved) => resolve(resolved), (error) => reject(error));
+        });
+    }
+    else {
+        return Promise.resolve(value);
+    }
+}
+exports.asPromise = asPromise;
+//# sourceMappingURL=is.js.map

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

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

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

@@ -0,0 +1,98 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0;
+class ValueUUID {
+    constructor(_value) {
+        this._value = _value;
+        // empty
+    }
+    asHex() {
+        return this._value;
+    }
+    equals(other) {
+        return this.asHex() === other.asHex();
+    }
+}
+class V4UUID extends ValueUUID {
+    constructor() {
+        super([
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            '4',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._oneOf(V4UUID._timeHighBits),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+        ].join(''));
+    }
+    static _oneOf(array) {
+        return array[Math.floor(array.length * Math.random())];
+    }
+    static _randomHex() {
+        return V4UUID._oneOf(V4UUID._chars);
+    }
+}
+V4UUID._chars = ['0', '1', '2', '3', '4', '5', '6', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+V4UUID._timeHighBits = ['8', '9', 'a', 'b'];
+/**
+ * An empty UUID that contains only zeros.
+ */
+exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000');
+function v4() {
+    return new V4UUID();
+}
+exports.v4 = v4;
+const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+    return _UUIDPattern.test(value);
+}
+exports.isUUID = isUUID;
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+function parse(value) {
+    if (!isUUID(value)) {
+        throw new Error('invalid uuid');
+    }
+    return new ValueUUID(value);
+}
+exports.parse = parse;
+function generateUuid() {
+    return v4().asHex();
+}
+exports.generateUuid = generateUuid;
+//# sourceMappingURL=uuid.js.map

node_modules/vscode-languageclient/lib/common/workspaceFolders.d.ts

@@ -0,0 +1,25 @@
+import { WorkspaceFolder as VWorkspaceFolder, WorkspaceFoldersChangeEvent as VWorkspaceFoldersChangeEvent } from 'vscode';
+import { DynamicFeature, RegistrationData, BaseLanguageClient, NextSignature } from './client';
+import { ClientCapabilities, InitializeParams, ServerCapabilities, WorkspaceFoldersRequest, RegistrationType } from 'vscode-languageserver-protocol';
+export declare function arrayDiff<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): T[];
+export interface WorkspaceFolderWorkspaceMiddleware {
+    workspaceFolders?: WorkspaceFoldersRequest.MiddlewareSignature;
+    didChangeWorkspaceFolders?: NextSignature<VWorkspaceFoldersChangeEvent, void>;
+}
+export declare class WorkspaceFoldersFeature implements DynamicFeature<void> {
+    private _client;
+    private _listeners;
+    private _initialFolders;
+    constructor(_client: BaseLanguageClient);
+    get registrationType(): RegistrationType<void>;
+    fillInitializeParams(params: InitializeParams): void;
+    protected initializeWithFolders(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities): void;
+    protected sendInitialEvent(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
+    private doSendEvent;
+    register(data: RegistrationData<undefined>): void;
+    unregister(id: string): void;
+    dispose(): void;
+    private asProtocol;
+}

node_modules/vscode-languageclient/lib/common/workspaceFolders.js

@@ -0,0 +1,137 @@
+"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.WorkspaceFoldersFeature = exports.arrayDiff = void 0;
+const UUID = require("./utils/uuid");
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+function access(target, key) {
+    if (target === void 0) {
+        return undefined;
+    }
+    return target[key];
+}
+function arrayDiff(left, right) {
+    return left.filter(element => right.indexOf(element) < 0);
+}
+exports.arrayDiff = arrayDiff;
+class WorkspaceFoldersFeature {
+    constructor(_client) {
+        this._client = _client;
+        this._listeners = new Map();
+    }
+    get registrationType() {
+        return vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type;
+    }
+    fillInitializeParams(params) {
+        const folders = vscode_1.workspace.workspaceFolders;
+        this.initializeWithFolders(folders);
+        if (folders === void 0) {
+            params.workspaceFolders = null;
+        }
+        else {
+            params.workspaceFolders = folders.map(folder => this.asProtocol(folder));
+        }
+    }
+    initializeWithFolders(currentWorkspaceFolders) {
+        this._initialFolders = currentWorkspaceFolders;
+    }
+    fillClientCapabilities(capabilities) {
+        capabilities.workspace = capabilities.workspace || {};
+        capabilities.workspace.workspaceFolders = true;
+    }
+    initialize(capabilities) {
+        const client = this._client;
+        client.onRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type, (token) => {
+            const workspaceFolders = () => {
+                const folders = vscode_1.workspace.workspaceFolders;
+                if (folders === undefined) {
+                    return null;
+                }
+                const result = folders.map((folder) => {
+                    return this.asProtocol(folder);
+                });
+                return result;
+            };
+            const middleware = client.clientOptions.middleware.workspace;
+            return middleware && middleware.workspaceFolders
+                ? middleware.workspaceFolders(token, workspaceFolders)
+                : workspaceFolders(token);
+        });
+        const value = access(access(access(capabilities, 'workspace'), 'workspaceFolders'), 'changeNotifications');
+        let id;
+        if (typeof value === 'string') {
+            id = value;
+        }
+        else if (value === true) {
+            id = UUID.generateUuid();
+        }
+        if (id) {
+            this.register({ id: id, registerOptions: undefined });
+        }
+    }
+    sendInitialEvent(currentWorkspaceFolders) {
+        if (this._initialFolders && currentWorkspaceFolders) {
+            const removed = arrayDiff(this._initialFolders, currentWorkspaceFolders);
+            const added = arrayDiff(currentWorkspaceFolders, this._initialFolders);
+            if (added.length > 0 || removed.length > 0) {
+                this.doSendEvent(added, removed);
+            }
+        }
+        else if (this._initialFolders) {
+            this.doSendEvent([], this._initialFolders);
+        }
+        else if (currentWorkspaceFolders) {
+            this.doSendEvent(currentWorkspaceFolders, []);
+        }
+    }
+    doSendEvent(addedFolders, removedFolders) {
+        let params = {
+            event: {
+                added: addedFolders.map(folder => this.asProtocol(folder)),
+                removed: removedFolders.map(folder => this.asProtocol(folder))
+            }
+        };
+        this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, params);
+    }
+    register(data) {
+        let id = data.id;
+        let client = this._client;
+        let disposable = vscode_1.workspace.onDidChangeWorkspaceFolders((event) => {
+            let didChangeWorkspaceFolders = (event) => {
+                this.doSendEvent(event.added, event.removed);
+            };
+            let middleware = client.clientOptions.middleware.workspace;
+            middleware && middleware.didChangeWorkspaceFolders
+                ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders)
+                : didChangeWorkspaceFolders(event);
+        });
+        this._listeners.set(id, disposable);
+        this.sendInitialEvent(vscode_1.workspace.workspaceFolders);
+    }
+    unregister(id) {
+        let disposable = this._listeners.get(id);
+        if (disposable === void 0) {
+            return;
+        }
+        this._listeners.delete(id);
+        disposable.dispose();
+    }
+    dispose() {
+        for (let disposable of this._listeners.values()) {
+            disposable.dispose();
+        }
+        this._listeners.clear();
+    }
+    asProtocol(workspaceFolder) {
+        if (workspaceFolder === void 0) {
+            return null;
+        }
+        return { uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri), name: workspaceFolder.name };
+    }
+}
+exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;
+//# sourceMappingURL=workspaceFolders.js.map