@mswjs/interceptors 0.41.9 → 0.42.0

package/lib/node/buffer-utils-BvPY1Tc-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-utils-BvPY1Tc-.js","names":["#owners","#getLoggerNamespace"],"sources":["../../src/disposable.ts","../../src/utils/logger.ts","../../src/interceptor.ts","../../src/utils/buffer-utils.ts"],"sourcesContent":["export type DisposableSubscription = () => void\n\nexport class Disposable {\n  protected subscriptions: Array<DisposableSubscription> = []\n\n  public dispose() {\n    let subscription: DisposableSubscription | undefined\n\n    while ((subscription = this.subscriptions.pop())) {\n      subscription()\n    }\n  }\n}\n","import debug from 'debug'\n\nexport type LogLevel = 'default' | 'verbose'\n\nexport interface Logger {\n  info(message: string, ...positionals: Array<unknown>): void\n  verbose(message: string, ...positionals: Array<unknown>): void\n  isEnabled(level: LogLevel): boolean\n}\n\nconst LOG_TIMESTAMP_REGEXP = /\\d{2}:\\d{2}:\\d{2}\\.\\d{3}/\n\nfunction normalizeNamespace(namespace: string): string {\n  return namespace\n    .split(':')\n    .map((segment) => {\n      return segment\n        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n        .replace(/[^a-zA-Z0-9]+/g, '-')\n        .replace(/^-|-$/g, '')\n        .toLowerCase()\n    })\n    .filter(Boolean)\n    .join(':')\n}\n\nfunction getTimestamp(): string {\n  return new Date().toISOString().slice(11, 23)\n}\n\nasync function readBody(message: Request | Response): Promise<string | null> {\n  if (message.body == null) {\n    return null\n  }\n\n  try {\n    return await message.clone().text()\n  } catch {\n    return null\n  }\n}\n\nfunction formatHeaders(headers: Headers): Array<string> {\n  return Array.from(headers.entries()).map(([name, value]) => {\n    return `${name}: ${value}`\n  })\n}\n\nasync function formatHttpMessage(\n  startLine: string,\n  message: Request | Response\n): Promise<string> {\n  const lines = [startLine, ...formatHeaders(message.headers)]\n  const body = await readBody(message)\n\n  lines.push('', body ?? '')\n\n  return lines.join('\\n')\n}\n\nexport async function formatRequest(request: Request): Promise<string> {\n  return formatHttpMessage(`${request.method} ${request.url}`, request)\n}\n\nexport async function formatResponse(response: Response): Promise<string> {\n  const statusText = response.statusText ? ` ${response.statusText}` : ''\n  return formatHttpMessage(\n    `HTTP ${response.status}${statusText}`,\n    response\n  )\n}\n\nfunction formatLogArguments(arguments_: Array<unknown>): void {\n  const message = arguments_[0]\n\n  if (typeof message === 'string') {\n    const messageWithoutDebugTimestamp = message.replace(\n      /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z /,\n      ''\n    )\n    const timestampMatch = messageWithoutDebugTimestamp.match(\n      LOG_TIMESTAMP_REGEXP\n    )\n\n    if (!timestampMatch || timestampMatch.index === undefined) {\n      arguments_[0] = messageWithoutDebugTimestamp\n      return\n    }\n\n    const messagePrefix = messageWithoutDebugTimestamp\n      .slice(0, timestampMatch.index)\n      .trim()\n    const messageBody = messageWithoutDebugTimestamp\n      .slice(timestampMatch.index + timestampMatch[0].length)\n      .trimStart()\n\n    arguments_[0] = `${timestampMatch[0]} ${messagePrefix} ${messageBody}`\n  }\n}\n\nfunction useConciseTimestamp(logger: debug.Debugger): void {\n  logger.log = (...arguments_) => {\n    formatLogArguments(arguments_)\n    debug.log(...arguments_)\n  }\n}\n\nfunction isVerboseLoggingEnabled(): boolean {\n  if (typeof process !== 'undefined' && process.env.DEBUG_LEVEL === 'verbose') {\n    return true\n  }\n\n  /**\n   * @note Consult the localStorage only in browser-like environments.\n   * In Node.js 26+, reading \"globalThis.localStorage\" without the\n   * \"--localstorage-file\" flag set emits an experimental warning\n   * (a try/catch cannot suppress it). Node.js consumers control the\n   * log level via the \"DEBUG_LEVEL\" environment variable above.\n   */\n  if (typeof document === 'undefined') {\n    return false\n  }\n\n  try {\n    return globalThis.localStorage?.getItem('debugLevel') === 'verbose'\n  } catch {\n    return false\n  }\n}\n\nexport function createLogger(namespace: string): Logger {\n  const normalizedNamespace = normalizeNamespace(namespace)\n  const logger = debug(`interceptors:${normalizedNamespace}`)\n  Reflect.set(logger, 'useColors', true)\n  useConciseTimestamp(logger)\n\n  return {\n    info(message, ...positionals) {\n      logger(`${getTimestamp()} ${message}`, ...positionals)\n    },\n    verbose(message, ...positionals) {\n      if (!isVerboseLoggingEnabled()) {\n        return\n      }\n\n      logger(`${getTimestamp()} ${message}`, ...positionals)\n    },\n    isEnabled(level) {\n      return (\n        logger.enabled && (level === 'default' || isVerboseLoggingEnabled())\n      )\n    },\n  }\n}\n","import { Emitter, type DefaultEventMap } from 'rettime'\nimport { Disposable } from './disposable'\nimport { createLogger, type Logger } from './utils/logger'\n\nexport enum InterceptorReadyState {\n  INACTIVE = 'INACTIVE',\n  ACTIVE = 'ACTIVE',\n  DISPOSED = 'DISPOSED',\n}\n\ndeclare global {\n  var __MSW_INTERCEPTORS_REGISTRY: Map<symbol, Interceptor<any>> | undefined\n}\n\nconst interceptorsRegistry = (globalThis.__MSW_INTERCEPTORS_REGISTRY ??=\n  new Map<symbol, Interceptor<any>>())\n\nexport abstract class Interceptor<\n  Events extends DefaultEventMap,\n> extends Disposable {\n  declare ['constructor']: typeof Interceptor\n\n  protected emitter: Emitter<Events>\n  protected readonly logger: Logger\n\n  public readyState: InterceptorReadyState\n\n  static readonly symbol: symbol\n\n  #owners: Set<object>\n\n  static singleton<T extends Interceptor<any>>(\n    InterceptorClass: (new () => T) & { symbol: symbol }\n  ): T {\n    const symbol = InterceptorClass.symbol\n    const existing = interceptorsRegistry.get(symbol)\n\n    if (existing instanceof InterceptorClass) {\n      return existing\n    }\n\n    const newInstance = new InterceptorClass()\n    interceptorsRegistry.set(symbol, newInstance)\n    return newInstance\n  }\n\n  constructor() {\n    super()\n\n    this.#owners = new Set()\n    this.readyState = InterceptorReadyState.INACTIVE\n    this.emitter = new Emitter()\n    this.logger = createLogger(this.#getLoggerNamespace())\n  }\n\n  protected abstract predicate(): boolean\n  protected abstract setup(): void\n\n  public apply(owner: object = this): void {\n    if (this.#owners.has(owner)) {\n      return\n    }\n\n    if (\n      this.readyState !== InterceptorReadyState.ACTIVE &&\n      !this.predicate()\n    ) {\n      return\n    }\n\n    this.#owners.add(owner)\n\n    if (this.readyState === InterceptorReadyState.ACTIVE) {\n      return\n    }\n\n    try {\n      this.setup()\n      this.readyState = InterceptorReadyState.ACTIVE\n      this.logger.info('apply')\n    } catch (error) {\n      this.dispose(owner)\n      throw error\n    }\n  }\n\n  public dispose(owner: object = this): void {\n    if (!this.#owners.delete(owner)) {\n      return\n    }\n\n    if (this.#owners.size > 0) {\n      return\n    }\n\n    super.dispose()\n    this.emitter.removeAllListeners()\n    this.readyState = InterceptorReadyState.DISPOSED\n    this.logger.info('disable')\n  }\n\n  public on: Emitter<Events>['on'] = (type, listener, options) => {\n    return this.emitter.on(type, listener, options)\n  }\n\n  public once: Emitter<Events>['once'] = (type, listener, options) => {\n    return this.emitter.once(type, listener, options)\n  }\n\n  public listeners: Emitter<Events>['listeners'] = (type) => {\n    return this.emitter.listeners(type)\n  }\n\n  public listenerCount: Emitter<Events>['listenerCount'] = (type) => {\n    return this.emitter.listenerCount(type)\n  }\n\n  public removeListener: Emitter<Events>['removeListener'] = (\n    type,\n    listener\n  ) => {\n    return this.emitter.removeListener(type, listener)\n  }\n\n  public removeAllListeners: Emitter<Events>['removeAllListeners'] = (type) => {\n    this.logger.info('removeAllListeners %o', { eventType: type ?? '*' })\n    return this.emitter.removeAllListeners(type)\n  }\n\n  #getLoggerNamespace(): string {\n    const symbolDescription = this.constructor.symbol?.description\n\n    if (symbolDescription) {\n      return symbolDescription.replace(/-interceptor$/, '')\n    }\n\n    return this.constructor.name.replace(/Interceptor$/, '')\n  }\n}\n","const encoder = new TextEncoder()\n\nexport function encodeBuffer(text: string) {\n  return encoder.encode(text)\n}\n\nexport function decodeBuffer(buffer: AllowSharedBufferSource, encoding?: string): string {\n  const decoder = new TextDecoder(encoding)\n  return decoder.decode(buffer)\n}\n\n/**\n * Create an `ArrayBuffer` from the given `Uint8Array`.\n * Takes the byte offset into account to produce the right buffer\n * in the case when the buffer is bigger than the data view.\n */\nexport function toArrayBuffer(array: Uint8Array<ArrayBuffer>): ArrayBuffer {\n  return array.buffer.slice(\n    array.byteOffset,\n    array.byteOffset + array.byteLength\n  )\n}\n\nexport function toBuffer(\n  data: string | Buffer | Uint8Array<ArrayBufferLike>,\n  encoding?: BufferEncoding\n): Buffer {\n  if (Buffer.isBuffer(data)) {\n    return data\n  }\n\n  if (data instanceof Uint8Array) {\n    return Buffer.from(data.buffer)\n  }\n\n  return Buffer.from(data, encoding)\n}\n"],"mappings":"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"}

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