@npy/fetch 0.1.0 → 0.1.1

package/_internal/consts.cjs

@@ -0,0 +1,4 @@
+//#region src/_internal/consts.ts
+var CRLF_BYTES = new Uint8Array([13, 10]);
+//#endregion
+exports.CRLF_BYTES = CRLF_BYTES;

package/_internal/consts.js

@@ -0,0 +1,4 @@
+//#region src/_internal/consts.ts
+var CRLF_BYTES = new Uint8Array([13, 10]);
+//#endregion
+export { CRLF_BYTES };

package/_internal/error-adapters.cjs

@@ -0,0 +1,146 @@
+const require_errors = require("../errors.cjs");
+//#region src/_internal/error-adapters.ts
+function getErrorChain(error, maxDepth = 8) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	let depth = 0;
+	while (current instanceof Error && depth < maxDepth && !seen.has(current)) {
+		const entry = current;
+		chain.push(entry);
+		seen.add(current);
+		current = entry.cause;
+		depth += 1;
+	}
+	return chain;
+}
+function unknownToError(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	return new Error("Unknown error", { cause: error });
+}
+function isAbortLike(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = "name" in error ? error.name : void 0;
+	return name === "AbortError" || name === "TimeoutError";
+}
+function defaultAbortDomException() {
+	return new DOMException("This operation was aborted", "AbortError");
+}
+function getRawAbortReason(signal) {
+	return signal?.reason ?? defaultAbortDomException();
+}
+function toAbortCause(signal, fallback) {
+	return unknownToError(signal?.reason ?? fallback ?? defaultAbortDomException());
+}
+function isTimeoutReason(reason) {
+	return !!reason && typeof reason === "object" && "name" in reason && reason.name === "TimeoutError";
+}
+function looksLikeDecodeError(error) {
+	const chain = getErrorChain(error);
+	for (const entry of chain) {
+		const code = typeof entry.code === "string" ? entry.code.toLowerCase() : "";
+		const text = `${entry.name} ${entry.message} ${code}`.toLowerCase();
+		if (code === "z_data_error" || code === "z_buf_error" || code === "z_stream_error" || text.includes("decode") || text.includes("decompress") || text.includes("encoding") || text.includes("gzip") || text.includes("deflate") || text.includes("brotli") || text.includes("incorrect header check") || text.includes("invalid block type") || text.includes("invalid distance") || text.includes("invalid stored block") || text.includes("unexpected end of file") || text.includes("unexpected end of stream") || text.includes("header check")) return true;
+	}
+	return false;
+}
+function mapAdvancedConnectError(error, { signal, context, timedOut }) {
+	if (error instanceof require_errors.FetchError) return error;
+	if (timedOut || isTimeoutReason(signal?.reason)) return new require_errors.ConnectTimeoutError(unknownToError(error), context, "Connection timeout");
+	if (signal?.aborted || isAbortLike(error)) return new require_errors.RequestAbortedError(toAbortCause(signal, error), context, "The request was aborted while connecting");
+	return new require_errors.ConnectionError(unknownToError(error), context, "Connection failed");
+}
+function mapAdvancedSendError(error, { signal, context, phase }) {
+	if (error instanceof require_errors.FetchError) return error;
+	if (signal?.aborted || isAbortLike(error)) return new require_errors.RequestAbortedError(toAbortCause(signal, error), context, phase === "body" ? "The request was aborted while reading the response body" : "The request was aborted");
+	const cause = unknownToError(error);
+	if (phase === "request") return new require_errors.RequestWriteError(cause, context);
+	if (phase === "response") return new require_errors.ResponseHeaderError(cause, context);
+	if (looksLikeDecodeError(cause)) return new require_errors.ResponseDecodeError(cause, context);
+	return new require_errors.ResponseBodyError(cause, context);
+}
+function wrapResponseBodyErrors(response, mapError) {
+	const source = response.body;
+	if (!source) return response;
+	const reader = source.getReader();
+	let pending = null;
+	const wrapped = new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				const byob = controller.byobRequest;
+				if (byob?.view) {
+					const target = new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength);
+					if (target.byteLength === 0) {
+						byob.respond(0);
+						return;
+					}
+					let written = 0;
+					if (pending && pending.byteLength > 0) {
+						const n = Math.min(target.byteLength, pending.byteLength);
+						target.set(pending.subarray(0, n), written);
+						written += n;
+						pending = n === pending.byteLength ? null : pending.subarray(n);
+					}
+					while (written === 0) {
+						const { done, value } = await reader.read();
+						if (done) {
+							byob.respond(0);
+							controller.close();
+							return;
+						}
+						if (!value || value.byteLength === 0) continue;
+						const n = Math.min(target.byteLength - written, value.byteLength);
+						target.set(value.subarray(0, n), written);
+						written += n;
+						if (n < value.byteLength) pending = value.subarray(n);
+					}
+					byob.respond(written);
+					return;
+				}
+				if (pending && pending.byteLength > 0) {
+					const chunk = pending;
+					pending = null;
+					controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				if (value && value.byteLength > 0) controller.enqueue(value);
+			} catch (error) {
+				controller.error(mapError(error));
+			}
+		},
+		async cancel(reason) {
+			pending = null;
+			await reader.cancel(reason);
+		}
+	});
+	return new Response(wrapped, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: new Headers(response.headers)
+	});
+}
+function toWebFetchError(error, signal) {
+	if (signal?.aborted) return getRawAbortReason(signal);
+	if (error instanceof DOMException || error instanceof TypeError) return error;
+	const cause = error instanceof Error ? error : unknownToError(error);
+	return new TypeError("fetch failed", { cause });
+}
+function toWebBodyReadError(error, signal) {
+	if (signal?.aborted) return getRawAbortReason(signal);
+	if (error instanceof DOMException || error instanceof TypeError || error instanceof RangeError) return error;
+	const cause = error instanceof Error ? error : unknownToError(error);
+	return new TypeError("Failed to read response body", { cause });
+}
+//#endregion
+exports.mapAdvancedConnectError = mapAdvancedConnectError;
+exports.mapAdvancedSendError = mapAdvancedSendError;
+exports.toWebBodyReadError = toWebBodyReadError;
+exports.toWebFetchError = toWebFetchError;
+exports.wrapResponseBodyErrors = wrapResponseBodyErrors;

package/_internal/error-adapters.js

@@ -0,0 +1,142 @@
+import { ConnectTimeoutError, ConnectionError, FetchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError } from "../errors.js";
+//#region src/_internal/error-adapters.ts
+function getErrorChain(error, maxDepth = 8) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	let depth = 0;
+	while (current instanceof Error && depth < maxDepth && !seen.has(current)) {
+		const entry = current;
+		chain.push(entry);
+		seen.add(current);
+		current = entry.cause;
+		depth += 1;
+	}
+	return chain;
+}
+function unknownToError(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	return new Error("Unknown error", { cause: error });
+}
+function isAbortLike(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = "name" in error ? error.name : void 0;
+	return name === "AbortError" || name === "TimeoutError";
+}
+function defaultAbortDomException() {
+	return new DOMException("This operation was aborted", "AbortError");
+}
+function getRawAbortReason(signal) {
+	return signal?.reason ?? defaultAbortDomException();
+}
+function toAbortCause(signal, fallback) {
+	return unknownToError(signal?.reason ?? fallback ?? defaultAbortDomException());
+}
+function isTimeoutReason(reason) {
+	return !!reason && typeof reason === "object" && "name" in reason && reason.name === "TimeoutError";
+}
+function looksLikeDecodeError(error) {
+	const chain = getErrorChain(error);
+	for (const entry of chain) {
+		const code = typeof entry.code === "string" ? entry.code.toLowerCase() : "";
+		const text = `${entry.name} ${entry.message} ${code}`.toLowerCase();
+		if (code === "z_data_error" || code === "z_buf_error" || code === "z_stream_error" || text.includes("decode") || text.includes("decompress") || text.includes("encoding") || text.includes("gzip") || text.includes("deflate") || text.includes("brotli") || text.includes("incorrect header check") || text.includes("invalid block type") || text.includes("invalid distance") || text.includes("invalid stored block") || text.includes("unexpected end of file") || text.includes("unexpected end of stream") || text.includes("header check")) return true;
+	}
+	return false;
+}
+function mapAdvancedConnectError(error, { signal, context, timedOut }) {
+	if (error instanceof FetchError) return error;
+	if (timedOut || isTimeoutReason(signal?.reason)) return new ConnectTimeoutError(unknownToError(error), context, "Connection timeout");
+	if (signal?.aborted || isAbortLike(error)) return new RequestAbortedError(toAbortCause(signal, error), context, "The request was aborted while connecting");
+	return new ConnectionError(unknownToError(error), context, "Connection failed");
+}
+function mapAdvancedSendError(error, { signal, context, phase }) {
+	if (error instanceof FetchError) return error;
+	if (signal?.aborted || isAbortLike(error)) return new RequestAbortedError(toAbortCause(signal, error), context, phase === "body" ? "The request was aborted while reading the response body" : "The request was aborted");
+	const cause = unknownToError(error);
+	if (phase === "request") return new RequestWriteError(cause, context);
+	if (phase === "response") return new ResponseHeaderError(cause, context);
+	if (looksLikeDecodeError(cause)) return new ResponseDecodeError(cause, context);
+	return new ResponseBodyError(cause, context);
+}
+function wrapResponseBodyErrors(response, mapError) {
+	const source = response.body;
+	if (!source) return response;
+	const reader = source.getReader();
+	let pending = null;
+	const wrapped = new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				const byob = controller.byobRequest;
+				if (byob?.view) {
+					const target = new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength);
+					if (target.byteLength === 0) {
+						byob.respond(0);
+						return;
+					}
+					let written = 0;
+					if (pending && pending.byteLength > 0) {
+						const n = Math.min(target.byteLength, pending.byteLength);
+						target.set(pending.subarray(0, n), written);
+						written += n;
+						pending = n === pending.byteLength ? null : pending.subarray(n);
+					}
+					while (written === 0) {
+						const { done, value } = await reader.read();
+						if (done) {
+							byob.respond(0);
+							controller.close();
+							return;
+						}
+						if (!value || value.byteLength === 0) continue;
+						const n = Math.min(target.byteLength - written, value.byteLength);
+						target.set(value.subarray(0, n), written);
+						written += n;
+						if (n < value.byteLength) pending = value.subarray(n);
+					}
+					byob.respond(written);
+					return;
+				}
+				if (pending && pending.byteLength > 0) {
+					const chunk = pending;
+					pending = null;
+					controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				if (value && value.byteLength > 0) controller.enqueue(value);
+			} catch (error) {
+				controller.error(mapError(error));
+			}
+		},
+		async cancel(reason) {
+			pending = null;
+			await reader.cancel(reason);
+		}
+	});
+	return new Response(wrapped, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: new Headers(response.headers)
+	});
+}
+function toWebFetchError(error, signal) {
+	if (signal?.aborted) return getRawAbortReason(signal);
+	if (error instanceof DOMException || error instanceof TypeError) return error;
+	const cause = error instanceof Error ? error : unknownToError(error);
+	return new TypeError("fetch failed", { cause });
+}
+function toWebBodyReadError(error, signal) {
+	if (signal?.aborted) return getRawAbortReason(signal);
+	if (error instanceof DOMException || error instanceof TypeError || error instanceof RangeError) return error;
+	const cause = error instanceof Error ? error : unknownToError(error);
+	return new TypeError("Failed to read response body", { cause });
+}
+//#endregion
+export { mapAdvancedConnectError, mapAdvancedSendError, toWebBodyReadError, toWebFetchError, wrapResponseBodyErrors };

package/_internal/guards.cjs

@@ -0,0 +1,24 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let node_stream = require("node:stream");
+//#region src/_internal/guards.ts
+var isReadable = (object) => node_stream.Readable.isReadable(object);
+var isIterable = (object) => typeof object?.[Symbol.asyncIterator] === "function" || typeof object?.[Symbol.iterator] === "function";
+var isMultipartFormDataStream = (object) => typeof object?.getBoundary === "function" && typeof object?.hasKnownLength === "function" && typeof object?.getLengthSync === "function" && node_stream.Readable.isReadable(object);
+var isFormData = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.set === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.delete === "function" && typeof object?.keys === "function" && typeof object?.values === "function" && typeof object?.entries === "function" && typeof object?.constructor === "function" && object?.[Symbol.toStringTag] === "FormData";
+var isURLSearchParameters = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.delete === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.has === "function" && typeof object?.set === "function" && typeof object?.sort === "function" && object?.[Symbol.toStringTag] === "URLSearchParams";
+var isReadableStream = (object) => typeof object === "object" && typeof object?.getReader === "function" && typeof object?.cancel === "function" && typeof object?.tee === "function";
+var isBlob = (object) => {
+	if (typeof object === "object" && typeof object?.arrayBuffer === "function" && typeof object?.type === "string" && typeof object?.stream === "function" && typeof object?.constructor === "function") {
+		const tag = object[Symbol.toStringTag];
+		return typeof tag === "string" && (tag.startsWith("Blob") || tag.startsWith("File"));
+	}
+	return false;
+};
+//#endregion
+exports.isBlob = isBlob;
+exports.isFormData = isFormData;
+exports.isIterable = isIterable;
+exports.isMultipartFormDataStream = isMultipartFormDataStream;
+exports.isReadable = isReadable;
+exports.isReadableStream = isReadableStream;
+exports.isURLSearchParameters = isURLSearchParameters;

package/_internal/guards.js

@@ -0,0 +1,17 @@
+import { Readable } from "node:stream";
+//#region src/_internal/guards.ts
+var isReadable = (object) => Readable.isReadable(object);
+var isIterable = (object) => typeof object?.[Symbol.asyncIterator] === "function" || typeof object?.[Symbol.iterator] === "function";
+var isMultipartFormDataStream = (object) => typeof object?.getBoundary === "function" && typeof object?.hasKnownLength === "function" && typeof object?.getLengthSync === "function" && Readable.isReadable(object);
+var isFormData = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.set === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.delete === "function" && typeof object?.keys === "function" && typeof object?.values === "function" && typeof object?.entries === "function" && typeof object?.constructor === "function" && object?.[Symbol.toStringTag] === "FormData";
+var isURLSearchParameters = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.delete === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.has === "function" && typeof object?.set === "function" && typeof object?.sort === "function" && object?.[Symbol.toStringTag] === "URLSearchParams";
+var isReadableStream = (object) => typeof object === "object" && typeof object?.getReader === "function" && typeof object?.cancel === "function" && typeof object?.tee === "function";
+var isBlob = (object) => {
+	if (typeof object === "object" && typeof object?.arrayBuffer === "function" && typeof object?.type === "string" && typeof object?.stream === "function" && typeof object?.constructor === "function") {
+		const tag = object[Symbol.toStringTag];
+		return typeof tag === "string" && (tag.startsWith("Blob") || tag.startsWith("File"));
+	}
+	return false;
+};
+//#endregion
+export { isBlob, isFormData, isIterable, isMultipartFormDataStream, isReadable, isReadableStream, isURLSearchParameters };

package/_internal/net.cjs

@@ -0,0 +1,95 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let node_net = require("node:net");
+let node_tls = require("node:tls");
+let _fuman_node = require("@fuman/node");
+//#region src/_internal/net.ts
+function toAbortError(reason) {
+	if (reason instanceof Error && reason.name === "AbortError") return reason;
+	const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "The operation was aborted";
+	if (typeof DOMException !== "undefined") return new DOMException(message, "AbortError");
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw toAbortError(signal.reason);
+}
+async function withSocketSignal(createSocket, wrapConnection, signal, readyEvent = "connect", onFailureCleanup) {
+	return new Promise((resolve, reject) => {
+		throwIfAborted(signal);
+		const socket = createSocket();
+		let settled = false;
+		const cleanup = () => {
+			socket.removeListener("error", onError);
+			socket.removeListener("timeout", onError);
+			socket.removeListener(readyEvent, onReady);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const safeCleanup = () => {
+			try {
+				onFailureCleanup?.();
+			} catch {}
+		};
+		const resolveOnce = (value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		};
+		const rejectOnce = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onError = (error) => {
+			safeCleanup();
+			rejectOnce(error);
+		};
+		const onAbort = () => {
+			const error = toAbortError(signal?.reason);
+			safeCleanup();
+			rejectOnce(error);
+			try {
+				socket.destroy(error);
+			} catch {}
+		};
+		const onReady = () => {
+			resolveOnce(wrapConnection(socket));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		socket.on("error", onError);
+		socket.on("timeout", onError);
+		socket.on(readyEvent, onReady);
+	});
+}
+var connectTcp = async ({ address, port, signal }) => {
+	return withSocketSignal(() => (0, node_net.createConnection)({
+		host: address,
+		port
+	}), (socket) => new _fuman_node.TcpConnection(socket), signal);
+};
+var connectTls = async (options) => {
+	const { address, port, signal, sni, caCerts, alpnProtocols, extraOptions } = options;
+	return withSocketSignal(() => (0, node_tls.connect)({
+		host: address,
+		port,
+		ca: caCerts,
+		ALPNProtocols: alpnProtocols,
+		servername: sni,
+		...extraOptions
+	}), (socket) => new _fuman_node.TlsConnection(socket), signal, "secureConnect");
+};
+var upgradeTls = async (conn, options) => {
+	return withSocketSignal(() => (0, node_tls.connect)({
+		socket: conn.socket,
+		ca: options.caCerts,
+		ALPNProtocols: options.alpnProtocols,
+		servername: options.sni,
+		...options.extraOptions
+	}), (socket) => new _fuman_node.TlsConnection(socket), options.signal, "secureConnect", () => conn.close());
+};
+//#endregion
+exports.connectTcp = connectTcp;
+exports.connectTls = connectTls;
+exports.upgradeTls = upgradeTls;

package/_internal/net.js

@@ -0,0 +1,92 @@
+import { createConnection } from "node:net";
+import { connect } from "node:tls";
+import { TcpConnection, TlsConnection } from "@fuman/node";
+//#region src/_internal/net.ts
+function toAbortError(reason) {
+	if (reason instanceof Error && reason.name === "AbortError") return reason;
+	const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "The operation was aborted";
+	if (typeof DOMException !== "undefined") return new DOMException(message, "AbortError");
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw toAbortError(signal.reason);
+}
+async function withSocketSignal(createSocket, wrapConnection, signal, readyEvent = "connect", onFailureCleanup) {
+	return new Promise((resolve, reject) => {
+		throwIfAborted(signal);
+		const socket = createSocket();
+		let settled = false;
+		const cleanup = () => {
+			socket.removeListener("error", onError);
+			socket.removeListener("timeout", onError);
+			socket.removeListener(readyEvent, onReady);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const safeCleanup = () => {
+			try {
+				onFailureCleanup?.();
+			} catch {}
+		};
+		const resolveOnce = (value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		};
+		const rejectOnce = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onError = (error) => {
+			safeCleanup();
+			rejectOnce(error);
+		};
+		const onAbort = () => {
+			const error = toAbortError(signal?.reason);
+			safeCleanup();
+			rejectOnce(error);
+			try {
+				socket.destroy(error);
+			} catch {}
+		};
+		const onReady = () => {
+			resolveOnce(wrapConnection(socket));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		socket.on("error", onError);
+		socket.on("timeout", onError);
+		socket.on(readyEvent, onReady);
+	});
+}
+var connectTcp = async ({ address, port, signal }) => {
+	return withSocketSignal(() => createConnection({
+		host: address,
+		port
+	}), (socket) => new TcpConnection(socket), signal);
+};
+var connectTls = async (options) => {
+	const { address, port, signal, sni, caCerts, alpnProtocols, extraOptions } = options;
+	return withSocketSignal(() => connect({
+		host: address,
+		port,
+		ca: caCerts,
+		ALPNProtocols: alpnProtocols,
+		servername: sni,
+		...extraOptions
+	}), (socket) => new TlsConnection(socket), signal, "secureConnect");
+};
+var upgradeTls = async (conn, options) => {
+	return withSocketSignal(() => connect({
+		socket: conn.socket,
+		ca: options.caCerts,
+		ALPNProtocols: options.alpnProtocols,
+		servername: options.sni,
+		...options.extraOptions
+	}), (socket) => new TlsConnection(socket), options.signal, "secureConnect", () => conn.close());
+};
+//#endregion
+export { connectTcp, connectTls, upgradeTls };

package/_internal/promises.cjs

@@ -0,0 +1,18 @@
+//#region src/_internal/promises.ts
+function raceSignal(promise, signal) {
+	return Promise.race([promise, new Promise((_, reject) => {
+		function onAbort() {
+			reject(signal.reason);
+		}
+		if (signal.aborted) onAbort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			function cleanup() {
+				signal.removeEventListener("abort", onAbort);
+			}
+			promise.then(cleanup, cleanup);
+		}
+	})]);
+}
+//#endregion
+exports.raceSignal = raceSignal;

package/_internal/promises.js

@@ -0,0 +1,18 @@
+//#region src/_internal/promises.ts
+function raceSignal(promise, signal) {
+	return Promise.race([promise, new Promise((_, reject) => {
+		function onAbort() {
+			reject(signal.reason);
+		}
+		if (signal.aborted) onAbort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			function cleanup() {
+				signal.removeEventListener("abort", onAbort);
+			}
+			promise.then(cleanup, cleanup);
+		}
+	})]);
+}
+//#endregion
+export { raceSignal };

package/_internal/streams.cjs

@@ -0,0 +1,37 @@
+//#region src/_internal/streams.ts
+/**
+* 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.
+*/
+function bytesToStream(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+/**
+* 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.
+*/
+var MaxBytesTransformStream = class extends TransformStream {
+	constructor(maxBytes) {
+		if (!(maxBytes >= 0)) throw new TypeError("maxBytes must be a non-negative number");
+		let bytesRead = 0;
+		super({ transform: (chunk, ctrl) => {
+			if ((bytesRead += chunk.length) <= maxBytes) ctrl.enqueue(chunk);
+			else ctrl.error(/* @__PURE__ */ new Error("Response too large"));
+		} });
+	}
+};
+//#endregion
+exports.MaxBytesTransformStream = MaxBytesTransformStream;
+exports.bytesToStream = bytesToStream;

package/_internal/streams.js

@@ -0,0 +1,36 @@
+//#region src/_internal/streams.ts
+/**
+* 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.
+*/
+function bytesToStream(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+/**
+* 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.
+*/
+var MaxBytesTransformStream = class extends TransformStream {
+	constructor(maxBytes) {
+		if (!(maxBytes >= 0)) throw new TypeError("maxBytes must be a non-negative number");
+		let bytesRead = 0;
+		super({ transform: (chunk, ctrl) => {
+			if ((bytesRead += chunk.length) <= maxBytes) ctrl.enqueue(chunk);
+			else ctrl.error(/* @__PURE__ */ new Error("Response too large"));
+		} });
+	}
+};
+//#endregion
+export { MaxBytesTransformStream, bytesToStream };

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;