@mswjs/interceptors 0.39.8 → 0.41.0

package/lib/node/ClientRequest-Ca8Qykuv.mjs

@@ -0,0 +1,1034 @@
+import { i as RequestController, o as INTERNAL_REQUEST_ID_HEADER_NAME, r as createRequestId, s as Interceptor, t as FetchResponse } from "./fetchUtils-CoU35g3M.mjs";
+import { n as setRawRequest } from "./getRawRequest-DnwmXyOW.mjs";
+import { a as isPropertyAccessible, i as emitAsync, r as isObject, t as handleRequest } from "./handleRequest-Y97UwBbF.mjs";
+import { n as setRawRequestBodyStream } from "./node-DwCc6iuP.mjs";
+import { Logger } from "@open-draft/logger";
+import { invariant } from "outvariant";
+import http, { IncomingMessage, STATUS_CODES, ServerResponse, globalAgent } from "node:http";
+import https, { globalAgent as globalAgent$1 } from "node:https";
+import net from "node:net";
+import { HTTPParser } from "_http_common";
+import { Readable } from "node:stream";
+import { URL as URL$1, parse, urlToHttpOptions } from "node:url";
+import { Agent } from "http";
+
+//#region src/interceptors/Socket/utils/normalizeSocketWriteArgs.ts
+/**
+* Normalizes the arguments provided to the `Writable.prototype.write()`
+* and `Writable.prototype.end()`.
+*/
+function normalizeSocketWriteArgs(args) {
+	const normalized = [
+		args[0],
+		void 0,
+		void 0
+	];
+	if (typeof args[1] === "string") normalized[1] = args[1];
+	else if (typeof args[1] === "function") normalized[2] = args[1];
+	if (typeof args[2] === "function") normalized[2] = args[2];
+	return normalized;
+}
+
+//#endregion
+//#region src/interceptors/Socket/MockSocket.ts
+var MockSocket = class extends net.Socket {
+	constructor(options) {
+		super();
+		this.options = options;
+		this.connecting = false;
+		this.connect();
+		this._final = (callback) => {
+			callback(null);
+		};
+	}
+	connect() {
+		this.connecting = true;
+		return this;
+	}
+	write(...args) {
+		const [chunk, encoding, callback] = normalizeSocketWriteArgs(args);
+		this.options.write(chunk, encoding, callback);
+		return true;
+	}
+	end(...args) {
+		const [chunk, encoding, callback] = normalizeSocketWriteArgs(args);
+		this.options.write(chunk, encoding, callback);
+		return super.end.apply(this, args);
+	}
+	push(chunk, encoding) {
+		this.options.read(chunk, encoding);
+		return super.push(chunk, encoding);
+	}
+};
+
+//#endregion
+//#region src/interceptors/Socket/utils/baseUrlFromConnectionOptions.ts
+function baseUrlFromConnectionOptions(options) {
+	if ("href" in options) return new URL(options.href);
+	const protocol = options.port === 443 ? "https:" : "http:";
+	const host = options.host;
+	const url = new URL(`${protocol}//${host}`);
+	if (options.port) url.port = options.port.toString();
+	if (options.path) url.pathname = options.path;
+	if (options.auth) {
+		const [username, password] = options.auth.split(":");
+		url.username = username;
+		url.password = password;
+	}
+	return url;
+}
+
+//#endregion
+//#region src/interceptors/ClientRequest/utils/recordRawHeaders.ts
+const kRawHeaders = Symbol("kRawHeaders");
+const kRestorePatches = Symbol("kRestorePatches");
+function recordRawHeader(headers, args, behavior) {
+	ensureRawHeadersSymbol(headers, []);
+	const rawHeaders = Reflect.get(headers, kRawHeaders);
+	if (behavior === "set") {
+		for (let index = rawHeaders.length - 1; index >= 0; index--) if (rawHeaders[index][0].toLowerCase() === args[0].toLowerCase()) rawHeaders.splice(index, 1);
+	}
+	rawHeaders.push(args);
+}
+/**
+* Define the raw headers symbol on the given `Headers` instance.
+* If the symbol already exists, this function does nothing.
+*/
+function ensureRawHeadersSymbol(headers, rawHeaders) {
+	if (Reflect.has(headers, kRawHeaders)) return;
+	defineRawHeadersSymbol(headers, rawHeaders);
+}
+/**
+* Define the raw headers symbol on the given `Headers` instance.
+* If the symbol already exists, it gets overridden.
+*/
+function defineRawHeadersSymbol(headers, rawHeaders) {
+	Object.defineProperty(headers, kRawHeaders, {
+		value: rawHeaders,
+		enumerable: false,
+		configurable: true
+	});
+}
+/**
+* Patch the global `Headers` class to store raw headers.
+* This is for compatibility with `IncomingMessage.prototype.rawHeaders`.
+*
+* @note Node.js has their own raw headers symbol but it
+* only records the first header name in case of multi-value headers.
+* Any other headers are normalized before comparing. This makes it
+* incompatible with the `rawHeaders` format.
+*
+* let h = new Headers()
+* h.append('X-Custom', 'one')
+* h.append('x-custom', 'two')
+* h[Symbol('headers map')] // Map { 'X-Custom' => 'one, two' }
+*/
+function recordRawFetchHeaders() {
+	if (Reflect.get(Headers, kRestorePatches)) return Reflect.get(Headers, kRestorePatches);
+	const { Headers: OriginalHeaders, Request: OriginalRequest, Response: OriginalResponse } = globalThis;
+	const { set, append, delete: headersDeleteMethod } = Headers.prototype;
+	Object.defineProperty(Headers, kRestorePatches, {
+		value: () => {
+			Headers.prototype.set = set;
+			Headers.prototype.append = append;
+			Headers.prototype.delete = headersDeleteMethod;
+			globalThis.Headers = OriginalHeaders;
+			globalThis.Request = OriginalRequest;
+			globalThis.Response = OriginalResponse;
+			Reflect.deleteProperty(Headers, kRestorePatches);
+		},
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(globalThis, "Headers", {
+		enumerable: true,
+		writable: true,
+		value: new Proxy(Headers, { construct(target, args, newTarget) {
+			const headersInit = args[0] || [];
+			if (headersInit instanceof Headers && Reflect.has(headersInit, kRawHeaders)) {
+				const headers$1 = Reflect.construct(target, [Reflect.get(headersInit, kRawHeaders)], newTarget);
+				ensureRawHeadersSymbol(headers$1, [...Reflect.get(headersInit, kRawHeaders)]);
+				return headers$1;
+			}
+			const headers = Reflect.construct(target, args, newTarget);
+			if (!Reflect.has(headers, kRawHeaders)) ensureRawHeadersSymbol(headers, Array.isArray(headersInit) ? headersInit : Object.entries(headersInit));
+			return headers;
+		} })
+	});
+	Headers.prototype.set = new Proxy(Headers.prototype.set, { apply(target, thisArg, args) {
+		recordRawHeader(thisArg, args, "set");
+		return Reflect.apply(target, thisArg, args);
+	} });
+	Headers.prototype.append = new Proxy(Headers.prototype.append, { apply(target, thisArg, args) {
+		recordRawHeader(thisArg, args, "append");
+		return Reflect.apply(target, thisArg, args);
+	} });
+	Headers.prototype.delete = new Proxy(Headers.prototype.delete, { apply(target, thisArg, args) {
+		const rawHeaders = Reflect.get(thisArg, kRawHeaders);
+		if (rawHeaders) {
+			for (let index = rawHeaders.length - 1; index >= 0; index--) if (rawHeaders[index][0].toLowerCase() === args[0].toLowerCase()) rawHeaders.splice(index, 1);
+		}
+		return Reflect.apply(target, thisArg, args);
+	} });
+	Object.defineProperty(globalThis, "Request", {
+		enumerable: true,
+		writable: true,
+		value: new Proxy(Request, { construct(target, args, newTarget) {
+			const request = Reflect.construct(target, args, newTarget);
+			const inferredRawHeaders = [];
+			if (typeof args[0] === "object" && args[0].headers != null) inferredRawHeaders.push(...inferRawHeaders(args[0].headers));
+			if (typeof args[1] === "object" && args[1].headers != null) inferredRawHeaders.push(...inferRawHeaders(args[1].headers));
+			if (inferredRawHeaders.length > 0) ensureRawHeadersSymbol(request.headers, inferredRawHeaders);
+			return request;
+		} })
+	});
+	Object.defineProperty(globalThis, "Response", {
+		enumerable: true,
+		writable: true,
+		value: new Proxy(Response, { construct(target, args, newTarget) {
+			const response = Reflect.construct(target, args, newTarget);
+			if (typeof args[1] === "object" && args[1].headers != null) ensureRawHeadersSymbol(response.headers, inferRawHeaders(args[1].headers));
+			return response;
+		} })
+	});
+}
+function restoreHeadersPrototype() {
+	if (!Reflect.get(Headers, kRestorePatches)) return;
+	Reflect.get(Headers, kRestorePatches)();
+}
+function getRawFetchHeaders(headers) {
+	if (!Reflect.has(headers, kRawHeaders)) return Array.from(headers.entries());
+	const rawHeaders = Reflect.get(headers, kRawHeaders);
+	return rawHeaders.length > 0 ? rawHeaders : Array.from(headers.entries());
+}
+/**
+* Infers the raw headers from the given `HeadersInit` provided
+* to the Request/Response constructor.
+*
+* If the `init.headers` is a Headers instance, use it directly.
+* That means the headers were created standalone and already have
+* the raw headers stored.
+* If the `init.headers` is a HeadersInit, create a new Headers
+* instance out of it.
+*/
+function inferRawHeaders(headers) {
+	if (headers instanceof Headers) return Reflect.get(headers, kRawHeaders) || [];
+	return Reflect.get(new Headers(headers), kRawHeaders);
+}
+
+//#endregion
+//#region src/interceptors/ClientRequest/utils/parserUtils.ts
+/**
+* @see https://github.com/nodejs/node/blob/f3adc11e37b8bfaaa026ea85c1cf22e3a0e29ae9/lib/_http_common.js#L180
+*/
+function freeParser(parser, socket) {
+	if (parser._consumed) parser.unconsume();
+	parser._headers = [];
+	parser._url = "";
+	parser.socket = null;
+	parser.incoming = null;
+	parser.outgoing = null;
+	parser.maxHeaderPairs = 2e3;
+	parser._consumed = false;
+	parser.onIncoming = null;
+	parser[HTTPParser.kOnHeaders] = null;
+	parser[HTTPParser.kOnHeadersComplete] = null;
+	parser[HTTPParser.kOnMessageBegin] = null;
+	parser[HTTPParser.kOnMessageComplete] = null;
+	parser[HTTPParser.kOnBody] = null;
+	parser[HTTPParser.kOnExecute] = null;
+	parser[HTTPParser.kOnTimeout] = null;
+	parser.remove();
+	parser.free();
+	if (socket)
+ /**
+	* @note Unassigning the socket's parser will fail this assertion
+	* if there's still some data being processed on the socket:
+	* @see https://github.com/nodejs/node/blob/4e1f39b678b37017ac9baa0971e3aeecd3b67b51/lib/_http_client.js#L613
+	*/
+	if (socket.destroyed) socket.parser = null;
+	else socket.once("end", () => {
+		socket.parser = null;
+	});
+}
+
+//#endregion
+//#region src/interceptors/ClientRequest/MockHttpSocket.ts
+const kRequestId = Symbol("kRequestId");
+var MockHttpSocket = class extends MockSocket {
+	constructor(options) {
+		super({
+			write: (chunk, encoding, callback) => {
+				if (this.socketState !== "passthrough") this.writeBuffer.push([
+					chunk,
+					encoding,
+					callback
+				]);
+				if (chunk) {
+					/**
+					* Forward any writes to the mock socket to the underlying original socket.
+					* This ensures functional duplex connections, like WebSocket.
+					* @see https://github.com/mswjs/interceptors/issues/682
+					*/
+					if (this.socketState === "passthrough") this.originalSocket?.write(chunk, encoding, callback);
+					this.requestParser.execute(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding));
+				}
+			},
+			read: (chunk) => {
+				if (chunk !== null)
+ /**
+				* @todo We need to free the parser if the connection has been
+				* upgraded to a non-HTTP protocol. It won't be able to parse data
+				* from that point onward anyway. No need to keep it in memory.
+				*/
+				this.responseParser.execute(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+			}
+		});
+		this.requestRawHeadersBuffer = [];
+		this.responseRawHeadersBuffer = [];
+		this.writeBuffer = [];
+		this.socketState = "unknown";
+		this.onRequestHeaders = (rawHeaders) => {
+			this.requestRawHeadersBuffer.push(...rawHeaders);
+		};
+		this.onRequestStart = (versionMajor, versionMinor, rawHeaders, _, path, __, ___, ____, shouldKeepAlive) => {
+			this.shouldKeepAlive = shouldKeepAlive;
+			const url = new URL(path || "", this.baseUrl);
+			const method = this.connectionOptions.method?.toUpperCase() || "GET";
+			const headers = FetchResponse.parseRawHeaders([...this.requestRawHeadersBuffer, ...rawHeaders || []]);
+			this.requestRawHeadersBuffer.length = 0;
+			const canHaveBody = method !== "GET" && method !== "HEAD";
+			if (url.username || url.password) {
+				if (!headers.has("authorization")) headers.set("authorization", `Basic ${url.username}:${url.password}`);
+				url.username = "";
+				url.password = "";
+			}
+			this.requestStream = new Readable({ read: () => {
+				this.flushWriteBuffer();
+			} });
+			const requestId = createRequestId();
+			this.request = new Request(url, {
+				method,
+				headers,
+				credentials: "same-origin",
+				duplex: canHaveBody ? "half" : void 0,
+				body: canHaveBody ? Readable.toWeb(this.requestStream) : null
+			});
+			Reflect.set(this.request, kRequestId, requestId);
+			setRawRequest(this.request, Reflect.get(this, "_httpMessage"));
+			setRawRequestBodyStream(this.request, this.requestStream);
+			/**
+			* @fixme Stop relying on the "X-Request-Id" request header
+			* to figure out if one interceptor has been invoked within another.
+			* @see https://github.com/mswjs/interceptors/issues/378
+			*/
+			if (this.request.headers.has(INTERNAL_REQUEST_ID_HEADER_NAME)) {
+				this.passthrough();
+				return;
+			}
+			this.onRequest({
+				requestId,
+				request: this.request,
+				socket: this
+			});
+		};
+		this.onResponseHeaders = (rawHeaders) => {
+			this.responseRawHeadersBuffer.push(...rawHeaders);
+		};
+		this.onResponseStart = (versionMajor, versionMinor, rawHeaders, method, url, status, statusText) => {
+			const headers = FetchResponse.parseRawHeaders([...this.responseRawHeadersBuffer, ...rawHeaders || []]);
+			this.responseRawHeadersBuffer.length = 0;
+			const response = new FetchResponse(
+				/**
+				* @note The Fetch API response instance exposed to the consumer
+				* is created over the response stream of the HTTP parser. It is NOT
+				* related to the Socket instance. This way, you can read response body
+				* in response listener while the Socket instance delays the emission
+				* of "end" and other events until those response listeners are finished.
+				*/
+				FetchResponse.isResponseWithBody(status) ? Readable.toWeb(this.responseStream = new Readable({ read() {} })) : null,
+				{
+					url,
+					status,
+					statusText,
+					headers
+				}
+			);
+			invariant(this.request, "Failed to handle a response: request does not exist");
+			FetchResponse.setUrl(this.request.url, response);
+			/**
+			* @fixme Stop relying on the "X-Request-Id" request header
+			* to figure out if one interceptor has been invoked within another.
+			* @see https://github.com/mswjs/interceptors/issues/378
+			*/
+			if (this.request.headers.has(INTERNAL_REQUEST_ID_HEADER_NAME)) return;
+			this.responseListenersPromise = this.onResponse({
+				response,
+				isMockedResponse: this.socketState === "mock",
+				requestId: Reflect.get(this.request, kRequestId),
+				request: this.request,
+				socket: this
+			});
+		};
+		this.connectionOptions = options.connectionOptions;
+		this.createConnection = options.createConnection;
+		this.onRequest = options.onRequest;
+		this.onResponse = options.onResponse;
+		this.baseUrl = baseUrlFromConnectionOptions(this.connectionOptions);
+		this.requestParser = new HTTPParser();
+		this.requestParser.initialize(HTTPParser.REQUEST, {});
+		this.requestParser[HTTPParser.kOnHeaders] = this.onRequestHeaders.bind(this);
+		this.requestParser[HTTPParser.kOnHeadersComplete] = this.onRequestStart.bind(this);
+		this.requestParser[HTTPParser.kOnBody] = this.onRequestBody.bind(this);
+		this.requestParser[HTTPParser.kOnMessageComplete] = this.onRequestEnd.bind(this);
+		this.responseParser = new HTTPParser();
+		this.responseParser.initialize(HTTPParser.RESPONSE, {});
+		this.responseParser[HTTPParser.kOnHeaders] = this.onResponseHeaders.bind(this);
+		this.responseParser[HTTPParser.kOnHeadersComplete] = this.onResponseStart.bind(this);
+		this.responseParser[HTTPParser.kOnBody] = this.onResponseBody.bind(this);
+		this.responseParser[HTTPParser.kOnMessageComplete] = this.onResponseEnd.bind(this);
+		this.once("finish", () => freeParser(this.requestParser, this));
+		if (this.baseUrl.protocol === "https:") {
+			Reflect.set(this, "encrypted", true);
+			Reflect.set(this, "authorized", false);
+			Reflect.set(this, "getProtocol", () => "TLSv1.3");
+			Reflect.set(this, "getSession", () => void 0);
+			Reflect.set(this, "isSessionReused", () => false);
+			Reflect.set(this, "getCipher", () => ({
+				name: "AES256-SHA",
+				standardName: "TLS_RSA_WITH_AES_256_CBC_SHA",
+				version: "TLSv1.3"
+			}));
+		}
+	}
+	emit(event, ...args) {
+		const emitEvent = super.emit.bind(this, event, ...args);
+		if (this.responseListenersPromise) {
+			this.responseListenersPromise.finally(emitEvent);
+			return this.listenerCount(event) > 0;
+		}
+		return emitEvent();
+	}
+	destroy(error) {
+		freeParser(this.responseParser, this);
+		if (error) this.emit("error", error);
+		return super.destroy(error);
+	}
+	/**
+	* Establish this Socket connection as-is and pipe
+	* its data/events through this Socket.
+	*/
+	passthrough() {
+		this.socketState = "passthrough";
+		if (this.destroyed) return;
+		const socket = this.createConnection();
+		this.originalSocket = socket;
+		/**
+		* @note Inherit the original socket's connection handle.
+		* Without this, each push to the mock socket results in a
+		* new "connection" listener being added (i.e. buffering pushes).
+		* @see https://github.com/nodejs/node/blob/b18153598b25485ce4f54d0c5cb830a9457691ee/lib/net.js#L734
+		*/
+		if ("_handle" in socket) Object.defineProperty(this, "_handle", {
+			value: socket._handle,
+			enumerable: true,
+			writable: true
+		});
+		this.once("close", () => {
+			socket.removeAllListeners();
+			if (!socket.destroyed) socket.destroy();
+			this.originalSocket = void 0;
+		});
+		this.address = socket.address.bind(socket);
+		let writeArgs;
+		let headersWritten = false;
+		while (writeArgs = this.writeBuffer.shift()) if (writeArgs !== void 0) {
+			if (!headersWritten) {
+				const [chunk, encoding, callback] = writeArgs;
+				const chunkString = chunk.toString();
+				const chunkBeforeRequestHeaders = chunkString.slice(0, chunkString.indexOf("\r\n") + 2);
+				const chunkAfterRequestHeaders = chunkString.slice(chunk.indexOf("\r\n\r\n"));
+				const headersChunk = `${chunkBeforeRequestHeaders}${getRawFetchHeaders(this.request.headers).filter(([name]) => {
+					return name.toLowerCase() !== INTERNAL_REQUEST_ID_HEADER_NAME;
+				}).map(([name, value]) => `${name}: ${value}`).join("\r\n")}${chunkAfterRequestHeaders}`;
+				socket.write(headersChunk, encoding, callback);
+				headersWritten = true;
+				continue;
+			}
+			socket.write(...writeArgs);
+		}
+		if (Reflect.get(socket, "encrypted")) [
+			"encrypted",
+			"authorized",
+			"getProtocol",
+			"getSession",
+			"isSessionReused",
+			"getCipher"
+		].forEach((propertyName) => {
+			Object.defineProperty(this, propertyName, {
+				enumerable: true,
+				get: () => {
+					const value = Reflect.get(socket, propertyName);
+					return typeof value === "function" ? value.bind(socket) : value;
+				}
+			});
+		});
+		socket.on("lookup", (...args) => this.emit("lookup", ...args)).on("connect", () => {
+			this.connecting = socket.connecting;
+			this.emit("connect");
+		}).on("secureConnect", () => this.emit("secureConnect")).on("secure", () => this.emit("secure")).on("session", (session) => this.emit("session", session)).on("ready", () => this.emit("ready")).on("drain", () => this.emit("drain")).on("data", (chunk) => {
+			this.push(chunk);
+		}).on("error", (error) => {
+			Reflect.set(this, "_hadError", Reflect.get(socket, "_hadError"));
+			this.emit("error", error);
+		}).on("resume", () => this.emit("resume")).on("timeout", () => this.emit("timeout")).on("prefinish", () => this.emit("prefinish")).on("finish", () => this.emit("finish")).on("close", (hadError) => this.emit("close", hadError)).on("end", () => this.emit("end"));
+	}
+	/**
+	* Convert the given Fetch API `Response` instance to an
+	* HTTP message and push it to the socket.
+	*/
+	async respondWith(response) {
+		if (this.destroyed) return;
+		invariant(this.socketState !== "mock", "[MockHttpSocket] Failed to respond to the \"%s %s\" request with \"%s %s\": the request has already been handled", this.request?.method, this.request?.url, response.status, response.statusText);
+		if (isPropertyAccessible(response, "type") && response.type === "error") {
+			this.errorWith(/* @__PURE__ */ new TypeError("Network error"));
+			return;
+		}
+		this.mockConnect();
+		this.socketState = "mock";
+		this.flushWriteBuffer();
+		const serverResponse = new ServerResponse(new IncomingMessage(this));
+		/**
+		* Assign a mock socket instance to the server response to
+		* spy on the response chunk writes. Push the transformed response chunks
+		* to this `MockHttpSocket` instance to trigger the "data" event.
+		* @note Providing the same `MockSocket` instance when creating `ServerResponse`
+		* does not have the same effect.
+		* @see https://github.com/nodejs/node/blob/10099bb3f7fd97bb9dd9667188426866b3098e07/test/parallel/test-http-server-response-standalone.js#L32
+		*/
+		serverResponse.assignSocket(new MockSocket({
+			write: (chunk, encoding, callback) => {
+				this.push(chunk, encoding);
+				callback?.();
+			},
+			read() {}
+		}));
+		/**
+		* @note Remove the `Connection` and `Date` response headers
+		* injected by `ServerResponse` by default. Those are required
+		* from the server but the interceptor is NOT technically a server.
+		* It's confusing to add response headers that the developer didn't
+		* specify themselves. They can always add these if they wish.
+		* @see https://www.rfc-editor.org/rfc/rfc9110#field.date
+		* @see https://www.rfc-editor.org/rfc/rfc9110#field.connection
+		*/
+		serverResponse.removeHeader("connection");
+		serverResponse.removeHeader("date");
+		const rawResponseHeaders = getRawFetchHeaders(response.headers);
+		/**
+		* @note Call `.writeHead` in order to set the raw response headers
+		* in the same case as they were provided by the developer. Using
+		* `.setHeader()`/`.appendHeader()` normalizes header names.
+		*/
+		serverResponse.writeHead(response.status, response.statusText || STATUS_CODES[response.status], rawResponseHeaders);
+		this.once("error", () => {
+			serverResponse.destroy();
+		});
+		if (response.body) try {
+			const reader = response.body.getReader();
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					serverResponse.end();
+					break;
+				}
+				serverResponse.write(value);
+			}
+		} catch (error) {
+			if (error instanceof Error) {
+				serverResponse.destroy();
+				/**
+				* @note Destroy the request socket gracefully.
+				* Response stream errors do NOT produce request errors.
+				*/
+				this.destroy();
+				return;
+			}
+			serverResponse.destroy();
+			throw error;
+		}
+		else serverResponse.end();
+		if (!this.shouldKeepAlive) {
+			this.emit("readable");
+			/**
+			* @todo @fixme This is likely a hack.
+			* Since we push null to the socket, it never propagates to the
+			* parser, and the parser never calls "onResponseEnd" to close
+			* the response stream. We are closing the stream here manually
+			* but that shouldn't be the case.
+			*/
+			this.responseStream?.push(null);
+			this.push(null);
+		}
+	}
+	/**
+	* Close this socket connection with the given error.
+	*/
+	errorWith(error) {
+		this.destroy(error);
+	}
+	mockConnect() {
+		this.connecting = false;
+		const isIPv6 = net.isIPv6(this.connectionOptions.hostname) || this.connectionOptions.family === 6;
+		const addressInfo = {
+			address: isIPv6 ? "::1" : "127.0.0.1",
+			family: isIPv6 ? "IPv6" : "IPv4",
+			port: this.connectionOptions.port
+		};
+		this.address = () => addressInfo;
+		this.emit("lookup", null, addressInfo.address, addressInfo.family === "IPv6" ? 6 : 4, this.connectionOptions.host);
+		this.emit("connect");
+		this.emit("ready");
+		if (this.baseUrl.protocol === "https:") {
+			this.emit("secure");
+			this.emit("secureConnect");
+			this.emit("session", this.connectionOptions.session || Buffer.from("mock-session-renegotiate"));
+			this.emit("session", Buffer.from("mock-session-resume"));
+		}
+	}
+	flushWriteBuffer() {
+		for (const writeCall of this.writeBuffer) if (typeof writeCall[2] === "function") {
+			writeCall[2]();
+			/**
+			* @note Remove the callback from the write call
+			* so it doesn't get called twice on passthrough
+			* if `request.end()` was called within `request.write()`.
+			* @see https://github.com/mswjs/interceptors/issues/684
+			*/
+			writeCall[2] = void 0;
+		}
+	}
+	onRequestBody(chunk) {
+		invariant(this.requestStream, "Failed to write to a request stream: stream does not exist");
+		this.requestStream.push(chunk);
+	}
+	onRequestEnd() {
+		if (this.requestStream) this.requestStream.push(null);
+	}
+	onResponseBody(chunk) {
+		invariant(this.responseStream, "Failed to write to a response stream: stream does not exist");
+		this.responseStream.push(chunk);
+	}
+	onResponseEnd() {
+		if (this.responseStream) this.responseStream.push(null);
+	}
+};
+
+//#endregion
+//#region src/interceptors/ClientRequest/agents.ts
+var MockAgent = class extends http.Agent {
+	constructor(options) {
+		super();
+		this.customAgent = options.customAgent;
+		this.onRequest = options.onRequest;
+		this.onResponse = options.onResponse;
+	}
+	createConnection(options, callback) {
+		const createConnection = this.customAgent instanceof http.Agent ? this.customAgent.createConnection : super.createConnection;
+		const createConnectionOptions = this.customAgent instanceof http.Agent ? {
+			...options,
+			...this.customAgent.options
+		} : options;
+		return new MockHttpSocket({
+			connectionOptions: options,
+			createConnection: createConnection.bind(this.customAgent || this, createConnectionOptions, callback),
+			onRequest: this.onRequest.bind(this),
+			onResponse: this.onResponse.bind(this)
+		});
+	}
+};
+var MockHttpsAgent = class extends https.Agent {
+	constructor(options) {
+		super();
+		this.customAgent = options.customAgent;
+		this.onRequest = options.onRequest;
+		this.onResponse = options.onResponse;
+	}
+	createConnection(options, callback) {
+		const createConnection = this.customAgent instanceof http.Agent ? this.customAgent.createConnection : super.createConnection;
+		const createConnectionOptions = this.customAgent instanceof http.Agent ? {
+			...options,
+			...this.customAgent.options
+		} : options;
+		return new MockHttpSocket({
+			connectionOptions: options,
+			createConnection: createConnection.bind(this.customAgent || this, createConnectionOptions, callback),
+			onRequest: this.onRequest.bind(this),
+			onResponse: this.onResponse.bind(this)
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/getUrlByRequestOptions.ts
+const logger$2 = new Logger("utils getUrlByRequestOptions");
+const DEFAULT_PATH = "/";
+const DEFAULT_PROTOCOL = "http:";
+const DEFAULT_HOSTNAME = "localhost";
+const SSL_PORT = 443;
+function getAgent(options) {
+	return options.agent instanceof Agent ? options.agent : void 0;
+}
+function getProtocolByRequestOptions(options) {
+	if (options.protocol) return options.protocol;
+	const agentProtocol = getAgent(options)?.protocol;
+	if (agentProtocol) return agentProtocol;
+	const port = getPortByRequestOptions(options);
+	return options.cert || port === SSL_PORT ? "https:" : options.uri?.protocol || DEFAULT_PROTOCOL;
+}
+function getPortByRequestOptions(options) {
+	if (options.port) return Number(options.port);
+	const agent = getAgent(options);
+	if (agent?.options.port) return Number(agent.options.port);
+	if (agent?.defaultPort) return Number(agent.defaultPort);
+}
+function getAuthByRequestOptions(options) {
+	if (options.auth) {
+		const [username, password] = options.auth.split(":");
+		return {
+			username,
+			password
+		};
+	}
+}
+/**
+* Returns true if host looks like an IPv6 address without surrounding brackets
+* It assumes any host containing `:` is definitely not IPv4 and probably IPv6,
+* but note that this could include invalid IPv6 addresses as well.
+*/
+function isRawIPv6Address(host) {
+	return host.includes(":") && !host.startsWith("[") && !host.endsWith("]");
+}
+function getHostname(options) {
+	let host = options.hostname || options.host;
+	if (host) {
+		if (isRawIPv6Address(host)) host = `[${host}]`;
+		return new URL(`http://${host}`).hostname;
+	}
+	return DEFAULT_HOSTNAME;
+}
+/**
+* Creates a `URL` instance from a given `RequestOptions` object.
+*/
+function getUrlByRequestOptions(options) {
+	logger$2.info("request options", options);
+	if (options.uri) {
+		logger$2.info("constructing url from explicitly provided \"options.uri\": %s", options.uri);
+		return new URL(options.uri.href);
+	}
+	logger$2.info("figuring out url from request options...");
+	const protocol = getProtocolByRequestOptions(options);
+	logger$2.info("protocol", protocol);
+	const port = getPortByRequestOptions(options);
+	logger$2.info("port", port);
+	const hostname = getHostname(options);
+	logger$2.info("hostname", hostname);
+	const path = options.path || DEFAULT_PATH;
+	logger$2.info("path", path);
+	const credentials = getAuthByRequestOptions(options);
+	logger$2.info("credentials", credentials);
+	const authString = credentials ? `${credentials.username}:${credentials.password}@` : "";
+	logger$2.info("auth string:", authString);
+	const portString = typeof port !== "undefined" ? `:${port}` : "";
+	const url = new URL(`${protocol}//${hostname}${portString}${path}`);
+	url.username = credentials?.username || "";
+	url.password = credentials?.password || "";
+	logger$2.info("created url:", url);
+	return url;
+}
+
+//#endregion
+//#region src/utils/cloneObject.ts
+const logger$1 = new Logger("cloneObject");
+function isPlainObject(obj) {
+	logger$1.info("is plain object?", obj);
+	if (obj == null || !obj.constructor?.name) {
+		logger$1.info("given object is undefined, not a plain object...");
+		return false;
+	}
+	logger$1.info("checking the object constructor:", obj.constructor.name);
+	return obj.constructor.name === "Object";
+}
+function cloneObject(obj) {
+	logger$1.info("cloning object:", obj);
+	const enumerableProperties = Object.entries(obj).reduce((acc, [key, value]) => {
+		logger$1.info("analyzing key-value pair:", key, value);
+		acc[key] = isPlainObject(value) ? cloneObject(value) : value;
+		return acc;
+	}, {});
+	return isPlainObject(obj) ? enumerableProperties : Object.assign(Object.getPrototypeOf(obj), enumerableProperties);
+}
+
+//#endregion
+//#region src/interceptors/ClientRequest/utils/normalizeClientRequestArgs.ts
+const logger = new Logger("http normalizeClientRequestArgs");
+function resolveRequestOptions(args, url) {
+	if (typeof args[1] === "undefined" || typeof args[1] === "function") {
+		logger.info("request options not provided, deriving from the url", url);
+		return urlToHttpOptions(url);
+	}
+	if (args[1]) {
+		logger.info("has custom RequestOptions!", args[1]);
+		const requestOptionsFromUrl = urlToHttpOptions(url);
+		logger.info("derived RequestOptions from the URL:", requestOptionsFromUrl);
+		/**
+		* Clone the request options to lock their state
+		* at the moment they are provided to `ClientRequest`.
+		* @see https://github.com/mswjs/interceptors/issues/86
+		*/
+		logger.info("cloning RequestOptions...");
+		const clonedRequestOptions = cloneObject(args[1]);
+		logger.info("successfully cloned RequestOptions!", clonedRequestOptions);
+		return {
+			...requestOptionsFromUrl,
+			...clonedRequestOptions
+		};
+	}
+	logger.info("using an empty object as request options");
+	return {};
+}
+/**
+* Overrides the given `URL` instance with the explicit properties provided
+* on the `RequestOptions` object. The options object takes precedence,
+* and will replace URL properties like "host", "path", and "port", if specified.
+*/
+function overrideUrlByRequestOptions(url, options) {
+	url.host = options.host || url.host;
+	url.hostname = options.hostname || url.hostname;
+	url.port = options.port ? options.port.toString() : url.port;
+	if (options.path) {
+		const parsedOptionsPath = parse(options.path, false);
+		url.pathname = parsedOptionsPath.pathname || "";
+		url.search = parsedOptionsPath.search || "";
+	}
+	return url;
+}
+function resolveCallback(args) {
+	return typeof args[1] === "function" ? args[1] : args[2];
+}
+/**
+* Normalizes parameters given to a `http.request` call
+* so it always has a `URL` and `RequestOptions`.
+*/
+function normalizeClientRequestArgs(defaultProtocol, args) {
+	let url;
+	let options;
+	let callback;
+	logger.info("arguments", args);
+	logger.info("using default protocol:", defaultProtocol);
+	if (args.length === 0) {
+		const url$1 = new URL$1("http://localhost");
+		return [url$1, resolveRequestOptions(args, url$1)];
+	}
+	if (typeof args[0] === "string") {
+		logger.info("first argument is a location string:", args[0]);
+		url = new URL$1(args[0]);
+		logger.info("created a url:", url);
+		const requestOptionsFromUrl = urlToHttpOptions(url);
+		logger.info("request options from url:", requestOptionsFromUrl);
+		options = resolveRequestOptions(args, url);
+		logger.info("resolved request options:", options);
+		callback = resolveCallback(args);
+	} else if (args[0] instanceof URL$1) {
+		url = args[0];
+		logger.info("first argument is a URL:", url);
+		if (typeof args[1] !== "undefined" && isObject(args[1])) url = overrideUrlByRequestOptions(url, args[1]);
+		options = resolveRequestOptions(args, url);
+		logger.info("derived request options:", options);
+		callback = resolveCallback(args);
+	} else if ("hash" in args[0] && !("method" in args[0])) {
+		const [legacyUrl] = args;
+		logger.info("first argument is a legacy URL:", legacyUrl);
+		if (legacyUrl.hostname === null) {
+			/**
+			* We are dealing with a relative url, so use the path as an "option" and
+			* merge in any existing options, giving priority to existing options -- i.e. a path in any
+			* existing options will take precedence over the one contained in the url. This is consistent
+			* with the behaviour in ClientRequest.
+			* @see https://github.com/nodejs/node/blob/d84f1312915fe45fe0febe888db692c74894c382/lib/_http_client.js#L122
+			*/
+			logger.info("given legacy URL is relative (no hostname)");
+			return isObject(args[1]) ? normalizeClientRequestArgs(defaultProtocol, [{
+				path: legacyUrl.path,
+				...args[1]
+			}, args[2]]) : normalizeClientRequestArgs(defaultProtocol, [{ path: legacyUrl.path }, args[1]]);
+		}
+		logger.info("given legacy url is absolute");
+		const resolvedUrl = new URL$1(legacyUrl.href);
+		return args[1] === void 0 ? normalizeClientRequestArgs(defaultProtocol, [resolvedUrl]) : typeof args[1] === "function" ? normalizeClientRequestArgs(defaultProtocol, [resolvedUrl, args[1]]) : normalizeClientRequestArgs(defaultProtocol, [
+			resolvedUrl,
+			args[1],
+			args[2]
+		]);
+	} else if (isObject(args[0])) {
+		options = { ...args[0] };
+		logger.info("first argument is RequestOptions:", options);
+		options.protocol = options.protocol || defaultProtocol;
+		logger.info("normalized request options:", options);
+		url = getUrlByRequestOptions(options);
+		logger.info("created a URL from RequestOptions:", url.href);
+		callback = resolveCallback(args);
+	} else throw new Error(`Failed to construct ClientRequest with these parameters: ${args}`);
+	options.protocol = options.protocol || url.protocol;
+	options.method = options.method || "GET";
+	/**
+	* Ensure that the default Agent is always set.
+	* This prevents the protocol mismatch for requests with { agent: false },
+	* where the global Agent is inferred.
+	* @see https://github.com/mswjs/msw/issues/1150
+	* @see https://github.com/nodejs/node/blob/418ff70b810f0e7112d48baaa72932a56cfa213b/lib/_http_client.js#L130
+	* @see https://github.com/nodejs/node/blob/418ff70b810f0e7112d48baaa72932a56cfa213b/lib/_http_client.js#L157-L159
+	*/
+	if (!options._defaultAgent) {
+		logger.info("has no default agent, setting the default agent for \"%s\"", options.protocol);
+		options._defaultAgent = options.protocol === "https:" ? globalAgent$1 : globalAgent;
+	}
+	logger.info("successfully resolved url:", url.href);
+	logger.info("successfully resolved options:", options);
+	logger.info("successfully resolved callback:", callback);
+	/**
+	* @note If the user-provided URL is not a valid URL in Node.js,
+	* (e.g. the one provided by the JSDOM polyfills), case it to
+	* string. Otherwise, this throws on Node.js incompatibility
+	* (`ERR_INVALID_ARG_TYPE` on the connection listener)
+	* @see https://github.com/node-fetch/node-fetch/issues/1376#issuecomment-966435555
+	*/
+	if (!(url instanceof URL$1)) url = url.toString();
+	return [
+		url,
+		options,
+		callback
+	];
+}
+
+//#endregion
+//#region src/interceptors/ClientRequest/index.ts
+var ClientRequestInterceptor = class ClientRequestInterceptor extends Interceptor {
+	static {
+		this.symbol = Symbol("client-request-interceptor");
+	}
+	constructor() {
+		super(ClientRequestInterceptor.symbol);
+		this.onRequest = async ({ request, socket }) => {
+			const controller = new RequestController(request, {
+				passthrough() {
+					socket.passthrough();
+				},
+				async respondWith(response) {
+					await socket.respondWith(response);
+				},
+				errorWith(reason) {
+					if (reason instanceof Error) socket.errorWith(reason);
+				}
+			});
+			await handleRequest({
+				request,
+				requestId: Reflect.get(request, kRequestId),
+				controller,
+				emitter: this.emitter
+			});
+		};
+		this.onResponse = async ({ requestId, request, response, isMockedResponse }) => {
+			return emitAsync(this.emitter, "response", {
+				requestId,
+				request,
+				response,
+				isMockedResponse
+			});
+		};
+	}
+	setup() {
+		const { ClientRequest: OriginalClientRequest, get: originalGet, request: originalRequest } = http;
+		const { get: originalHttpsGet, request: originalHttpsRequest } = https;
+		const onRequest = this.onRequest.bind(this);
+		const onResponse = this.onResponse.bind(this);
+		http.ClientRequest = new Proxy(http.ClientRequest, { construct: (target, args) => {
+			const [url, options, callback] = normalizeClientRequestArgs("http:", args);
+			options.agent = new (options.protocol === "https:" ? MockHttpsAgent : MockAgent)({
+				customAgent: options.agent,
+				onRequest,
+				onResponse
+			});
+			return Reflect.construct(target, [
+				url,
+				options,
+				callback
+			]);
+		} });
+		http.request = new Proxy(http.request, { apply: (target, thisArg, args) => {
+			const [url, options, callback] = normalizeClientRequestArgs("http:", args);
+			options.agent = new MockAgent({
+				customAgent: options.agent,
+				onRequest,
+				onResponse
+			});
+			return Reflect.apply(target, thisArg, [
+				url,
+				options,
+				callback
+			]);
+		} });
+		http.get = new Proxy(http.get, { apply: (target, thisArg, args) => {
+			const [url, options, callback] = normalizeClientRequestArgs("http:", args);
+			options.agent = new MockAgent({
+				customAgent: options.agent,
+				onRequest,
+				onResponse
+			});
+			return Reflect.apply(target, thisArg, [
+				url,
+				options,
+				callback
+			]);
+		} });
+		https.request = new Proxy(https.request, { apply: (target, thisArg, args) => {
+			const [url, options, callback] = normalizeClientRequestArgs("https:", args);
+			options.agent = new MockHttpsAgent({
+				customAgent: options.agent,
+				onRequest,
+				onResponse
+			});
+			return Reflect.apply(target, thisArg, [
+				url,
+				options,
+				callback
+			]);
+		} });
+		https.get = new Proxy(https.get, { apply: (target, thisArg, args) => {
+			const [url, options, callback] = normalizeClientRequestArgs("https:", args);
+			options.agent = new MockHttpsAgent({
+				customAgent: options.agent,
+				onRequest,
+				onResponse
+			});
+			return Reflect.apply(target, thisArg, [
+				url,
+				options,
+				callback
+			]);
+		} });
+		recordRawFetchHeaders();
+		this.subscriptions.push(() => {
+			http.ClientRequest = OriginalClientRequest;
+			http.get = originalGet;
+			http.request = originalRequest;
+			https.get = originalHttpsGet;
+			https.request = originalHttpsRequest;
+			restoreHeadersPrototype();
+		});
+	}
+};
+
+//#endregion
+export { ClientRequestInterceptor as t };
+//# sourceMappingURL=ClientRequest-Ca8Qykuv.mjs.map