@hono/node-server 1.19.10 → 2.0.0-rc.1

package/dist/listener-Brd4yZ5d.js

@@ -0,0 +1,726 @@
+const require_constants = require('./constants-B7DBcQew.js');
+let node_http2 = require("node:http2");
+let node_stream = require("node:stream");
+
+//#region src/error.ts
+var RequestError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "RequestError";
+	}
+};
+
+//#endregion
+//#region src/url.ts
+const isPathDelimiter = (charCode) => charCode === 47 || charCode === 63 || charCode === 35;
+const hasDotSegment = (url, dotIndex) => {
+	if ((dotIndex === 0 ? 47 : url.charCodeAt(dotIndex - 1)) !== 47) return false;
+	const nextIndex = dotIndex + 1;
+	if (nextIndex === url.length) return true;
+	const next = url.charCodeAt(nextIndex);
+	if (isPathDelimiter(next)) return true;
+	if (next !== 46) return false;
+	const nextNextIndex = dotIndex + 2;
+	if (nextNextIndex === url.length) return true;
+	return isPathDelimiter(url.charCodeAt(nextNextIndex));
+};
+const allowedRequestUrlChar = new Uint8Array(128);
+for (let c = 48; c <= 57; c++) allowedRequestUrlChar[c] = 1;
+for (let c = 65; c <= 90; c++) allowedRequestUrlChar[c] = 1;
+for (let c = 97; c <= 122; c++) allowedRequestUrlChar[c] = 1;
+(() => {
+	const chars = "-./:?#[]@!$&'()*+,;=~_";
+	for (let i = 0; i < 22; i++) allowedRequestUrlChar[chars.charCodeAt(i)] = 1;
+})();
+const safeHostChar = new Uint8Array(128);
+for (let c = 48; c <= 57; c++) safeHostChar[c] = 1;
+for (let c = 97; c <= 122; c++) safeHostChar[c] = 1;
+(() => {
+	const chars = ".-_:";
+	for (let i = 0; i < 4; i++) safeHostChar[chars.charCodeAt(i)] = 1;
+})();
+const buildUrl = (scheme, host, incomingUrl) => {
+	const url = `${scheme}://${host}${incomingUrl}`;
+	let needsHostValidationByURL = false;
+	for (let i = 0, len = host.length; i < len; i++) {
+		const c = host.charCodeAt(i);
+		if (c > 127 || safeHostChar[c] === 0) {
+			needsHostValidationByURL = true;
+			break;
+		}
+		if (c === 58) {
+			i++;
+			const firstDigit = host.charCodeAt(i);
+			if (firstDigit < 49 || firstDigit > 57 || i + 4 > len || i + (firstDigit < 54 ? 5 : 4) < len) {
+				needsHostValidationByURL = true;
+				break;
+			}
+			for (; i < len; i++) {
+				const c = host.charCodeAt(i);
+				if (c < 48 || c > 57) {
+					needsHostValidationByURL = true;
+					break;
+				}
+			}
+		}
+	}
+	if (needsHostValidationByURL) {
+		const urlObj = new URL(url);
+		if (urlObj.hostname.length !== host.length && urlObj.hostname !== (host.includes(":") ? host.replace(/:\d+$/, "") : host).toLowerCase()) throw new RequestError("Invalid host header");
+		return urlObj.href;
+	} else if (incomingUrl.length === 0) return url + "/";
+	else {
+		if (incomingUrl.charCodeAt(0) !== 47) throw new RequestError("Invalid URL");
+		for (let i = 1, len = incomingUrl.length; i < len; i++) {
+			const c = incomingUrl.charCodeAt(i);
+			if (c > 127 || allowedRequestUrlChar[c] === 0 || c === 46 && hasDotSegment(incomingUrl, i)) return new URL(url).href;
+		}
+		return url;
+	}
+};
+
+//#endregion
+//#region src/request.ts
+const toRequestError = (e) => {
+	if (e instanceof RequestError) return e;
+	return new RequestError(e.message, { cause: e });
+};
+const GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+	constructor(input, options) {
+		if (typeof input === "object" && getRequestCache in input) {
+			const hasReplacementBody = options !== void 0 && "body" in options && options.body != null;
+			if (input[bodyConsumedDirectlyKey] && !hasReplacementBody) throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
+			input = input[getRequestCache]();
+		}
+		if (typeof (options?.body)?.getReader !== "undefined") options.duplex ??= "half";
+		super(input, options);
+	}
+};
+const newHeadersFromIncoming = (incoming) => {
+	const headerRecord = [];
+	const rawHeaders = incoming.rawHeaders;
+	for (let i = 0; i < rawHeaders.length; i += 2) {
+		const { [i]: key, [i + 1]: value } = rawHeaders;
+		if (key.charCodeAt(0) !== 58) headerRecord.push([key, value]);
+	}
+	return new Headers(headerRecord);
+};
+const wrapBodyStream = Symbol("wrapBodyStream");
+const newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+	const init = {
+		method,
+		headers,
+		signal: abortController.signal
+	};
+	if (method === "TRACE") {
+		init.method = "GET";
+		const req = new Request(url, init);
+		Object.defineProperty(req, "method", { get() {
+			return "TRACE";
+		} });
+		return req;
+	}
+	if (!(method === "GET" || method === "HEAD")) if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) init.body = new ReadableStream({ start(controller) {
+		controller.enqueue(incoming.rawBody);
+		controller.close();
+	} });
+	else if (incoming[wrapBodyStream]) {
+		let reader;
+		init.body = new ReadableStream({ async pull(controller) {
+			try {
+				reader ||= node_stream.Readable.toWeb(incoming).getReader();
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			} catch (error) {
+				controller.error(error);
+			}
+		} });
+	} else init.body = node_stream.Readable.toWeb(incoming);
+	return new Request(url, init);
+};
+const getRequestCache = Symbol("getRequestCache");
+const requestCache = Symbol("requestCache");
+const incomingKey = Symbol("incomingKey");
+const urlKey = Symbol("urlKey");
+const methodKey = Symbol("methodKey");
+const headersKey = Symbol("headersKey");
+const abortControllerKey = Symbol("abortControllerKey");
+const getAbortController = Symbol("getAbortController");
+const abortRequest = Symbol("abortRequest");
+const bodyBufferKey = Symbol("bodyBuffer");
+const bodyReadPromiseKey = Symbol("bodyReadPromise");
+const bodyConsumedDirectlyKey = Symbol("bodyConsumedDirectly");
+const bodyLockReaderKey = Symbol("bodyLockReader");
+const abortReasonKey = Symbol("abortReason");
+const newBodyUnusableError = () => {
+	return /* @__PURE__ */ new TypeError("Body is unusable");
+};
+const rejectBodyUnusable = () => {
+	return Promise.reject(newBodyUnusableError());
+};
+const textDecoder = new TextDecoder();
+const consumeBodyDirectOnce = (request) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	request[bodyConsumedDirectlyKey] = true;
+};
+const toArrayBuffer = (buf) => {
+	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+};
+const contentType = (request) => {
+	return (request[headersKey] ||= newHeadersFromIncoming(request[incomingKey])).get("content-type") || "";
+};
+const methodTokenRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const normalizeIncomingMethod = (method) => {
+	if (typeof method !== "string" || method.length === 0) return "GET";
+	switch (method) {
+		case "DELETE":
+		case "GET":
+		case "HEAD":
+		case "OPTIONS":
+		case "POST":
+		case "PUT": return method;
+	}
+	const upper = method.toUpperCase();
+	switch (upper) {
+		case "DELETE":
+		case "GET":
+		case "HEAD":
+		case "OPTIONS":
+		case "POST":
+		case "PUT": return upper;
+		default: return method;
+	}
+};
+const validateDirectReadMethod = (method) => {
+	if (!methodTokenRegExp.test(method)) return /* @__PURE__ */ new TypeError(`'${method}' is not a valid HTTP method.`);
+	const normalized = method.toUpperCase();
+	if (normalized === "CONNECT" || normalized === "TRACK" || normalized === "TRACE" && method !== "TRACE") return /* @__PURE__ */ new TypeError(`'${method}' HTTP method is unsupported.`);
+};
+const readBodyWithFastPath = (request, method, fromBuffer) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	const methodName = request.method;
+	if (methodName === "GET" || methodName === "HEAD") return request[getRequestCache]()[method]();
+	const methodValidationError = validateDirectReadMethod(methodName);
+	if (methodValidationError) return Promise.reject(methodValidationError);
+	if (request[requestCache]) {
+		if (methodName !== "TRACE") return request[requestCache][method]();
+	}
+	const alreadyUsedError = consumeBodyDirectOnce(request);
+	if (alreadyUsedError) return alreadyUsedError;
+	const raw = readRawBodyIfAvailable(request);
+	if (raw) {
+		const result = Promise.resolve(fromBuffer(raw, request));
+		request[bodyBufferKey] = void 0;
+		return result;
+	}
+	return readBodyDirect(request).then((buf) => {
+		const result = fromBuffer(buf, request);
+		request[bodyBufferKey] = void 0;
+		return result;
+	});
+};
+const readRawBodyIfAvailable = (request) => {
+	const incoming = request[incomingKey];
+	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
+};
+const readBodyDirect = (request) => {
+	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
+	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
+	const incoming = request[incomingKey];
+	if (node_stream.Readable.isDisturbed(incoming)) return rejectBodyUnusable();
+	const promise = new Promise((resolve, reject) => {
+		const chunks = [];
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const onData = (chunk) => {
+			chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		};
+		const onEnd = () => {
+			finish(() => {
+				const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+				request[bodyBufferKey] = buffer;
+				resolve(buffer);
+			});
+		};
+		const onError = (error) => {
+			finish(() => {
+				reject(error);
+			});
+		};
+		const onClose = () => {
+			if (incoming.readableEnded) {
+				onEnd();
+				return;
+			}
+			finish(() => {
+				if (incoming.errored) {
+					reject(incoming.errored);
+					return;
+				}
+				const reason = request[abortReasonKey];
+				if (reason !== void 0) {
+					reject(reason instanceof Error ? reason : new Error(String(reason)));
+					return;
+				}
+				reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+			});
+		};
+		const cleanup = () => {
+			incoming.off("data", onData);
+			incoming.off("end", onEnd);
+			incoming.off("error", onError);
+			incoming.off("close", onClose);
+			request[bodyReadPromiseKey] = void 0;
+		};
+		incoming.on("data", onData);
+		incoming.on("end", onEnd);
+		incoming.on("error", onError);
+		incoming.on("close", onClose);
+		queueMicrotask(() => {
+			if (settled) return;
+			if (incoming.readableEnded) onEnd();
+			else if (incoming.errored) onError(incoming.errored);
+			else if (incoming.destroyed) onClose();
+		});
+	});
+	request[bodyReadPromiseKey] = promise;
+	return promise;
+};
+const requestPrototype = {
+	get method() {
+		return this[methodKey];
+	},
+	get url() {
+		return this[urlKey];
+	},
+	get headers() {
+		return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+	},
+	[abortRequest](reason) {
+		if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason;
+		const abortController = this[abortControllerKey];
+		if (abortController && !abortController.signal.aborted) abortController.abort(reason);
+	},
+	[getAbortController]() {
+		this[abortControllerKey] ||= new AbortController();
+		if (this[abortReasonKey] !== void 0 && !this[abortControllerKey].signal.aborted) this[abortControllerKey].abort(this[abortReasonKey]);
+		return this[abortControllerKey];
+	},
+	[getRequestCache]() {
+		const abortController = this[getAbortController]();
+		if (this[requestCache]) return this[requestCache];
+		const method = this.method;
+		if (this[bodyConsumedDirectlyKey] && !(method === "GET" || method === "HEAD")) {
+			this[bodyBufferKey] = void 0;
+			const init = {
+				method: method === "TRACE" ? "GET" : method,
+				headers: this.headers,
+				signal: abortController.signal
+			};
+			if (method !== "TRACE") {
+				init.body = new ReadableStream({ start(c) {
+					c.close();
+				} });
+				init.duplex = "half";
+			}
+			const req = new Request(this[urlKey], init);
+			if (method === "TRACE") Object.defineProperty(req, "method", { get() {
+				return "TRACE";
+			} });
+			return this[requestCache] = req;
+		}
+		return this[requestCache] = newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], abortController);
+	},
+	get body() {
+		if (!this[bodyConsumedDirectlyKey]) return this[getRequestCache]().body;
+		const request = this[getRequestCache]();
+		if (!this[bodyLockReaderKey] && request.body) this[bodyLockReaderKey] = request.body.getReader();
+		return request.body;
+	},
+	get bodyUsed() {
+		if (this[bodyConsumedDirectlyKey]) return true;
+		if (this[requestCache]) return this[requestCache].bodyUsed;
+		return false;
+	}
+};
+[
+	"cache",
+	"credentials",
+	"destination",
+	"integrity",
+	"mode",
+	"redirect",
+	"referrer",
+	"referrerPolicy",
+	"signal",
+	"keepalive"
+].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { get() {
+		return this[getRequestCache]()[k];
+	} });
+});
+["clone", "formData"].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { value: function() {
+		if (this[bodyConsumedDirectlyKey]) {
+			if (k === "clone") throw newBodyUnusableError();
+			return rejectBodyUnusable();
+		}
+		return this[getRequestCache]()[k]();
+	} });
+});
+Object.defineProperty(requestPrototype, "text", { value: function() {
+	return readBodyWithFastPath(this, "text", (buf) => textDecoder.decode(buf));
+} });
+Object.defineProperty(requestPrototype, "arrayBuffer", { value: function() {
+	return readBodyWithFastPath(this, "arrayBuffer", (buf) => toArrayBuffer(buf));
+} });
+Object.defineProperty(requestPrototype, "blob", { value: function() {
+	return readBodyWithFastPath(this, "blob", (buf, request) => {
+		const type = contentType(request);
+		const init = type ? { headers: { "content-type": type } } : void 0;
+		return new Response(buf, init).blob();
+	});
+} });
+Object.defineProperty(requestPrototype, "json", { value: function() {
+	if (this[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	return this.text().then(JSON.parse);
+} });
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+const newRequest = (incoming, defaultHostname) => {
+	const req = Object.create(requestPrototype);
+	req[incomingKey] = incoming;
+	req[methodKey] = normalizeIncomingMethod(incoming.method);
+	const incomingUrl = incoming.url || "";
+	if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+		if (incoming instanceof node_http2.Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+		try {
+			req[urlKey] = new URL(incomingUrl).href;
+		} catch (e) {
+			throw new RequestError("Invalid absolute URL", { cause: e });
+		}
+		return req;
+	}
+	const host = (incoming instanceof node_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+	if (!host) throw new RequestError("Missing host header");
+	let scheme;
+	if (incoming instanceof node_http2.Http2ServerRequest) {
+		scheme = incoming.scheme;
+		if (!(scheme === "http" || scheme === "https")) throw new RequestError("Unsupported scheme");
+	} else scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+	try {
+		req[urlKey] = buildUrl(scheme, host, incomingUrl);
+	} catch (e) {
+		if (e instanceof RequestError) throw e;
+		else throw new RequestError("Invalid URL", { cause: e });
+	}
+	return req;
+};
+
+//#endregion
+//#region src/response.ts
+const responseCache = Symbol("responseCache");
+const getResponseCache = Symbol("getResponseCache");
+const cacheKey = Symbol("cache");
+const GlobalResponse = global.Response;
+var Response$1 = class Response$1 {
+	#body;
+	#init;
+	[getResponseCache]() {
+		delete this[cacheKey];
+		return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+	}
+	constructor(body, init) {
+		let headers;
+		this.#body = body;
+		if (init instanceof Response$1) {
+			const cachedGlobalResponse = init[responseCache];
+			if (cachedGlobalResponse) {
+				this.#init = cachedGlobalResponse;
+				this[getResponseCache]();
+				return;
+			} else {
+				this.#init = init.#init;
+				headers = new Headers(init.#init.headers);
+			}
+		} else this.#init = init;
+		if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+			init?.status || 200,
+			body,
+			headers || init?.headers
+		];
+	}
+	get headers() {
+		const cache = this[cacheKey];
+		if (cache) {
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
+			return cache[2];
+		}
+		return this[getResponseCache]().headers;
+	}
+	get status() {
+		return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+	}
+	get ok() {
+		const status = this.status;
+		return status >= 200 && status < 300;
+	}
+};
+[
+	"body",
+	"bodyUsed",
+	"redirected",
+	"statusText",
+	"trailers",
+	"type",
+	"url"
+].forEach((k) => {
+	Object.defineProperty(Response$1.prototype, k, { get() {
+		return this[getResponseCache]()[k];
+	} });
+});
+[
+	"arrayBuffer",
+	"blob",
+	"clone",
+	"formData",
+	"json",
+	"text"
+].forEach((k) => {
+	Object.defineProperty(Response$1.prototype, k, { value: function() {
+		return this[getResponseCache]()[k]();
+	} });
+});
+Object.setPrototypeOf(Response$1, GlobalResponse);
+Object.setPrototypeOf(Response$1.prototype, GlobalResponse.prototype);
+
+//#endregion
+//#region src/utils.ts
+async function readWithoutBlocking(readPromise) {
+	return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+	const cancel = (error) => {
+		reader.cancel(error).catch(() => {});
+	};
+	writable.on("close", cancel);
+	writable.on("error", cancel);
+	(currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+	return reader.closed.finally(() => {
+		writable.off("close", cancel);
+		writable.off("error", cancel);
+	});
+	function handleStreamError(error) {
+		if (error) writable.destroy(error);
+	}
+	function onDrain() {
+		reader.read().then(flow, handleStreamError);
+	}
+	function flow({ done, value }) {
+		try {
+			if (done) writable.end();
+			else if (!writable.write(value)) writable.once("drain", onDrain);
+			else return reader.read().then(flow, handleStreamError);
+		} catch (e) {
+			handleStreamError(e);
+		}
+	}
+}
+function writeFromReadableStream(stream, writable) {
+	if (stream.locked) throw new TypeError("ReadableStream is locked.");
+	else if (writable.destroyed) return;
+	return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+const buildOutgoingHttpHeaders = (headers) => {
+	const res = {};
+	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
+	if (headers.has("set-cookie")) {
+		const cookies = [];
+		for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
+		else res[k] = v;
+		if (cookies.length > 0) res["set-cookie"] = cookies;
+	} else for (const [k, v] of headers) res[k] = v;
+	res["content-type"] ??= "text/plain; charset=UTF-8";
+	return res;
+};
+
+//#endregion
+//#region src/listener.ts
+const outgoingEnded = Symbol("outgoingEnded");
+const handleRequestError = () => new Response(null, { status: 400 });
+const handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
+const handleResponseError = (e, outgoing) => {
+	const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+	if (err.code === "ERR_STREAM_PREMATURE_CLOSE") console.info("The user aborted a request.");
+	else {
+		console.error(e);
+		if (!outgoing.headersSent) outgoing.writeHead(500, { "Content-Type": "text/plain" });
+		outgoing.end(`Error: ${err.message}`);
+		outgoing.destroy(err);
+	}
+};
+const flushHeaders = (outgoing) => {
+	if ("flushHeaders" in outgoing && outgoing.writable) outgoing.flushHeaders();
+};
+const responseViaCache = async (res, outgoing) => {
+	let [status, body, header] = res[cacheKey];
+	let hasContentLength = false;
+	if (!header) header = { "content-type": "text/plain; charset=UTF-8" };
+	else if (header instanceof Headers) {
+		hasContentLength = header.has("content-length");
+		header = buildOutgoingHttpHeaders(header);
+	} else if (Array.isArray(header)) {
+		const headerObj = new Headers(header);
+		hasContentLength = headerObj.has("content-length");
+		header = buildOutgoingHttpHeaders(headerObj);
+	} else for (const key in header) if (key.length === 14 && key.toLowerCase() === "content-length") {
+		hasContentLength = true;
+		break;
+	}
+	if (!hasContentLength) {
+		if (typeof body === "string") header["Content-Length"] = Buffer.byteLength(body);
+		else if (body instanceof Uint8Array) header["Content-Length"] = body.byteLength;
+		else if (body instanceof Blob) header["Content-Length"] = body.size;
+	}
+	outgoing.writeHead(status, header);
+	if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
+	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
+	else {
+		flushHeaders(outgoing);
+		await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+	}
+	outgoing[outgoingEnded]?.();
+};
+const isPromise = (res) => typeof res.then === "function";
+const responseViaResponseObject = async (res, outgoing, options = {}) => {
+	if (isPromise(res)) if (options.errorHandler) try {
+		res = await res;
+	} catch (err) {
+		const errRes = await options.errorHandler(err);
+		if (!errRes) return;
+		res = errRes;
+	}
+	else res = await res.catch(handleFetchError);
+	if (cacheKey in res) return responseViaCache(res, outgoing);
+	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+	if (res.body) {
+		const reader = res.body.getReader();
+		const values = [];
+		let done = false;
+		let currentReadPromise = void 0;
+		if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+			let maxReadCount = 2;
+			for (let i = 0; i < maxReadCount; i++) {
+				currentReadPromise ||= reader.read();
+				const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+					console.error(e);
+					done = true;
+				});
+				if (!chunk) {
+					if (i === 1) {
+						await new Promise((resolve) => setTimeout(resolve));
+						maxReadCount = 3;
+						continue;
+					}
+					break;
+				}
+				currentReadPromise = void 0;
+				if (chunk.value) values.push(chunk.value);
+				if (chunk.done) {
+					done = true;
+					break;
+				}
+			}
+			if (done && !("content-length" in resHeaderRecord)) resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+		}
+		outgoing.writeHead(res.status, resHeaderRecord);
+		values.forEach((value) => {
+			outgoing.write(value);
+		});
+		if (done) outgoing.end();
+		else {
+			if (values.length === 0) flushHeaders(outgoing);
+			await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+		}
+	} else if (resHeaderRecord[require_constants.X_ALREADY_SENT]) {} else {
+		outgoing.writeHead(res.status, resHeaderRecord);
+		outgoing.end();
+	}
+	outgoing[outgoingEnded]?.();
+};
+const getRequestListener = (fetchCallback, options = {}) => {
+	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+	if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+		Object.defineProperty(global, "Request", { value: Request });
+		Object.defineProperty(global, "Response", { value: Response$1 });
+	}
+	return async (incoming, outgoing) => {
+		let res, req;
+		try {
+			req = newRequest(incoming, options.hostname);
+			let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+			if (!incomingEnded) {
+				incoming[wrapBodyStream] = true;
+				incoming.on("end", () => {
+					incomingEnded = true;
+				});
+				if (incoming instanceof node_http2.Http2ServerRequest) outgoing[outgoingEnded] = () => {
+					if (!incomingEnded) setTimeout(() => {
+						if (!incomingEnded) setTimeout(() => {
+							incoming.destroy();
+							outgoing.destroy();
+						});
+					});
+				};
+			}
+			outgoing.on("close", () => {
+				let abortReason;
+				if (incoming.errored) abortReason = incoming.errored.toString();
+				else if (!outgoing.writableFinished) abortReason = "Client connection prematurely closed.";
+				if (abortReason !== void 0) req[abortRequest](abortReason);
+				if (!incomingEnded) setTimeout(() => {
+					if (!incomingEnded) setTimeout(() => {
+						incoming.destroy();
+					});
+				});
+			});
+			res = fetchCallback(req, {
+				incoming,
+				outgoing
+			});
+			if (cacheKey in res) return responseViaCache(res, outgoing);
+		} catch (e) {
+			if (!res) if (options.errorHandler) {
+				res = await options.errorHandler(req ? e : toRequestError(e));
+				if (!res) return;
+			} else if (!req) res = handleRequestError();
+			else res = handleFetchError(e);
+			else return handleResponseError(e, outgoing);
+		}
+		try {
+			return await responseViaResponseObject(res, outgoing, options);
+		} catch (e) {
+			return handleResponseError(e, outgoing);
+		}
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'RequestError', {
+  enumerable: true,
+  get: function () {
+    return RequestError;
+  }
+});
+Object.defineProperty(exports, 'getRequestListener', {
+  enumerable: true,
+  get: function () {
+    return getRequestListener;
+  }
+});