@npy/fetch 0.1.0 → 0.1.1

package/io/writers.js

@@ -0,0 +1,190 @@
+import { isReadableStream } from "../_internal/guards.js";
+import { extractBody } from "../body.js";
+import { createEncoders, encodeStream } from "../encoding.js";
+import { bytesToStream } from "../_internal/streams.js";
+import { parseContentLength, parseTransferEncoding } from "./_utils.js";
+import { sanitizeHeaderValue } from "./readers.js";
+import { BufWriter } from "./buf-writer.js";
+import { nodeReadableToWeb } from "@fuman/node";
+import { Bytes, write } from "@fuman/io";
+//#region src/io/writers.ts
+function toRequestTarget(url) {
+	return (url.pathname?.startsWith("/") ? url.pathname : "/") + (url.search || "");
+}
+function encodeHead(into, head) {
+	write.rawString(into, `${head.method.toUpperCase()} ${head.target} HTTP/1.1\r
+`);
+	for (const [k, v] of head.headers) write.rawString(into, `${k}: ${sanitizeHeaderValue(v)}\r
+`);
+	write.rawString(into, "\r\n");
+}
+function prepareBody(headers, init) {
+	const state = extractBody(init);
+	if (state.body != null && !headers.has("content-type")) headers.set("content-type", state.contentType ?? "application/octet-stream");
+	const body = state.body;
+	if (body == null) return { kind: "none" };
+	if (body instanceof Uint8Array) return {
+		kind: "bytes",
+		bytes: body,
+		length: body.byteLength
+	};
+	if (isReadableStream(body)) return {
+		kind: "stream",
+		stream: body,
+		length: state.contentLength
+	};
+	return {
+		kind: "stream",
+		stream: nodeReadableToWeb(body),
+		length: state.contentLength
+	};
+}
+function finalizeDelimitation(headers, body) {
+	if (body.kind === "none") return { chunked: false };
+	const te = parseTransferEncoding(headers);
+	if (te.has) {
+		headers.delete("content-length");
+		if (!te.chunked) {
+			const tokens = [...te.codings, "chunked"].filter(Boolean);
+			headers.set("transfer-encoding", tokens.join(", "));
+		}
+		return { chunked: true };
+	}
+	const knownLength = body.kind === "bytes" ? body.length : body.length ?? null;
+	if (knownLength != null) {
+		const existing = parseContentLength(headers);
+		if (existing != null && existing !== knownLength) throw new Error(`Conflicting content-length: header=${existing} body=${knownLength}`);
+		if (existing == null) headers.set("content-length", String(knownLength));
+		return { chunked: false };
+	}
+	if (parseContentLength(headers) != null) return { chunked: false };
+	headers.set("transfer-encoding", "chunked");
+	headers.delete("content-length");
+	return { chunked: true };
+}
+function createBufferedConnWriter(dst, opts) {
+	const bufferSize = opts.highWaterMark ?? 16 * 1024;
+	const directWriteThreshold = opts.directWriteThreshold ?? 64 * 1024;
+	const bufWriter = new BufWriter(dst, bufferSize);
+	const flush = async () => {
+		await bufWriter.flush();
+	};
+	const writeBytes = async (bytes) => {
+		if (bytes.length === 0) return;
+		if (bytes.length >= directWriteThreshold) {
+			await bufWriter.flush();
+			await dst.write(bytes);
+			return;
+		}
+		await bufWriter.write(bytes);
+	};
+	const writeRawString = async (str) => {
+		if (str.length === 0) return;
+		write.rawString(bufWriter, str);
+	};
+	return {
+		flush,
+		writeBytes,
+		writeRawString,
+		directWriteThreshold
+	};
+}
+async function writeBody(dst, body, chunked, opts, signal) {
+	const bw = createBufferedConnWriter(dst, opts);
+	const writeChunk = async (chunk) => {
+		if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
+		if (!chunked) {
+			await bw.writeBytes(chunk);
+			return;
+		}
+		if (chunk.length === 0) return;
+		await bw.writeRawString(chunk.length.toString(16));
+		await bw.writeRawString("\r\n");
+		await bw.writeBytes(chunk);
+		await bw.writeRawString("\r\n");
+	};
+	if (body.kind === "bytes") await writeChunk(body.bytes);
+	else for await (const chunk of body.stream) await writeChunk(chunk);
+	if (chunked) await bw.writeRawString(`0\r
+\r
+`);
+	await bw.flush();
+}
+async function writeCoalesced(dst, scratch, head, bodyBytes, chunked) {
+	scratch.reset();
+	encodeHead(scratch, head);
+	if (!chunked) {
+		write.bytes(scratch, bodyBytes);
+		await dst.write(scratch.result());
+		scratch.reset();
+		return;
+	}
+	write.rawString(scratch, bodyBytes.length.toString(16));
+	write.rawString(scratch, "\r\n");
+	write.bytes(scratch, bodyBytes);
+	write.rawString(scratch, `\r
+0\r
+\r
+`);
+	await dst.write(scratch.result());
+	scratch.reset();
+}
+function createRequestWriter(dst, opts = {}) {
+	const scratch = Bytes.alloc(opts.highWaterMark ?? 16 * 1024);
+	const write = async (req) => {
+		if (req.signal?.aborted) throw req.signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
+		const method = req.method.toUpperCase();
+		const headers = req.headers ? new Headers(req.headers) : new Headers();
+		const url = req.url;
+		if (!headers.has("host")) headers.set("host", url.host);
+		if (!headers.has("date")) headers.set("date", (/* @__PURE__ */ new Date()).toUTCString());
+		const target = toRequestTarget(url);
+		let body = prepareBody(headers, req.body ?? null);
+		const ceRaw = headers.get("content-encoding") ?? void 0;
+		const ceEncoders = createEncoders(ceRaw);
+		if (body.kind !== "none" && ceEncoders.length > 0) {
+			body = {
+				kind: "stream",
+				stream: encodeStream(body.kind === "stream" ? body.stream : bytesToStream(body.bytes), ceRaw),
+				length: null
+			};
+			headers.delete("content-length");
+		}
+		const teInfo = parseTransferEncoding(headers);
+		if (body.kind !== "none" && teInfo.has && teInfo.codings.length > 0) {
+			body = {
+				kind: "stream",
+				stream: encodeStream(body.kind === "stream" ? body.stream : bytesToStream(body.bytes), teInfo.codings),
+				length: null
+			};
+			headers.delete("content-length");
+		}
+		const { chunked } = finalizeDelimitation(headers, body);
+		const head = {
+			method,
+			target,
+			headers
+		};
+		if (body.kind === "bytes") {
+			const max = opts.coalesceBodyMaxBytes ?? 64 * 1024;
+			if (body.bytes.length <= max) {
+				await writeCoalesced(dst, scratch, head, body.bytes, chunked);
+				return;
+			}
+		}
+		scratch.reset();
+		encodeHead(scratch, head);
+		await dst.write(scratch.result());
+		scratch.reset();
+		if (body.kind === "none") return;
+		if (body.kind === "bytes" && !chunked) {
+			if (req.signal?.aborted) throw req.signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
+			await dst.write(body.bytes);
+			return;
+		}
+		await writeBody(dst, body, chunked, opts, req.signal);
+	};
+	return { write };
+}
+//#endregion
+export { createRequestWriter };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@npy/fetch",
     "type": "module",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "license": "MIT",
     "scripts": {},
     "dependencies": {
@@ -9,10 +9,9 @@
         "@fuman/net": "^0.0.19",
         "@fuman/node": "^0.0.19",
         "@fuman/utils": "^0.0.19",
-        "@npy/proxy-kit": "0.1.0",
+        "@npy/proxy-kit": "0.1.1",
         "bytes": "^3.1.2",
-        "generic-pool": "^3.9.0",
-        "mitata": "^1.0.34"
+        "generic-pool": "^3.9.0"
     },
     "exports": {
         ".": {
@@ -27,13 +26,11 @@
         }
     },
     "sideEffects": false,
-    "files": [
-        "dist",
-        "LICENSE",
-        "README.md"
-    ],
     "repository": {
         "type": "git",
         "url": "git+https://github.com/neeopy/npy.git"
-    }
+    },
+    "files": [
+        "**/*"
+    ]
 }

package/src/_internal/consts.d.cts

@@ -0,0 +1,3 @@
+export declare const CRLF_BYTES: Uint8Array<ArrayBuffer>;
+export declare const CRLF_STR = "\r\n";
+export declare const CRLF_LENGTH = 2;

package/src/_internal/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const CRLF_BYTES: Uint8Array<ArrayBuffer>;
+export declare const CRLF_STR = "\r\n";
+export declare const CRLF_LENGTH = 2;

package/src/_internal/error-adapters.d.cts

@@ -0,0 +1,22 @@
+import { FetchError, FetchErrorContext } from '../errors';
+export interface ErrorMappingContext extends FetchErrorContext {
+}
+export declare function unknownToError(error: unknown): Error;
+export declare function isAbortLike(error: unknown): boolean;
+export declare function defaultAbortDomException(): DOMException;
+export declare function getRawAbortReason(signal?: AbortSignal): unknown;
+export declare function toAbortCause(signal?: AbortSignal, fallback?: unknown): Error;
+export declare function isTimeoutReason(reason: unknown): boolean;
+export declare function mapAdvancedConnectError(error: unknown, { signal, context, timedOut, }: {
+    signal?: AbortSignal;
+    context?: ErrorMappingContext;
+    timedOut?: boolean;
+}): FetchError;
+export declare function mapAdvancedSendError(error: unknown, { signal, context, phase, }: {
+    signal?: AbortSignal;
+    context?: ErrorMappingContext;
+    phase: "request" | "response" | "body";
+}): FetchError;
+export declare function wrapResponseBodyErrors(response: Response, mapError: (error: unknown) => unknown): Response;
+export declare function toWebFetchError(error: unknown, signal?: AbortSignal): unknown;
+export declare function toWebBodyReadError(error: unknown, signal?: AbortSignal): unknown;

package/src/_internal/error-adapters.d.ts

@@ -0,0 +1,22 @@
+import { FetchError, FetchErrorContext } from '../errors';
+export interface ErrorMappingContext extends FetchErrorContext {
+}
+export declare function unknownToError(error: unknown): Error;
+export declare function isAbortLike(error: unknown): boolean;
+export declare function defaultAbortDomException(): DOMException;
+export declare function getRawAbortReason(signal?: AbortSignal): unknown;
+export declare function toAbortCause(signal?: AbortSignal, fallback?: unknown): Error;
+export declare function isTimeoutReason(reason: unknown): boolean;
+export declare function mapAdvancedConnectError(error: unknown, { signal, context, timedOut, }: {
+    signal?: AbortSignal;
+    context?: ErrorMappingContext;
+    timedOut?: boolean;
+}): FetchError;
+export declare function mapAdvancedSendError(error: unknown, { signal, context, phase, }: {
+    signal?: AbortSignal;
+    context?: ErrorMappingContext;
+    phase: "request" | "response" | "body";
+}): FetchError;
+export declare function wrapResponseBodyErrors(response: Response, mapError: (error: unknown) => unknown): Response;
+export declare function toWebFetchError(error: unknown, signal?: AbortSignal): unknown;
+export declare function toWebBodyReadError(error: unknown, signal?: AbortSignal): unknown;

package/src/_internal/guards.d.cts

@@ -0,0 +1,13 @@
+import { Readable } from 'node:stream';
+export interface FormDataPolyfill extends Readable {
+    getBoundary(): string;
+    getLengthSync(): number;
+    hasKnownLength(): boolean;
+}
+export declare const isReadable: (object: any) => object is Readable;
+export declare const isIterable: (object: any) => object is AsyncIterable<any> | Iterable<any>;
+export declare const isMultipartFormDataStream: (object: any) => object is FormDataPolyfill;
+export declare const isFormData: (object: any) => object is FormData;
+export declare const isURLSearchParameters: (object: any) => object is URLSearchParams;
+export declare const isReadableStream: (object: any) => object is ReadableStream;
+export declare const isBlob: (object: any) => object is Blob;

package/src/_internal/guards.d.ts

@@ -0,0 +1,13 @@
+import { Readable } from 'node:stream';
+export interface FormDataPolyfill extends Readable {
+    getBoundary(): string;
+    getLengthSync(): number;
+    hasKnownLength(): boolean;
+}
+export declare const isReadable: (object: any) => object is Readable;
+export declare const isIterable: (object: any) => object is AsyncIterable<any> | Iterable<any>;
+export declare const isMultipartFormDataStream: (object: any) => object is FormDataPolyfill;
+export declare const isFormData: (object: any) => object is FormData;
+export declare const isURLSearchParameters: (object: any) => object is URLSearchParams;
+export declare const isReadableStream: (object: any) => object is ReadableStream;
+export declare const isBlob: (object: any) => object is Blob;

package/src/_internal/net.d.cts

@@ -0,0 +1,12 @@
+import { ConnectFunction, TcpEndpoint, TlsUpgradeFunction } from '@fuman/net';
+import { NodeTlsConnectOptions, NodeTlsUpgradeOptions, TcpConnection, TlsConnection } from '@fuman/node';
+type WithSignal<T = {}> = T & {
+    signal?: AbortSignal;
+};
+export interface AbortError extends Error {
+    name: "AbortError";
+}
+export declare const connectTcp: ConnectFunction<WithSignal<TcpEndpoint>, TcpConnection>;
+export declare const connectTls: ConnectFunction<WithSignal<NodeTlsConnectOptions>, TlsConnection>;
+export declare const upgradeTls: TlsUpgradeFunction<WithSignal<NodeTlsUpgradeOptions>, TcpConnection, TlsConnection>;
+export {};

package/src/_internal/net.d.ts

@@ -0,0 +1,12 @@
+import { ConnectFunction, TcpEndpoint, TlsUpgradeFunction } from '@fuman/net';
+import { NodeTlsConnectOptions, NodeTlsUpgradeOptions, TcpConnection, TlsConnection } from '@fuman/node';
+type WithSignal<T = {}> = T & {
+    signal?: AbortSignal;
+};
+export interface AbortError extends Error {
+    name: "AbortError";
+}
+export declare const connectTcp: ConnectFunction<WithSignal<TcpEndpoint>, TcpConnection>;
+export declare const connectTls: ConnectFunction<WithSignal<NodeTlsConnectOptions>, TlsConnection>;
+export declare const upgradeTls: TlsUpgradeFunction<WithSignal<NodeTlsUpgradeOptions>, TcpConnection, TlsConnection>;
+export {};

package/src/_internal/promises.d.cts

@@ -0,0 +1 @@
+export declare function raceSignal<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;

package/src/_internal/promises.d.ts

@@ -0,0 +1 @@
+export declare function raceSignal<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;

package/src/_internal/streams.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Create a ReadableStream from a Uint8Array.
+ *
+ * The stream will emit the entire byte array as a single chunk,
+ * then close immediately.
+ *
+ * @param bytes - The byte array to wrap.
+ * @returns A ReadableStream that emits the bytes.
+ */
+export declare function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array<ArrayBufferLike>>;
+/**
+ * A TransformStream that limits the total number of bytes passed through.
+ *
+ * It accumulates the byte count from incoming chunks and enqueues them
+ * if the total remains within the limit; otherwise, it errors.
+ *
+ * @param maxBytes - The maximum allowed bytes before erroring.
+ */
+export declare class MaxBytesTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+    constructor(maxBytes: number);
+}

package/src/_internal/streams.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Create a ReadableStream from a Uint8Array.
+ *
+ * The stream will emit the entire byte array as a single chunk,
+ * then close immediately.
+ *
+ * @param bytes - The byte array to wrap.
+ * @returns A ReadableStream that emits the bytes.
+ */
+export declare function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array<ArrayBufferLike>>;
+/**
+ * A TransformStream that limits the total number of bytes passed through.
+ *
+ * It accumulates the byte count from incoming chunks and enqueues them
+ * if the total remains within the limit; otherwise, it errors.
+ *
+ * @param maxBytes - The maximum allowed bytes before erroring.
+ */
+export declare class MaxBytesTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+    constructor(maxBytes: number);
+}

package/src/agent-pool.d.cts

@@ -0,0 +1,2 @@
+import { AgentPool, AgentPoolOptions } from './types/agent';
+export declare function createAgentPool(baseUrl: string, options?: AgentPoolOptions): AgentPool;

package/src/agent-pool.d.ts

@@ -0,0 +1,2 @@
+import { AgentPool, AgentPoolOptions } from './types/agent';
+export declare function createAgentPool(baseUrl: string, options?: AgentPoolOptions): AgentPool;

package/src/agent.d.cts

@@ -0,0 +1,3 @@
+import { Agent } from './types/agent';
+import { Dialer } from './types/dialer';
+export declare function createAgent(dialer: Dialer, baseUrl: string, options?: Agent.Options): Agent;

package/src/agent.d.ts

@@ -0,0 +1,3 @@
+import { Agent } from './types/agent';
+import { Dialer } from './types/dialer';
+export declare function createAgent(dialer: Dialer, baseUrl: string, options?: Agent.Options): Agent;

package/src/body.d.cts

@@ -0,0 +1,23 @@
+import { Readable } from 'node:stream';
+import { FormDataPolyfill } from './_internal/guards';
+export type BodyInit = Exclude<RequestInit["body"], undefined | null> | FormDataPolyfill | Readable;
+export interface BodyState {
+    contentLength: number | null;
+    contentType: string | null;
+    body: Readable | ReadableStream | Uint8Array | null;
+}
+export declare const getFormDataLength: (form: FormData, boundary: string) => number;
+export declare const extractBody: (object: BodyInit | null) => BodyState;
+declare const kBodyInternals: unique symbol;
+export declare class Body {
+    private [kBodyInternals];
+    constructor(init: BodyInit | null);
+    get body(): Uint8Array<ArrayBufferLike> | Readable | ReadableStream<any> | null;
+    get bodyUsed(): boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<FormData>;
+    blob(): Promise<Blob>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+export {};

package/src/body.d.ts

@@ -0,0 +1,23 @@
+import { Readable } from 'node:stream';
+import { FormDataPolyfill } from './_internal/guards';
+export type BodyInit = Exclude<RequestInit["body"], undefined | null> | FormDataPolyfill | Readable;
+export interface BodyState {
+    contentLength: number | null;
+    contentType: string | null;
+    body: Readable | ReadableStream | Uint8Array | null;
+}
+export declare const getFormDataLength: (form: FormData, boundary: string) => number;
+export declare const extractBody: (object: BodyInit | null) => BodyState;
+declare const kBodyInternals: unique symbol;
+export declare class Body {
+    private [kBodyInternals];
+    constructor(init: BodyInit | null);
+    get body(): Uint8Array<ArrayBufferLike> | Readable | ReadableStream<any> | null;
+    get bodyUsed(): boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<FormData>;
+    blob(): Promise<Blob>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+export {};

package/src/dialers/index.d.cts

@@ -0,0 +1,3 @@
+export type { ConnectionLike, Dialer, DialTarget } from '../types/dialer';
+export * from './proxy';
+export * from './tcp';

package/src/dialers/index.d.ts

@@ -0,0 +1,3 @@
+export type { ConnectionLike, Dialer, DialTarget } from '../types/dialer';
+export * from './proxy';
+export * from './tcp';

package/src/dialers/proxy.d.cts

@@ -0,0 +1,19 @@
+import { NodeTlsUpgradeOptions } from '@fuman/node';
+import { createProxyConnection, ProxyInfo } from '@npy/proxy-kit';
+import { Dialer } from '../types/dialer';
+export declare class ProxyDialer implements Dialer {
+    #private;
+    readonly proxy: ProxyDialer.Proxy;
+    constructor(proxy: ProxyDialer.Input, options?: ProxyDialer.Options);
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace ProxyDialer {
+    type Proxy = Parameters<typeof createProxyConnection>[0]["proxy"];
+    type Input = string | Proxy | ProxyInfo;
+    interface Options {
+        caCerts?: string[];
+        sni?: string;
+        alpnProtocols?: string[];
+        extraOptions?: NodeTlsUpgradeOptions["extraOptions"];
+    }
+}

package/src/dialers/proxy.d.ts

@@ -0,0 +1,19 @@
+import { NodeTlsUpgradeOptions } from '@fuman/node';
+import { createProxyConnection, ProxyInfo } from '@npy/proxy-kit';
+import { Dialer } from '../types/dialer';
+export declare class ProxyDialer implements Dialer {
+    #private;
+    readonly proxy: ProxyDialer.Proxy;
+    constructor(proxy: ProxyDialer.Input, options?: ProxyDialer.Options);
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace ProxyDialer {
+    type Proxy = Parameters<typeof createProxyConnection>[0]["proxy"];
+    type Input = string | Proxy | ProxyInfo;
+    interface Options {
+        caCerts?: string[];
+        sni?: string;
+        alpnProtocols?: string[];
+        extraOptions?: NodeTlsUpgradeOptions["extraOptions"];
+    }
+}

package/src/dialers/tcp.d.cts

@@ -0,0 +1,36 @@
+import { NodeTlsConnectOptions } from '@fuman/node';
+import { Dialer } from '../types/dialer';
+type HostPort = {
+    address: string;
+    port: number;
+};
+export declare function resolveHostPort(target: URL | Dialer.Target, defaultPort: number): HostPort;
+export declare class TcpDialer implements Dialer {
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare class TlsDialer implements Dialer {
+    #private;
+    constructor(options?: TlsDialer.Options);
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace TlsDialer {
+    interface Options {
+        caCerts?: string[];
+        sni?: string;
+        alpnProtocols?: string[];
+        extraOptions?: NodeTlsConnectOptions["extraOptions"];
+    }
+}
+export declare class AutoDialer implements Dialer {
+    readonly tcpDialer: TcpDialer;
+    readonly tlsDialer: TlsDialer;
+    constructor(options?: AutoDialer.Options);
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace AutoDialer {
+    interface Options {
+        tcp?: TcpDialer;
+        tls?: TlsDialer;
+    }
+}
+export {};

package/src/dialers/tcp.d.ts

@@ -0,0 +1,36 @@
+import { NodeTlsConnectOptions } from '@fuman/node';
+import { Dialer } from '../types/dialer';
+type HostPort = {
+    address: string;
+    port: number;
+};
+export declare function resolveHostPort(target: URL | Dialer.Target, defaultPort: number): HostPort;
+export declare class TcpDialer implements Dialer {
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare class TlsDialer implements Dialer {
+    #private;
+    constructor(options?: TlsDialer.Options);
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace TlsDialer {
+    interface Options {
+        caCerts?: string[];
+        sni?: string;
+        alpnProtocols?: string[];
+        extraOptions?: NodeTlsConnectOptions["extraOptions"];
+    }
+}
+export declare class AutoDialer implements Dialer {
+    readonly tcpDialer: TcpDialer;
+    readonly tlsDialer: TlsDialer;
+    constructor(options?: AutoDialer.Options);
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace AutoDialer {
+    interface Options {
+        tcp?: TcpDialer;
+        tls?: TlsDialer;
+    }
+}
+export {};

package/src/encoding.d.cts

@@ -0,0 +1,24 @@
+type ByteStream = ReadableStream<Uint8Array>;
+type ByteTransform = TransformStream<Uint8Array, Uint8Array>;
+export declare function decodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function decodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+export declare function encodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function encodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+/**
+ * Create a series of decoding streams based on the content-encoding header. The
+ * resulting streams should be piped together to decode the content.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+ */
+export declare function createDecoders(contentEncoding?: string | string[]): ByteTransform[];
+/**
+ * Create a series of encoding streams based on the content-encoding header (or
+ * transfer-coding list).
+ *
+ * The resulting streams should be piped together to apply the encoding in the
+ * declared order.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+ */
+export declare function createEncoders(contentEncoding?: string | string[]): ByteTransform[];
+export {};

package/src/encoding.d.ts

@@ -0,0 +1,24 @@
+type ByteStream = ReadableStream<Uint8Array>;
+type ByteTransform = TransformStream<Uint8Array, Uint8Array>;
+export declare function decodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function decodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+export declare function encodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function encodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+/**
+ * Create a series of decoding streams based on the content-encoding header. The
+ * resulting streams should be piped together to decode the content.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+ */
+export declare function createDecoders(contentEncoding?: string | string[]): ByteTransform[];
+/**
+ * Create a series of encoding streams based on the content-encoding header (or
+ * transfer-coding list).
+ *
+ * The resulting streams should be piped together to apply the encoding in the
+ * declared order.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+ */
+export declare function createEncoders(contentEncoding?: string | string[]): ByteTransform[];
+export {};