msw 0.41.1 → 0.42.0

package/lib/iife/index.js

@@ -1415,9 +1415,17 @@ var MockServiceWorker = (() => {
         return to;
       };
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.invariant = exports.InvariantError = void 0;
+      exports.invariant = exports.createInvariantWith = exports.InvariantError = void 0;
       var format_1 = require_format();
       var STACK_FRAMES_TO_IGNORE = 2;
+      function cleanErrorStack(error2) {
+        if (!error2.stack) {
+          return;
+        }
+        var nextStack = error2.stack.split("\n");
+        nextStack.splice(1, STACK_FRAMES_TO_IGNORE);
+        error2.stack = nextStack.join("\n");
+      }
       var InvariantError = function(_super) {
         __extends(InvariantError2, _super);
         function InvariantError2(message) {
@@ -1426,28 +1434,41 @@ var MockServiceWorker = (() => {
             positionals[_i - 1] = arguments[_i];
           }
           var _this = _super.call(this, message) || this;
+          _this.message = message;
           _this.name = "Invariant Violation";
           _this.message = format_1.format.apply(void 0, __spreadArray([message], positionals));
-          if (_this.stack) {
-            var nextStack = _this.stack.split("\n");
-            nextStack.splice(1, STACK_FRAMES_TO_IGNORE);
-            _this.stack = nextStack.join("\n");
-          }
+          cleanErrorStack(_this);
           return _this;
         }
         return InvariantError2;
       }(Error);
       exports.InvariantError = InvariantError;
-      function invariant2(predicate, message) {
-        var positionals = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-          positionals[_i - 2] = arguments[_i];
-        }
-        if (!predicate) {
-          throw new (InvariantError.bind.apply(InvariantError, __spreadArray([void 0, message], positionals)))();
+      function createInvariantWith(ErrorConstructor) {
+        var invariant2 = function(predicate, message) {
+          var positionals = [];
+          for (var _i = 2; _i < arguments.length; _i++) {
+            positionals[_i - 2] = arguments[_i];
+          }
+          if (!predicate) {
+            var resolvedMessage = format_1.format.apply(void 0, __spreadArray([message], positionals));
+            var isConstructor = !!ErrorConstructor.prototype.name;
+            var error2 = isConstructor ? new ErrorConstructor(resolvedMessage) : ErrorConstructor(resolvedMessage);
+            cleanErrorStack(error2);
+            throw error2;
+          }
+        };
+        return invariant2;
+      }
+      exports.createInvariantWith = createInvariantWith;
+      function polymorphicInvariant(ErrorClass) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+          args[_i - 1] = arguments[_i];
         }
+        return createInvariantWith(ErrorClass).apply(void 0, args);
       }
-      exports.invariant = invariant2;
+      exports.invariant = createInvariantWith(InvariantError);
+      exports.invariant.as = polymorphicInvariant;
     }
   });
 
@@ -1895,795 +1916,1745 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     }
   });
 
-  // node_modules/@mswjs/interceptors/lib/createInterceptor.js
-  var require_createInterceptor = __commonJS({
-    "node_modules/@mswjs/interceptors/lib/createInterceptor.js"(exports) {
+  // node_modules/@mswjs/interceptors/lib/glossary.js
+  var require_glossary = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/glossary.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createInterceptor = void 0;
-      var strict_event_emitter_1 = require_lib3();
-      function createInterceptor2(options) {
-        var observer = new strict_event_emitter_1.StrictEventEmitter();
-        var cleanupFns = [];
-        return {
-          apply: function() {
-            cleanupFns = options.modules.map(function(interceptor) {
-              return interceptor(observer, options.resolver);
-            });
-          },
-          on: function(event, listener) {
-            observer.addListener(event, listener);
-          },
-          restore: function() {
-            observer.removeAllListeners();
-            if (cleanupFns.length === 0) {
-              throw new Error('Failed to restore patched modules: no patches found. Did you forget to run ".apply()"?');
-            }
-            cleanupFns.forEach(function(restore) {
-              return restore();
-            });
-          }
-        };
-      }
-      exports.createInterceptor = createInterceptor2;
     }
   });
 
-  // node_modules/@mswjs/interceptors/lib/utils/toIsoResponse.js
-  var require_toIsoResponse = __commonJS({
-    "node_modules/@mswjs/interceptors/lib/utils/toIsoResponse.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.toIsoResponse = void 0;
-      var headers_polyfill_1 = require_lib();
-      function toIsoResponse(response2) {
-        return {
-          status: response2.status || 200,
-          statusText: response2.statusText || "OK",
-          headers: headers_polyfill_1.objectToHeaders(response2.headers || {}),
-          body: response2.body
-        };
+  // node_modules/ms/index.js
+  var require_ms = __commonJS({
+    "node_modules/ms/index.js"(exports, module) {
+      var s = 1e3;
+      var m = s * 60;
+      var h = m * 60;
+      var d = h * 24;
+      var w = d * 7;
+      var y = d * 365.25;
+      module.exports = function(val, options) {
+        options = options || {};
+        var type = typeof val;
+        if (type === "string" && val.length > 0) {
+          return parse5(val);
+        } else if (type === "number" && isFinite(val)) {
+          return options.long ? fmtLong(val) : fmtShort(val);
+        }
+        throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+      };
+      function parse5(str) {
+        str = String(str);
+        if (str.length > 100) {
+          return;
+        }
+        var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+        if (!match2) {
+          return;
+        }
+        var n = parseFloat(match2[1]);
+        var type = (match2[2] || "ms").toLowerCase();
+        switch (type) {
+          case "years":
+          case "year":
+          case "yrs":
+          case "yr":
+          case "y":
+            return n * y;
+          case "weeks":
+          case "week":
+          case "w":
+            return n * w;
+          case "days":
+          case "day":
+          case "d":
+            return n * d;
+          case "hours":
+          case "hour":
+          case "hrs":
+          case "hr":
+          case "h":
+            return n * h;
+          case "minutes":
+          case "minute":
+          case "mins":
+          case "min":
+          case "m":
+            return n * m;
+          case "seconds":
+          case "second":
+          case "secs":
+          case "sec":
+          case "s":
+            return n * s;
+          case "milliseconds":
+          case "millisecond":
+          case "msecs":
+          case "msec":
+          case "ms":
+            return n;
+          default:
+            return void 0;
+        }
+      }
+      function fmtShort(ms) {
+        var msAbs = Math.abs(ms);
+        if (msAbs >= d) {
+          return Math.round(ms / d) + "d";
+        }
+        if (msAbs >= h) {
+          return Math.round(ms / h) + "h";
+        }
+        if (msAbs >= m) {
+          return Math.round(ms / m) + "m";
+        }
+        if (msAbs >= s) {
+          return Math.round(ms / s) + "s";
+        }
+        return ms + "ms";
+      }
+      function fmtLong(ms) {
+        var msAbs = Math.abs(ms);
+        if (msAbs >= d) {
+          return plural(ms, msAbs, d, "day");
+        }
+        if (msAbs >= h) {
+          return plural(ms, msAbs, h, "hour");
+        }
+        if (msAbs >= m) {
+          return plural(ms, msAbs, m, "minute");
+        }
+        if (msAbs >= s) {
+          return plural(ms, msAbs, s, "second");
+        }
+        return ms + " ms";
+      }
+      function plural(ms, msAbs, n, name) {
+        var isPlural = msAbs >= n * 1.5;
+        return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
       }
-      exports.toIsoResponse = toIsoResponse;
     }
   });
 
-  // node_modules/@mswjs/interceptors/lib/remote.js
-  var require_remote = __commonJS({
-    "node_modules/@mswjs/interceptors/lib/remote.js"(exports) {
-      "use strict";
-      var __assign = exports && exports.__assign || function() {
-        __assign = Object.assign || function(t) {
-          for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s)
-              if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
+  // node_modules/@mswjs/interceptors/node_modules/debug/src/common.js
+  var require_common = __commonJS({
+    "node_modules/@mswjs/interceptors/node_modules/debug/src/common.js"(exports, module) {
+      function setup(env) {
+        createDebug.debug = createDebug;
+        createDebug.default = createDebug;
+        createDebug.coerce = coerce;
+        createDebug.disable = disable;
+        createDebug.enable = enable;
+        createDebug.enabled = enabled;
+        createDebug.humanize = require_ms();
+        createDebug.destroy = destroy;
+        Object.keys(env).forEach((key) => {
+          createDebug[key] = env[key];
+        });
+        createDebug.names = [];
+        createDebug.skips = [];
+        createDebug.formatters = {};
+        function selectColor(namespace) {
+          let hash = 0;
+          for (let i = 0; i < namespace.length; i++) {
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+            hash |= 0;
           }
-          return t;
-        };
-        return __assign.apply(this, arguments);
-      };
-      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
-        function adopt(value) {
-          return value instanceof P ? value : new P(function(resolve) {
-            resolve(value);
-          });
+          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
         }
-        return new (P || (P = Promise))(function(resolve, reject) {
-          function fulfilled(value) {
-            try {
-              step(generator.next(value));
-            } catch (e) {
-              reject(e);
+        createDebug.selectColor = selectColor;
+        function createDebug(namespace) {
+          let prevTime;
+          let enableOverride = null;
+          let namespacesCache;
+          let enabledCache;
+          function debug(...args) {
+            if (!debug.enabled) {
+              return;
             }
-          }
-          function rejected(value) {
-            try {
-              step(generator["throw"](value));
-            } catch (e) {
-              reject(e);
+            const self2 = debug;
+            const curr = Number(new Date());
+            const ms = curr - (prevTime || curr);
+            self2.diff = ms;
+            self2.prev = prevTime;
+            self2.curr = curr;
+            prevTime = curr;
+            args[0] = createDebug.coerce(args[0]);
+            if (typeof args[0] !== "string") {
+              args.unshift("%O");
             }
+            let index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format2) => {
+              if (match2 === "%%") {
+                return "%";
+              }
+              index++;
+              const formatter = createDebug.formatters[format2];
+              if (typeof formatter === "function") {
+                const val = args[index];
+                match2 = formatter.call(self2, val);
+                args.splice(index, 1);
+                index--;
+              }
+              return match2;
+            });
+            createDebug.formatArgs.call(self2, args);
+            const logFn = self2.log || createDebug.log;
+            logFn.apply(self2, args);
           }
-          function step(result) {
-            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-          }
-          step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-      };
-      var __generator = exports && exports.__generator || function(thisArg, body2) {
-        var _ = { label: 0, sent: function() {
-          if (t[0] & 1)
-            throw t[1];
-          return t[1];
-        }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-          return this;
-        }), g;
-        function verb(n) {
-          return function(v) {
-            return step([n, v]);
-          };
-        }
-        function step(op) {
-          if (f)
-            throw new TypeError("Generator is already executing.");
-          while (_)
-            try {
-              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-                return t;
-              if (y = 0, t)
-                op = [op[0] & 2, t.value];
-              switch (op[0]) {
-                case 0:
-                case 1:
-                  t = op;
-                  break;
-                case 4:
-                  _.label++;
-                  return { value: op[1], done: false };
-                case 5:
-                  _.label++;
-                  y = op[1];
-                  op = [0];
-                  continue;
-                case 7:
-                  op = _.ops.pop();
-                  _.trys.pop();
-                  continue;
-                default:
-                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                    _ = 0;
-                    continue;
-                  }
-                  if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                    _.label = op[1];
-                    break;
-                  }
-                  if (op[0] === 6 && _.label < t[1]) {
-                    _.label = t[1];
-                    t = op;
-                    break;
-                  }
-                  if (t && _.label < t[2]) {
-                    _.label = t[2];
-                    _.ops.push(op);
-                    break;
-                  }
-                  if (t[2])
-                    _.ops.pop();
-                  _.trys.pop();
-                  continue;
+          debug.namespace = namespace;
+          debug.useColors = createDebug.useColors();
+          debug.color = createDebug.selectColor(namespace);
+          debug.extend = extend;
+          debug.destroy = createDebug.destroy;
+          Object.defineProperty(debug, "enabled", {
+            enumerable: true,
+            configurable: false,
+            get: () => {
+              if (enableOverride !== null) {
+                return enableOverride;
               }
-              op = body2.call(thisArg, _);
-            } catch (e) {
-              op = [6, e];
-              y = 0;
-            } finally {
-              f = t = 0;
+              if (namespacesCache !== createDebug.namespaces) {
+                namespacesCache = createDebug.namespaces;
+                enabledCache = createDebug.enabled(namespace);
+              }
+              return enabledCache;
+            },
+            set: (v) => {
+              enableOverride = v;
             }
-          if (op[0] & 5)
-            throw op[1];
-          return { value: op[0] ? op[1] : void 0, done: true };
+          });
+          if (typeof createDebug.init === "function") {
+            createDebug.init(debug);
+          }
+          return debug;
         }
-      };
-      var __read = exports && exports.__read || function(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m)
-          return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-          while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
-            ar.push(r.value);
-        } catch (error2) {
-          e = { error: error2 };
-        } finally {
-          try {
-            if (r && !r.done && (m = i["return"]))
-              m.call(i);
-          } finally {
-            if (e)
-              throw e.error;
+        function extend(namespace, delimiter) {
+          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+          newDebug.log = this.log;
+          return newDebug;
+        }
+        function enable(namespaces) {
+          createDebug.save(namespaces);
+          createDebug.namespaces = namespaces;
+          createDebug.names = [];
+          createDebug.skips = [];
+          let i;
+          const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+          const len = split.length;
+          for (i = 0; i < len; i++) {
+            if (!split[i]) {
+              continue;
+            }
+            namespaces = split[i].replace(/\*/g, ".*?");
+            if (namespaces[0] === "-") {
+              createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+            } else {
+              createDebug.names.push(new RegExp("^" + namespaces + "$"));
+            }
           }
         }
-        return ar;
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createRemoteResolver = exports.createRemoteInterceptor = void 0;
-      var headers_polyfill_1 = require_lib();
-      var outvariant_1 = require_lib5();
-      var strict_event_emitter_1 = require_lib3();
-      var createInterceptor_1 = require_createInterceptor();
-      var toIsoResponse_1 = require_toIsoResponse();
-      function requestReviver(key, value) {
-        switch (key) {
-          case "url":
-            return new URL(value);
-          case "headers":
-            return new headers_polyfill_1.Headers(value);
-          default:
-            return value;
+        function disable() {
+          const namespaces = [
+            ...createDebug.names.map(toNamespace),
+            ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
+          ].join(",");
+          createDebug.enable("");
+          return namespaces;
         }
-      }
-      function createRemoteInterceptor(options) {
-        outvariant_1.invariant(process.connected, "Failed to create a remote interceptor: the current process (%s) does not have a parent. Please make sure you're spawning this process as a child process in order to use remote request interception.", process.pid);
-        if (typeof process.send === "undefined") {
-          throw new Error("Failed to create a remote interceptor: the current process (" + process.pid + `) does not have the IPC enabled. Please make sure you're spawning this process with the "ipc" stdio value set:
-
-spawn('node', ['module.js'], { stdio: ['ipc'] })`);
+        function enabled(name) {
+          if (name[name.length - 1] === "*") {
+            return true;
+          }
+          let i;
+          let len;
+          for (i = 0, len = createDebug.skips.length; i < len; i++) {
+            if (createDebug.skips[i].test(name)) {
+              return false;
+            }
+          }
+          for (i = 0, len = createDebug.names.length; i < len; i++) {
+            if (createDebug.names[i].test(name)) {
+              return true;
+            }
+          }
+          return false;
         }
-        var handleParentMessage;
-        var interceptor = createInterceptor_1.createInterceptor(__assign(__assign({}, options), { resolver: function(request) {
-          var _a;
-          var serializedRequest = JSON.stringify(request);
-          (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, "request:" + serializedRequest);
-          return new Promise(function(resolve) {
-            handleParentMessage = function(message) {
-              if (typeof message !== "string") {
-                return;
-              }
-              if (message.startsWith("response:" + request.id)) {
-                var _a2 = __read(message.match(/^response:.+?:(.+)$/) || [], 2), responseString = _a2[1];
-                if (!responseString) {
-                  return resolve();
-                }
-                var mockedResponse = JSON.parse(responseString);
-                return resolve(mockedResponse);
-              }
-            };
-            process.addListener("message", handleParentMessage);
-          });
-        } }));
-        return __assign(__assign({}, interceptor), { restore: function() {
-          interceptor.restore();
-          process.removeListener("message", handleParentMessage);
-        } });
-      }
-      exports.createRemoteInterceptor = createRemoteInterceptor;
-      function createRemoteResolver(options) {
-        var _this = this;
-        var observer = new strict_event_emitter_1.StrictEventEmitter();
-        var handleChildMessage = function(message) {
-          return __awaiter(_this, void 0, void 0, function() {
-            var _a, requestString, isoRequest_1, mockedResponse_1, serializedResponse;
-            return __generator(this, function(_b) {
-              switch (_b.label) {
-                case 0:
-                  if (typeof message !== "string") {
-                    return [2];
-                  }
-                  if (!message.startsWith("request:"))
-                    return [3, 2];
-                  _a = __read(message.match(/^request:(.+)$/) || [], 2), requestString = _a[1];
-                  if (!requestString) {
-                    return [2];
-                  }
-                  isoRequest_1 = JSON.parse(requestString, requestReviver);
-                  observer.emit("request", isoRequest_1);
-                  return [
-                    4,
-                    options.resolver(isoRequest_1, void 0)
-                  ];
-                case 1:
-                  mockedResponse_1 = _b.sent();
-                  serializedResponse = JSON.stringify(mockedResponse_1);
-                  options.process.send("response:" + isoRequest_1.id + ":" + serializedResponse, function(error2) {
-                    if (error2) {
-                      return;
-                    }
-                    if (mockedResponse_1) {
-                      observer.emit("response", isoRequest_1, toIsoResponse_1.toIsoResponse(mockedResponse_1));
-                    }
-                  });
-                  _b.label = 2;
-                case 2:
-                  return [2];
-              }
-            });
-          });
-        };
-        var cleanup = function() {
-          options.process.removeListener("message", handleChildMessage);
-        };
-        options.process.addListener("message", handleChildMessage);
-        options.process.addListener("disconnect", cleanup);
-        options.process.addListener("error", cleanup);
-        options.process.addListener("exit", cleanup);
-        return {
-          on: function(event, listener) {
-            observer.addListener(event, listener);
+        function toNamespace(regexp) {
+          return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+        }
+        function coerce(val) {
+          if (val instanceof Error) {
+            return val.stack || val.message;
           }
-        };
-      }
-      exports.createRemoteResolver = createRemoteResolver;
-    }
-  });
-
-  // node_modules/@mswjs/interceptors/lib/index.js
-  var require_lib7 = __commonJS({
-    "node_modules/@mswjs/interceptors/lib/index.js"(exports) {
-      "use strict";
-      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];
-        } });
-      } : function(o, m, k, k2) {
-        if (k2 === void 0)
-          k2 = k;
-        o[k2] = m[k];
-      });
-      var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-        for (var p in m)
-          if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-            __createBinding(exports2, m, p);
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.getCleanUrl = void 0;
-      __exportStar(require_createInterceptor(), exports);
-      __exportStar(require_remote(), exports);
-      var getCleanUrl_1 = require_getCleanUrl();
-      Object.defineProperty(exports, "getCleanUrl", { enumerable: true, get: function() {
-        return getCleanUrl_1.getCleanUrl;
-      } });
-    }
-  });
-
-  // node_modules/@mswjs/interceptors/lib/utils/uuid.js
-  var require_uuid = __commonJS({
-    "node_modules/@mswjs/interceptors/lib/utils/uuid.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.uuidv4 = void 0;
-      function uuidv4() {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-          var r = Math.random() * 16 | 0;
-          var v = c == "x" ? r : r & 3 | 8;
-          return v.toString(16);
-        });
+          return val;
+        }
+        function destroy() {
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+        createDebug.enable(createDebug.load());
+        return createDebug;
       }
-      exports.uuidv4 = uuidv4;
+      module.exports = setup;
     }
   });
 
-  // node_modules/ms/index.js
-  var require_ms = __commonJS({
-    "node_modules/ms/index.js"(exports, module) {
-      var s = 1e3;
-      var m = s * 60;
-      var h = m * 60;
-      var d = h * 24;
-      var w = d * 7;
-      var y = d * 365.25;
-      module.exports = function(val, options) {
-        options = options || {};
-        var type = typeof val;
-        if (type === "string" && val.length > 0) {
-          return parse5(val);
-        } else if (type === "number" && isFinite(val)) {
-          return options.long ? fmtLong(val) : fmtShort(val);
+  // node_modules/@mswjs/interceptors/node_modules/debug/src/browser.js
+  var require_browser2 = __commonJS({
+    "node_modules/@mswjs/interceptors/node_modules/debug/src/browser.js"(exports, module) {
+      exports.formatArgs = formatArgs;
+      exports.save = save;
+      exports.load = load;
+      exports.useColors = useColors;
+      exports.storage = localstorage();
+      exports.destroy = (() => {
+        let warned = false;
+        return () => {
+          if (!warned) {
+            warned = true;
+            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+          }
+        };
+      })();
+      exports.colors = [
+        "#0000CC",
+        "#0000FF",
+        "#0033CC",
+        "#0033FF",
+        "#0066CC",
+        "#0066FF",
+        "#0099CC",
+        "#0099FF",
+        "#00CC00",
+        "#00CC33",
+        "#00CC66",
+        "#00CC99",
+        "#00CCCC",
+        "#00CCFF",
+        "#3300CC",
+        "#3300FF",
+        "#3333CC",
+        "#3333FF",
+        "#3366CC",
+        "#3366FF",
+        "#3399CC",
+        "#3399FF",
+        "#33CC00",
+        "#33CC33",
+        "#33CC66",
+        "#33CC99",
+        "#33CCCC",
+        "#33CCFF",
+        "#6600CC",
+        "#6600FF",
+        "#6633CC",
+        "#6633FF",
+        "#66CC00",
+        "#66CC33",
+        "#9900CC",
+        "#9900FF",
+        "#9933CC",
+        "#9933FF",
+        "#99CC00",
+        "#99CC33",
+        "#CC0000",
+        "#CC0033",
+        "#CC0066",
+        "#CC0099",
+        "#CC00CC",
+        "#CC00FF",
+        "#CC3300",
+        "#CC3333",
+        "#CC3366",
+        "#CC3399",
+        "#CC33CC",
+        "#CC33FF",
+        "#CC6600",
+        "#CC6633",
+        "#CC9900",
+        "#CC9933",
+        "#CCCC00",
+        "#CCCC33",
+        "#FF0000",
+        "#FF0033",
+        "#FF0066",
+        "#FF0099",
+        "#FF00CC",
+        "#FF00FF",
+        "#FF3300",
+        "#FF3333",
+        "#FF3366",
+        "#FF3399",
+        "#FF33CC",
+        "#FF33FF",
+        "#FF6600",
+        "#FF6633",
+        "#FF9900",
+        "#FF9933",
+        "#FFCC00",
+        "#FFCC33"
+      ];
+      function useColors() {
+        if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+          return true;
         }
-        throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
-      };
-      function parse5(str) {
-        str = String(str);
-        if (str.length > 100) {
-          return;
+        if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+          return false;
         }
-        var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
-        if (!match2) {
+        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+      }
+      function formatArgs(args) {
+        args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+        if (!this.useColors) {
           return;
         }
-        var n = parseFloat(match2[1]);
-        var type = (match2[2] || "ms").toLowerCase();
-        switch (type) {
-          case "years":
-          case "year":
-          case "yrs":
-          case "yr":
-          case "y":
-            return n * y;
-          case "weeks":
-          case "week":
-          case "w":
-            return n * w;
-          case "days":
-          case "day":
-          case "d":
-            return n * d;
-          case "hours":
-          case "hour":
-          case "hrs":
-          case "hr":
-          case "h":
-            return n * h;
-          case "minutes":
-          case "minute":
-          case "mins":
-          case "min":
-          case "m":
-            return n * m;
-          case "seconds":
-          case "second":
-          case "secs":
-          case "sec":
-          case "s":
-            return n * s;
-          case "milliseconds":
-          case "millisecond":
-          case "msecs":
-          case "msec":
-          case "ms":
-            return n;
-          default:
-            return void 0;
-        }
+        const c = "color: " + this.color;
+        args.splice(1, 0, c, "color: inherit");
+        let index = 0;
+        let lastC = 0;
+        args[0].replace(/%[a-zA-Z%]/g, (match2) => {
+          if (match2 === "%%") {
+            return;
+          }
+          index++;
+          if (match2 === "%c") {
+            lastC = index;
+          }
+        });
+        args.splice(lastC, 0, c);
       }
-      function fmtShort(ms) {
-        var msAbs = Math.abs(ms);
-        if (msAbs >= d) {
-          return Math.round(ms / d) + "d";
-        }
-        if (msAbs >= h) {
-          return Math.round(ms / h) + "h";
-        }
-        if (msAbs >= m) {
-          return Math.round(ms / m) + "m";
-        }
-        if (msAbs >= s) {
-          return Math.round(ms / s) + "s";
+      exports.log = console.debug || console.log || (() => {
+      });
+      function save(namespaces) {
+        try {
+          if (namespaces) {
+            exports.storage.setItem("debug", namespaces);
+          } else {
+            exports.storage.removeItem("debug");
+          }
+        } catch (error2) {
         }
-        return ms + "ms";
       }
-      function fmtLong(ms) {
-        var msAbs = Math.abs(ms);
-        if (msAbs >= d) {
-          return plural(ms, msAbs, d, "day");
-        }
-        if (msAbs >= h) {
-          return plural(ms, msAbs, h, "hour");
-        }
-        if (msAbs >= m) {
-          return plural(ms, msAbs, m, "minute");
+      function load() {
+        let r;
+        try {
+          r = exports.storage.getItem("debug");
+        } catch (error2) {
         }
-        if (msAbs >= s) {
-          return plural(ms, msAbs, s, "second");
+        if (!r && typeof process !== "undefined" && "env" in process) {
+          r = process.env.DEBUG;
         }
-        return ms + " ms";
+        return r;
       }
-      function plural(ms, msAbs, n, name) {
-        var isPlural = msAbs >= n * 1.5;
-        return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+      function localstorage() {
+        try {
+          return localStorage;
+        } catch (error2) {
+        }
       }
+      module.exports = require_common()(exports);
+      var { formatters } = module.exports;
+      formatters.j = function(v) {
+        try {
+          return JSON.stringify(v);
+        } catch (error2) {
+          return "[UnexpectedJSONParseError]: " + error2.message;
+        }
+      };
     }
   });
 
-  // node_modules/@mswjs/interceptors/node_modules/debug/src/common.js
-  var require_common = __commonJS({
-    "node_modules/@mswjs/interceptors/node_modules/debug/src/common.js"(exports, module) {
-      function setup(env) {
-        createDebug.debug = createDebug;
-        createDebug.default = createDebug;
-        createDebug.coerce = coerce;
-        createDebug.disable = disable;
-        createDebug.enable = enable;
-        createDebug.enabled = enabled;
-        createDebug.humanize = require_ms();
-        createDebug.destroy = destroy;
-        Object.keys(env).forEach((key) => {
-          createDebug[key] = env[key];
-        });
-        createDebug.names = [];
-        createDebug.skips = [];
-        createDebug.formatters = {};
-        function selectColor(namespace) {
-          let hash = 0;
-          for (let i = 0; i < namespace.length; i++) {
-            hash = (hash << 5) - hash + namespace.charCodeAt(i);
-            hash |= 0;
-          }
-          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+  // node_modules/@mswjs/interceptors/node_modules/events/events.js
+  var require_events2 = __commonJS({
+    "node_modules/@mswjs/interceptors/node_modules/events/events.js"(exports, module) {
+      "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;
+      };
+      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);
         }
-        createDebug.selectColor = selectColor;
-        function createDebug(namespace) {
-          let prevTime;
-          let enableOverride = null;
-          let namespacesCache;
-          let enabledCache;
-          function debug(...args) {
-            if (!debug.enabled) {
-              return;
-            }
-            const self2 = debug;
-            const curr = Number(new Date());
-            const ms = curr - (prevTime || curr);
-            self2.diff = ms;
-            self2.prev = prevTime;
-            self2.curr = curr;
-            prevTime = curr;
-            args[0] = createDebug.coerce(args[0]);
-            if (typeof args[0] !== "string") {
-              args.unshift("%O");
-            }
-            let index = 0;
-            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format2) => {
-              if (match2 === "%%") {
-                return "%";
-              }
-              index++;
-              const formatter = createDebug.formatters[format2];
-              if (typeof formatter === "function") {
-                const val = args[index];
-                match2 = formatter.call(self2, val);
-                args.splice(index, 1);
-                index--;
-              }
-              return match2;
-            });
-            createDebug.formatArgs.call(self2, args);
-            const logFn = self2.log || createDebug.log;
-            logFn.apply(self2, args);
-          }
-          debug.namespace = namespace;
-          debug.useColors = createDebug.useColors();
-          debug.color = createDebug.selectColor(namespace);
-          debug.extend = extend;
-          debug.destroy = createDebug.destroy;
-          Object.defineProperty(debug, "enabled", {
-            enumerable: true,
-            configurable: false,
-            get: () => {
-              if (enableOverride !== null) {
-                return enableOverride;
-              }
-              if (namespacesCache !== createDebug.namespaces) {
-                namespacesCache = createDebug.namespaces;
-                enabledCache = createDebug.enabled(namespace);
-              }
-              return enabledCache;
-            },
-            set: (v) => {
-              enableOverride = v;
-            }
-          });
-          if (typeof createDebug.init === "function") {
-            createDebug.init(debug);
+      }
+      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 + ".");
           }
-          return debug;
-        }
-        function extend(namespace, delimiter) {
-          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
-          newDebug.log = this.log;
-          return newDebug;
+          defaultMaxListeners = arg;
         }
-        function enable(namespaces) {
-          createDebug.save(namespaces);
-          createDebug.namespaces = namespaces;
-          createDebug.names = [];
-          createDebug.skips = [];
-          let i;
-          const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
-          const len = split.length;
-          for (i = 0; i < len; i++) {
-            if (!split[i]) {
-              continue;
-            }
-            namespaces = split[i].replace(/\*/g, ".*?");
-            if (namespaces[0] === "-") {
-              createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
-            } else {
-              createDebug.names.push(new RegExp("^" + namespaces + "$"));
-            }
-          }
+      });
+      EventEmitter.init = function() {
+        if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
         }
-        function disable() {
-          const namespaces = [
-            ...createDebug.names.map(toNamespace),
-            ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
-          ].join(",");
-          createDebug.enable("");
-          return namespaces;
+        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 + ".");
         }
-        function enabled(name) {
-          if (name[name.length - 1] === "*") {
-            return true;
-          }
-          let i;
-          let len;
-          for (i = 0, len = createDebug.skips.length; i < len; i++) {
-            if (createDebug.skips[i].test(name)) {
-              return false;
-            }
-          }
-          for (i = 0, len = createDebug.names.length; i < len; i++) {
-            if (createDebug.names[i].test(name)) {
-              return true;
-            }
+        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;
           }
+          var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+          err.context = er;
+          throw err;
+        }
+        var handler = events[type];
+        if (handler === void 0)
           return false;
+        if (typeof handler === "function") {
+          ReflectApply(handler, this, args);
+        } else {
+          var len = handler.length;
+          var listeners2 = arrayClone(handler, len);
+          for (var i = 0; i < len; ++i)
+            ReflectApply(listeners2[i], this, args);
         }
-        function toNamespace(regexp) {
-          return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+        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];
         }
-        function coerce(val) {
-          if (val instanceof Error) {
-            return val.stack || val.message;
+        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);
+          } else {
+            existing.push(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 val;
         }
-        function destroy() {
-          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        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);
         }
-        createDebug.enable(createDebug.load());
-        return createDebug;
       }
-      module.exports = setup;
+      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 listeners2, 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;
+        }
+        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);
+          }
+          this.removeAllListeners("removeListener");
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+          return this;
+        }
+        listeners2 = events[type];
+        if (typeof listeners2 === "function") {
+          this.removeListener(type, listeners2);
+        } else if (listeners2 !== void 0) {
+          for (i = listeners2.length - 1; i >= 0; i--) {
+            this.removeListener(type, listeners2[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 listeners2(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);
+        }
+      };
+      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;
+          }
+        }
+        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];
+        }
+        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);
+        }
+      }
+      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);
+        }
+      }
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/node_modules/strict-event-emitter/lib/StrictEventEmitter.js
+  var require_StrictEventEmitter2 = __commonJS({
+    "node_modules/@mswjs/interceptors/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;
+        }
+        StrictEventEmitter3.prototype.on = function(event, listener) {
+          return _super.prototype.on.call(this, event.toString(), listener);
+        };
+        StrictEventEmitter3.prototype.once = function(event, listener) {
+          return _super.prototype.on.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) {
+          return _super.prototype.removeAllListeners.call(this, event ? event.toString() : void 0);
+        };
+        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 StrictEventEmitter3;
+      }(events_1.EventEmitter);
+      exports.StrictEventEmitter = StrictEventEmitter2;
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/node_modules/strict-event-emitter/lib/index.js
+  var require_lib7 = __commonJS({
+    "node_modules/@mswjs/interceptors/node_modules/strict-event-emitter/lib/index.js"(exports) {
+      "use strict";
+      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];
+        } });
+      } : function(o, m, k, k2) {
+        if (k2 === void 0)
+          k2 = k;
+        o[k2] = m[k];
+      });
+      var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+        for (var p in m)
+          if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+            __createBinding(exports2, m, p);
+      };
+      exports.__esModule = true;
+      __exportStar(require_StrictEventEmitter2(), exports);
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/utils/nextTick.js
+  var require_nextTick = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/utils/nextTick.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.nextTickAsync = exports.nextTick = void 0;
+      function nextTick(callback) {
+        setTimeout(callback, 0);
+      }
+      exports.nextTick = nextTick;
+      function nextTickAsync(callback) {
+        return new Promise(function(resolve) {
+          setTimeout(function() {
+            resolve(callback());
+          }, 0);
+        });
+      }
+      exports.nextTickAsync = nextTickAsync;
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/utils/AsyncEventEmitter.js
+  var require_AsyncEventEmitter = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/utils/AsyncEventEmitter.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) {
+          if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+          extendStatics(d, b);
+          function __() {
+            this.constructor = d;
+          }
+          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+        };
+      }();
+      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      var __generator = exports && exports.__generator || function(thisArg, body2) {
+        var _ = { label: 0, sent: function() {
+          if (t[0] & 1)
+            throw t[1];
+          return t[1];
+        }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+          return this;
+        }), g;
+        function verb(n) {
+          return function(v) {
+            return step([n, v]);
+          };
+        }
+        function step(op) {
+          if (f)
+            throw new TypeError("Generator is already executing.");
+          while (_)
+            try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                return t;
+              if (y = 0, t)
+                op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                case 0:
+                case 1:
+                  t = op;
+                  break;
+                case 4:
+                  _.label++;
+                  return { value: op[1], done: false };
+                case 5:
+                  _.label++;
+                  y = op[1];
+                  op = [0];
+                  continue;
+                case 7:
+                  op = _.ops.pop();
+                  _.trys.pop();
+                  continue;
+                default:
+                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                    _ = 0;
+                    continue;
+                  }
+                  if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                    _.label = op[1];
+                    break;
+                  }
+                  if (op[0] === 6 && _.label < t[1]) {
+                    _.label = t[1];
+                    t = op;
+                    break;
+                  }
+                  if (t && _.label < t[2]) {
+                    _.label = t[2];
+                    _.ops.push(op);
+                    break;
+                  }
+                  if (t[2])
+                    _.ops.pop();
+                  _.trys.pop();
+                  continue;
+              }
+              op = body2.call(thisArg, _);
+            } catch (e) {
+              op = [6, e];
+              y = 0;
+            } finally {
+              f = t = 0;
+            }
+          if (op[0] & 5)
+            throw op[1];
+          return { value: op[0] ? op[1] : void 0, done: true };
+        }
+      };
+      var __read = exports && exports.__read || function(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+          return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+          while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+            ar.push(r.value);
+        } catch (error2) {
+          e = { error: error2 };
+        } finally {
+          try {
+            if (r && !r.done && (m = i["return"]))
+              m.call(i);
+          } finally {
+            if (e)
+              throw e.error;
+          }
+        }
+        return ar;
+      };
+      var __spreadArray = exports && exports.__spreadArray || function(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+          to[j] = from[i];
+        return to;
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.AsyncEventEmitter = exports.AsyncEventEmitterReadyState = void 0;
+      var debug_1 = require_browser2();
+      var strict_event_emitter_1 = require_lib7();
+      var nextTick_1 = require_nextTick();
+      var AsyncEventEmitterReadyState;
+      (function(AsyncEventEmitterReadyState2) {
+        AsyncEventEmitterReadyState2["ACTIVE"] = "ACTIVE";
+        AsyncEventEmitterReadyState2["DEACTIVATED"] = "DEACTIVATED";
+      })(AsyncEventEmitterReadyState = exports.AsyncEventEmitterReadyState || (exports.AsyncEventEmitterReadyState = {}));
+      var AsyncEventEmitter = function(_super) {
+        __extends(AsyncEventEmitter2, _super);
+        function AsyncEventEmitter2() {
+          var _this = _super.call(this) || this;
+          _this.log = debug_1.debug("async-event-emitter");
+          _this.queue = /* @__PURE__ */ new Map();
+          _this.readyState = AsyncEventEmitterReadyState.ACTIVE;
+          return _this;
+        }
+        AsyncEventEmitter2.prototype.on = function(event, listener) {
+          var _this = this;
+          var log = this.log.extend("on");
+          log('adding "%s" listener...', event);
+          if (this.readyState === AsyncEventEmitterReadyState.DEACTIVATED) {
+            log("the emitter is destroyed, skipping!");
+            return this;
+          }
+          return _super.prototype.on.call(this, event, function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function() {
+              var queue;
+              var _this2 = this;
+              return __generator(this, function(_a) {
+                queue = this.openListenerQueue(event);
+                log('awaiting the "%s" listener...', event);
+                queue.push({
+                  args,
+                  done: new Promise(function(resolve, reject) {
+                    return __awaiter(_this2, void 0, void 0, function() {
+                      var error_1;
+                      return __generator(this, function(_a2) {
+                        switch (_a2.label) {
+                          case 0:
+                            _a2.trys.push([0, 2, , 3]);
+                            return [4, listener.apply(void 0, __spreadArray([], __read(args)))];
+                          case 1:
+                            _a2.sent();
+                            resolve();
+                            log('"%s" listener has resolved!', event);
+                            return [3, 3];
+                          case 2:
+                            error_1 = _a2.sent();
+                            log('"%s" listener has rejected!', error_1);
+                            reject(error_1);
+                            return [3, 3];
+                          case 3:
+                            return [2];
+                        }
+                      });
+                    });
+                  })
+                });
+                return [2];
+              });
+            });
+          });
+        };
+        AsyncEventEmitter2.prototype.emit = function(event) {
+          var _this = this;
+          var args = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+          }
+          var log = this.log.extend("emit");
+          log('emitting "%s" event...', event);
+          if (this.readyState === AsyncEventEmitterReadyState.DEACTIVATED) {
+            log("the emitter is destroyed, skipping!");
+            return false;
+          }
+          this.openListenerQueue(event);
+          log('appending a one-time cleanup "%s" listener...', event);
+          this.once(event, function() {
+            nextTick_1.nextTick(function() {
+              _this.queue.delete(event);
+              log('cleaned up "%s" listeners queue!', event);
+            });
+          });
+          return _super.prototype.emit.apply(this, __spreadArray([event], __read(args)));
+        };
+        AsyncEventEmitter2.prototype.untilIdle = function(event, filter) {
+          if (filter === void 0) {
+            filter = function() {
+              return true;
+            };
+          }
+          return __awaiter(this, void 0, void 0, function() {
+            var listenersQueue;
+            var _this = this;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  listenersQueue = this.queue.get(event) || [];
+                  return [4, Promise.all(listenersQueue.filter(filter).map(function(_a2) {
+                    var done = _a2.done;
+                    return done;
+                  })).finally(function() {
+                    _this.queue.delete(event);
+                  })];
+                case 1:
+                  _a.sent();
+                  return [2];
+              }
+            });
+          });
+        };
+        AsyncEventEmitter2.prototype.openListenerQueue = function(event) {
+          var log = this.log.extend("openListenerQueue");
+          log('opening "%s" listeners queue...', event);
+          var queue = this.queue.get(event);
+          if (!queue) {
+            log("no queue found, creating one...");
+            this.queue.set(event, []);
+            return [];
+          }
+          log("returning an exising queue:", queue);
+          return queue;
+        };
+        AsyncEventEmitter2.prototype.removeAllListeners = function(event) {
+          var log = this.log.extend("removeAllListeners");
+          log("event:", event);
+          if (event) {
+            this.queue.delete(event);
+            log('cleared the "%s" listeners queue!', event, this.queue.get(event));
+          } else {
+            this.queue.clear();
+            log("cleared the listeners queue!", this.queue);
+          }
+          return _super.prototype.removeAllListeners.call(this, event);
+        };
+        AsyncEventEmitter2.prototype.activate = function() {
+          var log = this.log.extend("activate");
+          this.readyState = AsyncEventEmitterReadyState.ACTIVE;
+          log("set state to:", this.readyState);
+        };
+        AsyncEventEmitter2.prototype.deactivate = function() {
+          var log = this.log.extend("deactivate");
+          log("removing all listeners...");
+          this.removeAllListeners();
+          this.readyState = AsyncEventEmitterReadyState.DEACTIVATED;
+          log("set state to:", this.readyState);
+        };
+        return AsyncEventEmitter2;
+      }(strict_event_emitter_1.StrictEventEmitter);
+      exports.AsyncEventEmitter = AsyncEventEmitter;
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/Interceptor.js
+  var require_Interceptor = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/Interceptor.js"(exports) {
+      "use strict";
+      var __values = exports && exports.__values || function(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+          return m.call(o);
+        if (o && typeof o.length === "number")
+          return {
+            next: function() {
+              if (o && i >= o.length)
+                o = void 0;
+              return { value: o && o[i++], done: !o };
+            }
+          };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.Interceptor = exports.InterceptorReadyState = exports.deleteGlobalSymbol = exports.getGlobalSymbol = void 0;
+      var debug_1 = require_browser2();
+      var AsyncEventEmitter_1 = require_AsyncEventEmitter();
+      var nextTick_1 = require_nextTick();
+      function getGlobalSymbol(symbol) {
+        return globalThis[symbol] || void 0;
+      }
+      exports.getGlobalSymbol = getGlobalSymbol;
+      function setGlobalSymbol(symbol, value) {
+        globalThis[symbol] = value;
+      }
+      function deleteGlobalSymbol(symbol) {
+        delete globalThis[symbol];
+      }
+      exports.deleteGlobalSymbol = deleteGlobalSymbol;
+      var InterceptorReadyState;
+      (function(InterceptorReadyState2) {
+        InterceptorReadyState2["IDLE"] = "IDLE";
+        InterceptorReadyState2["APPLYING"] = "APPLYING";
+        InterceptorReadyState2["APPLIED"] = "APPLIED";
+        InterceptorReadyState2["DISPOSING"] = "DISPOSING";
+        InterceptorReadyState2["DISPOSED"] = "DISPOSED";
+      })(InterceptorReadyState = exports.InterceptorReadyState || (exports.InterceptorReadyState = {}));
+      var Interceptor2 = function() {
+        function Interceptor3(symbol) {
+          this.symbol = symbol;
+          this.readyState = InterceptorReadyState.IDLE;
+          this.emitter = new AsyncEventEmitter_1.AsyncEventEmitter();
+          this.subscriptions = [];
+          this.log = debug_1.debug(symbol.description);
+          this.emitter.setMaxListeners(0);
+          this.log("constructing the interceptor...");
+        }
+        Interceptor3.prototype.checkEnvironment = function() {
+          return true;
+        };
+        Interceptor3.prototype.apply = function() {
+          var _this = this;
+          var log = this.log.extend("apply");
+          log("applying the interceptor...");
+          if (this.readyState === InterceptorReadyState.APPLIED) {
+            log("intercepted already applied!");
+            return;
+          }
+          var shouldApply = this.checkEnvironment();
+          if (!shouldApply) {
+            log("the interceptor cannot be applied in this environment!");
+            return;
+          }
+          this.readyState = InterceptorReadyState.APPLYING;
+          this.emitter.activate();
+          log("activated the emiter!", this.emitter.readyState);
+          var runningInstance = this.getInstance();
+          if (runningInstance) {
+            log("found a running instance, reusing...");
+            this.on = function(event, listener) {
+              log('proxying the "%s" listener', event);
+              runningInstance.emitter.addListener(event, listener);
+              _this.subscriptions.push(function() {
+                runningInstance.emitter.removeListener(event, listener);
+                log('removed proxied "%s" listener!', event);
+              });
+            };
+            nextTick_1.nextTick(function() {
+              _this.readyState = InterceptorReadyState.APPLIED;
+            });
+            return;
+          }
+          log("no running instance found, setting up a new instance...");
+          this.setup();
+          this.setInstance();
+          nextTick_1.nextTick(function() {
+            _this.readyState = InterceptorReadyState.APPLIED;
+          });
+        };
+        Interceptor3.prototype.setup = function() {
+        };
+        Interceptor3.prototype.on = function(event, listener) {
+          var log = this.log.extend("on");
+          if (this.readyState === InterceptorReadyState.DISPOSING || this.readyState === InterceptorReadyState.DISPOSED) {
+            log("cannot listen to events, already disposed!");
+            return;
+          }
+          log('adding "%s" event listener:', event, listener.name);
+          this.emitter.on(event, listener);
+        };
+        Interceptor3.prototype.dispose = function() {
+          var e_1, _a;
+          var _this = this;
+          var log = this.log.extend("dispose");
+          if (this.readyState === InterceptorReadyState.DISPOSED) {
+            log("cannot dispose, already disposed!");
+            return;
+          }
+          log("disposing the interceptor...");
+          this.readyState = InterceptorReadyState.DISPOSING;
+          if (!this.getInstance()) {
+            log("no interceptors running, skipping dispose...");
+            return;
+          }
+          this.clearInstance();
+          log("global symbol deleted:", getGlobalSymbol(this.symbol));
+          if (this.subscriptions.length > 0) {
+            log("disposing of %d subscriptions...", this.subscriptions.length);
+            try {
+              for (var _b = __values(this.subscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var dispose = _c.value;
+                dispose();
+              }
+            } catch (e_1_1) {
+              e_1 = { error: e_1_1 };
+            } finally {
+              try {
+                if (_c && !_c.done && (_a = _b.return))
+                  _a.call(_b);
+              } finally {
+                if (e_1)
+                  throw e_1.error;
+              }
+            }
+            this.subscriptions = [];
+            log("disposed of all subscriptions!", this.subscriptions.length);
+          }
+          this.emitter.deactivate();
+          log("destroyed the listener!");
+          nextTick_1.nextTick(function() {
+            _this.readyState = InterceptorReadyState.DISPOSED;
+          });
+        };
+        Interceptor3.prototype.getInstance = function() {
+          var _a;
+          var instance = getGlobalSymbol(this.symbol);
+          this.log("retrieved global instance:", (_a = instance === null || instance === void 0 ? void 0 : instance.constructor) === null || _a === void 0 ? void 0 : _a.name);
+          return instance;
+        };
+        Interceptor3.prototype.setInstance = function() {
+          setGlobalSymbol(this.symbol, this);
+          this.log("set global instance!", this.symbol.description);
+        };
+        Interceptor3.prototype.clearInstance = function() {
+          deleteGlobalSymbol(this.symbol);
+          this.log("cleared global instance!", this.symbol.description);
+        };
+        return Interceptor3;
+      }();
+      exports.Interceptor = Interceptor2;
     }
   });
 
-  // node_modules/@mswjs/interceptors/node_modules/debug/src/browser.js
-  var require_browser2 = __commonJS({
-    "node_modules/@mswjs/interceptors/node_modules/debug/src/browser.js"(exports, module) {
-      exports.formatArgs = formatArgs;
-      exports.save = save;
-      exports.load = load;
-      exports.useColors = useColors;
-      exports.storage = localstorage();
-      exports.destroy = (() => {
-        let warned = false;
-        return () => {
-          if (!warned) {
-            warned = true;
-            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  // node_modules/@mswjs/interceptors/lib/BatchInterceptor.js
+  var require_BatchInterceptor = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/BatchInterceptor.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) {
+          if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+          extendStatics(d, b);
+          function __() {
+            this.constructor = d;
           }
+          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
         };
-      })();
-      exports.colors = [
-        "#0000CC",
-        "#0000FF",
-        "#0033CC",
-        "#0033FF",
-        "#0066CC",
-        "#0066FF",
-        "#0099CC",
-        "#0099FF",
-        "#00CC00",
-        "#00CC33",
-        "#00CC66",
-        "#00CC99",
-        "#00CCCC",
-        "#00CCFF",
-        "#3300CC",
-        "#3300FF",
-        "#3333CC",
-        "#3333FF",
-        "#3366CC",
-        "#3366FF",
-        "#3399CC",
-        "#3399FF",
-        "#33CC00",
-        "#33CC33",
-        "#33CC66",
-        "#33CC99",
-        "#33CCCC",
-        "#33CCFF",
-        "#6600CC",
-        "#6600FF",
-        "#6633CC",
-        "#6633FF",
-        "#66CC00",
-        "#66CC33",
-        "#9900CC",
-        "#9900FF",
-        "#9933CC",
-        "#9933FF",
-        "#99CC00",
-        "#99CC33",
-        "#CC0000",
-        "#CC0033",
-        "#CC0066",
-        "#CC0099",
-        "#CC00CC",
-        "#CC00FF",
-        "#CC3300",
-        "#CC3333",
-        "#CC3366",
-        "#CC3399",
-        "#CC33CC",
-        "#CC33FF",
-        "#CC6600",
-        "#CC6633",
-        "#CC9900",
-        "#CC9933",
-        "#CCCC00",
-        "#CCCC33",
-        "#FF0000",
-        "#FF0033",
-        "#FF0066",
-        "#FF0099",
-        "#FF00CC",
-        "#FF00FF",
-        "#FF3300",
-        "#FF3333",
-        "#FF3366",
-        "#FF3399",
-        "#FF33CC",
-        "#FF33FF",
-        "#FF6600",
-        "#FF6633",
-        "#FF9900",
-        "#FF9933",
-        "#FFCC00",
-        "#FFCC33"
-      ];
-      function useColors() {
-        if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
-          return true;
+      }();
+      var __values = exports && exports.__values || function(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+          return m.call(o);
+        if (o && typeof o.length === "number")
+          return {
+            next: function() {
+              if (o && i >= o.length)
+                o = void 0;
+              return { value: o && o[i++], done: !o };
+            }
+          };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.BatchInterceptor = void 0;
+      var Interceptor_1 = require_Interceptor();
+      var BatchInterceptor2 = function(_super) {
+        __extends(BatchInterceptor3, _super);
+        function BatchInterceptor3(options) {
+          var _this = this;
+          BatchInterceptor3.symbol = Symbol(options.name);
+          _this = _super.call(this, BatchInterceptor3.symbol) || this;
+          _this.interceptors = options.interceptors;
+          return _this;
         }
-        if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-          return false;
+        BatchInterceptor3.prototype.setup = function() {
+          var e_1, _a;
+          var log = this.log.extend("setup");
+          log("applying all %d interceptors...", this.interceptors.length);
+          var _loop_1 = function(interceptor2) {
+            log('applying "%s" interceptor...', interceptor2.constructor.name);
+            interceptor2.apply();
+            log("adding interceptor dispose subscription");
+            this_1.subscriptions.push(function() {
+              return interceptor2.dispose();
+            });
+          };
+          var this_1 = this;
+          try {
+            for (var _b = __values(this.interceptors), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var interceptor = _c.value;
+              _loop_1(interceptor);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return))
+                _a.call(_b);
+            } finally {
+              if (e_1)
+                throw e_1.error;
+            }
+          }
+        };
+        BatchInterceptor3.prototype.on = function(event, listener) {
+          this.interceptors.forEach(function(interceptor) {
+            interceptor.on(event, listener);
+          });
+        };
+        return BatchInterceptor3;
+      }(Interceptor_1.Interceptor);
+      exports.BatchInterceptor = BatchInterceptor2;
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/index.js
+  var require_lib8 = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/index.js"(exports) {
+      "use strict";
+      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];
+        } });
+      } : function(o, m, k, k2) {
+        if (k2 === void 0)
+          k2 = k;
+        o[k2] = m[k];
+      });
+      var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+        for (var p in m)
+          if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+            __createBinding(exports2, m, p);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getCleanUrl = void 0;
+      __exportStar(require_glossary(), exports);
+      __exportStar(require_Interceptor(), exports);
+      __exportStar(require_BatchInterceptor(), exports);
+      var getCleanUrl_1 = require_getCleanUrl();
+      Object.defineProperty(exports, "getCleanUrl", { enumerable: true, get: function() {
+        return getCleanUrl_1.getCleanUrl;
+      } });
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/utils/createLazyCallback.js
+  var require_createLazyCallback = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/utils/createLazyCallback.js"(exports) {
+      "use strict";
+      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
         }
-        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
-      }
-      function formatArgs(args) {
-        args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
-        if (!this.useColors) {
-          return;
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      var __generator = exports && exports.__generator || function(thisArg, body2) {
+        var _ = { label: 0, sent: function() {
+          if (t[0] & 1)
+            throw t[1];
+          return t[1];
+        }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+          return this;
+        }), g;
+        function verb(n) {
+          return function(v) {
+            return step([n, v]);
+          };
+        }
+        function step(op) {
+          if (f)
+            throw new TypeError("Generator is already executing.");
+          while (_)
+            try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                return t;
+              if (y = 0, t)
+                op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                case 0:
+                case 1:
+                  t = op;
+                  break;
+                case 4:
+                  _.label++;
+                  return { value: op[1], done: false };
+                case 5:
+                  _.label++;
+                  y = op[1];
+                  op = [0];
+                  continue;
+                case 7:
+                  op = _.ops.pop();
+                  _.trys.pop();
+                  continue;
+                default:
+                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                    _ = 0;
+                    continue;
+                  }
+                  if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                    _.label = op[1];
+                    break;
+                  }
+                  if (op[0] === 6 && _.label < t[1]) {
+                    _.label = t[1];
+                    t = op;
+                    break;
+                  }
+                  if (t && _.label < t[2]) {
+                    _.label = t[2];
+                    _.ops.push(op);
+                    break;
+                  }
+                  if (t[2])
+                    _.ops.pop();
+                  _.trys.pop();
+                  continue;
+              }
+              op = body2.call(thisArg, _);
+            } catch (e) {
+              op = [6, e];
+              y = 0;
+            } finally {
+              f = t = 0;
+            }
+          if (op[0] & 5)
+            throw op[1];
+          return { value: op[0] ? op[1] : void 0, done: true };
         }
-        const c = "color: " + this.color;
-        args.splice(1, 0, c, "color: inherit");
-        let index = 0;
-        let lastC = 0;
-        args[0].replace(/%[a-zA-Z%]/g, (match2) => {
-          if (match2 === "%%") {
-            return;
-          }
-          index++;
-          if (match2 === "%c") {
-            lastC = index;
-          }
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.createLazyCallback = void 0;
+      function createLazyCallback(options) {
+        var _this = this;
+        if (options === void 0) {
+          options = {};
+        }
+        var calledTimes = 0;
+        var autoResolveTimeout;
+        var remoteResolve;
+        var callPromise = new Promise(function(resolve) {
+          remoteResolve = resolve;
+        }).finally(function() {
+          clearTimeout(autoResolveTimeout);
         });
-        args.splice(lastC, 0, c);
-      }
-      exports.log = console.debug || console.log || (() => {
-      });
-      function save(namespaces) {
-        try {
-          if (namespaces) {
-            exports.storage.setItem("debug", namespaces);
-          } else {
-            exports.storage.removeItem("debug");
+        var fn = function() {
+          var _a;
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
           }
-        } catch (error2) {
-        }
+          if (options.maxCalls && calledTimes >= options.maxCalls) {
+            (_a = options.maxCallsCallback) === null || _a === void 0 ? void 0 : _a.call(options);
+          }
+          remoteResolve(args);
+          calledTimes++;
+        };
+        fn.invoked = function() {
+          return __awaiter(_this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              autoResolveTimeout = setTimeout(function() {
+                remoteResolve([]);
+              }, 0);
+              return [2, callPromise];
+            });
+          });
+        };
+        return fn;
       }
-      function load() {
-        let r;
-        try {
-          r = exports.storage.getItem("debug");
-        } catch (error2) {
-        }
-        if (!r && typeof process !== "undefined" && "env" in process) {
-          r = process.env.DEBUG;
-        }
-        return r;
+      exports.createLazyCallback = createLazyCallback;
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/utils/toIsoResponse.js
+  var require_toIsoResponse = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/utils/toIsoResponse.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.toIsoResponse = void 0;
+      var headers_polyfill_1 = require_lib();
+      function toIsoResponse(response2) {
+        return {
+          status: response2.status || 200,
+          statusText: response2.statusText || "OK",
+          headers: headers_polyfill_1.objectToHeaders(response2.headers || {}),
+          body: response2.body
+        };
       }
-      function localstorage() {
-        try {
-          return localStorage;
-        } catch (error2) {
-        }
+      exports.toIsoResponse = toIsoResponse;
+    }
+  });
+
+  // node_modules/@mswjs/interceptors/lib/utils/uuid.js
+  var require_uuid = __commonJS({
+    "node_modules/@mswjs/interceptors/lib/utils/uuid.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.uuidv4 = void 0;
+      function uuidv4() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+          var r = Math.random() * 16 | 0;
+          var v = c == "x" ? r : r & 3 | 8;
+          return v.toString(16);
+        });
       }
-      module.exports = require_common()(exports);
-      var { formatters } = module.exports;
-      formatters.j = function(v) {
-        try {
-          return JSON.stringify(v);
-        } catch (error2) {
-          return "[UnexpectedJSONParseError]: " + error2.message;
-        }
-      };
+      exports.uuidv4 = uuidv4;
     }
   });
 
@@ -2691,6 +3662,27 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
   var require_fetch = __commonJS({
     "node_modules/@mswjs/interceptors/lib/interceptors/fetch/index.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) {
+          if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+          extendStatics(d, b);
+          function __() {
+            this.constructor = d;
+          }
+          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+        };
+      }();
       var __assign = exports && exports.__assign || function() {
         __assign = Object.assign || function(t) {
           for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -2806,83 +3798,126 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
           return { value: op[0] ? op[1] : void 0, done: true };
         }
       };
+      var __read = exports && exports.__read || function(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+          return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+          while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+            ar.push(r.value);
+        } catch (error2) {
+          e = { error: error2 };
+        } finally {
+          try {
+            if (r && !r.done && (m = i["return"]))
+              m.call(i);
+          } finally {
+            if (e)
+              throw e.error;
+          }
+        }
+        return ar;
+      };
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.interceptFetch = void 0;
+      exports.FetchInterceptor = void 0;
       var headers_polyfill_1 = require_lib();
+      var Interceptor_1 = require_Interceptor();
+      var createLazyCallback_1 = require_createLazyCallback();
       var toIsoResponse_1 = require_toIsoResponse();
       var uuid_1 = require_uuid();
-      var debug = require_browser2()("fetch");
-      var interceptFetch2 = function(observer, resolver) {
-        var pureFetch = window.fetch;
-        debug('replacing "window.fetch"...');
-        window.fetch = function(input, init) {
-          return __awaiter(void 0, void 0, void 0, function() {
-            var request, url, method, isoRequest, response2, isomorphicResponse;
-            var _a;
-            return __generator(this, function(_b) {
-              switch (_b.label) {
-                case 0:
-                  request = new Request(input, init);
-                  url = typeof input === "string" ? input : input.url;
-                  method = request.method;
-                  debug("[%s] %s", method, url);
-                  _a = {
-                    id: uuid_1.uuidv4(),
-                    url: new URL(url, location.origin),
-                    method,
-                    headers: new headers_polyfill_1.Headers(request.headers),
-                    credentials: request.credentials
-                  };
-                  return [4, request.clone().text()];
-                case 1:
-                  isoRequest = (_a.body = _b.sent(), _a);
-                  debug("isomorphic request", isoRequest);
-                  observer.emit("request", isoRequest);
-                  debug("awaiting for the mocked response...");
-                  return [4, resolver(isoRequest, request)];
-                case 2:
-                  response2 = _b.sent();
-                  debug("mocked response", response2);
-                  if (response2) {
-                    isomorphicResponse = toIsoResponse_1.toIsoResponse(response2);
-                    debug("derived isomorphic response", isomorphicResponse);
-                    observer.emit("response", isoRequest, isomorphicResponse);
-                    return [2, new Response(response2.body, __assign(__assign({}, isomorphicResponse), {
-                      headers: headers_polyfill_1.flattenHeadersObject(response2.headers || {})
-                    }))];
-                  }
-                  debug("no mocked response found, bypassing...");
-                  return [2, pureFetch(request).then(function(response3) {
-                    return __awaiter(void 0, void 0, void 0, function() {
-                      var cloneResponse, _a2, _b2, _c;
-                      return __generator(this, function(_d) {
-                        switch (_d.label) {
-                          case 0:
-                            cloneResponse = response3.clone();
-                            debug("original fetch performed", cloneResponse);
-                            _b2 = (_a2 = observer).emit;
-                            _c = [
-                              "response",
-                              isoRequest
-                            ];
-                            return [4, normalizeFetchResponse(cloneResponse)];
-                          case 1:
-                            _b2.apply(_a2, _c.concat([_d.sent()]));
-                            return [2, response3];
-                        }
+      var FetchInterceptor2 = function(_super) {
+        __extends(FetchInterceptor3, _super);
+        function FetchInterceptor3() {
+          return _super.call(this, FetchInterceptor3.symbol) || this;
+        }
+        FetchInterceptor3.prototype.checkEnvironment = function() {
+          return typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined";
+        };
+        FetchInterceptor3.prototype.setup = function() {
+          var _this = this;
+          var pureFetch = globalThis.fetch;
+          globalThis.fetch = function(input, init) {
+            return __awaiter(_this, void 0, void 0, function() {
+              var request, url, method, isomorphicRequest, _a, mockedResponse, isomorphicResponse;
+              var _b;
+              var _this2 = this;
+              return __generator(this, function(_c) {
+                switch (_c.label) {
+                  case 0:
+                    request = new Request(input, init);
+                    url = typeof input === "string" ? input : input.url;
+                    method = request.method;
+                    this.log("[%s] %s", method, url);
+                    _b = {
+                      id: uuid_1.uuidv4(),
+                      url: new URL(url, location.origin),
+                      method,
+                      headers: new headers_polyfill_1.Headers(request.headers),
+                      credentials: request.credentials
+                    };
+                    return [4, request.clone().text()];
+                  case 1:
+                    isomorphicRequest = (_b.body = _c.sent(), _b.respondWith = createLazyCallback_1.createLazyCallback(), _b);
+                    this.log("isomorphic request", isomorphicRequest);
+                    this.log('emitting the "request" event for %d listener(s)...', this.emitter.listenerCount("request"));
+                    this.emitter.emit("request", isomorphicRequest);
+                    this.log("awaiting for the mocked response...");
+                    return [4, this.emitter.untilIdle("request", function(_a2) {
+                      var _b2 = __read(_a2.args, 1), request2 = _b2[0];
+                      return request2.id === isomorphicRequest.id;
+                    })];
+                  case 2:
+                    _c.sent();
+                    this.log("all request listeners have been resolved!");
+                    return [4, isomorphicRequest.respondWith.invoked()];
+                  case 3:
+                    _a = __read.apply(void 0, [_c.sent(), 1]), mockedResponse = _a[0];
+                    this.log("event.respondWith called with:", mockedResponse);
+                    if (mockedResponse) {
+                      this.log("received mocked response:", mockedResponse);
+                      isomorphicResponse = toIsoResponse_1.toIsoResponse(mockedResponse);
+                      this.log("derived isomorphic response:", isomorphicResponse);
+                      this.emitter.emit("response", isomorphicRequest, isomorphicResponse);
+                      return [2, new Response(mockedResponse.body, __assign(__assign({}, isomorphicResponse), {
+                        headers: headers_polyfill_1.flattenHeadersObject(mockedResponse.headers || {})
+                      }))];
+                    }
+                    this.log("no mocked response received!");
+                    return [2, pureFetch(request).then(function(response2) {
+                      return __awaiter(_this2, void 0, void 0, function() {
+                        var cloneResponse, _a2, _b2, _c2;
+                        return __generator(this, function(_d) {
+                          switch (_d.label) {
+                            case 0:
+                              cloneResponse = response2.clone();
+                              this.log("original fetch performed", cloneResponse);
+                              _b2 = (_a2 = this.emitter).emit;
+                              _c2 = [
+                                "response",
+                                isomorphicRequest
+                              ];
+                              return [4, normalizeFetchResponse(cloneResponse)];
+                            case 1:
+                              _b2.apply(_a2, _c2.concat([_d.sent()]));
+                              return [2, response2];
+                          }
+                        });
                       });
-                    });
-                  })];
-              }
+                    })];
+                }
+              });
             });
+          };
+          this.subscriptions.push(function() {
+            globalThis.fetch = pureFetch;
+            _this.log('restored native "globalThis.fetch"!', globalThis.fetch.name);
           });
         };
-        return function() {
-          debug("restoring modules...");
-          window.fetch = pureFetch;
-        };
-      };
-      exports.interceptFetch = interceptFetch2;
+        FetchInterceptor3.symbol = Symbol("fetch");
+        return FetchInterceptor3;
+      }(Interceptor_1.Interceptor);
+      exports.FetchInterceptor = FetchInterceptor2;
       function normalizeFetchResponse(response2) {
         return __awaiter(this, void 0, void 0, function() {
           var _a;
@@ -5066,7 +6101,7 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
   });
 
   // node_modules/@xmldom/xmldom/lib/index.js
-  var require_lib8 = __commonJS({
+  var require_lib9 = __commonJS({
     "node_modules/@xmldom/xmldom/lib/index.js"(exports) {
       var dom = require_dom();
       exports.DOMImplementation = dom.DOMImplementation;
@@ -5248,6 +6283,18 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
   var require_XMLHttpRequestOverride = __commonJS({
     "node_modules/@mswjs/interceptors/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.js"(exports) {
       "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s)
+              if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
       var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
         function adopt(value) {
           return value instanceof P ? value : new P(function(resolve) {
@@ -5390,20 +6437,20 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
       exports.createXMLHttpRequestOverride = void 0;
       var until_1 = require_lib4();
       var headers_polyfill_1 = require_lib();
-      var xmldom_1 = require_lib8();
+      var xmldom_1 = require_lib9();
       var parseJson_1 = require_parseJson();
       var toIsoResponse_1 = require_toIsoResponse();
       var uuid_1 = require_uuid();
       var bufferFrom_1 = require_bufferFrom();
       var createEvent_1 = require_createEvent();
-      var createDebug = require_browser2();
+      var createLazyCallback_1 = require_createLazyCallback();
       var createXMLHttpRequestOverride = function(options) {
         var _a;
-        var pureXMLHttpRequest = options.pureXMLHttpRequest, observer = options.observer, resolver = options.resolver;
-        var debug = createDebug("XHR");
+        var XMLHttpRequest = options.XMLHttpRequest, emitter = options.emitter, log = options.log;
         return _a = function() {
           function XMLHttpRequestOverride() {
             this._events = [];
+            this.log = log;
             this.UNSENT = 0;
             this.OPENED = 1;
             this.HEADERS_RECEIVED = 2;
@@ -5438,24 +6485,24 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             if (nextState === this.readyState) {
               return;
             }
-            debug("readyState change %d -> %d", this.readyState, nextState);
+            this.log("readyState change %d -> %d", this.readyState, nextState);
             this.readyState = nextState;
             if (nextState !== this.UNSENT) {
-              debug("triggerring readystate change...");
+              this.log("triggerring readystate change...");
               this.trigger("readystatechange");
             }
           };
           XMLHttpRequestOverride.prototype.trigger = function(eventName, options2) {
             var e_1, _a2;
-            debug('trigger "%s" (%d)', eventName, this.readyState);
-            debug('resolve listener for event "%s"', eventName);
+            this.log('trigger "%s" (%d)', eventName, this.readyState);
+            this.log('resolve listener for event "%s"', eventName);
             var callback = this["on" + eventName];
             callback === null || callback === void 0 ? void 0 : callback.call(this, createEvent_1.createEvent(this, eventName, options2));
             try {
               for (var _b = __values(this._events), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var event_1 = _c.value;
                 if (event_1.name === eventName) {
-                  debug('calling mock event listener "%s" (%d)', eventName, this.readyState);
+                  log('calling mock event listener "%s" (%d)', eventName, this.readyState);
                   event_1.listener.call(this, createEvent_1.createEvent(this, eventName, options2));
                 }
               }
@@ -5473,7 +6520,7 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             return this;
           };
           XMLHttpRequestOverride.prototype.reset = function() {
-            debug("reset");
+            this.log("reset");
             this.setReadyState(this.UNSENT);
             this.status = 200;
             this.statusText = "OK";
@@ -5490,8 +6537,8 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             }
             return __awaiter(this, void 0, void 0, function() {
               return __generator(this, function(_a2) {
-                debug = createDebug("XHR " + method + " " + url);
-                debug("open", { method, url, async, user, password });
+                this.log = this.log.extend("request " + method + " " + url);
+                this.log("open", { method, url, async, user, password });
                 this.reset();
                 this.setReadyState(this.OPENED);
                 if (typeof url === "undefined") {
@@ -5510,7 +6557,7 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
           };
           XMLHttpRequestOverride.prototype.send = function(data2) {
             var _this = this;
-            debug("send %s %s", this.method, this.url);
+            this.log("send %s %s", this.method, this.url);
             this.data = data2 || "";
             var url;
             try {
@@ -5518,8 +6565,8 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             } catch (error2) {
               url = new URL(this.url, window.location.href);
             }
-            debug("request headers", this._requestHeaders);
-            var isoRequest = {
+            this.log("request headers", this._requestHeaders);
+            var isomorphicRequest = {
               id: uuid_1.uuidv4(),
               url,
               method: this.method,
@@ -5527,37 +6574,55 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
               credentials: this.withCredentials ? "include" : "omit",
               body: this.data
             };
-            observer.emit("request", isoRequest);
-            debug("awaiting mocked response...");
+            var interactiveIsomorphicRequest = __assign(__assign({}, isomorphicRequest), { respondWith: createLazyCallback_1.createLazyCallback() });
+            this.log('emitting the "request" event for %d listener(s)...', emitter.listenerCount("request"));
+            emitter.emit("request", interactiveIsomorphicRequest);
+            this.log("awaiting mocked response...");
             Promise.resolve(until_1.until(function() {
               return __awaiter(_this, void 0, void 0, function() {
-                return __generator(this, function(_a2) {
-                  return [2, resolver(isoRequest, this)];
+                var _a2, mockedResponse;
+                return __generator(this, function(_b) {
+                  switch (_b.label) {
+                    case 0:
+                      return [4, emitter.untilIdle("request", function(_a3) {
+                        var _b2 = __read(_a3.args, 1), request = _b2[0];
+                        return request.id === interactiveIsomorphicRequest.id;
+                      })];
+                    case 1:
+                      _b.sent();
+                      this.log("all request listeners have been resolved!");
+                      return [4, interactiveIsomorphicRequest.respondWith.invoked()];
+                    case 2:
+                      _a2 = __read.apply(void 0, [_b.sent(), 1]), mockedResponse = _a2[0];
+                      this.log("event.respondWith called with:", mockedResponse);
+                      return [2, mockedResponse];
+                  }
                 });
               });
             })).then(function(_a2) {
               var _b;
               var _c = __read(_a2, 2), middlewareException = _c[0], mockedResponse = _c[1];
               if (middlewareException) {
-                debug("middleware function threw an exception!", middlewareException);
+                _this.log("middleware function threw an exception!", middlewareException);
                 _this.trigger("error");
                 _this.abort();
                 return;
               }
               if (mockedResponse) {
-                debug("received mocked response", mockedResponse);
+                _this.log("received mocked response", mockedResponse);
                 _this.trigger("loadstart");
                 _this.status = mockedResponse.status || 200;
                 _this.statusText = mockedResponse.statusText || "OK";
                 _this._responseHeaders = mockedResponse.headers ? headers_polyfill_1.objectToHeaders(mockedResponse.headers) : new headers_polyfill_1.Headers();
-                debug("set response status", _this.status, _this.statusText);
-                debug("set response headers", _this._responseHeaders);
+                _this.log("set response status", _this.status, _this.statusText);
+                _this.log("set response headers", _this._responseHeaders);
                 _this.setReadyState(_this.HEADERS_RECEIVED);
-                debug("response type", _this.responseType);
+                _this.log("response type", _this.responseType);
                 _this.response = _this.getResponseBody(mockedResponse.body);
+                _this.responseURL = _this.url;
                 _this.responseText = mockedResponse.body || "";
                 _this.responseXML = _this.getResponseXML();
-                debug("set response body", _this.response);
+                _this.log("set response body", _this.response);
                 if (mockedResponse.body && _this.response) {
                   _this.setReadyState(_this.LOADING);
                   var bodyBuffer = bufferFrom_1.bufferFrom(mockedResponse.body);
@@ -5569,14 +6634,14 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
                 _this.setReadyState(_this.DONE);
                 _this.trigger("load");
                 _this.trigger("loadend");
-                observer.emit("response", isoRequest, toIsoResponse_1.toIsoResponse(mockedResponse));
+                emitter.emit("response", isomorphicRequest, toIsoResponse_1.toIsoResponse(mockedResponse));
               } else {
-                debug("no mocked response received!");
-                var originalRequest_1 = new pureXMLHttpRequest();
-                debug("opening an original request %s %s", _this.method, _this.url);
+                _this.log("no mocked response received!");
+                var originalRequest_1 = new XMLHttpRequest();
+                _this.log("opening an original request %s %s", _this.method, _this.url);
                 originalRequest_1.open(_this.method, _this.url, (_b = _this.async) !== null && _b !== void 0 ? _b : true, _this.user, _this.password);
                 originalRequest_1.addEventListener("load", function() {
-                  debug('original "onload"');
+                  _this.log('original "onload"');
                   _this.status = originalRequest_1.status;
                   _this.statusText = originalRequest_1.statusText;
                   _this.responseURL = originalRequest_1.responseURL;
@@ -5584,16 +6649,16 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
                   _this.response = originalRequest_1.response;
                   _this.responseText = originalRequest_1.responseText;
                   _this.responseXML = originalRequest_1.responseXML;
-                  debug("set mock request readyState to DONE");
+                  _this.log("set mock request readyState to DONE");
                   _this.setReadyState(_this.DONE);
-                  debug("received original response", _this.status, _this.statusText);
-                  debug("original response body:", _this.response);
+                  _this.log("received original response", _this.status, _this.statusText);
+                  _this.log("original response body:", _this.response);
                   var responseHeaders = originalRequest_1.getAllResponseHeaders();
-                  debug("original response headers:\n", responseHeaders);
+                  _this.log("original response headers:\n", responseHeaders);
                   _this._responseHeaders = headers_polyfill_1.stringToHeaders(responseHeaders);
-                  debug("original response headers (normalized)", _this._responseHeaders);
-                  debug("original response finished");
-                  observer.emit("response", isoRequest, {
+                  _this.log("original response headers (normalized)", _this._responseHeaders);
+                  _this.log("original response finished");
+                  emitter.emit("response", isomorphicRequest, {
                     status: originalRequest_1.status,
                     statusText: originalRequest_1.statusText,
                     headers: _this._responseHeaders,
@@ -5606,13 +6671,13 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
                 if (_this.async) {
                   originalRequest_1.timeout = _this.timeout;
                 }
-                debug("send", _this.data);
+                _this.log("send", _this.data);
                 originalRequest_1.send(_this.data);
               }
             });
           };
           XMLHttpRequestOverride.prototype.abort = function() {
-            debug("abort");
+            this.log("abort");
             if (this.readyState > this.UNSENT && this.readyState < this.DONE) {
               this.setReadyState(this.UNSENT);
               this.trigger("abort");
@@ -5622,36 +6687,36 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             return false;
           };
           XMLHttpRequestOverride.prototype.setRequestHeader = function(name, value) {
-            debug('set request header "%s" to "%s"', name, value);
+            this.log('set request header "%s" to "%s"', name, value);
             this._requestHeaders.append(name, value);
           };
           XMLHttpRequestOverride.prototype.getResponseHeader = function(name) {
-            debug('get response header "%s"', name);
+            this.log('get response header "%s"', name);
             if (this.readyState < this.HEADERS_RECEIVED) {
-              debug("cannot return a header: headers not received (state: %s)", this.readyState);
+              this.log("cannot return a header: headers not received (state: %s)", this.readyState);
               return null;
             }
             var headerValue = this._responseHeaders.get(name);
-            debug('resolved response header "%s" to "%s"', name, headerValue, this._responseHeaders);
+            this.log('resolved response header "%s" to "%s"', name, headerValue, this._responseHeaders);
             return headerValue;
           };
           XMLHttpRequestOverride.prototype.getAllResponseHeaders = function() {
-            debug("get all response headers");
+            this.log("get all response headers");
             if (this.readyState < this.HEADERS_RECEIVED) {
-              debug("cannot return headers: headers not received (state: %s)", this.readyState);
+              this.log("cannot return headers: headers not received (state: %s)", this.readyState);
               return "";
             }
             return headers_polyfill_1.headersToString(this._responseHeaders);
           };
           XMLHttpRequestOverride.prototype.addEventListener = function(name, listener) {
-            debug("addEventListener", name, listener);
+            this.log("addEventListener", name, listener);
             this._events.push({
               name,
               listener
             });
           };
           XMLHttpRequestOverride.prototype.removeEventListener = function(name, listener) {
-            debug("removeEventListener", name, listener);
+            this.log("removeEventListener", name, listener);
             this._events = this._events.filter(function(storedEvent) {
               return storedEvent.name !== name && storedEvent.listener !== listener;
             });
@@ -5660,21 +6725,21 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
           };
           XMLHttpRequestOverride.prototype.getResponseBody = function(body2) {
             var textBody = body2 !== null && body2 !== void 0 ? body2 : "";
-            debug("coerced response body to", textBody);
+            this.log("coerced response body to", textBody);
             switch (this.responseType) {
               case "json": {
-                debug("resolving response body as JSON");
+                this.log("resolving response body as JSON");
                 return parseJson_1.parseJson(textBody);
               }
               case "blob": {
                 var blobType = this.getResponseHeader("content-type") || "text/plain";
-                debug("resolving response body as Blob", { type: blobType });
+                this.log("resolving response body as Blob", { type: blobType });
                 return new Blob([textBody], {
                   type: blobType
                 });
               }
               case "arraybuffer": {
-                debug("resolving response body as ArrayBuffer");
+                this.log("resolving response body as ArrayBuffer");
                 var arrayBuffer = bufferFrom_1.bufferFrom(textBody);
                 return arrayBuffer;
               }
@@ -5690,6 +6755,38 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             return null;
           };
           XMLHttpRequestOverride.prototype.propagateCallbacks = function(request) {
+            var e_2, _a2;
+            this.log("propagating request callbacks to the original request");
+            var callbackNames = [
+              "abort",
+              "onerror",
+              "ontimeout",
+              "onload",
+              "onloadstart",
+              "onloadend",
+              "onprogress",
+              "onreadystatechange"
+            ];
+            try {
+              for (var callbackNames_1 = __values(callbackNames), callbackNames_1_1 = callbackNames_1.next(); !callbackNames_1_1.done; callbackNames_1_1 = callbackNames_1.next()) {
+                var callbackName = callbackNames_1_1.value;
+                var callback = this[callbackName];
+                if (callback) {
+                  request[callbackName] = this[callbackName];
+                  this.log('propagated the "%s" callback', callbackName, callback);
+                }
+              }
+            } catch (e_2_1) {
+              e_2 = { error: e_2_1 };
+            } finally {
+              try {
+                if (callbackNames_1_1 && !callbackNames_1_1.done && (_a2 = callbackNames_1.return))
+                  _a2.call(callbackNames_1);
+              } finally {
+                if (e_2)
+                  throw e_2.error;
+              }
+            }
             request.onabort = this.abort;
             request.onerror = this.onerror;
             request.ontimeout = this.ontimeout;
@@ -5700,17 +6797,18 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
             request.onreadystatechange = this.onreadystatechange;
           };
           XMLHttpRequestOverride.prototype.propagateListeners = function(request) {
-            debug("propagating request listeners (%d) to the original request", this._events.length, this._events);
+            this.log("propagating request listeners (%d) to the original request", this._events.length, this._events);
             this._events.forEach(function(_a2) {
               var name = _a2.name, listener = _a2.listener;
               request.addEventListener(name, listener);
             });
           };
           XMLHttpRequestOverride.prototype.propagateHeaders = function(request, headers) {
-            debug("propagating request headers to the original request", headers);
+            var _this = this;
+            this.log("propagating request headers to the original request", headers);
             Object.entries(headers.raw()).forEach(function(_a2) {
               var _b = __read(_a2, 2), name = _b[0], value = _b[1];
-              debug('setting "%s" (%s) header on the original request', name, value);
+              _this.log('setting "%s" (%s) header on the original request', name, value);
               request.setRequestHeader(name, value);
             });
           };
@@ -5725,29 +6823,58 @@ spawn('node', ['module.js'], { stdio: ['ipc'] })`);
   var require_XMLHttpRequest = __commonJS({
     "node_modules/@mswjs/interceptors/lib/interceptors/XMLHttpRequest/index.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) {
+          if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+          extendStatics(d, b);
+          function __() {
+            this.constructor = d;
+          }
+          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+        };
+      }();
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.interceptXMLHttpRequest = void 0;
+      exports.XMLHttpRequestInterceptor = void 0;
+      var Interceptor_1 = require_Interceptor();
       var XMLHttpRequestOverride_1 = require_XMLHttpRequestOverride();
-      var debug = require_browser2()("XHR");
-      var pureXMLHttpRequest = typeof window === "undefined" ? void 0 : window.XMLHttpRequest;
-      var interceptXMLHttpRequest2 = function(observer, resolver) {
-        if (pureXMLHttpRequest) {
-          debug('patching "XMLHttpRequest" module...');
-          var XMLHttpRequestOverride = XMLHttpRequestOverride_1.createXMLHttpRequestOverride({
-            pureXMLHttpRequest,
-            observer,
-            resolver
-          });
-          window.XMLHttpRequest = XMLHttpRequestOverride;
+      var XMLHttpRequestInterceptor2 = function(_super) {
+        __extends(XMLHttpRequestInterceptor3, _super);
+        function XMLHttpRequestInterceptor3() {
+          return _super.call(this, XMLHttpRequestInterceptor3.symbol) || this;
         }
-        return function() {
-          if (pureXMLHttpRequest) {
-            debug("restoring modules...");
-            window.XMLHttpRequest = pureXMLHttpRequest;
-          }
+        XMLHttpRequestInterceptor3.prototype.checkEnvironment = function() {
+          return typeof window !== "undefined" && typeof window.XMLHttpRequest !== "undefined";
         };
-      };
-      exports.interceptXMLHttpRequest = interceptXMLHttpRequest2;
+        XMLHttpRequestInterceptor3.prototype.setup = function() {
+          var log = this.log.extend("setup");
+          log('patching "XMLHttpRequest" module...');
+          var PureXMLHttpRequest = window.XMLHttpRequest;
+          window.XMLHttpRequest = XMLHttpRequestOverride_1.createXMLHttpRequestOverride({
+            XMLHttpRequest: PureXMLHttpRequest,
+            emitter: this.emitter,
+            log: this.log
+          });
+          log('native "XMLHttpRequest" module patched!', window.XMLHttpRequest.name);
+          this.subscriptions.push(function() {
+            window.XMLHttpRequest = PureXMLHttpRequest;
+            log('native "XMLHttpRequest" module restored!', window.XMLHttpRequest.name);
+          });
+        };
+        XMLHttpRequestInterceptor3.symbol = Symbol("xhr");
+        return XMLHttpRequestInterceptor3;
+      }(Interceptor_1.Interceptor);
+      exports.XMLHttpRequestInterceptor = XMLHttpRequestInterceptor2;
     }
   });
 
@@ -9275,11 +10402,7 @@ Read more: https://mswjs.io/docs/getting-started/mocks`
       try {
         const request = parseWorkerRequest(message.payload);
         await handleRequest(request, context.requestHandlers, options, context.emitter, {
-          transformResponse(response2) {
-            return __spreadProps(__spreadValues({}, response2), {
-              headers: response2.headers.all()
-            });
-          },
+          transformResponse,
           onPassthroughResponse() {
             return channel.send({
               type: "MOCK_NOT_FOUND"
@@ -9292,9 +10415,10 @@ Read more: https://mswjs.io/docs/getting-started/mocks`
             });
           },
           onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
-            if (!options.quiet) {
-              handler.log(publicRequest, response2, handler, parsedRequest);
+            if (options.quiet) {
+              return;
             }
+            handler.log(publicRequest, response2, handler, parsedRequest);
           }
         });
       } catch (error2) {
@@ -9323,6 +10447,15 @@ Read more: https://mswjs.io/docs/getting-started/mocks`
       }
     };
   };
+  function transformResponse(response2) {
+    return {
+      status: response2.status,
+      statusText: response2.statusText,
+      headers: response2.headers.all(),
+      body: response2.body,
+      delay: response2.delay
+    };
+  }
 
   // src/utils/internal/requestIntegrityCheck.ts
   async function requestIntegrityCheck(context, serviceWorker) {
@@ -9507,7 +10640,7 @@ If this message still persists after updating, please report an issue: https://g
   }
 
   // src/utils/worker/createFallbackRequestListener.ts
-  var import_interceptors = __toESM(require_lib7());
+  var import_interceptors = __toESM(require_lib8());
   var import_fetch3 = __toESM(require_fetch());
   var import_XMLHttpRequest = __toESM(require_XMLHttpRequest());
 
@@ -9538,25 +10671,30 @@ If this message still persists after updating, please report an issue: https://g
 
   // src/utils/worker/createFallbackRequestListener.ts
   function createFallbackRequestListener(context, options) {
-    const interceptor = (0, import_interceptors.createInterceptor)({
-      modules: [import_fetch3.interceptFetch, import_XMLHttpRequest.interceptXMLHttpRequest],
-      async resolver(request) {
-        const mockedRequest = parseIsomorphicRequest(request);
-        return handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
-          transformResponse(response2) {
-            return {
-              status: response2.status,
-              statusText: response2.statusText,
-              headers: response2.headers.all(),
-              body: response2.body
-            };
-          },
-          onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
-            if (!options.quiet) {
-              handler.log(publicRequest, response2, handler, parsedRequest);
-            }
+    const interceptor = new import_interceptors.BatchInterceptor({
+      name: "fallback",
+      interceptors: [new import_fetch3.FetchInterceptor(), new import_XMLHttpRequest.XMLHttpRequestInterceptor()]
+    });
+    interceptor.on("request", async (request) => {
+      const mockedRequest = parseIsomorphicRequest(request);
+      const response2 = await handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
+        transformResponse(response3) {
+          return {
+            status: response3.status,
+            statusText: response3.statusText,
+            headers: response3.headers.all(),
+            body: response3.body,
+            delay: response3.delay
+          };
+        },
+        onMockedResponseSent(response3, { handler, publicRequest, parsedRequest }) {
+          if (!options.quiet) {
+            handler.log(publicRequest, response3, handler, parsedRequest);
           }
-        });
+        }
+      });
+      if (response2) {
+        request.respondWith(response2);
       }
     });
     interceptor.apply();
@@ -9579,7 +10717,7 @@ If this message still persists after updating, please report an issue: https://g
   function createFallbackStop(context) {
     return function stop() {
       var _a, _b;
-      (_a = context.fallbackInterceptor) == null ? void 0 : _a.restore();
+      (_a = context.fallbackInterceptor) == null ? void 0 : _a.dispose();
       printStopMessage({ quiet: (_b = context.startOptions) == null ? void 0 : _b.quiet });
     };
   }