@mswjs/interceptors 0.42.4 → 0.42.6

package/src/interceptors/http/source.ts

@@ -27,6 +27,7 @@ import {
 } from '../net/socket-controller'
 import { unwrapPendingData } from '../net/utils/flush-writes'
 import { FetchResponse } from '../../utils/fetch-utils'
+import { cloneResponse } from '../../utils/clone-response'
 import { requestContext } from '../../request-context'
 import { Interceptor } from '#/src/interceptor'
 
@@ -69,6 +70,20 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
         let abortPendingRequest: (() => void) | undefined
         let pendingRequestController: RequestController | undefined
 
+        // Protocol detection runs inside a client write. Let the write finish,
+        // other data observers run, and the remaining "connection" listeners
+        // get their chance to claim before flushing it to the real socket.
+        const passthroughNonHttp = () => {
+          setImmediate(() => {
+            if (
+              socketController.readyState === SocketController.PENDING &&
+              !socket.destroyed
+            ) {
+              socketController.passthrough()
+            }
+          })
+        }
+
         // A malformed request loses the boundary for subsequent requests.
         // Preserve the original bytes for the client and server to handle.
         const stopParsingRequests = (error: Error) => {
@@ -80,7 +95,7 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
           ) {
             void pendingRequestController.passthrough()
           } else {
-            socketController.decline()
+            passthroughNonHttp()
           }
 
           requestParser?.free(error)
@@ -111,26 +126,36 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
           realSocketDestroy(error, callback)
         }
 
+        const executeRequestParser = (
+          parser: HttpRequestParser,
+          chunk: Buffer
+        ) => {
+          // llhttp pauses permanently at an upgrade boundary. Release the
+          // parser after execute returns, outside its native callbacks.
+          if (parser.execute(chunk) !== null) {
+            socket.removeListener('data', onRequestData)
+            parser.free()
+            requestParser = undefined
+          }
+        }
+
         /**
-         * @note Only inspect the first sent packet to determine the protocol.
-         * A single socket cannot be used for different protocols.
+         * @note Inspect the first sent packet to determine the protocol,
+         * including when entering a mocked "CONNECT" tunnel.
          */
-        socket.on('data', (chunk) => {
+        const onRequestData = (chunk: Buffer) => {
           if (isHttpConnection === false) {
-            socketController.decline()
+            passthroughNonHttp()
             return
           }
 
           /**
            * @note A mocked "CONNECT" request has established a tunnel.
            * The data that follows belongs to a new exchange addressed to
-           * the tunnel target. The parser stopped at the tunnel boundary
-           * (HTTP upgrade semantics), so tear it down and detect the
-           * tunneled protocol anew, like on a fresh connection.
+           * the tunnel target. The previous parser was freed at the upgrade
+           * boundary, so detect the tunneled protocol anew.
            */
-          if (tunnelUrl && requestParser) {
-            requestParser.free()
-            requestParser = undefined
+          if (tunnelUrl && !requestParser) {
             isHttpConnection = undefined
 
             /**
@@ -149,18 +174,17 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
           }
 
           if (requestParser) {
-            requestParser.execute(toBuffer(chunk))
+            executeRequestParser(requestParser, toBuffer(chunk))
             return
           }
 
           const httpMessage = chunk.toString()
           const httpMethod = httpMessage.split(' ')[0] || ''
 
-          // Decline non-HTTP connections so the socket controller can
-          // pass them through once every subscriber has declined.
+          // Stop parsing connections that do not carry HTTP traffic.
           if (!METHODS.includes(httpMethod.toUpperCase())) {
             isHttpConnection = false
-            socketController.decline()
+            passthroughNonHttp()
             return
           }
 
@@ -245,9 +269,14 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
 
                     socketController.claim()
 
-                    const response = FetchResponse.from(rawResponse, {
+                    const originalResponse = FetchResponse.from(rawResponse, {
                       url: request.url,
                     })
+                    const [response, responseClone] =
+                      !isResponseError(originalResponse) &&
+                      this.emitter.listenerCount('response') > 0
+                        ? cloneResponse(originalResponse)
+                        : [originalResponse, null]
 
                     /**
                      * @note A successful mocked response to a "CONNECT"
@@ -257,17 +286,9 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                      */
                     if (request.method === 'CONNECT' && response.ok) {
                       tunnelUrl = new URL(`http://${request.url}`)
+                      socket.on('data', onRequestData)
                     }
 
-                    /**
-                     * @note Clone the response before "respondWith" because it will
-                     * consume its body. This way, we can have a readable response copy
-                     * for the "response" event below.
-                     */
-                    const responseClone = isResponseError(response)
-                      ? null
-                      : response.clone()
-
                     const respond = () => {
                       return this.respondWith({
                         socket: socketController[kRawSocket],
@@ -402,11 +423,11 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                         }
                       }
 
-                      const onResponseClose = () => {
+                      const onResponseEnd = () => {
                         disposeResponseParser()
 
-                        // Without a response, no response listener will release
-                        // the buffered EOF/close that rejects the client request.
+                        // Without a final response, release EOF now. A half-open
+                        // socket cannot close until the client consumes it.
                         if (!hasFinalResponse) {
                           socketController.uncorkReads()
                         }
@@ -415,13 +436,15 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                       const disposeResponseParser = (error?: Error) => {
                         responseParserDisposed = true
                         realSocket.removeListener('data', onResponseData)
-                        realSocket.removeListener('close', onResponseClose)
+                        realSocket.removeListener('end', onResponseEnd)
+                        realSocket.removeListener('close', onResponseEnd)
                         responseParser.free(error)
                       }
 
                       realSocket
                         .on('data', onResponseData)
-                        .once('close', onResponseClose)
+                        .once('end', onResponseEnd)
+                        .once('close', onResponseEnd)
                     }
                   },
                 },
@@ -480,9 +503,10 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
           })
 
           // Forward the first frame to the parser.
-          requestParser.execute(toBuffer(chunk))
-        })
+          executeRequestParser(requestParser, toBuffer(chunk))
+        }
 
+        socket.on('data', onRequestData)
         socket.on('close', () => requestParser?.free())
       },
       {

package/src/interceptors/net/index.ts

@@ -271,26 +271,28 @@ export class SocketInterceptor extends Interceptor<SocketEventMap> {
               })
             }
 
-            process.nextTick(() => {
+            process.nextTick(async () => {
               if (socket.destroyed) {
                 return
               }
 
-              /**
-               * @note Expect a verdict on this connection from every
-               * "connection" listener before emitting the event. With no
-               * listeners to claim the connection (or once every listener
-               * declines it), the controller passes it through as-is.
-               */
-              controller.awaitVerdicts(interceptor.listenerCount('connection'))
-
-              interceptor.emitter.emit(
-                new SocketConnectionEvent({
-                  socket: controller.serverSocket,
-                  controller,
-                  connectionOptions,
-                })
-              )
+              if (interceptor.listenerCount('connection') === 0) {
+                controller.passthrough()
+                return
+              }
+
+              try {
+                await interceptor.emitter.emitAsPromise(
+                  new SocketConnectionEvent({
+                    socket: controller.serverSocket,
+                    controller,
+                    connectionOptions,
+                  })
+                )
+              } catch (error) {
+                socket.destroy(error as Error)
+                return
+              }
 
               logger.verbose('emitted "connection" event!')
             })

package/src/interceptors/net/socket-controller.ts

@@ -239,9 +239,10 @@ function toServerSocket<T extends net.Socket>(socket: T): T {
               listener(toBuffer(chunk, encoding))
             }
 
+            // Writable so a removed listener can be added again.
             Object.defineProperty(listener, kListenerWrap, {
               enumerable: false,
-              writable: false,
+              writable: true,
               value: listenerWrap,
             })
 
@@ -365,8 +366,6 @@ export abstract class SocketController {
     | typeof SocketController.CLAIMED
     | typeof SocketController.PASSTHROUGH
 
-  #awaitedVerdicts = 0
-
   private [kRawSocket]: net.Socket
 
   constructor(socket: net.Socket) {
@@ -405,55 +404,6 @@ export abstract class SocketController {
 
     this.readyState = SocketController.PASSTHROUGH
   }
-
-  /**
-   * Await a verdict on this connection from the given number of
-   * subscribers. A connection nobody awaits to inspect (or one that
-   * every awaited subscriber has declined) is passed through as-is.
-   * This makes "unclaimed after everyone declined" a state owned by
-   * the controller instead of the individual subscribers.
-   */
-  public awaitVerdicts(count: number): void {
-    this.#awaitedVerdicts = count
-
-    if (this.#awaitedVerdicts === 0) {
-      this.passthrough()
-    }
-  }
-
-  /**
-   * Decline this socket connection. Declining means the subscriber
-   * has inspected the connection and will not handle it (e.g. the
-   * traffic is not of the protocol that subscriber implements).
-   * Once every awaited subscriber declines, the connection is
-   * passed through as-is.
-   */
-  public decline(): void {
-    if (this.readyState !== SocketController.PENDING) {
-      return
-    }
-
-    this.#awaitedVerdicts -= 1
-
-    if (this.#awaitedVerdicts <= 0) {
-      /**
-       * @note Defer the passthrough so it never transitions this
-       * controller in the middle of a client write. Declines are
-       * issued while the written data is being pushed to the server
-       * socket, and a synchronous transition would race the write's
-       * own bookkeeping (e.g. re-buffering the write after a reset
-       * at an exchange boundary).
-       */
-      process.nextTick(() => {
-        if (
-          this.readyState === SocketController.PENDING &&
-          !this[kRawSocket].destroyed
-        ) {
-          this.passthrough()
-        }
-      })
-    }
-  }
 }
 
 export type FlushPendingDataFunction = (
@@ -472,6 +422,8 @@ export class TcpSocketController extends SocketController {
 
   protected pendingConnection: PromiseWithResolvers<[TcpWrap, TcpHandle]>
 
+  #removePassthroughSocketListeners?: () => void
+
   #connectionOptions?: NetworkConnectionOptions
   #retargetedConnectionOptions?: NetworkConnectionOptions &
     net.SocketConnectOpts
@@ -599,9 +551,7 @@ export class TcpSocketController extends SocketController {
    * authority of an established "CONNECT" tunnel). An unclaimed
    * exchange then passes through to that target instead of the
    * originally dialed one, and a claimed exchange reports it as the
-   * peer. The verdict count is deliberately not re-armed: subscribers
-   * that declined this connection's protocol stay declined across
-   * the exchanges, retargeted or not.
+   * peer.
    */
   public reset(
     connectionOptions?: NetworkConnectionOptions & net.SocketConnectOpts
@@ -618,21 +568,8 @@ export class TcpSocketController extends SocketController {
        * must not close the client socket).
        */
       if (this.#passthroughSocket) {
-        this.#passthroughSocket
-          .removeListener('connect', this.#onRealSocketConnect)
-          .removeListener(
-            'connectionAttemptFailed',
-            this.#onRealSocketConnectionAttemptFailed
-          )
-          .removeListener(
-            'connectionAttemptTimeout',
-            this.#onRealSocketConnectionAttemptTimeout
-          )
-          .removeListener('data', this.#onRealSocketData)
-          .removeListener('error', this.#onRealSocketError)
-          .removeListener('end', this.#onRealSocketEnd)
-          .removeListener('close', this.#onRealSocketClose)
-          .destroy()
+        this.#removePassthroughSocketListeners?.()
+        this.#passthroughSocket.destroy()
 
         this.#passthroughSocket = null
 
@@ -1325,6 +1262,11 @@ export class TcpSocketController extends SocketController {
       // but this skips the detection cost on its every "destroyed" read).
       realSocket[kPatched] = true
 
+      // The client owns half-close semantics. It may not have consumed
+      // the forwarded EOF yet, so keep the real connection writable until
+      // the client ends its writable side.
+      realSocket.allowHalfOpen = true
+
       if (this.socket.timeout != null) {
         realSocket.setTimeout(this.socket.timeout)
       }
@@ -1338,9 +1280,8 @@ export class TcpSocketController extends SocketController {
         ? this.#passthroughSocket
         : createRealSocket()
 
-    if (realSocket !== this.#passthroughSocket) {
-      this.#passthroughSocket = realSocket
-    }
+    const isNewConnection = realSocket !== this.#passthroughSocket
+    this.#passthroughSocket = realSocket
 
     if (this.#bufferedWrites.length === 0) {
       logger.verbose(
@@ -1378,32 +1319,15 @@ export class TcpSocketController extends SocketController {
     this.socket.removeListener('drain', this.#onMockSocketDrain)
     this.socket.on('drain', this.#onMockSocketDrain)
 
-    realSocket
-      .removeListener('connect', this.#onRealSocketConnect)
-      .removeListener(
-        'connectionAttemptFailed',
-        this.#onRealSocketConnectionAttemptFailed
-      )
-      .removeListener(
-        'connectionAttemptTimeout',
-        this.#onRealSocketConnectionAttemptTimeout
-      )
-      .removeListener('data', this.#onRealSocketData)
-      .removeListener('error', this.#onRealSocketError)
-      .removeListener('end', this.#onRealSocketEnd)
-      .removeListener('close', this.#onRealSocketClose)
+    // Let Node register its pending-write "connect" listener first so
+    // buffered writes flush before our listener swaps the socket handle.
+    if (isNewConnection) {
+      this.#removePassthroughSocketListeners =
+        this.addPassthroughSocketListeners(realSocket)
 
-    realSocket
-      .once('connect', this.#onRealSocketConnect)
-      .on('connectionAttemptFailed', this.#onRealSocketConnectionAttemptFailed)
-      .on(
-        'connectionAttemptTimeout',
-        this.#onRealSocketConnectionAttemptTimeout
-      )
-      .on('data', this.#onRealSocketData)
-      .on('error', this.#onRealSocketError)
-      .on('end', this.#onRealSocketEnd)
-      .on('close', this.#onRealSocketClose)
+      // The real socket may still emit errors after the client closes.
+      realSocket.once('close', this.#removePassthroughSocketListeners)
+    }
 
     /**
      * @note Forward the client's half-close, unless the real handle
@@ -1422,6 +1346,41 @@ export class TcpSocketController extends SocketController {
     return realSocket
   }
 
+  /**
+   * Forward events for the lifetime of the connection, including while
+   * it is idle in an agent pool. Reusing it must not add more listeners.
+   */
+  protected addPassthroughSocketListeners(realSocket: net.Socket): () => void {
+    realSocket
+      .once('connect', this.#onRealSocketConnect)
+      .on('connectionAttemptFailed', this.#onRealSocketConnectionAttemptFailed)
+      .on(
+        'connectionAttemptTimeout',
+        this.#onRealSocketConnectionAttemptTimeout
+      )
+      .on('data', this.#onRealSocketData)
+      .on('error', this.#onRealSocketError)
+      .on('end', this.#onRealSocketEnd)
+      .on('close', this.#onRealSocketClose)
+
+    return () => {
+      realSocket
+        .removeListener('connect', this.#onRealSocketConnect)
+        .removeListener(
+          'connectionAttemptFailed',
+          this.#onRealSocketConnectionAttemptFailed
+        )
+        .removeListener(
+          'connectionAttemptTimeout',
+          this.#onRealSocketConnectionAttemptTimeout
+        )
+        .removeListener('data', this.#onRealSocketData)
+        .removeListener('error', this.#onRealSocketError)
+        .removeListener('end', this.#onRealSocketEnd)
+        .removeListener('close', this.#onRealSocketClose)
+    }
+  }
+
   /**
    * Create the passthrough connection to the target this controller
    * was retargeted to (see `reset()`). The original `createConnection`
@@ -1663,20 +1622,44 @@ export class TlsSocketController extends TcpSocketController {
       }
     }
 
-    realSocket
-      .on('secure', () => {
-        this.socket.emit('secure')
-      })
-      .on('session', (...args) => {
-        this.socket.emit('session', ...args)
-      })
-      .on('keylog', (...args) => {
-        this.socket.emit('keylog', ...args)
-      })
-      .on('OCSPResponse', (...args) => {
-        this.socket.emit('OCSPResponse', ...args)
-      })
-
     return realSocket
   }
+
+  #onRealSocketSecure = () => {
+    this.socket.emit('secure')
+  }
+
+  #onRealSocketSession = (session: Buffer) => {
+    this.socket.emit('session', session)
+  }
+
+  #onRealSocketKeylog = (line: Buffer) => {
+    this.socket.emit('keylog', line)
+  }
+
+  #onRealSocketOCSPResponse = (response: Buffer | null) => {
+    this.socket.emit('OCSPResponse', response)
+  }
+
+  protected addPassthroughSocketListeners(realSocket: net.Socket): () => void {
+    const removeTcpSocketListeners = super.addPassthroughSocketListeners(
+      realSocket
+    )
+
+    realSocket
+      .on('secure', this.#onRealSocketSecure)
+      .on('session', this.#onRealSocketSession)
+      .on('keylog', this.#onRealSocketKeylog)
+      .on('OCSPResponse', this.#onRealSocketOCSPResponse)
+
+    return () => {
+      removeTcpSocketListeners()
+
+      realSocket
+        .removeListener('secure', this.#onRealSocketSecure)
+        .removeListener('session', this.#onRealSocketSession)
+        .removeListener('keylog', this.#onRealSocketKeylog)
+        .removeListener('OCSPResponse', this.#onRealSocketOCSPResponse)
+    }
+  }
 }

package/src/utils/clone-response.ts

@@ -0,0 +1,72 @@
+import { FetchResponse } from './fetch-utils'
+import { copyRawHeaders } from '../interceptors/ClientRequest/utils/record-raw-headers'
+
+/** Clone for observers without letting their unread body block caller cancellation. */
+export function cloneResponse(response: Response): [Response, Response] {
+  const clone = FetchResponse.clone(response)
+
+  if (!response.body || !clone.body) {
+    return [response, clone]
+  }
+
+  const observer = wrapResponse(clone)
+  const caller = wrapResponse(response, observer.cancel)
+
+  return [caller.response, observer.response]
+}
+
+function wrapResponse(
+  response: Response,
+  onCancel?: (reason: unknown) => Promise<void>
+) {
+  const body = response.body!
+  const reader = body.getReader()
+  const cancel = (reason: unknown) => {
+    return body.locked ? reader.cancel(reason) : body.cancel(reason)
+  }
+  const stream = new ReadableStream<Uint8Array>(
+    {
+      async pull(controller) {
+        try {
+          const { done, value } = await reader.read()
+
+          if (done) {
+            controller.close()
+            reader.releaseLock()
+            return
+          }
+
+          controller.enqueue(value)
+        } catch (error) {
+          controller.error(error)
+          reader.releaseLock()
+        }
+      },
+      async cancel(reason) {
+        try {
+          const cancellation = cancel(reason)
+
+          if (onCancel) {
+            // Caller cancellation owns both branches.
+            await Promise.all([cancellation, onCancel(reason)])
+          } else {
+            // An observer must not wait for the caller to consume its branch:
+            // Response delivery is still waiting for this listener to finish.
+            void cancellation.catch(() => {})
+          }
+        } finally {
+          reader.releaseLock()
+        }
+      },
+    },
+    { highWaterMark: 0 }
+  )
+  const wrappedResponse = new FetchResponse(stream, response)
+  copyRawHeaders(response.headers, wrappedResponse.headers)
+  Object.defineProperties(wrappedResponse, {
+    type: { value: response.type },
+    redirected: { value: response.redirected },
+  })
+
+  return { response: wrappedResponse, cancel }
+}

package/lib/browser/web-CdcYFjgm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-CdcYFjgm.js","names":[],"sources":["../../src/interceptors/fetch/utils/create-network-error.ts","../../src/interceptors/fetch/utils/follow-redirect.ts","../../src/interceptors/fetch/utils/brotli-decompress.browser.ts","../../src/interceptors/fetch/utils/decompression.ts","../../src/interceptors/fetch/web.ts"],"sourcesContent":["export function createNetworkError(cause?: unknown) {\n  return Object.assign(new TypeError('Failed to fetch'), {\n    cause,\n  })\n}\n","import { createNetworkError } from './create-network-error'\n\nconst REQUEST_BODY_HEADERS = [\n  'content-encoding',\n  'content-language',\n  'content-location',\n  'content-type',\n  'content-length',\n]\n\nconst kRedirectCount = Symbol('kRedirectCount')\n\n/**\n * @see https://github.com/nodejs/undici/blob/a6dac3149c505b58d2e6d068b97f4dc993da55f0/lib/web/fetch/index.js#L1210\n */\nexport async function followFetchRedirect(\n  request: Request,\n  response: Response\n): Promise<Response> {\n  if (response.status !== 303 && request.body != null) {\n    return Promise.reject(createNetworkError())\n  }\n\n  const requestUrl = new URL(request.url)\n\n  let locationUrl: URL\n  try {\n    // If the location is a relative URL, use the request URL as the base URL.\n    locationUrl = new URL(response.headers.get('location')!, request.url) \n  } catch (error) {\n    return Promise.reject(createNetworkError(error))\n  }\n\n  if (\n    !(locationUrl.protocol === 'http:' || locationUrl.protocol === 'https:')\n  ) {\n    return Promise.reject(\n      createNetworkError('URL scheme must be a HTTP(S) scheme')\n    )\n  }\n\n  if (Reflect.get(request, kRedirectCount) > 20) {\n    return Promise.reject(createNetworkError('redirect count exceeded'))\n  }\n\n  Object.defineProperty(request, kRedirectCount, {\n    value: (Reflect.get(request, kRedirectCount) || 0) + 1,\n  })\n\n  if (\n    request.mode === 'cors' &&\n    (locationUrl.username || locationUrl.password) &&\n    !sameOrigin(requestUrl, locationUrl)\n  ) {\n    return Promise.reject(\n      createNetworkError('cross origin not allowed for request mode \"cors\"')\n    )\n  }\n\n  const requestInit: RequestInit = {}\n\n  if (\n    ([301, 302].includes(response.status) && request.method === 'POST') ||\n    (response.status === 303 && !['HEAD', 'GET'].includes(request.method))\n  ) {\n    requestInit.method = 'GET'\n    requestInit.body = null\n\n    REQUEST_BODY_HEADERS.forEach((headerName) => {\n      request.headers.delete(headerName)\n    })\n  }\n\n  if (!sameOrigin(requestUrl, locationUrl)) {\n    request.headers.delete('authorization')\n    request.headers.delete('proxy-authorization')\n    request.headers.delete('cookie')\n    request.headers.delete('host')\n  }\n\n  /**\n   * @note Undici \"safely\" extracts the request body.\n   * I suspect we cannot dispatch this request again\n   * since its body has been read and the stream is locked.\n   */\n\n  requestInit.headers = request.headers\n  const finalResponse = await fetch(new Request(locationUrl, requestInit))\n  Object.defineProperty(finalResponse, 'redirected', {\n    value: true,\n    configurable: true,\n  })\n\n  return finalResponse\n}\n\n/**\n * @see https://github.com/nodejs/undici/blob/a6dac3149c505b58d2e6d068b97f4dc993da55f0/lib/web/fetch/util.js#L761\n */\nfunction sameOrigin(left: URL, right: URL): boolean {\n  if (left.origin === right.origin && left.origin === 'null') {\n    return true\n  }\n\n  if (\n    left.protocol === right.protocol &&\n    left.hostname === right.hostname &&\n    left.port === right.port\n  ) {\n    return true\n  }\n\n  return false\n}\n","export class BrotliDecompressionStream extends TransformStream {\n  constructor() {\n    console.warn(\n      '[Interceptors]: Brotli decompression of response streams is not supported in the browser'\n    )\n\n    super({\n      transform(chunk, controller) {\n        // Keep the stream as passthrough, it does nothing.\n        controller.enqueue(chunk)\n      },\n    })\n  }\n}\n","// Import from an internal alias that resolves to different modules\n// depending on the environment. This way, we can keep the fetch interceptor\n// intact while using different strategies for Brotli decompression.\nimport { BrotliDecompressionStream } from 'internal:brotli-decompress'\n\nclass PipelineStream extends TransformStream {\n  constructor(\n    transformStreams: Array<TransformStream>,\n    ...strategies: Array<QueuingStrategy>\n  ) {\n    super({}, ...strategies)\n\n    const readable = [super.readable as any, ...transformStreams].reduce(\n      (readable, transform) => readable.pipeThrough(transform)\n    )\n\n    Object.defineProperty(this, 'readable', {\n      get() {\n        return readable\n      },\n    })\n  }\n}\n\nexport function parseContentEncoding(contentEncoding: string): Array<string> {\n  return contentEncoding\n    .toLowerCase()\n    .split(',')\n    .map((coding) => coding.trim())\n}\n\nfunction createDecompressionStream(\n  contentEncoding: string\n): TransformStream | null {\n  if (contentEncoding === '') {\n    return null\n  }\n\n  const codings = parseContentEncoding(contentEncoding)\n\n  if (codings.length === 0) {\n    return null\n  }\n\n  const transformers = codings.reduceRight<Array<TransformStream>>(\n    (transformers, coding) => {\n      if (coding === 'gzip' || coding === 'x-gzip') {\n        return transformers.concat(new DecompressionStream('gzip'))\n      } else if (coding === 'deflate') {\n        return transformers.concat(new DecompressionStream('deflate'))\n      } else if (coding === 'br') {\n        return transformers.concat(new BrotliDecompressionStream())\n      } else {\n        transformers.length = 0\n      }\n\n      return transformers\n    },\n    []\n  )\n\n  return new PipelineStream(transformers)\n}\n\nexport function decompressResponse(\n  response: Response\n): ReadableStream<any> | null {\n  if (response.body === null) {\n    return null\n  }\n\n  const decompressionStream = createDecompressionStream(\n    response.headers.get('content-encoding') || ''\n  )\n\n  if (!decompressionStream) {\n    return null\n  }\n\n  // Use `pipeTo` and return the decompression stream's readable\n  // instead of `pipeThrough` because that will lock the original\n  // response stream, making it unusable as the input to Response.\n  response.body.pipeTo(decompressionStream.writable)\n  return decompressionStream.readable\n}\n","import { until } from '@open-draft/until'\nimport { HttpResponseEvent, type HttpRequestEventMap } from '../../events/http'\nimport { RequestController } from '../../request-controller'\nimport { handleRequest } from '../../utils/handle-request'\nimport { createRequestId } from '../../create-request-id'\nimport { createNetworkError } from './utils/create-network-error'\nimport { followFetchRedirect } from './utils/follow-redirect'\nimport { decompressResponse } from './utils/decompression'\nimport { hasConfigurableGlobal } from '../../utils/has-configurable-global'\nimport { FetchResponse } from '../../utils/fetch-utils'\nimport { isResponseError } from '../../utils/response-utils'\nimport { patchesRegistry } from '../../utils/patches-registry'\nimport { copyRawHeaders } from '../ClientRequest/utils/record-raw-headers'\nimport { Interceptor } from '../../interceptor'\nimport { createLogger } from '../../utils/logger'\n\nconst logger = createLogger('fetch')\n\n/**\n * Interceptor for `fetch` requests in the browser.\n */\nexport class FetchInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol.for('fetch-interceptor')\n\n  protected predicate() {\n    return hasConfigurableGlobal('fetch')\n  }\n\n  protected async setup() {\n    logger.verbose('patching global fetch...')\n\n    this.subscriptions.push(\n      patchesRegistry.applyPatch(globalThis, 'fetch', (realFetch) => {\n        return async (input, init) => {\n          const requestId = createRequestId()\n\n          /**\n           * @note Resolve potentially relative request URL\n           * against the present `location`. This is mainly\n           * for native `fetch` in JSDOM.\n           * @see https://github.com/mswjs/msw/issues/1625\n           */\n          const resolvedInput =\n            typeof input === 'string' &&\n            typeof location !== 'undefined' &&\n            !URL.canParse(input)\n              ? new URL(input, location.href)\n              : input\n\n          const request = new Request(resolvedInput, init)\n\n          const responsePromise = Promise.withResolvers<Response>()\n\n          const controller = new RequestController(\n            request,\n            {\n              passthrough: async () => {\n                logger.verbose('performing request as-is')\n\n                /**\n                 * @note Clone the request instance right before performing it.\n                 * This preserves any modifications made to the intercepted request\n                 * in the \"request\" listener. This also allows the user to read the\n                 * request body in the \"response\" listener (otherwise \"unusable\").\n                 */\n                const requestCloneForResponseEvent = request.clone()\n\n                // Perform the intercepted request as-is.\n                const [responseError, originalResponse] = await until(() =>\n                  realFetch(request)\n                )\n\n                if (responseError) {\n                  return responsePromise.reject(responseError)\n                }\n\n                logger.verbose('original fetch performed %o', originalResponse)\n\n                if (this.emitter.listenerCount('response') > 0) {\n                  logger.verbose('emitting the \"response\" event')\n\n                  const responseClone = FetchResponse.clone(originalResponse)\n                  await this.emitter.emitAsPromise(\n                    new HttpResponseEvent({\n                      initiator: requestCloneForResponseEvent,\n                      request: requestCloneForResponseEvent,\n                      requestId,\n                      response: responseClone,\n                      responseType: 'original',\n                    })\n                  )\n                }\n\n                // Resolve the response promise with the original response\n                // since the `fetch()` return this internal promise.\n                responsePromise.resolve(originalResponse)\n              },\n              respondWith: async (rawResponse) => {\n                // Handle mocked `Response.error()` (i.e. request errors).\n                if (isResponseError(rawResponse)) {\n                  logger.verbose('request errored %o', {\n                    response: rawResponse,\n                  })\n                  responsePromise.reject(createNetworkError(rawResponse))\n                  return\n                }\n\n                // Decompress the mocked response body, if applicable.\n                const decompressedStream = decompressResponse(rawResponse)\n                const response = new FetchResponse(\n                  decompressedStream || rawResponse.body,\n                  {\n                    url: request.url,\n                    status: rawResponse.status,\n                    statusText: rawResponse.statusText,\n                    headers: rawResponse.headers,\n                  }\n                )\n\n                copyRawHeaders(rawResponse.headers, response.headers)\n\n                /**\n                 * Undici's handling of following redirect responses.\n                 * Treat the \"manual\" redirect mode as a regular mocked response.\n                 * This way, the client can manually follow the redirect it receives.\n                 * @see https://github.com/nodejs/undici/blob/a6dac3149c505b58d2e6d068b97f4dc993da55f0/lib/web/fetch/index.js#L1173\n                 */\n                if (FetchResponse.isRedirectResponse(response.status)) {\n                  // Reject the request promise if its `redirect` is set to `error`\n                  // and it receives a mocked redirect response.\n                  if (request.redirect === 'error') {\n                    responsePromise.reject(\n                      createNetworkError('unexpected redirect')\n                    )\n                    return\n                  }\n\n                  if (request.redirect === 'follow') {\n                    followFetchRedirect(request, response).then(\n                      (response) => {\n                        responsePromise.resolve(response)\n                      },\n                      (reason) => {\n                        responsePromise.reject(reason)\n                      }\n                    )\n                    return\n                  }\n                }\n\n                if (this.emitter.listenerCount('response') > 0) {\n                  logger.verbose('emitting the \"response\" event')\n\n                  // Await the response listeners to finish before resolving\n                  // the response promise. This ensures all your logic finishes\n                  // before the interceptor resolves the pending response.\n                  await this.emitter.emitAsPromise(\n                    new HttpResponseEvent({\n                      initiator: request,\n                      // Clone the mocked response for the \"response\" event listener.\n                      // This way, the listener can read the response and not lock its body\n                      // for the actual fetch consumer.\n                      response: FetchResponse.clone(response),\n                      responseType: 'mock',\n                      request,\n                      requestId,\n                    })\n                  )\n                }\n\n                responsePromise.resolve(response)\n              },\n              errorWith: (reason) => {\n                logger.verbose('request aborted %o', { reason })\n                responsePromise.reject(reason)\n              },\n            },\n            {\n              logger,\n              requestId,\n            }\n          )\n\n          logger.verbose('awaiting request resolution')\n\n          logger.verbose(\n            'emitting the \"request\" event for %s listener(s)...',\n            this.emitter.listenerCount('request')\n          )\n\n          /**\n           * @note Give the consumer a chance to abort the request before\n           * it is dispatched. Fetch queues the request processing as a\n           * task, so a signal aborted synchronously after `fetch()` must\n           * prevent the request from ever reaching the \"request\" listeners.\n           * Without this, the first listener is invoked synchronously\n           * within the `fetch()` call itself.\n           */\n          await Promise.resolve()\n\n          await handleRequest({\n            initiator: request,\n            request,\n            requestId,\n            emitter: this.emitter,\n            controller,\n            logger,\n          })\n\n          return responsePromise.promise\n        }\n      })\n    )\n\n    logger.verbose('global fetch patched: %s', globalThis.fetch.name)\n  }\n}\n"],"mappings":"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"}