@npy/fetch 0.1.1 → 0.1.2

package/body.cjs

@@ -1,10 +1,10 @@
 require("./_virtual/_rolldown/runtime.cjs");
 const require_guards = require("./_internal/guards.cjs");
-let _fuman_node = require("@fuman/node");
-let node_crypto = require("node:crypto");
+let _fuman_utils = require("@fuman/utils");
 let node_stream = require("node:stream");
+let _fuman_io = require("@fuman/io");
+let node_crypto = require("node:crypto");
 let node_util_types = require("node:util/types");
-let _fuman_utils = require("@fuman/utils");
 //#region src/body.ts
 var BOUNDARY = "-".repeat(2);
 var makeFormBoundary = () => `formdata-${(0, node_crypto.randomBytes)(8).toString("hex")}`;
@@ -70,6 +70,7 @@ var extractBody = (object) => {
 		body = bytes;
 		size = bytes.byteLength;
 	} else if (require_guards.isReadableStream(object)) body = object;
+	else if (require_guards.isFumanReadable(object)) body = object;
 	else if (require_guards.isFormData(object)) {
 		const boundary = makeFormBoundary();
 		type = `multipart/form-data; boundary=${boundary}`;
@@ -93,62 +94,12 @@ var extractBody = (object) => {
 		body
 	};
 };
-var kBodyInternals = Symbol("kBodyInternals");
-var toWebBodyInit = (body) => {
-	if (body == null) return null;
-	if (require_guards.isReadable(body)) return (0, _fuman_node.nodeReadableToWeb)(body);
-	return body;
-};
-var bytesToArrayBuffer = (bytes) => {
-	const bytesAsArrayBuffer = new ArrayBuffer(bytes.byteLength);
-	new Uint8Array(bytesAsArrayBuffer).set(bytes);
-	return bytesAsArrayBuffer;
-};
-var Body = class {
-	[kBodyInternals];
-	constructor(init) {
-		this[kBodyInternals] = extractBody(init);
-	}
-	get body() {
-		return this[kBodyInternals].body;
-	}
-	get bodyUsed() {
-		const { body } = this[kBodyInternals];
-		if (require_guards.isReadable(body)) return node_stream.Readable.isDisturbed(body);
-		if (require_guards.isReadableStream(body)) return body.locked;
-		return false;
-	}
-	async arrayBuffer() {
-		const { body } = this[kBodyInternals];
-		if (body == null) return /* @__PURE__ */ new ArrayBuffer(0);
-		if (body instanceof Uint8Array) return bytesToArrayBuffer(body);
-		return new Response(toWebBodyInit(body)).arrayBuffer();
-	}
-	async formData() {
-		const { body, contentLength, contentType } = this[kBodyInternals];
-		const headers = {};
-		if (contentLength != null) headers["Content-Length"] = String(contentLength);
-		if (contentType != null) headers["Content-Type"] = contentType;
-		return new Response(toWebBodyInit(body), { headers }).formData();
-	}
-	async blob() {
-		const { body, contentType } = this[kBodyInternals];
-		if (body == null) return new Blob([], { type: contentType ?? "" });
-		if (body instanceof Uint8Array) return new Blob([new Uint8Array(body.buffer, body.byteOffset, body.byteLength)], { type: contentType ?? "" });
-		return new Response(toWebBodyInit(body), { headers: contentType ? { "Content-Type": contentType } : void 0 }).blob();
-	}
-	async json() {
-		const text = await this.text();
-		return JSON.parse(text);
-	}
-	async text() {
-		const { body } = this[kBodyInternals];
-		if (body == null) return "";
-		if (body instanceof Uint8Array) return _fuman_utils.utf8.decoder.decode(body);
-		return new Response(toWebBodyInit(body)).text();
-	}
-};
+function fromRequestBody(request) {
+	if (request.bodyUsed) throw new TypeError("Request body has already been used");
+	if (request.body == null) return null;
+	return (0, _fuman_io.webReadableToFuman)(request.body);
+}
 //#endregion
-exports.Body = Body;
 exports.extractBody = extractBody;
+exports.fromRequestBody = fromRequestBody;
 exports.getFormDataLength = getFormDataLength;

package/body.d.cts

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import { IClosable, IReadable } from '@fuman/io';
+import { FormDataPolyfill } from './_internal/guards';
+export type BodyInit = Exclude<RequestInit["body"], undefined | null> | FormDataPolyfill | Readable | (IReadable & IClosable);
+export interface BodyState {
+    contentLength: number | null;
+    contentType: string | null;
+    body: Readable | ReadableStream | Uint8Array | (IReadable & IClosable) | null;
+}
+export declare const getFormDataLength: (form: FormData, boundary: string) => number;
+export declare const extractBody: (object: BodyInit | null) => BodyState;
+export declare function fromRequestBody(request: Request): BodyInit | null;

package/body.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import { IClosable, IReadable } from '@fuman/io';
+import { FormDataPolyfill } from './_internal/guards';
+export type BodyInit = Exclude<RequestInit["body"], undefined | null> | FormDataPolyfill | Readable | (IReadable & IClosable);
+export interface BodyState {
+    contentLength: number | null;
+    contentType: string | null;
+    body: Readable | ReadableStream | Uint8Array | (IReadable & IClosable) | null;
+}
+export declare const getFormDataLength: (form: FormData, boundary: string) => number;
+export declare const extractBody: (object: BodyInit | null) => BodyState;
+export declare function fromRequestBody(request: Request): BodyInit | null;

package/body.js

@@ -1,9 +1,9 @@
-import { isBlob, isFormData, isIterable, isMultipartFormDataStream, isReadable, isReadableStream, isURLSearchParameters } from "./_internal/guards.js";
-import { nodeReadableToWeb } from "@fuman/node";
-import { randomBytes } from "node:crypto";
+import { isBlob, isFormData, isFumanReadable, isIterable, isMultipartFormDataStream, isReadable, isReadableStream, isURLSearchParameters } from "./_internal/guards.js";
+import { utf8 } from "@fuman/utils";
 import { Readable } from "node:stream";
+import { webReadableToFuman } from "@fuman/io";
+import { randomBytes } from "node:crypto";
 import { isAnyArrayBuffer } from "node:util/types";
-import { utf8 } from "@fuman/utils";
 //#region src/body.ts
 var BOUNDARY = "-".repeat(2);
 var makeFormBoundary = () => `formdata-${randomBytes(8).toString("hex")}`;
@@ -69,6 +69,7 @@ var extractBody = (object) => {
 		body = bytes;
 		size = bytes.byteLength;
 	} else if (isReadableStream(object)) body = object;
+	else if (isFumanReadable(object)) body = object;
 	else if (isFormData(object)) {
 		const boundary = makeFormBoundary();
 		type = `multipart/form-data; boundary=${boundary}`;
@@ -92,60 +93,10 @@ var extractBody = (object) => {
 		body
 	};
 };
-var kBodyInternals = Symbol("kBodyInternals");
-var toWebBodyInit = (body) => {
-	if (body == null) return null;
-	if (isReadable(body)) return nodeReadableToWeb(body);
-	return body;
-};
-var bytesToArrayBuffer = (bytes) => {
-	const bytesAsArrayBuffer = new ArrayBuffer(bytes.byteLength);
-	new Uint8Array(bytesAsArrayBuffer).set(bytes);
-	return bytesAsArrayBuffer;
-};
-var Body = class {
-	[kBodyInternals];
-	constructor(init) {
-		this[kBodyInternals] = extractBody(init);
-	}
-	get body() {
-		return this[kBodyInternals].body;
-	}
-	get bodyUsed() {
-		const { body } = this[kBodyInternals];
-		if (isReadable(body)) return Readable.isDisturbed(body);
-		if (isReadableStream(body)) return body.locked;
-		return false;
-	}
-	async arrayBuffer() {
-		const { body } = this[kBodyInternals];
-		if (body == null) return /* @__PURE__ */ new ArrayBuffer(0);
-		if (body instanceof Uint8Array) return bytesToArrayBuffer(body);
-		return new Response(toWebBodyInit(body)).arrayBuffer();
-	}
-	async formData() {
-		const { body, contentLength, contentType } = this[kBodyInternals];
-		const headers = {};
-		if (contentLength != null) headers["Content-Length"] = String(contentLength);
-		if (contentType != null) headers["Content-Type"] = contentType;
-		return new Response(toWebBodyInit(body), { headers }).formData();
-	}
-	async blob() {
-		const { body, contentType } = this[kBodyInternals];
-		if (body == null) return new Blob([], { type: contentType ?? "" });
-		if (body instanceof Uint8Array) return new Blob([new Uint8Array(body.buffer, body.byteOffset, body.byteLength)], { type: contentType ?? "" });
-		return new Response(toWebBodyInit(body), { headers: contentType ? { "Content-Type": contentType } : void 0 }).blob();
-	}
-	async json() {
-		const text = await this.text();
-		return JSON.parse(text);
-	}
-	async text() {
-		const { body } = this[kBodyInternals];
-		if (body == null) return "";
-		if (body instanceof Uint8Array) return utf8.decoder.decode(body);
-		return new Response(toWebBodyInit(body)).text();
-	}
-};
+function fromRequestBody(request) {
+	if (request.bodyUsed) throw new TypeError("Request body has already been used");
+	if (request.body == null) return null;
+	return webReadableToFuman(request.body);
+}
 //#endregion
-export { Body, extractBody, getFormDataLength };
+export { extractBody, fromRequestBody, getFormDataLength };

package/dialers/proxy.cjs

@@ -9,6 +9,13 @@ function normalizeProxy(proxy) {
 	if (parsed == null) throw new TypeError(`Invalid proxy string: ${proxy}`);
 	return parsed;
 }
+/**
+* Dialer that routes connections through an HTTP, HTTPS or SOCKS proxy.
+*
+* @remarks
+* Secure targets are tunneled and then upgraded to TLS after the proxy connection
+* has been established.
+*/
 var ProxyDialer = class {
 	proxy;
 	#options;

package/{src/dialers → dialers}/proxy.d.cts

@@ -1,15 +1,22 @@
 import { NodeTlsUpgradeOptions } from '@fuman/node';
 import { createProxyConnection, ProxyInfo } from '@npy/proxy-kit';
 import { Dialer } from '../types/dialer';
+type ResolvedProxy = Parameters<typeof createProxyConnection>[0]["proxy"];
+/**
+ * Dialer that routes connections through an HTTP, HTTPS or SOCKS proxy.
+ *
+ * @remarks
+ * Secure targets are tunneled and then upgraded to TLS after the proxy connection
+ * has been established.
+ */
 export declare class ProxyDialer implements Dialer {
     #private;
-    readonly proxy: ProxyDialer.Proxy;
+    readonly proxy: ResolvedProxy;
     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;
+    type Input = string | ProxyInfo;
     interface Options {
         caCerts?: string[];
         sni?: string;
@@ -17,3 +24,4 @@ export declare namespace ProxyDialer {
         extraOptions?: NodeTlsUpgradeOptions["extraOptions"];
     }
 }
+export {};

package/{src/dialers → dialers}/proxy.d.ts

@@ -1,15 +1,22 @@
 import { NodeTlsUpgradeOptions } from '@fuman/node';
 import { createProxyConnection, ProxyInfo } from '@npy/proxy-kit';
 import { Dialer } from '../types/dialer';
+type ResolvedProxy = Parameters<typeof createProxyConnection>[0]["proxy"];
+/**
+ * Dialer that routes connections through an HTTP, HTTPS or SOCKS proxy.
+ *
+ * @remarks
+ * Secure targets are tunneled and then upgraded to TLS after the proxy connection
+ * has been established.
+ */
 export declare class ProxyDialer implements Dialer {
     #private;
-    readonly proxy: ProxyDialer.Proxy;
+    readonly proxy: ResolvedProxy;
     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;
+    type Input = string | ProxyInfo;
     interface Options {
         caCerts?: string[];
         sni?: string;
@@ -17,3 +24,4 @@ export declare namespace ProxyDialer {
         extraOptions?: NodeTlsUpgradeOptions["extraOptions"];
     }
 }
+export {};

package/dialers/proxy.js

@@ -8,6 +8,13 @@ function normalizeProxy(proxy) {
 	if (parsed == null) throw new TypeError(`Invalid proxy string: ${proxy}`);
 	return parsed;
 }
+/**
+* Dialer that routes connections through an HTTP, HTTPS or SOCKS proxy.
+*
+* @remarks
+* Secure targets are tunneled and then upgraded to TLS after the proxy connection
+* has been established.
+*/
 var ProxyDialer = class {
 	proxy;
 	#options;

package/dialers/tcp.cjs

@@ -13,6 +13,12 @@ function parsePort(value) {
 	if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) throw new TypeError(`Invalid port: ${JSON.stringify(value)}`);
 	return parsed;
 }
+/**
+* Resolves the effective network address and port for a URL or dial target.
+*
+* @remarks
+* When the input does not include an explicit port, the provided default port is used.
+*/
 function resolveHostPort(target, defaultPort) {
 	const address = target instanceof URL ? target.hostname : target.address;
 	if (!address) throw new TypeError("Target address is required");
@@ -21,6 +27,12 @@ function resolveHostPort(target, defaultPort) {
 		port: target instanceof URL ? parsePort(target.port || String(defaultPort)) : parsePort(target.port || defaultPort)
 	};
 }
+/**
+* Dialer for plain TCP targets.
+*
+* @remarks
+* This dialer rejects secure targets and is intended for HTTP over raw TCP.
+*/
 var TcpDialer = class {
 	async dial(target, options = {}) {
 		if (target.secure) throw new Error("TcpDialer cannot dial a secure target");
@@ -30,6 +42,13 @@ var TcpDialer = class {
 		});
 	}
 };
+/**
+* Dialer for TLS targets.
+*
+* @remarks
+* This dialer rejects insecure targets and applies TLS-specific options such as
+* CA certificates, SNI and ALPN.
+*/
 var TlsDialer = class {
 	#options;
 	constructor(options = {}) {
@@ -52,6 +71,9 @@ var TlsDialer = class {
 		});
 	}
 };
+/**
+* Selects {@link TcpDialer} or {@link TlsDialer} based on the target security mode.
+*/
 var AutoDialer = class {
 	tcpDialer;
 	tlsDialer;

package/{src/dialers → dialers}/tcp.d.cts

@@ -1,13 +1,32 @@
 import { NodeTlsConnectOptions } from '@fuman/node';
 import { Dialer } from '../types/dialer';
-type HostPort = {
+export type HostPort = {
     address: string;
     port: number;
 };
+/**
+ * Resolves the effective network address and port for a URL or dial target.
+ *
+ * @remarks
+ * When the input does not include an explicit port, the provided default port is used.
+ */
 export declare function resolveHostPort(target: URL | Dialer.Target, defaultPort: number): HostPort;
+/**
+ * Dialer for plain TCP targets.
+ *
+ * @remarks
+ * This dialer rejects secure targets and is intended for HTTP over raw TCP.
+ */
 export declare class TcpDialer implements Dialer {
     dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
 }
+/**
+ * Dialer for TLS targets.
+ *
+ * @remarks
+ * This dialer rejects insecure targets and applies TLS-specific options such as
+ * CA certificates, SNI and ALPN.
+ */
 export declare class TlsDialer implements Dialer {
     #private;
     constructor(options?: TlsDialer.Options);
@@ -21,6 +40,9 @@ export declare namespace TlsDialer {
         extraOptions?: NodeTlsConnectOptions["extraOptions"];
     }
 }
+/**
+ * Selects {@link TcpDialer} or {@link TlsDialer} based on the target security mode.
+ */
 export declare class AutoDialer implements Dialer {
     readonly tcpDialer: TcpDialer;
     readonly tlsDialer: TlsDialer;
@@ -33,4 +55,3 @@ export declare namespace AutoDialer {
         tls?: TlsDialer;
     }
 }
-export {};

package/{src/dialers → dialers}/tcp.d.ts

@@ -1,13 +1,32 @@
 import { NodeTlsConnectOptions } from '@fuman/node';
 import { Dialer } from '../types/dialer';
-type HostPort = {
+export type HostPort = {
     address: string;
     port: number;
 };
+/**
+ * Resolves the effective network address and port for a URL or dial target.
+ *
+ * @remarks
+ * When the input does not include an explicit port, the provided default port is used.
+ */
 export declare function resolveHostPort(target: URL | Dialer.Target, defaultPort: number): HostPort;
+/**
+ * Dialer for plain TCP targets.
+ *
+ * @remarks
+ * This dialer rejects secure targets and is intended for HTTP over raw TCP.
+ */
 export declare class TcpDialer implements Dialer {
     dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
 }
+/**
+ * Dialer for TLS targets.
+ *
+ * @remarks
+ * This dialer rejects insecure targets and applies TLS-specific options such as
+ * CA certificates, SNI and ALPN.
+ */
 export declare class TlsDialer implements Dialer {
     #private;
     constructor(options?: TlsDialer.Options);
@@ -21,6 +40,9 @@ export declare namespace TlsDialer {
         extraOptions?: NodeTlsConnectOptions["extraOptions"];
     }
 }
+/**
+ * Selects {@link TcpDialer} or {@link TlsDialer} based on the target security mode.
+ */
 export declare class AutoDialer implements Dialer {
     readonly tcpDialer: TcpDialer;
     readonly tlsDialer: TlsDialer;
@@ -33,4 +55,3 @@ export declare namespace AutoDialer {
         tls?: TlsDialer;
     }
 }
-export {};

package/dialers/tcp.js

@@ -13,6 +13,12 @@ function parsePort(value) {
 	if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) throw new TypeError(`Invalid port: ${JSON.stringify(value)}`);
 	return parsed;
 }
+/**
+* Resolves the effective network address and port for a URL or dial target.
+*
+* @remarks
+* When the input does not include an explicit port, the provided default port is used.
+*/
 function resolveHostPort(target, defaultPort) {
 	const address = target instanceof URL ? target.hostname : target.address;
 	if (!address) throw new TypeError("Target address is required");
@@ -21,6 +27,12 @@ function resolveHostPort(target, defaultPort) {
 		port: target instanceof URL ? parsePort(target.port || String(defaultPort)) : parsePort(target.port || defaultPort)
 	};
 }
+/**
+* Dialer for plain TCP targets.
+*
+* @remarks
+* This dialer rejects secure targets and is intended for HTTP over raw TCP.
+*/
 var TcpDialer = class {
 	async dial(target, options = {}) {
 		if (target.secure) throw new Error("TcpDialer cannot dial a secure target");
@@ -30,6 +42,13 @@ var TcpDialer = class {
 		});
 	}
 };
+/**
+* Dialer for TLS targets.
+*
+* @remarks
+* This dialer rejects insecure targets and applies TLS-specific options such as
+* CA certificates, SNI and ALPN.
+*/
 var TlsDialer = class {
 	#options;
 	constructor(options = {}) {
@@ -52,6 +71,9 @@ var TlsDialer = class {
 		});
 	}
 };
+/**
+* Selects {@link TcpDialer} or {@link TlsDialer} based on the target security mode.
+*/
 var AutoDialer = class {
 	tcpDialer;
 	tlsDialer;

package/encoding.cjs

@@ -1,4 +1,5 @@
 require("./_virtual/_rolldown/runtime.cjs");
+const require_decode_stream_error = require("./_internal/decode-stream-error.cjs");
 let _fuman_node = require("@fuman/node");
 let node_stream = require("node:stream");
 //#region src/encoding.ts
@@ -18,10 +19,11 @@ function encodeStream(stream, contentEncoding) {
 	return applyTransforms(stream, contentEncoding, createEncoders);
 }
 /**
-* Create a series of decoding streams based on the content-encoding header. The
-* resulting streams should be piped together to decode the content.
+* Creates the decoder pipeline for a Content-Encoding or transfer-coding list.
 *
-* @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+* @remarks
+* Decoding is applied in reverse order of encoding, as required by HTTP semantics.
+* The special value `identity` is ignored.
 */
 function createDecoders(contentEncoding) {
 	const decoders = [];
@@ -36,13 +38,10 @@ function createDecoders(contentEncoding) {
 	return decoders.reverse();
 }
 /**
-* Create a series of encoding streams based on the content-encoding header (or
-* transfer-coding list).
+* Creates the encoder pipeline for a Content-Encoding 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}
+* @remarks
+* Encoders are returned in the declared order. The special value `identity` is ignored.
 */
 function createEncoders(contentEncoding) {
 	const encoders = [];
@@ -62,15 +61,35 @@ function commaSplit(header) {
 function normalizeEncoding(encoding) {
 	return encoding.trim().toLowerCase();
 }
+function tagDecodeErrors(native) {
+	const reader = native.readable.getReader();
+	const tagged = new ReadableStream({
+		pull(controller) {
+			return reader.read().then(({ done, value }) => {
+				if (done) controller.close();
+				else if (value) controller.enqueue(value);
+			}, (err) => {
+				controller.error(new require_decode_stream_error.DecodeStreamError(err));
+			});
+		},
+		cancel(reason) {
+			return reader.cancel(reason);
+		}
+	});
+	return {
+		writable: native.writable,
+		readable: tagged
+	};
+}
 function createDecoder(normalizedEncoding) {
 	switch (normalizedEncoding) {
 		case "gzip":
-		case "x-gzip": return new DecompressionStream("gzip");
+		case "x-gzip": return tagDecodeErrors(new DecompressionStream("gzip"));
 		case "deflate":
-		case "x-deflate": return new DecompressionStream("deflate");
+		case "x-deflate": return tagDecodeErrors(new DecompressionStream("deflate"));
 		case "zstd":
-		case "x-zstd": return new DecompressionStream("zstd");
-		case "br": return new DecompressionStream("brotli");
+		case "x-zstd": return tagDecodeErrors(new DecompressionStream("zstd"));
+		case "br": return tagDecodeErrors(new DecompressionStream("brotli"));
 		case "identity": return new TransformStream();
 		default: throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
 	}

package/encoding.d.cts

@@ -0,0 +1,35 @@
+export type ByteStream = ReadableStream<Uint8Array>;
+export type ByteTransform = TransformStream<Uint8Array, Uint8Array>;
+/**
+ * Applies decoding transforms for the given content-encoding list.
+ *
+ * @remarks
+ * If no supported encodings are provided, the original source is returned unchanged.
+ * Async iterables are converted to Web Streams only when transforms are required.
+ */
+export declare function decodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function decodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+/**
+ * Applies encoding transforms for the given content-encoding list.
+ *
+ * @remarks
+ * If no supported encodings are provided, the original source is returned unchanged.
+ * Async iterables are converted to Web Streams only when transforms are required.
+ */
+export declare function encodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function encodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+/**
+ * Creates the decoder pipeline for a Content-Encoding or transfer-coding list.
+ *
+ * @remarks
+ * Decoding is applied in reverse order of encoding, as required by HTTP semantics.
+ * The special value `identity` is ignored.
+ */
+export declare function createDecoders(contentEncoding?: string | string[]): ByteTransform[];
+/**
+ * Creates the encoder pipeline for a Content-Encoding or transfer-coding list.
+ *
+ * @remarks
+ * Encoders are returned in the declared order. The special value `identity` is ignored.
+ */
+export declare function createEncoders(contentEncoding?: string | string[]): ByteTransform[];

package/encoding.d.ts

@@ -0,0 +1,35 @@
+export type ByteStream = ReadableStream<Uint8Array>;
+export type ByteTransform = TransformStream<Uint8Array, Uint8Array>;
+/**
+ * Applies decoding transforms for the given content-encoding list.
+ *
+ * @remarks
+ * If no supported encodings are provided, the original source is returned unchanged.
+ * Async iterables are converted to Web Streams only when transforms are required.
+ */
+export declare function decodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function decodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+/**
+ * Applies encoding transforms for the given content-encoding list.
+ *
+ * @remarks
+ * If no supported encodings are provided, the original source is returned unchanged.
+ * Async iterables are converted to Web Streams only when transforms are required.
+ */
+export declare function encodeStream(stream: ByteStream, contentEncoding?: string | string[]): ByteStream;
+export declare function encodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | ByteStream;
+/**
+ * Creates the decoder pipeline for a Content-Encoding or transfer-coding list.
+ *
+ * @remarks
+ * Decoding is applied in reverse order of encoding, as required by HTTP semantics.
+ * The special value `identity` is ignored.
+ */
+export declare function createDecoders(contentEncoding?: string | string[]): ByteTransform[];
+/**
+ * Creates the encoder pipeline for a Content-Encoding or transfer-coding list.
+ *
+ * @remarks
+ * Encoders are returned in the declared order. The special value `identity` is ignored.
+ */
+export declare function createEncoders(contentEncoding?: string | string[]): ByteTransform[];