@mswjs/interceptors 0.41.9 → 0.42.1

package/lib/node/fetch-utils-Dw1PsmtX.js

@@ -0,0 +1,568 @@
+import { s as formatResponse } from "./buffer-utils-BvPY1Tc-.js";
+import { invariant } from "outvariant";
+//#region src/interceptor-error.ts
+var InterceptorError = class InterceptorError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InterceptorError";
+		Object.setPrototypeOf(this, InterceptorError.prototype);
+	}
+};
+//#endregion
+//#region src/request-controller.ts
+var RequestController = class RequestController {
+	static {
+		this.PENDING = 0;
+	}
+	static {
+		this.PASSTHROUGH = 1;
+	}
+	static {
+		this.RESPONSE = 2;
+	}
+	static {
+		this.ERROR = 3;
+	}
+	#handled;
+	constructor(request, source, options) {
+		this.request = request;
+		this.source = source;
+		this.options = options;
+		this.readyState = RequestController.PENDING;
+		this.#handled = Promise.withResolvers();
+		this.handled = this.#handled.promise;
+	}
+	/**
+	* Perform this request as-is.
+	*/
+	async passthrough() {
+		invariant.as(InterceptorError, this.readyState === RequestController.PENDING, "Failed to passthrough the \"%s %s\" request: the request has already been handled", this.request.method, this.request.url);
+		this.readyState = RequestController.PASSTHROUGH;
+		if (this.options) this.options.logger.info("[%s] passthrough", this.options.requestId);
+		await this.source.passthrough();
+		this.#handled.resolve();
+	}
+	/**
+	* Respond to this request with the given `Response` instance.
+	*
+	* @example
+	* controller.respondWith(new Response())
+	* controller.respondWith(Response.json({ id }))
+	* controller.respondWith(Response.error())
+	*/
+	respondWith(response) {
+		invariant.as(InterceptorError, this.readyState === RequestController.PENDING, "Failed to respond to the \"%s %s\" request with \"%d %s\": the request has already been handled (%d)", this.request.method, this.request.url, response.status, response.statusText || "OK", this.readyState);
+		this.readyState = RequestController.RESPONSE;
+		if (this.options?.logger.isEnabled("default")) {
+			const { logger, requestId } = this.options;
+			formatResponse(response).then((message) => {
+				logger.info("[%s] mocked %s", requestId, message);
+			});
+		}
+		this.#handled.resolve();
+		/**
+		* @note Although `source.respondWith()` is potentially asynchronous,
+		* do NOT await it for backward-compatibility. Awaiting it will short-circuit
+		* the request listener invocation as soon as a listener responds to a request.
+		* Ideally, that's what we want, but that's not what we promise the user.
+		*/
+		this.source.respondWith(response);
+	}
+	/**
+	* Error this request with the given reason.
+	*
+	* @example
+	* controller.errorWith()
+	* controller.errorWith(new Error('Oops!'))
+	* controller.errorWith({ message: 'Oops!'})
+	*/
+	errorWith(reason) {
+		invariant.as(InterceptorError, this.readyState === RequestController.PENDING, "Failed to error the \"%s %s\" request with \"%s\": the request has already been handled (%d)", this.request.method, this.request.url, reason?.toString(), this.readyState);
+		this.readyState = RequestController.ERROR;
+		if (this.options) this.options.logger.info("[%s] error %o", this.options.requestId, reason);
+		this.source.errorWith(reason);
+		this.#handled.resolve();
+	}
+};
+//#endregion
+//#region src/create-request-id.ts
+/**
+* Generate a random ID string to represent a request.
+* @example
+* createRequestId()
+* // "f774b6c9c600f"
+*/
+function createRequestId() {
+	return Math.random().toString(16).slice(2);
+}
+//#endregion
+//#region src/interceptors/ClientRequest/utils/record-raw-headers.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;
+			Object.setPrototypeOf(FetchRequest, OriginalRequest);
+			Object.setPrototypeOf(FetchRequest.prototype, OriginalRequest.prototype);
+			Object.setPrototypeOf(FetchResponse, OriginalResponse);
+			Object.setPrototypeOf(FetchResponse.prototype, OriginalResponse.prototype);
+			Reflect.deleteProperty(Headers, kRestorePatches);
+		},
+		enumerable: false,
+		/**
+		* @note Mark this property as configurable
+		* so we can delete it using `Reflect.delete` during cleanup.
+		*/
+		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 sanitizedHeaders = Reflect.get(headersInit, kRawHeaders).map((tuple) => [tuple[0], tuple[1]]);
+				const headers = Reflect.construct(target, [sanitizedHeaders], newTarget);
+				ensureRawHeadersSymbol(headers, [...sanitizedHeaders]);
+				return headers;
+			}
+			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[0], args[1]], "set");
+		return Reflect.apply(target, thisArg, args);
+	} });
+	Headers.prototype.append = new Proxy(Headers.prototype.append, { apply(target, thisArg, args) {
+		recordRawHeader(thisArg, [args[0], args[1]], "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;
+		} })
+	});
+	/**
+	* Re-parent FetchRequest/FetchResponse so their `super()` calls go
+	* through the proxied globalThis.Request/Response above. Without this,
+	* FetchRequest extends the statically-captured (original) Request,
+	* bypassing the construct proxy that records raw headers.
+	*/
+	Object.setPrototypeOf(FetchRequest, globalThis.Request);
+	Object.setPrototypeOf(FetchRequest.prototype, globalThis.Request.prototype);
+	Object.setPrototypeOf(FetchResponse, globalThis.Response);
+	Object.setPrototypeOf(FetchResponse.prototype, globalThis.Response.prototype);
+	return restoreHeadersPrototype;
+}
+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);
+}
+function copyRawHeaders(source, destination) {
+	const rawHeaders = [...getRawFetchHeaders(source)];
+	if (rawHeaders.length === 0) return;
+	/**
+	* @note Add headers from trhe destination that raw headers from the source
+	* don't have. Undici automatically appends a "Content-Type" header for responses
+	* and, for some reason, that change is not recorded. This preserves it.
+	*/
+	for (const [name, value] of destination) if (rawHeaders.every((header) => header[0].toLowerCase() !== name.toLowerCase())) rawHeaders.push([name, value]);
+	defineRawHeadersSymbol(destination, rawHeaders);
+}
+//#endregion
+//#region src/utils/get-value-by-symbol.ts
+/**
+* Returns the value behind the symbol with the given name.
+*/
+function getValueBySymbol(symbolName, source) {
+	const symbol = Object.getOwnPropertySymbols(source).find((symbol) => {
+		return symbol.description === symbolName;
+	});
+	if (symbol) return Reflect.get(source, symbol);
+}
+//#endregion
+//#region src/utils/is-object.ts
+/**
+* Determines if a given value is an instance of object.
+*/
+function isObject(value, loose = false) {
+	return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region src/utils/is-property-accessible.ts
+/**
+* A function that validates if property access is possible on an object
+* without throwing. It returns `true` if the property access is possible
+* and `false` otherwise.
+*
+* Environments like miniflare will throw on property access on certain objects
+* like Request and Response, for unimplemented properties.
+*/
+function isPropertyAccessible(obj, key) {
+	try {
+		obj[key];
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/utils/response-utils.ts
+/**
+* Creates a generic 500 Unhandled Exception response.
+*/
+function createServerErrorResponse(body) {
+	return new Response(JSON.stringify(body instanceof Error ? {
+		name: body.name,
+		message: body.message,
+		stack: body.stack
+	} : body), {
+		status: 500,
+		statusText: "Unhandled Exception",
+		headers: { "Content-Type": "application/json" }
+	});
+}
+/**
+* A key on the error a mocked `Response.error()` destroys the socket
+* with, referencing that error response. Allows the client-side
+* interceptors (e.g. fetch) to surface the error response to the
+* consumer instead of the internal socket error.
+*/
+const kErrorResponse = Symbol("kErrorResponse");
+/**
+* Get the mocked error response that caused the given error, if any.
+*/
+function getErrorResponse(error) {
+	if (error instanceof Error && kErrorResponse in error && isResponseError(error[kErrorResponse])) return error[kErrorResponse];
+}
+/**
+* Check if the given response is a `Response.error()`.
+*
+* @note Some environments, like Miniflare (Cloudflare) do not
+* implement the "Response.type" property and throw on its access.
+* Safely check if we can access "type" on "Response" before continuing.
+* @see https://github.com/mswjs/msw/issues/1834
+*/
+function isResponseError(response) {
+	return response != null && response instanceof Response && isPropertyAccessible(response, "type") && response.type === "error";
+}
+/**
+* Check if the given value is a `Response` or a Response-like object.
+* This is different from `value instanceof Response` because it supports
+* custom `Response` constructors, like the one when using Undici directly.
+*/
+function isResponseLike(value) {
+	return isObject(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
+}
+//#endregion
+//#region src/utils/fetch-utils.ts
+var FetchRequest = class FetchRequest extends Request {
+	static #resolveProperty(input, init = {}, key) {
+		return init[key] ?? (input instanceof Request ? input[key] : void 0);
+	}
+	/**
+	* Check if the given request method is configurable.
+	* @see https://fetch.spec.whatwg.org/#methods
+	*/
+	static isConfigurableMethod(method) {
+		return method !== "CONNECT" && method !== "TRACE" && method !== "TRACK";
+	}
+	static isMethodWithBody(method) {
+		return method !== "HEAD" && method !== "GET" && FetchRequest.isConfigurableMethod(method);
+	}
+	/**
+	* Check if the given request `mode` is configurable.
+	* @see https://fetch.spec.whatwg.org/#concept-request-mode
+	*/
+	static isConfigurableMode(mode) {
+		return mode !== "navigate" && mode !== "websocket" && mode !== "webtransport";
+	}
+	constructor(input, init) {
+		const method = FetchRequest.#resolveProperty(input, init, "method") || "GET";
+		const safeMethod = FetchRequest.isConfigurableMethod(method) ? method : "GET";
+		const hasExplicitBody = init != null && "body" in init;
+		/**
+		* Only include `body` in the super init when it needs to be overridden.
+		* When `input` is a Request and no explicit body is in `init`, let the
+		* Request constructor handle body transfer naturally so it properly
+		* marks the original request's body as consumed (bodyUsed = true).
+		*/
+		const bodyInit = !FetchRequest.isMethodWithBody(method) ? { body: void 0 } : hasExplicitBody ? { body: init.body } : {};
+		const mode = FetchRequest.#resolveProperty(input, init, "mode") ?? void 0;
+		const safeMode = FetchRequest.isConfigurableMode(mode) ? mode : void 0;
+		super(input, {
+			...init || {},
+			method: safeMethod,
+			mode: safeMode,
+			duplex: init?.duplex ?? (FetchRequest.isMethodWithBody(method) ? "half" : void 0),
+			...bodyInit
+		});
+		if (method !== safeMethod) this.#setInternalProperty("method", method);
+		if (method === "CONNECT") {
+			const url = new URL(input instanceof Request ? input.url : input);
+			let authority;
+			/**
+			* @note Node.js has a bug parsing raw CONNECT requests URLs like
+			* "http://127.0.0.1:1337/localhost:80". It would treat "localhost:" as a protocol.
+			*/
+			if (url.protocol === "localhost:") authority = url.href;
+			else authority = url.pathname.replace(/^\/+/, "");
+			/**
+			* @note Define "url" as a getter because Undici uses their own
+			* logic to resolve the "request.url" property. Simply reassigning
+			* its value doesn't do anything. This is a destructive action
+			* but it's safe because "CONNECT" requests are forbidden per fetch.
+			*/
+			Object.defineProperty(this, "url", {
+				get: () => authority,
+				enumerable: true,
+				configurable: true
+			});
+		}
+		if (mode != null && mode !== safeMode) this.#setInternalProperty("mode", mode);
+	}
+	#setInternalProperty(key, value) {
+		const internalState = getValueBySymbol("state", this);
+		if (internalState) Reflect.set(internalState, key, value);
+		else Object.defineProperty(this, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: false
+		});
+	}
+};
+const kStatus = Symbol("kStatus");
+const kUrl = Symbol("kUrl");
+var FetchResponse = class FetchResponse extends Response {
+	static from(response, init) {
+		if (response instanceof FetchResponse) return response;
+		if (isResponseError(response)) return response;
+		const fetchResponse = new FetchResponse(response.body, {
+			url: init?.url ?? response.url,
+			status: init?.status || response.status,
+			statusText: init?.statusText ?? response.statusText,
+			headers: init?.headers ?? response.headers
+		});
+		copyRawHeaders(response.headers, fetchResponse.headers);
+		return fetchResponse;
+	}
+	static {
+		this.STATUS_CODES_WITHOUT_BODY = [
+			101,
+			103,
+			204,
+			205,
+			304
+		];
+	}
+	static {
+		this.STATUS_CODES_WITH_REDIRECT = [
+			301,
+			302,
+			303,
+			307,
+			308
+		];
+	}
+	static isConfigurableStatusCode(status) {
+		return status >= 200 && status <= 599;
+	}
+	static isRedirectResponse(status) {
+		return FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status);
+	}
+	/**
+	* Returns a boolean indicating whether the given response status
+	* code represents a response that can have a body.
+	*/
+	static isResponseWithBody(status) {
+		return !FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status);
+	}
+	static setStatus(status, response) {
+		/**
+		* @note Undici keeps an internal "Symbol(state)" that holds
+		* the actual value of response status. Update that in Node.js.
+		*/
+		const internalState = getValueBySymbol("state", response);
+		if (internalState) internalState.status = status;
+		else Object.defineProperty(response, "status", {
+			value: status,
+			enumerable: true,
+			configurable: true,
+			writable: false
+		});
+		Object.defineProperty(response, kStatus, {
+			value: status,
+			enumerable: false
+		});
+	}
+	static setUrl(url, response) {
+		if (!url || url === "about:" || !URL.canParse(url)) return;
+		const state = getValueBySymbol("state", response);
+		if (state) state.urlList.push(new URL(url));
+		else Object.defineProperty(response, "url", {
+			value: url,
+			enumerable: true,
+			configurable: true,
+			writable: false
+		});
+		Object.defineProperty(response, kUrl, {
+			value: url,
+			enumerable: false
+		});
+	}
+	/**
+	* Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+	*/
+	static parseRawHeaders(rawHeaders) {
+		const headers = new Headers();
+		for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
+		return headers;
+	}
+	/**
+	* Safely clones the given `Response`.
+	* Coerces response clone exceptions into 500 mocked responses.
+	* Handy in the environments that introduce arbitrary response
+	* cloning restrictions, like "101 Switching Protocols" cloning
+	* in "miniflare".
+	*/
+	static clone(response) {
+		try {
+			return response.clone();
+		} catch (error) {
+			return Response.json(error instanceof Error ? {
+				name: error.name,
+				message: error.message,
+				stack: error.stack
+			} : {}, {
+				status: 500,
+				statusText: "Unclonable Response"
+			});
+		}
+	}
+	#status;
+	#url;
+	constructor(body, init = {}) {
+		const status = init.status ?? 200;
+		const safeStatus = FetchResponse.isConfigurableStatusCode(status) ? status : 200;
+		const finalBody = FetchResponse.isResponseWithBody(status) ? body : null;
+		super(finalBody, {
+			status: safeStatus,
+			statusText: init.statusText,
+			headers: init.headers
+		});
+		/**
+		* Since Node.js v24, Undici stores the Response state in an inaccessible field "#state".
+		* Forward the modified status/URL to the cloned response manually.
+		* @see https://github.com/nodejs/undici/blob/f734c87280e626c75f59aad55b65eb6a89cef392/lib/web/fetch/response.js#L242
+		*/
+		if (status !== safeStatus) FetchResponse.setStatus(status, this);
+		FetchResponse.setUrl(init.url, this);
+	}
+	clone() {
+		const clonedResponse = super.clone();
+		const customStatus = Reflect.get(this, kStatus);
+		if (customStatus) FetchResponse.setStatus(customStatus, clonedResponse);
+		const customUrl = Reflect.get(this, kUrl);
+		if (customUrl) FetchResponse.setUrl(customUrl, clonedResponse);
+		return clonedResponse;
+	}
+};
+//#endregion
+export { isResponseError as a, isObject as c, createRequestId as d, RequestController as f, getErrorResponse as i, getRawFetchHeaders as l, FetchResponse as n, isResponseLike as o, InterceptorError as p, createServerErrorResponse as r, kErrorResponse as s, FetchRequest as t, recordRawFetchHeaders as u };
+
+//# sourceMappingURL=fetch-utils-Dw1PsmtX.js.map

package/lib/node/fetch-utils-Dw1PsmtX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-utils-Dw1PsmtX.js","names":["#handled","#resolveProperty","#setInternalProperty"],"sources":["../../src/interceptor-error.ts","../../src/request-controller.ts","../../src/create-request-id.ts","../../src/interceptors/ClientRequest/utils/record-raw-headers.ts","../../src/utils/get-value-by-symbol.ts","../../src/utils/is-object.ts","../../src/utils/is-property-accessible.ts","../../src/utils/response-utils.ts","../../src/utils/fetch-utils.ts"],"sourcesContent":["export class InterceptorError extends Error {\n  constructor(message?: string) {\n    super(message)\n    this.name = 'InterceptorError'\n    Object.setPrototypeOf(this, InterceptorError.prototype)\n  }\n}\n","import { invariant } from 'outvariant'\nimport { InterceptorError } from './interceptor-error'\nimport { formatResponse, type Logger } from './utils/logger'\n\nexport interface RequestControllerSource {\n  passthrough(): void | Promise<void>\n  respondWith(response: Response): void | Promise<void>\n  errorWith(reason?: unknown): void | Promise<void>\n}\n\ninterface RequestControllerOptions {\n  logger: Logger\n  requestId: string\n}\n\nexport class RequestController {\n  static PENDING = 0 as const\n  static PASSTHROUGH = 1 as const\n  static RESPONSE = 2 as const\n  static ERROR = 3 as const\n\n  public readyState: number\n\n  /**\n   * A Promise that resolves when this controller handles a request.\n   * See `controller.readyState` for more information on the handling result.\n   */\n  public handled: Promise<void>\n\n  readonly #handled: PromiseWithResolvers<void>\n\n  constructor(\n    protected readonly request: Request,\n    protected readonly source: RequestControllerSource,\n    protected readonly options?: RequestControllerOptions\n  ) {\n    this.readyState = RequestController.PENDING\n    this.#handled = Promise.withResolvers<void>()\n    this.handled = this.#handled.promise\n  }\n\n  /**\n   * Perform this request as-is.\n   */\n  public async passthrough(): Promise<void> {\n    invariant.as(\n      InterceptorError,\n      this.readyState === RequestController.PENDING,\n      'Failed to passthrough the \"%s %s\" request: the request has already been handled',\n      this.request.method,\n      this.request.url\n    )\n\n    this.readyState = RequestController.PASSTHROUGH\n    if (this.options) {\n      this.options.logger.info('[%s] passthrough', this.options.requestId)\n    }\n    await this.source.passthrough()\n    this.#handled.resolve()\n  }\n\n  /**\n   * Respond to this request with the given `Response` instance.\n   *\n   * @example\n   * controller.respondWith(new Response())\n   * controller.respondWith(Response.json({ id }))\n   * controller.respondWith(Response.error())\n   */\n  public respondWith(response: Response): void {\n    invariant.as(\n      InterceptorError,\n      this.readyState === RequestController.PENDING,\n      'Failed to respond to the \"%s %s\" request with \"%d %s\": the request has already been handled (%d)',\n      this.request.method,\n      this.request.url,\n      response.status,\n      response.statusText || 'OK',\n      this.readyState\n    )\n\n    this.readyState = RequestController.RESPONSE\n    if (this.options?.logger.isEnabled('default')) {\n      const { logger, requestId } = this.options\n\n      void formatResponse(response).then((message) => {\n        logger.info('[%s] mocked %s', requestId, message)\n      })\n    }\n    this.#handled.resolve()\n\n    /**\n     * @note Although `source.respondWith()` is potentially asynchronous,\n     * do NOT await it for backward-compatibility. Awaiting it will short-circuit\n     * the request listener invocation as soon as a listener responds to a request.\n     * Ideally, that's what we want, but that's not what we promise the user.\n     */\n    this.source.respondWith(response)\n  }\n\n  /**\n   * Error this request with the given reason.\n   *\n   * @example\n   * controller.errorWith()\n   * controller.errorWith(new Error('Oops!'))\n   * controller.errorWith({ message: 'Oops!'})\n   */\n  public errorWith(reason?: unknown): void {\n    invariant.as(\n      InterceptorError,\n      this.readyState === RequestController.PENDING,\n      'Failed to error the \"%s %s\" request with \"%s\": the request has already been handled (%d)',\n      this.request.method,\n      this.request.url,\n      reason?.toString(),\n      this.readyState\n    )\n\n    this.readyState = RequestController.ERROR\n    if (this.options) {\n      this.options.logger.info(\n        '[%s] error %o',\n        this.options.requestId,\n        reason\n      )\n    }\n    this.source.errorWith(reason)\n    this.#handled.resolve()\n  }\n}\n","/**\n * Generate a random ID string to represent a request.\n * @example\n * createRequestId()\n * // \"f774b6c9c600f\"\n */\nexport function createRequestId(): string {\n  return Math.random().toString(16).slice(2)\n}\n","import { FetchRequest, FetchResponse } from '../../../utils/fetch-utils'\n\ntype HeaderTuple = [string, string]\ntype RawHeaders = Array<HeaderTuple>\ntype SetHeaderBehavior = 'set' | 'append'\n\nconst kRawHeaders = Symbol('kRawHeaders')\nconst kRestorePatches = Symbol('kRestorePatches')\n\nfunction recordRawHeader(\n  headers: Headers,\n  args: HeaderTuple,\n  behavior: SetHeaderBehavior\n) {\n  ensureRawHeadersSymbol(headers, [])\n  const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders\n\n  if (behavior === 'set') {\n    // When recording a set header, ensure we remove any matching existing headers.\n    for (let index = rawHeaders.length - 1; index >= 0; index--) {\n      if (rawHeaders[index][0].toLowerCase() === args[0].toLowerCase()) {\n        rawHeaders.splice(index, 1)\n      }\n    }\n  }\n\n  rawHeaders.push(args)\n}\n\n/**\n * Define the raw headers symbol on the given `Headers` instance.\n * If the symbol already exists, this function does nothing.\n */\nfunction ensureRawHeadersSymbol(\n  headers: Headers,\n  rawHeaders: RawHeaders\n): void {\n  if (Reflect.has(headers, kRawHeaders)) {\n    return\n  }\n\n  defineRawHeadersSymbol(headers, rawHeaders)\n}\n\n/**\n * Define the raw headers symbol on the given `Headers` instance.\n * If the symbol already exists, it gets overridden.\n */\nfunction defineRawHeadersSymbol(headers: Headers, rawHeaders: RawHeaders) {\n  Object.defineProperty(headers, kRawHeaders, {\n    value: rawHeaders,\n    enumerable: false,\n    // Mark the symbol as configurable so its value can be overridden.\n    // Overrides happen when merging raw headers from multiple sources.\n    // E.g. new Request(new Request(url, { headers }), { headers })\n    configurable: true,\n  })\n}\n\n/**\n * Patch the global `Headers` class to store raw headers.\n * This is for compatibility with `IncomingMessage.prototype.rawHeaders`.\n *\n * @note Node.js has their own raw headers symbol but it\n * only records the first header name in case of multi-value headers.\n * Any other headers are normalized before comparing. This makes it\n * incompatible with the `rawHeaders` format.\n *\n * let h = new Headers()\n * h.append('X-Custom', 'one')\n * h.append('x-custom', 'two')\n * h[Symbol('headers map')] // Map { 'X-Custom' => 'one, two' }\n */\nexport function recordRawFetchHeaders(): () => void {\n  // Prevent patching the Headers prototype multiple times.\n  if (Reflect.get(Headers, kRestorePatches)) {\n    return Reflect.get(Headers, kRestorePatches)\n  }\n\n  const {\n    Headers: OriginalHeaders,\n    Request: OriginalRequest,\n    Response: OriginalResponse,\n  } = globalThis\n  const { set, append, delete: headersDeleteMethod } = Headers.prototype\n\n  Object.defineProperty(Headers, kRestorePatches, {\n    value: () => {\n      Headers.prototype.set = set\n      Headers.prototype.append = append\n      Headers.prototype.delete = headersDeleteMethod\n      globalThis.Headers = OriginalHeaders\n\n      globalThis.Request = OriginalRequest\n      globalThis.Response = OriginalResponse\n\n      Object.setPrototypeOf(FetchRequest, OriginalRequest)\n      Object.setPrototypeOf(FetchRequest.prototype, OriginalRequest.prototype)\n      Object.setPrototypeOf(FetchResponse, OriginalResponse)\n      Object.setPrototypeOf(FetchResponse.prototype, OriginalResponse.prototype)\n\n      Reflect.deleteProperty(Headers, kRestorePatches)\n    },\n    enumerable: false,\n    /**\n     * @note Mark this property as configurable\n     * so we can delete it using `Reflect.delete` during cleanup.\n     */\n    configurable: true,\n  })\n\n  Object.defineProperty(globalThis, 'Headers', {\n    enumerable: true,\n    writable: true,\n    value: new Proxy(Headers, {\n      construct(target, args, newTarget) {\n        const headersInit = args[0] || []\n\n        if (\n          headersInit instanceof Headers &&\n          Reflect.has(headersInit, kRawHeaders)\n        ) {\n          // Ensure each header tuple has exactly 2 elements (name, value).\n          // Node.js 24+ may have stored tuples with extra internal arguments.\n          const rawHeadersFromInit = Reflect.get(\n            headersInit,\n            kRawHeaders\n          ) as RawHeaders\n          const sanitizedHeaders = rawHeadersFromInit.map(\n            (tuple): HeaderTuple => [tuple[0], tuple[1]]\n          )\n          const headers = Reflect.construct(\n            target,\n            [sanitizedHeaders],\n            newTarget\n          )\n          ensureRawHeadersSymbol(headers, [\n            /**\n             * @note Spread the retrieved headers to clone them.\n             * This prevents multiple Headers instances from pointing\n             * at the same internal \"rawHeaders\" array.\n             */\n            ...sanitizedHeaders,\n          ])\n          return headers\n        }\n\n        const headers = Reflect.construct(target, args, newTarget)\n\n        // Request/Response constructors will set the symbol\n        // upon creating a new instance, using the raw developer\n        // input as the raw headers. Skip the symbol altogether\n        // in those cases because the input to Headers will be normalized.\n        if (!Reflect.has(headers, kRawHeaders)) {\n          const rawHeadersInit = Array.isArray(headersInit)\n            ? headersInit\n            : Object.entries(headersInit)\n          ensureRawHeadersSymbol(headers, rawHeadersInit)\n        }\n\n        return headers\n      },\n    }),\n  })\n\n  Headers.prototype.set = new Proxy(Headers.prototype.set, {\n    apply(target, thisArg, args: HeaderTuple) {\n      // Use only the first two arguments (name, value) to record raw headers.\n      // Node.js 24+ may pass additional internal arguments that should not\n      // be included in the raw headers array.\n      recordRawHeader(thisArg, [args[0], args[1]], 'set')\n      return Reflect.apply(target, thisArg, args)\n    },\n  })\n\n  Headers.prototype.append = new Proxy(Headers.prototype.append, {\n    apply(target, thisArg, args: HeaderTuple) {\n      // Use only the first two arguments (name, value) to record raw headers.\n      // Node.js 24+ may pass additional internal arguments that should not\n      // be included in the raw headers array.\n      recordRawHeader(thisArg, [args[0], args[1]], 'append')\n      return Reflect.apply(target, thisArg, args)\n    },\n  })\n\n  Headers.prototype.delete = new Proxy(Headers.prototype.delete, {\n    apply(target, thisArg, args: [string]) {\n      const rawHeaders = Reflect.get(thisArg, kRawHeaders) as RawHeaders\n\n      if (rawHeaders) {\n        for (let index = rawHeaders.length - 1; index >= 0; index--) {\n          if (rawHeaders[index][0].toLowerCase() === args[0].toLowerCase()) {\n            rawHeaders.splice(index, 1)\n          }\n        }\n      }\n\n      return Reflect.apply(target, thisArg, args)\n    },\n  })\n\n  Object.defineProperty(globalThis, 'Request', {\n    enumerable: true,\n    writable: true,\n    value: new Proxy(Request, {\n      construct(target, args, newTarget) {\n        const request = Reflect.construct(target, args, newTarget)\n        const inferredRawHeaders: RawHeaders = []\n\n        // Infer raw headers from a `Request` instance used as init.\n        if (typeof args[0] === 'object' && args[0].headers != null) {\n          inferredRawHeaders.push(...inferRawHeaders(args[0].headers))\n        }\n\n        // Infer raw headers from the \"headers\" init argument.\n        if (typeof args[1] === 'object' && args[1].headers != null) {\n          inferredRawHeaders.push(...inferRawHeaders(args[1].headers))\n        }\n\n        if (inferredRawHeaders.length > 0) {\n          ensureRawHeadersSymbol(request.headers, inferredRawHeaders)\n        }\n\n        return request\n      },\n    }),\n  })\n\n  Object.defineProperty(globalThis, 'Response', {\n    enumerable: true,\n    writable: true,\n    value: new Proxy(Response, {\n      construct(target, args, newTarget) {\n        const response = Reflect.construct(target, args, newTarget)\n\n        if (typeof args[1] === 'object' && args[1].headers != null) {\n          ensureRawHeadersSymbol(\n            response.headers,\n            inferRawHeaders(args[1].headers)\n          )\n        }\n\n        return response\n      },\n    }),\n  })\n\n  /**\n   * Re-parent FetchRequest/FetchResponse so their `super()` calls go\n   * through the proxied globalThis.Request/Response above. Without this,\n   * FetchRequest extends the statically-captured (original) Request,\n   * bypassing the construct proxy that records raw headers.\n   */\n  Object.setPrototypeOf(FetchRequest, globalThis.Request)\n  Object.setPrototypeOf(FetchRequest.prototype, globalThis.Request.prototype)\n  Object.setPrototypeOf(FetchResponse, globalThis.Response)\n  Object.setPrototypeOf(FetchResponse.prototype, globalThis.Response.prototype)\n\n  return restoreHeadersPrototype\n}\n\nexport function restoreHeadersPrototype() {\n  if (!Reflect.get(Headers, kRestorePatches)) {\n    return\n  }\n\n  Reflect.get(Headers, kRestorePatches)()\n}\n\nexport function getRawFetchHeaders(headers: Headers): RawHeaders {\n  // If the raw headers recording failed for some reason,\n  // use the normalized header entries instead.\n  if (!Reflect.has(headers, kRawHeaders)) {\n    return Array.from(headers.entries())\n  }\n\n  const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders\n  return rawHeaders.length > 0 ? rawHeaders : Array.from(headers.entries())\n}\n\n/**\n * Infers the raw headers from the given `HeadersInit` provided\n * to the Request/Response constructor.\n *\n * If the `init.headers` is a Headers instance, use it directly.\n * That means the headers were created standalone and already have\n * the raw headers stored.\n * If the `init.headers` is a HeadersInit, create a new Headers\n * instance out of it.\n */\nfunction inferRawHeaders(headers: HeadersInit): RawHeaders {\n  if (headers instanceof Headers) {\n    return Reflect.get(headers, kRawHeaders) || []\n  }\n\n  return Reflect.get(new Headers(headers), kRawHeaders)\n}\n\nexport function copyRawHeaders(source: Headers, destination: Headers): void {\n  const rawHeaders = [...getRawFetchHeaders(source)]\n\n  if (rawHeaders.length === 0) {\n    return\n  }\n\n  /**\n   * @note Add headers from trhe destination that raw headers from the source\n   * don't have. Undici automatically appends a \"Content-Type\" header for responses\n   * and, for some reason, that change is not recorded. This preserves it.\n   */\n  for (const [name, value] of destination) {\n    if (\n      rawHeaders.every(\n        (header) => header[0].toLowerCase() !== name.toLowerCase()\n      )\n    ) {\n      rawHeaders.push([name, value])\n    }\n  }\n\n  defineRawHeadersSymbol(destination, rawHeaders)\n}\n","/**\n * Returns the value behind the symbol with the given name.\n */\nexport function getValueBySymbol<T>(\n  symbolName: string,\n  source: object\n): T | undefined {\n  const ownSymbols = Object.getOwnPropertySymbols(source)\n\n  const symbol = ownSymbols.find((symbol) => {\n    return symbol.description === symbolName\n  })\n\n  if (symbol) {\n    return Reflect.get(source, symbol)\n  }\n\n  return\n}\n","/**\n * Determines if a given value is an instance of object.\n */\nexport function isObject<T>(value: any, loose = false): value is T {\n  return loose\n    ? Object.prototype.toString.call(value).startsWith('[object ')\n    : Object.prototype.toString.call(value) === '[object Object]'\n}\n","/**\n * A function that validates if property access is possible on an object\n * without throwing. It returns `true` if the property access is possible\n * and `false` otherwise.\n *\n * Environments like miniflare will throw on property access on certain objects\n * like Request and Response, for unimplemented properties.\n */\nexport function isPropertyAccessible<Obj extends Record<string, any>>(\n  obj: Obj,\n  key: keyof Obj\n) {\n  try {\n    obj[key]\n    return true\n  } catch {\n    return false\n  }\n}\n","import { isObject } from './is-object'\nimport { isPropertyAccessible } from './is-property-accessible'\n\n/**\n * Creates a generic 500 Unhandled Exception response.\n */\nexport function createServerErrorResponse(body: unknown): Response {\n  return new Response(\n    JSON.stringify(\n      body instanceof Error\n        ? {\n            name: body.name,\n            message: body.message,\n            stack: body.stack,\n          }\n        : body\n    ),\n    {\n      status: 500,\n      statusText: 'Unhandled Exception',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n    }\n  )\n}\n\nexport type ResponseError = Response & { type: 'error' }\n\n/**\n * A key on the error a mocked `Response.error()` destroys the socket\n * with, referencing that error response. Allows the client-side\n * interceptors (e.g. fetch) to surface the error response to the\n * consumer instead of the internal socket error.\n */\nexport const kErrorResponse = Symbol('kErrorResponse')\n\n/**\n * Get the mocked error response that caused the given error, if any.\n */\nexport function getErrorResponse(error: unknown): ResponseError | undefined {\n  if (\n    error instanceof Error &&\n    kErrorResponse in error &&\n    isResponseError(error[kErrorResponse])\n  ) {\n    return error[kErrorResponse]\n  }\n\n  return undefined\n}\n\n/**\n * Check if the given response is a `Response.error()`.\n *\n * @note Some environments, like Miniflare (Cloudflare) do not\n * implement the \"Response.type\" property and throw on its access.\n * Safely check if we can access \"type\" on \"Response\" before continuing.\n * @see https://github.com/mswjs/msw/issues/1834\n */\nexport function isResponseError(response: unknown): response is ResponseError {\n  return (\n    response != null &&\n    response instanceof Response &&\n    isPropertyAccessible(response, 'type') &&\n    response.type === 'error'\n  )\n}\n\n/**\n * Check if the given value is a `Response` or a Response-like object.\n * This is different from `value instanceof Response` because it supports\n * custom `Response` constructors, like the one when using Undici directly.\n */\nexport function isResponseLike(value: unknown): value is Response {\n  return (\n    isObject<Record<string, any>>(value, true) &&\n    isPropertyAccessible(value, 'status') &&\n    isPropertyAccessible(value, 'statusText') &&\n    isPropertyAccessible(value, 'bodyUsed')\n  )\n}\n","import { copyRawHeaders } from '../interceptors/ClientRequest/utils/record-raw-headers'\nimport { getValueBySymbol } from './get-value-by-symbol'\nimport { isResponseError } from './response-utils'\n\ninterface UndiciRequestState extends RequestInit {}\n\ninterface FetchRequestInit extends Omit<RequestInit, 'mode'> {\n  mode?: RequestMode | 'websocket' | 'webtransport'\n  duplex?: 'half' | 'full'\n}\n\nexport class FetchRequest extends Request {\n  static #resolveProperty<T extends keyof FetchRequestInit & keyof Request>(\n    input: RequestInfo | URL,\n    init: FetchRequestInit = {},\n    key: T\n  ): FetchRequestInit[T] {\n    return init[key] ?? (input instanceof Request ? input[key] : undefined)\n  }\n\n  /**\n   * Check if the given request method is configurable.\n   * @see https://fetch.spec.whatwg.org/#methods\n   */\n  static isConfigurableMethod(method: string): boolean {\n    return method !== 'CONNECT' && method !== 'TRACE' && method !== 'TRACK'\n  }\n\n  static isMethodWithBody(method: string): boolean {\n    return (\n      method !== 'HEAD' &&\n      method !== 'GET' &&\n      FetchRequest.isConfigurableMethod(method)\n    )\n  }\n\n  /**\n   * Check if the given request `mode` is configurable.\n   * @see https://fetch.spec.whatwg.org/#concept-request-mode\n   */\n  static isConfigurableMode(mode: string): boolean {\n    return (\n      mode !== 'navigate' && mode !== 'websocket' && mode !== 'webtransport'\n    )\n  }\n\n  constructor(input: URL | RequestInfo, init?: FetchRequestInit) {\n    const method = FetchRequest.#resolveProperty(input, init, 'method') || 'GET'\n    const safeMethod = FetchRequest.isConfigurableMethod(method)\n      ? method\n      : 'GET'\n\n    const hasExplicitBody = init != null && 'body' in init\n\n    /**\n     * Only include `body` in the super init when it needs to be overridden.\n     * When `input` is a Request and no explicit body is in `init`, let the\n     * Request constructor handle body transfer naturally so it properly\n     * marks the original request's body as consumed (bodyUsed = true).\n     */\n    const bodyInit: { body?: BodyInit | null } = !FetchRequest.isMethodWithBody(\n      method\n    )\n      ? { body: undefined }\n      : hasExplicitBody\n        ? { body: init.body }\n        : {}\n\n    const mode =\n      (FetchRequest.#resolveProperty(input, init, 'mode') as RequestMode) ??\n      undefined\n    const safeMode = FetchRequest.isConfigurableMode(mode) ? mode : undefined\n\n    super(input, {\n      ...(init || {}),\n      method: safeMethod,\n      mode: safeMode,\n      // @ts-expect-error Untyped Node.js property.\n      duplex:\n        init?.duplex ??\n        (FetchRequest.isMethodWithBody(method) ? 'half' : undefined),\n      ...bodyInit,\n    })\n\n    if (method !== safeMethod) {\n      this.#setInternalProperty('method', method)\n    }\n\n    if (method === 'CONNECT') {\n      const url = new URL(input instanceof Request ? input.url : input)\n\n      let authority: string\n\n      /**\n       * @note Node.js has a bug parsing raw CONNECT requests URLs like\n       * \"http://127.0.0.1:1337/localhost:80\". It would treat \"localhost:\" as a protocol.\n       */\n      if (url.protocol === 'localhost:') {\n        authority = url.href\n      } else {\n        authority = url.pathname.replace(/^\\/+/, '')\n      }\n\n      /**\n       * @note Define \"url\" as a getter because Undici uses their own\n       * logic to resolve the \"request.url\" property. Simply reassigning\n       * its value doesn't do anything. This is a destructive action\n       * but it's safe because \"CONNECT\" requests are forbidden per fetch.\n       */\n      Object.defineProperty(this, 'url', {\n        get: () => authority,\n        enumerable: true,\n        configurable: true,\n      })\n    }\n\n    if (mode != null && mode !== safeMode) {\n      this.#setInternalProperty('mode', mode)\n    }\n  }\n\n  #setInternalProperty<T extends keyof Request>(\n    key: T,\n    value: Request[T]\n  ): void {\n    const internalState = getValueBySymbol<UndiciRequestState>('state', this)\n\n    if (internalState) {\n      Reflect.set(internalState, key, value)\n    } else {\n      Object.defineProperty(this, key, {\n        value,\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n  }\n}\n\nexport interface FetchResponseInit extends ResponseInit {\n  url?: string\n}\n\ninterface UndiciResponseState {\n  aborted: boolean\n  rangeRequested: boolean\n  timingAllowPassed: boolean\n  requestIncludesCredentials: boolean\n  type: ResponseType\n  status: number\n  statusText: string\n  timingInfo: unknown\n  cacheState: unknown\n  headersList: Record<symbol, Map<string, unknown>>\n  urlList: Array<URL>\n  body?: {\n    stream: ReadableStream\n    source: unknown\n    length: number\n  }\n}\n\nconst kStatus = Symbol('kStatus')\nconst kUrl = Symbol('kUrl')\n\nexport class FetchResponse extends Response {\n  static from(response: Response, init?: FetchResponseInit): FetchResponse {\n    if (response instanceof FetchResponse) {\n      return response\n    }\n\n    if (isResponseError(response)) {\n      return response\n    }\n\n    const fetchResponse = new FetchResponse(response.body, {\n      url: init?.url ?? response.url,\n      status: init?.status || response.status,\n      statusText: init?.statusText ?? response.statusText,\n      headers: init?.headers ?? response.headers,\n    })\n\n    copyRawHeaders(response.headers, fetchResponse.headers)\n\n    return fetchResponse\n  }\n\n  /**\n   * Response status codes for responses that cannot have body.\n   * @see https://fetch.spec.whatwg.org/#statuses\n   */\n  static readonly STATUS_CODES_WITHOUT_BODY = [101, 103, 204, 205, 304]\n\n  static readonly STATUS_CODES_WITH_REDIRECT = [301, 302, 303, 307, 308]\n\n  static isConfigurableStatusCode(status: number): boolean {\n    return status >= 200 && status <= 599\n  }\n\n  static isRedirectResponse(status: number): boolean {\n    return FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status)\n  }\n\n  /**\n   * Returns a boolean indicating whether the given response status\n   * code represents a response that can have a body.\n   */\n  static isResponseWithBody(status: number): boolean {\n    return !FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status)\n  }\n\n  static setStatus(status: number, response: Response): void {\n    /**\n     * @note Undici keeps an internal \"Symbol(state)\" that holds\n     * the actual value of response status. Update that in Node.js.\n     */\n    const internalState = getValueBySymbol<UndiciResponseState>(\n      'state',\n      response\n    )\n\n    if (internalState) {\n      internalState.status = status\n    } else {\n      Object.defineProperty(response, 'status', {\n        value: status,\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n\n    Object.defineProperty(response, kStatus, {\n      value: status,\n      enumerable: false,\n    })\n  }\n\n  static setUrl(url: string | undefined, response: Response): void {\n    if (!url || url === 'about:' || !URL.canParse(url)) {\n      return\n    }\n\n    const state = getValueBySymbol<UndiciResponseState>('state', response)\n\n    if (state) {\n      // In Undici, push the URL to the internal list of URLs.\n      // This will respect the `response.url` getter logic correctly.\n      state.urlList.push(new URL(url))\n    } else {\n      // In other libraries, redefine the `url` property directly.\n      Object.defineProperty(response, 'url', {\n        value: url,\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n\n    Object.defineProperty(response, kUrl, {\n      value: url,\n      enumerable: false,\n    })\n  }\n\n  /**\n   * Parses the given raw HTTP headers into a Fetch API `Headers` instance.\n   */\n  static parseRawHeaders(rawHeaders: Array<string>): Headers {\n    const headers = new Headers()\n\n    for (let line = 0; line < rawHeaders.length; line += 2) {\n      headers.append(rawHeaders[line], rawHeaders[line + 1])\n    }\n\n    return headers\n  }\n\n  /**\n   * Safely clones the given `Response`.\n   * Coerces response clone exceptions into 500 mocked responses.\n   * Handy in the environments that introduce arbitrary response\n   * cloning restrictions, like \"101 Switching Protocols\" cloning\n   * in \"miniflare\".\n   */\n  static clone(response: Response): Response {\n    try {\n      const clone = response.clone()\n      return clone\n    } catch (error) {\n      return Response.json(\n        error instanceof Error\n          ? {\n              name: error.name,\n              message: error.message,\n              stack: error.stack,\n            }\n          : {},\n        {\n          status: 500,\n          statusText: 'Unclonable Response',\n        }\n      )\n    }\n  }\n\n  #status?: number\n  #url?: string\n\n  constructor(body?: BodyInit | null, init: FetchResponseInit = {}) {\n    const status = init.status ?? 200\n    const safeStatus = FetchResponse.isConfigurableStatusCode(status)\n      ? status\n      : 200\n    const finalBody = FetchResponse.isResponseWithBody(status) ? body : null\n\n    super(finalBody, {\n      status: safeStatus,\n      statusText: init.statusText,\n      headers: init.headers,\n    })\n\n    /**\n     * Since Node.js v24, Undici stores the Response state in an inaccessible field \"#state\".\n     * Forward the modified status/URL to the cloned response manually.\n     * @see https://github.com/nodejs/undici/blob/f734c87280e626c75f59aad55b65eb6a89cef392/lib/web/fetch/response.js#L242\n     */\n    if (status !== safeStatus) {\n      FetchResponse.setStatus(status, this)\n    }\n\n    FetchResponse.setUrl(init.url, this)\n  }\n\n  public clone() {\n    const clonedResponse = super.clone()\n\n    const customStatus = Reflect.get(this, kStatus) as number | undefined\n\n    if (customStatus) {\n      FetchResponse.setStatus(customStatus, clonedResponse)\n    }\n\n    const customUrl = Reflect.get(this, kUrl) as string | undefined\n\n    if (customUrl) {\n      FetchResponse.setUrl(customUrl, clonedResponse)\n    }\n\n    return clonedResponse\n  }\n}\n"],"mappings":";;;AAAA,IAAa,mBAAb,MAAa,yBAAyB,MAAM;CAC1C,YAAY,SAAkB;EAC5B,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,OAAO,eAAe,MAAM,iBAAiB,SAAS;CACxD;AACF;;;ACSA,IAAa,oBAAb,MAAa,kBAAkB;;EACZ,KAAA,UAAA;;;EACI,KAAA,cAAA;;;EACH,KAAA,WAAA;;;EACH,KAAA,QAAA;;CAUf;CAEA,YACE,SACA,QACA,SACA;EAHmB,KAAA,UAAA;EACA,KAAA,SAAA;EACA,KAAA,UAAA;EAEnB,KAAK,aAAa,kBAAkB;EACpC,KAAKA,WAAW,QAAQ,cAAoB;EAC5C,KAAK,UAAU,KAAKA,SAAS;CAC/B;;;;CAKA,MAAa,cAA6B;EACxC,UAAU,GACR,kBACA,KAAK,eAAe,kBAAkB,SACtC,qFACA,KAAK,QAAQ,QACb,KAAK,QAAQ,GACf;EAEA,KAAK,aAAa,kBAAkB;EACpC,IAAI,KAAK,SACP,KAAK,QAAQ,OAAO,KAAK,oBAAoB,KAAK,QAAQ,SAAS;EAErE,MAAM,KAAK,OAAO,YAAY;EAC9B,KAAKA,SAAS,QAAQ;CACxB;;;;;;;;;CAUA,YAAmB,UAA0B;EAC3C,UAAU,GACR,kBACA,KAAK,eAAe,kBAAkB,SACtC,wGACA,KAAK,QAAQ,QACb,KAAK,QAAQ,KACb,SAAS,QACT,SAAS,cAAc,MACvB,KAAK,UACP;EAEA,KAAK,aAAa,kBAAkB;EACpC,IAAI,KAAK,SAAS,OAAO,UAAU,SAAS,GAAG;GAC7C,MAAM,EAAE,QAAQ,cAAc,KAAK;GAEnC,eAAoB,QAAQ,CAAC,CAAC,MAAM,YAAY;IAC9C,OAAO,KAAK,kBAAkB,WAAW,OAAO;GAClD,CAAC;EACH;EACA,KAAKA,SAAS,QAAQ;;;;;;;EAQtB,KAAK,OAAO,YAAY,QAAQ;CAClC;;;;;;;;;CAUA,UAAiB,QAAwB;EACvC,UAAU,GACR,kBACA,KAAK,eAAe,kBAAkB,SACtC,gGACA,KAAK,QAAQ,QACb,KAAK,QAAQ,KACb,QAAQ,SAAS,GACjB,KAAK,UACP;EAEA,KAAK,aAAa,kBAAkB;EACpC,IAAI,KAAK,SACP,KAAK,QAAQ,OAAO,KAClB,iBACA,KAAK,QAAQ,WACb,MACF;EAEF,KAAK,OAAO,UAAU,MAAM;EAC5B,KAAKA,SAAS,QAAQ;CACxB;AACF;;;;;;;;;AC5HA,SAAgB,kBAA0B;CACxC,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC;AAC3C;;;ACFA,MAAM,cAAc,OAAO,aAAa;AACxC,MAAM,kBAAkB,OAAO,iBAAiB;AAEhD,SAAS,gBACP,SACA,MACA,UACA;CACA,uBAAuB,SAAS,CAAC,CAAC;CAClC,MAAM,aAAa,QAAQ,IAAI,SAAS,WAAW;CAEnD,IAAI,aAAa,OAEV;OAAA,IAAI,QAAQ,WAAW,SAAS,GAAG,SAAS,GAAG,SAClD,IAAI,WAAW,MAAM,CAAC,EAAE,CAAC,YAAY,MAAM,KAAK,EAAE,CAAC,YAAY,GAC7D,WAAW,OAAO,OAAO,CAAC;CAAA;CAKhC,WAAW,KAAK,IAAI;AACtB;;;;;AAMA,SAAS,uBACP,SACA,YACM;CACN,IAAI,QAAQ,IAAI,SAAS,WAAW,GAClC;CAGF,uBAAuB,SAAS,UAAU;AAC5C;;;;;AAMA,SAAS,uBAAuB,SAAkB,YAAwB;CACxE,OAAO,eAAe,SAAS,aAAa;EAC1C,OAAO;EACP,YAAY;EAIZ,cAAc;CAChB,CAAC;AACH;;;;;;;;;;;;;;;AAgBA,SAAgB,wBAAoC;CAElD,IAAI,QAAQ,IAAI,SAAS,eAAe,GACtC,OAAO,QAAQ,IAAI,SAAS,eAAe;CAG7C,MAAM,EACJ,SAAS,iBACT,SAAS,iBACT,UAAU,qBACR;CACJ,MAAM,EAAE,KAAK,QAAQ,QAAQ,wBAAwB,QAAQ;CAE7D,OAAO,eAAe,SAAS,iBAAiB;EAC9C,aAAa;GACX,QAAQ,UAAU,MAAM;GACxB,QAAQ,UAAU,SAAS;GAC3B,QAAQ,UAAU,SAAS;GAC3B,WAAW,UAAU;GAErB,WAAW,UAAU;GACrB,WAAW,WAAW;GAEtB,OAAO,eAAe,cAAc,eAAe;GACnD,OAAO,eAAe,aAAa,WAAW,gBAAgB,SAAS;GACvE,OAAO,eAAe,eAAe,gBAAgB;GACrD,OAAO,eAAe,cAAc,WAAW,iBAAiB,SAAS;GAEzE,QAAQ,eAAe,SAAS,eAAe;EACjD;EACA,YAAY;;;;;EAKZ,cAAc;CAChB,CAAC;CAED,OAAO,eAAe,YAAY,WAAW;EAC3C,YAAY;EACZ,UAAU;EACV,OAAO,IAAI,MAAM,SAAS,EACxB,UAAU,QAAQ,MAAM,WAAW;GACjC,MAAM,cAAc,KAAK,MAAM,CAAC;GAEhC,IACE,uBAAuB,WACvB,QAAQ,IAAI,aAAa,WAAW,GACpC;IAOA,MAAM,mBAJqB,QAAQ,IACjC,aACA,WAEwC,CAAC,CAAC,KACzC,UAAuB,CAAC,MAAM,IAAI,MAAM,EAAE,CAC7C;IACA,MAAM,UAAU,QAAQ,UACtB,QACA,CAAC,gBAAgB,GACjB,SACF;IACA,uBAAuB,SAAS,CAM9B,GAAG,gBACL,CAAC;IACD,OAAO;GACT;GAEA,MAAM,UAAU,QAAQ,UAAU,QAAQ,MAAM,SAAS;GAMzD,IAAI,CAAC,QAAQ,IAAI,SAAS,WAAW,GAInC,uBAAuB,SAHA,MAAM,QAAQ,WAAW,IAC5C,cACA,OAAO,QAAQ,WAAW,CACgB;GAGhD,OAAO;EACT,EACF,CAAC;CACH,CAAC;CAED,QAAQ,UAAU,MAAM,IAAI,MAAM,QAAQ,UAAU,KAAK,EACvD,MAAM,QAAQ,SAAS,MAAmB;EAIxC,gBAAgB,SAAS,CAAC,KAAK,IAAI,KAAK,EAAE,GAAG,KAAK;EAClD,OAAO,QAAQ,MAAM,QAAQ,SAAS,IAAI;CAC5C,EACF,CAAC;CAED,QAAQ,UAAU,SAAS,IAAI,MAAM,QAAQ,UAAU,QAAQ,EAC7D,MAAM,QAAQ,SAAS,MAAmB;EAIxC,gBAAgB,SAAS,CAAC,KAAK,IAAI,KAAK,EAAE,GAAG,QAAQ;EACrD,OAAO,QAAQ,MAAM,QAAQ,SAAS,IAAI;CAC5C,EACF,CAAC;CAED,QAAQ,UAAU,SAAS,IAAI,MAAM,QAAQ,UAAU,QAAQ,EAC7D,MAAM,QAAQ,SAAS,MAAgB;EACrC,MAAM,aAAa,QAAQ,IAAI,SAAS,WAAW;EAEnD,IAAI,YACG;QAAA,IAAI,QAAQ,WAAW,SAAS,GAAG,SAAS,GAAG,SAClD,IAAI,WAAW,MAAM,CAAC,EAAE,CAAC,YAAY,MAAM,KAAK,EAAE,CAAC,YAAY,GAC7D,WAAW,OAAO,OAAO,CAAC;EAAA;EAKhC,OAAO,QAAQ,MAAM,QAAQ,SAAS,IAAI;CAC5C,EACF,CAAC;CAED,OAAO,eAAe,YAAY,WAAW;EAC3C,YAAY;EACZ,UAAU;EACV,OAAO,IAAI,MAAM,SAAS,EACxB,UAAU,QAAQ,MAAM,WAAW;GACjC,MAAM,UAAU,QAAQ,UAAU,QAAQ,MAAM,SAAS;GACzD,MAAM,qBAAiC,CAAC;GAGxC,IAAI,OAAO,KAAK,OAAO,YAAY,KAAK,EAAE,CAAC,WAAW,MACpD,mBAAmB,KAAK,GAAG,gBAAgB,KAAK,EAAE,CAAC,OAAO,CAAC;GAI7D,IAAI,OAAO,KAAK,OAAO,YAAY,KAAK,EAAE,CAAC,WAAW,MACpD,mBAAmB,KAAK,GAAG,gBAAgB,KAAK,EAAE,CAAC,OAAO,CAAC;GAG7D,IAAI,mBAAmB,SAAS,GAC9B,uBAAuB,QAAQ,SAAS,kBAAkB;GAG5D,OAAO;EACT,EACF,CAAC;CACH,CAAC;CAED,OAAO,eAAe,YAAY,YAAY;EAC5C,YAAY;EACZ,UAAU;EACV,OAAO,IAAI,MAAM,UAAU,EACzB,UAAU,QAAQ,MAAM,WAAW;GACjC,MAAM,WAAW,QAAQ,UAAU,QAAQ,MAAM,SAAS;GAE1D,IAAI,OAAO,KAAK,OAAO,YAAY,KAAK,EAAE,CAAC,WAAW,MACpD,uBACE,SAAS,SACT,gBAAgB,KAAK,EAAE,CAAC,OAAO,CACjC;GAGF,OAAO;EACT,EACF,CAAC;CACH,CAAC;;;;;;;CAQD,OAAO,eAAe,cAAc,WAAW,OAAO;CACtD,OAAO,eAAe,aAAa,WAAW,WAAW,QAAQ,SAAS;CAC1E,OAAO,eAAe,eAAe,WAAW,QAAQ;CACxD,OAAO,eAAe,cAAc,WAAW,WAAW,SAAS,SAAS;CAE5E,OAAO;AACT;AAEA,SAAgB,0BAA0B;CACxC,IAAI,CAAC,QAAQ,IAAI,SAAS,eAAe,GACvC;CAGF,QAAQ,IAAI,SAAS,eAAe,CAAC,CAAC;AACxC;AAEA,SAAgB,mBAAmB,SAA8B;CAG/D,IAAI,CAAC,QAAQ,IAAI,SAAS,WAAW,GACnC,OAAO,MAAM,KAAK,QAAQ,QAAQ,CAAC;CAGrC,MAAM,aAAa,QAAQ,IAAI,SAAS,WAAW;CACnD,OAAO,WAAW,SAAS,IAAI,aAAa,MAAM,KAAK,QAAQ,QAAQ,CAAC;AAC1E;;;;;;;;;;;AAYA,SAAS,gBAAgB,SAAkC;CACzD,IAAI,mBAAmB,SACrB,OAAO,QAAQ,IAAI,SAAS,WAAW,KAAK,CAAC;CAG/C,OAAO,QAAQ,IAAI,IAAI,QAAQ,OAAO,GAAG,WAAW;AACtD;AAEA,SAAgB,eAAe,QAAiB,aAA4B;CAC1E,MAAM,aAAa,CAAC,GAAG,mBAAmB,MAAM,CAAC;CAEjD,IAAI,WAAW,WAAW,GACxB;;;;;;CAQF,KAAK,MAAM,CAAC,MAAM,UAAU,aAC1B,IACE,WAAW,OACR,WAAW,OAAO,EAAE,CAAC,YAAY,MAAM,KAAK,YAAY,CAC3D,GAEA,WAAW,KAAK,CAAC,MAAM,KAAK,CAAC;CAIjC,uBAAuB,aAAa,UAAU;AAChD;;;;;;AC9TA,SAAgB,iBACd,YACA,QACe;CAGf,MAAM,SAFa,OAAO,sBAAsB,MAExB,CAAC,CAAC,MAAM,WAAW;EACzC,OAAO,OAAO,gBAAgB;CAChC,CAAC;CAED,IAAI,QACF,OAAO,QAAQ,IAAI,QAAQ,MAAM;AAIrC;;;;;;ACfA,SAAgB,SAAY,OAAY,QAAQ,OAAmB;CACjE,OAAO,QACH,OAAO,UAAU,SAAS,KAAK,KAAK,CAAC,CAAC,WAAW,UAAU,IAC3D,OAAO,UAAU,SAAS,KAAK,KAAK,MAAM;AAChD;;;;;;;;;;;ACCA,SAAgB,qBACd,KACA,KACA;CACA,IAAI;EACF,IAAI;EACJ,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;;ACZA,SAAgB,0BAA0B,MAAyB;CACjE,OAAO,IAAI,SACT,KAAK,UACH,gBAAgB,QACZ;EACE,MAAM,KAAK;EACX,SAAS,KAAK;EACd,OAAO,KAAK;CACd,IACA,IACN,GACA;EACE,QAAQ;EACR,YAAY;EACZ,SAAS,EACP,gBAAgB,mBAClB;CACF,CACF;AACF;;;;;;;AAUA,MAAa,iBAAiB,OAAO,gBAAgB;;;;AAKrD,SAAgB,iBAAiB,OAA2C;CAC1E,IACE,iBAAiB,SACjB,kBAAkB,SAClB,gBAAgB,MAAM,eAAe,GAErC,OAAO,MAAM;AAIjB;;;;;;;;;AAUA,SAAgB,gBAAgB,UAA8C;CAC5E,OACE,YAAY,QACZ,oBAAoB,YACpB,qBAAqB,UAAU,MAAM,KACrC,SAAS,SAAS;AAEtB;;;;;;AAOA,SAAgB,eAAe,OAAmC;CAChE,OACE,SAA8B,OAAO,IAAI,KACzC,qBAAqB,OAAO,QAAQ,KACpC,qBAAqB,OAAO,YAAY,KACxC,qBAAqB,OAAO,UAAU;AAE1C;;;ACtEA,IAAa,eAAb,MAAa,qBAAqB,QAAQ;CACxC,OAAOC,iBACL,OACA,OAAyB,CAAC,GAC1B,KACqB;EACrB,OAAO,KAAK,SAAS,iBAAiB,UAAU,MAAM,OAAO,KAAA;CAC/D;;;;;CAMA,OAAO,qBAAqB,QAAyB;EACnD,OAAO,WAAW,aAAa,WAAW,WAAW,WAAW;CAClE;CAEA,OAAO,iBAAiB,QAAyB;EAC/C,OACE,WAAW,UACX,WAAW,SACX,aAAa,qBAAqB,MAAM;CAE5C;;;;;CAMA,OAAO,mBAAmB,MAAuB;EAC/C,OACE,SAAS,cAAc,SAAS,eAAe,SAAS;CAE5D;CAEA,YAAY,OAA0B,MAAyB;EAC7D,MAAM,SAAS,aAAaA,iBAAiB,OAAO,MAAM,QAAQ,KAAK;EACvE,MAAM,aAAa,aAAa,qBAAqB,MAAM,IACvD,SACA;EAEJ,MAAM,kBAAkB,QAAQ,QAAQ,UAAU;;;;;;;EAQlD,MAAM,WAAuC,CAAC,aAAa,iBACzD,MACF,IACI,EAAE,MAAM,KAAA,EAAU,IAClB,kBACE,EAAE,MAAM,KAAK,KAAK,IAClB,CAAC;EAEP,MAAM,OACH,aAAaA,iBAAiB,OAAO,MAAM,MAAM,KAClD,KAAA;EACF,MAAM,WAAW,aAAa,mBAAmB,IAAI,IAAI,OAAO,KAAA;EAEhE,MAAM,OAAO;GACX,GAAI,QAAQ,CAAC;GACb,QAAQ;GACR,MAAM;GAEN,QACE,MAAM,WACL,aAAa,iBAAiB,MAAM,IAAI,SAAS,KAAA;GACpD,GAAG;EACL,CAAC;EAED,IAAI,WAAW,YACb,KAAKC,qBAAqB,UAAU,MAAM;EAG5C,IAAI,WAAW,WAAW;GACxB,MAAM,MAAM,IAAI,IAAI,iBAAiB,UAAU,MAAM,MAAM,KAAK;GAEhE,IAAI;;;;;GAMJ,IAAI,IAAI,aAAa,cACnB,YAAY,IAAI;QAEhB,YAAY,IAAI,SAAS,QAAQ,QAAQ,EAAE;;;;;;;GAS7C,OAAO,eAAe,MAAM,OAAO;IACjC,WAAW;IACX,YAAY;IACZ,cAAc;GAChB,CAAC;EACH;EAEA,IAAI,QAAQ,QAAQ,SAAS,UAC3B,KAAKA,qBAAqB,QAAQ,IAAI;CAE1C;CAEA,qBACE,KACA,OACM;EACN,MAAM,gBAAgB,iBAAqC,SAAS,IAAI;EAExE,IAAI,eACF,QAAQ,IAAI,eAAe,KAAK,KAAK;OAErC,OAAO,eAAe,MAAM,KAAK;GAC/B;GACA,YAAY;GACZ,cAAc;GACd,UAAU;EACZ,CAAC;CAEL;AACF;AAyBA,MAAM,UAAU,OAAO,SAAS;AAChC,MAAM,OAAO,OAAO,MAAM;AAE1B,IAAa,gBAAb,MAAa,sBAAsB,SAAS;CAC1C,OAAO,KAAK,UAAoB,MAAyC;EACvE,IAAI,oBAAoB,eACtB,OAAO;EAGT,IAAI,gBAAgB,QAAQ,GAC1B,OAAO;EAGT,MAAM,gBAAgB,IAAI,cAAc,SAAS,MAAM;GACrD,KAAK,MAAM,OAAO,SAAS;GAC3B,QAAQ,MAAM,UAAU,SAAS;GACjC,YAAY,MAAM,cAAc,SAAS;GACzC,SAAS,MAAM,WAAW,SAAS;EACrC,CAAC;EAED,eAAe,SAAS,SAAS,cAAc,OAAO;EAEtD,OAAO;CACT;;EAM4C,KAAA,4BAAA;GAAC;GAAK;GAAK;GAAK;GAAK;EAAG;;;EAEvB,KAAA,6BAAA;GAAC;GAAK;GAAK;GAAK;GAAK;EAAG;;CAErE,OAAO,yBAAyB,QAAyB;EACvD,OAAO,UAAU,OAAO,UAAU;CACpC;CAEA,OAAO,mBAAmB,QAAyB;EACjD,OAAO,cAAc,2BAA2B,SAAS,MAAM;CACjE;;;;;CAMA,OAAO,mBAAmB,QAAyB;EACjD,OAAO,CAAC,cAAc,0BAA0B,SAAS,MAAM;CACjE;CAEA,OAAO,UAAU,QAAgB,UAA0B;;;;;EAKzD,MAAM,gBAAgB,iBACpB,SACA,QACF;EAEA,IAAI,eACF,cAAc,SAAS;OAEvB,OAAO,eAAe,UAAU,UAAU;GACxC,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ,CAAC;EAGH,OAAO,eAAe,UAAU,SAAS;GACvC,OAAO;GACP,YAAY;EACd,CAAC;CACH;CAEA,OAAO,OAAO,KAAyB,UAA0B;EAC/D,IAAI,CAAC,OAAO,QAAQ,YAAY,CAAC,IAAI,SAAS,GAAG,GAC/C;EAGF,MAAM,QAAQ,iBAAsC,SAAS,QAAQ;EAErE,IAAI,OAGF,MAAM,QAAQ,KAAK,IAAI,IAAI,GAAG,CAAC;OAG/B,OAAO,eAAe,UAAU,OAAO;GACrC,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ,CAAC;EAGH,OAAO,eAAe,UAAU,MAAM;GACpC,OAAO;GACP,YAAY;EACd,CAAC;CACH;;;;CAKA,OAAO,gBAAgB,YAAoC;EACzD,MAAM,UAAU,IAAI,QAAQ;EAE5B,KAAK,IAAI,OAAO,GAAG,OAAO,WAAW,QAAQ,QAAQ,GACnD,QAAQ,OAAO,WAAW,OAAO,WAAW,OAAO,EAAE;EAGvD,OAAO;CACT;;;;;;;;CASA,OAAO,MAAM,UAA8B;EACzC,IAAI;GAEF,OADc,SAAS,MACZ;EACb,SAAS,OAAO;GACd,OAAO,SAAS,KACd,iBAAiB,QACb;IACE,MAAM,MAAM;IACZ,SAAS,MAAM;IACf,OAAO,MAAM;GACf,IACA,CAAC,GACL;IACE,QAAQ;IACR,YAAY;GACd,CACF;EACF;CACF;CAEA;CACA;CAEA,YAAY,MAAwB,OAA0B,CAAC,GAAG;EAChE,MAAM,SAAS,KAAK,UAAU;EAC9B,MAAM,aAAa,cAAc,yBAAyB,MAAM,IAC5D,SACA;EACJ,MAAM,YAAY,cAAc,mBAAmB,MAAM,IAAI,OAAO;EAEpE,MAAM,WAAW;GACf,QAAQ;GACR,YAAY,KAAK;GACjB,SAAS,KAAK;EAChB,CAAC;;;;;;EAOD,IAAI,WAAW,YACb,cAAc,UAAU,QAAQ,IAAI;EAGtC,cAAc,OAAO,KAAK,KAAK,IAAI;CACrC;CAEA,QAAe;EACb,MAAM,iBAAiB,MAAM,MAAM;EAEnC,MAAM,eAAe,QAAQ,IAAI,MAAM,OAAO;EAE9C,IAAI,cACF,cAAc,UAAU,cAAc,cAAc;EAGtD,MAAM,YAAY,QAAQ,IAAI,MAAM,IAAI;EAExC,IAAI,WACF,cAAc,OAAO,WAAW,cAAc;EAGhD,OAAO;CACT;AACF"}