Criada a API do site

2025-10-29 19:56:41 -03:00
parent f201c8edbd
commit 4a14f533d2
3074 changed files with 780728 additions and 41 deletions
--- a/node_modules/vite-plugin-inspect/dist/client/assets/ModuleList-ByxGSHde.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/ModuleList-ByxGSHde.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/QuerySelector-iLRAQoow.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/QuerySelector-iLRAQoow.js
@@ -0,0 +1,240 @@
+import { Fragment, computed, createBaseVNode, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, h, normalizeClass, normalizeStyle, openBlock, renderList, renderSlot, resolveDynamicComponent, toDisplayString, unref, withCtx } from "./runtime-core.esm-bundler-Cyv4obHQ.js";
+import { isDark, toggleDark, usePayloadStore } from "./payload-BX9lTMvN.js";
+import { __plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-DfavQbjy.js";
+const _sfc_main = {};
+const _hoisted_1$4 = { class: "h-[calc(100vh-55px)]" };
+function _sfc_render(_ctx, _cache) {
+	return openBlock(), createElementBlock("div", _hoisted_1$4, [renderSlot(_ctx.$slots, "default")]);
+}
+var Container_default = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main, [["render", _sfc_render]]);
+/**
+* Predefined color map for matching the branding
+*
+* Accpet a 6-digit hex color string or a hue number
+* Hue numbers are preferred because they will adapt better contrast in light/dark mode
+*
+* Hue numbers reference:
+* - 0: red
+* - 30: orange
+* - 60: yellow
+* - 120: green
+* - 180: cyan
+* - 240: blue
+* - 270: purple
+*/
+const predefinedColorMap = {
+	error: 0,
+	client: 60,
+	bailout: -1,
+	ssr: 270,
+	vite: 250,
+	vite1: 240,
+	vite2: 120,
+	virtual: 140
+};
+function getHashColorFromString(name, opacity = 1) {
+	if (predefinedColorMap[name]) return getHsla(predefinedColorMap[name], opacity);
+	let hash = 0;
+	for (let i = 0; i < name.length; i++) hash = name.charCodeAt(i) + ((hash << 5) - hash);
+	const hue = hash % 360;
+	return getHsla(hue, opacity);
+}
+function getHsla(hue, opacity = 1) {
+	const saturation = hue === -1 ? 0 : isDark.value ? 50 : 100;
+	const lightness = isDark.value ? 60 : 20;
+	return `hsla(${hue}, ${saturation}%, ${lightness}%, ${opacity})`;
+}
+function getPluginColor(name, opacity = 1) {
+	if (predefinedColorMap[name]) {
+		const color = predefinedColorMap[name];
+		if (typeof color === "number") return getHsla(color, opacity);
+		else {
+			if (opacity === 1) return color;
+			const opacityHex = Math.floor(opacity * 255).toString(16).padStart(2, "0");
+			return color + opacityHex;
+		}
+	}
+	return getHashColorFromString(name, opacity);
+}
+var PluginName_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "PluginName",
+	props: {
+		name: {},
+		compact: { type: Boolean },
+		colored: { type: Boolean },
+		hide: { type: Boolean }
+	},
+	setup(__props) {
+		const props = __props;
+		const startsGeneric = [
+			"__load__",
+			"vite-plugin-",
+			"vite-",
+			"rollup-plugin-",
+			"rollup-",
+			"unplugin-"
+		];
+		const startCompact = [...startsGeneric, "vite:"];
+		function render() {
+			const starts = props.compact ? startCompact : startsGeneric;
+			for (const s of starts) if (props.name.startsWith(s)) {
+				if (props.compact) return h("span", props.name.slice(s.length));
+				return h("span", [h("span", { class: "op50" }, s), h("span", props.name.slice(s.length))]);
+			}
+			const parts = props.name.split(":");
+			if (parts.length > 1) return h("span", [h("span", { style: { color: getHashColorFromString(parts[0]) } }, `${parts[0]}:`), h("span", parts.slice(1).join(":"))]);
+			return h("span", props.name);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(render));
+		};
+	}
+});
+var PluginName_default = PluginName_vue_vue_type_script_setup_true_lang_default;
+const _hoisted_1$3 = ["textContent"];
+var Badge_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "Badge",
+	props: {
+		text: {},
+		color: {
+			type: [Boolean, Number],
+			default: true
+		},
+		as: {},
+		size: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const style = computed(() => {
+			if (!props.text || props.color === false) return {};
+			return {
+				color: typeof props.color === "number" ? getHsla(props.color) : getHashColorFromString(props.text),
+				background: typeof props.color === "number" ? getHsla(props.color, .1) : getHashColorFromString(props.text, .1)
+			};
+		});
+		const sizeClasses = computed(() => {
+			switch (props.size || "sm") {
+				case "sm": return "px-1.5 text-11px leading-1.6em";
+			}
+			return "";
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(_ctx.as || "span"), {
+				"ws-nowrap": "",
+				rounded: "",
+				class: normalizeClass(unref(sizeClasses)),
+				style: normalizeStyle(unref(style))
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {}, () => [createBaseVNode("span", { textContent: toDisplayString(props.text) }, null, 8, _hoisted_1$3)])]),
+				_: 3
+			}, 8, ["class", "style"]);
+		};
+	}
+});
+var Badge_default = Badge_vue_vue_type_script_setup_true_lang_default;
+const _hoisted_1$2 = {
+	"h-54px": "",
+	flex: "~ none gap-2",
+	border: "b main",
+	"pl-4": "",
+	"pr-4": "",
+	"font-light": "",
+	"children:my-auto": ""
+};
+var NavBar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "NavBar",
+	setup(__props) {
+		const payload = usePayloadStore();
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("nav", _hoisted_1$2, [renderSlot(_ctx.$slots, "default"), renderSlot(_ctx.$slots, "actions", {}, () => [!unref(payload).metadata.embedded ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+				_cache[2] || (_cache[2] = createBaseVNode("div", {
+					mx1: "",
+					"h-full": "",
+					"w-0": "",
+					border: "r main"
+				}, null, -1)),
+				_cache[3] || (_cache[3] = createBaseVNode("a", {
+					"icon-btn": "",
+					"text-lg": "",
+					href: "https://github.com/antfu/vite-plugin-inspect",
+					target: "_blank"
+				}, [createBaseVNode("div", { "i-carbon-logo-github": "" })], -1)),
+				createBaseVNode("button", {
+					class: "icon-btn text-lg",
+					title: "Toggle Dark Mode",
+					onClick: _cache[0] || (_cache[0] = ($event) => unref(toggleDark)())
+				}, [..._cache[1] || (_cache[1] = [createBaseVNode("span", {
+					"i-carbon-sun": "",
+					"dark:i-carbon-moon": ""
+				}, null, -1)])])
+			], 64)) : createCommentVNode("", true)])]);
+		};
+	}
+});
+var NavBar_default = NavBar_vue_vue_type_script_setup_true_lang_default;
+const _hoisted_1$1 = {
+	flex: "~ gap-1 items-center",
+	border: "~ subtle rounded",
+	"bg-subtle": "",
+	p1: ""
+};
+var SegmentControl_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "SegmentControl",
+	props: {
+		options: {},
+		modelValue: {}
+	},
+	emits: ["update:modelValue"],
+	setup(__props) {
+		return (_ctx, _cache) => {
+			const _component_Badge = Badge_default;
+			return openBlock(), createElementBlock("div", _hoisted_1$1, [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, (option) => {
+				return openBlock(), createBlock(_component_Badge, {
+					key: option.value,
+					class: normalizeClass(["px-2 py-1 text-xs font-mono", option.value === _ctx.modelValue ? "" : "op50"]),
+					color: option.value === _ctx.modelValue,
+					"aria-pressed": option.value === _ctx.modelValue,
+					size: "none",
+					text: option.label,
+					as: "button",
+					onClick: ($event) => _ctx.$emit("update:modelValue", option.value)
+				}, null, 8, [
+					"class",
+					"color",
+					"aria-pressed",
+					"text",
+					"onClick"
+				]);
+			}), 128))]);
+		};
+	}
+});
+var SegmentControl_default = SegmentControl_vue_vue_type_script_setup_true_lang_default;
+const _hoisted_1 = { flex: "~ gap-2" };
+var QuerySelector_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "QuerySelector",
+	setup(__props) {
+		const payload = usePayloadStore();
+		return (_ctx, _cache) => {
+			const _component_SegmentControl = SegmentControl_default;
+			return openBlock(), createElementBlock("div", _hoisted_1, [unref(payload).metadata.instances.length > 1 ? (openBlock(), createBlock(_component_SegmentControl, {
+				key: 0,
+				modelValue: unref(payload).query.vite,
+				"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(payload).query.vite = $event),
+				options: unref(payload).metadata.instances.map((i) => ({
+					label: i.vite,
+					value: i.vite
+				}))
+			}, null, 8, ["modelValue", "options"])) : createCommentVNode("", true), createVNode(_component_SegmentControl, {
+				modelValue: unref(payload).query.env,
+				"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => unref(payload).query.env = $event),
+				options: unref(payload).instance.environments.map((i) => ({
+					label: i,
+					value: i
+				}))
+			}, null, 8, ["modelValue", "options"])]);
+		};
+	}
+});
+var QuerySelector_default = QuerySelector_vue_vue_type_script_setup_true_lang_default;
+export { Badge_default, Container_default, NavBar_default, PluginName_default, QuerySelector_default, SegmentControl_default, getPluginColor };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/_...all_-DVz6Qbfk.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/_...all_-DVz6Qbfk.js
@@ -0,0 +1,8 @@
+import { createElementBlock, openBlock } from "./runtime-core.esm-bundler-Cyv4obHQ.js";
+import { __plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-DfavQbjy.js";
+const _sfc_main = {};
+function _sfc_render(_ctx, _cache) {
+	return openBlock(), createElementBlock("div", null, " Not Found ");
+}
+var _____all__default = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main, [["render", _sfc_render]]);
+export { _____all__default as default };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/_plugin-vue_export-helper-DfavQbjy.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/_plugin-vue_export-helper-DfavQbjy.js
@@ -0,0 +1,6 @@
+var __plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+export { __plugin_vue_export_helper_default };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/diff.worker-CMaeQEBs.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/diff.worker-CMaeQEBs.js
@@ -0,0 +1,866 @@
+(function() {
+	"use strict";
+	/**
+	* @license
+	* Copyright 2019 Google LLC
+	* SPDX-License-Identifier: Apache-2.0
+	*/
+	const proxyMarker = Symbol("Comlink.proxy");
+	const createEndpoint = Symbol("Comlink.endpoint");
+	const releaseProxy = Symbol("Comlink.releaseProxy");
+	const finalizer = Symbol("Comlink.finalizer");
+	const throwMarker = Symbol("Comlink.thrown");
+	const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+	/**
+	* Internal transfer handle to handle objects marked to proxy.
+	*/
+	const proxyTransferHandler = {
+		canHandle: (val) => isObject(val) && val[proxyMarker],
+		serialize(obj) {
+			const { port1, port2 } = new MessageChannel();
+			expose(obj, port1);
+			return [port2, [port2]];
+		},
+		deserialize(port) {
+			port.start();
+			return wrap(port);
+		}
+	};
+	/**
+	* Internal transfer handler to handle thrown exceptions.
+	*/
+	const throwTransferHandler = {
+		canHandle: (value) => isObject(value) && throwMarker in value,
+		serialize({ value }) {
+			let serialized;
+			if (value instanceof Error) serialized = {
+				isError: true,
+				value: {
+					message: value.message,
+					name: value.name,
+					stack: value.stack
+				}
+			};
+			else serialized = {
+				isError: false,
+				value
+			};
+			return [serialized, []];
+		},
+		deserialize(serialized) {
+			if (serialized.isError) throw Object.assign(new Error(serialized.value.message), serialized.value);
+			throw serialized.value;
+		}
+	};
+	/**
+	* Allows customizing the serialization of certain values.
+	*/
+	const transferHandlers = new Map([["proxy", proxyTransferHandler], ["throw", throwTransferHandler]]);
+	function isAllowedOrigin(allowedOrigins, origin) {
+		for (const allowedOrigin of allowedOrigins) {
+			if (origin === allowedOrigin || allowedOrigin === "*") return true;
+			if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) return true;
+		}
+		return false;
+	}
+	function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+		ep.addEventListener("message", function callback(ev) {
+			if (!ev || !ev.data) return;
+			if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+				console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+				return;
+			}
+			const { id, type, path } = Object.assign({ path: [] }, ev.data);
+			const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+			let returnValue;
+			try {
+				const parent = path.slice(0, -1).reduce((obj$1, prop) => obj$1[prop], obj);
+				const rawValue = path.reduce((obj$1, prop) => obj$1[prop], obj);
+				switch (type) {
+					case "GET":
+						returnValue = rawValue;
+						break;
+					case "SET":
+						{
+							parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+							returnValue = true;
+						}
+						break;
+					case "APPLY":
+						returnValue = rawValue.apply(parent, argumentList);
+						break;
+					case "CONSTRUCT":
+						{
+							const value = new rawValue(...argumentList);
+							returnValue = proxy(value);
+						}
+						break;
+					case "ENDPOINT":
+						{
+							const { port1, port2 } = new MessageChannel();
+							expose(obj, port2);
+							returnValue = transfer(port1, [port1]);
+						}
+						break;
+					case "RELEASE":
+						returnValue = void 0;
+						break;
+					default: return;
+				}
+			} catch (value) {
+				returnValue = {
+					value,
+					[throwMarker]: 0
+				};
+			}
+			Promise.resolve(returnValue).catch((value) => {
+				return {
+					value,
+					[throwMarker]: 0
+				};
+			}).then((returnValue$1) => {
+				const [wireValue, transferables] = toWireValue(returnValue$1);
+				ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+				if (type === "RELEASE") {
+					ep.removeEventListener("message", callback);
+					closeEndPoint(ep);
+					if (finalizer in obj && typeof obj[finalizer] === "function") obj[finalizer]();
+				}
+			}).catch((error) => {
+				const [wireValue, transferables] = toWireValue({
+					value: new TypeError("Unserializable return value"),
+					[throwMarker]: 0
+				});
+				ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+			});
+		});
+		if (ep.start) ep.start();
+	}
+	function isMessagePort(endpoint) {
+		return endpoint.constructor.name === "MessagePort";
+	}
+	function closeEndPoint(endpoint) {
+		if (isMessagePort(endpoint)) endpoint.close();
+	}
+	function wrap(ep, target) {
+		const pendingListeners = new Map();
+		ep.addEventListener("message", function handleMessage(ev) {
+			const { data } = ev;
+			if (!data || !data.id) return;
+			const resolver = pendingListeners.get(data.id);
+			if (!resolver) return;
+			try {
+				resolver(data);
+			} finally {
+				pendingListeners.delete(data.id);
+			}
+		});
+		return createProxy(ep, pendingListeners, [], target);
+	}
+	function throwIfProxyReleased(isReleased) {
+		if (isReleased) throw new Error("Proxy has been released and is not useable");
+	}
+	function releaseEndpoint(ep) {
+		return requestResponseMessage(ep, new Map(), { type: "RELEASE" }).then(() => {
+			closeEndPoint(ep);
+		});
+	}
+	const proxyCounter = new WeakMap();
+	const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+		const newCount = (proxyCounter.get(ep) || 0) - 1;
+		proxyCounter.set(ep, newCount);
+		if (newCount === 0) releaseEndpoint(ep);
+	});
+	function registerProxy(proxy$1, ep) {
+		const newCount = (proxyCounter.get(ep) || 0) + 1;
+		proxyCounter.set(ep, newCount);
+		if (proxyFinalizers) proxyFinalizers.register(proxy$1, ep, proxy$1);
+	}
+	function unregisterProxy(proxy$1) {
+		if (proxyFinalizers) proxyFinalizers.unregister(proxy$1);
+	}
+	function createProxy(ep, pendingListeners, path = [], target = function() {}) {
+		let isProxyReleased = false;
+		const proxy$1 = new Proxy(target, {
+			get(_target, prop) {
+				throwIfProxyReleased(isProxyReleased);
+				if (prop === releaseProxy) return () => {
+					unregisterProxy(proxy$1);
+					releaseEndpoint(ep);
+					pendingListeners.clear();
+					isProxyReleased = true;
+				};
+				if (prop === "then") {
+					if (path.length === 0) return { then: () => proxy$1 };
+					const r = requestResponseMessage(ep, pendingListeners, {
+						type: "GET",
+						path: path.map((p) => p.toString())
+					}).then(fromWireValue);
+					return r.then.bind(r);
+				}
+				return createProxy(ep, pendingListeners, [...path, prop]);
+			},
+			set(_target, prop, rawValue) {
+				throwIfProxyReleased(isProxyReleased);
+				const [value, transferables] = toWireValue(rawValue);
+				return requestResponseMessage(ep, pendingListeners, {
+					type: "SET",
+					path: [...path, prop].map((p) => p.toString()),
+					value
+				}, transferables).then(fromWireValue);
+			},
+			apply(_target, _thisArg, rawArgumentList) {
+				throwIfProxyReleased(isProxyReleased);
+				const last = path[path.length - 1];
+				if (last === createEndpoint) return requestResponseMessage(ep, pendingListeners, { type: "ENDPOINT" }).then(fromWireValue);
+				if (last === "bind") return createProxy(ep, pendingListeners, path.slice(0, -1));
+				const [argumentList, transferables] = processArguments(rawArgumentList);
+				return requestResponseMessage(ep, pendingListeners, {
+					type: "APPLY",
+					path: path.map((p) => p.toString()),
+					argumentList
+				}, transferables).then(fromWireValue);
+			},
+			construct(_target, rawArgumentList) {
+				throwIfProxyReleased(isProxyReleased);
+				const [argumentList, transferables] = processArguments(rawArgumentList);
+				return requestResponseMessage(ep, pendingListeners, {
+					type: "CONSTRUCT",
+					path: path.map((p) => p.toString()),
+					argumentList
+				}, transferables).then(fromWireValue);
+			}
+		});
+		registerProxy(proxy$1, ep);
+		return proxy$1;
+	}
+	function myFlat(arr) {
+		return Array.prototype.concat.apply([], arr);
+	}
+	function processArguments(argumentList) {
+		const processed = argumentList.map(toWireValue);
+		return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+	}
+	const transferCache = new WeakMap();
+	function transfer(obj, transfers) {
+		transferCache.set(obj, transfers);
+		return obj;
+	}
+	function proxy(obj) {
+		return Object.assign(obj, { [proxyMarker]: true });
+	}
+	function toWireValue(value) {
+		for (const [name, handler] of transferHandlers) if (handler.canHandle(value)) {
+			const [serializedValue, transferables] = handler.serialize(value);
+			return [{
+				type: "HANDLER",
+				name,
+				value: serializedValue
+			}, transferables];
+		}
+		return [{
+			type: "RAW",
+			value
+		}, transferCache.get(value) || []];
+	}
+	function fromWireValue(value) {
+		switch (value.type) {
+			case "HANDLER": return transferHandlers.get(value.name).deserialize(value.value);
+			case "RAW": return value.value;
+		}
+	}
+	function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+		return new Promise((resolve) => {
+			const id = generateUUID();
+			pendingListeners.set(id, resolve);
+			if (ep.start) ep.start();
+			ep.postMessage(Object.assign({ id }, msg), transfers);
+		});
+	}
+	function generateUUID() {
+		return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+	}
+	const defaultOptions = /* @__PURE__ */ Object.freeze({
+		diffTimeout: 1,
+		diffEditCost: 4,
+		matchThreshold: .5,
+		matchDistance: 1e3,
+		patchDeleteThreshold: .5,
+		patchMargin: 4,
+		matchMaxBits: 32
+	});
+	function resolveOptions(options) {
+		if (options?.__resolved) return options;
+		const resolved = {
+			...defaultOptions,
+			...options
+		};
+		Object.defineProperty(resolved, "__resolved", {
+			value: true,
+			enumerable: false
+		});
+		return resolved;
+	}
+	const DIFF_DELETE = -1;
+	const DIFF_INSERT = 1;
+	const DIFF_EQUAL = 0;
+	function createDiff(op, text) {
+		return [op, text];
+	}
+	function diffMain(text1, text2, options, opt_checklines = true, opt_deadline) {
+		const resolved = resolveOptions(options);
+		if (typeof opt_deadline == "undefined") if (resolved.diffTimeout <= 0) opt_deadline = Number.MAX_VALUE;
+		else opt_deadline = (/* @__PURE__ */ new Date()).getTime() + resolved.diffTimeout * 1e3;
+		const deadline = opt_deadline;
+		if (text1 == null || text2 == null) throw new Error("Null input. (diff_main)");
+		if (text1 === text2) {
+			if (text1) return [createDiff(DIFF_EQUAL, text1)];
+			return [];
+		}
+		const checklines = opt_checklines;
+		let commonlength = diffCommonPrefix(text1, text2);
+		const commonprefix = text1.substring(0, commonlength);
+		text1 = text1.substring(commonlength);
+		text2 = text2.substring(commonlength);
+		commonlength = diffCommonSuffix(text1, text2);
+		const commonsuffix = text1.substring(text1.length - commonlength);
+		text1 = text1.substring(0, text1.length - commonlength);
+		text2 = text2.substring(0, text2.length - commonlength);
+		const diffs = diffCompute(text1, text2, resolved, checklines, deadline);
+		if (commonprefix) diffs.unshift(createDiff(DIFF_EQUAL, commonprefix));
+		if (commonsuffix) diffs.push(createDiff(DIFF_EQUAL, commonsuffix));
+		diffCleanupMerge(diffs);
+		return diffs;
+	}
+	function diffCompute(text1, text2, options, checklines, deadline) {
+		let diffs;
+		if (!text1) return [createDiff(DIFF_INSERT, text2)];
+		if (!text2) return [createDiff(DIFF_DELETE, text1)];
+		const longtext = text1.length > text2.length ? text1 : text2;
+		const shorttext = text1.length > text2.length ? text2 : text1;
+		const i = longtext.indexOf(shorttext);
+		if (i !== -1) {
+			diffs = [
+				createDiff(DIFF_INSERT, longtext.substring(0, i)),
+				createDiff(DIFF_EQUAL, shorttext),
+				createDiff(DIFF_INSERT, longtext.substring(i + shorttext.length))
+			];
+			if (text1.length > text2.length) diffs[0][0] = diffs[2][0] = DIFF_DELETE;
+			return diffs;
+		}
+		if (shorttext.length === 1) return [createDiff(DIFF_DELETE, text1), createDiff(DIFF_INSERT, text2)];
+		const hm = diffHalfMatch(text1, text2, options);
+		if (hm) {
+			const text1_a = hm[0];
+			const text1_b = hm[1];
+			const text2_a = hm[2];
+			const text2_b = hm[3];
+			const mid_common = hm[4];
+			const diffs_a = diffMain(text1_a, text2_a, options, checklines, deadline);
+			const diffs_b = diffMain(text1_b, text2_b, options, checklines, deadline);
+			return diffs_a.concat([createDiff(DIFF_EQUAL, mid_common)], diffs_b);
+		}
+		if (checklines && text1.length > 100 && text2.length > 100) return diffLineMode(text1, text2, options, deadline);
+		return diffBisect(text1, text2, options, deadline);
+	}
+	function diffLineMode(text1, text2, options, deadline) {
+		const a = diffLinesToChars(text1, text2);
+		text1 = a.chars1;
+		text2 = a.chars2;
+		const linearray = a.lineArray;
+		const diffs = diffMain(text1, text2, options, false, deadline);
+		diffCharsToLines(diffs, linearray);
+		diffCleanupSemantic(diffs);
+		diffs.push(createDiff(DIFF_EQUAL, ""));
+		let pointer = 0;
+		let count_delete = 0;
+		let count_insert = 0;
+		let text_delete = "";
+		let text_insert = "";
+		while (pointer < diffs.length) {
+			switch (diffs[pointer][0]) {
+				case DIFF_INSERT:
+					count_insert++;
+					text_insert += diffs[pointer][1];
+					break;
+				case DIFF_DELETE:
+					count_delete++;
+					text_delete += diffs[pointer][1];
+					break;
+				case DIFF_EQUAL:
+					if (count_delete >= 1 && count_insert >= 1) {
+						diffs.splice(pointer - count_delete - count_insert, count_delete + count_insert);
+						pointer = pointer - count_delete - count_insert;
+						const subDiff = diffMain(text_delete, text_insert, options, false, deadline);
+						for (let j = subDiff.length - 1; j >= 0; j--) diffs.splice(pointer, 0, subDiff[j]);
+						pointer = pointer + subDiff.length;
+					}
+					count_insert = 0;
+					count_delete = 0;
+					text_delete = "";
+					text_insert = "";
+					break;
+			}
+			pointer++;
+		}
+		diffs.pop();
+		return diffs;
+	}
+	function diffBisect(text1, text2, options, deadline) {
+		const text1_length = text1.length;
+		const text2_length = text2.length;
+		const max_d = Math.ceil((text1_length + text2_length) / 2);
+		const v_offset = max_d;
+		const v_length = 2 * max_d;
+		const v1 = new Array(v_length);
+		const v2 = new Array(v_length);
+		for (let x = 0; x < v_length; x++) {
+			v1[x] = -1;
+			v2[x] = -1;
+		}
+		v1[v_offset + 1] = 0;
+		v2[v_offset + 1] = 0;
+		const delta = text1_length - text2_length;
+		const front = delta % 2 !== 0;
+		let k1start = 0;
+		let k1end = 0;
+		let k2start = 0;
+		let k2end = 0;
+		for (let d = 0; d < max_d; d++) {
+			if ((/* @__PURE__ */ new Date()).getTime() > deadline) break;
+			for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+				const k1_offset = v_offset + k1;
+				let x1;
+				if (k1 === -d || k1 !== d && v1[k1_offset - 1] < v1[k1_offset + 1]) x1 = v1[k1_offset + 1];
+				else x1 = v1[k1_offset - 1] + 1;
+				let y1 = x1 - k1;
+				while (x1 < text1_length && y1 < text2_length && text1.charAt(x1) === text2.charAt(y1)) {
+					x1++;
+					y1++;
+				}
+				v1[k1_offset] = x1;
+				if (x1 > text1_length) k1end += 2;
+				else if (y1 > text2_length) k1start += 2;
+				else if (front) {
+					const k2_offset = v_offset + delta - k1;
+					if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] !== -1) {
+						const x2 = text1_length - v2[k2_offset];
+						if (x1 >= x2) return diffBisectSplit(text1, text2, options, x1, y1, deadline);
+					}
+				}
+			}
+			for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+				const k2_offset = v_offset + k2;
+				let x2;
+				if (k2 === -d || k2 !== d && v2[k2_offset - 1] < v2[k2_offset + 1]) x2 = v2[k2_offset + 1];
+				else x2 = v2[k2_offset - 1] + 1;
+				let y2 = x2 - k2;
+				while (x2 < text1_length && y2 < text2_length && text1.charAt(text1_length - x2 - 1) === text2.charAt(text2_length - y2 - 1)) {
+					x2++;
+					y2++;
+				}
+				v2[k2_offset] = x2;
+				if (x2 > text1_length) k2end += 2;
+				else if (y2 > text2_length) k2start += 2;
+				else if (!front) {
+					const k1_offset = v_offset + delta - k2;
+					if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] !== -1) {
+						const x1 = v1[k1_offset];
+						const y1 = v_offset + x1 - k1_offset;
+						x2 = text1_length - x2;
+						if (x1 >= x2) return diffBisectSplit(text1, text2, options, x1, y1, deadline);
+					}
+				}
+			}
+		}
+		return [createDiff(DIFF_DELETE, text1), createDiff(DIFF_INSERT, text2)];
+	}
+	function diffBisectSplit(text1, text2, options, x, y, deadline) {
+		const text1a = text1.substring(0, x);
+		const text2a = text2.substring(0, y);
+		const text1b = text1.substring(x);
+		const text2b = text2.substring(y);
+		const diffs = diffMain(text1a, text2a, options, false, deadline);
+		const diffsb = diffMain(text1b, text2b, options, false, deadline);
+		return diffs.concat(diffsb);
+	}
+	function diffLinesToChars(text1, text2) {
+		const lineArray = [];
+		const lineHash = {};
+		let maxLines = 4e4;
+		lineArray[0] = "";
+		function diffLinesToCharsMunge(text) {
+			let chars = "";
+			let lineStart = 0;
+			let lineEnd = -1;
+			let lineArrayLength = lineArray.length;
+			while (lineEnd < text.length - 1) {
+				lineEnd = text.indexOf("\n", lineStart);
+				if (lineEnd === -1) lineEnd = text.length - 1;
+				let line = text.substring(lineStart, lineEnd + 1);
+				if (lineHash.hasOwnProperty ? Object.prototype.hasOwnProperty.call(lineHash, line) : lineHash[line] !== void 0) chars += String.fromCharCode(lineHash[line]);
+				else {
+					if (lineArrayLength === maxLines) {
+						line = text.substring(lineStart);
+						lineEnd = text.length;
+					}
+					chars += String.fromCharCode(lineArrayLength);
+					lineHash[line] = lineArrayLength;
+					lineArray[lineArrayLength++] = line;
+				}
+				lineStart = lineEnd + 1;
+			}
+			return chars;
+		}
+		const chars1 = diffLinesToCharsMunge(text1);
+		maxLines = 65535;
+		const chars2 = diffLinesToCharsMunge(text2);
+		return {
+			chars1,
+			chars2,
+			lineArray
+		};
+	}
+	function diffCharsToLines(diffs, lineArray) {
+		for (let i = 0; i < diffs.length; i++) {
+			const chars = diffs[i][1];
+			const text = [];
+			for (let j = 0; j < chars.length; j++) text[j] = lineArray[chars.charCodeAt(j)];
+			diffs[i][1] = text.join("");
+		}
+	}
+	function diffCommonPrefix(text1, text2) {
+		if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) return 0;
+		let pointermin = 0;
+		let pointermax = Math.min(text1.length, text2.length);
+		let pointermid = pointermax;
+		let pointerstart = 0;
+		while (pointermin < pointermid) {
+			if (text1.substring(pointerstart, pointermid) === text2.substring(pointerstart, pointermid)) {
+				pointermin = pointermid;
+				pointerstart = pointermin;
+			} else pointermax = pointermid;
+			pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+		}
+		return pointermid;
+	}
+	function diffCommonSuffix(text1, text2) {
+		if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) return 0;
+		let pointermin = 0;
+		let pointermax = Math.min(text1.length, text2.length);
+		let pointermid = pointermax;
+		let pointerend = 0;
+		while (pointermin < pointermid) {
+			if (text1.substring(text1.length - pointermid, text1.length - pointerend) === text2.substring(text2.length - pointermid, text2.length - pointerend)) {
+				pointermin = pointermid;
+				pointerend = pointermin;
+			} else pointermax = pointermid;
+			pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+		}
+		return pointermid;
+	}
+	function diffCommonOverlap(text1, text2) {
+		const text1_length = text1.length;
+		const text2_length = text2.length;
+		if (text1_length === 0 || text2_length === 0) return 0;
+		if (text1_length > text2_length) text1 = text1.substring(text1_length - text2_length);
+		else if (text1_length < text2_length) text2 = text2.substring(0, text1_length);
+		const text_length = Math.min(text1_length, text2_length);
+		if (text1 === text2) return text_length;
+		let best = 0;
+		let length = 1;
+		while (true) {
+			const pattern = text1.substring(text_length - length);
+			const found = text2.indexOf(pattern);
+			if (found === -1) return best;
+			length += found;
+			if (found === 0 || text1.substring(text_length - length) === text2.substring(0, length)) {
+				best = length;
+				length++;
+			}
+		}
+	}
+	function diffHalfMatch(text1, text2, options) {
+		if (options.diffTimeout <= 0) return null;
+		const longtext = text1.length > text2.length ? text1 : text2;
+		const shorttext = text1.length > text2.length ? text2 : text1;
+		if (longtext.length < 4 || shorttext.length * 2 < longtext.length) return null;
+		function diffHalfMatchI(longtext2, shorttext2, i) {
+			const seed = longtext2.substring(i, i + Math.floor(longtext2.length / 4));
+			let j = -1;
+			let best_common = "";
+			let best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
+			while ((j = shorttext2.indexOf(seed, j + 1)) !== -1) {
+				const prefixLength = diffCommonPrefix(longtext2.substring(i), shorttext2.substring(j));
+				const suffixLength = diffCommonSuffix(longtext2.substring(0, i), shorttext2.substring(0, j));
+				if (best_common.length < suffixLength + prefixLength) {
+					best_common = shorttext2.substring(j - suffixLength, j) + shorttext2.substring(j, j + prefixLength);
+					best_longtext_a = longtext2.substring(0, i - suffixLength);
+					best_longtext_b = longtext2.substring(i + prefixLength);
+					best_shorttext_a = shorttext2.substring(0, j - suffixLength);
+					best_shorttext_b = shorttext2.substring(j + prefixLength);
+				}
+			}
+			if (best_common.length * 2 >= longtext2.length) return [
+				best_longtext_a,
+				best_longtext_b,
+				best_shorttext_a,
+				best_shorttext_b,
+				best_common
+			];
+			else return null;
+		}
+		const hm1 = diffHalfMatchI(longtext, shorttext, Math.ceil(longtext.length / 4));
+		const hm2 = diffHalfMatchI(longtext, shorttext, Math.ceil(longtext.length / 2));
+		let hm;
+		if (!hm1 && !hm2) return null;
+		else if (!hm2) hm = hm1;
+		else if (!hm1) hm = hm2;
+		else hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
+		let text1_a, text1_b, text2_a, text2_b;
+		if (text1.length > text2.length) {
+			text1_a = hm[0];
+			text1_b = hm[1];
+			text2_a = hm[2];
+			text2_b = hm[3];
+		} else {
+			text2_a = hm[0];
+			text2_b = hm[1];
+			text1_a = hm[2];
+			text1_b = hm[3];
+		}
+		const mid_common = hm[4];
+		return [
+			text1_a,
+			text1_b,
+			text2_a,
+			text2_b,
+			mid_common
+		];
+	}
+	function diffCleanupSemantic(diffs) {
+		let changes = false;
+		const equalities = [];
+		let equalitiesLength = 0;
+		let lastEquality = null;
+		let pointer = 0;
+		let length_insertions1 = 0;
+		let length_deletions1 = 0;
+		let length_insertions2 = 0;
+		let length_deletions2 = 0;
+		while (pointer < diffs.length) {
+			if (diffs[pointer][0] === DIFF_EQUAL) {
+				equalities[equalitiesLength++] = pointer;
+				length_insertions1 = length_insertions2;
+				length_deletions1 = length_deletions2;
+				length_insertions2 = 0;
+				length_deletions2 = 0;
+				lastEquality = diffs[pointer][1];
+			} else {
+				if (diffs[pointer][0] === DIFF_INSERT) length_insertions2 += diffs[pointer][1].length;
+				else length_deletions2 += diffs[pointer][1].length;
+				if (lastEquality && lastEquality.length <= Math.max(length_insertions1, length_deletions1) && lastEquality.length <= Math.max(length_insertions2, length_deletions2)) {
+					diffs.splice(equalities[equalitiesLength - 1], 0, createDiff(DIFF_DELETE, lastEquality));
+					diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
+					equalitiesLength--;
+					equalitiesLength--;
+					pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+					length_insertions1 = 0;
+					length_deletions1 = 0;
+					length_insertions2 = 0;
+					length_deletions2 = 0;
+					lastEquality = null;
+					changes = true;
+				}
+			}
+			pointer++;
+		}
+		if (changes) diffCleanupMerge(diffs);
+		diffCleanupSemanticLossless(diffs);
+		pointer = 1;
+		while (pointer < diffs.length) {
+			if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
+				const deletion = diffs[pointer - 1][1];
+				const insertion = diffs[pointer][1];
+				const overlap_length1 = diffCommonOverlap(deletion, insertion);
+				const overlap_length2 = diffCommonOverlap(insertion, deletion);
+				if (overlap_length1 >= overlap_length2) {
+					if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
+						diffs.splice(pointer, 0, createDiff(DIFF_EQUAL, insertion.substring(0, overlap_length1)));
+						diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1);
+						diffs[pointer + 1][1] = insertion.substring(overlap_length1);
+						pointer++;
+					}
+				} else if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
+					diffs.splice(pointer, 0, createDiff(DIFF_EQUAL, deletion.substring(0, overlap_length2)));
+					diffs[pointer - 1][0] = DIFF_INSERT;
+					diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
+					diffs[pointer + 1][0] = DIFF_DELETE;
+					diffs[pointer + 1][1] = deletion.substring(overlap_length2);
+					pointer++;
+				}
+				pointer++;
+			}
+			pointer++;
+		}
+	}
+	const nonAlphaNumericRegex_ = /[^a-z0-9]/i;
+	const whitespaceRegex_ = /\s/;
+	const linebreakRegex_ = /[\r\n]/;
+	const blanklineEndRegex_ = /\n\r?\n$/;
+	const blanklineStartRegex_ = /^\r?\n\r?\n/;
+	function diffCleanupSemanticLossless(diffs) {
+		function diffCleanupSemanticScore(one, two) {
+			if (!one || !two) return 6;
+			const char1 = one.charAt(one.length - 1);
+			const char2 = two.charAt(0);
+			const nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
+			const nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
+			const whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);
+			const whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);
+			const lineBreak1 = whitespace1 && char1.match(linebreakRegex_);
+			const lineBreak2 = whitespace2 && char2.match(linebreakRegex_);
+			const blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);
+			const blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);
+			if (blankLine1 || blankLine2) return 5;
+			else if (lineBreak1 || lineBreak2) return 4;
+			else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) return 3;
+			else if (whitespace1 || whitespace2) return 2;
+			else if (nonAlphaNumeric1 || nonAlphaNumeric2) return 1;
+			return 0;
+		}
+		let pointer = 1;
+		while (pointer < diffs.length - 1) {
+			if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+				let equality1 = diffs[pointer - 1][1];
+				let edit = diffs[pointer][1];
+				let equality2 = diffs[pointer + 1][1];
+				const commonOffset = diffCommonSuffix(equality1, edit);
+				if (commonOffset) {
+					const commonString = edit.substring(edit.length - commonOffset);
+					equality1 = equality1.substring(0, equality1.length - commonOffset);
+					edit = commonString + edit.substring(0, edit.length - commonOffset);
+					equality2 = commonString + equality2;
+				}
+				let bestEquality1 = equality1;
+				let bestEdit = edit;
+				let bestEquality2 = equality2;
+				let bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+				while (edit.charAt(0) === equality2.charAt(0)) {
+					equality1 += edit.charAt(0);
+					edit = edit.substring(1) + equality2.charAt(0);
+					equality2 = equality2.substring(1);
+					const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+					if (score >= bestScore) {
+						bestScore = score;
+						bestEquality1 = equality1;
+						bestEdit = edit;
+						bestEquality2 = equality2;
+					}
+				}
+				if (diffs[pointer - 1][1] !== bestEquality1) {
+					if (bestEquality1) diffs[pointer - 1][1] = bestEquality1;
+					else {
+						diffs.splice(pointer - 1, 1);
+						pointer--;
+					}
+					diffs[pointer][1] = bestEdit;
+					if (bestEquality2) diffs[pointer + 1][1] = bestEquality2;
+					else {
+						diffs.splice(pointer + 1, 1);
+						pointer--;
+					}
+				}
+			}
+			pointer++;
+		}
+	}
+	function diffCleanupMerge(diffs) {
+		diffs.push(createDiff(DIFF_EQUAL, ""));
+		let pointer = 0;
+		let count_delete = 0;
+		let count_insert = 0;
+		let text_delete = "";
+		let text_insert = "";
+		let commonlength;
+		while (pointer < diffs.length) switch (diffs[pointer][0]) {
+			case DIFF_INSERT:
+				count_insert++;
+				text_insert += diffs[pointer][1];
+				pointer++;
+				break;
+			case DIFF_DELETE:
+				count_delete++;
+				text_delete += diffs[pointer][1];
+				pointer++;
+				break;
+			case DIFF_EQUAL:
+				if (count_delete + count_insert > 1) {
+					if (count_delete !== 0 && count_insert !== 0) {
+						commonlength = diffCommonPrefix(text_insert, text_delete);
+						if (commonlength !== 0) {
+							if (pointer - count_delete - count_insert > 0 && diffs[pointer - count_delete - count_insert - 1][0] === DIFF_EQUAL) diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);
+							else {
+								diffs.splice(0, 0, createDiff(DIFF_EQUAL, text_insert.substring(0, commonlength)));
+								pointer++;
+							}
+							text_insert = text_insert.substring(commonlength);
+							text_delete = text_delete.substring(commonlength);
+						}
+						commonlength = diffCommonSuffix(text_insert, text_delete);
+						if (commonlength !== 0) {
+							diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];
+							text_insert = text_insert.substring(0, text_insert.length - commonlength);
+							text_delete = text_delete.substring(0, text_delete.length - commonlength);
+						}
+					}
+					pointer -= count_delete + count_insert;
+					diffs.splice(pointer, count_delete + count_insert);
+					if (text_delete.length) {
+						diffs.splice(pointer, 0, createDiff(DIFF_DELETE, text_delete));
+						pointer++;
+					}
+					if (text_insert.length) {
+						diffs.splice(pointer, 0, createDiff(DIFF_INSERT, text_insert));
+						pointer++;
+					}
+					pointer++;
+				} else if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {
+					diffs[pointer - 1][1] += diffs[pointer][1];
+					diffs.splice(pointer, 1);
+				} else pointer++;
+				count_insert = 0;
+				count_delete = 0;
+				text_delete = "";
+				text_insert = "";
+				break;
+		}
+		if (diffs[diffs.length - 1][1] === "") diffs.pop();
+		let changes = false;
+		pointer = 1;
+		while (pointer < diffs.length - 1) {
+			if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+				if (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {
+					diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length);
+					diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
+					diffs.splice(pointer - 1, 1);
+					changes = true;
+				} else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1]) {
+					diffs[pointer - 1][1] += diffs[pointer + 1][1];
+					diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1];
+					diffs.splice(pointer + 1, 1);
+					changes = true;
+				}
+			}
+			pointer++;
+		}
+		if (changes) diffCleanupMerge(diffs);
+	}
+	function calculateDiff(left, right) {
+		const changes = diffMain(left.replace(/\r\n/g, "\n"), right.replace(/\r\n/g, "\n"));
+		diffCleanupSemantic(changes);
+		return changes;
+	}
+	const exports$1 = { calculateDiff };
+	expose(exports$1);
+})();
--- a/node_modules/vite-plugin-inspect/dist/client/assets/dist-Dp-WpU5V.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/dist-Dp-WpU5V.js
@@ -0,0 +1,249 @@
+function serialize(o) {
+	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
+}
+const c = /* @__PURE__ */ function() {
+	class o {
+		#t = new Map();
+		compare(t, r$1) {
+			const e = typeof t, n = typeof r$1;
+			return e === "string" && n === "string" ? t.localeCompare(r$1) : e === "number" && n === "number" ? t - r$1 : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r$1, true));
+		}
+		serialize(t, r$1) {
+			if (t === null) return "null";
+			switch (typeof t) {
+				case "string": return r$1 ? t : `'${t}'`;
+				case "bigint": return `${t}n`;
+				case "object": return this.$object(t);
+				case "function": return this.$function(t);
+			}
+			return String(t);
+		}
+		serializeObject(t) {
+			const r$1 = Object.prototype.toString.call(t);
+			if (r$1 !== "[object Object]") return this.serializeBuiltInType(r$1.length < 10 ? `unknown:${r$1}` : r$1.slice(8, -1), t);
+			const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
+			if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
+			if (typeof t.toJSON == "function") {
+				const i = t.toJSON();
+				return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
+			}
+			return this.serializeObjectEntries(n, Object.entries(t));
+		}
+		serializeBuiltInType(t, r$1) {
+			const e = this["$" + t];
+			if (e) return e.call(this, r$1);
+			if (typeof r$1?.entries == "function") return this.serializeObjectEntries(t, r$1.entries());
+			throw new Error(`Cannot serialize ${t}`);
+		}
+		serializeObjectEntries(t, r$1) {
+			const e = Array.from(r$1).sort((i, a) => this.compare(i[0], a[0]));
+			let n = `${t}{`;
+			for (let i = 0; i < e.length; i++) {
+				const [a, l$1] = e[i];
+				n += `${this.serialize(a, true)}:${this.serialize(l$1)}`, i < e.length - 1 && (n += ",");
+			}
+			return n + "}";
+		}
+		$object(t) {
+			let r$1 = this.#t.get(t);
+			return r$1 === void 0 && (this.#t.set(t, `#${this.#t.size}`), r$1 = this.serializeObject(t), this.#t.set(t, r$1)), r$1;
+		}
+		$function(t) {
+			const r$1 = Function.prototype.toString.call(t);
+			return r$1.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r$1.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(t) {
+			let r$1 = "[";
+			for (let e = 0; e < t.length; e++) r$1 += this.serialize(t[e]), e < t.length - 1 && (r$1 += ",");
+			return r$1 + "]";
+		}
+		$Date(t) {
+			try {
+				return `Date(${t.toISOString()})`;
+			} catch {
+				return "Date(null)";
+			}
+		}
+		$ArrayBuffer(t) {
+			return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
+		}
+		$Set(t) {
+			return `Set${this.$Array(Array.from(t).sort((r$1, e) => this.compare(r$1, e)))}`;
+		}
+		$Map(t) {
+			return this.serializeObjectEntries("Map", t.entries());
+		}
+	}
+	for (const s of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}(${t})`;
+	};
+	for (const s of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join(",")}]`;
+	};
+	for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
+	};
+	return o;
+}();
+const z = [
+	1779033703,
+	-1150833019,
+	1013904242,
+	-1521486534,
+	1359893119,
+	-1694144372,
+	528734635,
+	1541459225
+], R = [
+	1116352408,
+	1899447441,
+	-1245643825,
+	-373957723,
+	961987163,
+	1508970993,
+	-1841331548,
+	-1424204075,
+	-670586216,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	-2132889090,
+	-1680079193,
+	-1046744716,
+	-459576895,
+	-272742522,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	-1740746414,
+	-1473132947,
+	-1341970488,
+	-1084653625,
+	-958395405,
+	-710438585,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	-2117940946,
+	-1838011259,
+	-1564481375,
+	-1474664885,
+	-1035236496,
+	-949202525,
+	-778901479,
+	-694614492,
+	-200395387,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	-2067236844,
+	-1933114872,
+	-1866530822,
+	-1538233109,
+	-1090935817,
+	-965641998
+], S = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", r = [];
+var k = class {
+	_data = new l();
+	_hash = new l([...z]);
+	_nDataBytes = 0;
+	_minBufferSize = 0;
+	finalize(e) {
+		e && this._append(e);
+		const s = this._nDataBytes * 8, t = this._data.sigBytes * 8;
+		return this._data.words[t >>> 5] |= 128 << 24 - t % 32, this._data.words[(t + 64 >>> 9 << 4) + 14] = Math.floor(s / 4294967296), this._data.words[(t + 64 >>> 9 << 4) + 15] = s, this._data.sigBytes = this._data.words.length * 4, this._process(), this._hash;
+	}
+	_doProcessBlock(e, s) {
+		const t = this._hash.words;
+		let i = t[0], o = t[1], a = t[2], c$1 = t[3], h = t[4], g = t[5], f = t[6], y = t[7];
+		for (let n = 0; n < 64; n++) {
+			if (n < 16) r[n] = e[s + n] | 0;
+			else {
+				const d = r[n - 15], j = (d << 25 | d >>> 7) ^ (d << 14 | d >>> 18) ^ d >>> 3, B = r[n - 2], x = (B << 15 | B >>> 17) ^ (B << 13 | B >>> 19) ^ B >>> 10;
+				r[n] = j + r[n - 7] + x + r[n - 16];
+			}
+			const m = h & g ^ ~h & f, p = i & o ^ i & a ^ o & a, u = (i << 30 | i >>> 2) ^ (i << 19 | i >>> 13) ^ (i << 10 | i >>> 22), b = (h << 26 | h >>> 6) ^ (h << 21 | h >>> 11) ^ (h << 7 | h >>> 25), w = y + b + m + R[n] + r[n], M = u + p;
+			y = f, f = g, g = h, h = c$1 + w | 0, c$1 = a, a = o, o = i, i = w + M | 0;
+		}
+		t[0] = t[0] + i | 0, t[1] = t[1] + o | 0, t[2] = t[2] + a | 0, t[3] = t[3] + c$1 | 0, t[4] = t[4] + h | 0, t[5] = t[5] + g | 0, t[6] = t[6] + f | 0, t[7] = t[7] + y | 0;
+	}
+	_append(e) {
+		typeof e == "string" && (e = l.fromUtf8(e)), this._data.concat(e), this._nDataBytes += e.sigBytes;
+	}
+	_process(e) {
+		let s, t = this._data.sigBytes / 64;
+		e ? t = Math.ceil(t) : t = Math.max((t | 0) - this._minBufferSize, 0);
+		const i = t * 16, o = Math.min(i * 4, this._data.sigBytes);
+		if (i) {
+			for (let a = 0; a < i; a += 16) this._doProcessBlock(this._data.words, a);
+			s = this._data.words.splice(0, i), this._data.sigBytes -= o;
+		}
+		return new l(s, o);
+	}
+};
+var l = class l {
+	words;
+	sigBytes;
+	constructor(e, s) {
+		e = this.words = e || [], this.sigBytes = s === void 0 ? e.length * 4 : s;
+	}
+	static fromUtf8(e) {
+		const s = unescape(encodeURIComponent(e)), t = s.length, i = [];
+		for (let o = 0; o < t; o++) i[o >>> 2] |= (s.charCodeAt(o) & 255) << 24 - o % 4 * 8;
+		return new l(i, t);
+	}
+	toBase64() {
+		const e = [];
+		for (let s = 0; s < this.sigBytes; s += 3) {
+			const t = this.words[s >>> 2] >>> 24 - s % 4 * 8 & 255, i = this.words[s + 1 >>> 2] >>> 24 - (s + 1) % 4 * 8 & 255, o = this.words[s + 2 >>> 2] >>> 24 - (s + 2) % 4 * 8 & 255, a = t << 16 | i << 8 | o;
+			for (let c$1 = 0; c$1 < 4 && s * 8 + c$1 * 6 < this.sigBytes * 8; c$1++) e.push(S.charAt(a >>> 6 * (3 - c$1) & 63));
+		}
+		return e.join("");
+	}
+	concat(e) {
+		if (this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8, this.words.length = Math.ceil(this.sigBytes / 4), this.sigBytes % 4) for (let s = 0; s < e.sigBytes; s++) {
+			const t = e.words[s >>> 2] >>> 24 - s % 4 * 8 & 255;
+			this.words[this.sigBytes + s >>> 2] |= t << 24 - (this.sigBytes + s) % 4 * 8;
+		}
+		else for (let s = 0; s < e.sigBytes; s += 4) this.words[this.sigBytes + s >>> 2] = e.words[s >>> 2];
+		this.sigBytes += e.sigBytes;
+	}
+};
+function digest(_) {
+	return new k().finalize(_).toBase64();
+}
+function hash(input) {
+	return digest(serialize(input));
+}
+export { hash };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmmono-8beacb38.woff2
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmmono-8beacb38.woff2
--- a/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmmono-bb868a37.woff2
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmmono-bb868a37.woff2
--- a/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmsans-a41acbfa.woff2
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmsans-a41acbfa.woff2
--- a/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmsans-bde470c1.woff2
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/fonts/dmsans-bde470c1.woff2
--- a/node_modules/vite-plugin-inspect/dist/client/assets/hot-D67q3Up2.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/hot-D67q3Up2.js
@@ -0,0 +1,33 @@
+import { createHotContext } from "./payload-BX9lTMvN.js";
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		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));
+const hotContext = createHotContext();
+async function getHot() {
+	return await hotContext;
+}
+export { __commonJSMin, __export, __toESM, getHot };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/index---UmQy10.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/index---UmQy10.js
@@ -0,0 +1,96 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./pages-g-EVEhKa.js","./_plugin-vue_export-helper-DfavQbjy.js","./payload-BX9lTMvN.js","./runtime-core.esm-bundler-Cyv4obHQ.js","./ModuleList-ByxGSHde.js","./vue-router-BxYGFXy-.js","./QuerySelector-iLRAQoow.js","./options-D_MMddT_.js","./search-Bklj8tNk.js","./_...all_-DVz6Qbfk.js","./metric-D2Mof43y.js","./hot-D67q3Up2.js","./module-BFxZWV4q.js","./module-2YhSO2gi.css","./plugins-Ngzgf8uz.js"])))=>i.map(i=>d[i]);
+import { Suspense, createBlock, createElementBlock, createTextVNode, createVNode, defineComponent, h, onMounted, openBlock, resolveComponent, withAsyncContext, withCtx } from "./runtime-core.esm-bundler-Cyv4obHQ.js";
+import { createApp, createRouter, createWebHashHistory } from "./vue-router-BxYGFXy-.js";
+import { __vitePreload, createPinia, isStaticMode, usePayloadStore } from "./payload-BX9lTMvN.js";
+(function polyfill() {
+	const relList = document.createElement("link").relList;
+	if (relList && relList.supports && relList.supports("modulepreload")) return;
+	for (const link of document.querySelectorAll("link[rel=\"modulepreload\"]")) processPreload(link);
+	new MutationObserver((mutations) => {
+		for (const mutation of mutations) {
+			if (mutation.type !== "childList") continue;
+			for (const node of mutation.addedNodes) if (node.tagName === "LINK" && node.rel === "modulepreload") processPreload(node);
+		}
+	}).observe(document, {
+		childList: true,
+		subtree: true
+	});
+	function getFetchOpts(link) {
+		const fetchOpts = {};
+		if (link.integrity) fetchOpts.integrity = link.integrity;
+		if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
+		if (link.crossOrigin === "use-credentials") fetchOpts.credentials = "include";
+		else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
+		else fetchOpts.credentials = "same-origin";
+		return fetchOpts;
+	}
+	function processPreload(link) {
+		if (link.ep) return;
+		link.ep = true;
+		const fetchOpts = getFetchOpts(link);
+		fetch(link.href, fetchOpts);
+	}
+})();
+const routes = [{
+	path: "/",
+	name: "/",
+	component: () => __vitePreload(() => import("./pages-g-EVEhKa.js"), __vite__mapDeps([0,1,2,3,4,5,6,7,8]), import.meta.url),
+	children: [
+		{
+			path: ":all(.*)",
+			name: "//[...all]",
+			component: () => __vitePreload(() => import("./_...all_-DVz6Qbfk.js"), __vite__mapDeps([9,1,3]), import.meta.url)
+		},
+		{
+			path: "metric",
+			name: "//metric",
+			component: () => __vitePreload(() => import("./metric-D2Mof43y.js"), __vite__mapDeps([10,1,2,3,8,7,6,11]), import.meta.url)
+		},
+		{
+			path: "module",
+			name: "//module",
+			component: () => __vitePreload(() => import("./module-BFxZWV4q.js"), __vite__mapDeps([12,1,2,3,4,5,6,7,11,13]), import.meta.url)
+		},
+		{
+			path: "plugins",
+			name: "//plugins",
+			component: () => __vitePreload(() => import("./plugins-Ngzgf8uz.js"), __vite__mapDeps([14,1,2,3,6]), import.meta.url)
+		}
+	]
+}];
+const _hoisted_1 = {
+	grid: "~ rows-[min-content_1fr]",
+	size: "h-screen w-screen"
+};
+var App_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "App",
+	async setup(__props) {
+		let __temp, __restore;
+		onMounted(() => {
+			if (isStaticMode) document.title = "Vite Inspect (Production)";
+		});
+		const payload = usePayloadStore();
+		[__temp, __restore] = withAsyncContext(() => payload.init()), await __temp, __restore();
+		return (_ctx, _cache) => {
+			const _component_RouterView = resolveComponent("RouterView");
+			return openBlock(), createElementBlock("main", _hoisted_1, [(openBlock(), createBlock(Suspense, null, {
+				fallback: withCtx(() => [..._cache[0] || (_cache[0] = [createTextVNode(" Loading... ", -1)])]),
+				default: withCtx(() => [createVNode(_component_RouterView)]),
+				_: 1
+			}))]);
+		};
+	}
+});
+var App_default = App_vue_vue_type_script_setup_true_lang_default;
+const app = createApp(() => h(Suspense, {}, {
+	default: () => h(App_default),
+	fallback: "Loading..."
+}));
+const router = createRouter({
+	routes,
+	history: createWebHashHistory()
+});
+const pinia = createPinia();
+app.use(pinia);
+app.use(router);
+app.mount("#app");
--- a/node_modules/vite-plugin-inspect/dist/client/assets/index-shvuXdj8.css
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/index-shvuXdj8.css
--- a/node_modules/vite-plugin-inspect/dist/client/assets/metric-D2Mof43y.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/metric-D2Mof43y.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/module-2YhSO2gi.css
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/module-2YhSO2gi.css
@@ -0,0 +1,389 @@
+.CodeMirror-dialog {
+  position: absolute;
+  left: 0; right: 0;
+  background: inherit;
+  z-index: 15;
+  padding: .1em .8em;
+  overflow: hidden;
+  color: inherit;
+}
+
+.CodeMirror-dialog-top {
+  border-bottom: 1px solid #eee;
+  top: 0;
+}
+
+.CodeMirror-dialog-bottom {
+  border-top: 1px solid #eee;
+  bottom: 0;
+}
+
+.CodeMirror-dialog input {
+  border: none;
+  outline: none;
+  background: transparent;
+  width: 20em;
+  color: inherit;
+  font-family: monospace;
+}
+
+.CodeMirror-dialog button {
+  font-size: 70%;
+}
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+  color: black;
+  direction: ltr;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre.CodeMirror-line,
+.CodeMirror pre.CodeMirror-line-like {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+  white-space: nowrap;
+}
+.CodeMirror-linenumbers {}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+  white-space: nowrap;
+}
+
+.CodeMirror-guttermarker { color: black; }
+.CodeMirror-guttermarker-subtle { color: #999; }
+
+/* CURSOR */
+
+.CodeMirror-cursor {
+  border-left: 1px solid black;
+  border-right: none;
+  width: 0;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.cm-fat-cursor .CodeMirror-cursor {
+  width: auto;
+  border: 0 !important;
+  background: #7e7;
+}
+.cm-fat-cursor div.CodeMirror-cursors {
+  z-index: 1;
+}
+.cm-fat-cursor .CodeMirror-line::selection,
+.cm-fat-cursor .CodeMirror-line > span::selection, 
+.cm-fat-cursor .CodeMirror-line > span > span::selection { background: transparent; }
+.cm-fat-cursor .CodeMirror-line::-moz-selection,
+.cm-fat-cursor .CodeMirror-line > span::-moz-selection,
+.cm-fat-cursor .CodeMirror-line > span > span::-moz-selection { background: transparent; }
+.cm-fat-cursor { caret-color: transparent; }
+@-moz-keyframes blink {
+  0% {}
+  50% { background-color: transparent; }
+  100% {}
+}
+@-webkit-keyframes blink {
+  0% {}
+  50% { background-color: transparent; }
+  100% {}
+}
+@keyframes blink {
+  0% {}
+  50% { background-color: transparent; }
+  100% {}
+}
+
+/* Can style cursor different in overwrite (non-insert) mode */
+.CodeMirror-overwrite .CodeMirror-cursor {}
+
+.cm-tab { display: inline-block; text-decoration: inherit; }
+
+.CodeMirror-rulers {
+  position: absolute;
+  left: 0; right: 0; top: -50px; bottom: 0;
+  overflow: hidden;
+}
+.CodeMirror-ruler {
+  border-left: 1px solid #ccc;
+  top: 0; bottom: 0;
+  position: absolute;
+}
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-header {color: blue;}
+.cm-s-default .cm-quote {color: #090;}
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-link {text-decoration: underline;}
+.cm-strikethrough {text-decoration: line-through;}
+
+.cm-s-default .cm-keyword {color: #708;}
+.cm-s-default .cm-atom {color: #219;}
+.cm-s-default .cm-number {color: #164;}
+.cm-s-default .cm-def {color: #00f;}
+.cm-s-default .cm-variable,
+.cm-s-default .cm-punctuation,
+.cm-s-default .cm-property,
+.cm-s-default .cm-operator {}
+.cm-s-default .cm-variable-2 {color: #05a;}
+.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}
+.cm-s-default .cm-comment {color: #a50;}
+.cm-s-default .cm-string {color: #a11;}
+.cm-s-default .cm-string-2 {color: #f50;}
+.cm-s-default .cm-meta {color: #555;}
+.cm-s-default .cm-qualifier {color: #555;}
+.cm-s-default .cm-builtin {color: #30a;}
+.cm-s-default .cm-bracket {color: #997;}
+.cm-s-default .cm-tag {color: #170;}
+.cm-s-default .cm-attribute {color: #00c;}
+.cm-s-default .cm-hr {color: #999;}
+.cm-s-default .cm-link {color: #00c;}
+
+.cm-s-default .cm-error {color: #f00;}
+.cm-invalidchar {color: #f00;}
+
+.CodeMirror-composing { border-bottom: 2px solid; }
+
+/* Default styles for common addons */
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}
+.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
+.CodeMirror-activeline-background {background: #e8f2ff;}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  position: relative;
+  overflow: hidden;
+  background: white;
+}
+
+.CodeMirror-scroll {
+  overflow: scroll !important; /* Things will break if this is overridden */
+  /* 50px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror */
+  margin-bottom: -50px; margin-right: -50px;
+  padding-bottom: 50px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+  z-index: 0;
+}
+.CodeMirror-sizer {
+  position: relative;
+  border-right: 50px solid transparent;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actual scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+  outline: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0; top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0; left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0; bottom: 0;
+}
+.CodeMirror-gutter-filler {
+  left: 0; bottom: 0;
+}
+
+.CodeMirror-gutters {
+  position: absolute; left: 0; top: 0;
+  min-height: 100%;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  white-space: normal;
+  height: 100%;
+  display: inline-block;
+  vertical-align: top;
+  margin-bottom: -50px;
+}
+.CodeMirror-gutter-wrapper {
+  position: absolute;
+  z-index: 4;
+  background: none !important;
+  border: none !important;
+}
+.CodeMirror-gutter-background {
+  position: absolute;
+  top: 0; bottom: 0;
+  z-index: 4;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+.CodeMirror-gutter-wrapper ::selection { background-color: transparent }
+.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }
+
+.CodeMirror-lines {
+  cursor: text;
+  min-height: 1px; /* prevents collapsing before first draw */
+}
+.CodeMirror pre.CodeMirror-line,
+.CodeMirror pre.CodeMirror-line-like {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+  -webkit-tap-highlight-color: transparent;
+  -webkit-font-variant-ligatures: contextual;
+  font-variant-ligatures: contextual;
+}
+.CodeMirror-wrap pre.CodeMirror-line,
+.CodeMirror-wrap pre.CodeMirror-line-like {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0; right: 0; top: 0; bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  padding: 0.1px; /* Force widget margins to stay inside of the container */
+}
+
+.CodeMirror-widget {}
+
+.CodeMirror-rtl pre { direction: rtl; }
+
+.CodeMirror-code {
+  outline: none;
+}
+
+/* Force content-box sizing for the elements where we expect it */
+.CodeMirror-scroll,
+.CodeMirror-sizer,
+.CodeMirror-gutter,
+.CodeMirror-gutters,
+.CodeMirror-linenumber {
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%;
+  height: 0;
+  overflow: hidden;
+  visibility: hidden;
+}
+
+.CodeMirror-cursor {
+  position: absolute;
+  pointer-events: none;
+}
+.CodeMirror-measure pre { position: static; }
+
+div.CodeMirror-cursors {
+  visibility: hidden;
+  position: relative;
+  z-index: 3;
+}
+div.CodeMirror-dragcursors {
+  visibility: visible;
+}
+
+.CodeMirror-focused div.CodeMirror-cursors {
+  visibility: visible;
+}
+
+.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
+.CodeMirror-crosshair { cursor: crosshair; }
+.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }
+.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }
+
+.cm-searching {
+  background-color: #ffa;
+  background-color: rgba(255, 255, 0, .4);
+}
+
+/* Used to force a border model for a node */
+.cm-force-border { padding-right: .1px; }
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursors {
+    visibility: hidden;
+  }
+}
+
+/* See issue #2901 */
+.cm-tab-wrap-hack:after { content: ''; }
+
+/* Help users use markselection to safely style text background */
+span.CodeMirror-selectedtext { background: none; }
+
+.diff-added {
+  background-color:rgb(74 222 128 / 0.15) /* #4ade80 */;
+}
+.diff-removed {
+  background-color:rgb(248 113 113 / 0.15) /* #f87171 */;
+}
+.diff-added-inline {
+  background-color:rgb(74 222 128 / 0.3) /* #4ade80 */;
+}
+.diff-removed-inline {
+  background-color:rgb(248 113 113 / 0.3) /* #f87171 */;
+}
--- a/node_modules/vite-plugin-inspect/dist/client/assets/module-BFxZWV4q.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/module-BFxZWV4q.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/options-D_MMddT_.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/options-D_MMddT_.js
@@ -0,0 +1,114 @@
+import { computed, createBaseVNode, createBlock, createElementBlock, defineComponent, normalizeClass, openBlock, toDisplayString, unref } from "./runtime-core.esm-bundler-Cyv4obHQ.js";
+import { defineStore, useLocalStorage } from "./payload-BX9lTMvN.js";
+const _hoisted_1 = { block: "" };
+const _hoisted_2 = {
+	"ml-0.4": "",
+	"text-xs": "",
+	op75: ""
+};
+var NumberWithUnit_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "NumberWithUnit",
+	props: {
+		number: {},
+		unit: {}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", _hoisted_1, [createBaseVNode("span", null, toDisplayString(_ctx.number), 1), createBaseVNode("span", _hoisted_2, toDisplayString(_ctx.unit), 1)]);
+		};
+	}
+});
+var NumberWithUnit_default = NumberWithUnit_vue_vue_type_script_setup_true_lang_default;
+var DurationDisplay_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "DurationDisplay",
+	props: {
+		duration: {},
+		factor: { default: 1 },
+		color: {
+			type: Boolean,
+			default: true
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		function getDurationColor(duration) {
+			if (!props.color) return "";
+			if (duration == null) return "";
+			duration = duration * props.factor;
+			if (duration < 1) return "";
+			if (duration > 1e3) return "status-red";
+			if (duration > 500) return "status-yellow";
+			if (duration > 200) return "status-green";
+			return "";
+		}
+		const units = computed(() => {
+			if (!props.duration) return ["", "-"];
+			if (props.duration < 1) return ["<1", "ms"];
+			if (props.duration < 1e3) return [props.duration.toFixed(0), "ms"];
+			if (props.duration < 1e3 * 60) return [(props.duration / 1e3).toFixed(1), "s"];
+			return [(props.duration / 1e3 / 60).toFixed(1), "min"];
+		});
+		return (_ctx, _cache) => {
+			const _component_NumberWithUnit = NumberWithUnit_default;
+			return openBlock(), createBlock(_component_NumberWithUnit, {
+				class: normalizeClass(getDurationColor(_ctx.duration)),
+				number: unref(units)[0],
+				unit: unref(units)[1]
+			}, null, 8, [
+				"class",
+				"number",
+				"unit"
+			]);
+		};
+	}
+});
+var DurationDisplay_default = DurationDisplay_vue_vue_type_script_setup_true_lang_default;
+const useOptionsStore = defineStore("options", () => {
+	const view = useLocalStorage(
+		"vite-inspect-v1-options",
+		// @keep-sorted
+		{
+			diff: true,
+			graphWeightMode: "deps",
+			lineWrapping: false,
+			listMode: "detailed",
+			metricDisplayHook: "transform",
+			panelSizeDiff: 30,
+			panelSizeModule: 10,
+			showBailout: false,
+			showOneColumn: false,
+			sort: "default"
+		},
+		{ mergeDefaults: true }
+);
+	const search = useLocalStorage("vite-inspect-v1-search", {
+		text: "",
+		includeNodeModules: false,
+		includeVirtual: false,
+		includeUnreached: false,
+		exactSearch: false
+	}, { mergeDefaults: true });
+	function toggleSort() {
+		const rules = [
+			"default",
+			"time-asc",
+			"time-desc"
+		];
+		view.value.sort = rules[(rules.indexOf(view.value.sort) + 1) % rules.length];
+	}
+	function toggleListMode() {
+		const modes = [
+			"detailed",
+			"graph",
+			"list"
+		];
+		view.value.listMode = modes[(modes.indexOf(view.value.listMode) + 1) % modes.length];
+	}
+	return {
+		view,
+		search,
+		toggleSort,
+		toggleListMode
+	};
+});
+export { DurationDisplay_default, NumberWithUnit_default, useOptionsStore };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/pages-g-EVEhKa.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/pages-g-EVEhKa.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/payload-BX9lTMvN.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/payload-BX9lTMvN.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/plugins-Ngzgf8uz.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/plugins-Ngzgf8uz.js
@@ -0,0 +1,76 @@
+import { Fragment, createBaseVNode, createBlock, createElementBlock, createVNode, defineComponent, h, openBlock, renderList, resolveComponent, resolveDynamicComponent, unref, withCtx } from "./runtime-core.esm-bundler-Cyv4obHQ.js";
+import { usePayloadStore } from "./payload-BX9lTMvN.js";
+import "./_plugin-vue_export-helper-DfavQbjy.js";
+import { Badge_default, Container_default, NavBar_default, PluginName_default, QuerySelector_default } from "./QuerySelector-iLRAQoow.js";
+const _hoisted_1 = { "w-full": "" };
+var plugins_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "plugins",
+	setup(__props) {
+		const payload = usePayloadStore();
+		function renderRow(idx) {
+			const envs = payload.instance.environments.map((e) => payload.instance.environmentPlugins[e].includes(idx));
+			const nodes = [];
+			envs.forEach((e, i) => {
+				if (envs[i - 1] === e) return;
+				if (!e) nodes.push(h("td"));
+				else {
+					let length = envs.slice(i).findIndex((e$1) => !e$1);
+					if (length === -1) length = envs.length - i;
+					nodes.push(h("td", {
+						colspan: length,
+						class: "border border-main px4 py1"
+					}, [h(PluginName_default, { name: payload.instance.plugins[idx].name })]));
+				}
+			});
+			return () => nodes;
+		}
+		return (_ctx, _cache) => {
+			const _component_RouterLink = resolveComponent("RouterLink");
+			const _component_QuerySelector = QuerySelector_default;
+			const _component_NavBar = NavBar_default;
+			const _component_Badge = Badge_default;
+			const _component_Container = Container_default;
+			return openBlock(), createElementBlock(Fragment, null, [createVNode(_component_NavBar, null, {
+				default: withCtx(() => [
+					createVNode(_component_RouterLink, {
+						"my-auto": "",
+						"icon-btn": "",
+						"outline-none": "",
+						to: "/"
+					}, {
+						default: withCtx(() => [..._cache[0] || (_cache[0] = [createBaseVNode("div", { "i-carbon-arrow-left": "" }, null, -1)])]),
+						_: 1
+					}),
+					_cache[1] || (_cache[1] = createBaseVNode("div", { "flex-auto": "" }, null, -1)),
+					createVNode(_component_QuerySelector)
+				]),
+				_: 1
+			}), createVNode(_component_Container, {
+				flex: "",
+				"overflow-auto": "",
+				p5: ""
+			}, {
+				default: withCtx(() => [createBaseVNode("table", _hoisted_1, [createBaseVNode("thead", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(payload).instance.environments, (e) => {
+					return openBlock(), createElementBlock("td", {
+						key: e,
+						border: "~ main",
+						p2: "",
+						"text-center": ""
+					}, [createVNode(_component_Badge, {
+						text: e,
+						size: "none",
+						px2: "",
+						py1: "",
+						"text-sm": "",
+						"font-mono": ""
+					}, null, 8, ["text"])]);
+				}), 128))]), createBaseVNode("tbody", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(payload).instance.plugins, (p, idx) => {
+					return openBlock(), createElementBlock("tr", { key: idx }, [(openBlock(), createBlock(resolveDynamicComponent(renderRow(idx))))]);
+				}), 128))])])]),
+				_: 1
+			})], 64);
+		};
+	}
+});
+var plugins_default = plugins_vue_vue_type_script_setup_true_lang_default;
+export { plugins_default as default };
--- a/node_modules/vite-plugin-inspect/dist/client/assets/runtime-core.esm-bundler-Cyv4obHQ.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/runtime-core.esm-bundler-Cyv4obHQ.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/search-Bklj8tNk.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/search-Bklj8tNk.js
--- a/node_modules/vite-plugin-inspect/dist/client/assets/vue-router-BxYGFXy-.js
+++ b/node_modules/vite-plugin-inspect/dist/client/assets/vue-router-BxYGFXy-.js
--- a/node_modules/vite-plugin-inspect/dist/client/favicon.svg
+++ b/node_modules/vite-plugin-inspect/dist/client/favicon.svg
@@ -0,0 +1,21 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img"
+  class="iconify iconify--carbon" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32">
+  <style>
+    .a {
+      fill: #333;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      .a {
+        fill: #eee;
+      }
+    }
+  </style>
+  <path class="a" d="M6 17h8v2H6z" />
+  <circle cx="3" cy="18" r="1" class="a" />
+  <circle cx="13" cy="14" r="1" class="a" />
+  <path class="a" d="M2 13h8v2H2zm4-4h8v2H6z" />
+  <circle cx="3" cy="10" r="1" class="a" />
+  <path class="a"
+    d="m30 28.6l-7.4-7.4c1.5-2 2.4-4.5 2.4-7.2c0-6.6-5.4-12-12-12c-3.3 0-6.4 1.3-8.7 3.8l1.5 1.4C7.6 5.1 10.2 4 13 4c5.5 0 10 4.5 10 10s-4.5 10-10 10c-3 0-5.8-1.3-7.7-3.6l-1.5 1.3C6 24.4 9.4 26 13 26c3.2 0 6.1-1.3 8.3-3.3l7.3 7.3l1.4-1.4z" />
+</svg>
--- a/node_modules/vite-plugin-inspect/dist/client/index.html
+++ b/node_modules/vite-plugin-inspect/dist/client/index.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="icon" href="./favicon.svg" type="image/svg+xml">
+  <title>Vite Inspect</title>
+  <script type="module" crossorigin src="./assets/index---UmQy10.js"></script>
+  <link rel="modulepreload" crossorigin href="./assets/runtime-core.esm-bundler-Cyv4obHQ.js">
+  <link rel="modulepreload" crossorigin href="./assets/payload-BX9lTMvN.js">
+  <link rel="modulepreload" crossorigin href="./assets/vue-router-BxYGFXy-.js">
+  <link rel="stylesheet" crossorigin href="./assets/index-shvuXdj8.css">
+</head>
+<body data-vite-inspect-mode="DEV" class="bg-main text-main font-sans">
+  <div id="app"></div>
+  <script>
+    (function () {
+      const prefersDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches
+      const setting = localStorage.getItem('color-schema') || 'auto'
+      if (setting === 'dark' || (prefersDark && setting !== 'light'))
+        document.documentElement.classList.toggle('dark', true)
+    })()
+
+    ;(function () {
+      if (!location.pathname.endsWith('/'))
+        location.pathname += '/'
+    })()
+  </script>
+</body>
+</html>