@mswjs/interceptors 0.41.8 → 0.42.0

package/lib/node/source-lP0yyEtA.js

@@ -0,0 +1,1990 @@
+import { a as createLogger, i as Interceptor, o as formatRequest, r as toBuffer } from "./buffer-utils-BvPY1Tc-.js";
+import { a as isResponseError, c as isObject, d as createRequestId, f as RequestController, l as getRawFetchHeaders, n as FetchResponse, o as isResponseLike, p as InterceptorError, r as createServerErrorResponse, s as kErrorResponse, t as FetchRequest, u as recordRawFetchHeaders } from "./fetch-utils-Dw1PsmtX.js";
+import { i as unwrapPendingData, n as SocketController, r as kRawSocket, t as SocketInterceptor } from "./net-DtMnyEeg.js";
+import { TypedEvent } from "rettime";
+import { invariant } from "outvariant";
+import { IncomingMessage, METHODS, STATUS_CODES, ServerResponse } from "node:http";
+import { AsyncLocalStorage } from "node:async_hooks";
+import net from "node:net";
+import tls from "node:tls";
+import { Readable } from "node:stream";
+import fs from "node:fs";
+import { until } from "@open-draft/until";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/request-context.ts
+const requestContext = new AsyncLocalStorage();
+function runInRequestContext(callback, logger) {
+	/**
+	* @note Never shadow an existing request context. Nested calls
+	* (e.g. a patched entry point re-entered synchronously, or a request
+	* made within the fetch/XMLHttpRequest interceptor context) must run
+	* within the parent context so the sockets they create capture it.
+	*/
+	if (requestContext.getStore()) return callback();
+	/**
+	* @note The initiator is the callback's return value (e.g. the
+	* "ClientRequest" instance), so it cannot be known before running
+	* the callback. The context is mutated in place once the callback
+	* returns; readers hold the context object by reference and sample
+	* "initiator" only after the request has been written.
+	*/
+	const context = {
+		initiator: void 0,
+		logger
+	};
+	return requestContext.run(context, () => {
+		const initiator = callback();
+		context.initiator = initiator;
+		return initiator;
+	});
+}
+//#endregion
+//#region src/interceptors/http/forward-events.ts
+const logger = createLogger("http-request");
+function forwardHttpEvents(options) {
+	const controller = new AbortController();
+	const { source, emitter, predicate, responsePredicate } = options;
+	source.on("request", async (event) => {
+		if (predicate(event.initiator)) {
+			logger.verbose("forwarding \"request\" event %o", { requestId: event.requestId });
+			await emitter.emitAsPromise(event);
+		}
+	}, { signal: controller.signal });
+	const responseListener = async (event) => {
+		if (predicate(event.initiator) && (responsePredicate == null || responsePredicate(event))) {
+			logger.verbose("forwarding \"response\" event %o", {
+				requestId: event.requestId,
+				responseType: event.responseType
+			});
+			await emitter.emitAsPromise(event);
+		}
+	};
+	const unhandledExceptionListener = async (event) => {
+		if (predicate(event.initiator)) {
+			logger.verbose("forwarding \"unhandledException\" event %o", { requestId: event.requestId });
+			await emitter.emitAsPromise(event);
+		}
+	};
+	const addResponseListener = () => {
+		if (!source.listeners("response").includes(responseListener)) source.on("response", responseListener, { signal: controller.signal });
+	};
+	const addUnhandledExceptionListener = () => {
+		if (!source.listeners("unhandledException").includes(unhandledExceptionListener)) source.on("unhandledException", unhandledExceptionListener, { signal: controller.signal });
+	};
+	if (emitter.listenerCount("response") > 0) addResponseListener();
+	if (emitter.listenerCount("unhandledException") > 0) addUnhandledExceptionListener();
+	emitter.hooks.on("newListener", (type) => {
+		if (type === "response") addResponseListener();
+		if (type === "unhandledException") addUnhandledExceptionListener();
+	}, {
+		signal: controller.signal,
+		persist: true
+	});
+	emitter.hooks.on("removeListener", (type) => {
+		if (type === "response" && emitter.listenerCount("response") === 0) source.removeListener("response", responseListener);
+		if (type === "unhandledException" && emitter.listenerCount("unhandledException") === 0) source.removeListener("unhandledException", unhandledExceptionListener);
+	}, {
+		signal: controller.signal,
+		persist: true
+	});
+	return () => {
+		controller.abort();
+	};
+}
+//#endregion
+//#region src/events/http.ts
+var HttpRequestEvent = class extends TypedEvent {
+	constructor(data) {
+		super(...["request", {}]);
+		this.request = data.request;
+		this.requestId = data.requestId;
+		this.initiator = data.initiator;
+		this.controller = data.controller;
+	}
+};
+var HttpResponseEvent = class extends TypedEvent {
+	constructor(data) {
+		super(...["response", {}]);
+		this.response = data.response;
+		this.responseType = data.responseType;
+		this.request = data.request;
+		this.requestId = data.requestId;
+		this.initiator = data.initiator;
+	}
+};
+var UnhandledHttpException = class extends TypedEvent {
+	constructor(data) {
+		super(...["unhandledException", {}]);
+		this.error = data.error;
+		this.request = data.request;
+		this.requestId = data.requestId;
+		this.initiator = data.initiator;
+		this.controller = data.controller;
+	}
+};
+//#endregion
+//#region src/interceptors/net/utils/connection-options-to-url.ts
+/**
+* Creates a `URL` instance out of the `net.connect()` options.
+* @note This implies that the passed connection is an HTTP connection.
+*/
+function connectionOptionsToUrl(options, socket) {
+	const isIPv6 = net.isIPv6(options.host || "");
+	const protocol = socket instanceof tls.TLSSocket ? "https:" : getProtocolByConnectionOptions(options);
+	const host = options.host || "localhost";
+	const url = new URL(`${protocol}//${isIPv6 ? `[${host}]` : host}`);
+	if (options.path) url.pathname = options.path;
+	if (options.port) url.port = options.port.toString();
+	if (options.auth) {
+		const [username, password] = options.auth.split(":");
+		/**
+		* Authentication options are provided as plain values.
+		* Encode them to form a valid URL.
+		* @see https://github.com/nodejs/node/blob/f3adc11e37b8bfaaa026ea85c1cf22e3a0e29ae9/lib/internal/url.js#L1452
+		*/
+		url.username = encodeURIComponent(username);
+		url.password = encodeURIComponent(password);
+	}
+	return url;
+}
+function getProtocolByConnectionOptions(options) {
+	if (options.protocol) return options.protocol;
+	if (options.port === 443) return "https:";
+	return "http:";
+}
+//#endregion
+//#region src/interceptors/http/http-parser/index.ts
+var import_constants = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SPECIAL_HEADERS = exports.MINOR = exports.MAJOR = exports.QDTEXT = exports.CONNECTION_TOKEN_CHARS = exports.RELAXED_HEADER_CHARS = exports.HEADER_CHARS = exports.HTAB_SP_VCHAR_OBS_TEXT = exports.SP = exports.HTAB = exports.TOKEN = exports.HEX = exports.URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.DIGIT = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.METHODS = exports.METHODS_HTTP = exports.METHODS_HTTP2 = exports.METHODS_HTTP1 = exports.METHODS_RTSP = exports.METHODS_RAOP = exports.METHODS_AIRPLAY = exports.METHODS_ICECAST = exports.METHODS_NON_STANDARD = exports.METHODS_CALDAV = exports.METHODS_UPNP = exports.METHODS_SUBVERSION = exports.METHODS_WEBDAV = exports.METHODS_BASIC_HTTP = exports.METHODS_HTTP1_HEAD = exports.HEADER_STATE = exports.FINISH = exports.STATUSES = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0;
+	exports.ERROR = {
+		OK: 0,
+		INTERNAL: 1,
+		STRICT: 2,
+		CR_EXPECTED: 25,
+		LF_EXPECTED: 3,
+		UNEXPECTED_CONTENT_LENGTH: 4,
+		UNEXPECTED_SPACE: 30,
+		CLOSED_CONNECTION: 5,
+		INVALID_METHOD: 6,
+		INVALID_URL: 7,
+		INVALID_CONSTANT: 8,
+		INVALID_VERSION: 9,
+		INVALID_HEADER_TOKEN: 10,
+		INVALID_CONTENT_LENGTH: 11,
+		INVALID_CHUNK_SIZE: 12,
+		INVALID_STATUS: 13,
+		INVALID_EOF_STATE: 14,
+		INVALID_TRANSFER_ENCODING: 15,
+		CB_MESSAGE_BEGIN: 16,
+		CB_HEADERS_COMPLETE: 17,
+		CB_MESSAGE_COMPLETE: 18,
+		CB_CHUNK_HEADER: 19,
+		CB_CHUNK_COMPLETE: 20,
+		PAUSED: 21,
+		PAUSED_UPGRADE: 22,
+		PAUSED_H2_UPGRADE: 23,
+		USER: 24,
+		CB_URL_COMPLETE: 26,
+		CB_STATUS_COMPLETE: 27,
+		CB_METHOD_COMPLETE: 32,
+		CB_VERSION_COMPLETE: 33,
+		CB_HEADER_FIELD_COMPLETE: 28,
+		CB_HEADER_VALUE_COMPLETE: 29,
+		CB_CHUNK_EXTENSION_NAME_COMPLETE: 34,
+		CB_CHUNK_EXTENSION_VALUE_COMPLETE: 35,
+		CB_RESET: 31,
+		CB_PROTOCOL_COMPLETE: 38
+	};
+	exports.TYPE = {
+		BOTH: 0,
+		REQUEST: 1,
+		RESPONSE: 2
+	};
+	exports.FLAGS = {
+		CONNECTION_KEEP_ALIVE: 1,
+		CONNECTION_CLOSE: 2,
+		CONNECTION_UPGRADE: 4,
+		CHUNKED: 8,
+		UPGRADE: 16,
+		CONTENT_LENGTH: 32,
+		SKIPBODY: 64,
+		TRAILING: 128,
+		TRANSFER_ENCODING: 512
+	};
+	exports.LENIENT_FLAGS = {
+		HEADERS: 1,
+		CHUNKED_LENGTH: 2,
+		KEEP_ALIVE: 4,
+		TRANSFER_ENCODING: 8,
+		VERSION: 16,
+		DATA_AFTER_CLOSE: 32,
+		OPTIONAL_LF_AFTER_CR: 64,
+		OPTIONAL_CRLF_AFTER_CHUNK: 128,
+		OPTIONAL_CR_BEFORE_LF: 256,
+		SPACES_AFTER_CHUNK_SIZE: 512,
+		HEADER_VALUE_RELAXED: 1024
+	};
+	exports.STATUSES = {
+		CONTINUE: 100,
+		SWITCHING_PROTOCOLS: 101,
+		PROCESSING: 102,
+		EARLY_HINTS: 103,
+		RESPONSE_IS_STALE: 110,
+		REVALIDATION_FAILED: 111,
+		DISCONNECTED_OPERATION: 112,
+		HEURISTIC_EXPIRATION: 113,
+		MISCELLANEOUS_WARNING: 199,
+		OK: 200,
+		CREATED: 201,
+		ACCEPTED: 202,
+		NON_AUTHORITATIVE_INFORMATION: 203,
+		NO_CONTENT: 204,
+		RESET_CONTENT: 205,
+		PARTIAL_CONTENT: 206,
+		MULTI_STATUS: 207,
+		ALREADY_REPORTED: 208,
+		TRANSFORMATION_APPLIED: 214,
+		IM_USED: 226,
+		MISCELLANEOUS_PERSISTENT_WARNING: 299,
+		MULTIPLE_CHOICES: 300,
+		MOVED_PERMANENTLY: 301,
+		FOUND: 302,
+		SEE_OTHER: 303,
+		NOT_MODIFIED: 304,
+		USE_PROXY: 305,
+		SWITCH_PROXY: 306,
+		TEMPORARY_REDIRECT: 307,
+		PERMANENT_REDIRECT: 308,
+		BAD_REQUEST: 400,
+		UNAUTHORIZED: 401,
+		PAYMENT_REQUIRED: 402,
+		FORBIDDEN: 403,
+		NOT_FOUND: 404,
+		METHOD_NOT_ALLOWED: 405,
+		NOT_ACCEPTABLE: 406,
+		PROXY_AUTHENTICATION_REQUIRED: 407,
+		REQUEST_TIMEOUT: 408,
+		CONFLICT: 409,
+		GONE: 410,
+		LENGTH_REQUIRED: 411,
+		PRECONDITION_FAILED: 412,
+		PAYLOAD_TOO_LARGE: 413,
+		URI_TOO_LONG: 414,
+		UNSUPPORTED_MEDIA_TYPE: 415,
+		RANGE_NOT_SATISFIABLE: 416,
+		EXPECTATION_FAILED: 417,
+		IM_A_TEAPOT: 418,
+		PAGE_EXPIRED: 419,
+		ENHANCE_YOUR_CALM: 420,
+		MISDIRECTED_REQUEST: 421,
+		UNPROCESSABLE_ENTITY: 422,
+		LOCKED: 423,
+		FAILED_DEPENDENCY: 424,
+		TOO_EARLY: 425,
+		UPGRADE_REQUIRED: 426,
+		PRECONDITION_REQUIRED: 428,
+		TOO_MANY_REQUESTS: 429,
+		REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL: 430,
+		REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+		LOGIN_TIMEOUT: 440,
+		NO_RESPONSE: 444,
+		RETRY_WITH: 449,
+		BLOCKED_BY_PARENTAL_CONTROL: 450,
+		UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+		CLIENT_CLOSED_LOAD_BALANCED_REQUEST: 460,
+		INVALID_X_FORWARDED_FOR: 463,
+		REQUEST_HEADER_TOO_LARGE: 494,
+		SSL_CERTIFICATE_ERROR: 495,
+		SSL_CERTIFICATE_REQUIRED: 496,
+		HTTP_REQUEST_SENT_TO_HTTPS_PORT: 497,
+		INVALID_TOKEN: 498,
+		CLIENT_CLOSED_REQUEST: 499,
+		INTERNAL_SERVER_ERROR: 500,
+		NOT_IMPLEMENTED: 501,
+		BAD_GATEWAY: 502,
+		SERVICE_UNAVAILABLE: 503,
+		GATEWAY_TIMEOUT: 504,
+		HTTP_VERSION_NOT_SUPPORTED: 505,
+		VARIANT_ALSO_NEGOTIATES: 506,
+		INSUFFICIENT_STORAGE: 507,
+		LOOP_DETECTED: 508,
+		BANDWIDTH_LIMIT_EXCEEDED: 509,
+		NOT_EXTENDED: 510,
+		NETWORK_AUTHENTICATION_REQUIRED: 511,
+		WEB_SERVER_UNKNOWN_ERROR: 520,
+		WEB_SERVER_IS_DOWN: 521,
+		CONNECTION_TIMEOUT: 522,
+		ORIGIN_IS_UNREACHABLE: 523,
+		TIMEOUT_OCCURED: 524,
+		SSL_HANDSHAKE_FAILED: 525,
+		INVALID_SSL_CERTIFICATE: 526,
+		RAILGUN_ERROR: 527,
+		SITE_IS_OVERLOADED: 529,
+		SITE_IS_FROZEN: 530,
+		IDENTITY_PROVIDER_AUTHENTICATION_ERROR: 561,
+		NETWORK_READ_TIMEOUT: 598,
+		NETWORK_CONNECT_TIMEOUT: 599
+	};
+	exports.FINISH = {
+		SAFE: 0,
+		SAFE_WITH_CB: 1,
+		UNSAFE: 2
+	};
+	exports.HEADER_STATE = {
+		GENERAL: 0,
+		CONNECTION: 1,
+		CONTENT_LENGTH: 2,
+		TRANSFER_ENCODING: 3,
+		UPGRADE: 4,
+		CONNECTION_KEEP_ALIVE: 5,
+		CONNECTION_CLOSE: 6,
+		CONNECTION_UPGRADE: 7,
+		TRANSFER_ENCODING_CHUNKED: 8
+	};
+	exports.METHODS_HTTP1_HEAD = { HEAD: 2 };
+	/**
+	* HTTP methods as defined by RFC-9110 and other specifications.
+	* @see https://httpwg.org/specs/rfc9110.html#method.definitions
+	*/
+	exports.METHODS_BASIC_HTTP = {
+		DELETE: 0,
+		GET: 1,
+		...exports.METHODS_HTTP1_HEAD,
+		POST: 3,
+		PUT: 4,
+		CONNECT: 5,
+		OPTIONS: 6,
+		TRACE: 7,
+		/**
+		* @see https://www.rfc-editor.org/rfc/rfc5789.html
+		*/
+		PATCH: 28,
+		LINK: 31,
+		UNLINK: 32
+	};
+	exports.METHODS_WEBDAV = {
+		COPY: 8,
+		LOCK: 9,
+		MKCOL: 10,
+		MOVE: 11,
+		PROPFIND: 12,
+		PROPPATCH: 13,
+		SEARCH: 14,
+		UNLOCK: 15,
+		BIND: 16,
+		REBIND: 17,
+		UNBIND: 18,
+		ACL: 19
+	};
+	exports.METHODS_SUBVERSION = {
+		REPORT: 20,
+		MKACTIVITY: 21,
+		CHECKOUT: 22,
+		MERGE: 23
+	};
+	exports.METHODS_UPNP = {
+		"M-SEARCH": 24,
+		NOTIFY: 25,
+		SUBSCRIBE: 26,
+		UNSUBSCRIBE: 27
+	};
+	exports.METHODS_CALDAV = { MKCALENDAR: 30 };
+	exports.METHODS_NON_STANDARD = {
+		/**
+		* Not defined in any RFC but commonly used
+		*/
+		PURGE: 29,
+		QUERY: 46
+	};
+	exports.METHODS_ICECAST = { SOURCE: 33 };
+	exports.METHODS_AIRPLAY = {
+		GET: 1,
+		POST: 3
+	};
+	exports.METHODS_RAOP = { FLUSH: 45 };
+	exports.METHODS_RTSP = {
+		OPTIONS: exports.METHODS_BASIC_HTTP.OPTIONS,
+		DESCRIBE: 35,
+		ANNOUNCE: 36,
+		SETUP: 37,
+		PLAY: 38,
+		PAUSE: 39,
+		TEARDOWN: 40,
+		GET_PARAMETER: 41,
+		SET_PARAMETER: 42,
+		REDIRECT: 43,
+		RECORD: 44,
+		...exports.METHODS_AIRPLAY,
+		...exports.METHODS_RAOP
+	};
+	exports.METHODS_HTTP1 = {
+		...exports.METHODS_BASIC_HTTP,
+		...exports.METHODS_WEBDAV,
+		...exports.METHODS_SUBVERSION,
+		...exports.METHODS_UPNP,
+		...exports.METHODS_CALDAV,
+		...exports.METHODS_NON_STANDARD,
+		...exports.METHODS_ICECAST
+	};
+	exports.METHODS_HTTP2 = { 
+	/**
+	* RFC-9113, section 11.6
+	* @see https://www.rfc-editor.org/rfc/rfc9113.html#preface
+	*/
+PRI: 34 };
+	exports.METHODS_HTTP = {
+		...exports.METHODS_HTTP1,
+		...exports.METHODS_HTTP2
+	};
+	exports.METHODS = {
+		...exports.METHODS_HTTP1,
+		...exports.METHODS_HTTP2,
+		...exports.METHODS_RTSP
+	};
+	exports.ALPHA = [
+		"A",
+		"a",
+		"B",
+		"b",
+		"C",
+		"c",
+		"D",
+		"d",
+		"E",
+		"e",
+		"F",
+		"f",
+		"G",
+		"g",
+		"H",
+		"h",
+		"I",
+		"i",
+		"J",
+		"j",
+		"K",
+		"k",
+		"L",
+		"l",
+		"M",
+		"m",
+		"N",
+		"n",
+		"O",
+		"o",
+		"P",
+		"p",
+		"Q",
+		"q",
+		"R",
+		"r",
+		"S",
+		"s",
+		"T",
+		"t",
+		"U",
+		"u",
+		"V",
+		"v",
+		"W",
+		"w",
+		"X",
+		"x",
+		"Y",
+		"y",
+		"Z",
+		"z"
+	];
+	exports.NUM_MAP = {
+		0: 0,
+		1: 1,
+		2: 2,
+		3: 3,
+		4: 4,
+		5: 5,
+		6: 6,
+		7: 7,
+		8: 8,
+		9: 9
+	};
+	exports.HEX_MAP = {
+		0: 0,
+		1: 1,
+		2: 2,
+		3: 3,
+		4: 4,
+		5: 5,
+		6: 6,
+		7: 7,
+		8: 8,
+		9: 9,
+		A: 10,
+		B: 11,
+		C: 12,
+		D: 13,
+		E: 14,
+		F: 15,
+		a: 10,
+		b: 11,
+		c: 12,
+		d: 13,
+		e: 14,
+		f: 15
+	};
+	exports.DIGIT = [
+		"0",
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9"
+	];
+	exports.ALPHANUM = [...exports.ALPHA, ...exports.DIGIT];
+	exports.MARK = [
+		"-",
+		"_",
+		".",
+		"!",
+		"~",
+		"*",
+		"'",
+		"(",
+		")"
+	];
+	exports.USERINFO_CHARS = [
+		...exports.ALPHANUM,
+		...exports.MARK,
+		"%",
+		";",
+		":",
+		"&",
+		"=",
+		"+",
+		"$",
+		","
+	];
+	exports.URL_CHAR = [
+		"!",
+		"\"",
+		"$",
+		"%",
+		"&",
+		"'",
+		"(",
+		")",
+		"*",
+		"+",
+		",",
+		"-",
+		".",
+		"/",
+		":",
+		";",
+		"<",
+		"=",
+		">",
+		"@",
+		"[",
+		"\\",
+		"]",
+		"^",
+		"_",
+		"`",
+		"{",
+		"|",
+		"}",
+		"~",
+		...exports.ALPHANUM
+	];
+	exports.HEX = [
+		...exports.DIGIT,
+		"a",
+		"b",
+		"c",
+		"d",
+		"e",
+		"f",
+		"A",
+		"B",
+		"C",
+		"D",
+		"E",
+		"F"
+	];
+	exports.TOKEN = [
+		"!",
+		"#",
+		"$",
+		"%",
+		"&",
+		"'",
+		"*",
+		"+",
+		"-",
+		".",
+		"^",
+		"_",
+		"`",
+		"|",
+		"~",
+		...exports.ALPHANUM
+	];
+	exports.HTAB = ["	"];
+	exports.SP = [" "];
+	const VCHAR = [
+		33,
+		34,
+		35,
+		36,
+		37,
+		38,
+		39,
+		40,
+		41,
+		42,
+		43,
+		44,
+		45,
+		46,
+		47,
+		48,
+		49,
+		50,
+		51,
+		52,
+		53,
+		54,
+		55,
+		56,
+		57,
+		58,
+		59,
+		60,
+		61,
+		62,
+		63,
+		64,
+		65,
+		66,
+		67,
+		68,
+		69,
+		70,
+		71,
+		72,
+		73,
+		74,
+		75,
+		76,
+		77,
+		78,
+		79,
+		80,
+		81,
+		82,
+		83,
+		84,
+		85,
+		86,
+		87,
+		88,
+		89,
+		90,
+		91,
+		92,
+		93,
+		94,
+		95,
+		96,
+		97,
+		98,
+		99,
+		100,
+		101,
+		102,
+		103,
+		104,
+		105,
+		106,
+		107,
+		108,
+		109,
+		110,
+		111,
+		112,
+		113,
+		114,
+		115,
+		116,
+		117,
+		118,
+		119,
+		120,
+		121,
+		122,
+		123,
+		124,
+		125,
+		126
+	];
+	const OBS_TEXT = [
+		128,
+		129,
+		130,
+		131,
+		132,
+		133,
+		134,
+		135,
+		136,
+		137,
+		138,
+		139,
+		140,
+		141,
+		142,
+		143,
+		144,
+		145,
+		146,
+		147,
+		148,
+		149,
+		150,
+		151,
+		152,
+		153,
+		154,
+		155,
+		156,
+		157,
+		158,
+		159,
+		160,
+		161,
+		162,
+		163,
+		164,
+		165,
+		166,
+		167,
+		168,
+		169,
+		170,
+		171,
+		172,
+		173,
+		174,
+		175,
+		176,
+		177,
+		178,
+		179,
+		180,
+		181,
+		182,
+		183,
+		184,
+		185,
+		186,
+		187,
+		188,
+		189,
+		190,
+		191,
+		192,
+		193,
+		194,
+		195,
+		196,
+		197,
+		198,
+		199,
+		200,
+		201,
+		202,
+		203,
+		204,
+		205,
+		206,
+		207,
+		208,
+		209,
+		210,
+		211,
+		212,
+		213,
+		214,
+		215,
+		216,
+		217,
+		218,
+		219,
+		220,
+		221,
+		222,
+		223,
+		224,
+		225,
+		226,
+		227,
+		228,
+		229,
+		230,
+		231,
+		232,
+		233,
+		234,
+		235,
+		236,
+		237,
+		238,
+		239,
+		240,
+		241,
+		242,
+		243,
+		244,
+		245,
+		246,
+		247,
+		248,
+		249,
+		250,
+		251,
+		252,
+		253,
+		254,
+		255
+	];
+	exports.HTAB_SP_VCHAR_OBS_TEXT = [
+		...exports.HTAB,
+		...exports.SP,
+		...VCHAR,
+		...OBS_TEXT
+	];
+	exports.HEADER_CHARS = exports.HTAB_SP_VCHAR_OBS_TEXT;
+	exports.RELAXED_HEADER_CHARS = [...[
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		11,
+		12,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19,
+		20,
+		21,
+		22,
+		23,
+		24,
+		25,
+		26,
+		27,
+		28,
+		29,
+		30,
+		31,
+		127
+	], ...exports.HEADER_CHARS];
+	exports.CONNECTION_TOKEN_CHARS = [
+		...exports.HTAB,
+		...exports.SP,
+		33,
+		34,
+		35,
+		36,
+		37,
+		38,
+		39,
+		40,
+		41,
+		42,
+		43,
+		45,
+		46,
+		47,
+		48,
+		49,
+		50,
+		51,
+		52,
+		53,
+		54,
+		55,
+		56,
+		57,
+		58,
+		59,
+		60,
+		61,
+		62,
+		63,
+		64,
+		65,
+		66,
+		67,
+		68,
+		69,
+		70,
+		71,
+		72,
+		73,
+		74,
+		75,
+		76,
+		77,
+		78,
+		79,
+		80,
+		81,
+		82,
+		83,
+		84,
+		85,
+		86,
+		87,
+		88,
+		89,
+		90,
+		91,
+		92,
+		93,
+		94,
+		95,
+		96,
+		97,
+		98,
+		99,
+		100,
+		101,
+		102,
+		103,
+		104,
+		105,
+		106,
+		107,
+		108,
+		109,
+		110,
+		111,
+		112,
+		113,
+		114,
+		115,
+		116,
+		117,
+		118,
+		119,
+		120,
+		121,
+		122,
+		123,
+		124,
+		125,
+		126,
+		...OBS_TEXT
+	];
+	exports.QDTEXT = [
+		...exports.HTAB,
+		...exports.SP,
+		33,
+		35,
+		36,
+		37,
+		38,
+		39,
+		40,
+		41,
+		42,
+		43,
+		44,
+		45,
+		46,
+		47,
+		48,
+		49,
+		50,
+		51,
+		52,
+		53,
+		54,
+		55,
+		56,
+		57,
+		58,
+		59,
+		60,
+		61,
+		62,
+		63,
+		64,
+		65,
+		66,
+		67,
+		68,
+		69,
+		70,
+		71,
+		72,
+		73,
+		74,
+		75,
+		76,
+		77,
+		78,
+		79,
+		80,
+		81,
+		82,
+		83,
+		84,
+		85,
+		86,
+		87,
+		88,
+		89,
+		90,
+		91,
+		93,
+		94,
+		95,
+		96,
+		97,
+		98,
+		99,
+		100,
+		101,
+		102,
+		103,
+		104,
+		105,
+		106,
+		107,
+		108,
+		109,
+		110,
+		111,
+		112,
+		113,
+		114,
+		115,
+		116,
+		117,
+		118,
+		119,
+		120,
+		121,
+		122,
+		123,
+		124,
+		125,
+		126,
+		...OBS_TEXT
+	];
+	exports.MAJOR = exports.NUM_MAP;
+	exports.MINOR = exports.MAJOR;
+	exports.SPECIAL_HEADERS = {
+		"connection": exports.HEADER_STATE.CONNECTION,
+		"content-length": exports.HEADER_STATE.CONTENT_LENGTH,
+		"proxy-connection": exports.HEADER_STATE.CONNECTION,
+		"transfer-encoding": exports.HEADER_STATE.TRANSFER_ENCODING,
+		"upgrade": exports.HEADER_STATE.UPGRADE
+	};
+	exports.default = {
+		ERROR: exports.ERROR,
+		TYPE: exports.TYPE,
+		FLAGS: exports.FLAGS,
+		LENIENT_FLAGS: exports.LENIENT_FLAGS,
+		STATUSES: exports.STATUSES,
+		FINISH: exports.FINISH,
+		HEADER_STATE: exports.HEADER_STATE,
+		ALPHA: exports.ALPHA,
+		NUM_MAP: exports.NUM_MAP,
+		HEX_MAP: exports.HEX_MAP,
+		DIGIT: exports.DIGIT,
+		ALPHANUM: exports.ALPHANUM,
+		MARK: exports.MARK,
+		USERINFO_CHARS: exports.USERINFO_CHARS,
+		URL_CHAR: exports.URL_CHAR,
+		HEX: exports.HEX,
+		TOKEN: exports.TOKEN,
+		HEADER_CHARS: exports.HEADER_CHARS,
+		RELAXED_HEADER_CHARS: exports.RELAXED_HEADER_CHARS,
+		CONNECTION_TOKEN_CHARS: exports.CONNECTION_TOKEN_CHARS,
+		QDTEXT: exports.QDTEXT,
+		HTAB_SP_VCHAR_OBS_TEXT: exports.HTAB_SP_VCHAR_OBS_TEXT,
+		MAJOR: exports.MAJOR,
+		MINOR: exports.MINOR,
+		SPECIAL_HEADERS: exports.SPECIAL_HEADERS,
+		METHODS: exports.METHODS,
+		METHODS_HTTP: exports.METHODS_HTTP,
+		METHODS_HTTP1_HEAD: exports.METHODS_HTTP1_HEAD,
+		METHODS_HTTP1: exports.METHODS_HTTP1,
+		METHODS_HTTP2: exports.METHODS_HTTP2,
+		METHODS_ICECAST: exports.METHODS_ICECAST,
+		METHODS_RTSP: exports.METHODS_RTSP
+	};
+})))(), 1);
+const KIND_REQUEST = import_constants.TYPE.REQUEST;
+import_constants.TYPE.RESPONSE;
+const kPointer = Symbol("kPtr");
+const kUrl = Symbol("kUrl");
+const kStatusMessage = Symbol("kStatusMessage");
+const kHeadersFields = Symbol("kHeadersFields");
+const kHeadersValues = Symbol("kHeadersValues");
+const kLastHeaderCallback = Symbol("kLastHeaderCallback");
+const kCallbacks = Symbol("kCallbacks");
+const kType = Symbol("kType");
+const HEADER_CB_NONE = 0;
+const HEADER_CB_FIELD = 1;
+const HEADER_CB_VALUE = 2;
+const parsersMap = /* @__PURE__ */ new Map();
+const methodNames = Object.fromEntries(Object.entries(import_constants.METHODS).map(([name, num]) => [num, name]));
+function readStringFrom(pointer, length) {
+	return Buffer.from(llhttp_memory.buffer, pointer, length).toString("latin1");
+}
+/**
+* @note Reference the base URL through a variable. Bundlers (e.g. Vite)
+* statically rewrite the `new URL('...', import.meta.url)` pattern into
+* an asset URL resolved against the served origin, which breaks reading
+* the WASM binary from the file system in DOM-like test environments.
+*/
+const wasmBaseUrl = import.meta.url;
+const llhttpModule = new WebAssembly.Module(fs.readFileSync(new URL("./llhttp/llhttp.wasm", wasmBaseUrl)));
+const llhttpInstance = new WebAssembly.Instance(llhttpModule, { env: {
+	wasm_on_message_begin(parserPointer) {
+		const parser = parsersMap.get(parserPointer);
+		parser[kUrl] = "";
+		parser[kStatusMessage] = "";
+		parser[kHeadersFields] = [];
+		parser[kHeadersValues] = [];
+		parser[kLastHeaderCallback] = HEADER_CB_NONE;
+		return parser[kCallbacks].onMessageBegin?.() ?? 0;
+	},
+	wasm_on_url(parserPointer, at, length) {
+		parsersMap.get(parserPointer)[kUrl] = readStringFrom(at, length);
+		return 0;
+	},
+	wasm_on_status(parserPointer, at, length) {
+		parsersMap.get(parserPointer)[kStatusMessage] = readStringFrom(at, length);
+		return 0;
+	},
+	wasm_on_header_field(parserPointer, at, length) {
+		const parser = parsersMap.get(parserPointer);
+		const chunk = readStringFrom(at, length);
+		const fields = parser[kHeadersFields];
+		if (parser[kLastHeaderCallback] === HEADER_CB_FIELD) fields[fields.length - 1] += chunk;
+		else {
+			fields.push(chunk);
+			parser[kLastHeaderCallback] = HEADER_CB_FIELD;
+		}
+		return 0;
+	},
+	wasm_on_header_value(parserPointer, at, length) {
+		const parser = parsersMap.get(parserPointer);
+		const chunk = readStringFrom(at, length);
+		const values = parser[kHeadersValues];
+		if (parser[kLastHeaderCallback] === HEADER_CB_VALUE) values[values.length - 1] += chunk;
+		else {
+			values.push(chunk);
+			parser[kLastHeaderCallback] = HEADER_CB_VALUE;
+		}
+		return 0;
+	},
+	wasm_on_headers_complete(parserPointer, statusCode, rawUpgrade, rawShouldKeepAlive) {
+		const parser = parsersMap.get(parserPointer);
+		const versionMajor = llhttp_get_version_major(parserPointer);
+		const versionMinor = llhttp_get_version_minor(parserPointer);
+		const rawHeaders = [];
+		const upgrade = rawUpgrade === 1;
+		const shouldKeepAlive = rawShouldKeepAlive === 1;
+		for (let c = 0; c < parser[kHeadersFields].length; c++) rawHeaders.push(parser[kHeadersFields][c], parser[kHeadersValues][c]);
+		if (parser[kType] === KIND_REQUEST) {
+			const method = methodNames[llhttp_get_method(parserPointer)];
+			const url = parser[kUrl];
+			return parser[kCallbacks].onHeadersComplete?.({
+				versionMajor,
+				versionMinor,
+				rawHeaders,
+				method,
+				url,
+				upgrade,
+				shouldKeepAlive
+			}) ?? 0;
+		} else {
+			const statusCode = llhttp_get_status_code(parserPointer);
+			const statusMessage = parser[kStatusMessage];
+			return parser[kCallbacks].onHeadersComplete?.({
+				versionMajor,
+				versionMinor,
+				rawHeaders,
+				statusCode,
+				statusMessage,
+				upgrade,
+				shouldKeepAlive
+			}) ?? 0;
+		}
+	},
+	wasm_on_body(parserPointer, at, length) {
+		const parser = parsersMap.get(parserPointer);
+		const body = Buffer.from(new Uint8Array(llhttp_memory.buffer, at, length));
+		return parser[kCallbacks].onBody?.(body) ?? 0;
+	},
+	wasm_on_message_complete(parserPointer) {
+		return parsersMap.get(parserPointer)[kCallbacks].onMessageComplete?.() ?? 0;
+	}
+} });
+const llhttp_memory = llhttpInstance.exports.memory;
+const llhttp_alloc = llhttpInstance.exports.llhttp_alloc;
+const llhttp_malloc = llhttpInstance.exports.malloc;
+const llhttp_execute = llhttpInstance.exports.llhttp_execute;
+llhttpInstance.exports.llhttp_get_type;
+llhttpInstance.exports.llhttp_get_upgrade;
+llhttpInstance.exports.llhttp_should_keep_alive;
+const llhttp_get_method = llhttpInstance.exports.llhttp_get_method;
+const llhttp_get_status_code = llhttpInstance.exports.llhttp_get_status_code;
+const llhttp_get_version_minor = llhttpInstance.exports.llhttp_get_http_minor;
+const llhttp_get_version_major = llhttpInstance.exports.llhttp_get_http_major;
+const llhttp_get_error_reason = llhttpInstance.exports.llhttp_get_error_reason;
+const llhttp_get_error_pos = llhttpInstance.exports.llhttp_get_error_pos;
+const llhttp_free = llhttpInstance.exports.free;
+const initialize = llhttpInstance.exports._initialize;
+initialize();
+var HttpParser = class {
+	constructor(type, callbacks) {
+		this[kUrl] = "";
+		this[kStatusMessage] = "";
+		this[kHeadersFields] = [];
+		this[kHeadersValues] = [];
+		this[kLastHeaderCallback] = HEADER_CB_NONE;
+		this[kType] = type;
+		this[kCallbacks] = callbacks;
+		const parserPointer = llhttp_alloc(type);
+		if (parserPointer === 0) throw new Error("Failed to allocate llhttp parser");
+		this[kPointer] = parserPointer;
+		parsersMap.set(this[kPointer], this);
+	}
+	destroy() {
+		if (this[kPointer] === 0) return;
+		parsersMap.delete(this[kPointer]);
+		llhttp_free(this[kPointer]);
+		this[kPointer] = 0;
+	}
+	execute(data) {
+		const pointer = llhttp_malloc(data.byteLength);
+		if (pointer === 0) throw new Error("Failed to allocate llhttp input buffer");
+		let ret;
+		try {
+			new Uint8Array(llhttp_memory.buffer).set(data, pointer);
+			ret = llhttp_execute(this[kPointer], pointer, data.byteLength);
+		} catch (error) {
+			llhttp_free(pointer);
+			throw error;
+		}
+		if (ret === import_constants.ERROR.PAUSED_UPGRADE) {
+			const consumed = llhttp_get_error_pos(this[kPointer]) - pointer;
+			llhttp_free(pointer);
+			return data.subarray(consumed);
+		}
+		llhttp_free(pointer);
+		this.#checkError(ret);
+		return null;
+	}
+	#checkError(errorCode) {
+		if (errorCode === import_constants.ERROR.OK) return;
+		const errorPointer = llhttp_get_error_reason(this[kPointer]);
+		const length = new Uint8Array(llhttp_memory.buffer).indexOf(0, errorPointer) - errorPointer;
+		throw new Error(readStringFrom(errorPointer, length));
+	}
+};
+//#endregion
+//#region src/interceptors/http/http-parser.ts
+var HttpRequestParser = class extends HttpParser {
+	#requestBodyStream;
+	constructor(options) {
+		super(1, {
+			onHeadersComplete: ({ rawHeaders, method, url: path }) => {
+				/**
+				* @note When the socket is reused, "connectionOptions" will point
+				* to the "net.connect()" call options that established the connection,
+				* which may differ from the description of the current request (e.g. method).
+				* Rely on the HTTPParser supplying us with the correct "rawMethod" number.
+				*/
+				const finalMethod = (method || options.connectionOptions.method || "GET").toUpperCase();
+				const url = new URL(path || "", options.connectionOptions.url);
+				const headers = FetchResponse.parseRawHeaders([...rawHeaders]);
+				if (url.username || url.password) {
+					if (!headers.has("authorization")) {
+						const credentials = Buffer.from(`${url.username}:${url.password}`).toString("base64");
+						headers.set("authorization", `Basic ${credentials}`);
+					}
+					url.username = "";
+					url.password = "";
+				}
+				this.#requestBodyStream = new Readable({ 
+				/**
+				* @note Provide the `read()` method so a `Readable` could be
+				* used as the actual request body (the stream calls "read()").
+				*/
+read: () => {} });
+				/**
+				* @note Expose an abort controller for the parsed request so the
+				* consumer can abort it (e.g. when the client destroys the
+				* connection before the request is handled).
+				*/
+				const abortController = new AbortController();
+				const request = new FetchRequest(url, {
+					method: finalMethod,
+					headers,
+					credentials: "same-origin",
+					body: Readable.toWeb(this.#requestBodyStream),
+					signal: abortController.signal
+				});
+				options.onRequest(request, abortController);
+			},
+			onBody: (chunk) => {
+				invariant(this.#requestBodyStream, "Failed to write to a request stream: stream does not exist. This is likely an issue with the library. Please report it on GitHub.");
+				this.#requestBodyStream.push(chunk);
+			},
+			onMessageComplete: () => {
+				this.#requestBodyStream?.push(null);
+			}
+		});
+	}
+	free() {
+		this.destroy();
+		this.#requestBodyStream?.destroy();
+		this.#requestBodyStream = void 0;
+	}
+};
+var HttpResponseParser = class extends HttpParser {
+	#responseBodyStream;
+	constructor(options) {
+		super(2, {
+			onHeadersComplete: ({ rawHeaders, statusCode: status, statusMessage: statusText }) => {
+				const headers = FetchResponse.parseRawHeaders([...rawHeaders]);
+				const response = new FetchResponse(FetchResponse.isResponseWithBody(status) ? Readable.toWeb(this.#responseBodyStream = new Readable({ read() {} })) : null, {
+					status,
+					statusText,
+					headers
+				});
+				options.onResponse(response);
+			},
+			onBody: (chunk) => {
+				invariant(this.#responseBodyStream, "Failed to read from a response stream: stream does not exist. This is likely an issue with the library. Please report it on GitHub.");
+				this.#responseBodyStream.push(chunk);
+			},
+			onMessageComplete: () => {
+				this.#responseBodyStream?.push(null);
+			}
+		});
+	}
+	free() {
+		this.destroy();
+		this.#responseBodyStream = null;
+	}
+};
+//#endregion
+//#region src/utils/is-node-like-error.ts
+function isNodeLikeError(error) {
+	if (error == null) return false;
+	if (!(error instanceof Error)) return false;
+	return "code" in error && "errno" in error;
+}
+//#endregion
+//#region src/utils/handle-request.ts
+async function handleRequest(options) {
+	if (options.logger?.isEnabled("default")) formatRequest(options.request).then((message) => {
+		options.logger?.info("[%s] %s", options.requestId, message);
+	});
+	const handleResponse = async (response) => {
+		if (response instanceof Error) {
+			await options.controller.errorWith(response);
+			return true;
+		}
+		if (isResponseError(response)) {
+			await options.controller.respondWith(response);
+			return true;
+		}
+		/**
+		* Handle normal responses or response-like objects.
+		* @note This must come before the arbitrary object check
+		* since Response instances are, in fact, objects.
+		*/
+		if (isResponseLike(response)) {
+			await options.controller.respondWith(response);
+			return true;
+		}
+		if (isObject(response)) {
+			await options.controller.errorWith(response);
+			return true;
+		}
+		return false;
+	};
+	const handleResponseError = async (error) => {
+		if (error instanceof InterceptorError) throw resultError;
+		if (isNodeLikeError(error)) {
+			await options.controller.errorWith(error);
+			return true;
+		}
+		if (error instanceof Response) return await handleResponse(error);
+		return false;
+	};
+	const requestAbortPromise = Promise.withResolvers();
+	let requestAbortReason;
+	let isRequestAborted = false;
+	const onAbort = () => {
+		isRequestAborted = true;
+		requestAbortReason = options.request.signal?.reason;
+		requestAbortPromise.reject(requestAbortReason);
+	};
+	/**
+	* @note `signal` is not always defined in React Native.
+	*/
+	if (options.request.signal) {
+		if (options.request.signal.aborted) {
+			await options.controller.errorWith(options.request.signal.reason);
+			return;
+		}
+		options.request.signal.addEventListener("abort", onAbort, { once: true });
+	}
+	const [resultError] = await until(async () => {
+		const requestEvent = new HttpRequestEvent({
+			initiator: options.initiator,
+			requestId: options.requestId,
+			request: options.request,
+			controller: options.controller
+		});
+		const requestListenersPromise = options.emitter.emitAsPromise(requestEvent);
+		await Promise.race([
+			requestAbortPromise.promise,
+			requestListenersPromise,
+			options.controller.handled
+		]);
+		/**
+		* @note If the "request" listener has replaced the request instance,
+		* propagate that mutation back to the underlying insterceptor.
+		* This happens with XMLHttpRequest that replaces request instances
+		* to correctly reflect the "withCredentials" option on the Fetch API request.
+		*/
+		if (requestEvent.request !== options.request) options.request = requestEvent.request;
+	});
+	options.request.signal?.removeEventListener("abort", onAbort);
+	if (isRequestAborted) {
+		await options.controller.errorWith(requestAbortReason);
+		return;
+	}
+	if (resultError) {
+		if (await handleResponseError(resultError)) return;
+		if (options.emitter.listenerCount("unhandledException") > 0) {
+			const unhandledExceptionController = new RequestController(options.request, {
+				/**
+				* @note Intentionally empty passthrough handle.
+				* This controller is created within another controller and we only need
+				* to know if `unhandledException` listeners handled the request.
+				*/
+				passthrough() {},
+				async respondWith(response) {
+					await handleResponse(response);
+				},
+				async errorWith(reason) {
+					/**
+					* @note Handle the result of the unhandled controller
+					* in the same way as the original request controller.
+					* The exception here is that thrown errors within the
+					* "unhandledException" event do NOT result in another
+					* emit of the same event. They are forwarded as-is.
+					*/
+					await options.controller.errorWith(reason);
+				}
+			});
+			await options.emitter.emitAsPromise(new UnhandledHttpException({
+				initiator: options.initiator,
+				error: resultError,
+				request: options.request,
+				requestId: options.requestId,
+				controller: unhandledExceptionController
+			}));
+			if (unhandledExceptionController.readyState !== RequestController.PENDING) return;
+		}
+		await options.controller.respondWith(createServerErrorResponse(resultError));
+		return;
+	}
+	if (options.controller.readyState === RequestController.PENDING) return await options.controller.passthrough();
+	return options.controller.handled;
+}
+//#endregion
+//#region src/interceptors/http/source.ts
+const httpLogger = createLogger("http-request");
+/**
+* Interceptor for HTTP requests in Node.js.
+* Routes socket connections through an HTTP parser.
+*/
+var NodeHttpRequestSource = class extends Interceptor {
+	static {
+		this.symbol = Symbol.for("node-http-request-source");
+	}
+	predicate() {
+		return true;
+	}
+	setup() {
+		const socketInterceptor = Interceptor.singleton(SocketInterceptor);
+		socketInterceptor.apply(this);
+		this.subscriptions.push(() => {
+			socketInterceptor.dispose(this);
+		});
+		/**
+		* @note Record the raw values provided to Headers set/append
+		* in order to support "IncomingMessage.prototype.rawHeaders".
+		* This is meant for the headers in mocked responses.
+		*/
+		this.subscriptions.push(recordRawFetchHeaders());
+		const controller = new AbortController();
+		this.subscriptions.push(() => controller.abort());
+		socketInterceptor.on("connection", ({ connectionOptions, socket, controller: socketController }) => {
+			let isHttpConnection;
+			let requestParser;
+			let tunnelUrl;
+			let abortPendingRequest;
+			/**
+			* @note Capture the request context of the connection itself.
+			* The socket is created synchronously within the request async
+			* context (e.g. inside the patched `http.request()`), but the
+			* first data may reach the socket from a foreign context (e.g.
+			* a form-data stream piped into the request), where sampling
+			* the request context yields nothing.
+			*/
+			const connectionRequestContext = requestContext.getStore();
+			/**
+			* @note The client destroys the socket synchronously (e.g. Undici
+			* on request abort) but the socket teardown events ("error",
+			* "close") are emitted asynchronously, after the consumer has
+			* already observed the rejected request promise. Hook into the
+			* destroy itself so the pending request is aborted before any
+			* of its listeners can resume.
+			*/
+			const rawSocket = socketController[kRawSocket];
+			const realSocketDestroy = rawSocket._destroy.bind(rawSocket);
+			rawSocket._destroy = (error, callback) => {
+				abortPendingRequest?.();
+				realSocketDestroy(error, callback);
+			};
+			/**
+			* @note Only inspect the first sent packet to determine the protocol.
+			* A single socket cannot be used for different protocols.
+			*/
+			socket.on("data", (chunk) => {
+				if (isHttpConnection === false) return;
+				/**
+				* @note A mocked "CONNECT" request has established a tunnel.
+				* The data that follows belongs to a new exchange addressed to
+				* the tunnel target. The parser stopped at the tunnel boundary
+				* (HTTP upgrade semantics), so tear it down and detect the
+				* tunneled protocol anew, like on a fresh connection.
+				*/
+				if (tunnelUrl && requestParser) {
+					requestParser.free();
+					requestParser = void 0;
+					isHttpConnection = void 0;
+					socketController.reset();
+				}
+				if (requestParser) {
+					requestParser.execute(toBuffer(chunk));
+					return;
+				}
+				const httpMessage = chunk.toString();
+				const httpMethod = httpMessage.split(" ")[0] || "";
+				if (!METHODS.includes(httpMethod.toUpperCase())) {
+					isHttpConnection = false;
+					return;
+				}
+				isHttpConnection = true;
+				const baseUrl = tunnelUrl ?? connectionOptionsToUrl(connectionOptions, socket);
+				httpLogger.verbose("handling http message %o", {
+					httpMessage,
+					httpMethod,
+					baseUrl
+				});
+				const requestContextValue = requestContext.getStore() ?? connectionRequestContext;
+				const initiator = requestContextValue?.initiator || socket;
+				requestParser = new HttpRequestParser({
+					connectionOptions: {
+						method: httpMethod,
+						url: baseUrl
+					},
+					onRequest: async (parsedRequest, requestAbortController) => {
+						const request = requestContextValue?.transformRequest?.(parsedRequest) ?? parsedRequest;
+						/**
+						* @note A subsequent request arriving on a kept-alive socket
+						* that has already been handled (passed through or mocked).
+						* Clients like Undici reuse sockets without emitting the
+						* "free" event, so reset the controller here, at the HTTP
+						* message boundary, to handle the new request from the
+						* pending state again.
+						*/
+						if (socketController["readyState"] !== SocketController.PENDING) socketController.reset();
+						const requestId = createRequestId();
+						const requestLogger = requestContextValue?.logger ?? httpLogger;
+						httpLogger.verbose("received a parsed HTTP request %o", {
+							method: request.method,
+							url: request.url
+						});
+						const requestController = new RequestController(request, {
+							respondWith: async (rawResponse) => {
+								httpLogger.verbose("respondWith() %o", {
+									status: rawResponse.status,
+									statusText: rawResponse.statusText,
+									hasBody: rawResponse.body != null
+								});
+								/**
+								* @note The client may destroy the socket (e.g. on request
+								* abort) moments before a response arrives. A destroyed
+								* socket cannot be claimed and has no one reading it.
+								*/
+								if (socket.destroyed) return;
+								socketController.claim();
+								const response = FetchResponse.from(rawResponse, { url: request.url });
+								/**
+								* @note A successful mocked response to a "CONNECT"
+								* request establishes a tunnel to the requested authority
+								* (e.g. "127.0.0.1:80"). The exchange that follows on this
+								* socket is addressed to that authority, not to the proxy.
+								*/
+								if (request.method === "CONNECT" && response.ok) tunnelUrl = new URL(`http://${request.url}`);
+								/**
+								* @note Clone the response before "respondWith" because it will
+								* consume its body. This way, we can have a readable response copy
+								* for the "response" event below.
+								*/
+								const responseClone = isResponseError(response) ? null : response.clone();
+								const respond = () => {
+									return this.respondWith({
+										socket: socketController[kRawSocket],
+										request: context.request,
+										response
+									});
+								};
+								if (responseClone) await this.emitter.emitAsPromise(new HttpResponseEvent({
+									initiator,
+									requestId,
+									request: context.request,
+									response: responseClone,
+									responseType: "mock"
+								}));
+								if (socket.connecting) socket.once("connect", respond);
+								else
+ /**
+								* @note Reused sockets stay connected between requests and will not
+								* emit "connect" anymore. If that's the case, respond immediately.
+								*/
+								await respond();
+							},
+							errorWith: (reason) => {
+								if (reason instanceof Error) socket.destroy(reason);
+							},
+							passthrough: () => {
+								const realSocket = socketController.passthrough(this.#modifyHttpHeaders(context.request));
+								if (this.emitter.listenerCount("response") > 0) {
+									httpLogger.verbose("found \"response\" listener, corking socket reads");
+									/**
+									* Suspend the delivery of the original response to the client
+									* until the "response" event listeners settle. This guarantees
+									* that the request promise (e.g. `await fetch()`) does not
+									* resolve before the listeners are done. The real socket keeps
+									* emitting data for the response parser meanwhile.
+									*/
+									socketController.corkReads();
+									const responseParser = new HttpResponseParser({ onResponse: async (response) => {
+										httpLogger.verbose("HTTP response parser parsed: %d %s", response.status, response.statusText);
+										if (isResponseError(response)) {
+											httpLogger.verbose("response is an error response, uncorking socket reads...");
+											socketController.uncorkReads();
+											return;
+										}
+										FetchResponse.setUrl(request.url, response);
+										try {
+											httpLogger.verbose("emitting \"response\" event");
+											await this.emitter.emitAsPromise(new HttpResponseEvent({
+												initiator,
+												requestId,
+												request: context.request,
+												response,
+												responseType: "original"
+											}));
+										} finally {
+											httpLogger.verbose("uncorking socket reads");
+											socketController.uncorkReads();
+											/**
+											* @note Informational responses other than
+											* "101 Switching Protocols" are followed by a final
+											* response on the same connection. Keep gating that
+											* final response on the "response" event listeners.
+											*/
+											if (response.status < 200 && response.status !== 101) socketController.corkReads();
+										}
+									} });
+									realSocket.on("data", (chunk) => responseParser.execute(chunk)).on("close", () => responseParser.free());
+								}
+							}
+						}, {
+							logger: requestLogger,
+							requestId
+						});
+						invariant(socketController["readyState"] === SocketController.PENDING, "CANNOT HANDLE ALREADY HANDLED REQUEST", request.method, request.url, socketController["readyState"]);
+						/**
+						* @note Create a request resolution context.
+						* This is so modifications to the "request" in upstream interceptors
+						* are correctly picked up by the underlying HTTP interceptor.
+						*/
+						const context = {
+							initiator,
+							requestId,
+							request,
+							controller: requestController,
+							emitter: this.emitter,
+							logger: requestLogger
+						};
+						/**
+						* @note The client destroying the socket while the request
+						* is still pending means the request was aborted (e.g. via
+						* `AbortController`). Abort the parsed request so its
+						* handling settles and late interactions with the request
+						* controller become controlled errors.
+						*/
+						abortPendingRequest = () => {
+							if (requestController.readyState === RequestController.PENDING) requestAbortController.abort();
+						};
+						try {
+							await handleRequest(context);
+						} finally {
+							abortPendingRequest = void 0;
+						}
+					}
+				});
+				requestParser.execute(toBuffer(chunk));
+			});
+			socket.on("close", () => requestParser?.free());
+		}, { signal: controller.signal });
+	}
+	async respondWith(args) {
+		const { socket, request, response } = args;
+		if (socket.destroyed) return;
+		if (isResponseError(response)) {
+			/**
+			* @note Reference the error response on the socket error so the
+			* client-side interceptors (e.g. fetch) can surface it to the
+			* consumer as the reason behind the failed request. Keep the
+			* reference non-enumerable so the error remains observably
+			* identical for the clients that expose it as-is.
+			*/
+			socket.destroy(Object.defineProperty(/* @__PURE__ */ new TypeError("Network error"), kErrorResponse, {
+				value: response,
+				enumerable: false
+			}));
+			return;
+		}
+		invariant(!socket.connecting, "Failed to mock a response for \"%s %s\": socket has not connected", request.method, request.url);
+		/**
+		* Use native server response handling in Node.js.
+		* @see https://github.com/nodejs/node/blob/13eb80f3b718452213e0fc449702aefbbfe4110f/lib/_http_server.js#L202
+		*/
+		const incomingMessage = new IncomingMessage(socket);
+		/**
+		* @note Describe the request method so the response body is
+		* handled appropriately (e.g. "HEAD" responses must not write
+		* a body). The HTTP version is deliberately left unset: with it,
+		* `ServerResponse` frames bodies of unknown length as chunked,
+		* polluting the mocked response headers with "Transfer-Encoding"
+		* the mock never specified.
+		*/
+		incomingMessage.method = request.method;
+		const serverResponse = new ServerResponse(incomingMessage);
+		const responseSocket = new net.Socket();
+		responseSocket._writeGeneric = (writev, data, encoding, callback) => {
+			unwrapPendingData(data, (chunk, encoding) => {
+				socket.push(toBuffer(chunk), encoding);
+			});
+			callback?.();
+		};
+		responseSocket._destroy = (error, callback) => {
+			/**
+			* Only destroy the socket on stream errors.
+			* On a clean end, the socket is already signaled via `socket.push(null)`
+			* in the main response flow. Destroying it here prematurely would prevent
+			* the client from processing the response (e.g. calling `response.destroy()`).
+			* @see https://github.com/mswjs/interceptors/issues/738
+			*/
+			if (error) socket.destroy();
+			callback(null);
+		};
+		responseSocket.on("drain", () => serverResponse.emit("drain"));
+		serverResponse.assignSocket(responseSocket);
+		serverResponse.removeHeader("connection");
+		serverResponse.removeHeader("date");
+		const rawResponseHeaders = getRawFetchHeaders(response.headers);
+		serverResponse.writeHead(response.status, response.statusText || STATUS_CODES[response.status], rawResponseHeaders);
+		/**
+		* @note Override the socket's `_destroy` before writing the response body.
+		* The underlying TCP handle (from `socket.connect()`) makes `_destroy` async
+		* (`_handle.close()` callback), which delays the 'error' event. Since the real
+		* TCP connection is irrelevant for mocked responses, take the synchronous path
+		* so that user-initiated `response.destroy(error)` emits the error promptly.
+		* This must happen before `serverResponse.end()` because the HTTP parser may
+		* fire the 'response' event synchronously during `socket.push()`.
+		*/
+		socket._destroy = function(error, callback) {
+			if (error)
+ /**
+			* Emit the error event as a microtask instead of relying on the default
+			* `process.nextTick(emitErrorNT)` from `callback(error)`. This is necessary
+			* because `respondWith` runs inside a microtask (from `await reader.read()`).
+			* A resolved promise continuation (from toWebResponse) is queued as
+			* another microtask during the same phase. Since microtasks are drained before
+			* nextTick, the test's `await` would resolve before the error event fires.
+			* Using `queueMicrotask` ensures the error event is emitted within the current
+			* microtask phase, before other queued microtasks.
+			*/
+			queueMicrotask(() => this.emit("error", error));
+			callback(null);
+			/**
+			* @note `net.Socket` is constructed with `emitClose: false`, so Node's
+			* stream destroy machinery does not emit `'close'` automatically; the
+			* stock `net.Socket._destroy` only emits it via `_handle.close()`.
+			* Since this override replaces `_destroy`, emit `'close'` here so the
+			* mocked socket completes its lifecycle (otherwise consumers waiting
+			* on `'close'`, like `http.ClientRequest`, hang).
+			*/
+			process.nextTick(() => this.emit("close", error != null));
+		};
+		if (response.body) {
+			const reader = response.body.getReader();
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) {
+						serverResponse.end();
+						break;
+					}
+					if (!serverResponse.write(value)) await new Promise((resolve) => {
+						serverResponse.once("drain", resolve);
+					});
+				}
+			} catch {
+				/**
+				* @note Delay the socket destruction to allow the event loop
+				* to flush already-pushed response data (headers + body chunks)
+				* through the HTTP parser. Without this, the socket is destroyed
+				* on the same tick as `socket.push(data)` and the client never
+				* reads the response.
+				*/
+				await new Promise((resolve) => process.nextTick(resolve));
+				socket.destroy();
+				return;
+			}
+		} else serverResponse.end();
+		/**
+		* @note Self-delimiting responses (chunked, explicit "Content-Length",
+		* or bodiless by definition) must NOT signal the end-of-stream.
+		* The client parser completes them from their framing alone, and
+		* ending the socket would kill the kept-alive connection that
+		* agents pool and reuse for subsequent requests.
+		*/
+		const isSelfDelimitingResponse = request.method === "HEAD" || response.headers.has("content-length") || response.headers.has("transfer-encoding") || !FetchResponse.isResponseWithBody(response.status);
+		if (request.method !== "CONNECT" && !isSelfDelimitingResponse) {
+			/**
+			* @note Defer the end-of-stream signal so the HTTP parser has a chance
+			* to process already-pushed response data and fire the 'response' event
+			* before the socket is ended. Without this, the parser marks the response
+			* as "complete" before the client can interact with it (e.g. `response.destroy()`).
+			*/
+			await new Promise((resolve) => process.nextTick(resolve));
+			socket.push(null);
+		}
+	}
+	#modifyHttpHeaders(request) {
+		const transformRequestMessage = (httpMessage, encoding) => {
+			/**
+			* @note Socket can write a buffer (e.g. uploaded file) even before
+			* it writes the HTTP message. Bypass those cases.
+			*/
+			if (encoding === "buffer") return httpMessage;
+			const parts = httpMessage.toString(encoding).split("\r\n");
+			const headersEndIndex = parts.findIndex((field) => field === "");
+			const httpMessageHeaderPairs = parts.slice(1, headersEndIndex);
+			const httpMessageRawHeaders = httpMessageHeaderPairs.map((line) => {
+				const separatorIndex = line.indexOf(": ");
+				return [line.slice(0, separatorIndex), line.slice(separatorIndex + 2)];
+			});
+			const requestRawHeaders = getRawFetchHeaders(request.headers);
+			if (httpMessageRawHeaders.length === requestRawHeaders.length && httpMessageRawHeaders.every((tuple, index) => {
+				const requestTuple = requestRawHeaders[index];
+				return tuple[0] === requestTuple[0] && tuple[1] === requestTuple[1];
+			})) return httpMessage;
+			const httpMessageHeaders = FetchResponse.parseRawHeaders(httpMessageHeaderPairs.flatMap((header) => header.split(": ")));
+			const visitedHeaders = /* @__PURE__ */ new Set();
+			for (const [headerName] of requestRawHeaders) {
+				const normalizedHeaderName = headerName.toLowerCase();
+				if (visitedHeaders.has(normalizedHeaderName)) continue;
+				visitedHeaders.add(normalizedHeaderName);
+				/**
+				* @note Forbidden Fetch headers (e.g. Host, Origin, Connection)
+				* are stripped from `request.headers` but remain in the raw
+				* headers list. Skip them so the original values from the
+				* outgoing HTTP message are preserved.
+				*/
+				const headerValue = request.headers.get(headerName);
+				if (headerValue === null) continue;
+				httpMessageHeaders.set(headerName, headerValue);
+			}
+			visitedHeaders.clear();
+			const httpMessageHeadersString = Array.from(httpMessageHeaders).map(([name, value]) => `${name}: ${value}`).join("\r\n");
+			parts.splice(1, headersEndIndex - 1, httpMessageHeadersString);
+			return parts.join("\r\n");
+		};
+		return (pendingData, encoding, callback) => {
+			if (Array.isArray(pendingData)) pendingData[0].chunk = transformRequestMessage(pendingData[0].chunk, pendingData[0].encoding);
+			else pendingData = transformRequestMessage(pendingData, encoding);
+			callback(pendingData);
+		};
+	}
+};
+//#endregion
+export { requestContext as a, forwardHttpEvents as i, handleRequest as n, runInRequestContext as o, HttpResponseEvent as r, NodeHttpRequestSource as t };
+
+//# sourceMappingURL=source-lP0yyEtA.js.map