msw 2.4.3 → 2.4.5

package/lib/iife/index.js

@@ -77,7 +77,7 @@ var MockServiceWorker = (() => {
   });
 
   // node_modules/.pnpm/graphql@16.9.0/node_modules/graphql/jsutils/invariant.mjs
-  function invariant2(condition, message3) {
+  function invariant3(condition, message3) {
     const booleanCondition = Boolean(condition);
     if (!booleanCondition) {
       throw new Error(
@@ -96,7 +96,7 @@ var MockServiceWorker = (() => {
     let lastLineStart = 0;
     let line = 1;
     for (const match2 of source.body.matchAll(LineRegExp)) {
-      typeof match2.index === "number" || invariant2(false);
+      typeof match2.index === "number" || invariant3(false);
       if (match2.index >= position) {
         break;
       }
@@ -4968,7 +4968,7 @@ spurious results.`);
       }
       throw new TypeError(`Cannot convert value to AST: ${inspect(serialized)}.`);
     }
-    invariant2(false, "Unexpected input type: " + inspect(type));
+    invariant3(false, "Unexpected input type: " + inspect(type));
   }
   var integerStringRegExp;
   var init_astFromValue = __esm({
@@ -5190,7 +5190,7 @@ spurious results.`);
               if (isNonNullType(type)) {
                 return TypeKind.NON_NULL;
               }
-              invariant2(false, `Unexpected type: "${inspect(type)}".`);
+              invariant3(false, `Unexpected type: "${inspect(type)}".`);
             }
           },
           name: {
@@ -6760,7 +6760,7 @@ spurious results.`);
   }
   function getDirectiveLocationForASTPath(ancestors) {
     const appliedTo = ancestors[ancestors.length - 1];
-    "kind" in appliedTo || invariant2(false);
+    "kind" in appliedTo || invariant3(false);
     switch (appliedTo.kind) {
       case Kind.OPERATION_DEFINITION:
         return getDirectiveLocationForOperation(appliedTo.operation);
@@ -6801,11 +6801,11 @@ spurious results.`);
         return DirectiveLocation.INPUT_OBJECT;
       case Kind.INPUT_VALUE_DEFINITION: {
         const parentNode = ancestors[ancestors.length - 3];
-        "kind" in parentNode || invariant2(false);
+        "kind" in parentNode || invariant3(false);
         return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ? DirectiveLocation.INPUT_FIELD_DEFINITION : DirectiveLocation.ARGUMENT_DEFINITION;
       }
       default:
-        invariant2(false, "Unexpected kind: " + inspect(appliedTo.kind));
+        invariant3(false, "Unexpected kind: " + inspect(appliedTo.kind));
     }
   }
   function getDirectiveLocationForOperation(operation) {
@@ -7875,7 +7875,7 @@ spurious results.`);
     if (isInputObjectType(type)) {
       return Kind.INPUT_OBJECT_TYPE_EXTENSION;
     }
-    invariant2(false, "Unexpected type: " + inspect(type));
+    invariant3(false, "Unexpected type: " + inspect(type));
   }
   function extensionKindToTypeName(kind) {
     switch (kind) {
@@ -7892,7 +7892,7 @@ spurious results.`);
       case Kind.INPUT_OBJECT_TYPE_EXTENSION:
         return "input object";
       default:
-        invariant2(false, "Unexpected kind: " + inspect(kind));
+        invariant3(false, "Unexpected kind: " + inspect(kind));
     }
   }
   var defKindToExtKind;
@@ -8238,7 +8238,7 @@ spurious results.`);
       }
       return parseResult;
     }
-    invariant2(false, "Unexpected input type: " + inspect(type));
+    invariant3(false, "Unexpected input type: " + inspect(type));
   }
   var init_coerceInputValue = __esm({
     "node_modules/.pnpm/graphql@16.9.0/node_modules/graphql/utilities/coerceInputValue.mjs"() {
@@ -8352,7 +8352,7 @@ spurious results.`);
       }
       return result;
     }
-    invariant2(false, "Unexpected input type: " + inspect(type));
+    invariant3(false, "Unexpected input type: " + inspect(type));
   }
   function isMissingVariable(valueNode, variables) {
     return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === void 0);
@@ -9114,7 +9114,7 @@ spurious results.`);
         },
         leave() {
           const prevKnownNames = knownNameStack.pop();
-          prevKnownNames || invariant2(false);
+          prevKnownNames || invariant3(false);
           knownNames = prevKnownNames;
         }
       },
@@ -10383,7 +10383,7 @@ spurious results.`);
         result
       );
     }
-    invariant2(
+    invariant3(
       false,
       "Cannot complete value of unexpected output type: " + inspect(returnType)
     );
@@ -10950,7 +10950,7 @@ spurious results.`);
         const deprecationReason = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.deprecationReason;
         if (fieldDef && deprecationReason != null) {
           const parentType = context.getParentType();
-          parentType != null || invariant2(false);
+          parentType != null || invariant3(false);
           context.reportError(
             new GraphQLError(
               `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,
@@ -10978,7 +10978,7 @@ spurious results.`);
           } else {
             const parentType = context.getParentType();
             const fieldDef = context.getFieldDef();
-            parentType != null && fieldDef != null || invariant2(false);
+            parentType != null && fieldDef != null || invariant3(false);
             context.reportError(
               new GraphQLError(
                 `Field "${parentType.name}.${fieldDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
@@ -11012,7 +11012,7 @@ spurious results.`);
         const deprecationReason = enumValueDef === null || enumValueDef === void 0 ? void 0 : enumValueDef.deprecationReason;
         if (enumValueDef && deprecationReason != null) {
           const enumTypeDef = getNamedType(context.getInputType());
-          enumTypeDef != null || invariant2(false);
+          enumTypeDef != null || invariant3(false);
           context.reportError(
             new GraphQLError(
               `The enum value "${enumTypeDef.name}.${enumValueDef.name}" is deprecated. ${deprecationReason}`,
@@ -11337,7 +11337,7 @@ spurious results.`);
       schema,
       document: document2
     });
-    !result.errors && result.data || invariant2(false);
+    !result.errors && result.data || invariant3(false);
     return result.data;
   }
   var init_introspectionFromSchema = __esm({
@@ -11726,7 +11726,7 @@ spurious results.`);
       if (isInputObjectType(type)) {
         return extendInputObjectType(type);
       }
-      invariant2(false, "Unexpected type: " + inspect(type));
+      invariant3(false, "Unexpected type: " + inspect(type));
     }
     function extendInputObjectType(type) {
       var _typeExtensionsMap$co;
@@ -12253,7 +12253,7 @@ spurious results.`);
           fields: () => sortInputFields(config.fields)
         });
       }
-      invariant2(false, "Unexpected type: " + inspect(type));
+      invariant3(false, "Unexpected type: " + inspect(type));
     }
   }
   function sortObjMap(map, sortValueFn) {
@@ -12365,7 +12365,7 @@ ${operationTypes.join("\n")}
     if (isInputObjectType(type)) {
       return printInputObject(type);
     }
-    invariant2(false, "Unexpected type: " + inspect(type));
+    invariant3(false, "Unexpected type: " + inspect(type));
   }
   function printScalar(type) {
     return printDescription(type) + `scalar ${type.name}` + printSpecifiedByURL(type);
@@ -12952,11 +12952,11 @@ ${operationTypes.join("\n")}
     if (isInputObjectType(type)) {
       return "an Input type";
     }
-    invariant2(false, "Unexpected type: " + inspect(type));
+    invariant3(false, "Unexpected type: " + inspect(type));
   }
   function stringifyValue2(value, type) {
     const ast = astFromValue(value, type);
-    ast != null || invariant2(false);
+    ast != null || invariant3(false);
     return print(sortValueNode(ast));
   }
   function diff(oldArray, newArray) {
@@ -14388,7 +14388,7 @@ ${operationTypes.join("\n")}
     return stringToRegexp(path, keys, options);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
   var encoder = new TextEncoder();
   function encodeBuffer(text) {
     return encoder.encode(text);
@@ -14404,7 +14404,7 @@ ${operationTypes.join("\n")}
     );
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/chunk-OMISYKWR.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/chunk-XVPRNJO7.mjs
   var IS_PATCHED_MODULE = Symbol("isPatchedModule");
   function isPropertyAccessible(obj, key) {
     try {
@@ -14421,6 +14421,13 @@ ${operationTypes.join("\n")}
     205,
     304
   ]);
+  var RESPONSE_STATUS_CODES_WITH_REDIRECT = /* @__PURE__ */ new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+  ]);
   function isResponseWithoutBody(status) {
     return RESPONSE_STATUS_CODES_WITHOUT_BODY.has(status);
   }
@@ -14461,6 +14468,90 @@ ${operationTypes.join("\n")}
     return false;
   }
 
+  // node_modules/.pnpm/outvariant@1.4.3/node_modules/outvariant/lib/index.mjs
+  var POSITIONALS_EXP2 = /(%?)(%([sdijo]))/g;
+  function serializePositional2(positional, flag) {
+    switch (flag) {
+      case "s":
+        return positional;
+      case "d":
+      case "i":
+        return Number(positional);
+      case "j":
+        return JSON.stringify(positional);
+      case "o": {
+        if (typeof positional === "string") {
+          return positional;
+        }
+        const json = JSON.stringify(positional);
+        if (json === "{}" || json === "[]" || /^\[object .+?\]$/.test(json)) {
+          return positional;
+        }
+        return json;
+      }
+    }
+  }
+  function format2(message3, ...positionals) {
+    if (positionals.length === 0) {
+      return message3;
+    }
+    let positionalIndex = 0;
+    let formattedMessage = message3.replace(
+      POSITIONALS_EXP2,
+      (match2, isEscaped, _, flag) => {
+        const positional = positionals[positionalIndex];
+        const value = serializePositional2(positional, flag);
+        if (!isEscaped) {
+          positionalIndex++;
+          return value;
+        }
+        return match2;
+      }
+    );
+    if (positionalIndex < positionals.length) {
+      formattedMessage += ` ${positionals.slice(positionalIndex).join(" ")}`;
+    }
+    formattedMessage = formattedMessage.replace(/%{2,2}/g, "%");
+    return formattedMessage;
+  }
+  var STACK_FRAMES_TO_IGNORE2 = 2;
+  function cleanErrorStack2(error3) {
+    if (!error3.stack) {
+      return;
+    }
+    const nextStack = error3.stack.split("\n");
+    nextStack.splice(1, STACK_FRAMES_TO_IGNORE2);
+    error3.stack = nextStack.join("\n");
+  }
+  var InvariantError2 = class extends Error {
+    constructor(message3, ...positionals) {
+      super(message3);
+      this.message = message3;
+      this.name = "Invariant Violation";
+      this.message = format2(message3, ...positionals);
+      cleanErrorStack2(this);
+    }
+  };
+  var invariant2 = (predicate, message3, ...positionals) => {
+    if (!predicate) {
+      throw new InvariantError2(message3, ...positionals);
+    }
+  };
+  invariant2.as = (ErrorConstructor, predicate, message3, ...positionals) => {
+    if (!predicate) {
+      const formatMessage2 = positionals.length === 0 ? message3 : format2(message3, ...positionals);
+      let error3;
+      try {
+        error3 = Reflect.construct(ErrorConstructor, [
+          formatMessage2
+        ]);
+      } catch (err) {
+        error3 = ErrorConstructor(formatMessage2);
+      }
+      throw error3;
+    }
+  };
+
   // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
   var __defProp3 = Object.defineProperty;
   var __export2 = (target, all) => {
@@ -14689,21 +14780,21 @@ ${operationTypes.join("\n")}
   var noop = () => void 0;
   function log(message3, ...positionals) {
     if (IS_NODE) {
-      process.stdout.write(format(message3, ...positionals) + "\n");
+      process.stdout.write(format2(message3, ...positionals) + "\n");
       return;
     }
     console.log(message3, ...positionals);
   }
   function warn2(message3, ...positionals) {
     if (IS_NODE) {
-      process.stderr.write(format(message3, ...positionals) + "\n");
+      process.stderr.write(format2(message3, ...positionals) + "\n");
       return;
     }
     console.warn(message3, ...positionals);
   }
   function error2(message3, ...positionals) {
     if (IS_NODE) {
-      process.stderr.write(format(message3, ...positionals) + "\n");
+      process.stderr.write(format2(message3, ...positionals) + "\n");
       return;
     }
     console.error(message3, ...positionals);
@@ -14733,7 +14824,7 @@ ${operationTypes.join("\n")}
     return message3.toString();
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/chunk-QED3Q6Z2.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/chunk-QED3Q6Z2.mjs
   var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
   function getGlobalSymbol(symbol) {
     return (
@@ -14881,7 +14972,7 @@ ${operationTypes.join("\n")}
     return Math.random().toString(16).slice(2);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/index.mjs
   var BatchInterceptor = class extends Interceptor {
     constructor(options) {
       BatchInterceptor.symbol = Symbol(options.name);
@@ -27060,6 +27151,9 @@ ${operationTypes.join("\n")}
     }
     putCookie(cookie, callback) {
       try {
+        if (cookie.maxAge === 0) {
+          return;
+        }
         const store2 = this.getStore();
         store2.push(cookie);
         this.updateStore(store2);
@@ -27070,6 +27164,15 @@ ${operationTypes.join("\n")}
       }
     }
     updateCookie(oldCookie, newCookie, callback) {
+      if (newCookie.maxAge === 0) {
+        this.removeCookie(
+          newCookie.domain || "",
+          newCookie.path || "",
+          newCookie.key,
+          callback
+        );
+        return;
+      }
       this.putCookie(newCookie, callback);
     }
     removeCookie(domain, path, key, callback) {
@@ -29010,34 +29113,58 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   };
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/chunk-OUWBQF3Z.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/chunk-THPGBWJQ.mjs
+  var InterceptorError = class extends Error {
+    constructor(message3) {
+      super(message3);
+      this.name = "InterceptorError";
+      Object.setPrototypeOf(this, InterceptorError.prototype);
+    }
+  };
+  var kRequestHandled = Symbol("kRequestHandled");
+  var kResponsePromise = Symbol("kResponsePromise");
   var RequestController = class {
     constructor(request) {
       this.request = request;
-      this.responsePromise = new DeferredPromise();
+      this[kRequestHandled] = false;
+      this[kResponsePromise] = new DeferredPromise();
     }
+    /**
+     * 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(
-        this.responsePromise.state === "pending",
-        'Failed to respond to "%s %s" request: the "request" event has already been responded to.',
+      invariant2.as(
+        InterceptorError,
+        !this[kRequestHandled],
+        'Failed to respond to the "%s %s" request: the "request" event has already been handled.',
+        this.request.method,
+        this.request.url
+      );
+      this[kRequestHandled] = true;
+      this[kResponsePromise].resolve(response);
+    }
+    /**
+     * Error this request with the given error.
+     * @example
+     * controller.errorWith()
+     * controller.errorWith(new Error('Oops!'))
+     */
+    errorWith(error3) {
+      invariant2.as(
+        InterceptorError,
+        !this[kRequestHandled],
+        'Failed to error the "%s %s" request: the "request" event has already been handled.',
         this.request.method,
         this.request.url
       );
-      this.responsePromise.resolve(response);
+      this[kRequestHandled] = true;
+      this[kResponsePromise].resolve(error3);
     }
   };
-  function toInteractiveRequest(request) {
-    const requestController = new RequestController(request);
-    Reflect.set(
-      request,
-      "respondWith",
-      requestController.respondWith.bind(requestController)
-    );
-    return {
-      interactiveRequest: request,
-      requestController
-    };
-  }
   async function emitAsync(emitter, eventName, ...data) {
     const listners = emitter.listeners(eventName);
     if (listners.length === 0) {
@@ -29047,8 +29174,114 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       await listener.apply(emitter, data);
     }
   }
+  function isNodeLikeError(error3) {
+    if (error3 == null) {
+      return false;
+    }
+    if (!(error3 instanceof Error)) {
+      return false;
+    }
+    return "code" in error3 && "errno" in error3;
+  }
+  async function handleRequest2(options) {
+    const handleResponse = async (response) => {
+      if (response instanceof Error) {
+        options.onError(response);
+      } else if (isResponseError(response)) {
+        options.onRequestError(response);
+      } else {
+        await options.onResponse(response);
+      }
+      return true;
+    };
+    const handleResponseError = async (error3) => {
+      if (error3 instanceof InterceptorError) {
+        throw result.error;
+      }
+      if (isNodeLikeError(error3)) {
+        options.onError(error3);
+        return true;
+      }
+      if (error3 instanceof Response) {
+        return await handleResponse(error3);
+      }
+      return false;
+    };
+    options.emitter.once("request", ({ requestId: pendingRequestId }) => {
+      if (pendingRequestId !== options.requestId) {
+        return;
+      }
+      if (options.controller[kResponsePromise].state === "pending") {
+        options.controller[kResponsePromise].resolve(void 0);
+      }
+    });
+    const requestAbortPromise = new DeferredPromise();
+    if (options.request.signal) {
+      options.request.signal.addEventListener(
+        "abort",
+        () => {
+          requestAbortPromise.reject(options.request.signal.reason);
+        },
+        { once: true }
+      );
+    }
+    const result = await until(async () => {
+      const requestListtenersPromise = emitAsync(options.emitter, "request", {
+        requestId: options.requestId,
+        request: options.request,
+        controller: options.controller
+      });
+      await Promise.race([
+        // Short-circuit the request handling promise if the request gets aborted.
+        requestAbortPromise,
+        requestListtenersPromise,
+        options.controller[kResponsePromise]
+      ]);
+      const mockedResponse = await options.controller[kResponsePromise];
+      return mockedResponse;
+    });
+    if (requestAbortPromise.state === "rejected") {
+      options.onError(requestAbortPromise.rejectionReason);
+      return true;
+    }
+    if (result.error) {
+      if (await handleResponseError(result.error)) {
+        return true;
+      }
+      if (options.emitter.listenerCount("unhandledException") > 0) {
+        const unhandledExceptionController = new RequestController(
+          options.request
+        );
+        await emitAsync(options.emitter, "unhandledException", {
+          error: result.error,
+          request: options.request,
+          requestId: options.requestId,
+          controller: unhandledExceptionController
+        }).then(() => {
+          if (unhandledExceptionController[kResponsePromise].state === "pending") {
+            unhandledExceptionController[kResponsePromise].resolve(void 0);
+          }
+        });
+        const nextResult = await until(
+          () => unhandledExceptionController[kResponsePromise]
+        );
+        if (nextResult.error) {
+          return handleResponseError(nextResult.error);
+        }
+        if (nextResult.data) {
+          return handleResponse(nextResult.data);
+        }
+      }
+      options.onResponse(createServerErrorResponse(result.error));
+      return true;
+    }
+    if (result.data) {
+      return handleResponse(result.data);
+    }
+    return false;
+  }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/chunk-MAEPOYB6.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/chunk-DZCGGRSJ.mjs
   function canParseUrl(url) {
     try {
       new URL(url);
@@ -29057,6 +29290,72 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       return false;
     }
   }
+  function createNetworkError(cause) {
+    return Object.assign(new TypeError("Failed to fetch"), {
+      cause
+    });
+  }
+  var REQUEST_BODY_HEADERS = [
+    "content-encoding",
+    "content-language",
+    "content-location",
+    "content-type",
+    "content-length"
+  ];
+  var kRedirectCount = Symbol("kRedirectCount");
+  async function followFetchRedirect(request, response) {
+    if (response.status !== 303 && request.body != null) {
+      return Promise.reject(createNetworkError());
+    }
+    const requestUrl = new URL(request.url);
+    let locationUrl;
+    try {
+      locationUrl = new URL(response.headers.get("location"));
+    } catch (error3) {
+      return Promise.reject(createNetworkError(error3));
+    }
+    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";
+      requestInit.body = null;
+      REQUEST_BODY_HEADERS.forEach((headerName) => {
+        request.headers.delete(headerName);
+      });
+    }
+    if (!sameOrigin(requestUrl, locationUrl)) {
+      request.headers.delete("authorization");
+      request.headers.delete("proxy-authorization");
+      request.headers.delete("cookie");
+      request.headers.delete("host");
+    }
+    requestInit.headers = request.headers;
+    return fetch(new Request(locationUrl, requestInit));
+  }
+  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;
+    }
+    return false;
+  }
   var _FetchInterceptor = class extends Interceptor {
     constructor() {
       super(_FetchInterceptor.symbol);
@@ -29066,136 +29365,84 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
     async setup() {
       const pureFetch = globalThis.fetch;
-      invariant(
+      invariant2(
         !pureFetch[IS_PATCHED_MODULE],
         'Failed to patch the "fetch" module: already patched.'
       );
       globalThis.fetch = async (input, init) => {
-        var _a2;
         const requestId = createRequestId();
         const resolvedInput = typeof input === "string" && typeof location !== "undefined" && !canParseUrl(input) ? new URL(input, location.origin) : input;
         const request = new Request(resolvedInput, init);
+        const responsePromise = new DeferredPromise();
+        const controller = new RequestController(request);
         this.logger.info("[%s] %s", request.method, request.url);
-        const { interactiveRequest, requestController } = toInteractiveRequest(request);
+        this.logger.info("awaiting for the mocked response...");
         this.logger.info(
-          'emitting the "request" event for %d listener(s)...',
+          'emitting the "request" event for %s listener(s)...',
           this.emitter.listenerCount("request")
         );
-        this.emitter.once("request", ({ requestId: pendingRequestId }) => {
-          if (pendingRequestId !== requestId) {
-            return;
-          }
-          if (requestController.responsePromise.state === "pending") {
-            requestController.responsePromise.resolve(void 0);
-          }
-        });
-        this.logger.info("awaiting for the mocked response...");
-        const signal = interactiveRequest.signal;
-        const requestAborted = new DeferredPromise();
-        if (signal) {
-          signal.addEventListener(
-            "abort",
-            () => {
-              requestAborted.reject(signal.reason);
-            },
-            { once: true }
-          );
-        }
-        const responsePromise = new DeferredPromise();
-        const respondWith = (response) => {
-          this.logger.info("responding with a mock response:", response);
-          if (this.emitter.listenerCount("response") > 0) {
-            this.logger.info('emitting the "response" event...');
-            const responseClone = response.clone();
-            this.emitter.emit("response", {
-              response: responseClone,
-              isMockedResponse: true,
-              request: interactiveRequest,
-              requestId
-            });
-          }
-          Object.defineProperty(response, "url", {
-            writable: false,
-            enumerable: true,
-            configurable: false,
-            value: request.url
-          });
-          responsePromise.resolve(response);
-        };
-        const errorWith = (reason) => {
-          responsePromise.reject(reason);
-        };
-        const resolverResult = await until(
-          async () => {
-            const listenersFinished = emitAsync(this.emitter, "request", {
-              request: interactiveRequest,
-              requestId
+        const isRequestHandled = await handleRequest2({
+          request,
+          requestId,
+          emitter: this.emitter,
+          controller,
+          onResponse: async (response) => {
+            this.logger.info("received mocked response!", {
+              response
             });
-            await Promise.race([
-              requestAborted,
-              // Put the listeners invocation Promise in the same race condition
-              // with the request abort Promise because otherwise awaiting the listeners
-              // would always yield some response (or undefined).
-              listenersFinished,
-              requestController.responsePromise
-            ]);
-            this.logger.info("all request listeners have been resolved!");
-            const mockedResponse2 = await requestController.responsePromise;
-            this.logger.info("event.respondWith called with:", mockedResponse2);
-            return mockedResponse2;
-          }
-        );
-        if (requestAborted.state === "rejected") {
-          this.logger.info(
-            "request has been aborted:",
-            requestAborted.rejectionReason
-          );
-          responsePromise.reject(requestAborted.rejectionReason);
-          return responsePromise;
-        }
-        if (resolverResult.error) {
-          this.logger.info(
-            "request listerner threw an error:",
-            resolverResult.error
-          );
-          if (resolverResult.error instanceof Response) {
-            if (isResponseError(resolverResult.error)) {
-              errorWith(createNetworkError(resolverResult.error));
-            } else {
-              respondWith(resolverResult.error);
-            }
-          }
-          if (this.emitter.listenerCount("unhandledException") > 0) {
-            await emitAsync(this.emitter, "unhandledException", {
-              error: resolverResult.error,
-              request,
-              requestId,
-              controller: {
-                respondWith,
-                errorWith
+            if (RESPONSE_STATUS_CODES_WITH_REDIRECT.has(response.status)) {
+              if (request.redirect === "error") {
+                responsePromise.reject(createNetworkError("unexpected redirect"));
+                return;
+              }
+              if (request.redirect === "follow") {
+                followFetchRedirect(request, response).then(
+                  (response2) => {
+                    responsePromise.resolve(response2);
+                  },
+                  (reason) => {
+                    responsePromise.reject(reason);
+                  }
+                );
+                return;
               }
-            });
-            if (responsePromise.state !== "pending") {
-              return responsePromise;
             }
+            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,
+                requestId
+              });
+            }
+            Object.defineProperty(response, "url", {
+              writable: false,
+              enumerable: true,
+              configurable: false,
+              value: request.url
+            });
+            responsePromise.resolve(response);
+          },
+          onRequestError: (response) => {
+            this.logger.info("request has errored!", { response });
+            responsePromise.reject(createNetworkError(response));
+          },
+          onError: (error3) => {
+            this.logger.info("request has been aborted!", { error: error3 });
+            responsePromise.reject(error3);
           }
-          respondWith(createServerErrorResponse(resolverResult.error));
-          return responsePromise;
-        }
-        const mockedResponse = resolverResult.data;
-        if (mockedResponse && !((_a2 = request.signal) == null ? void 0 : _a2.aborted)) {
-          this.logger.info("received mocked response:", mockedResponse);
-          if (isResponseError(mockedResponse)) {
-            this.logger.info(
-              "received a network error response, rejecting the request promise..."
-            );
-            errorWith(createNetworkError(mockedResponse));
-          } else {
-            respondWith(mockedResponse);
-          }
+        });
+        if (isRequestHandled) {
+          this.logger.info("request has been handled, returning mock promise...");
           return responsePromise;
         }
-        this.logger.info("no mocked response received!");
+        this.logger.info(
+          "no mocked response received, performing request as-is..."
+        );
         return pureFetch(request).then((response) => {
           this.logger.info("original fetch performed", response);
           if (this.emitter.listenerCount("response") > 0) {
@@ -29204,7 +29451,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
             this.emitter.emit("response", {
               response: responseClone,
               isMockedResponse: false,
-              request: interactiveRequest,
+              request,
               requestId
             });
           }
@@ -29230,13 +29477,8 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   };
   var FetchInterceptor = _FetchInterceptor;
   FetchInterceptor.symbol = Symbol("fetch");
-  function createNetworkError(cause) {
-    return Object.assign(new TypeError("Failed to fetch"), {
-      cause
-    });
-  }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.29.0/node_modules/@mswjs/interceptors/lib/browser/chunk-732REFPX.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.35.0/node_modules/@mswjs/interceptors/lib/browser/chunk-PRBA3ES4.mjs
   function concatArrayBuffer(left, right) {
     const result = new Uint8Array(left.byteLength + right.byteLength);
     result.set(left, 0);
@@ -29245,10 +29487,10 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   }
   var EventPolyfill = class {
     constructor(type, options) {
-      this.AT_TARGET = 0;
-      this.BUBBLING_PHASE = 0;
-      this.CAPTURING_PHASE = 0;
       this.NONE = 0;
+      this.CAPTURING_PHASE = 1;
+      this.AT_TARGET = 2;
+      this.BUBBLING_PHASE = 3;
       this.type = "";
       this.srcElement = null;
       this.currentTarget = null;
@@ -29421,15 +29663,26 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
     return headers;
   }
-  var IS_MOCKED_RESPONSE = Symbol("isMockedResponse");
+  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;
+  }
+  var kIsRequestHandled = Symbol("kIsRequestHandled");
   var IS_NODE2 = isNodeProcess();
+  var kFetchRequest = Symbol("kFetchRequest");
   var XMLHttpRequestController = class {
     constructor(initialRequest, logger) {
       this.initialRequest = initialRequest;
       this.logger = logger;
       this.method = "GET";
       this.url = null;
+      this[kIsRequestHandled] = false;
       this.events = /* @__PURE__ */ new Map();
+      this.uploadEvents = /* @__PURE__ */ new Map();
       this.requestId = createRequestId();
       this.requestHeaders = new Headers();
       this.responseBuffer = new Uint8Array();
@@ -29478,9 +29731,6 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
             }
             case "send": {
               const [body] = args;
-              if (body != null) {
-                this.requestBody = typeof body === "string" ? encodeBuffer(body) : body;
-              }
               this.request.addEventListener("load", () => {
                 if (typeof this.onResponse !== "undefined") {
                   const fetchResponse = createResponse(
@@ -29494,19 +29744,21 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
                   );
                   this.onResponse.call(this, {
                     response: fetchResponse,
-                    isMockedResponse: IS_MOCKED_RESPONSE in this.request,
+                    isMockedResponse: this[kIsRequestHandled],
                     request: fetchRequest,
                     requestId: this.requestId
                   });
                 }
               });
-              const fetchRequest = this.toFetchApiRequest();
+              const requestBody = typeof body === "string" ? encodeBuffer(body) : body;
+              const fetchRequest = this.toFetchApiRequest(requestBody);
+              this[kFetchRequest] = fetchRequest;
               const onceRequestSettled = ((_a2 = this.onRequest) == null ? void 0 : _a2.call(this, {
                 request: fetchRequest,
                 requestId: this.requestId
               })) || Promise.resolve();
               onceRequestSettled.finally(() => {
-                if (this.request.readyState < this.request.LOADING) {
+                if (!this[kIsRequestHandled]) {
                   this.logger.info(
                     "request callback settled but request has not been handled (readystate %d), performing as-is...",
                     this.request.readyState
@@ -29528,6 +29780,39 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           }
         }
       });
+      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();
+              }
+            }
+          }
+        })
+      );
     }
     registerEvent(eventName, listener) {
       const prevEvents = this.events.get(eventName) || [];
@@ -29535,17 +29820,44 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       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);
+      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.
      */
-    respondWith(response) {
+    async respondWith(response) {
+      this[kIsRequestHandled] = true;
+      if (this[kFetchRequest]) {
+        const totalRequestBodyLength = await getBodyByteLength(
+          this[kFetchRequest].clone()
+        );
+        this.trigger("loadstart", this.request.upload, {
+          loaded: 0,
+          total: totalRequestBodyLength
+        });
+        this.trigger("progress", this.request.upload, {
+          loaded: totalRequestBodyLength,
+          total: totalRequestBodyLength
+        });
+        this.trigger("load", this.request.upload, {
+          loaded: totalRequestBodyLength,
+          total: totalRequestBodyLength
+        });
+        this.trigger("loadend", this.request.upload, {
+          loaded: totalRequestBodyLength,
+          total: totalRequestBodyLength
+        });
+      }
       this.logger.info(
         "responding with a mocked response: %d %s",
         response.status,
         response.statusText
       );
-      define(this.request, IS_MOCKED_RESPONSE, true);
       define(this.request, "status", response.status);
       define(this.request, "statusText", response.statusText);
       define(this.request, "responseURL", this.url.href);
@@ -29600,14 +29912,9 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           get: () => this.responseXML
         }
       });
-      const totalResponseBodyLength = response.headers.has("Content-Length") ? Number(response.headers.get("Content-Length")) : (
-        /**
-         * @todo Infer the response body length from the response body.
-         */
-        void 0
-      );
+      const totalResponseBodyLength = await getBodyByteLength(response.clone());
       this.logger.info("calculated response body length", totalResponseBodyLength);
-      this.trigger("loadstart", {
+      this.trigger("loadstart", this.request, {
         loaded: 0,
         total: totalResponseBodyLength
       });
@@ -29616,11 +29923,11 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       const finalizeResponse = () => {
         this.logger.info("finalizing the mocked response...");
         this.setReadyState(this.request.DONE);
-        this.trigger("load", {
+        this.trigger("load", this.request, {
           loaded: this.responseBuffer.byteLength,
           total: totalResponseBodyLength
         });
-        this.trigger("loadend", {
+        this.trigger("loadend", this.request, {
           loaded: this.responseBuffer.byteLength,
           total: totalResponseBodyLength
         });
@@ -29638,7 +29945,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           if (value) {
             this.logger.info("read response body chunk:", value);
             this.responseBuffer = concatArrayBuffer(this.responseBuffer, value);
-            this.trigger("progress", {
+            this.trigger("progress", this.request, {
               loaded: this.responseBuffer.byteLength,
               total: totalResponseBodyLength
             });
@@ -29696,7 +30003,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       }
     }
     get responseText() {
-      invariant(
+      invariant2(
         this.request.responseType === "" || this.request.responseType === "text",
         "InvalidStateError: The object is in invalid state."
       );
@@ -29708,7 +30015,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       return responseText;
     }
     get responseXML() {
-      invariant(
+      invariant2(
         this.request.responseType === "" || this.request.responseType === "document",
         "InvalidStateError: The object is in invalid state."
       );
@@ -29731,10 +30038,11 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       return null;
     }
     errorWith(error3) {
+      this[kIsRequestHandled] = true;
       this.logger.info("responding with an error");
       this.setReadyState(this.request.DONE);
-      this.trigger("error");
-      this.trigger("loadend");
+      this.trigger("error", this.request);
+      this.trigger("loadend", this.request);
     }
     /**
      * Transitions this request's `readyState` to the given one.
@@ -29753,36 +30061,38 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       this.logger.info("set readyState to: %d", nextReadyState);
       if (nextReadyState !== this.request.UNSENT) {
         this.logger.info('triggerring "readystatechange" event...');
-        this.trigger("readystatechange");
+        this.trigger("readystatechange", this.request);
       }
     }
     /**
      * Triggers given event on the `XMLHttpRequest` instance.
      */
-    trigger(eventName, options) {
-      const callback = this.request[`on${eventName}`];
-      const event = createEvent(this.request, eventName, options);
+    trigger(eventName, target, options) {
+      const callback = target[`on${eventName}`];
+      const event = createEvent(target, eventName, options);
       this.logger.info('trigger "%s"', eventName, options || "");
       if (typeof callback === "function") {
         this.logger.info('found a direct "%s" callback, calling...', eventName);
-        callback.call(this.request, event);
+        callback.call(target, event);
       }
-      for (const [registeredEventName, listeners] of this.events) {
+      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(this.request, event));
+          listeners.forEach((listener) => listener.call(target, event));
         }
       }
     }
     /**
      * Converts this `XMLHttpRequest` instance into a Fetch API `Request` instance.
      */
-    toFetchApiRequest() {
+    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,
@@ -29790,7 +30100,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
          * @see https://xhr.spec.whatwg.org/#cross-origin-credentials
          */
         credentials: this.request.withCredentials ? "include" : "same-origin",
-        body: ["GET", "HEAD"].includes(this.method) ? null : this.requestBody
+        body: ["GET", "HEAD"].includes(this.method.toUpperCase()) ? null : resolvedBody
       });
       const proxyHeaders = createProxy(fetchRequest.headers, {
         methodCall: ([methodName, args], invoke) => {
@@ -29858,81 +30168,35 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           logger
         );
         xhrRequestController.onRequest = async function({ request, requestId }) {
-          const { interactiveRequest, requestController } = toInteractiveRequest(request);
+          const controller = new RequestController(request);
           this.logger.info("awaiting mocked response...");
-          emitter.once("request", ({ requestId: pendingRequestId }) => {
-            if (pendingRequestId !== requestId) {
-              return;
-            }
-            if (requestController.responsePromise.state === "pending") {
-              requestController.respondWith(void 0);
-            }
-          });
-          const resolverResult = await until(async () => {
-            this.logger.info(
-              'emitting the "request" event for %s listener(s)...',
-              emitter.listenerCount("request")
-            );
-            await emitAsync(emitter, "request", {
-              request: interactiveRequest,
-              requestId
-            });
-            this.logger.info('all "request" listeners settled!');
-            const mockedResponse2 = await requestController.responsePromise;
-            this.logger.info("event.respondWith called with:", mockedResponse2);
-            return mockedResponse2;
-          });
-          if (resolverResult.error) {
-            this.logger.info(
-              "request listener threw an exception, aborting request...",
-              resolverResult.error
-            );
-            if (resolverResult.error instanceof Response) {
-              if (isResponseError(resolverResult.error)) {
-                xhrRequestController.errorWith(new TypeError("Network error"));
-              } else {
-                this.respondWith(resolverResult.error);
-              }
-              return;
-            }
-            if (emitter.listenerCount("unhandledException") > 0) {
-              await emitAsync(emitter, "unhandledException", {
-                error: resolverResult.error,
-                request,
-                requestId,
-                controller: {
-                  respondWith: xhrRequestController.respondWith.bind(xhrRequestController),
-                  errorWith: xhrRequestController.errorWith.bind(xhrRequestController)
-                }
-              });
-              if (originalRequest.readyState > XMLHttpRequest.OPENED) {
-                return;
+          this.logger.info(
+            'emitting the "request" event for %s listener(s)...',
+            emitter.listenerCount("request")
+          );
+          const isRequestHandled = await handleRequest2({
+            request,
+            requestId,
+            controller,
+            emitter,
+            onResponse: async (response) => {
+              await this.respondWith(response);
+            },
+            onRequestError: () => {
+              this.errorWith(new TypeError("Network error"));
+            },
+            onError: (error3) => {
+              this.logger.info("request errored!", { error: error3 });
+              if (error3 instanceof Error) {
+                this.errorWith(error3);
               }
             }
-            xhrRequestController.respondWith(
-              createServerErrorResponse(resolverResult.error)
-            );
-            return;
-          }
-          const mockedResponse = resolverResult.data;
-          if (typeof mockedResponse !== "undefined") {
+          });
+          if (!isRequestHandled) {
             this.logger.info(
-              "received mocked response: %d %s",
-              mockedResponse.status,
-              mockedResponse.statusText
+              "no mocked response received, performing request as-is..."
             );
-            if (isResponseError(mockedResponse)) {
-              this.logger.info(
-                "received a network error response, rejecting the request promise..."
-              );
-              xhrRequestController.errorWith(new TypeError("Network error"));
-              return;
-            }
-            return xhrRequestController.respondWith(mockedResponse);
           }
-          this.logger.info(
-            "no mocked response received, performing request as-is..."
-          );
         };
         xhrRequestController.onResponse = async function({
           response,
@@ -29967,7 +30231,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       const logger = this.logger.extend("setup");
       logger.info('patching "XMLHttpRequest" module...');
       const PureXMLHttpRequest = globalThis.XMLHttpRequest;
-      invariant(
+      invariant2(
         !PureXMLHttpRequest[IS_PATCHED_MODULE],
         'Failed to patch the "XMLHttpRequest" module: already patched.'
       );
@@ -30005,7 +30269,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       name: "fallback",
       interceptors: [new FetchInterceptor(), new XMLHttpRequestInterceptor()]
     });
-    interceptor.on("request", async ({ request, requestId }) => {
+    interceptor.on("request", async ({ request, requestId, controller }) => {
       const requestCloneForLogs = request.clone();
       const response = await handleRequest(
         request,
@@ -30028,7 +30292,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         }
       );
       if (response) {
-        request.respondWith(response);
+        controller.respondWith(response);
       }
     });
     interceptor.on(