typescript 6.0.3 → 7.0.2

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

@@ -0,0 +1,412 @@
+"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.LRUCache = exports.LinkedMap = exports.Touch = void 0;
+var Touch;
+(function (Touch) {
+    Touch.None = 0;
+    Touch.First = 1;
+    Touch.AsOld = Touch.First;
+    Touch.Last = 2;
+    Touch.AsNew = Touch.Last;
+})(Touch || (exports.Touch = Touch = {}));
+class LinkedMap {
+    [Symbol.toStringTag] = 'LinkedMap';
+    _map;
+    _head;
+    _tail;
+    _size;
+    _state;
+    constructor() {
+        this._map = new Map();
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+        this._state = 0;
+    }
+    clear() {
+        this._map.clear();
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+        this._state++;
+    }
+    isEmpty() {
+        return !this._head && !this._tail;
+    }
+    get size() {
+        return this._size;
+    }
+    get first() {
+        return this._head?.value;
+    }
+    get last() {
+        return this._tail?.value;
+    }
+    before(key) {
+        const item = this._map.get(key);
+        return item ? item.previous?.value : undefined;
+    }
+    after(key) {
+        const item = this._map.get(key);
+        return item ? item.next?.value : undefined;
+    }
+    has(key) {
+        return this._map.has(key);
+    }
+    get(key, touch = Touch.None) {
+        const item = this._map.get(key);
+        if (!item) {
+            return undefined;
+        }
+        if (touch !== Touch.None) {
+            this.touch(item, touch);
+        }
+        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++;
+        }
+        return this;
+    }
+    delete(key) {
+        return !!this.remove(key);
+    }
+    remove(key) {
+        const item = this._map.get(key);
+        if (!item) {
+            return undefined;
+        }
+        this._map.delete(key);
+        this.removeItem(item);
+        this._size--;
+        return item.value;
+    }
+    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) {
+        const state = this._state;
+        let current = this._head;
+        while (current) {
+            if (thisArg) {
+                callbackfn.bind(thisArg)(current.value, current.key, this);
+            }
+            else {
+                callbackfn(current.value, current.key, this);
+            }
+            if (this._state !== state) {
+                throw new Error(`LinkedMap got modified during iteration.`);
+            }
+            current = current.next;
+        }
+    }
+    keys() {
+        const state = this._state;
+        let current = this._head;
+        const iterator = {
+            [Symbol.iterator]: () => {
+                return iterator;
+            },
+            next: () => {
+                if (this._state !== state) {
+                    throw new Error(`LinkedMap got modified during iteration.`);
+                }
+                if (current) {
+                    const result = { value: current.key, done: false };
+                    current = current.next;
+                    return result;
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+    values() {
+        const state = this._state;
+        let current = this._head;
+        const iterator = {
+            [Symbol.iterator]: () => {
+                return iterator;
+            },
+            next: () => {
+                if (this._state !== state) {
+                    throw new Error(`LinkedMap got modified during iteration.`);
+                }
+                if (current) {
+                    const result = { value: current.value, done: false };
+                    current = current.next;
+                    return result;
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+    entries() {
+        const state = this._state;
+        let current = this._head;
+        const iterator = {
+            [Symbol.iterator]: () => {
+                return iterator;
+            },
+            next: () => {
+                if (this._state !== state) {
+                    throw new Error(`LinkedMap got modified during iteration.`);
+                }
+                if (current) {
+                    const result = { value: [current.key, current.value], done: false };
+                    current = current.next;
+                    return result;
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    trimOld(newSize) {
+        if (newSize >= this.size) {
+            return;
+        }
+        if (newSize === 0) {
+            this.clear();
+            return;
+        }
+        let current = this._head;
+        let currentSize = this.size;
+        while (current && currentSize > newSize) {
+            this._map.delete(current.key);
+            current = current.next;
+            currentSize--;
+        }
+        this._head = current;
+        this._size = currentSize;
+        if (current) {
+            current.previous = undefined;
+        }
+        this._state++;
+    }
+    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;
+        this._state++;
+    }
+    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;
+        this._state++;
+    }
+    removeItem(item) {
+        if (item === this._head && item === this._tail) {
+            this._head = undefined;
+            this._tail = undefined;
+        }
+        else if (item === this._head) {
+            // This can only happened if size === 1 which is handle
+            // by the case above.
+            if (!item.next) {
+                throw new Error('Invalid list');
+            }
+            item.next.previous = undefined;
+            this._head = item.next;
+        }
+        else if (item === this._tail) {
+            // This can only happened if size === 1 which is handle
+            // by the case above.
+            if (!item.previous) {
+                throw new Error('Invalid list');
+            }
+            item.previous.next = undefined;
+            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;
+        }
+        item.next = undefined;
+        item.previous = undefined;
+        this._state++;
+    }
+    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;
+            this._state++;
+        }
+        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;
+            this._state++;
+        }
+    }
+    toJSON() {
+        const data = [];
+        this.forEach((value, key) => {
+            data.push([key, value]);
+        });
+        return data;
+    }
+    fromJSON(data) {
+        this.clear();
+        for (const [key, value] of data) {
+            this.set(key, value);
+        }
+    }
+}
+exports.LinkedMap = LinkedMap;
+class LRUCache extends LinkedMap {
+    _limit;
+    _ratio;
+    constructor(limit, ratio = 1) {
+        super();
+        this._limit = limit;
+        this._ratio = Math.min(Math.max(0, ratio), 1);
+    }
+    get limit() {
+        return this._limit;
+    }
+    set limit(limit) {
+        this._limit = limit;
+        this.checkTrim();
+    }
+    get ratio() {
+        return this._ratio;
+    }
+    set ratio(ratio) {
+        this._ratio = Math.min(Math.max(0, ratio), 1);
+        this.checkTrim();
+    }
+    get(key, touch = Touch.AsNew) {
+        return super.get(key, touch);
+    }
+    peek(key) {
+        return super.get(key, Touch.None);
+    }
+    set(key, value) {
+        super.set(key, value, Touch.Last);
+        this.checkTrim();
+        return this;
+    }
+    checkTrim() {
+        if (this.size > this._limit) {
+            this.trimOld(Math.round(this._limit * this._ratio));
+        }
+    }
+}
+exports.LRUCache = LRUCache;

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

@@ -0,0 +1,18 @@
+import RAL from './ral';
+export declare abstract class AbstractMessageBuffer implements RAL.MessageBuffer {
+    private _encoding;
+    private _chunks;
+    private _totalLength;
+    constructor(encoding?: RAL.MessageBufferEncoding);
+    protected abstract emptyBuffer(): Uint8Array;
+    protected abstract fromString(value: string, encoding: RAL.MessageBufferEncoding): Uint8Array;
+    protected abstract toString(value: Uint8Array, encoding: RAL.MessageBufferEncoding): string;
+    protected abstract asNative(buffer: Uint8Array, length?: number): Uint8Array;
+    protected abstract allocNative(length: number): Uint8Array;
+    get encoding(): RAL.MessageBufferEncoding;
+    append(chunk: Uint8Array | string): void;
+    tryReadHeaders(lowerCaseKeys?: boolean): Map<string, string> | undefined;
+    tryReadBody(length: number): Uint8Array | undefined;
+    get numberOfBytes(): number;
+    private _read;
+}

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

@@ -0,0 +1,155 @@
+"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.AbstractMessageBuffer = void 0;
+const CR = 13;
+const LF = 10;
+const CRLF = '\r\n';
+class AbstractMessageBuffer {
+    _encoding;
+    _chunks;
+    _totalLength;
+    constructor(encoding = 'utf-8') {
+        this._encoding = encoding;
+        this._chunks = [];
+        this._totalLength = 0;
+    }
+    get encoding() {
+        return this._encoding;
+    }
+    append(chunk) {
+        const toAppend = typeof chunk === 'string' ? this.fromString(chunk, this._encoding) : chunk;
+        this._chunks.push(toAppend);
+        this._totalLength += toAppend.byteLength;
+    }
+    tryReadHeaders(lowerCaseKeys = false) {
+        if (this._chunks.length === 0) {
+            return undefined;
+        }
+        let state = 0;
+        let chunkIndex = 0;
+        let offset = 0;
+        let chunkBytesRead = 0;
+        row: while (chunkIndex < this._chunks.length) {
+            const chunk = this._chunks[chunkIndex];
+            offset = 0;
+            while (offset < chunk.length) {
+                const value = chunk[offset];
+                switch (value) {
+                    case CR:
+                        switch (state) {
+                            case 0:
+                                state = 1;
+                                break;
+                            case 2:
+                                state = 3;
+                                break;
+                            default:
+                                state = 0;
+                        }
+                        break;
+                    case LF:
+                        switch (state) {
+                            case 1:
+                                state = 2;
+                                break;
+                            case 3:
+                                state = 4;
+                                offset++;
+                                break row;
+                            default:
+                                state = 0;
+                        }
+                        break;
+                    default:
+                        state = 0;
+                }
+                offset++;
+            }
+            chunkBytesRead += chunk.byteLength;
+            chunkIndex++;
+        }
+        if (state !== 4) {
+            return undefined;
+        }
+        // The buffer contains the two CRLF at the end. So we will
+        // have two empty lines after the split at the end as well.
+        const buffer = this._read(chunkBytesRead + offset);
+        const result = new Map();
+        const headers = this.toString(buffer, 'ascii').split(CRLF);
+        if (headers.length < 2) {
+            return result;
+        }
+        for (let i = 0; i < headers.length - 2; i++) {
+            const header = headers[i];
+            const index = header.indexOf(':');
+            if (index === -1) {
+                throw new Error(`Message header must separate key and value using ':'\n${header}`);
+            }
+            const key = header.substr(0, index);
+            const value = header.substr(index + 1).trim();
+            result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
+        }
+        return result;
+    }
+    tryReadBody(length) {
+        if (this._totalLength < length) {
+            return undefined;
+        }
+        return this._read(length);
+    }
+    get numberOfBytes() {
+        return this._totalLength;
+    }
+    _read(byteCount) {
+        if (byteCount === 0) {
+            return this.emptyBuffer();
+        }
+        if (byteCount > this._totalLength) {
+            throw new Error(`Cannot read so many bytes!`);
+        }
+        if (this._chunks[0].byteLength === byteCount) {
+            // super fast path, precisely first chunk must be returned
+            const chunk = this._chunks[0];
+            this._chunks.shift();
+            this._totalLength -= byteCount;
+            return this.asNative(chunk);
+        }
+        if (this._chunks[0].byteLength > byteCount) {
+            // fast path, the reading is entirely within the first chunk
+            const chunk = this._chunks[0];
+            const result = this.asNative(chunk, byteCount);
+            this._chunks[0] = chunk.slice(byteCount);
+            this._totalLength -= byteCount;
+            return result;
+        }
+        const result = this.allocNative(byteCount);
+        let resultOffset = 0;
+        const chunkIndex = 0;
+        while (byteCount > 0) {
+            const chunk = this._chunks[chunkIndex];
+            if (chunk.byteLength > byteCount) {
+                // this chunk will survive
+                const chunkPart = chunk.slice(0, byteCount);
+                result.set(chunkPart, resultOffset);
+                resultOffset += byteCount;
+                this._chunks[chunkIndex] = chunk.slice(byteCount);
+                this._totalLength -= byteCount;
+                byteCount -= byteCount;
+            }
+            else {
+                // this chunk will be entirely read
+                result.set(chunk, resultOffset);
+                resultOffset += chunk.byteLength;
+                this._chunks.shift();
+                this._totalLength -= chunk.byteLength;
+                byteCount -= chunk.byteLength;
+            }
+        }
+        return result;
+    }
+}
+exports.AbstractMessageBuffer = AbstractMessageBuffer;

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

@@ -0,0 +1,77 @@
+import RAL from './ral';
+import { Event } from './events';
+import { Message } from './messages';
+import { ContentDecoder, ContentTypeDecoder } from './encoding';
+import { Disposable } from './api';
+/**
+ * A callback that receives each incoming JSON-RPC message.
+ */
+export interface DataCallback {
+    (data: Message): void;
+}
+export interface PartialMessageInfo {
+    readonly messageToken: number;
+    readonly waitingTime: number;
+}
+/** Reads JSON-RPC messages from some underlying transport. */
+export interface MessageReader {
+    /** Raised whenever an error occurs while reading a message. */
+    readonly onError: Event<Error>;
+    /** An event raised when the end of the underlying transport has been reached. */
+    readonly onClose: Event<void>;
+    /**
+     * An event that *may* be raised to inform the owner that only part of a message has been received.
+     * A MessageReader implementation may choose to raise this event after a timeout elapses while waiting for more of a partially received message to be received.
+     */
+    readonly onPartialMessage: Event<PartialMessageInfo>;
+    /**
+     * Begins listening for incoming messages. To be called at most once.
+     * @param callback A callback for receiving decoded messages.
+     */
+    listen(callback: DataCallback): Disposable;
+    /** Releases resources incurred from reading or raising events. Does NOT close the underlying transport, if any. */
+    dispose(): void;
+}
+export declare namespace MessageReader {
+    function is(value: any): value is MessageReader;
+}
+export declare abstract class AbstractMessageReader implements MessageReader {
+    private errorEmitter;
+    private closeEmitter;
+    private partialMessageEmitter;
+    constructor();
+    dispose(): void;
+    get onError(): Event<Error>;
+    protected fireError(error: any): void;
+    get onClose(): Event<void>;
+    protected fireClose(): void;
+    get onPartialMessage(): Event<PartialMessageInfo>;
+    protected firePartialMessage(info: PartialMessageInfo): void;
+    private asError;
+    abstract listen(callback: DataCallback): Disposable;
+}
+export interface MessageReaderOptions {
+    charset?: RAL.MessageBufferEncoding;
+    contentDecoder?: ContentDecoder;
+    contentDecoders?: ContentDecoder[];
+    contentTypeDecoder?: ContentTypeDecoder;
+    contentTypeDecoders?: ContentTypeDecoder[];
+}
+export declare class ReadableStreamMessageReader extends AbstractMessageReader {
+    private readable;
+    private options;
+    private callback;
+    private nextMessageLength;
+    private messageToken;
+    private buffer;
+    private partialMessageTimer;
+    private _partialMessageTimeout;
+    private readSemaphore;
+    constructor(readable: RAL.ReadableStream, options?: RAL.MessageBufferEncoding | MessageReaderOptions);
+    set partialMessageTimeout(timeout: number);
+    get partialMessageTimeout(): number;
+    listen(callback: DataCallback): Disposable;
+    private onData;
+    private clearPartialMessageTimer;
+    private setPartialMessageTimer;
+}