msw 2.4.2 → 2.4.4

package/lib/browser/index.js

@@ -397,7 +397,7 @@ You can also automate this process and make the worker script update automatical
   }
 }
 
-// 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);
@@ -413,7 +413,7 @@ function toArrayBuffer(array) {
   );
 }
 
-// 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 {
@@ -430,6 +430,13 @@ var RESPONSE_STATUS_CODES_WITHOUT_BODY = /* @__PURE__ */ new Set([
   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);
 }
@@ -455,6 +462,90 @@ function isResponseError(response) {
   return isPropertyAccessible(response, "type") && response.type === "error";
 }
 
+// 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(message, ...positionals) {
+  if (positionals.length === 0) {
+    return message;
+  }
+  let positionalIndex = 0;
+  let formattedMessage = message.replace(
+    POSITIONALS_EXP2,
+    (match, isEscaped, _, flag) => {
+      const positional = positionals[positionalIndex];
+      const value = serializePositional2(positional, flag);
+      if (!isEscaped) {
+        positionalIndex++;
+        return value;
+      }
+      return match;
+    }
+  );
+  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(error2) {
+  if (!error2.stack) {
+    return;
+  }
+  const nextStack = error2.stack.split("\n");
+  nextStack.splice(1, STACK_FRAMES_TO_IGNORE2);
+  error2.stack = nextStack.join("\n");
+}
+var InvariantError2 = class extends Error {
+  constructor(message, ...positionals) {
+    super(message);
+    this.message = message;
+    this.name = "Invariant Violation";
+    this.message = format2(message, ...positionals);
+    cleanErrorStack2(this);
+  }
+};
+var invariant2 = (predicate, message, ...positionals) => {
+  if (!predicate) {
+    throw new InvariantError2(message, ...positionals);
+  }
+};
+invariant2.as = (ErrorConstructor, predicate, message, ...positionals) => {
+  if (!predicate) {
+    const formatMessage = positionals.length === 0 ? message : format2(message, ...positionals);
+    let error2;
+    try {
+      error2 = Reflect.construct(ErrorConstructor, [
+        formatMessage
+      ]);
+    } catch (err) {
+      error2 = ErrorConstructor(formatMessage);
+    }
+    throw error2;
+  }
+};
+
 // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
 var __defProp2 = Object.defineProperty;
 var __export2 = (target, all) => {
@@ -683,21 +774,21 @@ var PerformanceEntry = class {
 var noop = () => void 0;
 function log(message, ...positionals) {
   if (IS_NODE) {
-    process.stdout.write(format(message, ...positionals) + "\n");
+    process.stdout.write(format2(message, ...positionals) + "\n");
     return;
   }
   console.log(message, ...positionals);
 }
 function warn(message, ...positionals) {
   if (IS_NODE) {
-    process.stderr.write(format(message, ...positionals) + "\n");
+    process.stderr.write(format2(message, ...positionals) + "\n");
     return;
   }
   console.warn(message, ...positionals);
 }
 function error(message, ...positionals) {
   if (IS_NODE) {
-    process.stderr.write(format(message, ...positionals) + "\n");
+    process.stderr.write(format2(message, ...positionals) + "\n");
     return;
   }
   console.error(message, ...positionals);
@@ -892,7 +983,7 @@ var _Emitter = class {
 var Emitter = _Emitter;
 Emitter.defaultMaxListeners = 10;
 
-// 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 (
@@ -1040,7 +1131,7 @@ function createRequestId() {
   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);
@@ -1324,34 +1415,58 @@ var DeferredPromise = class extends Promise {
   }
 };
 
-// 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(message) {
+    super(message);
+    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.responsePromise.resolve(response);
+    this[kRequestHandled] = true;
+    this[kResponsePromise].resolve(response);
+  }
+  /**
+   * Error this request with the given error.
+   * @example
+   * controller.errorWith()
+   * controller.errorWith(new Error('Oops!'))
+   */
+  errorWith(error2) {
+    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[kRequestHandled] = true;
+    this[kResponsePromise].resolve(error2);
   }
 };
-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) {
@@ -1361,8 +1476,114 @@ async function emitAsync(emitter, eventName, ...data) {
     await listener.apply(emitter, data);
   }
 }
+function isNodeLikeError(error2) {
+  if (error2 == null) {
+    return false;
+  }
+  if (!(error2 instanceof Error)) {
+    return false;
+  }
+  return "code" in error2 && "errno" in error2;
+}
+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 (error2) => {
+    if (error2 instanceof InterceptorError) {
+      throw result.error;
+    }
+    if (isNodeLikeError(error2)) {
+      options.onError(error2);
+      return true;
+    }
+    if (error2 instanceof Response) {
+      return await handleResponse(error2);
+    }
+    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);
@@ -1371,6 +1592,72 @@ function canParseUrl(url) {
     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 (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"')
+    );
+  }
+  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);
@@ -1380,136 +1667,84 @@ var _FetchInterceptor = class extends Interceptor {
   }
   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 _a;
       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: (error2) => {
+          this.logger.info("request has been aborted!", { error: error2 });
+          responsePromise.reject(error2);
         }
-        respondWith(createServerErrorResponse(resolverResult.error));
-        return responsePromise;
-      }
-      const mockedResponse = resolverResult.data;
-      if (mockedResponse && !((_a = request.signal) == null ? void 0 : _a.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) {
@@ -1518,7 +1753,7 @@ var _FetchInterceptor = class extends Interceptor {
           this.emitter.emit("response", {
             response: responseClone,
             isMockedResponse: false,
-            request: interactiveRequest,
+            request,
             requestId
           });
         }
@@ -1544,13 +1779,8 @@ var _FetchInterceptor = class extends Interceptor {
 };
 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);
@@ -1559,10 +1789,10 @@ function concatArrayBuffer(left, right) {
 }
 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;
@@ -1735,15 +1965,26 @@ function createHeadersFromXMLHttpReqestHeaders(headersString) {
   }
   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();
@@ -1792,9 +2033,6 @@ var XMLHttpRequestController = class {
           }
           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(
@@ -1808,19 +2046,21 @@ var XMLHttpRequestController = class {
                 );
                 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 = ((_a = this.onRequest) == null ? void 0 : _a.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
@@ -1842,6 +2082,39 @@ var XMLHttpRequestController = class {
         }
       }
     });
+    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) || [];
@@ -1849,17 +2122,44 @@ var XMLHttpRequestController = class {
     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);
@@ -1914,14 +2214,9 @@ var XMLHttpRequestController = class {
         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
     });
@@ -1930,11 +2225,11 @@ var XMLHttpRequestController = class {
     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
       });
@@ -1952,7 +2247,7 @@ var XMLHttpRequestController = class {
         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
           });
@@ -2010,7 +2305,7 @@ var XMLHttpRequestController = class {
     }
   }
   get responseText() {
-    invariant(
+    invariant2(
       this.request.responseType === "" || this.request.responseType === "text",
       "InvalidStateError: The object is in invalid state."
     );
@@ -2022,7 +2317,7 @@ var XMLHttpRequestController = class {
     return responseText;
   }
   get responseXML() {
-    invariant(
+    invariant2(
       this.request.responseType === "" || this.request.responseType === "document",
       "InvalidStateError: The object is in invalid state."
     );
@@ -2045,10 +2340,11 @@ var XMLHttpRequestController = class {
     return null;
   }
   errorWith(error2) {
+    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.
@@ -2067,36 +2363,38 @@ var XMLHttpRequestController = class {
     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,
@@ -2104,7 +2402,7 @@ var XMLHttpRequestController = class {
        * @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) => {
@@ -2172,81 +2470,35 @@ function createXMLHttpRequestProxy({
         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: (error2) => {
+            this.logger.info("request errored!", { error: error2 });
+            if (error2 instanceof Error) {
+              this.errorWith(error2);
             }
           }
-          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,
@@ -2281,7 +2533,7 @@ var _XMLHttpRequestInterceptor = class extends Interceptor {
     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.'
     );
@@ -2320,7 +2572,7 @@ function createFallbackRequestListener(context, options) {
     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 (0, import_handleRequest2.handleRequest)(
       request,
@@ -2343,7 +2595,7 @@ function createFallbackRequestListener(context, options) {
       }
     );
     if (response) {
-      request.respondWith(response);
+      controller.respondWith(response);
     }
   });
   interceptor.on(