Initial

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

@@ -0,0 +1,146 @@
+import { ErrorCodes, ResponseError, CancellationToken, CancellationTokenSource, Disposable, Event, Emitter, Trace, Tracer, TraceFormat, TraceOptions, SetTraceNotification, LogTraceNotification, Message, NotificationMessage, RequestMessage, MessageType as RPCMessageType, RequestType, RequestType0, RequestHandler, RequestHandler0, GenericRequestHandler, StarRequestHandler, NotificationType, NotificationType0, NotificationHandler, NotificationHandler0, GenericNotificationHandler, StarNotificationHandler, MessageReader, MessageWriter, Logger, ConnectionStrategy, StreamMessageReader, StreamMessageWriter, IPCMessageReader, IPCMessageWriter, createClientPipeTransport, createServerPipeTransport, generateRandomPipeName, DataCallback, createClientSocketTransport, createServerSocketTransport } from 'vscode-jsonrpc';
+export { ErrorCodes, ResponseError, CancellationToken, CancellationTokenSource, Disposable, Event, Emitter, Trace, Tracer, TraceFormat, TraceOptions, SetTraceNotification, LogTraceNotification, Message, NotificationMessage, RequestMessage, RPCMessageType, RequestType, RequestType0, RequestHandler, RequestHandler0, GenericRequestHandler, StarRequestHandler, NotificationType, NotificationType0, NotificationHandler, NotificationHandler0, GenericNotificationHandler, StarNotificationHandler, MessageReader, MessageWriter, Logger, ConnectionStrategy, StreamMessageReader, StreamMessageWriter, IPCMessageReader, IPCMessageWriter, createClientPipeTransport, createServerPipeTransport, generateRandomPipeName, DataCallback, createClientSocketTransport, createServerSocketTransport, };
+export * from 'vscode-languageserver-types';
+export * from './protocol';
+export { FoldingRangeParams as FoldingRangeRequestParam } from './protocol';
+export declare namespace Proposed {
+}
+export interface ProtocolConnection {
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param type The type of request to sent.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<R, E, RO>(type: RequestType0<R, E, RO>, token?: CancellationToken): Thenable<R>;
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param type The type of request to sent.
+     * @param params The request's parameter.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<P, R, E, RO>(type: RequestType<P, R, E, RO>, params: P, token?: CancellationToken): Thenable<R>;
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param method the request's method name.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<R>(method: string, token?: CancellationToken): Thenable<R>;
+    /**
+     * Sends a request and returns a promise resolving to the result of the request.
+     *
+     * @param method the request's method name.
+     * @param params The request's parameter.
+     * @param token An optional cancellation token.
+     * @returns A promise resolving to the request's result.
+     */
+    sendRequest<R>(method: string, param: any, token?: CancellationToken): Thenable<R>;
+    /**
+     * Installs a request handler.
+     *
+     * @param type The request type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onRequest<R, E, RO>(type: RequestType0<R, E, RO>, handler: RequestHandler0<R, E>): void;
+    /**
+     * Installs a request handler.
+     *
+     * @param type The request type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onRequest<P, R, E, RO>(type: RequestType<P, R, E, RO>, handler: RequestHandler<P, R, E>): void;
+    /**
+     * Installs a request handler.
+     *
+     * @param methods The method name to install the handler for.
+     * @param handler The actual handler.
+     */
+    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): void;
+    /**
+     * Sends a notification.
+     *
+     * @param type the notification's type to send.
+     */
+    sendNotification<RO>(type: NotificationType0<RO>): void;
+    /**
+     * Sends a notification.
+     *
+     * @param type the notification's type to send.
+     * @param params the notification's parameters.
+     */
+    sendNotification<P, RO>(type: NotificationType<P, RO>, params?: P): void;
+    /**
+     * Sends a notification.
+     *
+     * @param method the notification's method name.
+     */
+    sendNotification(method: string): void;
+    /**
+     * Sends a notification.
+     *
+     * @param method the notification's method name.
+     * @param params the notification's parameters.
+     */
+    sendNotification(method: string, params: any): void;
+    /**
+     * Installs a notification handler.
+     *
+     * @param type The notification type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onNotification<RO>(type: NotificationType0<RO>, handler: NotificationHandler0): void;
+    /**
+     * Installs a notification handler.
+     *
+     * @param type The notification type to install the handler for.
+     * @param handler The actual handler.
+     */
+    onNotification<P, RO>(type: NotificationType<P, RO>, handler: NotificationHandler<P>): void;
+    /**
+     * Installs a notification handler.
+     *
+     * @param methods The method name to install the handler for.
+     * @param handler The actual handler.
+     */
+    onNotification(method: string, handler: GenericNotificationHandler): void;
+    /**
+     * Enables tracing mode for the connection.
+     */
+    trace(value: Trace, tracer: Tracer, sendNotification?: boolean): void;
+    trace(value: Trace, tracer: Tracer, traceOptions?: TraceOptions): void;
+    /**
+     * An event emitter firing when an error occurs on the connection.
+     */
+    onError: Event<[Error, Message | undefined, number | undefined]>;
+    /**
+     * An event emitter firing when the connection got closed.
+     */
+    onClose: Event<void>;
+    /**
+     * An event emiiter firing when the connection receives a notification that is not
+     * handled.
+     */
+    onUnhandledNotification: Event<NotificationMessage>;
+    /**
+     * An event emitter firing when the connection got disposed.
+     */
+    onDispose: Event<void>;
+    /**
+     * Actively disposes the connection.
+     */
+    dispose(): void;
+    /**
+     * Turns the connection into listening mode
+     */
+    listen(): void;
+}
+/**
+ * @deprecated Use ProtocolConnection instead.
+ */
+export declare type ProtocolConnetion = ProtocolConnection;
+export declare function createProtocolConnection(reader: MessageReader, writer: MessageWriter, logger: Logger, strategy?: ConnectionStrategy): ProtocolConnection;

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

@@ -0,0 +1,43 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+exports.ErrorCodes = vscode_jsonrpc_1.ErrorCodes;
+exports.ResponseError = vscode_jsonrpc_1.ResponseError;
+exports.CancellationToken = vscode_jsonrpc_1.CancellationToken;
+exports.CancellationTokenSource = vscode_jsonrpc_1.CancellationTokenSource;
+exports.Disposable = vscode_jsonrpc_1.Disposable;
+exports.Event = vscode_jsonrpc_1.Event;
+exports.Emitter = vscode_jsonrpc_1.Emitter;
+exports.Trace = vscode_jsonrpc_1.Trace;
+exports.TraceFormat = vscode_jsonrpc_1.TraceFormat;
+exports.SetTraceNotification = vscode_jsonrpc_1.SetTraceNotification;
+exports.LogTraceNotification = vscode_jsonrpc_1.LogTraceNotification;
+exports.RequestType = vscode_jsonrpc_1.RequestType;
+exports.RequestType0 = vscode_jsonrpc_1.RequestType0;
+exports.NotificationType = vscode_jsonrpc_1.NotificationType;
+exports.NotificationType0 = vscode_jsonrpc_1.NotificationType0;
+exports.MessageReader = vscode_jsonrpc_1.MessageReader;
+exports.MessageWriter = vscode_jsonrpc_1.MessageWriter;
+exports.ConnectionStrategy = vscode_jsonrpc_1.ConnectionStrategy;
+exports.StreamMessageReader = vscode_jsonrpc_1.StreamMessageReader;
+exports.StreamMessageWriter = vscode_jsonrpc_1.StreamMessageWriter;
+exports.IPCMessageReader = vscode_jsonrpc_1.IPCMessageReader;
+exports.IPCMessageWriter = vscode_jsonrpc_1.IPCMessageWriter;
+exports.createClientPipeTransport = vscode_jsonrpc_1.createClientPipeTransport;
+exports.createServerPipeTransport = vscode_jsonrpc_1.createServerPipeTransport;
+exports.generateRandomPipeName = vscode_jsonrpc_1.generateRandomPipeName;
+exports.createClientSocketTransport = vscode_jsonrpc_1.createClientSocketTransport;
+exports.createServerSocketTransport = vscode_jsonrpc_1.createServerSocketTransport;
+__export(require("vscode-languageserver-types"));
+__export(require("./protocol"));
+function createProtocolConnection(reader, writer, logger, strategy) {
+    return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy);
+}
+exports.createProtocolConnection = createProtocolConnection;

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

@@ -0,0 +1,73 @@
+import { RequestType } from 'vscode-jsonrpc';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions } from './protocol';
+import { TextDocumentIdentifier, Range, Color, ColorInformation, ColorPresentation } from 'vscode-languageserver-types';
+export interface ColorClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to the colorProvider
+         */
+        colorProvider?: {
+            /**
+             * Whether implementation supports dynamic registration. If this is set to `true`
+             * the client supports the new `(ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+             * return value for the corresponding server capability as well.
+             */
+            dynamicRegistration?: boolean;
+        };
+    };
+}
+export interface ColorProviderOptions {
+}
+export interface ColorServerCapabilities {
+    /**
+     * The server provides color provider support.
+     */
+    colorProvider?: boolean | ColorProviderOptions | (ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
+}
+/**
+ * Parameters for a [DocumentColorRequest](#DocumentColorRequest).
+ */
+export interface DocumentColorParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type [DocumentColorParams](#DocumentColorParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace DocumentColorRequest {
+    const type: RequestType<DocumentColorParams, ColorInformation[], void, TextDocumentRegistrationOptions>;
+}
+/**
+ * Parameters for a [ColorPresentationRequest](#ColorPresentationRequest).
+ */
+export interface ColorPresentationParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The color to request presentations for.
+     */
+    color: Color;
+    /**
+     * The range where the color would be inserted. Serves as a context.
+     */
+    range: Range;
+}
+/**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace ColorPresentationRequest {
+    const type: RequestType<ColorPresentationParams, ColorPresentation[], void, TextDocumentRegistrationOptions>;
+}

Client/node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js

@@ -0,0 +1,27 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+/**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type [DocumentColorParams](#DocumentColorParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+var DocumentColorRequest;
+(function (DocumentColorRequest) {
+    DocumentColorRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentColor');
+})(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {}));
+/**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the
+ * response is of type [ColorInformation[]](#ColorInformation) or a Thenable
+ * that resolves to such.
+ */
+var ColorPresentationRequest;
+(function (ColorPresentationRequest) {
+    ColorPresentationRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/colorPresentation');
+})(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {}));

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

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

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

@@ -0,0 +1,20 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+/**
+ * The 'workspace/configuration' request is sent from the server to the client to fetch a certain
+ * configuration setting.
+ *
+ * This pull model replaces the old push model were the client signaled configuration change via an
+ * event. If the server still needs to react to configuration changes (since the server caches the
+ * result of `workspace/configuration` requests) the server should register for an empty configuration
+ * change event and empty the cache if such an event is received.
+ */
+var ConfigurationRequest;
+(function (ConfigurationRequest) {
+    ConfigurationRequest.type = new vscode_jsonrpc_1.RequestType('workspace/configuration');
+})(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {}));

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

@@ -0,0 +1,101 @@
+import { RequestType } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier } from 'vscode-languageserver-types';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions } from './protocol';
+export interface FoldingRangeClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to `textDocument/foldingRange` requests
+         */
+        foldingRange?: {
+            /**
+             * Whether implementation supports dynamic registration for folding range providers. If this is set to `true`
+             * the client supports the new `(FoldingRangeProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+             * return value for the corresponding server capability as well.
+             */
+            dynamicRegistration?: boolean;
+            /**
+             * The maximum number of folding ranges that the client prefers to receive per document. The value serves as a
+             * hint, servers are free to follow the limit.
+             */
+            rangeLimit?: number;
+            /**
+             * If set, the client signals that it only supports folding complete lines. If set, client will
+             * ignore specified `startCharacter` and `endCharacter` properties in a FoldingRange.
+             */
+            lineFoldingOnly?: boolean;
+        };
+    };
+}
+export interface FoldingRangeProviderOptions {
+}
+export interface FoldingRangeServerCapabilities {
+    /**
+     * The server provides folding provider support.
+     */
+    foldingRangeProvider?: boolean | FoldingRangeProviderOptions | (FoldingRangeProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
+}
+/**
+ * Enum of known range kinds
+ */
+export declare enum FoldingRangeKind {
+    /**
+     * Folding range for a comment
+     */
+    Comment = "comment",
+    /**
+     * Folding range for a imports or includes
+     */
+    Imports = "imports",
+    /**
+     * Folding range for a region (e.g. `#region`)
+     */
+    Region = "region"
+}
+/**
+ * Represents a folding range.
+ */
+export interface FoldingRange {
+    /**
+     * The zero-based line number from where the folded range starts.
+     */
+    startLine: number;
+    /**
+     * The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.
+     */
+    startCharacter?: number;
+    /**
+     * The zero-based line number where the folded range ends.
+     */
+    endLine: number;
+    /**
+     * The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.
+     */
+    endCharacter?: number;
+    /**
+     * Describes the kind of the folding range such as `comment' or 'region'. The kind
+     * is used to categorize folding ranges and used by commands like 'Fold all comments'. See
+     * [FoldingRangeKind](#FoldingRangeKind) for an enumeration of standardized kinds.
+     */
+    kind?: string;
+}
+/**
+ * Parameters for a [FoldingRangeRequest](#FoldingRangeRequest).
+ */
+export interface FoldingRangeParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * A request to provide folding ranges in a document. The request's
+ * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the
+ * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace FoldingRangeRequest {
+    const type: RequestType<FoldingRangeParams, FoldingRange[] | null, any, any>;
+}

Client/node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js

@@ -0,0 +1,35 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+/**
+ * Enum of known range kinds
+ */
+var FoldingRangeKind;
+(function (FoldingRangeKind) {
+    /**
+     * Folding range for a comment
+     */
+    FoldingRangeKind["Comment"] = "comment";
+    /**
+     * Folding range for a imports or includes
+     */
+    FoldingRangeKind["Imports"] = "imports";
+    /**
+     * Folding range for a region (e.g. `#region`)
+     */
+    FoldingRangeKind["Region"] = "region";
+})(FoldingRangeKind = exports.FoldingRangeKind || (exports.FoldingRangeKind = {}));
+/**
+ * A request to provide folding ranges in a document. The request's
+ * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the
+ * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable
+ * that resolves to such.
+ */
+var FoldingRangeRequest;
+(function (FoldingRangeRequest) {
+    FoldingRangeRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/foldingRange');
+})(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {}));

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

@@ -0,0 +1,37 @@
+import { RequestType, RequestHandler } from 'vscode-jsonrpc';
+import { Definition } from 'vscode-languageserver-types';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams } from './protocol';
+export interface ImplementationClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to the `textDocument/implementation`
+         */
+        implementation?: {
+            /**
+             * Whether implementation supports dynamic registration. If this is set to `true`
+             * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+             * return value for the corresponding server capability as well.
+             */
+            dynamicRegistration?: boolean;
+        };
+    };
+}
+export interface ImplementationServerCapabilities {
+    /**
+     * The server provides Goto Implementation support.
+     */
+    implementationProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
+}
+/**
+ * A request to resolve the implementation locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+export declare namespace ImplementationRequest {
+    const type: RequestType<TextDocumentPositionParams, Definition, void, TextDocumentRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TextDocumentPositionParams, Definition | null, void>;
+}

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

@@ -0,0 +1,17 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+/**
+ * A request to resolve the implementation locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+var ImplementationRequest;
+(function (ImplementationRequest) {
+    ImplementationRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/implementation');
+})(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {}));

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

@@ -0,0 +1,538 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const Is = require("./utils/is");
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const protocol_implementation_1 = require("./protocol.implementation");
+exports.ImplementationRequest = protocol_implementation_1.ImplementationRequest;
+const protocol_typeDefinition_1 = require("./protocol.typeDefinition");
+exports.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest;
+const protocol_workspaceFolders_1 = require("./protocol.workspaceFolders");
+exports.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest;
+exports.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
+const protocol_configuration_1 = require("./protocol.configuration");
+exports.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest;
+const protocol_colorProvider_1 = require("./protocol.colorProvider");
+exports.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest;
+exports.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest;
+const protocol_foldingRange_1 = require("./protocol.foldingRange");
+exports.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest;
+var DocumentFilter;
+(function (DocumentFilter) {
+    function is(value) {
+        let candidate = value;
+        return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);
+    }
+    DocumentFilter.is = is;
+})(DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {}));
+/**
+ * The `client/registerCapability` request is sent from the server to the client to register a new capability
+ * handler on the client side.
+ */
+var RegistrationRequest;
+(function (RegistrationRequest) {
+    RegistrationRequest.type = new vscode_jsonrpc_1.RequestType('client/registerCapability');
+})(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {}));
+/**
+ * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
+ * handler on the client side.
+ */
+var UnregistrationRequest;
+(function (UnregistrationRequest) {
+    UnregistrationRequest.type = new vscode_jsonrpc_1.RequestType('client/unregisterCapability');
+})(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {}));
+var ResourceOperationKind;
+(function (ResourceOperationKind) {
+    /**
+     * Supports creating new resources.
+     */
+    ResourceOperationKind.Create = 'create';
+    /**
+     * Supports renaming existing resources.
+     */
+    ResourceOperationKind.Rename = 'rename';
+    /**
+     * Supports deleting existing resources.
+     */
+    ResourceOperationKind.Delete = 'delete';
+})(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {}));
+var FailureHandlingKind;
+(function (FailureHandlingKind) {
+    /**
+     * Applying the workspace change is simply aborted if one of the changes provided
+     * fails. All operations executed before the failing operation stay executed.
+     */
+    FailureHandlingKind.Abort = 'abort';
+    /**
+     * All operations are executed transactional. That means they either all
+     * succeed or no changes at all are applied to the workspace.
+     */
+    FailureHandlingKind.Transactional = 'transactional';
+    /**
+     * If the workspace edit contains only textual file changes they are executed transactional.
+     * If resource changes (create, rename or delete file) are part of the change the failure
+     * handling startegy is abort.
+     */
+    FailureHandlingKind.TextOnlyTransactional = 'textOnlyTransactional';
+    /**
+     * The client tries to undo the operations already executed. But there is no
+     * guaruntee that this is succeeding.
+     */
+    FailureHandlingKind.Undo = 'undo';
+})(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {}));
+/**
+ * Defines how the host (editor) should sync
+ * document changes to the language server.
+ */
+var TextDocumentSyncKind;
+(function (TextDocumentSyncKind) {
+    /**
+     * Documents should not be synced at all.
+     */
+    TextDocumentSyncKind.None = 0;
+    /**
+     * Documents are synced by always sending the full content
+     * of the document.
+     */
+    TextDocumentSyncKind.Full = 1;
+    /**
+     * Documents are synced by sending the full content on open.
+     * After that only incremental updates to the document are
+     * send.
+     */
+    TextDocumentSyncKind.Incremental = 2;
+})(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {}));
+/**
+ * The initialize request is sent from the client to the server.
+ * It is sent once as the request after starting up the server.
+ * The requests parameter is of type [InitializeParams](#InitializeParams)
+ * the response if of type [InitializeResult](#InitializeResult) of a Thenable that
+ * resolves to such.
+ */
+var InitializeRequest;
+(function (InitializeRequest) {
+    InitializeRequest.type = new vscode_jsonrpc_1.RequestType('initialize');
+})(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {}));
+/**
+ * Known error codes for an `InitializeError`;
+ */
+var InitializeError;
+(function (InitializeError) {
+    /**
+     * If the protocol version provided by the client can't be handled by the server.
+     * @deprecated This initialize error got replaced by client capabilities. There is
+     * no version handshake in version 3.0x
+     */
+    InitializeError.unknownProtocolVersion = 1;
+})(InitializeError = exports.InitializeError || (exports.InitializeError = {}));
+/**
+ * The intialized notification is sent from the client to the
+ * server after the client is fully initialized and the server
+ * is allowed to send requests from the server to the client.
+ */
+var InitializedNotification;
+(function (InitializedNotification) {
+    InitializedNotification.type = new vscode_jsonrpc_1.NotificationType('initialized');
+})(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {}));
+//---- Shutdown Method ----
+/**
+ * A shutdown request is sent from the client to the server.
+ * It is sent once when the client decides to shutdown the
+ * server. The only notification that is sent after a shutdown request
+ * is the exit event.
+ */
+var ShutdownRequest;
+(function (ShutdownRequest) {
+    ShutdownRequest.type = new vscode_jsonrpc_1.RequestType0('shutdown');
+})(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {}));
+//---- Exit Notification ----
+/**
+ * The exit event is sent from the client to the server to
+ * ask the server to exit its process.
+ */
+var ExitNotification;
+(function (ExitNotification) {
+    ExitNotification.type = new vscode_jsonrpc_1.NotificationType0('exit');
+})(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {}));
+//---- Configuration notification ----
+/**
+ * The configuration change notification is sent from the client to the server
+ * when the client's configuration has changed. The notification contains
+ * the changed configuration as defined by the language client.
+ */
+var DidChangeConfigurationNotification;
+(function (DidChangeConfigurationNotification) {
+    DidChangeConfigurationNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeConfiguration');
+})(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {}));
+//---- Message show and log notifications ----
+/**
+ * The message type
+ */
+var MessageType;
+(function (MessageType) {
+    /**
+     * An error message.
+     */
+    MessageType.Error = 1;
+    /**
+     * A warning message.
+     */
+    MessageType.Warning = 2;
+    /**
+     * An information message.
+     */
+    MessageType.Info = 3;
+    /**
+     * A log message.
+     */
+    MessageType.Log = 4;
+})(MessageType = exports.MessageType || (exports.MessageType = {}));
+/**
+ * The show message notification is sent from a server to a client to ask
+ * the client to display a particular message in the user interface.
+ */
+var ShowMessageNotification;
+(function (ShowMessageNotification) {
+    ShowMessageNotification.type = new vscode_jsonrpc_1.NotificationType('window/showMessage');
+})(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {}));
+/**
+ * The show message request is sent from the server to the client to show a message
+ * and a set of options actions to the user.
+ */
+var ShowMessageRequest;
+(function (ShowMessageRequest) {
+    ShowMessageRequest.type = new vscode_jsonrpc_1.RequestType('window/showMessageRequest');
+})(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {}));
+/**
+ * The log message notification is sent from the server to the client to ask
+ * the client to log a particular message.
+ */
+var LogMessageNotification;
+(function (LogMessageNotification) {
+    LogMessageNotification.type = new vscode_jsonrpc_1.NotificationType('window/logMessage');
+})(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {}));
+//---- Telemetry notification
+/**
+ * The telemetry event notification is sent from the server to the client to ask
+ * the client to log telemetry data.
+ */
+var TelemetryEventNotification;
+(function (TelemetryEventNotification) {
+    TelemetryEventNotification.type = new vscode_jsonrpc_1.NotificationType('telemetry/event');
+})(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {}));
+/**
+ * The document open notification is sent from the client to the server to signal
+ * newly opened text documents. The document's truth is now managed by the client
+ * and the server must not try to read the document's truth using the document's
+ * uri. Open in this sense means it is managed by the client. It doesn't necessarily
+ * mean that its content is presented in an editor. An open notification must not
+ * be sent more than once without a corresponding close notification send before.
+ * This means open and close notification must be balanced and the max open count
+ * is one.
+ */
+var DidOpenTextDocumentNotification;
+(function (DidOpenTextDocumentNotification) {
+    DidOpenTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didOpen');
+})(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {}));
+/**
+ * The document change notification is sent from the client to the server to signal
+ * changes to a text document.
+ */
+var DidChangeTextDocumentNotification;
+(function (DidChangeTextDocumentNotification) {
+    DidChangeTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didChange');
+})(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {}));
+/**
+ * The document close notification is sent from the client to the server when
+ * the document got closed in the client. The document's truth now exists where
+ * the document's uri points to (e.g. if the document's uri is a file uri the
+ * truth now exists on disk). As with the open notification the close notification
+ * is about managing the document's content. Receiving a close notification
+ * doesn't mean that the document was open in an editor before. A close
+ * notification requires a previous open notification to be sent.
+ */
+var DidCloseTextDocumentNotification;
+(function (DidCloseTextDocumentNotification) {
+    DidCloseTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didClose');
+})(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {}));
+/**
+ * The document save notification is sent from the client to the server when
+ * the document got saved in the client.
+ */
+var DidSaveTextDocumentNotification;
+(function (DidSaveTextDocumentNotification) {
+    DidSaveTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didSave');
+})(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {}));
+/**
+ * A document will save notification is sent from the client to the server before
+ * the document is actually saved.
+ */
+var WillSaveTextDocumentNotification;
+(function (WillSaveTextDocumentNotification) {
+    WillSaveTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/willSave');
+})(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {}));
+/**
+ * A document will save request is sent from the client to the server before
+ * the document is actually saved. The request can return an array of TextEdits
+ * which will be applied to the text document before it is saved. Please note that
+ * clients might drop results if computing the text edits took too long or if a
+ * server constantly fails on this request. This is done to keep the save fast and
+ * reliable.
+ */
+var WillSaveTextDocumentWaitUntilRequest;
+(function (WillSaveTextDocumentWaitUntilRequest) {
+    WillSaveTextDocumentWaitUntilRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/willSaveWaitUntil');
+})(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {}));
+//---- File eventing ----
+/**
+ * The watched files notification is sent from the client to the server when
+ * the client detects changes to file watched by the language client.
+ */
+var DidChangeWatchedFilesNotification;
+(function (DidChangeWatchedFilesNotification) {
+    DidChangeWatchedFilesNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeWatchedFiles');
+})(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {}));
+/**
+ * The file event type
+ */
+var FileChangeType;
+(function (FileChangeType) {
+    /**
+     * The file got created.
+     */
+    FileChangeType.Created = 1;
+    /**
+     * The file got changed.
+     */
+    FileChangeType.Changed = 2;
+    /**
+     * The file got deleted.
+     */
+    FileChangeType.Deleted = 3;
+})(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {}));
+var WatchKind;
+(function (WatchKind) {
+    /**
+     * Interested in create events.
+     */
+    WatchKind.Create = 1;
+    /**
+     * Interested in change events
+     */
+    WatchKind.Change = 2;
+    /**
+     * Interested in delete events
+     */
+    WatchKind.Delete = 4;
+})(WatchKind = exports.WatchKind || (exports.WatchKind = {}));
+//---- Diagnostic notification ----
+/**
+ * Diagnostics notification are sent from the server to the client to signal
+ * results of validation runs.
+ */
+var PublishDiagnosticsNotification;
+(function (PublishDiagnosticsNotification) {
+    PublishDiagnosticsNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/publishDiagnostics');
+})(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {}));
+/**
+ * How a completion was triggered
+ */
+var CompletionTriggerKind;
+(function (CompletionTriggerKind) {
+    /**
+     * Completion was triggered by typing an identifier (24x7 code
+     * complete), manual invocation (e.g Ctrl+Space) or via API.
+     */
+    CompletionTriggerKind.Invoked = 1;
+    /**
+     * Completion was triggered by a trigger character specified by
+     * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
+     */
+    CompletionTriggerKind.TriggerCharacter = 2;
+    /**
+     * Completion was re-triggered as current completion list is incomplete
+     */
+    CompletionTriggerKind.TriggerForIncompleteCompletions = 3;
+})(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {}));
+/**
+ * Request to request completion at a given text document position. The request's
+ * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response
+ * is of type [CompletionItem[]](#CompletionItem) or [CompletionList](#CompletionList)
+ * or a Thenable that resolves to such.
+ *
+ * The request can delay the computation of the [`detail`](#CompletionItem.detail)
+ * and [`documentation`](#CompletionItem.documentation) properties to the `completionItem/resolve`
+ * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
+ * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
+ */
+var CompletionRequest;
+(function (CompletionRequest) {
+    CompletionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/completion');
+})(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {}));
+/**
+ * Request to resolve additional information for a given completion item.The request's
+ * parameter is of type [CompletionItem](#CompletionItem) the response
+ * is of type [CompletionItem](#CompletionItem) or a Thenable that resolves to such.
+ */
+var CompletionResolveRequest;
+(function (CompletionResolveRequest) {
+    CompletionResolveRequest.type = new vscode_jsonrpc_1.RequestType('completionItem/resolve');
+})(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {}));
+//---- Hover Support -------------------------------
+/**
+ * Request to request hover information at a given text document position. The request's
+ * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response is of
+ * type [Hover](#Hover) or a Thenable that resolves to such.
+ */
+var HoverRequest;
+(function (HoverRequest) {
+    HoverRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/hover');
+})(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}));
+var SignatureHelpRequest;
+(function (SignatureHelpRequest) {
+    SignatureHelpRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/signatureHelp');
+})(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {}));
+//---- Goto Definition -------------------------------------
+/**
+ * A request to resolve the definition location of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPosition]
+ * (#TextDocumentPosition) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+var DefinitionRequest;
+(function (DefinitionRequest) {
+    DefinitionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/definition');
+})(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {}));
+/**
+ * A request to resolve project-wide references for the symbol denoted
+ * by the given text document position. The request's parameter is of
+ * type [ReferenceParams](#ReferenceParams) the response is of type
+ * [Location[]](#Location) or a Thenable that resolves to such.
+ */
+var ReferencesRequest;
+(function (ReferencesRequest) {
+    ReferencesRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/references');
+})(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {}));
+//---- Document Highlight ----------------------------------
+/**
+ * Request to resolve a [DocumentHighlight](#DocumentHighlight) for a given
+ * text document position. The request's parameter is of type [TextDocumentPosition]
+ * (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]
+ * (#DocumentHighlight) or a Thenable that resolves to such.
+ */
+var DocumentHighlightRequest;
+(function (DocumentHighlightRequest) {
+    DocumentHighlightRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentHighlight');
+})(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {}));
+//---- Document Symbol Provider ---------------------------
+/**
+ * A request to list all symbols found in a given text document. The request's
+ * parameter is of type [TextDocumentIdentifier](#TextDocumentIdentifier) the
+ * response is of type [SymbolInformation[]](#SymbolInformation) or a Thenable
+ * that resolves to such.
+ */
+var DocumentSymbolRequest;
+(function (DocumentSymbolRequest) {
+    DocumentSymbolRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentSymbol');
+})(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {}));
+//---- Workspace Symbol Provider ---------------------------
+/**
+ * A request to list project-wide symbols matching the query string given
+ * by the [WorkspaceSymbolParams](#WorkspaceSymbolParams). The response is
+ * of type [SymbolInformation[]](#SymbolInformation) or a Thenable that
+ * resolves to such.
+ */
+var WorkspaceSymbolRequest;
+(function (WorkspaceSymbolRequest) {
+    WorkspaceSymbolRequest.type = new vscode_jsonrpc_1.RequestType('workspace/symbol');
+})(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {}));
+/**
+ * A request to provide commands for the given text document and range.
+ */
+var CodeActionRequest;
+(function (CodeActionRequest) {
+    CodeActionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/codeAction');
+})(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {}));
+/**
+ * A request to provide code lens for the given text document.
+ */
+var CodeLensRequest;
+(function (CodeLensRequest) {
+    CodeLensRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/codeLens');
+})(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {}));
+/**
+ * A request to resolve a command for a given code lens.
+ */
+var CodeLensResolveRequest;
+(function (CodeLensResolveRequest) {
+    CodeLensResolveRequest.type = new vscode_jsonrpc_1.RequestType('codeLens/resolve');
+})(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {}));
+/**
+ * A request to to format a whole document.
+ */
+var DocumentFormattingRequest;
+(function (DocumentFormattingRequest) {
+    DocumentFormattingRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/formatting');
+})(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {}));
+/**
+ * A request to to format a range in a document.
+ */
+var DocumentRangeFormattingRequest;
+(function (DocumentRangeFormattingRequest) {
+    DocumentRangeFormattingRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/rangeFormatting');
+})(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {}));
+/**
+ * A request to format a document on type.
+ */
+var DocumentOnTypeFormattingRequest;
+(function (DocumentOnTypeFormattingRequest) {
+    DocumentOnTypeFormattingRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/onTypeFormatting');
+})(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {}));
+/**
+ * A request to rename a symbol.
+ */
+var RenameRequest;
+(function (RenameRequest) {
+    RenameRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/rename');
+})(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}));
+/**
+ * A request to test and perform the setup necessary for a rename.
+ */
+var PrepareRenameRequest;
+(function (PrepareRenameRequest) {
+    PrepareRenameRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/prepareRename');
+})(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {}));
+/**
+ * A request to provide document links
+ */
+var DocumentLinkRequest;
+(function (DocumentLinkRequest) {
+    DocumentLinkRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentLink');
+})(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {}));
+/**
+ * Request to resolve additional information for a given document link. The request's
+ * parameter is of type [DocumentLink](#DocumentLink) the response
+ * is of type [DocumentLink](#DocumentLink) or a Thenable that resolves to such.
+ */
+var DocumentLinkResolveRequest;
+(function (DocumentLinkResolveRequest) {
+    DocumentLinkResolveRequest.type = new vscode_jsonrpc_1.RequestType('documentLink/resolve');
+})(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {}));
+/**
+ * A request send from the client to the server to execute a command. The request might return
+ * a workspace edit which the client will apply to the workspace.
+ */
+var ExecuteCommandRequest;
+(function (ExecuteCommandRequest) {
+    ExecuteCommandRequest.type = new vscode_jsonrpc_1.RequestType('workspace/executeCommand');
+})(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {}));
+/**
+ * A request sent from the server to the client to modified certain resources.
+ */
+var ApplyWorkspaceEditRequest;
+(function (ApplyWorkspaceEditRequest) {
+    ApplyWorkspaceEditRequest.type = new vscode_jsonrpc_1.RequestType('workspace/applyEdit');
+})(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {}));

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

@@ -0,0 +1,37 @@
+import { RequestType, RequestHandler } from 'vscode-jsonrpc';
+import { Definition } from 'vscode-languageserver-types';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams } from './protocol';
+export interface TypeDefinitionClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to the `textDocument/typeDefinition`
+         */
+        typeDefinition?: {
+            /**
+             * Whether implementation supports dynamic registration. If this is set to `true`
+             * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+             * return value for the corresponding server capability as well.
+             */
+            dynamicRegistration?: boolean;
+        };
+    };
+}
+export interface TypeDefinitionServerCapabilities {
+    /**
+     * The server provides Goto Type Definition support.
+     */
+    typeDefinitionProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
+}
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+export declare namespace TypeDefinitionRequest {
+    const type: RequestType<TextDocumentPositionParams, Definition, void, TextDocumentRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TextDocumentPositionParams, Definition | null, void>;
+}

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

@@ -0,0 +1,17 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type [TextDocumentPositioParams]
+ * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a
+ * Thenable that resolves to such.
+ */
+var TypeDefinitionRequest;
+(function (TypeDefinitionRequest) {
+    TypeDefinitionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/typeDefinition');
+})(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));

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

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

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

@@ -0,0 +1,22 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+/**
+ * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
+ */
+var WorkspaceFoldersRequest;
+(function (WorkspaceFoldersRequest) {
+    WorkspaceFoldersRequest.type = new vscode_jsonrpc_1.RequestType0('workspace/workspaceFolders');
+})(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));
+/**
+ * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
+ * folder configuration changes.
+ */
+var DidChangeWorkspaceFoldersNotification;
+(function (DidChangeWorkspaceFoldersNotification) {
+    DidChangeWorkspaceFoldersNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeWorkspaceFolders');
+})(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));

Client/node_modules/vscode-languageserver-protocol/lib/utils/is.d.ts

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

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

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