renovate-log-parser 0.1.0 → 0.1.2

package/web/.output/server/node_modules/srvx/dist/adapters/node.mjs

@@ -1,976 +0,0 @@
-import { FastURL, lazyInherit } from "../_chunks/_url.mjs";
-import { createWaitUntil, fmtURL, printListening, resolvePortAndHost, resolveTLSOptions } from "../_chunks/_utils2.mjs";
-import { errorPlugin, gracefulShutdownPlugin, wrapFetch } from "../_chunks/_plugins.mjs";
-import { HOST_RE, firstForwardedValue, isTrustedProxy } from "../_chunks/_trust-proxy.mjs";
-import { createBodyTooLargeError, limitBodyStream } from "../_chunks/_body-limit.mjs";
-import nodeHTTP, { IncomingMessage, ServerResponse } from "node:http";
-import { Duplex, PassThrough, Readable, addAbortSignal } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import nodeHTTPS from "node:https";
-import nodeHTTP2 from "node:http2";
-function sendNodeResponse(nodeRes, webRes) {
-	try {
-		return _sendNodeResponse(nodeRes, webRes, false) || Promise.resolve();
-	} catch (error) {
-		return Promise.reject(error);
-	}
-}
-function sendNodeResponseDetached(nodeRes, webRes) {
-	try {
-		return _sendNodeResponse(nodeRes, webRes, true);
-	} catch (error) {
-		handleSendError(nodeRes, error);
-	}
-}
-function handleSendError(nodeRes, _error) {
-	if (nodeRes.headersSent) nodeRes.destroy();
-	else {
-		nodeRes.statusCode = 500;
-		nodeRes.end();
-	}
-}
-function _sendNodeResponse(nodeRes, webRes, detached) {
-	if (!webRes) {
-		nodeRes.statusCode = 500;
-		return endNodeResponse(nodeRes, detached);
-	}
-	if (webRes._toNodeResponse) {
-		const res = webRes._toNodeResponse();
-		if (res.body) {
-			if (res.body instanceof ReadableStream) {
-				writeHead(nodeRes, res.status, res.statusText, res.headers);
-				return streamBody(res.body, nodeRes);
-			} else if (typeof res.body?.pipe === "function") return pipeBody(res.body, nodeRes, res.status, res.statusText, res.headers);
-			writeHead(nodeRes, res.status, res.statusText, res.headers);
-			nodeRes.write(res.body);
-		} else writeHead(nodeRes, res.status, res.statusText, res.headers);
-		return endNodeResponse(nodeRes, detached);
-	}
-	const rawHeaders = [];
-	for (const [key, value] of webRes.headers) rawHeaders.push(key, value);
-	writeHead(nodeRes, webRes.status, webRes.statusText, rawHeaders);
-	return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes, detached);
-}
-function writeHead(nodeRes, status, statusText, rawHeaders) {
-	if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, rawHeaders);
-	else nodeRes.writeHead(status, statusText, rawHeaders);
-}
-function endNodeResponse(nodeRes, detached) {
-	if (detached) {
-		nodeRes.end();
-		return;
-	}
-	return new Promise((resolve) => nodeRes.end(resolve));
-}
-function pipeBody(stream, nodeRes, status, statusText, headers) {
-	if (nodeRes.destroyed) {
-		stream.destroy?.();
-		return;
-	}
-	if (typeof stream.on !== "function" || typeof stream.destroy !== "function") {
-		writeHead(nodeRes, status, statusText, headers);
-		stream.pipe(nodeRes);
-		return new Promise((resolve) => nodeRes.on("close", resolve));
-	}
-	if (stream.destroyed) {
-		writeHead(nodeRes, 500, "Internal Server Error", []);
-		return endNodeResponse(nodeRes);
-	}
-	return new Promise((resolve) => {
-		function onEarlyError() {
-			stream.off("readable", onReadable);
-			stream.destroy();
-			writeHead(nodeRes, 500, "Internal Server Error", []);
-			endNodeResponse(nodeRes).then(resolve);
-		}
-		function onReadable() {
-			stream.off("error", onEarlyError);
-			if (nodeRes.destroyed) {
-				stream.destroy();
-				return resolve();
-			}
-			writeHead(nodeRes, status, statusText, headers);
-			pipeline(stream, nodeRes).catch(() => {}).then(() => resolve());
-		}
-		stream.once("error", onEarlyError);
-		stream.once("readable", onReadable);
-	});
-}
-function streamBody(stream, nodeRes) {
-	if (nodeRes.destroyed) {
-		stream.cancel();
-		return;
-	}
-	const reader = stream.getReader();
-	function streamCancel(error) {
-		reader.cancel(error).catch(() => {});
-		if (error) nodeRes.destroy(error);
-	}
-	function streamHandle({ done, value }) {
-		try {
-			if (done) nodeRes.end();
-			else if (nodeRes.write(value)) reader.read().then(streamHandle, streamCancel);
-			else nodeRes.once("drain", () => reader.read().then(streamHandle, streamCancel));
-		} catch (error) {
-			streamCancel(error instanceof Error ? error : void 0);
-		}
-	}
-	nodeRes.on("close", streamCancel);
-	nodeRes.on("error", streamCancel);
-	reader.read().then(streamHandle, streamCancel);
-	return reader.closed.catch(streamCancel).finally(() => {
-		nodeRes.off("close", streamCancel);
-		nodeRes.off("error", streamCancel);
-	});
-}
-var NodeRequestURL = class extends FastURL {
-	constructor({ req, trusted = false }) {
-		const path = req.url || "/";
-		const forwardedHost = trusted ? firstForwardedValue(req.headers["x-forwarded-host"]) : void 0;
-		let host = (forwardedHost && HOST_RE.test(forwardedHost) ? forwardedHost : void 0) || req.headers.host || req.headers[":authority"];
-		if (host && !HOST_RE.test(host)) host = "_invalid_";
-		else if (!host) if (req.socket) host = `${req.socket.localFamily === "IPv6" ? "[" + req.socket.localAddress + "]" : req.socket.localAddress}:${req.socket?.localPort || "80"}`;
-		else host = "localhost";
-		const forwardedProto = trusted ? firstForwardedValue(req.headers["x-forwarded-proto"]) : void 0;
-		const protocol = req.socket?.encrypted || forwardedProto === "https" || trusted && req.headers[":scheme"] === "https" ? "https:" : "http:";
-		if (path[0] === "/") {
-			const qIndex = path.indexOf("?");
-			super({
-				protocol,
-				host,
-				pathname: qIndex === -1 ? path : path.slice(0, qIndex) || "/",
-				search: qIndex === -1 ? "" : path.slice(qIndex) || ""
-			});
-		} else if (path === "*") super({
-			protocol,
-			host,
-			pathname: "/*",
-			search: ""
-		});
-		else super(path);
-	}
-};
-const _nonJoinedHeaders = /* @__PURE__ */ new Set([
-	"age",
-	"authorization",
-	"content-length",
-	"content-type",
-	"etag",
-	"expires",
-	"from",
-	"host",
-	"if-modified-since",
-	"if-unmodified-since",
-	"last-modified",
-	"location",
-	"max-forwards",
-	"proxy-authorization",
-	"referer",
-	"retry-after",
-	"server",
-	"user-agent"
-]);
-const _validHeaderNameRE = /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/;
-function _isRepeated(rawHeaders, lowerName) {
-	let seen = false;
-	for (let i = 0; i < rawHeaders.length; i += 2) {
-		const key = rawHeaders[i];
-		if (key.length === lowerName.length && key.toLowerCase() === lowerName) {
-			if (seen) return true;
-			seen = true;
-		}
-	}
-	return false;
-}
-const NodeRequestHeaders = /* @__PURE__ */ (() => {
-	const NativeHeaders = globalThis.Headers;
-	class Headers {
-		#req;
-		#headers;
-		constructor(req) {
-			this.#req = req;
-		}
-		static [Symbol.hasInstance](val) {
-			return val instanceof NativeHeaders;
-		}
-		get _headers() {
-			if (!this.#headers) {
-				const headers = new NativeHeaders();
-				const rawHeaders = this.#req.rawHeaders;
-				const len = rawHeaders.length;
-				for (let i = 0; i < len; i += 2) {
-					const key = rawHeaders[i];
-					if (key.charCodeAt(0) === 58) continue;
-					const value = rawHeaders[i + 1];
-					headers.append(key, value);
-				}
-				this.#headers = headers;
-			}
-			return this.#headers;
-		}
-		get(name) {
-			if (this.#headers) return this.#headers.get(name);
-			const lower = name.toLowerCase();
-			if (lower.charCodeAt(0) === 58) return this._headers.get(name);
-			const value = this.#req.headers[lower];
-			if (typeof value === "string") return _nonJoinedHeaders.has(lower) && _isRepeated(this.#req.rawHeaders, lower) ? this._headers.get(name) : value;
-			if (Array.isArray(value)) return value.join(", ");
-			return lower !== "__proto__" && _validHeaderNameRE.test(name) ? null : this._headers.get(name);
-		}
-		has(name) {
-			if (this.#headers) return this.#headers.has(name);
-			const lower = name.toLowerCase();
-			if (lower.charCodeAt(0) === 58) return this._headers.has(name);
-			if (Object.hasOwn(this.#req.headers, lower)) return true;
-			return lower !== "__proto__" && _validHeaderNameRE.test(name) ? false : this._headers.has(name);
-		}
-		getSetCookie() {
-			if (this.#headers) return this.#headers.getSetCookie();
-			const value = this.#req.headers["set-cookie"];
-			return Array.isArray(value) ? value.slice() : value ? [value] : [];
-		}
-		entries() {
-			return this._headers.entries();
-		}
-		[Symbol.iterator]() {
-			return this.entries();
-		}
-	}
-	lazyInherit(Headers.prototype, NativeHeaders.prototype, "_headers");
-	Object.setPrototypeOf(Headers, NativeHeaders);
-	Object.setPrototypeOf(Headers.prototype, NativeHeaders.prototype);
-	return Headers;
-})();
-const kNativeRequest = /* @__PURE__ */ Symbol.for("srvx.nativeRequest");
-const NodeRequest = /* @__PURE__ */ (() => {
-	const NativeRequest = getNativeRequest();
-	class Request {
-		runtime;
-		waitUntil;
-		#req;
-		#url;
-		#bodyStream;
-		#request;
-		#headers;
-		#abortController;
-		#maxRequestBodySize;
-		#trustProxy;
-		#ip;
-		#ipResolved = false;
-		#remoteAddress;
-		#trusted;
-		constructor(ctx) {
-			this.#req = ctx.req;
-			this.#maxRequestBodySize = ctx.maxRequestBodySize;
-			this.#trustProxy = ctx.trustProxy;
-			this.runtime = {
-				name: "node",
-				node: ctx
-			};
-		}
-		static [Symbol.hasInstance](val) {
-			return val instanceof NativeRequest;
-		}
-		#resolveTrusted() {
-			if (this.#trusted === void 0) {
-				this.#remoteAddress = this.#req.socket?.remoteAddress;
-				this.#trusted = isTrustedProxy(this.#trustProxy, this.#remoteAddress);
-			}
-			return this.#trusted;
-		}
-		get ip() {
-			if (this.#ipResolved) return this.#ip;
-			this.#ipResolved = true;
-			if (this.#resolveTrusted()) {
-				const forwarded = firstForwardedValue(this.#req.headers["x-forwarded-for"]);
-				if (forwarded) return this.#ip = forwarded;
-			}
-			return this.#ip = this.#remoteAddress;
-		}
-		get method() {
-			if (this.#request) return this.#request.method;
-			return this.#req.method || "GET";
-		}
-		get _url() {
-			return this.#url ||= new NodeRequestURL({
-				req: this.#req,
-				trusted: this.#resolveTrusted()
-			});
-		}
-		set _url(url) {
-			this.#url = url;
-		}
-		get url() {
-			if (this.#request) return this.#request.url;
-			return this._url.href;
-		}
-		get headers() {
-			if (this.#request) return this.#request.headers;
-			return this.#headers ||= new NodeRequestHeaders(this.#req);
-		}
-		get _abortController() {
-			if (!this.#abortController) {
-				this.#abortController = new AbortController();
-				const { req, res } = this.runtime.node;
-				const abortController = this.#abortController;
-				const abort = (err) => abortController.abort?.(err);
-				if (res) res.once("close", () => {
-					const reqError = req.errored;
-					if (reqError) abort(reqError);
-					else if (!res.writableEnded) abort();
-				});
-				else req.once("close", () => {
-					if (!req.complete) abort();
-				});
-			}
-			return this.#abortController;
-		}
-		get signal() {
-			return this.#request ? this.#request.signal : this._abortController.signal;
-		}
-		get body() {
-			if (this.#request) return this.#request.body;
-			if (this.#bodyStream === void 0) {
-				const method = this.method;
-				let stream = !(method === "GET" || method === "HEAD") ? Readable.toWeb(this.#req) : null;
-				if (stream && this.#maxRequestBodySize !== void 0) stream = limitBodyStream(stream, this.#maxRequestBodySize);
-				this.#bodyStream = stream;
-			}
-			return this.#bodyStream;
-		}
-		#readBuffered() {
-			return readBody(this.#req, this.#maxRequestBodySize);
-		}
-		text() {
-			if (this.#request) return this.#request.text();
-			if (this.#bodyStream !== void 0) return this.#bodyStream ? new Response(this.#bodyStream).text() : Promise.resolve("");
-			return this.#readBuffered().then((buf) => buf.toString());
-		}
-		json() {
-			if (this.#request) return this.#request.json();
-			if (this.#bodyStream !== void 0) return this.text().then((text) => JSON.parse(text));
-			return this.#readBuffered().then((buf) => JSON.parse(buf.toString()));
-		}
-		get _request() {
-			if (!this.#request) {
-				const body = this.body;
-				this.#request = new NativeRequest(this.url, {
-					method: this.method,
-					headers: this.headers,
-					signal: this._abortController.signal,
-					body,
-					duplex: body ? "half" : void 0
-				});
-				this.#headers = void 0;
-				this.#bodyStream = void 0;
-			}
-			return this.#request;
-		}
-	}
-	lazyInherit(Request.prototype, NativeRequest.prototype, "_request");
-	Object.setPrototypeOf(Request.prototype, NativeRequest.prototype);
-	return Request;
-})();
-function patchGlobalRequest() {
-	const NativeRequest = getNativeRequest();
-	const PatchedRequest = class Request extends NativeRequest {
-		static _srvx = true;
-		static [Symbol.hasInstance](instance) {
-			if (this === PatchedRequest) return instance instanceof NativeRequest;
-			else return Object.prototype.isPrototypeOf.call(this.prototype, instance);
-		}
-		constructor(input, options) {
-			if (typeof input === "object" && "_request" in input) input = input._request;
-			super(input, options);
-		}
-	};
-	if (!globalThis.Request._srvx) globalThis.Request = PatchedRequest;
-	return PatchedRequest;
-}
-function readBody(req, maxRequestBodySize) {
-	if ("rawBody" in req && Buffer.isBuffer(req.rawBody)) {
-		if (maxRequestBodySize !== void 0 && req.rawBody.length > maxRequestBodySize) return Promise.reject(createBodyTooLargeError(maxRequestBodySize));
-		return Promise.resolve(req.rawBody);
-	}
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		let size = 0;
-		const cleanup = () => {
-			req.off("data", onData);
-			req.off("end", onEnd);
-			req.off("error", onError);
-		};
-		const onData = (chunk) => {
-			if (maxRequestBodySize !== void 0) {
-				size += chunk.length;
-				if (size > maxRequestBodySize) {
-					cleanup();
-					req.pause?.();
-					reject(createBodyTooLargeError(maxRequestBodySize));
-					return;
-				}
-			}
-			chunks.push(chunk);
-		};
-		const onError = (err) => {
-			cleanup();
-			reject(err);
-		};
-		const onEnd = () => {
-			cleanup();
-			resolve(chunks.length === 1 ? chunks[0] : Buffer.concat(chunks));
-		};
-		req.on("data", onData).once("end", onEnd).once("error", onError);
-	});
-}
-function getNativeRequest() {
-	let R = globalThis[kNativeRequest] || globalThis.Request;
-	while (R?._srvx) R = Object.getPrototypeOf(R);
-	return globalThis[kNativeRequest] ??= R;
-}
-const NodeResponse = /* @__PURE__ */ (() => {
-	const NativeResponse = globalThis.Response;
-	const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
-	class NodeResponse {
-		#body;
-		#init;
-		#headers;
-		#response;
-		constructor(body, init) {
-			this.#body = body;
-			this.#init = init;
-		}
-		static [Symbol.hasInstance](val) {
-			return val instanceof NativeResponse;
-		}
-		get status() {
-			return this.#response?.status || this.#init?.status || 200;
-		}
-		get statusText() {
-			return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
-		}
-		get headers() {
-			if (this.#response) return this.#response.headers;
-			if (this.#headers) return this.#headers;
-			const initHeaders = this.#init?.headers;
-			return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
-		}
-		get ok() {
-			if (this.#response) return this.#response.ok;
-			const status = this.status;
-			return status >= 200 && status < 300;
-		}
-		get _response() {
-			if (this.#response) return this.#response;
-			let body = this.#body;
-			if (body && typeof body.pipe === "function" && !(body instanceof Readable)) {
-				const stream = new PassThrough();
-				body.pipe(stream);
-				const abort = body.abort;
-				if (abort) stream.once("close", () => abort());
-				body = stream;
-			}
-			this.#response = new NativeResponse(body, this.#headers ? {
-				...this.#init,
-				headers: this.#headers
-			} : this.#init);
-			this.#init = void 0;
-			this.#headers = void 0;
-			this.#body = void 0;
-			return this.#response;
-		}
-		_toNodeResponse() {
-			const status = this.status;
-			const statusText = this.statusText;
-			let body;
-			let contentType;
-			let contentLength;
-			if (this.#response) body = this.#response.body;
-			else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
-			else if (typeof this.#body === "string") {
-				body = this.#body;
-				contentType = "text/plain; charset=UTF-8";
-				contentLength = Buffer.byteLength(this.#body);
-			} else if (this.#body instanceof ArrayBuffer) {
-				body = Buffer.from(this.#body);
-				contentLength = this.#body.byteLength;
-			} else if (this.#body instanceof Uint8Array) {
-				body = this.#body;
-				contentLength = this.#body.byteLength;
-			} else if (this.#body instanceof DataView) {
-				body = Buffer.from(this.#body.buffer);
-				contentLength = this.#body.byteLength;
-			} else if (this.#body instanceof Blob) {
-				body = this.#body.stream();
-				contentType = this.#body.type;
-				contentLength = this.#body.size;
-			} else if (typeof this.#body.pipe === "function") body = this.#body;
-			else body = this._response.body;
-			const headers = [];
-			const initHeaders = this.#init?.headers;
-			const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders) : void 0);
-			let hasContentTypeHeader;
-			let hasContentLength;
-			if (headerEntries) for (const [key, value] of headerEntries) {
-				const lowerKey = typeof key === "string" ? key.toLowerCase() : String(key);
-				if (Array.isArray(value)) for (const v of value) headers.push(lowerKey, v);
-				else headers.push(lowerKey, value);
-				if (lowerKey === "content-type") hasContentTypeHeader = true;
-				else if (lowerKey === "content-length") hasContentLength = true;
-			}
-			if (contentType && !hasContentTypeHeader) headers.push("content-type", contentType);
-			if (contentLength && !hasContentLength) headers.push("content-length", String(contentLength));
-			this.#init = void 0;
-			this.#headers = void 0;
-			this.#response = void 0;
-			this.#body = void 0;
-			return {
-				status,
-				statusText,
-				headers,
-				body
-			};
-		}
-	}
-	lazyInherit(NodeResponse.prototype, NativeResponse.prototype, "_response");
-	Object.setPrototypeOf(NodeResponse, NativeResponse);
-	Object.setPrototypeOf(NodeResponse.prototype, NativeResponse.prototype);
-	return NodeResponse;
-})();
-function prematureCloseError() {
-	return Object.assign(/* @__PURE__ */ new Error("Connection closed before response was finished"), { code: "ERR_STREAM_PREMATURE_CLOSE" });
-}
-var WebRequestSocket = class extends Duplex {
-	_httpMessage;
-	autoSelectFamilyAttemptedAddresses = [];
-	bufferSize = 0;
-	bytesRead = 0;
-	bytesWritten = 0;
-	connecting = false;
-	pending = false;
-	readyState = "open";
-	remoteAddress = "";
-	remoteFamily = "";
-	remotePort = 0;
-	#request;
-	#timeoutTimer;
-	#reqReader;
-	#headersWritten;
-	#_writeBody;
-	#resBodyController;
-	#resBodyClosed;
-	_webResBody;
-	#tos = 0;
-	constructor(request) {
-		super({ allowHalfOpen: true });
-		this.#request = request;
-		this._webResBody = new ReadableStream({ start: (controller) => {
-			this.#resBodyController = controller;
-			this.#_writeBody = controller.enqueue.bind(controller);
-			this.once("finish", () => {
-				this.readyState = "closed";
-				this.#resBodyClosed = true;
-				controller.close();
-			});
-		} });
-		addAbortSignal(request.signal, this);
-	}
-	setTimeout(ms, cb) {
-		if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) return this;
-		if (cb) this.on("timeout", cb);
-		if (this.#timeoutTimer) clearTimeout(this.#timeoutTimer);
-		if (ms > 0) this.#timeoutTimer = setTimeout(() => this.emit("timeout"), ms);
-		return this;
-	}
-	setNoDelay() {
-		return this;
-	}
-	setKeepAlive() {
-		return this;
-	}
-	ref() {
-		return this;
-	}
-	unref() {
-		return this;
-	}
-	destroySoon() {
-		this.destroy();
-	}
-	connect() {
-		return this;
-	}
-	resetAndDestroy() {
-		this.destroy();
-		return this;
-	}
-	address() {
-		return {
-			address: "",
-			family: "",
-			port: 0
-		};
-	}
-	bodyReader() {
-		try {
-			return this.#request.body?.getReader();
-		} catch (error) {
-			this.emit("error", error);
-		}
-	}
-	getTypeOfService() {
-		return this.#tos;
-	}
-	setTypeOfService(tos) {
-		this.#tos = tos;
-		return this;
-	}
-	_read(_size) {
-		const reader = this.#reqReader ??= this.bodyReader();
-		if (!reader) {
-			this.push(null);
-			return;
-		}
-		reader.read().then((res) => this._onRead(res)).catch((error) => {
-			this.emit("error", error);
-		});
-	}
-	_onRead(res) {
-		if (res.done) {
-			this.push(null);
-			return;
-		}
-		if (res.value) {
-			this.bytesRead += res.value.byteLength;
-			this.push(res.value);
-		}
-	}
-	_write(chunk, encoding, callback) {
-		if (this.#headersWritten) this.#_writeBody(typeof chunk === "string" ? Buffer.from(chunk, encoding) : chunk);
-		else if (chunk?.length > 0) {
-			this.#headersWritten = true;
-			const headerEnd = chunk.lastIndexOf("\r\n\r\n");
-			if (headerEnd === -1) throw new Error("Invalid HTTP headers chunk!");
-			if (headerEnd < chunk.length - 4) {
-				this._write(chunk.slice(headerEnd + 4), encoding, () => {
-					callback(null);
-				});
-				return;
-			}
-		}
-		callback(null);
-	}
-	_final(callback) {
-		callback(null);
-	}
-	_destroy(err, cb) {
-		if (this.#timeoutTimer) clearTimeout(this.#timeoutTimer);
-		if (this.#reqReader) this.#reqReader.cancel().catch((error) => {
-			console.error(error);
-		});
-		if (!this.#resBodyClosed) {
-			this.#resBodyClosed = true;
-			try {
-				this.#resBodyController?.error(err ?? prematureCloseError());
-			} catch {}
-		}
-		this.readyState = "closed";
-		cb(err ?? void 0);
-	}
-};
-var WebIncomingMessage = class extends IncomingMessage {
-	constructor(req, socket) {
-		super(socket);
-		this.method = req.method;
-		const url = req._url ??= new FastURL(req.url);
-		this.url = url.pathname + url.search;
-		for (const [key, value] of req.headers.entries()) this.headers[key.toLowerCase()] = value;
-		if (req.method !== "GET" && req.method !== "HEAD" && !this.headers["content-length"] && !this.headers["transfer-encoding"]) this.headers["transfer-encoding"] = "chunked";
-		const onData = (chunk) => {
-			this.push(chunk);
-		};
-		socket.on("data", onData);
-		socket.once("end", () => {
-			this.emit("end");
-			this.off("data", onData);
-		});
-	}
-};
-function callNodeHandler(handler, req) {
-	const isMiddleware = handler.length > 2;
-	const nodeCtx = req.runtime?.node;
-	if (!nodeCtx || !nodeCtx.req || !nodeCtx.res) throw new Error("Node.js runtime context is not available.");
-	const { req: nodeReq, res: nodeRes } = nodeCtx;
-	let _headers;
-	const webRes = new NodeResponse(void 0, {
-		get status() {
-			return nodeRes.statusCode;
-		},
-		get statusText() {
-			return nodeRes.statusMessage;
-		},
-		get headers() {
-			if (!_headers) {
-				const headerEntries = [];
-				const rawHeaders = nodeRes.getHeaders();
-				for (const [name, value] of Object.entries(rawHeaders)) if (Array.isArray(value)) for (const v of value) headerEntries.push([name, v]);
-				else if (value) headerEntries.push([name, String(value)]);
-				_headers = new Headers(headerEntries);
-			}
-			return _headers;
-		}
-	});
-	return new Promise((resolve, reject) => {
-		nodeRes.once("close", () => resolve(webRes));
-		nodeRes.once("finish", () => resolve(webRes));
-		nodeRes.once("error", (error) => reject(error));
-		let streamPromise;
-		nodeRes.once("pipe", (stream) => {
-			streamPromise = new Promise((resolve) => {
-				stream.once("end", () => resolve(webRes));
-				stream.once("error", (error) => reject(error));
-			});
-		});
-		try {
-			if (isMiddleware) Promise.resolve(handler(nodeReq, nodeRes, (error) => error ? reject(error) : streamPromise || resolve(webRes))).catch((error) => reject(error));
-			else Promise.resolve(handler(nodeReq, nodeRes)).then(() => streamPromise || webRes);
-		} catch (error) {
-			reject(error);
-		}
-	});
-}
-let needDrainSymbol;
-function getNeedDrainSymbol(res) {
-	if (needDrainSymbol === void 0) needDrainSymbol = Object.getOwnPropertySymbols(res).find((s) => s.description === "kNeedDrain") ?? null;
-	return needDrainSymbol;
-}
-var WebServerResponse = class extends ServerResponse {
-	#socket;
-	#socketError;
-	constructor(req, socket) {
-		super(req);
-		this.assignSocket(socket);
-		this.once("finish", () => {
-			socket.end();
-		});
-		this.#socket = socket;
-		socket.once("error", (err) => {
-			this.#socketError ??= err;
-		});
-		socket.on("drain", () => {
-			const kNeedDrain = getNeedDrainSymbol(this);
-			if (kNeedDrain && !this[kNeedDrain]) return;
-			if (this.destroyed || this.writableFinished) return;
-			if (kNeedDrain) this[kNeedDrain] = false;
-			this.emit("drain");
-		});
-		this.waitToFinish = this.waitToFinish.bind(this);
-		this.toWebResponse = this.toWebResponse.bind(this);
-	}
-	waitToFinish() {
-		if (this.writableFinished) return Promise.resolve();
-		if (this.#socketError || this.#socket.destroyed) return Promise.reject(this.#socketError ?? prematureCloseError());
-		if (this.writableEnded) return Promise.resolve();
-		return new Promise((resolve, reject) => {
-			const socket = this.#socket;
-			const settle = (err) => {
-				this.removeListener("finish", onFinish);
-				this.removeListener("error", onError);
-				socket.removeListener("error", onError);
-				socket.removeListener("close", onClose);
-				if (err) reject(err);
-				else resolve();
-			};
-			const onFinish = () => settle();
-			const onError = (err) => settle(err);
-			const onClose = () => {
-				if (!this.writableFinished) settle(this.#socketError ?? prematureCloseError());
-			};
-			this.on("finish", onFinish);
-			this.on("error", onError);
-			socket.on("error", onError);
-			socket.on("close", onClose);
-		});
-	}
-	async toWebResponse() {
-		await this.waitToFinish();
-		const headers = [];
-		const httpHeader = this._header?.split("\r\n");
-		for (let i = 1; httpHeader && i < httpHeader.length; i++) {
-			const sepIndex = httpHeader[i].indexOf(": ");
-			if (sepIndex === -1) continue;
-			const key = httpHeader[i].slice(0, Math.max(0, sepIndex));
-			const value = httpHeader[i].slice(Math.max(0, sepIndex + 2));
-			if (!key) continue;
-			headers.push([key, value]);
-		}
-		return new Response(this.#socket._webResBody, {
-			status: this.statusCode,
-			statusText: this.statusMessage,
-			headers
-		});
-	}
-};
-async function fetchNodeHandler(handler, req) {
-	const nodeRuntime = req.runtime?.node;
-	if (nodeRuntime && nodeRuntime.req && nodeRuntime.res) return await callNodeHandler(handler, req);
-	const socket = new WebRequestSocket(req);
-	const nodeReq = new WebIncomingMessage(req, socket);
-	const nodeRes = new WebServerResponse(nodeReq, socket);
-	try {
-		await handler(nodeReq, nodeRes);
-		return await nodeRes.toWebResponse();
-	} catch (error) {
-		if (!(req.signal?.aborted || error?.name === "AbortError" || error?.code === "ERR_STREAM_PREMATURE_CLOSE")) console.error(error, { cause: {
-			req,
-			handler
-		} });
-		return new Response(null, {
-			status: 500,
-			statusText: "Internal Server Error"
-		});
-	}
-}
-function toNodeHandler(handler, options) {
-	if (handler.__nodeHandler) return handler.__nodeHandler;
-	function convertedNodeHandler(nodeReq, nodeRes) {
-		const res = handler(new NodeRequest({
-			req: nodeReq,
-			res: nodeRes,
-			maxRequestBodySize: options?.maxRequestBodySize,
-			trustProxy: options?.trustProxy
-		}));
-		return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes)) : sendNodeResponse(nodeRes, res);
-	}
-	convertedNodeHandler.__fetchHandler = handler;
-	assignFnName(convertedNodeHandler, handler, " (converted to Node handler)");
-	return convertedNodeHandler;
-}
-function toFetchHandler(handler) {
-	if (handler.__fetchHandler) return handler.__fetchHandler;
-	function convertedNodeHandler(req) {
-		return fetchNodeHandler(handler, req);
-	}
-	convertedNodeHandler.__nodeHandler = handler;
-	assignFnName(convertedNodeHandler, handler, " (converted to Web handler)");
-	return convertedNodeHandler;
-}
-function assignFnName(target, source, suffix) {
-	if (source.name) try {
-		Object.defineProperty(target, "name", { value: `${source.name}${suffix}` });
-	} catch {}
-}
-function serve(options) {
-	return new NodeServer(options);
-}
-var NodeServer = class {
-	runtime = "node";
-	options;
-	node;
-	serveOptions;
-	fetch;
-	waitUntil;
-	#isSecure;
-	#listeningPromise;
-	#listenError;
-	#wait;
-	constructor(options) {
-		this.options = {
-			...options,
-			middleware: [...options.middleware || []]
-		};
-		for (const plugin of options.plugins || []) plugin(this);
-		errorPlugin(this);
-		const fetchHandler = this.fetch = wrapFetch(this);
-		const handler = (nodeReq, nodeRes) => {
-			const reqUrl = nodeReq.url;
-			if (reqUrl && reqUrl[0] !== "/" && reqUrl !== "*" && !URL.canParse(reqUrl)) {
-				nodeRes.statusCode = 400;
-				nodeRes.end();
-				return;
-			}
-			const request = new NodeRequest({
-				req: nodeReq,
-				res: nodeRes,
-				maxRequestBodySize: this.options.maxRequestBodySize,
-				trustProxy: this.options.trustProxy
-			});
-			request.waitUntil = this.#wait?.waitUntil;
-			const res = fetchHandler(request);
-			return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponseDetached(nodeRes, resolvedRes)) : sendNodeResponseDetached(nodeRes, res);
-		};
-		this.node = {
-			handler,
-			server: void 0
-		};
-		const loader = globalThis.__srvxLoader__;
-		if (loader) {
-			loader({ server: this });
-			return;
-		}
-		gracefulShutdownPlugin(this);
-		this.#wait = createWaitUntil();
-		this.waitUntil = this.#wait.waitUntil;
-		const tls = resolveTLSOptions(this.options);
-		const { port, hostname: host } = resolvePortAndHost(this.options);
-		this.serveOptions = {
-			port,
-			host,
-			exclusive: !this.options.reusePort,
-			...tls,
-			...this.options.node
-		};
-		let server;
-		this.#isSecure = !!this.serveOptions.cert && this.options.protocol !== "http";
-		if (this.options.node?.http2 ?? this.#isSecure) if (this.#isSecure) server = nodeHTTP2.createSecureServer({
-			allowHTTP1: true,
-			...this.serveOptions
-		}, handler);
-		else throw new Error("node.http2 option requires tls certificate!");
-		else if (this.#isSecure) server = nodeHTTPS.createServer(this.serveOptions, handler);
-		else server = nodeHTTP.createServer(this.serveOptions, handler);
-		this.node.server = server;
-		if (!options.manual) this.serve().catch(() => {});
-	}
-	serve() {
-		if (this.#listeningPromise) return this.#listeningPromise.then(() => this);
-		const server = this.node?.server;
-		if (!server) return Promise.reject(/* @__PURE__ */ new Error("Server not initialized"));
-		this.#listenError = void 0;
-		this.#listeningPromise = new Promise((resolve, reject) => {
-			const onError = (error) => {
-				server.off("listening", onListening);
-				this.#listenError = error;
-				this.#listeningPromise = void 0;
-				reject(error);
-			};
-			const onListening = () => {
-				server.off("error", onError);
-				printListening(this.options, this.url);
-				resolve();
-			};
-			server.once("error", onError);
-			server.once("listening", onListening);
-			server.listen(this.serveOptions);
-		});
-		return this.#listeningPromise.then(() => this);
-	}
-	get url() {
-		const addr = this.node?.server?.address();
-		if (!addr) return;
-		return typeof addr === "string" ? addr : fmtURL(addr.address, addr.port, this.#isSecure);
-	}
-	ready() {
-		if (this.#listenError) return Promise.reject(this.#listenError);
-		return Promise.resolve(this.#listeningPromise).then(() => this);
-	}
-	async close(closeAll) {
-		await Promise.all([this.#wait?.wait(), new Promise((resolve, reject) => {
-			const server = this.node?.server;
-			if (server && closeAll && "closeAllConnections" in server) server.closeAllConnections();
-			if (!server || !server.listening) return resolve();
-			server.close((error) => error ? reject(error) : resolve());
-		})]);
-	}
-};
-export { NodeResponse as FastResponse, FastURL, NodeRequest, NodeResponse, fetchNodeHandler, patchGlobalRequest, sendNodeResponse, serve, toFetchHandler, toNodeHandler };