@mswjs/interceptors 0.41.9 → 0.42.0

package/lib/browser/{XMLHttpRequest-DrZAf3w6.mjs → web-C2oKsT3Q.js}

@@ -1,12 +1,11 @@
-import { n as INTERNAL_REQUEST_ID_HEADER_NAME, r as Interceptor, t as createRequestId } from "./createRequestId-DYCsFHOi.mjs";
-import { i as FetchResponse, n as setRawRequest, o as RequestController, r as FetchRequest } from "./getRawRequest-B1BqgWG6.mjs";
-import { n as encodeBuffer, r as toArrayBuffer, t as decodeBuffer } from "./bufferUtils-BiiO6HZv.mjs";
-import { n as patchesRegistry, t as hasConfigurableGlobal } from "./hasConfigurableGlobal-C8zq1MCg.mjs";
-import { n as isResponseError, t as handleRequest } from "./handleRequest-CPPgsG7s.mjs";
+import { n as Interceptor, r as createLogger, t as createRequestId } from "./create-request-id-DlEd4GOA.js";
+import { c as RequestController, i as isResponseError, n as FetchResponse, t as FetchRequest } from "./fetch-utils-zxA_SD66.js";
+import { n as encodeBuffer, r as toArrayBuffer, t as decodeBuffer } from "./buffer-utils-DJj7YzLG.js";
+import { n as HttpResponseEvent, t as handleRequest } from "./handle-request-CIOa9O-N.js";
+import { n as patchesRegistry, t as hasConfigurableGlobal } from "./has-configurable-global-Cew-dYqk.js";
 import { invariant } from "outvariant";
-import { isNodeProcess } from "is-node-process";
-
-//#region src/interceptors/XMLHttpRequest/utils/concatArrayBuffer.ts
+import { until } from "@open-draft/until";
+//#region src/interceptors/XMLHttpRequest/utils/concat-array-buffer.ts
 /**
 * Concatenate two `Uint8Array` buffers.
 */
@@ -16,9 +15,8 @@ function concatArrayBuffer(left, right) {
 	result.set(right, left.byteLength);
 	return result;
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/polyfills/EventPolyfill.ts
+//#region src/interceptors/XMLHttpRequest/polyfills/event-polyfill.ts
 var EventPolyfill = class {
 	constructor(type, options) {
 		this.NONE = 0;
@@ -58,9 +56,8 @@ var EventPolyfill = class {
 	stopPropagation() {}
 	stopImmediatePropagation() {}
 };
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/polyfills/ProgressEventPolyfill.ts
+//#region src/interceptors/XMLHttpRequest/polyfills/progress-event-polyfill.ts
 var ProgressEventPolyfill = class extends EventPolyfill {
 	constructor(type, init) {
 		super(type);
@@ -70,9 +67,8 @@ var ProgressEventPolyfill = class extends EventPolyfill {
 		this.total = init?.total || 0;
 	}
 };
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/utils/createEvent.ts
+//#region src/interceptors/XMLHttpRequest/utils/create-event.ts
 const SUPPORTS_PROGRESS_EVENT = typeof ProgressEvent !== "undefined";
 function createEvent(target, type, init) {
 	const progressEvents = [
@@ -98,9 +94,8 @@ function createEvent(target, type, init) {
 		currentTarget: target
 	});
 }
-
 //#endregion
-//#region src/utils/findPropertySource.ts
+//#region src/utils/find-property-source.ts
 /**
 * Returns the source object of the given property on the target object
 * (the target itself, any parent in its prototype, or null).
@@ -111,9 +106,8 @@ function findPropertySource(target, propertyName) {
 	const prototype = Reflect.getPrototypeOf(target);
 	return prototype ? findPropertySource(prototype, propertyName) : null;
 }
-
 //#endregion
-//#region src/utils/createProxy.ts
+//#region src/utils/create-proxy.ts
 function createProxy(target, options) {
 	return new Proxy(target, optionsToProxyHandler(options));
 }
@@ -149,17 +143,16 @@ function optionsToProxyHandler(options) {
 		const next = () => target[propertyName];
 		const value = typeof getProperty !== "undefined" ? getProperty.call(target, [propertyName, receiver], next) : next();
 		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();
+			const next = value.bind(target, ...args);
+			if (typeof methodCall !== "undefined") return methodCall.call(target, [propertyName, args], next);
+			return next();
 		};
 		return value;
 	};
 	return handler;
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/utils/isDomParserSupportedType.ts
+//#region src/interceptors/XMLHttpRequest/utils/is-dom-parser-supported-type.ts
 function isDomParserSupportedType(type) {
 	return [
 		"application/xhtml+xml",
@@ -171,9 +164,8 @@ function isDomParserSupportedType(type) {
 		return type.startsWith(supportedType);
 	});
 }
-
 //#endregion
-//#region src/utils/parseJson.ts
+//#region src/utils/parse-json.ts
 /**
 * Parses a given string into JSON.
 * Gracefully handles invalid JSON by returning `null`.
@@ -185,9 +177,8 @@ function parseJson(data) {
 		return null;
 	}
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/utils/createResponse.ts
+//#region src/interceptors/XMLHttpRequest/utils/create-response.ts
 /**
 * Creates a Fetch API `Response` instance from the given
 * `XMLHttpRequest` instance and a response body.
@@ -211,9 +202,8 @@ function createHeadersFromXMLHttpRequestHeaders(headersString) {
 	}
 	return headers;
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/utils/getBodyByteLength.ts
+//#region src/interceptors/XMLHttpRequest/utils/get-body-byte-length.ts
 /**
 * Return a total byte length of the given request/response body.
 * If the `Content-Length` header is present, it will be used as the byte length.
@@ -223,12 +213,11 @@ async function getBodyByteLength(input) {
 	if (explicitContentLength != null && explicitContentLength !== "") return Number(explicitContentLength);
 	return (await input.arrayBuffer()).byteLength;
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts
+//#region src/interceptors/XMLHttpRequest/xml-http-request-controller.ts
 const kIsRequestHandled = Symbol("kIsRequestHandled");
-const IS_NODE = isNodeProcess();
 const kFetchRequest = Symbol("kFetchRequest");
+const MAX_REDIRECTS = 20;
 /**
 * An `XMLHttpRequest` instance controller that allows us
 * to handle any given request instance (e.g. responding to it).
@@ -237,112 +226,91 @@ var XMLHttpRequestController = class {
 	constructor(initialRequest, logger) {
 		this.initialRequest = initialRequest;
 		this.logger = logger;
+		this.sync = false;
 		this.method = "GET";
 		this.url = null;
 		this[kIsRequestHandled] = false;
+		this.redirectCount = 0;
 		this.events = /* @__PURE__ */ new Map();
 		this.uploadEvents = /* @__PURE__ */ new Map();
 		this.requestId = createRequestId();
 		this.requestHeaders = new Headers();
-		this.responseBuffer = new Uint8Array();
-		this.request = createProxy(initialRequest, {
-			setProperty: ([propertyName, nextValue], invoke) => {
-				switch (propertyName) {
-					case "ontimeout": {
-						const eventName = propertyName.slice(2);
-						/**
-						* @note Proxy callbacks to event listeners because JSDOM has trouble
-						* translating these properties to callbacks. It seemed to be operating
-						* on events exclusively.
-						*/
-						this.request.addEventListener(eventName, nextValue);
-						return invoke();
+		this.responseBuffer = /* @__PURE__ */ new Uint8Array();
+		this.request = createProxy(initialRequest, { methodCall: ([methodName, args], invoke) => {
+			switch (methodName) {
+				case "open": {
+					const [method, url, async] = args;
+					this.sync = !(async ?? true);
+					if (typeof url === "undefined") {
+						this.method = "GET";
+						this.url = toAbsoluteUrl(method);
+					} else {
+						this.method = method;
+						this.url = toAbsoluteUrl(url);
 					}
-					default: return invoke();
+					this.logger.verbose("open %s %s", this.method, this.url.href);
+					return invoke();
 				}
-			},
-			methodCall: ([methodName, args], invoke) => {
-				switch (methodName) {
-					case "open": {
-						const [method, url] = args;
-						if (typeof url === "undefined") {
-							this.method = "GET";
-							this.url = toAbsoluteUrl(method);
-						} else {
-							this.method = method;
-							this.url = toAbsoluteUrl(url);
-						}
-						this.logger = this.logger.extend(`${this.method} ${this.url.href}`);
-						this.logger.info("open", this.method, this.url.href);
-						return invoke();
-					}
-					case "addEventListener": {
-						const [eventName, listener] = args;
-						this.registerEvent(eventName, listener);
-						this.logger.info("addEventListener", eventName, listener);
-						return invoke();
-					}
-					case "setRequestHeader": {
-						const [name, value] = args;
-						this.requestHeaders.set(name, value);
-						this.logger.info("setRequestHeader", name, value);
+				case "addEventListener": {
+					const [eventName, listener] = args;
+					this.registerEvent(eventName, listener);
+					this.logger.verbose("addEventListener", eventName, listener);
+					return invoke();
+				}
+				case "setRequestHeader": {
+					const [name, value] = args;
+					this.requestHeaders.set(name, value);
+					this.logger.verbose("setRequestHeader", name, value);
+					return invoke();
+				}
+				case "send": {
+					const [body] = args;
+					if (this.sync) {
+						console.warn(`Failed to intercept an XMLHttpRequest (${this.method} ${this.url}): synchronous requests are not supported. This request will be performed as-is.`);
 						return invoke();
 					}
-					case "send": {
-						const [body] = args;
-						this.request.addEventListener("load", () => {
-							if (typeof this.onResponse !== "undefined") {
-								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
-									*/
-									this.request.response
-								);
-								this.onResponse.call(this, {
-									response: fetchResponse,
-									isMockedResponse: this[kIsRequestHandled],
-									request: fetchRequest,
-									requestId: this.requestId
-								});
-							}
-						});
-						const requestBody = typeof body === "string" ? encodeBuffer(body) : body;
-						const fetchRequest = this.toFetchApiRequest(requestBody);
-						this[kFetchRequest] = fetchRequest.clone();
-						/**
-						* @note Start request handling on the next tick so that the user
-						* could add event listeners for "loadend" before the interceptor fires it.
-						*/
-						queueMicrotask(() => {
-							(this.onRequest?.call(this, {
+					this.request.addEventListener("load", () => {
+						if (typeof this.onResponse !== "undefined") {
+							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
+								*/
+								this.request.response
+							);
+							this.onResponse.call(this, {
+								response: fetchResponse,
+								responseType: this[kIsRequestHandled] ? "mock" : "original",
 								request: fetchRequest,
 								requestId: this.requestId
-							}) || 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);
-									/**
-									* @note Set the intercepted request ID on the original request in Node.js
-									* so that if it triggers any other interceptors, they don't attempt
-									* to process it once again.
-									*
-									* For instance, XMLHttpRequest is often implemented via "http.ClientRequest"
-									* and we don't want for both XHR and ClientRequest interceptors to
-									* handle the same request at the same time (e.g. emit the "response" event twice).
-									*/
-									if (IS_NODE) this.request.setRequestHeader(INTERNAL_REQUEST_ID_HEADER_NAME, this.requestId);
-									return invoke();
-								}
 							});
+						}
+					});
+					const requestBody = typeof body === "string" ? encodeBuffer(body) : body;
+					const fetchRequest = this.toFetchApiRequest(requestBody);
+					this[kFetchRequest] = fetchRequest.clone();
+					/**
+					* @note Start request handling on the next tick so that the user
+					* could add event listeners for "loadend" before the interceptor fires it.
+					*/
+					queueMicrotask(() => {
+						(this.onRequest?.call(this, {
+							request: fetchRequest,
+							requestId: this.requestId
+						}) || Promise.resolve()).finally(() => {
+							if (!this[kIsRequestHandled]) {
+								this.logger.verbose("request callback settled but request has not been handled (readystate %d), performing as-is...", this.request.readyState);
+								return invoke();
+							}
 						});
-						break;
-					}
-					default: return invoke();
+					});
+					break;
 				}
+				default: return invoke();
 			}
-		});
+		} });
 		/**
 		* Proxy the `.upload` property to gather the event listeners/callbacks.
 		*/
@@ -367,7 +335,7 @@ var XMLHttpRequestController = class {
 					case "addEventListener": {
 						const [eventName, listener] = args;
 						this.registerUploadEvent(eventName, listener);
-						this.logger.info("upload.addEventListener", eventName, listener);
+						this.logger.verbose("upload.addEventListener", eventName, listener);
 						return invoke();
 					}
 				}
@@ -377,12 +345,12 @@ var XMLHttpRequestController = class {
 	registerEvent(eventName, listener) {
 		const nextEvents = (this.events.get(eventName) || []).concat(listener);
 		this.events.set(eventName, nextEvents);
-		this.logger.info("registered event \"%s\"", eventName, listener);
+		this.logger.verbose("registered event \"%s\"", eventName, listener);
 	}
 	registerUploadEvent(eventName, listener) {
 		const nextEvents = (this.uploadEvents.get(eventName) || []).concat(listener);
 		this.uploadEvents.set(eventName, nextEvents);
-		this.logger.info("registered upload event \"%s\"", eventName, listener);
+		this.logger.verbose("registered upload event \"%s\"", eventName, listener);
 	}
 	/**
 	* Responds to the current request with the given
@@ -398,55 +366,8 @@ var XMLHttpRequestController = class {
 		* calculating request/response total body length is asynchronous.
 		*/
 		this[kIsRequestHandled] = true;
-		/**
-		* Dispatch request upload events for requests with a body.
-		* @see https://github.com/mswjs/interceptors/issues/573
-		*/
-		if (this[kFetchRequest]) {
-			const totalRequestBodyLength = await getBodyByteLength(this[kFetchRequest]);
-			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, "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.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;
-		} });
+		this.logger.verbose("responding with a mocked response: %d %s", response.status, response.statusText);
+		FetchResponse.setUrl(this.url.href, response);
 		Object.defineProperties(this.request, {
 			response: {
 				enumerable: true,
@@ -464,75 +385,203 @@ var XMLHttpRequestController = class {
 				get: () => this.responseXML
 			}
 		});
-		const totalResponseBodyLength = await getBodyByteLength(response.clone());
-		this.logger.info("calculated response body length", totalResponseBodyLength);
 		this.trigger("loadstart", this.request, {
 			loaded: 0,
-			total: totalResponseBodyLength
+			total: 0
 		});
-		this.setReadyState(this.request.HEADERS_RECEIVED);
-		this.setReadyState(this.request.LOADING);
-		const finalizeResponse = () => {
-			this.logger.info("finalizing the mocked response...");
+		let requestBodyTransmitted = 0;
+		let uploadComplete = false;
+		if (this[kFetchRequest]) {
+			const requestBodyLength = await getBodyByteLength(this[kFetchRequest].clone());
+			if (!uploadComplete) this.trigger("loadstart", this.request.upload, {
+				loaded: 0,
+				total: requestBodyLength
+			});
+			const processRequestBodyChunkLength = (bytesLength) => {
+				requestBodyTransmitted += bytesLength;
+				if (requestBodyTransmitted < requestBodyLength) this.trigger("progress", this.request.upload, {
+					loaded: requestBodyTransmitted,
+					total: requestBodyLength
+				});
+			};
+			const processRequestEndOfBody = () => {
+				uploadComplete = true;
+				this.trigger("progress", this.request.upload, {
+					loaded: requestBodyTransmitted,
+					total: requestBodyLength
+				});
+				this.trigger("load", this.request.upload, {
+					loaded: requestBodyTransmitted,
+					total: requestBodyLength
+				});
+				this.trigger("loadend", this.request.upload, {
+					loaded: requestBodyTransmitted,
+					total: requestBodyLength
+				});
+			};
+			if (this[kFetchRequest]?.body != null) {
+				const reader = this[kFetchRequest].body.getReader();
+				while (true) {
+					const { value, done } = await reader.read();
+					if (done) {
+						processRequestEndOfBody();
+						break;
+					}
+					processRequestBodyChunkLength(value.byteLength);
+				}
+			} else processRequestEndOfBody();
+		}
+		let timedOut = false;
+		const responseReadController = new AbortController();
+		const requestErrorSteps = (event) => {
 			this.setReadyState(this.request.DONE);
-			this.trigger("load", this.request, {
-				loaded: this.responseBuffer.byteLength,
-				total: totalResponseBodyLength
+			if (!uploadComplete) {
+				this.trigger(event, this.request.upload, {
+					loaded: 0,
+					total: 0
+				});
+				this.trigger("loadend", this.request.upload, {
+					loaded: 0,
+					total: 0
+				});
+			}
+			this.trigger(event, this.request, {
+				loaded: 0,
+				total: 0
 			});
 			this.trigger("loadend", this.request, {
-				loaded: this.responseBuffer.byteLength,
-				total: totalResponseBodyLength
+				loaded: 0,
+				total: 0
 			});
 		};
-		if (response.body) {
-			this.logger.info("mocked response has body, streaming...");
-			const reader = response.body.getReader();
-			const readNextResponseBodyChunk = async () => {
-				const { value, done } = await reader.read();
-				if (done) {
-					this.logger.info("response body stream done!");
-					finalizeResponse();
-					return;
-				}
-				if (value) {
-					this.logger.info("read response body chunk:", value);
-					this.responseBuffer = concatArrayBuffer(this.responseBuffer, value);
-					this.trigger("progress", this.request, {
-						loaded: this.responseBuffer.byteLength,
-						total: totalResponseBodyLength
-					});
-				}
-				readNextResponseBodyChunk();
+		const processResponse = async (response) => {
+			const handleErrors = () => {
+				if (timedOut) requestErrorSteps("timeout");
+				else if (responseReadController.signal.aborted) requestErrorSteps("abort");
+				else if (isResponseError(response)) requestErrorSteps("error");
+			};
+			handleErrors();
+			define(this.request, "status", response.status);
+			define(this.request, "statusText", response.statusText);
+			if (!this.request.responseURL) define(this.request, "responseURL", response.url);
+			if (isResponseError(response)) return;
+			/**
+			* @note The response body length is derived ONLY from the "content-length" header.
+			* If that response header is not set, the "total" in all progress events must be 0.
+			*/
+			const responseBodyLength = Number(response.headers.get("content-length") ?? "0");
+			this.setReadyState(this.request.HEADERS_RECEIVED);
+			let receivedBytes = 0;
+			let lastReceivedResponseBytesAt = performance.now();
+			const processResponseBodyChunk = (bytesLength) => {
+				receivedBytes += bytesLength;
+				const now = performance.now();
+				const shouldBuffer = now - lastReceivedResponseBytesAt <= 60 && receivedBytes < responseBodyLength;
+				lastReceivedResponseBytesAt = now;
+				if (shouldBuffer) return;
+				if (this.request.readyState === this.request.HEADERS_RECEIVED) this.setReadyState(this.request.LOADING, false);
+				this.trigger("readystatechange", this.request);
+				this.trigger("progress", this.request, {
+					loaded: receivedBytes,
+					total: responseBodyLength
+				});
 			};
-			readNextResponseBodyChunk();
-		} else finalizeResponse();
+			const processResponseBodyError = () => {
+				requestErrorSteps("error");
+			};
+			const processResponseEndOfBody = async () => {
+				handleErrors();
+				if (isResponseError(response)) return;
+				let transmitted = receivedBytes;
+				this.setReadyState(this.request.DONE);
+				this.trigger("load", this.request, {
+					loaded: transmitted,
+					total: responseBodyLength
+				});
+				this.trigger("loadend", this.request, {
+					loaded: transmitted,
+					total: responseBodyLength
+				});
+			};
+			if (response.body == null) processResponseEndOfBody();
+			else {
+				const reader = response.body.getReader();
+				while (true) {
+					if (responseReadController.signal.aborted) break;
+					try {
+						const { value, done } = await reader.read();
+						if (done) {
+							processResponseEndOfBody();
+							return;
+						}
+						processResponseBodyChunk(value.byteLength);
+						this.responseBuffer = concatArrayBuffer(this.responseBuffer, value);
+					} catch {
+						processResponseBodyError();
+					}
+				}
+			}
+		};
+		const [redirectError, finalResponse] = await until(() => {
+			return this.followRedirects(response);
+		});
+		if (redirectError) return;
+		processResponse(finalResponse);
+		if (this.request.timeout) setTimeout(() => {
+			if (this.request.readyState !== this.request.DONE) {
+				timedOut = true;
+				responseReadController.abort();
+			}
+		}, this.request.timeout);
+		this.request.getResponseHeader = new Proxy(this.request.getResponseHeader, { apply: (_, __, args) => {
+			this.logger.verbose("getResponseHeader", args[0]);
+			if (this.request.readyState < this.request.HEADERS_RECEIVED) {
+				this.logger.verbose("headers not received yet, returning null");
+				return null;
+			}
+			const headerValue = finalResponse.headers.get(args[0]);
+			this.logger.verbose("resolved response header \"%s\" to", args[0], headerValue);
+			return headerValue;
+		} });
+		this.request.getAllResponseHeaders = new Proxy(this.request.getAllResponseHeaders, { apply: () => {
+			this.logger.verbose("getAllResponseHeaders");
+			if (this.request.readyState < this.request.HEADERS_RECEIVED) {
+				this.logger.verbose("headers not received yet, returning empty string");
+				return "";
+			}
+			const allHeaders = Array.from(finalResponse.headers).map(([headerName, headerValue]) => {
+				return `${headerName}: ${headerValue}`;
+			}).join("\r\n");
+			this.logger.verbose("resolved all response headers to", allHeaders);
+			return allHeaders;
+		} });
 	}
 	responseBufferToText() {
 		return decodeBuffer(this.responseBuffer);
 	}
 	get response() {
-		this.logger.info("getResponse (responseType: %s)", this.request.responseType);
+		this.logger.verbose("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());
-				this.logger.info("resolved response JSON", responseJson);
+				this.logger.verbose("resolved response JSON", responseJson);
 				return responseJson;
 			}
 			case "arraybuffer": {
 				const arrayBuffer = toArrayBuffer(this.responseBuffer);
-				this.logger.info("resolved response ArrayBuffer", arrayBuffer);
+				this.logger.verbose("resolved response ArrayBuffer", arrayBuffer);
 				return arrayBuffer;
 			}
 			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);
+				this.logger.verbose("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.verbose("resolving \"%s\" response type as text", this.request.responseType, responseText);
 				return responseText;
 			}
 		}
@@ -546,7 +595,7 @@ var XMLHttpRequestController = class {
 		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);
+		this.logger.verbose("getResponseText: \"%s\"", responseText);
 		return responseText;
 	}
 	get responseXML() {
@@ -560,13 +609,36 @@ var XMLHttpRequestController = class {
 		if (isDomParserSupportedType(contentType)) return new DOMParser().parseFromString(this.responseBufferToText(), contentType);
 		return null;
 	}
+	async followRedirects(response) {
+		const redirectLocation = response.headers.get("location");
+		if (!redirectLocation || !FetchResponse.isRedirectResponse(response.status)) return response;
+		this.redirectCount++;
+		if (this.redirectCount > MAX_REDIRECTS) throw new Error("Too many redirects");
+		const redirectUrl = new URL(redirectLocation, location.href);
+		const redirectMethod = FetchResponse.isResponseWithBody(response.status) ? this.method : "GET";
+		const redirectResponse = await new Promise((resolve, reject) => {
+			const request = new XMLHttpRequest();
+			request.responseType = this.request.responseType;
+			request.addEventListener("load", () => {
+				this.url = new URL(request.responseURL);
+				resolve(createResponse(request, request.response));
+			});
+			request.addEventListener("error", () => {
+				this.errorWith();
+				reject(/* @__PURE__ */ new Error("Redirect request failed"));
+			});
+			request.open(redirectMethod, redirectUrl.href);
+			request.send();
+		});
+		return this.followRedirects(redirectResponse);
+	}
 	errorWith(error) {
 		/**
 		* @note Mark this request as handled even if it received a mock error.
 		* This prevents the controller from trying to perform this request as-is.
 		*/
 		this[kIsRequestHandled] = true;
-		this.logger.info("responding with an error");
+		this.logger.verbose("responding with an error");
 		this.setReadyState(this.request.DONE);
 		this.trigger("error", this.request);
 		this.trigger("loadend", this.request);
@@ -574,16 +646,17 @@ var XMLHttpRequestController = class {
 	/**
 	* Transitions this request's `readyState` to the given one.
 	*/
-	setReadyState(nextReadyState) {
-		this.logger.info("setReadyState: %d -> %d", this.request.readyState, nextReadyState);
+	setReadyState(nextReadyState, triggerReadyStateChangeEvent = true) {
+		this.logger.verbose("setReadyState: %d -> %d", this.request.readyState, nextReadyState);
 		if (this.request.readyState === nextReadyState) {
-			this.logger.info("ready state identical, skipping transition...");
+			this.logger.verbose("ready state identical, skipping transition...");
 			return;
 		}
 		define(this.request, "readyState", nextReadyState);
-		this.logger.info("set readyState to: %d", nextReadyState);
+		this.logger.verbose("set readyState to: %d", nextReadyState);
+		if (!triggerReadyStateChangeEvent) return;
 		if (nextReadyState !== this.request.UNSENT) {
-			this.logger.info("triggering \"readystatechange\" event...");
+			this.logger.verbose("triggering \"readystatechange\" event...");
 			this.trigger("readystatechange", this.request);
 		}
 	}
@@ -593,14 +666,14 @@ var XMLHttpRequestController = class {
 	trigger(eventName, target, options) {
 		const callback = target[`on${eventName}`];
 		const event = createEvent(target, eventName, options);
-		this.logger.info("trigger \"%s\"", eventName, options || "");
+		this.logger.verbose("trigger \"%s\"", eventName, options || "");
 		if (typeof callback === "function") {
-			this.logger.info("found a direct \"%s\" callback, calling...", eventName);
+			this.logger.verbose("found a direct \"%s\" callback, calling...", eventName);
 			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);
+			this.logger.verbose("found %d listener(s) for \"%s\" event, calling...", listeners.length, eventName);
 			listeners.forEach((listener) => listener.call(target, event));
 		}
 	}
@@ -608,13 +681,16 @@ var XMLHttpRequestController = class {
 	* Converts this `XMLHttpRequest` instance into a Fetch API `Request` instance.
 	*/
 	toFetchApiRequest(body) {
-		this.logger.info("converting request to a Fetch API Request...");
+		this.logger.verbose("converting request to a Fetch API Request...");
 		const resolvedBody = body instanceof Document ? body.documentElement.innerText : body;
 		const fetchRequest = new FetchRequest(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
+			body: resolvedBody
 		});
 		define(fetchRequest, "headers", createProxy(fetchRequest.headers, { methodCall: ([methodName, args], invoke) => {
 			switch (methodName) {
@@ -632,8 +708,7 @@ var XMLHttpRequestController = class {
 			}
 			return invoke();
 		} }));
-		setRawRequest(fetchRequest, this.request);
-		this.logger.info("converted request to a Fetch API Request!", fetchRequest);
+		this.logger.verbose("converted request to a Fetch API Request!", fetchRequest);
 		return fetchRequest;
 	}
 };
@@ -655,9 +730,8 @@ function define(target, property, value) {
 		value
 	});
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts
+//#region src/interceptors/XMLHttpRequest/xml-http-request-proxy.ts
 /**
 * Create a proxied `XMLHttpRequest` class.
 * The proxied class establishes spies on certain methods,
@@ -665,7 +739,7 @@ function define(target, property, value) {
 */
 function createXMLHttpRequestProxy({ emitter, logger }) {
 	return new Proxy(globalThis.XMLHttpRequest, { construct(target, args, newTarget) {
-		logger.info("constructed new XMLHttpRequest");
+		logger.verbose("constructed new XMLHttpRequest");
 		const originalRequest = Reflect.construct(target, args, newTarget);
 		/**
 		* @note Forward prototype descriptors onto the proxied object.
@@ -680,67 +754,65 @@ function createXMLHttpRequestProxy({ emitter, logger }) {
 		xhrRequestController.onRequest = async function({ request, requestId }) {
 			const controller = new RequestController(request, {
 				passthrough: () => {
-					this.logger.info("no mocked response received, performing request as-is...");
+					this.logger.verbose("no mocked response received, performing request as-is...");
 				},
 				respondWith: async (response) => {
-					if (isResponseError(response)) {
-						this.errorWith(/* @__PURE__ */ new TypeError("Network error"));
-						return;
-					}
 					await this.respondWith(response);
 				},
 				errorWith: (reason) => {
-					this.logger.info("request errored!", { error: reason });
+					this.logger.verbose("request errored %o", { error: reason });
 					if (reason instanceof Error) this.errorWith(reason);
 				}
+			}, {
+				logger,
+				requestId
 			});
-			this.logger.info("awaiting mocked response...");
-			this.logger.info("emitting the \"request\" event for %s listener(s)...", emitter.listenerCount("request"));
+			this.logger.verbose("awaiting mocked response");
+			this.logger.verbose("emitting the \"request\" event for %s listener(s)...", emitter.listenerCount("request"));
 			await handleRequest({
+				initiator: this.request,
 				request,
 				requestId,
 				controller,
-				emitter
+				emitter,
+				logger
 			});
 		};
-		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", {
+		xhrRequestController.onResponse = async function({ response, responseType, request, requestId }) {
+			this.logger.verbose("emitting the \"response\" event for %s listener(s)...", emitter.listenerCount("response"));
+			await emitter.emitAsPromise(new HttpResponseEvent({
+				initiator: this.request,
 				response,
-				isMockedResponse,
+				responseType,
 				request,
 				requestId
-			});
+			}));
 		};
 		return xhrRequestController.request;
 	} });
 }
-
 //#endregion
-//#region src/interceptors/XMLHttpRequest/index.ts
-var XMLHttpRequestInterceptor = class XMLHttpRequestInterceptor extends Interceptor {
+//#region src/interceptors/XMLHttpRequest/web.ts
+const logger = createLogger("xhr");
+var XMLHttpRequestInterceptor = class extends Interceptor {
 	static {
 		this.symbol = Symbol.for("xhr-interceptor");
 	}
-	constructor() {
-		super(XMLHttpRequestInterceptor.symbol);
-	}
-	checkEnvironment() {
+	predicate() {
 		return hasConfigurableGlobal("XMLHttpRequest");
 	}
 	setup() {
-		const logger = this.logger.extend("setup");
-		logger.info("patching global XMLHttpRequest...");
+		logger.verbose("patching \"XMLHttpRequest\"...");
 		this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "XMLHttpRequest", () => {
 			return createXMLHttpRequestProxy({
 				emitter: this.emitter,
-				logger: this.logger
+				logger
 			});
 		}));
-		logger.info("global XMLHttpRequest patched!", globalThis.XMLHttpRequest.name);
+		logger.verbose("global \"XMLHttpRequest\" patched!", globalThis.XMLHttpRequest.name);
 	}
 };
-
 //#endregion
 export { XMLHttpRequestInterceptor as t };
-//# sourceMappingURL=XMLHttpRequest-DrZAf3w6.mjs.map
+
+//# sourceMappingURL=web-C2oKsT3Q.js.map