nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_libs/httpxy.mjs

@@ -0,0 +1,410 @@
+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
+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);
+	for (const e of [
+		"host",
+		"hostname",
+		"socketPath",
+		"pfx",
+		"key",
+		"passphrase",
+		"cert",
+		"ca",
+		"ciphers",
+		"secureProtocol"
+	]) outgoing[e] = options[forward || "target"][e];
+	outgoing.method = options.method || req.method;
+	outgoing.headers = { ...req.headers };
+	if (options.headers) outgoing.headers = {
+		...outgoing.headers,
+		...options.headers
+	};
+	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;
+	outgoing.agent = options.agent || false;
+	outgoing.localAddress = options.localAddress;
+	if (!outgoing.agent) {
+		outgoing.headers = outgoing.headers || {};
+		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 || "";
+	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;
+	return outgoing;
+}
+function joinURL(base, path) {
+	if (!base || base === "/") return path || "/";
+	if (!path || path === "/") return base || "/";
+	const baseHasTrailing = base[base.length - 1] === "/";
+	const pathHasLeading = path[0] === "/";
+	if (baseHasTrailing && pathHasLeading) return base + path.slice(1);
+	if (!baseHasTrailing && !pathHasLeading) return base + "/" + path;
+	return base + path;
+}
+function setupSocket(socket) {
+	socket.setTimeout(0);
+	socket.setNoDelay(true);
+	socket.setKeepAlive(true, 0);
+	return socket;
+}
+function getPort(req) {
+	const res = req.headers.host ? req.headers.host.match(/:(\d+)/) : "";
+	if (res) return res[1];
+	return hasEncryptedConnection(req) ? "443" : "80";
+}
+function hasEncryptedConnection(req) {
+	return Boolean(req.connection.encrypted || req.connection.pair);
+}
+function rewriteCookieProperty(header, config, property) {
+	if (Array.isArray(header)) return header.map(function(headerElement) {
+		return rewriteCookieProperty(headerElement, config, property);
+	});
+	return header.replace(new RegExp(String.raw`(;\s*` + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
+		let newValue;
+		if (previousValue in config) newValue = config[previousValue];
+		else if ("*" in config) newValue = config["*"];
+		else return match;
+		return newValue ? prefix + newValue : "";
+	});
+}
+function hasPort(host) {
+	return !!~host.indexOf(":");
+}
+function requiresPort(_port, _protocol) {
+	const protocol = _protocol.split(":")[0];
+	const port = +_port;
+	if (!port) return false;
+	switch (protocol) {
+		case "http":
+		case "ws": return port !== 80;
+		case "https":
+		case "wss": return port !== 443;
+		case "ftp": return port !== 21;
+		case "gopher": return port !== 70;
+		case "file": return false;
+	}
+	return port !== 0;
+}
+function defineProxyMiddleware(m) {
+	return m;
+}
+function defineProxyOutgoingMiddleware(m) {
+	return m;
+}
+const redirectRegex = /^201|30([1278])$/;
+const webOutgoingMiddleware = [
+	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
+		if (req.httpVersion === "1.0") 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";
+	}),
+	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 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;
+			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 preserveHeaderKeyCase = options.preserveHeaderKeyCase;
+		let rawHeaderKeyMap;
+		const setHeader = function(key, header) {
+			if (header === void 0) 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);
+		};
+		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) {
+				const key = proxyRes.rawHeaders[i];
+				rawHeaderKeyMap[key.toLowerCase()] = key;
+			}
+		}
+		for (let key of Object.keys(proxyRes.headers)) {
+			const header = proxyRes.headers[key];
+			if (preserveHeaderKeyCase && rawHeaderKeyMap) key = rawHeaderKeyMap[key] || key;
+			setHeader(key, header);
+		}
+	}),
+	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
+		if (proxyRes.statusMessage) {
+			res.statusCode = proxyRes.statusCode;
+			res.statusMessage = proxyRes.statusMessage;
+		} else res.statusCode = proxyRes.statusCode;
+	})
+];
+const nativeAgents = {
+	http,
+	https
+};
+const webIncomingMiddleware = [
+	defineProxyMiddleware((req) => {
+		if ((req.method === "DELETE" || req.method === "OPTIONS") && !req.headers["content-length"]) {
+			req.headers["content-length"] = "0";
+			delete req.headers["transfer-encoding"];
+		}
+	}),
+	defineProxyMiddleware((req, res, options) => {
+		if (options.timeout) req.socket.setTimeout(options.timeout);
+	}),
+	defineProxyMiddleware((req, res, options) => {
+		if (!options.xfwd) return;
+		const encrypted = req.isSpdy || hasEncryptedConnection(req);
+		const values = {
+			for: req.connection.remoteAddress || req.socket.remoteAddress,
+			port: getPort(req),
+			proto: encrypted ? "https" : "http"
+		};
+		for (const header of [
+			"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 || "";
+	}),
+	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;
+		if (options.forward) {
+			const forwardReq = (options.forward.protocol === "https:" ? https$1 : http$1).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
+			const forwardError = createErrorHandler(forwardReq, options.forward);
+			req.on("error", forwardError);
+			forwardReq.on("error", forwardError);
+			(options.buffer || req).pipe(forwardReq);
+			if (!options.target) {
+				res.end();
+				return;
+			}
+		}
+		const proxyReq = (options.target.protocol === "https:" ? https$1 : http$1).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();
+		});
+		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") {
+					server.emit("econnreset", err, req, res, url);
+					return proxyReq2.abort();
+				}
+				if (callback) callback(err, req, res, url);
+				else server.emit("error", err, req, res, url);
+			};
+		}
+		(options.buffer || req).pipe(proxyReq);
+		proxyReq.on("response", function(proxyRes) {
+			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;
+			}
+			if (res.finished) {
+				if (server) server.emit("end", req, res, proxyRes);
+			} else {
+				res.on("close", function() {
+					proxyRes.destroy();
+				});
+				proxyRes.on("end", function() {
+					if (server) server.emit("end", req, res, proxyRes);
+				});
+				if (!options.selfHandleResponse) proxyRes.pipe(res);
+			}
+		});
+	})
+];
+const websocketIncomingMiddleware = [
+	defineProxyMiddleware((req, socket) => {
+		if (req.method !== "GET" || !req.headers.upgrade) {
+			socket.destroy();
+			return true;
+		}
+		if (req.headers.upgrade.toLowerCase() !== "websocket") {
+			socket.destroy();
+			return true;
+		}
+	}),
+	defineProxyMiddleware((req, socket, options) => {
+		if (!options.xfwd) return;
+		const values = {
+			for: req.connection.remoteAddress || req.socket.remoteAddress,
+			port: getPort(req),
+			proto: hasEncryptedConnection(req) ? "wss" : "ws"
+		};
+		for (const header of [
+			"for",
+			"port",
+			"proto"
+		]) req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
+	}),
+	defineProxyMiddleware((req, socket, options, server, head, callback) => {
+		const createHttpHeader = function(line, headers) {
+			return Object.keys(headers).reduce(function(head2, key) {
+				const value = headers[key];
+				if (!Array.isArray(value)) {
+					head2.push(key + ": " + value);
+					return head2;
+				}
+				for (const element of value) head2.push(key + ": " + element);
+				return head2;
+			}, [line]).join("\r\n") + "\r\n\r\n";
+		};
+		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));
+		if (server) server.emit("proxyReqWs", proxyReq, req, socket, options, head);
+		proxyReq.on("error", onOutgoingError);
+		proxyReq.on("response", function(res) {
+			if (!res.upgrade) {
+				socket.write(createHttpHeader("HTTP/" + res.httpVersion + " " + res.statusCode + " " + res.statusMessage, res.headers));
+				res.pipe(socket);
+			}
+		});
+		proxyReq.on("upgrade", function(proxyRes, proxySocket, proxyHead) {
+			proxySocket.on("error", onOutgoingError);
+			proxySocket.on("end", function() {
+				server.emit("close", proxyRes, proxySocket, proxyHead);
+			});
+			socket.on("error", function() {
+				proxySocket.end();
+			});
+			setupSocket(proxySocket);
+			if (proxyHead && proxyHead.length > 0) proxySocket.unshift(proxyHead);
+			socket.write(createHttpHeader("HTTP/1.1 101 Switching Protocols", proxyRes.headers));
+			proxySocket.pipe(socket).pipe(proxySocket);
+			server.emit("open", proxySocket);
+			server.emit("proxySocket", proxySocket);
+		});
+		proxyReq.end();
+		function onOutgoingError(err) {
+			if (callback) callback(err, req, socket);
+			else server.emit("error", err, req, socket);
+			socket.end();
+		}
+	})
+];
+var ProxyServer = class extends EventEmitter {
+	_server;
+	_webPasses = [...webIncomingMiddleware];
+	_wsPasses = [...websocketIncomingMiddleware];
+	options;
+	web;
+	ws;
+	/**
+	* Creates the proxy server with specified options.
+	* @param options - Config object passed to the proxy
+	*/
+	constructor(options = {}) {
+		super();
+		this.options = options || {};
+		this.options.prependPath = options.prependPath !== false;
+		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);
+		};
+		this._server = this.options.ssl ? https.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._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;
+			if (callback) Reflect.apply(callback, void 0, args);
+		});
+	}
+	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;
+		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);
+	}
+	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;
+		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);
+	}
+};
+function createProxyServer(options = {}) {
+	return new ProxyServer(options);
+}
+function _createProxyFn(type, server) {
+	return function(req, res, opts, head) {
+		const requestOptions = {
+			...opts,
+			...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"));
+		let _resolve;
+		let _reject;
+		const callbackPromise = new Promise((resolve, reject) => {
+			_resolve = resolve;
+			_reject = reject;
+		});
+		res.on("close", () => {
+			_resolve();
+		});
+		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);
+		})) {
+			_resolve();
+			break;
+		}
+		return callbackPromise;
+	};
+}
+
+//#endregion
+export { createProxyServer as t };

package/dist/_libs/is-core-module.mjs

@@ -0,0 +1,220 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+import { t as require_hasown } from "./hasown.mjs";
+
+//#region node_modules/.pnpm/is-core-module@2.16.1/node_modules/is-core-module/core.json
+var require_core = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/is-core-module@2.16.1/node_modules/is-core-module/core.json": ((exports, module) => {
+	module.exports = {
+		"assert": true,
+		"node:assert": [">= 14.18 && < 15", ">= 16"],
+		"assert/strict": ">= 15",
+		"node:assert/strict": ">= 16",
+		"async_hooks": ">= 8",
+		"node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+		"buffer_ieee754": ">= 0.5 && < 0.9.7",
+		"buffer": true,
+		"node:buffer": [">= 14.18 && < 15", ">= 16"],
+		"child_process": true,
+		"node:child_process": [">= 14.18 && < 15", ">= 16"],
+		"cluster": ">= 0.5",
+		"node:cluster": [">= 14.18 && < 15", ">= 16"],
+		"console": true,
+		"node:console": [">= 14.18 && < 15", ">= 16"],
+		"constants": true,
+		"node:constants": [">= 14.18 && < 15", ">= 16"],
+		"crypto": true,
+		"node:crypto": [">= 14.18 && < 15", ">= 16"],
+		"_debug_agent": ">= 1 && < 8",
+		"_debugger": "< 8",
+		"dgram": true,
+		"node:dgram": [">= 14.18 && < 15", ">= 16"],
+		"diagnostics_channel": [">= 14.17 && < 15", ">= 15.1"],
+		"node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+		"dns": true,
+		"node:dns": [">= 14.18 && < 15", ">= 16"],
+		"dns/promises": ">= 15",
+		"node:dns/promises": ">= 16",
+		"domain": ">= 0.7.12",
+		"node:domain": [">= 14.18 && < 15", ">= 16"],
+		"events": true,
+		"node:events": [">= 14.18 && < 15", ">= 16"],
+		"freelist": "< 6",
+		"fs": true,
+		"node:fs": [">= 14.18 && < 15", ">= 16"],
+		"fs/promises": [">= 10 && < 10.1", ">= 14"],
+		"node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+		"_http_agent": ">= 0.11.1",
+		"node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+		"_http_client": ">= 0.11.1",
+		"node:_http_client": [">= 14.18 && < 15", ">= 16"],
+		"_http_common": ">= 0.11.1",
+		"node:_http_common": [">= 14.18 && < 15", ">= 16"],
+		"_http_incoming": ">= 0.11.1",
+		"node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+		"_http_outgoing": ">= 0.11.1",
+		"node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+		"_http_server": ">= 0.11.1",
+		"node:_http_server": [">= 14.18 && < 15", ">= 16"],
+		"http": true,
+		"node:http": [">= 14.18 && < 15", ">= 16"],
+		"http2": ">= 8.8",
+		"node:http2": [">= 14.18 && < 15", ">= 16"],
+		"https": true,
+		"node:https": [">= 14.18 && < 15", ">= 16"],
+		"inspector": ">= 8",
+		"node:inspector": [">= 14.18 && < 15", ">= 16"],
+		"inspector/promises": [">= 19"],
+		"node:inspector/promises": [">= 19"],
+		"_linklist": "< 8",
+		"module": true,
+		"node:module": [">= 14.18 && < 15", ">= 16"],
+		"net": true,
+		"node:net": [">= 14.18 && < 15", ">= 16"],
+		"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+		"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+		"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+		"os": true,
+		"node:os": [">= 14.18 && < 15", ">= 16"],
+		"path": true,
+		"node:path": [">= 14.18 && < 15", ">= 16"],
+		"path/posix": ">= 15.3",
+		"node:path/posix": ">= 16",
+		"path/win32": ">= 15.3",
+		"node:path/win32": ">= 16",
+		"perf_hooks": ">= 8.5",
+		"node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+		"process": ">= 1",
+		"node:process": [">= 14.18 && < 15", ">= 16"],
+		"punycode": ">= 0.5",
+		"node:punycode": [">= 14.18 && < 15", ">= 16"],
+		"querystring": true,
+		"node:querystring": [">= 14.18 && < 15", ">= 16"],
+		"readline": true,
+		"node:readline": [">= 14.18 && < 15", ">= 16"],
+		"readline/promises": ">= 17",
+		"node:readline/promises": ">= 17",
+		"repl": true,
+		"node:repl": [">= 14.18 && < 15", ">= 16"],
+		"node:sea": [">= 20.12 && < 21", ">= 21.7"],
+		"smalloc": ">= 0.11.5 && < 3",
+		"node:sqlite": [">= 22.13 && < 23", ">= 23.4"],
+		"_stream_duplex": ">= 0.9.4",
+		"node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+		"_stream_transform": ">= 0.9.4",
+		"node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+		"_stream_wrap": ">= 1.4.1",
+		"node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+		"_stream_passthrough": ">= 0.9.4",
+		"node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+		"_stream_readable": ">= 0.9.4",
+		"node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+		"_stream_writable": ">= 0.9.4",
+		"node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+		"stream": true,
+		"node:stream": [">= 14.18 && < 15", ">= 16"],
+		"stream/consumers": ">= 16.7",
+		"node:stream/consumers": ">= 16.7",
+		"stream/promises": ">= 15",
+		"node:stream/promises": ">= 16",
+		"stream/web": ">= 16.5",
+		"node:stream/web": ">= 16.5",
+		"string_decoder": true,
+		"node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+		"sys": [">= 0.4 && < 0.7", ">= 0.8"],
+		"node:sys": [">= 14.18 && < 15", ">= 16"],
+		"test/reporters": ">= 19.9 && < 20.2",
+		"node:test/reporters": [
+			">= 18.17 && < 19",
+			">= 19.9",
+			">= 20"
+		],
+		"test/mock_loader": ">= 22.3 && < 22.7",
+		"node:test/mock_loader": ">= 22.3 && < 22.7",
+		"node:test": [">= 16.17 && < 17", ">= 18"],
+		"timers": true,
+		"node:timers": [">= 14.18 && < 15", ">= 16"],
+		"timers/promises": ">= 15",
+		"node:timers/promises": ">= 16",
+		"_tls_common": ">= 0.11.13",
+		"node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+		"_tls_legacy": ">= 0.11.3 && < 10",
+		"_tls_wrap": ">= 0.11.3",
+		"node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+		"tls": true,
+		"node:tls": [">= 14.18 && < 15", ">= 16"],
+		"trace_events": ">= 10",
+		"node:trace_events": [">= 14.18 && < 15", ">= 16"],
+		"tty": true,
+		"node:tty": [">= 14.18 && < 15", ">= 16"],
+		"url": true,
+		"node:url": [">= 14.18 && < 15", ">= 16"],
+		"util": true,
+		"node:util": [">= 14.18 && < 15", ">= 16"],
+		"util/types": ">= 15.3",
+		"node:util/types": ">= 16",
+		"v8/tools/arguments": ">= 10 && < 12",
+		"v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8": ">= 1",
+		"node:v8": [">= 14.18 && < 15", ">= 16"],
+		"vm": true,
+		"node:vm": [">= 14.18 && < 15", ">= 16"],
+		"wasi": [
+			">= 13.4 && < 13.5",
+			">= 18.17 && < 19",
+			">= 20"
+		],
+		"node:wasi": [">= 18.17 && < 19", ">= 20"],
+		"worker_threads": ">= 11.7",
+		"node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+		"zlib": ">= 0.5",
+		"node:zlib": [">= 14.18 && < 15", ">= 16"]
+	};
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/is-core-module@2.16.1/node_modules/is-core-module/index.js
+var require_is_core_module = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/is-core-module@2.16.1/node_modules/is-core-module/index.js": ((exports, module) => {
+	var hasOwn = require_hasown();
+	function specifierIncluded(current, specifier) {
+		var nodeParts = current.split(".");
+		var parts = specifier.split(" ");
+		var op = parts.length > 1 ? parts[0] : "=";
+		var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
+		for (var i = 0; i < 3; ++i) {
+			var cur = parseInt(nodeParts[i] || 0, 10);
+			var ver = parseInt(versionParts[i] || 0, 10);
+			if (cur === ver) continue;
+			if (op === "<") return cur < ver;
+			if (op === ">=") return cur >= ver;
+			return false;
+		}
+		return op === ">=";
+	}
+	function matchesRange(current, range) {
+		var specifiers = range.split(/ ?&& ?/);
+		if (specifiers.length === 0) return false;
+		for (var i = 0; i < specifiers.length; ++i) if (!specifierIncluded(current, specifiers[i])) return false;
+		return true;
+	}
+	function versionIncluded(nodeVersion, specifierValue) {
+		if (typeof specifierValue === "boolean") return specifierValue;
+		var current = typeof nodeVersion === "undefined" ? process.versions && process.versions.node : nodeVersion;
+		if (typeof current !== "string") throw new TypeError(typeof nodeVersion === "undefined" ? "Unable to determine current node version" : "If provided, a valid node version is required");
+		if (specifierValue && typeof specifierValue === "object") {
+			for (var i = 0; i < specifierValue.length; ++i) if (matchesRange(current, specifierValue[i])) return true;
+			return false;
+		}
+		return matchesRange(current, specifierValue);
+	}
+	var data = require_core();
+	module.exports = function isCore(x, nodeVersion) {
+		return hasOwn(data, x) && versionIncluded(nodeVersion, data[x]);
+	};
+}) });
+
+//#endregion
+export { require_is_core_module as t };

package/dist/_libs/is-module.mjs

@@ -0,0 +1,13 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/is-module@1.0.0/node_modules/is-module/index.js
+var require_is_module = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/is-module@1.0.0/node_modules/is-module/index.js": ((exports, module) => {
+	var ES6ImportExportRegExp = /(?:^\s*|[}{\(\);,\n]\s*)(import\s+['"]|(import|module)\s+[^"'\(\)\n;]+\s+from\s+['"]|export\s+(\*|\{|default|function|var|const|let|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))/;
+	var ES6AliasRegExp = /(?:^\s*|[}{\(\);,\n]\s*)(export\s*\*\s*from\s*(?:'([^']+)'|"([^"]+)"))/;
+	module.exports = function(sauce) {
+		return ES6ImportExportRegExp.test(sauce) || ES6AliasRegExp.test(sauce);
+	};
+}) });
+
+//#endregion
+export { require_is_module as t };

package/dist/_libs/is-reference.mjs

@@ -0,0 +1,32 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/is-reference@1.2.1/node_modules/is-reference/dist/is-reference.js
+var require_is_reference = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/is-reference@1.2.1/node_modules/is-reference/dist/is-reference.js": ((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = global || self, global.isReference = factory());
+	})(exports, (function() {
+		function isReference(node, parent) {
+			if (node.type === "MemberExpression") return !node.computed && isReference(node.object, node);
+			if (node.type === "Identifier") {
+				if (!parent) return true;
+				switch (parent.type) {
+					case "MemberExpression": return parent.computed || node === parent.object;
+					case "MethodDefinition": return parent.computed;
+					case "FieldDefinition": return parent.computed || node === parent.value;
+					case "Property": return parent.computed || node === parent.value;
+					case "ExportSpecifier":
+					case "ImportSpecifier": return node === parent.local;
+					case "LabeledStatement":
+					case "BreakStatement":
+					case "ContinueStatement": return false;
+					default: return true;
+				}
+			}
+			return false;
+		}
+		return isReference;
+	}));
+}) });
+
+//#endregion
+export { require_is_reference as t };