@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

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

@@ -0,0 +1,369 @@
+/**
+ * A language server message
+ */
+export interface Message {
+    jsonrpc: string;
+}
+/**
+ * Request message
+ */
+export interface RequestMessage extends Message {
+    /**
+     * The request id.
+     */
+    id: number | string | null;
+    /**
+     * The method to be invoked.
+     */
+    method: string;
+    /**
+     * The method's params.
+     */
+    params?: any[] | object;
+}
+/**
+ * Predefined error codes.
+ */
+export declare namespace ErrorCodes {
+    const ParseError: -32700;
+    const InvalidRequest: -32600;
+    const MethodNotFound: -32601;
+    const InvalidParams: -32602;
+    const InternalError: -32603;
+    /**
+     * This is the start range of JSON RPC reserved error codes.
+     * It doesn't denote a real error code. No application error codes should
+     * be defined between the start and end range. For backwards
+     * compatibility the `ServerNotInitialized` and the `UnknownErrorCode`
+     * are left in the range.
+     *
+     * @since 3.16.0
+    */
+    const jsonrpcReservedErrorRangeStart: -32099;
+    /** @deprecated use  jsonrpcReservedErrorRangeStart */
+    const serverErrorStart: -32099;
+    /**
+     * An error occurred when write a message to the transport layer.
+     */
+    const MessageWriteError: -32099;
+    /**
+     * An error occurred when reading a message from the transport layer.
+     */
+    const MessageReadError: -32098;
+    /**
+     * The connection got disposed or lost and all pending responses got
+     * rejected.
+     */
+    const PendingResponseRejected: -32097;
+    /**
+     * The connection is inactive and a use of it failed.
+     */
+    const ConnectionInactive: -32096;
+    /**
+     * Error code indicating that a server received a notification or
+     * request before the server has received the `initialize` request.
+     */
+    const ServerNotInitialized: -32002;
+    const UnknownErrorCode: -32001;
+    /**
+     * This is the end range of JSON RPC reserved error codes.
+     * It doesn't denote a real error code.
+     *
+     * @since 3.16.0
+    */
+    const jsonrpcReservedErrorRangeEnd: -32000;
+    /** @deprecated use  jsonrpcReservedErrorRangeEnd */
+    const serverErrorEnd: -32000;
+}
+type integer = number;
+export type ErrorCodes = integer;
+export interface ResponseErrorLiteral<D = void> {
+    /**
+     * A number indicating the error type that occurred.
+     */
+    code: number;
+    /**
+     * A string providing a short description of the error.
+     */
+    message: string;
+    /**
+     * A Primitive or Structured value that contains additional
+     * information about the error. Can be omitted.
+     */
+    data?: D;
+}
+/**
+ * An error object return in a response in case a request
+ * has failed.
+ */
+export declare class ResponseError<D = void> extends Error {
+    readonly code: number;
+    readonly data: D | undefined;
+    constructor(code: number, message: string, data?: D);
+    toJson(): ResponseErrorLiteral<D>;
+}
+/**
+ * A response message.
+ */
+export interface ResponseMessage extends Message {
+    /**
+     * The request id.
+     */
+    id: number | string | null;
+    /**
+     * The result of a request. This member is REQUIRED on success.
+     * This member MUST NOT exist if there was an error invoking the method.
+     */
+    result?: string | number | boolean | object | any[] | null;
+    /**
+     * The error object in case a request fails.
+     */
+    error?: ResponseErrorLiteral<any>;
+}
+/**
+ * A LSP Log Entry.
+ */
+export type LSPMessageType = 'send-request' | 'receive-request' | 'send-response' | 'receive-response' | 'send-notification' | 'receive-notification';
+export interface LSPLogMessage {
+    type: LSPMessageType;
+    message: RequestMessage | ResponseMessage | NotificationMessage;
+    timestamp: number;
+}
+export declare class ParameterStructures {
+    private readonly kind;
+    /**
+     * The parameter structure is automatically inferred on the number of parameters
+     * and the parameter type in case of a single param.
+     */
+    static readonly auto: ParameterStructures;
+    /**
+     * Forces `byPosition` parameter structure. This is useful if you have a single
+     * parameter which has a literal type.
+     */
+    static readonly byPosition: ParameterStructures;
+    /**
+     * Forces `byName` parameter structure. This is only useful when having a single
+     * parameter. The library will report errors if used with a different number of
+     * parameters.
+     */
+    static readonly byName: ParameterStructures;
+    private constructor();
+    static is(value: any): value is ParameterStructures;
+    toString(): string;
+}
+/**
+ * An interface to type messages.
+ */
+export interface MessageSignature {
+    readonly method: string;
+    readonly numberOfParams: number;
+    readonly parameterStructures: ParameterStructures;
+}
+/**
+ * An abstract implementation of a MessageType.
+ */
+export declare abstract class AbstractMessageSignature implements MessageSignature {
+    readonly method: string;
+    readonly numberOfParams: number;
+    constructor(method: string, numberOfParams: number);
+    get parameterStructures(): ParameterStructures;
+}
+/**
+ * End marker interface for request and notification types.
+ */
+export interface _EM {
+    _$endMarker$_: number;
+}
+/**
+ * Classes to type request response pairs
+ */
+export declare class RequestType0<R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType<P, R, E> extends AbstractMessageSignature {
+    private _parameterStructures;
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P, R, E, _EM] | undefined;
+    constructor(method: string, _parameterStructures?: ParameterStructures);
+    get parameterStructures(): ParameterStructures;
+}
+export declare class RequestType1<P1, R, E> extends AbstractMessageSignature {
+    private _parameterStructures;
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, R, E, _EM] | undefined;
+    constructor(method: string, _parameterStructures?: ParameterStructures);
+    get parameterStructures(): ParameterStructures;
+}
+export declare class RequestType2<P1, P2, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType3<P1, P2, P3, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType4<P1, P2, P3, P4, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType5<P1, P2, P3, P4, P5, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType6<P1, P2, P3, P4, P5, P6, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType7<P1, P2, P3, P4, P5, P6, P7, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, P7, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType8<P1, P2, P3, P4, P5, P6, P7, P8, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, P7, P8, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class RequestType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E, _EM] | undefined;
+    constructor(method: string);
+}
+/**
+ * Notification Message
+ */
+export interface NotificationMessage extends Message {
+    /**
+     * The method to be invoked.
+     */
+    method: string;
+    /**
+     * The notification's params.
+     */
+    params?: any[] | object;
+}
+export declare class NotificationType<P> extends AbstractMessageSignature {
+    private _parameterStructures;
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P, _EM] | undefined;
+    constructor(method: string, _parameterStructures?: ParameterStructures);
+    get parameterStructures(): ParameterStructures;
+}
+export declare class NotificationType0 extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [_EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType1<P1> extends AbstractMessageSignature {
+    private _parameterStructures;
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, _EM] | undefined;
+    constructor(method: string, _parameterStructures?: ParameterStructures);
+    get parameterStructures(): ParameterStructures;
+}
+export declare class NotificationType2<P1, P2> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType3<P1, P2, P3> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType4<P1, P2, P3, P4> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType5<P1, P2, P3, P4, P5> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType6<P1, P2, P3, P4, P5, P6> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType7<P1, P2, P3, P4, P5, P6, P7> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, P7, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType8<P1, P2, P3, P4, P5, P6, P7, P8> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, P7, P8, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class NotificationType9<P1, P2, P3, P4, P5, P6, P7, P8, P9> extends AbstractMessageSignature {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly _: [P1, P2, P3, P4, P5, P6, P7, P8, P9, _EM] | undefined;
+    constructor(method: string);
+}
+export declare namespace Message {
+    /**
+     * Tests if the given message is a request message
+     */
+    function isRequest(message: Message | undefined): message is RequestMessage;
+    /**
+     * Tests if the given message is a notification message
+     */
+    function isNotification(message: Message | undefined): message is NotificationMessage;
+    /**
+     * Tests if the given message is a response message
+     */
+    function isResponse(message: Message | undefined): message is ResponseMessage;
+}
+export {};

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

@@ -0,0 +1,306 @@
+"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.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
+const is = require("./is");
+/**
+ * Predefined error codes.
+ */
+var ErrorCodes;
+(function (ErrorCodes) {
+    // Defined by JSON RPC
+    ErrorCodes.ParseError = -32700;
+    ErrorCodes.InvalidRequest = -32600;
+    ErrorCodes.MethodNotFound = -32601;
+    ErrorCodes.InvalidParams = -32602;
+    ErrorCodes.InternalError = -32603;
+    /**
+     * This is the start range of JSON RPC reserved error codes.
+     * It doesn't denote a real error code. No application error codes should
+     * be defined between the start and end range. For backwards
+     * compatibility the `ServerNotInitialized` and the `UnknownErrorCode`
+     * are left in the range.
+     *
+     * @since 3.16.0
+    */
+    ErrorCodes.jsonrpcReservedErrorRangeStart = -32099;
+    /** @deprecated use  jsonrpcReservedErrorRangeStart */
+    ErrorCodes.serverErrorStart = -32099;
+    /**
+     * An error occurred when write a message to the transport layer.
+     */
+    ErrorCodes.MessageWriteError = -32099;
+    /**
+     * An error occurred when reading a message from the transport layer.
+     */
+    ErrorCodes.MessageReadError = -32098;
+    /**
+     * The connection got disposed or lost and all pending responses got
+     * rejected.
+     */
+    ErrorCodes.PendingResponseRejected = -32097;
+    /**
+     * The connection is inactive and a use of it failed.
+     */
+    ErrorCodes.ConnectionInactive = -32096;
+    /**
+     * Error code indicating that a server received a notification or
+     * request before the server has received the `initialize` request.
+     */
+    ErrorCodes.ServerNotInitialized = -32002;
+    ErrorCodes.UnknownErrorCode = -32001;
+    /**
+     * This is the end range of JSON RPC reserved error codes.
+     * It doesn't denote a real error code.
+     *
+     * @since 3.16.0
+    */
+    ErrorCodes.jsonrpcReservedErrorRangeEnd = -32000;
+    /** @deprecated use  jsonrpcReservedErrorRangeEnd */
+    ErrorCodes.serverErrorEnd = -32000;
+})(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
+/**
+ * An error object return in a response in case a request
+ * has failed.
+ */
+class ResponseError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
+        this.data = data;
+        Object.setPrototypeOf(this, ResponseError.prototype);
+    }
+    toJson() {
+        const result = {
+            code: this.code,
+            message: this.message
+        };
+        if (this.data !== undefined) {
+            result.data = this.data;
+        }
+        return result;
+    }
+}
+exports.ResponseError = ResponseError;
+class ParameterStructures {
+    constructor(kind) {
+        this.kind = kind;
+    }
+    static is(value) {
+        return value === ParameterStructures.auto || value === ParameterStructures.byName || value === ParameterStructures.byPosition;
+    }
+    toString() {
+        return this.kind;
+    }
+}
+exports.ParameterStructures = ParameterStructures;
+/**
+ * The parameter structure is automatically inferred on the number of parameters
+ * and the parameter type in case of a single param.
+ */
+ParameterStructures.auto = new ParameterStructures('auto');
+/**
+ * Forces `byPosition` parameter structure. This is useful if you have a single
+ * parameter which has a literal type.
+ */
+ParameterStructures.byPosition = new ParameterStructures('byPosition');
+/**
+ * Forces `byName` parameter structure. This is only useful when having a single
+ * parameter. The library will report errors if used with a different number of
+ * parameters.
+ */
+ParameterStructures.byName = new ParameterStructures('byName');
+/**
+ * An abstract implementation of a MessageType.
+ */
+class AbstractMessageSignature {
+    constructor(method, numberOfParams) {
+        this.method = method;
+        this.numberOfParams = numberOfParams;
+    }
+    get parameterStructures() {
+        return ParameterStructures.auto;
+    }
+}
+exports.AbstractMessageSignature = AbstractMessageSignature;
+/**
+ * Classes to type request response pairs
+ */
+class RequestType0 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 0);
+    }
+}
+exports.RequestType0 = RequestType0;
+class RequestType extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+        super(method, 1);
+        this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+        return this._parameterStructures;
+    }
+}
+exports.RequestType = RequestType;
+class RequestType1 extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+        super(method, 1);
+        this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+        return this._parameterStructures;
+    }
+}
+exports.RequestType1 = RequestType1;
+class RequestType2 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 2);
+    }
+}
+exports.RequestType2 = RequestType2;
+class RequestType3 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 3);
+    }
+}
+exports.RequestType3 = RequestType3;
+class RequestType4 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 4);
+    }
+}
+exports.RequestType4 = RequestType4;
+class RequestType5 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 5);
+    }
+}
+exports.RequestType5 = RequestType5;
+class RequestType6 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 6);
+    }
+}
+exports.RequestType6 = RequestType6;
+class RequestType7 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 7);
+    }
+}
+exports.RequestType7 = RequestType7;
+class RequestType8 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 8);
+    }
+}
+exports.RequestType8 = RequestType8;
+class RequestType9 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 9);
+    }
+}
+exports.RequestType9 = RequestType9;
+class NotificationType extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+        super(method, 1);
+        this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+        return this._parameterStructures;
+    }
+}
+exports.NotificationType = NotificationType;
+class NotificationType0 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 0);
+    }
+}
+exports.NotificationType0 = NotificationType0;
+class NotificationType1 extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+        super(method, 1);
+        this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+        return this._parameterStructures;
+    }
+}
+exports.NotificationType1 = NotificationType1;
+class NotificationType2 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 2);
+    }
+}
+exports.NotificationType2 = NotificationType2;
+class NotificationType3 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 3);
+    }
+}
+exports.NotificationType3 = NotificationType3;
+class NotificationType4 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 4);
+    }
+}
+exports.NotificationType4 = NotificationType4;
+class NotificationType5 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 5);
+    }
+}
+exports.NotificationType5 = NotificationType5;
+class NotificationType6 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 6);
+    }
+}
+exports.NotificationType6 = NotificationType6;
+class NotificationType7 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 7);
+    }
+}
+exports.NotificationType7 = NotificationType7;
+class NotificationType8 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 8);
+    }
+}
+exports.NotificationType8 = NotificationType8;
+class NotificationType9 extends AbstractMessageSignature {
+    constructor(method) {
+        super(method, 9);
+    }
+}
+exports.NotificationType9 = NotificationType9;
+var Message;
+(function (Message) {
+    /**
+     * Tests if the given message is a request message
+     */
+    function isRequest(message) {
+        const candidate = message;
+        return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
+    }
+    Message.isRequest = isRequest;
+    /**
+     * Tests if the given message is a notification message
+     */
+    function isNotification(message) {
+        const candidate = message;
+        return candidate && is.string(candidate.method) && message.id === void 0;
+    }
+    Message.isNotification = isNotification;
+    /**
+     * Tests if the given message is a response message
+     */
+    function isResponse(message) {
+        const candidate = message;
+        return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
+    }
+    Message.isResponse = isResponse;
+})(Message || (exports.Message = Message = {}));