css-variable-lsp 1.0.0 → 1.0.1

package/client/node_modules/vscode-jsonrpc/lib/common/linkedMap.js

@@ -1,398 +0,0 @@
-"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 _a;
-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 {
-    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);
-        }
-    }
-}
-exports.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));
-        }
-    }
-}
-exports.LRUCache = LRUCache;

package/client/node_modules/vscode-jsonrpc/lib/common/messageBuffer.d.ts

@@ -1,18 +0,0 @@
-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/client/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js

@@ -1,152 +0,0 @@
-"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 {
-    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;
-            column: 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;
-    }
-}
-exports.AbstractMessageBuffer = AbstractMessageBuffer;

package/client/node_modules/vscode-jsonrpc/lib/common/messageReader.d.ts

@@ -1,77 +0,0 @@
-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;
-}