Initial

Client/node_modules/vscode-languageserver-protocol/License.txt

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

Client/node_modules/vscode-languageserver-protocol/README.md

@@ -0,0 +1,16 @@
+# VSCode Language Server - Protocol Module
+
+[![NPM Version](https://img.shields.io/npm/v/vscode-languageserver-protocol.svg)](https://npmjs.org/package/vscode-languageclient)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-languageserver-protocol.svg)](https://npmjs.org/package/vscode-languageclient)
+[![Build Status](https://travis-ci.org/Microsoft/vscode-languageserver-node.svg?branch=master)](https://travis-ci.org/Microsoft/vscode-languageserver-node)
+
+This npm module is a tool independent implementation of the language server protocol and can be used in any type of node application.
+
+See [here](https://github.com/Microsoft/language-server-protocol) for a detailed documentation on the language server protocol.
+
+## History
+
+For the history please see the [main repository](https://github.com/Microsoft/vscode-languageserver-node/blob/master/README.md)
+
+## License
+[MIT](https://github.com/Microsoft/vscode-languageserver-node/blob/master/License.txt)

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;

Client/node_modules/vscode-languageserver-protocol/package.json

@@ -0,0 +1,57 @@
+{
+  "_from": "vscode-languageserver-protocol@^3.10.3",
+  "_id": "vscode-languageserver-protocol@3.13.0",
+  "_inBundle": false,
+  "_integrity": "sha512-2ZGKwI+P2ovQll2PGAp+2UfJH+FK9eait86VBUdkPd9HRlm8e58aYT9pV/NYanHOcp3pL6x2yTLVCFMcTer0mg==",
+  "_location": "/vscode-languageserver-protocol",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "vscode-languageserver-protocol@^3.10.3",
+    "name": "vscode-languageserver-protocol",
+    "escapedName": "vscode-languageserver-protocol",
+    "rawSpec": "^3.10.3",
+    "saveSpec": null,
+    "fetchSpec": "^3.10.3"
+  },
+  "_requiredBy": [
+    "/vscode-languageclient"
+  ],
+  "_resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.13.0.tgz",
+  "_shasum": "710d8e42119bb3affb1416e1e104bd6b4d503595",
+  "_spec": "vscode-languageserver-protocol@^3.10.3",
+  "_where": "/home/nathan/Projects/Upsilon/UpsilonVsCodeLanguageServer/Client/node_modules/vscode-languageclient",
+  "author": {
+    "name": "Microsoft Corporation"
+  },
+  "bugs": {
+    "url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "vscode-jsonrpc": "^4.0.0",
+    "vscode-languageserver-types": "3.13.0"
+  },
+  "deprecated": false,
+  "description": "VSCode Language Server Protocol implementation",
+  "homepage": "https://github.com/Microsoft/vscode-languageserver-node#readme",
+  "license": "MIT",
+  "main": "./lib/main.js",
+  "name": "vscode-languageserver-protocol",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Microsoft/vscode-languageserver-node.git"
+  },
+  "scripts": {
+    "clean": "node ../node_modules/rimraf/bin.js lib",
+    "compile": "node ../build/bin/tsc -p ./tsconfig.json",
+    "postpublish": "node ../build/npm/post-publish.js",
+    "prepublishOnly": "npm run clean && npm run compile && npm test",
+    "preversion": "npm test",
+    "test": "node ../node_modules/mocha/bin/_mocha",
+    "watch": "node ../build/bin/tsc -w -p ./tsconfig.json"
+  },
+  "typings": "./lib/main",
+  "version": "3.13.0"
+}

Client/node_modules/vscode-languageserver-protocol/thirdpartynotices.txt

@@ -0,0 +1,31 @@
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+For Microsoft vscode-languageclient
+
+This project incorporates material from the project(s) listed below (collectively, “Third Party Code”).
+Microsoft is not the original author of the Third Party Code.  The original copyright notice and license
+under which Microsoft received such Third Party Code are set out below. This Third Party Code is licensed
+to you under their original license terms set forth below.  Microsoft reserves all other rights not expressly
+granted, whether by implication, estoppel or otherwise.
+
+1.       DefinitelyTyped version 0.0.1 (https://github.com/borisyankov/DefinitelyTyped)
+
+This project is licensed under the MIT license.
+Copyrights are respective of each contributor listed at the beginning of each definition file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.