@mrclrchtr/supi-code-intelligence 1.11.1 → 1.11.3

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/messageReader.js

@@ -1,197 +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.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
-const ral_1 = require("./ral");
-const Is = require("./is");
-const events_1 = require("./events");
-const semaphore_1 = require("./semaphore");
-var MessageReader;
-(function (MessageReader) {
-    function is(value) {
-        let candidate = value;
-        return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&
-            Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
-    }
-    MessageReader.is = is;
-})(MessageReader || (exports.MessageReader = MessageReader = {}));
-class AbstractMessageReader {
-    constructor() {
-        this.errorEmitter = new events_1.Emitter();
-        this.closeEmitter = new events_1.Emitter();
-        this.partialMessageEmitter = new events_1.Emitter();
-    }
-    dispose() {
-        this.errorEmitter.dispose();
-        this.closeEmitter.dispose();
-    }
-    get onError() {
-        return this.errorEmitter.event;
-    }
-    fireError(error) {
-        this.errorEmitter.fire(this.asError(error));
-    }
-    get onClose() {
-        return this.closeEmitter.event;
-    }
-    fireClose() {
-        this.closeEmitter.fire(undefined);
-    }
-    get onPartialMessage() {
-        return this.partialMessageEmitter.event;
-    }
-    firePartialMessage(info) {
-        this.partialMessageEmitter.fire(info);
-    }
-    asError(error) {
-        if (error instanceof Error) {
-            return error;
-        }
-        else {
-            return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
-        }
-    }
-}
-exports.AbstractMessageReader = AbstractMessageReader;
-var ResolvedMessageReaderOptions;
-(function (ResolvedMessageReaderOptions) {
-    function fromOptions(options) {
-        let charset;
-        let result;
-        let contentDecoder;
-        const contentDecoders = new Map();
-        let contentTypeDecoder;
-        const contentTypeDecoders = new Map();
-        if (options === undefined || typeof options === 'string') {
-            charset = options ?? 'utf-8';
-        }
-        else {
-            charset = options.charset ?? 'utf-8';
-            if (options.contentDecoder !== undefined) {
-                contentDecoder = options.contentDecoder;
-                contentDecoders.set(contentDecoder.name, contentDecoder);
-            }
-            if (options.contentDecoders !== undefined) {
-                for (const decoder of options.contentDecoders) {
-                    contentDecoders.set(decoder.name, decoder);
-                }
-            }
-            if (options.contentTypeDecoder !== undefined) {
-                contentTypeDecoder = options.contentTypeDecoder;
-                contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
-            }
-            if (options.contentTypeDecoders !== undefined) {
-                for (const decoder of options.contentTypeDecoders) {
-                    contentTypeDecoders.set(decoder.name, decoder);
-                }
-            }
-        }
-        if (contentTypeDecoder === undefined) {
-            contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
-            contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
-        }
-        return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
-    }
-    ResolvedMessageReaderOptions.fromOptions = fromOptions;
-})(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
-class ReadableStreamMessageReader extends AbstractMessageReader {
-    constructor(readable, options) {
-        super();
-        this.readable = readable;
-        this.options = ResolvedMessageReaderOptions.fromOptions(options);
-        this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
-        this._partialMessageTimeout = 10000;
-        this.nextMessageLength = -1;
-        this.messageToken = 0;
-        this.readSemaphore = new semaphore_1.Semaphore(1);
-    }
-    set partialMessageTimeout(timeout) {
-        this._partialMessageTimeout = timeout;
-    }
-    get partialMessageTimeout() {
-        return this._partialMessageTimeout;
-    }
-    listen(callback) {
-        this.nextMessageLength = -1;
-        this.messageToken = 0;
-        this.partialMessageTimer = undefined;
-        this.callback = callback;
-        const result = this.readable.onData((data) => {
-            this.onData(data);
-        });
-        this.readable.onError((error) => this.fireError(error));
-        this.readable.onClose(() => this.fireClose());
-        return result;
-    }
-    onData(data) {
-        try {
-            this.buffer.append(data);
-            while (true) {
-                if (this.nextMessageLength === -1) {
-                    const headers = this.buffer.tryReadHeaders(true);
-                    if (!headers) {
-                        return;
-                    }
-                    const contentLength = headers.get('content-length');
-                    if (!contentLength) {
-                        this.fireError(new Error(`Header must provide a Content-Length property.\n${JSON.stringify(Object.fromEntries(headers))}`));
-                        return;
-                    }
-                    const length = parseInt(contentLength);
-                    if (isNaN(length)) {
-                        this.fireError(new Error(`Content-Length value must be a number. Got ${contentLength}`));
-                        return;
-                    }
-                    this.nextMessageLength = length;
-                }
-                const body = this.buffer.tryReadBody(this.nextMessageLength);
-                if (body === undefined) {
-                    /** We haven't received the full message yet. */
-                    this.setPartialMessageTimer();
-                    return;
-                }
-                this.clearPartialMessageTimer();
-                this.nextMessageLength = -1;
-                // Make sure that we convert one received message after the
-                // other. Otherwise it could happen that a decoding of a second
-                // smaller message finished before the decoding of a first larger
-                // message and then we would deliver the second message first.
-                this.readSemaphore.lock(async () => {
-                    const bytes = this.options.contentDecoder !== undefined
-                        ? await this.options.contentDecoder.decode(body)
-                        : body;
-                    const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
-                    this.callback(message);
-                }).catch((error) => {
-                    this.fireError(error);
-                });
-            }
-        }
-        catch (error) {
-            this.fireError(error);
-        }
-    }
-    clearPartialMessageTimer() {
-        if (this.partialMessageTimer) {
-            this.partialMessageTimer.dispose();
-            this.partialMessageTimer = undefined;
-        }
-    }
-    setPartialMessageTimer() {
-        this.clearPartialMessageTimer();
-        if (this._partialMessageTimeout <= 0) {
-            return;
-        }
-        this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
-            this.partialMessageTimer = undefined;
-            if (token === this.messageToken) {
-                this.firePartialMessage({ messageToken: token, waitingTime: timeout });
-                this.setPartialMessageTimer();
-            }
-        }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
-    }
-}
-exports.ReadableStreamMessageReader = ReadableStreamMessageReader;

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

@@ -1,60 +0,0 @@
-import RAL from './ral';
-import { Message } from './messages';
-import { Event } from './events';
-import { ContentEncoder, ContentTypeEncoder } from './encoding';
-/**
- * Writes JSON-RPC messages to an underlying transport.
- */
-export interface MessageWriter {
-    /**
-     * Raised whenever an error occurs while writing a message.
-     */
-    readonly onError: Event<[Error, Message | undefined, number | undefined]>;
-    /**
-     * An event raised when the underlying transport has closed and writing is no longer possible.
-     */
-    readonly onClose: Event<void>;
-    /**
-     * Sends a JSON-RPC message.
-     * @param msg The JSON-RPC message to be sent.
-     * @description Implementations should guarantee messages are transmitted in the same order that they are received by this method.
-     */
-    write(msg: Message): Promise<void>;
-    /**
-     * Call when the connection using this message writer ends
-     * (e.g. MessageConnection.end() is called)
-     */
-    end(): void;
-    /** Releases resources incurred from writing or raising events. Does NOT close the underlying transport, if any. */
-    dispose(): void;
-}
-export declare namespace MessageWriter {
-    function is(value: any): value is MessageWriter;
-}
-export declare abstract class AbstractMessageWriter {
-    private errorEmitter;
-    private closeEmitter;
-    constructor();
-    dispose(): void;
-    get onError(): Event<[Error, Message | undefined, number | undefined]>;
-    protected fireError(error: any, message?: Message, count?: number): void;
-    get onClose(): Event<void>;
-    protected fireClose(): void;
-    private asError;
-}
-export interface MessageWriterOptions {
-    charset?: RAL.MessageBufferEncoding;
-    contentEncoder?: ContentEncoder;
-    contentTypeEncoder?: ContentTypeEncoder;
-}
-export declare class WriteableStreamMessageWriter extends AbstractMessageWriter implements MessageWriter {
-    private writable;
-    private options;
-    private errorCount;
-    private writeSemaphore;
-    constructor(writable: RAL.WritableStream, options?: RAL.MessageBufferEncoding | MessageWriterOptions);
-    write(msg: Message): Promise<void>;
-    private doWrite;
-    private handleError;
-    end(): void;
-}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/common/messageWriter.js

@@ -1,115 +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.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
-const ral_1 = require("./ral");
-const Is = require("./is");
-const semaphore_1 = require("./semaphore");
-const events_1 = require("./events");
-const ContentLength = 'Content-Length: ';
-const CRLF = '\r\n';
-var MessageWriter;
-(function (MessageWriter) {
-    function is(value) {
-        let candidate = value;
-        return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&
-            Is.func(candidate.onError) && Is.func(candidate.write);
-    }
-    MessageWriter.is = is;
-})(MessageWriter || (exports.MessageWriter = MessageWriter = {}));
-class AbstractMessageWriter {
-    constructor() {
-        this.errorEmitter = new events_1.Emitter();
-        this.closeEmitter = new events_1.Emitter();
-    }
-    dispose() {
-        this.errorEmitter.dispose();
-        this.closeEmitter.dispose();
-    }
-    get onError() {
-        return this.errorEmitter.event;
-    }
-    fireError(error, message, count) {
-        this.errorEmitter.fire([this.asError(error), message, count]);
-    }
-    get onClose() {
-        return this.closeEmitter.event;
-    }
-    fireClose() {
-        this.closeEmitter.fire(undefined);
-    }
-    asError(error) {
-        if (error instanceof Error) {
-            return error;
-        }
-        else {
-            return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
-        }
-    }
-}
-exports.AbstractMessageWriter = AbstractMessageWriter;
-var ResolvedMessageWriterOptions;
-(function (ResolvedMessageWriterOptions) {
-    function fromOptions(options) {
-        if (options === undefined || typeof options === 'string') {
-            return { charset: options ?? 'utf-8', contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
-        }
-        else {
-            return { charset: options.charset ?? 'utf-8', contentEncoder: options.contentEncoder, contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
-        }
-    }
-    ResolvedMessageWriterOptions.fromOptions = fromOptions;
-})(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
-class WriteableStreamMessageWriter extends AbstractMessageWriter {
-    constructor(writable, options) {
-        super();
-        this.writable = writable;
-        this.options = ResolvedMessageWriterOptions.fromOptions(options);
-        this.errorCount = 0;
-        this.writeSemaphore = new semaphore_1.Semaphore(1);
-        this.writable.onError((error) => this.fireError(error));
-        this.writable.onClose(() => this.fireClose());
-    }
-    async write(msg) {
-        return this.writeSemaphore.lock(async () => {
-            const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
-                if (this.options.contentEncoder !== undefined) {
-                    return this.options.contentEncoder.encode(buffer);
-                }
-                else {
-                    return buffer;
-                }
-            });
-            return payload.then((buffer) => {
-                const headers = [];
-                headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
-                headers.push(CRLF);
-                return this.doWrite(msg, headers, buffer);
-            }, (error) => {
-                this.fireError(error);
-                throw error;
-            });
-        });
-    }
-    async doWrite(msg, headers, data) {
-        try {
-            await this.writable.write(headers.join(''), 'ascii');
-            return this.writable.write(data);
-        }
-        catch (error) {
-            this.handleError(error, msg);
-            return Promise.reject(error);
-        }
-    }
-    handleError(error, msg) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-    }
-    end() {
-        this.writable.end();
-    }
-}
-exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;