nitro 3.0.260311-beta → 3.0.260415-beta

package/dist/_libs/httpxy.mjs

@@ -1,10 +1,28 @@
 import { EventEmitter } from "node:events";
 import { Readable } from "node:stream";
 import http, { request } from "node:http";
-import nodeHTTPS, { request as request$1 } from "node:https";
-//#region node_modules/.pnpm/httpxy@0.3.1/node_modules/httpxy/dist/index.mjs
+import https, { request as request$1 } from "node:https";
+import http2 from "node:http2";
 const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+const defaultAgents = {
+	http: new http.Agent({
+		keepAlive: true,
+		maxSockets: 256,
+		maxFreeSockets: 64
+	}),
+	https: new https.Agent({
+		keepAlive: true,
+		maxSockets: 256,
+		maxFreeSockets: 64
+	})
+};
 const isSSL = /^https|wss/;
+const HTTP2_HEADER_BLACKLIST = [
+	":method",
+	":path",
+	":scheme",
+	":authority"
+];
 function setupOutgoing(outgoing, options, req, forward) {
 	outgoing.port = options[forward || "target"].port || (isSSL.test(options[forward || "target"].protocol ?? "http") ? 443 : 80);
 	for (const e of [
@@ -18,17 +36,24 @@ function setupOutgoing(outgoing, options, req, forward) {
 		"ca",
 		"ciphers",
 		"secureProtocol"
-	]) outgoing[e] = options[forward || "target"][e];
+	]) {
+		const value = options[forward || "target"][e];
+		if (value !== void 0) outgoing[e] = value;
+	}
 	outgoing.method = options.method || req.method;
 	outgoing.headers = { ...req.headers };
-	if (options.headers) outgoing.headers = {
-		...outgoing.headers,
-		...options.headers
-	};
+	if (req.headers?.[":authority"]) outgoing.headers.host = req.headers[":authority"];
+	if (options.headers) for (const key of Object.keys(options.headers)) outgoing.headers[key] = options.headers[key];
+	if (req.httpVersionMajor > 1) for (const header of HTTP2_HEADER_BLACKLIST) delete outgoing.headers[header];
 	if (options.auth) outgoing.auth = options.auth;
 	if (options.ca) outgoing.ca = options.ca;
 	if (isSSL.test(options[forward || "target"].protocol ?? "http")) outgoing.rejectUnauthorized = options.secure === void 0 ? true : options.secure;
-	outgoing.agent = options.agent || false;
+	if (options.agent !== void 0) outgoing.agent = options.agent || false;
+	else if (req.httpVersionMajor > 1) outgoing.agent = false;
+	else {
+		const targetProto = options[forward || "target"].protocol ?? "http";
+		outgoing.agent = isSSL.test(targetProto) ? defaultAgents.https : defaultAgents.http;
+	}
 	outgoing.localAddress = options.localAddress;
 	if (!outgoing.agent) {
 		outgoing.headers = outgoing.headers || {};
@@ -36,6 +61,7 @@ function setupOutgoing(outgoing, options, req, forward) {
 	}
 	const target = options[forward || "target"];
 	const targetPath = target && options.prependPath !== false ? target.pathname || "" : "";
+	const targetSearch = target instanceof URL && options.prependPath !== false ? target.search || "" : "";
 	const reqUrl = req.url || "";
 	const qIdx = reqUrl.indexOf("?");
 	const reqPath = qIdx === -1 ? reqUrl : reqUrl.slice(0, qIdx);
@@ -43,7 +69,9 @@ function setupOutgoing(outgoing, options, req, forward) {
 	const normalizedPath = reqPath ? reqPath[0] === "/" ? reqPath : "/" + reqPath : "/";
 	let outgoingPath = options.toProxy ? "/" + reqUrl : normalizedPath + reqSearch;
 	outgoingPath = options.ignorePath ? "" : outgoingPath;
-	outgoing.path = joinURL(targetPath, outgoingPath);
+	let fullPath = joinURL(targetPath, outgoingPath);
+	if (targetSearch) fullPath = fullPath.includes("?") ? fullPath.replace("?", targetSearch + "&") : fullPath + targetSearch;
+	outgoing.path = fullPath;
 	if (options.changeOrigin) outgoing.headers.host = requiresPort(outgoing.port, options[forward || "target"].protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host ?? void 0;
 	return outgoing;
 }
@@ -63,12 +91,14 @@ function setupSocket(socket) {
 	return socket;
 }
 function getPort(req) {
-	const res = req.headers.host ? req.headers.host.match(/:(\d+)/) : "";
+	const hostHeader = req.headers[":authority"] || req.headers.host;
+	const res = hostHeader ? hostHeader.match(/:(\d+)/) : "";
 	if (res) return res[1];
 	return hasEncryptedConnection(req) ? "443" : "80";
 }
 function hasEncryptedConnection(req) {
-	return Boolean(req.connection.encrypted || req.connection.pair);
+	const socket = req.socket;
+	return !!socket && "encrypted" in socket && socket.encrypted;
 }
 function rewriteCookieProperty(header, config, property) {
 	if (Array.isArray(header)) return header.map(function(headerElement) {
@@ -118,22 +148,26 @@ function defineProxyMiddleware(m) {
 function defineProxyOutgoingMiddleware(m) {
 	return m;
 }
-const redirectRegex = /^201|30([1278])$/;
+const redirectRegex = /^201|30([12378])$/;
 const webOutgoingMiddleware = [
 	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
-		if (req.httpVersion === "1.0") delete proxyRes.headers["transfer-encoding"];
+		if (req.httpVersion === "1.0" || req.httpVersionMajor >= 2 || proxyRes.statusCode === 204 || proxyRes.statusCode === 304) delete proxyRes.headers["transfer-encoding"];
 	}),
 	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
 		if (req.httpVersion === "1.0") proxyRes.headers.connection = req.headers.connection || "close";
-		else if (req.httpVersion !== "2.0" && !proxyRes.headers.connection) proxyRes.headers.connection = req.headers.connection || "keep-alive";
+		else if (req.httpVersionMajor < 2 && !proxyRes.headers.connection) proxyRes.headers.connection = req.headers.connection || "keep-alive";
+		else if (req.httpVersionMajor >= 2) delete proxyRes.headers.connection;
 	}),
 	defineProxyOutgoingMiddleware((req, res, proxyRes, options) => {
 		if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers.location && redirectRegex.test(String(proxyRes.statusCode))) {
-			const target = options.target instanceof URL ? options.target : new URL(options.target);
-			const u = new URL(proxyRes.headers.location);
+			const target = _toURL(options.target);
+			const u = new URL(proxyRes.headers.location, target);
 			if (target.host !== u.host) return;
 			if (options.hostRewrite) u.host = options.hostRewrite;
-			else if (options.autoRewrite && req.headers.host) u.host = req.headers.host;
+			else if (options.autoRewrite) {
+				if (req.headers[":authority"]) u.host = req.headers[":authority"];
+				else if (req.headers.host) u.host = req.headers.host;
+			}
 			if (options.protocolRewrite) u.protocol = options.protocolRewrite;
 			proxyRes.headers.location = u.toString();
 		}
@@ -144,10 +178,12 @@ const webOutgoingMiddleware = [
 		const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
 		let rawHeaderKeyMap;
 		const setHeader = function(key, header) {
-			if (header === void 0) return;
+			if (header === void 0 || !String(key).trim()) return;
 			if (rewriteCookieDomainConfig && key.toLowerCase() === "set-cookie") header = rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
 			if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") header = rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
-			res.setHeader(String(key).trim(), header);
+			try {
+				res.setHeader(String(key).trim(), header);
+			} catch {}
 		};
 		if (preserveHeaderKeyCase && proxyRes.rawHeaders !== void 0) {
 			rawHeaderKeyMap = {};
@@ -163,17 +199,23 @@ const webOutgoingMiddleware = [
 		}
 	}),
 	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
-		if (proxyRes.statusMessage) {
-			res.statusCode = proxyRes.statusCode;
-			res.statusMessage = proxyRes.statusMessage;
-		} else res.statusCode = proxyRes.statusCode;
+		res.statusCode = proxyRes.statusCode;
+		if (proxyRes.statusMessage && req.httpVersionMajor < 2) res.statusMessage = proxyRes.statusMessage;
 	})
 ];
+function _toURL(target) {
+	if (target instanceof URL) return target;
+	if (typeof target === "string") return new URL(target);
+	const protocol = target.protocol || "http:";
+	const host = target.host || target.hostname || "localhost";
+	const port = target.port;
+	return new URL(`${protocol}//${host}${port ? ":" + port : ""}`);
+}
 const nativeAgents = {
 	http,
-	https: nodeHTTPS
+	https
 };
-const redirectStatuses = /* @__PURE__ */ new Set([
+const redirectStatuses = new Set([
 	301,
 	302,
 	303,
@@ -204,8 +246,11 @@ const webIncomingMiddleware = [
 			"for",
 			"port",
 			"proto"
-		]) req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
-		req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers.host || "";
+		]) {
+			const key = "x-forwarded-" + header;
+			if (!req.headers[key]) req.headers[key] = values[header];
+		}
+		req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers.host || "";
 	}),
 	defineProxyMiddleware((req, res, options, server, head, callback) => {
 		server.emit("start", req, res, options.target || options.forward);
@@ -213,7 +258,7 @@ const webIncomingMiddleware = [
 		const https = nativeAgents.https;
 		const maxRedirects = typeof options.followRedirects === "number" ? options.followRedirects : options.followRedirects ? 5 : 0;
 		if (options.forward) {
-			const forwardReq = (options.forward.protocol === "https:" ? https : http).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
+			const forwardReq = (isSSL.test(options.forward.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
 			const forwardError = createErrorHandler(forwardReq, options.forward);
 			req.on("error", forwardError);
 			forwardReq.on("error", forwardError);
@@ -223,15 +268,12 @@ const webIncomingMiddleware = [
 				return;
 			}
 		}
-		const proxyReq = (options.target.protocol === "https:" ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
+		const proxyReq = (isSSL.test(options.target.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
 		proxyReq.on("socket", (_socket) => {
 			if (server && !proxyReq.getHeader("expect")) server.emit("proxyReq", proxyReq, req, res, options);
 		});
 		if (options.proxyTimeout) proxyReq.setTimeout(options.proxyTimeout, function() {
-			proxyReq.abort();
-		});
-		req.on("aborted", function() {
-			proxyReq.abort();
+			proxyReq.destroy();
 		});
 		res.on("close", function() {
 			if (!res.writableFinished) proxyReq.destroy();
@@ -239,11 +281,11 @@ const webIncomingMiddleware = [
 		const proxyError = createErrorHandler(proxyReq, options.target);
 		req.on("error", proxyError);
 		proxyReq.on("error", proxyError);
-		function createErrorHandler(proxyReq2, url) {
-			return function proxyError2(err) {
-				if (req.socket.destroyed && err.code === "ECONNRESET") {
+		function createErrorHandler(proxyReq, url) {
+			return function proxyError(err) {
+				if (!req.socket?.writable && err.code === "ECONNRESET") {
 					server.emit("econnreset", err, req, res, url);
-					return proxyReq2.abort();
+					return proxyReq.destroy();
 				}
 				if (callback) callback(err, req, res, url);
 				else server.emit("error", err, req, res, url);
@@ -264,7 +306,10 @@ const webIncomingMiddleware = [
 			source.on("error", (err) => {
 				proxyReq.destroy(err);
 			});
-		} else (options.buffer || req).pipe(proxyReq);
+		} else proxyReq.on("socket", (socket) => {
+			if (socket.pending) socket.on("connect", () => (options.buffer || req).pipe(proxyReq));
+			else (options.buffer || req).pipe(proxyReq);
+		});
 		function handleResponse(proxyRes, redirectCount, currentUrl) {
 			const statusCode = proxyRes.statusCode;
 			if (maxRedirects > 0 && redirectStatuses.has(statusCode) && redirectCount < maxRedirects && proxyRes.headers.location) {
@@ -272,7 +317,7 @@ const webIncomingMiddleware = [
 				const location = new URL(proxyRes.headers.location, currentUrl);
 				const preserveMethod = statusCode === 307 || statusCode === 308;
 				const redirectMethod = preserveMethod ? req.method || "GET" : "GET";
-				const isHTTPS = location.protocol === "https:";
+				const isHTTPS = isSSL.test(location.protocol);
 				const agent = isHTTPS ? https : http;
 				const redirectHeaders = { ...req.headers };
 				if (options.headers) Object.assign(redirectHeaders, options.headers);
@@ -298,7 +343,7 @@ const webIncomingMiddleware = [
 				const redirectReq = agent.request(redirectOpts);
 				if (server && !redirectReq.getHeader("expect")) server.emit("proxyReq", redirectReq, req, res, options);
 				if (options.proxyTimeout) redirectReq.setTimeout(options.proxyTimeout, () => {
-					redirectReq.abort();
+					redirectReq.destroy();
 				});
 				const redirectError = createErrorHandler(redirectReq, location);
 				redirectReq.on("error", redirectError);
@@ -319,6 +364,13 @@ const webIncomingMiddleware = [
 				res.on("close", function() {
 					proxyRes.destroy();
 				});
+				proxyRes.on("close", function() {
+					if (!proxyRes.complete && !res.destroyed) res.destroy();
+				});
+				proxyRes.on("error", function(err) {
+					if (!res.destroyed) res.destroy(err);
+					if (server.listenerCount("error") > 0) server.emit("error", err, req, res, currentUrl);
+				});
 				proxyRes.on("end", function() {
 					if (server) server.emit("end", req, res, proxyRes);
 				});
@@ -352,37 +404,42 @@ const websocketIncomingMiddleware = [
 			"for",
 			"port",
 			"proto"
-		]) req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
+		]) {
+			const key = "x-forwarded-" + header;
+			if (!req.headers[key]) req.headers[key] = values[header];
+		}
 	}),
 	defineProxyMiddleware((req, socket, options, server, head, callback) => {
 		const createHttpHeader = function(line, headers) {
-			return Object.keys(headers).reduce(function(head2, key) {
+			return Object.keys(headers).reduce(function(head, key) {
 				const value = headers[key];
 				if (!Array.isArray(value)) {
-					head2.push(key + ": " + value);
-					return head2;
+					head.push(key + ": " + value);
+					return head;
 				}
-				for (const element of value) head2.push(key + ": " + element);
-				return head2;
+				for (const element of value) head.push(key + ": " + element);
+				return head;
 			}, [line]).join("\r\n") + "\r\n\r\n";
 		};
 		setupSocket(socket);
 		if (head && head.length > 0) socket.unshift(head);
 		socket.on("error", onSocketError);
-		const proxyReq = (isSSL.test(options.target.protocol || "http") ? nodeHTTPS : http).request(setupOutgoing(options.ssl || {}, options, req));
+		const proxyReq = (isSSL.test(options.target.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
 		if (server) server.emit("proxyReqWs", proxyReq, req, socket, options, head);
 		proxyReq.on("error", onOutgoingError);
 		proxyReq.on("response", function(res) {
-			if (!res.upgrade) {
+			if (!res.upgrade) if (!socket.destroyed && socket.writable) {
 				socket.write(createHttpHeader("HTTP/" + res.httpVersion + " " + res.statusCode + " " + res.statusMessage, res.headers));
+				res.on("error", onOutgoingError);
 				res.pipe(socket);
-			}
+			} else res.resume();
 		});
 		proxyReq.on("upgrade", function(proxyRes, proxySocket, proxyHead) {
 			proxySocket.on("error", onOutgoingError);
 			proxySocket.on("end", function() {
 				server.emit("close", proxyRes, proxySocket, proxyHead);
 			});
+			socket.removeListener("error", onSocketError);
 			socket.on("error", function() {
 				proxySocket.end();
 			});
@@ -413,10 +470,6 @@ var ProxyServer = class extends EventEmitter {
 	options;
 	web;
 	ws;
-	/**
-	* Creates the proxy server with specified options.
-	* @param options - Config object passed to the proxy
-	*/
 	constructor(options = {}) {
 		super();
 		this.options = options || {};
@@ -424,25 +477,24 @@ var ProxyServer = class extends EventEmitter {
 		this.web = _createProxyFn("web", this);
 		this.ws = _createProxyFn("ws", this);
 	}
-	/**
-	* A function that wraps the object in a webserver, for your convenience
-	* @param port - Port to listen on
-	* @param hostname - The hostname to listen on
-	*/
 	listen(port, hostname) {
 		const closure = (req, res) => {
-			this.web(req, res);
+			return this.web(req, res);
 		};
-		this._server = this.options.ssl ? nodeHTTPS.createServer(this.options.ssl, closure) : http.createServer(closure);
+		if (this.options.http2) {
+			if (!this.options.ssl) throw new Error("HTTP/2 requires ssl option");
+			this._server = http2.createSecureServer({
+				...this.options.ssl,
+				allowHTTP1: true
+			}, closure);
+		} else if (this.options.ssl) this._server = https.createServer(this.options.ssl, closure);
+		else this._server = http.createServer(closure);
 		if (this.options.ws) this._server.on("upgrade", (req, socket, head) => {
-			this.ws(req, socket, head).catch(() => {});
+			this.ws(req, socket, this.options, head).catch(() => {});
 		});
 		this._server.listen(port, hostname);
 		return this;
 	}
-	/**
-	* A function that closes the inner webserver and stops listening on given port
-	*/
 	close(callback) {
 		if (this._server) this._server.close((...args) => {
 			this._server = void 0;
@@ -465,7 +517,6 @@ var ProxyServer = class extends EventEmitter {
 		if (i === false) throw new Error("No such pass");
 		passes.splice(i++, 0, pass);
 	}
-	/** @internal */
 	_getPasses(type) {
 		return type === "ws" ? this._wsPasses : this._webPasses;
 	}
@@ -496,20 +547,39 @@ function _createProxyFn(type, server) {
 		res.on("error", (error) => {
 			_reject(error);
 		});
-		for (const pass of server._getPasses(type)) if (pass(req, res, requestOptions, server, head, (error) => {
-			if (server.listenerCount("error") > 0) {
-				server.emit("error", error, req, res);
+		for (const pass of server._getPasses(type)) {
+			let stop;
+			try {
+				stop = pass(req, res, requestOptions, server, head, (error) => {
+					if (server.listenerCount("error") > 0) {
+						server.emit("error", error, req, res);
+						_resolve();
+					} else _reject(error);
+				});
+			} catch (error) {
+				if (server.listenerCount("error") > 0) {
+					server.emit("error", error, req, res);
+					_resolve();
+				} else _reject(error);
+				break;
+			}
+			if (stop) {
 				_resolve();
-			} else _reject(error);
-		})) {
-			_resolve();
-			break;
+				break;
+			}
 		}
 		return callbackPromise;
 	};
 }
-async function proxyFetch(addr, input, inputInit) {
+async function proxyFetch(addr, input, inputInit, opts) {
 	const resolvedAddr = parseAddr(addr);
+	let useHTTPS = false;
+	let addrBasePath = "";
+	if (typeof addr === "string" && !addr.startsWith("unix:")) {
+		const addrURL = new URL(addr);
+		useHTTPS = isSSL.test(addrURL.protocol);
+		if (addrURL.pathname && addrURL.pathname !== "/") addrBasePath = addrURL.pathname;
+	}
 	let url;
 	let init;
 	if (input instanceof Request) {
@@ -527,43 +597,52 @@ async function proxyFetch(addr, input, inputInit) {
 		...init
 	};
 	if (init.body) init.duplex = "half";
-	const path = url.pathname + url.search;
+	const requestPath = url.pathname + url.search;
+	const path = addrBasePath ? joinURL(addrBasePath, requestPath) : requestPath;
 	const reqHeaders = {};
-	if (init.headers) {
-		const h = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
-		for (const [key, value] of h) reqHeaders[key] = value;
+	if (init.headers) if (!(init.headers instanceof Headers) && !Array.isArray(init.headers)) Object.assign(reqHeaders, init.headers);
+	else for (const [key, value] of init.headers) {
+		const existing = reqHeaders[key];
+		if (existing === void 0) reqHeaders[key] = value;
+		else reqHeaders[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
 	}
-	const res = await new Promise((resolve, reject) => {
-		const reqOpts = {
-			method: init.method || "GET",
-			path,
-			headers: reqHeaders
-		};
-		if (resolvedAddr.socketPath) reqOpts.socketPath = resolvedAddr.socketPath;
-		else {
-			reqOpts.hostname = resolvedAddr.host || "localhost";
-			reqOpts.port = resolvedAddr.port;
-		}
-		const req = request(reqOpts, resolve);
-		req.on("error", reject);
-		if (init.body instanceof ReadableStream) {
-			const readable = Readable.fromWeb(init.body);
-			readable.on("error", reject);
-			readable.pipe(req);
-		} else if (init.body) req.end(init.body);
-		else req.end();
+	if (opts?.xfwd) {
+		if (!reqHeaders["x-forwarded-for"]) reqHeaders["x-forwarded-for"] = url.hostname;
+		if (!reqHeaders["x-forwarded-port"]) reqHeaders["x-forwarded-port"] = url.port || (url.protocol === "https:" ? "443" : "80");
+		if (!reqHeaders["x-forwarded-proto"]) reqHeaders["x-forwarded-proto"] = url.protocol.replace(":", "");
+		if (!reqHeaders["x-forwarded-host"]) reqHeaders["x-forwarded-host"] = url.host;
+	}
+	if (opts?.changeOrigin) if (resolvedAddr.socketPath) reqHeaders.host = "localhost";
+	else {
+		const targetHost = resolvedAddr.host || "localhost";
+		const targetPort = resolvedAddr.port;
+		reqHeaders.host = targetPort && targetPort !== (useHTTPS ? 443 : 80) ? `${targetHost}:${targetPort}` : targetHost;
+	}
+	const maxRedirects = typeof opts?.followRedirects === "number" ? opts.followRedirects : opts?.followRedirects ? 5 : 0;
+	const body = maxRedirects > 0 ? await _bufferBody(init.body) : _toNodeStream(init.body);
+	const agent = opts?.agent !== void 0 ? opts.agent || false : useHTTPS ? defaultAgents.https : defaultAgents.http;
+	const res = await _sendRequest(useHTTPS ? request$1 : request, init.method || "GET", path, reqHeaders, resolvedAddr, body, {
+		signal: init.signal || void 0,
+		agent,
+		timeout: opts?.timeout,
+		ssl: opts?.ssl,
+		maxRedirects,
+		redirectCount: 0,
+		originalHeaders: reqHeaders
 	});
-	const headers = new Headers();
-	for (const [key, value] of Object.entries(res.headers)) {
-		if (key === "transfer-encoding" || key === "keep-alive" || key === "connection") continue;
-		if (Array.isArray(value)) for (const v of value) headers.append(key, v);
-		else if (value) headers.set(key, value);
+	const resHeaders = [];
+	const rawHeaders = res.rawHeaders;
+	for (let i = 0; i < rawHeaders.length; i += 2) {
+		const key = rawHeaders[i];
+		const keyLower = key.toLowerCase();
+		if (keyLower === "transfer-encoding" || keyLower === "keep-alive" || keyLower === "connection") continue;
+		resHeaders.push([key, rawHeaders[i + 1]]);
 	}
 	const hasBody = res.statusCode !== 204 && res.statusCode !== 304;
 	return new Response(hasBody ? Readable.toWeb(res) : null, {
 		status: res.statusCode,
 		statusText: res.statusMessage,
-		headers
+		headers: resHeaders
 	});
 }
 function toInit(init) {
@@ -576,8 +655,98 @@ function toInit(init) {
 	};
 	return init;
 }
+function _toNodeStream(body) {
+	if (!body) return;
+	if (typeof body === "string") return Buffer.from(body);
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return Buffer.from(body);
+	if (body instanceof ReadableStream) return Readable.fromWeb(body);
+	if (body instanceof Blob) return Readable.fromWeb(body.stream());
+	return Buffer.from(String(body));
+}
+async function _bufferBody(body) {
+	if (!body) return;
+	if (typeof body === "string") return Buffer.from(body);
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return Buffer.from(body);
+	if (body instanceof ReadableStream) {
+		const readable = Readable.fromWeb(body);
+		const chunks = [];
+		for await (const chunk of readable) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+		return Buffer.concat(chunks);
+	}
+	if (body instanceof Blob) return Buffer.from(await body.arrayBuffer());
+	return Buffer.from(String(body));
+}
+const _redirectStatuses = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+function _sendRequest(doRequest, method, path, headers, addr, body, opts) {
+	return new Promise((resolve, reject) => {
+		const reqOpts = {
+			method,
+			path,
+			headers,
+			agent: opts.agent
+		};
+		if (addr.socketPath) reqOpts.socketPath = addr.socketPath;
+		else {
+			reqOpts.hostname = addr.host || "localhost";
+			reqOpts.port = addr.port;
+		}
+		if (opts.signal) reqOpts.signal = opts.signal;
+		if (opts.ssl) Object.assign(reqOpts, opts.ssl);
+		const req = doRequest(reqOpts, (res) => {
+			const statusCode = res.statusCode;
+			if (opts.maxRedirects > 0 && _redirectStatuses.has(statusCode) && opts.redirectCount < opts.maxRedirects && res.headers.location) {
+				res.resume();
+				const currentURL = new URL(path, `http://${addr.host || "localhost"}:${addr.port || 80}`);
+				const location = new URL(res.headers.location, currentURL);
+				const redirectHTTPS = isSSL.test(location.protocol);
+				const preserveMethod = statusCode === 307 || statusCode === 308;
+				const redirectMethod = preserveMethod ? method : "GET";
+				const redirectHeaders = { ...opts.originalHeaders };
+				redirectHeaders.host = location.host;
+				if (location.host !== currentURL.host) {
+					delete redirectHeaders.authorization;
+					delete redirectHeaders.cookie;
+				}
+				if (!preserveMethod) {
+					delete redirectHeaders["content-length"];
+					delete redirectHeaders["content-type"];
+					delete redirectHeaders["transfer-encoding"];
+				}
+				_sendRequest(redirectHTTPS ? request$1 : request, redirectMethod, location.pathname + location.search, redirectHeaders, {
+					host: location.hostname,
+					port: Number(location.port) || (redirectHTTPS ? 443 : 80)
+				}, preserveMethod ? body : void 0, {
+					...opts,
+					redirectCount: opts.redirectCount + 1
+				}).then(resolve, reject);
+				return;
+			}
+			resolve(res);
+		});
+		req.on("error", reject);
+		if (opts.timeout) req.setTimeout(opts.timeout, () => {
+			req.destroy(/* @__PURE__ */ new Error("Proxy request timed out"));
+		});
+		if (body instanceof Readable) {
+			body.on("error", (err) => {
+				req.destroy(err);
+				reject(err);
+			});
+			body.pipe(req);
+		} else if (body) req.end(body);
+		else req.end();
+	});
+}
 function proxyUpgrade(addr, req, socket, head, opts) {
 	const resolvedAddr = parseAddr(addr);
+	let useSSL = false;
+	if (typeof addr === "string" && !addr.startsWith("unix:")) useSSL = isSSL.test(new URL(addr).protocol);
 	if (req.method !== "GET" || req.headers.upgrade?.toLowerCase() !== "websocket") {
 		socket.destroy();
 		return Promise.reject(/* @__PURE__ */ new Error("Not a valid WebSocket upgrade request"));
@@ -590,7 +759,7 @@ function proxyUpgrade(addr, req, socket, head, opts) {
 		req.headers["x-forwarded-port"] = `${xfPort ? `${xfPort},` : ""}${getPort(req)}`;
 		req.headers["x-forwarded-proto"] = `${xfProto ? `${xfProto},` : ""}${hasEncryptedConnection(req) ? "wss" : "ws"}`;
 	}
-	const target = _buildTargetURL(resolvedAddr);
+	const target = _buildTargetURL(resolvedAddr, useSSL);
 	const requestOptions = {
 		...opts,
 		target,
@@ -607,8 +776,11 @@ function proxyUpgrade(addr, req, socket, head, opts) {
 		proxyReq.once("error", onOutgoingError);
 		proxyReq.once("response", (res) => {
 			if (!res.upgrade) {
-				sock.write(_createHttpHeader(`HTTP/${res.httpVersion} ${res.statusCode} ${res.statusMessage}`, res.headers));
-				res.pipe(sock);
+				if (!sock.destroyed && sock.writable) {
+					sock.write(_createHttpHeader(`HTTP/${res.httpVersion} ${res.statusCode} ${res.statusMessage}`, res.headers));
+					res.on("error", onOutgoingError);
+					res.pipe(sock);
+				} else res.resume();
 				if (!settled) {
 					settled = true;
 					reject(/* @__PURE__ */ new Error("Upstream server did not upgrade the connection"));
@@ -645,27 +817,23 @@ function proxyUpgrade(addr, req, socket, head, opts) {
 		}
 	});
 }
-function _buildTargetURL(addr) {
+function _buildTargetURL(addr, useSSL = false) {
+	const protocol = useSSL ? "https" : "http";
 	if (addr.socketPath) {
-		const url = new URL("http://unix");
+		const url = new URL(`${protocol}://unix`);
 		url.socketPath = addr.socketPath;
 		return url;
 	}
-	return new URL(`http://${addr.host || "localhost"}${addr.port ? `:${addr.port}` : ""}`);
+	return new URL(`${protocol}://${addr.host || "localhost"}${addr.port ? `:${addr.port}` : ""}`);
 }
 function _createHttpHeader(line, headers) {
 	let result = line;
 	for (const key of Object.keys(headers)) {
 		const value = headers[key];
 		if (value === void 0) continue;
-		if (Array.isArray(value)) for (const element of value) result += `\r
-${key}: ${element}`;
-		else result += `\r
-${key}: ${value}`;
+		if (Array.isArray(value)) for (const element of value) result += `\r\n${key}: ${element}`;
+		else result += `\r\n${key}: ${value}`;
 	}
-	return `${result}\r
-\r
-`;
+	return `${result}\r\n\r\n`;
 }
-//#endregion
 export { proxyFetch as n, proxyUpgrade as r, createProxyServer as t };

package/dist/_libs/klona.mjs

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/klona@2.0.6/node_modules/klona/full/index.mjs
 function set(obj, key, val) {
 	if (typeof val.value === "object") val.value = klona(val.value);
 	if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") Object.defineProperty(obj, key, val);
@@ -33,5 +32,4 @@ function klona(x) {
 	}
 	return tmp || x;
 }
-//#endregion
 export { klona as t };