@npy/fetch 0.1.0 → 0.1.1

package/body.cjs

@@ -0,0 +1,154 @@
+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 node_stream = require("node:stream");
+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")}`;
+var getFormHeader = (boundary, name, field) => {
+	let header = `${BOUNDARY}${boundary}\r
+`;
+	header += `Content-Disposition: form-data; name="${name}"`;
+	if (require_guards.isBlob(field)) {
+		header += `; filename="${field.name ?? "blob"}"\r
+`;
+		header += `Content-Type: ${field.type || "application/octet-stream"}`;
+	}
+	return `${header}\r
+\r
+`;
+};
+var getFormFooter = (boundary) => `${BOUNDARY}${boundary}${BOUNDARY}\r
+\r
+`;
+var getFormDataLength = (form, boundary) => {
+	let length = Buffer.byteLength(getFormFooter(boundary));
+	for (const [name, value] of form) length += Buffer.byteLength(getFormHeader(boundary, name, value)) + (require_guards.isBlob(value) ? value.size : Buffer.byteLength(`${value}`)) + 2;
+	return length;
+};
+async function* generatorOfFormData(form, boundary) {
+	for (const [name, value] of form) if (require_guards.isBlob(value)) {
+		yield _fuman_utils.utf8.encoder.encode(getFormHeader(boundary, name, value));
+		for await (const chunk of value.stream()) yield chunk;
+		yield _fuman_utils.utf8.encoder.encode("\r\n");
+	} else yield _fuman_utils.utf8.encoder.encode(getFormHeader(boundary, name, value) + value + "\r\n");
+	yield _fuman_utils.utf8.encoder.encode(getFormFooter(boundary));
+}
+var extractBody = (object) => {
+	let type = null;
+	let body;
+	let size = null;
+	if (object == null) {
+		body = null;
+		size = 0;
+	} else if (typeof object === "string") {
+		const bytes = _fuman_utils.utf8.encoder.encode(`${object}`);
+		type = "text/plain;charset=UTF-8";
+		size = bytes.byteLength;
+		body = bytes;
+	} else if (require_guards.isURLSearchParameters(object)) {
+		const bytes = _fuman_utils.utf8.encoder.encode(object.toString());
+		body = bytes;
+		size = bytes.byteLength;
+		type = "application/x-www-form-urlencoded;charset=UTF-8";
+	} else if (require_guards.isBlob(object)) {
+		size = object.size;
+		type = object.type || null;
+		body = object.stream();
+	} else if (object instanceof Uint8Array) {
+		body = object;
+		size = object.byteLength;
+	} else if ((0, node_util_types.isAnyArrayBuffer)(object)) {
+		const bytes = new Uint8Array(object);
+		body = bytes;
+		size = bytes.byteLength;
+	} else if (ArrayBuffer.isView(object)) {
+		const bytes = new Uint8Array(object.buffer, object.byteOffset, object.byteLength);
+		body = bytes;
+		size = bytes.byteLength;
+	} else if (require_guards.isReadableStream(object)) body = object;
+	else if (require_guards.isFormData(object)) {
+		const boundary = makeFormBoundary();
+		type = `multipart/form-data; boundary=${boundary}`;
+		size = getFormDataLength(object, boundary);
+		body = node_stream.Readable.from(generatorOfFormData(object, boundary));
+	} else if (require_guards.isMultipartFormDataStream(object)) {
+		type = `multipart/form-data; boundary=${object.getBoundary()}`;
+		size = object.hasKnownLength() ? object.getLengthSync() : null;
+		body = object;
+	} else if (require_guards.isReadable(object)) body = object;
+	else if (require_guards.isIterable(object)) body = node_stream.Readable.from(object);
+	else {
+		const bytes = _fuman_utils.utf8.encoder.encode(`${object}`);
+		type = "text/plain;charset=UTF-8";
+		body = bytes;
+		size = bytes.byteLength;
+	}
+	return {
+		contentLength: size,
+		contentType: type,
+		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();
+	}
+};
+//#endregion
+exports.Body = Body;
+exports.extractBody = extractBody;
+exports.getFormDataLength = getFormDataLength;

package/body.js

@@ -0,0 +1,151 @@
+import { isBlob, isFormData, isIterable, isMultipartFormDataStream, isReadable, isReadableStream, isURLSearchParameters } from "./_internal/guards.js";
+import { nodeReadableToWeb } from "@fuman/node";
+import { randomBytes } from "node:crypto";
+import { Readable } from "node:stream";
+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")}`;
+var getFormHeader = (boundary, name, field) => {
+	let header = `${BOUNDARY}${boundary}\r
+`;
+	header += `Content-Disposition: form-data; name="${name}"`;
+	if (isBlob(field)) {
+		header += `; filename="${field.name ?? "blob"}"\r
+`;
+		header += `Content-Type: ${field.type || "application/octet-stream"}`;
+	}
+	return `${header}\r
+\r
+`;
+};
+var getFormFooter = (boundary) => `${BOUNDARY}${boundary}${BOUNDARY}\r
+\r
+`;
+var getFormDataLength = (form, boundary) => {
+	let length = Buffer.byteLength(getFormFooter(boundary));
+	for (const [name, value] of form) length += Buffer.byteLength(getFormHeader(boundary, name, value)) + (isBlob(value) ? value.size : Buffer.byteLength(`${value}`)) + 2;
+	return length;
+};
+async function* generatorOfFormData(form, boundary) {
+	for (const [name, value] of form) if (isBlob(value)) {
+		yield utf8.encoder.encode(getFormHeader(boundary, name, value));
+		for await (const chunk of value.stream()) yield chunk;
+		yield utf8.encoder.encode("\r\n");
+	} else yield utf8.encoder.encode(getFormHeader(boundary, name, value) + value + "\r\n");
+	yield utf8.encoder.encode(getFormFooter(boundary));
+}
+var extractBody = (object) => {
+	let type = null;
+	let body;
+	let size = null;
+	if (object == null) {
+		body = null;
+		size = 0;
+	} else if (typeof object === "string") {
+		const bytes = utf8.encoder.encode(`${object}`);
+		type = "text/plain;charset=UTF-8";
+		size = bytes.byteLength;
+		body = bytes;
+	} else if (isURLSearchParameters(object)) {
+		const bytes = utf8.encoder.encode(object.toString());
+		body = bytes;
+		size = bytes.byteLength;
+		type = "application/x-www-form-urlencoded;charset=UTF-8";
+	} else if (isBlob(object)) {
+		size = object.size;
+		type = object.type || null;
+		body = object.stream();
+	} else if (object instanceof Uint8Array) {
+		body = object;
+		size = object.byteLength;
+	} else if (isAnyArrayBuffer(object)) {
+		const bytes = new Uint8Array(object);
+		body = bytes;
+		size = bytes.byteLength;
+	} else if (ArrayBuffer.isView(object)) {
+		const bytes = new Uint8Array(object.buffer, object.byteOffset, object.byteLength);
+		body = bytes;
+		size = bytes.byteLength;
+	} else if (isReadableStream(object)) body = object;
+	else if (isFormData(object)) {
+		const boundary = makeFormBoundary();
+		type = `multipart/form-data; boundary=${boundary}`;
+		size = getFormDataLength(object, boundary);
+		body = Readable.from(generatorOfFormData(object, boundary));
+	} else if (isMultipartFormDataStream(object)) {
+		type = `multipart/form-data; boundary=${object.getBoundary()}`;
+		size = object.hasKnownLength() ? object.getLengthSync() : null;
+		body = object;
+	} else if (isReadable(object)) body = object;
+	else if (isIterable(object)) body = Readable.from(object);
+	else {
+		const bytes = utf8.encoder.encode(`${object}`);
+		type = "text/plain;charset=UTF-8";
+		body = bytes;
+		size = bytes.byteLength;
+	}
+	return {
+		contentLength: size,
+		contentType: type,
+		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();
+	}
+};
+//#endregion
+export { Body, extractBody, getFormDataLength };

package/dialers/proxy.cjs

@@ -0,0 +1,49 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_net = require("../_internal/net.cjs");
+let _npy_proxy_kit = require("@npy/proxy-kit");
+//#region src/dialers/proxy.ts
+var DEFAULT_HTTP_ALPN_PROTOCOLS = ["http/1.1"];
+function normalizeProxy(proxy) {
+	if (typeof proxy !== "string") return proxy;
+	const parsed = (0, _npy_proxy_kit.parse)(proxy, { strict: true });
+	if (parsed == null) throw new TypeError(`Invalid proxy string: ${proxy}`);
+	return parsed;
+}
+var ProxyDialer = class {
+	proxy;
+	#options;
+	#connectThroughProxy;
+	constructor(proxy, options = {}) {
+		this.proxy = normalizeProxy(proxy);
+		this.#options = { ...options };
+		this.#connectThroughProxy = (0, _npy_proxy_kit.createProxyConnection)({
+			proxy: this.proxy,
+			connectionFn: require_net.connectTcp
+		});
+	}
+	async dial(target, options = {}) {
+		const tunneled = await this.#connectThroughProxy({
+			address: target.address,
+			port: target.port,
+			signal: options.signal
+		});
+		if (!target.secure) return tunneled;
+		return this.#upgradeSecureTarget(tunneled, target, options.signal);
+	}
+	async #upgradeSecureTarget(conn, target, signal) {
+		const sni = target.sni ?? this.#options.sni ?? target.address;
+		const extraOptions = this.#options.extraOptions || target.extraOptions ? {
+			...this.#options.extraOptions,
+			...target.extraOptions
+		} : void 0;
+		return require_net.upgradeTls(conn, {
+			signal,
+			caCerts: this.#options.caCerts,
+			sni,
+			alpnProtocols: target.alpnProtocols ?? this.#options.alpnProtocols ?? [...DEFAULT_HTTP_ALPN_PROTOCOLS],
+			extraOptions
+		});
+	}
+};
+//#endregion
+exports.ProxyDialer = ProxyDialer;

package/dialers/proxy.js

@@ -0,0 +1,48 @@
+import { connectTcp, upgradeTls } from "../_internal/net.js";
+import { createProxyConnection, parse } from "@npy/proxy-kit";
+//#region src/dialers/proxy.ts
+var DEFAULT_HTTP_ALPN_PROTOCOLS = ["http/1.1"];
+function normalizeProxy(proxy) {
+	if (typeof proxy !== "string") return proxy;
+	const parsed = parse(proxy, { strict: true });
+	if (parsed == null) throw new TypeError(`Invalid proxy string: ${proxy}`);
+	return parsed;
+}
+var ProxyDialer = class {
+	proxy;
+	#options;
+	#connectThroughProxy;
+	constructor(proxy, options = {}) {
+		this.proxy = normalizeProxy(proxy);
+		this.#options = { ...options };
+		this.#connectThroughProxy = createProxyConnection({
+			proxy: this.proxy,
+			connectionFn: connectTcp
+		});
+	}
+	async dial(target, options = {}) {
+		const tunneled = await this.#connectThroughProxy({
+			address: target.address,
+			port: target.port,
+			signal: options.signal
+		});
+		if (!target.secure) return tunneled;
+		return this.#upgradeSecureTarget(tunneled, target, options.signal);
+	}
+	async #upgradeSecureTarget(conn, target, signal) {
+		const sni = target.sni ?? this.#options.sni ?? target.address;
+		const extraOptions = this.#options.extraOptions || target.extraOptions ? {
+			...this.#options.extraOptions,
+			...target.extraOptions
+		} : void 0;
+		return upgradeTls(conn, {
+			signal,
+			caCerts: this.#options.caCerts,
+			sni,
+			alpnProtocols: target.alpnProtocols ?? this.#options.alpnProtocols ?? [...DEFAULT_HTTP_ALPN_PROTOCOLS],
+			extraOptions
+		});
+	}
+};
+//#endregion
+export { ProxyDialer };

package/dialers/tcp.cjs

@@ -0,0 +1,70 @@
+const require_net = require("../_internal/net.cjs");
+//#region src/dialers/tcp.ts
+var DEFAULT_TCP_PORT = 80;
+var DEFAULT_TLS_PORT = 443;
+var DEFAULT_HTTP_ALPN_PROTOCOLS = ["http/1.1"];
+function parsePort(value) {
+	if (typeof value === "number") {
+		if (!Number.isInteger(value) || value <= 0 || value > 65535) throw new TypeError(`Invalid port: ${String(value)}`);
+		return value;
+	}
+	if (!/^\d+$/.test(value)) throw new TypeError(`Invalid port: ${JSON.stringify(value)}`);
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) throw new TypeError(`Invalid port: ${JSON.stringify(value)}`);
+	return parsed;
+}
+function resolveHostPort(target, defaultPort) {
+	const address = target instanceof URL ? target.hostname : target.address;
+	if (!address) throw new TypeError("Target address is required");
+	return {
+		address,
+		port: target instanceof URL ? parsePort(target.port || String(defaultPort)) : parsePort(target.port || defaultPort)
+	};
+}
+var TcpDialer = class {
+	async dial(target, options = {}) {
+		if (target.secure) throw new Error("TcpDialer cannot dial a secure target");
+		return require_net.connectTcp({
+			...resolveHostPort(target, DEFAULT_TCP_PORT),
+			signal: options.signal
+		});
+	}
+};
+var TlsDialer = class {
+	#options;
+	constructor(options = {}) {
+		this.#options = { ...options };
+	}
+	async dial(target, options = {}) {
+		if (!target.secure) throw new Error("TlsDialer cannot dial an insecure target");
+		const endpoint = resolveHostPort(target, DEFAULT_TLS_PORT);
+		const extraOptions = this.#options.extraOptions || target.extraOptions ? {
+			...this.#options.extraOptions,
+			...target.extraOptions
+		} : void 0;
+		return require_net.connectTls({
+			...endpoint,
+			signal: options.signal,
+			caCerts: this.#options.caCerts,
+			sni: target.sni ?? this.#options.sni ?? endpoint.address,
+			alpnProtocols: target.alpnProtocols ?? this.#options.alpnProtocols ?? [...DEFAULT_HTTP_ALPN_PROTOCOLS],
+			extraOptions
+		});
+	}
+};
+var AutoDialer = class {
+	tcpDialer;
+	tlsDialer;
+	constructor(options = {}) {
+		this.tcpDialer = options.tcp ?? new TcpDialer();
+		this.tlsDialer = options.tls ?? new TlsDialer();
+	}
+	dial(target, options = {}) {
+		return target.secure ? this.tlsDialer.dial(target, options) : this.tcpDialer.dial(target, options);
+	}
+};
+//#endregion
+exports.AutoDialer = AutoDialer;
+exports.TcpDialer = TcpDialer;
+exports.TlsDialer = TlsDialer;
+exports.resolveHostPort = resolveHostPort;

package/dialers/tcp.js

@@ -0,0 +1,67 @@
+import { connectTcp, connectTls } from "../_internal/net.js";
+//#region src/dialers/tcp.ts
+var DEFAULT_TCP_PORT = 80;
+var DEFAULT_TLS_PORT = 443;
+var DEFAULT_HTTP_ALPN_PROTOCOLS = ["http/1.1"];
+function parsePort(value) {
+	if (typeof value === "number") {
+		if (!Number.isInteger(value) || value <= 0 || value > 65535) throw new TypeError(`Invalid port: ${String(value)}`);
+		return value;
+	}
+	if (!/^\d+$/.test(value)) throw new TypeError(`Invalid port: ${JSON.stringify(value)}`);
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) throw new TypeError(`Invalid port: ${JSON.stringify(value)}`);
+	return parsed;
+}
+function resolveHostPort(target, defaultPort) {
+	const address = target instanceof URL ? target.hostname : target.address;
+	if (!address) throw new TypeError("Target address is required");
+	return {
+		address,
+		port: target instanceof URL ? parsePort(target.port || String(defaultPort)) : parsePort(target.port || defaultPort)
+	};
+}
+var TcpDialer = class {
+	async dial(target, options = {}) {
+		if (target.secure) throw new Error("TcpDialer cannot dial a secure target");
+		return connectTcp({
+			...resolveHostPort(target, DEFAULT_TCP_PORT),
+			signal: options.signal
+		});
+	}
+};
+var TlsDialer = class {
+	#options;
+	constructor(options = {}) {
+		this.#options = { ...options };
+	}
+	async dial(target, options = {}) {
+		if (!target.secure) throw new Error("TlsDialer cannot dial an insecure target");
+		const endpoint = resolveHostPort(target, DEFAULT_TLS_PORT);
+		const extraOptions = this.#options.extraOptions || target.extraOptions ? {
+			...this.#options.extraOptions,
+			...target.extraOptions
+		} : void 0;
+		return connectTls({
+			...endpoint,
+			signal: options.signal,
+			caCerts: this.#options.caCerts,
+			sni: target.sni ?? this.#options.sni ?? endpoint.address,
+			alpnProtocols: target.alpnProtocols ?? this.#options.alpnProtocols ?? [...DEFAULT_HTTP_ALPN_PROTOCOLS],
+			extraOptions
+		});
+	}
+};
+var AutoDialer = class {
+	tcpDialer;
+	tlsDialer;
+	constructor(options = {}) {
+		this.tcpDialer = options.tcp ?? new TcpDialer();
+		this.tlsDialer = options.tls ?? new TlsDialer();
+	}
+	dial(target, options = {}) {
+		return target.secure ? this.tlsDialer.dial(target, options) : this.tcpDialer.dial(target, options);
+	}
+};
+//#endregion
+export { AutoDialer, TcpDialer, TlsDialer, resolveHostPort };

package/encoding.cjs

@@ -0,0 +1,95 @@
+require("./_virtual/_rolldown/runtime.cjs");
+let _fuman_node = require("@fuman/node");
+let node_stream = require("node:stream");
+//#region src/encoding.ts
+function applyTransforms(stream, contentEncoding, factory) {
+	const transforms = factory(contentEncoding);
+	if (transforms.length === 0) return stream;
+	let result;
+	if (stream instanceof ReadableStream) result = stream;
+	else result = (0, _fuman_node.nodeReadableToWeb)(node_stream.Readable.from(stream));
+	for (const t of transforms) result = result.pipeThrough(t);
+	return result;
+}
+function decodeStream(stream, contentEncoding) {
+	return applyTransforms(stream, contentEncoding, createDecoders);
+}
+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.
+*
+* @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+*/
+function createDecoders(contentEncoding) {
+	const decoders = [];
+	if (contentEncoding?.length) {
+		const encodings = Array.isArray(contentEncoding) ? contentEncoding.flatMap(commaSplit) : contentEncoding.split(",");
+		for (const encoding of encodings) {
+			const normalizedEncoding = normalizeEncoding(encoding);
+			if (normalizedEncoding === "identity") continue;
+			decoders.push(createDecoder(normalizedEncoding));
+		}
+	}
+	return decoders.reverse();
+}
+/**
+* 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}
+*/
+function createEncoders(contentEncoding) {
+	const encoders = [];
+	if (contentEncoding?.length) {
+		const encodings = Array.isArray(contentEncoding) ? contentEncoding.flatMap(commaSplit) : contentEncoding.split(",");
+		for (const encoding of encodings) {
+			const normalizedEncoding = normalizeEncoding(encoding);
+			if (normalizedEncoding === "identity") continue;
+			encoders.push(createEncoder(normalizedEncoding));
+		}
+	}
+	return encoders;
+}
+function commaSplit(header) {
+	return header.split(",");
+}
+function normalizeEncoding(encoding) {
+	return encoding.trim().toLowerCase();
+}
+function createDecoder(normalizedEncoding) {
+	switch (normalizedEncoding) {
+		case "gzip":
+		case "x-gzip": return new DecompressionStream("gzip");
+		case "deflate":
+		case "x-deflate": return new DecompressionStream("deflate");
+		case "zstd":
+		case "x-zstd": return new DecompressionStream("zstd");
+		case "br": return new DecompressionStream("brotli");
+		case "identity": return new TransformStream();
+		default: throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
+	}
+}
+function createEncoder(normalizedEncoding) {
+	switch (normalizedEncoding) {
+		case "gzip":
+		case "x-gzip": return new CompressionStream("gzip");
+		case "deflate":
+		case "x-deflate": return new CompressionStream("deflate");
+		case "zstd":
+		case "x-zstd": return new CompressionStream("zstd");
+		case "br": return new CompressionStream("brotli");
+		case "identity": return new TransformStream();
+		default: throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
+	}
+}
+//#endregion
+exports.createDecoders = createDecoders;
+exports.createEncoders = createEncoders;
+exports.decodeStream = decodeStream;
+exports.encodeStream = encodeStream;