nitro 3.0.1-alpha.2 → 3.0.260311-beta

package/dist/_libs/httpxy.d.mts

@@ -1,11 +1,12 @@
-import http, { IncomingMessage, OutgoingMessage } from "node:http";
 import { EventEmitter } from "node:events";
 import * as stream from "node:stream";
+import http, { IncomingMessage } from "node:http";
+import { Socket } from "node:net";
 
-//#region node_modules/.pnpm/httpxy@0.1.7/node_modules/httpxy/dist/index.d.ts
+//#region node_modules/.pnpm/httpxy@0.3.1/node_modules/httpxy/dist/index.d.ts
 interface ProxyTargetDetailed {
-  host: string;
-  port: number;
+  host?: string;
+  port?: number | string;
   protocol?: string;
   hostname?: string;
   socketPath?: string;
@@ -17,13 +18,13 @@ interface ProxyTargetDetailed {
   ciphers?: string;
   secureProtocol?: string;
 }
-type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
-type ProxyTargetUrl = string | Partial<URL>;
+type ProxyTarget = string | URL | ProxyTargetDetailed;
+/** Resolved proxy address — either TCP (host + port) or Unix socket. */
 interface ProxyServerOptions {
-  /** URL string to be parsed with the url module. */
+  /** URL string to be parsed. */
   target?: ProxyTarget;
-  /** URL string to be parsed with the url module. */
-  forward?: ProxyTargetUrl;
+  /** URL string to be parsed. */
+  forward?: ProxyTarget;
   /** Object to be passed to http(s).request. */
   agent?: any;
   /** Object to be passed to https.createServer(). */
@@ -72,6 +73,8 @@ interface ProxyServerOptions {
   timeout?: number;
   /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
   selfHandleResponse?: boolean;
+  /** Follow HTTP redirects from target. `true` = max 5 hops; number = custom max. */
+  followRedirects?: boolean | number;
   /** Buffer */
   buffer?: stream.Stream;
 }

package/dist/_libs/httpxy.mjs

@@ -1,17 +1,12 @@
-import { n as __exportAll } from "../_common.mjs";
-import http from "node:http";
-import https from "node:https";
 import { EventEmitter } from "node:events";
-
-//#region node_modules/.pnpm/httpxy@0.1.7/node_modules/httpxy/dist/index.mjs
-var dist_exports = /* @__PURE__ */ __exportAll({
-	ProxyServer: () => ProxyServer,
-	createProxyServer: () => createProxyServer
-});
+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
 const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
 const isSSL = /^https|wss/;
 function setupOutgoing(outgoing, options, req, forward) {
-	outgoing.port = options[forward || "target"].port || (isSSL.test(options[forward || "target"].protocol) ? 443 : 80);
+	outgoing.port = options[forward || "target"].port || (isSSL.test(options[forward || "target"].protocol ?? "http") ? 443 : 80);
 	for (const e of [
 		"host",
 		"hostname",
@@ -32,7 +27,7 @@ function setupOutgoing(outgoing, options, req, forward) {
 	};
 	if (options.auth) outgoing.auth = options.auth;
 	if (options.ca) outgoing.ca = options.ca;
-	if (isSSL.test(options[forward || "target"].protocol)) outgoing.rejectUnauthorized = options.secure === void 0 ? true : options.secure;
+	if (isSSL.test(options[forward || "target"].protocol ?? "http")) outgoing.rejectUnauthorized = options.secure === void 0 ? true : options.secure;
 	outgoing.agent = options.agent || false;
 	outgoing.localAddress = options.localAddress;
 	if (!outgoing.agent) {
@@ -40,12 +35,16 @@ function setupOutgoing(outgoing, options, req, forward) {
 		if (typeof outgoing.headers.connection !== "string" || !upgradeHeader.test(outgoing.headers.connection)) outgoing.headers.connection = "close";
 	}
 	const target = options[forward || "target"];
-	const targetPath = target && options.prependPath !== false ? target.pathname || target.path || "" : "";
-	const parsed = new URL(req.url, "http://localhost");
-	let outgoingPath = options.toProxy ? req.url : parsed.pathname + parsed.search || "";
+	const targetPath = target && options.prependPath !== false ? target.pathname || "" : "";
+	const reqUrl = req.url || "";
+	const qIdx = reqUrl.indexOf("?");
+	const reqPath = qIdx === -1 ? reqUrl : reqUrl.slice(0, qIdx);
+	const reqSearch = qIdx === -1 ? "" : reqUrl.slice(qIdx);
+	const normalizedPath = reqPath ? reqPath[0] === "/" ? reqPath : "/" + reqPath : "/";
+	let outgoingPath = options.toProxy ? "/" + reqUrl : normalizedPath + reqSearch;
 	outgoingPath = options.ignorePath ? "" : outgoingPath;
 	outgoing.path = joinURL(targetPath, outgoingPath);
-	if (options.changeOrigin) outgoing.headers.host = requiresPort(outgoing.port, options[forward || "target"].protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host;
+	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;
 }
 function joinURL(base, path) {
@@ -83,11 +82,23 @@ function rewriteCookieProperty(header, config, property) {
 		return newValue ? prefix + newValue : "";
 	});
 }
+function parseAddr(addr) {
+	if (typeof addr === "string") {
+		if (addr.startsWith("unix:")) return { socketPath: addr.slice(5) };
+		const url = new URL(addr);
+		return {
+			host: url.hostname,
+			port: Number(url.port) || (isSSL.test(url.protocol) ? 443 : 80)
+		};
+	}
+	if (!addr.socketPath && !addr.port) throw new Error("ProxyAddr must have either `port` or `socketPath`");
+	return addr;
+}
 function hasPort(host) {
-	return !!~host.indexOf(":");
+	return host ? !!~host.indexOf(":") : false;
 }
 function requiresPort(_port, _protocol) {
-	const protocol = _protocol.split(":")[0];
+	const protocol = _protocol?.split(":")[0];
 	const port = +_port;
 	if (!port) return false;
 	switch (protocol) {
@@ -118,18 +129,18 @@ const webOutgoingMiddleware = [
 	}),
 	defineProxyOutgoingMiddleware((req, res, proxyRes, options) => {
 		if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers.location && redirectRegex.test(String(proxyRes.statusCode))) {
-			const target = new URL(options.target);
+			const target = options.target instanceof URL ? options.target : new URL(options.target);
 			const u = new URL(proxyRes.headers.location);
 			if (target.host !== u.host) return;
 			if (options.hostRewrite) u.host = options.hostRewrite;
-			else if (options.autoRewrite) u.host = req.headers.host;
+			else if (options.autoRewrite && req.headers.host) u.host = req.headers.host;
 			if (options.protocolRewrite) u.protocol = options.protocolRewrite;
 			proxyRes.headers.location = u.toString();
 		}
 	}),
 	defineProxyOutgoingMiddleware((req, res, proxyRes, options) => {
-		let rewriteCookieDomainConfig = options.cookieDomainRewrite;
-		let rewriteCookiePathConfig = options.cookiePathRewrite;
+		const rewriteCookieDomainConfig = typeof options.cookieDomainRewrite === "string" ? { "*": options.cookieDomainRewrite } : options.cookieDomainRewrite;
+		const rewriteCookiePathConfig = typeof options.cookiePathRewrite === "string" ? { "*": options.cookiePathRewrite } : options.cookiePathRewrite;
 		const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
 		let rawHeaderKeyMap;
 		const setHeader = function(key, header) {
@@ -138,8 +149,6 @@ const webOutgoingMiddleware = [
 			if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") header = rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
 			res.setHeader(String(key).trim(), header);
 		};
-		if (typeof rewriteCookieDomainConfig === "string") rewriteCookieDomainConfig = { "*": rewriteCookieDomainConfig };
-		if (typeof rewriteCookiePathConfig === "string") rewriteCookiePathConfig = { "*": rewriteCookiePathConfig };
 		if (preserveHeaderKeyCase && proxyRes.rawHeaders !== void 0) {
 			rawHeaderKeyMap = {};
 			for (let i = 0; i < proxyRes.rawHeaders.length; i += 2) {
@@ -162,8 +171,15 @@ const webOutgoingMiddleware = [
 ];
 const nativeAgents = {
 	http,
-	https
+	https: nodeHTTPS
 };
+const redirectStatuses = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
 const webIncomingMiddleware = [
 	defineProxyMiddleware((req) => {
 		if ((req.method === "DELETE" || req.method === "OPTIONS") && !req.headers["content-length"]) {
@@ -172,7 +188,9 @@ const webIncomingMiddleware = [
 		}
 	}),
 	defineProxyMiddleware((req, res, options) => {
-		if (options.timeout) req.socket.setTimeout(options.timeout);
+		if (options.timeout) req.socket.setTimeout(options.timeout, () => {
+			req.socket.destroy();
+		});
 	}),
 	defineProxyMiddleware((req, res, options) => {
 		if (!options.xfwd) return;
@@ -191,11 +209,11 @@ const webIncomingMiddleware = [
 	}),
 	defineProxyMiddleware((req, res, options, server, head, callback) => {
 		server.emit("start", req, res, options.target || options.forward);
-		const agents = nativeAgents;
-		const http$1 = agents.http;
-		const https$1 = agents.https;
+		const http = nativeAgents.http;
+		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$1 : http$1).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
+			const forwardReq = (options.forward.protocol === "https:" ? https : http).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
 			const forwardError = createErrorHandler(forwardReq, options.forward);
 			req.on("error", forwardError);
 			forwardReq.on("error", forwardError);
@@ -205,8 +223,8 @@ const webIncomingMiddleware = [
 				return;
 			}
 		}
-		const proxyReq = (options.target.protocol === "https:" ? https$1 : http$1).request(setupOutgoing(options.ssl || {}, options, req));
-		proxyReq.on("socket", (socket) => {
+		const proxyReq = (options.target.protocol === "https:" ? 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() {
@@ -215,6 +233,9 @@ const webIncomingMiddleware = [
 		req.on("aborted", function() {
 			proxyReq.abort();
 		});
+		res.on("close", function() {
+			if (!res.writableFinished) proxyReq.destroy();
+		});
 		const proxyError = createErrorHandler(proxyReq, options.target);
 		req.on("error", proxyError);
 		proxyReq.on("error", proxyError);
@@ -228,8 +249,66 @@ const webIncomingMiddleware = [
 				else server.emit("error", err, req, res, url);
 			};
 		}
-		(options.buffer || req).pipe(proxyReq);
-		proxyReq.on("response", function(proxyRes) {
+		let bodyBuffer;
+		if (maxRedirects > 0) {
+			const chunks = [];
+			const source = options.buffer || req;
+			source.on("data", (chunk) => {
+				chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+				proxyReq.write(chunk);
+			});
+			source.on("end", () => {
+				bodyBuffer = Buffer.concat(chunks);
+				proxyReq.end();
+			});
+			source.on("error", (err) => {
+				proxyReq.destroy(err);
+			});
+		} 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) {
+				proxyRes.resume();
+				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 agent = isHTTPS ? https : http;
+				const redirectHeaders = { ...req.headers };
+				if (options.headers) Object.assign(redirectHeaders, options.headers);
+				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"];
+				}
+				const redirectOpts = {
+					hostname: location.hostname,
+					port: location.port || (isHTTPS ? 443 : 80),
+					path: location.pathname + location.search,
+					method: redirectMethod,
+					headers: redirectHeaders,
+					agent: options.agent || false
+				};
+				if (isHTTPS) redirectOpts.rejectUnauthorized = options.secure === void 0 ? true : options.secure;
+				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();
+				});
+				const redirectError = createErrorHandler(redirectReq, location);
+				redirectReq.on("error", redirectError);
+				redirectReq.on("response", (nextRes) => {
+					handleResponse(nextRes, redirectCount + 1, location);
+				});
+				if (preserveMethod && bodyBuffer && bodyBuffer.length > 0) redirectReq.end(bodyBuffer);
+				else redirectReq.end();
+				return;
+			}
 			if (server) server.emit("proxyRes", proxyRes, req, res);
 			if (!res.headersSent && !options.selfHandleResponse) {
 				for (const pass of webOutgoingMiddleware) if (pass(req, res, proxyRes, options)) break;
@@ -245,6 +324,9 @@ const webIncomingMiddleware = [
 				});
 				if (!options.selfHandleResponse) proxyRes.pipe(res);
 			}
+		}
+		proxyReq.on("response", function(proxyRes) {
+			handleResponse(proxyRes, 0, options.target);
 		});
 	})
 ];
@@ -286,7 +368,8 @@ const websocketIncomingMiddleware = [
 		};
 		setupSocket(socket);
 		if (head && head.length > 0) socket.unshift(head);
-		const proxyReq = (isSSL.test(options.target.protocol) ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
+		socket.on("error", onSocketError);
+		const proxyReq = (isSSL.test(options.target.protocol || "http") ? nodeHTTPS : 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) {
@@ -311,6 +394,11 @@ const websocketIncomingMiddleware = [
 			server.emit("proxySocket", proxySocket);
 		});
 		proxyReq.end();
+		function onSocketError(err) {
+			if (callback) callback(err, req, socket);
+			else server.emit("error", err, req, socket);
+			proxyReq.destroy();
+		}
 		function onOutgoingError(err) {
 			if (callback) callback(err, req, socket);
 			else server.emit("error", err, req, socket);
@@ -345,9 +433,9 @@ var ProxyServer = class extends EventEmitter {
 		const closure = (req, res) => {
 			this.web(req, res);
 		};
-		this._server = this.options.ssl ? https.createServer(this.options.ssl, closure) : http.createServer(closure);
+		this._server = this.options.ssl ? nodeHTTPS.createServer(this.options.ssl, closure) : http.createServer(closure);
 		if (this.options.ws) this._server.on("upgrade", (req, socket, head) => {
-			this._ws(req, socket, head);
+			this.ws(req, socket, head).catch(() => {});
 		});
 		this._server.listen(port, hostname);
 		return this;
@@ -363,7 +451,7 @@ var ProxyServer = class extends EventEmitter {
 	}
 	before(type, passName, pass) {
 		if (type !== "ws" && type !== "web") throw new Error("type must be `web` or `ws`");
-		const passes = type === "ws" ? this._wsPasses : this._webPasses;
+		const passes = this._getPasses(type);
 		let i = false;
 		for (const [idx, v] of passes.entries()) if (v.name === passName) i = idx;
 		if (i === false) throw new Error("No such pass");
@@ -371,12 +459,16 @@ var ProxyServer = class extends EventEmitter {
 	}
 	after(type, passName, pass) {
 		if (type !== "ws" && type !== "web") throw new Error("type must be `web` or `ws`");
-		const passes = type === "ws" ? this._wsPasses : this._webPasses;
+		const passes = this._getPasses(type);
 		let i = false;
 		for (const [idx, v] of passes.entries()) if (v.name === passName) i = idx;
 		if (i === false) throw new Error("No such pass");
 		passes.splice(i++, 0, pass);
 	}
+	/** @internal */
+	_getPasses(type) {
+		return type === "ws" ? this._wsPasses : this._webPasses;
+	}
 };
 function createProxyServer(options = {}) {
 	return new ProxyServer(options);
@@ -388,7 +480,10 @@ function _createProxyFn(type, server) {
 			...server.options
 		};
 		for (const key of ["target", "forward"]) if (typeof requestOptions[key] === "string") requestOptions[key] = new URL(requestOptions[key]);
-		if (!requestOptions.target && !requestOptions.forward) return this.emit("error", /* @__PURE__ */ new Error("Must provide a proper URL as target"));
+		if (!requestOptions.target && !requestOptions.forward) {
+			this.emit("error", /* @__PURE__ */ new Error("Must provide a proper URL as target"));
+			return Promise.resolve();
+		}
 		let _resolve;
 		let _reject;
 		const callbackPromise = new Promise((resolve, reject) => {
@@ -401,8 +496,11 @@ function _createProxyFn(type, server) {
 		res.on("error", (error) => {
 			_reject(error);
 		});
-		for (const pass of type === "ws" ? server._wsPasses : server._webPasses) if (pass(req, res, requestOptions, server, head, (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);
+				_resolve();
+			} else _reject(error);
 		})) {
 			_resolve();
 			break;
@@ -410,6 +508,164 @@ function _createProxyFn(type, server) {
 		return callbackPromise;
 	};
 }
-
+async function proxyFetch(addr, input, inputInit) {
+	const resolvedAddr = parseAddr(addr);
+	let url;
+	let init;
+	if (input instanceof Request) {
+		url = new URL(input.url);
+		init = {
+			...toInit(input),
+			...toInit(inputInit)
+		};
+	} else {
+		url = new URL(input);
+		init = toInit(inputInit);
+	}
+	init = {
+		redirect: "manual",
+		...init
+	};
+	if (init.body) init.duplex = "half";
+	const path = url.pathname + url.search;
+	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;
+	}
+	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();
+	});
+	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 hasBody = res.statusCode !== 204 && res.statusCode !== 304;
+	return new Response(hasBody ? Readable.toWeb(res) : null, {
+		status: res.statusCode,
+		statusText: res.statusMessage,
+		headers
+	});
+}
+function toInit(init) {
+	if (!init) return;
+	if (init instanceof Request) return {
+		method: init.method,
+		headers: init.headers,
+		body: init.body,
+		duplex: init.body ? "half" : void 0
+	};
+	return init;
+}
+function proxyUpgrade(addr, req, socket, head, opts) {
+	const resolvedAddr = parseAddr(addr);
+	if (req.method !== "GET" || req.headers.upgrade?.toLowerCase() !== "websocket") {
+		socket.destroy();
+		return Promise.reject(/* @__PURE__ */ new Error("Not a valid WebSocket upgrade request"));
+	}
+	if (opts?.xfwd !== false) {
+		const xfFor = req.headers["x-forwarded-for"];
+		const xfPort = req.headers["x-forwarded-port"];
+		const xfProto = req.headers["x-forwarded-proto"];
+		req.headers["x-forwarded-for"] = `${xfFor ? `${xfFor},` : ""}${req.socket?.remoteAddress}`;
+		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 requestOptions = {
+		...opts,
+		target,
+		prependPath: opts?.prependPath !== false
+	};
+	const outgoing = setupOutgoing(requestOptions.ssl || {}, requestOptions, req);
+	const sock = socket;
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		setupSocket(sock);
+		if (head && head.length > 0) sock.unshift(head);
+		sock.once("error", onSocketError);
+		const proxyReq = (isSSL.test(target.protocol) ? request$1 : request)(outgoing);
+		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 (!settled) {
+					settled = true;
+					reject(/* @__PURE__ */ new Error("Upstream server did not upgrade the connection"));
+				}
+			}
+		});
+		proxyReq.once("upgrade", (proxyRes, proxySocket, proxyHead) => {
+			proxySocket.once("error", onOutgoingError);
+			sock.removeListener("error", onSocketError);
+			sock.once("error", () => {
+				proxySocket.end();
+			});
+			setupSocket(proxySocket);
+			if (proxyHead && proxyHead.length > 0) proxySocket.unshift(proxyHead);
+			sock.write(_createHttpHeader("HTTP/1.1 101 Switching Protocols", proxyRes.headers));
+			proxySocket.pipe(sock).pipe(proxySocket);
+			settled = true;
+			resolve(proxySocket);
+		});
+		proxyReq.end();
+		function onSocketError(err) {
+			proxyReq.destroy();
+			if (!settled) {
+				settled = true;
+				reject(err);
+			}
+		}
+		function onOutgoingError(err) {
+			sock.end();
+			if (!settled) {
+				settled = true;
+				reject(err);
+			}
+		}
+	});
+}
+function _buildTargetURL(addr) {
+	if (addr.socketPath) {
+		const url = new URL("http://unix");
+		url.socketPath = addr.socketPath;
+		return url;
+	}
+	return new URL(`http://${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}`;
+	}
+	return `${result}\r
+\r
+`;
+}
 //#endregion
-export { dist_exports as n, createProxyServer as t };
+export { proxyFetch as n, proxyUpgrade as r, createProxyServer as t };

package/dist/_libs/js-tokens.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/_libs/klona.mjs

@@ -33,6 +33,5 @@ function klona(x) {
 	}
 	return tmp || x;
 }
-
 //#endregion
-export { klona as t };
+export { klona as t };

package/dist/_libs/mlly.d.mts

@@ -1,4 +1,4 @@
-//#region node_modules/.pnpm/mlly@1.8.0/node_modules/mlly/dist/index.d.ts
+//#region node_modules/.pnpm/mlly@1.8.1/node_modules/mlly/dist/index.d.ts
 /**
  * Represents a general structure for ECMAScript module exports.
  */