@npy/fetch 0.1.1 → 0.1.2

package/fetch.js

@@ -1,53 +1,81 @@
+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 { toWebBodyReadError, toWebFetchError, wrapResponseBodyErrors } from "./_internal/error-adapters.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 normalized = new Headers();
+	const result = new Headers();
+	if (!headers) return result;
 	if (Array.isArray(headers)) {
-		headers.forEach(([key, value]) => {
-			normalized.append(key, value);
-		});
-		return normalized;
+		for (const [key, value] of headers) result.append(key, value);
+		return result;
 	}
-	if (headers) Object.entries(headers).forEach(([key, value]) => {
-		if (Array.isArray(value)) value.forEach((entry) => {
-			normalized.append(key, entry);
-		});
-		else if (value !== void 0) normalized.append(key, value);
-	});
-	return normalized;
+	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;
-	if (input instanceof Request) return new URL(input.url);
-	return new URL(String(input));
+	return new URL(input instanceof Request ? input.url : String(input));
 }
 function resolveMethod(input, init) {
-	if (init.method != null) return init.method.toUpperCase();
-	if (input instanceof Request) return input.method.toUpperCase();
-	return "GET";
+	return (init.method ?? (input instanceof Request ? input.method : void 0))?.toUpperCase().trim() ?? "GET";
 }
 function resolveHeaders(input, init) {
-	if (init.headers !== void 0) return normalizeHeaders(init.headers);
-	if (input instanceof Request) return normalizeHeaders(input.headers);
-	return new Headers();
+	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;
-	if (!(input instanceof Request)) return;
-	if (input.bodyUsed) throw new TypeError("Request body has already been used");
-	return input.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");
@@ -57,36 +85,236 @@ function assertValidFetchBody(method, body) {
 	if (body == null) return;
 	if (method === "GET" || method === "HEAD") throw new TypeError(`Request with ${method} method cannot have a body`);
 }
-async function fetchImpl(input, init) {
+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);
-	assertValidFetchUrl(url);
 	const method = resolveMethod(input, init);
 	const headers = resolveHeaders(input, init);
 	const body = resolveBody(input, init);
 	const signal = resolveSignal(input, init);
-	assertValidFetchBody(method, body);
-	try {
-		return wrapResponseBodyErrors(await init.client.send({
-			url,
-			method,
-			headers,
-			body: body ?? null,
-			signal
-		}), (error) => toWebBodyReadError(error, signal));
-	} catch (error) {
-		throw toWebFetchError(error, signal);
-	}
+	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 = {}) => {
-		return fetchImpl(input, init.client == null ? {
-			...init,
-			client: defaultHttpClient
-		} : 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 (client == null) await defaultHttpClient.close();
+		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: {
@@ -110,6 +338,13 @@ function createFetch(client) {
 	});
 	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

@@ -1,20 +1,62 @@
 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() {
-		const entries = Array.from(this.#agentPools.entries());
-		const failed = (await Promise.allSettled(entries.map(([origin, agentPool]) => agentPool.close().then(() => {
-			this.#agentPools.delete(origin);
-		})))).find((r) => r.status === "rejected");
-		if (failed) throw failed.reason;
+		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();

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

@@ -1,20 +1,62 @@
 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() {
-		const entries = Array.from(this.#agentPools.entries());
-		const failed = (await Promise.allSettled(entries.map(([origin, agentPool]) => agentPool.close().then(() => {
-			this.#agentPools.delete(origin);
-		})))).find((r) => r.status === "rejected");
-		if (failed) throw failed.reason;
+		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();

package/index.cjs

@@ -1,16 +1,17 @@
 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_encoding = require("./encoding.cjs");
-const require_errors = require("./errors.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.Body = require_body.Body;
 exports.ConnectTimeoutError = require_errors.ConnectTimeoutError;
 exports.ConnectionError = require_errors.ConnectionError;
 exports.ErrorType = require_errors.ErrorType;
@@ -32,6 +33,8 @@ 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;
@@ -39,6 +42,7 @@ 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;

package/index.d.cts

@@ -1 +1,14 @@
-export * from "./src/index.js"
+export type { FormDataPolyfill } from './_internal/guards';
+export type { WithSignal } from './_internal/net';
+export { connectTcp, connectTls, upgradeTls } from './_internal/net';
+export * from './agent';
+export * from './agent-pool';
+export * from './body';
+export * from './dialers';
+export * from './encoding';
+export * from './errors';
+export * from './fetch';
+export * from './http-client';
+export type { LineReader, Readers } from './io/readers';
+export type { Writers } from './io/writers';
+export * from './types';

package/index.d.ts

@@ -1 +1,14 @@
-export * from "./src/index.js"
+export type { FormDataPolyfill } from './_internal/guards';
+export type { WithSignal } from './_internal/net';
+export { connectTcp, connectTls, upgradeTls } from './_internal/net';
+export * from './agent';
+export * from './agent-pool';
+export * from './body';
+export * from './dialers';
+export * from './encoding';
+export * from './errors';
+export * from './fetch';
+export * from './http-client';
+export type { LineReader, Readers } from './io/readers';
+export type { Writers } from './io/writers';
+export * from './types';

package/index.js

@@ -1,9 +1,11 @@
 import { connectTcp, connectTls, upgradeTls } from "./_internal/net.js";
-import { Body, extractBody, getFormDataLength } from "./body.js";
+import { AgentBusyError, AgentClosedError, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpStatusError, OriginMismatchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError } from "./errors.js";
+import { createDecoders, createEncoders, decodeStream, encodeStream } from "./encoding.js";
+import { extractBody, fromRequestBody, getFormDataLength } from "./body.js";
+import { createAgent } from "./agent.js";
 import { ProxyDialer } from "./dialers/proxy.js";
 import { AutoDialer, TcpDialer, TlsDialer, resolveHostPort } from "./dialers/tcp.js";
-import { createDecoders, createEncoders, decodeStream, encodeStream } from "./encoding.js";
-import { AgentBusyError, AgentClosedError, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpStatusError, OriginMismatchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError } from "./errors.js";
+import { createAgentPool } from "./agent-pool.js";
 import { HttpClient } from "./http-client.js";
 import fetch, { createFetch, normalizeHeaders } from "./fetch.js";
-export { AgentBusyError, AgentClosedError, AutoDialer, Body, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpClient, HttpStatusError, OriginMismatchError, ProxyDialer, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, TcpDialer, TlsDialer, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError, connectTcp, connectTls, createDecoders, createEncoders, createFetch, decodeStream, encodeStream, extractBody, fetch, getFormDataLength, normalizeHeaders, resolveHostPort, upgradeTls };
+export { AgentBusyError, AgentClosedError, AutoDialer, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpClient, HttpStatusError, OriginMismatchError, ProxyDialer, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, TcpDialer, TlsDialer, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError, connectTcp, connectTls, createAgent, createAgentPool, createDecoders, createEncoders, createFetch, decodeStream, encodeStream, extractBody, fetch, fromRequestBody, getFormDataLength, normalizeHeaders, resolveHostPort, upgradeTls };