@vuetify/v0 0.0.2-beta.4 → 0.0.2

package/dist/browser/index.js

@@ -0,0 +1,3123 @@
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createPropsRestProxy, defineComponent, getCurrentInstance, getCurrentScope, guardReactiveProps, inject, isRef, mergeModels, mergeProps, normalizeProps, normalizeStyle, onMounted, onScopeDispose, onUnmounted, openBlock, provide, reactive, readonly, ref, renderSlot, resolveDynamicComponent, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toValue, unref, useAttrs, useId, useModel, useTemplateRef, watch, withCtx } from "vue";
+
+//#region src/constants/htmlElements.ts
+const selfClosingTags = [
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+];
+/**
+* Set of HTML elements that are self-closing (void elements)
+* These elements cannot have children and don't need closing tags
+*/
+const SELF_CLOSING_TAGS = new Set(selfClosingTags);
+/**
+* Common HTML element types for polymorphic components
+*/
+const COMMON_ELEMENTS = {
+	DIV: "div",
+	SPAN: "span",
+	SECTION: "section",
+	ARTICLE: "article",
+	ASIDE: "aside",
+	HEADER: "header",
+	FOOTER: "footer",
+	MAIN: "main",
+	NAV: "nav",
+	P: "p",
+	H1: "h1",
+	H2: "h2",
+	H3: "h3",
+	H4: "h4",
+	H5: "h5",
+	H6: "h6",
+	BUTTON: "button",
+	A: "a",
+	INPUT: "input",
+	TEXTAREA: "textarea",
+	SELECT: "select",
+	LABEL: "label",
+	UL: "ul",
+	OL: "ol",
+	LI: "li",
+	DL: "dl",
+	DT: "dt",
+	DD: "dd",
+	IMG: "img",
+	VIDEO: "video",
+	AUDIO: "audio",
+	CANVAS: "canvas",
+	SVG: "svg",
+	TABLE: "table",
+	THEAD: "thead",
+	TBODY: "tbody",
+	TFOOT: "tfoot",
+	TR: "tr",
+	TH: "th",
+	TD: "td",
+	FORM: "form",
+	FIELDSET: "fieldset",
+	LEGEND: "legend"
+};
+/**
+* Check if an element is self-closing
+*/
+function isSelfClosingTag(tag) {
+	return SELF_CLOSING_TAGS.has(tag.toLowerCase());
+}
+
+//#endregion
+//#region src/components/Atom/Atom.vue?vue&type=script&setup=true&lang.ts
+var Atom_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "Atom",
+	__name: "Atom",
+	props: {
+		as: { default: "div" },
+		renderless: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		__expose({ element });
+		const attrs = useAttrs();
+		const isSelfClosing = toRef(() => typeof __props.as === "string" && isSelfClosingTag(__props.as));
+		const slotProps = toRef(() => attrs);
+		return (_ctx, _cache) => {
+			return _ctx.renderless || _ctx.as === null ? renderSlot(_ctx.$slots, "default", normalizeProps(mergeProps({ key: 0 }, slotProps.value))) : !isSelfClosing.value ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.as), mergeProps({ key: 1 }, slotProps.value, {
+				ref_key: "element",
+				ref: element
+			}), {
+				default: withCtx(() => [!isSelfClosing.value ? renderSlot(_ctx.$slots, "default", normalizeProps(mergeProps({ key: 0 }, slotProps.value))) : createCommentVNode("v-if", true)]),
+				_: 3
+			}, 16)) : (openBlock(), createBlock(resolveDynamicComponent(_ctx.as), mergeProps({
+				key: 2,
+				ref_key: "element",
+				ref: element
+			}, slotProps.value), null, 16));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Atom/Atom.vue
+var Atom_default = Atom_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/factories/createContext/index.ts
+/**
+* A simple wrapper for tapping into a v0 namespace
+* @param key The provided string or InjectionKey
+* @template Z The type values for the context.
+* @returns A function that retrieves context
+* @throws Error if namespace is not found.
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+*/
+function useContext(key) {
+	return function(namespace) {
+		const context = inject(namespace || key, void 0);
+		if (context === void 0) throw new Error(`Context "${String(key)}" not found. Ensure it's provided by an ancestor.`);
+		return context;
+	};
+}
+/**
+* A simple wrapper for Vues provide & inject systems
+* to create context for managing application state
+* @param key The provided string or InjectionKey
+* @template Z The type values for the context.
+* @returns A tuple containing provide/inject
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*/
+function createContext(key) {
+	function provideContext(context, app) {
+		app?.provide(key, context) ?? provide(key, context);
+		return context;
+	}
+	return [useContext(key), provideContext];
+}
+
+//#endregion
+//#region src/factories/createPlugin/index.ts
+/**
+* A universal plugin factory to reduce boilerplate code for Vue plugin creation
+* @param options Configurable object with namespace and provide/setup methods
+* @returns A Vue plugin object with install method that runs app w/ context
+*
+* @see https://vuejs.org/api/application.html#app-runwithcontext
+* @see https://0.vuetifyjs.com/factories/create-plugin
+*/
+function createPlugin(options) {
+	return { install(app) {
+		app.runWithContext(() => {
+			options.provide(app);
+			options.setup?.(app);
+		});
+	} };
+}
+
+//#endregion
+//#region src/composables/useHydration/index.ts
+const [useHydrationContext, provideHydrationContext] = createContext("v0:hydration");
+/**
+* Creates a hydration context for tracking client-side hydration state in SSR applications.
+* This function provides a way to determine when the application has been fully hydrated
+* on the client side, which is essential for SSR/SSG compatibility.
+*
+* @returns A hydration context object with reactive state and hydration control.
+*/
+function createHydration() {
+	const isHydrated = shallowRef(false);
+	function hydrate() {
+		isHydrated.value = true;
+	}
+	return {
+		isHydrated: shallowReadonly(isHydrated),
+		hydrate
+	};
+}
+/**
+* Simple hook to access the hydration context.
+*
+* @returns The hydration context containing hydration state and controls.
+*/
+function useHydration() {
+	return useHydrationContext();
+}
+/**
+* Creates a Vue plugin for hydration state management in SSR/SSG applications.
+* This plugin automatically detects when the root component is mounted and
+* triggers the hydration process, ensuring proper client-side hydration timing.
+*
+* @returns A Vue plugin object with install method.
+*/
+function createHydrationPlugin() {
+	const context = createHydration();
+	return createPlugin({
+		namespace: "v0:hydration",
+		provide: (app) => {
+			provideHydrationContext(context, app);
+		},
+		setup: (app) => {
+			app.mixin({ mounted() {
+				if (this.$parent !== null) return;
+				context.hydrate();
+			} });
+		}
+	});
+}
+
+//#endregion
+//#region src/utilities/helpers.ts
+/* @__NO_SIDE_EFFECTS__ */
+function isFunction(item) {
+	return typeof item === "function";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isString(item) {
+	return typeof item === "string";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isNumber(item) {
+	return typeof item === "number";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isBoolean(item) {
+	return typeof item === "boolean";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isObject(item) {
+	return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isArray(item) {
+	return Array.isArray(item);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isNullOrUndefined(item) {
+	return item == null;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function isPrimitive(item) {
+	return typeof item === "string" || typeof item === "number" || typeof item === "boolean";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function mergeDeep(target, ...sources) {
+	if (sources.length === 0) return target;
+	const source = sources.shift();
+	if (/* @__PURE__ */ isObject(target) && /* @__PURE__ */ isObject(source)) {
+		for (const key in source) if (Object.prototype.hasOwnProperty.call(source, key)) {
+			const sourceValue = source[key];
+			const targetValue = target[key];
+			if (/* @__PURE__ */ isObject(sourceValue)) {
+				if (!/* @__PURE__ */ isObject(targetValue)) Object.assign(target, { [key]: {} });
+			} else Object.assign(target, { [key]: sourceValue });
+		}
+	}
+	return /* @__PURE__ */ mergeDeep(target, ...sources);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function genId() {
+	return Math.random().toString(36).slice(2, 9);
+}
+
+//#endregion
+//#region src/constants/globals.ts
+const IN_BROWSER = typeof window !== "undefined";
+const SUPPORTS_TOUCH = IN_BROWSER && ("ontouchstart" in window || window.navigator.maxTouchPoints > 0);
+const SUPPORTS_MATCH_MEDIA = IN_BROWSER && "matchMedia" in window && typeof window.matchMedia === "function";
+const SUPPORTS_OBSERVER = IN_BROWSER && "ResizeObserver" in window;
+const SUPPORTS_INTERSECTION_OBSERVER = IN_BROWSER && "IntersectionObserver" in window;
+const SUPPORTS_MUTATION_OBSERVER = IN_BROWSER && "MutationObserver" in window;
+const version = "0.0.2";
+const __LOGGER_ENABLED__ = false;
+
+//#endregion
+//#region src/composables/useBreakpoints/index.ts
+const [useBreakpointsContext, provideBreakpointsContext] = createContext("v0:breakpoints");
+/**
+* Simple hook to access the breakpoints context.
+*
+* @returns The breakpoints context containing current breakpoint information.
+*/
+function useBreakpoints() {
+	return useBreakpointsContext();
+}
+/**
+* Creates default breakpoint configuration.
+*
+* @returns The default breakpoint configuration object.
+*/
+function createDefaultBreakpoints() {
+	return {
+		mobileBreakpoint: "md",
+		breakpoints: {
+			xs: 0,
+			sm: 600,
+			md: 960,
+			lg: 1280,
+			xl: 1920,
+			xxl: 2560
+		}
+	};
+}
+/**
+* Creates a reactive breakpoints system for responsive behavior management.
+* This function provides access to viewport dimensions, breakpoint detection, and helper flags
+* for determining current screen size and implementing responsive logic.
+*
+* @param options Optional configuration for breakpoint thresholds and mobile breakpoint.
+* @returns A breakpoints context object with reactive state and utility methods.
+*/
+function createBreakpoints(options = {}) {
+	const defaults = createDefaultBreakpoints();
+	const { mobileBreakpoint, breakpoints } = mergeDeep(defaults, options);
+	const sorted = Object.entries(breakpoints).sort((a, b) => a[1] - b[1]);
+	const names = sorted.map(([n]) => n);
+	const mb = typeof mobileBreakpoint === "number" ? mobileBreakpoint : breakpoints[mobileBreakpoint] ?? breakpoints.md;
+	const state = shallowReactive({
+		breakpoints,
+		name: "xs",
+		width: 0,
+		height: 0,
+		isMobile: true,
+		xs: true,
+		sm: false,
+		md: false,
+		lg: false,
+		xl: false,
+		xxl: false,
+		smAndUp: false,
+		mdAndUp: false,
+		lgAndUp: false,
+		xlAndUp: false,
+		xxlAndUp: false,
+		smAndDown: true,
+		mdAndDown: true,
+		lgAndDown: true,
+		xlAndDown: true,
+		xxlAndDown: true,
+		update
+	});
+	function update() {
+		if (!IN_BROWSER) return;
+		state.width = window.innerWidth;
+		state.height = window.innerHeight;
+		let current = "xs";
+		for (let i = sorted.length - 1; i >= 0; i--) if (state.width >= sorted[i][1]) {
+			current = sorted[i][0];
+			break;
+		}
+		state.name = current;
+		const index = names.indexOf(current);
+		state.isMobile = state.width < mb;
+		state.xs = index === 0;
+		state.sm = index === 1;
+		state.md = index === 2;
+		state.lg = index === 3;
+		state.xl = index === 4;
+		state.xxl = index === 5;
+		state.smAndUp = index >= 1;
+		state.mdAndUp = index >= 2;
+		state.lgAndUp = index >= 3;
+		state.xlAndUp = index >= 4;
+		state.xxlAndUp = index >= 5;
+		state.smAndDown = index <= 1;
+		state.mdAndDown = index <= 2;
+		state.lgAndDown = index <= 3;
+		state.xlAndDown = index <= 4;
+		state.xxlAndDown = index <= 5;
+	}
+	if (getCurrentInstance()) onMounted(() => {
+		const { isHydrated } = useHydration();
+		if (isHydrated.value) update();
+		watch(isHydrated, (hydrated) => {
+			if (hydrated) update();
+		}, { immediate: true });
+	});
+	if (IN_BROWSER) {
+		function listener() {
+			update();
+		}
+		window.addEventListener("resize", listener, { passive: true });
+		if (getCurrentInstance()) onScopeDispose(() => window.removeEventListener("resize", listener));
+	}
+	return state;
+}
+/**
+* Creates a Vue plugin for managing responsive breakpoints with automatic updates.
+* This plugin sets up breakpoint tracking and updates the context when the window
+* is resized, providing reactive breakpoint state throughout the application.
+*
+* @param options Optional configuration for breakpoint thresholds and mobile breakpoint.
+* @returns A Vue plugin object with install method.
+*/
+function createBreakpointsPlugin(options = {}) {
+	const context = createBreakpoints(options);
+	return createPlugin({
+		namespace: "v0:breakpoints",
+		provide: (app) => {
+			provideBreakpointsContext(context, app);
+		},
+		setup: (app) => {
+			app.mixin({ mounted() {
+				context.update();
+			} });
+		}
+	});
+}
+
+//#endregion
+//#region src/components/Breakpoints/BreakpointsItem.vue?vue&type=script&setup=true&lang.ts
+var BreakpointsItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "BreakpointsItem",
+	__name: "BreakpointsItem",
+	setup(__props) {
+		const breakpointsContext = useBreakpoints();
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [_ctx.$slots.xs && unref(breakpointsContext).xs ? renderSlot(_ctx.$slots, "xs", normalizeProps(mergeProps({ key: 0 }, unref(breakpointsContext)))) : _ctx.$slots.sm && unref(breakpointsContext).sm ? renderSlot(_ctx.$slots, "sm", normalizeProps(mergeProps({ key: 1 }, unref(breakpointsContext)))) : _ctx.$slots.md && unref(breakpointsContext).md ? renderSlot(_ctx.$slots, "md", normalizeProps(mergeProps({ key: 2 }, unref(breakpointsContext)))) : _ctx.$slots.lg && unref(breakpointsContext).lg ? renderSlot(_ctx.$slots, "lg", normalizeProps(mergeProps({ key: 3 }, unref(breakpointsContext)))) : _ctx.$slots.xl && unref(breakpointsContext).xl ? renderSlot(_ctx.$slots, "xl", normalizeProps(mergeProps({ key: 4 }, unref(breakpointsContext)))) : _ctx.$slots.xxl && unref(breakpointsContext).xxl ? renderSlot(_ctx.$slots, "xxl", normalizeProps(mergeProps({ key: 5 }, unref(breakpointsContext)))) : createCommentVNode("v-if", true), renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(breakpointsContext))))], 64);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Breakpoints/BreakpointsItem.vue
+var BreakpointsItem_default = BreakpointsItem_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Breakpoints/BreakpointsRoot.vue?vue&type=script&setup=true&lang.ts
+var BreakpointsRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "BreakpointsRoot",
+	__name: "BreakpointsRoot",
+	props: {
+		mobileBreakpoint: {},
+		breakpoints: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const breakpointsContext = createBreakpoints(props);
+		provideBreakpointsContext(breakpointsContext);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(breakpointsContext))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Breakpoints/BreakpointsRoot.vue
+var BreakpointsRoot_default = BreakpointsRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Breakpoints/index.ts
+const Breakpoints = {
+	Item: BreakpointsItem_default,
+	Root: BreakpointsRoot_default
+};
+
+//#endregion
+//#region src/components/Context/ContextItem.vue?vue&type=script&setup=true&lang.ts
+var ContextItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "ContextItem",
+	__name: "ContextItem",
+	props: {
+		contextKey: {},
+		value: {}
+	},
+	setup(__props) {
+		let contextValue;
+		if (__props.value !== void 0) contextValue = __props.value;
+		else if (__props.contextKey) {
+			const [injectContext] = createContext(__props.contextKey);
+			contextValue = injectContext();
+		} else throw new Error("Context component requires either a \"value\" prop or a \"contextKey\" prop");
+		const bindableProps = toRef(() => ({ value: contextValue }));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Context/ContextItem.vue
+var ContextItem_default = ContextItem_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Context/ContextRoot.vue?vue&type=script&setup=true&lang.ts
+var ContextRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "ContextRoot",
+	__name: "ContextRoot",
+	props: {
+		contextKey: {},
+		value: {}
+	},
+	setup(__props) {
+		const [, provideContext] = createContext(__props.contextKey);
+		provideContext(__props.value);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Context/ContextRoot.vue
+var ContextRoot_default = ContextRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Context/index.ts
+const Context = {
+	Item: ContextItem_default,
+	Root: ContextRoot_default
+};
+
+//#endregion
+//#region src/composables/useLogger/adapters/consola.ts
+var ConsolaLoggerAdapter = class {
+	consola;
+	constructor(consolaInstance) {
+		if (!consolaInstance) throw new Error("Consola instance is required for ConsolaLoggerAdapter");
+		this.consola = consolaInstance;
+	}
+	debug(message, ...args) {
+		this.consola.debug(message, ...args);
+	}
+	info(message, ...args) {
+		this.consola.info(message, ...args);
+	}
+	warn(message, ...args) {
+		this.consola.warn(message, ...args);
+	}
+	error(message, ...args) {
+		this.consola.error(message, ...args);
+	}
+	trace(message, ...args) {
+		if (this.consola.trace) this.consola.trace(message, ...args);
+		else this.consola.debug(message, ...args);
+	}
+	fatal(message, ...args) {
+		if (this.consola.fatal) this.consola.fatal(message, ...args);
+		else this.consola.error("[FATAL]", message, ...args);
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/adapters/pino.ts
+/**
+* Pino logger adapter implementation
+*
+* This adapter integrates with the Pino logging library,
+* providing high-performance structured logging optimized
+* for Node.js applications with minimal overhead.
+*/
+var PinoLoggerAdapter = class {
+	pino;
+	constructor(pinoInstance) {
+		if (!pinoInstance) throw new Error("Pino instance is required for PinoLoggerAdapter");
+		this.pino = pinoInstance;
+	}
+	debug(message, ...args) {
+		this.pino.debug(this.format(message, ...args));
+	}
+	info(message, ...args) {
+		this.pino.info(this.format(message, ...args));
+	}
+	warn(message, ...args) {
+		this.pino.warn(this.format(message, ...args));
+	}
+	error(message, ...args) {
+		this.pino.error(this.format(message, ...args));
+	}
+	trace(message, ...args) {
+		this.pino.trace(this.format(message, ...args));
+	}
+	fatal(message, ...args) {
+		this.pino.fatal(this.format(message, ...args));
+	}
+	format(message, ...args) {
+		if (args.length === 0) return { msg: message };
+		if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) return {
+			...args[0],
+			msg: message
+		};
+		return {
+			msg: message,
+			args
+		};
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/adapters/v0.ts
+/**
+* Vuetify0.x logger adapter implementation
+*
+* This adapter provides console-based logging with proper formatting,
+* color coding, timestamps, and log level filtering for development
+* and production environments.
+*/
+var Vuetify0LoggerAdapter = class {
+	prefix;
+	colors;
+	timestamps;
+	constructor(options = {}) {
+		this.prefix = options.prefix || "v0";
+		this.colors = options.colors !== false;
+		this.timestamps = options.timestamps !== false;
+	}
+	debug(message, ...args) {
+		this.log("debug", "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log("info", "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log("warn", "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log("error", "error", message, ...args);
+	}
+	trace(message, ...args) {
+		this.log("trace", "trace", message, ...args);
+	}
+	fatal(message, ...args) {
+		this.log("fatal", "error", message, ...args);
+	}
+	format(level, message, ...args) {
+		const timestamp = this.timestamps ? this.timestamp() : "";
+		const prefixTag = `[${this.prefix} ${level.toLowerCase()}]`;
+		const formattedMessage = [
+			timestamp,
+			prefixTag,
+			message
+		].filter(Boolean).join(" ");
+		return [formattedMessage, ...args];
+	}
+	timestamp() {
+		if (!IN_BROWSER) return (/* @__PURE__ */ new Date()).toISOString();
+		const now = /* @__PURE__ */ new Date();
+		return now.toTimeString().split(" ")[0];
+	}
+	style(level) {
+		if (!this.colors || !IN_BROWSER) return "";
+		const styles = {
+			trace: "color: #64748b",
+			debug: "color: #3b82f6",
+			info: "color: #10b981",
+			warn: "color: #f59e0b",
+			error: "color: #ef4444",
+			fatal: "color: #dc2626; font-weight: bold",
+			silent: ""
+		};
+		return styles[level] || "";
+	}
+	log(level, method, message, ...args) {
+		const [formattedMessage, ...restArgs] = this.format(level, message, ...args);
+		const style = this.style(level);
+		if (IN_BROWSER && style && typeof console[method] === "function") console[method](`%c${formattedMessage}`, style, ...restArgs);
+		else if (typeof console[method] === "function") console[method](formattedMessage, ...restArgs);
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/index.ts
+const [useLoggerContext, provideLoggerContext] = createContext("v0:logger");
+/**
+* Creates a logger context for application logging with configurable adapters and levels.
+* This function provides a consistent logging interface that can be configured with
+* different adapters and optimized for production builds with conditional compilation.
+*
+* @param options Configuration for the logger adapter, level, and behavior.
+* @returns A logger context object with logging methods and controls.
+*/
+function createLogger(options = {}) {
+	const { adapter = new Vuetify0LoggerAdapter({ prefix: options.prefix }), level: initialLevel = "info", enabled: initialEnabled = __LOGGER_ENABLED__ } = options;
+	const currentLevel = shallowRef(initialLevel);
+	const isEnabled = shallowRef(initialEnabled);
+	function value(level$1) {
+		const levels = {
+			trace: 0,
+			debug: 1,
+			info: 2,
+			warn: 3,
+			error: 4,
+			fatal: 5,
+			silent: 6
+		};
+		return levels[level$1] ?? 2;
+	}
+	function can(level$1) {
+		if (!isEnabled.value) return false;
+		return value(level$1) >= value(currentLevel.value);
+	}
+	function format(message) {
+		return message;
+	}
+	function debug(message, ...args) {
+		if (can("debug")) adapter.debug(format(message), ...args);
+	}
+	function info(message, ...args) {
+		if (can("info")) adapter.info(format(message), ...args);
+	}
+	function warn(message, ...args) {
+		if (can("warn")) adapter.warn(format(message), ...args);
+	}
+	function error(message, ...args) {
+		if (can("error")) adapter.error(format(message), ...args);
+	}
+	function trace(message, ...args) {
+		if (can("trace")) adapter.trace?.(format(message), ...args);
+	}
+	function fatal(message, ...args) {
+		if (can("fatal")) adapter.fatal?.(format(message), ...args);
+	}
+	function level(newLevel) {
+		currentLevel.value = newLevel;
+	}
+	function current() {
+		return currentLevel.value;
+	}
+	function enabled() {
+		return isEnabled.value;
+	}
+	function enable() {
+		isEnabled.value = true;
+	}
+	function disable() {
+		isEnabled.value = false;
+	}
+	return {
+		debug,
+		info,
+		warn,
+		error,
+		trace,
+		fatal,
+		level,
+		current,
+		enabled,
+		enable,
+		disable
+	};
+}
+function createFallbackLogger(namespace = "v0:logger") {
+	function format(message, type) {
+		return `[${namespace} ${type}] ${message}`;
+	}
+	return {
+		debug: (message, ...args) => console.log(format(message, "debug"), ...args),
+		info: (message, ...args) => console.log(format(message, "info"), ...args),
+		warn: (message, ...args) => console.log(format(message, "warn"), ...args),
+		error: (message, ...args) => console.log(format(message, "error"), ...args),
+		trace: (message, ...args) => console.log(format(message, "trace"), ...args),
+		fatal: (message, ...args) => console.log(format(message, "fatal"), ...args),
+		level: () => {},
+		current: () => "info",
+		enabled: () => true,
+		enable: () => {},
+		disable: () => {}
+	};
+}
+function useLogger(namespace) {
+	if (getCurrentInstance()) try {
+		return useLoggerContext(namespace);
+	} catch (error) {}
+	return createFallbackLogger(namespace);
+}
+function createLoggerPlugin(options = {}) {
+	const context = createLogger(options);
+	return createPlugin({
+		namespace: "v0:logger",
+		provide: (app) => {
+			provideLoggerContext(context, app);
+		},
+		setup: (_app) => {}
+	});
+}
+
+//#endregion
+//#region src/factories/createTrinity/index.ts
+/**
+* A tuple containing Vue's provide/inject and a context object
+* @param createContext The function that creates the context
+* @param provideContext The function that provides context
+* @param context The underlying context object singleton
+* @template Z The type parameter for the context value
+* @template E The vmodel type for the context state.
+* @returns [createContext, provideContext, context]
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-trinity
+*/
+function createTrinity(createContext$1, provideContext, context) {
+	return [
+		createContext$1,
+		(_context = context, app) => provideContext(_context, app),
+		context
+	];
+}
+
+//#endregion
+//#region src/composables/useRegistry/index.ts
+/**
+* Creates a registry for managing collections of items with registration and lookup capabilities.
+* This function provides the foundation for item management systems with ID-based, value-based,
+* and index-based access patterns.
+*
+* @param options Optional configuration for enabling events.
+* @template Z The type of items managed by the registry.
+* @template E The type of the registry context.
+* @returns The registry context object.
+*/
+function useRegistry(options) {
+	const logger = useLogger();
+	const collection = /* @__PURE__ */ new Map();
+	const catalog = /* @__PURE__ */ new Map();
+	const directory = /* @__PURE__ */ new Map();
+	const cache = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	function emit(event, data) {
+		if (!options?.events) return;
+		const cbs = listeners.get(event);
+		if (!cbs) return;
+		for (const cb of cbs) cb(data);
+	}
+	function on(event, cb) {
+		if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+		listeners.get(event).add(cb);
+	}
+	function off(event, cb) {
+		listeners.get(event)?.delete(cb);
+	}
+	function dispose() {
+		if (listeners.size > 0) listeners.clear();
+		clear();
+	}
+	function get(id) {
+		return collection.get(id);
+	}
+	function upsert(id, patch = {}) {
+		const existing = get(id);
+		if (!existing) return register({
+			...patch,
+			id
+		});
+		const hasValue = Object.prototype.hasOwnProperty.call(patch, "value");
+		let value = existing.value;
+		let valueIsIndex = existing.valueIsIndex;
+		if (hasValue) {
+			if (patch.value === void 0) {
+				value = existing.index;
+				valueIsIndex = true;
+			} else {
+				value = patch.value;
+				valueIsIndex = false;
+			}
+			if (!Object.is(value, existing.value)) {
+				unassign(existing.value, id);
+				assign(value, id);
+			}
+		}
+		const updated = {
+			...existing,
+			...patch,
+			id,
+			index: existing.index,
+			value,
+			valueIsIndex
+		};
+		collection.set(id, updated);
+		invalidate();
+		return updated;
+	}
+	function browse(value) {
+		return catalog.get(value);
+	}
+	function lookup(index) {
+		return directory.get(index);
+	}
+	function has(id) {
+		return collection.has(id);
+	}
+	function assign(value, id) {
+		const bucket = catalog.get(value);
+		if (bucket) {
+			if (isArray(bucket)) {
+				if (!bucket.includes(id)) bucket.push(id);
+			} else if (bucket !== id) catalog.set(value, [bucket, id]);
+		} else catalog.set(value, id);
+	}
+	function unassign(value, id) {
+		const bucket = catalog.get(value);
+		if (!bucket) return;
+		if (isArray(bucket)) {
+			const next = bucket.filter((v) => v !== id);
+			if (next.length === 0) catalog.delete(value);
+			else if (next.length === 1) catalog.set(value, next[0]);
+			else catalog.set(value, next);
+		} else if (bucket === id) catalog.delete(value);
+	}
+	function keys() {
+		const cached = cache.get("keys");
+		if (cached != void 0) return cached;
+		const keys$1 = Array.from(collection.keys());
+		cache.set("keys", keys$1);
+		return keys$1;
+	}
+	function values() {
+		const cached = cache.get("values");
+		if (cached != void 0) return cached;
+		const values$1 = Array.from(collection.values());
+		cache.set("values", values$1);
+		return values$1;
+	}
+	function entries() {
+		const cached = cache.get("entries");
+		if (cached != void 0) return cached;
+		const entries$1 = Array.from(collection.entries());
+		cache.set("entries", entries$1);
+		return entries$1;
+	}
+	function clear() {
+		if (collection.size > 0) collection.clear();
+		if (catalog.size > 0) catalog.clear();
+		if (directory.size > 0) directory.clear();
+		invalidate();
+	}
+	function invalidate() {
+		if (cache.size > 0) cache.clear();
+	}
+	function reindex() {
+		if (catalog.size > 0) catalog.clear();
+		if (directory.size > 0) directory.clear();
+		let index = 0;
+		for (const item of values()) {
+			if (item.index !== index) {
+				item.index = index;
+				if (item.valueIsIndex) item.value = index;
+			}
+			directory.set(index, item.id);
+			assign(item.value, item.id);
+			index++;
+		}
+		invalidate();
+	}
+	function register(registration = {}) {
+		const size = collection.size;
+		const id = registration.id ?? genId();
+		if (has(id)) {
+			logger.warn(`Item with id "${id}" already exists in the registry. Skipping registration.`);
+			return get(id);
+		}
+		const index = registration.index ?? size;
+		const value = registration.value === void 0 ? index : registration.value;
+		const valueIsIndex = registration.value === void 0;
+		const item = {
+			...registration,
+			id,
+			index,
+			value,
+			valueIsIndex
+		};
+		collection.set(item.id, item);
+		directory.set(item.index, item.id);
+		assign(item.value, item.id);
+		invalidate();
+		emit("register", item);
+		return item;
+	}
+	function unregister(id) {
+		const item = collection.get(id);
+		if (!item) return;
+		collection.delete(item.id);
+		directory.delete(item.index);
+		unassign(item.value, item.id);
+		emit("unregister", item);
+		reindex();
+	}
+	return {
+		collection,
+		emit,
+		on,
+		off,
+		dispose,
+		has,
+		keys,
+		clear,
+		browse,
+		entries,
+		values,
+		lookup,
+		get,
+		upsert,
+		register,
+		unregister,
+		reindex,
+		onboard(registrations) {
+			return registrations.map((registration) => this.register(registration));
+		},
+		get size() {
+			return collection.size;
+		}
+	};
+}
+/**
+* Creates a registry context with full injection/provision control.
+* Returns the complete trinity for advanced usage scenarios.
+*
+* @param namespace The namespace for the registry context.
+* @param options Optional configuration for reactivity behavior.
+* @template Z The type of tickets managed by the registry.
+* @template E The type of the registry context.
+* @returns A tuple containing the inject function, provide function, and the registry context.
+*/
+function createRegistryContext(namespace, options) {
+	const [useRegistryContext, _provideRegistryContext] = createContext(namespace);
+	const context = useRegistry(options);
+	function provideRegistryContext(_context = context, app) {
+		return _provideRegistryContext(_context, app);
+	}
+	return createTrinity(useRegistryContext, provideRegistryContext, context);
+}
+
+//#endregion
+//#region src/composables/useSelection/index.ts
+/**
+* Creates a selection context for managing collections of selectable items.
+* This function extends the registry functionality with selection state management.
+*
+* @param options Optional configuration for selection behavior.
+* @template Z The type of items managed by the selection.
+* @template E The type of the selection context.
+* @returns The selection context object.
+*/
+function useSelection(options) {
+	const registry = useRegistry(options);
+	const selectedIds = shallowReactive(/* @__PURE__ */ new Set());
+	const enroll = options?.enroll ?? false;
+	const mandatory = options?.mandatory ?? false;
+	const selectedItems = computed(() => {
+		return new Set(Array.from(selectedIds).map((id) => registry.get(id)));
+	});
+	const selectedValues = computed(() => {
+		return new Set(Array.from(selectedItems.value).map((item) => item?.value));
+	});
+	function mandate() {
+		if (!mandatory || registry.selectedIds.size > 0 || registry.size === 0) return;
+		select(registry.lookup(0));
+	}
+	function select(id) {
+		const item = registry.get(id);
+		if (!item || item.disabled) return;
+		selectedIds.add(id);
+	}
+	function unselect(id) {
+		if (mandatory && selectedIds.size === 1) return;
+		selectedIds.delete(id);
+	}
+	function toggle(id) {
+		if (selectedIds.has(id)) unselect(id);
+		else select(id);
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? genId();
+		const item = {
+			disabled: false,
+			...registration,
+			id,
+			isActive: toRef(() => selectedIds.has(id)),
+			select: () => select(id),
+			unselect: () => unselect(id),
+			toggle: () => toggle(id)
+		};
+		const ticket = registry.register(item);
+		if (enroll && !item.disabled) selectedIds.add(ticket.id);
+		if (mandatory === "force") mandate();
+		return ticket;
+	}
+	function unregister(id) {
+		selectedIds.delete(id);
+		registry.unregister(id);
+	}
+	function reset() {
+		registry.clear();
+		registry.reindex();
+		registry.mandate();
+	}
+	return {
+		...registry,
+		selectedIds,
+		selectedItems,
+		selectedValues,
+		register,
+		unregister,
+		reset,
+		mandate,
+		select,
+		unselect,
+		toggle
+	};
+}
+
+//#endregion
+//#region src/utilities/benchmark.ts
+async function run(name, fn, samples = 100) {
+	fn();
+	return {
+		name,
+		duration: 0,
+		ops: Infinity
+	};
+}
+
+//#endregion
+//#region src/transformers/toArray/index.ts
+/* @__NO_SIDE_EFFECTS__ */
+function toArray(value) {
+	return isNullOrUndefined(value) ? [] : Array.isArray(value) ? value : [value];
+}
+
+//#endregion
+//#region src/transformers/toReactive/index.ts
+/**
+* Converts an object to a reactive reference using Vue's reactivity system.
+* This function creates a reactive version of the provided object,
+* making its properties automatically track dependencies and trigger re-renders
+* when they change.
+*
+* @param objectRef - A reference to an object that should be made reactive.
+* @template Z The type of the object that extends object.
+* @returns A reactive reference to the object.
+*/
+function toReactive(objectRef) {
+	if (!isRef(objectRef)) return reactive(objectRef);
+	const target = objectRef.value;
+	if (target instanceof Map) {
+		const mapProxy = new Proxy(/* @__PURE__ */ new Map(), { get(_, p) {
+			const map = objectRef.value;
+			if (p === "get") return (key) => unref(map.get(key));
+			if (p === "set") return (key, value) => {
+				const existingValue = map.get(key);
+				if (isRef(existingValue)) existingValue.value = unref(value);
+				else map.set(key, value);
+				return mapProxy;
+			};
+			if (p === "has") return (key) => map.has(key);
+			if (p === "delete") return (key) => map.delete(key);
+			if (p === "clear") return () => map.clear();
+			if (p === "size") return map.size;
+			if (p === "keys") return () => map.keys();
+			if (p === "values") return function* () {
+				for (const value of map.values()) yield unref(value);
+			};
+			if (p === "entries") return function* () {
+				for (const [key, value] of map.entries()) yield [key, unref(value)];
+			};
+			if (p === "forEach") return (callback, thisArg) => {
+				for (const [key, value] of map.entries()) callback.call(thisArg, unref(value), key, mapProxy);
+			};
+			if (p === Symbol.iterator) return function* () {
+				for (const [key, value] of map.entries()) yield [key, unref(value)];
+			};
+			return Reflect.get(map, p);
+		} });
+		return reactive(mapProxy);
+	}
+	if (target instanceof Set) {
+		const setProxy = new Proxy(/* @__PURE__ */ new Set(), { get(_, p) {
+			const set = objectRef.value;
+			if (p === "add") return (value) => {
+				set.add(value);
+				return setProxy;
+			};
+			if (p === "has") return (value) => set.has(value);
+			if (p === "delete") return (value) => set.delete(value);
+			if (p === "clear") return () => set.clear();
+			if (p === "size") return set.size;
+			if (p === "keys" || p === "values") return function* () {
+				for (const value of set.values()) yield unref(value);
+			};
+			if (p === "entries") return function* () {
+				for (const value of set.values()) {
+					const unreffedValue = unref(value);
+					yield [unreffedValue, unreffedValue];
+				}
+			};
+			if (p === "forEach") return (callback, thisArg) => {
+				for (const value of set) {
+					const unreffedValue = unref(value);
+					callback.call(thisArg, unreffedValue, unreffedValue, setProxy);
+				}
+			};
+			if (p === Symbol.iterator) return function* () {
+				for (const value of set.values()) yield unref(value);
+			};
+			return Reflect.get(set, p);
+		} });
+		return reactive(setProxy);
+	}
+	const proxy = new Proxy({}, {
+		get(_, p, receiver) {
+			return unref(Reflect.get(objectRef.value, p, receiver));
+		},
+		set(_, p, value) {
+			const currentTarget = objectRef.value;
+			currentTarget[p] = value;
+			return true;
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(objectRef.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(objectRef.value, p);
+		},
+		ownKeys() {
+			return Object.keys(objectRef.value);
+		},
+		getOwnPropertyDescriptor(_, p) {
+			const desc = Reflect.getOwnPropertyDescriptor(objectRef.value, p);
+			if (!desc) return void 0;
+			const newDesc = {
+				...desc,
+				configurable: true
+			};
+			if ("value" in newDesc) newDesc.value = unref(newDesc.value);
+			return newDesc;
+		}
+	});
+	return reactive(proxy);
+}
+
+//#endregion
+//#region src/composables/useGroup/index.ts
+/**
+* Creates a group selection context for managing collections of items where multiple selections can be made.
+* This function extends the selection functionality with group selection capabilities.
+*
+* @param options Optional configuration for group selection behavior.
+* @template Z The type of items managed by the group selection.
+* @template E The type of the group selection context.
+* @returns The group selection context object.
+*/
+function useGroup(options) {
+	const registry = useSelection(options);
+	const selectedIndexes = computed(() => {
+		return new Set(Array.from(registry.selectedItems.value).map((item) => item?.index));
+	});
+	function select(ids) {
+		for (const id of toArray(ids)) registry.select(id);
+	}
+	function unselect(ids) {
+		for (const id of toArray(ids)) registry.unselect(id);
+	}
+	function toggle(ids) {
+		for (const id of toArray(ids)) registry.toggle(id);
+	}
+	return {
+		...registry,
+		select,
+		unselect,
+		toggle,
+		selectedIndexes
+	};
+}
+
+//#endregion
+//#region src/components/Group/GroupItem.vue?vue&type=script&setup=true&lang.ts
+var GroupItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "GroupItem",
+	__name: "GroupItem",
+	props: {
+		id: { default: () => useId() },
+		value: {},
+		disabled: { type: Boolean },
+		namespace: { default: "group" }
+	},
+	setup(__props) {
+		const [useGroupContext] = useGroup(__props.namespace);
+		const group = useGroupContext();
+		if (!group) throw new Error(`Failed to get group context at namespace "${__props.namespace}"`);
+		const { isActive, toggle, index } = group.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		onUnmounted(() => {
+			group.unregister(__props.id);
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				index: unref(index),
+				isActive: unref(isActive),
+				toggle: unref(toggle)
+			});
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Group/GroupItem.vue
+var GroupItem_default = GroupItem_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Group/GroupRoot.vue?vue&type=script&setup=true&lang.ts
+var GroupRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "GroupRoot",
+	__name: "GroupRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "group" },
+		enroll: { type: Boolean },
+		mandatory: { type: [Boolean, String] },
+		events: { type: Boolean }
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["namespace"]);
+		const model = useModel(__props, "modelValue");
+		const [, provideGroupContext] = useGroup(__props.namespace, props);
+		const { register, unregister, reset, mandate, select } = provideGroupContext(model);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				mandate: unref(mandate),
+				model: model.value,
+				register: unref(register),
+				reset: unref(reset),
+				select: unref(select),
+				unregister: unref(unregister)
+			});
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Group/GroupRoot.vue
+var GroupRoot_default = GroupRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Group/index.ts
+const Group = {
+	Item: GroupItem_default,
+	Root: GroupRoot_default
+};
+
+//#endregion
+//#region src/components/Hydration/Hydration.vue?vue&type=script&setup=true&lang.ts
+var Hydration_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "Hydration",
+	__name: "Hydration",
+	setup(__props) {
+		const hydrationContext = useHydration();
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(hydrationContext))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Hydration/Hydration.vue
+var Hydration_default = Hydration_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Hydration/HydrationRoot.vue?vue&type=script&setup=true&lang.ts
+var HydrationRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "HydrationRoot",
+	__name: "HydrationRoot",
+	setup(__props) {
+		const hydrationContext = createHydration();
+		provideHydrationContext(hydrationContext);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(hydrationContext))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Hydration/HydrationRoot.vue
+var HydrationRoot_default = HydrationRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Popover/PopoverRoot.vue?vue&type=script&setup=true&lang.ts
+const [usePopoverContext, providePopoverContext] = createContext("Popover");
+var PopoverRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "PopoverRoot",
+	__name: "PopoverRoot",
+	props: /* @__PURE__ */ mergeModels({
+		id: {},
+		as: { default: null },
+		renderless: { type: Boolean }
+	}, {
+		"modelValue": {
+			type: Boolean,
+			default: false
+		},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["as"]);
+		const isActive = useModel(__props, "modelValue");
+		const id = toRef(() => props.id ?? useId());
+		function toggle() {
+			isActive.value = !isActive.value;
+		}
+		const bindableProps = toRef(() => ({
+			id,
+			isActive,
+			toggle
+		}));
+		providePopoverContext({
+			isActive,
+			toggle,
+			id: id.value
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				as: _ctx.as,
+				renderless: _ctx.renderless
+			}, bindableProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Popover/PopoverRoot.vue
+var PopoverRoot_default = PopoverRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Popover/PopoverAnchor.vue?vue&type=script&setup=true&lang.ts
+var PopoverAnchor_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "PopoverAnchor",
+	__name: "PopoverAnchor",
+	props: {
+		target: {},
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["as"]);
+		const context = usePopoverContext();
+		const popovertarget = toRef(() => props.target ?? context.id);
+		const style = toRef(() => ({ anchorName: `--${popovertarget.value}` }));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				as: _ctx.as,
+				"data-popover-open": unref(context).isActive.value ? "" : void 0,
+				popovertarget: popovertarget.value,
+				style: normalizeStyle(style.value),
+				type: _ctx.as === "button" ? "button" : void 0
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as",
+				"data-popover-open",
+				"popovertarget",
+				"style",
+				"type"
+			]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Popover/PopoverAnchor.vue
+var PopoverAnchor_default = PopoverAnchor_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Popover/PopoverContent.vue?vue&type=script&setup=true&lang.ts
+var PopoverContent_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "PopoverContent",
+	__name: "PopoverContent",
+	props: {
+		id: {},
+		positionArea: { default: "bottom" },
+		positionTry: { default: "most-width bottom" },
+		as: {},
+		renderless: { type: Boolean }
+	},
+	emits: ["beforetoggle"],
+	setup(__props, { emit: __emit }) {
+		const props = createPropsRestProxy(__props, ["positionArea", "positionTry"]);
+		const emit = __emit;
+		const context = usePopoverContext();
+		const ref$1 = useTemplateRef("ref");
+		const id = toRef(() => props.id ?? context.id);
+		const style = toRef(() => ({
+			positionArea: __props.positionArea,
+			positionAnchor: `--${id.value}`,
+			positionTry: __props.positionTry
+		}));
+		onMounted(() => {
+			if (context.isActive.value) ref$1.value?.element?.showPopover();
+		});
+		function onBeforeToggle(e) {
+			context.isActive.value = e.newState === "open";
+			emit("beforetoggle", e);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				id: id.value,
+				ref_key: "ref",
+				ref: ref$1,
+				popover: "",
+				style: normalizeStyle(style.value),
+				onBeforetoggle: onBeforeToggle
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["id", "style"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Popover/PopoverContent.vue
+var PopoverContent_default = PopoverContent_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Popover/index.ts
+const Popover = {
+	Root: PopoverRoot_default,
+	Anchor: PopoverAnchor_default,
+	Content: PopoverContent_default
+};
+
+//#endregion
+//#region src/composables/useSingle/index.ts
+/**
+* Creates a single selection context for managing collections where only one item can be selected.
+* This function extends the selection functionality with single-selection constraints.
+*
+* @param options Optional configuration for single selection behavior.
+* @template Z The type of items managed by the single selection.
+* @template E The type of the single selection context.
+* @returns The single selection context object.
+*/
+function useSingle(options) {
+	const registry = useSelection(options);
+	const mandatory = options?.mandatory ?? true;
+	const selectedId = computed(() => registry.selectedIds.values().next().value);
+	const selectedItem = computed(() => registry.selectedItems.value.values().next().value);
+	const selectedIndex = computed(() => selectedItem.value?.index ?? -1);
+	const selectedValue = computed(() => selectedItem.value?.value);
+	function select(id) {
+		const item = registry.get(id);
+		if (!item || item.disabled) return;
+		registry.selectedIds.clear();
+		registry.selectedIds.add(id);
+	}
+	function unselect(id) {
+		if (mandatory && registry.selectedIds.size === 1) return;
+		registry.selectedIds.delete(id);
+	}
+	function toggle(id) {
+		if (registry.selectedIds.has(id)) unselect(id);
+		else select(id);
+	}
+	return {
+		...registry,
+		selectedId,
+		selectedItem,
+		selectedIndex,
+		selectedValue,
+		select,
+		unselect,
+		toggle
+	};
+}
+
+//#endregion
+//#region src/composables/useStep/index.ts
+/**
+* Creates a step selection context for managing collections where users can navigate through items sequentially.
+* This function extends the single selection functionality with stepping navigation.
+*
+* @param options Optional configuration for step behavior.
+* @template Z The type of items managed by the step selection.
+* @template E The type of the step selection context.
+* @returns The step selection context object.
+*/
+function useStep(options) {
+	const registry = useSingle(options);
+	function first() {
+		if (registry.size === 0) return;
+		registry.selectedIds.clear();
+		registry.select(registry.lookup(0));
+	}
+	function last() {
+		const size = registry.size;
+		if (size === 0) return;
+		registry.selectedIds.clear();
+		registry.select(registry.lookup(size - 1));
+	}
+	function next() {
+		step(1);
+	}
+	function prev() {
+		step(-1);
+	}
+	function wrapped(length, index) {
+		return (index + length) % length;
+	}
+	function step(count = 1) {
+		const length = registry.size;
+		if (!length) return;
+		const direction = Math.sign(count || 1);
+		let hops = 0;
+		let index = wrapped(length, registry.selectedIndex.value + count);
+		let id = registry.lookup(index);
+		while (id !== void 0 && registry.get(id)?.disabled && hops < length) {
+			index = wrapped(length, index + direction);
+			id = registry.lookup(index);
+			hops++;
+		}
+		if (id === void 0 || hops === length) return;
+		registry.selectedIds.clear();
+		registry.select(id);
+	}
+	return {
+		...registry,
+		first,
+		last,
+		next,
+		prev,
+		step
+	};
+}
+
+//#endregion
+//#region src/components/Step/StepItem.vue?vue&type=script&setup=true&lang.ts
+var StepItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "StepItem",
+	__name: "StepItem",
+	props: {
+		id: { default: () => useId() },
+		value: {},
+		disabled: { type: Boolean },
+		namespace: { default: "step" }
+	},
+	setup(__props) {
+		const [useStepContext] = useStep(__props.namespace);
+		const step = useStepContext();
+		if (!step) throw new Error(`Failed to get step context at namespace "${__props.namespace}"`);
+		const { index, isActive, toggle } = step.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		onUnmounted(() => {
+			step.unregister(__props.id);
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				index: unref(index),
+				isActive: unref(isActive),
+				toggle: unref(toggle)
+			});
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Step/StepItem.vue
+var StepItem_default = StepItem_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Step/StepRoot.vue?vue&type=script&setup=true&lang.ts
+var StepRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "StepRoot",
+	__name: "StepRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "step" },
+		enroll: { type: Boolean },
+		mandatory: { type: [Boolean, String] },
+		events: { type: Boolean }
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["namespace"]);
+		const model = useModel(__props, "modelValue");
+		const [, provideStepContext] = useStep(__props.namespace, props);
+		const { register, unregister, reset, mandate, select, first, last, next, prev, step } = provideStepContext(model);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				first: unref(first),
+				last: unref(last),
+				mandate: unref(mandate),
+				model: model.value,
+				next: unref(next),
+				prev: unref(prev),
+				register: unref(register),
+				reset: unref(reset),
+				select: unref(select),
+				step: unref(step),
+				unregister: unref(unregister)
+			});
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Step/StepRoot.vue
+var StepRoot_default = StepRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Step/index.ts
+const Step = {
+	Item: StepItem_default,
+	Root: StepRoot_default
+};
+
+//#endregion
+//#region src/composables/useTokens/index.ts
+/**
+* Creates a token registry for managing design token collections with alias resolution.
+* Returns the token context directly for simple usage.
+*
+* @param tokens A collection of tokens to initialize with
+* @template Z The structure of the registry token items.
+* @template E The available methods for the token's context.
+* @returns The token context object.
+* @see https://www.designtokens.org/tr/drafts/format/
+*/
+function useTokens(tokens = {}) {
+	const logger = useLogger();
+	const registry = useRegistry();
+	const cache = /* @__PURE__ */ new Map();
+	registry.onboard(flatten(tokens));
+	function isAlias(token) {
+		return isString(token) && token.length > 2 && token[0] === "{" && token.at(-1) === "}";
+	}
+	function isTokenAlias(value) {
+		return isObject(value) && "$value" in value;
+	}
+	function resolve(token) {
+		const cacheKey = isString(token) ? token : JSON.stringify(token);
+		const cached = cache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const reference = isTokenAlias(token) ? token.$value : token;
+		const clean = isString(reference) && isAlias(reference) ? reference.slice(1, -1) : String(reference);
+		let found = registry.get(clean);
+		let segments = [];
+		if (!found && clean.includes(".")) {
+			const parts = clean.split(".");
+			for (let i = parts.length - 1; i > 0; i--) {
+				const prefix = parts.slice(0, i).join(".");
+				const suffix = parts.slice(i);
+				const candidate = registry.get(prefix);
+				if (candidate?.value !== void 0) {
+					found = candidate;
+					segments = suffix;
+					break;
+				}
+			}
+		}
+		if (found?.value === void 0) {
+			logger.warn(`Alias not found for "${String(reference)}"`);
+			cache.set(cacheKey, void 0);
+			return void 0;
+		}
+		let result;
+		let current = found.value;
+		if (segments.length > 0) {
+			if (isTokenAlias(current)) current = current.$value;
+			for (const segment of segments) {
+				if (!isObject(current) || !(segment in current)) {
+					current = void 0;
+					break;
+				}
+				current = current[segment];
+				if (isTokenAlias(current)) current = current.$value;
+			}
+			if (current === void 0) {
+				logger.warn(`Path not found inside "${clean}": ${segments.join(".")}`);
+				cache.set(cacheKey, void 0);
+				return void 0;
+			}
+			result = current;
+		} else if (isTokenAlias(current)) {
+			const inner = current.$value;
+			if (isString(inner) && isAlias(inner)) return resolve(inner);
+			result = inner;
+		} else if (isString(current) && isAlias(current)) return resolve(current);
+		else result = current;
+		cache.set(cacheKey, result);
+		return result;
+	}
+	return {
+		...registry,
+		resolve
+	};
+}
+/**
+* Creates a token registry context with full injection/provision control.
+* Returns the complete trinity for advanced usage scenarios.
+*
+* @param namespace The namespace for the token registry context
+* @param tokens An optional collection of tokens to initialize
+* @template Z The structure of the registry token items.
+* @template E The available methods for the token's context.
+* @returns A tuple containing the inject function, provide function, and the token context.
+*/
+function createTokensContext(namespace, tokens = {}) {
+	const [useTokensContext, _provideTokensContext] = createContext(namespace);
+	const context = useTokens(tokens);
+	function provideTokensContext(_context = context, app) {
+		return _provideTokensContext(_context, app);
+	}
+	return createTrinity(useTokensContext, provideTokensContext, context);
+}
+/**
+* Flattens a nested collection of tokens into a flat array of tokens.
+* Each token is represented by an object containing its ID & value.
+* @param tokens The collection of tokens to flatten.
+* @param prefix An optional prefix to prepend to each token ID.
+* @returns An array of flattened tokens, each with an ID and value.
+*/
+function flatten(tokens, prefix = "") {
+	const flattened = [];
+	const stack = [{
+		tokens,
+		prefix
+	}];
+	while (stack.length > 0) {
+		const { tokens: currentTokens, prefix: currentPrefix } = stack.pop();
+		const meta = {};
+		for (const k in currentTokens) if (k.startsWith("$")) meta[k] = currentTokens[k];
+		if (Object.keys(meta).length > 0 && currentPrefix) flattened.push({
+			id: currentPrefix,
+			value: meta
+		});
+		for (const key in currentTokens) {
+			if (key.startsWith("$")) continue;
+			const value = currentTokens[key];
+			const id = currentPrefix ? `${currentPrefix}.${key}` : key;
+			if (!isObject(value)) {
+				flattened.push({
+					id,
+					value
+				});
+				continue;
+			}
+			if ("$value" in value) {
+				flattened.push({
+					id,
+					value
+				});
+				const inner = value.$value;
+				if (isObject(inner)) for (const innerKey in inner) {
+					if (innerKey.startsWith("$")) continue;
+					const child = inner[innerKey];
+					const childId = `${id}.${innerKey}`;
+					if (!isObject(child)) flattened.push({
+						id: childId,
+						value: child
+					});
+					else if ("$value" in child) flattened.push({
+						id: childId,
+						value: child
+					});
+					else stack.push({
+						tokens: child,
+						prefix: childId
+					});
+				}
+				continue;
+			}
+			stack.push({
+				tokens: value,
+				prefix: id
+			});
+		}
+	}
+	return flattened;
+}
+
+//#endregion
+//#region src/composables/useTheme/adapters/adapter.ts
+var ThemeAdapter = class {
+	prefix;
+	constructor(prefix) {
+		this.prefix = prefix;
+	}
+	generate(colors) {
+		let css = "";
+		for (const theme in colors) {
+			const themeColors = colors[theme];
+			if (!themeColors) continue;
+			const vars = Object.entries(themeColors).map(([key, val]) => `  --${this.prefix}-${key}: ${val};`).join("\n");
+			css += `.${this.prefix}-theme--${theme} {\n${vars}\n}\n`;
+		}
+		return css;
+	}
+};
+
+//#endregion
+//#region src/composables/useTheme/adapters/v0.ts
+/**
+* Theme adapter implementation for Vuetify v0 design system.
+* This adapter generates CSS custom properties and injects them into the DOM
+* as a stylesheet, allowing themes to be applied globally.
+*/
+var Vuetify0ThemeAdapter = class extends ThemeAdapter {
+	cspNonce;
+	stylesheetId = "v0-theme-stylesheet";
+	constructor(options = {}) {
+		super(options.prefix ?? "v0");
+		this.cspNonce = options.cspNonce;
+		this.stylesheetId = options.stylesheetId ?? this.stylesheetId;
+	}
+	update(colors) {
+		if (!IN_BROWSER) return;
+		this.upsert(this.generate(colors));
+	}
+	upsert(styles) {
+		if (!IN_BROWSER) return;
+		let styleEl = document.querySelector(`#${this.stylesheetId}`);
+		if (!styleEl) {
+			styleEl = document.createElement("style");
+			styleEl.id = this.stylesheetId.startsWith("#") ? this.stylesheetId.slice(1) : this.stylesheetId;
+			if (this.cspNonce) styleEl.setAttribute("nonce", this.cspNonce);
+			document.head.append(styleEl);
+		}
+		styleEl.textContent = styles;
+	}
+};
+
+//#endregion
+//#region src/composables/useTheme/index.ts
+/**
+* Creates a theme registry for managing theme selections with dynamic color resolution.
+* Supports token-based color systems and lazy theme loading for optimal performance.
+*
+* @param namespace The namespace for the theme context.
+* @param options Configuration including adapter and themes.
+* @template Z The type of theme context.
+* @template E The type of theme items managed by the registry.
+* @returns A tuple containing inject, provide functions and the theme context.
+*/
+function createTheme(namespace = "v0:theme", options = {}) {
+	const { themes = {}, palette = {} } = options;
+	const [useThemeContext, _provideThemeContext] = createContext(namespace);
+	const registry = useSingle();
+	for (const id in themes) {
+		register({
+			id,
+			value: themes[id].colors,
+			dark: themes[id].dark ?? false,
+			lazy: themes[id].lazy ?? false
+		});
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	const names = computed(() => registry.keys());
+	const colors = computed(() => {
+		const resolved = {};
+		for (const theme of registry.values()) {
+			if (theme.lazy && theme.id !== registry.selectedId.value) continue;
+			resolved[String(theme.id)] = resolve(theme.id, theme.value);
+		}
+		return resolved;
+	});
+	function cycle(themes$1 = names.value) {
+		const current = themes$1.indexOf(registry.selectedId.value ?? "");
+		const next = current === -1 ? 0 : (current + 1) % themes$1.length;
+		registry.select(themes$1[next]);
+	}
+	function resolve(themeId, colors$1) {
+		const resolved = {};
+		for (const [key, value] of Object.entries(colors$1)) resolved[key] = resolveTokenReference(themeId, value);
+		return resolved;
+	}
+	function resolveTokenReference(themeId, value) {
+		return value.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, tokenKey) => {
+			if (palette[tokenKey]) return isString(palette[tokenKey]) ? palette[tokenKey] : match;
+			const [targetTheme, ...colorPath] = tokenKey.split(".");
+			const colorKey = colorPath.join(".");
+			if (targetTheme && colorKey) {
+				const targetColors = themes[targetTheme];
+				const resolved$1 = targetColors?.[colorKey];
+				return isString(resolved$1) ? resolveTokenReference(targetTheme, resolved$1) : match;
+			}
+			const currentColors = themes[themeId];
+			const resolved = currentColors?.[tokenKey];
+			return isString(resolved) ? resolveTokenReference(themeId, resolved) : match;
+		});
+	}
+	function register(registration = {}) {
+		const item = {
+			lazy: false,
+			dark: false,
+			...registration
+		};
+		return registry.register(item);
+	}
+	const context = {
+		...registry,
+		colors,
+		register,
+		cycle
+	};
+	function provideThemeContext(_context = context, app) {
+		return _provideThemeContext(_context, app);
+	}
+	return createTrinity(useThemeContext, provideThemeContext, context);
+}
+/**
+* Simple hook to access the theme context.
+*
+* @returns The theme context containing current theme state and utilities.
+*/
+function useTheme() {
+	return useContext("v0:theme")();
+}
+/**
+* Creates a Vue plugin for theme management with automatic color system updates.
+* Integrates with token system for dynamic color resolution and provides reactive
+* theme switching capabilities throughout the application.
+*
+* @param options Configuration for themes, palette, and adapter.
+* @template Z The type of theme context.
+* @template E The type of theme items.
+* @template R The type of token context.
+* @template O The type of token items.
+* @returns A Vue plugin object with install method.
+*/
+function createThemePlugin(_options = {}) {
+	const { adapter = new Vuetify0ThemeAdapter(), palette = {}, themes = {},...options } = _options;
+	const [, provideThemeTokenContext, tokensContext] = createTokensContext("v0:theme:tokens", {
+		palette,
+		...themes
+	});
+	const [, provideThemeContext, themeContext] = createTheme("v0:theme", {
+		...options,
+		themes,
+		palette
+	});
+	function update(colors) {
+		adapter.update(colors);
+	}
+	return createPlugin({
+		namespace: "v0:theme",
+		provide: (app) => {
+			provideThemeContext(themeContext, app);
+			provideThemeTokenContext(tokensContext, app);
+		},
+		setup: () => {
+			if (IN_BROWSER) watch(themeContext.colors, update, {
+				immediate: true,
+				deep: true
+			});
+			else update(themeContext.colors.value);
+		}
+	});
+}
+
+//#endregion
+//#region src/components/Theme/ThemeItem.vue?vue&type=script&setup=true&lang.ts
+var ThemeItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "ThemeItem",
+	__name: "ThemeItem",
+	setup(__props) {
+		const themeContext = useTheme();
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(themeContext))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Theme/ThemeItem.vue
+var ThemeItem_default = ThemeItem_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Theme/ThemeRoot.vue?vue&type=script&setup=true&lang.ts
+var ThemeRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "ThemeRoot",
+	__name: "ThemeRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:theme" },
+		themes: { default: () => [] }
+	}, {
+		"modelValue": { default: "default" },
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		useModel(__props, "modelValue");
+		const [provideThemeContext] = createTheme(__props.namespace);
+		const themeContext = provideThemeContext();
+		for (const theme of __props.themes) themeContext.register(theme);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(themeContext))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/Theme/ThemeRoot.vue
+var ThemeRoot_default = ThemeRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/Theme/index.ts
+const Theme = {
+	Item: ThemeItem_default,
+	Root: ThemeRoot_default
+};
+
+//#endregion
+//#region src/composables/useEventListener/index.ts
+function useEventListener(target, event, listener, options) {
+	const cleanups = [];
+	function cleanup() {
+		for (const fn of cleanups) fn();
+		cleanups.length = 0;
+	}
+	const register = (el, event$1, listener$1, options$1) => {
+		el.addEventListener(event$1, listener$1, options$1);
+		return () => el.removeEventListener(event$1, listener$1, options$1);
+	};
+	const stopWatcher = watch(() => [
+		toValue(target),
+		toValue(event),
+		unref(listener),
+		toValue(options)
+	], ([el, events, listeners, opts]) => {
+		cleanup();
+		if (!el) return;
+		const eventList = toArray(events);
+		const listenerList = toArray(listeners);
+		for (const event$1 of eventList) for (const listenerFn of listenerList) cleanups.push(register(el, event$1, listenerFn, opts));
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	function stop() {
+		stopWatcher();
+		cleanup();
+	}
+	onScopeDispose(stop, true);
+	return stop;
+}
+/**
+* Convenience function for attaching event listeners to the window object.
+* This function provides a simplified API by pre-binding the window target,
+* making it easier to handle window-specific events with automatic cleanup.
+*
+* @param event Event name(s) to listen for from WindowEventMap.
+* @param listener Event handler function(s) with proper window event typing.
+* @param options Optional event listener configuration.
+* @returns Function to manually remove all attached listeners.
+*/
+function useWindowEventListener(event, listener, options) {
+	return useEventListener(window, event, listener, options);
+}
+/**
+* Convenience function for attaching event listeners to the document object.
+* This function provides a simplified API by pre-binding the document target,
+* making it easier to handle document-specific events with automatic cleanup.
+*
+* @param event Event name(s) to listen for from DocumentEventMap.
+* @param listener Event handler function(s) with proper document event typing.
+* @param options Optional event listener configuration.
+* @returns Function to manually remove all attached listeners.
+*/
+function useDocumentEventListener(event, listener, options) {
+	return useEventListener(document, event, listener, options);
+}
+
+//#endregion
+//#region src/composables/useFilter/index.ts
+function defaultFilter(query, item, keys, mode = "some") {
+	const queries = Array.isArray(query) ? query.map((q) => String(q).toLowerCase()) : [String(query).toLowerCase()];
+	function match(value, q) {
+		return String(value).toLowerCase().includes(q);
+	}
+	const values = typeof item === "object" && item !== null ? keys?.length ? keys.map((k) => item[k]) : Object.values(item) : [item];
+	const stringValues = values.map((v) => String(v).toLowerCase());
+	if (mode === "some") return stringValues.some((val) => match(val, queries[0]));
+	if (mode === "every") return stringValues.every((val) => match(val, queries[0]));
+	if (mode === "union") return queries.some((q) => stringValues.some((val) => match(val, q)));
+	if (mode === "intersection") return queries.every((q) => stringValues.some((val) => match(val, q)));
+	return false;
+}
+function toRefOrGetter(value) {
+	return isRef(value) ? value : typeof value === "function" ? toRef(value) : toRef(() => value);
+}
+/**
+* Creates a reactive filter for arrays based on query matching with configurable search modes.
+* Supports 'some' (any field matches), 'every' (all fields match), 'union' (any query matches),
+* and 'intersection' (all queries match) filtering strategies.
+*
+* @param query Filter query to match against items.
+* @param items Collection of items to filter.
+* @param options Optional configuration for the filter behavior.
+* @template Z The type of the items being filtered.
+* @returns A computed reference to the filtered items based on the query and options.
+*/
+function useFilter(query, items, options = {}) {
+	const { customFilter, keys, mode = "some" } = options;
+	const filterFunction = customFilter ?? ((q, i) => defaultFilter(q, i, keys, mode));
+	const itemsRef = isRef(items) ? items : toRef(() => items);
+	const queryRef = toRefOrGetter(query);
+	const filteredItems = computed(() => {
+		const q = toValue(queryRef);
+		const queries = (Array.isArray(q) ? q : [q]).filter((q$1) => String(q$1).trim());
+		if (queries.length === 0) return itemsRef.value;
+		const queryParam = queries.length === 1 ? queries[0] : queries;
+		return itemsRef.value.filter((item) => filterFunction(queryParam, item));
+	});
+	return { items: filteredItems };
+}
+
+//#endregion
+//#region src/composables/useForm/index.ts
+function useForm(options) {
+	const registry = useRegistry(options);
+	const validateOn = options?.validateOn || "submit";
+	function parse(value) {
+		return value.toLowerCase().split(/\s+/);
+	}
+	function validatesOn(event) {
+		return parse(validateOn).includes(event);
+	}
+	const isValidating = computed(() => {
+		for (const ticket of registry.collection.values()) if (ticket.isValidating.value) return true;
+		return false;
+	});
+	const isValid = computed(() => {
+		let hasFields = false;
+		for (const ticket of registry.values()) {
+			hasFields = true;
+			if (ticket.isValid.value === false) return false;
+			if (ticket.isValid.value === null) return null;
+		}
+		return hasFields ? true : null;
+	});
+	function reset() {
+		for (const ticket of registry.values()) ticket.reset();
+	}
+	async function submit() {
+		return validate(registry.keys());
+	}
+	async function validate(id) {
+		const validating = toArray(id);
+		if (validatesOn("submit")) {
+			const results = await Promise.all(validating.map(async (id$1) => await registry.get(id$1)?.validate() ?? true));
+			return results.every(Boolean);
+		}
+		const tickets = validating.map((id$1) => registry.get(id$1)).filter(Boolean);
+		return tickets.every((ticket) => ticket.isValid.value === true);
+	}
+	function register(registration) {
+		const model = shallowRef(registration.value == null ? "" : toValue(registration.value));
+		const rules = registration.rules || [];
+		const errors = shallowRef([]);
+		const isValidating$1 = shallowRef(false);
+		const initialValue = model.value;
+		const triggers = registration.validateOn || validateOn;
+		const isPristine = shallowRef(true);
+		const isValid$1 = shallowRef(null);
+		function _validatesOn(event) {
+			return parse(triggers).includes(event);
+		}
+		function _reset() {
+			model.value = initialValue;
+			errors.value = [];
+			isPristine.value = true;
+			isValid$1.value = null;
+		}
+		async function validate$1(silent = false) {
+			if (rules.length === 0) return true;
+			isValidating$1.value = true;
+			try {
+				const results = await Promise.all(rules.map((rule) => rule(model.value)));
+				const errorMessages = results.filter((result) => typeof result === "string");
+				if (!silent) {
+					errors.value = errorMessages;
+					isValid$1.value = errorMessages.length === 0;
+					isPristine.value = toValue(model) === initialValue;
+				}
+				return errorMessages.length === 0;
+			} finally {
+				isValidating$1.value = false;
+			}
+		}
+		const item = {
+			...registration,
+			rules,
+			errors,
+			disabled: registration.disabled || false,
+			validateOn: triggers,
+			isValidating: isValidating$1,
+			isPristine,
+			isValid: isValid$1,
+			reset: _reset,
+			validate: validate$1
+		};
+		const ticket = registry.register(item);
+		Object.defineProperty(ticket, "value", {
+			get() {
+				return model.value;
+			},
+			set(val) {
+				model.value = val;
+				isPristine.value = val === initialValue;
+				isValid$1.value = null;
+				if (_validatesOn("change")) validate$1();
+			},
+			enumerable: true,
+			configurable: true
+		});
+		return ticket;
+	}
+	return {
+		...registry,
+		register,
+		reset,
+		submit,
+		validateOn,
+		isValid,
+		isValidating
+	};
+}
+
+//#endregion
+//#region src/composables/useIntersectionObserver/index.ts
+/**
+* Composable for observing element intersection with viewport or ancestor
+*
+* @param target - Element ref to observe
+* @param callback - Callback fired on intersection change
+* @param options - Observer options
+* @returns Observer controls and intersection state
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
+*/
+function useIntersectionObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	const isIntersecting = shallowRef(false);
+	watch([isHydrated, target], ([hydrated, el]) => {
+		cleanup();
+		if (!hydrated || !SUPPORTS_INTERSECTION_OBSERVER || !el) return;
+		observer.value = new IntersectionObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				boundingClientRect: entry.boundingClientRect,
+				intersectionRatio: entry.intersectionRatio,
+				intersectionRect: entry.intersectionRect,
+				isIntersecting: entry.isIntersecting,
+				rootBounds: entry.rootBounds,
+				target: entry.target,
+				time: entry.time
+			}));
+			const latestEntry = transformedEntries.at(-1);
+			if (latestEntry) isIntersecting.value = latestEntry.isIntersecting;
+			callback(transformedEntries);
+		}, {
+			root: options.root || null,
+			rootMargin: options.rootMargin || "0px",
+			threshold: options.threshold || 0
+		});
+		observer.value.observe(el);
+		if (options.immediate) {
+			const rect = el.getBoundingClientRect();
+			const syntheticEntry = {
+				boundingClientRect: rect,
+				intersectionRatio: 0,
+				intersectionRect: new DOMRect(0, 0, 0, 0),
+				isIntersecting: false,
+				rootBounds: null,
+				target: el,
+				time: performance.now()
+			};
+			callback([syntheticEntry]);
+		}
+	});
+	function setup() {
+		if (!isHydrated.value || !SUPPORTS_INTERSECTION_OBSERVER || !target.value || isPaused.value) return;
+		observer.value = new IntersectionObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				boundingClientRect: entry.boundingClientRect,
+				intersectionRatio: entry.intersectionRatio,
+				intersectionRect: entry.intersectionRect,
+				isIntersecting: entry.isIntersecting,
+				rootBounds: entry.rootBounds,
+				target: entry.target,
+				time: entry.time
+			}));
+			const latestEntry = transformedEntries.at(-1);
+			if (latestEntry) isIntersecting.value = latestEntry.isIntersecting;
+			callback(transformedEntries);
+		}, {
+			root: options.root || null,
+			rootMargin: options.rootMargin || "0px",
+			threshold: options.threshold || 0
+		});
+		observer.value.observe(target.value);
+		if (options.immediate) {
+			const rect = target.value.getBoundingClientRect();
+			const syntheticEntry = {
+				boundingClientRect: rect,
+				intersectionRatio: 0,
+				intersectionRect: new DOMRect(0, 0, 0, 0),
+				isIntersecting: false,
+				rootBounds: null,
+				target: target.value,
+				time: performance.now()
+			};
+			callback([syntheticEntry]);
+		}
+	}
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		cleanup();
+	}
+	onUnmounted(stop);
+	return {
+		isIntersecting: readonly(isIntersecting),
+		isPaused: readonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+/**
+* Convenience composable for simple intersection detection
+*
+* @param target - Element ref to observe
+* @param options - Observer options
+* @returns Reactive intersection state
+*/
+function useElementIntersection(target, options = {}) {
+	const isIntersecting = shallowRef(false);
+	const intersectionRatio = shallowRef(0);
+	useIntersectionObserver(target, (entries) => {
+		const entry = entries.at(-1);
+		if (entry) {
+			isIntersecting.value = entry.isIntersecting;
+			intersectionRatio.value = entry.intersectionRatio;
+		}
+	}, {
+		immediate: true,
+		...options
+	});
+	return {
+		isIntersecting: readonly(isIntersecting),
+		intersectionRatio: readonly(intersectionRatio)
+	};
+}
+
+//#endregion
+//#region src/composables/useKeydown/index.ts
+/**
+* Sets up global keyboard event listeners for specified key handlers with automatic cleanup.
+* This composable automatically starts listening when mounted and cleans up when the scope
+* is disposed, providing a clean way to handle global keyboard interactions.
+*
+* @param handlers A single handler or array of handlers to register for keydown events.
+* @returns Object with methods to manually start and stop listening for keydown events.
+*/
+function useKeydown(handlers) {
+	const keyHandlers = Array.isArray(handlers) ? handlers : [handlers];
+	function onKeydown(event) {
+		const handler = keyHandlers.find((h) => h.key === event.key);
+		if (handler) {
+			if (handler.preventDefault) event.preventDefault();
+			if (handler.stopPropagation) event.stopPropagation();
+			handler.handler(event);
+		}
+	}
+	function startListening() {
+		document.addEventListener("keydown", onKeydown);
+	}
+	function stopListening() {
+		document.removeEventListener("keydown", onKeydown);
+	}
+	if (getCurrentScope()) onMounted(startListening);
+	onScopeDispose(stopListening, true);
+	return {
+		startListening,
+		stopListening
+	};
+}
+
+//#endregion
+//#region src/composables/useLayout/index.ts
+function useLayout(_options = {}) {
+	const { enroll = true, events = true,...options } = _options;
+	const registry = useGroup({
+		enroll,
+		events,
+		...options
+	});
+	const sizes = shallowReactive(/* @__PURE__ */ new Map());
+	const height = shallowRef(0);
+	const width = shallowRef(0);
+	const bounds = {
+		top: computed(() => sum("top")),
+		bottom: computed(() => sum("bottom")),
+		left: computed(() => sum("left")),
+		right: computed(() => sum("right"))
+	};
+	const main = {
+		x: computed(() => bounds.left.value),
+		y: computed(() => bounds.top.value),
+		width: computed(() => width.value - bounds.left.value - bounds.right.value),
+		height: computed(() => height.value - bounds.top.value - bounds.bottom.value)
+	};
+	function sum(position) {
+		let total = 0;
+		for (const item of registry.values()) if (item.position === position && item.isActive.value) total += sizes.get(item.id) ?? item.value ?? 0;
+		return total;
+	}
+	function register(registration) {
+		const item = {
+			position: registration.position,
+			order: registration.order ?? 0,
+			...registration
+		};
+		const ticket = registry.register(item);
+		sizes.set(ticket.id, ticket.value);
+		return ticket;
+	}
+	if (IN_BROWSER && getCurrentInstance()) {
+		function resize() {
+			height.value = window.innerHeight;
+			width.value = window.innerWidth;
+		}
+		onMounted(() => {
+			resize();
+			window.addEventListener("resize", resize);
+		});
+		onUnmounted(() => {
+			window.removeEventListener("resize", resize);
+		});
+	}
+	registry.on("unregister", (item) => {
+		sizes.delete(item.id);
+	});
+	return {
+		...registry,
+		register,
+		bounds,
+		main,
+		sizes,
+		height,
+		width
+	};
+}
+
+//#endregion
+//#region src/composables/useLocale/adapters/v0.ts
+/**
+* Vuetify0.x locale adapter implementation
+*
+* This adapter provides translation and number formatting
+* capabilities using the Intl API and supports both
+* numbered and named variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && typeof params[0] === "object" && params[0] !== null && !Array.isArray(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return variables[name] === void 0 ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (params[idx] !== void 0) return String(params[idx]);
+			return match;
+		});
+		return resolvedMessage;
+	}
+	n(value, locale, ...params) {
+		if (!IN_BROWSER || !locale) return value.toString();
+		const options = params[0];
+		return new Intl.NumberFormat(String(locale), options).format(value);
+	}
+};
+
+//#endregion
+//#region src/composables/useLocale/index.ts
+/**
+* Creates a locale registry for managing internationalization with translations and number formatting.
+* Supports message resolution with token references and locale-specific number formatting.
+*
+* @param namespace The namespace for the locale context.
+* @param options Configuration including adapter and messages.
+* @template Z The type of the locale context.
+* @template E The type of the locale items managed by the registry.
+* @returns An array containing the inject function, provide function, and the locale context.
+*/
+function createLocale(namespace = "v0:locale", options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [useLocaleContext, _provideLocaleContext] = createContext(namespace);
+	const registry = useSingle();
+	for (const id in messages) {
+		registry.register({
+			value: messages[id],
+			id
+		});
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	function t(key, ...params) {
+		const locale = registry.selectedId.value;
+		if (!locale) return key;
+		const message = messages[locale]?.[key];
+		const template = typeof message === "string" ? resolve(locale, message) : key;
+		return adapter.t(template, ...params);
+	}
+	function n(value, ...params) {
+		return adapter.n(value, registry.selectedId.value, ...params);
+	}
+	function resolve(locale, str) {
+		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, linkedKey) => {
+			const [linkedLocale, ...rest] = linkedKey.split(".");
+			const keyPath = rest.join(".");
+			const targetLocale = messages[linkedLocale] ? linkedLocale : locale;
+			const targetKey = messages[linkedLocale] ? keyPath : linkedKey;
+			const resolved = messages[targetLocale]?.[targetKey];
+			return typeof resolved === "string" ? resolve(targetLocale, resolved) : match;
+		});
+	}
+	const context = {
+		...registry,
+		t,
+		n
+	};
+	function provideLocaleContext(_context = context, app) {
+		return _provideLocaleContext(_context, app);
+	}
+	return createTrinity(useLocaleContext, provideLocaleContext, context);
+}
+/**
+* Simple hook to access the locale context.
+*
+* @returns The locale context containing translation and formatting functions.
+*/
+function useLocale() {
+	return useContext("v0:locale")();
+}
+/**
+* Creates a Vue plugin for internationalization with locale management and translation support.
+* Integrates with token system for message resolution and provides app-wide locale context.
+*
+* @param options Configuration for adapter, default locale, and messages.
+* @template Z The type of the locale context.
+* @template E The type of the locale items managed by the registry.
+* @template R The type of the token context.
+* @template O The type of the token items managed by the registry.
+* @returns Vue install function for the plugin
+*/
+function createLocalePlugin(options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [, provideLocaleTokenContext, tokensContext] = createTokensContext("v0:locale:tokens", messages);
+	const [, provideLocaleContext, localeContext] = createLocale("v0:locale", {
+		adapter,
+		messages
+	});
+	return createPlugin({
+		namespace: "v0:locale",
+		provide: (app) => {
+			provideLocaleContext(localeContext, app);
+			provideLocaleTokenContext(tokensContext, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useMutationObserver/index.ts
+/**
+* Composable for observing DOM mutations
+*
+* @param target - Element ref to observe
+* @param callback - Callback fired on mutation
+* @param options - Observer options
+* @returns Observer controls
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+*/
+function useMutationObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	const observerOptions = {
+		childList: options.childList ?? true,
+		attributes: options.attributes ?? false,
+		characterData: options.characterData ?? false,
+		subtree: options.subtree ?? false,
+		attributeOldValue: options.attributeOldValue ?? false,
+		characterDataOldValue: options.characterDataOldValue ?? false,
+		attributeFilter: options.attributeFilter
+	};
+	watch([isHydrated, target], ([hydrated, el]) => {
+		cleanup();
+		if (!hydrated || !SUPPORTS_MUTATION_OBSERVER || !el) return;
+		observer.value = new MutationObserver((mutations) => {
+			const transformedEntries = mutations.map((mutation) => ({
+				type: mutation.type,
+				target: mutation.target,
+				addedNodes: mutation.addedNodes,
+				removedNodes: mutation.removedNodes,
+				previousSibling: mutation.previousSibling,
+				nextSibling: mutation.nextSibling,
+				attributeName: mutation.attributeName,
+				attributeNamespace: mutation.attributeNamespace,
+				oldValue: mutation.oldValue
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(el, observerOptions);
+		if (options.immediate) {
+			const emptyNodeList = {
+				length: 0,
+				item: () => null,
+				forEach: () => {},
+				*[Symbol.iterator]() {}
+			};
+			const syntheticEntry = {
+				type: "childList",
+				target: el,
+				addedNodes: emptyNodeList,
+				removedNodes: emptyNodeList,
+				previousSibling: null,
+				nextSibling: null,
+				attributeName: null,
+				attributeNamespace: null,
+				oldValue: null
+			};
+			callback([syntheticEntry]);
+		}
+	}, { immediate: true });
+	function setup() {
+		if (!isHydrated.value || !SUPPORTS_MUTATION_OBSERVER || !target.value || isPaused.value) return;
+		observer.value = new MutationObserver((mutations) => {
+			const transformedEntries = mutations.map((mutation) => ({
+				type: mutation.type,
+				target: mutation.target,
+				addedNodes: mutation.addedNodes,
+				removedNodes: mutation.removedNodes,
+				previousSibling: mutation.previousSibling,
+				nextSibling: mutation.nextSibling,
+				attributeName: mutation.attributeName,
+				attributeNamespace: mutation.attributeNamespace,
+				oldValue: mutation.oldValue
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(target.value, observerOptions);
+		if (options.immediate) {
+			const emptyNodeList = {
+				length: 0,
+				item: () => null,
+				forEach: () => {},
+				*[Symbol.iterator]() {}
+			};
+			const syntheticEntry = {
+				type: "childList",
+				target: target.value,
+				addedNodes: emptyNodeList,
+				removedNodes: emptyNodeList,
+				previousSibling: null,
+				nextSibling: null,
+				attributeName: null,
+				attributeNamespace: null,
+				oldValue: null
+			};
+			callback([syntheticEntry]);
+		}
+	}
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		cleanup();
+	}
+	onUnmounted(stop);
+	return {
+		isPaused: readonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* Creates a proxy model for two-way binding with a selection context.
+*
+* @param registry SelectionContext | GroupContext | SingleContext | StepContext
+* @template Z The type of items managed by the selection.
+* @template E The type of the selection context.
+* @returns The proxy model for two-way binding with the selection context.
+*/
+function useProxyModel(registry, initial, options, _transformIn, _transformOut) {
+	const logger = useLogger();
+	const reactivity = options?.deep ? ref : shallowRef;
+	const internal = reactivity(initial ? toArray(initial) : []);
+	const isModelArray = isArray(initial);
+	function transformIn(val) {
+		if (isFunction(_transformIn)) return _transformIn(val);
+		return toArray(val);
+	}
+	function transformOut(val) {
+		if (isFunction(_transformOut)) return _transformOut(val);
+		return isModelArray ? val : val[0];
+	}
+	const model = computed({
+		get() {
+			return transformOut(internal.value);
+		},
+		set(val) {
+			internal.value = transformIn(val);
+		}
+	});
+	const watcher = watch(registry.selectedIds, (val, oldVal) => {
+		if (toRaw(val).symmetricDifference(toRaw(oldVal)).size === 0) return;
+		if (val.size === 0) {
+			model.value = [];
+			return;
+		}
+		model.value = Array.from(registry.selectedValues.value);
+	});
+	watch(model, (val) => {
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of toArray(val)) {
+			const id = registry.browse(value);
+			if (id) targetIds.add(id);
+			else logger.warn("Unable to find id for value", value);
+		}
+		watcher.pause();
+		if (isModelArray) {
+			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
+			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
+		} else {
+			const next = targetIds.values().next().value;
+			const last = currentIds.values().next().value;
+			registry.selectedIds.delete(last);
+			registry.selectedIds.add(next);
+		}
+		watcher.resume();
+	});
+	return model;
+}
+
+//#endregion
+//#region src/composables/useResizeObserver/index.ts
+/**
+* Composable for observing element resize events
+*
+* @param target - Element ref to observe
+* @param callback - Callback fired on resize
+* @param options - Observer options
+* @returns Observer controls
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+*/
+function useResizeObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	watch([isHydrated, target], ([hydrated, el]) => {
+		cleanup();
+		if (!hydrated || !SUPPORTS_OBSERVER || !el) return;
+		observer.value = new ResizeObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				contentRect: {
+					width: entry.contentRect.width,
+					height: entry.contentRect.height,
+					top: entry.contentRect.top,
+					left: entry.contentRect.left
+				},
+				target: entry.target
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(el, { box: options.box || "content-box" });
+		if (options.immediate) {
+			const rect = el.getBoundingClientRect();
+			callback([{
+				contentRect: {
+					width: rect.width,
+					height: rect.height,
+					top: rect.top,
+					left: rect.left
+				},
+				target: el
+			}]);
+		}
+	});
+	function setup() {
+		if (!isHydrated.value || !SUPPORTS_OBSERVER || !target.value || isPaused.value) return;
+		observer.value = new ResizeObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				contentRect: {
+					width: entry.contentRect.width,
+					height: entry.contentRect.height,
+					top: entry.contentRect.top,
+					left: entry.contentRect.left
+				},
+				target: entry.target
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(target.value, { box: options.box || "content-box" });
+		if (options.immediate) {
+			const rect = target.value.getBoundingClientRect();
+			callback([{
+				contentRect: {
+					width: rect.width,
+					height: rect.height,
+					top: rect.top,
+					left: rect.left
+				},
+				target: target.value
+			}]);
+		}
+	}
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		cleanup();
+	}
+	onUnmounted(stop);
+	return {
+		isPaused: readonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+/**
+* Convenience composable for tracking element dimensions
+*
+* @param target - Element ref to observe
+* @returns Reactive width and height
+*/
+function useElementSize(target) {
+	const width = shallowRef(0);
+	const height = shallowRef(0);
+	useResizeObserver(target, (entries) => {
+		const entry = entries[0];
+		if (entry) {
+			width.value = entry.contentRect.width;
+			height.value = entry.contentRect.height;
+		}
+	}, { immediate: true });
+	return {
+		width,
+		height
+	};
+}
+
+//#endregion
+//#region src/composables/useStorage/adapters/memory.ts
+/**
+* In-memory storage adapter that implements the StorageAdapter interface.
+* This adapter provides temporary storage that persists only for the current
+* session and is useful for testing or when persistent storage is not available.
+*/
+var MemoryAdapter = class {
+	store = /* @__PURE__ */ new Map();
+	get length() {
+		return this.store.size;
+	}
+	getItem(key) {
+		return this.store.get(key) ?? null;
+	}
+	setItem(key, value) {
+		this.store.set(key, value);
+	}
+	removeItem(key) {
+		this.store.delete(key);
+	}
+	key(index) {
+		return Array.from(this.store.keys())[index];
+	}
+};
+
+//#endregion
+//#region src/composables/useStorage/index.ts
+const [useStorageContext, provideStorageContext] = createContext("v0:storage");
+/**
+* Creates a reactive storage system with automatic persistence and cross-adapter support.
+* This function provides a consistent interface for storing and retrieving reactive values
+* that automatically sync with the underlying storage adapter (localStorage, memory, etc.).
+*
+* @param options Optional configuration for storage adapter, prefix, and serialization.
+* @template E The type of the storage context.
+* @returns A storage context object with get, set, remove, and clear methods.
+*/
+function createStorage(options = {}) {
+	const { adapter = IN_BROWSER ? window.localStorage : new MemoryAdapter(), prefix = "v0:", serializer = {
+		read: JSON.parse,
+		write: JSON.stringify
+	} } = options;
+	const cache = /* @__PURE__ */ new Map();
+	function get(key, defaultValue) {
+		const prefixedKey = `${prefix}${key}`;
+		if (cache.has(prefixedKey)) return cache.get(prefixedKey);
+		const storedValue = adapter?.getItem(prefixedKey);
+		let initialValue = defaultValue;
+		if (storedValue) try {
+			initialValue = serializer.read(storedValue);
+		} catch (error) {
+			console.error(`[v0:storage] Failed to parse stored value for key "${prefixedKey}":`, error);
+		}
+		const valueRef = ref(initialValue);
+		watch(valueRef, (newValue) => {
+			if (newValue === void 0 || newValue === null) adapter?.removeItem(prefixedKey);
+			else adapter?.setItem(prefixedKey, serializer.write(newValue));
+		}, { deep: true });
+		cache.set(prefixedKey, valueRef);
+		return valueRef;
+	}
+	function set(key, value) {
+		const valueRef = get(key);
+		valueRef.value = value;
+	}
+	function remove(key) {
+		const prefixedKey = `${prefix}${key}`;
+		adapter?.removeItem(prefixedKey);
+		cache.delete(prefixedKey);
+	}
+	function clear() {
+		for (const key of cache.keys()) adapter?.removeItem(key);
+		cache.clear();
+	}
+	return {
+		get,
+		set,
+		remove,
+		clear
+	};
+}
+/**
+* Simple hook to access the storage context.
+*
+* @returns The storage context containing reactive storage methods.
+*/
+function useStorage() {
+	return useStorageContext();
+}
+/**
+* Creates a Vue plugin for reactive storage capabilities with automatic persistence.
+* Provides app-wide access to reactive storage that syncs with the configured adapter.
+*
+* @param options Optional configuration for the storage system.
+* @returns A Vue plugin object with install method.
+*/
+function createStoragePlugin(options = {}) {
+	const context = createStorage(options);
+	return createPlugin({
+		namespace: "v0:storage",
+		provide: (app) => {
+			provideStorageContext(context, app);
+		}
+	});
+}
+
+//#endregion
+export { Atom_default as Atom, Breakpoints, COMMON_ELEMENTS, ConsolaLoggerAdapter, Context, Group, Hydration_default as Hydration, HydrationRoot_default as HydrationRoot, IN_BROWSER, PinoLoggerAdapter, Popover, SELF_CLOSING_TAGS, SUPPORTS_INTERSECTION_OBSERVER, SUPPORTS_MATCH_MEDIA, SUPPORTS_MUTATION_OBSERVER, SUPPORTS_OBSERVER, SUPPORTS_TOUCH, Step, Theme, Vuetify0LoggerAdapter, __LOGGER_ENABLED__, createBreakpoints, createBreakpointsPlugin, createContext, createHydration, createHydrationPlugin, createLocale, createLocalePlugin, createLogger, createLoggerPlugin, createPlugin, createRegistryContext, createStorage, createStoragePlugin, createTheme, createThemePlugin, createTokensContext, createTrinity, genId, isArray, isBoolean, isFunction, isNullOrUndefined, isNumber, isObject, isPrimitive, isSelfClosingTag, isString, mergeDeep, provideBreakpointsContext, provideHydrationContext, providePopoverContext, provideStorageContext, run, toArray, toReactive, useBreakpoints, useBreakpointsContext, useContext, useDocumentEventListener, useElementIntersection, useElementSize, useEventListener, useFilter, useForm, useGroup, useHydration, useHydrationContext, useIntersectionObserver, useKeydown, useLayout, useLocale, useLogger, useMutationObserver, usePopoverContext, useProxyModel, useRegistry, useResizeObserver, useSelection, useSingle, useStep, useStorage, useStorageContext, useTheme, useTokens, useWindowEventListener, version };