@vitejs/devtools 0.0.0-alpha.1 → 0.0.0-alpha.3

package/dist/plugins-DDjui9Ga.js

@@ -0,0 +1,1314 @@
+import { dirClientStandalone, dirDist } from "./dirs-B7dOX6eI.js";
+import { existsSync } from "node:fs";
+import Debug from "debug";
+import sirv from "sirv";
+import { defineRpcFunction, getRpcHandler } from "@vitejs/devtools-kit";
+import { DevToolsViteUI } from "@vitejs/devtools-vite";
+import { join } from "node:path";
+import process$1 from "node:process";
+import { normalizePath } from "vite";
+import { createRpcServer } from "@vitejs/devtools-rpc";
+import { createWsRpcPreset } from "@vitejs/devtools-rpc/presets/ws/server";
+import { createServer } from "node:net";
+import { networkInterfaces } from "node:os";
+import "node:fs/promises";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i$1 = 0, n$1 = keys.length, key; i$1 < n$1; i$1++) {
+		key = keys[i$1];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/node/host-docks.ts
+var DevToolsDockHost = class {
+	views = /* @__PURE__ */ new Map();
+	constructor() {}
+	values() {
+		return Array.from(this.views.values());
+	}
+	register(view) {
+		this.views.set(view.id, view);
+	}
+};
+
+//#endregion
+//#region src/node/host-functions.ts
+var RpcFunctionsHost = class {
+	definitions = /* @__PURE__ */ new Map();
+	functions;
+	context = void 0;
+	constructor() {
+		const definitions = this.definitions;
+		const self = this;
+		this.functions = new Proxy({}, {
+			get(_, prop) {
+				const definition = definitions.get(prop);
+				if (!definition) return void 0;
+				return getRpcHandler(definition, self.context);
+			},
+			has(_, prop) {
+				return definitions.has(prop);
+			},
+			getOwnPropertyDescriptor(_, prop) {
+				return {
+					value: definitions.get(prop)?.handler,
+					configurable: true,
+					enumerable: true
+				};
+			},
+			ownKeys() {
+				return Array.from(definitions.keys());
+			}
+		});
+	}
+	register(fn) {
+		this.definitions.set(fn.name, fn);
+	}
+};
+
+//#endregion
+//#region src/node/rpc/list-dock-entries.ts
+const listDockEntries = defineRpcFunction({
+	name: "vite:core:list-dock-entries",
+	type: "query",
+	setup: (context) => {
+		return { handler: () => Array.from(context.docks.values()) };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/list-rpc-functions.ts
+const listRpcFunctions = defineRpcFunction({
+	name: "vite:core:list-rpc-functions",
+	type: "action",
+	setup: (context) => {
+		return { async handler() {
+			return Object.fromEntries(Array.from(context.rpc.definitions.entries()).map(([name, fn]) => [name, { type: fn.type }]));
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/open-in-editor.ts
+const openInEditor = defineRpcFunction({
+	name: "vite:core:open-in-editor",
+	type: "action",
+	setup: () => {
+		return { handler: async (path) => {
+			await import("launch-editor").then((r$2) => r$2.default(path));
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/open-in-finder.ts
+const openInFinder = defineRpcFunction({
+	name: "vite:core:open-in-finder",
+	type: "action",
+	setup: () => {
+		return { handler: async (path) => {
+			await import("open").then((r$2) => r$2.default(path));
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/index.ts
+const builtinRpcFunctions = [
+	listRpcFunctions,
+	listDockEntries,
+	openInEditor,
+	openInFinder
+];
+
+//#endregion
+//#region src/node/context.ts
+const debug = Debug("vite:devtools:context");
+async function createDevToolsContext(viteConfig, viteServer) {
+	const cwd = viteConfig.root;
+	const rpcHost = new RpcFunctionsHost();
+	const docksHost = new DevToolsDockHost();
+	const context = {
+		cwd,
+		viteConfig,
+		viteServer,
+		mode: viteConfig.command === "serve" ? "dev" : "build",
+		rpc: rpcHost,
+		docks: docksHost,
+		hostStatic,
+		staticDirs: []
+	};
+	rpcHost.context = context;
+	function hostStatic(baseUrl, distDir) {
+		if (!existsSync(distDir)) throw new Error(`[Vite DevTools] distDir ${distDir} does not exist`);
+		if (viteConfig.command === "serve") {
+			if (!viteServer) throw new Error("[Vite DevTools] viteServer is required in dev mode");
+			viteServer.middlewares.use(baseUrl, sirv(distDir, {
+				dev: true,
+				single: true
+			}));
+		} else context.staticDirs.push({
+			baseUrl,
+			distDir
+		});
+	}
+	for (const fn of builtinRpcFunctions) rpcHost.register(fn);
+	const plugins = viteConfig.plugins.filter((plugin) => "devtools" in plugin);
+	for (const plugin of plugins) {
+		if (!plugin.devtools?.setup) continue;
+		try {
+			debug(`Setting up plugin ${plugin.name}`);
+			await plugin.devtools?.setup?.(context);
+		} catch (error) {
+			console.error(`[Vite DevTools] Error setting up plugin ${plugin.name}:`, error);
+			throw error;
+		}
+	}
+	return context;
+}
+
+//#endregion
+//#region src/node/plugins/injection.ts
+function DevToolsInjection() {
+	return {
+		name: "vite:devtools:injection",
+		enforce: "post",
+		transformIndexHtml() {
+			return [{
+				tag: "script",
+				attrs: {
+					src: `/@fs/${process$1.env.VITE_DEVTOOLS_LOCAL_DEV ? normalizePath(join(dirDist, "..", "src/client/inject/index.ts")) : normalizePath(join(dirDist, "client/inject.js"))}`,
+					type: "module"
+				},
+				injectTo: "body"
+			}];
+		}
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ufo@1.6.1/node_modules/ufo/dist/index.mjs
+const r$1 = String.fromCharCode;
+const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasProtocol(inputString, opts = {}) {
+	if (typeof opts === "boolean") opts = { acceptRelative: opts };
+	if (opts.strict) return PROTOCOL_STRICT_REGEX.test(inputString);
+	return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+}
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+	}
+	const [s0, ...s$1] = path.split("?");
+	return ((s0.endsWith("/") ? s0.slice(0, -1) : s0) || "/") + (s$1.length > 0 ? `?${s$1.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s$1] = path.split("?");
+	return s0 + "/" + (s$1.length > 0 ? `?${s$1.join("?")}` : "") + fragment;
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+const protocolRelative = Symbol.for("ufo:protocolRelative");
+function parseURL(input = "", defaultProto) {
+	const _specialProtoMatch = input.match(/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i);
+	if (_specialProtoMatch) {
+		const [, _proto, _pathname = ""] = _specialProtoMatch;
+		return {
+			protocol: _proto.toLowerCase(),
+			pathname: _pathname,
+			href: _proto + _pathname,
+			auth: "",
+			host: "",
+			search: "",
+			hash: ""
+		};
+	}
+	if (!hasProtocol(input, { acceptRelative: true })) return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
+	const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+	let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
+	if (protocol === "file:") path = path.replace(/\/(?=[A-Za-z]:)/, "");
+	const { pathname, search, hash } = parsePath(path);
+	return {
+		protocol: protocol.toLowerCase(),
+		auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
+		host,
+		pathname,
+		search,
+		hash,
+		[protocolRelative]: !protocol
+	};
+}
+function parsePath(input = "") {
+	const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+	return {
+		pathname,
+		search,
+		hash
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p$1, c$1) => _defu(p$1, c$1, "", merger), {});
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+	if (object[key] !== void 0 && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+const defuArrayFn = createDefu((object, key, currentValue) => {
+	if (Array.isArray(object[key]) && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/h3@1.15.4/node_modules/h3/dist/index.mjs
+function hasProp(obj, prop) {
+	try {
+		return prop in obj;
+	} catch {
+		return false;
+	}
+}
+var H3Error = class extends Error {
+	static __h3_error__ = true;
+	statusCode = 500;
+	fatal = false;
+	unhandled = false;
+	statusMessage;
+	data;
+	cause;
+	constructor(message, opts = {}) {
+		super(message, opts);
+		if (opts.cause && !this.cause) this.cause = opts.cause;
+	}
+	toJSON() {
+		const obj = {
+			message: this.message,
+			statusCode: sanitizeStatusCode(this.statusCode, 500)
+		};
+		if (this.statusMessage) obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
+		if (this.data !== void 0) obj.data = this.data;
+		return obj;
+	}
+};
+function createError(input) {
+	if (typeof input === "string") return new H3Error(input);
+	if (isError(input)) return input;
+	const err = new H3Error(input.message ?? input.statusMessage ?? "", { cause: input.cause || input });
+	if (hasProp(input, "stack")) try {
+		Object.defineProperty(err, "stack", { get() {
+			return input.stack;
+		} });
+	} catch {
+		try {
+			err.stack = input.stack;
+		} catch {}
+	}
+	if (input.data) err.data = input.data;
+	if (input.statusCode) err.statusCode = sanitizeStatusCode(input.statusCode, err.statusCode);
+	else if (input.status) err.statusCode = sanitizeStatusCode(input.status, err.statusCode);
+	if (input.statusMessage) err.statusMessage = input.statusMessage;
+	else if (input.statusText) err.statusMessage = input.statusText;
+	if (err.statusMessage) {
+		const originalMessage = err.statusMessage;
+		if (sanitizeStatusMessage(err.statusMessage) !== originalMessage) console.warn("[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default.");
+	}
+	if (input.fatal !== void 0) err.fatal = input.fatal;
+	if (input.unhandled !== void 0) err.unhandled = input.unhandled;
+	return err;
+}
+function sendError(event, error, debug$1) {
+	if (event.handled) return;
+	const h3Error = isError(error) ? error : createError(error);
+	const responseBody = {
+		statusCode: h3Error.statusCode,
+		statusMessage: h3Error.statusMessage,
+		stack: [],
+		data: h3Error.data
+	};
+	if (debug$1) responseBody.stack = (h3Error.stack || "").split("\n").map((l$1) => l$1.trim());
+	if (event.handled) return;
+	const _code = Number.parseInt(h3Error.statusCode);
+	setResponseStatus(event, _code, h3Error.statusMessage);
+	event.node.res.setHeader("content-type", MIMES.json);
+	event.node.res.end(JSON.stringify(responseBody, void 0, 2));
+}
+function isError(input) {
+	return input?.constructor?.__h3_error__ === true;
+}
+const RawBodySymbol = Symbol.for("h3RawBody");
+const ParsedBodySymbol = Symbol.for("h3ParsedBody");
+const MIMES = {
+	html: "text/html",
+	json: "application/json"
+};
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+	if (!statusCode) return defaultStatusCode;
+	if (typeof statusCode === "string") statusCode = Number.parseInt(statusCode, 10);
+	if (statusCode < 100 || statusCode > 999) return defaultStatusCode;
+	return statusCode;
+}
+function splitCookiesString(cookiesString) {
+	if (Array.isArray(cookiesString)) return cookiesString.flatMap((c$1) => splitCookiesString(c$1));
+	if (typeof cookiesString !== "string") return [];
+	const cookiesStrings = [];
+	let pos = 0;
+	let start;
+	let ch;
+	let lastComma;
+	let nextStart;
+	let cookiesSeparatorFound;
+	const skipWhitespace = () => {
+		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
+		return pos < cookiesString.length;
+	};
+	const notSpecialChar = () => {
+		ch = cookiesString.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	};
+	while (pos < cookiesString.length) {
+		start = pos;
+		cookiesSeparatorFound = false;
+		while (skipWhitespace()) {
+			ch = cookiesString.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+				skipWhitespace();
+				nextStart = pos;
+				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
+				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(cookiesString.slice(start, lastComma));
+					start = pos;
+				} else pos = lastComma + 1;
+			} else pos += 1;
+		}
+		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start));
+	}
+	return cookiesStrings;
+}
+const defer = typeof setImmediate === "undefined" ? (fn) => fn() : setImmediate;
+function send(event, data, type) {
+	if (type) defaultContentType(event, type);
+	return new Promise((resolve) => {
+		defer(() => {
+			if (!event.handled) event.node.res.end(data);
+			resolve();
+		});
+	});
+}
+function sendNoContent(event, code) {
+	if (event.handled) return;
+	if (!code && event.node.res.statusCode !== 200) code = event.node.res.statusCode;
+	const _code = sanitizeStatusCode(code, 204);
+	if (_code === 204) event.node.res.removeHeader("content-length");
+	event.node.res.writeHead(_code);
+	event.node.res.end();
+}
+function setResponseStatus(event, code, text) {
+	if (code) event.node.res.statusCode = sanitizeStatusCode(code, event.node.res.statusCode);
+	if (text) event.node.res.statusMessage = sanitizeStatusMessage(text);
+}
+function defaultContentType(event, type) {
+	if (type && event.node.res.statusCode !== 304 && !event.node.res.getHeader("content-type")) event.node.res.setHeader("content-type", type);
+}
+function sendRedirect(event, location, code = 302) {
+	event.node.res.statusCode = sanitizeStatusCode(code, event.node.res.statusCode);
+	event.node.res.setHeader("location", location);
+	const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${location.replace(/"/g, "%22")}"></head></html>`;
+	return send(event, html, MIMES.html);
+}
+function isStream(data) {
+	if (!data || typeof data !== "object") return false;
+	if (typeof data.pipe === "function") {
+		if (typeof data._read === "function") return true;
+		if (typeof data.abort === "function") return true;
+	}
+	if (typeof data.pipeTo === "function") return true;
+	return false;
+}
+function isWebResponse(data) {
+	return typeof Response !== "undefined" && data instanceof Response;
+}
+function sendStream(event, stream) {
+	if (!stream || typeof stream !== "object") throw new Error("[h3] Invalid stream provided.");
+	event.node.res._data = stream;
+	if (!event.node.res.socket) {
+		event._handled = true;
+		return Promise.resolve();
+	}
+	if (hasProp(stream, "pipeTo") && typeof stream.pipeTo === "function") return stream.pipeTo(new WritableStream({ write(chunk) {
+		event.node.res.write(chunk);
+	} })).then(() => {
+		event.node.res.end();
+	});
+	if (hasProp(stream, "pipe") && typeof stream.pipe === "function") return new Promise((resolve, reject) => {
+		stream.pipe(event.node.res);
+		if (stream.on) {
+			stream.on("end", () => {
+				event.node.res.end();
+				resolve();
+			});
+			stream.on("error", (error) => {
+				reject(error);
+			});
+		}
+		event.node.res.on("close", () => {
+			if (stream.abort) stream.abort();
+		});
+	});
+	throw new Error("[h3] Invalid or incompatible stream provided.");
+}
+function sendWebResponse(event, response) {
+	for (const [key, value] of response.headers) if (key === "set-cookie") event.node.res.appendHeader(key, splitCookiesString(value));
+	else event.node.res.setHeader(key, value);
+	if (response.status) event.node.res.statusCode = sanitizeStatusCode(response.status, event.node.res.statusCode);
+	if (response.statusText) event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
+	if (response.redirected) event.node.res.setHeader("location", response.url);
+	if (!response.body) {
+		event.node.res.end();
+		return;
+	}
+	return sendStream(event, response.body);
+}
+const getSessionPromise = Symbol("getSession");
+var H3Event = class {
+	"__is_event__" = true;
+	node;
+	web;
+	context = {};
+	_method;
+	_path;
+	_headers;
+	_requestBody;
+	_handled = false;
+	_onBeforeResponseCalled;
+	_onAfterResponseCalled;
+	constructor(req, res) {
+		this.node = {
+			req,
+			res
+		};
+	}
+	get method() {
+		if (!this._method) this._method = (this.node.req.method || "GET").toUpperCase();
+		return this._method;
+	}
+	get path() {
+		return this._path || this.node.req.url || "/";
+	}
+	get headers() {
+		if (!this._headers) this._headers = _normalizeNodeHeaders(this.node.req.headers);
+		return this._headers;
+	}
+	get handled() {
+		return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
+	}
+	respondWith(response) {
+		return Promise.resolve(response).then((_response) => sendWebResponse(this, _response));
+	}
+	toString() {
+		return `[${this.method}] ${this.path}`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	/** @deprecated Please use `event.node.req` instead. */
+	get req() {
+		return this.node.req;
+	}
+	/** @deprecated Please use `event.node.res` instead. */
+	get res() {
+		return this.node.res;
+	}
+};
+function createEvent(req, res) {
+	return new H3Event(req, res);
+}
+function _normalizeNodeHeaders(nodeHeaders) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(nodeHeaders)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+	else if (value) headers.set(name, value);
+	return headers;
+}
+function defineEventHandler(handler) {
+	if (typeof handler === "function") {
+		handler.__is_handler__ = true;
+		return handler;
+	}
+	const _hooks = {
+		onRequest: _normalizeArray(handler.onRequest),
+		onBeforeResponse: _normalizeArray(handler.onBeforeResponse)
+	};
+	const _handler = (event) => {
+		return _callHandler(event, handler.handler, _hooks);
+	};
+	_handler.__is_handler__ = true;
+	_handler.__resolve__ = handler.handler.__resolve__;
+	_handler.__websocket__ = handler.websocket;
+	return _handler;
+}
+function _normalizeArray(input) {
+	return input ? Array.isArray(input) ? input : [input] : void 0;
+}
+async function _callHandler(event, handler, hooks) {
+	if (hooks.onRequest) for (const hook of hooks.onRequest) {
+		await hook(event);
+		if (event.handled) return;
+	}
+	const response = { body: await handler(event) };
+	if (hooks.onBeforeResponse) for (const hook of hooks.onBeforeResponse) await hook(event, response);
+	return response.body;
+}
+const eventHandler = defineEventHandler;
+function isEventHandler(input) {
+	return hasProp(input, "__is_handler__");
+}
+function toEventHandler(input, _, _route) {
+	if (!isEventHandler(input)) console.warn("[h3] Implicit event handler conversion is deprecated. Use `eventHandler()` or `fromNodeMiddleware()` to define event handlers.", _route && _route !== "/" ? `
+     Route: ${_route}` : "", `
+     Handler: ${input}`);
+	return input;
+}
+function defineLazyEventHandler(factory) {
+	let _promise;
+	let _resolved;
+	const resolveHandler = () => {
+		if (_resolved) return Promise.resolve(_resolved);
+		if (!_promise) _promise = Promise.resolve(factory()).then((r$2) => {
+			const handler2 = r$2.default || r$2;
+			if (typeof handler2 !== "function") throw new TypeError("Invalid lazy handler result. It should be a function:", handler2);
+			_resolved = { handler: toEventHandler(r$2.default || r$2) };
+			return _resolved;
+		});
+		return _promise;
+	};
+	const handler = eventHandler((event) => {
+		if (_resolved) return _resolved.handler(event);
+		return resolveHandler().then((r$2) => r$2.handler(event));
+	});
+	handler.__resolve__ = resolveHandler;
+	return handler;
+}
+const lazyEventHandler = defineLazyEventHandler;
+const H3Headers = globalThis.Headers;
+const H3Response = globalThis.Response;
+function createApp(options = {}) {
+	const stack = [];
+	const handler = createAppEventHandler(stack, options);
+	const resolve = createResolver(stack);
+	handler.__resolve__ = resolve;
+	const getWebsocket = cachedFn(() => websocketOptions(resolve, options));
+	const app = {
+		use: (arg1, arg2, arg3) => use(app, arg1, arg2, arg3),
+		resolve,
+		handler,
+		stack,
+		options,
+		get websocket() {
+			return getWebsocket();
+		}
+	};
+	return app;
+}
+function use(app, arg1, arg2, arg3) {
+	if (Array.isArray(arg1)) for (const i$1 of arg1) use(app, i$1, arg2, arg3);
+	else if (Array.isArray(arg2)) for (const i$1 of arg2) use(app, arg1, i$1, arg3);
+	else if (typeof arg1 === "string") app.stack.push(normalizeLayer({
+		...arg3,
+		route: arg1,
+		handler: arg2
+	}));
+	else if (typeof arg1 === "function") app.stack.push(normalizeLayer({
+		...arg2,
+		handler: arg1
+	}));
+	else app.stack.push(normalizeLayer({ ...arg1 }));
+	return app;
+}
+function createAppEventHandler(stack, options) {
+	const spacing = options.debug ? 2 : void 0;
+	return eventHandler(async (event) => {
+		event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
+		const _reqPath = event._path || event.node.req.url || "/";
+		let _layerPath;
+		if (options.onRequest) await options.onRequest(event);
+		for (const layer of stack) {
+			if (layer.route.length > 1) {
+				if (!_reqPath.startsWith(layer.route)) continue;
+				_layerPath = _reqPath.slice(layer.route.length) || "/";
+			} else _layerPath = _reqPath;
+			if (layer.match && !layer.match(_layerPath, event)) continue;
+			event._path = _layerPath;
+			event.node.req.url = _layerPath;
+			const val = await layer.handler(event);
+			const _body = val === void 0 ? void 0 : await val;
+			if (_body !== void 0) {
+				const _response = { body: _body };
+				if (options.onBeforeResponse) {
+					event._onBeforeResponseCalled = true;
+					await options.onBeforeResponse(event, _response);
+				}
+				await handleHandlerResponse(event, _response.body, spacing);
+				if (options.onAfterResponse) {
+					event._onAfterResponseCalled = true;
+					await options.onAfterResponse(event, _response);
+				}
+				return;
+			}
+			if (event.handled) {
+				if (options.onAfterResponse) {
+					event._onAfterResponseCalled = true;
+					await options.onAfterResponse(event, void 0);
+				}
+				return;
+			}
+		}
+		if (!event.handled) throw createError({
+			statusCode: 404,
+			statusMessage: `Cannot find any path matching ${event.path || "/"}.`
+		});
+		if (options.onAfterResponse) {
+			event._onAfterResponseCalled = true;
+			await options.onAfterResponse(event, void 0);
+		}
+	});
+}
+function createResolver(stack) {
+	return async (path) => {
+		let _layerPath;
+		for (const layer of stack) {
+			if (layer.route === "/" && !layer.handler.__resolve__) continue;
+			if (!path.startsWith(layer.route)) continue;
+			_layerPath = path.slice(layer.route.length) || "/";
+			if (layer.match && !layer.match(_layerPath, void 0)) continue;
+			let res = {
+				route: layer.route,
+				handler: layer.handler
+			};
+			if (res.handler.__resolve__) {
+				const _res = await res.handler.__resolve__(_layerPath);
+				if (!_res) continue;
+				res = {
+					...res,
+					..._res,
+					route: joinURL(res.route || "/", _res.route || "/")
+				};
+			}
+			return res;
+		}
+	};
+}
+function normalizeLayer(input) {
+	let handler = input.handler;
+	if (handler.handler) handler = handler.handler;
+	if (input.lazy) handler = lazyEventHandler(handler);
+	else if (!isEventHandler(handler)) handler = toEventHandler(handler, void 0, input.route);
+	return {
+		route: withoutTrailingSlash(input.route),
+		match: input.match,
+		handler
+	};
+}
+function handleHandlerResponse(event, val, jsonSpace) {
+	if (val === null) return sendNoContent(event);
+	if (val) {
+		if (isWebResponse(val)) return sendWebResponse(event, val);
+		if (isStream(val)) return sendStream(event, val);
+		if (val.buffer) return send(event, val);
+		if (val.arrayBuffer && typeof val.arrayBuffer === "function") return val.arrayBuffer().then((arrayBuffer) => {
+			return send(event, Buffer.from(arrayBuffer), val.type);
+		});
+		if (val instanceof Error) throw createError(val);
+		if (typeof val.end === "function") return true;
+	}
+	const valType = typeof val;
+	if (valType === "string") return send(event, val, MIMES.html);
+	if (valType === "object" || valType === "boolean" || valType === "number") return send(event, JSON.stringify(val, void 0, jsonSpace), MIMES.json);
+	if (valType === "bigint") return send(event, val.toString(), MIMES.json);
+	throw createError({
+		statusCode: 500,
+		statusMessage: `[h3] Cannot send ${valType} as response.`
+	});
+}
+function cachedFn(fn) {
+	let cache;
+	return () => {
+		if (!cache) cache = fn();
+		return cache;
+	};
+}
+function websocketOptions(evResolver, appOptions) {
+	return {
+		...appOptions.websocket,
+		async resolve(info) {
+			const url = info.request?.url || info.url || "/";
+			const { pathname } = typeof url === "string" ? parseURL(url) : url;
+			return (await evResolver(pathname))?.handler?.__websocket__ || {};
+		}
+	};
+}
+function fromNodeMiddleware(handler) {
+	if (isEventHandler(handler)) return handler;
+	if (typeof handler !== "function") throw new TypeError("Invalid handler. It should be a function:", handler);
+	return eventHandler((event) => {
+		return callNodeListener(handler, event.node.req, event.node.res);
+	});
+}
+function toNodeListener(app) {
+	const toNodeHandle = async function(req, res) {
+		const event = createEvent(req, res);
+		try {
+			await app.handler(event);
+		} catch (_error) {
+			const error = createError(_error);
+			if (!isError(_error)) error.unhandled = true;
+			setResponseStatus(event, error.statusCode, error.statusMessage);
+			if (app.options.onError) await app.options.onError(error, event);
+			if (event.handled) return;
+			if (error.unhandled || error.fatal) console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
+			if (app.options.onBeforeResponse && !event._onBeforeResponseCalled) await app.options.onBeforeResponse(event, { body: error });
+			await sendError(event, error, !!app.options.debug);
+			if (app.options.onAfterResponse && !event._onAfterResponseCalled) await app.options.onAfterResponse(event, { body: error });
+		}
+	};
+	return toNodeHandle;
+}
+function callNodeListener(handler, req, res) {
+	const isMiddleware = handler.length > 2;
+	return new Promise((resolve, reject) => {
+		const next = (err) => {
+			if (isMiddleware) {
+				res.off("close", next);
+				res.off("error", next);
+			}
+			return err ? reject(createError(err)) : resolve(void 0);
+		};
+		try {
+			const returned = handler(req, res, next);
+			if (isMiddleware && returned === void 0) {
+				res.once("close", next);
+				res.once("error", next);
+			} else resolve(returned);
+		} catch (error) {
+			next(error);
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ansis@4.2.0/node_modules/ansis/index.cjs
+var require_ansis = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ansis@4.2.0/node_modules/ansis/index.cjs": ((exports, module) => {
+	let e, t, r, { defineProperty: l, setPrototypeOf: n, create: o, keys: s } = Object, i = "", { round: c, max: a$1 } = Math, p = (e$1) => {
+		let t$1 = /([a-f\d]{3,6})/i.exec(e$1)?.[1], r$2 = t$1?.length, l$1 = parseInt(6 ^ r$2 ? 3 ^ r$2 ? "0" : t$1[0] + t$1[0] + t$1[1] + t$1[1] + t$1[2] + t$1[2] : t$1, 16);
+		return [
+			l$1 >> 16 & 255,
+			l$1 >> 8 & 255,
+			255 & l$1
+		];
+	}, u = (e$1, t$1, r$2) => e$1 ^ t$1 || t$1 ^ r$2 ? 16 + 36 * c(e$1 / 51) + 6 * c(t$1 / 51) + c(r$2 / 51) : 8 > e$1 ? 16 : e$1 > 248 ? 231 : c(24 * (e$1 - 8) / 247) + 232, d = (e$1) => {
+		let t$1, r$2, l$1, n$1, o$1;
+		return 8 > e$1 ? 30 + e$1 : 16 > e$1 ? e$1 - 8 + 90 : (232 > e$1 ? (o$1 = (e$1 -= 16) % 36, t$1 = (e$1 / 36 | 0) / 5, r$2 = (o$1 / 6 | 0) / 5, l$1 = o$1 % 6 / 5) : t$1 = r$2 = l$1 = (10 * (e$1 - 232) + 8) / 255, n$1 = 2 * a$1(t$1, r$2, l$1), n$1 ? 30 + (c(l$1) << 2 | c(r$2) << 1 | c(t$1)) + (2 ^ n$1 ? 0 : 60) : 30);
+	}, f = (() => {
+		let r$2 = (e$1) => o$1.some(((t$1) => e$1.test(t$1))), l$1 = globalThis, n$1 = l$1.process ?? {}, o$1 = n$1.argv ?? [], i$1 = n$1.env ?? {}, c$1 = -1;
+		try {
+			e = "," + s(i$1).join(",");
+		} catch (e$1) {
+			i$1 = {}, c$1 = 0;
+		}
+		let a$2 = "FORCE_COLOR", p$1 = {
+			false: 0,
+			0: 0,
+			1: 1,
+			2: 2,
+			3: 3
+		}[i$1[a$2]] ?? -1, u$1 = a$2 in i$1 && p$1 || r$2(/^--color=?(true|always)?$/);
+		return u$1 && (c$1 = p$1), ~c$1 || (c$1 = ((r$3, l$2, n$2) => (t = r$3.TERM, {
+			"24bit": 3,
+			truecolor: 3,
+			ansi256: 2,
+			ansi: 1
+		}[r$3.COLORTERM] || (r$3.CI ? /,GITHUB/.test(e) ? 3 : 1 : l$2 && "dumb" !== t ? n$2 ? 3 : /-256/.test(t) ? 2 : 1 : 0)))(i$1, !!i$1.PM2_HOME || i$1.NEXT_RUNTIME?.includes("edge") || !!n$1.stdout?.isTTY, "win32" === n$1.platform)), !p$1 || i$1.NO_COLOR || r$2(/^--(no-color|color=(false|never))$/) ? 0 : l$1.window?.chrome || u$1 && !c$1 ? 3 : c$1;
+	})(), g = {
+		open: i,
+		close: i
+	}, h = 39, b = 49, O = {}, m = ({ p: e$1 }, { open: t$1, close: l$1 }) => {
+		let o$1 = (e$2, ...r$2) => {
+			if (!e$2) {
+				if (t$1 && t$1 === l$1) return t$1;
+				if ((e$2 ?? i) === i) return i;
+			}
+			let n$1, s$2 = e$2.raw ? String.raw({ raw: e$2 }, ...r$2) : i + e$2, c$2 = o$1.p, a$2 = c$2.o, p$1 = c$2.c;
+			if (s$2.includes("\x1B")) for (; c$2; c$2 = c$2.p) {
+				let { open: e$3, close: t$2 } = c$2, r$3 = t$2.length, l$2 = i, o$2 = 0;
+				if (r$3) for (; ~(n$1 = s$2.indexOf(t$2, o$2)); o$2 = n$1 + r$3) l$2 += s$2.slice(o$2, n$1) + e$3;
+				s$2 = l$2 + s$2.slice(o$2);
+			}
+			return a$2 + (s$2.includes("\n") ? s$2.replace(/(\r?\n)/g, p$1 + "$1" + a$2) : s$2) + p$1;
+		}, s$1 = t$1, c$1 = l$1;
+		return e$1 && (s$1 = e$1.o + t$1, c$1 = l$1 + e$1.c), n(o$1, r), o$1.p = {
+			open: t$1,
+			close: l$1,
+			o: s$1,
+			c: c$1,
+			p: e$1
+		}, o$1.open = s$1, o$1.close = c$1, o$1;
+	};
+	const w = new function e$1(t$1 = f) {
+		let s$1 = {
+			Ansis: e$1,
+			level: t$1,
+			isSupported: () => a$2,
+			strip: (e$2) => e$2.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, i),
+			extend(e$2) {
+				for (let t$2 in e$2) {
+					let r$2 = e$2[t$2], l$1 = (typeof r$2)[0];
+					"s" === l$1 ? (c$1(t$2, T(...p(r$2))), c$1(_(t$2), v(...p(r$2)))) : c$1(t$2, r$2, "f" === l$1);
+				}
+				return r = o({}, O), n(s$1, r), s$1;
+			}
+		}, c$1 = (e$2, t$2, r$2) => {
+			O[e$2] = { get() {
+				let n$1 = r$2 ? (...e$3) => m(this, t$2(...e$3)) : m(this, t$2);
+				return l(this, e$2, { value: n$1 }), n$1;
+			} };
+		}, a$2 = t$1 > 0, w$1 = (e$2, t$2) => a$2 ? {
+			open: `[${e$2}m`,
+			close: `[${t$2}m`
+		} : g, y = (e$2) => (t$2) => e$2(...p(t$2)), R = (e$2, t$2) => (r$2, l$1, n$1) => w$1(`${e$2}8;2;${r$2};${l$1};${n$1}`, t$2), $ = (e$2, t$2) => (r$2, l$1, n$1) => w$1(((e$3, t$3, r$3) => d(u(e$3, t$3, r$3)))(r$2, l$1, n$1) + e$2, t$2), x = (e$2) => (t$2, r$2, l$1) => e$2(u(t$2, r$2, l$1)), T = R(3, h), v = R(4, b), C = (e$2) => w$1("38;5;" + e$2, h), E = (e$2) => w$1("48;5;" + e$2, b);
+		2 === t$1 ? (T = x(C), v = x(E)) : 1 === t$1 && (T = $(0, h), v = $(10, b), C = (e$2) => w$1(d(e$2), h), E = (e$2) => w$1(d(e$2) + 10, b));
+		let M, I = {
+			fg: C,
+			bg: E,
+			rgb: T,
+			bgRgb: v,
+			hex: y(T),
+			bgHex: y(v),
+			visible: g,
+			reset: w$1(0, 0),
+			bold: w$1(1, 22),
+			dim: w$1(2, 22),
+			italic: w$1(3, 23),
+			underline: w$1(4, 24),
+			inverse: w$1(7, 27),
+			hidden: w$1(8, 28),
+			strikethrough: w$1(9, 29)
+		}, _ = (e$2) => "bg" + e$2[0].toUpperCase() + e$2.slice(1), k = "Bright";
+		return "black,red,green,yellow,blue,magenta,cyan,white,gray".split(",").map(((e$2, t$2) => {
+			M = _(e$2), 8 > t$2 ? (I[e$2 + k] = w$1(90 + t$2, h), I[M + k] = w$1(100 + t$2, b)) : t$2 = 60, I[e$2] = w$1(30 + t$2, h), I[M] = w$1(40 + t$2, b);
+		})), s$1.extend(I);
+	}();
+	module.exports = w, w.default = w;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/ansis@4.2.0/node_modules/ansis/index.mjs
+var import_ansis = /* @__PURE__ */ __toESM(require_ansis(), 1);
+var ansis_default = import_ansis.default;
+const { Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, bold, dim, italic, underline, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = import_ansis.default;
+
+//#endregion
+//#region ../../node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.mjs
+const unsafePorts = /* @__PURE__ */ new Set([
+	1,
+	7,
+	9,
+	11,
+	13,
+	15,
+	17,
+	19,
+	20,
+	21,
+	22,
+	23,
+	25,
+	37,
+	42,
+	43,
+	53,
+	69,
+	77,
+	79,
+	87,
+	95,
+	101,
+	102,
+	103,
+	104,
+	109,
+	110,
+	111,
+	113,
+	115,
+	117,
+	119,
+	123,
+	135,
+	137,
+	139,
+	143,
+	161,
+	179,
+	389,
+	427,
+	465,
+	512,
+	513,
+	514,
+	515,
+	526,
+	530,
+	531,
+	532,
+	540,
+	548,
+	554,
+	556,
+	563,
+	587,
+	601,
+	636,
+	989,
+	990,
+	993,
+	995,
+	1719,
+	1720,
+	1723,
+	2049,
+	3659,
+	4045,
+	5060,
+	5061,
+	6e3,
+	6566,
+	6665,
+	6666,
+	6667,
+	6668,
+	6669,
+	6697,
+	10080
+]);
+function isUnsafePort(port) {
+	return unsafePorts.has(port);
+}
+function isSafePort(port) {
+	return !isUnsafePort(port);
+}
+var GetPortError = class extends Error {
+	constructor(message, opts) {
+		super(message, opts);
+		this.message = message;
+	}
+	name = "GetPortError";
+};
+function _log(verbose, message) {
+	if (verbose) console.log(`[get-port] ${message}`);
+}
+function _generateRange(from, to) {
+	if (to < from) return [];
+	const r$2 = [];
+	for (let index = from; index <= to; index++) r$2.push(index);
+	return r$2;
+}
+function _tryPort(port, host) {
+	return new Promise((resolve) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", () => {
+			resolve(false);
+		});
+		server.listen({
+			port,
+			host
+		}, () => {
+			const { port: port2 } = server.address();
+			server.close(() => {
+				resolve(isSafePort(port2) && port2);
+			});
+		});
+	});
+}
+function _getLocalHosts(additional) {
+	const hosts = new Set(additional);
+	for (const _interface of Object.values(networkInterfaces())) for (const config of _interface || []) if (config.address && !config.internal && !config.address.startsWith("fe80::") && !config.address.startsWith("169.254")) hosts.add(config.address);
+	return [...hosts];
+}
+async function _findPort(ports, host) {
+	for (const port of ports) {
+		const r$2 = await _tryPort(port, host);
+		if (r$2) return r$2;
+	}
+}
+function _fmtOnHost(hostname) {
+	return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
+}
+const HOSTNAME_RE = /^(?!-)[\d.:A-Za-z-]{1,63}(?<!-)$/;
+function _validateHostname(hostname, _public, verbose) {
+	if (hostname && !HOSTNAME_RE.test(hostname)) {
+		const fallbackHost = _public ? "0.0.0.0" : "127.0.0.1";
+		_log(verbose, `Invalid hostname: ${JSON.stringify(hostname)}. Using ${JSON.stringify(fallbackHost)} as fallback.`);
+		return fallbackHost;
+	}
+	return hostname;
+}
+async function getPort(_userOptions = {}) {
+	if (typeof _userOptions === "number" || typeof _userOptions === "string") _userOptions = { port: Number.parseInt(_userOptions + "") || 0 };
+	const _port = Number(_userOptions.port ?? process.env.PORT);
+	const _userSpecifiedAnyPort = Boolean(_userOptions.port || _userOptions.ports?.length || _userOptions.portRange?.length);
+	const options = {
+		random: _port === 0,
+		ports: [],
+		portRange: [],
+		alternativePortRange: _userSpecifiedAnyPort ? [] : [3e3, 3100],
+		verbose: false,
+		..._userOptions,
+		port: _port,
+		host: _validateHostname(_userOptions.host ?? process.env.HOST, _userOptions.public, _userOptions.verbose)
+	};
+	if (options.random && !_userSpecifiedAnyPort) return getRandomPort(options.host);
+	const portsToCheck = [
+		options.port,
+		...options.ports,
+		..._generateRange(...options.portRange)
+	].filter((port) => {
+		if (!port) return false;
+		if (!isSafePort(port)) {
+			_log(options.verbose, `Ignoring unsafe port: ${port}`);
+			return false;
+		}
+		return true;
+	});
+	if (portsToCheck.length === 0) portsToCheck.push(3e3);
+	let availablePort = await _findPort(portsToCheck, options.host);
+	if (!availablePort && options.alternativePortRange.length > 0) {
+		availablePort = await _findPort(_generateRange(...options.alternativePortRange), options.host);
+		if (portsToCheck.length > 0) {
+			let message = `Unable to find an available port (tried ${portsToCheck.join("-")} ${_fmtOnHost(options.host)}).`;
+			if (availablePort) message += ` Using alternative port ${availablePort}.`;
+			_log(options.verbose, message);
+		}
+	}
+	if (!availablePort && _userOptions.random !== false) {
+		availablePort = await getRandomPort(options.host);
+		if (availablePort) _log(options.verbose, `Using random port ${availablePort}`);
+	}
+	if (!availablePort) {
+		const triedRanges = [
+			options.port,
+			options.portRange.join("-"),
+			options.alternativePortRange.join("-")
+		].filter(Boolean).join(", ");
+		throw new GetPortError(`Unable to find an available port ${_fmtOnHost(options.host)} (tried ${triedRanges})`);
+	}
+	return availablePort;
+}
+async function getRandomPort(host) {
+	const port = await checkPort(0, host);
+	if (port === false) throw new GetPortError(`Unable to find a random port ${_fmtOnHost(host)}`);
+	return port;
+}
+async function checkPort(port, host = process.env.HOST, verbose) {
+	if (!host) host = _getLocalHosts([void 0, "0.0.0.0"]);
+	if (!Array.isArray(host)) return _tryPort(port, host);
+	for (const _host of host) {
+		const _port = await _tryPort(port, _host);
+		if (_port === false) {
+			if (port < 1024 && verbose) _log(verbose, `Unable to listen to the privileged port ${port} ${_fmtOnHost(_host)}`);
+			return false;
+		}
+		if (port === 0 && _port !== 0) port = _port;
+	}
+	return port;
+}
+
+//#endregion
+//#region src/node/constants.ts
+const MARK_CHECK = ansis_default.green("✔");
+const MARK_INFO = ansis_default.blue("ℹ");
+const MARK_ERROR = ansis_default.red("✖");
+const MARK_NODE = "⬢";
+
+//#endregion
+//#region src/node/ws.ts
+async function createWsServer(options) {
+	const rpcHost = options.context.rpc;
+	const port = options.portWebSocket ?? await getPort({
+		port: 7812,
+		random: true
+	});
+	const wsClients = /* @__PURE__ */ new Set();
+	const preset = createWsRpcPreset({
+		port,
+		onConnected: (ws) => {
+			wsClients.add(ws);
+			console.log(ansis_default.green`${MARK_CHECK} Websocket client connected`);
+		},
+		onDisconnected: (ws) => {
+			wsClients.delete(ws);
+			console.log(ansis_default.red`${MARK_CHECK} Websocket client disconnected`);
+		}
+	});
+	const rpc = createRpcServer(rpcHost.functions, {
+		preset,
+		rpcOptions: { onError(error, name) {
+			console.error(ansis_default.red`⬢ RPC error on executing "${ansis_default.bold(name)}":`);
+			console.error(error);
+			throw error;
+		} }
+	});
+	const getMetadata = async () => {
+		return {
+			backend: "websocket",
+			websocket: port
+		};
+	};
+	return {
+		port,
+		rpc,
+		functions: rpcHost,
+		getMetadata
+	};
+}
+
+//#endregion
+//#region src/node/server.ts
+async function createDevToolsMiddleware(options) {
+	const app = createApp();
+	const { rpc, getMetadata } = await createWsServer(options);
+	app.use("/api/connection.json", eventHandler(async (event) => {
+		event.node.res.setHeader("Content-Type", "application/json");
+		return event.node.res.end(JSON.stringify(await getMetadata()));
+	}));
+	app.use(fromNodeMiddleware(sirv(dirClientStandalone, {
+		dev: true,
+		single: true
+	})));
+	return {
+		h3: app,
+		middleware: toNodeListener(app),
+		rpc
+	};
+}
+
+//#endregion
+//#region src/node/plugins/server.ts
+/**
+* Core plugin for enabling Vite DevTools
+*/
+function DevToolsServer() {
+	return {
+		name: "vite:devtools:server",
+		enforce: "post",
+		apply: "serve",
+		async configureServer(viteDevServer) {
+			const context = await createDevToolsContext(viteDevServer.config, viteDevServer);
+			const { middleware } = await createDevToolsMiddleware({
+				cwd: viteDevServer.config.root,
+				context
+			});
+			viteDevServer.middlewares.use("/__vite_devtools__/", middleware);
+		}
+	};
+}
+
+//#endregion
+//#region src/node/plugins/index.ts
+function DevTools(options = {}) {
+	const { builtinDevTools = true } = options;
+	const plugins = [DevToolsInjection(), DevToolsServer()];
+	if (builtinDevTools) plugins.push(DevToolsViteUI());
+	return plugins;
+}
+
+//#endregion
+export { DevTools, MARK_NODE, ansis_default, createApp, createDevToolsContext, createDevToolsMiddleware, eventHandler, getPort, sendRedirect, toNodeListener };