create-yoya-ui 0.2.0 → 0.2.2

package/templates/admin/node_modules/typescript/vendor/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/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/browser/main.js

@@ -0,0 +1,83 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
+exports.createMessageConnection = createMessageConnection;
+const ril_1 = __importDefault(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 {
+    _onData;
+    _messageListener;
+    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 {
+    port;
+    errorCount;
+    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);
+}

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/browser/ril.d.ts

@@ -0,0 +1,22 @@
+import { RAL, Disposable } from '../common/api';
+interface RIL extends RAL {
+    readonly stream: {
+        readonly asReadableStream: (stream: WebSocket) => RAL.ReadableStream;
+        readonly asWritableStream: (stream: WebSocket) => RAL.WritableStream;
+    };
+}
+export declare class QueueMicrotaskImpl implements Disposable {
+    private isDisposed;
+    constructor(callback: (...args: any[]) => void, ...args: any[]);
+    dispose(): void;
+}
+export declare class PromiseImpl implements Disposable {
+    private isDisposed;
+    constructor(callback: (...args: any[]) => void, ...args: any[]);
+    dispose(): void;
+}
+declare function RIL(): RIL;
+declare namespace RIL {
+    function install(): void;
+}
+export default RIL;

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/browser/ril.js

@@ -0,0 +1,210 @@
+"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.PromiseImpl = exports.QueueMicrotaskImpl = void 0;
+const api_1 = require("../common/api");
+class MessageBuffer extends api_1.AbstractMessageBuffer {
+    static emptyBuffer = new Uint8Array(0);
+    asciiDecoder;
+    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);
+    }
+}
+class ReadableStreamWrapper {
+    socket;
+    _onData;
+    _messageListener;
+    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 {
+    socket;
+    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 {
+            if (data.buffer instanceof ArrayBuffer) {
+                this.socket.send(data.buffer);
+            }
+            else {
+                // We can't send a shared array buffer directly, so we need to
+                // create a copy of it.
+                this.socket.send(new Uint8Array(data.buffer).slice().buffer);
+            }
+        }
+        return Promise.resolve();
+    }
+    end() {
+        this.socket.close();
+    }
+}
+class QueueMicrotaskImpl {
+    isDisposed;
+    constructor(callback, ...args) {
+        this.isDisposed = false;
+        queueMicrotask(() => {
+            if (!this.isDisposed) {
+                callback(...args);
+            }
+        });
+    }
+    dispose() {
+        this.isDisposed = true;
+    }
+}
+exports.QueueMicrotaskImpl = QueueMicrotaskImpl;
+class PromiseImpl {
+    isDisposed;
+    constructor(callback, ...args) {
+        this.isDisposed = false;
+        Promise.resolve().then(() => {
+            if (!this.isDisposed) {
+                callback(...args);
+            }
+        }, () => {
+        });
+    }
+    dispose() {
+        this.isDisposed = true;
+    }
+}
+exports.PromiseImpl = PromiseImpl;
+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) {
+            // Browser don't have setImmediate and setTimeout with 0 delay of 0 can cause problems
+            // in webviews and similar environments due to throttling.
+            if (typeof globalThis.queueMicrotask === 'function') {
+                return new QueueMicrotaskImpl(callback, ...args);
+            }
+            else if (Promise !== undefined) {
+                return new PromiseImpl(callback, ...args);
+            }
+            else {
+                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/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/common/api.d.ts

@@ -0,0 +1,14 @@
+/// <reference path="../../typings/thenable.d.ts" preserve="true" />
+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, RequestParam, 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, TraceValue, TraceFormat, TraceOptions, SetTraceParams, SetTraceNotification, LogTraceParams, LogTraceNotification, Tracer, ConnectionErrors, ConnectionError, CancellationId, CancellationReceiverStrategy, IdCancellationReceiverStrategy, RequestCancellationReceiverStrategy, CancellationSenderStrategy, CancellationStrategy, MessageStrategy, TraceValues } 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, RequestParam, 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, TraceValue, TraceValues, TraceFormat, TraceOptions, SetTraceParams, SetTraceNotification, LogTraceParams, LogTraceNotification, Tracer, ConnectionErrors, ConnectionError, CancellationId, CancellationReceiverStrategy, IdCancellationReceiverStrategy, RequestCancellationReceiverStrategy, CancellationSenderStrategy, CancellationStrategy, MessageStrategy };

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/common/api.js

@@ -0,0 +1,87 @@
+"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" preserve="true"/>
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.TraceValue = 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, "TraceValue", { enumerable: true, get: function () { return connection_1.TraceValue; } });
+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, "IdCancellationReceiverStrategy", { enumerable: true, get: function () { return connection_1.IdCancellationReceiverStrategy; } });
+Object.defineProperty(exports, "RequestCancellationReceiverStrategy", { enumerable: true, get: function () { return connection_1.RequestCancellationReceiverStrategy; } });
+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; } });
+Object.defineProperty(exports, "TraceValues", { enumerable: true, get: function () { return connection_1.TraceValues; } });
+const ral_1 = __importDefault(require("./ral"));
+exports.RAL = ral_1.default;

package/templates/admin/node_modules/typescript/vendor/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/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/common/cancellation.js

@@ -0,0 +1,132 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancellationTokenSource = exports.CancellationToken = void 0;
+const ral_1 = __importDefault(require("./ral"));
+const Is = __importStar(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 {
+    _isCancelled = false;
+    _emitter;
+    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 {
+    _token;
+    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;