@vuetify/v0 0.0.14 → 0.0.16

package/dist/composables-CGvbvF3U.mjs

@@ -1,4902 +0,0 @@
-import { a as isNull, c as isObject, d as isUndefined, f as mergeDeep, i as isFunction, n as isArray, o as isNullOrUndefined, r as isBoolean, s as isNumber, t as genId, u as isString } from "./utilities-C26nB74O.mjs";
-import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-D7kNBw5Q.mjs";
-import { computed, getCurrentInstance, getCurrentScope, inject, isRef, onMounted, onScopeDispose, onUnmounted, provide, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch } from "vue";
-
-//#region src/composables/createContext/index.ts
-/**
-* @module createContext
-*
-* @see https://0.vuetifyjs.com/composables/foundation/create-context
-*
-* @remarks
-* Factory for creating type-safe Vue dependency injection contexts.
-*
-* Provides a wrapper around Vue's provide/inject that throws errors when context is not found,
-* eliminating silent failures and improving developer experience. Supports both app-level and
-* component-level provision.
-*/
-/**
-* Injects a context provided by an ancestor component.
-*
-* @param key The key of the context to inject.
-* @param defaultValue Optional default value if context is not found.
-* @template Z The type of the context.
-* @returns The injected context.
-* @throws An error if the context is not found and no default is provided.
-*
-* @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
-* @see https://0.vuetifyjs.com/composables/foundation/create-context#use-context
-*
-* @example
-* ```ts
-* // Without default value
-* const context = useContext<MyContext>('my-context')
-*
-* // With default value
-* const context = useContext<MyContext>('my-context', defaultContext)
-* ```
-*/
-function useContext(key, defaultValue) {
-	const context = inject(key, defaultValue);
-	if (context === void 0) throw new Error(`Context "${String(key)}" not found. Ensure it's provided by an ancestor.`);
-	return context;
-}
-/**
-* Provides a context to all descendant components.
-*
-* @param key The key of the context to provide.
-* @param context The context to provide.
-* @param app Optional Vue app instance to provide the context at app level instead of component level.
-* @template Z The type of the context.
-* @returns The provided context.
-*
-* @remarks
-* When `app` parameter is provided, the context is made available to all components in the app.
-* When omitted, the context is provided at the current component level and available to descendants only.
-*
-* @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
-* @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
-*
-* @example
-* ```ts
-* // Component-level provision
-* provideContext<MyContext>('my-context', context)
-*
-* // App-level provision (typically used in plugins)
-* const app = createApp()
-* provideContext<MyContext>('my-context', context, app)
-* ```
-*/
-function provideContext(key, context, app) {
-	if (app) app.provide(key, context);
-	else provide(key, context);
-	return context;
-}
-/**
-* Creates a new context for providing and injecting data.
-*
-* @param key The key of the context to create.
-* @param defaultValue Optional default value if context is not found.
-* @template Z The type of the context.
-* @returns A tuple containing the `useContext` and `provideContext` functions.
-*
-* @see https://vuejs.org/api/composition-api-dependency-injection.html
-* @see https://0.vuetifyjs.com/composables/foundation/create-context#create-context
-*
-* @example
-* ```ts
-* // Without default value
-* const [useMyContext, provideMyContext] = createContext<MyContext>('my-context')
-*
-* // With default value
-* const [useMyContext, provideMyContext] = createContext<MyContext>('my-context', defaultContext)
-* ```
-*/
-function createContext(_key, defaultValue) {
-	function _provideContext(context, app) {
-		return provideContext(_key, context, app);
-	}
-	function _useContext(key = _key) {
-		return useContext(key, defaultValue);
-	}
-	return [_useContext, _provideContext];
-}
-
-//#endregion
-//#region src/composables/createPlugin/index.ts
-/**
-* Creates a new Vue plugin.
-*
-* @param options The plugin options.
-* @returns A new Vue plugin.
-*
-* @see https://0.vuetifyjs.com/composables/foundation/create-plugin#create-plugin
-*
-* @example
-* ```ts
-* export const [useContext, provideContext] = createContext<MyContext>('my-plugin')
-*
-* const context = {}
-*
-* export const MyPlugin = createPlugin({
-*   namespace: 'my-plugin',
-*   provide: (app) => {
-*     provideContext(context, app)
-*   },
-*   setup: (app) => {
-*     // Optional setup logic
-*   },
-* })
-*/
-function createPlugin(options) {
-	return { install(app) {
-		app.runWithContext(() => {
-			options.provide(app);
-			options.setup?.(app);
-		});
-	} };
-}
-
-//#endregion
-//#region src/composables/createTrinity/index.ts
-/**
-* Creates a new trinity for a context composable and its provider.
-*
-* @param useContext The function that retrieves/uses the context (typically named `useContext`).
-* @param provideContext The function that provides the context to descendants.
-* @param context The default context instance to use when no custom context is provided.
-* @template Z The type of the context.
-* @returns A readonly tuple containing: [useContext function, provideContext wrapper function, default context instance].
-*
-* @remarks The trinity pattern is a foundational pattern used throughout the codebase for creating reusable context systems. It provides three related elements:
-*
-* 1. A function to retrieve/use the context
-* 2. A function to provide the context (with default value support)
-* 3. The default context instance
-*
-* The returned tuple is readonly (using `as const`) to ensure proper type inference.
-*
-* @see https://0.vuetifyjs.com/composables/foundation/create-trinity#create-trinity
-*
-* @example
-* ```ts
-* interface MyContext {
-*   foo: string
-*   bar: number
-* }
-*
-* export function createMyFeature<E extends MyContext = MyContext>() {
-*   const [useContext, _provideContext] = createContext<E>('my-context')
-*
-*   const context = { foo: 'hello', bar: 42 }
-*
-*   function provideContext (_context: E = context, app?: App): E {
-*     return _provideContext(_context, app)
-*   }
-*
-*   return createTrinity<E>(useContext, provideContext, context)
-* }
-* ```
-*/
-function createTrinity(useContext$1, provideContext$1, context) {
-	return [
-		useContext$1,
-		(_context = context, app) => provideContext$1(_context, app),
-		context
-	];
-}
-
-//#endregion
-//#region src/composables/toArray/index.ts
-/**
-* @module toArray
-*
-* @remarks
-* Utility function to normalize single values and arrays into arrays.
-*
-* Converts single values into single-element arrays, passes arrays through unchanged,
-* and handles null/undefined by returning empty arrays. Perfect for functions that
-* accept both single values and arrays as input (e.g., ID | ID[]).
-*/
-/**
-* Converts a value to an array.
-*
-* @param value The value to convert.
-* @template Z The type of the value.
-* @returns The converted array.
-*
-* @see https://0.vuetifyjs.com/composables/transformers/to-array
-*
-* @example
-* ```ts
-* import { toArray } from '@vuetify/v0'
-*
-* const value = 'Example Value'
-* const valueAsArray = toArray(value)
-*
-* console.log(valueAsArray) // ['Example Value']
-* ```
-*/
-function toArray(value) {
-	return /* @__PURE__ */ isNullOrUndefined(value) ? [] : Array.isArray(value) ? value : [value];
-}
-
-//#endregion
-//#region src/composables/toReactive/index.ts
-/**
-* @module toReactive
-*
-* @remarks
-* Utility function to convert values and refs into reactive proxies with ref unwrapping.
-*
-* Key features:
-* - Automatic ref unwrapping
-* - Deep reactive proxying
-* - Map and Set support with ref unwrapping
-* - Nested object/array reactivity
-* - Type preservation
-*
-* Perfect for creating reactive versions of plain objects while automatically unwrapping refs.
-*/
-/**
-* Converts a `MaybeRef` to a `UnwrapNestedRefs`.
-*
-* @param objectRef The object to convert.
-* @template Z The type of the object.
-* @returns The converted object.
-*
-* @see https://0.vuetifyjs.com/composables/transformers/to-reactive
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { toReactive } from '@vuetify/v0'
-*
-* const state = ref({ name: 'John', age: 30 })
-* const rstate = toReactive(state)
-*
-* console.log(rstate.name) // John
-* ```
-*/
-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);
-	}
-	return reactive(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;
-			const newDesc = {
-				...desc,
-				configurable: true
-			};
-			if ("value" in newDesc) newDesc.value = unref(newDesc.value);
-			return newDesc;
-		}
-	}));
-}
-
-//#endregion
-//#region src/composables/useHydration/index.ts
-/**
-* @module useHydration
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
-*
-* @remarks
-* SSR hydration state management composable.
-*
-* Key features:
-* - Hydration state detection (browser vs SSR)
-* - Root component detection
-* - Readonly hydration state refs
-* - Plugin installation support
-* - Perfect for hydration-safe rendering
-*
-* Essential for composables that need to behave differently during SSR vs client-side.
-*/
-/**
-* Creates a new hydration instance.
-*
-* @returns A new hydration instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
-*
-* @example
-* ```ts
-* import { createHydration } from '@vuetify/v0'
-*
-* const hydration = createHydration()
-* console.log(hydration.isHydrated.value) // false
-* hydration.hydrate()
-* console.log(hydration.isHydrated.value) // true
-* ```
-*/
-function createHydration() {
-	const isHydrated = shallowRef(false);
-	function hydrate() {
-		isHydrated.value = true;
-	}
-	return {
-		isHydrated: shallowReadonly(isHydrated),
-		hydrate
-	};
-}
-/**
-* Creates a new hydration context trinity.
-*
-* @param options Options for creating the hydration context.
-* @template E The type of the hydration context.
-* @returns A new hydration context trinity.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
-*
-* @example
-* ```ts
-* import { createHydrationContext } from '@vuetify/v0'
-*
-* export const [useHydrationContext, provideHydrationContext, context] = createHydrationContext({
-*   namespace: 'app:hydration',
-* })
-* ```
-*/
-function createHydrationContext(_options = {}) {
-	const { namespace = "v0:hydration" } = _options;
-	const [useHydrationContext, _provideHydrationContext] = createContext(namespace);
-	const context = createHydration();
-	function provideHydrationContext(_context = context, app) {
-		return _provideHydrationContext(_context, app);
-	}
-	return createTrinity(useHydrationContext, provideHydrationContext, context);
-}
-/**
-* Creates a new hydration plugin.
-*
-* @param options The options for the hydration plugin.
-* @template E The type of the hydration context.
-* @returns A new hydration plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createHydrationPlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(createHydrationPlugin())
-*
-* app.mount('#app')
-* ```
-*/
-function createHydrationPlugin(_options = {}) {
-	const { namespace = "v0:hydration",...options } = _options;
-	const [, provideHydrationContext, context] = createHydrationContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideHydrationContext(context, app);
-		},
-		setup: (app) => {
-			app.mixin({ mounted() {
-				if (this.$parent !== null) return;
-				context.hydrate();
-			} });
-		}
-	});
-}
-/**
-* Returns the current hydration instance.
-*
-* @param namespace The namespace for the hydration context. Defaults to `v0:hydration`.
-* @returns The current hydration instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useHydration } from '@vuetify/v0'
-*
-*   const hydration = useHydration()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Is hydrated: {{ hydration.isHydrated.value }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useHydration(namespace = "v0:hydration") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useBreakpoints/index.ts
-/**
-* @module useBreakpoints
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
-*
-* @remarks
-* Responsive breakpoint detection composable with window resize handling.
-*
-* Key features:
-* - Window matchMedia integration
-* - Six built-in breakpoints (xs, sm, md, lg, xl, xxl)
-* - Automatic resize listener with cleanup
-* - SSR-safe (checks IN_BROWSER)
-* - Hydration-aware
-* - Custom breakpoint configuration
-*
-* Perfect for responsive layouts and conditional rendering based on screen size.
-*/
-/**
-* 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 new breakpoints instance.
-*
-* @param options The options for the breakpoints instance.
-* @template E The type of the breakpoints context.
-* @returns A new breakpoints instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
-*
-* @example
-* ```ts
-* import { createBreakpoints } from '@vuetify/v0'
-*
-* export const [useBreakpoints, provideBreakpoints] = createBreakpoints({
-*   namespace: 'v0:breakpoints',
-*   mobileBreakpoint: 'sm',
-*   breakpoints: {
-*     xs: 0,
-*     sm: 680,
-*     md: 1024,
-*     lg: 1280,
-*     xl: 1920,
-*     xxl: 2560,
-*   },
-* })
-* ```
-*/
-function createBreakpoints(_options = {}) {
-	const { mobileBreakpoint, breakpoints } = /* @__PURE__ */ mergeDeep(createDefaultBreakpoints(), _options);
-	const sorted = Object.entries(breakpoints).toSorted((a, b) => a[1] - b[1]);
-	const names = sorted.map(([n]) => n);
-	const mb = /* @__PURE__ */ isNumber(mobileBreakpoint) ? mobileBreakpoint : breakpoints[mobileBreakpoint] ?? breakpoints.md;
-	const name = shallowRef("xs");
-	const width = shallowRef(0);
-	const height = shallowRef(0);
-	const isMobile = shallowRef(true);
-	const xs = shallowRef(true);
-	const sm = shallowRef(false);
-	const md = shallowRef(false);
-	const lg = shallowRef(false);
-	const xl = shallowRef(false);
-	const xxl = shallowRef(false);
-	const smAndUp = shallowRef(false);
-	const mdAndUp = shallowRef(false);
-	const lgAndUp = shallowRef(false);
-	const xlAndUp = shallowRef(false);
-	const xxlAndUp = shallowRef(false);
-	const smAndDown = shallowRef(true);
-	const mdAndDown = shallowRef(true);
-	const lgAndDown = shallowRef(true);
-	const xlAndDown = shallowRef(true);
-	const xxlAndDown = shallowRef(true);
-	function update() {
-		if (!IN_BROWSER) return;
-		width.value = window.innerWidth;
-		height.value = window.innerHeight;
-		let current = "xs";
-		for (let i = sorted.length - 1; i >= 0; i--) if (width.value >= sorted[i][1]) {
-			current = sorted[i][0];
-			break;
-		}
-		name.value = current;
-		const index = names.indexOf(current);
-		isMobile.value = width.value < mb;
-		xs.value = index === 0;
-		sm.value = index === 1;
-		md.value = index === 2;
-		lg.value = index === 3;
-		xl.value = index === 4;
-		xxl.value = index === 5;
-		smAndUp.value = index >= 1;
-		mdAndUp.value = index >= 2;
-		lgAndUp.value = index >= 3;
-		xlAndUp.value = index >= 4;
-		xxlAndUp.value = index >= 5;
-		smAndDown.value = index <= 1;
-		mdAndDown.value = index <= 2;
-		lgAndDown.value = index <= 3;
-		xlAndDown.value = index <= 4;
-		xxlAndDown.value = index <= 5;
-	}
-	return {
-		breakpoints,
-		name: readonly(name),
-		width: readonly(width),
-		height: readonly(height),
-		isMobile: readonly(isMobile),
-		xs: readonly(xs),
-		sm: readonly(sm),
-		md: readonly(md),
-		lg: readonly(lg),
-		xl: readonly(xl),
-		xxl: readonly(xxl),
-		smAndUp: readonly(smAndUp),
-		mdAndUp: readonly(mdAndUp),
-		lgAndUp: readonly(lgAndUp),
-		xlAndUp: readonly(xlAndUp),
-		xxlAndUp: readonly(xxlAndUp),
-		smAndDown: readonly(smAndDown),
-		mdAndDown: readonly(mdAndDown),
-		lgAndDown: readonly(lgAndDown),
-		xlAndDown: readonly(xlAndDown),
-		xxlAndDown: readonly(xxlAndDown),
-		update
-	};
-}
-/**
-* Creates a new breakpoints context.
-*
-* @param options The options for the breakpoints context.
-* @template E The type of the breakpoints context.
-* @returns A new breakpoints context.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
-*
-* @example
-* ```ts
-* import { createBreakpointsContext } from '@vuetify/v0'
-*
-* export const [useBreakpoints, provideBreakpoints, context] = createBreakpointsContext({
-*   namespace: 'v0:breakpoints',
-*   mobileBreakpoint: 'sm',
-* })
-* ```
-*/
-function createBreakpointsContext(_options = {}) {
-	const { namespace = "v0:breakpoints",...options } = _options;
-	const [useBreakpointsContext, _provideBreakpointsContext] = createContext(namespace);
-	const context = createBreakpoints(options);
-	function provideBreakpointsContext(_context = context, app) {
-		return _provideBreakpointsContext(_context, app);
-	}
-	return createTrinity(useBreakpointsContext, provideBreakpointsContext, context);
-}
-/**
-* Creates a new breakpoints plugin.
-*
-* @param options The options for the breakpoints plugin.
-* @template E The type of the breakpoints context.
-* @returns A new breakpoints plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createBreakpointsPlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(
-*   createBreakpointsPlugin({
-*     namespace: 'v0:breakpoints',
-*     mobileBreakpoint: 'sm',
-*     breakpoints: {
-*       xs: 0,
-*       sm: 680,
-*       md: 1024,
-*       lg: 1280,
-*       xl: 1920,
-*       xxl: 2560,
-*     },
-*   })
-* )
-*
-* app.mount('#app')
-* ```
-*/
-function createBreakpointsPlugin(_options = {}) {
-	const { namespace = "v0:breakpoints",...options } = _options;
-	const [, provideBreakpointsContext, context] = createBreakpointsContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideBreakpointsContext(context, app);
-		},
-		setup: (app) => {
-			app.mixin({ mounted() {
-				if (this.$parent !== null) return;
-				const hydration = useHydration();
-				function listener() {
-					context.update();
-				}
-				const unwatch = watch(hydration.isHydrated, (hydrated) => {
-					if (hydrated) listener();
-				}, { immediate: true });
-				window.addEventListener("resize", listener, { passive: true });
-				onScopeDispose(() => {
-					window.removeEventListener("resize", listener);
-					unwatch();
-				}, true);
-			} });
-		}
-	});
-}
-/**
-* Returns the current breakpoints instance.
-*
-* @param namespace The namespace for the breakpoints context. Defaults to `v0:breakpoints`.
-* @returns The current breakpoints instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useBreakpoints } from '@vuetify/v0'
-*
-*   const { isMobile, mdAndUp } = useBreakpoints()
-* <\/script>
-*
-* <template>
-*   <div class="pa-4">
-*     <p v-if="isMobile.value">Mobile layout active</p>
-*     <p v-else-if="mdAndUp.value">Medium and up layout active</p>
-*   </div>
-* </template>
-* ```
-*/
-function useBreakpoints(namespace = "v0:breakpoints") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useEventListener/index.ts
-/**
-* @module useEventListener
-*
-* @remarks
-* Event listener composable with automatic cleanup on scope disposal.
-*
-* Key features:
-* - Supports Window, Document, and HTMLElement targets
-* - Reactive targets, events, and listeners
-* - Event options support (capture, passive, once)
-* - Automatic removeEventListener on unmount
-* - Multiple overloads for type safety
-*
-* Perfect for safely managing event listeners in Vue components.
-*/
-/**
-* Attaches an event listener to a target.
-*
-* @param target The target to attach the event listener to.
-* @param event The event to listen for.
-* @param listener The event listener.
-* @param options The event listener options.
-* @returns A function to remove the event listener.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-event-listener
-*/
-function useEventListener(target, event, listener, options) {
-	const cleanups = [];
-	function cleanup() {
-		for (const fn of cleanups) fn();
-		cleanups.length = 0;
-	}
-	function 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;
-}
-/**
-* Attaches an event listener to the window.
-*
-* @param event The event to listen for.
-* @param listener The event listener.
-* @param options The event listener options.
-* @template E The event type.
-* @returns A function to remove the event listener.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-event-listener
-*/
-function useWindowEventListener(event, listener, options) {
-	return useEventListener(window, event, listener, options);
-}
-/**
-* Attaches an event listener to the document.
-*
-* @param event The event to listen for.
-* @param listener The event listener.
-* @param options The event listener options.
-* @template E The event type.
-* @returns A function to remove the event listener.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-event-listener
-*/
-function useDocumentEventListener(event, listener, options) {
-	return useEventListener(document, event, listener, options);
-}
-
-//#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 && /* @__PURE__ */ isObject(args[0])) 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) {
-		return [[
-			this.timestamps ? this.timestamp() : "",
-			`[${this.prefix} ${level.toLowerCase()}]`,
-			message
-		].filter(Boolean).join(" "), ...args];
-	}
-	timestamp() {
-		if (!IN_BROWSER) return (/* @__PURE__ */ new Date()).toISOString();
-		return (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0] ?? "";
-	}
-	style(level) {
-		if (!this.colors || !IN_BROWSER) return "";
-		return {
-			trace: "color: #64748b",
-			debug: "color: #3b82f6",
-			info: "color: #10b981",
-			warn: "color: #f59e0b",
-			error: "color: #ef4444",
-			fatal: "color: #dc2626; font-weight: bold",
-			silent: ""
-		}[level] || "";
-	}
-	log(level, method, message, ...args) {
-		const [formattedMessage, ...restArgs] = this.format(level, message, ...args);
-		const style = this.style(level);
-		if (IN_BROWSER && style && /* @__PURE__ */ isFunction(console[method])) console[method](`%c${formattedMessage}`, style, ...restArgs);
-		else if (/* @__PURE__ */ isFunction(console[method])) console[method](formattedMessage, ...restArgs);
-	}
-};
-
-//#endregion
-//#region src/composables/useLogger/index.ts
-/**
-* @module useLogger
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-logger
-*
-* @remarks
-* Logging composable with adapter pattern supporting console, consola, and pino.
-*
-* Key features:
-* - Multiple log levels (trace, debug, info, warn, error, fatal)
-* - Adapter pattern for console/consola/pino integration
-* - Enable/disable logging
-* - Fallback logger for undefined loggers
-* - Context logging support
-*
-* Uses adapter pattern to abstract logging implementation.
-*/
-/**
-* Creates a new logger instance.
-*
-* @param options The options for the logger instance.
-* @returns A new logger instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-logger
-*
-* @example
-* ```ts
-* import { createLogger } from '@vuetify/v0'
-*
-* const logger = createLogger({
-*   level: 'debug',
-*   prefix: '[MyApp]',
-* })
-*
-* logger.info('This is an info message')
-* logger.debug('This is a debug message')
-* logger.error('This is an error message')
-* logger.level('debug')
-* logger.debug('This debug message will now be logged')
-* ```
-*/
-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) {
-		return {
-			trace: 0,
-			debug: 1,
-			info: 2,
-			warn: 3,
-			error: 4,
-			fatal: 5,
-			silent: 6
-		}[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: () => {}
-	};
-}
-/**
-* Creates a new logger context.
-*
-* @param options The options for the logger context.
-* @template E The type of the logger context.
-* @returns A new logger context.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-logger
-*
-* @example
-* ```ts
-* import { createLoggerContext } from '@vuetify/v0'
-*
-* export const [useAppLogger, provideAppLogger, appLogger] = createLoggerContext({
-*   namespace: 'app:logger',
-*   level: 'debug',
-* })
-* ```
-*/
-function createLoggerContext(_options = {}) {
-	const { namespace = "v0:logger",...options } = _options;
-	const [useLoggerContext, _provideLoggerContext] = createContext(namespace);
-	const context = createLogger(options);
-	function provideLoggerContext(_context = context, app) {
-		return _provideLoggerContext(_context, app);
-	}
-	return createTrinity(useLoggerContext, provideLoggerContext, context);
-}
-/**
-* Creates a new logger plugin.
-*
-* @param options The options for the logger plugin.
-* @returns A new logger plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-logger
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createLoggerPlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(
-*  createLoggerPlugin({
-*    level: 'debug',
-*    prefix: '[MyApp]',
-*  })
-* )
-*
-* app.mount('#app')
-* ```
-*/
-function createLoggerPlugin(_options = {}) {
-	const { namespace = "v0:logger",...options } = _options;
-	const [, provideLoggerContext, context] = createLoggerContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideLoggerContext(context, app);
-		},
-		setup: (_app) => {
-			if (process.env.NODE_ENV !== "production" && IN_BROWSER) window.__v0Logger__ = context;
-		}
-	});
-}
-/**
-* Uses an existing or creates a new logger instance.
-*
-* @param namespace The namespace for the logger context. Defaults to `'v0:logger'`.
-* @returns The logger instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-logger
-*
-* @example
-* ```ts
-* import { useLogger } from '@vuetify/v0'
-*
-* const logger = useLogger()
-*
-* logger.info('This is an info message')
-* logger.debug('This is a debug message')
-* logger.error('This is an error message')
-* logger.level('debug')
-* logger.debug('This debug message will now be logged')
-* ```
-*/
-function useLogger(namespace = "v0:logger") {
-	const fallback = createFallbackLogger(namespace);
-	if (!getCurrentInstance()) return fallback;
-	try {
-		return useContext(namespace, fallback);
-	} catch {
-		return fallback;
-	}
-}
-
-//#endregion
-//#region src/composables/useRegistry/index.ts
-/**
-* @module useRegistry
-*
-* @remarks
-* A foundational composable for managing collections of items (tickets) with:
-* - Unique ID-based access
-* - Index-based ordering
-* - Value-based reverse lookup
-* - Automatic reindexing
-* - Optional event emission
-* - Performance-optimized caching
-*
-* The registry serves as the base for many other composables in the system,
-* including useSelection, useForm, useTimeline, and more.
-*/
-/**
-* Creates a new registry instance.
-*
-* @param options The options for the registry instance.
-* @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
-* @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
-* @returns A new registry instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-registry#use-registry
-*
-* @example
-* ```ts
-* import { useRegistry } from '@vuetify/v0'
-*
-* const registry = useRegistry()
-*
-* const ticket1 = registry.register({ id: 'user-1', value: { name: 'John' } })
-* const ticket2 = registry.register({ id: 'user-2', value: { name: 'Jane' } })
-*
-* console.log(registry.size) // 2
-* console.log(registry.get('user-1')) // { id: 'user-1', index: 0, value: { name: 'John' }, ... }
-* ```
-*/
-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();
-	const events = options?.events ?? false;
-	function emit(event, data = void 0) {
-		if (!events) return;
-		const cbs = listeners.get(event);
-		if (!cbs) return;
-		for (const cb of cbs) cb(data);
-	}
-	function on(event, cb) {
-		if (!events) {
-			logger.warn(`Attempted to register event listener for "${event}" but events are disabled.`);
-			return;
-		}
-		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();
-		emit("update:ticket", updated);
-		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 (/* @__PURE__ */ 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 (/* @__PURE__ */ 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 (!/* @__PURE__ */ isUndefined(cached)) 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 (!/* @__PURE__ */ isUndefined(cached)) 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();
-		emit("clear:registry");
-	}
-	function invalidate() {
-		if (cache.size > 0) cache.clear();
-	}
-	function reindex() {
-		if (catalog.size > 0) catalog.clear();
-		if (directory.size > 0) directory.clear();
-		invalidate();
-		let index = 0;
-		for (const ticket of values()) {
-			if (ticket.index !== index) {
-				ticket.index = index;
-				if (ticket.valueIsIndex) ticket.value = index;
-			}
-			directory.set(index, ticket.id);
-			assign(ticket.value, ticket.id);
-			index++;
-		}
-		emit("reindex:registry");
-	}
-	function register(registration = {}) {
-		const size = collection.size;
-		const id = registration.id ?? /* @__PURE__ */ genId();
-		if (has(id)) {
-			logger.warn(`Ticket with id "${id}" already exists in the registry. Skipping registration.`);
-			return get(id);
-		}
-		const valueIsUndefined = /* @__PURE__ */ isUndefined(registration.value);
-		const index = registration.index ?? size;
-		const value = valueIsUndefined ? index : registration.value;
-		const valueIsIndex = valueIsUndefined;
-		const ticket = {
-			...registration,
-			id,
-			index,
-			value,
-			valueIsIndex
-		};
-		collection.set(ticket.id, ticket);
-		directory.set(ticket.index, ticket.id);
-		assign(ticket.value, ticket.id);
-		invalidate();
-		emit("register:ticket", ticket);
-		return ticket;
-	}
-	function unregister(id) {
-		const ticket = collection.get(id);
-		if (!ticket) return;
-		collection.delete(ticket.id);
-		directory.delete(ticket.index);
-		unassign(ticket.value, ticket.id);
-		invalidate();
-		emit("unregister:ticket", ticket);
-		reindex();
-	}
-	function seek(direction = "first", from, predicate) {
-		if (collection.size === 0) return void 0;
-		const tickets = values();
-		const index = /* @__PURE__ */ isUndefined(from) ? void 0 : Math.max(0, Math.min(from, tickets.length - 1));
-		if (direction === "last") {
-			const start = /* @__PURE__ */ isUndefined(index) ? tickets.length - 1 : index;
-			for (let i = start; i >= 0; i--) {
-				const ticket = tickets[i];
-				if (!predicate || predicate(ticket)) return ticket;
-			}
-		} else {
-			const start = /* @__PURE__ */ isUndefined(index) ? 0 : index;
-			for (let i = start; i < tickets.length; i++) {
-				const ticket = tickets[i];
-				if (!predicate || predicate(ticket)) return ticket;
-			}
-		}
-	}
-	return {
-		collection,
-		emit,
-		on,
-		off,
-		dispose,
-		has,
-		keys,
-		clear,
-		browse,
-		entries,
-		values,
-		lookup,
-		get,
-		upsert,
-		register,
-		unregister,
-		reindex,
-		seek,
-		onboard(registrations) {
-			return registrations.map((registration) => this.register(registration));
-		},
-		get size() {
-			return collection.size;
-		}
-	};
-}
-/**
-* Creates a new registry context.
-*
-* @param namespace The namespace for the registry context.
-* @param options The options for the registry context.
-* @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
-* @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
-* @returns A new registry context.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-registry#create-registry-context
-*
-* @example
-* ```ts
-* import { createRegistryContext } from '@vuetify/v0'
-*
-* export const [useItems, provideItems, items] = createRegistryContext('items')
-*
-* // In a parent component:
-* provideItems()
-*
-* // In a child component:
-* const items = useItems()
-* items.register({ id: 'item-1', value: 'Value 1' })
-* ```
-*/
-function createRegistryContext(_options) {
-	const { namespace,...options } = _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
-/**
-* @module useSelection
-*
-* @remarks
-* Base composable for managing selected items in a collection with Set-based tracking.
-*
-* Key features:
-* - Set-based selectedIds for O(1) selection checks
-* - Mandatory selection mode (prevents deselecting last item)
-* - Auto-enrollment option (selects non-disabled items on register)
-* - Disabled item filtering
-* - Computed selectedItems and selectedValues Sets
-*
-* Extends useRegistry and serves as the base for useSingle, useGroup, useStep, and useFeatures.
-*/
-/**
-* Creates a new selection instance for managing multiple selected items.
-*
-* Extends `useRegistry` with selection tracking via a reactive `Set` of selected IDs.
-* Supports disabled items, mandatory selection enforcement, and auto-enrollment.
-*
-* @param options The options for the selection instance.
-* @template Z The type of the selection ticket.
-* @template E The type of the selection context.
-* @returns A new selection instance with selection management methods.
-*
-* @remarks
-* **Key Features:**
-* - Multi-selection support (unlike `useSingle` which enforces single selection)
-* - Set-based `selectedIds` tracking for efficient lookups
-* - Computed `selectedItems` and `selectedValues` for reactive access
-* - Each ticket gets `isSelected`, `select()`, `unselect()`, and `toggle()` methods
-* - Disabled items cannot be selected
-* - Mandatory mode prevents deselecting the last item
-* - Force mode auto-selects first non-disabled item on registration
-* - Enroll option auto-selects all non-disabled items on registration
-*
-* **Inheritance Chain:**
-* `useRegistry` → `createSelection` → `createSingle`/`createGroup` → `createStep`
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-selection
-*
-* @example
-* ```ts
-* import { createSelection } from '@vuetify/v0'
-*
-* const selection = createSelection({ mandatory: true })
-*
-* selection.onboard([
-*   { id: 'item-1', value: 'Item 1' },
-*   { id: 'item-2', value: 'Item 2', disabled: true },
-*   { id: 'item-3', value: 'Item 3' },
-* ])
-*
-* selection.select('item-1')
-* selection.select('item-3')
-*
-* console.log(selection.selectedIds) // Set { 'item-1', 'item-3' }
-* console.log(Array.from(selection.selectedValues.value)) // ['Item 1', 'Item 3']
-* ```
-*/
-function createSelection(_options = {}) {
-	const { disabled = false, enroll = false, mandatory = false, multiple = false,...options } = _options;
-	const registry = useRegistry(options);
-	const selectedIds = shallowReactive(/* @__PURE__ */ new Set());
-	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 seek(direction = "first", from) {
-		return registry.seek(direction, from, (ticket) => !toValue(ticket.disabled));
-	}
-	function mandate() {
-		if (!mandatory || registry.size === 0 || selectedIds.size > 0) return;
-		const ticket = seek("first");
-		if (ticket) select(ticket.id);
-	}
-	function select(id) {
-		const item = registry.get(id);
-		if (!item || toValue(item.disabled)) return;
-		if (!multiple) selectedIds.clear();
-		selectedIds.add(id);
-	}
-	function unselect(id) {
-		if (mandatory && selectedIds.size === 1) return;
-		selectedIds.delete(id);
-	}
-	function toggle(id) {
-		if (selected(id)) unselect(id);
-		else select(id);
-	}
-	function selected(id) {
-		return selectedIds.has(id);
-	}
-	function register(registration = {}) {
-		const id = registration.id ?? /* @__PURE__ */ genId();
-		const item = {
-			disabled: false,
-			...registration,
-			id,
-			isSelected: toRef(() => selected(id)),
-			select: () => select(id),
-			unselect: () => unselect(id),
-			toggle: () => toggle(id)
-		};
-		const ticket = registry.register(item);
-		if (enroll && !toValue(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();
-		selectedIds.clear();
-		mandate();
-	}
-	return {
-		...registry,
-		disabled,
-		selectedIds,
-		selectedItems,
-		selectedValues,
-		register,
-		unregister,
-		reset,
-		mandate,
-		seek,
-		select,
-		unselect,
-		toggle,
-		selected,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new selection context.
-*
-* @param namespace The namespace for the selection context.
-* @param options The options for the selection context.
-* @template Z The type of the selection ticket.
-* @template E The type of the selection context.
-* @returns A new selection context.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-selection
-*
-* @example
-* ```ts
-* import { createSelectionContext } from '@vuetify/v0'
-*
-* export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext('checkboxes')
-*
-* // In a parent component:
-* provideCheckboxes()
-*
-* // In a child component:
-* const checkboxes = useCheckboxes()
-* checkboxes.select('checkbox-1')
-* ```
-*/
-function createSelectionContext(_options) {
-	const { namespace,...options } = _options;
-	const [useSelectionContext, _provideSelectionContext] = createContext(namespace);
-	const context = createSelection(options);
-	function provideSelectionContext(_context = context, app) {
-		return _provideSelectionContext(_context, app);
-	}
-	return createTrinity(useSelectionContext, provideSelectionContext, context);
-}
-/**
-* Returns the current selection instance.
-*
-* @param namespace The namespace for the selection context. Defaults to `'v0:selection'`.
-* @returns The current selection instance.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-selection
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useSelection } from '@vuetify/v0'
-*
-*   const selection = useSelection()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Selected: {{ selection.selectedIds.size }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useSelection(namespace = "v0:selection") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useGroup/index.ts
-/**
-* @module useGroup
-*
-* @remarks
-* Multi-selection composable that extends useSelection with batch operation support.
-*
-* Key features:
-* - Batch operations (select/unselect/toggle accept ID | ID[])
-* - selectedIndexes computed Set for position-based tracking
-* - Perfect for checkboxes, multi-select dropdowns, filter panels
-*
-* Inheritance chain: useRegistry → useSelection → useGroup
-* Extended by: useFeatures
-*/
-/**
-* Creates a new group instance with batch selection operations.
-*
-* Extends `createSelection` to support selecting, unselecting, and toggling multiple items
-* at once by passing an array of IDs. Adds `selectedIndexes` computed property.
-*
-* @param options The options for the group instance.
-* @template Z The type of the group ticket.
-* @template E The type of the group context.
-* @returns A new group instance with batch selection support.
-*
-* @remarks
-* **Key Differences from `createSelection`:**
-* - `select()` accepts `ID | ID[]` for batch operations
-* - `unselect()` accepts `ID | ID[]` for batch operations
-* - `toggle()` accepts `ID | ID[]` for batch operations
-* - Adds `selectedIndexes` computed Set for getting selected item indexes
-* - Perfect for checkboxes, multi-select dropdowns, and bulk operations
-*
-* **Batch Operations:**
-* - Single ID: `group.select('item-1')`
-* - Array of IDs: `group.select(['item-1', 'item-2', 'item-3'])`
-* - Uses `toArray()` utility internally to normalize input
-* - Disabled items are automatically skipped in batch operations
-* - Non-existent IDs are silently ignored
-*
-* **Inheritance Chain:**
-* `useRegistry` → `createSelection` → `createGroup`
-*
-* **Used By:**
-* - `createFeatures` for feature flag management with multiple selections
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-group
-*
-* @example
-* ```ts
-* import { createGroup } from '@vuetify/v0'
-*
-* const checkboxes = createGroup()
-*
-* checkboxes.onboard([
-*   { id: 'option-a', value: 'Option A' },
-*   { id: 'option-b', value: 'Option B' },
-*   { id: 'option-c', value: 'Option C' },
-* ])
-*
-* // Select multiple items at once
-* checkboxes.select(['option-a', 'option-c'])
-*
-* console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
-* console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
-*
-* // Toggle operations
-* checkboxes.toggle(['option-a', 'option-b'])
-* console.log(checkboxes.selectedIds) // Set { 'option-b', 'option-c' }
-* ```
-*/
-function createGroup(_options = {}) {
-	const { mandatory = false, multiple = true,...options } = _options;
-	const registry = createSelection({
-		...options,
-		mandatory,
-		multiple
-	});
-	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,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new group context.
-*
-* @param namespace The namespace for the group context.
-* @param options The options for the group context.
-* @template Z The type of the group ticket.
-* @template E The type of the group context.
-* @returns A new group context.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-group
-*
-* @example
-* ```ts
-* import { createGroupContext } from '@vuetify/v0'
-*
-* export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext('my-group')
-*
-* // In a parent component:
-* provideMyGroup()
-*
-* // In a child component:
-* const group = useMyGroup()
-* ```
-*/
-function createGroupContext(_options) {
-	const { namespace,...options } = _options;
-	const [useGroupContext, _provideGroupContext] = createContext(namespace);
-	const context = createGroup(options);
-	function provideGroupContext(_context = context, app) {
-		return _provideGroupContext(_context, app);
-	}
-	return createTrinity(useGroupContext, provideGroupContext, context);
-}
-/**
-* Returns the current group instance.
-*
-* @param namespace The namespace for the group context. Defaults to `'v0:group'`.
-* @returns The current group instance.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-group
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useGroup } from '@vuetify/v0'
-*
-*   const group = useGroup()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Selected: {{ group.selectedIds.size }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useGroup(namespace) {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useTokens/index.ts
-/**
-* @module useTokens
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-tokens
-*
-* @remarks
-* Design token registry with alias resolution and W3C Design Tokens format support.
-*
-* Key features:
-* - Alias resolution with circular reference detection
-* - Nested token flattening with dot notation
-* - W3C Design Tokens format ($value, $type, $description, $extensions)
-* - Path-based resolution (e.g., {colors}.blue.500)
-* - Resolution caching for performance (~28,590 ops/sec)
-*
-* Used by useTheme, useLocale, and useFeatures for token-based configuration.
-*/
-/**
-* Creates a new token instance.
-*
-* @param tokens The tokens to use.
-* @param options The options for the token instance.
-* @template Z The type of the token ticket.
-* @template E The type of the token context.
-* @returns A new token instance.
-*
-* @see https://www.designtokens.org/tr/drafts/format/
-* @see https://0.vuetifyjs.com/composables/registration/use-tokens
-*
-* @example
-* ```ts
-* import { useTokens } from '@vuetify/v0'
-*
-* const tokens = useTokens({
-*   colors: {
-*     primary: '#3b82f6',
-*     secondary: '{colors.primary}', // Alias reference
-*   },
-* })
-*
-* console.log(tokens.resolve('{colors.primary}')) // '#3b82f6'
-* console.log(tokens.resolve('{colors.secondary}')) // '#3b82f6'
-* ```
-*/
-function createTokens(tokens = {}, options = {}) {
-	const logger = useLogger();
-	const registry = useRegistry(options);
-	const cache = /* @__PURE__ */ new Map();
-	registry.onboard(flatten(tokens, options.prefix, !!options.flat));
-	function isAlias(token) {
-		return /* @__PURE__ */ isString(token) && token.length > 2 && token[0] === "{" && token.at(-1) === "}";
-	}
-	function isTokenAlias(value) {
-		return /* @__PURE__ */ isObject(value) && "$value" in value;
-	}
-	function resolve(token, visited = /* @__PURE__ */ new Set()) {
-		const cacheKey = /* @__PURE__ */ 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 = /* @__PURE__ */ isString(reference) && isAlias(reference) ? reference.slice(1, -1) : String(reference);
-		if (visited.has(clean)) {
-			logger.warn(`Circular alias detected for "${clean}"`);
-			cache.set(cacheKey, void 0);
-			return;
-		}
-		visited.add(clean);
-		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;
-		}
-		let result;
-		let current = found.value;
-		if (segments.length > 0) {
-			if (isTokenAlias(current)) current = current.$value;
-			for (const segment of segments) {
-				if (!/* @__PURE__ */ 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;
-			}
-			result = current;
-		} else if (isTokenAlias(current)) {
-			const inner = current.$value;
-			if (/* @__PURE__ */ isString(inner) && isAlias(inner)) return resolve(inner, visited);
-			result = inner;
-		} else if (/* @__PURE__ */ isString(current) && isAlias(current)) return resolve(current, visited);
-		else result = current;
-		cache.set(cacheKey, result);
-		return result;
-	}
-	return {
-		...registry,
-		resolve,
-		isAlias,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new token context.
-*
-* @param namespace The namespace for the token context.
-* @param tokens The tokens to use.
-* @template Z The type of the token ticket.
-* @template E The type of the token context.
-* @returns A new token context.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-tokens
-*
-* @example
-* ```ts
-* import { createTokensContext } from '@vuetify/v0'
-*
-* export const [useTokens, provideTokens, context] = createTokensContext({
-*  namespace: 'v0:tokens',
-*  tokens: {
-*    colors: {
-*      primary: '#3b82f6',
-*      secondary: '{colors.primary}', // Alias reference
-*    },
-*  },
-* })
-* ```
-*/
-function createTokensContext(_options) {
-	const { namespace, tokens = {},...options } = _options;
-	const [useTokensContext, _provideTokensContext] = createContext(namespace);
-	const context = createTokens(tokens, options);
-	function provideTokensContext(_context = context, app) {
-		return _provideTokensContext(_context, app);
-	}
-	return createTrinity(useTokensContext, provideTokensContext, context);
-}
-/**
-* Returns the current tokens instance.
-*
-* @param namespace The namespace for the tokens context. Defaults to `'v0:tokens'`.
-* @returns The current tokens instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-tokens
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useTokens } from '@vuetify/v0'
-*
-*   const tokens = useTokens()
-* <\/script>
-* ```
-*/
-function useTokens(namespace = "v0:tokens") {
-	return useContext(namespace);
-}
-/**
-* 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 = "", flat = false) {
-	const flattened = [];
-	const stack = [{
-		tokens,
-		prefix,
-		flat
-	}];
-	while (stack.length > 0) {
-		const { tokens: currentTokens, prefix: currentPrefix, flat: flat$1 } = 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 (!/* @__PURE__ */ isObject(value)) {
-				flattened.push({
-					id,
-					value
-				});
-				continue;
-			}
-			if ("$value" in value) {
-				flattened.push({
-					id,
-					value
-				});
-				const inner = value.$value;
-				if (/* @__PURE__ */ isObject(inner) && !flat$1) for (const innerKey in inner) {
-					if (innerKey.startsWith("$")) continue;
-					const child = inner[innerKey];
-					const childId = `${id}.${innerKey}`;
-					if (!/* @__PURE__ */ 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,
-						flat: flat$1
-					});
-				}
-				continue;
-			}
-			if (flat$1) {
-				flattened.push({
-					id,
-					value
-				});
-				continue;
-			}
-			stack.push({
-				tokens: value,
-				prefix: id,
-				flat: flat$1
-			});
-		}
-	}
-	return flattened;
-}
-
-//#endregion
-//#region src/composables/useFeatures/index.ts
-/**
-* @module useFeatures
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-features
-*
-* @remarks
-* Feature flag system with boolean and token-based features.
-*
-* Key features:
-* - Boolean features (true/false activation)
-* - Token features with $variation support
-* - Auto-selection of enabled features
-* - Multi-select support for feature combinations
-* - Perfect for A/B testing, progressive rollout, feature toggles
-*
-* Inheritance chain: useRegistry → createSelection → createGroup → createFeatures
-* Integrates with useTokens for token-based features.
-*/
-/**
-* Creates a new features instance.
-*
-* @param options The options for the features instance.
-* @template Z The type of the feature ticket.
-* @template E The type of the feature context.
-* @returns A new features instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-features
-*
-* @example
-* ```ts
-* import { createFeatures } from '@vuetify/v0'
-*
-* const [useFeatures, provideFeaturesContext, context] = createFeatures({
-*   namespace: 'v0:features',
-*   features: {
-*     'dark-mode': true,
-*     'theme-color': { $variation: 'blue' },
-*   },
-* })
-* ```
-*/
-function createFeatures(_options = {}) {
-	const { features,...options } = _options;
-	const tokens = createTokens(features, { flat: true });
-	const registry = createGroup(options);
-	for (const [id, { value }] of tokens.entries()) register({
-		id,
-		value
-	});
-	function variation(id, fallback = null) {
-		const ticket = registry.get(id);
-		if (!ticket) return fallback;
-		return /* @__PURE__ */ isObject(ticket.value) ? ticket.value.$variation ?? fallback : ticket.value ?? fallback;
-	}
-	function register(registration = {}) {
-		const item = {
-			value: false,
-			...registration
-		};
-		const ticket = registry.register(item);
-		if (/* @__PURE__ */ isBoolean(ticket.value) && ticket.value === true || /* @__PURE__ */ isObject(ticket.value) && /* @__PURE__ */ isBoolean(ticket.value.$value) && ticket.value.$value === true) registry.select(ticket.id);
-		return ticket;
-	}
-	return {
-		...registry,
-		variation,
-		register,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new features context.
-*
-* @param options The options for the features context.
-* @template Z The type of the feature ticket.
-* @template E The type of the feature context.
-* @returns A new features context.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-features
-*
-* @example
-* ```ts
-* import { createFeaturesContext } from '@vuetify/v0'
-*
-* export const [useFeatures, provideFeatures, context] = createFeaturesContext({
-*   namespace: 'app:features',
-*   features: {
-*     'dark-mode': true,
-*     'theme-color': { $variation: 'blue' },
-*   },
-* })
-* ```
-*/
-function createFeaturesContext(_options = {}) {
-	const { namespace = "v0:features",...options } = _options;
-	const [useFeaturesContext, _provideFeaturesContext] = createContext(namespace);
-	const context = createFeatures(options);
-	function provideFeaturesContext(_context = context, app) {
-		return _provideFeaturesContext(_context, app);
-	}
-	return createTrinity(useFeaturesContext, provideFeaturesContext, context);
-}
-/**
-* Creates a new features plugin.
-*
-* @param options The options for the features plugin.
-* @template Z The type of the feature ticket.
-* @template E The type of the feature context.
-* @returns A new features plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-features
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createFeaturesPlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(
-*   createFeaturesPlugin({
-*     features: {
-*       'dark-mode': true,
-*       'theme-color': { $variation: 'blue' },
-*     },
-*   })
-* )
-*
-* app.mount('#app')
-* ```
-*/
-function createFeaturesPlugin(_options = {}) {
-	const { namespace = "v0:features",...options } = _options;
-	const [, provideFeaturesContext, context] = createFeaturesContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideFeaturesContext(context, app);
-		}
-	});
-}
-/**
-* Returns the current features instance.
-*
-* @param namespace The namespace for the features context. Defaults to `v0:features`.
-* @template Z The type of the feature ticket.
-* @returns The current features instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-features
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useFeatures } from '@vuetify/v0'
-*
-*   const features = useFeatures()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Features: {{ features.get('dark-mode') }}</p>
-*     <p>Theme Color: {{ features.variation('theme-color') }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useFeatures(namespace = "v0:features") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useFilter/index.ts
-/**
-* @module useFilter
-*
-* @remarks
-* Reactive array filtering composable with multiple filter modes.
-*
-* Key features:
-* - Four filter modes: some, every, union, intersection
-* - Case-insensitive filtering
-* - Custom filter functions
-* - Reactive updates
-* - Perfect for search, multi-criteria filtering
-*
-* Filters arrays based on query strings with configurable matching strategies.
-*/
-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 stringValues = (/* @__PURE__ */ isObject(item) ? keys?.length ? keys.map((k) => item[k]) : Object.values(item) : [item]).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;
-}
-/**
-* A reusable function for filtering an array of items.
-*
-* @param query The query to filter by.
-* @param items The items to filter.
-* @param options The filter options.
-* @template Z The type of the items.
-* @returns The filtered items.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-filter
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useFilter } from '@vuetify/v0'
-*
-* const items = ref([
-*   { name: 'John Doe', age: 30 },
-*   { name: 'Jane Doe', age: 25 },
-*   { name: 'Peter Jones', age: 40 },
-* ])
-*
-* const query = ref('doe')
-* const { items: filtered } = useFilter(query, items, { keys: ['name'] })
-*
-* console.log(filtered.value) // [ { name: 'John Doe', age: 30 }, { name: 'Jane Doe', age: 25 } ]
-* ```
-*/
-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 = toRef(query);
-	return { items: 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));
-	}) };
-}
-
-//#endregion
-//#region src/composables/useForm/index.ts
-/**
-* @module useForm
-*
-* @remarks
-* Form validation composable with async rule support and multiple validation modes.
-*
-* Key features:
-* - Sync and async validation rules
-* - Multiple validation modes (submit, change, combined)
-* - Tri-state isValid (null/true/false)
-* - isPristine tracking
-* - Silent validation mode
-* - Form-level validation and reset
-*
-* Each field is registered with validation rules and tracks its own state independently.
-*/
-/**
-* Creates a new form instance.
-*
-* @param options The options for the form instance.
-* @template Z The type of the form ticket.
-* @template E The type of the form context.
-* @returns A new form instance.
-*
-* @see https://0.vuetifyjs.com/composables/forms/use-form
-*
-* @example
-* ```ts
-* import { createForm } from '@vuetify/v0'
-*
-* const form = createForm()
-*
-* const username = form.register({
-*   id: 'username',
-*   value: '',
-*   rules: [(v) => v.length > 0 || 'Username is required'],
-* })
-*
-* await form.submit()
-*
-* console.log(username.errors.value) // ['Username is required']
-*
-* form.reset()
-* ```
-*/
-function createForm(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 || 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")) return (await Promise.all(validating.map(async (id$1) => await registry.get(id$1)?.validate() ?? true))).every(Boolean);
-		return validating.map((id$1) => registry.get(id$1)).filter(Boolean).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 isValid$1.value = true;
-			isValidating$1.value = true;
-			try {
-				const errorMessages = (await Promise.all(rules.map((rule) => rule(model.value)))).filter((result) => /* @__PURE__ */ isString(result));
-				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,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new form context.
-*
-* @param namespace The namespace for the form context.
-* @param options The options for the form context.
-* @template Z The type of the form ticket.
-* @template E The type of the form context.
-* @returns A new form context.
-*
-* @see https://0.vuetifyjs.com/composables/forms/use-form
-*
-* @example
-* ```ts
-* import { createFormContext } from '@vuetify/v0'
-*
-* export const [useMyForm, provideMyForm, myForm] = createFormContext('my-form', {
-*   validateOn: 'change',
-* })
-*
-* // In a parent component:
-* provideMyForm()
-*
-* // In a child component:
-* const form = useMyForm()
-* form.register({ id: 'field', value: ref(''), rules: [...] })
-* ```
-*/
-function createFormContext(_options) {
-	const { namespace,...options } = _options;
-	const [useFormContext, _provideFormContext] = createContext(namespace);
-	const context = createForm(options);
-	function provideFormContext(_context = context, app) {
-		return _provideFormContext(_context, app);
-	}
-	return createTrinity(useFormContext, provideFormContext, context);
-}
-/**
-* Returns the current form instance.
-*
-* @param namespace The namespace for the form context. Defaults to `'v0:form'`.
-* @returns The current form instance.
-*
-* @see https://0.vuetifyjs.com/composables/forms/use-form
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useForm } from '@vuetify/v0'
-*
-*   const form = useForm()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Form is {{ form.isValid.value ? 'valid' : 'invalid' }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useForm(namespace = "v0:form") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useIntersectionObserver/index.ts
-/**
-* @module useIntersectionObserver
-*
-* @remarks
-* IntersectionObserver composable with lifecycle management.
-*
-* Key features:
-* - IntersectionObserver API wrapper
-* - Pause/resume/stop functionality
-* - Automatic cleanup on unmount
-* - SSR-safe (checks SUPPORTS_INTERSECTION_OBSERVER)
-* - Hydration-aware
-* - Immediate callback option
-*
-* Perfect for lazy loading, infinite scroll, and visibility detection.
-*/
-/**
-* A composable that uses the Intersection Observer API to detect when an element
-* is visible in the viewport.
-*
-* @param target The element to observe.
-* @param callback The callback to execute when the element's intersection changes.
-* @param options The options for the Intersection Observer.
-* @returns An object with methods to control the observer.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
-* @see https://0.vuetifyjs.com/composables/system/use-intersection-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useIntersectionObserver } from '@vuetify/v0'
-*
-* const target = ref<HTMLElement>()
-* const isVisible = ref(false)
-*
-* const { isIntersecting, pause, resume } = useIntersectionObserver(
-*   target,
-*   (entries) => {
-*     const entry = entries[0]
-*     if (entry) {
-*       isVisible.value = entry.isIntersecting
-*       console.log('Element is visible:', entry.isIntersecting)
-*     }
-*   },
-*   { threshold: 0.5 }
-* )
-*
-* // Pause observation
-* pause()
-*
-* // Resume observation
-* resume()
-* ```
-*/
-function useIntersectionObserver(target, callback, options = {}) {
-	const { isHydrated } = useHydration();
-	const observer = shallowRef();
-	const isPaused = shallowRef(false);
-	const isIntersecting = shallowRef(false);
-	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) callback([{
-			boundingClientRect: target.value.getBoundingClientRect(),
-			intersectionRatio: 0,
-			intersectionRect: new DOMRect(0, 0, 0, 0),
-			isIntersecting: false,
-			rootBounds: null,
-			target: target.value,
-			time: performance.now()
-		}]);
-	}
-	watch([isHydrated, target], () => {
-		cleanup();
-		setup();
-	}, { immediate: true });
-	function cleanup() {
-		if (observer.value) {
-			observer.value.disconnect();
-			observer.value = void 0;
-		}
-	}
-	function pause() {
-		isPaused.value = true;
-		isIntersecting.value = false;
-		observer.value?.disconnect();
-	}
-	function resume() {
-		isPaused.value = false;
-		setup();
-	}
-	function stop() {
-		cleanup();
-	}
-	onUnmounted(stop);
-	return {
-		isIntersecting: readonly(isIntersecting),
-		isPaused: readonly(isPaused),
-		pause,
-		resume,
-		stop
-	};
-}
-/**
-* A convenience composable that uses the Intersection Observer API to detect
-* when an element is visible in the viewport.
-*
-* @param target The element to observe.
-* @param options The options for the Intersection Observer.
-* @returns An object with the intersection state.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-intersection-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useElementIntersection } from '@vuetify/v0'
-*
-* const myElement = ref<HTMLElement>()
-* const { isIntersecting, intersectionRatio } = useElementIntersection(myElement, {
-*   threshold: 0.5
-* })
-*
-* // Use in template to conditionally render or animate
-* watchEffect(() => {
-*   if (isIntersecting.value) {
-*     console.log('Element is visible!', intersectionRatio.value)
-*   }
-* })
-* ```
-*/
-function useElementIntersection(target, options = {}) {
-	const isIntersecting = shallowRef(false);
-	const intersectionRatio = shallowRef(0);
-	const { pause: _pause, resume, stop, isPaused } = useIntersectionObserver(target, (entries) => {
-		const entry = entries.at(-1);
-		if (entry) {
-			isIntersecting.value = entry.isIntersecting;
-			intersectionRatio.value = entry.intersectionRatio;
-		}
-	}, {
-		immediate: true,
-		...options
-	});
-	function pause() {
-		isIntersecting.value = false;
-		intersectionRatio.value = 0;
-		_pause();
-	}
-	return {
-		isIntersecting: readonly(isIntersecting),
-		intersectionRatio: readonly(intersectionRatio),
-		isPaused,
-		pause,
-		resume,
-		stop
-	};
-}
-
-//#endregion
-//#region src/composables/useKeydown/index.ts
-/**
-* @module useKeydown
-*
-* @remarks
-* Keydown event listener composable with key filtering.
-*
-* Key features:
-* - Key-specific event handling
-* - preventDefault and stopPropagation options
-* - Automatic cleanup on scope disposal
-* - Auto-starts when in component scope
-*
-* Simplified wrapper around useEventListener for keyboard interactions.
-*/
-/**
-* A composable that adds a keydown event listener to the document.
-*
-* @param handlers The key handlers to add.
-* @returns An object with methods to start and stop listening.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-keydown
-*
-* @example
-* ```ts
-* import { useKeydown } from '@vuetify/v0'
-*
-* const { startListening, stopListening } = useKeydown([
-*   { key: 'Enter', handler: () => console.log('Enter pressed') },
-*   { key: 'Escape', handler: () => console.log('Escape pressed'), preventDefault: true },
-* ])
-*
-* startListening()
-* stopListening()
-* ```
-*/
-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/useSingle/index.ts
-/**
-* @module useSingle
-*
-* @remarks
-* Single-selection composable that extends useSelection to enforce only one selected item.
-*
-* Key features:
-* - Auto-clears previous selection when selecting new item
-* - Singular computed properties (selectedId, selectedItem, selectedIndex, selectedValue)
-* - Perfect for tabs, radio buttons, theme selectors
-*
-* Inheritance chain: useRegistry → useSelection → useSingle
-*/
-/**
-* Creates a new single selection instance that enforces only one selected item at a time.
-*
-* Extends `createSelection` by automatically clearing previous selections when a new item is selected.
-* Adds computed singular properties: `selectedId`, `selectedItem`, `selectedIndex`, `selectedValue`.
-*
-* @param options The options for the single selection instance.
-* @template Z The type of the single selection ticket.
-* @template E The type of the single selection context.
-* @returns A new single selection instance with single-selection enforcement.
-*
-* @remarks
-* **Key Differences from `createSelection`:**
-* - Automatically clears `selectedIds` before selecting a new item (enforces single selection)
-* - Provides singular computed properties instead of plural sets
-* - Perfect for tabs, radio buttons, theme selectors, and other single-choice UI components
-*
-* **Computed Properties:**
-* - `selectedId`: The ID of the selected item (undefined if none selected)
-* - `selectedItem`: The selected ticket object (undefined if none selected)
-* - `selectedIndex`: The index of the selected item (-1 if none selected)
-* - `selectedValue`: The value of the selected item (undefined if none selected)
-*
-* **Inheritance Chain:**
-* `useRegistry` → `createSelection` → `createSingle` → `createStep`
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-single
-*
-* @example
-* ```ts
-* import { createSingle } from '@vuetify/v0'
-*
-* const tabs = createSingle({ mandatory: true })
-*
-* tabs.onboard([
-*   { id: 'home', value: 'Home' },
-*   { id: 'about', value: 'About' },
-*   { id: 'contact', value: 'Contact' },
-* ])
-*
-* tabs.first() // Select first tab
-*
-* console.log(tabs.selectedId.value) // 'home'
-* console.log(tabs.selectedIndex.value) // 0
-*
-* tabs.select('about') // Switch to about tab
-* console.log(tabs.selectedId.value) // 'about'
-* console.log(tabs.selectedIds.size) // 1 (always enforces single selection)
-* ```
-*/
-function createSingle(_options = {}) {
-	const { mandatory = false, multiple = false,...options } = _options;
-	const registry = createSelection({
-		...options,
-		mandatory,
-		multiple
-	});
-	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 unselect(id) {
-		if (mandatory && registry.selectedIds.size === 1) return;
-		registry.selectedIds.delete(id);
-	}
-	function toggle(id) {
-		if (registry.selectedIds.has(id)) unselect(id);
-		else registry.select(id);
-	}
-	return {
-		...registry,
-		selectedId,
-		selectedItem,
-		selectedIndex,
-		selectedValue,
-		unselect,
-		toggle,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new single selection context.
-*
-* @param namespace The namespace for the single selection context.
-* @param options The options for the single selection context.
-* @template Z The type of the single selection ticket.
-* @template E The type of the single selection context.
-* @returns A new single selection context.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-single
-*
-* @example
-* ```ts
-* import { createSingleContext } from '@vuetify/v0'
-*
-* export const [useTabs, provideTabs, tabs] = createSingleContext('tabs', { mandatory: true })
-*
-* // In a parent component:
-* provideTabs()
-*
-* // In a child component:
-* const tabs = useTabs()
-* tabs.select('tab-1')
-* ```
-*/
-function createSingleContext(_options) {
-	const { namespace,...options } = _options;
-	const [useSingleContext, _provideSingleContext] = createContext(namespace);
-	const context = createSingle(options);
-	function provideSingleContext(_context = context, app) {
-		return _provideSingleContext(_context, app);
-	}
-	return createTrinity(useSingleContext, provideSingleContext, context);
-}
-/**
-* Returns the current single selection instance.
-*
-* @param namespace The namespace for the single selection context. Defaults to `'v0:single'`.
-* @returns The current single selection instance.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-single
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useSingle } from '@vuetify/v0'
-*
-*   const tabs = useSingle()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Selected: {{ tabs.selectedId }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useSingle(namespace = "v0:single") {
-	return useContext(namespace);
-}
-
-//#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 && /* @__PURE__ */ isObject(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
-/**
-* @module useLocale
-*
-* @remarks
-* Internationalization (i18n) composable with adapter pattern for message translation.
-*
-* Key features:
-* - Locale selection with createSingle
-* - Token-based message storage with useTokens
-* - Numbered and named placeholder support ({0}, {name})
-* - Number formatting with Intl.NumberFormat
-* - Adapter pattern for integration with i18n providers
-*
-* Integrates with createSingle for locale selection and useTokens for message resolution.
-*/
-/**
-* Creates a new locale instance.
-*
-* @param options The options for the locale instance.
-* @template Z The type of the locale ticket.
-* @template E The type of the locale context.
-* @returns A new locale instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-locale
-*/
-function createLocale(_options = {}) {
-	const { adapter = new Vuetify0LocaleAdapter(), messages = {},...options } = _options;
-	const tokens = createTokens(messages, { flat: true });
-	const registry = createSingle(options);
-	for (const id in messages) {
-		registry.register({
-			id,
-			value: messages[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 = (registry.get(locale)?.value)?.[key];
-		const template = /* @__PURE__ */ isString(message) ? 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, key) => {
-			const [prefix, ...rest] = key.split(".");
-			const path = rest.join(".");
-			const prefixTicket = registry.get(prefix);
-			const target = prefixTicket ? prefix : locale;
-			const name = prefixTicket ? path : key;
-			const resolved = (registry.get(target)?.value)?.[name];
-			if (/* @__PURE__ */ isString(resolved)) return resolve(target, resolved);
-			const alias = `{${key}}`;
-			if (tokens.isAlias(alias)) {
-				const result = tokens.resolve(alias);
-				return /* @__PURE__ */ isString(result) ? result : match;
-			}
-			return match;
-		});
-	}
-	return {
-		...registry,
-		t,
-		n,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new locale context.
-*
-* @param options The options for the locale context.
-* @template Z The type of the locale ticket.
-* @template E The type of the locale context.
-* @returns A new locale context.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-locale
-*
-* @example
-* ```ts
-* import { createLocaleContext } from '@vuetify/v0'
-*
-* export const [useAppLocale, provideAppLocale, appLocale] = createLocaleContext({
-*   namespace: 'app:locale',
-*   messages: {
-*     en: { hello: 'Hello' },
-*     es: { hello: 'Hola' },
-*   },
-* })
-*
-* // In a parent component:
-* provideAppLocale()
-*
-* // In a child component:
-* const locale = useAppLocale()
-* locale.select('es')
-* ```
-*/
-function createLocaleContext(_options = {}) {
-	const { namespace = "v0:locale",...options } = _options;
-	const [useLocaleContext, _provideLocaleContext] = createContext(namespace);
-	const context = createLocale(options);
-	function provideLocaleContext(_context = context, app) {
-		return _provideLocaleContext(_context, app);
-	}
-	return createTrinity(useLocaleContext, provideLocaleContext, context);
-}
-/**
-* Creates a new locale plugin.
-*
-* @param options The options for the locale plugin.
-* @template Z The type of the locale ticket.
-* @template E The type of the locale context.
-* @template R The type of the token ticket.
-* @template O The type of the token context.
-* @returns A new locale plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-locale
-*/
-function createLocalePlugin(_options = {}) {
-	const { namespace = "v0:locale", adapter = new Vuetify0LocaleAdapter(), messages = {},...options } = _options;
-	const [, provideLocaleContext, context] = createLocaleContext({
-		...options,
-		namespace,
-		adapter,
-		messages
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideLocaleContext(context, app);
-		}
-	});
-}
-/**
-* Returns the current locale instance.
-*
-* @returns The current locale instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-locale
-*/
-function useLocale(namespace = "v0:locale") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useMutationObserver/index.ts
-/**
-* @module useMutationObserver
-*
-* @remarks
-* MutationObserver composable with lifecycle management.
-*
-* Key features:
-* - MutationObserver API wrapper
-* - Pause/resume/stop functionality
-* - Automatic cleanup on unmount
-* - SSR-safe (checks SUPPORTS_MUTATION_OBSERVER)
-* - Hydration-aware
-* - Configurable observation options (childList, attributes, characterData, etc.)
-*
-* Perfect for detecting DOM changes and responding to mutations.
-*/
-/**
-* A composable that uses the Mutation Observer API to detect changes in the DOM.
-*
-* @param target The element to observe.
-* @param callback The callback to execute when a mutation is observed.
-* @param options The options for the Mutation Observer.
-* @returns An object with methods to control the observer.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
-* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useMutationObserver } from '@vuetify/v0'
-*
-* const container = ref<HTMLElement>()
-*
-* const { pause, resume, isPaused } = useMutationObserver(
-*   container,
-*   (mutations) => {
-*     mutations.forEach((mutation) => {
-*       if (mutation.type === 'childList') {
-*         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
-*       } else if (mutation.type === 'attributes') {
-*         console.log('Attribute changed:', mutation.attributeName)
-*       }
-*     })
-*   },
-*   {
-*     childList: true,
-*     attributes: true,
-*     subtree: true
-*   }
-* )
-*
-* // Pause observation
-* pause()
-*
-* // Resume observation
-* resume()
-* ```
-*/
-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
-	};
-	function setup() {
-		if (!isHydrated.value || !SUPPORTS_MUTATION_OBSERVER || !target.value || isPaused.value) return;
-		observer.value = new MutationObserver((mutations) => {
-			callback(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
-			})));
-		});
-		observer.value.observe(target.value, observerOptions);
-		if (options.immediate) {
-			const emptyNodeList = {
-				length: 0,
-				item: () => null,
-				forEach: () => {},
-				*[Symbol.iterator]() {}
-			};
-			callback([{
-				type: "childList",
-				target: target.value,
-				addedNodes: emptyNodeList,
-				removedNodes: emptyNodeList,
-				previousSibling: null,
-				nextSibling: null,
-				attributeName: null,
-				attributeNamespace: null,
-				oldValue: null
-			}]);
-		}
-	}
-	watch([isHydrated, target], () => {
-		cleanup();
-		setup();
-	}, { immediate: true });
-	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/usePermissions/adapters/adapter.ts
-var PermissionAdapter = class {};
-
-//#endregion
-//#region src/composables/usePermissions/adapters/v0.ts
-var Vuetify0PermissionAdapter = class extends PermissionAdapter {
-	constructor() {
-		super();
-	}
-	can(role, action, subject, context, permissions) {
-		const access = `${role}.${action}.${subject}`;
-		const ticket = permissions.get(access);
-		if (!ticket || !ticket.value) return false;
-		return /* @__PURE__ */ isFunction(ticket.value) ? ticket.value(context) : ticket.value;
-	}
-};
-
-//#endregion
-//#region src/composables/usePermissions/index.ts
-/**
-* @module usePermissions
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
-*
-* @remarks
-* Permission management composable with support for RBAC and ABAC patterns.
-*
-* Key features:
-* - Role-Based Access Control (RBAC) support
-* - Attribute-Based Access Control (ABAC) with context
-* - Functional permission conditions
-* - Token-based permission storage
-* - Adapter pattern for custom permission systems
-*
-* Built on useTokens for flexible permission configuration.
-*/
-/**
-* Creates a new permissions instance.
-*
-* @param options The options for the permissions instance.
-* @template Z The type of the permission ticket.
-* @template E The type of the permission context.
-* @returns A new permissions instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
-*
-* @example
-* ```ts
-* import { createPermissions } from '@vuetify/v0'
-*
-* const [usePermissions, providePermissions] = createPermissions({
-*   namespace: 'v0:permissions',
-*   permissions: {
-*     admin: [['read', 'users']],
-*     editor: [['edit', 'posts']],
-*   },
-* })
-* ```
-*/
-function createPermissions(_options = {}) {
-	const { adapter = new Vuetify0PermissionAdapter(), permissions = {},...options } = _options;
-	const record = {};
-	for (const role in permissions) {
-		if (!record[role]) record[role] = {};
-		for (const [actions, subjects, condition = true] of permissions[role]) for (const action of toArray(actions)) for (const subject of toArray(subjects)) {
-			if (!record[role][action]) record[role][action] = {};
-			record[role][action][subject] = condition;
-		}
-	}
-	const tokens = createTokens(record, options);
-	function can(id, action, subject, context = {}) {
-		return adapter.can(id, action, subject, context, tokens);
-	}
-	return {
-		...tokens,
-		can
-	};
-}
-/**
-* Creates a new permissions context.
-*
-* @param options The options for the permissions context.
-* @template Z The type of the permission ticket.
-* @template E The type of the permission context.
-* @returns A new permissions context.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
-*
-* @example
-* ```ts
-* import { createPermissionsContext } from '@vuetify/v0'
-*
-* export const [usePermissions, providePermissions, context] = createPermissionsContext({
-*   namespace: 'app:permissions',
-*   permissions: {
-*     admin: [['read', 'users'], ['edit', 'users']],
-*     editor: [['edit', 'posts']],
-*   },
-* })
-* ```
-*/
-function createPermissionsContext(_options = {}) {
-	const { namespace = "v0:permissions",...options } = _options;
-	const [usePermissionsContext, _providePermissionsContext] = createContext(namespace);
-	const context = createPermissions(options);
-	function providePermissionsContext(_context = context, app) {
-		return _providePermissionsContext(_context, app);
-	}
-	return createTrinity(usePermissionsContext, providePermissionsContext, context);
-}
-/**
-* Creates a new permissions plugin.
-*
-* @param options The options for the permissions plugin.
-* @template Z The type of the permission ticket.
-* @template E The type of the permission context.
-* @returns A new permissions plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createPermissionsPlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(
-*   createPermissionsPlugin({
-*     permissions: {
-*       admin: [['read', 'users']],
-*       editor: [['edit', 'posts']],
-*     },
-*   })
-* )
-*
-* app.mount('#app')
-* ```
-*/
-function createPermissionsPlugin(_options = {}) {
-	const { namespace = "v0:permissions",...options } = _options;
-	const [, providePermissionContext, context] = createPermissionsContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			providePermissionContext(context, app);
-		}
-	});
-}
-/**
-* Returns the current permissions instance.
-*
-* @template Z The type of the permission ticket.
-* @returns The current permissions instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { usePermissions } from '@vuetify/v0'
-*
-*   const { can } = usePermissions()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p v-if="can('admin', 'read', 'users')">Admin access</p>
-*   </div>
-* </template>
-* ```
-*/
-function usePermissions(namespace = "v0:permissions") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useProxyModel/index.ts
-/**
-* @module useProxyModel
-*
-* @remarks
-* Proxy composable for bidirectional sync between selection registry and v-model.
-*
-* Key features:
-* - Bidirectional synchronization
-* - Array and single-value modes
-* - Automatic cleanup on scope disposal
-* - Perfect for form controls with selection backing
-*
-* Bridges the gap between selection composables and Vue's v-model.
-*/
-/**
-* Syncs a ref with a selection registry bidirectionally.
-*
-* @param registry The selection registry to bind to.
-* @param model The ref to sync.
-* @param options The options for the proxy model.
-* @template Z The type of the selection ticket.
-* @returns A function to stop the sync.
-*
-* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
-*
-* @example
-* ```ts
-* import { createSelection, useProxyModel } from '@vuetify/v0'
-*
-* const model = ref()
-* const registry = createSelection({ events: true })
-* registry.onboard([
-*   { id: 'item-1', value: 'Item 1' },
-*   { id: 'item-2', value: 'Item 2' },
-* ])
-*
-* const stop = useProxyModel(registry, model)
-* ```
-*/
-function useProxyModel(registry, model, options) {
-	const multiple = options?.multiple ?? false;
-	const _transformIn = options?.transformIn;
-	const _transformOut = options?.transformOut;
-	function transformIn(val) {
-		const value = toValue(val);
-		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
-	}
-	function transformOut(val) {
-		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
-		return multiple ? val : val[0];
-	}
-	const modelAsArray = transformIn(model);
-	const pending = new Set(modelAsArray);
-	for (const value of modelAsArray) {
-		const ids = registry.browse(value);
-		if (/* @__PURE__ */ isArray(ids)) {
-			for (const id of ids) registry.select(id);
-			pending.delete(value);
-		} else if (ids) {
-			registry.select(ids);
-			pending.delete(value);
-		}
-	}
-	const registryWatch = watch(registry.selectedValues, (val) => {
-		modelWatch.pause();
-		model.value = transformOut(Array.from(toValue(val)));
-		modelWatch.resume();
-	}, { flush: "sync" });
-	const modelWatch = watch(model, (val) => {
-		registryWatch.pause();
-		const currentIds = new Set(toValue(registry.selectedIds));
-		const targetIds = /* @__PURE__ */ new Set();
-		for (const value of transformIn(val)) {
-			const ids = registry.browse(value);
-			if (/* @__PURE__ */ isArray(ids)) for (const single of ids) targetIds.add(single);
-			else if (ids) targetIds.add(ids);
-		}
-		if (multiple) {
-			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;
-			if (last !== void 0) registry.unselect(last);
-			if (next !== void 0) registry.select(next);
-		}
-		registryWatch.resume();
-	}, {
-		flush: "sync",
-		deep: multiple
-	});
-	function onRegister(ticket) {
-		if (!pending.has(ticket.value) || ticket.disabled) return;
-		registryWatch.pause();
-		modelWatch.pause();
-		registry.select(ticket.id);
-		pending.delete(ticket.value);
-		modelWatch.resume();
-		registryWatch.resume();
-	}
-	registry.on("register:ticket", onRegister);
-	function stop() {
-		registryWatch();
-		modelWatch();
-		registry.off("register:ticket", onRegister);
-	}
-	onScopeDispose(stop, true);
-	return stop;
-}
-
-//#endregion
-//#region src/composables/useProxyRegistry/index.ts
-/**
-* @module useProxyRegistry
-*
-* @remarks
-* Proxy composable for reactive registry keys, values, entries, and size.
-*
-* Key features:
-* - Reactive proxy for registry data
-* - Deep or shallow reactivity options
-* - Event-based updates
-* - Automatic cleanup on scope disposal
-* - Transforms Map-based registry into reactive refs
-*
-* Perfect for exposing registry data as reactive computed properties.
-*/
-/**
-* Creates a proxy registry that provides reactive objects for registry data.
-*
-* @param registry The registry instance to proxy.
-* @param options The options for the proxy registry.
-* @template Z The type of the registry ticket.
-* @returns A proxy registry with reactive objects.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-proxy-registry
-*
-* @example
-* ```ts
-* import { useRegistry, useProxyRegistry } from '@vuetify/v0'
-*
-* const registry = useRegistry({ events: true })
-* const proxy = useProxyRegistry(registry)
-*
-* registry.register({ value: 'Item 1' })
-* console.log(proxy.size) // 1
-* ```
-*/
-function useProxyRegistry(registry, options) {
-	const state = (options?.deep ? reactive : shallowReactive)({
-		keys: registry.keys(),
-		values: registry.values(),
-		entries: registry.entries(),
-		size: registry.size
-	});
-	function update() {
-		state.keys = registry.keys();
-		state.values = registry.values();
-		state.entries = registry.entries();
-		state.size = registry.size;
-	}
-	registry.on("register:ticket", update);
-	registry.on("unregister:ticket", update);
-	registry.on("update:ticket", update);
-	registry.on("clear:registry", update);
-	onScopeDispose(() => {
-		registry.off("register:ticket", update);
-		registry.off("unregister:ticket", update);
-		registry.off("update:ticket", update);
-		registry.off("clear:registry", update);
-	}, true);
-	return state;
-}
-
-//#endregion
-//#region src/composables/useQueue/index.ts
-/**
-* @module useQueue
-*
-* @remarks
-* A queue composable for managing time-based collections with:
-* - Automatic timeout-based removal
-* - Pause/resume functionality
-* - FIFO (First In, First Out) ordering
-* - Manual dismissal support
-* - Queue progression management
-*
-* Built on top of useRegistry, the queue automatically manages timeouts for tickets,
-* ensuring only the first ticket in the queue is active at any time. When an ticket
-* expires or is removed, the next ticket in the queue automatically becomes active.
-*/
-/**
-* Creates a new queue instance
-*
-* @param options The options for the queue instance
-* @template Z The type of queue ticket that extends QueueTicket. Use this to add custom properties to tickets.
-* @template E The type of queue context that extends QueueContext<Z>. Use this when extending the queue with additional methods.
-* @returns A new queue instance
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-queue
-*
-* @example
-* ```ts
-* import { useQueue } from '@vuetify/v0'
-*
-* const queue = useQueue()
-*
-* // Register an ticket with default timeout (3000ms)
-* const ticket1 = queue.register({ value: 'Ticket 1' })
-*
-* // Register an ticket with custom timeout
-* const ticket2 = queue.register({ value: 'Ticket 2', timeout: 5000 })
-*
-* // Register a persistent ticket that must be manually dismissed
-* const ticket3 = queue.register({ value: 'Ticket 3', timeout: -1 })
-*
-* // Dismiss an ticket using the convenience method
-* ticket3.dismiss()
-*
-* console.log(queue.size) // 2
-* ```
-*/
-function createQueue(_options = {}) {
-	const { timeout: _timeout = 3e3,...options } = _options;
-	const registry = useRegistry({
-		...options,
-		events: true
-	});
-	const timeouts = /* @__PURE__ */ new Map();
-	function startTimeout(ticket) {
-		if (ticket.timeout === void 0 || ticket.timeout === -1 || ticket.isPaused) return;
-		const timeout = setTimeout(() => {
-			timeouts.delete(ticket.id);
-			registry.unregister(ticket.id);
-			resume();
-		}, ticket.timeout);
-		timeouts.set(ticket.id, timeout);
-	}
-	function clearTimeout(id) {
-		const timeout = timeouts.get(id);
-		if (timeout) {
-			globalThis.clearTimeout(timeout);
-			timeouts.delete(id);
-		}
-	}
-	function register(registration = {}) {
-		const id = registration.id ?? /* @__PURE__ */ genId();
-		const timeout = Object.prototype.hasOwnProperty.call(registration, "timeout") ? registration.timeout : _timeout;
-		const ticket = {
-			...registration,
-			id,
-			timeout,
-			isPaused: registry.size > 0,
-			dismiss: () => unregister(id)
-		};
-		const registered = registry.register(ticket);
-		startTimeout(registered);
-		return registered;
-	}
-	function unregister(id) {
-		const ticket = id === void 0 ? registry.seek("first") : registry.get(id);
-		if (!ticket) return void 0;
-		const wasFirst = ticket.index === 0;
-		clearTimeout(ticket.id);
-		registry.unregister(ticket.id);
-		if (wasFirst) resume();
-		return ticket;
-	}
-	function pause() {
-		const ticket = registry.seek("first");
-		if (!ticket || ticket.isPaused) return void 0;
-		clearTimeout(ticket.id);
-		registry.upsert(ticket.id, { isPaused: true });
-		return ticket;
-	}
-	function resume() {
-		const ticket = registry.seek("first");
-		if (!ticket || ticket.index !== 0 || !ticket.isPaused) return void 0;
-		registry.upsert(ticket.id, { isPaused: false });
-		startTimeout(ticket);
-		return ticket;
-	}
-	function clear() {
-		for (const id of timeouts.keys()) clearTimeout(id);
-		registry.clear();
-	}
-	function dispose() {
-		clear();
-		registry.dispose();
-	}
-	onScopeDispose(dispose, true);
-	return {
-		...registry,
-		register,
-		unregister,
-		pause,
-		resume,
-		clear,
-		dispose,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new queue context.
-*
-* @param namespace The namespace for the queue context.
-* @param options The options for the queue context.
-* @template Z The type of the queue ticket.
-* @template E The type of the queue context.
-* @returns A new queue context.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-queue
-*
-* @example
-* ```ts
-* import { createQueueContext } from '@vuetify/v0'
-*
-* export const [useQueue, provideQueue] = createQueueContext('v0:queue', {
-*   timeout: 5000,
-* })
-* ```
-*/
-function createQueueContext(_options) {
-	const { namespace,...options } = _options;
-	const [useQueueContext, _provideQueueContext] = createContext(namespace);
-	const context = createQueue(options);
-	function provideQueueContext(_context = context, app) {
-		return _provideQueueContext(_context, app);
-	}
-	return createTrinity(useQueueContext, provideQueueContext, context);
-}
-/**
-* Returns the current queue instance.
-*
-* @param namespace The namespace for the queue context. Defaults to `'v0:queue'`.
-* @returns The current queue instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-queue
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useQueue } from '@vuetify/v0'
-*
-*   const queue = useQueue()
-* <\/script>
-* ```
-*/
-function useQueue(namespace = "v0:queue") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useResizeObserver/index.ts
-/**
-* @module useResizeObserver
-*
-* @remarks
-* ResizeObserver composable with lifecycle management.
-*
-* Key features:
-* - ResizeObserver API wrapper
-* - Pause/resume/stop functionality
-* - Automatic cleanup on unmount
-* - SSR-safe (checks SUPPORTS_OBSERVER)
-* - Hydration-aware
-* - Box model options (content-box/border-box)
-*
-* Perfect for responsive components and size-based rendering.
-*/
-/**
-* A composable that uses the Resize Observer API to detect when an element's
-* size changes.
-*
-* @param target The element to observe.
-* @param callback The callback to execute when the element's size changes.
-* @param options The options for the Resize Observer.
-* @returns An object with methods to control the observer.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
-* @see https://0.vuetifyjs.com/composables/system/use-resize-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useResizeObserver } from '@vuetify/v0'
-*
-* const el = ref<HTMLElement>()
-* const width = ref(0)
-* const height = ref(0)
-*
-* const { pause, resume, isPaused } = useResizeObserver(
-*   el,
-*   (entries) => {
-*     const entry = entries[0]
-*     if (entry) {
-*       width.value = entry.contentRect.width
-*       height.value = entry.contentRect.height
-*       console.log('Size changed:', width.value, 'x', height.value)
-*     }
-*   },
-*   { immediate: true }
-* )
-*
-* // Pause observation
-* pause()
-*
-* // Resume observation
-* resume()
-* ```
-*/
-function useResizeObserver(target, callback, options = {}) {
-	const { isHydrated } = useHydration();
-	const observer = shallowRef();
-	const isPaused = shallowRef(false);
-	function setup() {
-		if (!isHydrated.value || !SUPPORTS_OBSERVER || !target.value || isPaused.value) return;
-		observer.value = new ResizeObserver((entries) => {
-			callback(entries.map((entry) => ({
-				contentRect: {
-					width: entry.contentRect.width,
-					height: entry.contentRect.height,
-					top: entry.contentRect.top,
-					left: entry.contentRect.left
-				},
-				target: entry.target
-			})));
-		});
-		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
-			}]);
-		}
-	}
-	watch([isHydrated, target], () => {
-		cleanup();
-		setup();
-	}, { immediate: true });
-	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
-	};
-}
-/**
-* A convenience composable that uses the Resize Observer API to track an
-* element's size.
-*
-* @param target The element to observe.
-* @returns An object with the element's width and height.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-resize-observer#use-element-size
-*
-* @example
-* ```ts
-* import { ref, watchEffect } from 'vue'
-* import { useElementSize } from '@vuetify/v0'
-*
-* const box = ref<HTMLElement>()
-* const { width, height } = useElementSize(box)
-*
-* // Width and height are reactive refs
-* watchEffect(() => {
-*   console.log('Box size:', width.value, 'x', height.value)
-* })
-* ```
-*/
-function useElementSize(target) {
-	const width = shallowRef(0);
-	const height = shallowRef(0);
-	const { pause: _pause, resume, stop, isPaused } = useResizeObserver(target, (entries) => {
-		const entry = entries[0];
-		if (entry) {
-			width.value = entry.contentRect.width;
-			height.value = entry.contentRect.height;
-		}
-	}, { immediate: true });
-	function pause() {
-		width.value = 0;
-		height.value = 0;
-		_pause();
-	}
-	return {
-		width,
-		height,
-		isPaused,
-		pause,
-		resume,
-		stop
-	};
-}
-
-//#endregion
-//#region src/composables/useStep/index.ts
-/**
-* @module useStep
-*
-* @remarks
-* Navigation composable that extends useSingle with first/last/next/prev/step methods.
-*
-* Key features:
-* - Configurable circular or bounded navigation
-* - Automatic disabled item skipping
-* - Arbitrary step counts (positive/negative)
-* - Perfect for wizards, carousels, pagination, onboarding flows
-*
-* Inheritance chain: useRegistry → useSelection → useSingle → useStep
-*/
-/**
-* Creates a new step instance with navigation through items.
-*
-* Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
-* for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
-*
-* @param options The options for the step instance.
-* @template Z The type of the step ticket.
-* @template E The type of the step context.
-* @returns A new step instance with navigation methods.
-*
-* @remarks
-* **Key Features:**
-* - **Configurable Navigation**: `circular: true` for wrapping, `false` for bounded (default: false)
-* - **Disabled Item Skipping**: Automatically skips disabled items during navigation
-* - **Bidirectional**: Forward (`next`, positive `step`) and backward (`prev`, negative `step`)
-* - **Safe Edge Cases**: Handles empty registries and all-disabled scenarios gracefully
-*
-* **Navigation Methods:**
-* - `first()`: Select first non-disabled item
-* - `last()`: Select last non-disabled item
-* - `next()`: Move to next item (wraps if circular, stops at end if bounded)
-* - `prev()`: Move to previous item (wraps if circular, stops at start if bounded)
-* - `step(count)`: Move by `count` positions (negative for backward)
-*
-* **Circular Mode (`circular: true`):**
-* - Uses modulo arithmetic for wrapping: `((index % length) + length) % length`
-* - Works correctly with negative indexes and large step counts
-* - Perfect for carousels, theme switchers, infinite scrolling
-*
-* **Bounded Mode (`circular: false`, default):**
-* - Navigation stops at boundaries (no wrapping)
-* - `next()` on last item does nothing
-* - `prev()` on first item does nothing
-* - Perfect for pagination, wizards with explicit completion, forms
-*
-* **Inheritance Chain:**
-* `useRegistry` → `createSelection` → `createSingle` → `createStep`
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-step
-*
-* @example
-* ```ts
-* import { createStep } from '@vuetify/v0'
-*
-* // Bounded navigation (default) - for pagination
-* const pagination = createStep({ circular: false })
-* pagination.onboard([
-*   { id: 'page-1', value: 1 },
-*   { id: 'page-2', value: 2 },
-*   { id: 'page-3', value: 3 },
-* ])
-* pagination.first() // Select page 1
-* pagination.prev() // Does nothing (already at first)
-* pagination.next() // Select page 2
-*
-* // Circular navigation - for carousels
-* const carousel = createStep({ circular: true })
-* carousel.onboard([
-*   { id: 'slide-1', value: 'First' },
-*   { id: 'slide-2', value: 'Second' },
-*   { id: 'slide-3', value: 'Third' },
-* ])
-* carousel.first()
-* carousel.prev() // Wraps to 'slide-3'
-* carousel.next() // Wraps to 'slide-1'
-* ```
-*/
-function createStep(_options = {}) {
-	const { circular = false,...options } = _options;
-	const registry = createSingle(options);
-	function first() {
-		const ticket = registry.seek("first");
-		if (ticket) registry.select(ticket.id);
-	}
-	function last() {
-		const ticket = registry.seek("last");
-		if (ticket) registry.select(ticket.id);
-	}
-	function next() {
-		step(1);
-	}
-	function prev() {
-		step(-1);
-	}
-	function wrapped(length, index) {
-		return (index % length + length) % length;
-	}
-	function step(count = 1) {
-		const length = registry.size;
-		if (!length) return;
-		const currentIndex = registry.selectedIndex.value;
-		const direction = Math.sign(count || 1);
-		let hops = 0;
-		let index = circular ? wrapped(length, currentIndex + count) : currentIndex + count;
-		if (!circular && (index < 0 || index >= length)) return;
-		let id = registry.lookup(index);
-		while (id !== void 0 && toValue(registry.get(id)?.disabled) && hops < length) {
-			index = circular ? wrapped(length, index + direction) : index + direction;
-			if (!circular && (index < 0 || index >= length)) return;
-			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,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new step context.
-*
-* @param namespace The namespace for the step context.
-* @param options The options for the step context.
-* @template Z The type of the step ticket.
-* @template E The type of the step context.
-* @returns A new step context.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-step
-*
-* @example
-* ```ts
-* import { createStepContext } from '@vuetify/v0'
-*
-* export const [useWizard, provideWizard, wizard] = createStepContext('wizard')
-*
-* // In a parent component:
-* provideWizard()
-*
-* // In a child component:
-* const wizard = useWizard()
-* wizard.next() // Progress to next step
-* ```
-*/
-function createStepContext(_options) {
-	const { namespace,...options } = _options;
-	const [useStepContext, _provideStepContext] = createContext(namespace);
-	const context = createStep(options);
-	function provideStepContext(_context = context, app) {
-		return _provideStepContext(_context, app);
-	}
-	return createTrinity(useStepContext, provideStepContext, context);
-}
-/**
-* Returns the current step instance.
-*
-* @param namespace The namespace for the step context. Defaults to `'v0:step'`.
-* @returns The current step instance.
-*
-* @see https://0.vuetifyjs.com/composables/selection/use-step
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useStep } from '@vuetify/v0'
-*
-*   const wizard = useStep()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Current step: {{ wizard.selectedIndex }}</p>
-*     <button @click="wizard.next()">Next</button>
-*   </div>
-* </template>
-* ```
-*/
-function useStep(namespace = "v0:step") {
-	return useContext(namespace);
-}
-
-//#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 String(Array.from(this.store.keys())[index] ?? "");
-	}
-};
-
-//#endregion
-//#region src/composables/useStorage/index.ts
-/**
-* @module useStorage
-*
-* @remarks
-* Reactive storage composable with adapter pattern for localStorage, sessionStorage, or memory.
-*
-* Key features:
-* - Reactive refs that sync with storage
-* - localStorage, sessionStorage, and memory adapters
-* - Custom serialization support
-* - SSR fallback to memory adapter
-* - Automatic cleanup on remove/clear
-*
-* Uses adapter pattern to abstract storage implementation details.
-*/
-const [useStorageContext, provideStorageContext] = createContext("v0:storage");
-/**
-* Creates a new storage instance.
-*
-* @param options The options for the storage instance.
-* @template E The type of the storage context.
-* @returns A new storage instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-storage
-*
-* @example
-* ```ts
-* import { createStorage } from '@vuetify/v0'
-*
-* const storage = createStorage()
-*
-* storage.set('username', 'MyUsername')
-*
-* const username = storage.get('username')
-*
-* console.log(username.value) // MyUsername
-*
-* storage.clear()
-* ```
-*/
-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();
-	const watchers = /* @__PURE__ */ new Map();
-	function has(key) {
-		const prefixedKey = `${prefix}${key}`;
-		return cache.has(prefixedKey);
-	}
-	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);
-		const stop = watch(valueRef, (newValue) => {
-			if (newValue === void 0 || newValue === null) adapter?.removeItem(prefixedKey);
-			else adapter?.setItem(prefixedKey, serializer.write(newValue));
-		}, { deep: true });
-		watchers.set(prefixedKey, stop);
-		cache.set(prefixedKey, valueRef);
-		return valueRef;
-	}
-	function set(key, value) {
-		const valueRef = get(key);
-		valueRef.value = value;
-	}
-	function remove(key) {
-		const prefixedKey = `${prefix}${key}`;
-		const stop = watchers.get(prefixedKey);
-		if (!stop) return;
-		stop();
-		watchers.delete(prefixedKey);
-		adapter?.removeItem(prefixedKey);
-		cache.delete(prefixedKey);
-	}
-	function clear() {
-		if (watchers.size > 0) {
-			for (const stop of watchers.values()) stop();
-			watchers.clear();
-		}
-		if (cache.size > 0) {
-			for (const key of cache.keys()) adapter?.removeItem(key);
-			cache.clear();
-		}
-	}
-	return {
-		has,
-		get,
-		set,
-		remove,
-		clear
-	};
-}
-function createStorageContext(_options = {}) {
-	const { namespace = "v0:storage",...options } = _options;
-	const [useStorageContext$1, _provideStorageContext] = createContext(namespace);
-	const context = createStorage(options);
-	function provideStorageContext$1(_context = context, app) {
-		return _provideStorageContext(_context, app);
-	}
-	return createTrinity(useStorageContext$1, provideStorageContext$1, context);
-}
-/**
-* Creates a new storage plugin.
-*
-* @param options The options for the storage plugin.
-* @returns A new storage plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-storage
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createStoragePlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(createStoragePlugin())
-*
-* app.mount('#app')
-* ```
-*/
-function createStoragePlugin(_options = {}) {
-	const { namespace = "v0:storage",...options } = _options;
-	const [, provideStorageContext$1, context] = createStorageContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideStorageContext$1(context, app);
-		}
-	});
-}
-/**
-* Returns the current storage instance.
-*
-* @param namespace The namespace for the storage context. Defaults to `'v0:storage'`.
-* @returns The current storage instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-storage
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useStorage } from '@vuetify/v0'
-*
-*   const storage = useStorage()
-*   const username = storage.get('username', 'Guest')
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Username: {{ username }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useStorage(namespace = "v0:storage") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useTheme/adapters/adapter.ts
-var ThemeAdapter = class {
-	stylesheetId = "v0-theme-stylesheet";
-	prefix;
-	constructor(prefix) {
-		this.prefix = prefix;
-	}
-	generate(colors, isDark) {
-		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 += `[data-theme="${theme}"] {\n${vars}\n}\n`;
-		}
-		if (isDark !== void 0) css += `:root {\n  color-scheme: ${isDark ? "dark" : "light"};\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;
-	constructor(options = {}) {
-		super(options.prefix ?? "v0");
-		this.cspNonce = options.cspNonce;
-		this.stylesheetId = options.stylesheetId ?? this.stylesheetId;
-	}
-	setup(app, context, target) {
-		if (IN_BROWSER) {
-			onScopeDispose(watch([context.colors, context.isDark], ([colors, isDark]) => {
-				this.update(colors, isDark);
-			}, { immediate: true }), true);
-			if (/* @__PURE__ */ isNull(target)) return;
-			const targetEl = target instanceof HTMLElement ? target : /* @__PURE__ */ isString(target) ? document.querySelector(target) : app._container || document.querySelector("#app") || document.body;
-			if (!targetEl) return;
-			onScopeDispose(watch(context.selectedId, (id) => {
-				if (!id) return;
-				targetEl.dataset.theme = String(id);
-			}, { immediate: true }), true);
-		} else {
-			const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
-			if (head?.push) {
-				const id = context.selectedId.value;
-				head.push({
-					htmlAttrs: { "data-theme": id ? String(id) : "" },
-					style: [{
-						innerHTML: this.generate(context.colors.value, context.isDark.value),
-						id: this.stylesheetId
-					}]
-				});
-			}
-		}
-	}
-	update(colors, isDark) {
-		if (!IN_BROWSER) return;
-		this.upsert(this.generate(colors, isDark));
-	}
-	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
-/**
-* @module useTheme
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-theme
-*
-* @remarks
-* Theme management composable with token resolution and CSS variable injection.
-*
-* Key features:
-* - Single-selection theme switching (extends createSingle)
-* - Token alias resolution via useTokens
-* - Lazy theme loading (compute colors only when selected)
-* - CSS variable generation via adapter pattern
-* - SSR support with head integration
-* - Theme cycling
-*
-* Integrates with createSingle for selection and useTokens for color resolution.
-*/
-/**
-* Creates a new theme instance.
-*
-* @param options The options for the theme instance.
-* @template Z The type of the theme ticket.
-* @template E The type of the theme context.
-* @returns A new theme instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-theme
-*
-* @example
-* ```ts
-* import { createTheme } from '@vuetify/v0'
-*
-* export const [useTheme, provideTheme] = createTheme({
-*   namespace: 'v0:theme',
-*   default: 'light',
-*   themes: {
-*     light: {
-*       dark: false,
-*       colors: {
-*         primary: '#3b82f6',
-*       },
-*     },
-*     dark: {
-*       dark: true,
-*       colors: {
-*         primary: '#675496',
-*       },
-*     },
-*   },
-* })
-* ```
-*/
-function createTheme(_options = {}) {
-	const { themes = {}, palette = {},...options } = _options;
-	const tokens = createTokens({
-		palette,
-		...themes
-	}, { flat: true });
-	const registry = createSingle(options);
-	for (const id in themes) {
-		const { colors: value,...theme } = themes[id];
-		register({
-			id,
-			value,
-			...theme
-		});
-		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[theme.id] = resolve(theme.value);
-		}
-		return resolved;
-	});
-	const isDark = toRef(() => registry.selectedItem.value?.dark ?? false);
-	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(colors$1) {
-		const resolved = {};
-		for (const [key, value] of Object.entries(colors$1)) resolved[key] = tokens.isAlias(value) ? tokens.resolve(value) : value;
-		return resolved;
-	}
-	function register(registration = {}) {
-		const item = {
-			lazy: false,
-			dark: false,
-			...registration
-		};
-		return registry.register(item);
-	}
-	return {
-		...registry,
-		colors,
-		isDark,
-		register,
-		cycle,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new theme context trinity.
-*
-* @param options The options for the theme context.
-* @template Z The type of the theme ticket.
-* @template E The type of the theme context.
-* @returns A new theme context trinity.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-theme
-*
-* @example
-* ```ts
-* import { createThemeContext } from '@vuetify/v0'
-*
-* export const [useThemeContext, provideThemeContext, context] = createThemeContext({
-*   namespace: 'v0:theme',
-*   default: 'light',
-*   themes: {
-*     light: {
-*       dark: false,
-*       colors: {
-*         primary: '#3b82f6',
-*       },
-*     },
-*     dark: {
-*       dark: true,
-*       colors: {
-*         primary: '#675496',
-*       },
-*     },
-*   },
-* })
-* ```
-*/
-function createThemeContext(_options = {}) {
-	const { namespace = "v0:theme",...options } = _options;
-	const [useThemeContext, _provideThemeContext] = createContext(namespace);
-	const context = createTheme(options);
-	function provideThemeContext(_context = context, app) {
-		return _provideThemeContext(_context, app);
-	}
-	return createTrinity(useThemeContext, provideThemeContext, context);
-}
-/**
-* Creates a new theme plugin.
-*
-* @param options The options for the theme plugin.
-* @template Z The type of the theme ticket.
-* @template E The type of the theme context.
-* @returns A new theme plugin.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-theme
-*
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createThemePlugin } from '@vuetify/v0'
-* import App from './App.vue'
-*
-* const app = createApp(App)
-*
-* app.use(
-*   createThemePlugin({
-*     default: 'light',
-*     themes: {
-*       light: {
-*         dark: false,
-*         colors: {
-*           primary: '#3b82f6',
-*         },
-*       },
-*       dark: {
-*         dark: true,
-*         colors: {
-*           primary: '#675496',
-*         },
-*       },
-*     },
-*   })
-* )
-*
-* app.mount('#app')
-* ```
-*/
-function createThemePlugin(_options = {}) {
-	const { adapter = new Vuetify0ThemeAdapter(), namespace = "v0:theme", palette = {}, themes = {}, target,...options } = _options;
-	const [, provideThemeContext, context] = createThemeContext({
-		...options,
-		namespace,
-		themes,
-		palette
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideThemeContext(context, app);
-		},
-		setup: (app) => {
-			adapter.setup(app, context, target);
-		}
-	});
-}
-/**
-* Returns the current theme instance.
-*
-* @param namespace The namespace for the theme context. Defaults to `v0:theme`.
-* @returns The current theme instance.
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-theme
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useTheme } from '@vuetify/v0'
-*
-*   const theme = useTheme()
-* <\/script>
-*
-* <template>
-*   <div>
-*     <p>Current theme: {{ theme.selected.value }}</p>
-*   </div>
-* </template>
-* ```
-*/
-function useTheme(namespace = "v0:theme") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useTimeline/index.ts
-/**
-* @module useTimeline
-*
-* @remarks
-* Bounded undo/redo system with overflow management.
-*
-* Key features:
-* - Fixed-size history (default: 10 items)
-* - Undo/redo stack management
-* - Overflow queue (preserves oldest items)
-* - Automatic reindexing after operations
-* - Perfect for command pattern, history tracking
-*
-* Extends useRegistry with temporal navigation capabilities.
-*/
-/**
-* Creates a new timeline instance.
-*
-* @param _options The options for the timeline instance.
-* @template Z The type of the timeline ticket.
-* @template E The type of the timeline context.
-* @returns A new timeline instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-timeline
-*
-* @example
-* ```ts
-* import { useTimeline } from '@vuetify/v0'
-*
-* const timeline = useTimeline({ size: 3 })
-*
-* timeline.onboard([{ id: 'one' }, { id: 'two' }, { id: 'three' }])
-*
-* console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }, { id: 'three' }]
-*
-* timeline.undo()
-* console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }]
-*
-* timeline.redo()
-* console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }, { id: 'three' }]
-* ```
-*/
-function createTimeline(_options = {}) {
-	const { size = 10,...options } = _options;
-	const registry = useRegistry(options);
-	const stack = [];
-	const overflow = [];
-	function register(item) {
-		stack.length = 0;
-		if (registry.size < size) return registry.register({ ...item });
-		const removing = registry.seek("first");
-		if (overflow.length === size) overflow.shift();
-		overflow.push(removing);
-		registry.unregister(removing.id);
-		const ticket = registry.register({ ...item });
-		registry.reindex();
-		return ticket;
-	}
-	function undo() {
-		const item = registry.seek("last");
-		if (!item) return void 0;
-		stack.push(item);
-		registry.unregister(item.id);
-		const restored = overflow.pop();
-		if (restored) {
-			const remaining = registry.values();
-			registry.clear();
-			registry.onboard([restored, ...remaining]);
-			registry.reindex();
-		}
-		return item;
-	}
-	function redo() {
-		if (stack.length === 0) return void 0;
-		const item = stack.pop();
-		const ticket = registry.register(item);
-		registry.reindex();
-		return ticket;
-	}
-	return {
-		...registry,
-		register,
-		undo,
-		redo,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new timeline plugin.
-*
-* @param namespace The namespace for the timeline plugin.
-* @param options The options for the timeline plugin.
-* @template Z The type of the timeline ticket.
-* @template E The type of the timeline context.
-* @returns A new timeline plugin.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-timeline
-*
-* @example
-* ```ts
-* import { createTimelineContext } from '@vuetify/v0'
-*
-* export const [useTimeline, provideTimeline, context] = createTimelineContext('v0:timeline', { size: 5 })
-* context.register({ id: 'example' })
-*
-* // In a parent component
-* provideTimeline()
-*
-* // In a child component
-* const timeline = useTimeline()
-*
-* console.log(timeline.values()) // [{ id: 'example' }]
-* ```
-*/
-function createTimelineContext(_options) {
-	const { namespace,...options } = _options;
-	const [useTimelineContext, _provideTimelineContext] = createContext(namespace);
-	const context = createTimeline(options);
-	function provideTimelineContext(_context = context, app) {
-		return _provideTimelineContext(_context, app);
-	}
-	return createTrinity(useTimelineContext, provideTimelineContext, context);
-}
-/**
-* Returns the current timeline instance.
-*
-* @param namespace The namespace for the timeline context. Defaults to `'v0:timeline'`.
-* @returns The current timeline instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-timeline
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useTimeline } from '@vuetify/v0'
-*
-*   const timeline = useTimeline()
-* <\/script>
-* ```
-*/
-function useTimeline(namespace = "v0:timeline") {
-	return useContext(namespace);
-}
-
-//#endregion
-export { useTokens as $, PermissionAdapter as A, createContext as At, useKeydown as B, useQueue as C, createHydrationContext as Ct, createPermissionsContext as D, toArray as Dt, createPermissions as E, toReactive as Et, useLocale as F, useForm as G, useIntersectionObserver as H, Vuetify0LocaleAdapter as I, createFeaturesContext as J, useFilter as K, createSingle as L, createLocale as M, useContext as Mt, createLocaleContext as N, createPermissionsPlugin as O, createTrinity as Ot, createLocalePlugin as P, createTokensContext as Q, createSingleContext as R, createQueueContext as S, createHydration as St, useProxyModel as T, useHydration as Tt, createForm as U, useElementIntersection as V, createFormContext as W, useFeatures as X, createFeaturesPlugin as Y, createTokens as Z, createStepContext as _, useWindowEventListener as _t, createThemeContext as a, useSelection as at, useResizeObserver as b, createBreakpointsPlugin as bt, Vuetify0ThemeAdapter as c, createLogger as ct, createStoragePlugin as d, useLogger as dt, createGroup as et, provideStorageContext as f, Vuetify0LoggerAdapter as ft, createStep as g, useEventListener as gt, MemoryAdapter as h, useDocumentEventListener as ht, createTheme as i, createSelectionContext as it, useMutationObserver as j, provideContext as jt, usePermissions as k, createPlugin as kt, createStorage as l, createLoggerContext as lt, useStorageContext as m, ConsolaLoggerAdapter as mt, createTimelineContext as n, useGroup as nt, createThemePlugin as o, createRegistryContext as ot, useStorage as p, PinoLoggerAdapter as pt, createFeatures as q, useTimeline as r, createSelection as rt, useTheme as s, useRegistry as st, createTimeline as t, createGroupContext as tt, createStorageContext as u, createLoggerPlugin as ut, useStep as v, createBreakpoints as vt, useProxyRegistry as w, createHydrationPlugin as wt, createQueue as x, useBreakpoints as xt, useElementSize as y, createBreakpointsContext as yt, useSingle as z };