@mswjs/interceptors 0.31.1 → 0.32.1

package/lib/node/chunk-3OJLYEWA.mjs

@@ -0,0 +1,963 @@
+import {
+  emitAsync,
+  toInteractiveRequest
+} from "./chunk-KWV3JXSI.mjs";
+import {
+  INTERNAL_REQUEST_ID_HEADER_NAME,
+  Interceptor,
+  RESPONSE_STATUS_CODES_WITHOUT_BODY,
+  createRequestId,
+  createServerErrorResponse,
+  isPropertyAccessible
+} from "./chunk-TGTPXCLF.mjs";
+
+// src/interceptors/ClientRequest/index.ts
+import http2 from "http";
+import https2 from "https";
+import { until } from "@open-draft/until";
+
+// src/interceptors/ClientRequest/MockHttpSocket.ts
+import net2 from "net";
+import {
+  HTTPParser
+} from "_http_common";
+import { IncomingMessage, ServerResponse } from "http";
+import { Readable } from "stream";
+import { invariant } from "outvariant";
+
+// src/interceptors/Socket/MockSocket.ts
+import net from "net";
+
+// src/interceptors/Socket/utils/normalizeSocketWriteArgs.ts
+function normalizeSocketWriteArgs(args) {
+  const normalized = [args[0], void 0, void 0];
+  if (typeof args[1] === "string") {
+    normalized[1] = args[1];
+  } else if (typeof args[1] === "function") {
+    normalized[2] = args[1];
+  }
+  if (typeof args[2] === "function") {
+    normalized[2] = args[2];
+  }
+  return normalized;
+}
+
+// src/interceptors/Socket/MockSocket.ts
+var MockSocket = class extends net.Socket {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.connecting = false;
+    this.connect();
+    this._final = (callback) => {
+      callback(null);
+    };
+  }
+  connect() {
+    this.connecting = true;
+    return this;
+  }
+  write(...args) {
+    const [chunk, encoding, callback] = normalizeSocketWriteArgs(
+      args
+    );
+    this.options.write(chunk, encoding, callback);
+    return true;
+  }
+  end(...args) {
+    const [chunk, encoding, callback] = normalizeSocketWriteArgs(
+      args
+    );
+    this.options.write(chunk, encoding, callback);
+    return super.end.apply(this, args);
+  }
+  push(chunk, encoding) {
+    this.options.read(chunk, encoding);
+    return super.push(chunk, encoding);
+  }
+};
+
+// src/interceptors/Socket/utils/baseUrlFromConnectionOptions.ts
+function baseUrlFromConnectionOptions(options) {
+  if ("href" in options) {
+    return new URL(options.href);
+  }
+  const protocol = options.port === 443 ? "https:" : "http:";
+  const host = options.host;
+  const url = new URL(`${protocol}//${host}`);
+  if (options.port) {
+    url.port = options.port.toString();
+  }
+  if (options.path) {
+    url.pathname = options.path;
+  }
+  if (options.auth) {
+    const [username, password] = options.auth.split(":");
+    url.username = username;
+    url.password = password;
+  }
+  return url;
+}
+
+// src/interceptors/Socket/utils/parseRawHeaders.ts
+function parseRawHeaders(rawHeaders) {
+  const headers = new Headers();
+  for (let line = 0; line < rawHeaders.length; line += 2) {
+    headers.append(rawHeaders[line], rawHeaders[line + 1]);
+  }
+  return headers;
+}
+
+// src/utils/getValueBySymbol.ts
+function getValueBySymbol(symbolName, source) {
+  const ownSymbols = Object.getOwnPropertySymbols(source);
+  const symbol = ownSymbols.find((symbol2) => {
+    return symbol2.description === symbolName;
+  });
+  if (symbol) {
+    return Reflect.get(source, symbol);
+  }
+  return;
+}
+
+// src/utils/isObject.ts
+function isObject(value, loose = false) {
+  return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
+}
+
+// src/utils/getRawFetchHeaders.ts
+function getRawFetchHeaders(headers) {
+  const headersList = getValueBySymbol("headers list", headers);
+  if (!headersList) {
+    return;
+  }
+  const headersMap = getValueBySymbol("headers map", headersList);
+  if (!headersMap || !isHeadersMapWithRawHeaderNames(headersMap)) {
+    return;
+  }
+  const rawHeaders = /* @__PURE__ */ new Map();
+  headersMap.forEach(({ name, value }) => {
+    rawHeaders.set(name, value);
+  });
+  return rawHeaders;
+}
+function isHeadersMapWithRawHeaderNames(headersMap) {
+  return Array.from(
+    headersMap.values()
+  ).every((value) => {
+    return isObject(value) && "name" in value;
+  });
+}
+
+// src/interceptors/ClientRequest/MockHttpSocket.ts
+var kRequestId = Symbol("kRequestId");
+var MockHttpSocket = class extends MockSocket {
+  constructor(options) {
+    super({
+      write: (chunk, encoding, callback) => {
+        this.writeBuffer.push([chunk, encoding, callback]);
+        if (chunk) {
+          this.requestParser.execute(
+            Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding)
+          );
+        }
+      },
+      read: (chunk) => {
+        if (chunk !== null) {
+          this.responseParser.execute(
+            Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+          );
+        }
+      }
+    });
+    this.writeBuffer = [];
+    this.responseType = "bypassed";
+    this.onRequestStart = (versionMajor, versionMinor, rawHeaders, _, path, __, ___, ____, shouldKeepAlive) => {
+      this.shouldKeepAlive = shouldKeepAlive;
+      const url = new URL(path, this.baseUrl);
+      const method = this.connectionOptions.method || "GET";
+      const headers = parseRawHeaders(rawHeaders);
+      const canHaveBody = method !== "GET" && method !== "HEAD";
+      if (url.username || url.password) {
+        if (!headers.has("authorization")) {
+          headers.set("authorization", `Basic ${url.username}:${url.password}`);
+        }
+        url.username = "";
+        url.password = "";
+      }
+      if (canHaveBody) {
+        this.requestStream = new Readable({
+          /**
+           * @note Provide the `read()` method so a `Readable` could be
+           * used as the actual request body (the stream calls "read()").
+           * We control the queue in the onRequestBody/End functions.
+           */
+          read: () => {
+            this.flushWriteBuffer();
+          }
+        });
+      }
+      const requestId = createRequestId();
+      this.request = new Request(url, {
+        method,
+        headers,
+        credentials: "same-origin",
+        // @ts-expect-error Undocumented Fetch property.
+        duplex: canHaveBody ? "half" : void 0,
+        body: canHaveBody ? Readable.toWeb(this.requestStream) : null
+      });
+      Reflect.set(this.request, kRequestId, requestId);
+      if (this.request.headers.has(INTERNAL_REQUEST_ID_HEADER_NAME)) {
+        this.passthrough();
+        return;
+      }
+      this.onRequest({
+        requestId,
+        request: this.request,
+        socket: this
+      });
+    };
+    this.onResponseStart = (versionMajor, versionMinor, rawHeaders, method, url, status, statusText) => {
+      const headers = parseRawHeaders(rawHeaders);
+      const canHaveBody = !RESPONSE_STATUS_CODES_WITHOUT_BODY.has(status);
+      if (canHaveBody) {
+        this.responseStream = new Readable();
+      }
+      const response = new Response(
+        /**
+         * @note The Fetch API response instance exposed to the consumer
+         * is created over the response stream of the HTTP parser. It is NOT
+         * related to the Socket instance. This way, you can read response body
+         * in response listener while the Socket instance delays the emission
+         * of "end" and other events until those response listeners are finished.
+         */
+        canHaveBody ? Readable.toWeb(this.responseStream) : null,
+        {
+          status,
+          statusText,
+          headers
+        }
+      );
+      invariant(
+        this.request,
+        "Failed to handle a response: request does not exist"
+      );
+      if (this.request.headers.has(INTERNAL_REQUEST_ID_HEADER_NAME)) {
+        return;
+      }
+      this.responseListenersPromise = this.onResponse({
+        response,
+        isMockedResponse: this.responseType === "mock",
+        requestId: Reflect.get(this.request, kRequestId),
+        request: this.request,
+        socket: this
+      });
+    };
+    this.connectionOptions = options.connectionOptions;
+    this.createConnection = options.createConnection;
+    this.onRequest = options.onRequest;
+    this.onResponse = options.onResponse;
+    this.baseUrl = baseUrlFromConnectionOptions(this.connectionOptions);
+    this.requestParser = new HTTPParser();
+    this.requestParser.initialize(HTTPParser.REQUEST, {});
+    this.requestParser[HTTPParser.kOnHeadersComplete] = this.onRequestStart.bind(this);
+    this.requestParser[HTTPParser.kOnBody] = this.onRequestBody.bind(this);
+    this.requestParser[HTTPParser.kOnMessageComplete] = this.onRequestEnd.bind(this);
+    this.responseParser = new HTTPParser();
+    this.responseParser.initialize(HTTPParser.RESPONSE, {});
+    this.responseParser[HTTPParser.kOnHeadersComplete] = this.onResponseStart.bind(this);
+    this.responseParser[HTTPParser.kOnBody] = this.onResponseBody.bind(this);
+    this.responseParser[HTTPParser.kOnMessageComplete] = this.onResponseEnd.bind(this);
+    this.once("finish", () => this.requestParser.free());
+    if (this.baseUrl.protocol === "https:") {
+      Reflect.set(this, "encrypted", true);
+      Reflect.set(this, "authorized", false);
+      Reflect.set(this, "getProtocol", () => "TLSv1.3");
+      Reflect.set(this, "getSession", () => void 0);
+      Reflect.set(this, "isSessionReused", () => false);
+    }
+  }
+  emit(event, ...args) {
+    const emitEvent = super.emit.bind(this, event, ...args);
+    if (this.responseListenersPromise) {
+      this.responseListenersPromise.finally(emitEvent);
+      return this.listenerCount(event) > 0;
+    }
+    return emitEvent();
+  }
+  destroy(error) {
+    this.responseParser.free();
+    if (error) {
+      this.emit("error", error);
+    }
+    return super.destroy(error);
+  }
+  /**
+   * Establish this Socket connection as-is and pipe
+   * its data/events through this Socket.
+   */
+  passthrough() {
+    if (this.destroyed) {
+      return;
+    }
+    const socket = this.createConnection();
+    this.once("error", (error) => {
+      socket.destroy(error);
+    });
+    this.address = socket.address.bind(socket);
+    let writeArgs;
+    let headersWritten = false;
+    while (writeArgs = this.writeBuffer.shift()) {
+      if (writeArgs !== void 0) {
+        if (!headersWritten) {
+          const [chunk, encoding, callback] = writeArgs;
+          const chunkString = chunk.toString();
+          const chunkBeforeRequestHeaders = chunkString.slice(
+            0,
+            chunkString.indexOf("\r\n") + 2
+          );
+          const chunkAfterRequestHeaders = chunkString.slice(
+            chunk.indexOf("\r\n\r\n")
+          );
+          const requestHeaders = getRawFetchHeaders(this.request.headers) || this.request.headers;
+          const requestHeadersString = Array.from(requestHeaders.entries()).filter(([name]) => name !== INTERNAL_REQUEST_ID_HEADER_NAME).map(([name, value]) => `${name}: ${value}`).join("\r\n");
+          const headersChunk = `${chunkBeforeRequestHeaders}${requestHeadersString}${chunkAfterRequestHeaders}`;
+          socket.write(headersChunk, encoding, callback);
+          headersWritten = true;
+          continue;
+        }
+        socket.write(...writeArgs);
+      }
+    }
+    if (Reflect.get(socket, "encrypted")) {
+      const tlsProperties = [
+        "encrypted",
+        "authorized",
+        "getProtocol",
+        "getSession",
+        "isSessionReused"
+      ];
+      tlsProperties.forEach((propertyName) => {
+        Object.defineProperty(this, propertyName, {
+          enumerable: true,
+          get: () => {
+            const value = Reflect.get(socket, propertyName);
+            return typeof value === "function" ? value.bind(socket) : value;
+          }
+        });
+      });
+    }
+    socket.on("lookup", (...args) => this.emit("lookup", ...args)).on("connect", () => {
+      this.connecting = socket.connecting;
+      this.emit("connect");
+    }).on("secureConnect", () => this.emit("secureConnect")).on("secure", () => this.emit("secure")).on("session", (session) => this.emit("session", session)).on("ready", () => this.emit("ready")).on("drain", () => this.emit("drain")).on("data", (chunk) => {
+      this.push(chunk);
+    }).on("error", (error) => {
+      Reflect.set(this, "_hadError", Reflect.get(socket, "_hadError"));
+      this.emit("error", error);
+    }).on("resume", () => this.emit("resume")).on("timeout", () => this.emit("timeout")).on("prefinish", () => this.emit("prefinish")).on("finish", () => this.emit("finish")).on("close", (hadError) => this.emit("close", hadError)).on("end", () => this.emit("end"));
+  }
+  /**
+   * Convert the given Fetch API `Response` instance to an
+   * HTTP message and push it to the socket.
+   */
+  async respondWith(response) {
+    var _a;
+    if (this.destroyed) {
+      return;
+    }
+    if (isPropertyAccessible(response, "type") && response.type === "error") {
+      this.errorWith(new TypeError("Network error"));
+      return;
+    }
+    this.mockConnect();
+    this.responseType = "mock";
+    this.flushWriteBuffer();
+    const serverResponse = new ServerResponse(new IncomingMessage(this));
+    serverResponse.assignSocket(
+      new MockSocket({
+        write: (chunk, encoding, callback) => {
+          this.push(chunk, encoding);
+          callback == null ? void 0 : callback();
+        },
+        read() {
+        }
+      })
+    );
+    serverResponse.statusCode = response.status;
+    serverResponse.statusMessage = response.statusText;
+    serverResponse.removeHeader("connection");
+    serverResponse.removeHeader("date");
+    this.once("error", () => {
+      serverResponse.destroy();
+    });
+    const headers = getRawFetchHeaders(response.headers) || response.headers;
+    for (const [name, value] of headers) {
+      serverResponse.setHeader(name, value);
+    }
+    if (response.body) {
+      try {
+        const reader = response.body.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            serverResponse.end();
+            break;
+          }
+          serverResponse.write(value);
+        }
+      } catch (error) {
+        this.respondWith(createServerErrorResponse(error));
+        return;
+      }
+    } else {
+      serverResponse.end();
+    }
+    if (!this.shouldKeepAlive) {
+      this.emit("readable");
+      (_a = this.responseStream) == null ? void 0 : _a.push(null);
+      this.push(null);
+    }
+  }
+  /**
+   * Close this socket connection with the given error.
+   */
+  errorWith(error) {
+    this.destroy(error);
+  }
+  mockConnect() {
+    this.connecting = false;
+    const isIPv6 = net2.isIPv6(this.connectionOptions.hostname) || this.connectionOptions.family === 6;
+    const addressInfo = {
+      address: isIPv6 ? "::1" : "127.0.0.1",
+      family: isIPv6 ? "IPv6" : "IPv4",
+      port: this.connectionOptions.port
+    };
+    this.address = () => addressInfo;
+    this.emit(
+      "lookup",
+      null,
+      addressInfo.address,
+      addressInfo.family === "IPv6" ? 6 : 4,
+      this.connectionOptions.host
+    );
+    this.emit("connect");
+    this.emit("ready");
+    if (this.baseUrl.protocol === "https:") {
+      this.emit("secure");
+      this.emit("secureConnect");
+      this.emit(
+        "session",
+        this.connectionOptions.session || Buffer.from("mock-session-renegotiate")
+      );
+      this.emit("session", Buffer.from("mock-session-resume"));
+    }
+  }
+  flushWriteBuffer() {
+    var _a;
+    let args;
+    while (args = this.writeBuffer.shift()) {
+      (_a = args == null ? void 0 : args[2]) == null ? void 0 : _a.call(args);
+    }
+  }
+  onRequestBody(chunk) {
+    invariant(
+      this.requestStream,
+      "Failed to write to a request stream: stream does not exist"
+    );
+    this.requestStream.push(chunk);
+  }
+  onRequestEnd() {
+    if (this.requestStream) {
+      this.requestStream.push(null);
+    }
+  }
+  onResponseBody(chunk) {
+    invariant(
+      this.responseStream,
+      "Failed to write to a response stream: stream does not exist"
+    );
+    this.responseStream.push(chunk);
+  }
+  onResponseEnd() {
+    if (this.responseStream) {
+      this.responseStream.push(null);
+    }
+  }
+};
+
+// src/interceptors/ClientRequest/agents.ts
+import http from "http";
+import https from "https";
+var MockAgent = class extends http.Agent {
+  constructor(options) {
+    super();
+    this.customAgent = options.customAgent;
+    this.onRequest = options.onRequest;
+    this.onResponse = options.onResponse;
+  }
+  createConnection(options, callback) {
+    const createConnection = this.customAgent instanceof http.Agent && this.customAgent.createConnection || super.createConnection;
+    const socket = new MockHttpSocket({
+      connectionOptions: options,
+      createConnection: createConnection.bind(this, options, callback),
+      onRequest: this.onRequest.bind(this),
+      onResponse: this.onResponse.bind(this)
+    });
+    return socket;
+  }
+};
+var MockHttpsAgent = class extends https.Agent {
+  constructor(options) {
+    super();
+    this.customAgent = options.customAgent;
+    this.onRequest = options.onRequest;
+    this.onResponse = options.onResponse;
+  }
+  createConnection(options, callback) {
+    const createConnection = this.customAgent instanceof https.Agent && this.customAgent.createConnection || super.createConnection;
+    const socket = new MockHttpSocket({
+      connectionOptions: options,
+      createConnection: createConnection.bind(this, options, callback),
+      onRequest: this.onRequest.bind(this),
+      onResponse: this.onResponse.bind(this)
+    });
+    return socket;
+  }
+};
+
+// src/interceptors/ClientRequest/utils/normalizeClientRequestArgs.ts
+import {
+  Agent as HttpAgent,
+  globalAgent as httpGlobalAgent
+} from "http";
+import {
+  Agent as HttpsAgent,
+  globalAgent as httpsGlobalAgent
+} from "https";
+import {
+  URL as URL2,
+  parse as parseUrl
+} from "url";
+import { Logger as Logger3 } from "@open-draft/logger";
+
+// src/utils/getRequestOptionsByUrl.ts
+function getRequestOptionsByUrl(url) {
+  const options = {
+    method: "GET",
+    protocol: url.protocol,
+    hostname: typeof url.hostname === "string" && url.hostname.startsWith("[") ? url.hostname.slice(1, -1) : url.hostname,
+    host: url.host,
+    path: `${url.pathname}${url.search || ""}`
+  };
+  if (!!url.port) {
+    options.port = Number(url.port);
+  }
+  if (url.username || url.password) {
+    options.auth = `${url.username}:${url.password}`;
+  }
+  return options;
+}
+
+// src/utils/getUrlByRequestOptions.ts
+import { Agent } from "http";
+import { Logger } from "@open-draft/logger";
+var logger = new Logger("utils getUrlByRequestOptions");
+var DEFAULT_PATH = "/";
+var DEFAULT_PROTOCOL = "http:";
+var DEFAULT_HOSTNAME = "localhost";
+var SSL_PORT = 443;
+function getAgent(options) {
+  return options.agent instanceof Agent ? options.agent : void 0;
+}
+function getProtocolByRequestOptions(options) {
+  var _a;
+  if (options.protocol) {
+    return options.protocol;
+  }
+  const agent = getAgent(options);
+  const agentProtocol = agent == null ? void 0 : agent.protocol;
+  if (agentProtocol) {
+    return agentProtocol;
+  }
+  const port = getPortByRequestOptions(options);
+  const isSecureRequest = options.cert || port === SSL_PORT;
+  return isSecureRequest ? "https:" : ((_a = options.uri) == null ? void 0 : _a.protocol) || DEFAULT_PROTOCOL;
+}
+function getPortByRequestOptions(options) {
+  if (options.port) {
+    return Number(options.port);
+  }
+  const agent = getAgent(options);
+  if (agent == null ? void 0 : agent.options.port) {
+    return Number(agent.options.port);
+  }
+  if (agent == null ? void 0 : agent.defaultPort) {
+    return Number(agent.defaultPort);
+  }
+  return void 0;
+}
+function getAuthByRequestOptions(options) {
+  if (options.auth) {
+    const [username, password] = options.auth.split(":");
+    return { username, password };
+  }
+}
+function isRawIPv6Address(host) {
+  return host.includes(":") && !host.startsWith("[") && !host.endsWith("]");
+}
+function getHostname(options) {
+  let host = options.hostname || options.host;
+  if (host) {
+    if (isRawIPv6Address(host)) {
+      host = `[${host}]`;
+    }
+    return new URL(`http://${host}`).hostname;
+  }
+  return DEFAULT_HOSTNAME;
+}
+function getUrlByRequestOptions(options) {
+  logger.info("request options", options);
+  if (options.uri) {
+    logger.info(
+      'constructing url from explicitly provided "options.uri": %s',
+      options.uri
+    );
+    return new URL(options.uri.href);
+  }
+  logger.info("figuring out url from request options...");
+  const protocol = getProtocolByRequestOptions(options);
+  logger.info("protocol", protocol);
+  const port = getPortByRequestOptions(options);
+  logger.info("port", port);
+  const hostname = getHostname(options);
+  logger.info("hostname", hostname);
+  const path = options.path || DEFAULT_PATH;
+  logger.info("path", path);
+  const credentials = getAuthByRequestOptions(options);
+  logger.info("credentials", credentials);
+  const authString = credentials ? `${credentials.username}:${credentials.password}@` : "";
+  logger.info("auth string:", authString);
+  const portString = typeof port !== "undefined" ? `:${port}` : "";
+  const url = new URL(`${protocol}//${hostname}${portString}${path}`);
+  url.username = (credentials == null ? void 0 : credentials.username) || "";
+  url.password = (credentials == null ? void 0 : credentials.password) || "";
+  logger.info("created url:", url);
+  return url;
+}
+
+// src/utils/cloneObject.ts
+import { Logger as Logger2 } from "@open-draft/logger";
+var logger2 = new Logger2("cloneObject");
+function isPlainObject(obj) {
+  var _a;
+  logger2.info("is plain object?", obj);
+  if (obj == null || !((_a = obj.constructor) == null ? void 0 : _a.name)) {
+    logger2.info("given object is undefined, not a plain object...");
+    return false;
+  }
+  logger2.info("checking the object constructor:", obj.constructor.name);
+  return obj.constructor.name === "Object";
+}
+function cloneObject(obj) {
+  logger2.info("cloning object:", obj);
+  const enumerableProperties = Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      logger2.info("analyzing key-value pair:", key, value);
+      acc[key] = isPlainObject(value) ? cloneObject(value) : value;
+      return acc;
+    },
+    {}
+  );
+  return isPlainObject(obj) ? enumerableProperties : Object.assign(Object.getPrototypeOf(obj), enumerableProperties);
+}
+
+// src/interceptors/ClientRequest/utils/normalizeClientRequestArgs.ts
+var logger3 = new Logger3("http normalizeClientRequestArgs");
+function resolveRequestOptions(args, url) {
+  if (typeof args[1] === "undefined" || typeof args[1] === "function") {
+    logger3.info("request options not provided, deriving from the url", url);
+    return getRequestOptionsByUrl(url);
+  }
+  if (args[1]) {
+    logger3.info("has custom RequestOptions!", args[1]);
+    const requestOptionsFromUrl = getRequestOptionsByUrl(url);
+    logger3.info("derived RequestOptions from the URL:", requestOptionsFromUrl);
+    logger3.info("cloning RequestOptions...");
+    const clonedRequestOptions = cloneObject(args[1]);
+    logger3.info("successfully cloned RequestOptions!", clonedRequestOptions);
+    return {
+      ...requestOptionsFromUrl,
+      ...clonedRequestOptions
+    };
+  }
+  logger3.info("using an empty object as request options");
+  return {};
+}
+function overrideUrlByRequestOptions(url, options) {
+  url.host = options.host || url.host;
+  url.hostname = options.hostname || url.hostname;
+  url.port = options.port ? options.port.toString() : url.port;
+  if (options.path) {
+    const parsedOptionsPath = parseUrl(options.path, false);
+    url.pathname = parsedOptionsPath.pathname || "";
+    url.search = parsedOptionsPath.search || "";
+  }
+  return url;
+}
+function resolveCallback(args) {
+  return typeof args[1] === "function" ? args[1] : args[2];
+}
+function normalizeClientRequestArgs(defaultProtocol, args) {
+  let url;
+  let options;
+  let callback;
+  logger3.info("arguments", args);
+  logger3.info("using default protocol:", defaultProtocol);
+  if (args.length === 0) {
+    const url2 = new URL2("http://localhost");
+    const options2 = resolveRequestOptions(args, url2);
+    return [url2, options2];
+  }
+  if (typeof args[0] === "string") {
+    logger3.info("first argument is a location string:", args[0]);
+    url = new URL2(args[0]);
+    logger3.info("created a url:", url);
+    const requestOptionsFromUrl = getRequestOptionsByUrl(url);
+    logger3.info("request options from url:", requestOptionsFromUrl);
+    options = resolveRequestOptions(args, url);
+    logger3.info("resolved request options:", options);
+    callback = resolveCallback(args);
+  } else if (args[0] instanceof URL2) {
+    url = args[0];
+    logger3.info("first argument is a URL:", url);
+    if (typeof args[1] !== "undefined" && isObject(args[1])) {
+      url = overrideUrlByRequestOptions(url, args[1]);
+    }
+    options = resolveRequestOptions(args, url);
+    logger3.info("derived request options:", options);
+    callback = resolveCallback(args);
+  } else if ("hash" in args[0] && !("method" in args[0])) {
+    const [legacyUrl] = args;
+    logger3.info("first argument is a legacy URL:", legacyUrl);
+    if (legacyUrl.hostname === null) {
+      logger3.info("given legacy URL is relative (no hostname)");
+      return isObject(args[1]) ? normalizeClientRequestArgs(defaultProtocol, [
+        { path: legacyUrl.path, ...args[1] },
+        args[2]
+      ]) : normalizeClientRequestArgs(defaultProtocol, [
+        { path: legacyUrl.path },
+        args[1]
+      ]);
+    }
+    logger3.info("given legacy url is absolute");
+    const resolvedUrl = new URL2(legacyUrl.href);
+    return args[1] === void 0 ? normalizeClientRequestArgs(defaultProtocol, [resolvedUrl]) : typeof args[1] === "function" ? normalizeClientRequestArgs(defaultProtocol, [resolvedUrl, args[1]]) : normalizeClientRequestArgs(defaultProtocol, [
+      resolvedUrl,
+      args[1],
+      args[2]
+    ]);
+  } else if (isObject(args[0])) {
+    options = { ...args[0] };
+    logger3.info("first argument is RequestOptions:", options);
+    options.protocol = options.protocol || defaultProtocol;
+    logger3.info("normalized request options:", options);
+    url = getUrlByRequestOptions(options);
+    logger3.info("created a URL from RequestOptions:", url.href);
+    callback = resolveCallback(args);
+  } else {
+    throw new Error(
+      `Failed to construct ClientRequest with these parameters: ${args}`
+    );
+  }
+  options.protocol = options.protocol || url.protocol;
+  options.method = options.method || "GET";
+  if (typeof options.agent === "undefined") {
+    const agent = options.protocol === "https:" ? new HttpsAgent({
+      rejectUnauthorized: options.rejectUnauthorized
+    }) : new HttpAgent();
+    options.agent = agent;
+    logger3.info("resolved fallback agent:", agent);
+  }
+  if (!options._defaultAgent) {
+    logger3.info(
+      'has no default agent, setting the default agent for "%s"',
+      options.protocol
+    );
+    options._defaultAgent = options.protocol === "https:" ? httpsGlobalAgent : httpGlobalAgent;
+  }
+  logger3.info("successfully resolved url:", url.href);
+  logger3.info("successfully resolved options:", options);
+  logger3.info("successfully resolved callback:", callback);
+  if (!(url instanceof URL2)) {
+    url = url.toString();
+  }
+  return [url, options, callback];
+}
+
+// src/utils/isNodeLikeError.ts
+function isNodeLikeError(error) {
+  if (error == null) {
+    return false;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return "code" in error && "errno" in error;
+}
+
+// src/interceptors/ClientRequest/index.ts
+var _ClientRequestInterceptor = class extends Interceptor {
+  constructor() {
+    super(_ClientRequestInterceptor.symbol);
+    this.onRequest = async ({
+      request,
+      socket
+    }) => {
+      const requestId = Reflect.get(request, kRequestId);
+      const { interactiveRequest, requestController } = toInteractiveRequest(request);
+      this.emitter.once("request", ({ requestId: pendingRequestId }) => {
+        if (pendingRequestId !== requestId) {
+          return;
+        }
+        if (requestController.responsePromise.state === "pending") {
+          this.logger.info(
+            "request has not been handled in listeners, executing fail-safe listener..."
+          );
+          requestController.responsePromise.resolve(void 0);
+        }
+      });
+      const listenerResult = await until(async () => {
+        await emitAsync(this.emitter, "request", {
+          requestId,
+          request: interactiveRequest
+        });
+        return await requestController.responsePromise;
+      });
+      if (listenerResult.error) {
+        if (listenerResult.error instanceof Response) {
+          socket.respondWith(listenerResult.error);
+          return;
+        }
+        if (isNodeLikeError(listenerResult.error)) {
+          socket.errorWith(listenerResult.error);
+          return;
+        }
+        if (this.emitter.listenerCount("unhandledException") > 0) {
+          await emitAsync(this.emitter, "unhandledException", {
+            error: listenerResult.error,
+            request,
+            requestId,
+            controller: {
+              respondWith: socket.respondWith.bind(socket),
+              errorWith: socket.errorWith.bind(socket)
+            }
+          });
+          if (!socket.connecting || socket.destroyed) {
+            return;
+          }
+        }
+        socket.respondWith(createServerErrorResponse(listenerResult.error));
+        return;
+      }
+      const mockedResponse = listenerResult.data;
+      if (mockedResponse) {
+        socket.respondWith(mockedResponse);
+        return;
+      }
+      socket.passthrough();
+    };
+    this.onResponse = async ({
+      requestId,
+      request,
+      response,
+      isMockedResponse
+    }) => {
+      return emitAsync(this.emitter, "response", {
+        requestId,
+        request,
+        response,
+        isMockedResponse
+      });
+    };
+  }
+  setup() {
+    const { get: originalGet, request: originalRequest } = http2;
+    const { get: originalHttpsGet, request: originalHttpsRequest } = https2;
+    const onRequest = this.onRequest.bind(this);
+    const onResponse = this.onResponse.bind(this);
+    http2.request = new Proxy(http2.request, {
+      apply: (target, thisArg, args) => {
+        const [url, options, callback] = normalizeClientRequestArgs(
+          "http:",
+          args
+        );
+        const mockAgent = new MockAgent({
+          customAgent: options.agent,
+          onRequest,
+          onResponse
+        });
+        options.agent = mockAgent;
+        return Reflect.apply(target, thisArg, [url, options, callback]);
+      }
+    });
+    http2.get = new Proxy(http2.get, {
+      apply: (target, thisArg, args) => {
+        const [url, options, callback] = normalizeClientRequestArgs(
+          "http:",
+          args
+        );
+        const mockAgent = new MockAgent({
+          customAgent: options.agent,
+          onRequest,
+          onResponse
+        });
+        options.agent = mockAgent;
+        return Reflect.apply(target, thisArg, [url, options, callback]);
+      }
+    });
+    https2.request = new Proxy(https2.request, {
+      apply: (target, thisArg, args) => {
+        const [url, options, callback] = normalizeClientRequestArgs(
+          "https:",
+          args
+        );
+        const mockAgent = new MockHttpsAgent({
+          customAgent: options.agent,
+          onRequest,
+          onResponse
+        });
+        options.agent = mockAgent;
+        return Reflect.apply(target, thisArg, [url, options, callback]);
+      }
+    });
+    https2.get = new Proxy(https2.get, {
+      apply: (target, thisArg, args) => {
+        const [url, options, callback] = normalizeClientRequestArgs(
+          "https:",
+          args
+        );
+        const mockAgent = new MockHttpsAgent({
+          customAgent: options.agent,
+          onRequest,
+          onResponse
+        });
+        options.agent = mockAgent;
+        return Reflect.apply(target, thisArg, [url, options, callback]);
+      }
+    });
+    this.subscriptions.push(() => {
+      http2.get = originalGet;
+      http2.request = originalRequest;
+      https2.get = originalHttpsGet;
+      https2.request = originalHttpsRequest;
+    });
+  }
+};
+var ClientRequestInterceptor = _ClientRequestInterceptor;
+ClientRequestInterceptor.symbol = Symbol("client-request-interceptor");
+
+export {
+  ClientRequestInterceptor
+};
+//# sourceMappingURL=chunk-3OJLYEWA.mjs.map