@tsc-rs/typescript 0.0.0-placeholder → 0.8.0

package/vendor/vscode-jsonrpc/lib/common/disposable.d.ts

@@ -0,0 +1,9 @@
+export interface Disposable {
+    /**
+     * Dispose this object.
+     */
+    dispose(): void;
+}
+export declare namespace Disposable {
+    function create(func: () => void): Disposable;
+}

package/vendor/vscode-jsonrpc/lib/common/disposable.js

@@ -0,0 +1,16 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Disposable = void 0;
+var Disposable;
+(function (Disposable) {
+    function create(func) {
+        return {
+            dispose: func
+        };
+    }
+    Disposable.create = create;
+})(Disposable || (exports.Disposable = Disposable = {}));

package/vendor/vscode-jsonrpc/lib/common/encoding.d.ts

@@ -0,0 +1,52 @@
+import type RAL from './ral';
+import { Message } from './messages';
+export interface FunctionContentEncoder {
+    name: string;
+    encode(input: Uint8Array): Promise<Uint8Array>;
+}
+export interface StreamContentEncoder {
+    name: string;
+    create(): RAL.WritableStream;
+}
+export type ContentEncoder = FunctionContentEncoder | (FunctionContentEncoder & StreamContentEncoder);
+export interface FunctionContentDecoder {
+    name: string;
+    decode(buffer: Uint8Array): Promise<Uint8Array>;
+}
+export interface StreamContentDecoder {
+    name: string;
+    create(): RAL.WritableStream;
+}
+export type ContentDecoder = FunctionContentDecoder | (FunctionContentDecoder & StreamContentDecoder);
+export interface ContentTypeEncoderOptions {
+    charset: RAL.MessageBufferEncoding;
+}
+export interface FunctionContentTypeEncoder {
+    name: string;
+    encode(msg: Message, options: ContentTypeEncoderOptions): Promise<Uint8Array>;
+}
+export interface StreamContentTypeEncoder {
+    name: string;
+    create(options: ContentTypeEncoderOptions): RAL.WritableStream;
+}
+export type ContentTypeEncoder = FunctionContentTypeEncoder | (FunctionContentTypeEncoder & StreamContentTypeEncoder);
+export interface ContentTypeDecoderOptions {
+    charset: RAL.MessageBufferEncoding;
+}
+export interface FunctionContentTypeDecoder {
+    name: string;
+    decode(buffer: Uint8Array, options: ContentTypeDecoderOptions): Promise<Message>;
+}
+export interface StreamContentTypeDecoder {
+    name: string;
+    create(options: ContentTypeDecoderOptions): RAL.WritableStream;
+}
+export type ContentTypeDecoder = FunctionContentTypeDecoder | (FunctionContentTypeDecoder & StreamContentTypeDecoder);
+interface Named {
+    name: string;
+}
+export declare namespace Encodings {
+    function getEncodingHeaderValue(encodings: Named[]): string | undefined;
+    function parseEncodingHeaderValue(value: string): string[];
+}
+export {};

package/vendor/vscode-jsonrpc/lib/common/encoding.js

@@ -0,0 +1,70 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encodings = void 0;
+var Encodings;
+(function (Encodings) {
+    function getEncodingHeaderValue(encodings) {
+        if (encodings.length === 1) {
+            return encodings[0].name;
+        }
+        const distribute = encodings.length - 1;
+        if (distribute > 1000) {
+            throw new Error(`Quality value can only have three decimal digits but trying to distribute ${encodings.length} elements.`);
+        }
+        const digits = Math.ceil(Math.log10(distribute));
+        const factor = Math.pow(10, digits);
+        const diff = Math.floor((1 / distribute) * factor) / factor;
+        const result = [];
+        let q = 1;
+        for (const encoding of encodings) {
+            result.push(`${encoding.name};q=${q === 1 || q === 0 ? q.toFixed(0) : q.toFixed(digits)}`);
+            q = q - diff;
+        }
+        return result.join(', ');
+    }
+    Encodings.getEncodingHeaderValue = getEncodingHeaderValue;
+    function parseEncodingHeaderValue(value) {
+        const map = new Map();
+        const encodings = value.split(/\s*,\s*/);
+        for (const value of encodings) {
+            const [encoding, q] = parseEncoding(value);
+            if (encoding === '*') {
+                continue;
+            }
+            let values = map.get(q);
+            if (values === undefined) {
+                values = [];
+                map.set(q, values);
+            }
+            values.push(encoding);
+        }
+        const keys = Array.from(map.keys());
+        keys.sort((a, b) => b - a);
+        const result = [];
+        for (const key of keys) {
+            result.push(...map.get(key));
+        }
+        return result;
+    }
+    Encodings.parseEncodingHeaderValue = parseEncodingHeaderValue;
+    function parseEncoding(value) {
+        let q = 1;
+        let encoding;
+        const index = value.indexOf(';q=');
+        if (index !== -1) {
+            const parsed = parseFloat(value.substr(index));
+            if (!Number.isNaN(parsed)) {
+                q = parsed;
+            }
+            encoding = value.substr(0, index);
+        }
+        else {
+            encoding = value;
+        }
+        return [encoding, q];
+    }
+})(Encodings || (exports.Encodings = Encodings = {}));

package/vendor/vscode-jsonrpc/lib/common/events.d.ts

@@ -0,0 +1,39 @@
+import { Disposable } from './disposable';
+/**
+ * Represents a typed event.
+ */
+export interface Event<T> {
+    /**
+     *
+     * @param listener The listener function will be called 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.
+     * @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
+     */
+    get event(): Event<T>;
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event: T): any;
+    dispose(): void;
+}

package/vendor/vscode-jsonrpc/lib/common/events.js

@@ -0,0 +1,135 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = exports.Event = void 0;
+const ral_1 = __importDefault(require("./ral"));
+var Event;
+(function (Event) {
+    const _disposable = { dispose() { } };
+    Event.None = function () { return _disposable; };
+})(Event || (exports.Event = Event = {}));
+class CallbackList {
+    _callbacks;
+    _contexts;
+    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;
+        }
+        let foundCallbackWithDifferentContext = false;
+        for (let 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 [];
+        }
+        const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+        for (let i = 0, len = callbacks.length; i < len; i++) {
+            try {
+                ret.push(callbacks[i].apply(contexts[i], args));
+            }
+            catch (e) {
+                (0, ral_1.default)().console.error(e);
+            }
+        }
+        return ret;
+    }
+    isEmpty() {
+        return !this._callbacks || this._callbacks.length === 0;
+    }
+    dispose() {
+        this._callbacks = undefined;
+        this._contexts = undefined;
+    }
+}
+class Emitter {
+    _options;
+    static _noop = function () { };
+    _event;
+    _callbacks;
+    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);
+                const result = {
+                    dispose: () => {
+                        if (!this._callbacks) {
+                            // disposable is disposed after emitter is disposed.
+                            return;
+                        }
+                        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;
+        }
+    }
+}
+exports.Emitter = Emitter;

package/vendor/vscode-jsonrpc/lib/common/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[];

package/vendor/vscode-jsonrpc/lib/common/is.js

@@ -0,0 +1,34 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = boolean;
+exports.string = string;
+exports.number = number;
+exports.error = error;
+exports.func = func;
+exports.array = array;
+exports.stringArray = stringArray;
+function boolean(value) {
+    return value === true || value === false;
+}
+function string(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+function number(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+function error(value) {
+    return value instanceof Error;
+}
+function func(value) {
+    return typeof value === 'function';
+}
+function array(value) {
+    return Array.isArray(value);
+}
+function stringArray(value) {
+    return array(value) && value.every(elem => string(elem));
+}

package/vendor/vscode-jsonrpc/lib/common/linkedMap.d.ts

@@ -0,0 +1,55 @@
+export declare namespace Touch {
+    const None: 0;
+    const First: 1;
+    const AsOld: 1;
+    const Last: 2;
+    const AsNew: 2;
+}
+export type Touch = 0 | 1 | 2;
+export declare class LinkedMap<K, V> {
+    readonly [Symbol.toStringTag] = "LinkedMap";
+    private _map;
+    private _head;
+    private _tail;
+    private _size;
+    private _state;
+    constructor();
+    clear(): void;
+    isEmpty(): boolean;
+    get size(): number;
+    get first(): V | undefined;
+    get last(): V | undefined;
+    before(key: K): V | undefined;
+    after(key: K): V | undefined;
+    has(key: K): boolean;
+    get(key: K, touch?: Touch): V | undefined;
+    set(key: K, value: V, touch?: Touch): this;
+    delete(key: K): boolean;
+    remove(key: K): V | undefined;
+    shift(): V | undefined;
+    forEach(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    protected trimOld(newSize: number): void;
+    private addItemFirst;
+    private addItemLast;
+    private removeItem;
+    private touch;
+    toJSON(): [K, V][];
+    fromJSON(data: [K, V][]): void;
+}
+export declare class LRUCache<K, V> extends LinkedMap<K, V> {
+    private _limit;
+    private _ratio;
+    constructor(limit: number, ratio?: number);
+    get limit(): number;
+    set limit(limit: number);
+    get ratio(): number;
+    set ratio(ratio: number);
+    get(key: K, touch?: Touch): V | undefined;
+    peek(key: K): V | undefined;
+    set(key: K, value: V): this;
+    private checkTrim;
+}