@vuetify/v0 0.0.2-beta.1

package/dist/index.mjs

@@ -0,0 +1,2588 @@
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createPropsRestProxy, defineComponent, getCurrentInstance, getCurrentScope, guardReactiveProps, inject, isRef, mergeModels, mergeProps, normalizeProps, normalizeStyle, onMounted, onScopeDispose, onUnmounted, openBlock, provide, reactive, 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);
+/**
+* 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 __LOGGER_ENABLED__ = process.env.NODE_ENV !== "production" || process.env.VITE_LOGGER_ENABLED === "true";
+
+//#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$1 = /* @__PURE__ */ new Date();
+		return now$1.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) {
+		if (process.env.NODE_ENV !== "production" && IN_BROWSER && namespace) console.warn(error);
+	}
+	return createFallbackLogger(namespace);
+}
+function createLoggerPlugin(options = {}) {
+	const context = createLogger(options);
+	return createPlugin({
+		namespace: "v0:logger",
+		provide: (app) => {
+			provideLoggerContext(context, app);
+		},
+		setup: (_app) => {
+			if (process.env.NODE_ENV !== "production" && IN_BROWSER) window.__v0Logger__ = 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 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) return;
+		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 item = {
+			...registration,
+			id,
+			index: registration.index ?? size,
+			value: registration.value ?? size,
+			valueIsIndex: registration.valueIsIndex ?? registration.value == null
+		};
+		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,
+		register,
+		unregister,
+		reindex,
+		onboard(registrations) {
+			return registrations.map((registration) => this.register(registration));
+		},
+		get size() {
+			return collection.size;
+		}
+	};
+}
+
+//#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
+function now() {
+	if (typeof performance !== "undefined") return performance.now();
+	return Date.now();
+}
+async function run(name, fn, samples = 100) {
+	if (!(process.env.NODE_ENV !== "production")) {
+		fn();
+		return {
+			name,
+			duration: 0,
+			ops: Infinity
+		};
+	}
+	const times = [];
+	for (let i = 0; i < 5; i++) fn();
+	for (let i = 0; i < samples; i++) {
+		const start = now();
+		fn();
+		times.push(now() - start);
+	}
+	const duration = times.reduce((a, b) => a + b, 0) / times.length;
+	const ops = Math.round(1e3 / duration);
+	return {
+		name,
+		duration,
+		ops
+	};
+}
+
+//#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/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/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.
+*/
+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 cached = cache.get(token);
+		if (cached !== void 0) return cached;
+		const reference = isTokenAlias(token) ? token.$value : token;
+		const cleaned = isAlias(reference) ? reference.slice(1, -1) : reference;
+		const found = registry.get(cleaned);
+		if (found?.value === void 0) {
+			logger.warn(`Alias not found for "${reference}"`);
+			cache.set(token, void 0);
+			return void 0;
+		}
+		let result;
+		if (isTokenAlias(found.value)) result = resolve(found.value.$value);
+		else if (isAlias(found.value)) result = resolve(found.value);
+		else result = String(found.value);
+		cache.set(token, 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();
+		for (const key in currentTokens) {
+			const value = currentTokens[key];
+			const id = currentPrefix ? `${currentPrefix}.${key}` : key;
+			if (isPrimitive(value)) flattened.push({
+				id,
+				value: String(value)
+			});
+			else if (isObject(value) && "$value" in value) flattened.push({
+				id,
+				value
+			});
+			else if (isObject(value)) 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) {
+		const model = useModel(__props, "modelValue");
+		const [provideThemeContext] = createTheme(__props.namespace);
+		const themeContext = provideThemeContext(model);
+		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/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$1) => h$1.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/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/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, ConsolaLoggerAdapter, Context, Group, Hydration_default as Hydration, HydrationRoot_default as HydrationRoot, PinoLoggerAdapter, Popover, Step, Theme, Vuetify0LoggerAdapter, createBreakpoints, createBreakpointsPlugin, createContext, createHydration, createHydrationPlugin, createLocale, createLocalePlugin, createLogger, createLoggerPlugin, createPlugin, createStorage, createStoragePlugin, createTheme, createThemePlugin, createTokensContext, createTrinity, genId, isArray, isBoolean, isFunction, isNullOrUndefined, isNumber, isObject, isPrimitive, isString, mergeDeep, provideBreakpointsContext, provideHydrationContext, providePopoverContext, provideStorageContext, run, toArray, toReactive, useBreakpoints, useBreakpointsContext, useContext, useDocumentEventListener, useEventListener, useFilter, useForm, useGroup, useHydration, useHydrationContext, useKeydown, useLayout, useLocale, useLogger, usePopoverContext, useProxyModel, useRegistry, useSelection, useSingle, useStep, useStorage, useStorageContext, useTheme, useTokens, useWindowEventListener };