css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,74 +0,0 @@
-import type { Disposable } from './disposable';
-import type { ContentTypeEncoder, ContentTypeDecoder } from './encoding';
-interface _MessageBuffer {
-    readonly encoding: RAL.MessageBufferEncoding;
-    /**
-     * Append data to the message buffer.
-     *
-     * @param chunk the data to append.
-     */
-    append(chunk: Uint8Array | string): void;
-    /**
-     * Tries to read the headers from the buffer
-     *
-     * @param lowerCaseKeys Whether the keys should be stored lower case. Doing
-     * so is recommended since HTTP headers are case insensitive.
-     *
-     * @returns the header properties or undefined in not enough data can be read.
-     */
-    tryReadHeaders(lowerCaseKeys?: boolean): Map<string, string> | undefined;
-    /**
-     * Tries to read the body of the given length.
-     *
-     * @param length the amount of bytes to read.
-     * @returns the data or undefined int less data is available.
-     */
-    tryReadBody(length: number): Uint8Array | undefined;
-}
-type _MessageBufferEncoding = 'ascii' | 'utf-8';
-interface _ReadableStream {
-    onData(listener: (data: Uint8Array) => void): Disposable;
-    onClose(listener: () => void): Disposable;
-    onError(listener: (error: any) => void): Disposable;
-    onEnd(listener: () => void): Disposable;
-}
-interface _WritableStream {
-    onClose(listener: () => void): Disposable;
-    onError(listener: (error: any) => void): Disposable;
-    onEnd(listener: () => void): Disposable;
-    write(data: Uint8Array): Promise<void>;
-    write(data: string, encoding: _MessageBufferEncoding): Promise<void>;
-    end(): void;
-}
-interface _DuplexStream extends _ReadableStream, _WritableStream {
-}
-interface RAL {
-    readonly applicationJson: {
-        readonly encoder: ContentTypeEncoder;
-        readonly decoder: ContentTypeDecoder;
-    };
-    readonly messageBuffer: {
-        create(encoding: RAL.MessageBufferEncoding): RAL.MessageBuffer;
-    };
-    readonly console: {
-        info(message?: any, ...optionalParams: any[]): void;
-        log(message?: any, ...optionalParams: any[]): void;
-        warn(message?: any, ...optionalParams: any[]): void;
-        error(message?: any, ...optionalParams: any[]): void;
-    };
-    readonly timer: {
-        setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): Disposable;
-        setImmediate(callback: (...args: any[]) => void, ...args: any[]): Disposable;
-        setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): Disposable;
-    };
-}
-declare function RAL(): RAL;
-declare namespace RAL {
-    type MessageBuffer = _MessageBuffer;
-    type MessageBufferEncoding = _MessageBufferEncoding;
-    type ReadableStream = _ReadableStream;
-    type WritableStream = _WritableStream;
-    type DuplexStream = _DuplexStream;
-    function install(ral: RAL): void;
-}
-export default RAL;

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

@@ -1,23 +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 });
-let _ral;
-function RAL() {
-    if (_ral === undefined) {
-        throw new Error(`No runtime abstraction layer installed`);
-    }
-    return _ral;
-}
-(function (RAL) {
-    function install(ral) {
-        if (ral === undefined) {
-            throw new Error(`No runtime abstraction layer provided`);
-        }
-        _ral = ral;
-    }
-    RAL.install = install;
-})(RAL || (RAL = {}));
-exports.default = RAL;

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

@@ -1,10 +0,0 @@
-export declare class Semaphore<T = void> {
-    private _capacity;
-    private _active;
-    private _waiting;
-    constructor(capacity?: number);
-    lock(thunk: () => T | PromiseLike<T>): Promise<T>;
-    get active(): number;
-    private runNext;
-    private doRunNext;
-}

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

@@ -1,68 +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.Semaphore = void 0;
-const ral_1 = require("./ral");
-class Semaphore {
-    constructor(capacity = 1) {
-        if (capacity <= 0) {
-            throw new Error('Capacity must be greater than 0');
-        }
-        this._capacity = capacity;
-        this._active = 0;
-        this._waiting = [];
-    }
-    lock(thunk) {
-        return new Promise((resolve, reject) => {
-            this._waiting.push({ thunk, resolve, reject });
-            this.runNext();
-        });
-    }
-    get active() {
-        return this._active;
-    }
-    runNext() {
-        if (this._waiting.length === 0 || this._active === this._capacity) {
-            return;
-        }
-        (0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
-    }
-    doRunNext() {
-        if (this._waiting.length === 0 || this._active === this._capacity) {
-            return;
-        }
-        const next = this._waiting.shift();
-        this._active++;
-        if (this._active > this._capacity) {
-            throw new Error(`To many thunks active`);
-        }
-        try {
-            const result = next.thunk();
-            if (result instanceof Promise) {
-                result.then((value) => {
-                    this._active--;
-                    next.resolve(value);
-                    this.runNext();
-                }, (err) => {
-                    this._active--;
-                    next.reject(err);
-                    this.runNext();
-                });
-            }
-            else {
-                this._active--;
-                next.resolve(result);
-                this.runNext();
-            }
-        }
-        catch (err) {
-            this._active--;
-            next.reject(err);
-            this.runNext();
-        }
-    }
-}
-exports.Semaphore = Semaphore;

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

@@ -1,15 +0,0 @@
-import { RequestMessage } from './messages';
-import { AbstractCancellationTokenSource } from './cancellation';
-import { CancellationId, RequestCancellationReceiverStrategy, CancellationSenderStrategy, MessageConnection } from './connection';
-export declare class SharedArraySenderStrategy implements CancellationSenderStrategy {
-    private readonly buffers;
-    constructor();
-    enableCancellation(request: RequestMessage): void;
-    sendCancellation(_conn: MessageConnection, id: CancellationId): Promise<void>;
-    cleanup(id: CancellationId): void;
-    dispose(): void;
-}
-export declare class SharedArrayReceiverStrategy implements RequestCancellationReceiverStrategy {
-    readonly kind: "request";
-    createCancellationTokenSource(request: RequestMessage): AbstractCancellationTokenSource;
-}

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

@@ -1,76 +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.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
-const cancellation_1 = require("./cancellation");
-var CancellationState;
-(function (CancellationState) {
-    CancellationState.Continue = 0;
-    CancellationState.Cancelled = 1;
-})(CancellationState || (CancellationState = {}));
-class SharedArraySenderStrategy {
-    constructor() {
-        this.buffers = new Map();
-    }
-    enableCancellation(request) {
-        if (request.id === null) {
-            return;
-        }
-        const buffer = new SharedArrayBuffer(4);
-        const data = new Int32Array(buffer, 0, 1);
-        data[0] = CancellationState.Continue;
-        this.buffers.set(request.id, buffer);
-        request.$cancellationData = buffer;
-    }
-    async sendCancellation(_conn, id) {
-        const buffer = this.buffers.get(id);
-        if (buffer === undefined) {
-            return;
-        }
-        const data = new Int32Array(buffer, 0, 1);
-        Atomics.store(data, 0, CancellationState.Cancelled);
-    }
-    cleanup(id) {
-        this.buffers.delete(id);
-    }
-    dispose() {
-        this.buffers.clear();
-    }
-}
-exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
-class SharedArrayBufferCancellationToken {
-    constructor(buffer) {
-        this.data = new Int32Array(buffer, 0, 1);
-    }
-    get isCancellationRequested() {
-        return Atomics.load(this.data, 0) === CancellationState.Cancelled;
-    }
-    get onCancellationRequested() {
-        throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
-    }
-}
-class SharedArrayBufferCancellationTokenSource {
-    constructor(buffer) {
-        this.token = new SharedArrayBufferCancellationToken(buffer);
-    }
-    cancel() {
-    }
-    dispose() {
-    }
-}
-class SharedArrayReceiverStrategy {
-    constructor() {
-        this.kind = 'request';
-    }
-    createCancellationTokenSource(request) {
-        const buffer = request.$cancellationData;
-        if (buffer === undefined) {
-            return new cancellation_1.CancellationTokenSource();
-        }
-        return new SharedArrayBufferCancellationTokenSource(buffer);
-    }
-}
-exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;

package/client/node_modules/vscode-jsonrpc/lib/node/main.d.ts

@@ -1,63 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { ChildProcess } from 'child_process';
-import { Socket } from 'net';
-import { MessagePort, Worker } from 'worker_threads';
-import { RAL, AbstractMessageReader, DataCallback, AbstractMessageWriter, Message, ReadableStreamMessageReader, WriteableStreamMessageWriter, MessageWriterOptions, MessageReaderOptions, MessageReader, MessageWriter, ConnectionStrategy, ConnectionOptions, MessageConnection, Logger, Disposable } from '../common/api';
-export * from '../common/api';
-export declare class IPCMessageReader extends AbstractMessageReader {
-    private process;
-    constructor(process: NodeJS.Process | ChildProcess);
-    listen(callback: DataCallback): Disposable;
-}
-export declare class IPCMessageWriter extends AbstractMessageWriter implements MessageWriter {
-    private readonly process;
-    private errorCount;
-    constructor(process: NodeJS.Process | ChildProcess);
-    write(msg: Message): Promise<void>;
-    private handleError;
-    end(): void;
-}
-export declare class PortMessageReader extends AbstractMessageReader implements MessageReader {
-    private onData;
-    constructor(port: MessagePort | Worker);
-    listen(callback: DataCallback): Disposable;
-}
-export declare class PortMessageWriter extends AbstractMessageWriter implements MessageWriter {
-    private readonly port;
-    private errorCount;
-    constructor(port: MessagePort | Worker);
-    write(msg: Message): Promise<void>;
-    private handleError;
-    end(): void;
-}
-export declare class SocketMessageReader extends ReadableStreamMessageReader {
-    constructor(socket: Socket, encoding?: RAL.MessageBufferEncoding);
-}
-export declare class SocketMessageWriter extends WriteableStreamMessageWriter {
-    private socket;
-    constructor(socket: Socket, options?: RAL.MessageBufferEncoding | MessageWriterOptions);
-    dispose(): void;
-}
-export declare class StreamMessageReader extends ReadableStreamMessageReader {
-    constructor(readable: NodeJS.ReadableStream, encoding?: RAL.MessageBufferEncoding | MessageReaderOptions);
-}
-export declare class StreamMessageWriter extends WriteableStreamMessageWriter {
-    constructor(writable: NodeJS.WritableStream, options?: RAL.MessageBufferEncoding | MessageWriterOptions);
-}
-export declare function generateRandomPipeName(): string;
-export interface PipeTransport {
-    onConnected(): Promise<[MessageReader, MessageWriter]>;
-}
-export declare function createClientPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): Promise<PipeTransport>;
-export declare function createServerPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];
-export interface SocketTransport {
-    onConnected(): Promise<[MessageReader, MessageWriter]>;
-}
-export declare function createClientSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): Promise<SocketTransport>;
-export declare function createServerSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];
-export declare function createMessageConnection(reader: MessageReader, writer: MessageWriter, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): MessageConnection;
-export declare function createMessageConnection(inputStream: NodeJS.ReadableStream, outputStream: NodeJS.WritableStream, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): MessageConnection;

package/client/node_modules/vscode-jsonrpc/lib/node/main.js

@@ -1,257 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMessageConnection = exports.createServerSocketTransport = exports.createClientSocketTransport = exports.createServerPipeTransport = exports.createClientPipeTransport = exports.generateRandomPipeName = exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.PortMessageWriter = exports.PortMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = void 0;
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ----------------------------------------------------------------------------------------- */
-const ril_1 = require("./ril");
-// Install the node runtime abstract.
-ril_1.default.install();
-const path = require("path");
-const os = require("os");
-const crypto_1 = require("crypto");
-const net_1 = require("net");
-const api_1 = require("../common/api");
-__exportStar(require("../common/api"), exports);
-class IPCMessageReader extends api_1.AbstractMessageReader {
-    constructor(process) {
-        super();
-        this.process = process;
-        let eventEmitter = this.process;
-        eventEmitter.on('error', (error) => this.fireError(error));
-        eventEmitter.on('close', () => this.fireClose());
-    }
-    listen(callback) {
-        this.process.on('message', callback);
-        return api_1.Disposable.create(() => this.process.off('message', callback));
-    }
-}
-exports.IPCMessageReader = IPCMessageReader;
-class IPCMessageWriter extends api_1.AbstractMessageWriter {
-    constructor(process) {
-        super();
-        this.process = process;
-        this.errorCount = 0;
-        const eventEmitter = this.process;
-        eventEmitter.on('error', (error) => this.fireError(error));
-        eventEmitter.on('close', () => this.fireClose);
-    }
-    write(msg) {
-        try {
-            if (typeof this.process.send === 'function') {
-                this.process.send(msg, undefined, undefined, (error) => {
-                    if (error) {
-                        this.errorCount++;
-                        this.handleError(error, msg);
-                    }
-                    else {
-                        this.errorCount = 0;
-                    }
-                });
-            }
-            return Promise.resolve();
-        }
-        catch (error) {
-            this.handleError(error, msg);
-            return Promise.reject(error);
-        }
-    }
-    handleError(error, msg) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-    }
-    end() {
-    }
-}
-exports.IPCMessageWriter = IPCMessageWriter;
-class PortMessageReader extends api_1.AbstractMessageReader {
-    constructor(port) {
-        super();
-        this.onData = new api_1.Emitter;
-        port.on('close', () => this.fireClose);
-        port.on('error', (error) => this.fireError(error));
-        port.on('message', (message) => {
-            this.onData.fire(message);
-        });
-    }
-    listen(callback) {
-        return this.onData.event(callback);
-    }
-}
-exports.PortMessageReader = PortMessageReader;
-class PortMessageWriter extends api_1.AbstractMessageWriter {
-    constructor(port) {
-        super();
-        this.port = port;
-        this.errorCount = 0;
-        port.on('close', () => this.fireClose());
-        port.on('error', (error) => this.fireError(error));
-    }
-    write(msg) {
-        try {
-            this.port.postMessage(msg);
-            return Promise.resolve();
-        }
-        catch (error) {
-            this.handleError(error, msg);
-            return Promise.reject(error);
-        }
-    }
-    handleError(error, msg) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-    }
-    end() {
-    }
-}
-exports.PortMessageWriter = PortMessageWriter;
-class SocketMessageReader extends api_1.ReadableStreamMessageReader {
-    constructor(socket, encoding = 'utf-8') {
-        super((0, ril_1.default)().stream.asReadableStream(socket), encoding);
-    }
-}
-exports.SocketMessageReader = SocketMessageReader;
-class SocketMessageWriter extends api_1.WriteableStreamMessageWriter {
-    constructor(socket, options) {
-        super((0, ril_1.default)().stream.asWritableStream(socket), options);
-        this.socket = socket;
-    }
-    dispose() {
-        super.dispose();
-        this.socket.destroy();
-    }
-}
-exports.SocketMessageWriter = SocketMessageWriter;
-class StreamMessageReader extends api_1.ReadableStreamMessageReader {
-    constructor(readable, encoding) {
-        super((0, ril_1.default)().stream.asReadableStream(readable), encoding);
-    }
-}
-exports.StreamMessageReader = StreamMessageReader;
-class StreamMessageWriter extends api_1.WriteableStreamMessageWriter {
-    constructor(writable, options) {
-        super((0, ril_1.default)().stream.asWritableStream(writable), options);
-    }
-}
-exports.StreamMessageWriter = StreamMessageWriter;
-const XDG_RUNTIME_DIR = process.env['XDG_RUNTIME_DIR'];
-const safeIpcPathLengths = new Map([
-    ['linux', 107],
-    ['darwin', 103]
-]);
-function generateRandomPipeName() {
-    const randomSuffix = (0, crypto_1.randomBytes)(21).toString('hex');
-    if (process.platform === 'win32') {
-        return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
-    }
-    let result;
-    if (XDG_RUNTIME_DIR) {
-        result = path.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
-    }
-    else {
-        result = path.join(os.tmpdir(), `vscode-${randomSuffix}.sock`);
-    }
-    const limit = safeIpcPathLengths.get(process.platform);
-    if (limit !== undefined && result.length > limit) {
-        (0, ril_1.default)().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
-    }
-    return result;
-}
-exports.generateRandomPipeName = generateRandomPipeName;
-function createClientPipeTransport(pipeName, encoding = 'utf-8') {
-    let connectResolve;
-    const connected = new Promise((resolve, _reject) => {
-        connectResolve = resolve;
-    });
-    return new Promise((resolve, reject) => {
-        let server = (0, net_1.createServer)((socket) => {
-            server.close();
-            connectResolve([
-                new SocketMessageReader(socket, encoding),
-                new SocketMessageWriter(socket, encoding)
-            ]);
-        });
-        server.on('error', reject);
-        server.listen(pipeName, () => {
-            server.removeListener('error', reject);
-            resolve({
-                onConnected: () => { return connected; }
-            });
-        });
-    });
-}
-exports.createClientPipeTransport = createClientPipeTransport;
-function createServerPipeTransport(pipeName, encoding = 'utf-8') {
-    const socket = (0, net_1.createConnection)(pipeName);
-    return [
-        new SocketMessageReader(socket, encoding),
-        new SocketMessageWriter(socket, encoding)
-    ];
-}
-exports.createServerPipeTransport = createServerPipeTransport;
-function createClientSocketTransport(port, encoding = 'utf-8') {
-    let connectResolve;
-    const connected = new Promise((resolve, _reject) => {
-        connectResolve = resolve;
-    });
-    return new Promise((resolve, reject) => {
-        const server = (0, net_1.createServer)((socket) => {
-            server.close();
-            connectResolve([
-                new SocketMessageReader(socket, encoding),
-                new SocketMessageWriter(socket, encoding)
-            ]);
-        });
-        server.on('error', reject);
-        server.listen(port, '127.0.0.1', () => {
-            server.removeListener('error', reject);
-            resolve({
-                onConnected: () => { return connected; }
-            });
-        });
-    });
-}
-exports.createClientSocketTransport = createClientSocketTransport;
-function createServerSocketTransport(port, encoding = 'utf-8') {
-    const socket = (0, net_1.createConnection)(port, '127.0.0.1');
-    return [
-        new SocketMessageReader(socket, encoding),
-        new SocketMessageWriter(socket, encoding)
-    ];
-}
-exports.createServerSocketTransport = createServerSocketTransport;
-function isReadableStream(value) {
-    const candidate = value;
-    return candidate.read !== undefined && candidate.addListener !== undefined;
-}
-function isWritableStream(value) {
-    const candidate = value;
-    return candidate.write !== undefined && candidate.addListener !== undefined;
-}
-function createMessageConnection(input, output, logger, options) {
-    if (!logger) {
-        logger = api_1.NullLogger;
-    }
-    const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
-    const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
-    if (api_1.ConnectionStrategy.is(options)) {
-        options = { connectionStrategy: options };
-    }
-    return (0, api_1.createMessageConnection)(reader, writer, logger, options);
-}
-exports.createMessageConnection = createMessageConnection;

package/client/node_modules/vscode-jsonrpc/lib/node/ril.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import { RAL } from '../common/api';
-interface RIL extends RAL {
-    readonly stream: {
-        readonly asReadableStream: (stream: NodeJS.ReadableStream) => RAL.ReadableStream;
-        readonly asWritableStream: (stream: NodeJS.WritableStream) => RAL.WritableStream;
-    };
-}
-declare function RIL(): RIL;
-declare namespace RIL {
-    function install(): void;
-}
-export default RIL;