css-variable-lsp 1.0.0 → 1.0.1

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

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

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

@@ -1,16 +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.Disposable = void 0;
-var Disposable;
-(function (Disposable) {
-    function create(func) {
-        return {
-            dispose: func
-        };
-    }
-    Disposable.create = create;
-})(Disposable || (exports.Disposable = Disposable = {}));

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

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

@@ -1,70 +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.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/client/node_modules/vscode-jsonrpc/lib/common/events.d.ts

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

@@ -1,128 +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.Emitter = exports.Event = void 0;
-const ral_1 = require("./ral");
-var Event;
-(function (Event) {
-    const _disposable = { dispose() { } };
-    Event.None = function () { return _disposable; };
-})(Event || (exports.Event = Event = {}));
-class CallbackList {
-    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) {
-                // eslint-disable-next-line no-console
-                (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 {
-    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;
-Emitter._noop = function () { };

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

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

@@ -1,35 +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.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
-function boolean(value) {
-    return value === true || value === false;
-}
-exports.boolean = boolean;
-function string(value) {
-    return typeof value === 'string' || value instanceof String;
-}
-exports.string = string;
-function number(value) {
-    return typeof value === 'number' || value instanceof Number;
-}
-exports.number = number;
-function error(value) {
-    return value instanceof Error;
-}
-exports.error = error;
-function func(value) {
-    return typeof value === 'function';
-}
-exports.func = func;
-function array(value) {
-    return Array.isArray(value);
-}
-exports.array = array;
-function stringArray(value) {
-    return array(value) && value.every(elem => string(elem));
-}
-exports.stringArray = stringArray;

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

@@ -1,53 +0,0 @@
-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> implements Map<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;
-    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;
-}