@mrclrchtr/supi-code-intelligence 1.7.0 → 1.8.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/ral.d.ts

@@ -0,0 +1,74 @@
+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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/ral.js

@@ -0,0 +1,23 @@
+"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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/semaphore.d.ts

@@ -0,0 +1,10 @@
+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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/semaphore.js

@@ -0,0 +1,68 @@
+"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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.d.ts

@@ -0,0 +1,15 @@
+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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js

@@ -0,0 +1,76 @@
+"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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/node/main.d.ts

@@ -0,0 +1,63 @@
+/// <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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/node/main.js

@@ -0,0 +1,257 @@
+"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/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/node/ril.d.ts

@@ -0,0 +1,13 @@
+/// <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;