@mrclrchtr/supi-code-intelligence 1.7.0 → 1.8.0

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

@@ -0,0 +1,15 @@
+"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.createProtocolConnection = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+function createProtocolConnection(input, output, logger, options) {
+    if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
+        options = { connectionStrategy: options };
+    }
+    return (0, vscode_jsonrpc_1.createMessageConnection)(input, output, logger, options);
+}
+exports.createProtocolConnection = createProtocolConnection;

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

@@ -0,0 +1,51 @@
+import { RequestType, RequestType0, NotificationType, NotificationType0, ProgressType, _EM } from 'vscode-jsonrpc';
+export declare enum MessageDirection {
+    clientToServer = "clientToServer",
+    serverToClient = "serverToClient",
+    both = "both"
+}
+export declare class RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ____: [RO, _EM] | undefined;
+    readonly method: string;
+    constructor(method: string);
+}
+export declare class ProtocolRequestType0<R, PR, E, RO> extends RequestType0<R, E> implements ProgressType<PR>, RegistrationType<RO> {
+    /**
+     * Clients must not use these properties. They are here to ensure correct typing.
+     * in TypeScript
+     */
+    readonly __: [PR, _EM] | undefined;
+    readonly ___: [PR, RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    readonly _pr: PR | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolRequestType<P, R, PR, E, RO> extends RequestType<P, R, E> implements ProgressType<PR>, RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly __: [PR, _EM] | undefined;
+    readonly ___: [PR, RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    readonly _pr: PR | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolNotificationType0<RO> extends NotificationType0 implements RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolNotificationType<P, RO> extends NotificationType<P> implements RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    constructor(method: string);
+}

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

@@ -0,0 +1,44 @@
+"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.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = exports.MessageDirection = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+var MessageDirection;
+(function (MessageDirection) {
+    MessageDirection["clientToServer"] = "clientToServer";
+    MessageDirection["serverToClient"] = "serverToClient";
+    MessageDirection["both"] = "both";
+})(MessageDirection || (exports.MessageDirection = MessageDirection = {}));
+class RegistrationType {
+    constructor(method) {
+        this.method = method;
+    }
+}
+exports.RegistrationType = RegistrationType;
+class ProtocolRequestType0 extends vscode_jsonrpc_1.RequestType0 {
+    constructor(method) {
+        super(method);
+    }
+}
+exports.ProtocolRequestType0 = ProtocolRequestType0;
+class ProtocolRequestType extends vscode_jsonrpc_1.RequestType {
+    constructor(method) {
+        super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+}
+exports.ProtocolRequestType = ProtocolRequestType;
+class ProtocolNotificationType0 extends vscode_jsonrpc_1.NotificationType0 {
+    constructor(method) {
+        super(method);
+    }
+}
+exports.ProtocolNotificationType0 = ProtocolNotificationType0;
+class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType {
+    constructor(method) {
+        super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+}
+exports.ProtocolNotificationType = ProtocolNotificationType;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,43 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) TypeFox, Microsoft and others. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const messages_1 = require("./messages");
+const api_1 = require("./api");
+// This file is used to define the $ notification partly specified in JSON-RPC
+// so that we generate proper data for them in the meta model.
+// @ts-ignore 6196
+var SetTraceNotification;
+(function (SetTraceNotification) {
+    SetTraceNotification.method = '$/setTrace';
+    SetTraceNotification.messageDirection = messages_1.MessageDirection.clientToServer;
+    SetTraceNotification.type = new messages_1.ProtocolNotificationType(SetTraceNotification.method);
+})(SetTraceNotification || (SetTraceNotification = {}));
+// @ts-ignore 6196
+var LogTraceNotification;
+(function (LogTraceNotification) {
+    LogTraceNotification.method = '$/logTrace';
+    LogTraceNotification.messageDirection = messages_1.MessageDirection.serverToClient;
+    LogTraceNotification.type = new messages_1.ProtocolNotificationType(LogTraceNotification.method);
+})(LogTraceNotification || (LogTraceNotification = {}));
+// @ts-ignore 6196
+const $ErrorCodes = vscode_jsonrpc_1.ErrorCodes;
+// @ts-ignore 6196
+const $LSPErrorCodes = api_1.LSPErrorCodes;
+// @ts-ignore 6196
+var CancelNotification;
+(function (CancelNotification) {
+    CancelNotification.method = '$/cancelRequest';
+    CancelNotification.messageDirection = messages_1.MessageDirection.both;
+    CancelNotification.type = new messages_1.ProtocolNotificationType(CancelNotification.method);
+})(CancelNotification || (CancelNotification = {}));
+// @ts-ignore 6196
+var ProgressNotification;
+(function (ProgressNotification) {
+    ProgressNotification.method = '$/progress';
+    ProgressNotification.messageDirection = messages_1.MessageDirection.both;
+    ProgressNotification.type = new messages_1.ProtocolNotificationType(ProgressNotification.method);
+})(ProgressNotification || (ProgressNotification = {}));

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

@@ -0,0 +1,86 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType } from './messages';
+import type { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * @since 3.16.0
+ */
+export interface CallHierarchyClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * Call hierarchy options used during static registration.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Call hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, CallHierarchyOptions, StaticRegistrationOptions {
+}
+/**
+ * The parameter of a `textDocument/prepareCallHierarchy` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+/**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to an incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0
+ */
+export declare namespace CallHierarchyPrepareRequest {
+    const method: 'textDocument/prepareCallHierarchy';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CallHierarchyPrepareParams, CallHierarchyItem[] | null, never, void, CallHierarchyRegistrationOptions>;
+    type HandlerSignature = RequestHandler<CallHierarchyPrepareParams, CallHierarchyItem[] | null, void>;
+}
+/**
+ * The parameter of a `callHierarchy/incomingCalls` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyIncomingCallsParams extends WorkDoneProgressParams, PartialResultParams {
+    item: CallHierarchyItem;
+}
+/**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+export declare namespace CallHierarchyIncomingCallsRequest {
+    const method: 'callHierarchy/incomingCalls';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, CallHierarchyIncomingCall[], void, void>;
+    type HandlerSignature = RequestHandler<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, void>;
+}
+/**
+ * The parameter of a `callHierarchy/outgoingCalls` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOutgoingCallsParams extends WorkDoneProgressParams, PartialResultParams {
+    item: CallHierarchyItem;
+}
+/**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+export declare namespace CallHierarchyOutgoingCallsRequest {
+    const method: 'callHierarchy/outgoingCalls';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, CallHierarchyOutgoingCall[], void, void>;
+    type HandlerSignature = RequestHandler<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, void>;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) TypeFox, Microsoft and others. 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.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to an incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0
+ */
+var CallHierarchyPrepareRequest;
+(function (CallHierarchyPrepareRequest) {
+    CallHierarchyPrepareRequest.method = 'textDocument/prepareCallHierarchy';
+    CallHierarchyPrepareRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    CallHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest.method);
+})(CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = CallHierarchyPrepareRequest = {}));
+/**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+var CallHierarchyIncomingCallsRequest;
+(function (CallHierarchyIncomingCallsRequest) {
+    CallHierarchyIncomingCallsRequest.method = 'callHierarchy/incomingCalls';
+    CallHierarchyIncomingCallsRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    CallHierarchyIncomingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest.method);
+})(CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = CallHierarchyIncomingCallsRequest = {}));
+/**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+var CallHierarchyOutgoingCallsRequest;
+(function (CallHierarchyOutgoingCallsRequest) {
+    CallHierarchyOutgoingCallsRequest.method = 'callHierarchy/outgoingCalls';
+    CallHierarchyOutgoingCallsRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    CallHierarchyOutgoingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest.method);
+})(CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = CallHierarchyOutgoingCallsRequest = {}));

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

@@ -0,0 +1,66 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier, Range, Color, ColorInformation, ColorPresentation } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType } from './messages';
+import type { TextDocumentRegistrationOptions, StaticRegistrationOptions, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+export interface DocumentColorClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `DocumentColorRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface DocumentColorOptions extends WorkDoneProgressOptions {
+}
+export interface DocumentColorRegistrationOptions extends TextDocumentRegistrationOptions, StaticRegistrationOptions, DocumentColorOptions {
+}
+/**
+ * Parameters for a {@link DocumentColorRequest}.
+ */
+export interface DocumentColorParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type {@link DocumentColorParams} the
+ * response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+ * that resolves to such.
+ */
+export declare namespace DocumentColorRequest {
+    const method: 'textDocument/documentColor';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentColorParams, ColorInformation[], ColorInformation[], void, DocumentColorRegistrationOptions>;
+    type HandlerSignature = RequestHandler<DocumentColorParams, ColorInformation[], void>;
+}
+/**
+ * Parameters for a {@link ColorPresentationRequest}.
+ */
+export interface ColorPresentationParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The color to request presentations for.
+     */
+    color: Color;
+    /**
+     * The range where the color would be inserted. Serves as a context.
+     */
+    range: Range;
+}
+/**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type {@link ColorPresentationParams} the
+ * response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+ * that resolves to such.
+ */
+export declare namespace ColorPresentationRequest {
+    const method: 'textDocument/colorPresentation';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ColorPresentationParams, ColorPresentation[], ColorPresentation[], void, WorkDoneProgressOptions & TextDocumentRegistrationOptions>;
+    type HandlerSignature = RequestHandler<ColorPresentationParams, ColorPresentation[], void>;
+}

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

@@ -0,0 +1,32 @@
+"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.ColorPresentationRequest = exports.DocumentColorRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type {@link DocumentColorParams} the
+ * response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+ * that resolves to such.
+ */
+var DocumentColorRequest;
+(function (DocumentColorRequest) {
+    DocumentColorRequest.method = 'textDocument/documentColor';
+    DocumentColorRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    DocumentColorRequest.type = new messages_1.ProtocolRequestType(DocumentColorRequest.method);
+})(DocumentColorRequest || (exports.DocumentColorRequest = DocumentColorRequest = {}));
+/**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type {@link ColorPresentationParams} the
+ * response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+ * that resolves to such.
+ */
+var ColorPresentationRequest;
+(function (ColorPresentationRequest) {
+    ColorPresentationRequest.method = 'textDocument/colorPresentation';
+    ColorPresentationRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    ColorPresentationRequest.type = new messages_1.ProtocolRequestType(ColorPresentationRequest.method);
+})(ColorPresentationRequest || (exports.ColorPresentationRequest = ColorPresentationRequest = {}));

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

@@ -0,0 +1,35 @@
+import { RequestHandler, HandlerResult, CancellationToken } from 'vscode-jsonrpc';
+import { LSPAny, URI } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType } from './messages';
+/**
+ * The 'workspace/configuration' request is sent from the server to the client to fetch a certain
+ * configuration setting.
+ *
+ * This pull model replaces the old push model were the client signaled configuration change via an
+ * event. If the server still needs to react to configuration changes (since the server caches the
+ * result of `workspace/configuration` requests) the server should register for an empty configuration
+ * change event and empty the cache if such an event is received.
+ */
+export declare namespace ConfigurationRequest {
+    const method: 'workspace/configuration';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ConfigurationParams, any[], never, void, void>;
+    type HandlerSignature = RequestHandler<ConfigurationParams, LSPAny[], void>;
+    type MiddlewareSignature = (params: ConfigurationParams, token: CancellationToken, next: HandlerSignature) => HandlerResult<LSPAny[], void>;
+}
+export interface ConfigurationItem {
+    /**
+     * The scope to get the configuration section for.
+     */
+    scopeUri?: URI;
+    /**
+     * The configuration section asked for.
+     */
+    section?: string;
+}
+/**
+ * The parameters of a configuration request.
+ */
+export interface ConfigurationParams {
+    items: ConfigurationItem[];
+}

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

@@ -0,0 +1,24 @@
+"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.ConfigurationRequest = void 0;
+const messages_1 = require("./messages");
+//---- Get Configuration request ----
+/**
+ * The 'workspace/configuration' request is sent from the server to the client to fetch a certain
+ * configuration setting.
+ *
+ * This pull model replaces the old push model were the client signaled configuration change via an
+ * event. If the server still needs to react to configuration changes (since the server caches the
+ * result of `workspace/configuration` requests) the server should register for an empty configuration
+ * change event and empty the cache if such an event is received.
+ */
+var ConfigurationRequest;
+(function (ConfigurationRequest) {
+    ConfigurationRequest.method = 'workspace/configuration';
+    ConfigurationRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    ConfigurationRequest.type = new messages_1.ProtocolRequestType(ConfigurationRequest.method);
+})(ConfigurationRequest || (exports.ConfigurationRequest = ConfigurationRequest = {}));