@opensumi/ide-core-common 2.17.9 → 2.18.1

package/lib/event.js

@@ -1,816 +0,0 @@
-"use strict";
-/* ---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// Some code copied and modified from https://github.com/microsoft/vscode/blob/1.44.0/src/vs/base/common/event.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadyEvent = exports.Relay = exports.EventBufferer = exports.EventMultiplexer = exports.AsyncEmitter = exports.WaitUntilEvent = exports.PauseableEmitter = exports.Emitter = exports.setGlobalLeakWarningThreshold = exports.Event = void 0;
-const disposable_1 = require("./disposable");
-const errors_1 = require("./errors");
-const functional_1 = require("./functional");
-const linked_list_1 = require("./linked-list");
-var Event;
-(function (Event) {
-    const _disposable = { dispose() { } };
-    Event.None = function () {
-        return _disposable;
-    };
-    /**
-     * Given an event, returns another event which only fires once.
-     */
-    function once(event) {
-        return (listener, thisArgs = null, disposables) => {
-            // we need this, in case the event fires during the listener call
-            let didFire = false;
-            let result;
-            result = event((e) => {
-                if (didFire) {
-                    return;
-                }
-                else if (result) {
-                    result.dispose();
-                }
-                else {
-                    didFire = true;
-                }
-                return listener.call(thisArgs, e);
-            }, null, disposables);
-            if (didFire) {
-                result.dispose();
-            }
-            return result;
-        };
-    }
-    Event.once = once;
-    /**
-     * Given an event and a `map` function, returns another event which maps each element
-     * throught the mapping function.
-     */
-    function map(event, map) {
-        return snapshot((listener, thisArgs = null, disposables) => event((i) => listener.call(thisArgs, map(i)), null, disposables));
-    }
-    Event.map = map;
-    /**
-     * Given an event and an `each` function, returns another identical event and calls
-     * the `each` function per each element.
-     */
-    function forEach(event, each) {
-        return snapshot((listener, thisArgs = null, disposables) => event((i) => {
-            each(i);
-            listener.call(thisArgs, i);
-        }, null, disposables));
-    }
-    Event.forEach = forEach;
-    function filter(event, filter) {
-        return snapshot((listener, thisArgs = null, disposables) => event((e) => filter(e) && listener.call(thisArgs, e), null, disposables));
-    }
-    Event.filter = filter;
-    /**
-     * Given an event, returns the same event but typed as `Event<void>`.
-     */
-    function signal(event) {
-        return event;
-    }
-    Event.signal = signal;
-    /**
-     * Given a collection of events, returns a single event which emits
-     * whenever any of the provided events emit.
-     */
-    function any(...events) {
-        return (listener, thisArgs = null, disposables) => (0, disposable_1.combinedDisposable)(events.map((event) => event((e) => listener.call(thisArgs, e), null, disposables)));
-    }
-    Event.any = any;
-    /**
-     * Given an event and a `merge` function, returns another event which maps each element
-     * and the cummulative result throught the `merge` function. Similar to `map`, but with memory.
-     */
-    function reduce(event, merge, initial) {
-        let output = initial;
-        return map(event, (e) => {
-            output = merge(output, e);
-            return output;
-        });
-    }
-    Event.reduce = reduce;
-    /**
-     * Given a chain of event processing functions (filter, map, etc), each
-     * function will be invoked per event & per listener. Snapshotting an event
-     * chain allows each function to be invoked just once per event.
-     */
-    function snapshot(event) {
-        let listener;
-        const emitter = new Emitter({
-            onFirstListenerAdd() {
-                listener = event(emitter.fire, emitter);
-            },
-            onLastListenerRemove() {
-                listener.dispose();
-            },
-        });
-        return emitter.event;
-    }
-    Event.snapshot = snapshot;
-    function debounce(event, merge, delay = 100, leading = false, leakWarningThreshold) {
-        let subscription;
-        let output;
-        let handle;
-        let numDebouncedCalls = 0;
-        const emitter = new Emitter({
-            leakWarningThreshold,
-            onFirstListenerAdd() {
-                subscription = event((cur) => {
-                    numDebouncedCalls++;
-                    output = merge(output, cur);
-                    if (leading && !handle) {
-                        emitter.fire(output);
-                    }
-                    clearTimeout(handle);
-                    handle = setTimeout(() => {
-                        const _output = output;
-                        output = undefined;
-                        handle = undefined;
-                        if (!leading || numDebouncedCalls > 1) {
-                            emitter.fire(_output);
-                        }
-                        numDebouncedCalls = 0;
-                    }, delay);
-                });
-            },
-            onLastListenerRemove() {
-                subscription.dispose();
-            },
-        });
-        return emitter.event;
-    }
-    Event.debounce = debounce;
-    /**
-     * Given an event, it returns another event which fires only once and as soon as
-     * the input event emits. The event data is the number of millis it took for the
-     * event to fire.
-     */
-    function stopwatch(event) {
-        const start = new Date().getTime();
-        return map(once(event), (_) => new Date().getTime() - start);
-    }
-    Event.stopwatch = stopwatch;
-    /**
-     * Given an event, it returns another event which fires only when the event
-     * element changes.
-     */
-    function latch(event) {
-        let firstCall = true;
-        let cache;
-        return filter(event, (value) => {
-            const shouldEmit = firstCall || value !== cache;
-            firstCall = false;
-            cache = value;
-            return shouldEmit;
-        });
-    }
-    Event.latch = latch;
-    /**
-     * Buffers the provided event until a first listener comes
-     * along, at which point fire all the events at once and
-     * pipe the event from then on.
-     *
-     * ```typescript
-     * const emitter = new Emitter<number>();
-     * const event = emitter.event;
-     * const bufferedEvent = buffer(event);
-     *
-     * emitter.fire(1);
-     * emitter.fire(2);
-     * emitter.fire(3);
-     * // nothing...
-     *
-     * const listener = bufferedEvent(num => console.log(num));
-     * // 1, 2, 3
-     *
-     * emitter.fire(4);
-     * // 4
-     * ```
-     */
-    function buffer(event, nextTick = false, _buffer = []) {
-        let buffer = _buffer.slice();
-        let listener = event((e) => {
-            if (buffer) {
-                buffer.push(e);
-            }
-            else {
-                emitter.fire(e);
-            }
-        });
-        const flush = () => {
-            if (buffer) {
-                buffer.forEach((e) => emitter.fire(e));
-            }
-            buffer = null;
-        };
-        const emitter = new Emitter({
-            onFirstListenerAdd() {
-                if (!listener) {
-                    listener = event((e) => emitter.fire(e));
-                }
-            },
-            onFirstListenerDidAdd() {
-                if (buffer) {
-                    if (nextTick) {
-                        setTimeout(flush);
-                    }
-                    else {
-                        flush();
-                    }
-                }
-            },
-            onLastListenerRemove() {
-                if (listener) {
-                    listener.dispose();
-                }
-                listener = null;
-            },
-        });
-        return emitter.event;
-    }
-    Event.buffer = buffer;
-    class ChainableEvent {
-        constructor(event) {
-            this.event = event;
-        }
-        map(fn) {
-            return new ChainableEvent(map(this.event, fn));
-        }
-        forEach(fn) {
-            return new ChainableEvent(forEach(this.event, fn));
-        }
-        filter(fn) {
-            return new ChainableEvent(filter(this.event, fn));
-        }
-        reduce(merge, initial) {
-            return new ChainableEvent(reduce(this.event, merge, initial));
-        }
-        latch() {
-            return new ChainableEvent(latch(this.event));
-        }
-        on(listener, thisArgs, disposables) {
-            return this.event(listener, thisArgs, disposables);
-        }
-        once(listener, thisArgs, disposables) {
-            return once(this.event)(listener, thisArgs, disposables);
-        }
-    }
-    function chain(event) {
-        return new ChainableEvent(event);
-    }
-    Event.chain = chain;
-    function fromNodeEventEmitter(emitter, eventName, map = (id) => id) {
-        const fn = (...args) => result.fire(map(...args));
-        const onFirstListenerAdd = () => emitter.on(eventName, fn);
-        const onLastListenerRemove = () => emitter.removeListener(eventName, fn);
-        const result = new Emitter({ onFirstListenerAdd, onLastListenerRemove });
-        return result.event;
-    }
-    Event.fromNodeEventEmitter = fromNodeEventEmitter;
-    function fromPromise(promise) {
-        const emitter = new Emitter();
-        let shouldEmit = false;
-        promise
-            .then(undefined, () => null)
-            .then(() => {
-            if (!shouldEmit) {
-                setTimeout(() => emitter.fire(undefined), 0);
-            }
-            else {
-                emitter.fire(undefined);
-            }
-        });
-        shouldEmit = true;
-        return emitter.event;
-    }
-    Event.fromPromise = fromPromise;
-    function toPromise(event) {
-        return new Promise((c) => once(event)(c));
-    }
-    Event.toPromise = toPromise;
-})(Event = exports.Event || (exports.Event = {}));
-let _globalLeakWarningThreshold = -1;
-function setGlobalLeakWarningThreshold(n) {
-    const oldValue = _globalLeakWarningThreshold;
-    _globalLeakWarningThreshold = n;
-    return {
-        dispose() {
-            _globalLeakWarningThreshold = oldValue;
-        },
-    };
-}
-exports.setGlobalLeakWarningThreshold = setGlobalLeakWarningThreshold;
-class LeakageMonitor {
-    constructor(customThreshold, name = Math.random().toString(18).slice(2, 5)) {
-        this.customThreshold = customThreshold;
-        this.name = name;
-        this._warnCountdown = 0;
-    }
-    dispose() {
-        if (this._stacks) {
-            this._stacks.clear();
-        }
-    }
-    check(listenerCount) {
-        let threshold = _globalLeakWarningThreshold;
-        if (typeof this.customThreshold === 'number') {
-            threshold = this.customThreshold;
-        }
-        if (threshold <= 0 || listenerCount < threshold) {
-            return undefined;
-        }
-        if (!this._stacks) {
-            this._stacks = new Map();
-        }
-        const stack = new Error().stack.split('\n').slice(3).join('\n');
-        const count = this._stacks.get(stack) || 0;
-        this._stacks.set(stack, count + 1);
-        this._warnCountdown -= 1;
-        if (this._warnCountdown <= 0) {
-            // only warn on first exceed and then every time the limit
-            // is exceeded by 50% again
-            this._warnCountdown = threshold * 0.5;
-            // find most frequent listener and print warning
-            let topStack = '';
-            let topCount = 0;
-            this._stacks.forEach((count, stack) => {
-                if (!topStack || topCount < count) {
-                    topStack = stack;
-                    topCount = count;
-                }
-            });
-            // eslint-disable-next-line no-console
-            console.warn(`[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`);
-            // eslint-disable-next-line no-console
-            console.warn(topStack);
-        }
-        return () => {
-            const count = this._stacks.get(stack) || 0;
-            this._stacks.set(stack, count - 1);
-        };
-    }
-}
-class Emitter {
-    constructor(options) {
-        this._disposed = false;
-        this._options = options;
-        this._leakageMon =
-            _globalLeakWarningThreshold > 0
-                ? new LeakageMonitor(this._options && this._options.leakWarningThreshold)
-                : undefined;
-    }
-    /**
-     * For the public to allow to subscribe
-     * to events from this Emitter
-     */
-    get event() {
-        if (!this._event) {
-            this._event = (listener, thisArgs, disposables) => {
-                if (!this._listeners) {
-                    this._listeners = new linked_list_1.LinkedList();
-                }
-                const firstListener = this._listeners.isEmpty();
-                if (firstListener && this._options && this._options.onFirstListenerAdd) {
-                    this._options.onFirstListenerAdd(this);
-                }
-                const remove = this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);
-                if (firstListener && this._options && this._options.onFirstListenerDidAdd) {
-                    this._options.onFirstListenerDidAdd(this);
-                }
-                if (this._options && this._options.onListenerDidAdd) {
-                    this._options.onListenerDidAdd(this, listener, thisArgs);
-                }
-                // check and record this emitter for potential leakage
-                let removeMonitor;
-                if (this._leakageMon) {
-                    removeMonitor = this._leakageMon.check(this._listeners.size);
-                }
-                let result;
-                result = {
-                    dispose: () => {
-                        if (removeMonitor) {
-                            removeMonitor();
-                        }
-                        result.dispose = Emitter._noop;
-                        if (!this._disposed) {
-                            remove();
-                            if (this._options && this._options.onLastListenerRemove) {
-                                const hasListeners = this._listeners && !this._listeners.isEmpty();
-                                if (!hasListeners) {
-                                    this._options.onLastListenerRemove(this);
-                                }
-                            }
-                        }
-                    },
-                };
-                if (disposables instanceof disposable_1.DisposableStore) {
-                    disposables.add(result);
-                }
-                else if (Array.isArray(disposables)) {
-                    disposables.push(result);
-                }
-                return result;
-            };
-        }
-        return this._event;
-    }
-    /**
-     * To be kept private to fire an event to
-     * subscribers
-     */
-    fire(event) {
-        if (this._listeners) {
-            // put all [listener,event]-pairs into delivery queue
-            // then emit all event. an inner/nested event might be
-            // the driver of this
-            if (!this._deliveryQueue) {
-                this._deliveryQueue = new linked_list_1.LinkedList();
-            }
-            for (let iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {
-                this._deliveryQueue.push([e.value, event]);
-            }
-            while (this._deliveryQueue.size > 0) {
-                const [listener, event] = this._deliveryQueue.shift();
-                try {
-                    if (typeof listener === 'function') {
-                        listener.call(undefined, event);
-                    }
-                    else {
-                        listener[0].call(listener[1], event);
-                    }
-                }
-                catch (e) {
-                    (0, errors_1.onUnexpectedError)(e);
-                }
-            }
-        }
-    }
-    /**
-     * 发送一个异步事件，等待所有监听器返回，并收集返回值
-     * @param e
-     * @param timeout
-     */
-    async fireAndAwait(event, timeout = 2000) {
-        if (this._listeners) {
-            if (!this._deliveryQueue) {
-                this._deliveryQueue = new linked_list_1.LinkedList();
-            }
-            for (let iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {
-                this._deliveryQueue.push([e.value, event]);
-            }
-            const promises = [];
-            const timeoutPromise = new Promise((resolve) => {
-                setTimeout(() => {
-                    resolve({
-                        err: new Error('timeout'),
-                    });
-                }, timeout);
-            });
-            while (this._deliveryQueue.size > 0) {
-                const [listener, event] = this._deliveryQueue.shift();
-                try {
-                    const promise = (async () => {
-                        try {
-                            if (typeof listener === 'function') {
-                                return {
-                                    result: (await listener.call(undefined, event)),
-                                };
-                            }
-                            else {
-                                return {
-                                    result: (await listener[0].call(listener[1], event)),
-                                };
-                            }
-                        }
-                        catch (e) {
-                            return {
-                                err: e,
-                            };
-                        }
-                    })();
-                    promises.push(Promise.race([timeoutPromise, promise]));
-                }
-                catch (e) {
-                    (0, errors_1.onUnexpectedError)(e);
-                }
-            }
-            return Promise.all(promises);
-        }
-        else {
-            return [];
-        }
-    }
-    get listenerSize() {
-        return this._listeners ? this._listeners.size : 0;
-    }
-    dispose() {
-        if (this._listeners) {
-            this._listeners.clear();
-        }
-        if (this._deliveryQueue) {
-            this._deliveryQueue.clear();
-        }
-        if (this._leakageMon) {
-            this._leakageMon.dispose();
-        }
-        this._disposed = true;
-    }
-}
-exports.Emitter = Emitter;
-Emitter._noop = function () { };
-class PauseableEmitter extends Emitter {
-    constructor(options) {
-        super(options);
-        this._isPaused = 0;
-        this._eventQueue = new linked_list_1.LinkedList();
-        this._mergeFn = options && options.merge;
-    }
-    pause() {
-        this._isPaused++;
-    }
-    resume() {
-        if (this._isPaused !== 0 && --this._isPaused === 0) {
-            if (this._mergeFn) {
-                // use the merge function to create a single composite
-                // event. make a copy in case firing pauses this emitter
-                const events = this._eventQueue.toArray();
-                this._eventQueue.clear();
-                super.fire(this._mergeFn(events));
-            }
-            else {
-                // no merging, fire each event individually and test
-                // that this emitter isn't paused halfway through
-                while (!this._isPaused && this._eventQueue.size !== 0) {
-                    super.fire(this._eventQueue.shift());
-                }
-            }
-        }
-    }
-    fire(event) {
-        if (this._listeners) {
-            if (this._isPaused !== 0) {
-                this._eventQueue.push(event);
-            }
-            else {
-                super.fire(event);
-            }
-        }
-    }
-}
-exports.PauseableEmitter = PauseableEmitter;
-var WaitUntilEvent;
-(function (WaitUntilEvent) {
-    async function fire(emitter, event, timeout = undefined) {
-        const waitables = [];
-        const asyncEvent = Object.assign(event, {
-            waitUntil: (thenable) => {
-                if (Object.isFrozen(waitables)) {
-                    throw new Error('waitUntil cannot be called asynchronously.');
-                }
-                waitables.push(thenable);
-            },
-        });
-        emitter.fire(asyncEvent);
-        // Asynchronous calls to `waitUntil` should fail.
-        Object.freeze(waitables);
-        // ts 要求 delete 的属性是 optional
-        delete asyncEvent.waitUntil;
-        if (!waitables.length) {
-            return;
-        }
-        if (timeout !== undefined) {
-            await Promise.race([Promise.all(waitables), new Promise((resolve) => setTimeout(resolve, timeout))]);
-        }
-        else {
-            await Promise.all(waitables);
-        }
-    }
-    WaitUntilEvent.fire = fire;
-})(WaitUntilEvent = exports.WaitUntilEvent || (exports.WaitUntilEvent = {}));
-class AsyncEmitter extends Emitter {
-    async fireAsync(data, token, promiseJoin) {
-        if (!this._listeners) {
-            return;
-        }
-        if (!this._asyncDeliveryQueue) {
-            this._asyncDeliveryQueue = new linked_list_1.LinkedList();
-        }
-        for (let iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {
-            this._asyncDeliveryQueue.push([e.value, data]);
-        }
-        while (this._asyncDeliveryQueue.size > 0 && !token.isCancellationRequested) {
-            const [listener, data] = this._asyncDeliveryQueue.shift();
-            const thenables = [];
-            const event = Object.assign(Object.assign({}, data), { waitUntil: (p) => {
-                    if (Object.isFrozen(thenables)) {
-                        throw new Error('waitUntil can NOT be called asynchronous');
-                    }
-                    if (promiseJoin) {
-                        p = promiseJoin(p, typeof listener === 'function' ? listener : listener[0]);
-                    }
-                    thenables.push(p);
-                } });
-            try {
-                if (typeof listener === 'function') {
-                    listener.call(undefined, event);
-                }
-                else {
-                    listener[0].call(listener[1], event);
-                }
-            }
-            catch (e) {
-                (0, errors_1.onUnexpectedError)(e);
-                continue;
-            }
-            // freeze thenables-collection to enforce sync-calls to
-            // wait until and then wait for all thenables to resolve
-            Object.freeze(thenables);
-            await Promise.all(
-            // Promise.allSettled 只有 core-js3 才支持，先手动加 catch 处理下
-            thenables.map((thenable) => thenable.catch((e) => e))).catch((e) => (0, errors_1.onUnexpectedError)(e));
-        }
-    }
-}
-exports.AsyncEmitter = AsyncEmitter;
-class EventMultiplexer {
-    constructor() {
-        this.hasListeners = false;
-        this.events = [];
-        this.emitter = new Emitter({
-            onFirstListenerAdd: () => this.onFirstListenerAdd(),
-            onLastListenerRemove: () => this.onLastListenerRemove(),
-        });
-    }
-    get event() {
-        return this.emitter.event;
-    }
-    add(event) {
-        const e = { event, listener: null };
-        this.events.push(e);
-        if (this.hasListeners) {
-            this.hook(e);
-        }
-        const dispose = () => {
-            if (this.hasListeners) {
-                this.unhook(e);
-            }
-            const idx = this.events.indexOf(e);
-            this.events.splice(idx, 1);
-        };
-        return (0, disposable_1.toDisposable)((0, functional_1.once)(dispose));
-    }
-    onFirstListenerAdd() {
-        this.hasListeners = true;
-        this.events.forEach((e) => this.hook(e));
-    }
-    onLastListenerRemove() {
-        this.hasListeners = false;
-        this.events.forEach((e) => this.unhook(e));
-    }
-    hook(e) {
-        e.listener = e.event((r) => this.emitter.fire(r));
-    }
-    unhook(e) {
-        if (e.listener) {
-            e.listener.dispose();
-        }
-        e.listener = null;
-    }
-    dispose() {
-        this.emitter.dispose();
-    }
-}
-exports.EventMultiplexer = EventMultiplexer;
-/**
- * The EventBufferer is useful in situations in which you want
- * to delay firing your events during some code.
- * You can wrap that code and be sure that the event will not
- * be fired during that wrap.
- *
- * ```
- * const emitter: Emitter;
- * const delayer = new EventDelayer();
- * const delayedEvent = delayer.wrapEvent(emitter.event);
- *
- * delayedEvent(console.log);
- *
- * delayer.bufferEvents(() => {
- *   emitter.fire(); // event will not be fired yet
- * });
- *
- * // event will only be fired at this point
- * ```
- */
-class EventBufferer {
-    constructor() {
-        this.buffers = [];
-    }
-    wrapEvent(event) {
-        return (listener, thisArgs, disposables) => event((i) => {
-            const buffer = this.buffers[this.buffers.length - 1];
-            if (buffer) {
-                buffer.push(() => listener.call(thisArgs, i));
-            }
-            else {
-                listener.call(thisArgs, i);
-            }
-        }, undefined, disposables);
-    }
-    bufferEvents(fn) {
-        const buffer = [];
-        this.buffers.push(buffer);
-        const r = fn();
-        this.buffers.pop();
-        buffer.forEach((flush) => flush());
-        return r;
-    }
-}
-exports.EventBufferer = EventBufferer;
-/**
- * A Relay is an event forwarder which functions as a replugabble event pipe.
- * Once created, you can connect an input event to it and it will simply forward
- * events from that input event through its own `event` property. The `input`
- * can be changed at any point in time.
- */
-class Relay {
-    constructor() {
-        this.listening = false;
-        this.inputEvent = Event.None;
-        this.inputEventListener = disposable_1.Disposable.None;
-        this.emitter = new Emitter({
-            onFirstListenerDidAdd: () => {
-                this.listening = true;
-                this.inputEventListener = this.inputEvent(this.emitter.fire, this.emitter);
-            },
-            onLastListenerRemove: () => {
-                this.listening = false;
-                this.inputEventListener.dispose();
-            },
-        });
-        this.event = this.emitter.event;
-    }
-    set input(event) {
-        this.inputEvent = event;
-        if (this.listening) {
-            this.inputEventListener.dispose();
-            this.inputEventListener = event(this.emitter.fire, this.emitter);
-        }
-    }
-    dispose() {
-        this.inputEventListener.dispose();
-        this.emitter.dispose();
-    }
-}
-exports.Relay = Relay;
-/**
- * 同步执行的 Ready， 对 ready 的实时响应比 promise 快，多用在需要快速响应初始化回调的场景
- */
-class ReadyEvent {
-    constructor() {
-        this._isReady = false;
-        this._param = undefined;
-        this._emitter = new Emitter();
-    }
-    onceReady(cb) {
-        if (this._isReady) {
-            try {
-                return Promise.resolve(cb(this._param));
-            }
-            catch (e) {
-                return Promise.reject(e);
-            }
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                this._emitter.event((param) => {
-                    try {
-                        resolve(cb(param));
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                });
-            });
-        }
-    }
-    ready(param) {
-        if (!this._isReady) {
-            this._isReady = true;
-            this._param = param;
-        }
-        this._emitter.fire(param);
-        this._emitter.dispose;
-        this._emitter = null;
-    }
-    dispose() {
-        if (this._emitter) {
-            this._emitter.dispose();
-        }
-    }
-}
-exports.ReadyEvent = ReadyEvent;
-//# sourceMappingURL=event.js.map