@windrun-huaiin/third-ui 12.1.0 → 13.0.1

package/dist/node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/linkedMap.mjs

@@ -0,0 +1,408 @@
+import { __exports as linkedMap } from '../../../../../../../_virtual/linkedMap.mjs';
+
+var hasRequiredLinkedMap;
+
+function requireLinkedMap () {
+	if (hasRequiredLinkedMap) return linkedMap;
+	hasRequiredLinkedMap = 1;
+	/*---------------------------------------------------------------------------------------------
+	 *  Copyright (c) Microsoft Corporation. All rights reserved.
+	 *  Licensed under the MIT License. See License.txt in the project root for license information.
+	 *--------------------------------------------------------------------------------------------*/
+	var _a;
+	Object.defineProperty(linkedMap, "__esModule", { value: true });
+	linkedMap.LRUCache = linkedMap.LinkedMap = linkedMap.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 || (linkedMap.Touch = Touch = {}));
+	class LinkedMap {
+	    constructor() {
+	        this[_a] = 'LinkedMap';
+	        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;
+	    }
+	    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;
+	    }
+	    [(_a = Symbol.toStringTag, 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);
+	        }
+	    }
+	}
+	linkedMap.LinkedMap = LinkedMap;
+	class LRUCache extends LinkedMap {
+	    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));
+	        }
+	    }
+	}
+	linkedMap.LRUCache = LRUCache;
+	return linkedMap;
+}
+
+export { requireLinkedMap as __require };

package/dist/node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js

@@ -0,0 +1,164 @@
+'use strict';
+
+var messageBuffer = require('../../../../../../../_virtual/messageBuffer.js');
+
+var hasRequiredMessageBuffer;
+
+function requireMessageBuffer () {
+	if (hasRequiredMessageBuffer) return messageBuffer.__exports;
+	hasRequiredMessageBuffer = 1;
+	/*---------------------------------------------------------------------------------------------
+	 *  Copyright (c) Microsoft Corporation. All rights reserved.
+	 *  Licensed under the MIT License. See License.txt in the project root for license information.
+	 *--------------------------------------------------------------------------------------------*/
+	Object.defineProperty(messageBuffer.__exports, "__esModule", { value: true });
+	messageBuffer.__exports.AbstractMessageBuffer = void 0;
+	const CR = 13;
+	const LF = 10;
+	const CRLF = '\r\n';
+	class AbstractMessageBuffer {
+	    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;
+	        let 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;
+	    }
+	}
+	messageBuffer.__exports.AbstractMessageBuffer = AbstractMessageBuffer;
+	return messageBuffer.__exports;
+}
+
+exports.__require = requireMessageBuffer;