@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node.cmd

@@ -0,0 +1,5 @@
+@echo off
+REM This file is necessary to ensure that under Windows we don't
+REM run the node.js file in the Windows Script Host when using
+REM node in packakge.json scripts. See also PATHEXT setting
+node.exe %*

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node.d.ts

@@ -0,0 +1,6 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+
+export * from './lib/node/main';

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node.js

@@ -0,0 +1,7 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+'use strict';
+
+module.exports = require('./lib/node/main');

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/License.txt

@@ -0,0 +1,11 @@
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/README.md

@@ -0,0 +1,69 @@
+# VSCode JSON RPC
+
+[![NPM Version](https://img.shields.io/npm/v/vscode-jsonrpc.svg)](https://npmjs.org/package/vscode-jsonrpc)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-jsonrpc.svg)](https://npmjs.org/package/vscode-jsonrpc)
+[![Build Status](https://travis-ci.org/Microsoft/vscode-languageserver-node.svg?branch=master)](https://travis-ci.org/Microsoft/vscode-languageserver-node)
+
+This npm module implements the base messaging protocol spoken between a VSCode language server and a VSCode language client.
+
+The npm module can also be used standalone to establish a [JSON-RPC](http://www.jsonrpc.org/) channel between
+a client and a server. Below an example how to setup a JSON-RPC connection. First the client side.
+
+```ts
+import * as cp from 'child_process';
+import * as rpc from 'vscode-jsonrpc/node';
+
+let childProcess = cp.spawn(...);
+
+// Use stdin and stdout for communication:
+let connection = rpc.createMessageConnection(
+	new rpc.StreamMessageReader(childProcess.stdout),
+	new rpc.StreamMessageWriter(childProcess.stdin));
+
+let notification = new rpc.NotificationType<string, void>('testNotification');
+
+connection.listen();
+
+connection.sendNotification(notification, 'Hello World');
+```
+
+The server side looks very symmetrical:
+
+```ts
+import * as rpc from 'vscode-jsonrpc/node';
+
+
+let connection = rpc.createMessageConnection(
+	new rpc.StreamMessageReader(process.stdin),
+	new rpc.StreamMessageWriter(process.stdout));
+
+let notification = new rpc.NotificationType<string, void>('testNotification');
+connection.onNotification(notification, (param: string) => {
+	console.log(param); // This prints Hello World
+});
+
+connection.listen();
+```
+
+# History
+
+### 5.0.0
+
+- add progress support
+- move JS target to ES2017
+
+### 4.0.0
+
+- move JS target to ES6.
+
+### 3.0.0:
+
+- converted the NPM module to use TypeScript 2.0.3.
+- added strict null support.
+- support for passing more than one parameter to a request or notification.
+- Breaking changes:
+  - due to the use of TypeScript 2.0.3 and differences in d.ts generation users of the new version need to move to
+    TypeScript 2.0.3 as well.
+
+## License
+[MIT](https://github.com/Microsoft/vscode-languageserver-node/blob/master/License.txt)

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/browser.d.ts

@@ -0,0 +1,6 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+
+export * from './lib/browser/main';

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/browser.js

@@ -0,0 +1,7 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ----------------------------------------------------------------------------------------- */
+'use strict';
+
+module.exports = require('./lib/browser/main');

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

@@ -0,0 +1,17 @@
+import { AbstractMessageReader, DataCallback, AbstractMessageWriter, Message, Disposable, ConnectionStrategy, ConnectionOptions, MessageReader, MessageWriter, Logger, MessageConnection } from '../common/api';
+export * from '../common/api';
+export declare class BrowserMessageReader extends AbstractMessageReader implements MessageReader {
+    private _onData;
+    private _messageListener;
+    constructor(port: MessagePort | Worker | DedicatedWorkerGlobalScope);
+    listen(callback: DataCallback): Disposable;
+}
+export declare class BrowserMessageWriter extends AbstractMessageWriter implements MessageWriter {
+    private port;
+    private errorCount;
+    constructor(port: MessagePort | Worker | DedicatedWorkerGlobalScope);
+    write(msg: Message): Promise<void>;
+    private handleError;
+    end(): void;
+}
+export declare function createMessageConnection(reader: MessageReader, writer: MessageWriter, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): MessageConnection;

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/browser/main.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.
+ * ------------------------------------------------------------------------------------------ */
+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.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
+const ril_1 = require("./ril");
+// Install the browser runtime abstract.
+ril_1.default.install();
+const api_1 = require("../common/api");
+__exportStar(require("../common/api"), exports);
+class BrowserMessageReader extends api_1.AbstractMessageReader {
+    constructor(port) {
+        super();
+        this._onData = new api_1.Emitter();
+        this._messageListener = (event) => {
+            this._onData.fire(event.data);
+        };
+        port.addEventListener('error', (event) => this.fireError(event));
+        port.onmessage = this._messageListener;
+    }
+    listen(callback) {
+        return this._onData.event(callback);
+    }
+}
+exports.BrowserMessageReader = BrowserMessageReader;
+class BrowserMessageWriter extends api_1.AbstractMessageWriter {
+    constructor(port) {
+        super();
+        this.port = port;
+        this.errorCount = 0;
+        port.addEventListener('error', (event) => this.fireError(event));
+    }
+    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.BrowserMessageWriter = BrowserMessageWriter;
+function createMessageConnection(reader, writer, logger, options) {
+    if (logger === undefined) {
+        logger = api_1.NullLogger;
+    }
+    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/browser/ril.d.ts

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

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/node_modules/vscode-jsonrpc/lib/browser/ril.js

@@ -0,0 +1,156 @@
+"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 });
+const api_1 = require("../common/api");
+class MessageBuffer extends api_1.AbstractMessageBuffer {
+    constructor(encoding = 'utf-8') {
+        super(encoding);
+        this.asciiDecoder = new TextDecoder('ascii');
+    }
+    emptyBuffer() {
+        return MessageBuffer.emptyBuffer;
+    }
+    fromString(value, _encoding) {
+        return (new TextEncoder()).encode(value);
+    }
+    toString(value, encoding) {
+        if (encoding === 'ascii') {
+            return this.asciiDecoder.decode(value);
+        }
+        else {
+            return (new TextDecoder(encoding)).decode(value);
+        }
+    }
+    asNative(buffer, length) {
+        if (length === undefined) {
+            return buffer;
+        }
+        else {
+            return buffer.slice(0, length);
+        }
+    }
+    allocNative(length) {
+        return new Uint8Array(length);
+    }
+}
+MessageBuffer.emptyBuffer = new Uint8Array(0);
+class ReadableStreamWrapper {
+    constructor(socket) {
+        this.socket = socket;
+        this._onData = new api_1.Emitter();
+        this._messageListener = (event) => {
+            const blob = event.data;
+            blob.arrayBuffer().then((buffer) => {
+                this._onData.fire(new Uint8Array(buffer));
+            }, () => {
+                (0, api_1.RAL)().console.error(`Converting blob to array buffer failed.`);
+            });
+        };
+        this.socket.addEventListener('message', this._messageListener);
+    }
+    onClose(listener) {
+        this.socket.addEventListener('close', listener);
+        return api_1.Disposable.create(() => this.socket.removeEventListener('close', listener));
+    }
+    onError(listener) {
+        this.socket.addEventListener('error', listener);
+        return api_1.Disposable.create(() => this.socket.removeEventListener('error', listener));
+    }
+    onEnd(listener) {
+        this.socket.addEventListener('end', listener);
+        return api_1.Disposable.create(() => this.socket.removeEventListener('end', listener));
+    }
+    onData(listener) {
+        return this._onData.event(listener);
+    }
+}
+class WritableStreamWrapper {
+    constructor(socket) {
+        this.socket = socket;
+    }
+    onClose(listener) {
+        this.socket.addEventListener('close', listener);
+        return api_1.Disposable.create(() => this.socket.removeEventListener('close', listener));
+    }
+    onError(listener) {
+        this.socket.addEventListener('error', listener);
+        return api_1.Disposable.create(() => this.socket.removeEventListener('error', listener));
+    }
+    onEnd(listener) {
+        this.socket.addEventListener('end', listener);
+        return api_1.Disposable.create(() => this.socket.removeEventListener('end', listener));
+    }
+    write(data, encoding) {
+        if (typeof data === 'string') {
+            if (encoding !== undefined && encoding !== 'utf-8') {
+                throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}`);
+            }
+            this.socket.send(data);
+        }
+        else {
+            this.socket.send(data);
+        }
+        return Promise.resolve();
+    }
+    end() {
+        this.socket.close();
+    }
+}
+const _textEncoder = new TextEncoder();
+const _ril = Object.freeze({
+    messageBuffer: Object.freeze({
+        create: (encoding) => new MessageBuffer(encoding)
+    }),
+    applicationJson: Object.freeze({
+        encoder: Object.freeze({
+            name: 'application/json',
+            encode: (msg, options) => {
+                if (options.charset !== 'utf-8') {
+                    throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}`);
+                }
+                return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, undefined, 0)));
+            }
+        }),
+        decoder: Object.freeze({
+            name: 'application/json',
+            decode: (buffer, options) => {
+                if (!(buffer instanceof Uint8Array)) {
+                    throw new Error(`In a Browser environments only Uint8Arrays are supported.`);
+                }
+                return Promise.resolve(JSON.parse(new TextDecoder(options.charset).decode(buffer)));
+            }
+        })
+    }),
+    stream: Object.freeze({
+        asReadableStream: (socket) => new ReadableStreamWrapper(socket),
+        asWritableStream: (socket) => new WritableStreamWrapper(socket)
+    }),
+    console: console,
+    timer: Object.freeze({
+        setTimeout(callback, ms, ...args) {
+            const handle = setTimeout(callback, ms, ...args);
+            return { dispose: () => clearTimeout(handle) };
+        },
+        setImmediate(callback, ...args) {
+            const handle = setTimeout(callback, 0, ...args);
+            return { dispose: () => clearTimeout(handle) };
+        },
+        setInterval(callback, ms, ...args) {
+            const handle = setInterval(callback, ms, ...args);
+            return { dispose: () => clearInterval(handle) };
+        },
+    })
+});
+function RIL() {
+    return _ril;
+}
+(function (RIL) {
+    function install() {
+        api_1.RAL.install(_ril);
+    }
+    RIL.install = install;
+})(RIL || (RIL = {}));
+exports.default = RIL;

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

@@ -0,0 +1,14 @@
+/// <reference path="../../typings/thenable.d.ts" />
+import { Message, MessageSignature, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, ResponseError, ErrorCodes, NotificationMessage, NotificationType, NotificationType0, NotificationType1, NotificationType2, NotificationType3, NotificationType4, NotificationType5, NotificationType6, NotificationType7, NotificationType8, NotificationType9, ResponseMessage, ParameterStructures, _EM } from './messages';
+import { LinkedMap, LRUCache, Touch } from './linkedMap';
+import { Disposable } from './disposable';
+import { Event, Emitter } from './events';
+import { AbstractCancellationTokenSource, CancellationTokenSource, CancellationToken } from './cancellation';
+import { SharedArraySenderStrategy, SharedArrayReceiverStrategy } from './sharedArrayCancellation';
+import { MessageReader, AbstractMessageReader, ReadableStreamMessageReader, DataCallback, MessageReaderOptions, PartialMessageInfo } from './messageReader';
+import { MessageWriter, AbstractMessageWriter, WriteableStreamMessageWriter, MessageWriterOptions } from './messageWriter';
+import { AbstractMessageBuffer } from './messageBuffer';
+import { ContentTypeEncoderOptions, ContentEncoder, ContentTypeEncoder, ContentTypeDecoderOptions, ContentDecoder, ContentTypeDecoder } from './encoding';
+import { Logger, ConnectionStrategy, ConnectionOptions, MessageConnection, NullLogger, createMessageConnection, ProgressToken, ProgressType, HandlerResult, StarRequestHandler, GenericRequestHandler, RequestHandler0, RequestHandler, RequestHandler1, RequestHandler2, RequestHandler3, RequestHandler4, RequestHandler5, RequestHandler6, RequestHandler7, RequestHandler8, RequestHandler9, StarNotificationHandler, GenericNotificationHandler, NotificationHandler0, NotificationHandler, NotificationHandler1, NotificationHandler2, NotificationHandler3, NotificationHandler4, NotificationHandler5, NotificationHandler6, NotificationHandler7, NotificationHandler8, NotificationHandler9, Trace, TraceValues, TraceFormat, TraceOptions, SetTraceParams, SetTraceNotification, LogTraceParams, LogTraceNotification, Tracer, ConnectionErrors, ConnectionError, CancellationId, CancellationReceiverStrategy, CancellationSenderStrategy, CancellationStrategy, MessageStrategy } from './connection';
+import RAL from './ral';
+export { RAL, Message, MessageSignature, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, ResponseError, ErrorCodes, NotificationMessage, NotificationType, NotificationType0, NotificationType1, NotificationType2, NotificationType3, NotificationType4, NotificationType5, NotificationType6, NotificationType7, NotificationType8, NotificationType9, ResponseMessage, ParameterStructures, _EM, LinkedMap, Touch, LRUCache, Disposable, Event, Emitter, AbstractCancellationTokenSource, CancellationTokenSource, CancellationToken, SharedArraySenderStrategy, SharedArrayReceiverStrategy, MessageReader, AbstractMessageReader, ReadableStreamMessageReader, DataCallback, MessageReaderOptions, PartialMessageInfo, MessageWriter, AbstractMessageWriter, WriteableStreamMessageWriter, MessageWriterOptions, AbstractMessageBuffer, ContentTypeEncoderOptions, ContentEncoder, ContentTypeEncoder, ContentTypeDecoderOptions, ContentDecoder, ContentTypeDecoder, Logger, ConnectionStrategy, ConnectionOptions, MessageConnection, NullLogger, createMessageConnection, ProgressToken, ProgressType, HandlerResult, StarRequestHandler, GenericRequestHandler, RequestHandler0, RequestHandler, RequestHandler1, RequestHandler2, RequestHandler3, RequestHandler4, RequestHandler5, RequestHandler6, RequestHandler7, RequestHandler8, RequestHandler9, StarNotificationHandler, GenericNotificationHandler, NotificationHandler0, NotificationHandler, NotificationHandler1, NotificationHandler2, NotificationHandler3, NotificationHandler4, NotificationHandler5, NotificationHandler6, NotificationHandler7, NotificationHandler8, NotificationHandler9, Trace, TraceValues, TraceFormat, TraceOptions, SetTraceParams, SetTraceNotification, LogTraceParams, LogTraceNotification, Tracer, ConnectionErrors, ConnectionError, CancellationId, CancellationReceiverStrategy, CancellationSenderStrategy, CancellationStrategy, MessageStrategy };

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

@@ -0,0 +1,81 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+/// <reference path="../../typings/thenable.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0;
+exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = void 0;
+const messages_1 = require("./messages");
+Object.defineProperty(exports, "Message", { enumerable: true, get: function () { return messages_1.Message; } });
+Object.defineProperty(exports, "RequestType", { enumerable: true, get: function () { return messages_1.RequestType; } });
+Object.defineProperty(exports, "RequestType0", { enumerable: true, get: function () { return messages_1.RequestType0; } });
+Object.defineProperty(exports, "RequestType1", { enumerable: true, get: function () { return messages_1.RequestType1; } });
+Object.defineProperty(exports, "RequestType2", { enumerable: true, get: function () { return messages_1.RequestType2; } });
+Object.defineProperty(exports, "RequestType3", { enumerable: true, get: function () { return messages_1.RequestType3; } });
+Object.defineProperty(exports, "RequestType4", { enumerable: true, get: function () { return messages_1.RequestType4; } });
+Object.defineProperty(exports, "RequestType5", { enumerable: true, get: function () { return messages_1.RequestType5; } });
+Object.defineProperty(exports, "RequestType6", { enumerable: true, get: function () { return messages_1.RequestType6; } });
+Object.defineProperty(exports, "RequestType7", { enumerable: true, get: function () { return messages_1.RequestType7; } });
+Object.defineProperty(exports, "RequestType8", { enumerable: true, get: function () { return messages_1.RequestType8; } });
+Object.defineProperty(exports, "RequestType9", { enumerable: true, get: function () { return messages_1.RequestType9; } });
+Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function () { return messages_1.ResponseError; } });
+Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function () { return messages_1.ErrorCodes; } });
+Object.defineProperty(exports, "NotificationType", { enumerable: true, get: function () { return messages_1.NotificationType; } });
+Object.defineProperty(exports, "NotificationType0", { enumerable: true, get: function () { return messages_1.NotificationType0; } });
+Object.defineProperty(exports, "NotificationType1", { enumerable: true, get: function () { return messages_1.NotificationType1; } });
+Object.defineProperty(exports, "NotificationType2", { enumerable: true, get: function () { return messages_1.NotificationType2; } });
+Object.defineProperty(exports, "NotificationType3", { enumerable: true, get: function () { return messages_1.NotificationType3; } });
+Object.defineProperty(exports, "NotificationType4", { enumerable: true, get: function () { return messages_1.NotificationType4; } });
+Object.defineProperty(exports, "NotificationType5", { enumerable: true, get: function () { return messages_1.NotificationType5; } });
+Object.defineProperty(exports, "NotificationType6", { enumerable: true, get: function () { return messages_1.NotificationType6; } });
+Object.defineProperty(exports, "NotificationType7", { enumerable: true, get: function () { return messages_1.NotificationType7; } });
+Object.defineProperty(exports, "NotificationType8", { enumerable: true, get: function () { return messages_1.NotificationType8; } });
+Object.defineProperty(exports, "NotificationType9", { enumerable: true, get: function () { return messages_1.NotificationType9; } });
+Object.defineProperty(exports, "ParameterStructures", { enumerable: true, get: function () { return messages_1.ParameterStructures; } });
+const linkedMap_1 = require("./linkedMap");
+Object.defineProperty(exports, "LinkedMap", { enumerable: true, get: function () { return linkedMap_1.LinkedMap; } });
+Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return linkedMap_1.LRUCache; } });
+Object.defineProperty(exports, "Touch", { enumerable: true, get: function () { return linkedMap_1.Touch; } });
+const disposable_1 = require("./disposable");
+Object.defineProperty(exports, "Disposable", { enumerable: true, get: function () { return disposable_1.Disposable; } });
+const events_1 = require("./events");
+Object.defineProperty(exports, "Event", { enumerable: true, get: function () { return events_1.Event; } });
+Object.defineProperty(exports, "Emitter", { enumerable: true, get: function () { return events_1.Emitter; } });
+const cancellation_1 = require("./cancellation");
+Object.defineProperty(exports, "CancellationTokenSource", { enumerable: true, get: function () { return cancellation_1.CancellationTokenSource; } });
+Object.defineProperty(exports, "CancellationToken", { enumerable: true, get: function () { return cancellation_1.CancellationToken; } });
+const sharedArrayCancellation_1 = require("./sharedArrayCancellation");
+Object.defineProperty(exports, "SharedArraySenderStrategy", { enumerable: true, get: function () { return sharedArrayCancellation_1.SharedArraySenderStrategy; } });
+Object.defineProperty(exports, "SharedArrayReceiverStrategy", { enumerable: true, get: function () { return sharedArrayCancellation_1.SharedArrayReceiverStrategy; } });
+const messageReader_1 = require("./messageReader");
+Object.defineProperty(exports, "MessageReader", { enumerable: true, get: function () { return messageReader_1.MessageReader; } });
+Object.defineProperty(exports, "AbstractMessageReader", { enumerable: true, get: function () { return messageReader_1.AbstractMessageReader; } });
+Object.defineProperty(exports, "ReadableStreamMessageReader", { enumerable: true, get: function () { return messageReader_1.ReadableStreamMessageReader; } });
+const messageWriter_1 = require("./messageWriter");
+Object.defineProperty(exports, "MessageWriter", { enumerable: true, get: function () { return messageWriter_1.MessageWriter; } });
+Object.defineProperty(exports, "AbstractMessageWriter", { enumerable: true, get: function () { return messageWriter_1.AbstractMessageWriter; } });
+Object.defineProperty(exports, "WriteableStreamMessageWriter", { enumerable: true, get: function () { return messageWriter_1.WriteableStreamMessageWriter; } });
+const messageBuffer_1 = require("./messageBuffer");
+Object.defineProperty(exports, "AbstractMessageBuffer", { enumerable: true, get: function () { return messageBuffer_1.AbstractMessageBuffer; } });
+const connection_1 = require("./connection");
+Object.defineProperty(exports, "ConnectionStrategy", { enumerable: true, get: function () { return connection_1.ConnectionStrategy; } });
+Object.defineProperty(exports, "ConnectionOptions", { enumerable: true, get: function () { return connection_1.ConnectionOptions; } });
+Object.defineProperty(exports, "NullLogger", { enumerable: true, get: function () { return connection_1.NullLogger; } });
+Object.defineProperty(exports, "createMessageConnection", { enumerable: true, get: function () { return connection_1.createMessageConnection; } });
+Object.defineProperty(exports, "ProgressToken", { enumerable: true, get: function () { return connection_1.ProgressToken; } });
+Object.defineProperty(exports, "ProgressType", { enumerable: true, get: function () { return connection_1.ProgressType; } });
+Object.defineProperty(exports, "Trace", { enumerable: true, get: function () { return connection_1.Trace; } });
+Object.defineProperty(exports, "TraceValues", { enumerable: true, get: function () { return connection_1.TraceValues; } });
+Object.defineProperty(exports, "TraceFormat", { enumerable: true, get: function () { return connection_1.TraceFormat; } });
+Object.defineProperty(exports, "SetTraceNotification", { enumerable: true, get: function () { return connection_1.SetTraceNotification; } });
+Object.defineProperty(exports, "LogTraceNotification", { enumerable: true, get: function () { return connection_1.LogTraceNotification; } });
+Object.defineProperty(exports, "ConnectionErrors", { enumerable: true, get: function () { return connection_1.ConnectionErrors; } });
+Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return connection_1.ConnectionError; } });
+Object.defineProperty(exports, "CancellationReceiverStrategy", { enumerable: true, get: function () { return connection_1.CancellationReceiverStrategy; } });
+Object.defineProperty(exports, "CancellationSenderStrategy", { enumerable: true, get: function () { return connection_1.CancellationSenderStrategy; } });
+Object.defineProperty(exports, "CancellationStrategy", { enumerable: true, get: function () { return connection_1.CancellationStrategy; } });
+Object.defineProperty(exports, "MessageStrategy", { enumerable: true, get: function () { return connection_1.MessageStrategy; } });
+const ral_1 = require("./ral");
+exports.RAL = ral_1.default;

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

@@ -0,0 +1,32 @@
+import { Event } from './events';
+import { Disposable } from './disposable';
+/**
+ * Defines a CancellationToken. This interface is not
+ * intended to be implemented. A CancellationToken must
+ * be created via a CancellationTokenSource.
+ */
+export interface CancellationToken {
+    /**
+     * Is `true` when the token has been cancelled, `false` otherwise.
+     */
+    readonly isCancellationRequested: boolean;
+    /**
+     * An {@link Event event} which fires upon cancellation.
+     */
+    readonly onCancellationRequested: Event<any>;
+}
+export declare namespace CancellationToken {
+    const None: CancellationToken;
+    const Cancelled: CancellationToken;
+    function is(value: any): value is CancellationToken;
+}
+export interface AbstractCancellationTokenSource extends Disposable {
+    token: CancellationToken;
+    cancel(): void;
+}
+export declare class CancellationTokenSource implements AbstractCancellationTokenSource {
+    private _token;
+    get token(): CancellationToken;
+    cancel(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,96 @@
+"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.CancellationTokenSource = exports.CancellationToken = void 0;
+const ral_1 = require("./ral");
+const Is = require("./is");
+const events_1 = require("./events");
+var CancellationToken;
+(function (CancellationToken) {
+    CancellationToken.None = Object.freeze({
+        isCancellationRequested: false,
+        onCancellationRequested: events_1.Event.None
+    });
+    CancellationToken.Cancelled = Object.freeze({
+        isCancellationRequested: true,
+        onCancellationRequested: events_1.Event.None
+    });
+    function is(value) {
+        const candidate = value;
+        return candidate && (candidate === CancellationToken.None
+            || candidate === CancellationToken.Cancelled
+            || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));
+    }
+    CancellationToken.is = is;
+})(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
+const shortcutEvent = Object.freeze(function (callback, context) {
+    const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
+    return { dispose() { handle.dispose(); } };
+});
+class MutableToken {
+    constructor() {
+        this._isCancelled = false;
+    }
+    cancel() {
+        if (!this._isCancelled) {
+            this._isCancelled = true;
+            if (this._emitter) {
+                this._emitter.fire(undefined);
+                this.dispose();
+            }
+        }
+    }
+    get isCancellationRequested() {
+        return this._isCancelled;
+    }
+    get onCancellationRequested() {
+        if (this._isCancelled) {
+            return shortcutEvent;
+        }
+        if (!this._emitter) {
+            this._emitter = new events_1.Emitter();
+        }
+        return this._emitter.event;
+    }
+    dispose() {
+        if (this._emitter) {
+            this._emitter.dispose();
+            this._emitter = undefined;
+        }
+    }
+}
+class CancellationTokenSource {
+    get token() {
+        if (!this._token) {
+            // be lazy and create the token only when
+            // actually needed
+            this._token = new MutableToken();
+        }
+        return this._token;
+    }
+    cancel() {
+        if (!this._token) {
+            // save an object by returning the default
+            // cancelled token when cancellation happens
+            // before someone asks for the token
+            this._token = CancellationToken.Cancelled;
+        }
+        else {
+            this._token.cancel();
+        }
+    }
+    dispose() {
+        if (!this._token) {
+            // ensure to initialize with an empty token if we had none
+            this._token = CancellationToken.None;
+        }
+        else if (this._token instanceof MutableToken) {
+            // actually dispose
+            this._token.dispose();
+        }
+    }
+}
+exports.CancellationTokenSource = CancellationTokenSource;