@mswjs/interceptors/lib/node/chunk-FWJSC2QD.mjs.map

Low-level HTTP/HTTPS/XHR/fetch request interception library.

{"version":3,"sources":["../../src/interceptors/ClientRequest/index.ts","../../src/interceptors/ClientRequest/MockHttpSocket.ts","../../src/interceptors/Socket/MockSocket.ts","../../src/interceptors/Socket/utils/normalizeSocketWriteArgs.ts","../../src/interceptors/Socket/utils/baseUrlFromConnectionOptions.ts","../../src/interceptors/ClientRequest/utils/recordRawHeaders.ts","../../src/interceptors/ClientRequest/agents.ts","../../src/interceptors/ClientRequest/utils/normalizeClientRequestArgs.ts","../../src/utils/getUrlByRequestOptions.ts","../../src/utils/cloneObject.ts","../../src/utils/isObject.ts"],"sourcesContent":["import http from 'node:http'\nimport https from 'node:https'\nimport { Interceptor } from '../../Interceptor'\nimport type { HttpRequestEventMap } from '../../glossary'\nimport {\n  kRequestId,\n  MockHttpSocketRequestCallback,\n  MockHttpSocketResponseCallback,\n} from './MockHttpSocket'\nimport { MockAgent, MockHttpsAgent } from './agents'\nimport { RequestController } from '../../RequestController'\nimport { emitAsync } from '../../utils/emitAsync'\nimport { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'\nimport { handleRequest } from '../../utils/handleRequest'\nimport {\n  recordRawFetchHeaders,\n  restoreHeadersPrototype,\n} from './utils/recordRawHeaders'\n\nexport class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol('client-request-interceptor')\n\n  constructor() {\n    super(ClientRequestInterceptor.symbol)\n  }\n\n  protected setup(): void {\n    const { get: originalGet, request: originalRequest } = http\n    const { get: originalHttpsGet, request: originalHttpsRequest } = https\n\n    const onRequest = this.onRequest.bind(this)\n    const onResponse = this.onResponse.bind(this)\n\n    http.request = new Proxy(http.request, {\n      apply: (target, thisArg, args: Parameters<typeof http.request>) => {\n        const [url, options, callback] = normalizeClientRequestArgs(\n          'http:',\n          args\n        )\n        const mockAgent = new MockAgent({\n          customAgent: options.agent,\n          onRequest,\n          onResponse,\n        })\n        options.agent = mockAgent\n\n        return Reflect.apply(target, thisArg, [url, options, callback])\n      },\n    })\n\n    http.get = new Proxy(http.get, {\n      apply: (target, thisArg, args: Parameters<typeof http.get>) => {\n        const [url, options, callback] = normalizeClientRequestArgs(\n          'http:',\n          args\n        )\n\n        const mockAgent = new MockAgent({\n          customAgent: options.agent,\n          onRequest,\n          onResponse,\n        })\n        options.agent = mockAgent\n\n        return Reflect.apply(target, thisArg, [url, options, callback])\n      },\n    })\n\n    //\n    // HTTPS.\n    //\n\n    https.request = new Proxy(https.request, {\n      apply: (target, thisArg, args: Parameters<typeof https.request>) => {\n        const [url, options, callback] = normalizeClientRequestArgs(\n          'https:',\n          args\n        )\n\n        const mockAgent = new MockHttpsAgent({\n          customAgent: options.agent,\n          onRequest,\n          onResponse,\n        })\n        options.agent = mockAgent\n\n        return Reflect.apply(target, thisArg, [url, options, callback])\n      },\n    })\n\n    https.get = new Proxy(https.get, {\n      apply: (target, thisArg, args: Parameters<typeof https.get>) => {\n        const [url, options, callback] = normalizeClientRequestArgs(\n          'https:',\n          args\n        )\n\n        const mockAgent = new MockHttpsAgent({\n          customAgent: options.agent,\n          onRequest,\n          onResponse,\n        })\n        options.agent = mockAgent\n\n        return Reflect.apply(target, thisArg, [url, options, callback])\n      },\n    })\n\n    // Spy on `Header.prototype.set` and `Header.prototype.append` calls\n    // and record the raw header names provided. This is to support\n    // `IncomingMessage.prototype.rawHeaders`.\n    recordRawFetchHeaders()\n\n    this.subscriptions.push(() => {\n      http.get = originalGet\n      http.request = originalRequest\n\n      https.get = originalHttpsGet\n      https.request = originalHttpsRequest\n\n      restoreHeadersPrototype()\n    })\n  }\n\n  private onRequest: MockHttpSocketRequestCallback = async ({\n    request,\n    socket,\n  }) => {\n    const requestId = Reflect.get(request, kRequestId)\n    const controller = new RequestController(request)\n\n    const isRequestHandled = await handleRequest({\n      request,\n      requestId,\n      controller,\n      emitter: this.emitter,\n      onResponse: (response) => {\n        socket.respondWith(response)\n      },\n      onRequestError: (response) => {\n        socket.respondWith(response)\n      },\n      onError: (error) => {\n        if (error instanceof Error) {\n          socket.errorWith(error)\n        }\n      },\n    })\n\n    if (!isRequestHandled) {\n      return socket.passthrough()\n    }\n  }\n\n  public onResponse: MockHttpSocketResponseCallback = async ({\n    requestId,\n    request,\n    response,\n    isMockedResponse,\n  }) => {\n    // Return the promise to when all the response event listeners\n    // are finished.\n    return emitAsync(this.emitter, 'response', {\n      requestId,\n      request,\n      response,\n      isMockedResponse,\n    })\n  }\n}\n","import net from 'node:net'\nimport {\n  HTTPParser,\n  type RequestHeadersCompleteCallback,\n  type ResponseHeadersCompleteCallback,\n} from '_http_common'\nimport { STATUS_CODES, IncomingMessage, ServerResponse } from 'node:http'\nimport { Readable } from 'node:stream'\nimport { invariant } from 'outvariant'\nimport { INTERNAL_REQUEST_ID_HEADER_NAME } from '../../Interceptor'\nimport { MockSocket } from '../Socket/MockSocket'\nimport type { NormalizedSocketWriteArgs } from '../Socket/utils/normalizeSocketWriteArgs'\nimport { isPropertyAccessible } from '../../utils/isPropertyAccessible'\nimport { baseUrlFromConnectionOptions } from '../Socket/utils/baseUrlFromConnectionOptions'\nimport { createServerErrorResponse } from '../../utils/responseUtils'\nimport { createRequestId } from '../../createRequestId'\nimport { getRawFetchHeaders } from './utils/recordRawHeaders'\nimport { FetchResponse } from '../../utils/fetchUtils'\n\ntype HttpConnectionOptions = any\n\nexport type MockHttpSocketRequestCallback = (args: {\n  requestId: string\n  request: Request\n  socket: MockHttpSocket\n}) => void\n\nexport type MockHttpSocketResponseCallback = (args: {\n  requestId: string\n  request: Request\n  response: Response\n  isMockedResponse: boolean\n  socket: MockHttpSocket\n}) => Promise<void>\n\ninterface MockHttpSocketOptions {\n  connectionOptions: HttpConnectionOptions\n  createConnection: () => net.Socket\n  onRequest: MockHttpSocketRequestCallback\n  onResponse: MockHttpSocketResponseCallback\n}\n\nexport const kRequestId = Symbol('kRequestId')\n\nexport class MockHttpSocket extends MockSocket {\n  private connectionOptions: HttpConnectionOptions\n  private createConnection: () => net.Socket\n  private baseUrl: URL\n\n  private onRequest: MockHttpSocketRequestCallback\n  private onResponse: MockHttpSocketResponseCallback\n  private responseListenersPromise?: Promise<void>\n\n  private writeBuffer: Array<NormalizedSocketWriteArgs> = []\n  private request?: Request\n  private requestParser: HTTPParser<0>\n  private requestStream?: Readable\n  private shouldKeepAlive?: boolean\n\n  private socketState: 'unknown' | 'mock' | 'passthrough' = 'unknown'\n  private responseParser: HTTPParser<1>\n  private responseStream?: Readable\n  private originalSocket?: net.Socket\n\n  constructor(options: MockHttpSocketOptions) {\n    super({\n      write: (chunk, encoding, callback) => {\n        // Buffer the writes so they can be flushed in case of the original connection\n        // and when reading the request body in the interceptor. If the connection has\n        // been established, no need to buffer the chunks anymore, they will be forwarded.\n        if (this.socketState !== 'passthrough') {\n          this.writeBuffer.push([chunk, encoding, callback])\n        }\n\n        if (chunk) {\n          /**\n           * Forward any writes to the mock socket to the underlying original socket.\n           * This ensures functional duplex connections, like WebSocket.\n           * @see https://github.com/mswjs/interceptors/issues/682\n           */\n          if (this.socketState === 'passthrough') {\n            this.originalSocket?.write(chunk, encoding, callback)\n          }\n\n          this.requestParser.execute(\n            Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding)\n          )\n        }\n      },\n      read: (chunk) => {\n        if (chunk !== null) {\n          /**\n           * @todo We need to free the parser if the connection has been\n           * upgraded to a non-HTTP protocol. It won't be able to parse data\n           * from that point onward anyway. No need to keep it in memory.\n           */\n          this.responseParser.execute(\n            Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)\n          )\n        }\n      },\n    })\n\n    this.connectionOptions = options.connectionOptions\n    this.createConnection = options.createConnection\n    this.onRequest = options.onRequest\n    this.onResponse = options.onResponse\n\n    this.baseUrl = baseUrlFromConnectionOptions(this.connectionOptions)\n\n    // Request parser.\n    this.requestParser = new HTTPParser()\n    this.requestParser.initialize(HTTPParser.REQUEST, {})\n    this.requestParser[HTTPParser.kOnHeadersComplete] =\n      this.onRequestStart.bind(this)\n    this.requestParser[HTTPParser.kOnBody] = this.onRequestBody.bind(this)\n    this.requestParser[HTTPParser.kOnMessageComplete] =\n      this.onRequestEnd.bind(this)\n\n    // Response parser.\n    this.responseParser = new HTTPParser()\n    this.responseParser.initialize(HTTPParser.RESPONSE, {})\n    this.responseParser[HTTPParser.kOnHeadersComplete] =\n      this.onResponseStart.bind(this)\n    this.responseParser[HTTPParser.kOnBody] = this.onResponseBody.bind(this)\n    this.responseParser[HTTPParser.kOnMessageComplete] =\n      this.onResponseEnd.bind(this)\n\n    // Once the socket is finished, nothing can write to it\n    // anymore. It has also flushed any buffered chunks.\n    this.once('finish', () => this.requestParser.free())\n\n    if (this.baseUrl.protocol === 'https:') {\n      Reflect.set(this, 'encrypted', true)\n      // The server certificate is not the same as a CA\n      // passed to the TLS socket connection options.\n      Reflect.set(this, 'authorized', false)\n      Reflect.set(this, 'getProtocol', () => 'TLSv1.3')\n      Reflect.set(this, 'getSession', () => undefined)\n      Reflect.set(this, 'isSessionReused', () => false)\n    }\n  }\n\n  public emit(event: string | symbol, ...args: any[]): boolean {\n    const emitEvent = super.emit.bind(this, event as any, ...args)\n\n    if (this.responseListenersPromise) {\n      this.responseListenersPromise.finally(emitEvent)\n      return this.listenerCount(event) > 0\n    }\n\n    return emitEvent()\n  }\n\n  public destroy(error?: Error | undefined): this {\n    // Destroy the response parser when the socket gets destroyed.\n    // Normally, we shoud listen to the \"close\" event but it\n    // can be suppressed by using the \"emitClose: false\" option.\n    this.responseParser.free()\n\n    if (error) {\n      this.emit('error', error)\n    }\n\n    return super.destroy(error)\n  }\n\n  /**\n   * Establish this Socket connection as-is and pipe\n   * its data/events through this Socket.\n   */\n  public passthrough(): void {\n    this.socketState = 'passthrough'\n\n    if (this.destroyed) {\n      return\n    }\n\n    const socket = this.createConnection()\n    this.originalSocket = socket\n\n    // If the developer destroys the socket, destroy the original connection.\n    this.once('error', (error) => {\n      socket.destroy(error)\n    })\n\n    this.address = socket.address.bind(socket)\n\n    // Flush the buffered \"socket.write()\" calls onto\n    // the original socket instance (i.e. write request body).\n    // Exhaust the \"requestBuffer\" in case this Socket\n    // gets reused for different requests.\n    let writeArgs: NormalizedSocketWriteArgs | undefined\n    let headersWritten = false\n\n    while ((writeArgs = this.writeBuffer.shift())) {\n      if (writeArgs !== undefined) {\n        if (!headersWritten) {\n          const [chunk, encoding, callback] = writeArgs\n          const chunkString = chunk.toString()\n          const chunkBeforeRequestHeaders = chunkString.slice(\n            0,\n            chunkString.indexOf('\\r\\n') + 2\n          )\n          const chunkAfterRequestHeaders = chunkString.slice(\n            chunk.indexOf('\\r\\n\\r\\n')\n          )\n          const rawRequestHeaders = getRawFetchHeaders(this.request!.headers)\n          const requestHeadersString = rawRequestHeaders\n            // Skip the internal request ID deduplication header.\n            .filter(([name]) => {\n              return name.toLowerCase() !== INTERNAL_REQUEST_ID_HEADER_NAME\n            })\n            .map(([name, value]) => `${name}: ${value}`)\n            .join('\\r\\n')\n\n          // Modify the HTTP request message headers\n          // to reflect any changes to the request headers\n          // from the \"request\" event listener.\n          const headersChunk = `${chunkBeforeRequestHeaders}${requestHeadersString}${chunkAfterRequestHeaders}`\n          socket.write(headersChunk, encoding, callback)\n          headersWritten = true\n          continue\n        }\n\n        socket.write(...writeArgs)\n      }\n    }\n\n    // Forward TLS Socket properties onto this Socket instance\n    // in the case of a TLS/SSL connection.\n    if (Reflect.get(socket, 'encrypted')) {\n      const tlsProperties = [\n        'encrypted',\n        'authorized',\n        'getProtocol',\n        'getSession',\n        'isSessionReused',\n      ]\n\n      tlsProperties.forEach((propertyName) => {\n        Object.defineProperty(this, propertyName, {\n          enumerable: true,\n          get: () => {\n            const value = Reflect.get(socket, propertyName)\n            return typeof value === 'function' ? value.bind(socket) : value\n          },\n        })\n      })\n    }\n\n    socket\n      .on('lookup', (...args) => this.emit('lookup', ...args))\n      .on('connect', () => {\n        this.connecting = socket.connecting\n        this.emit('connect')\n      })\n      .on('secureConnect', () => this.emit('secureConnect'))\n      .on('secure', () => this.emit('secure'))\n      .on('session', (session) => this.emit('session', session))\n      .on('ready', () => this.emit('ready'))\n      .on('drain', () => this.emit('drain'))\n      .on('data', (chunk) => {\n        // Push the original response to this socket\n        // so it triggers the HTTP response parser. This unifies\n        // the handling pipeline for original and mocked response.\n        this.push(chunk)\n      })\n      .on('error', (error) => {\n        Reflect.set(this, '_hadError', Reflect.get(socket, '_hadError'))\n        this.emit('error', error)\n      })\n      .on('resume', () => this.emit('resume'))\n      .on('timeout', () => this.emit('timeout'))\n      .on('prefinish', () => this.emit('prefinish'))\n      .on('finish', () => this.emit('finish'))\n      .on('close', (hadError) => this.emit('close', hadError))\n      .on('end', () => this.emit('end'))\n  }\n\n  /**\n   * Convert the given Fetch API `Response` instance to an\n   * HTTP message and push it to the socket.\n   */\n  public async respondWith(response: Response): Promise<void> {\n    // Ignore the mocked response if the socket has been destroyed\n    // (e.g. aborted or timed out),\n    if (this.destroyed) {\n      return\n    }\n\n    // Handle \"type: error\" responses.\n    if (isPropertyAccessible(response, 'type') && response.type === 'error') {\n      this.errorWith(new TypeError('Network error'))\n      return\n    }\n\n    // First, emit all the connection events\n    // to emulate a successful connection.\n    this.mockConnect()\n    this.socketState = 'mock'\n\n    // Flush the write buffer to trigger write callbacks\n    // if it hasn't been flushed already (e.g. someone started reading request stream).\n    this.flushWriteBuffer()\n\n    // Create a `ServerResponse` instance to delegate HTTP message parsing,\n    // Transfer-Encoding, and other things to Node.js internals.\n    const serverResponse = new ServerResponse(new IncomingMessage(this))\n\n    /**\n     * Assign a mock socket instance to the server response to\n     * spy on the response chunk writes. Push the transformed response chunks\n     * to this `MockHttpSocket` instance to trigger the \"data\" event.\n     * @note Providing the same `MockSocket` instance when creating `ServerResponse`\n     * does not have the same effect.\n     * @see https://github.com/nodejs/node/blob/10099bb3f7fd97bb9dd9667188426866b3098e07/test/parallel/test-http-server-response-standalone.js#L32\n     */\n    serverResponse.assignSocket(\n      new MockSocket({\n        write: (chunk, encoding, callback) => {\n          this.push(chunk, encoding)\n          callback?.()\n        },\n        read() {},\n      })\n    )\n\n    /**\n     * @note Remove the `Connection` and `Date` response headers\n     * injected by `ServerResponse` by default. Those are required\n     * from the server but the interceptor is NOT technically a server.\n     * It's confusing to add response headers that the developer didn't\n     * specify themselves. They can always add these if they wish.\n     * @see https://www.rfc-editor.org/rfc/rfc9110#field.date\n     * @see https://www.rfc-editor.org/rfc/rfc9110#field.connection\n     */\n    serverResponse.removeHeader('connection')\n    serverResponse.removeHeader('date')\n\n    const rawResponseHeaders = getRawFetchHeaders(response.headers)\n\n    /**\n     * @note Call `.writeHead` in order to set the raw response headers\n     * in the same case as they were provided by the developer. Using\n     * `.setHeader()`/`.appendHeader()` normalizes header names.\n     */\n    serverResponse.writeHead(\n      response.status,\n      response.statusText || STATUS_CODES[response.status],\n      rawResponseHeaders\n    )\n\n    // If the developer destroy the socket, gracefully destroy the response.\n    this.once('error', () => {\n      serverResponse.destroy()\n    })\n\n    if (response.body) {\n      try {\n        const reader = response.body.getReader()\n\n        while (true) {\n          const { done, value } = await reader.read()\n\n          if (done) {\n            serverResponse.end()\n            break\n          }\n\n          serverResponse.write(value)\n        }\n      } catch (error) {\n        // Coerce response stream errors to 500 responses.\n        this.respondWith(createServerErrorResponse(error))\n        return\n      }\n    } else {\n      serverResponse.end()\n    }\n\n    // Close the socket if the connection wasn't marked as keep-alive.\n    if (!this.shouldKeepAlive) {\n      this.emit('readable')\n\n      /**\n       * @todo @fixme This is likely a hack.\n       * Since we push null to the socket, it never propagates to the\n       * parser, and the parser never calls \"onResponseEnd\" to close\n       * the response stream. We are closing the stream here manually\n       * but that shouldn't be the case.\n       */\n      this.responseStream?.push(null)\n      this.push(null)\n    }\n  }\n\n  /**\n   * Close this socket connection with the given error.\n   */\n  public errorWith(error?: Error): void {\n    this.destroy(error)\n  }\n\n  private mockConnect(): void {\n    // Calling this method immediately puts the socket\n    // into the connected state.\n    this.connecting = false\n\n    const isIPv6 =\n      net.isIPv6(this.connectionOptions.hostname) ||\n      this.connectionOptions.family === 6\n    const addressInfo = {\n      address: isIPv6 ? '::1' : '127.0.0.1',\n      family: isIPv6 ? 'IPv6' : 'IPv4',\n      port: this.connectionOptions.port,\n    }\n    // Return fake address information for the socket.\n    this.address = () => addressInfo\n    this.emit(\n      'lookup',\n      null,\n      addressInfo.address,\n      addressInfo.family === 'IPv6' ? 6 : 4,\n      this.connectionOptions.host\n    )\n    this.emit('connect')\n    this.emit('ready')\n\n    if (this.baseUrl.protocol === 'https:') {\n      this.emit('secure')\n      this.emit('secureConnect')\n\n      // A single TLS connection is represented by two \"session\" events.\n      this.emit(\n        'session',\n        this.connectionOptions.session ||\n          Buffer.from('mock-session-renegotiate')\n      )\n      this.emit('session', Buffer.from('mock-session-resume'))\n    }\n  }\n\n  private flushWriteBuffer(): void {\n    for (const writeCall of this.writeBuffer) {\n      if (typeof writeCall[2] === 'function') {\n        writeCall[2]()\n        /**\n         * @note Remove the callback from the write call\n         * so it doesn't get called twice on passthrough\n         * if `request.end()` was called within `request.write()`.\n         * @see https://github.com/mswjs/interceptors/issues/684\n         */\n        writeCall[2] = undefined\n      }\n    }\n  }\n\n  private onRequestStart: RequestHeadersCompleteCallback = (\n    versionMajor,\n    versionMinor,\n    rawHeaders,\n    _,\n    path,\n    __,\n    ___,\n    ____,\n    shouldKeepAlive\n  ) => {\n    this.shouldKeepAlive = shouldKeepAlive\n\n    const url = new URL(path, this.baseUrl)\n    const method = this.connectionOptions.method?.toUpperCase() || 'GET'\n    const headers = FetchResponse.parseRawHeaders(rawHeaders)\n    const canHaveBody = method !== 'GET' && method !== 'HEAD'\n\n    // Translate the basic authorization in the URL to the request header.\n    // Constructing a Request instance with a URL containing auth is no-op.\n    if (url.username || url.password) {\n      if (!headers.has('authorization')) {\n        headers.set('authorization', `Basic ${url.username}:${url.password}`)\n      }\n      url.username = ''\n      url.password = ''\n    }\n\n    // Create a new stream for each request.\n    // If this Socket is reused for multiple requests,\n    // this ensures that each request gets its own stream.\n    // One Socket instance can only handle one request at a time.\n    if (canHaveBody) {\n      this.requestStream = new Readable({\n        /**\n         * @note Provide the `read()` method so a `Readable` could be\n         * used as the actual request body (the stream calls \"read()\").\n         * We control the queue in the onRequestBody/End functions.\n         */\n        read: () => {\n          // If the user attempts to read the request body,\n          // flush the write buffer to trigger the callbacks.\n          // This way, if the request stream ends in the write callback,\n          // it will indeed end correctly.\n          this.flushWriteBuffer()\n        },\n      })\n    }\n\n    const requestId = createRequestId()\n    this.request = new Request(url, {\n      method,\n      headers,\n      credentials: 'same-origin',\n      // @ts-expect-error Undocumented Fetch property.\n      duplex: canHaveBody ? 'half' : undefined,\n      body: canHaveBody ? (Readable.toWeb(this.requestStream!) as any) : null,\n    })\n\n    Reflect.set(this.request, kRequestId, requestId)\n\n    // Skip handling the request that's already being handled\n    // by another (parent) interceptor. For example, XMLHttpRequest\n    // is often implemented via ClientRequest in Node.js (e.g. JSDOM).\n    // In that case, XHR interceptor will bubble down to the ClientRequest\n    // interceptor. No need to try to handle that request again.\n    /**\n     * @fixme Stop relying on the \"X-Request-Id\" request header\n     * to figure out if one interceptor has been invoked within another.\n     * @see https://github.com/mswjs/interceptors/issues/378\n     */\n    if (this.request.headers.has(INTERNAL_REQUEST_ID_HEADER_NAME)) {\n      this.passthrough()\n      return\n    }\n\n    this.onRequest({\n      requestId,\n      request: this.request,\n      socket: this,\n    })\n  }\n\n  private onRequestBody(chunk: Buffer): void {\n    invariant(\n      this.requestStream,\n      'Failed to write to a request stream: stream does not exist'\n    )\n\n    this.requestStream.push(chunk)\n  }\n\n  private onRequestEnd(): void {\n    // Request end can be called for requests without body.\n    if (this.requestStream) {\n      this.requestStream.push(null)\n    }\n  }\n\n  private onResponseStart: ResponseHeadersCompleteCallback = (\n    versionMajor,\n    versionMinor,\n    rawHeaders,\n    method,\n    url,\n    status,\n    statusText\n  ) => {\n    const headers = FetchResponse.parseRawHeaders(rawHeaders)\n\n    const response = new FetchResponse(\n      /**\n       * @note The Fetch API response instance exposed to the consumer\n       * is created over the response stream of the HTTP parser. It is NOT\n       * related to the Socket instance. This way, you can read response body\n       * in response listener while the Socket instance delays the emission\n       * of \"end\" and other events until those response listeners are finished.\n       */\n      FetchResponse.isResponseWithBody(status)\n        ? (Readable.toWeb(\n            (this.responseStream = new Readable({ read() {} }))\n          ) as any)\n        : null,\n      {\n        url,\n        status,\n        statusText,\n        headers,\n      }\n    )\n\n    invariant(\n      this.request,\n      'Failed to handle a response: request does not exist'\n    )\n\n    /**\n     * @fixme Stop relying on the \"X-Request-Id\" request header\n     * to figure out if one interceptor has been invoked within another.\n     * @see https://github.com/mswjs/interceptors/issues/378\n     */\n    if (this.request.headers.has(INTERNAL_REQUEST_ID_HEADER_NAME)) {\n      return\n    }\n\n    this.responseListenersPromise = this.onResponse({\n      response,\n      isMockedResponse: this.socketState === 'mock',\n      requestId: Reflect.get(this.request, kRequestId),\n      request: this.request,\n      socket: this,\n    })\n  }\n\n  private onResponseBody(chunk: Buffer) {\n    invariant(\n      this.responseStream,\n      'Failed to write to a response stream: stream does not exist'\n    )\n\n    this.responseStream.push(chunk)\n  }\n\n  private onResponseEnd(): void {\n    // Response end can be called for responses without body.\n    if (this.responseStream) {\n      this.responseStream.push(null)\n    }\n  }\n}\n","import net from 'node:net'\nimport {\n  normalizeSocketWriteArgs,\n  type WriteArgs,\n  type WriteCallback,\n} from './utils/normalizeSocketWriteArgs'\n\nexport interface MockSocketOptions {\n  write: (\n    chunk: Buffer | string,\n    encoding: BufferEncoding | undefined,\n    callback?: WriteCallback\n  ) => void\n\n  read: (chunk: Buffer, encoding: BufferEncoding | undefined) => void\n}\n\nexport class MockSocket extends net.Socket {\n  public connecting: boolean\n\n  constructor(protected readonly options: MockSocketOptions) {\n    super()\n    this.connecting = false\n    this.connect()\n\n    this._final = (callback) => {\n      callback(null)\n    }\n  }\n\n  public connect() {\n    // The connection will remain pending until\n    // the consumer decides to handle it.\n    this.connecting = true\n    return this\n  }\n\n  public write(...args: Array<unknown>): boolean {\n    const [chunk, encoding, callback] = normalizeSocketWriteArgs(\n      args as WriteArgs\n    )\n    this.options.write(chunk, encoding, callback)\n    return true\n  }\n\n  public end(...args: Array<unknown>) {\n    const [chunk, encoding, callback] = normalizeSocketWriteArgs(\n      args as WriteArgs\n    )\n    this.options.write(chunk, encoding, callback)\n    return super.end.apply(this, args as any)\n  }\n\n  public push(chunk: any, encoding?: BufferEncoding): boolean {\n    this.options.read(chunk, encoding)\n    return super.push(chunk, encoding)\n  }\n}\n","export type WriteCallback = (error?: Error | null) => void\n\nexport type WriteArgs =\n  | [chunk: unknown, callback?: WriteCallback]\n  | [chunk: unknown, encoding: BufferEncoding, callback?: WriteCallback]\n\nexport type NormalizedSocketWriteArgs = [\n  chunk: any,\n  encoding?: BufferEncoding,\n  callback?: WriteCallback,\n]\n\n/**\n * Normalizes the arguments provided to the `Writable.prototype.write()`\n * and `Writable.prototype.end()`.\n */\nexport function normalizeSocketWriteArgs(\n  args: WriteArgs\n): NormalizedSocketWriteArgs {\n  const normalized: NormalizedSocketWriteArgs = [args[0], undefined, undefined]\n\n  if (typeof args[1] === 'string') {\n    normalized[1] = args[1]\n  } else if (typeof args[1] === 'function') {\n    normalized[2] = args[1]\n  }\n\n  if (typeof args[2] === 'function') {\n    normalized[2] = args[2]\n  }\n\n  return normalized\n}\n","export function baseUrlFromConnectionOptions(options: any): URL {\n  if ('href' in options) {\n    return new URL(options.href)\n  }\n\n  const protocol = options.port === 443 ? 'https:' : 'http:'\n  const host = options.host\n\n  const url = new URL(`${protocol}//${host}`)\n\n  if (options.port) {\n    url.port = options.port.toString()\n  }\n\n  if (options.path) {\n    url.pathname = options.path\n  }\n\n  if (options.auth) {\n    const [username, password] = options.auth.split(':')\n    url.username = username\n    url.password = password\n  }\n\n  return url\n}\n","type 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() {\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      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          const headers = Reflect.construct(\n            target,\n            [Reflect.get(headersInit, kRawHeaders)],\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            ...Reflect.get(headersInit, kRawHeaders),\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      recordRawHeader(thisArg, args, '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      recordRawHeader(thisArg, args, '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\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 * instace 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","import net from 'node:net'\nimport http from 'node:http'\nimport https from 'node:https'\nimport {\n  MockHttpSocket,\n  type MockHttpSocketRequestCallback,\n  type MockHttpSocketResponseCallback,\n} from './MockHttpSocket'\n\ndeclare module 'node:http' {\n  interface Agent {\n    options?: http.AgentOptions\n    createConnection(options: any, callback: any): net.Socket\n  }\n}\n\ninterface MockAgentOptions {\n  customAgent?: http.RequestOptions['agent']\n  onRequest: MockHttpSocketRequestCallback\n  onResponse: MockHttpSocketResponseCallback\n}\n\nexport class MockAgent extends http.Agent {\n  private customAgent?: http.RequestOptions['agent']\n  private onRequest: MockHttpSocketRequestCallback\n  private onResponse: MockHttpSocketResponseCallback\n\n  constructor(options: MockAgentOptions) {\n    super()\n    this.customAgent = options.customAgent\n    this.onRequest = options.onRequest\n    this.onResponse = options.onResponse\n  }\n\n  public createConnection(options: any, callback: any): net.Socket {\n    const createConnection =\n      this.customAgent instanceof http.Agent\n        ? this.customAgent.createConnection\n        : super.createConnection\n\n    const createConnectionOptions =\n      this.customAgent instanceof http.Agent\n        ? {\n            ...options,\n            ...this.customAgent.options,\n          }\n        : options\n\n    const socket = new MockHttpSocket({\n      connectionOptions: options,\n      createConnection: createConnection.bind(\n        this.customAgent || this,\n        createConnectionOptions,\n        callback\n      ),\n      onRequest: this.onRequest.bind(this),\n      onResponse: this.onResponse.bind(this),\n    })\n\n    return socket\n  }\n}\n\nexport class MockHttpsAgent extends https.Agent {\n  private customAgent?: https.RequestOptions['agent']\n  private onRequest: MockHttpSocketRequestCallback\n  private onResponse: MockHttpSocketResponseCallback\n\n  constructor(options: MockAgentOptions) {\n    super()\n    this.customAgent = options.customAgent\n    this.onRequest = options.onRequest\n    this.onResponse = options.onResponse\n  }\n\n  public createConnection(options: any, callback: any): net.Socket {\n    const createConnection =\n      this.customAgent instanceof https.Agent\n        ? this.customAgent.createConnection\n        : super.createConnection\n\n    const createConnectionOptions =\n      this.customAgent instanceof https.Agent\n        ? {\n            ...options,\n            ...this.customAgent.options,\n          }\n        : options\n\n    const socket = new MockHttpSocket({\n      connectionOptions: options,\n      createConnection: createConnection.bind(\n        this.customAgent || this,\n        createConnectionOptions,\n        callback\n      ),\n      onRequest: this.onRequest.bind(this),\n      onResponse: this.onResponse.bind(this),\n    })\n\n    return socket\n  }\n}\n","import { urlToHttpOptions } from 'node:url'\nimport {\n  Agent as HttpAgent,\n  globalAgent as httpGlobalAgent,\n  IncomingMessage,\n} from 'node:http'\nimport {\n  RequestOptions,\n  Agent as HttpsAgent,\n  globalAgent as httpsGlobalAgent,\n} from 'node:https'\nimport {\n  /**\n   * @note Use the Node.js URL instead of the global URL\n   * because environments like JSDOM may override the global,\n   * breaking the compatibility with Node.js.\n   * @see https://github.com/node-fetch/node-fetch/issues/1376#issuecomment-966435555\n   */\n  URL,\n  Url as LegacyURL,\n  parse as parseUrl,\n} from 'node:url'\nimport { Logger } from '@open-draft/logger'\nimport {\n  ResolvedRequestOptions,\n  getUrlByRequestOptions,\n} from '../../../utils/getUrlByRequestOptions'\nimport { cloneObject } from '../../../utils/cloneObject'\nimport { isObject } from '../../../utils/isObject'\n\nconst logger = new Logger('http normalizeClientRequestArgs')\n\nexport type HttpRequestCallback = (response: IncomingMessage) => void\n\nexport type ClientRequestArgs =\n  // Request without any arguments is also possible.\n  | []\n  | [string | URL | LegacyURL, HttpRequestCallback?]\n  | [string | URL | LegacyURL, RequestOptions, HttpRequestCallback?]\n  | [RequestOptions, HttpRequestCallback?]\n\nfunction resolveRequestOptions(\n  args: ClientRequestArgs,\n  url: URL\n): RequestOptions {\n  // Calling `fetch` provides only URL to `ClientRequest`\n  // without any `RequestOptions` or callback.\n  if (typeof args[1] === 'undefined' || typeof args[1] === 'function') {\n    logger.info('request options not provided, deriving from the url', url)\n    return urlToHttpOptions(url)\n  }\n\n  if (args[1]) {\n    logger.info('has custom RequestOptions!', args[1])\n    const requestOptionsFromUrl = urlToHttpOptions(url)\n\n    logger.info('derived RequestOptions from the URL:', requestOptionsFromUrl)\n\n    /**\n     * Clone the request options to lock their state\n     * at the moment they are provided to `ClientRequest`.\n     * @see https://github.com/mswjs/interceptors/issues/86\n     */\n    logger.info('cloning RequestOptions...')\n    const clonedRequestOptions = cloneObject(args[1])\n    logger.info('successfully cloned RequestOptions!', clonedRequestOptions)\n\n    return {\n      ...requestOptionsFromUrl,\n      ...clonedRequestOptions,\n    }\n  }\n\n  logger.info('using an empty object as request options')\n  return {} as RequestOptions\n}\n\n/**\n * Overrides the given `URL` instance with the explicit properties provided\n * on the `RequestOptions` object. The options object takes precedence,\n * and will replace URL properties like \"host\", \"path\", and \"port\", if specified.\n */\nfunction overrideUrlByRequestOptions(url: URL, options: RequestOptions): URL {\n  url.host = options.host || url.host\n  url.hostname = options.hostname || url.hostname\n  url.port = options.port ? options.port.toString() : url.port\n\n  if (options.path) {\n    const parsedOptionsPath = parseUrl(options.path, false)\n    url.pathname = parsedOptionsPath.pathname || ''\n    url.search = parsedOptionsPath.search || ''\n  }\n\n  return url\n}\n\nfunction resolveCallback(\n  args: ClientRequestArgs\n): HttpRequestCallback | undefined {\n  return typeof args[1] === 'function' ? args[1] : args[2]\n}\n\nexport type NormalizedClientRequestArgs = [\n  url: URL,\n  options: ResolvedRequestOptions,\n  callback?: HttpRequestCallback\n]\n\n/**\n * Normalizes parameters given to a `http.request` call\n * so it always has a `URL` and `RequestOptions`.\n */\nexport function normalizeClientRequestArgs(\n  defaultProtocol: string,\n  args: ClientRequestArgs\n): NormalizedClientRequestArgs {\n  let url: URL\n  let options: ResolvedRequestOptions\n  let callback: HttpRequestCallback | undefined\n\n  logger.info('arguments', args)\n  logger.info('using default protocol:', defaultProtocol)\n\n  // Support \"http.request()\" calls without any arguments.\n  // That call results in a \"GET http://localhost\" request.\n  if (args.length === 0) {\n    const url = new URL('http://localhost')\n    const options = resolveRequestOptions(args, url)\n    return [url, options]\n  }\n\n  // Convert a url string into a URL instance\n  // and derive request options from it.\n  if (typeof args[0] === 'string') {\n    logger.info('first argument is a location string:', args[0])\n\n    url = new URL(args[0])\n    logger.info('created a url:', url)\n\n    const requestOptionsFromUrl = urlToHttpOptions(url)\n    logger.info('request options from url:', requestOptionsFromUrl)\n\n    options = resolveRequestOptions(args, url)\n    logger.info('resolved request options:', options)\n\n    callback = resolveCallback(args)\n  }\n  // Handle a given URL instance as-is\n  // and derive request options from it.\n  else if (args[0] instanceof URL) {\n    url = args[0]\n    logger.info('first argument is a URL:', url)\n\n    // Check if the second provided argument is RequestOptions.\n    // If it is, check if \"options.path\" was set and rewrite it\n    // on the input URL.\n    // Do this before resolving options from the URL below\n    // to prevent query string from being duplicated in the path.\n    if (typeof args[1] !== 'undefined' && isObject<RequestOptions>(args[1])) {\n      url = overrideUrlByRequestOptions(url, args[1])\n    }\n\n    options = resolveRequestOptions(args, url)\n    logger.info('derived request options:', options)\n\n    callback = resolveCallback(args)\n  }\n  // Handle a legacy URL instance and re-normalize from either a RequestOptions object\n  // or a WHATWG URL.\n  else if ('hash' in args[0] && !('method' in args[0])) {\n    const [legacyUrl] = args\n    logger.info('first argument is a legacy URL:', legacyUrl)\n\n    if (legacyUrl.hostname === null) {\n      /**\n       * We are dealing with a relative url, so use the path as an \"option\" and\n       * merge in any existing options, giving priority to exising options -- i.e. a path in any\n       * existing options will take precedence over the one contained in the url. This is consistent\n       * with the behaviour in ClientRequest.\n       * @see https://github.com/nodejs/node/blob/d84f1312915fe45fe0febe888db692c74894c382/lib/_http_client.js#L122\n       */\n      logger.info('given legacy URL is relative (no hostname)')\n\n      return isObject(args[1])\n        ? normalizeClientRequestArgs(defaultProtocol, [\n            { path: legacyUrl.path, ...args[1] },\n            args[2],\n          ])\n        : normalizeClientRequestArgs(defaultProtocol, [\n            { path: legacyUrl.path },\n            args[1] as HttpRequestCallback,\n          ])\n    }\n\n    logger.info('given legacy url is absolute')\n\n    // We are dealing with an absolute URL, so convert to WHATWG and try again.\n    const resolvedUrl = new URL(legacyUrl.href)\n\n    return args[1] === undefined\n      ? normalizeClientRequestArgs(defaultProtocol, [resolvedUrl])\n      : typeof args[1] === 'function'\n      ? normalizeClientRequestArgs(defaultProtocol, [resolvedUrl, args[1]])\n      : normalizeClientRequestArgs(defaultProtocol, [\n          resolvedUrl,\n          args[1],\n          args[2],\n        ])\n  }\n  // Handle a given \"RequestOptions\" object as-is\n  // and derive the URL instance from it.\n  else if (isObject(args[0])) {\n    options = { ...(args[0] as any) }\n    logger.info('first argument is RequestOptions:', options)\n\n    // When handling a \"RequestOptions\" object without an explicit \"protocol\",\n    // infer the protocol from the request issuing module (http/https).\n    options.protocol = options.protocol || defaultProtocol\n    logger.info('normalized request options:', options)\n\n    url = getUrlByRequestOptions(options)\n    logger.info('created a URL from RequestOptions:', url.href)\n\n    callback = resolveCallback(args)\n  } else {\n    throw new Error(\n      `Failed to construct ClientRequest with these parameters: ${args}`\n    )\n  }\n\n  options.protocol = options.protocol || url.protocol\n  options.method = options.method || 'GET'\n\n  /**\n   * Infer a fallback agent from the URL protocol.\n   * The interception is done on the \"ClientRequest\" level (\"NodeClientRequest\")\n   * and it may miss the correct agent. Always align the agent\n   * with the URL protocol, if not provided.\n   *\n   * @note Respect the \"agent: false\" value.\n   */\n  if (typeof options.agent === 'undefined') {\n    const agent =\n      options.protocol === 'https:'\n        ? new HttpsAgent({\n            // Any other value other than false is considered as true, so we don't add this property if undefined.\n            ...('rejectUnauthorized' in options && {\n              rejectUnauthorized: options.rejectUnauthorized,\n            }),\n          })\n        : new HttpAgent()\n\n    options.agent = agent\n    logger.info('resolved fallback agent:', agent)\n  }\n\n  /**\n   * Ensure that the d