msw 2.12.7 → 2.12.8

package/lib/browser/index.js

@@ -494,20 +494,165 @@ You can also automate this process and make the worker script update automatical
   return integrityCheckPromise;
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
-var encoder = new TextEncoder();
-function encodeBuffer(text) {
-  return encoder.encode(text);
-}
-function decodeBuffer(buffer, encoding) {
-  const decoder = new TextDecoder(encoding);
-  return decoder.decode(buffer);
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-BTaNLFr0.mjs
+var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+var InterceptorError = class InterceptorError2 extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InterceptorError";
+    Object.setPrototypeOf(this, InterceptorError2.prototype);
+  }
+};
+var RequestController = class RequestController2 {
+  static {
+    this.PENDING = 0;
+  }
+  static {
+    this.PASSTHROUGH = 1;
+  }
+  static {
+    this.RESPONSE = 2;
+  }
+  static {
+    this.ERROR = 3;
+  }
+  constructor(request, source) {
+    this.request = request;
+    this.source = source;
+    this.readyState = RequestController2.PENDING;
+    this.handled = new DeferredPromise();
+  }
+  get #handled() {
+    return this.handled;
+  }
+  /**
+  * Perform this request as-is.
+  */
+  async passthrough() {
+    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to passthrough the "%s %s" request: the request has already been handled', this.request.method, this.request.url);
+    this.readyState = RequestController2.PASSTHROUGH;
+    await this.source.passthrough();
+    this.#handled.resolve();
+  }
+  /**
+  * Respond to this request with the given `Response` instance.
+  *
+  * @example
+  * controller.respondWith(new Response())
+  * controller.respondWith(Response.json({ id }))
+  * controller.respondWith(Response.error())
+  */
+  respondWith(response) {
+    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)', this.request.method, this.request.url, response.status, response.statusText || "OK", this.readyState);
+    this.readyState = RequestController2.RESPONSE;
+    this.#handled.resolve();
+    this.source.respondWith(response);
+  }
+  /**
+  * Error this request with the given reason.
+  *
+  * @example
+  * controller.errorWith()
+  * controller.errorWith(new Error('Oops!'))
+  * controller.errorWith({ message: 'Oops!'})
+  */
+  errorWith(reason) {
+    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)', this.request.method, this.request.url, reason?.toString(), this.readyState);
+    this.readyState = RequestController2.ERROR;
+    this.source.errorWith(reason);
+    this.#handled.resolve();
+  }
+};
+function canParseUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (_error) {
+    return false;
+  }
 }
-function toArrayBuffer(array) {
-  return array.buffer.slice(
-    array.byteOffset,
-    array.byteOffset + array.byteLength
-  );
+function getValueBySymbol(symbolName, source) {
+  const symbol = Object.getOwnPropertySymbols(source).find((symbol$1) => {
+    return symbol$1.description === symbolName;
+  });
+  if (symbol) return Reflect.get(source, symbol);
+}
+var FetchResponse = class FetchResponse2 extends Response {
+  static {
+    this.STATUS_CODES_WITHOUT_BODY = [
+      101,
+      103,
+      204,
+      205,
+      304
+    ];
+  }
+  static {
+    this.STATUS_CODES_WITH_REDIRECT = [
+      301,
+      302,
+      303,
+      307,
+      308
+    ];
+  }
+  static isConfigurableStatusCode(status) {
+    return status >= 200 && status <= 599;
+  }
+  static isRedirectResponse(status) {
+    return FetchResponse2.STATUS_CODES_WITH_REDIRECT.includes(status);
+  }
+  /**
+  * Returns a boolean indicating whether the given response status
+  * code represents a response that can have a body.
+  */
+  static isResponseWithBody(status) {
+    return !FetchResponse2.STATUS_CODES_WITHOUT_BODY.includes(status);
+  }
+  static setUrl(url, response) {
+    if (!url || url === "about:" || !canParseUrl(url)) return;
+    const state = getValueBySymbol("state", response);
+    if (state) state.urlList.push(new URL(url));
+    else Object.defineProperty(response, "url", {
+      value: url,
+      enumerable: true,
+      configurable: true,
+      writable: false
+    });
+  }
+  /**
+  * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+  */
+  static parseRawHeaders(rawHeaders) {
+    const headers = new Headers();
+    for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
+    return headers;
+  }
+  constructor(body, init = {}) {
+    const status = init.status ?? 200;
+    const safeStatus = FetchResponse2.isConfigurableStatusCode(status) ? status : 200;
+    const finalBody = FetchResponse2.isResponseWithBody(status) ? body : null;
+    super(finalBody, {
+      status: safeStatus,
+      statusText: init.statusText,
+      headers: init.headers
+    });
+    if (status !== safeStatus) {
+      const state = getValueBySymbol("state", this);
+      if (state) state.status = status;
+      else Object.defineProperty(this, "status", {
+        value: status,
+        enumerable: true,
+        configurable: true,
+        writable: false
+      });
+    }
+    FetchResponse2.setUrl(init.url, this);
+  }
+};
+var kRawRequest = Symbol("kRawRequest");
+function setRawRequest(request, rawRequest) {
+  Reflect.set(request, kRawRequest, rawRequest);
 }
 
 // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
@@ -947,26 +1092,10 @@ var _Emitter = class {
 var Emitter = _Emitter;
 Emitter.defaultMaxListeners = 10;
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-Z5TSB3T6.mjs
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DQcIlohW.mjs
 var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
 function getGlobalSymbol(symbol) {
-  return (
-    // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
-    globalThis[symbol] || void 0
-  );
+  return globalThis[symbol] || void 0;
 }
 function setGlobalSymbol(symbol, value) {
   globalThis[symbol] = value;
@@ -974,10 +1103,18 @@ function setGlobalSymbol(symbol, value) {
 function deleteGlobalSymbol(symbol) {
   delete globalThis[symbol];
 }
+var InterceptorReadyState = /* @__PURE__ */ (function(InterceptorReadyState$1) {
+  InterceptorReadyState$1["INACTIVE"] = "INACTIVE";
+  InterceptorReadyState$1["APPLYING"] = "APPLYING";
+  InterceptorReadyState$1["APPLIED"] = "APPLIED";
+  InterceptorReadyState$1["DISPOSING"] = "DISPOSING";
+  InterceptorReadyState$1["DISPOSED"] = "DISPOSED";
+  return InterceptorReadyState$1;
+})({});
 var Interceptor = class {
   constructor(symbol) {
     this.symbol = symbol;
-    this.readyState = "INACTIVE";
+    this.readyState = InterceptorReadyState.INACTIVE;
     this.emitter = new Emitter();
     this.subscriptions = [];
     this.logger = new Logger(symbol.description);
@@ -985,29 +1122,28 @@ var Interceptor = class {
     this.logger.info("constructing the interceptor...");
   }
   /**
-   * Determine if this interceptor can be applied
-   * in the current environment.
-   */
+  * Determine if this interceptor can be applied
+  * in the current environment.
+  */
   checkEnvironment() {
     return true;
   }
   /**
-   * Apply this interceptor to the current process.
-   * Returns an already running interceptor instance if it's present.
-   */
+  * Apply this interceptor to the current process.
+  * Returns an already running interceptor instance if it's present.
+  */
   apply() {
     const logger = this.logger.extend("apply");
     logger.info("applying the interceptor...");
-    if (this.readyState === "APPLIED") {
+    if (this.readyState === InterceptorReadyState.APPLIED) {
       logger.info("intercepted already applied!");
       return;
     }
-    const shouldApply = this.checkEnvironment();
-    if (!shouldApply) {
+    if (!this.checkEnvironment()) {
       logger.info("the interceptor cannot be applied in this environment!");
       return;
     }
-    this.readyState = "APPLYING";
+    this.readyState = InterceptorReadyState.APPLYING;
     const runningInstance = this.getInstance();
     if (runningInstance) {
       logger.info("found a running instance, reusing...");
@@ -1020,27 +1156,27 @@ var Interceptor = class {
         });
         return this;
       };
-      this.readyState = "APPLIED";
+      this.readyState = InterceptorReadyState.APPLIED;
       return;
     }
     logger.info("no running instance found, setting up a new instance...");
     this.setup();
     this.setInstance();
-    this.readyState = "APPLIED";
+    this.readyState = InterceptorReadyState.APPLIED;
   }
   /**
-   * Setup the module augments and stubs necessary for this interceptor.
-   * This method is not run if there's a running interceptor instance
-   * to prevent instantiating an interceptor multiple times.
-   */
+  * Setup the module augments and stubs necessary for this interceptor.
+  * This method is not run if there's a running interceptor instance
+  * to prevent instantiating an interceptor multiple times.
+  */
   setup() {
   }
   /**
-   * Listen to the interceptor's public events.
-   */
+  * Listen to the interceptor's public events.
+  */
   on(event, listener) {
     const logger = this.logger.extend("on");
-    if (this.readyState === "DISPOSING" || this.readyState === "DISPOSED") {
+    if (this.readyState === InterceptorReadyState.DISPOSING || this.readyState === InterceptorReadyState.DISPOSED) {
       logger.info("cannot listen to events, already disposed!");
       return this;
     }
@@ -1061,16 +1197,16 @@ var Interceptor = class {
     return this;
   }
   /**
-   * Disposes of any side-effects this interceptor has introduced.
-   */
+  * Disposes of any side-effects this interceptor has introduced.
+  */
   dispose() {
     const logger = this.logger.extend("dispose");
-    if (this.readyState === "DISPOSED") {
+    if (this.readyState === InterceptorReadyState.DISPOSED) {
       logger.info("cannot dispose, already disposed!");
       return;
     }
     logger.info("disposing the interceptor...");
-    this.readyState = "DISPOSING";
+    this.readyState = InterceptorReadyState.DISPOSING;
     if (!this.getInstance()) {
       logger.info("no interceptors running, skipping dispose...");
       return;
@@ -1079,20 +1215,17 @@ var Interceptor = class {
     logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
     if (this.subscriptions.length > 0) {
       logger.info("disposing of %d subscriptions...", this.subscriptions.length);
-      for (const dispose of this.subscriptions) {
-        dispose();
-      }
+      for (const dispose of this.subscriptions) dispose();
       this.subscriptions = [];
       logger.info("disposed of all subscriptions!", this.subscriptions.length);
     }
     this.emitter.removeAllListeners();
     logger.info("destroyed the listener!");
-    this.readyState = "DISPOSED";
+    this.readyState = InterceptorReadyState.DISPOSED;
   }
   getInstance() {
-    var _a;
     const instance = getGlobalSymbol(this.symbol);
-    this.logger.info("retrieved global instance:", (_a = instance == null ? void 0 : instance.constructor) == null ? void 0 : _a.name);
+    this.logger.info("retrieved global instance:", instance?.constructor?.name);
     return instance;
   }
   setInstance() {
@@ -1108,192 +1241,23 @@ function createRequestId() {
   return Math.random().toString(16).slice(2);
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-LIKZF2VU.mjs
-var IS_PATCHED_MODULE = Symbol("isPatchedModule");
-var InterceptorError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InterceptorError";
-    Object.setPrototypeOf(this, InterceptorError.prototype);
-  }
-};
-var _handled;
-var handled_get;
-var _RequestController = class {
-  constructor(request, source) {
-    this.request = request;
-    this.source = source;
-    __privateAdd(this, _handled);
-    this.readyState = _RequestController.PENDING;
-    this.handled = new DeferredPromise();
-  }
-  /**
-   * Perform this request as-is.
-   */
-  async passthrough() {
-    invariant.as(
-      InterceptorError,
-      this.readyState === _RequestController.PENDING,
-      'Failed to passthrough the "%s %s" request: the request has already been handled',
-      this.request.method,
-      this.request.url
-    );
-    this.readyState = _RequestController.PASSTHROUGH;
-    await this.source.passthrough();
-    __privateGet(this, _handled, handled_get).resolve();
-  }
-  /**
-   * Respond to this request with the given `Response` instance.
-   *
-   * @example
-   * controller.respondWith(new Response())
-   * controller.respondWith(Response.json({ id }))
-   * controller.respondWith(Response.error())
-   */
-  respondWith(response) {
-    invariant.as(
-      InterceptorError,
-      this.readyState === _RequestController.PENDING,
-      'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)',
-      this.request.method,
-      this.request.url,
-      response.status,
-      response.statusText || "OK",
-      this.readyState
-    );
-    this.readyState = _RequestController.RESPONSE;
-    __privateGet(this, _handled, handled_get).resolve();
-    this.source.respondWith(response);
-  }
-  /**
-   * Error this request with the given reason.
-   *
-   * @example
-   * controller.errorWith()
-   * controller.errorWith(new Error('Oops!'))
-   * controller.errorWith({ message: 'Oops!'})
-   */
-  errorWith(reason) {
-    invariant.as(
-      InterceptorError,
-      this.readyState === _RequestController.PENDING,
-      'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)',
-      this.request.method,
-      this.request.url,
-      reason == null ? void 0 : reason.toString(),
-      this.readyState
-    );
-    this.readyState = _RequestController.ERROR;
-    this.source.errorWith(reason);
-    __privateGet(this, _handled, handled_get).resolve();
-  }
-};
-var RequestController = _RequestController;
-_handled = /* @__PURE__ */ new WeakSet();
-handled_get = function() {
-  return this.handled;
-};
-RequestController.PENDING = 0;
-RequestController.PASSTHROUGH = 1;
-RequestController.RESPONSE = 2;
-RequestController.ERROR = 3;
-function canParseUrl(url) {
-  try {
-    new URL(url);
-    return true;
-  } catch (_error) {
-    return false;
-  }
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/bufferUtils-BiiO6HZv.mjs
+var encoder = new TextEncoder();
+function encodeBuffer(text) {
+  return encoder.encode(text);
 }
-function getValueBySymbol(symbolName, source) {
-  const ownSymbols = Object.getOwnPropertySymbols(source);
-  const symbol = ownSymbols.find((symbol2) => {
-    return symbol2.description === symbolName;
-  });
-  if (symbol) {
-    return Reflect.get(source, symbol);
-  }
-  return;
+function decodeBuffer(buffer, encoding) {
+  return new TextDecoder(encoding).decode(buffer);
 }
-var _FetchResponse = class extends Response {
-  static isConfigurableStatusCode(status) {
-    return status >= 200 && status <= 599;
-  }
-  static isRedirectResponse(status) {
-    return _FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status);
-  }
-  /**
-   * Returns a boolean indicating whether the given response status
-   * code represents a response that can have a body.
-   */
-  static isResponseWithBody(status) {
-    return !_FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status);
-  }
-  static setUrl(url, response) {
-    if (!url || url === "about:" || !canParseUrl(url)) {
-      return;
-    }
-    const state = getValueBySymbol("state", response);
-    if (state) {
-      state.urlList.push(new URL(url));
-    } else {
-      Object.defineProperty(response, "url", {
-        value: url,
-        enumerable: true,
-        configurable: true,
-        writable: false
-      });
-    }
-  }
-  /**
-   * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
-   */
-  static parseRawHeaders(rawHeaders) {
-    const headers = new Headers();
-    for (let line = 0; line < rawHeaders.length; line += 2) {
-      headers.append(rawHeaders[line], rawHeaders[line + 1]);
-    }
-    return headers;
-  }
-  constructor(body, init = {}) {
-    var _a;
-    const status = (_a = init.status) != null ? _a : 200;
-    const safeStatus = _FetchResponse.isConfigurableStatusCode(status) ? status : 200;
-    const finalBody = _FetchResponse.isResponseWithBody(status) ? body : null;
-    super(finalBody, {
-      status: safeStatus,
-      statusText: init.statusText,
-      headers: init.headers
-    });
-    if (status !== safeStatus) {
-      const state = getValueBySymbol("state", this);
-      if (state) {
-        state.status = status;
-      } else {
-        Object.defineProperty(this, "status", {
-          value: status,
-          enumerable: true,
-          configurable: true,
-          writable: false
-        });
-      }
-    }
-    _FetchResponse.setUrl(init.url, this);
-  }
-};
-var FetchResponse = _FetchResponse;
-FetchResponse.STATUS_CODES_WITHOUT_BODY = [101, 103, 204, 205, 304];
-FetchResponse.STATUS_CODES_WITH_REDIRECT = [301, 302, 303, 307, 308];
-var kRawRequest = Symbol("kRawRequest");
-function setRawRequest(request, rawRequest) {
-  Reflect.set(request, kRawRequest, rawRequest);
+function toArrayBuffer(array) {
+  return array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/index.mjs
-var BatchInterceptor = class extends Interceptor {
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+var BatchInterceptor = class BatchInterceptor2 extends Interceptor {
   constructor(options) {
-    BatchInterceptor.symbol = Symbol(options.name);
-    super(BatchInterceptor.symbol);
+    BatchInterceptor2.symbol = Symbol(options.name);
+    super(BatchInterceptor2.symbol);
     this.interceptors = options.interceptors;
   }
   setup() {
@@ -1307,27 +1271,19 @@ var BatchInterceptor = class extends Interceptor {
     }
   }
   on(event, listener) {
-    for (const interceptor of this.interceptors) {
-      interceptor.on(event, listener);
-    }
+    for (const interceptor of this.interceptors) interceptor.on(event, listener);
     return this;
   }
   once(event, listener) {
-    for (const interceptor of this.interceptors) {
-      interceptor.once(event, listener);
-    }
+    for (const interceptor of this.interceptors) interceptor.once(event, listener);
     return this;
   }
   off(event, listener) {
-    for (const interceptor of this.interceptors) {
-      interceptor.off(event, listener);
-    }
+    for (const interceptor of this.interceptors) interceptor.off(event, listener);
     return this;
   }
   removeAllListeners(event) {
-    for (const interceptors of this.interceptors) {
-      interceptors.removeAllListeners(event);
-    }
+    for (const interceptors of this.interceptors) interceptors.removeAllListeners(event);
     return this;
   }
 };
@@ -1472,16 +1428,85 @@ var import_webSocketInterceptor = require("../core/ws/webSocketInterceptor");
 var import_handleWebSocketEvent = require("../core/ws/handleWebSocketEvent");
 var import_attachWebSocketLogger = require("../core/ws/utils/attachWebSocketLogger");
 
-// node_modules/.pnpm/rettime@0.7.0/node_modules/rettime/build/index.js
+// node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/lens-list.mjs
+var LensList = class {
+  #list;
+  #lens;
+  constructor() {
+    this.#list = [];
+    this.#lens = /* @__PURE__ */ new Map();
+  }
+  get [Symbol.iterator]() {
+    return this.#list[Symbol.iterator].bind(this.#list);
+  }
+  entries() {
+    return this.#lens.entries();
+  }
+  /**
+  * Return an order-sensitive list of values by the given key.
+  */
+  get(key) {
+    return this.#lens.get(key) || [];
+  }
+  /**
+  * Return an order-sensitive list of all values.
+  */
+  getAll() {
+    return this.#list.map(([, value]) => value);
+  }
+  /**
+  * Append a new value to the given key.
+  */
+  append(key, value) {
+    this.#list.push([key, value]);
+    this.#openLens(key, (list) => list.push(value));
+  }
+  /**
+  * Prepend a new value to the given key.
+  */
+  prepend(key, value) {
+    this.#list.unshift([key, value]);
+    this.#openLens(key, (list) => list.unshift(value));
+  }
+  /**
+  * Delete the value belonging to the given key.
+  */
+  delete(key, value) {
+    if (this.size === 0) return;
+    this.#list = this.#list.filter((item) => item[1] !== value);
+    for (const [existingKey, values] of this.#lens) if (existingKey === key && values.includes(value)) values.splice(values.indexOf(value), 1);
+  }
+  /**
+  * Delete all values belogning to the given key.
+  */
+  deleteAll(key) {
+    if (this.size === 0) return;
+    this.#list = this.#list.filter((item) => item[0] !== key);
+    this.#lens.delete(key);
+  }
+  get size() {
+    return this.#list.length;
+  }
+  clear() {
+    if (this.size === 0) return;
+    this.#list.length = 0;
+    this.#lens.clear();
+  }
+  #openLens(key, setter) {
+    setter(this.#lens.get(key) || this.#lens.set(key, []).get(key));
+  }
+};
+
+// node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/index.mjs
 var kDefaultPrevented = Symbol("kDefaultPrevented");
 var kPropagationStopped = Symbol("kPropagationStopped");
 var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
 var TypedEvent = class extends MessageEvent {
   /**
-   * @note Keep a placeholder property with the return type
-   * because the type must be set somewhere in order to be
-   * correctly associated and inferred from the event.
-   */
+  * @note Keep a placeholder property with the return type
+  * because the type must be set somewhere in order to be
+  * correctly associated and inferred from the event.
+  */
   #returnType;
   [kDefaultPrevented];
   [kPropagationStopped];
@@ -1506,189 +1531,157 @@ var kListenerOptions = Symbol("kListenerOptions");
 var Emitter2 = class {
   #listeners;
   constructor() {
-    this.#listeners = {};
+    this.#listeners = new LensList();
   }
   /**
-   * Adds a listener for the given event type.
-   *
-   * @returns {AbortController} An `AbortController` that can be used to remove the listener.
-   */
+  * Adds a listener for the given event type.
+  */
   on(type, listener, options) {
-    return this.#addListener(type, listener, options);
+    this.#addListener(type, listener, options);
+    return this;
   }
   /**
-   * Adds a one-time listener for the given event type.
-   *
-   * @returns {AbortController} An `AbortController` that can be used to remove the listener.
-   */
+  * Adds a one-time listener for the given event type.
+  */
   once(type, listener, options) {
-    return this.on(type, listener, { ...options || {}, once: true });
+    return this.on(type, listener, {
+      ...options || {},
+      once: true
+    });
   }
   /**
-   * Prepends a listener for the given event type.
-   *
-   * @returns {AbortController} An `AbortController` that can be used to remove the listener.
-   */
+  * Prepends a listener for the given event type.
+  */
   earlyOn(type, listener, options) {
-    return this.#addListener(type, listener, options, "prepend");
+    this.#addListener(type, listener, options, "prepend");
+    return this;
   }
   /**
-   * Prepends a one-time listener for the given event type.
-   */
+  * Prepends a one-time listener for the given event type.
+  */
   earlyOnce(type, listener, options) {
-    return this.earlyOn(type, listener, { ...options || {}, once: true });
+    return this.earlyOn(type, listener, {
+      ...options || {},
+      once: true
+    });
   }
   /**
-   * Emits the given typed event.
-   *
-   * @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
-   */
+  * Emits the given typed event.
+  *
+  * @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
+  */
   emit(event) {
-    if (this.listenerCount(event.type) === 0) {
-      return false;
-    }
+    if (this.#listeners.size === 0) return false;
+    const hasListeners = this.listenerCount(event.type) > 0;
     const proxiedEvent = this.#proxyEvent(event);
-    for (const listener of this.#listeners[event.type]) {
+    for (const listener of this.#matchListeners(event.type)) {
       if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+        proxiedEvent.revoke();
         return false;
       }
-      if (proxiedEvent.event[kImmediatePropagationStopped]) {
-        break;
-      }
+      if (proxiedEvent.event[kImmediatePropagationStopped]) break;
       this.#callListener(proxiedEvent.event, listener);
     }
     proxiedEvent.revoke();
-    return true;
+    return hasListeners;
   }
   /**
-   * Emits the given typed event and returns a promise that resolves
-   * when all the listeners for that event have settled.
-   *
-   * @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
-   * with the return values of all listeners.
-   */
+  * Emits the given typed event and returns a promise that resolves
+  * when all the listeners for that event have settled.
+  *
+  * @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
+  * with the return values of all listeners.
+  */
   async emitAsPromise(event) {
-    if (this.listenerCount(event.type) === 0) {
-      return [];
-    }
+    if (this.#listeners.size === 0) return [];
     const pendingListeners = [];
     const proxiedEvent = this.#proxyEvent(event);
-    for (const listener of this.#listeners[event.type]) {
+    for (const listener of this.#matchListeners(event.type)) {
       if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+        proxiedEvent.revoke();
         return [];
       }
-      if (proxiedEvent.event[kImmediatePropagationStopped]) {
-        break;
-      }
-      pendingListeners.push(
-        // Awaiting individual listeners guarantees their call order.
-        await Promise.resolve(this.#callListener(proxiedEvent.event, listener))
-      );
+      if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+      const returnValue = await Promise.resolve(this.#callListener(proxiedEvent.event, listener));
+      if (!this.#isTypelessListener(listener)) pendingListeners.push(returnValue);
     }
     proxiedEvent.revoke();
     return Promise.allSettled(pendingListeners).then((results) => {
-      return results.map(
-        (result) => result.status === "fulfilled" ? result.value : result.reason
-      );
+      return results.map((result) => result.status === "fulfilled" ? result.value : result.reason);
     });
   }
   /**
-   * Emits the given event and returns a generator that yields
-   * the result of each listener in the order of their registration.
-   * This way, you stop exhausting the listeners once you get the expected value.
-   */
+  * Emits the given event and returns a generator that yields
+  * the result of each listener in the order of their registration.
+  * This way, you stop exhausting the listeners once you get the expected value.
+  */
   *emitAsGenerator(event) {
-    if (this.listenerCount(event.type) === 0) {
-      return;
-    }
+    if (this.#listeners.size === 0) return;
     const proxiedEvent = this.#proxyEvent(event);
-    for (const listener of this.#listeners[event.type]) {
+    for (const listener of this.#matchListeners(event.type)) {
       if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+        proxiedEvent.revoke();
         return;
       }
-      if (proxiedEvent.event[kImmediatePropagationStopped]) {
-        break;
-      }
-      yield this.#callListener(proxiedEvent.event, listener);
+      if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+      const returnValue = this.#callListener(proxiedEvent.event, listener);
+      if (!this.#isTypelessListener(listener)) yield returnValue;
     }
     proxiedEvent.revoke();
   }
   /**
-   * Removes a listener for the given event type.
-   */
+  * Removes a listener for the given event type.
+  */
   removeListener(type, listener) {
-    if (this.listenerCount(type) === 0) {
-      return;
-    }
-    const nextListeners = [];
-    for (const existingListener of this.#listeners[type]) {
-      if (existingListener !== listener) {
-        nextListeners.push(existingListener);
-      }
-    }
-    this.#listeners[type] = nextListeners;
+    this.#listeners.delete(type, listener);
   }
   /**
-   * Removes all listeners for the given event type.
-   * If no event type is provided, removes all existing listeners.
-   */
+  * Removes all listeners for the given event type.
+  * If no event type is provided, removes all existing listeners.
+  */
   removeAllListeners(type) {
     if (type == null) {
-      this.#listeners = {};
+      this.#listeners.clear();
       return;
     }
-    this.#listeners[type] = [];
+    this.#listeners.deleteAll(type);
   }
   /**
-   * Returns the list of listeners for the given event type.
-   * If no even type is provided, returns all listeners.
-   */
+  * Returns the list of listeners for the given event type.
+  * If no even type is provided, returns all listeners.
+  */
   listeners(type) {
-    if (type == null) {
-      return Object.values(this.#listeners).flat();
-    }
-    return this.#listeners[type] || [];
+    if (type == null) return this.#listeners.getAll();
+    return this.#listeners.get(type);
   }
   /**
-   * Returns the number of listeners for the given event type.
-   * If no even type is provided, returns the total number of listeners.
-   */
+  * Returns the number of listeners for the given event type.
+  * If no even type is provided, returns the total number of listeners.
+  */
   listenerCount(type) {
+    if (type == null) return this.#listeners.size;
     return this.listeners(type).length;
   }
   #addListener(type, listener, options, insertMode = "append") {
-    this.#listeners[type] ??= [];
-    if (insertMode === "prepend") {
-      this.#listeners[type].unshift(listener);
-    } else {
-      this.#listeners[type].push(listener);
-    }
+    if (insertMode === "prepend") this.#listeners.prepend(type, listener);
+    else this.#listeners.append(type, listener);
     if (options) {
       Object.defineProperty(listener, kListenerOptions, {
         value: options,
         enumerable: false,
         writable: false
       });
-      if (options.signal) {
-        options.signal.addEventListener(
-          "abort",
-          () => {
-            this.removeListener(type, listener);
-          },
-          { once: true }
-        );
-      }
+      if (options.signal) options.signal.addEventListener("abort", () => {
+        this.removeListener(type, listener);
+      }, { once: true });
     }
-    return this;
   }
   #proxyEvent(event) {
     const { stopPropagation } = event;
-    event.stopPropagation = new Proxy(event.stopPropagation, {
-      apply: (target, thisArg, argArray) => {
-        event[kPropagationStopped] = this;
-        return Reflect.apply(target, thisArg, argArray);
-      }
-    });
+    event.stopPropagation = new Proxy(event.stopPropagation, { apply: (target, thisArg, argArray) => {
+      event[kPropagationStopped] = this;
+      return Reflect.apply(target, thisArg, argArray);
+    } });
     return {
       event,
       revoke() {
@@ -1699,10 +1692,21 @@ var Emitter2 = class {
   #callListener(event, listener) {
     const returnValue = listener.call(this, event);
     if (listener[kListenerOptions]?.once) {
-      this.removeListener(event.type, listener);
+      const key = this.#isTypelessListener(listener) ? "*" : event.type;
+      this.#listeners.delete(key, listener);
     }
     return returnValue;
   }
+  /**
+  * Return a list of all event listeners relevant for the given event type.
+  * This includes the explicit event listeners and also typeless event listeners.
+  */
+  *#matchListeners(type) {
+    for (const [key, listener] of this.#listeners) if (key === "*" || key === type) yield listener;
+  }
+  #isTypelessListener(listener) {
+    return this.#listeners.get("*").includes(listener);
+  }
 };
 
 // src/browser/utils/workerChannel.ts
@@ -1765,31 +1769,19 @@ var WorkerChannel = class extends Emitter2 {
   }
 };
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-VYSDLBSS.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/hasConfigurableGlobal-C8kXFDic.mjs
 async function emitAsync(emitter, eventName, ...data) {
   const listeners = emitter.listeners(eventName);
-  if (listeners.length === 0) {
-    return;
-  }
-  for (const listener of listeners) {
-    await listener.apply(emitter, data);
-  }
+  if (listeners.length === 0) return;
+  for (const listener of listeners) await listener.apply(emitter, data);
 }
 function hasConfigurableGlobal(propertyName) {
   const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
-  if (typeof descriptor === "undefined") {
-    return false;
-  }
-  if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") {
-    return false;
-  }
-  if (typeof descriptor.get === "undefined" && descriptor.value == null) {
-    return false;
-  }
+  if (typeof descriptor === "undefined") return false;
+  if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") return false;
+  if (typeof descriptor.get === "undefined" && descriptor.value == null) return false;
   if (typeof descriptor.set === "undefined" && !descriptor.configurable) {
-    console.error(
-      `[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`
-    );
+    console.error(`[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`);
     return false;
   }
   return true;
@@ -1807,7 +1799,7 @@ var until2 = async (promise) => {
   }
 };
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-VOUOVDAW.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/handleRequest-DxGbCTbb.mjs
 function isObject2(value, loose = false) {
   return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
 }
@@ -1815,27 +1807,20 @@ function isPropertyAccessible(obj, key) {
   try {
     obj[key];
     return true;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
 function createServerErrorResponse(body) {
-  return new Response(
-    JSON.stringify(
-      body instanceof Error ? {
-        name: body.name,
-        message: body.message,
-        stack: body.stack
-      } : body
-    ),
-    {
-      status: 500,
-      statusText: "Unhandled Exception",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    }
-  );
+  return new Response(JSON.stringify(body instanceof Error ? {
+    name: body.name,
+    message: body.message,
+    stack: body.stack
+  } : body), {
+    status: 500,
+    statusText: "Unhandled Exception",
+    headers: { "Content-Type": "application/json" }
+  });
 }
 function isResponseError(response) {
   return response != null && response instanceof Response && isPropertyAccessible(response, "type") && response.type === "error";
@@ -1844,12 +1829,8 @@ function isResponseLike(value) {
   return isObject2(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
 }
 function isNodeLikeError(error2) {
-  if (error2 == null) {
-    return false;
-  }
-  if (!(error2 instanceof Error)) {
-    return false;
-  }
+  if (error2 == null) return false;
+  if (!(error2 instanceof Error)) return false;
   return "code" in error2 && "errno" in error2;
 }
 async function handleRequest2(options) {
@@ -1873,16 +1854,12 @@ async function handleRequest2(options) {
     return false;
   };
   const handleResponseError = async (error2) => {
-    if (error2 instanceof InterceptorError) {
-      throw result.error;
-    }
+    if (error2 instanceof InterceptorError) throw result.error;
     if (isNodeLikeError(error2)) {
       await options.controller.errorWith(error2);
       return true;
     }
-    if (error2 instanceof Response) {
-      return await handleResponse(error2);
-    }
+    if (error2 instanceof Response) return await handleResponse(error2);
     return false;
   };
   const requestAbortPromise = new DeferredPromise();
@@ -1891,13 +1868,9 @@ async function handleRequest2(options) {
       await options.controller.errorWith(options.request.signal.reason);
       return;
     }
-    options.request.signal.addEventListener(
-      "abort",
-      () => {
-        requestAbortPromise.reject(options.request.signal.reason);
-      },
-      { once: true }
-    );
+    options.request.signal.addEventListener("abort", () => {
+      requestAbortPromise.reject(options.request.signal.reason);
+    }, { once: true });
   }
   const result = await until2(async () => {
     const requestListenersPromise = emitAsync(options.emitter, "request", {
@@ -1906,7 +1879,6 @@ async function handleRequest2(options) {
       controller: options.controller
     });
     await Promise.race([
-      // Short-circuit the request handling promise if the request gets aborted.
       requestAbortPromise,
       requestListenersPromise,
       options.controller.handled
@@ -1917,54 +1889,36 @@ async function handleRequest2(options) {
     return;
   }
   if (result.error) {
-    if (await handleResponseError(result.error)) {
-      return;
-    }
+    if (await handleResponseError(result.error)) return;
     if (options.emitter.listenerCount("unhandledException") > 0) {
-      const unhandledExceptionController = new RequestController(
-        options.request,
-        {
-          /**
-           * @note Intentionally empty passthrough handle.
-           * This controller is created within another controller and we only need
-           * to know if `unhandledException` listeners handled the request.
-           */
-          passthrough() {
-          },
-          async respondWith(response) {
-            await handleResponse(response);
-          },
-          async errorWith(reason) {
-            await options.controller.errorWith(reason);
-          }
+      const unhandledExceptionController = new RequestController(options.request, {
+        passthrough() {
+        },
+        async respondWith(response) {
+          await handleResponse(response);
+        },
+        async errorWith(reason) {
+          await options.controller.errorWith(reason);
         }
-      );
+      });
       await emitAsync(options.emitter, "unhandledException", {
         error: result.error,
         request: options.request,
         requestId: options.requestId,
         controller: unhandledExceptionController
       });
-      if (unhandledExceptionController.readyState !== RequestController.PENDING) {
-        return;
-      }
+      if (unhandledExceptionController.readyState !== RequestController.PENDING) return;
     }
-    await options.controller.respondWith(
-      createServerErrorResponse(result.error)
-    );
+    await options.controller.respondWith(createServerErrorResponse(result.error));
     return;
   }
-  if (options.controller.readyState === RequestController.PENDING) {
-    return await options.controller.passthrough();
-  }
+  if (options.controller.readyState === RequestController.PENDING) return await options.controller.passthrough();
   return options.controller.handled;
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-WOWPV4GR.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/fetch-DSJoynSF.mjs
 function createNetworkError(cause) {
-  return Object.assign(new TypeError("Failed to fetch"), {
-    cause
-  });
+  return Object.assign(/* @__PURE__ */ new TypeError("Failed to fetch"), { cause });
 }
 var REQUEST_BODY_HEADERS = [
   "content-encoding",
@@ -1975,9 +1929,7 @@ var REQUEST_BODY_HEADERS = [
 ];
 var kRedirectCount = Symbol("kRedirectCount");
 async function followFetchRedirect(request, response) {
-  if (response.status !== 303 && request.body != null) {
-    return Promise.reject(createNetworkError());
-  }
+  if (response.status !== 303 && request.body != null) return Promise.reject(createNetworkError());
   const requestUrl = new URL(request.url);
   let locationUrl;
   try {
@@ -1985,22 +1937,10 @@ async function followFetchRedirect(request, response) {
   } catch (error2) {
     return Promise.reject(createNetworkError(error2));
   }
-  if (!(locationUrl.protocol === "http:" || locationUrl.protocol === "https:")) {
-    return Promise.reject(
-      createNetworkError("URL scheme must be a HTTP(S) scheme")
-    );
-  }
-  if (Reflect.get(request, kRedirectCount) > 20) {
-    return Promise.reject(createNetworkError("redirect count exceeded"));
-  }
-  Object.defineProperty(request, kRedirectCount, {
-    value: (Reflect.get(request, kRedirectCount) || 0) + 1
-  });
-  if (request.mode === "cors" && (locationUrl.username || locationUrl.password) && !sameOrigin(requestUrl, locationUrl)) {
-    return Promise.reject(
-      createNetworkError('cross origin not allowed for request mode "cors"')
-    );
-  }
+  if (!(locationUrl.protocol === "http:" || locationUrl.protocol === "https:")) return Promise.reject(createNetworkError("URL scheme must be a HTTP(S) scheme"));
+  if (Reflect.get(request, kRedirectCount) > 20) return Promise.reject(createNetworkError("redirect count exceeded"));
+  Object.defineProperty(request, kRedirectCount, { value: (Reflect.get(request, kRedirectCount) || 0) + 1 });
+  if (request.mode === "cors" && (locationUrl.username || locationUrl.password) && !sameOrigin(requestUrl, locationUrl)) return Promise.reject(createNetworkError('cross origin not allowed for request mode "cors"'));
   const requestInit = {};
   if ([301, 302].includes(response.status) && request.method === "POST" || response.status === 303 && !["HEAD", "GET"].includes(request.method)) {
     requestInit.method = "GET";
@@ -2024,111 +1964,74 @@ async function followFetchRedirect(request, response) {
   return finalResponse;
 }
 function sameOrigin(left, right) {
-  if (left.origin === right.origin && left.origin === "null") {
-    return true;
-  }
-  if (left.protocol === right.protocol && left.hostname === right.hostname && left.port === right.port) {
-    return true;
-  }
+  if (left.origin === right.origin && left.origin === "null") return true;
+  if (left.protocol === right.protocol && left.hostname === right.hostname && left.port === right.port) return true;
   return false;
 }
 var BrotliDecompressionStream = class extends TransformStream {
   constructor() {
-    console.warn(
-      "[Interceptors]: Brotli decompression of response streams is not supported in the browser"
-    );
-    super({
-      transform(chunk, controller) {
-        controller.enqueue(chunk);
-      }
-    });
+    console.warn("[Interceptors]: Brotli decompression of response streams is not supported in the browser");
+    super({ transform(chunk, controller) {
+      controller.enqueue(chunk);
+    } });
   }
 };
 var PipelineStream = class extends TransformStream {
   constructor(transformStreams, ...strategies) {
     super({}, ...strategies);
-    const readable = [super.readable, ...transformStreams].reduce(
-      (readable2, transform) => readable2.pipeThrough(transform)
-    );
-    Object.defineProperty(this, "readable", {
-      get() {
-        return readable;
-      }
-    });
+    const readable = [super.readable, ...transformStreams].reduce((readable$1, transform) => readable$1.pipeThrough(transform));
+    Object.defineProperty(this, "readable", { get() {
+      return readable;
+    } });
   }
 };
 function parseContentEncoding(contentEncoding) {
   return contentEncoding.toLowerCase().split(",").map((coding) => coding.trim());
 }
 function createDecompressionStream(contentEncoding) {
-  if (contentEncoding === "") {
-    return null;
-  }
+  if (contentEncoding === "") return null;
   const codings = parseContentEncoding(contentEncoding);
-  if (codings.length === 0) {
-    return null;
-  }
-  const transformers = codings.reduceRight(
-    (transformers2, coding) => {
-      if (coding === "gzip" || coding === "x-gzip") {
-        return transformers2.concat(new DecompressionStream("gzip"));
-      } else if (coding === "deflate") {
-        return transformers2.concat(new DecompressionStream("deflate"));
-      } else if (coding === "br") {
-        return transformers2.concat(new BrotliDecompressionStream());
-      } else {
-        transformers2.length = 0;
-      }
-      return transformers2;
-    },
-    []
-  );
-  return new PipelineStream(transformers);
+  if (codings.length === 0) return null;
+  return new PipelineStream(codings.reduceRight((transformers, coding) => {
+    if (coding === "gzip" || coding === "x-gzip") return transformers.concat(new DecompressionStream("gzip"));
+    else if (coding === "deflate") return transformers.concat(new DecompressionStream("deflate"));
+    else if (coding === "br") return transformers.concat(new BrotliDecompressionStream());
+    else transformers.length = 0;
+    return transformers;
+  }, []));
 }
 function decompressResponse(response) {
-  if (response.body === null) {
-    return null;
-  }
-  const decompressionStream = createDecompressionStream(
-    response.headers.get("content-encoding") || ""
-  );
-  if (!decompressionStream) {
-    return null;
-  }
+  if (response.body === null) return null;
+  const decompressionStream = createDecompressionStream(response.headers.get("content-encoding") || "");
+  if (!decompressionStream) return null;
   response.body.pipeTo(decompressionStream.writable);
   return decompressionStream.readable;
 }
-var _FetchInterceptor = class extends Interceptor {
+var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
+  static {
+    this.symbol = Symbol("fetch");
+  }
   constructor() {
-    super(_FetchInterceptor.symbol);
+    super(FetchInterceptor2.symbol);
   }
   checkEnvironment() {
     return hasConfigurableGlobal("fetch");
   }
   async setup() {
     const pureFetch = globalThis.fetch;
-    invariant(
-      !pureFetch[IS_PATCHED_MODULE],
-      'Failed to patch the "fetch" module: already patched.'
-    );
+    invariant(!pureFetch[IS_PATCHED_MODULE], 'Failed to patch the "fetch" module: already patched.');
     globalThis.fetch = async (input, init) => {
       const requestId = createRequestId();
       const resolvedInput = typeof input === "string" && typeof location !== "undefined" && !canParseUrl(input) ? new URL(input, location.href) : input;
       const request = new Request(resolvedInput, init);
-      if (input instanceof Request) {
-        setRawRequest(request, input);
-      }
+      if (input instanceof Request) setRawRequest(request, input);
       const responsePromise = new DeferredPromise();
       const controller = new RequestController(request, {
         passthrough: async () => {
           this.logger.info("request has not been handled, passthrough...");
           const requestCloneForResponseEvent = request.clone();
-          const { error: responseError, data: originalResponse } = await until2(
-            () => pureFetch(request)
-          );
-          if (responseError) {
-            return responsePromise.reject(responseError);
-          }
+          const { error: responseError, data: originalResponse } = await until2(() => pureFetch(request));
+          if (responseError) return responsePromise.reject(responseError);
           this.logger.info("original fetch performed", originalResponse);
           if (this.emitter.listenerCount("response") > 0) {
             this.logger.info('emitting the "response" event...');
@@ -2148,9 +2051,7 @@ var _FetchInterceptor = class extends Interceptor {
             responsePromise.reject(createNetworkError(rawResponse));
             return;
           }
-          this.logger.info("received mocked response!", {
-            rawResponse
-          });
+          this.logger.info("received mocked response!", { rawResponse });
           const decompressedStream = decompressResponse(rawResponse);
           const response = decompressedStream === null ? rawResponse : new FetchResponse(decompressedStream, rawResponse);
           FetchResponse.setUrl(request.url, response);
@@ -2160,23 +2061,17 @@ var _FetchInterceptor = class extends Interceptor {
               return;
             }
             if (request.redirect === "follow") {
-              followFetchRedirect(request, response).then(
-                (response2) => {
-                  responsePromise.resolve(response2);
-                },
-                (reason) => {
-                  responsePromise.reject(reason);
-                }
-              );
+              followFetchRedirect(request, response).then((response$1) => {
+                responsePromise.resolve(response$1);
+              }, (reason) => {
+                responsePromise.reject(reason);
+              });
               return;
             }
           }
           if (this.emitter.listenerCount("response") > 0) {
             this.logger.info('emitting the "response" event...');
             await emitAsync(this.emitter, "response", {
-              // Clone the mocked response for the "response" event listener.
-              // This way, the listener can read the response and not lock its body
-              // for the actual fetch consumer.
               response: response.clone(),
               isMockedResponse: true,
               request,
@@ -2192,10 +2087,7 @@ var _FetchInterceptor = class extends Interceptor {
       });
       this.logger.info("[%s] %s", request.method, request.url);
       this.logger.info("awaiting for the mocked response...");
-      this.logger.info(
-        'emitting the "request" event for %s listener(s)...',
-        this.emitter.listenerCount("request")
-      );
+      this.logger.info('emitting the "request" event for %s listener(s)...', this.emitter.listenerCount("request"));
       await handleRequest2({
         request,
         requestId,
@@ -2210,21 +2102,14 @@ var _FetchInterceptor = class extends Interceptor {
       value: true
     });
     this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
-        value: void 0
-      });
+      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, { value: void 0 });
       globalThis.fetch = pureFetch;
-      this.logger.info(
-        'restored native "globalThis.fetch"!',
-        globalThis.fetch.name
-      );
+      this.logger.info('restored native "globalThis.fetch"!', globalThis.fetch.name);
     });
   }
 };
-var FetchInterceptor = _FetchInterceptor;
-FetchInterceptor.symbol = Symbol("fetch");
 
-// node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-WADP6VHN.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.0/node_modules/@mswjs/interceptors/lib/browser/XMLHttpRequest-DS5fc8Qs.mjs
 function concatArrayBuffer(left, right) {
   const result = new Uint8Array(left.byteLength + right.byteLength);
   result.set(left, 0);
@@ -2252,8 +2137,8 @@ var EventPolyfill = class {
     this.cancelBubble = false;
     this.returnValue = true;
     this.type = type;
-    this.target = (options == null ? void 0 : options.target) || null;
-    this.currentTarget = (options == null ? void 0 : options.currentTarget) || null;
+    this.target = options?.target || null;
+    this.currentTarget = options?.currentTarget || null;
     this.timeStamp = Date.now();
   }
   composedPath() {
@@ -2275,10 +2160,10 @@ var EventPolyfill = class {
 var ProgressEventPolyfill = class extends EventPolyfill {
   constructor(type, init) {
     super(type);
-    this.lengthComputable = (init == null ? void 0 : init.lengthComputable) || false;
-    this.composed = (init == null ? void 0 : init.composed) || false;
-    this.loaded = (init == null ? void 0 : init.loaded) || 0;
-    this.total = (init == null ? void 0 : init.total) || 0;
+    this.lengthComputable = init?.lengthComputable || false;
+    this.composed = init?.composed || false;
+    this.loaded = init?.loaded || 0;
+    this.total = init?.total || 0;
   }
 };
 var SUPPORTS_PROGRESS_EVENT = typeof ProgressEvent !== "undefined";
@@ -2293,48 +2178,36 @@ function createEvent(target, type, init) {
     "abort"
   ];
   const ProgressEventClass = SUPPORTS_PROGRESS_EVENT ? ProgressEvent : ProgressEventPolyfill;
-  const event = progressEvents.includes(type) ? new ProgressEventClass(type, {
+  return progressEvents.includes(type) ? new ProgressEventClass(type, {
     lengthComputable: true,
-    loaded: (init == null ? void 0 : init.loaded) || 0,
-    total: (init == null ? void 0 : init.total) || 0
+    loaded: init?.loaded || 0,
+    total: init?.total || 0
   }) : new EventPolyfill(type, {
     target,
     currentTarget: target
   });
-  return event;
 }
 function findPropertySource(target, propertyName) {
-  if (!(propertyName in target)) {
-    return null;
-  }
-  const hasProperty = Object.prototype.hasOwnProperty.call(target, propertyName);
-  if (hasProperty) {
-    return target;
-  }
+  if (!(propertyName in target)) return null;
+  if (Object.prototype.hasOwnProperty.call(target, propertyName)) return target;
   const prototype = Reflect.getPrototypeOf(target);
   return prototype ? findPropertySource(prototype, propertyName) : null;
 }
 function createProxy(target, options) {
-  const proxy = new Proxy(target, optionsToProxyHandler(options));
-  return proxy;
+  return new Proxy(target, optionsToProxyHandler(options));
 }
 function optionsToProxyHandler(options) {
   const { constructorCall, methodCall, getProperty, setProperty } = options;
   const handler = {};
-  if (typeof constructorCall !== "undefined") {
-    handler.construct = function(target, args, newTarget) {
-      const next = Reflect.construct.bind(null, target, args, newTarget);
-      return constructorCall.call(newTarget, args, next);
-    };
-  }
+  if (typeof constructorCall !== "undefined") handler.construct = function(target, args, newTarget) {
+    const next = Reflect.construct.bind(null, target, args, newTarget);
+    return constructorCall.call(newTarget, args, next);
+  };
   handler.set = function(target, propertyName, nextValue) {
     const next = () => {
       const propertySource = findPropertySource(target, propertyName) || target;
-      const ownDescriptors = Reflect.getOwnPropertyDescriptor(
-        propertySource,
-        propertyName
-      );
-      if (typeof (ownDescriptors == null ? void 0 : ownDescriptors.set) !== "undefined") {
+      const ownDescriptors = Reflect.getOwnPropertyDescriptor(propertySource, propertyName);
+      if (typeof ownDescriptors?.set !== "undefined") {
         ownDescriptors.set.apply(target, [nextValue]);
         return true;
       }
@@ -2345,65 +2218,52 @@ function optionsToProxyHandler(options) {
         value: nextValue
       });
     };
-    if (typeof setProperty !== "undefined") {
-      return setProperty.call(target, [propertyName, nextValue], next);
-    }
+    if (typeof setProperty !== "undefined") return setProperty.call(target, [propertyName, nextValue], next);
     return next();
   };
   handler.get = function(target, propertyName, receiver) {
     const next = () => target[propertyName];
     const value = typeof getProperty !== "undefined" ? getProperty.call(target, [propertyName, receiver], next) : next();
-    if (typeof value === "function") {
-      return (...args) => {
-        const next2 = value.bind(target, ...args);
-        if (typeof methodCall !== "undefined") {
-          return methodCall.call(target, [propertyName, args], next2);
-        }
-        return next2();
-      };
-    }
+    if (typeof value === "function") return (...args) => {
+      const next$1 = value.bind(target, ...args);
+      if (typeof methodCall !== "undefined") return methodCall.call(target, [propertyName, args], next$1);
+      return next$1();
+    };
     return value;
   };
   return handler;
 }
 function isDomParserSupportedType(type) {
-  const supportedTypes = [
+  return [
     "application/xhtml+xml",
     "application/xml",
     "image/svg+xml",
     "text/html",
     "text/xml"
-  ];
-  return supportedTypes.some((supportedType) => {
+  ].some((supportedType) => {
     return type.startsWith(supportedType);
   });
 }
 function parseJson(data) {
   try {
-    const json = JSON.parse(data);
-    return json;
+    return JSON.parse(data);
   } catch (_) {
     return null;
   }
 }
 function createResponse(request, body) {
-  const responseBodyOrNull = FetchResponse.isResponseWithBody(request.status) ? body : null;
-  return new FetchResponse(responseBodyOrNull, {
+  return new FetchResponse(FetchResponse.isResponseWithBody(request.status) ? body : null, {
     url: request.responseURL,
     status: request.status,
     statusText: request.statusText,
-    headers: createHeadersFromXMLHttpRequestHeaders(
-      request.getAllResponseHeaders()
-    )
+    headers: createHeadersFromXMLHttpRequestHeaders(request.getAllResponseHeaders())
   });
 }
 function createHeadersFromXMLHttpRequestHeaders(headersString) {
   const headers = new Headers();
   const lines = headersString.split(/[\r\n]+/);
   for (const line of lines) {
-    if (line.trim() === "") {
-      continue;
-    }
+    if (line.trim() === "") continue;
     const [name, ...parts] = line.split(": ");
     const value = parts.join(": ");
     headers.append(name, value);
@@ -2412,11 +2272,8 @@ function createHeadersFromXMLHttpRequestHeaders(headersString) {
 }
 async function getBodyByteLength(input) {
   const explicitContentLength = input.headers.get("content-length");
-  if (explicitContentLength != null && explicitContentLength !== "") {
-    return Number(explicitContentLength);
-  }
-  const buffer = await input.arrayBuffer();
-  return buffer.byteLength;
+  if (explicitContentLength != null && explicitContentLength !== "") return Number(explicitContentLength);
+  return (await input.arrayBuffer()).byteLength;
 }
 var kIsRequestHandled = Symbol("kIsRequestHandled");
 var IS_NODE2 = isNodeProcess();
@@ -2437,15 +2294,12 @@ var XMLHttpRequestController = class {
       setProperty: ([propertyName, nextValue], invoke) => {
         switch (propertyName) {
           case "ontimeout": {
-            const eventName = propertyName.slice(
-              2
-            );
+            const eventName = propertyName.slice(2);
             this.request.addEventListener(eventName, nextValue);
             return invoke();
           }
-          default: {
+          default:
             return invoke();
-          }
         }
       },
       methodCall: ([methodName, args], invoke) => {
@@ -2482,10 +2336,10 @@ var XMLHttpRequestController = class {
                 const fetchResponse = createResponse(
                   this.request,
                   /**
-                   * The `response` property is the right way to read
-                   * the ambiguous response body, as the request's "responseType" may differ.
-                   * @see https://xhr.spec.whatwg.org/#the-response-attribute
-                   */
+                  * The `response` property is the right way to read
+                  * the ambiguous response body, as the request's "responseType" may differ.
+                  * @see https://xhr.spec.whatwg.org/#the-response-attribute
+                  */
                   this.request.response
                 );
                 this.onResponse.call(this, {
@@ -2500,91 +2354,70 @@ var XMLHttpRequestController = class {
             const fetchRequest = this.toFetchApiRequest(requestBody);
             this[kFetchRequest] = fetchRequest.clone();
             queueMicrotask(() => {
-              var _a;
-              const onceRequestSettled = ((_a = this.onRequest) == null ? void 0 : _a.call(this, {
+              (this.onRequest?.call(this, {
                 request: fetchRequest,
                 requestId: this.requestId
-              })) || Promise.resolve();
-              onceRequestSettled.finally(() => {
+              }) || Promise.resolve()).finally(() => {
                 if (!this[kIsRequestHandled]) {
-                  this.logger.info(
-                    "request callback settled but request has not been handled (readystate %d), performing as-is...",
-                    this.request.readyState
-                  );
-                  if (IS_NODE2) {
-                    this.request.setRequestHeader(
-                      INTERNAL_REQUEST_ID_HEADER_NAME,
-                      this.requestId
-                    );
-                  }
+                  this.logger.info("request callback settled but request has not been handled (readystate %d), performing as-is...", this.request.readyState);
+                  if (IS_NODE2) this.request.setRequestHeader(INTERNAL_REQUEST_ID_HEADER_NAME, this.requestId);
                   return invoke();
                 }
               });
             });
             break;
           }
-          default: {
+          default:
             return invoke();
-          }
         }
       }
     });
-    define(
-      this.request,
-      "upload",
-      createProxy(this.request.upload, {
-        setProperty: ([propertyName, nextValue], invoke) => {
-          switch (propertyName) {
-            case "onloadstart":
-            case "onprogress":
-            case "onaboart":
-            case "onerror":
-            case "onload":
-            case "ontimeout":
-            case "onloadend": {
-              const eventName = propertyName.slice(
-                2
-              );
-              this.registerUploadEvent(eventName, nextValue);
-            }
+    define(this.request, "upload", createProxy(this.request.upload, {
+      setProperty: ([propertyName, nextValue], invoke) => {
+        switch (propertyName) {
+          case "onloadstart":
+          case "onprogress":
+          case "onaboart":
+          case "onerror":
+          case "onload":
+          case "ontimeout":
+          case "onloadend": {
+            const eventName = propertyName.slice(2);
+            this.registerUploadEvent(eventName, nextValue);
           }
-          return invoke();
-        },
-        methodCall: ([methodName, args], invoke) => {
-          switch (methodName) {
-            case "addEventListener": {
-              const [eventName, listener] = args;
-              this.registerUploadEvent(eventName, listener);
-              this.logger.info("upload.addEventListener", eventName, listener);
-              return invoke();
-            }
+        }
+        return invoke();
+      },
+      methodCall: ([methodName, args], invoke) => {
+        switch (methodName) {
+          case "addEventListener": {
+            const [eventName, listener] = args;
+            this.registerUploadEvent(eventName, listener);
+            this.logger.info("upload.addEventListener", eventName, listener);
+            return invoke();
           }
         }
-      })
-    );
+      }
+    }));
   }
   registerEvent(eventName, listener) {
-    const prevEvents = this.events.get(eventName) || [];
-    const nextEvents = prevEvents.concat(listener);
+    const nextEvents = (this.events.get(eventName) || []).concat(listener);
     this.events.set(eventName, nextEvents);
     this.logger.info('registered event "%s"', eventName, listener);
   }
   registerUploadEvent(eventName, listener) {
-    const prevEvents = this.uploadEvents.get(eventName) || [];
-    const nextEvents = prevEvents.concat(listener);
+    const nextEvents = (this.uploadEvents.get(eventName) || []).concat(listener);
     this.uploadEvents.set(eventName, nextEvents);
     this.logger.info('registered upload event "%s"', eventName, listener);
   }
   /**
-   * Responds to the current request with the given
-   * Fetch API `Response` instance.
-   */
+  * Responds to the current request with the given
+  * Fetch API `Response` instance.
+  */
   async respondWith(response) {
     this[kIsRequestHandled] = true;
     if (this[kFetchRequest]) {
-      const totalRequestBodyLength = await getBodyByteLength(
-        this[kFetchRequest]
-      );
+      const totalRequestBodyLength = await getBodyByteLength(this[kFetchRequest]);
       this.trigger("loadstart", this.request.upload, {
         loaded: 0,
         total: totalRequestBodyLength
@@ -2602,48 +2435,32 @@ var XMLHttpRequestController = class {
         total: totalRequestBodyLength
       });
     }
-    this.logger.info(
-      "responding with a mocked response: %d %s",
-      response.status,
-      response.statusText
-    );
+    this.logger.info("responding with a mocked response: %d %s", response.status, response.statusText);
     define(this.request, "status", response.status);
     define(this.request, "statusText", response.statusText);
     define(this.request, "responseURL", this.url.href);
-    this.request.getResponseHeader = new Proxy(this.request.getResponseHeader, {
-      apply: (_, __, args) => {
-        this.logger.info("getResponseHeader", args[0]);
-        if (this.request.readyState < this.request.HEADERS_RECEIVED) {
-          this.logger.info("headers not received yet, returning null");
-          return null;
-        }
-        const headerValue = response.headers.get(args[0]);
-        this.logger.info(
-          'resolved response header "%s" to',
-          args[0],
-          headerValue
-        );
-        return headerValue;
+    this.request.getResponseHeader = new Proxy(this.request.getResponseHeader, { apply: (_, __, args) => {
+      this.logger.info("getResponseHeader", args[0]);
+      if (this.request.readyState < this.request.HEADERS_RECEIVED) {
+        this.logger.info("headers not received yet, returning null");
+        return null;
       }
-    });
-    this.request.getAllResponseHeaders = new Proxy(
-      this.request.getAllResponseHeaders,
-      {
-        apply: () => {
-          this.logger.info("getAllResponseHeaders");
-          if (this.request.readyState < this.request.HEADERS_RECEIVED) {
-            this.logger.info("headers not received yet, returning empty string");
-            return "";
-          }
-          const headersList = Array.from(response.headers.entries());
-          const allHeaders = headersList.map(([headerName, headerValue]) => {
-            return `${headerName}: ${headerValue}`;
-          }).join("\r\n");
-          this.logger.info("resolved all response headers to", allHeaders);
-          return allHeaders;
-        }
+      const headerValue = response.headers.get(args[0]);
+      this.logger.info('resolved response header "%s" to', args[0], headerValue);
+      return headerValue;
+    } });
+    this.request.getAllResponseHeaders = new Proxy(this.request.getAllResponseHeaders, { apply: () => {
+      this.logger.info("getAllResponseHeaders");
+      if (this.request.readyState < this.request.HEADERS_RECEIVED) {
+        this.logger.info("headers not received yet, returning empty string");
+        return "";
       }
-    );
+      const allHeaders = Array.from(response.headers.entries()).map(([headerName, headerValue]) => {
+        return `${headerName}: ${headerValue}`;
+      }).join("\r\n");
+      this.logger.info("resolved all response headers to", allHeaders);
+      return allHeaders;
+    } });
     Object.defineProperties(this.request, {
       response: {
         enumerable: true,
@@ -2702,21 +2519,14 @@ var XMLHttpRequestController = class {
         readNextResponseBodyChunk();
       };
       readNextResponseBodyChunk();
-    } else {
-      finalizeResponse();
-    }
+    } else finalizeResponse();
   }
   responseBufferToText() {
     return decodeBuffer(this.responseBuffer);
   }
   get response() {
-    this.logger.info(
-      "getResponse (responseType: %s)",
-      this.request.responseType
-    );
-    if (this.request.readyState !== this.request.DONE) {
-      return null;
-    }
+    this.logger.info("getResponse (responseType: %s)", this.request.responseType);
+    if (this.request.readyState !== this.request.DONE) return null;
     switch (this.request.responseType) {
       case "json": {
         const responseJson = parseJson(this.responseBufferToText());
@@ -2730,60 +2540,33 @@ var XMLHttpRequestController = class {
       }
       case "blob": {
         const mimeType = this.request.getResponseHeader("Content-Type") || "text/plain";
-        const responseBlob = new Blob([this.responseBufferToText()], {
-          type: mimeType
-        });
-        this.logger.info(
-          "resolved response Blob (mime type: %s)",
-          responseBlob,
-          mimeType
-        );
+        const responseBlob = new Blob([this.responseBufferToText()], { type: mimeType });
+        this.logger.info("resolved response Blob (mime type: %s)", responseBlob, mimeType);
         return responseBlob;
       }
       default: {
         const responseText = this.responseBufferToText();
-        this.logger.info(
-          'resolving "%s" response type as text',
-          this.request.responseType,
-          responseText
-        );
+        this.logger.info('resolving "%s" response type as text', this.request.responseType, responseText);
         return responseText;
       }
     }
   }
   get responseText() {
-    invariant(
-      this.request.responseType === "" || this.request.responseType === "text",
-      "InvalidStateError: The object is in invalid state."
-    );
-    if (this.request.readyState !== this.request.LOADING && this.request.readyState !== this.request.DONE) {
-      return "";
-    }
+    invariant(this.request.responseType === "" || this.request.responseType === "text", "InvalidStateError: The object is in invalid state.");
+    if (this.request.readyState !== this.request.LOADING && this.request.readyState !== this.request.DONE) return "";
     const responseText = this.responseBufferToText();
     this.logger.info('getResponseText: "%s"', responseText);
     return responseText;
   }
   get responseXML() {
-    invariant(
-      this.request.responseType === "" || this.request.responseType === "document",
-      "InvalidStateError: The object is in invalid state."
-    );
-    if (this.request.readyState !== this.request.DONE) {
-      return null;
-    }
+    invariant(this.request.responseType === "" || this.request.responseType === "document", "InvalidStateError: The object is in invalid state.");
+    if (this.request.readyState !== this.request.DONE) return null;
     const contentType = this.request.getResponseHeader("Content-Type") || "";
     if (typeof DOMParser === "undefined") {
-      console.warn(
-        "Cannot retrieve XMLHttpRequest response body as XML: DOMParser is not defined. You are likely using an environment that is not browser or does not polyfill browser globals correctly."
-      );
+      console.warn("Cannot retrieve XMLHttpRequest response body as XML: DOMParser is not defined. You are likely using an environment that is not browser or does not polyfill browser globals correctly.");
       return null;
     }
-    if (isDomParserSupportedType(contentType)) {
-      return new DOMParser().parseFromString(
-        this.responseBufferToText(),
-        contentType
-      );
-    }
+    if (isDomParserSupportedType(contentType)) return new DOMParser().parseFromString(this.responseBufferToText(), contentType);
     return null;
   }
   errorWith(error2) {
@@ -2794,14 +2577,10 @@ var XMLHttpRequestController = class {
     this.trigger("loadend", this.request);
   }
   /**
-   * Transitions this request's `readyState` to the given one.
-   */
+  * Transitions this request's `readyState` to the given one.
+  */
   setReadyState(nextReadyState) {
-    this.logger.info(
-      "setReadyState: %d -> %d",
-      this.request.readyState,
-      nextReadyState
-    );
+    this.logger.info("setReadyState: %d -> %d", this.request.readyState, nextReadyState);
     if (this.request.readyState === nextReadyState) {
       this.logger.info("ready state identical, skipping transition...");
       return;
@@ -2814,8 +2593,8 @@ var XMLHttpRequestController = class {
     }
   }
   /**
-   * Triggers given event on the `XMLHttpRequest` instance.
-   */
+  * Triggers given event on the `XMLHttpRequest` instance.
+  */
   trigger(eventName, target, options) {
     const callback = target[`on${eventName}`];
     const event = createEvent(target, eventName, options);
@@ -2825,156 +2604,106 @@ var XMLHttpRequestController = class {
       callback.call(target, event);
     }
     const events = target instanceof XMLHttpRequestUpload ? this.uploadEvents : this.events;
-    for (const [registeredEventName, listeners] of events) {
-      if (registeredEventName === eventName) {
-        this.logger.info(
-          'found %d listener(s) for "%s" event, calling...',
-          listeners.length,
-          eventName
-        );
-        listeners.forEach((listener) => listener.call(target, event));
-      }
+    for (const [registeredEventName, listeners] of events) if (registeredEventName === eventName) {
+      this.logger.info('found %d listener(s) for "%s" event, calling...', listeners.length, eventName);
+      listeners.forEach((listener) => listener.call(target, event));
     }
   }
   /**
-   * Converts this `XMLHttpRequest` instance into a Fetch API `Request` instance.
-   */
+  * Converts this `XMLHttpRequest` instance into a Fetch API `Request` instance.
+  */
   toFetchApiRequest(body) {
     this.logger.info("converting request to a Fetch API Request...");
     const resolvedBody = body instanceof Document ? body.documentElement.innerText : body;
     const fetchRequest = new Request(this.url.href, {
       method: this.method,
       headers: this.requestHeaders,
-      /**
-       * @see https://xhr.spec.whatwg.org/#cross-origin-credentials
-       */
       credentials: this.request.withCredentials ? "include" : "same-origin",
       body: ["GET", "HEAD"].includes(this.method.toUpperCase()) ? null : resolvedBody
     });
-    const proxyHeaders = createProxy(fetchRequest.headers, {
-      methodCall: ([methodName, args], invoke) => {
-        switch (methodName) {
-          case "append":
-          case "set": {
-            const [headerName, headerValue] = args;
-            this.request.setRequestHeader(headerName, headerValue);
-            break;
-          }
-          case "delete": {
-            const [headerName] = args;
-            console.warn(
-              `XMLHttpRequest: Cannot remove a "${headerName}" header from the Fetch API representation of the "${fetchRequest.method} ${fetchRequest.url}" request. XMLHttpRequest headers cannot be removed.`
-            );
-            break;
-          }
+    define(fetchRequest, "headers", createProxy(fetchRequest.headers, { methodCall: ([methodName, args], invoke) => {
+      switch (methodName) {
+        case "append":
+        case "set": {
+          const [headerName, headerValue] = args;
+          this.request.setRequestHeader(headerName, headerValue);
+          break;
+        }
+        case "delete": {
+          const [headerName] = args;
+          console.warn(`XMLHttpRequest: Cannot remove a "${headerName}" header from the Fetch API representation of the "${fetchRequest.method} ${fetchRequest.url}" request. XMLHttpRequest headers cannot be removed.`);
+          break;
         }
-        return invoke();
       }
-    });
-    define(fetchRequest, "headers", proxyHeaders);
+      return invoke();
+    } }));
     setRawRequest(fetchRequest, this.request);
     this.logger.info("converted request to a Fetch API Request!", fetchRequest);
     return fetchRequest;
   }
 };
 function toAbsoluteUrl(url) {
-  if (typeof location === "undefined") {
-    return new URL(url);
-  }
+  if (typeof location === "undefined") return new URL(url);
   return new URL(url.toString(), location.href);
 }
 function define(target, property, value) {
   Reflect.defineProperty(target, property, {
-    // Ensure writable properties to allow redefining readonly properties.
     writable: true,
     enumerable: true,
     value
   });
 }
-function createXMLHttpRequestProxy({
-  emitter,
-  logger
-}) {
-  const XMLHttpRequestProxy = new Proxy(globalThis.XMLHttpRequest, {
-    construct(target, args, newTarget) {
-      logger.info("constructed new XMLHttpRequest");
-      const originalRequest = Reflect.construct(
-        target,
-        args,
-        newTarget
-      );
-      const prototypeDescriptors = Object.getOwnPropertyDescriptors(
-        target.prototype
-      );
-      for (const propertyName in prototypeDescriptors) {
-        Reflect.defineProperty(
-          originalRequest,
-          propertyName,
-          prototypeDescriptors[propertyName]
-        );
-      }
-      const xhrRequestController = new XMLHttpRequestController(
-        originalRequest,
-        logger
-      );
-      xhrRequestController.onRequest = async function({ request, requestId }) {
-        const controller = new RequestController(request, {
-          passthrough: () => {
-            this.logger.info(
-              "no mocked response received, performing request as-is..."
-            );
-          },
-          respondWith: async (response) => {
-            if (isResponseError(response)) {
-              this.errorWith(new TypeError("Network error"));
-              return;
-            }
-            await this.respondWith(response);
-          },
-          errorWith: (reason) => {
-            this.logger.info("request errored!", { error: reason });
-            if (reason instanceof Error) {
-              this.errorWith(reason);
-            }
+function createXMLHttpRequestProxy({ emitter, logger }) {
+  return new Proxy(globalThis.XMLHttpRequest, { construct(target, args, newTarget) {
+    logger.info("constructed new XMLHttpRequest");
+    const originalRequest = Reflect.construct(target, args, newTarget);
+    const prototypeDescriptors = Object.getOwnPropertyDescriptors(target.prototype);
+    for (const propertyName in prototypeDescriptors) Reflect.defineProperty(originalRequest, propertyName, prototypeDescriptors[propertyName]);
+    const xhrRequestController = new XMLHttpRequestController(originalRequest, logger);
+    xhrRequestController.onRequest = async function({ request, requestId }) {
+      const controller = new RequestController(request, {
+        passthrough: () => {
+          this.logger.info("no mocked response received, performing request as-is...");
+        },
+        respondWith: async (response) => {
+          if (isResponseError(response)) {
+            this.errorWith(/* @__PURE__ */ new TypeError("Network error"));
+            return;
           }
-        });
-        this.logger.info("awaiting mocked response...");
-        this.logger.info(
-          'emitting the "request" event for %s listener(s)...',
-          emitter.listenerCount("request")
-        );
-        await handleRequest2({
-          request,
-          requestId,
-          controller,
-          emitter
-        });
-      };
-      xhrRequestController.onResponse = async function({
+          await this.respondWith(response);
+        },
+        errorWith: (reason) => {
+          this.logger.info("request errored!", { error: reason });
+          if (reason instanceof Error) this.errorWith(reason);
+        }
+      });
+      this.logger.info("awaiting mocked response...");
+      this.logger.info('emitting the "request" event for %s listener(s)...', emitter.listenerCount("request"));
+      await handleRequest2({
+        request,
+        requestId,
+        controller,
+        emitter
+      });
+    };
+    xhrRequestController.onResponse = async function({ response, isMockedResponse, request, requestId }) {
+      this.logger.info('emitting the "response" event for %s listener(s)...', emitter.listenerCount("response"));
+      emitter.emit("response", {
         response,
         isMockedResponse,
         request,
         requestId
-      }) {
-        this.logger.info(
-          'emitting the "response" event for %s listener(s)...',
-          emitter.listenerCount("response")
-        );
-        emitter.emit("response", {
-          response,
-          isMockedResponse,
-          request,
-          requestId
-        });
-      };
-      return xhrRequestController.request;
-    }
-  });
-  return XMLHttpRequestProxy;
+      });
+    };
+    return xhrRequestController.request;
+  } });
 }
-var _XMLHttpRequestInterceptor = class extends Interceptor {
+var XMLHttpRequestInterceptor = class XMLHttpRequestInterceptor2 extends Interceptor {
+  static {
+    this.interceptorSymbol = Symbol("xhr");
+  }
   constructor() {
-    super(_XMLHttpRequestInterceptor.interceptorSymbol);
+    super(XMLHttpRequestInterceptor2.interceptorSymbol);
   }
   checkEnvironment() {
     return hasConfigurableGlobal("XMLHttpRequest");
@@ -2983,37 +2712,24 @@ var _XMLHttpRequestInterceptor = class extends Interceptor {
     const logger = this.logger.extend("setup");
     logger.info('patching "XMLHttpRequest" module...');
     const PureXMLHttpRequest = globalThis.XMLHttpRequest;
-    invariant(
-      !PureXMLHttpRequest[IS_PATCHED_MODULE],
-      'Failed to patch the "XMLHttpRequest" module: already patched.'
-    );
+    invariant(!PureXMLHttpRequest[IS_PATCHED_MODULE], 'Failed to patch the "XMLHttpRequest" module: already patched.');
     globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
       emitter: this.emitter,
       logger: this.logger
     });
-    logger.info(
-      'native "XMLHttpRequest" module patched!',
-      globalThis.XMLHttpRequest.name
-    );
+    logger.info('native "XMLHttpRequest" module patched!', globalThis.XMLHttpRequest.name);
     Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
       enumerable: true,
       configurable: true,
       value: true
     });
     this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
-        value: void 0
-      });
+      Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, { value: void 0 });
       globalThis.XMLHttpRequest = PureXMLHttpRequest;
-      logger.info(
-        'native "XMLHttpRequest" module restored!',
-        globalThis.XMLHttpRequest.name
-      );
+      logger.info('native "XMLHttpRequest" module restored!', globalThis.XMLHttpRequest.name);
     });
   }
 };
-var XMLHttpRequestInterceptor = _XMLHttpRequestInterceptor;
-XMLHttpRequestInterceptor.interceptorSymbol = Symbol("xhr");
 
 // src/browser/setupWorker/start/createFallbackRequestListener.ts
 var import_handleRequest2 = require("../core/utils/handleRequest");