lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.87.cjs

@@ -1,80 +1,1355 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-var t = class FixedFIFO {
-    constructor(t) {
-        if (!(t > 0) || (t - 1 & t) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
-        this.buffer = new Array(t);
-        this.mask = t - 1;
-        this.top = 0;
-        this.btm = 0;
-        this.next = null;
-    }
-    clear() {
-        this.top = this.btm = 0;
-        this.next = null;
-        this.buffer.fill(undefined);
-    }
-    push(t) {
-        if (this.buffer[this.top] !== undefined) return false;
-        this.buffer[this.top] = t;
-        this.top = this.top + 1 & this.mask;
-        return true;
-    }
-    shift() {
-        const t = this.buffer[this.btm];
-        if (t === undefined) return undefined;
-        this.buffer[this.btm] = undefined;
-        this.btm = this.btm + 1 & this.mask;
-        return t;
-    }
-    peek() {
-        return this.buffer[this.btm];
-    }
-    isEmpty() {
-        return this.buffer[this.btm] === undefined;
-    }
+var e = {
+    exports: {}
 };
 
-const i = t;
-
-exports.fastFifo = class FastFIFO {
-    constructor(t) {
-        this.hwm = t || 16;
-        this.head = new i(this.hwm);
-        this.tail = this.head;
-        this.length = 0;
-    }
-    clear() {
-        this.head = this.tail;
-        this.head.clear();
-        this.length = 0;
-    }
-    push(t) {
-        this.length++;
-        if (!this.head.push(t)) {
-            const s = this.head;
-            this.head = s.next = new i(2 * this.head.buffer.length);
-            this.head.push(t);
-        }
-    }
-    shift() {
-        if (this.length !== 0) this.length--;
-        const t = this.tail.shift();
-        if (t === undefined && this.tail.next) {
-            const t = this.tail.next;
-            this.tail.next = null;
-            this.tail = t;
-            return this.tail.shift();
-        }
-        return t;
-    }
-    peek() {
-        const t = this.tail.peek();
-        if (t === undefined && this.tail.next) return this.tail.next.peek();
-        return t;
-    }
-    isEmpty() {
-        return this.length === 0;
-    }
-};
+e.exports;
+
+(function(e, t) {
+    !function(t) {
+        var r = Object.hasOwnProperty;
+        var i = Array.isArray ? Array.isArray : function e(t) {
+            return Object.prototype.toString.call(t) === "[object Array]";
+        };
+        var n = 10;
+        var s = typeof process == "object" && typeof process.nextTick == "function";
+        var o = typeof Symbol === "function";
+        var l = typeof Reflect === "object";
+        var a = typeof setImmediate === "function";
+        var f = a ? setImmediate : setTimeout;
+        var h = o ? l && typeof Reflect.ownKeys === "function" ? Reflect.ownKeys : function(e) {
+            var t = Object.getOwnPropertyNames(e);
+            t.push.apply(t, Object.getOwnPropertySymbols(e));
+            return t;
+        } : Object.keys;
+        function u() {
+            this._events = {};
+            if (this._conf) {
+                c.call(this, this._conf);
+            }
+        }
+        function c(e) {
+            if (e) {
+                this._conf = e;
+                e.delimiter && (this.delimiter = e.delimiter);
+                if (e.maxListeners !== t) {
+                    this._maxListeners = e.maxListeners;
+                }
+                e.wildcard && (this.wildcard = e.wildcard);
+                e.newListener && (this._newListener = e.newListener);
+                e.removeListener && (this._removeListener = e.removeListener);
+                e.verboseMemoryLeak && (this.verboseMemoryLeak = e.verboseMemoryLeak);
+                e.ignoreErrors && (this.ignoreErrors = e.ignoreErrors);
+                if (this.wildcard) {
+                    this.listenerTree = {};
+                }
+            }
+        }
+        function v(e, t) {
+            var r = "(node) warning: possible EventEmitter memory " + "leak detected. " + e + " listeners added. " + "Use emitter.setMaxListeners() to increase limit.";
+            if (this.verboseMemoryLeak) {
+                r += " Event name: " + t + ".";
+            }
+            if (typeof process !== "undefined" && process.emitWarning) {
+                var i = new Error(r);
+                i.name = "MaxListenersExceededWarning";
+                i.emitter = this;
+                i.count = e;
+                process.emitWarning(i);
+            } else {
+                console.error(r);
+                if (console.trace) {
+                    console.trace();
+                }
+            }
+        }
+        var p = function(e, t, r) {
+            var i = arguments.length;
+            switch (i) {
+              case 0:
+                return [];
+
+              case 1:
+                return [ e ];
+
+              case 2:
+                return [ e, t ];
+
+              case 3:
+                return [ e, t, r ];
+
+              default:
+                var n = new Array(i);
+                while (i--) {
+                    n[i] = arguments[i];
+                }
+                return n;
+            }
+        };
+        function y(e, r) {
+            var i = {};
+            var n;
+            var s = e.length;
+            var o = 0;
+            for (var l = 0; l < s; l++) {
+                n = e[l];
+                i[n] = l < o ? r[l] : t;
+            }
+            return i;
+        }
+        function _(e, t, r) {
+            this._emitter = e;
+            this._target = t;
+            this._listeners = {};
+            this._listenersCount = 0;
+            var i, n;
+            if (r.on || r.off) {
+                i = r.on;
+                n = r.off;
+            }
+            if (t.addEventListener) {
+                i = t.addEventListener;
+                n = t.removeEventListener;
+            } else if (t.addListener) {
+                i = t.addListener;
+                n = t.removeListener;
+            } else if (t.on) {
+                i = t.on;
+                n = t.off;
+            }
+            if (!i && !n) {
+                throw Error("target does not implement any known event API");
+            }
+            if (typeof i !== "function") {
+                throw TypeError("on method must be a function");
+            }
+            if (typeof n !== "function") {
+                throw TypeError("off method must be a function");
+            }
+            this._on = i;
+            this._off = n;
+            var s = e._observers;
+            if (s) {
+                s.push(this);
+            } else {
+                e._observers = [ this ];
+            }
+        }
+        Object.assign(_.prototype, {
+            subscribe: function(e, t, r) {
+                var i = this;
+                var n = this._target;
+                var s = this._emitter;
+                var o = this._listeners;
+                var l = function() {
+                    var i = p.apply(null, arguments);
+                    var o = {
+                        data: i,
+                        name: t,
+                        original: e
+                    };
+                    if (r) {
+                        var l = r.call(n, o);
+                        if (l !== false) {
+                            s.emit.apply(s, [ o.name ].concat(i));
+                        }
+                        return;
+                    }
+                    s.emit.apply(s, [ t ].concat(i));
+                };
+                if (o[e]) {
+                    throw Error("Event '" + e + "' is already listening");
+                }
+                this._listenersCount++;
+                if (s._newListener && s._removeListener && !i._onNewListener) {
+                    this._onNewListener = function(r) {
+                        if (r === t && o[e] === null) {
+                            o[e] = l;
+                            i._on.call(n, e, l);
+                        }
+                    };
+                    s.on("newListener", this._onNewListener);
+                    this._onRemoveListener = function(r) {
+                        if (r === t && !s.hasListeners(r) && o[e]) {
+                            o[e] = null;
+                            i._off.call(n, e, l);
+                        }
+                    };
+                    o[e] = null;
+                    s.on("removeListener", this._onRemoveListener);
+                } else {
+                    o[e] = l;
+                    i._on.call(n, e, l);
+                }
+            },
+            unsubscribe: function(e) {
+                var t = this;
+                var r = this._listeners;
+                var i = this._emitter;
+                var n;
+                var s;
+                var o = this._off;
+                var l = this._target;
+                var a;
+                if (e && typeof e !== "string") {
+                    throw TypeError("event must be a string");
+                }
+                function f() {
+                    if (t._onNewListener) {
+                        i.off("newListener", t._onNewListener);
+                        i.off("removeListener", t._onRemoveListener);
+                        t._onNewListener = null;
+                        t._onRemoveListener = null;
+                    }
+                    var e = E.call(i, t);
+                    i._observers.splice(e, 1);
+                }
+                if (e) {
+                    n = r[e];
+                    if (!n) return;
+                    o.call(l, e, n);
+                    delete r[e];
+                    if (! --this._listenersCount) {
+                        f();
+                    }
+                } else {
+                    s = h(r);
+                    a = s.length;
+                    while (a-- > 0) {
+                        e = s[a];
+                        o.call(l, e, r[e]);
+                    }
+                    this._listeners = {};
+                    this._listenersCount = 0;
+                    f();
+                }
+            }
+        });
+        function m(e, i, n, s) {
+            var o = Object.assign({}, i);
+            if (!e) return o;
+            if (typeof e !== "object") {
+                throw TypeError("options must be an object");
+            }
+            var l = Object.keys(e);
+            var a = l.length;
+            var f, h;
+            var u;
+            function c(e) {
+                throw Error('Invalid "' + f + '" option value' + (e ? ". Reason: " + e : ""));
+            }
+            for (var v = 0; v < a; v++) {
+                f = l[v];
+                if (!r.call(i, f)) {
+                    throw Error('Unknown "' + f + '" option');
+                }
+                h = e[f];
+                if (h !== t) {
+                    u = n[f];
+                    o[f] = u ? u(h, c) : h;
+                }
+            }
+            return o;
+        }
+        function d(e, t) {
+            if (typeof e !== "function" || !e.hasOwnProperty("prototype")) {
+                t("value must be a constructor");
+            }
+            return e;
+        }
+        function w(e) {
+            var t = "value must be type of " + e.join("|");
+            var r = e.length;
+            var i = e[0];
+            var n = e[1];
+            if (r === 1) {
+                return function(e, r) {
+                    if (typeof e === i) {
+                        return e;
+                    }
+                    r(t);
+                };
+            }
+            if (r === 2) {
+                return function(e, r) {
+                    var s = typeof e;
+                    if (s === i || s === n) return e;
+                    r(t);
+                };
+            }
+            return function(i, n) {
+                var s = typeof i;
+                var o = r;
+                while (o-- > 0) {
+                    if (s === e[o]) return i;
+                }
+                n(t);
+            };
+        }
+        var b = w([ "function" ]);
+        var g = w([ "object", "function" ]);
+        function L(e, t, r) {
+            var i;
+            var n;
+            var s = 0;
+            var o;
+            var l = new e(function(a, f, h) {
+                r = m(r, {
+                    timeout: 0,
+                    overload: false
+                }, {
+                    timeout: function(e, t) {
+                        e *= 1;
+                        if (typeof e !== "number" || e < 0 || !Number.isFinite(e)) {
+                            t("timeout must be a positive number");
+                        }
+                        return e;
+                    }
+                });
+                i = !r.overload && typeof e.prototype.cancel === "function" && typeof h === "function";
+                function u() {
+                    if (n) {
+                        n = null;
+                    }
+                    if (s) {
+                        clearTimeout(s);
+                        s = 0;
+                    }
+                }
+                var c = function(e) {
+                    u();
+                    a(e);
+                };
+                var v = function(e) {
+                    u();
+                    f(e);
+                };
+                if (i) {
+                    t(c, v, h);
+                } else {
+                    n = [ function(e) {
+                        v(e || Error("canceled"));
+                    } ];
+                    t(c, v, function(e) {
+                        if (o) {
+                            throw Error("Unable to subscribe on cancel event asynchronously");
+                        }
+                        if (typeof e !== "function") {
+                            throw TypeError("onCancel callback must be a function");
+                        }
+                        n.push(e);
+                    });
+                    o = true;
+                }
+                if (r.timeout > 0) {
+                    s = setTimeout(function() {
+                        var e = Error("timeout");
+                        e.code = "ETIMEDOUT";
+                        s = 0;
+                        l.cancel(e);
+                        f(e);
+                    }, r.timeout);
+                }
+            });
+            if (!i) {
+                l.cancel = function(e) {
+                    if (!n) {
+                        return;
+                    }
+                    var t = n.length;
+                    for (var r = 1; r < t; r++) {
+                        n[r](e);
+                    }
+                    n[0](e);
+                    n = null;
+                };
+            }
+            return l;
+        }
+        function E(e) {
+            var t = this._observers;
+            if (!t) {
+                return -1;
+            }
+            var r = t.length;
+            for (var i = 0; i < r; i++) {
+                if (t[i]._target === e) return i;
+            }
+            return -1;
+        }
+        function k(e, t, r, i, n) {
+            if (!r) {
+                return null;
+            }
+            if (i === 0) {
+                var s = typeof t;
+                if (s === "string") {
+                    var o, l, a = 0, f = 0, u = this.delimiter, c = u.length;
+                    if ((l = t.indexOf(u)) !== -1) {
+                        o = new Array(5);
+                        do {
+                            o[a++] = t.slice(f, l);
+                            f = l + c;
+                        } while ((l = t.indexOf(u, f)) !== -1);
+                        o[a++] = t.slice(f);
+                        t = o;
+                        n = a;
+                    } else {
+                        t = [ t ];
+                        n = 1;
+                    }
+                } else if (s === "object") {
+                    n = t.length;
+                } else {
+                    t = [ t ];
+                    n = 1;
+                }
+            }
+            var v = null, p, y, _, m, d, w = t[i], b = t[i + 1], g, L;
+            if (i === n) {
+                if (r._listeners) {
+                    if (typeof r._listeners === "function") {
+                        e && e.push(r._listeners);
+                        v = [ r ];
+                    } else {
+                        e && e.push.apply(e, r._listeners);
+                        v = [ r ];
+                    }
+                }
+            } else {
+                if (w === "*") {
+                    g = h(r);
+                    l = g.length;
+                    while (l-- > 0) {
+                        p = g[l];
+                        if (p !== "_listeners") {
+                            L = k(e, t, r[p], i + 1, n);
+                            if (L) {
+                                if (v) {
+                                    v.push.apply(v, L);
+                                } else {
+                                    v = L;
+                                }
+                            }
+                        }
+                    }
+                    return v;
+                } else if (w === "**") {
+                    d = i + 1 === n || i + 2 === n && b === "*";
+                    if (d && r._listeners) {
+                        v = k(e, t, r, n, n);
+                    }
+                    g = h(r);
+                    l = g.length;
+                    while (l-- > 0) {
+                        p = g[l];
+                        if (p !== "_listeners") {
+                            if (p === "*" || p === "**") {
+                                if (r[p]._listeners && !d) {
+                                    L = k(e, t, r[p], n, n);
+                                    if (L) {
+                                        if (v) {
+                                            v.push.apply(v, L);
+                                        } else {
+                                            v = L;
+                                        }
+                                    }
+                                }
+                                L = k(e, t, r[p], i, n);
+                            } else if (p === b) {
+                                L = k(e, t, r[p], i + 2, n);
+                            } else {
+                                L = k(e, t, r[p], i, n);
+                            }
+                            if (L) {
+                                if (v) {
+                                    v.push.apply(v, L);
+                                } else {
+                                    v = L;
+                                }
+                            }
+                        }
+                    }
+                    return v;
+                } else if (r[w]) {
+                    v = k(e, t, r[w], i + 1, n);
+                }
+            }
+            y = r["*"];
+            if (y) {
+                k(e, t, y, i + 1, n);
+            }
+            _ = r["**"];
+            if (_) {
+                if (i < n) {
+                    if (_._listeners) {
+                        k(e, t, _, n, n);
+                    }
+                    g = h(_);
+                    l = g.length;
+                    while (l-- > 0) {
+                        p = g[l];
+                        if (p !== "_listeners") {
+                            if (p === b) {
+                                k(e, t, _[p], i + 2, n);
+                            } else if (p === w) {
+                                k(e, t, _[p], i + 1, n);
+                            } else {
+                                m = {};
+                                m[p] = _[p];
+                                k(e, t, {
+                                    "**": m
+                                }, i + 1, n);
+                            }
+                        }
+                    }
+                } else if (_._listeners) {
+                    k(e, t, _, n, n);
+                } else if (_["*"] && _["*"]._listeners) {
+                    k(e, t, _["*"], n, n);
+                }
+            }
+            return v;
+        }
+        function j(e, t, r) {
+            var i = 0, n = 0, s, o = this.delimiter, l = o.length, a;
+            if (typeof e === "string") {
+                if ((s = e.indexOf(o)) !== -1) {
+                    a = new Array(5);
+                    do {
+                        a[i++] = e.slice(n, s);
+                        n = s + l;
+                    } while ((s = e.indexOf(o, n)) !== -1);
+                    a[i++] = e.slice(n);
+                } else {
+                    a = [ e ];
+                    i = 1;
+                }
+            } else {
+                a = e;
+                i = e.length;
+            }
+            if (i > 1) {
+                for (s = 0; s + 1 < i; s++) {
+                    if (a[s] === "**" && a[s + 1] === "**") {
+                        return;
+                    }
+                }
+            }
+            var f = this.listenerTree, h;
+            for (s = 0; s < i; s++) {
+                h = a[s];
+                f = f[h] || (f[h] = {});
+                if (s === i - 1) {
+                    if (!f._listeners) {
+                        f._listeners = t;
+                    } else {
+                        if (typeof f._listeners === "function") {
+                            f._listeners = [ f._listeners ];
+                        }
+                        if (r) {
+                            f._listeners.unshift(t);
+                        } else {
+                            f._listeners.push(t);
+                        }
+                        if (!f._listeners.warned && this._maxListeners > 0 && f._listeners.length > this._maxListeners) {
+                            f._listeners.warned = true;
+                            v.call(this, f._listeners.length, h);
+                        }
+                    }
+                    return true;
+                }
+            }
+            return true;
+        }
+        function x(e, t, r, i) {
+            var n = h(e);
+            var s = n.length;
+            var o, l, a;
+            var f = e["_listeners"];
+            var u;
+            while (s-- > 0) {
+                l = n[s];
+                o = e[l];
+                if (l === "_listeners") {
+                    a = r;
+                } else {
+                    a = r ? r.concat(l) : [ l ];
+                }
+                u = i || typeof l === "symbol";
+                f && t.push(u ? a : a.join(this.delimiter));
+                if (typeof o === "object") {
+                    x.call(this, o, t, a, u);
+                }
+            }
+            return t;
+        }
+        function T(e) {
+            var t = h(e);
+            var r = t.length;
+            var i, n, s;
+            while (r-- > 0) {
+                n = t[r];
+                i = e[n];
+                if (i) {
+                    s = true;
+                    if (n !== "_listeners" && !T(i)) {
+                        delete e[n];
+                    }
+                }
+            }
+            return s;
+        }
+        function A(e, t, r) {
+            this.emitter = e;
+            this.event = t;
+            this.listener = r;
+        }
+        A.prototype.off = function() {
+            this.emitter.off(this.event, this.listener);
+            return this;
+        };
+        function P(e, r, i) {
+            if (i === true) {
+                o = true;
+            } else if (i === false) {
+                n = true;
+            } else {
+                if (!i || typeof i !== "object") {
+                    throw TypeError("options should be an object or true");
+                }
+                var n = i.async;
+                var o = i.promisify;
+                var l = i.nextTick;
+                var a = i.objectify;
+            }
+            if (n || l || o) {
+                var h = r;
+                var u = r._origin || r;
+                if (l && !s) {
+                    throw Error("process.nextTick is not supported");
+                }
+                if (o === t) {
+                    o = r.constructor.name === "AsyncFunction";
+                }
+                r = function() {
+                    var e = arguments;
+                    var t = this;
+                    var r = this.event;
+                    return o ? l ? Promise.resolve() : new Promise(function(e) {
+                        f(e);
+                    }).then(function() {
+                        t.event = r;
+                        return h.apply(t, e);
+                    }) : (l ? process.nextTick : f)(function() {
+                        t.event = r;
+                        h.apply(t, e);
+                    });
+                };
+                r._async = true;
+                r._origin = u;
+            }
+            return [ r, a ? new A(this, e, r) : this ];
+        }
+        function O(e) {
+            this._events = {};
+            this._newListener = false;
+            this._removeListener = false;
+            this.verboseMemoryLeak = false;
+            c.call(this, e);
+        }
+        O.EventEmitter2 = O;
+        O.prototype.listenTo = function(e, r, n) {
+            if (typeof e !== "object") {
+                throw TypeError("target musts be an object");
+            }
+            var s = this;
+            n = m(n, {
+                on: t,
+                off: t,
+                reducers: t
+            }, {
+                on: b,
+                off: b,
+                reducers: g
+            });
+            function o(t) {
+                if (typeof t !== "object") {
+                    throw TypeError("events must be an object");
+                }
+                var r = n.reducers;
+                var i = E.call(s, e);
+                var o;
+                if (i === -1) {
+                    o = new _(s, e, n);
+                } else {
+                    o = s._observers[i];
+                }
+                var l = h(t);
+                var a = l.length;
+                var f;
+                var u = typeof r === "function";
+                for (var c = 0; c < a; c++) {
+                    f = l[c];
+                    o.subscribe(f, t[f] || f, u ? r : r && r[f]);
+                }
+            }
+            i(r) ? o(y(r)) : typeof r === "string" ? o(y(r.split(/\s+/))) : o(r);
+            return this;
+        };
+        O.prototype.stopListeningTo = function(e, t) {
+            var r = this._observers;
+            if (!r) {
+                return false;
+            }
+            var i = r.length;
+            var n;
+            var s = false;
+            if (e && typeof e !== "object") {
+                throw TypeError("target should be an object");
+            }
+            while (i-- > 0) {
+                n = r[i];
+                if (!e || n._target === e) {
+                    n.unsubscribe(t);
+                    s = true;
+                }
+            }
+            return s;
+        };
+        O.prototype.delimiter = ".";
+        O.prototype.setMaxListeners = function(e) {
+            if (e !== t) {
+                this._maxListeners = e;
+                if (!this._conf) this._conf = {};
+                this._conf.maxListeners = e;
+            }
+        };
+        O.prototype.getMaxListeners = function() {
+            return this._maxListeners;
+        };
+        O.prototype.event = "";
+        O.prototype.once = function(e, t, r) {
+            return this._once(e, t, false, r);
+        };
+        O.prototype.prependOnceListener = function(e, t, r) {
+            return this._once(e, t, true, r);
+        };
+        O.prototype._once = function(e, t, r, i) {
+            return this._many(e, 1, t, r, i);
+        };
+        O.prototype.many = function(e, t, r, i) {
+            return this._many(e, t, r, false, i);
+        };
+        O.prototype.prependMany = function(e, t, r, i) {
+            return this._many(e, t, r, true, i);
+        };
+        O.prototype._many = function(e, t, r, i, n) {
+            var s = this;
+            if (typeof r !== "function") {
+                throw new Error("many only accepts instances of Function");
+            }
+            function o() {
+                if (--t === 0) {
+                    s.off(e, o);
+                }
+                return r.apply(this, arguments);
+            }
+            o._origin = r;
+            return this._on(e, o, i, n);
+        };
+        O.prototype.emit = function() {
+            if (!this._events && !this._all) {
+                return false;
+            }
+            this._events || u.call(this);
+            var e = arguments[0], t, r = this.wildcard;
+            var i, n, s, l, a;
+            if (e === "newListener" && !this._newListener) {
+                if (!this._events.newListener) {
+                    return false;
+                }
+            }
+            if (r) {
+                t = e;
+                if (e !== "newListener" && e !== "removeListener") {
+                    if (typeof e === "object") {
+                        n = e.length;
+                        if (o) {
+                            for (s = 0; s < n; s++) {
+                                if (typeof e[s] === "symbol") {
+                                    a = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!a) {
+                            e = e.join(this.delimiter);
+                        }
+                    }
+                }
+            }
+            var f = arguments.length;
+            var h;
+            if (this._all && this._all.length) {
+                h = this._all.slice();
+                for (s = 0, n = h.length; s < n; s++) {
+                    this.event = e;
+                    switch (f) {
+                      case 1:
+                        h[s].call(this, e);
+                        break;
+
+                      case 2:
+                        h[s].call(this, e, arguments[1]);
+                        break;
+
+                      case 3:
+                        h[s].call(this, e, arguments[1], arguments[2]);
+                        break;
+
+                      default:
+                        h[s].apply(this, arguments);
+                    }
+                }
+            }
+            if (r) {
+                h = [];
+                k.call(this, h, t, this.listenerTree, 0, n);
+            } else {
+                h = this._events[e];
+                if (typeof h === "function") {
+                    this.event = e;
+                    switch (f) {
+                      case 1:
+                        h.call(this);
+                        break;
+
+                      case 2:
+                        h.call(this, arguments[1]);
+                        break;
+
+                      case 3:
+                        h.call(this, arguments[1], arguments[2]);
+                        break;
+
+                      default:
+                        i = new Array(f - 1);
+                        for (l = 1; l < f; l++) i[l - 1] = arguments[l];
+                        h.apply(this, i);
+                    }
+                    return true;
+                } else if (h) {
+                    h = h.slice();
+                }
+            }
+            if (h && h.length) {
+                if (f > 3) {
+                    i = new Array(f - 1);
+                    for (l = 1; l < f; l++) i[l - 1] = arguments[l];
+                }
+                for (s = 0, n = h.length; s < n; s++) {
+                    this.event = e;
+                    switch (f) {
+                      case 1:
+                        h[s].call(this);
+                        break;
+
+                      case 2:
+                        h[s].call(this, arguments[1]);
+                        break;
+
+                      case 3:
+                        h[s].call(this, arguments[1], arguments[2]);
+                        break;
+
+                      default:
+                        h[s].apply(this, i);
+                    }
+                }
+                return true;
+            } else if (!this.ignoreErrors && !this._all && e === "error") {
+                if (arguments[1] instanceof Error) {
+                    throw arguments[1];
+                } else {
+                    throw new Error("Uncaught, unspecified 'error' event.");
+                }
+            }
+            return !!this._all;
+        };
+        O.prototype.emitAsync = function() {
+            if (!this._events && !this._all) {
+                return false;
+            }
+            this._events || u.call(this);
+            var e = arguments[0], t = this.wildcard, r, i;
+            var n, s, l, a;
+            if (e === "newListener" && !this._newListener) {
+                if (!this._events.newListener) {
+                    return Promise.resolve([ false ]);
+                }
+            }
+            if (t) {
+                r = e;
+                if (e !== "newListener" && e !== "removeListener") {
+                    if (typeof e === "object") {
+                        s = e.length;
+                        if (o) {
+                            for (l = 0; l < s; l++) {
+                                if (typeof e[l] === "symbol") {
+                                    i = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!i) {
+                            e = e.join(this.delimiter);
+                        }
+                    }
+                }
+            }
+            var f = [];
+            var h = arguments.length;
+            var c;
+            if (this._all) {
+                for (l = 0, s = this._all.length; l < s; l++) {
+                    this.event = e;
+                    switch (h) {
+                      case 1:
+                        f.push(this._all[l].call(this, e));
+                        break;
+
+                      case 2:
+                        f.push(this._all[l].call(this, e, arguments[1]));
+                        break;
+
+                      case 3:
+                        f.push(this._all[l].call(this, e, arguments[1], arguments[2]));
+                        break;
+
+                      default:
+                        f.push(this._all[l].apply(this, arguments));
+                    }
+                }
+            }
+            if (t) {
+                c = [];
+                k.call(this, c, r, this.listenerTree, 0);
+            } else {
+                c = this._events[e];
+            }
+            if (typeof c === "function") {
+                this.event = e;
+                switch (h) {
+                  case 1:
+                    f.push(c.call(this));
+                    break;
+
+                  case 2:
+                    f.push(c.call(this, arguments[1]));
+                    break;
+
+                  case 3:
+                    f.push(c.call(this, arguments[1], arguments[2]));
+                    break;
+
+                  default:
+                    n = new Array(h - 1);
+                    for (a = 1; a < h; a++) n[a - 1] = arguments[a];
+                    f.push(c.apply(this, n));
+                }
+            } else if (c && c.length) {
+                c = c.slice();
+                if (h > 3) {
+                    n = new Array(h - 1);
+                    for (a = 1; a < h; a++) n[a - 1] = arguments[a];
+                }
+                for (l = 0, s = c.length; l < s; l++) {
+                    this.event = e;
+                    switch (h) {
+                      case 1:
+                        f.push(c[l].call(this));
+                        break;
+
+                      case 2:
+                        f.push(c[l].call(this, arguments[1]));
+                        break;
+
+                      case 3:
+                        f.push(c[l].call(this, arguments[1], arguments[2]));
+                        break;
+
+                      default:
+                        f.push(c[l].apply(this, n));
+                    }
+                }
+            } else if (!this.ignoreErrors && !this._all && e === "error") {
+                if (arguments[1] instanceof Error) {
+                    return Promise.reject(arguments[1]);
+                } else {
+                    return Promise.reject("Uncaught, unspecified 'error' event.");
+                }
+            }
+            return Promise.all(f);
+        };
+        O.prototype.on = function(e, t, r) {
+            return this._on(e, t, false, r);
+        };
+        O.prototype.prependListener = function(e, t, r) {
+            return this._on(e, t, true, r);
+        };
+        O.prototype.onAny = function(e) {
+            return this._onAny(e, false);
+        };
+        O.prototype.prependAny = function(e) {
+            return this._onAny(e, true);
+        };
+        O.prototype.addListener = O.prototype.on;
+        O.prototype._onAny = function(e, t) {
+            if (typeof e !== "function") {
+                throw new Error("onAny only accepts instances of Function");
+            }
+            if (!this._all) {
+                this._all = [];
+            }
+            if (t) {
+                this._all.unshift(e);
+            } else {
+                this._all.push(e);
+            }
+            return this;
+        };
+        O.prototype._on = function(e, r, i, n) {
+            if (typeof e === "function") {
+                this._onAny(e, r);
+                return this;
+            }
+            if (typeof r !== "function") {
+                throw new Error("on only accepts instances of Function");
+            }
+            this._events || u.call(this);
+            var s = this, o;
+            if (n !== t) {
+                o = P.call(this, e, r, n);
+                r = o[0];
+                s = o[1];
+            }
+            if (this._newListener) {
+                this.emit("newListener", e, r);
+            }
+            if (this.wildcard) {
+                j.call(this, e, r, i);
+                return s;
+            }
+            if (!this._events[e]) {
+                this._events[e] = r;
+            } else {
+                if (typeof this._events[e] === "function") {
+                    this._events[e] = [ this._events[e] ];
+                }
+                if (i) {
+                    this._events[e].unshift(r);
+                } else {
+                    this._events[e].push(r);
+                }
+                if (!this._events[e].warned && this._maxListeners > 0 && this._events[e].length > this._maxListeners) {
+                    this._events[e].warned = true;
+                    v.call(this, this._events[e].length, e);
+                }
+            }
+            return s;
+        };
+        O.prototype.off = function(e, t) {
+            if (typeof t !== "function") {
+                throw new Error("removeListener only takes instances of Function");
+            }
+            var r, n = [];
+            if (this.wildcard) {
+                var s = typeof e === "string" ? e.split(this.delimiter) : e.slice();
+                n = k.call(this, null, s, this.listenerTree, 0);
+                if (!n) return this;
+            } else {
+                if (!this._events[e]) return this;
+                r = this._events[e];
+                n.push({
+                    _listeners: r
+                });
+            }
+            for (var o = 0; o < n.length; o++) {
+                var l = n[o];
+                r = l._listeners;
+                if (i(r)) {
+                    var a = -1;
+                    for (var f = 0, h = r.length; f < h; f++) {
+                        if (r[f] === t || r[f].listener && r[f].listener === t || r[f]._origin && r[f]._origin === t) {
+                            a = f;
+                            break;
+                        }
+                    }
+                    if (a < 0) {
+                        continue;
+                    }
+                    if (this.wildcard) {
+                        l._listeners.splice(a, 1);
+                    } else {
+                        this._events[e].splice(a, 1);
+                    }
+                    if (r.length === 0) {
+                        if (this.wildcard) {
+                            delete l._listeners;
+                        } else {
+                            delete this._events[e];
+                        }
+                    }
+                    if (this._removeListener) this.emit("removeListener", e, t);
+                    return this;
+                } else if (r === t || r.listener && r.listener === t || r._origin && r._origin === t) {
+                    if (this.wildcard) {
+                        delete l._listeners;
+                    } else {
+                        delete this._events[e];
+                    }
+                    if (this._removeListener) this.emit("removeListener", e, t);
+                }
+            }
+            this.listenerTree && T(this.listenerTree);
+            return this;
+        };
+        O.prototype.offAny = function(e) {
+            var t = 0, r = 0, i;
+            if (e && this._all && this._all.length > 0) {
+                i = this._all;
+                for (t = 0, r = i.length; t < r; t++) {
+                    if (e === i[t]) {
+                        i.splice(t, 1);
+                        if (this._removeListener) this.emit("removeListenerAny", e);
+                        return this;
+                    }
+                }
+            } else {
+                i = this._all;
+                if (this._removeListener) {
+                    for (t = 0, r = i.length; t < r; t++) this.emit("removeListenerAny", i[t]);
+                }
+                this._all = [];
+            }
+            return this;
+        };
+        O.prototype.removeListener = O.prototype.off;
+        O.prototype.removeAllListeners = function(e) {
+            if (e === t) {
+                !this._events || u.call(this);
+                return this;
+            }
+            if (this.wildcard) {
+                var r = k.call(this, null, e, this.listenerTree, 0), i, n;
+                if (!r) return this;
+                for (n = 0; n < r.length; n++) {
+                    i = r[n];
+                    i._listeners = null;
+                }
+                this.listenerTree && T(this.listenerTree);
+            } else if (this._events) {
+                this._events[e] = null;
+            }
+            return this;
+        };
+        O.prototype.listeners = function(e) {
+            var r = this._events;
+            var i, n, s;
+            var o;
+            var l;
+            if (e === t) {
+                if (this.wildcard) {
+                    throw Error("event name required for wildcard emitter");
+                }
+                if (!r) {
+                    return [];
+                }
+                i = h(r);
+                o = i.length;
+                s = [];
+                while (o-- > 0) {
+                    n = r[i[o]];
+                    if (typeof n === "function") {
+                        s.push(n);
+                    } else {
+                        s.push.apply(s, n);
+                    }
+                }
+                return s;
+            } else {
+                if (this.wildcard) {
+                    l = this.listenerTree;
+                    if (!l) return [];
+                    var a = [];
+                    var f = typeof e === "string" ? e.split(this.delimiter) : e.slice();
+                    k.call(this, a, f, l, 0);
+                    return a;
+                }
+                if (!r) {
+                    return [];
+                }
+                n = r[e];
+                if (!n) {
+                    return [];
+                }
+                return typeof n === "function" ? [ n ] : n;
+            }
+        };
+        O.prototype.eventNames = function(e) {
+            var t = this._events;
+            return this.wildcard ? x.call(this, this.listenerTree, [], null, e) : t ? h(t) : [];
+        };
+        O.prototype.listenerCount = function(e) {
+            return this.listeners(e).length;
+        };
+        O.prototype.hasListeners = function(e) {
+            if (this.wildcard) {
+                var r = [];
+                var i = typeof e === "string" ? e.split(this.delimiter) : e.slice();
+                k.call(this, r, i, this.listenerTree, 0);
+                return r.length > 0;
+            }
+            var n = this._events;
+            var s = this._all;
+            return !!(s && s.length || n && (e === t ? h(n).length : n[e]));
+        };
+        O.prototype.listenersAny = function() {
+            if (this._all) {
+                return this._all;
+            } else {
+                return [];
+            }
+        };
+        O.prototype.waitFor = function(e, r) {
+            var i = this;
+            var n = typeof r;
+            if (n === "number") {
+                r = {
+                    timeout: r
+                };
+            } else if (n === "function") {
+                r = {
+                    filter: r
+                };
+            }
+            r = m(r, {
+                timeout: 0,
+                filter: t,
+                handleError: false,
+                Promise: Promise,
+                overload: false
+            }, {
+                filter: b,
+                Promise: d
+            });
+            return L(r.Promise, function(t, n, s) {
+                function o() {
+                    var s = r.filter;
+                    if (s && !s.apply(i, arguments)) {
+                        return;
+                    }
+                    i.off(e, o);
+                    if (r.handleError) {
+                        var l = arguments[0];
+                        l ? n(l) : t(p.apply(null, arguments).slice(1));
+                    } else {
+                        t(p.apply(null, arguments));
+                    }
+                }
+                s(function() {
+                    i.off(e, o);
+                });
+                i._on(e, o, false);
+            }, {
+                timeout: r.timeout,
+                overload: r.overload
+            });
+        };
+        function M(e, t, r) {
+            r = m(r, {
+                Promise: Promise,
+                timeout: 0,
+                overload: false
+            }, {
+                Promise: d
+            });
+            var i = r.Promise;
+            return L(i, function(r, i, n) {
+                var s;
+                if (typeof e.addEventListener === "function") {
+                    s = function() {
+                        r(p.apply(null, arguments));
+                    };
+                    n(function() {
+                        e.removeEventListener(t, s);
+                    });
+                    e.addEventListener(t, s, {
+                        once: true
+                    });
+                    return;
+                }
+                var o = function() {
+                    l && e.removeListener("error", l);
+                    r(p.apply(null, arguments));
+                };
+                var l;
+                if (t !== "error") {
+                    l = function(r) {
+                        e.removeListener(t, o);
+                        i(r);
+                    };
+                    e.once("error", l);
+                }
+                n(function() {
+                    l && e.removeListener("error", l);
+                    e.removeListener(t, o);
+                });
+                e.once(t, o);
+            }, {
+                timeout: r.timeout,
+                overload: r.overload
+            });
+        }
+        var N = O.prototype;
+        Object.defineProperties(O, {
+            defaultMaxListeners: {
+                get: function() {
+                    return N._maxListeners;
+                },
+                set: function(e) {
+                    if (typeof e !== "number" || e < 0 || Number.isNaN(e)) {
+                        throw TypeError("n must be a non-negative number");
+                    }
+                    N._maxListeners = e;
+                },
+                enumerable: true
+            },
+            once: {
+                value: M,
+                writable: true,
+                configurable: true
+            }
+        });
+        Object.defineProperties(N, {
+            _maxListeners: {
+                value: n,
+                writable: true,
+                configurable: true
+            },
+            _observers: {
+                value: null,
+                writable: true,
+                configurable: true
+            }
+        });
+        {
+            e.exports = O;
+        }
+    }();
+})(e, e.exports);
+
+exports.eventemitter2Exports = e.exports;