@windrun-huaiin/third-ui 13.1.4 → 13.1.5

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

@@ -1,408 +0,0 @@
-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

@@ -1,164 +0,0 @@
-'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;