msw 0.49.2 → 0.49.3

package/lib/iife/index.js

@@ -51,6 +51,32 @@ var MockServiceWorker = (() => {
   };
   var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  var __accessCheck = (obj, member, msg) => {
+    if (!member.has(obj))
+      throw TypeError("Cannot " + msg);
+  };
+  var __privateGet = (obj, member, getter) => {
+    __accessCheck(obj, member, "read from private field");
+    return getter ? getter.call(obj) : member.get(obj);
+  };
+  var __privateAdd = (obj, member, value) => {
+    if (member.has(obj))
+      throw TypeError("Cannot add the same private member more than once");
+    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  };
+  var __privateSet = (obj, member, value, setter) => {
+    __accessCheck(obj, member, "write to private field");
+    setter ? setter.call(obj, value) : member.set(obj, value);
+    return value;
+  };
+  var __privateMethod = (obj, member, method) => {
+    __accessCheck(obj, member, "access private method");
+    return method;
+  };
 
   // node_modules/cookie/index.js
   var require_cookie = __commonJS({
@@ -1258,57 +1284,57 @@ var MockServiceWorker = (() => {
       exports.__esModule = true;
       exports.StrictEventEmitter = void 0;
       var events_1 = require_events();
-      var StrictEventEmitter2 = function(_super) {
-        __extends(StrictEventEmitter3, _super);
-        function StrictEventEmitter3() {
+      var StrictEventEmitter = function(_super) {
+        __extends(StrictEventEmitter2, _super);
+        function StrictEventEmitter2() {
           return _super.call(this) || this;
         }
-        StrictEventEmitter3.prototype.on = function(event, listener) {
+        StrictEventEmitter2.prototype.on = function(event, listener) {
           return _super.prototype.on.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.once = function(event, listener) {
+        StrictEventEmitter2.prototype.once = function(event, listener) {
           return _super.prototype.on.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.off = function(event, listener) {
+        StrictEventEmitter2.prototype.off = function(event, listener) {
           return _super.prototype.off.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.emit = function(event) {
+        StrictEventEmitter2.prototype.emit = function(event) {
           var data2 = [];
           for (var _i = 1; _i < arguments.length; _i++) {
             data2[_i - 1] = arguments[_i];
           }
           return _super.prototype.emit.apply(this, __spreadArrays([event.toString()], data2));
         };
-        StrictEventEmitter3.prototype.addListener = function(event, listener) {
+        StrictEventEmitter2.prototype.addListener = function(event, listener) {
           return _super.prototype.addListener.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.prependListener = function(event, listener) {
+        StrictEventEmitter2.prototype.prependListener = function(event, listener) {
           return _super.prototype.prependListener.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.prependOnceListener = function(event, listener) {
+        StrictEventEmitter2.prototype.prependOnceListener = function(event, listener) {
           return _super.prototype.prependOnceListener.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.removeListener = function(event, listener) {
+        StrictEventEmitter2.prototype.removeListener = function(event, listener) {
           return _super.prototype.removeListener.call(this, event.toString(), listener);
         };
-        StrictEventEmitter3.prototype.removeAllListeners = function(event) {
+        StrictEventEmitter2.prototype.removeAllListeners = function(event) {
           return _super.prototype.removeAllListeners.call(this, event ? event.toString() : void 0);
         };
-        StrictEventEmitter3.prototype.eventNames = function() {
+        StrictEventEmitter2.prototype.eventNames = function() {
           return _super.prototype.eventNames.call(this);
         };
-        StrictEventEmitter3.prototype.listeners = function(event) {
+        StrictEventEmitter2.prototype.listeners = function(event) {
           return _super.prototype.listeners.call(this, event.toString());
         };
-        StrictEventEmitter3.prototype.rawListeners = function(event) {
+        StrictEventEmitter2.prototype.rawListeners = function(event) {
           return _super.prototype.rawListeners.call(this, event.toString());
         };
-        StrictEventEmitter3.prototype.listenerCount = function(event) {
+        StrictEventEmitter2.prototype.listenerCount = function(event) {
           return _super.prototype.listenerCount.call(this, event.toString());
         };
-        return StrictEventEmitter3;
+        return StrictEventEmitter2;
       }(events_1.EventEmitter);
-      exports.StrictEventEmitter = StrictEventEmitter2;
+      exports.StrictEventEmitter = StrictEventEmitter;
     }
   });
 
@@ -8572,462 +8598,159 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     }
   });
 
-  // node_modules/strict-event-emitter/node_modules/events/events.js
-  var require_events2 = __commonJS({
-    "node_modules/strict-event-emitter/node_modules/events/events.js"(exports, module) {
+  // node_modules/strict-event-emitter/lib/MemoryLeakError.js
+  var require_MemoryLeakError = __commonJS({
+    "node_modules/strict-event-emitter/lib/MemoryLeakError.js"(exports) {
       "use strict";
-      var R = typeof Reflect === "object" ? Reflect : null;
-      var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
-        return Function.prototype.apply.call(target, receiver, args);
-      };
-      var ReflectOwnKeys;
-      if (R && typeof R.ownKeys === "function") {
-        ReflectOwnKeys = R.ownKeys;
-      } else if (Object.getOwnPropertySymbols) {
-        ReflectOwnKeys = function ReflectOwnKeys2(target) {
-          return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
-        };
-      } else {
-        ReflectOwnKeys = function ReflectOwnKeys2(target) {
-          return Object.getOwnPropertyNames(target);
-        };
-      }
-      function ProcessEmitWarning(warning) {
-        if (console && console.warn)
-          console.warn(warning);
-      }
-      var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
-        return value !== value;
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.MemoryLeakError = void 0;
+      var MemoryLeakError = class extends Error {
+        emitter;
+        type;
+        count;
+        constructor(emitter, type, count) {
+          super(`Possible EventEmitter memory leak detected. ${count} ${type.toString()} listeners added. Use emitter.setMaxListeners() to increase limit`);
+          this.emitter = emitter;
+          this.type = type;
+          this.count = count;
+          this.name = "MaxListenersExceededWarning";
+        }
       };
-      function EventEmitter() {
-        EventEmitter.init.call(this);
-      }
-      module.exports = EventEmitter;
-      module.exports.once = once;
-      EventEmitter.EventEmitter = EventEmitter;
-      EventEmitter.prototype._events = void 0;
-      EventEmitter.prototype._eventsCount = 0;
-      EventEmitter.prototype._maxListeners = void 0;
-      var defaultMaxListeners = 10;
-      function checkListener(listener) {
-        if (typeof listener !== "function") {
-          throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+      exports.MemoryLeakError = MemoryLeakError;
+    }
+  });
+
+  // node_modules/strict-event-emitter/lib/Emitter.js
+  var require_Emitter = __commonJS({
+    "node_modules/strict-event-emitter/lib/Emitter.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.Emitter = void 0;
+      var MemoryLeakError_1 = require_MemoryLeakError();
+      var _events, _maxListeners, _hasWarnedAboutPotentialMemortyLeak, _getListeners, getListeners_fn, _removeListener, removeListener_fn, _wrapOnceListener, wrapOnceListener_fn, _internalEmit, internalEmit_fn;
+      var _Emitter = class {
+        constructor() {
+          __privateAdd(this, _getListeners);
+          __privateAdd(this, _removeListener);
+          __privateAdd(this, _wrapOnceListener);
+          __privateAdd(this, _internalEmit);
+          __privateAdd(this, _events, void 0);
+          __privateAdd(this, _maxListeners, void 0);
+          __privateAdd(this, _hasWarnedAboutPotentialMemortyLeak, void 0);
+          __privateSet(this, _events, /* @__PURE__ */ new Map());
+          __privateSet(this, _maxListeners, _Emitter.defaultMaxListeners);
+          __privateSet(this, _hasWarnedAboutPotentialMemortyLeak, false);
+        }
+        static listenerCount(emitter, eventName) {
+          return emitter.listenerCount(eventName);
+        }
+        setMaxListeners(maxListeners) {
+          __privateSet(this, _maxListeners, maxListeners);
+          return this;
         }
-      }
-      Object.defineProperty(EventEmitter, "defaultMaxListeners", {
-        enumerable: true,
-        get: function() {
-          return defaultMaxListeners;
-        },
-        set: function(arg) {
-          if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
-            throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
-          }
-          defaultMaxListeners = arg;
+        getMaxListeners() {
+          return __privateGet(this, _maxListeners);
         }
-      });
-      EventEmitter.init = function() {
-        if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
-          this._events = /* @__PURE__ */ Object.create(null);
-          this._eventsCount = 0;
+        eventNames() {
+          return Array.from(__privateGet(this, _events).keys());
         }
-        this._maxListeners = this._maxListeners || void 0;
-      };
-      EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-        if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
-          throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+        emit(eventName, ...data2) {
+          const listeners = __privateMethod(this, _getListeners, getListeners_fn).call(this, eventName);
+          listeners.forEach((listener) => {
+            listener.apply(this, data2);
+          });
+          return listeners.length > 0;
         }
-        this._maxListeners = n;
-        return this;
-      };
-      function _getMaxListeners(that) {
-        if (that._maxListeners === void 0)
-          return EventEmitter.defaultMaxListeners;
-        return that._maxListeners;
-      }
-      EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-        return _getMaxListeners(this);
-      };
-      EventEmitter.prototype.emit = function emit(type) {
-        var args = [];
-        for (var i = 1; i < arguments.length; i++)
-          args.push(arguments[i]);
-        var doError = type === "error";
-        var events = this._events;
-        if (events !== void 0)
-          doError = doError && events.error === void 0;
-        else if (!doError)
-          return false;
-        if (doError) {
-          var er;
-          if (args.length > 0)
-            er = args[0];
-          if (er instanceof Error) {
-            throw er;
+        addListener(eventName, listener) {
+          __privateMethod(this, _internalEmit, internalEmit_fn).call(this, "newListener", eventName, listener);
+          const nextListeners = __privateMethod(this, _getListeners, getListeners_fn).call(this, eventName).concat(listener);
+          __privateGet(this, _events).set(eventName, nextListeners);
+          if (__privateGet(this, _maxListeners) > 0 && this.listenerCount(eventName) > __privateGet(this, _maxListeners) && !__privateGet(this, _hasWarnedAboutPotentialMemortyLeak)) {
+            __privateSet(this, _hasWarnedAboutPotentialMemortyLeak, true);
+            const memoryLeakWarning = new MemoryLeakError_1.MemoryLeakError(this, eventName, this.listenerCount(eventName));
+            console.warn(memoryLeakWarning);
           }
-          var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
-          err.context = er;
-          throw err;
+          return this;
         }
-        var handler = events[type];
-        if (handler === void 0)
-          return false;
-        if (typeof handler === "function") {
-          ReflectApply(handler, this, args);
-        } else {
-          var len = handler.length;
-          var listeners = arrayClone(handler, len);
-          for (var i = 0; i < len; ++i)
-            ReflectApply(listeners[i], this, args);
+        on(eventName, listener) {
+          return this.addListener(eventName, listener);
         }
-        return true;
-      };
-      function _addListener(target, type, listener, prepend) {
-        var m;
-        var events;
-        var existing;
-        checkListener(listener);
-        events = target._events;
-        if (events === void 0) {
-          events = target._events = /* @__PURE__ */ Object.create(null);
-          target._eventsCount = 0;
-        } else {
-          if (events.newListener !== void 0) {
-            target.emit("newListener", type, listener.listener ? listener.listener : listener);
-            events = target._events;
-          }
-          existing = events[type];
+        once(eventName, listener) {
+          return this.addListener(eventName, __privateMethod(this, _wrapOnceListener, wrapOnceListener_fn).call(this, eventName, listener));
         }
-        if (existing === void 0) {
-          existing = events[type] = listener;
-          ++target._eventsCount;
-        } else {
-          if (typeof existing === "function") {
-            existing = events[type] = prepend ? [listener, existing] : [existing, listener];
-          } else if (prepend) {
-            existing.unshift(listener);
+        prependListener(eventName, listener) {
+          const listeners = __privateMethod(this, _getListeners, getListeners_fn).call(this, eventName);
+          if (listeners.length > 0) {
+            const nextListeners = [listener].concat(listeners);
+            __privateGet(this, _events).set(eventName, nextListeners);
           } else {
-            existing.push(listener);
+            __privateGet(this, _events).set(eventName, listeners.concat(listener));
           }
-          m = _getMaxListeners(target);
-          if (m > 0 && existing.length > m && !existing.warned) {
-            existing.warned = true;
-            var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
-            w.name = "MaxListenersExceededWarning";
-            w.emitter = target;
-            w.type = type;
-            w.count = existing.length;
-            ProcessEmitWarning(w);
-          }
-        }
-        return target;
-      }
-      EventEmitter.prototype.addListener = function addListener(type, listener) {
-        return _addListener(this, type, listener, false);
-      };
-      EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-      EventEmitter.prototype.prependListener = function prependListener(type, listener) {
-        return _addListener(this, type, listener, true);
-      };
-      function onceWrapper() {
-        if (!this.fired) {
-          this.target.removeListener(this.type, this.wrapFn);
-          this.fired = true;
-          if (arguments.length === 0)
-            return this.listener.call(this.target);
-          return this.listener.apply(this.target, arguments);
-        }
-      }
-      function _onceWrap(target, type, listener) {
-        var state = { fired: false, wrapFn: void 0, target, type, listener };
-        var wrapped = onceWrapper.bind(state);
-        wrapped.listener = listener;
-        state.wrapFn = wrapped;
-        return wrapped;
-      }
-      EventEmitter.prototype.once = function once2(type, listener) {
-        checkListener(listener);
-        this.on(type, _onceWrap(this, type, listener));
-        return this;
-      };
-      EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
-        checkListener(listener);
-        this.prependListener(type, _onceWrap(this, type, listener));
-        return this;
-      };
-      EventEmitter.prototype.removeListener = function removeListener(type, listener) {
-        var list, events, position, i, originalListener;
-        checkListener(listener);
-        events = this._events;
-        if (events === void 0)
           return this;
-        list = events[type];
-        if (list === void 0)
-          return this;
-        if (list === listener || list.listener === listener) {
-          if (--this._eventsCount === 0)
-            this._events = /* @__PURE__ */ Object.create(null);
-          else {
-            delete events[type];
-            if (events.removeListener)
-              this.emit("removeListener", type, list.listener || listener);
-          }
-        } else if (typeof list !== "function") {
-          position = -1;
-          for (i = list.length - 1; i >= 0; i--) {
-            if (list[i] === listener || list[i].listener === listener) {
-              originalListener = list[i].listener;
-              position = i;
-              break;
-            }
-          }
-          if (position < 0)
-            return this;
-          if (position === 0)
-            list.shift();
-          else {
-            spliceOne(list, position);
-          }
-          if (list.length === 1)
-            events[type] = list[0];
-          if (events.removeListener !== void 0)
-            this.emit("removeListener", type, originalListener || listener);
         }
-        return this;
-      };
-      EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-      EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-        var listeners, events, i;
-        events = this._events;
-        if (events === void 0)
-          return this;
-        if (events.removeListener === void 0) {
-          if (arguments.length === 0) {
-            this._events = /* @__PURE__ */ Object.create(null);
-            this._eventsCount = 0;
-          } else if (events[type] !== void 0) {
-            if (--this._eventsCount === 0)
-              this._events = /* @__PURE__ */ Object.create(null);
-            else
-              delete events[type];
-          }
-          return this;
+        prependOnceListener(eventName, listener) {
+          return this.prependListener(eventName, __privateMethod(this, _wrapOnceListener, wrapOnceListener_fn).call(this, eventName, listener));
         }
-        if (arguments.length === 0) {
-          var keys = Object.keys(events);
-          var key;
-          for (i = 0; i < keys.length; ++i) {
-            key = keys[i];
-            if (key === "removeListener")
-              continue;
-            this.removeAllListeners(key);
+        removeListener(eventName, listener) {
+          const listeners = __privateMethod(this, _getListeners, getListeners_fn).call(this, eventName);
+          if (listeners.length > 0) {
+            __privateMethod(this, _removeListener, removeListener_fn).call(this, listeners, listener);
+            __privateGet(this, _events).set(eventName, listeners);
+            __privateMethod(this, _internalEmit, internalEmit_fn).call(this, "removeListener", eventName, listener);
           }
-          this.removeAllListeners("removeListener");
-          this._events = /* @__PURE__ */ Object.create(null);
-          this._eventsCount = 0;
           return this;
         }
-        listeners = events[type];
-        if (typeof listeners === "function") {
-          this.removeListener(type, listeners);
-        } else if (listeners !== void 0) {
-          for (i = listeners.length - 1; i >= 0; i--) {
-            this.removeListener(type, listeners[i]);
-          }
-        }
-        return this;
-      };
-      function _listeners(target, type, unwrap) {
-        var events = target._events;
-        if (events === void 0)
-          return [];
-        var evlistener = events[type];
-        if (evlistener === void 0)
-          return [];
-        if (typeof evlistener === "function")
-          return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-        return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-      }
-      EventEmitter.prototype.listeners = function listeners(type) {
-        return _listeners(this, type, true);
-      };
-      EventEmitter.prototype.rawListeners = function rawListeners(type) {
-        return _listeners(this, type, false);
-      };
-      EventEmitter.listenerCount = function(emitter, type) {
-        if (typeof emitter.listenerCount === "function") {
-          return emitter.listenerCount(type);
-        } else {
-          return listenerCount.call(emitter, type);
+        off(eventName, listener) {
+          return this.removeListener(eventName, listener);
         }
-      };
-      EventEmitter.prototype.listenerCount = listenerCount;
-      function listenerCount(type) {
-        var events = this._events;
-        if (events !== void 0) {
-          var evlistener = events[type];
-          if (typeof evlistener === "function") {
-            return 1;
-          } else if (evlistener !== void 0) {
-            return evlistener.length;
+        removeAllListeners(eventName) {
+          if (eventName) {
+            __privateGet(this, _events).delete(eventName);
+          } else {
+            __privateGet(this, _events).clear();
           }
+          return this;
         }
-        return 0;
-      }
-      EventEmitter.prototype.eventNames = function eventNames() {
-        return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-      };
-      function arrayClone(arr, n) {
-        var copy = new Array(n);
-        for (var i = 0; i < n; ++i)
-          copy[i] = arr[i];
-        return copy;
-      }
-      function spliceOne(list, index) {
-        for (; index + 1 < list.length; index++)
-          list[index] = list[index + 1];
-        list.pop();
-      }
-      function unwrapListeners(arr) {
-        var ret = new Array(arr.length);
-        for (var i = 0; i < ret.length; ++i) {
-          ret[i] = arr[i].listener || arr[i];
+        listeners(eventName) {
+          return Array.from(__privateMethod(this, _getListeners, getListeners_fn).call(this, eventName));
         }
-        return ret;
-      }
-      function once(emitter, name) {
-        return new Promise(function(resolve, reject) {
-          function errorListener(err) {
-            emitter.removeListener(name, resolver);
-            reject(err);
-          }
-          function resolver() {
-            if (typeof emitter.removeListener === "function") {
-              emitter.removeListener("error", errorListener);
-            }
-            resolve([].slice.call(arguments));
-          }
-          ;
-          eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-          if (name !== "error") {
-            addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
-          }
-        });
-      }
-      function addErrorHandlerIfEventEmitter(emitter, handler, flags2) {
-        if (typeof emitter.on === "function") {
-          eventTargetAgnosticAddListener(emitter, "error", handler, flags2);
+        listenerCount(eventName) {
+          return __privateMethod(this, _getListeners, getListeners_fn).call(this, eventName).length;
         }
-      }
-      function eventTargetAgnosticAddListener(emitter, name, listener, flags2) {
-        if (typeof emitter.on === "function") {
-          if (flags2.once) {
-            emitter.once(name, listener);
-          } else {
-            emitter.on(name, listener);
-          }
-        } else if (typeof emitter.addEventListener === "function") {
-          emitter.addEventListener(name, function wrapListener(arg) {
-            if (flags2.once) {
-              emitter.removeEventListener(name, wrapListener);
-            }
-            listener(arg);
-          });
-        } else {
-          throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+        rawListeners(eventName) {
+          return this.listeners(eventName);
         }
-      }
-    }
-  });
-
-  // node_modules/strict-event-emitter/lib/StrictEventEmitter.js
-  var require_StrictEventEmitter2 = __commonJS({
-    "node_modules/strict-event-emitter/lib/StrictEventEmitter.js"(exports) {
-      "use strict";
-      var __extends = exports && exports.__extends || function() {
-        var extendStatics = function(d, b) {
-          extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-            d2.__proto__ = b2;
-          } || function(d2, b2) {
-            for (var p in b2)
-              if (Object.prototype.hasOwnProperty.call(b2, p))
-                d2[p] = b2[p];
-          };
-          return extendStatics(d, b);
-        };
-        return function(d, b) {
-          extendStatics(d, b);
-          function __() {
-            this.constructor = d;
-          }
-          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-        };
-      }();
-      var __spreadArrays = exports && exports.__spreadArrays || function() {
-        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
-          s += arguments[i].length;
-        for (var r = Array(s), k = 0, i = 0; i < il; i++)
-          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-        return r;
       };
-      exports.__esModule = true;
-      exports.StrictEventEmitter = void 0;
-      var events_1 = require_events2();
-      var StrictEventEmitter2 = function(_super) {
-        __extends(StrictEventEmitter3, _super);
-        function StrictEventEmitter3() {
-          return _super.call(this) || this;
+      var Emitter2 = _Emitter;
+      _events = new WeakMap();
+      _maxListeners = new WeakMap();
+      _hasWarnedAboutPotentialMemortyLeak = new WeakMap();
+      _getListeners = new WeakSet();
+      getListeners_fn = function(eventName) {
+        return __privateGet(this, _events).get(eventName) || [];
+      };
+      _removeListener = new WeakSet();
+      removeListener_fn = function(listeners, listener) {
+        const index = listeners.indexOf(listener);
+        if (index > -1) {
+          listeners.splice(index, 1);
         }
-        StrictEventEmitter3.prototype.on = function(event, listener) {
-          return _super.prototype.on.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.once = function(event, listener) {
-          return _super.prototype.once.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.off = function(event, listener) {
-          return _super.prototype.off.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.emit = function(event) {
-          var data2 = [];
-          for (var _i = 1; _i < arguments.length; _i++) {
-            data2[_i - 1] = arguments[_i];
-          }
-          return _super.prototype.emit.apply(this, __spreadArrays([event.toString()], data2));
-        };
-        StrictEventEmitter3.prototype.addListener = function(event, listener) {
-          return _super.prototype.addListener.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.prependListener = function(event, listener) {
-          return _super.prototype.prependListener.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.prependOnceListener = function(event, listener) {
-          return _super.prototype.prependOnceListener.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.removeListener = function(event, listener) {
-          return _super.prototype.removeListener.call(this, event.toString(), listener);
-        };
-        StrictEventEmitter3.prototype.removeAllListeners = function(event) {
-          if (event) {
-            return _super.prototype.removeAllListeners.call(this, event.toString());
-          }
-          return _super.prototype.removeAllListeners.call(this);
-        };
-        StrictEventEmitter3.prototype.eventNames = function() {
-          return _super.prototype.eventNames.call(this);
-        };
-        StrictEventEmitter3.prototype.listeners = function(event) {
-          return _super.prototype.listeners.call(this, event.toString());
-        };
-        StrictEventEmitter3.prototype.rawListeners = function(event) {
-          return _super.prototype.rawListeners.call(this, event.toString());
-        };
-        StrictEventEmitter3.prototype.listenerCount = function(event) {
-          return _super.prototype.listenerCount.call(this, event.toString());
+        return [];
+      };
+      _wrapOnceListener = new WeakSet();
+      wrapOnceListener_fn = function(eventName, listener) {
+        const onceListener = (...data2) => {
+          this.removeListener(eventName, onceListener);
+          listener.apply(this, data2);
         };
-        return StrictEventEmitter3;
-      }(events_1.EventEmitter);
-      exports.StrictEventEmitter = StrictEventEmitter2;
+        return onceListener;
+      };
+      _internalEmit = new WeakSet();
+      internalEmit_fn = function(internalEventName, eventName, listener) {
+        this.emit(internalEventName, ...[eventName, listener]);
+      };
+      __publicField(Emitter2, "defaultMaxListeners", 10);
+      exports.Emitter = Emitter2;
     }
   });
 
@@ -9038,9 +8761,13 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
       var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
         if (k2 === void 0)
           k2 = k;
-        Object.defineProperty(o, k2, { enumerable: true, get: function() {
-          return m[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 === void 0)
           k2 = k;
@@ -9051,8 +8778,9 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
           if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
             __createBinding(exports2, m, p);
       };
-      exports.__esModule = true;
-      __exportStar(require_StrictEventEmitter2(), exports);
+      Object.defineProperty(exports, "__esModule", { value: true });
+      __exportStar(require_Emitter(), exports);
+      __exportStar(require_MemoryLeakError(), exports);
     }
   });
 
@@ -13115,8 +12843,8 @@ If this message still persists after updating, please report an issue: https://g
       this.validateHandlers(...initialHandlers);
       this.initialHandlers = toReadonlyArray(initialHandlers);
       this.currentHandlers = [...initialHandlers];
-      this.emitter = new import_strict_event_emitter.StrictEventEmitter();
-      this.publicEmitter = new import_strict_event_emitter.StrictEventEmitter();
+      this.emitter = new import_strict_event_emitter.Emitter();
+      this.publicEmitter = new import_strict_event_emitter.Emitter();
       pipeEvents(this.emitter, this.publicEmitter);
       this.events = this.createLifeCycleEvents();
     }