Initial

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> {
+}