Initial

Client/node_modules/vscode-jsonrpc/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-jsonrpc/README.md

@@ -0,0 +1,64 @@
+# VSCode JSON RPC
+
+[![NPM Version](https://img.shields.io/npm/v/vscode-jsonrpc.svg)](https://npmjs.org/package/vscode-jsonrpc)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-jsonrpc.svg)](https://npmjs.org/package/vscode-jsonrpc)
+[![Build Status](https://travis-ci.org/Microsoft/vscode-languageserver-node.svg?branch=master)](https://travis-ci.org/Microsoft/vscode-languageserver-node)
+
+This npm module implements the base messaging protocol spoken between a VSCode language server and a VSCode language client.
+
+The npm module can also be used standalone to establish a [JSON-RPC](http://www.jsonrpc.org/) channel between
+a client and a server. Below an example how to setup a JSON-RPC connection. First the client side.
+
+```ts
+import * as cp from 'child_process';
+import * as rpc from 'vscode-jsonrpc';
+
+let childProcess = cp.spawn(...);
+
+// Use stdin and stdout for communication:
+let connection = rpc.createMessageConnection(
+	new rpc.StreamMessageReader(childProcess.stdout),
+	new rpc.StreamMessageWriter(childProcess.stdin));
+
+let notification = new NotificationType<string, void>('testNotification');
+
+connection.listen();
+
+connection.sendNotification(notification, 'Hello World');
+```
+
+The server side looks very symmetrical:
+
+```ts
+import * as rpc from 'vscode-jsonrpc';
+
+
+let connection = rpc.createMessageConnection(
+	new rpc.StreamMessageReader(process.stdin),
+	new rpc.StreamMessageWriter(process.stdout));
+
+let notification = new NotificationType<string, void>('testNotification');
+connection.onNotification(notification, (param: string) => {
+	console.log(param); // This prints Hello World
+});
+
+connection.listen();
+```
+
+# History
+
+### 4.0.0
+
+- move JS target to ES6.
+
+### 3.0.0:
+
+- converted the NPM module to use TypeScript 2.0.3.
+- added strict null support.
+- support for passing more than one parameter to a request or notification.
+- Breaking changes:
+  - due to the use of TypeScript 2.0.3 and differences in d.ts generation users of the new version need to move to
+    TypeScript 2.0.3 as well.
+
+## License
+[MIT](https://github.com/Microsoft/vscode-languageserver-node/blob/master/License.txt)

Client/node_modules/vscode-jsonrpc/lib/cancellation.d.ts

@@ -0,0 +1,27 @@
+import { Event } from './events';
+/**
+ * Defines a CancellationToken. This interface is not
+ * intended to be implemented. A CancellationToken must
+ * be created via a CancellationTokenSource.
+ */
+export interface CancellationToken {
+    /**
+     * Is `true` when the token has been cancelled, `false` otherwise.
+     */
+    readonly isCancellationRequested: boolean;
+    /**
+     * An [event](#Event) which fires upon cancellation.
+     */
+    readonly onCancellationRequested: Event<any>;
+}
+export declare namespace CancellationToken {
+    const None: CancellationToken;
+    const Cancelled: CancellationToken;
+    function is(value: any): value is CancellationToken;
+}
+export declare class CancellationTokenSource {
+    private _token;
+    readonly token: CancellationToken;
+    cancel(): void;
+    dispose(): void;
+}

Client/node_modules/vscode-jsonrpc/lib/cancellation.js

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 events_1 = require("./events");
+const Is = require("./is");
+var CancellationToken;
+(function (CancellationToken) {
+    CancellationToken.None = Object.freeze({
+        isCancellationRequested: false,
+        onCancellationRequested: events_1.Event.None
+    });
+    CancellationToken.Cancelled = Object.freeze({
+        isCancellationRequested: true,
+        onCancellationRequested: events_1.Event.None
+    });
+    function is(value) {
+        let candidate = value;
+        return candidate && (candidate === CancellationToken.None
+            || candidate === CancellationToken.Cancelled
+            || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));
+    }
+    CancellationToken.is = is;
+})(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));
+const shortcutEvent = Object.freeze(function (callback, context) {
+    let handle = setTimeout(callback.bind(context), 0);
+    return { dispose() { clearTimeout(handle); } };
+});
+class MutableToken {
+    constructor() {
+        this._isCancelled = false;
+    }
+    cancel() {
+        if (!this._isCancelled) {
+            this._isCancelled = true;
+            if (this._emitter) {
+                this._emitter.fire(undefined);
+                this._emitter = undefined;
+            }
+        }
+    }
+    get isCancellationRequested() {
+        return this._isCancelled;
+    }
+    get onCancellationRequested() {
+        if (this._isCancelled) {
+            return shortcutEvent;
+        }
+        if (!this._emitter) {
+            this._emitter = new events_1.Emitter();
+        }
+        return this._emitter.event;
+    }
+}
+class CancellationTokenSource {
+    get token() {
+        if (!this._token) {
+            // be lazy and create the token only when
+            // actually needed
+            this._token = new MutableToken();
+        }
+        return this._token;
+    }
+    cancel() {
+        if (!this._token) {
+            // save an object by returning the default
+            // cancelled token when cancellation happens
+            // before someone asks for the token
+            this._token = CancellationToken.Cancelled;
+        }
+        else {
+            this._token.cancel();
+        }
+    }
+    dispose() {
+        this.cancel();
+    }
+}
+exports.CancellationTokenSource = CancellationTokenSource;

Client/node_modules/vscode-jsonrpc/lib/events.d.ts

@@ -0,0 +1,47 @@
+export interface Disposable {
+    /**
+     * Dispose this object.
+     */
+    dispose(): void;
+}
+export declare namespace Disposable {
+    function create(func: () => void): Disposable;
+}
+/**
+ * Represents a typed event.
+ */
+export interface Event<T> {
+    /**
+     *
+     * @param listener The listener function will be call when the event happens.
+     * @param thisArgs The 'this' which will be used when calling the event listener.
+     * @param disposables An array to which a {{IDisposable}} will be added. The
+     * @return
+    */
+    (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable;
+}
+export declare namespace Event {
+    const None: Event<any>;
+}
+export interface EmitterOptions {
+    onFirstListenerAdd?: Function;
+    onLastListenerRemove?: Function;
+}
+export declare class Emitter<T> {
+    private _options?;
+    private static _noop;
+    private _event;
+    private _callbacks;
+    constructor(_options?: EmitterOptions | undefined);
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    readonly event: Event<T>;
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event: T): any;
+    dispose(): void;
+}

Client/node_modules/vscode-jsonrpc/lib/events.js

@@ -0,0 +1,131 @@
+/* --------------------------------------------------------------------------------------------
+ * 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 });
+var Disposable;
+(function (Disposable) {
+    function create(func) {
+        return {
+            dispose: func
+        };
+    }
+    Disposable.create = create;
+})(Disposable = exports.Disposable || (exports.Disposable = {}));
+var Event;
+(function (Event) {
+    const _disposable = { dispose() { } };
+    Event.None = function () { return _disposable; };
+})(Event = exports.Event || (exports.Event = {}));
+class CallbackList {
+    add(callback, context = null, bucket) {
+        if (!this._callbacks) {
+            this._callbacks = [];
+            this._contexts = [];
+        }
+        this._callbacks.push(callback);
+        this._contexts.push(context);
+        if (Array.isArray(bucket)) {
+            bucket.push({ dispose: () => this.remove(callback, context) });
+        }
+    }
+    remove(callback, context = null) {
+        if (!this._callbacks) {
+            return;
+        }
+        var foundCallbackWithDifferentContext = false;
+        for (var i = 0, len = this._callbacks.length; i < len; i++) {
+            if (this._callbacks[i] === callback) {
+                if (this._contexts[i] === context) {
+                    // callback & context match => remove it
+                    this._callbacks.splice(i, 1);
+                    this._contexts.splice(i, 1);
+                    return;
+                }
+                else {
+                    foundCallbackWithDifferentContext = true;
+                }
+            }
+        }
+        if (foundCallbackWithDifferentContext) {
+            throw new Error('When adding a listener with a context, you should remove it with the same context');
+        }
+    }
+    invoke(...args) {
+        if (!this._callbacks) {
+            return [];
+        }
+        var ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+        for (var i = 0, len = callbacks.length; i < len; i++) {
+            try {
+                ret.push(callbacks[i].apply(contexts[i], args));
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return ret;
+    }
+    isEmpty() {
+        return !this._callbacks || this._callbacks.length === 0;
+    }
+    dispose() {
+        this._callbacks = undefined;
+        this._contexts = undefined;
+    }
+}
+class Emitter {
+    constructor(_options) {
+        this._options = _options;
+    }
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event() {
+        if (!this._event) {
+            this._event = (listener, thisArgs, disposables) => {
+                if (!this._callbacks) {
+                    this._callbacks = new CallbackList();
+                }
+                if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+                    this._options.onFirstListenerAdd(this);
+                }
+                this._callbacks.add(listener, thisArgs);
+                let result;
+                result = {
+                    dispose: () => {
+                        this._callbacks.remove(listener, thisArgs);
+                        result.dispose = Emitter._noop;
+                        if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
+                            this._options.onLastListenerRemove(this);
+                        }
+                    }
+                };
+                if (Array.isArray(disposables)) {
+                    disposables.push(result);
+                }
+                return result;
+            };
+        }
+        return this._event;
+    }
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event) {
+        if (this._callbacks) {
+            this._callbacks.invoke.call(this._callbacks, event);
+        }
+    }
+    dispose() {
+        if (this._callbacks) {
+            this._callbacks.dispose();
+            this._callbacks = undefined;
+        }
+    }
+}
+Emitter._noop = function () { };
+exports.Emitter = Emitter;

Client/node_modules/vscode-jsonrpc/lib/is.d.ts

@@ -0,0 +1,7 @@
+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[];

Client/node_modules/vscode-jsonrpc/lib/is.js

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

Client/node_modules/vscode-jsonrpc/lib/linkedMap.d.ts

@@ -0,0 +1,29 @@
+export declare namespace Touch {
+    const None: 0;
+    const First: 1;
+    const Last: 2;
+}
+export declare type Touch = 0 | 1 | 2;
+export declare class LinkedMap<K, V> {
+    private _map;
+    private _head;
+    private _tail;
+    private _size;
+    constructor();
+    clear(): void;
+    isEmpty(): boolean;
+    readonly size: number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V, touch?: Touch): void;
+    delete(key: K): boolean;
+    shift(): V | undefined;
+    forEach(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void;
+    forEachReverse(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void;
+    values(): V[];
+    keys(): K[];
+    private addItemFirst;
+    private addItemLast;
+    private removeItem;
+    private touch;
+}

Client/node_modules/vscode-jsonrpc/lib/linkedMap.js

@@ -0,0 +1,279 @@
+"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 });
+var Touch;
+(function (Touch) {
+    Touch.None = 0;
+    Touch.First = 1;
+    Touch.Last = 2;
+})(Touch = exports.Touch || (exports.Touch = {}));
+class LinkedMap {
+    constructor() {
+        this._map = new Map();
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+    }
+    clear() {
+        this._map.clear();
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+    }
+    isEmpty() {
+        return !this._head && !this._tail;
+    }
+    get size() {
+        return this._size;
+    }
+    has(key) {
+        return this._map.has(key);
+    }
+    get(key) {
+        const item = this._map.get(key);
+        if (!item) {
+            return undefined;
+        }
+        return item.value;
+    }
+    set(key, value, touch = Touch.None) {
+        let item = this._map.get(key);
+        if (item) {
+            item.value = value;
+            if (touch !== Touch.None) {
+                this.touch(item, touch);
+            }
+        }
+        else {
+            item = { key, value, next: undefined, previous: undefined };
+            switch (touch) {
+                case Touch.None:
+                    this.addItemLast(item);
+                    break;
+                case Touch.First:
+                    this.addItemFirst(item);
+                    break;
+                case Touch.Last:
+                    this.addItemLast(item);
+                    break;
+                default:
+                    this.addItemLast(item);
+                    break;
+            }
+            this._map.set(key, item);
+            this._size++;
+        }
+    }
+    delete(key) {
+        const item = this._map.get(key);
+        if (!item) {
+            return false;
+        }
+        this._map.delete(key);
+        this.removeItem(item);
+        this._size--;
+        return true;
+    }
+    shift() {
+        if (!this._head && !this._tail) {
+            return undefined;
+        }
+        if (!this._head || !this._tail) {
+            throw new Error('Invalid list');
+        }
+        const item = this._head;
+        this._map.delete(item.key);
+        this.removeItem(item);
+        this._size--;
+        return item.value;
+    }
+    forEach(callbackfn, thisArg) {
+        let current = this._head;
+        while (current) {
+            if (thisArg) {
+                callbackfn.bind(thisArg)(current.value, current.key, this);
+            }
+            else {
+                callbackfn(current.value, current.key, this);
+            }
+            current = current.next;
+        }
+    }
+    forEachReverse(callbackfn, thisArg) {
+        let current = this._tail;
+        while (current) {
+            if (thisArg) {
+                callbackfn.bind(thisArg)(current.value, current.key, this);
+            }
+            else {
+                callbackfn(current.value, current.key, this);
+            }
+            current = current.previous;
+        }
+    }
+    values() {
+        let result = [];
+        let current = this._head;
+        while (current) {
+            result.push(current.value);
+            current = current.next;
+        }
+        return result;
+    }
+    keys() {
+        let result = [];
+        let current = this._head;
+        while (current) {
+            result.push(current.key);
+            current = current.next;
+        }
+        return result;
+    }
+    /* JSON RPC run on es5 which has no Symbol.iterator
+    public keys(): IterableIterator<K> {
+        let current = this._head;
+        let iterator: IterableIterator<K> = {
+            [Symbol.iterator]() {
+                return iterator;
+            },
+            next():IteratorResult<K> {
+                if (current) {
+                    let result = { value: current.key, done: false };
+                    current = current.next;
+                    return result;
+                } else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+
+    public values(): IterableIterator<V> {
+        let current = this._head;
+        let iterator: IterableIterator<V> = {
+            [Symbol.iterator]() {
+                return iterator;
+            },
+            next():IteratorResult<V> {
+                if (current) {
+                    let result = { value: current.value, done: false };
+                    current = current.next;
+                    return result;
+                } else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+    */
+    addItemFirst(item) {
+        // First time Insert
+        if (!this._head && !this._tail) {
+            this._tail = item;
+        }
+        else if (!this._head) {
+            throw new Error('Invalid list');
+        }
+        else {
+            item.next = this._head;
+            this._head.previous = item;
+        }
+        this._head = item;
+    }
+    addItemLast(item) {
+        // First time Insert
+        if (!this._head && !this._tail) {
+            this._head = item;
+        }
+        else if (!this._tail) {
+            throw new Error('Invalid list');
+        }
+        else {
+            item.previous = this._tail;
+            this._tail.next = item;
+        }
+        this._tail = item;
+    }
+    removeItem(item) {
+        if (item === this._head && item === this._tail) {
+            this._head = undefined;
+            this._tail = undefined;
+        }
+        else if (item === this._head) {
+            this._head = item.next;
+        }
+        else if (item === this._tail) {
+            this._tail = item.previous;
+        }
+        else {
+            const next = item.next;
+            const previous = item.previous;
+            if (!next || !previous) {
+                throw new Error('Invalid list');
+            }
+            next.previous = previous;
+            previous.next = next;
+        }
+    }
+    touch(item, touch) {
+        if (!this._head || !this._tail) {
+            throw new Error('Invalid list');
+        }
+        if ((touch !== Touch.First && touch !== Touch.Last)) {
+            return;
+        }
+        if (touch === Touch.First) {
+            if (item === this._head) {
+                return;
+            }
+            const next = item.next;
+            const previous = item.previous;
+            // Unlink the item
+            if (item === this._tail) {
+                // previous must be defined since item was not head but is tail
+                // So there are more than on item in the map
+                previous.next = undefined;
+                this._tail = previous;
+            }
+            else {
+                // Both next and previous are not undefined since item was neither head nor tail.
+                next.previous = previous;
+                previous.next = next;
+            }
+            // Insert the node at head
+            item.previous = undefined;
+            item.next = this._head;
+            this._head.previous = item;
+            this._head = item;
+        }
+        else if (touch === Touch.Last) {
+            if (item === this._tail) {
+                return;
+            }
+            const next = item.next;
+            const previous = item.previous;
+            // Unlink the item.
+            if (item === this._head) {
+                // next must be defined since item was not tail but is head
+                // So there are more than on item in the map
+                next.previous = undefined;
+                this._head = next;
+            }
+            else {
+                // Both next and previous are not undefined since item was neither head nor tail.
+                next.previous = previous;
+                previous.next = next;
+            }
+            item.next = undefined;
+            item.previous = this._tail;
+            this._tail.next = item;
+            this._tail = item;
+        }
+    }
+}
+exports.LinkedMap = LinkedMap;

Client/node_modules/vscode-jsonrpc/lib/main.d.ts

@@ -0,0 +1,223 @@
+/// <reference path="thenable.d.ts" />
+/// <reference types="node" />
+import { Message, MessageType, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, ResponseMessage, ResponseError, ErrorCodes, NotificationMessage, NotificationType, NotificationType0, NotificationType1, NotificationType2, NotificationType3, NotificationType4, NotificationType5, NotificationType6, NotificationType7, NotificationType8, NotificationType9 } from './messages';
+import { MessageReader, DataCallback, StreamMessageReader, IPCMessageReader, SocketMessageReader } from './messageReader';
+import { MessageWriter, StreamMessageWriter, IPCMessageWriter, SocketMessageWriter } from './messageWriter';
+import { Disposable, Event, Emitter } from './events';
+import { CancellationTokenSource, CancellationToken } from './cancellation';
+import { LinkedMap } from './linkedMap';
+export { Message, MessageType, ErrorCodes, ResponseError, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, NotificationMessage, NotificationType, NotificationType0, NotificationType1, NotificationType2, NotificationType3, NotificationType4, NotificationType5, NotificationType6, NotificationType7, NotificationType8, NotificationType9, MessageReader, DataCallback, StreamMessageReader, IPCMessageReader, SocketMessageReader, MessageWriter, StreamMessageWriter, IPCMessageWriter, SocketMessageWriter, CancellationTokenSource, CancellationToken, Disposable, Event, Emitter };
+export * from './pipeSupport';
+export * from './socketSupport';
+export declare type HandlerResult<R, E> = R | ResponseError<E> | Thenable<R> | Thenable<ResponseError<E>> | Thenable<R | ResponseError<E>>;
+export interface StarRequestHandler {
+    (method: string, ...params: any[]): HandlerResult<any, any>;
+}
+export interface GenericRequestHandler<R, E> {
+    (...params: any[]): HandlerResult<R, E>;
+}
+export interface RequestHandler0<R, E> {
+    (token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler<P, R, E> {
+    (params: P, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler1<P1, R, E> {
+    (p1: P1, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler2<P1, P2, R, E> {
+    (p1: P1, p2: P2, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler3<P1, P2, P3, R, E> {
+    (p1: P1, p2: P2, p3: P3, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler4<P1, P2, P3, P4, R, E> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler5<P1, P2, P3, P4, P5, R, E> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler6<P1, P2, P3, P4, P5, P6, R, E> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler7<P1, P2, P3, P4, P5, P6, P7, R, E> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler8<P1, P2, P3, P4, P5, P6, P7, P8, R, E> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface RequestHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, token: CancellationToken): HandlerResult<R, E>;
+}
+export interface StarNotificationHandler {
+    (method: string, ...params: any[]): void;
+}
+export interface GenericNotificationHandler {
+    (...params: any[]): void;
+}
+export interface NotificationHandler0 {
+    (): void;
+}
+export interface NotificationHandler<P> {
+    (params: P): void;
+}
+export interface NotificationHandler1<P1> {
+    (p1: P1): void;
+}
+export interface NotificationHandler2<P1, P2> {
+    (p1: P1, p2: P2): void;
+}
+export interface NotificationHandler3<P1, P2, P3> {
+    (p1: P1, p2: P2, p3: P3): void;
+}
+export interface NotificationHandler4<P1, P2, P3, P4> {
+    (p1: P1, p2: P2, p3: P3, p4: P4): void;
+}
+export interface NotificationHandler5<P1, P2, P3, P4, P5> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5): void;
+}
+export interface NotificationHandler6<P1, P2, P3, P4, P5, P6> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6): void;
+}
+export interface NotificationHandler7<P1, P2, P3, P4, P5, P6, P7> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7): void;
+}
+export interface NotificationHandler8<P1, P2, P3, P4, P5, P6, P7, P8> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8): void;
+}
+export interface NotificationHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9> {
+    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9): void;
+}
+export interface Logger {
+    error(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    log(message: string): void;
+}
+export declare const NullLogger: Logger;
+export declare enum Trace {
+    Off = 0,
+    Messages = 1,
+    Verbose = 2
+}
+export declare type TraceValues = 'off' | 'messages' | 'verbose';
+export declare namespace Trace {
+    function fromString(value: string): Trace;
+    function toString(value: Trace): TraceValues;
+}
+export declare enum TraceFormat {
+    Text = "text",
+    JSON = "json"
+}
+export declare namespace TraceFormat {
+    function fromString(value: string): TraceFormat;
+}
+export interface TraceOptions {
+    sendNotification?: boolean;
+    traceFormat?: TraceFormat;
+}
+export interface SetTraceParams {
+    value: TraceValues;
+}
+export declare namespace SetTraceNotification {
+    const type: NotificationType<SetTraceParams, void>;
+}
+export interface LogTraceParams {
+    message: string;
+    verbose?: string;
+}
+export declare namespace LogTraceNotification {
+    const type: NotificationType<LogTraceParams, void>;
+}
+export interface Tracer {
+    log(dataObject: any): void;
+    log(message: string, data?: string): void;
+}
+export declare enum ConnectionErrors {
+    /**
+     * The connection is closed.
+     */
+    Closed = 1,
+    /**
+     * The connection got disposed.
+     */
+    Disposed = 2,
+    /**
+     * The connection is already in listening mode.
+     */
+    AlreadyListening = 3
+}
+export declare class ConnectionError extends Error {
+    readonly code: ConnectionErrors;
+    constructor(code: ConnectionErrors, message: string);
+}
+export declare type MessageQueue = LinkedMap<string, Message>;
+export declare type ConnectionStrategy = {
+    cancelUndispatched?: (message: Message, next: (message: Message) => ResponseMessage | undefined) => ResponseMessage | undefined;
+};
+export declare namespace ConnectionStrategy {
+    function is(value: any): value is ConnectionStrategy;
+}
+export interface MessageConnection {
+    sendRequest<R, E, RO>(type: RequestType0<R, E, RO>, token?: CancellationToken): Thenable<R>;
+    sendRequest<P, R, E, RO>(type: RequestType<P, R, E, RO>, params: P, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, R, E, RO>(type: RequestType1<P1, R, E, RO>, p1: P1, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, R, E, RO>(type: RequestType2<P1, P2, R, E, RO>, p1: P1, p2: P2, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, R, E, RO>(type: RequestType3<P1, P2, P3, R, E, RO>, p1: P1, p2: P2, p3: P3, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, P4, R, E, RO>(type: RequestType4<P1, P2, P3, P4, R, E, RO>, p1: P1, p2: P2, p3: P3, p4: P4, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, P4, P5, R, E, RO>(type: RequestType5<P1, P2, P3, P4, P5, R, E, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, P4, P5, P6, R, E, RO>(type: RequestType6<P1, P2, P3, P4, P5, P6, R, E, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, P4, P5, P6, P7, R, E, RO>(type: RequestType7<P1, P2, P3, P4, P5, P6, P7, R, E, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, P4, P5, P6, P7, P8, R, E, RO>(type: RequestType8<P1, P2, P3, P4, P5, P6, P7, P8, R, E, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, token?: CancellationToken): Thenable<R>;
+    sendRequest<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, RO>(type: RequestType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, token?: CancellationToken): Thenable<R>;
+    sendRequest<R>(method: string, ...params: any[]): Thenable<R>;
+    onRequest<R, E, RO>(type: RequestType0<R, E, RO>, handler: RequestHandler0<R, E>): void;
+    onRequest<P, R, E, RO>(type: RequestType<P, R, E, RO>, handler: RequestHandler<P, R, E>): void;
+    onRequest<P1, R, E, RO>(type: RequestType1<P1, R, E, RO>, handler: RequestHandler1<P1, R, E>): void;
+    onRequest<P1, P2, R, E, RO>(type: RequestType2<P1, P2, R, E, RO>, handler: RequestHandler2<P1, P2, R, E>): void;
+    onRequest<P1, P2, P3, R, E, RO>(type: RequestType3<P1, P2, P3, R, E, RO>, handler: RequestHandler3<P1, P2, P3, R, E>): void;
+    onRequest<P1, P2, P3, P4, R, E, RO>(type: RequestType4<P1, P2, P3, P4, R, E, RO>, handler: RequestHandler4<P1, P2, P3, P4, R, E>): void;
+    onRequest<P1, P2, P3, P4, P5, R, E, RO>(type: RequestType5<P1, P2, P3, P4, P5, R, E, RO>, handler: RequestHandler5<P1, P2, P3, P4, P5, R, E>): void;
+    onRequest<P1, P2, P3, P4, P5, P6, R, E, RO>(type: RequestType6<P1, P2, P3, P4, P5, P6, R, E, RO>, handler: RequestHandler6<P1, P2, P3, P4, P5, P6, R, E>): void;
+    onRequest<P1, P2, P3, P4, P5, P6, P7, R, E, RO>(type: RequestType7<P1, P2, P3, P4, P5, P6, P7, R, E, RO>, handler: RequestHandler7<P1, P2, P3, P4, P5, P6, P7, R, E>): void;
+    onRequest<P1, P2, P3, P4, P5, P6, P7, P8, R, E, RO>(type: RequestType8<P1, P2, P3, P4, P5, P6, P7, P8, R, E, RO>, handler: RequestHandler8<P1, P2, P3, P4, P5, P6, P7, P8, R, E>): void;
+    onRequest<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, RO>(type: RequestType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, RO>, handler: RequestHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E>): void;
+    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): void;
+    onRequest(handler: StarRequestHandler): void;
+    sendNotification<RO>(type: NotificationType0<RO>): void;
+    sendNotification<P, RO>(type: NotificationType<P, RO>, params?: P): void;
+    sendNotification<P1, RO>(type: NotificationType1<P1, RO>, p1: P1): void;
+    sendNotification<P1, P2, RO>(type: NotificationType2<P1, P2, RO>, p1: P1, p2: P2): void;
+    sendNotification<P1, P2, P3, RO>(type: NotificationType3<P1, P2, P3, RO>, p1: P1, p2: P2, p3: P3): void;
+    sendNotification<P1, P2, P3, P4, RO>(type: NotificationType4<P1, P2, P3, P4, RO>, p1: P1, p2: P2, p3: P3, p4: P4): void;
+    sendNotification<P1, P2, P3, P4, P5, RO>(type: NotificationType5<P1, P2, P3, P4, P5, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5): void;
+    sendNotification<P1, P2, P3, P4, P5, P6, RO>(type: NotificationType6<P1, P2, P3, P4, P5, P6, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6): void;
+    sendNotification<P1, P2, P3, P4, P5, P6, P7, RO>(type: NotificationType7<P1, P2, P3, P4, P5, P6, P7, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7): void;
+    sendNotification<P1, P2, P3, P4, P5, P6, P7, P8, RO>(type: NotificationType8<P1, P2, P3, P4, P5, P6, P7, P8, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8): void;
+    sendNotification<P1, P2, P3, P4, P5, P6, P7, P8, P9, RO>(type: NotificationType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, RO>, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9): void;
+    sendNotification(method: string, ...params: any[]): void;
+    onNotification<RO>(type: NotificationType0<RO>, handler: NotificationHandler0): void;
+    onNotification<P, RO>(type: NotificationType<P, RO>, handler: NotificationHandler<P>): void;
+    onNotification<P1, RO>(type: NotificationType1<P1, RO>, handler: NotificationHandler1<P1>): void;
+    onNotification<P1, P2, RO>(type: NotificationType2<P1, P2, RO>, handler: NotificationHandler2<P1, P2>): void;
+    onNotification<P1, P2, P3, RO>(type: NotificationType3<P1, P2, P3, RO>, handler: NotificationHandler3<P1, P2, P3>): void;
+    onNotification<P1, P2, P3, P4, RO>(type: NotificationType4<P1, P2, P3, P4, RO>, handler: NotificationHandler4<P1, P2, P3, P4>): void;
+    onNotification<P1, P2, P3, P4, P5, RO>(type: NotificationType5<P1, P2, P3, P4, P5, RO>, handler: NotificationHandler5<P1, P2, P3, P4, P5>): void;
+    onNotification<P1, P2, P3, P4, P5, P6, RO>(type: NotificationType6<P1, P2, P3, P4, P5, P6, RO>, handler: NotificationHandler6<P1, P2, P3, P4, P5, P6>): void;
+    onNotification<P1, P2, P3, P4, P5, P6, P7, RO>(type: NotificationType7<P1, P2, P3, P4, P5, P6, P7, RO>, handler: NotificationHandler7<P1, P2, P3, P4, P5, P6, P7>): void;
+    onNotification<P1, P2, P3, P4, P5, P6, P7, P8, RO>(type: NotificationType8<P1, P2, P3, P4, P5, P6, P7, P8, RO>, handler: NotificationHandler8<P1, P2, P3, P4, P5, P6, P7, P8>): void;
+    onNotification<P1, P2, P3, P4, P5, P6, P7, P8, P9, RO>(type: NotificationType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, RO>, handler: NotificationHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9>): void;
+    onNotification(method: string, handler: GenericNotificationHandler): void;
+    onNotification(handler: StarNotificationHandler): void;
+    trace(value: Trace, tracer: Tracer, sendNotification?: boolean): void;
+    trace(value: Trace, tracer: Tracer, traceOptions?: TraceOptions): void;
+    onError: Event<[Error, Message | undefined, number | undefined]>;
+    onClose: Event<void>;
+    onUnhandledNotification: Event<NotificationMessage>;
+    listen(): void;
+    onDispose: Event<void>;
+    dispose(): void;
+    inspect(): void;
+}
+export declare function createMessageConnection(reader: MessageReader, writer: MessageWriter, logger?: Logger, strategy?: ConnectionStrategy): MessageConnection;
+export declare function createMessageConnection(inputStream: NodeJS.ReadableStream, outputStream: NodeJS.WritableStream, logger?: Logger, strategy?: ConnectionStrategy): MessageConnection;

Client/node_modules/vscode-jsonrpc/lib/main.js

@@ -0,0 +1,923 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+/// <reference path="./thenable.ts" />
+'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 Is = require("./is");
+const messages_1 = require("./messages");
+exports.RequestType = messages_1.RequestType;
+exports.RequestType0 = messages_1.RequestType0;
+exports.RequestType1 = messages_1.RequestType1;
+exports.RequestType2 = messages_1.RequestType2;
+exports.RequestType3 = messages_1.RequestType3;
+exports.RequestType4 = messages_1.RequestType4;
+exports.RequestType5 = messages_1.RequestType5;
+exports.RequestType6 = messages_1.RequestType6;
+exports.RequestType7 = messages_1.RequestType7;
+exports.RequestType8 = messages_1.RequestType8;
+exports.RequestType9 = messages_1.RequestType9;
+exports.ResponseError = messages_1.ResponseError;
+exports.ErrorCodes = messages_1.ErrorCodes;
+exports.NotificationType = messages_1.NotificationType;
+exports.NotificationType0 = messages_1.NotificationType0;
+exports.NotificationType1 = messages_1.NotificationType1;
+exports.NotificationType2 = messages_1.NotificationType2;
+exports.NotificationType3 = messages_1.NotificationType3;
+exports.NotificationType4 = messages_1.NotificationType4;
+exports.NotificationType5 = messages_1.NotificationType5;
+exports.NotificationType6 = messages_1.NotificationType6;
+exports.NotificationType7 = messages_1.NotificationType7;
+exports.NotificationType8 = messages_1.NotificationType8;
+exports.NotificationType9 = messages_1.NotificationType9;
+const messageReader_1 = require("./messageReader");
+exports.MessageReader = messageReader_1.MessageReader;
+exports.StreamMessageReader = messageReader_1.StreamMessageReader;
+exports.IPCMessageReader = messageReader_1.IPCMessageReader;
+exports.SocketMessageReader = messageReader_1.SocketMessageReader;
+const messageWriter_1 = require("./messageWriter");
+exports.MessageWriter = messageWriter_1.MessageWriter;
+exports.StreamMessageWriter = messageWriter_1.StreamMessageWriter;
+exports.IPCMessageWriter = messageWriter_1.IPCMessageWriter;
+exports.SocketMessageWriter = messageWriter_1.SocketMessageWriter;
+const events_1 = require("./events");
+exports.Disposable = events_1.Disposable;
+exports.Event = events_1.Event;
+exports.Emitter = events_1.Emitter;
+const cancellation_1 = require("./cancellation");
+exports.CancellationTokenSource = cancellation_1.CancellationTokenSource;
+exports.CancellationToken = cancellation_1.CancellationToken;
+const linkedMap_1 = require("./linkedMap");
+__export(require("./pipeSupport"));
+__export(require("./socketSupport"));
+var CancelNotification;
+(function (CancelNotification) {
+    CancelNotification.type = new messages_1.NotificationType('$/cancelRequest');
+})(CancelNotification || (CancelNotification = {}));
+exports.NullLogger = Object.freeze({
+    error: () => { },
+    warn: () => { },
+    info: () => { },
+    log: () => { }
+});
+var Trace;
+(function (Trace) {
+    Trace[Trace["Off"] = 0] = "Off";
+    Trace[Trace["Messages"] = 1] = "Messages";
+    Trace[Trace["Verbose"] = 2] = "Verbose";
+})(Trace = exports.Trace || (exports.Trace = {}));
+(function (Trace) {
+    function fromString(value) {
+        value = value.toLowerCase();
+        switch (value) {
+            case 'off':
+                return Trace.Off;
+            case 'messages':
+                return Trace.Messages;
+            case 'verbose':
+                return Trace.Verbose;
+            default:
+                return Trace.Off;
+        }
+    }
+    Trace.fromString = fromString;
+    function toString(value) {
+        switch (value) {
+            case Trace.Off:
+                return 'off';
+            case Trace.Messages:
+                return 'messages';
+            case Trace.Verbose:
+                return 'verbose';
+            default:
+                return 'off';
+        }
+    }
+    Trace.toString = toString;
+})(Trace = exports.Trace || (exports.Trace = {}));
+var TraceFormat;
+(function (TraceFormat) {
+    TraceFormat["Text"] = "text";
+    TraceFormat["JSON"] = "json";
+})(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));
+(function (TraceFormat) {
+    function fromString(value) {
+        value = value.toLowerCase();
+        if (value === 'json') {
+            return TraceFormat.JSON;
+        }
+        else {
+            return TraceFormat.Text;
+        }
+    }
+    TraceFormat.fromString = fromString;
+})(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));
+var SetTraceNotification;
+(function (SetTraceNotification) {
+    SetTraceNotification.type = new messages_1.NotificationType('$/setTraceNotification');
+})(SetTraceNotification = exports.SetTraceNotification || (exports.SetTraceNotification = {}));
+var LogTraceNotification;
+(function (LogTraceNotification) {
+    LogTraceNotification.type = new messages_1.NotificationType('$/logTraceNotification');
+})(LogTraceNotification = exports.LogTraceNotification || (exports.LogTraceNotification = {}));
+var ConnectionErrors;
+(function (ConnectionErrors) {
+    /**
+     * The connection is closed.
+     */
+    ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
+    /**
+     * The connection got disposed.
+     */
+    ConnectionErrors[ConnectionErrors["Disposed"] = 2] = "Disposed";
+    /**
+     * The connection is already in listening mode.
+     */
+    ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
+})(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));
+class ConnectionError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+}
+exports.ConnectionError = ConnectionError;
+var ConnectionStrategy;
+(function (ConnectionStrategy) {
+    function is(value) {
+        let candidate = value;
+        return candidate && Is.func(candidate.cancelUndispatched);
+    }
+    ConnectionStrategy.is = is;
+})(ConnectionStrategy = exports.ConnectionStrategy || (exports.ConnectionStrategy = {}));
+var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState[ConnectionState["New"] = 1] = "New";
+    ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
+    ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
+    ConnectionState[ConnectionState["Disposed"] = 4] = "Disposed";
+})(ConnectionState || (ConnectionState = {}));
+function _createMessageConnection(messageReader, messageWriter, logger, strategy) {
+    let sequenceNumber = 0;
+    let notificationSquenceNumber = 0;
+    let unknownResponseSquenceNumber = 0;
+    const version = '2.0';
+    let starRequestHandler = undefined;
+    let requestHandlers = Object.create(null);
+    let starNotificationHandler = undefined;
+    let notificationHandlers = Object.create(null);
+    let timer;
+    let messageQueue = new linkedMap_1.LinkedMap();
+    let responsePromises = Object.create(null);
+    let requestTokens = Object.create(null);
+    let trace = Trace.Off;
+    let traceFormat = TraceFormat.Text;
+    let tracer;
+    let state = ConnectionState.New;
+    let errorEmitter = new events_1.Emitter();
+    let closeEmitter = new events_1.Emitter();
+    let unhandledNotificationEmitter = new events_1.Emitter();
+    let disposeEmitter = new events_1.Emitter();
+    function createRequestQueueKey(id) {
+        return 'req-' + id.toString();
+    }
+    function createResponseQueueKey(id) {
+        if (id === null) {
+            return 'res-unknown-' + (++unknownResponseSquenceNumber).toString();
+        }
+        else {
+            return 'res-' + id.toString();
+        }
+    }
+    function createNotificationQueueKey() {
+        return 'not-' + (++notificationSquenceNumber).toString();
+    }
+    function addMessageToQueue(queue, message) {
+        if (messages_1.isRequestMessage(message)) {
+            queue.set(createRequestQueueKey(message.id), message);
+        }
+        else if (messages_1.isResponseMessage(message)) {
+            queue.set(createResponseQueueKey(message.id), message);
+        }
+        else {
+            queue.set(createNotificationQueueKey(), message);
+        }
+    }
+    function cancelUndispatched(_message) {
+        return undefined;
+    }
+    function isListening() {
+        return state === ConnectionState.Listening;
+    }
+    function isClosed() {
+        return state === ConnectionState.Closed;
+    }
+    function isDisposed() {
+        return state === ConnectionState.Disposed;
+    }
+    function closeHandler() {
+        if (state === ConnectionState.New || state === ConnectionState.Listening) {
+            state = ConnectionState.Closed;
+            closeEmitter.fire(undefined);
+        }
+        // If the connection is disposed don't sent close events.
+    }
+    ;
+    function readErrorHandler(error) {
+        errorEmitter.fire([error, undefined, undefined]);
+    }
+    function writeErrorHandler(data) {
+        errorEmitter.fire(data);
+    }
+    messageReader.onClose(closeHandler);
+    messageReader.onError(readErrorHandler);
+    messageWriter.onClose(closeHandler);
+    messageWriter.onError(writeErrorHandler);
+    function triggerMessageQueue() {
+        if (timer || messageQueue.size === 0) {
+            return;
+        }
+        timer = setImmediate(() => {
+            timer = undefined;
+            processMessageQueue();
+        });
+    }
+    function processMessageQueue() {
+        if (messageQueue.size === 0) {
+            return;
+        }
+        let message = messageQueue.shift();
+        try {
+            if (messages_1.isRequestMessage(message)) {
+                handleRequest(message);
+            }
+            else if (messages_1.isNotificationMessage(message)) {
+                handleNotification(message);
+            }
+            else if (messages_1.isResponseMessage(message)) {
+                handleResponse(message);
+            }
+            else {
+                handleInvalidMessage(message);
+            }
+        }
+        finally {
+            triggerMessageQueue();
+        }
+    }
+    let callback = (message) => {
+        try {
+            // We have received a cancellation message. Check if the message is still in the queue
+            // and cancel it if allowed to do so.
+            if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {
+                let key = createRequestQueueKey(message.params.id);
+                let toCancel = messageQueue.get(key);
+                if (messages_1.isRequestMessage(toCancel)) {
+                    let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+                    if (response && (response.error !== void 0 || response.result !== void 0)) {
+                        messageQueue.delete(key);
+                        response.id = toCancel.id;
+                        traceSendingResponse(response, message.method, Date.now());
+                        messageWriter.write(response);
+                        return;
+                    }
+                }
+            }
+            addMessageToQueue(messageQueue, message);
+        }
+        finally {
+            triggerMessageQueue();
+        }
+    };
+    function handleRequest(requestMessage) {
+        if (isDisposed()) {
+            // we return here silently since we fired an event when the
+            // connection got disposed.
+            return;
+        }
+        function reply(resultOrError, method, startTime) {
+            let message = {
+                jsonrpc: version,
+                id: requestMessage.id
+            };
+            if (resultOrError instanceof messages_1.ResponseError) {
+                message.error = resultOrError.toJson();
+            }
+            else {
+                message.result = resultOrError === void 0 ? null : resultOrError;
+            }
+            traceSendingResponse(message, method, startTime);
+            messageWriter.write(message);
+        }
+        function replyError(error, method, startTime) {
+            let message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                error: error.toJson()
+            };
+            traceSendingResponse(message, method, startTime);
+            messageWriter.write(message);
+        }
+        function replySuccess(result, method, startTime) {
+            // The JSON RPC defines that a response must either have a result or an error
+            // So we can't treat undefined as a valid response result.
+            if (result === void 0) {
+                result = null;
+            }
+            let message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                result: result
+            };
+            traceSendingResponse(message, method, startTime);
+            messageWriter.write(message);
+        }
+        traceReceivedRequest(requestMessage);
+        let element = requestHandlers[requestMessage.method];
+        let type;
+        let requestHandler;
+        if (element) {
+            type = element.type;
+            requestHandler = element.handler;
+        }
+        let startTime = Date.now();
+        if (requestHandler || starRequestHandler) {
+            let cancellationSource = new cancellation_1.CancellationTokenSource();
+            let tokenKey = String(requestMessage.id);
+            requestTokens[tokenKey] = cancellationSource;
+            try {
+                let handlerResult;
+                if (requestMessage.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {
+                    handlerResult = requestHandler
+                        ? requestHandler(cancellationSource.token)
+                        : starRequestHandler(requestMessage.method, cancellationSource.token);
+                }
+                else if (Is.array(requestMessage.params) && (type === void 0 || type.numberOfParams > 1)) {
+                    handlerResult = requestHandler
+                        ? requestHandler(...requestMessage.params, cancellationSource.token)
+                        : starRequestHandler(requestMessage.method, ...requestMessage.params, cancellationSource.token);
+                }
+                else {
+                    handlerResult = requestHandler
+                        ? requestHandler(requestMessage.params, cancellationSource.token)
+                        : starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
+                }
+                let promise = handlerResult;
+                if (!handlerResult) {
+                    delete requestTokens[tokenKey];
+                    replySuccess(handlerResult, requestMessage.method, startTime);
+                }
+                else if (promise.then) {
+                    promise.then((resultOrError) => {
+                        delete requestTokens[tokenKey];
+                        reply(resultOrError, requestMessage.method, startTime);
+                    }, error => {
+                        delete requestTokens[tokenKey];
+                        if (error instanceof messages_1.ResponseError) {
+                            replyError(error, requestMessage.method, startTime);
+                        }
+                        else if (error && Is.string(error.message)) {
+                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+                        }
+                        else {
+                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+                        }
+                    });
+                }
+                else {
+                    delete requestTokens[tokenKey];
+                    reply(handlerResult, requestMessage.method, startTime);
+                }
+            }
+            catch (error) {
+                delete requestTokens[tokenKey];
+                if (error instanceof messages_1.ResponseError) {
+                    reply(error, requestMessage.method, startTime);
+                }
+                else if (error && Is.string(error.message)) {
+                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+                }
+                else {
+                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+                }
+            }
+        }
+        else {
+            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
+        }
+    }
+    function handleResponse(responseMessage) {
+        if (isDisposed()) {
+            // See handle request.
+            return;
+        }
+        if (responseMessage.id === null) {
+            if (responseMessage.error) {
+                logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
+            }
+            else {
+                logger.error(`Received response message without id. No further error information provided.`);
+            }
+        }
+        else {
+            let key = String(responseMessage.id);
+            let responsePromise = responsePromises[key];
+            traceReceivedResponse(responseMessage, responsePromise);
+            if (responsePromise) {
+                delete responsePromises[key];
+                try {
+                    if (responseMessage.error) {
+                        let error = responseMessage.error;
+                        responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
+                    }
+                    else if (responseMessage.result !== void 0) {
+                        responsePromise.resolve(responseMessage.result);
+                    }
+                    else {
+                        throw new Error('Should never happen.');
+                    }
+                }
+                catch (error) {
+                    if (error.message) {
+                        logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
+                    }
+                    else {
+                        logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
+                    }
+                }
+            }
+        }
+    }
+    function handleNotification(message) {
+        if (isDisposed()) {
+            // See handle request.
+            return;
+        }
+        let type = undefined;
+        let notificationHandler;
+        if (message.method === CancelNotification.type.method) {
+            notificationHandler = (params) => {
+                let id = params.id;
+                let source = requestTokens[String(id)];
+                if (source) {
+                    source.cancel();
+                }
+            };
+        }
+        else {
+            let element = notificationHandlers[message.method];
+            if (element) {
+                notificationHandler = element.handler;
+                type = element.type;
+            }
+        }
+        if (notificationHandler || starNotificationHandler) {
+            try {
+                traceReceivedNotification(message);
+                if (message.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {
+                    notificationHandler ? notificationHandler() : starNotificationHandler(message.method);
+                }
+                else if (Is.array(message.params) && (type === void 0 || type.numberOfParams > 1)) {
+                    notificationHandler ? notificationHandler(...message.params) : starNotificationHandler(message.method, ...message.params);
+                }
+                else {
+                    notificationHandler ? notificationHandler(message.params) : starNotificationHandler(message.method, message.params);
+                }
+            }
+            catch (error) {
+                if (error.message) {
+                    logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
+                }
+                else {
+                    logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
+                }
+            }
+        }
+        else {
+            unhandledNotificationEmitter.fire(message);
+        }
+    }
+    function handleInvalidMessage(message) {
+        if (!message) {
+            logger.error('Received empty message.');
+            return;
+        }
+        logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
+        // Test whether we find an id to reject the promise
+        let responseMessage = message;
+        if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
+            let key = String(responseMessage.id);
+            let responseHandler = responsePromises[key];
+            if (responseHandler) {
+                responseHandler.reject(new Error('The received response has neither a result nor an error property.'));
+            }
+        }
+    }
+    function traceSendingRequest(message) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose && message.params) {
+                data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
+            }
+            tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
+        }
+        else {
+            logLSPMessage('send-request', message);
+        }
+    }
+    function traceSendingNotification(message) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose) {
+                if (message.params) {
+                    data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
+                }
+                else {
+                    data = 'No parameters provided.\n\n';
+                }
+            }
+            tracer.log(`Sending notification '${message.method}'.`, data);
+        }
+        else {
+            logLSPMessage('send-notification', message);
+        }
+    }
+    function traceSendingResponse(message, method, startTime) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose) {
+                if (message.error && message.error.data) {
+                    data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;
+                }
+                else {
+                    if (message.result) {
+                        data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;
+                    }
+                    else if (message.error === void 0) {
+                        data = 'No result returned.\n\n';
+                    }
+                }
+            }
+            tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
+        }
+        else {
+            logLSPMessage('send-response', message);
+        }
+    }
+    function traceReceivedRequest(message) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose && message.params) {
+                data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
+            }
+            tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
+        }
+        else {
+            logLSPMessage('receive-request', message);
+        }
+    }
+    function traceReceivedNotification(message) {
+        if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose) {
+                if (message.params) {
+                    data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
+                }
+                else {
+                    data = 'No parameters provided.\n\n';
+                }
+            }
+            tracer.log(`Received notification '${message.method}'.`, data);
+        }
+        else {
+            logLSPMessage('receive-notification', message);
+        }
+    }
+    function traceReceivedResponse(message, responsePromise) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose) {
+                if (message.error && message.error.data) {
+                    data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;
+                }
+                else {
+                    if (message.result) {
+                        data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;
+                    }
+                    else if (message.error === void 0) {
+                        data = 'No result returned.\n\n';
+                    }
+                }
+            }
+            if (responsePromise) {
+                let error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';
+                tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
+            }
+            else {
+                tracer.log(`Received response ${message.id} without active response promise.`, data);
+            }
+        }
+        else {
+            logLSPMessage('receive-response', message);
+        }
+    }
+    function logLSPMessage(type, message) {
+        if (!tracer || trace === Trace.Off) {
+            return;
+        }
+        const lspMessage = {
+            isLSPMessage: true,
+            type,
+            message,
+            timestamp: Date.now()
+        };
+        tracer.log(lspMessage);
+    }
+    function throwIfClosedOrDisposed() {
+        if (isClosed()) {
+            throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');
+        }
+        if (isDisposed()) {
+            throw new ConnectionError(ConnectionErrors.Disposed, 'Connection is disposed.');
+        }
+    }
+    function throwIfListening() {
+        if (isListening()) {
+            throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');
+        }
+    }
+    function throwIfNotListening() {
+        if (!isListening()) {
+            throw new Error('Call listen() first.');
+        }
+    }
+    function undefinedToNull(param) {
+        if (param === void 0) {
+            return null;
+        }
+        else {
+            return param;
+        }
+    }
+    function computeMessageParams(type, params) {
+        let result;
+        let numberOfParams = type.numberOfParams;
+        switch (numberOfParams) {
+            case 0:
+                result = null;
+                break;
+            case 1:
+                result = undefinedToNull(params[0]);
+                break;
+            default:
+                result = [];
+                for (let i = 0; i < params.length && i < numberOfParams; i++) {
+                    result.push(undefinedToNull(params[i]));
+                }
+                if (params.length < numberOfParams) {
+                    for (let i = params.length; i < numberOfParams; i++) {
+                        result.push(null);
+                    }
+                }
+                break;
+        }
+        return result;
+    }
+    let connection = {
+        sendNotification: (type, ...params) => {
+            throwIfClosedOrDisposed();
+            let method;
+            let messageParams;
+            if (Is.string(type)) {
+                method = type;
+                switch (params.length) {
+                    case 0:
+                        messageParams = null;
+                        break;
+                    case 1:
+                        messageParams = params[0];
+                        break;
+                    default:
+                        messageParams = params;
+                        break;
+                }
+            }
+            else {
+                method = type.method;
+                messageParams = computeMessageParams(type, params);
+            }
+            let notificationMessage = {
+                jsonrpc: version,
+                method: method,
+                params: messageParams
+            };
+            traceSendingNotification(notificationMessage);
+            messageWriter.write(notificationMessage);
+        },
+        onNotification: (type, handler) => {
+            throwIfClosedOrDisposed();
+            if (Is.func(type)) {
+                starNotificationHandler = type;
+            }
+            else if (handler) {
+                if (Is.string(type)) {
+                    notificationHandlers[type] = { type: undefined, handler };
+                }
+                else {
+                    notificationHandlers[type.method] = { type, handler };
+                }
+            }
+        },
+        sendRequest: (type, ...params) => {
+            throwIfClosedOrDisposed();
+            throwIfNotListening();
+            let method;
+            let messageParams;
+            let token = undefined;
+            if (Is.string(type)) {
+                method = type;
+                switch (params.length) {
+                    case 0:
+                        messageParams = null;
+                        break;
+                    case 1:
+                        // The cancellation token is optional so it can also be undefined.
+                        if (cancellation_1.CancellationToken.is(params[0])) {
+                            messageParams = null;
+                            token = params[0];
+                        }
+                        else {
+                            messageParams = undefinedToNull(params[0]);
+                        }
+                        break;
+                    default:
+                        const last = params.length - 1;
+                        if (cancellation_1.CancellationToken.is(params[last])) {
+                            token = params[last];
+                            if (params.length === 2) {
+                                messageParams = undefinedToNull(params[0]);
+                            }
+                            else {
+                                messageParams = params.slice(0, last).map(value => undefinedToNull(value));
+                            }
+                        }
+                        else {
+                            messageParams = params.map(value => undefinedToNull(value));
+                        }
+                        break;
+                }
+            }
+            else {
+                method = type.method;
+                messageParams = computeMessageParams(type, params);
+                let numberOfParams = type.numberOfParams;
+                token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;
+            }
+            let id = sequenceNumber++;
+            let result = new Promise((resolve, reject) => {
+                let requestMessage = {
+                    jsonrpc: version,
+                    id: id,
+                    method: method,
+                    params: messageParams
+                };
+                let responsePromise = { method: method, timerStart: Date.now(), resolve, reject };
+                traceSendingRequest(requestMessage);
+                try {
+                    messageWriter.write(requestMessage);
+                }
+                catch (e) {
+                    // Writing the message failed. So we need to reject the promise.
+                    responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));
+                    responsePromise = null;
+                }
+                if (responsePromise) {
+                    responsePromises[String(id)] = responsePromise;
+                }
+            });
+            if (token) {
+                token.onCancellationRequested(() => {
+                    connection.sendNotification(CancelNotification.type, { id });
+                });
+            }
+            return result;
+        },
+        onRequest: (type, handler) => {
+            throwIfClosedOrDisposed();
+            if (Is.func(type)) {
+                starRequestHandler = type;
+            }
+            else if (handler) {
+                if (Is.string(type)) {
+                    requestHandlers[type] = { type: undefined, handler };
+                }
+                else {
+                    requestHandlers[type.method] = { type, handler };
+                }
+            }
+        },
+        trace: (_value, _tracer, sendNotificationOrTraceOptions) => {
+            let _sendNotification = false;
+            let _traceFormat = TraceFormat.Text;
+            if (sendNotificationOrTraceOptions !== void 0) {
+                if (Is.boolean(sendNotificationOrTraceOptions)) {
+                    _sendNotification = sendNotificationOrTraceOptions;
+                }
+                else {
+                    _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
+                    _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
+                }
+            }
+            trace = _value;
+            traceFormat = _traceFormat;
+            if (trace === Trace.Off) {
+                tracer = undefined;
+            }
+            else {
+                tracer = _tracer;
+            }
+            if (_sendNotification && !isClosed() && !isDisposed()) {
+                connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
+            }
+        },
+        onError: errorEmitter.event,
+        onClose: closeEmitter.event,
+        onUnhandledNotification: unhandledNotificationEmitter.event,
+        onDispose: disposeEmitter.event,
+        dispose: () => {
+            if (isDisposed()) {
+                return;
+            }
+            state = ConnectionState.Disposed;
+            disposeEmitter.fire(undefined);
+            let error = new Error('Connection got disposed.');
+            Object.keys(responsePromises).forEach((key) => {
+                responsePromises[key].reject(error);
+            });
+            responsePromises = Object.create(null);
+            requestTokens = Object.create(null);
+            messageQueue = new linkedMap_1.LinkedMap();
+            // Test for backwards compatibility
+            if (Is.func(messageWriter.dispose)) {
+                messageWriter.dispose();
+            }
+            if (Is.func(messageReader.dispose)) {
+                messageReader.dispose();
+            }
+        },
+        listen: () => {
+            throwIfClosedOrDisposed();
+            throwIfListening();
+            state = ConnectionState.Listening;
+            messageReader.listen(callback);
+        },
+        inspect: () => {
+            console.log("inspect");
+        }
+    };
+    connection.onNotification(LogTraceNotification.type, (params) => {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        tracer.log(params.message, trace === Trace.Verbose ? params.verbose : undefined);
+    });
+    return connection;
+}
+function isMessageReader(value) {
+    return value.listen !== void 0 && value.read === void 0;
+}
+function isMessageWriter(value) {
+    return value.write !== void 0 && value.end === void 0;
+}
+function createMessageConnection(input, output, logger, strategy) {
+    if (!logger) {
+        logger = exports.NullLogger;
+    }
+    let reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input);
+    let writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output);
+    return _createMessageConnection(reader, writer, logger, strategy);
+}
+exports.createMessageConnection = createMessageConnection;

Client/node_modules/vscode-jsonrpc/lib/messageReader.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+import { Socket } from 'net';
+import { ChildProcess } from 'child_process';
+import { Message } from './messages';
+import { Event } from './events';
+export interface DataCallback {
+    (data: Message): void;
+}
+export interface PartialMessageInfo {
+    readonly messageToken: number;
+    readonly waitingTime: number;
+}
+export interface MessageReader {
+    readonly onError: Event<Error>;
+    readonly onClose: Event<void>;
+    readonly onPartialMessage: Event<PartialMessageInfo>;
+    listen(callback: DataCallback): void;
+    dispose(): void;
+}
+export declare namespace MessageReader {
+    function is(value: any): value is MessageReader;
+}
+export declare abstract class AbstractMessageReader {
+    private errorEmitter;
+    private closeEmitter;
+    private partialMessageEmitter;
+    constructor();
+    dispose(): void;
+    readonly onError: Event<Error>;
+    protected fireError(error: any): void;
+    readonly onClose: Event<void>;
+    protected fireClose(): void;
+    readonly onPartialMessage: Event<PartialMessageInfo>;
+    protected firePartialMessage(info: PartialMessageInfo): void;
+    private asError;
+}
+export declare class StreamMessageReader extends AbstractMessageReader implements MessageReader {
+    private readable;
+    private callback;
+    private buffer;
+    private nextMessageLength;
+    private messageToken;
+    private partialMessageTimer;
+    private _partialMessageTimeout;
+    constructor(readable: NodeJS.ReadableStream, encoding?: string);
+    partialMessageTimeout: number;
+    listen(callback: DataCallback): void;
+    private onData;
+    private clearPartialMessageTimer;
+    private setPartialMessageTimer;
+}
+export declare class IPCMessageReader extends AbstractMessageReader implements MessageReader {
+    private process;
+    constructor(process: NodeJS.Process | ChildProcess);
+    listen(callback: DataCallback): void;
+}
+export declare class SocketMessageReader extends StreamMessageReader {
+    constructor(socket: Socket, encoding?: string);
+}

Client/node_modules/vscode-jsonrpc/lib/messageReader.js

@@ -0,0 +1,225 @@
+/* --------------------------------------------------------------------------------------------
+ * 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 events_1 = require("./events");
+const Is = require("./is");
+let DefaultSize = 8192;
+let CR = Buffer.from('\r', 'ascii')[0];
+let LF = Buffer.from('\n', 'ascii')[0];
+let CRLF = '\r\n';
+class MessageBuffer {
+    constructor(encoding = 'utf8') {
+        this.encoding = encoding;
+        this.index = 0;
+        this.buffer = Buffer.allocUnsafe(DefaultSize);
+    }
+    append(chunk) {
+        var toAppend = chunk;
+        if (typeof (chunk) === 'string') {
+            var str = chunk;
+            var bufferLen = Buffer.byteLength(str, this.encoding);
+            toAppend = Buffer.allocUnsafe(bufferLen);
+            toAppend.write(str, 0, bufferLen, this.encoding);
+        }
+        if (this.buffer.length - this.index >= toAppend.length) {
+            toAppend.copy(this.buffer, this.index, 0, toAppend.length);
+        }
+        else {
+            var newSize = (Math.ceil((this.index + toAppend.length) / DefaultSize) + 1) * DefaultSize;
+            if (this.index === 0) {
+                this.buffer = Buffer.allocUnsafe(newSize);
+                toAppend.copy(this.buffer, 0, 0, toAppend.length);
+            }
+            else {
+                this.buffer = Buffer.concat([this.buffer.slice(0, this.index), toAppend], newSize);
+            }
+        }
+        this.index += toAppend.length;
+    }
+    tryReadHeaders() {
+        let result = undefined;
+        let current = 0;
+        while (current + 3 < this.index && (this.buffer[current] !== CR || this.buffer[current + 1] !== LF || this.buffer[current + 2] !== CR || this.buffer[current + 3] !== LF)) {
+            current++;
+        }
+        // No header / body separator found (e.g CRLFCRLF)
+        if (current + 3 >= this.index) {
+            return result;
+        }
+        result = Object.create(null);
+        let headers = this.buffer.toString('ascii', 0, current).split(CRLF);
+        headers.forEach((header) => {
+            let index = header.indexOf(':');
+            if (index === -1) {
+                throw new Error('Message header must separate key and value using :');
+            }
+            let key = header.substr(0, index);
+            let value = header.substr(index + 1).trim();
+            result[key] = value;
+        });
+        let nextStart = current + 4;
+        this.buffer = this.buffer.slice(nextStart);
+        this.index = this.index - nextStart;
+        return result;
+    }
+    tryReadContent(length) {
+        if (this.index < length) {
+            return null;
+        }
+        let result = this.buffer.toString(this.encoding, 0, length);
+        let nextStart = length;
+        this.buffer.copy(this.buffer, 0, nextStart);
+        this.index = this.index - nextStart;
+        return result;
+    }
+    get numberOfBytes() {
+        return this.index;
+    }
+}
+var MessageReader;
+(function (MessageReader) {
+    function is(value) {
+        let candidate = value;
+        return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&
+            Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
+    }
+    MessageReader.is = is;
+})(MessageReader = exports.MessageReader || (exports.MessageReader = {}));
+class AbstractMessageReader {
+    constructor() {
+        this.errorEmitter = new events_1.Emitter();
+        this.closeEmitter = new events_1.Emitter();
+        this.partialMessageEmitter = new events_1.Emitter();
+    }
+    dispose() {
+        this.errorEmitter.dispose();
+        this.closeEmitter.dispose();
+    }
+    get onError() {
+        return this.errorEmitter.event;
+    }
+    fireError(error) {
+        this.errorEmitter.fire(this.asError(error));
+    }
+    get onClose() {
+        return this.closeEmitter.event;
+    }
+    fireClose() {
+        this.closeEmitter.fire(undefined);
+    }
+    get onPartialMessage() {
+        return this.partialMessageEmitter.event;
+    }
+    firePartialMessage(info) {
+        this.partialMessageEmitter.fire(info);
+    }
+    asError(error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        else {
+            return new Error(`Reader recevied error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
+        }
+    }
+}
+exports.AbstractMessageReader = AbstractMessageReader;
+class StreamMessageReader extends AbstractMessageReader {
+    constructor(readable, encoding = 'utf8') {
+        super();
+        this.readable = readable;
+        this.buffer = new MessageBuffer(encoding);
+        this._partialMessageTimeout = 10000;
+    }
+    set partialMessageTimeout(timeout) {
+        this._partialMessageTimeout = timeout;
+    }
+    get partialMessageTimeout() {
+        return this._partialMessageTimeout;
+    }
+    listen(callback) {
+        this.nextMessageLength = -1;
+        this.messageToken = 0;
+        this.partialMessageTimer = undefined;
+        this.callback = callback;
+        this.readable.on('data', (data) => {
+            this.onData(data);
+        });
+        this.readable.on('error', (error) => this.fireError(error));
+        this.readable.on('close', () => this.fireClose());
+    }
+    onData(data) {
+        this.buffer.append(data);
+        while (true) {
+            if (this.nextMessageLength === -1) {
+                let headers = this.buffer.tryReadHeaders();
+                if (!headers) {
+                    return;
+                }
+                let contentLength = headers['Content-Length'];
+                if (!contentLength) {
+                    throw new Error('Header must provide a Content-Length property.');
+                }
+                let length = parseInt(contentLength);
+                if (isNaN(length)) {
+                    throw new Error('Content-Length value must be a number.');
+                }
+                this.nextMessageLength = length;
+                // Take the encoding form the header. For compatibility
+                // treat both utf-8 and utf8 as node utf8
+            }
+            var msg = this.buffer.tryReadContent(this.nextMessageLength);
+            if (msg === null) {
+                /** We haven't recevied the full message yet. */
+                this.setPartialMessageTimer();
+                return;
+            }
+            this.clearPartialMessageTimer();
+            this.nextMessageLength = -1;
+            this.messageToken++;
+            var json = JSON.parse(msg);
+            this.callback(json);
+        }
+    }
+    clearPartialMessageTimer() {
+        if (this.partialMessageTimer) {
+            clearTimeout(this.partialMessageTimer);
+            this.partialMessageTimer = undefined;
+        }
+    }
+    setPartialMessageTimer() {
+        this.clearPartialMessageTimer();
+        if (this._partialMessageTimeout <= 0) {
+            return;
+        }
+        this.partialMessageTimer = setTimeout((token, timeout) => {
+            this.partialMessageTimer = undefined;
+            if (token === this.messageToken) {
+                this.firePartialMessage({ messageToken: token, waitingTime: timeout });
+                this.setPartialMessageTimer();
+            }
+        }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
+    }
+}
+exports.StreamMessageReader = StreamMessageReader;
+class IPCMessageReader extends AbstractMessageReader {
+    constructor(process) {
+        super();
+        this.process = process;
+        let eventEmitter = this.process;
+        eventEmitter.on('error', (error) => this.fireError(error));
+        eventEmitter.on('close', () => this.fireClose());
+    }
+    listen(callback) {
+        this.process.on('message', callback);
+    }
+}
+exports.IPCMessageReader = IPCMessageReader;
+class SocketMessageReader extends StreamMessageReader {
+    constructor(socket, encoding = 'utf-8') {
+        super(socket, encoding);
+    }
+}
+exports.SocketMessageReader = SocketMessageReader;

Client/node_modules/vscode-jsonrpc/lib/messageWriter.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import { Socket } from 'net';
+import { Message } from './messages';
+import { Event } from './events';
+export interface MessageWriter {
+    readonly onError: Event<[Error, Message | undefined, number | undefined]>;
+    readonly onClose: Event<void>;
+    write(msg: Message): void;
+    dispose(): void;
+}
+export declare namespace MessageWriter {
+    function is(value: any): value is MessageWriter;
+}
+export declare abstract class AbstractMessageWriter {
+    private errorEmitter;
+    private closeEmitter;
+    constructor();
+    dispose(): void;
+    readonly onError: Event<[Error, Message | undefined, number | undefined]>;
+    protected fireError(error: any, message?: Message, count?: number): void;
+    readonly onClose: Event<void>;
+    protected fireClose(): void;
+    private asError;
+}
+export declare class StreamMessageWriter extends AbstractMessageWriter implements MessageWriter {
+    private writable;
+    private encoding;
+    private errorCount;
+    constructor(writable: NodeJS.WritableStream, encoding?: string);
+    write(msg: Message): void;
+}
+export declare class IPCMessageWriter extends AbstractMessageWriter implements MessageWriter {
+    private process;
+    private queue;
+    private sending;
+    private errorCount;
+    constructor(process: NodeJS.Process | ChildProcess);
+    write(msg: Message): void;
+    doWriteMessage(msg: Message): void;
+}
+export declare class SocketMessageWriter extends AbstractMessageWriter implements MessageWriter {
+    private socket;
+    private queue;
+    private sending;
+    private encoding;
+    private errorCount;
+    constructor(socket: Socket, encoding?: string);
+    write(msg: Message): void;
+    doWriteMessage(msg: Message): void;
+    private handleError;
+}

Client/node_modules/vscode-jsonrpc/lib/messageWriter.js

@@ -0,0 +1,190 @@
+/* --------------------------------------------------------------------------------------------
+ * 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 events_1 = require("./events");
+const Is = require("./is");
+let ContentLength = 'Content-Length: ';
+let CRLF = '\r\n';
+var MessageWriter;
+(function (MessageWriter) {
+    function is(value) {
+        let candidate = value;
+        return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&
+            Is.func(candidate.onError) && Is.func(candidate.write);
+    }
+    MessageWriter.is = is;
+})(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));
+class AbstractMessageWriter {
+    constructor() {
+        this.errorEmitter = new events_1.Emitter();
+        this.closeEmitter = new events_1.Emitter();
+    }
+    dispose() {
+        this.errorEmitter.dispose();
+        this.closeEmitter.dispose();
+    }
+    get onError() {
+        return this.errorEmitter.event;
+    }
+    fireError(error, message, count) {
+        this.errorEmitter.fire([this.asError(error), message, count]);
+    }
+    get onClose() {
+        return this.closeEmitter.event;
+    }
+    fireClose() {
+        this.closeEmitter.fire(undefined);
+    }
+    asError(error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        else {
+            return new Error(`Writer recevied error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
+        }
+    }
+}
+exports.AbstractMessageWriter = AbstractMessageWriter;
+class StreamMessageWriter extends AbstractMessageWriter {
+    constructor(writable, encoding = 'utf8') {
+        super();
+        this.writable = writable;
+        this.encoding = encoding;
+        this.errorCount = 0;
+        this.writable.on('error', (error) => this.fireError(error));
+        this.writable.on('close', () => this.fireClose());
+    }
+    write(msg) {
+        let json = JSON.stringify(msg);
+        let contentLength = Buffer.byteLength(json, this.encoding);
+        let headers = [
+            ContentLength, contentLength.toString(), CRLF,
+            CRLF
+        ];
+        try {
+            // Header must be written in ASCII encoding
+            this.writable.write(headers.join(''), 'ascii');
+            // Now write the content. This can be written in any encoding
+            this.writable.write(json, this.encoding);
+            this.errorCount = 0;
+        }
+        catch (error) {
+            this.errorCount++;
+            this.fireError(error, msg, this.errorCount);
+        }
+    }
+}
+exports.StreamMessageWriter = StreamMessageWriter;
+class IPCMessageWriter extends AbstractMessageWriter {
+    constructor(process) {
+        super();
+        this.process = process;
+        this.errorCount = 0;
+        this.queue = [];
+        this.sending = false;
+        let eventEmitter = this.process;
+        eventEmitter.on('error', (error) => this.fireError(error));
+        eventEmitter.on('close', () => this.fireClose);
+    }
+    write(msg) {
+        if (!this.sending && this.queue.length === 0) {
+            // See https://github.com/nodejs/node/issues/7657
+            this.doWriteMessage(msg);
+        }
+        else {
+            this.queue.push(msg);
+        }
+    }
+    doWriteMessage(msg) {
+        try {
+            if (this.process.send) {
+                this.sending = true;
+                this.process.send(msg, undefined, undefined, (error) => {
+                    this.sending = false;
+                    if (error) {
+                        this.errorCount++;
+                        this.fireError(error, msg, this.errorCount);
+                    }
+                    else {
+                        this.errorCount = 0;
+                    }
+                    if (this.queue.length > 0) {
+                        this.doWriteMessage(this.queue.shift());
+                    }
+                });
+            }
+        }
+        catch (error) {
+            this.errorCount++;
+            this.fireError(error, msg, this.errorCount);
+        }
+    }
+}
+exports.IPCMessageWriter = IPCMessageWriter;
+class SocketMessageWriter extends AbstractMessageWriter {
+    constructor(socket, encoding = 'utf8') {
+        super();
+        this.socket = socket;
+        this.queue = [];
+        this.sending = false;
+        this.encoding = encoding;
+        this.errorCount = 0;
+        this.socket.on('error', (error) => this.fireError(error));
+        this.socket.on('close', () => this.fireClose());
+    }
+    write(msg) {
+        if (!this.sending && this.queue.length === 0) {
+            // See https://github.com/nodejs/node/issues/7657
+            this.doWriteMessage(msg);
+        }
+        else {
+            this.queue.push(msg);
+        }
+    }
+    doWriteMessage(msg) {
+        let json = JSON.stringify(msg);
+        let contentLength = Buffer.byteLength(json, this.encoding);
+        let headers = [
+            ContentLength, contentLength.toString(), CRLF,
+            CRLF
+        ];
+        try {
+            // Header must be written in ASCII encoding
+            this.sending = true;
+            this.socket.write(headers.join(''), 'ascii', (error) => {
+                if (error) {
+                    this.handleError(error, msg);
+                }
+                try {
+                    // Now write the content. This can be written in any encoding
+                    this.socket.write(json, this.encoding, (error) => {
+                        this.sending = false;
+                        if (error) {
+                            this.handleError(error, msg);
+                        }
+                        else {
+                            this.errorCount = 0;
+                        }
+                        if (this.queue.length > 0) {
+                            this.doWriteMessage(this.queue.shift());
+                        }
+                    });
+                }
+                catch (error) {
+                    this.handleError(error, msg);
+                }
+            });
+        }
+        catch (error) {
+            this.handleError(error, msg);
+        }
+    }
+    handleError(error, msg) {
+        this.errorCount++;
+        this.fireError(error, msg, this.errorCount);
+    }
+}
+exports.SocketMessageWriter = SocketMessageWriter;

Client/node_modules/vscode-jsonrpc/lib/messages.d.ts

@@ -0,0 +1,231 @@
+/**
+ * A language server message
+ */
+export interface Message {
+    jsonrpc: string;
+}
+/**
+ * Request message
+ */
+export interface RequestMessage extends Message {
+    /**
+     * The request id.
+     */
+    id: number | string;
+    /**
+     * The method to be invoked.
+     */
+    method: string;
+    /**
+     * The method's params.
+     */
+    params?: any;
+}
+/**
+ * Predefined error codes.
+ */
+export declare namespace ErrorCodes {
+    const ParseError: number;
+    const InvalidRequest: number;
+    const MethodNotFound: number;
+    const InvalidParams: number;
+    const InternalError: number;
+    const serverErrorStart: number;
+    const serverErrorEnd: number;
+    const ServerNotInitialized: number;
+    const UnknownErrorCode: number;
+    const RequestCancelled: number;
+    const MessageWriteError: number;
+    const MessageReadError: number;
+}
+export interface ResponseErrorLiteral<D> {
+    /**
+     * A number indicating the error type that occured.
+     */
+    code: number;
+    /**
+     * A string providing a short decription of the error.
+     */
+    message: string;
+    /**
+     * A Primitive or Structured value that contains additional
+     * information about the error. Can be omitted.
+     */
+    data?: D;
+}
+/**
+ * An error object return in a response in case a request
+ * has failed.
+ */
+export declare class ResponseError<D> extends Error {
+    readonly code: number;
+    readonly data: D | undefined;
+    constructor(code: number, message: string, data?: D);
+    toJson(): ResponseErrorLiteral<D>;
+}
+/**
+ * A response message.
+ */
+export interface ResponseMessage extends Message {
+    /**
+     * The request id.
+     */
+    id: number | string | null;
+    /**
+     * The result of a request. This can be omitted in
+     * the case of an error.
+     */
+    result?: any;
+    /**
+     * The error object in case a request fails.
+     */
+    error?: ResponseErrorLiteral<any>;
+}
+/**
+ * A LSP Log Entry.
+ */
+export declare type LSPMessageType = 'send-request' | 'receive-request' | 'send-response' | 'receive-response' | 'send-notification' | 'receive-notification';
+export interface LSPLogMessage {
+    type: LSPMessageType;
+    message: RequestMessage | ResponseMessage | NotificationMessage;
+    timestamp: number;
+}
+/**
+ * An interface to type messages.
+ */
+export interface MessageType {
+    readonly method: string;
+    readonly numberOfParams: number;
+}
+/**
+ * An abstract implementation of a MessageType.
+ */
+export declare abstract class AbstractMessageType implements MessageType {
+    private _method;
+    private _numberOfParams;
+    constructor(_method: string, _numberOfParams: number);
+    readonly method: string;
+    readonly numberOfParams: number;
+}
+/**
+ * End marker interface for request and notification types.
+ */
+export interface _EM {
+    _$endMarker$_: number;
+}
+/**
+ * Classes to type request response pairs
+ */
+export declare class RequestType0<R, E, RO> extends AbstractMessageType {
+    readonly _?: [R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType<P, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType1<P1, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType2<P1, P2, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType3<P1, P2, P3, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType4<P1, P2, P3, P4, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType5<P1, P2, P3, P4, P5, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType6<P1, P2, P3, P4, P5, P6, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType7<P1, P2, P3, P4, P5, P6, P7, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, P7, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType8<P1, P2, P3, P4, P5, P6, P7, P8, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, P7, P8, R, E, RO, _EM];
+    constructor(method: string);
+}
+export declare class RequestType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, RO, _EM];
+    constructor(method: string);
+}
+/**
+ * Notification Message
+ */
+export interface NotificationMessage extends Message {
+    /**
+     * The method to be invoked.
+     */
+    method: string;
+    /**
+     * The notification's params.
+     */
+    params?: any;
+}
+export declare class NotificationType<P, RO> extends AbstractMessageType {
+    readonly _?: [P, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType0<RO> extends AbstractMessageType {
+    readonly _?: [RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType1<P1, RO> extends AbstractMessageType {
+    readonly _?: [P1, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType2<P1, P2, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType3<P1, P2, P3, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType4<P1, P2, P3, P4, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType5<P1, P2, P3, P4, P5, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType6<P1, P2, P3, P4, P5, P6, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType7<P1, P2, P3, P4, P5, P6, P7, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, P7, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType8<P1, P2, P3, P4, P5, P6, P7, P8, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, P7, P8, RO, _EM];
+    constructor(method: string);
+}
+export declare class NotificationType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, RO> extends AbstractMessageType {
+    readonly _?: [P1, P2, P3, P4, P5, P6, P7, P8, P9, RO, _EM];
+    constructor(method: string);
+}
+/**
+ * Tests if the given message is a request message
+ */
+export declare function isRequestMessage(message: Message | undefined): message is RequestMessage;
+/**
+ * Tests if the given message is a notification message
+ */
+export declare function isNotificationMessage(message: Message | undefined): message is NotificationMessage;
+/**
+ * Tests if the given message is a response message
+ */
+export declare function isResponseMessage(message: Message | undefined): message is ResponseMessage;

Client/node_modules/vscode-jsonrpc/lib/messages.js

@@ -0,0 +1,245 @@
+/* --------------------------------------------------------------------------------------------
+ * 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("./is");
+/**
+ * Predefined error codes.
+ */
+var ErrorCodes;
+(function (ErrorCodes) {
+    // Defined by JSON RPC
+    ErrorCodes.ParseError = -32700;
+    ErrorCodes.InvalidRequest = -32600;
+    ErrorCodes.MethodNotFound = -32601;
+    ErrorCodes.InvalidParams = -32602;
+    ErrorCodes.InternalError = -32603;
+    ErrorCodes.serverErrorStart = -32099;
+    ErrorCodes.serverErrorEnd = -32000;
+    ErrorCodes.ServerNotInitialized = -32002;
+    ErrorCodes.UnknownErrorCode = -32001;
+    // Defined by the protocol.
+    ErrorCodes.RequestCancelled = -32800;
+    // Defined by VSCode library.
+    ErrorCodes.MessageWriteError = 1;
+    ErrorCodes.MessageReadError = 2;
+})(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));
+/**
+ * An error object return in a response in case a request
+ * has failed.
+ */
+class ResponseError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
+        this.data = data;
+        Object.setPrototypeOf(this, ResponseError.prototype);
+    }
+    toJson() {
+        return {
+            code: this.code,
+            message: this.message,
+            data: this.data,
+        };
+    }
+}
+exports.ResponseError = ResponseError;
+/**
+ * An abstract implementation of a MessageType.
+ */
+class AbstractMessageType {
+    constructor(_method, _numberOfParams) {
+        this._method = _method;
+        this._numberOfParams = _numberOfParams;
+    }
+    get method() {
+        return this._method;
+    }
+    get numberOfParams() {
+        return this._numberOfParams;
+    }
+}
+exports.AbstractMessageType = AbstractMessageType;
+/**
+ * Classes to type request response pairs
+ */
+class RequestType0 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 0);
+        this._ = undefined;
+    }
+}
+exports.RequestType0 = RequestType0;
+class RequestType extends AbstractMessageType {
+    constructor(method) {
+        super(method, 1);
+        this._ = undefined;
+    }
+}
+exports.RequestType = RequestType;
+class RequestType1 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 1);
+        this._ = undefined;
+    }
+}
+exports.RequestType1 = RequestType1;
+class RequestType2 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 2);
+        this._ = undefined;
+    }
+}
+exports.RequestType2 = RequestType2;
+class RequestType3 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 3);
+        this._ = undefined;
+    }
+}
+exports.RequestType3 = RequestType3;
+class RequestType4 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 4);
+        this._ = undefined;
+    }
+}
+exports.RequestType4 = RequestType4;
+class RequestType5 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 5);
+        this._ = undefined;
+    }
+}
+exports.RequestType5 = RequestType5;
+class RequestType6 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 6);
+        this._ = undefined;
+    }
+}
+exports.RequestType6 = RequestType6;
+class RequestType7 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 7);
+        this._ = undefined;
+    }
+}
+exports.RequestType7 = RequestType7;
+class RequestType8 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 8);
+        this._ = undefined;
+    }
+}
+exports.RequestType8 = RequestType8;
+class RequestType9 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 9);
+        this._ = undefined;
+    }
+}
+exports.RequestType9 = RequestType9;
+class NotificationType extends AbstractMessageType {
+    constructor(method) {
+        super(method, 1);
+        this._ = undefined;
+    }
+}
+exports.NotificationType = NotificationType;
+class NotificationType0 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 0);
+        this._ = undefined;
+    }
+}
+exports.NotificationType0 = NotificationType0;
+class NotificationType1 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 1);
+        this._ = undefined;
+    }
+}
+exports.NotificationType1 = NotificationType1;
+class NotificationType2 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 2);
+        this._ = undefined;
+    }
+}
+exports.NotificationType2 = NotificationType2;
+class NotificationType3 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 3);
+        this._ = undefined;
+    }
+}
+exports.NotificationType3 = NotificationType3;
+class NotificationType4 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 4);
+        this._ = undefined;
+    }
+}
+exports.NotificationType4 = NotificationType4;
+class NotificationType5 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 5);
+        this._ = undefined;
+    }
+}
+exports.NotificationType5 = NotificationType5;
+class NotificationType6 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 6);
+        this._ = undefined;
+    }
+}
+exports.NotificationType6 = NotificationType6;
+class NotificationType7 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 7);
+        this._ = undefined;
+    }
+}
+exports.NotificationType7 = NotificationType7;
+class NotificationType8 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 8);
+        this._ = undefined;
+    }
+}
+exports.NotificationType8 = NotificationType8;
+class NotificationType9 extends AbstractMessageType {
+    constructor(method) {
+        super(method, 9);
+        this._ = undefined;
+    }
+}
+exports.NotificationType9 = NotificationType9;
+/**
+ * Tests if the given message is a request message
+ */
+function isRequestMessage(message) {
+    let candidate = message;
+    return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
+}
+exports.isRequestMessage = isRequestMessage;
+/**
+ * Tests if the given message is a notification message
+ */
+function isNotificationMessage(message) {
+    let candidate = message;
+    return candidate && is.string(candidate.method) && message.id === void 0;
+}
+exports.isNotificationMessage = isNotificationMessage;
+/**
+ * Tests if the given message is a response message
+ */
+function isResponseMessage(message) {
+    let candidate = message;
+    return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
+}
+exports.isResponseMessage = isResponseMessage;

Client/node_modules/vscode-jsonrpc/lib/pipeSupport.d.ts

@@ -0,0 +1,8 @@
+import { MessageReader } from './messageReader';
+import { MessageWriter } from './messageWriter';
+export declare function generateRandomPipeName(): string;
+export interface PipeTransport {
+    onConnected(): Thenable<[MessageReader, MessageWriter]>;
+}
+export declare function createClientPipeTransport(pipeName: string, encoding?: string): Thenable<PipeTransport>;
+export declare function createServerPipeTransport(pipeName: string, encoding?: string): [MessageReader, MessageWriter];

Client/node_modules/vscode-jsonrpc/lib/pipeSupport.js

@@ -0,0 +1,54 @@
+/* --------------------------------------------------------------------------------------------
+ * 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 path_1 = require("path");
+const os_1 = require("os");
+const crypto_1 = require("crypto");
+const net_1 = require("net");
+const messageReader_1 = require("./messageReader");
+const messageWriter_1 = require("./messageWriter");
+function generateRandomPipeName() {
+    const randomSuffix = crypto_1.randomBytes(21).toString('hex');
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
+    }
+    else {
+        // Mac/Unix: use socket file
+        return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`);
+    }
+}
+exports.generateRandomPipeName = generateRandomPipeName;
+function createClientPipeTransport(pipeName, encoding = 'utf-8') {
+    let connectResolve;
+    let connected = new Promise((resolve, _reject) => {
+        connectResolve = resolve;
+    });
+    return new Promise((resolve, reject) => {
+        let server = net_1.createServer((socket) => {
+            server.close();
+            connectResolve([
+                new messageReader_1.SocketMessageReader(socket, encoding),
+                new messageWriter_1.SocketMessageWriter(socket, encoding)
+            ]);
+        });
+        server.on('error', reject);
+        server.listen(pipeName, () => {
+            server.removeListener('error', reject);
+            resolve({
+                onConnected: () => { return connected; }
+            });
+        });
+    });
+}
+exports.createClientPipeTransport = createClientPipeTransport;
+function createServerPipeTransport(pipeName, encoding = 'utf-8') {
+    const socket = net_1.createConnection(pipeName);
+    return [
+        new messageReader_1.SocketMessageReader(socket, encoding),
+        new messageWriter_1.SocketMessageWriter(socket, encoding)
+    ];
+}
+exports.createServerPipeTransport = createServerPipeTransport;

Client/node_modules/vscode-jsonrpc/lib/socketSupport.d.ts

@@ -0,0 +1,7 @@
+import { MessageReader } from './messageReader';
+import { MessageWriter } from './messageWriter';
+export interface SocketTransport {
+    onConnected(): Thenable<[MessageReader, MessageWriter]>;
+}
+export declare function createClientSocketTransport(port: number, encoding?: string): Thenable<SocketTransport>;
+export declare function createServerSocketTransport(port: number, encoding?: string): [MessageReader, MessageWriter];

Client/node_modules/vscode-jsonrpc/lib/socketSupport.js

@@ -0,0 +1,40 @@
+/* --------------------------------------------------------------------------------------------
+ * 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 net_1 = require("net");
+const messageReader_1 = require("./messageReader");
+const messageWriter_1 = require("./messageWriter");
+function createClientSocketTransport(port, encoding = 'utf-8') {
+    let connectResolve;
+    let connected = new Promise((resolve, _reject) => {
+        connectResolve = resolve;
+    });
+    return new Promise((resolve, reject) => {
+        let server = net_1.createServer((socket) => {
+            server.close();
+            connectResolve([
+                new messageReader_1.SocketMessageReader(socket, encoding),
+                new messageWriter_1.SocketMessageWriter(socket, encoding)
+            ]);
+        });
+        server.on('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            server.removeListener('error', reject);
+            resolve({
+                onConnected: () => { return connected; }
+            });
+        });
+    });
+}
+exports.createClientSocketTransport = createClientSocketTransport;
+function createServerSocketTransport(port, encoding = 'utf-8') {
+    const socket = net_1.createConnection(port, '127.0.0.1');
+    return [
+        new messageReader_1.SocketMessageReader(socket, encoding),
+        new messageWriter_1.SocketMessageWriter(socket, encoding)
+    ];
+}
+exports.createServerSocketTransport = createServerSocketTransport;

Client/node_modules/vscode-jsonrpc/lib/thenable.d.ts

@@ -0,0 +1,2 @@
+interface Thenable<T> extends PromiseLike<T> {
+}

Client/node_modules/vscode-jsonrpc/package.json

@@ -0,0 +1,56 @@
+{
+  "_from": "vscode-jsonrpc@^4.0.0",
+  "_id": "vscode-jsonrpc@4.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-perEnXQdQOJMTDFNv+UF3h1Y0z4iSiaN9jIlb0OqIYgosPCZGYh/MCUlkFtV2668PL69lRDO32hmvL2yiidUYg==",
+  "_location": "/vscode-jsonrpc",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "vscode-jsonrpc@^4.0.0",
+    "name": "vscode-jsonrpc",
+    "escapedName": "vscode-jsonrpc",
+    "rawSpec": "^4.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^4.0.0"
+  },
+  "_requiredBy": [
+    "/vscode-languageserver-protocol"
+  ],
+  "_resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-4.0.0.tgz",
+  "_shasum": "a7bf74ef3254d0a0c272fab15c82128e378b3be9",
+  "_spec": "vscode-jsonrpc@^4.0.0",
+  "_where": "/home/nathan/Projects/Upsilon/UpsilonVsCodeLanguageServer/Client/node_modules/vscode-languageserver-protocol",
+  "author": {
+    "name": "Microsoft Corporation"
+  },
+  "bugs": {
+    "url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A json rpc implementation over streams",
+  "engines": {
+    "node": ">=8.0.0 || >=10.0.0"
+  },
+  "homepage": "https://github.com/Microsoft/vscode-languageserver-node#readme",
+  "license": "MIT",
+  "main": "./lib/main.js",
+  "name": "vscode-jsonrpc",
+  "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.d.ts",
+  "version": "4.0.0"
+}

Client/node_modules/vscode-jsonrpc/thirdpartynotices.txt

@@ -0,0 +1,31 @@
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+For Microsoft vscode-jsonrpc
+
+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.