@npy/fetch 0.1.0 → 0.1.2

package/fetch.d.ts

@@ -0,0 +1,58 @@
+import { ProxyInfo } from '@npy/proxy-kit';
+import { BodyInit as FetchBodyInit } from './body';
+import { HttpClientOptions, HttpClient } from './http-client';
+export type FetchProxyInput = string | ProxyInfo | null;
+export interface RequestInit extends Omit<globalThis.RequestInit, "body" | "headers"> {
+    body?: FetchBodyInit | null;
+    headers?: HeadersInit;
+    client?: HttpClient;
+    proxy?: FetchProxyInput;
+}
+export type FetchRequestInit = RequestInit;
+export interface FetchOptions extends HttpClientOptions {
+}
+export interface FetchLike {
+    (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    readonly client: HttpClient;
+}
+/**
+ * Normalizes any supported header input into a {@link Headers} instance.
+ *
+ * @remarks
+ * If the input is already a {@link Headers} object, the same instance is returned.
+ * Tuple arrays and plain records are copied into a new {@link Headers}.
+ */
+export declare function normalizeHeaders(headers?: HeadersInit): Headers;
+/**
+ * Creates a fetch-compatible client backed by {@link HttpClient}.
+ *
+ * @remarks
+ * The returned function follows the standard fetch shape, but uses this library's
+ * connection pooling, proxy support and body/error mapping rules.
+ *
+ * When no client is provided, an internal {@link HttpClient} is created and owned
+ * by the returned fetch-like function. Calling {@link FetchLike.close} closes that
+ * internal client and any proxy-specific clients created on demand.
+ *
+ * @example
+ * ```ts
+ * const fetchLike = createFetch();
+ * const response = await fetchLike("https://httpbin.org/anything");
+ * const data = await response.json();
+ * await fetchLike.close();
+ * ```
+ */
+export declare function createFetch(client?: HttpClient): FetchLike;
+export type { HttpClientOptions, ProxyInfo };
+export { HttpClient };
+/**
+ * Default fetch-compatible client created with {@link createFetch}.
+ *
+ * @remarks
+ * This singleton owns its internal {@link HttpClient}. Call {@link FetchLike.close}
+ * when you want to release pooled connections explicitly.
+ */
+export declare const fetch: FetchLike;
+export default fetch;

package/fetch.js

@@ -0,0 +1,350 @@
+import { toWebBodyReadError, toWebFetchError } from "./_internal/error-mapping.js";
+import { bodyErrorMapperSymbol } from "./_internal/symbols.js";
+import { isBlob, isFormData, isIterable, isMultipartFormDataStream, isReadable, isReadableStream, isURLSearchParameters } from "./_internal/guards.js";
+import { fromRequestBody } from "./body.js";
+import { ProxyDialer } from "./dialers/proxy.js";
+import { AutoDialer } from "./dialers/tcp.js";
+import { HttpClient } from "./http-client.js";
+import { parse, stringify } from "@npy/proxy-kit";
+//#region src/fetch.ts
+var MAX_REDIRECTS = 20;
+var REDIRECT_STATUSES = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+var SENSITIVE_REDIRECT_HEADERS = [
+	"authorization",
+	"cookie",
+	"proxy-authorization"
+];
+var BODY_HEADERS = [
+	"content-encoding",
+	"content-language",
+	"content-length",
+	"content-location",
+	"content-type",
+	"transfer-encoding"
+];
+function createDefaultHttpClient(options = {}) {
+	return new HttpClient({
+		...options,
+		dialer: options.dialer ?? new AutoDialer()
+	});
+}
+/**
+* Normalizes any supported header input into a {@link Headers} instance.
+*
+* @remarks
+* If the input is already a {@link Headers} object, the same instance is returned.
+* Tuple arrays and plain records are copied into a new {@link Headers}.
+*/
+function normalizeHeaders(headers) {
+	if (headers instanceof Headers) return headers;
+	const result = new Headers();
+	if (!headers) return result;
+	if (Array.isArray(headers)) {
+		for (const [key, value] of headers) result.append(key, value);
+		return result;
+	}
+	for (const [key, value] of Object.entries(headers)) if (Array.isArray(value)) for (const entry of value) result.append(key, entry);
+	else if (value !== void 0) result.append(key, value);
+	return result;
+}
+function resolveUrl(input) {
+	if (input instanceof URL) return input;
+	return new URL(input instanceof Request ? input.url : String(input));
+}
+function resolveMethod(input, init) {
+	return (init.method ?? (input instanceof Request ? input.method : void 0))?.toUpperCase().trim() ?? "GET";
+}
+function resolveHeaders(input, init) {
+	return normalizeHeaders(init.headers !== void 0 ? init.headers : input instanceof Request ? input.headers : void 0);
+}
+function resolveSignal(input, init) {
+	return init.signal ?? (input instanceof Request ? input.signal : void 0);
+}
+function resolveBody(input, init) {
+	if (init.body !== void 0) return init.body;
+	return input instanceof Request ? fromRequestBody(input) : void 0;
+}
+function resolveRedirectMode(input, init) {
+	return init.redirect ?? (input instanceof Request ? input.redirect : "follow");
+}
+function getBodyReplaySource(input, init, method, body, redirect) {
+	if (redirect !== "follow" || init.body !== void 0 || body == null || method === "GET" || method === "HEAD" || !(input instanceof Request)) return;
+	return input.clone();
+}
+function assertValidFetchUrl(url) {
+	if (url.username || url.password) throw new TypeError("Request URL must not include embedded credentials");
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new TypeError(`fetch failed: unsupported scheme ${url.protocol}`);
+}
+function assertValidFetchBody(method, body) {
+	if (body == null) return;
+	if (method === "GET" || method === "HEAD") throw new TypeError(`Request with ${method} method cannot have a body`);
+}
+function lookupEnvProxy(...names) {
+	for (const name of names) {
+		const normalized = (process.env[name] ?? process.env[name.toLowerCase()])?.trim();
+		if (normalized) return normalized;
+	}
+}
+function resolveProxyFromEnv(url) {
+	const socksProxy = lookupEnvProxy("SOCKS5_PROXY", "SOCKS_PROXY");
+	if (socksProxy) return socksProxy;
+	if (url.protocol === "https:") return lookupEnvProxy("HTTPS_PROXY", "HTTP_PROXY");
+	return lookupEnvProxy("HTTP_PROXY");
+}
+function normalizeProxyConfig(proxy) {
+	const parsed = typeof proxy === "string" ? parse(proxy, { strict: true }) : proxy;
+	if (parsed == null) throw new TypeError(`Invalid proxy string: ${String(proxy)}`);
+	const key = stringify(parsed, {
+		strict: true,
+		format: "user:pass@ip:port"
+	});
+	if (!key) throw new TypeError("Failed to normalize proxy configuration");
+	return {
+		key,
+		proxy: parsed
+	};
+}
+function resolveNormalizedProxy(url, proxy) {
+	if (proxy === null) return null;
+	if (proxy !== void 0) return normalizeProxyConfig(proxy);
+	const envProxy = resolveProxyFromEnv(url);
+	return envProxy ? normalizeProxyConfig(envProxy) : null;
+}
+function annotateResponse(response, url, redirected) {
+	try {
+		if (redirected) Object.defineProperties(response, {
+			redirected: {
+				configurable: true,
+				enumerable: true,
+				value: true,
+				writable: false
+			},
+			url: {
+				configurable: true,
+				enumerable: true,
+				value: url,
+				writable: false
+			}
+		});
+		else Object.defineProperty(response, "url", {
+			configurable: true,
+			enumerable: true,
+			value: url,
+			writable: false
+		});
+	} catch {}
+	return response;
+}
+async function discardResponse(response) {
+	try {
+		await response.body?.cancel();
+	} catch {}
+}
+function isRedirectResponse(response) {
+	return REDIRECT_STATUSES.has(response.status) && response.headers.get("location") != null;
+}
+function isReplayableBody(body) {
+	if (body == null || typeof body === "string" || body instanceof Uint8Array || isBlob(body) || isFormData(body) || isURLSearchParameters(body)) return true;
+	if (isReadableStream(body) || isReadable(body) || isMultipartFormDataStream(body) || isIterable(body)) return false;
+	return true;
+}
+async function resolveReplayableBody(current) {
+	if (isReplayableBody(current.body)) return current.body;
+	if (current.replayBodyRequest) {
+		const buffer = await current.replayBodyRequest.arrayBuffer();
+		return buffer.byteLength > 0 ? new Uint8Array(buffer) : null;
+	}
+	throw new TypeError("Cannot follow redirect with a non-replayable request body");
+}
+function shouldDropBodyOnRedirect(status, method) {
+	if (status === 303) return method !== "HEAD";
+	return (status === 301 || status === 302) && method === "POST";
+}
+function resolveRedirectMethod(status, method) {
+	if (status === 303 && method !== "HEAD" || (status === 301 || status === 302) && method === "POST") return "GET";
+	return method;
+}
+function createRedirectHeaders(current, nextUrl, dropBody) {
+	const headers = new Headers(current.headers);
+	const isCrossOrigin = current.url.origin !== nextUrl.origin;
+	const isDowngrade = current.url.protocol === "https:" && nextUrl.protocol === "http:";
+	headers.delete("host");
+	if (isCrossOrigin) for (const name of SENSITIVE_REDIRECT_HEADERS) headers.delete(name);
+	if (dropBody) for (const name of BODY_HEADERS) headers.delete(name);
+	if (!headers.has("referer") && !isDowngrade) headers.set("referer", current.url.toString());
+	return headers;
+}
+async function buildRedirectRequest(current, response) {
+	const location = response.headers.get("location");
+	if (!location) return current;
+	const nextUrl = new URL(location, current.url);
+	const nextMethod = resolveRedirectMethod(response.status, current.method);
+	const dropBody = shouldDropBodyOnRedirect(response.status, current.method);
+	const nextHeaders = createRedirectHeaders(current, nextUrl, dropBody);
+	const nextBody = dropBody ? void 0 : await resolveReplayableBody(current);
+	return {
+		...current,
+		url: nextUrl,
+		method: nextMethod,
+		headers: nextHeaders,
+		body: nextBody,
+		replayBodyRequest: void 0
+	};
+}
+async function sendPreparedRequest(prepared, getProxyClient) {
+	assertValidFetchUrl(prepared.url);
+	assertValidFetchBody(prepared.method, prepared.body);
+	const normalizedProxy = resolveNormalizedProxy(prepared.url, prepared.proxy);
+	const client = normalizedProxy ? getProxyClient(prepared.baseClient, normalizedProxy) : prepared.baseClient;
+	try {
+		const sendOptions = Object.defineProperty({
+			url: prepared.url,
+			method: prepared.method,
+			headers: prepared.headers,
+			body: prepared.body ?? null,
+			signal: prepared.signal
+		}, bodyErrorMapperSymbol, {
+			configurable: false,
+			enumerable: false,
+			writable: false,
+			value: (error) => toWebBodyReadError(error, prepared.signal)
+		});
+		return await client.send(sendOptions);
+	} catch (error) {
+		throw toWebFetchError(error, prepared.signal);
+	}
+}
+function prepareRequest(input, init, defaultHttpClient) {
+	const url = resolveUrl(input);
+	const method = resolveMethod(input, init);
+	const headers = resolveHeaders(input, init);
+	const body = resolveBody(input, init);
+	const signal = resolveSignal(input, init);
+	const redirect = resolveRedirectMode(input, init);
+	return {
+		url,
+		method,
+		headers,
+		body,
+		signal,
+		redirect,
+		baseClient: init.client ?? defaultHttpClient,
+		proxy: init.proxy,
+		replayBodyRequest: getBodyReplaySource(input, init, method, body, redirect)
+	};
+}
+/**
+* Creates a fetch-compatible client backed by {@link HttpClient}.
+*
+* @remarks
+* The returned function follows the standard fetch shape, but uses this library's
+* connection pooling, proxy support and body/error mapping rules.
+*
+* When no client is provided, an internal {@link HttpClient} is created and owned
+* by the returned fetch-like function. Calling {@link FetchLike.close} closes that
+* internal client and any proxy-specific clients created on demand.
+*
+* @example
+* ```ts
+* const fetchLike = createFetch();
+* const response = await fetchLike("https://httpbin.org/anything");
+* const data = await response.json();
+* await fetchLike.close();
+* ```
+*/
+function createFetch(client) {
+	const defaultHttpClient = client ?? createDefaultHttpClient();
+	const proxyClientsByBase = /* @__PURE__ */ new WeakMap();
+	const ownedProxyClients = /* @__PURE__ */ new Set();
+	let closePromise;
+	const getProxyClient = (baseClient, proxy) => {
+		let clients = proxyClientsByBase.get(baseClient);
+		if (!clients) {
+			clients = /* @__PURE__ */ new Map();
+			proxyClientsByBase.set(baseClient, clients);
+		}
+		const existing = clients.get(proxy.key);
+		if (existing) return existing;
+		const proxyClient = new HttpClient({
+			...baseClient.options,
+			dialer: new ProxyDialer(proxy.proxy)
+		});
+		clients.set(proxy.key, proxyClient);
+		ownedProxyClients.add(proxyClient);
+		return proxyClient;
+	};
+	const fetchLike = (async (input, init = {}) => {
+		let prepared = prepareRequest(input, init, defaultHttpClient);
+		let redirected = false;
+		let redirects = 0;
+		for (;;) {
+			const response = await sendPreparedRequest(prepared, getProxyClient);
+			if (!isRedirectResponse(response) || prepared.redirect === "manual") return annotateResponse(response, prepared.url.toString(), redirected);
+			if (prepared.redirect === "error") {
+				await discardResponse(response);
+				throw new TypeError(`fetch failed: redirect mode is set to "error"`);
+			}
+			if (redirects >= MAX_REDIRECTS) {
+				await discardResponse(response);
+				throw new TypeError(`fetch failed: maximum redirect count exceeded`);
+			}
+			prepared = await buildRedirectRequest(prepared, response);
+			await discardResponse(response);
+			redirected = true;
+			redirects += 1;
+		}
+	});
+	const close = async () => {
+		if (closePromise) return closePromise;
+		const promise = (async () => {
+			const proxyClients = Array.from(ownedProxyClients);
+			ownedProxyClients.clear();
+			const errors = (await Promise.allSettled([...proxyClients.map((c) => c.close()), ...client == null ? [defaultHttpClient.close()] : []])).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more fetch clients");
+		})();
+		closePromise = promise;
+		try {
+			await promise;
+		} finally {
+			if (closePromise === promise) closePromise = void 0;
+		}
+	};
+	Object.defineProperties(fetchLike, {
+		client: {
+			configurable: false,
+			enumerable: false,
+			value: defaultHttpClient,
+			writable: false
+		},
+		close: {
+			configurable: false,
+			enumerable: false,
+			value: close,
+			writable: false
+		},
+		[Symbol.asyncDispose]: {
+			configurable: false,
+			enumerable: false,
+			value: close,
+			writable: false
+		}
+	});
+	return fetchLike;
+}
+/**
+* Default fetch-compatible client created with {@link createFetch}.
+*
+* @remarks
+* This singleton owns its internal {@link HttpClient}. Call {@link FetchLike.close}
+* when you want to release pooled connections explicitly.
+*/
+var fetch = createFetch();
+//#endregion
+export { createFetch, fetch as default, normalizeHeaders };

package/http-client.cjs

@@ -0,0 +1,75 @@
+const require_agent_pool = require("./agent-pool.cjs");
+//#region src/http-client.ts
+/**
+* Advanced HTTP client with per-origin pooling and explicit lifecycle control.
+*
+* @remarks
+* Use this API when you want direct access to the library's richer error model and
+* transport options instead of the fetch-like compatibility layer.
+*
+*
+* @example
+* ```ts
+* const client = new HttpClient();
+* const response = await client.send({
+*   url: "https://httpbin.org/anything",
+*   method: "GET",
+* });
+* await client.close();
+* ```
+*/
+var HttpClient = class {
+	#agentPools = /* @__PURE__ */ new Map();
+	#agentPoolOptions;
+	#closePromise;
+	constructor(options = {}) {
+		this.#agentPoolOptions = { ...options };
+	}
+	get options() {
+		return this.#agentPoolOptions;
+	}
+	async send(options) {
+		return this.#getOrCreateAgentPool(options.url).send(options);
+	}
+	/**
+	* Closes all pooled connections owned by this client.
+	*
+	* @remarks
+	* After closing, future requests may recreate pools as needed.
+	*/
+	async close() {
+		if (this.#closePromise) return this.#closePromise;
+		const promise = (async () => {
+			const entries = Array.from(this.#agentPools.entries());
+			const errors = (await Promise.allSettled(entries.map(async ([origin, agentPool]) => {
+				try {
+					await agentPool.close();
+				} finally {
+					this.#agentPools.delete(origin);
+				}
+			}))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more agent pools");
+		})();
+		this.#closePromise = promise;
+		try {
+			await promise;
+		} finally {
+			if (this.#closePromise === promise) this.#closePromise = void 0;
+		}
+	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	#getOrCreateAgentPool(url) {
+		const origin = typeof url === "string" ? new URL(url).origin : url.origin;
+		let agentPool = this.#agentPools.get(origin);
+		if (!agentPool) {
+			agentPool = require_agent_pool.createAgentPool(origin, this.#agentPoolOptions);
+			this.#agentPools.set(origin, agentPool);
+		}
+		return agentPool;
+	}
+};
+//#endregion
+exports.HttpClient = HttpClient;

package/http-client.d.cts

@@ -0,0 +1,39 @@
+import { Agent, AgentPool } from './types/agent';
+/**
+ * Advanced HTTP client with per-origin pooling and explicit lifecycle control.
+ *
+ * @remarks
+ * Use this API when you want direct access to the library's richer error model and
+ * transport options instead of the fetch-like compatibility layer.
+ *
+ *
+ * @example
+ * ```ts
+ * const client = new HttpClient();
+ * const response = await client.send({
+ *   url: "https://httpbin.org/anything",
+ *   method: "GET",
+ * });
+ * await client.close();
+ * ```
+ */
+export declare class HttpClient implements AsyncDisposable {
+    #private;
+    constructor(options?: HttpClient.Options);
+    get options(): Readonly<HttpClient.Options>;
+    send(options: Agent.SendOptions): Promise<Response>;
+    /**
+     * Closes all pooled connections owned by this client.
+     *
+     * @remarks
+     * After closing, future requests may recreate pools as needed.
+     */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare namespace HttpClient {
+    interface Options extends AgentPool.Options {
+    }
+}
+export interface HttpClientOptions extends HttpClient.Options {
+}

package/http-client.d.ts

@@ -0,0 +1,39 @@
+import { Agent, AgentPool } from './types/agent';
+/**
+ * Advanced HTTP client with per-origin pooling and explicit lifecycle control.
+ *
+ * @remarks
+ * Use this API when you want direct access to the library's richer error model and
+ * transport options instead of the fetch-like compatibility layer.
+ *
+ *
+ * @example
+ * ```ts
+ * const client = new HttpClient();
+ * const response = await client.send({
+ *   url: "https://httpbin.org/anything",
+ *   method: "GET",
+ * });
+ * await client.close();
+ * ```
+ */
+export declare class HttpClient implements AsyncDisposable {
+    #private;
+    constructor(options?: HttpClient.Options);
+    get options(): Readonly<HttpClient.Options>;
+    send(options: Agent.SendOptions): Promise<Response>;
+    /**
+     * Closes all pooled connections owned by this client.
+     *
+     * @remarks
+     * After closing, future requests may recreate pools as needed.
+     */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare namespace HttpClient {
+    interface Options extends AgentPool.Options {
+    }
+}
+export interface HttpClientOptions extends HttpClient.Options {
+}

package/http-client.js

@@ -0,0 +1,75 @@
+import { createAgentPool } from "./agent-pool.js";
+//#region src/http-client.ts
+/**
+* Advanced HTTP client with per-origin pooling and explicit lifecycle control.
+*
+* @remarks
+* Use this API when you want direct access to the library's richer error model and
+* transport options instead of the fetch-like compatibility layer.
+*
+*
+* @example
+* ```ts
+* const client = new HttpClient();
+* const response = await client.send({
+*   url: "https://httpbin.org/anything",
+*   method: "GET",
+* });
+* await client.close();
+* ```
+*/
+var HttpClient = class {
+	#agentPools = /* @__PURE__ */ new Map();
+	#agentPoolOptions;
+	#closePromise;
+	constructor(options = {}) {
+		this.#agentPoolOptions = { ...options };
+	}
+	get options() {
+		return this.#agentPoolOptions;
+	}
+	async send(options) {
+		return this.#getOrCreateAgentPool(options.url).send(options);
+	}
+	/**
+	* Closes all pooled connections owned by this client.
+	*
+	* @remarks
+	* After closing, future requests may recreate pools as needed.
+	*/
+	async close() {
+		if (this.#closePromise) return this.#closePromise;
+		const promise = (async () => {
+			const entries = Array.from(this.#agentPools.entries());
+			const errors = (await Promise.allSettled(entries.map(async ([origin, agentPool]) => {
+				try {
+					await agentPool.close();
+				} finally {
+					this.#agentPools.delete(origin);
+				}
+			}))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more agent pools");
+		})();
+		this.#closePromise = promise;
+		try {
+			await promise;
+		} finally {
+			if (this.#closePromise === promise) this.#closePromise = void 0;
+		}
+	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	#getOrCreateAgentPool(url) {
+		const origin = typeof url === "string" ? new URL(url).origin : url.origin;
+		let agentPool = this.#agentPools.get(origin);
+		if (!agentPool) {
+			agentPool = createAgentPool(origin, this.#agentPoolOptions);
+			this.#agentPools.set(origin, agentPool);
+		}
+		return agentPool;
+	}
+};
+//#endregion
+export { HttpClient };

package/index.cjs

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_net = require("./_internal/net.cjs");
+const require_errors = require("./errors.cjs");
+const require_encoding = require("./encoding.cjs");
+const require_body = require("./body.cjs");
+const require_agent = require("./agent.cjs");
+const require_proxy = require("./dialers/proxy.cjs");
+const require_tcp = require("./dialers/tcp.cjs");
+const require_agent_pool = require("./agent-pool.cjs");
+const require_http_client = require("./http-client.cjs");
+const require_fetch = require("./fetch.cjs");
+exports.AgentBusyError = require_errors.AgentBusyError;
+exports.AgentClosedError = require_errors.AgentClosedError;
+exports.AutoDialer = require_tcp.AutoDialer;
+exports.ConnectTimeoutError = require_errors.ConnectTimeoutError;
+exports.ConnectionError = require_errors.ConnectionError;
+exports.ErrorType = require_errors.ErrorType;
+exports.FetchError = require_errors.FetchError;
+exports.FetchErrorCode = require_errors.FetchErrorCode;
+exports.HttpClient = require_http_client.HttpClient;
+exports.HttpStatusError = require_errors.HttpStatusError;
+exports.OriginMismatchError = require_errors.OriginMismatchError;
+exports.ProxyDialer = require_proxy.ProxyDialer;
+exports.RequestAbortedError = require_errors.RequestAbortedError;
+exports.RequestWriteError = require_errors.RequestWriteError;
+exports.ResponseBodyError = require_errors.ResponseBodyError;
+exports.ResponseDecodeError = require_errors.ResponseDecodeError;
+exports.ResponseHeaderError = require_errors.ResponseHeaderError;
+exports.TcpDialer = require_tcp.TcpDialer;
+exports.TlsDialer = require_tcp.TlsDialer;
+exports.UnsupportedAlpnProtocolError = require_errors.UnsupportedAlpnProtocolError;
+exports.UnsupportedMethodError = require_errors.UnsupportedMethodError;
+exports.UnsupportedProtocolError = require_errors.UnsupportedProtocolError;
+exports.connectTcp = require_net.connectTcp;
+exports.connectTls = require_net.connectTls;
+exports.createAgent = require_agent.createAgent;
+exports.createAgentPool = require_agent_pool.createAgentPool;
+exports.createDecoders = require_encoding.createDecoders;
+exports.createEncoders = require_encoding.createEncoders;
+exports.createFetch = require_fetch.createFetch;
+exports.decodeStream = require_encoding.decodeStream;
+exports.encodeStream = require_encoding.encodeStream;
+exports.extractBody = require_body.extractBody;
+exports.fetch = require_fetch;
+exports.fromRequestBody = require_body.fromRequestBody;
+exports.getFormDataLength = require_body.getFormDataLength;
+exports.normalizeHeaders = require_fetch.normalizeHeaders;
+exports.resolveHostPort = require_tcp.resolveHostPort;
+exports.upgradeTls = require_net.upgradeTls;