@vuetify/v0 0.0.2 → 0.0.6

package/dist/composables-CAbYjAkR.js

@@ -0,0 +1,3746 @@
+import { a as isNullOrUndefined, d as mergeDeep, i as isFunction, l as isString, n as isArray, r as isBoolean, s as isObject, t as genId, u as isUndefined } from "./utilities-rsKHgU2m.js";
+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-CHVv7nNV.js";
+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
+/**
+* Injects a context provided by an ancestor component.
+*
+* @param key The key of the context to inject.
+* @template Z The type of the context.
+* @returns The injected context.
+* @throws An error if the context is not found.
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*
+* @example
+* ```ts
+* const myContext = useContext<MyContext>('my-context')
+* ```
+*/
+function useContext(key) {
+	const context = inject(key, void 0);
+	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 The Vue app instance to provide the context to.
+* @template Z The type of the context.
+* @returns The provided context.
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*
+* @example
+* ```ts
+* provideContext<MyContext>('my-context', myContext)
+* ```
+*/
+function provideContext(key, context, app) {
+	app?.provide(key, context) ?? provide(key, context);
+	return context;
+}
+/**
+* Creates a new context for providing and injecting data.
+*
+* @param key The key of the context to create.
+* @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
+*
+* @example
+* ```ts
+* const [provideMyContext, useMyContext] = createContext<MyContext>('my-context')
+* ```
+*/
+function createContext(_key) {
+	function _provideContext(context, app) {
+		return provideContext(_key, context, app);
+	}
+	function _useContext(key = _key) {
+		return useContext(key);
+	}
+	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://vuejs.org/guide/reusability/plugins.html
+* @see https://0.vuetifyjs.com/composables/foundation/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 createContext The function that creates the context.
+* @param provideContext The function that provides the context.
+* @param context The context to provide.
+* @template Z The type of the context.
+* @returns A new trinity.
+*
+* @see https://0.vuetifyjs.com/composables/foundation/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(createContext$1, provideContext$1, context) {
+	return [
+		createContext$1,
+		(_context = context, app) => provideContext$1(_context, app),
+		context
+	];
+}
+
+//#endregion
+//#region src/composables/toArray/index.ts
+/**
+* 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
+/**
+* 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://vuejs.org/api/reactivity-utilities.html#toreactive
+*
+* @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
+const [useHydrationContext, provideHydrationContext] = createContext("v0:hydration");
+/**
+* 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 [useHydration, provideHydration] = createHydration()
+* ```
+*/
+function createHydration() {
+	const isHydrated = shallowRef(false);
+	function hydrate() {
+		isHydrated.value = true;
+	}
+	return {
+		isHydrated: shallowReadonly(isHydrated),
+		hydrate
+	};
+}
+/**
+* Returns the current hydration instance.
+*
+* @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() {
+	return useHydrationContext();
+}
+/**
+* Creates a new hydration plugin.
+*
+* @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 plugin = createHydrationPlugin()
+*
+* const app = createApp(App)
+*
+* app.use(plugin)
+*
+* app.mount('#app')
+* ```
+*/
+function createHydrationPlugin() {
+	const context = createHydration();
+	return createPlugin({
+		namespace: "v0:hydration",
+		provide: (app) => {
+			provideHydrationContext(context, app);
+		},
+		setup: (app) => {
+			app.mixin({ mounted() {
+				if (this.$parent !== null) return;
+				context.hydrate();
+			} });
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useBreakpoints/index.ts
+/**
+* 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 namespace The namespace to use for the 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('v0:breakpoints', {
+*   mobileBreakpoint: 'sm',
+*   breakpoints: {
+*     xs: 0,
+*     sm: 680,
+*     md: 1024,
+*     lg: 1280,
+*     xl: 1920,
+*     xxl: 2560,
+*   },
+* })
+* ```
+*/
+function createBreakpoints(namespace = "v0:breakpoints", options = {}) {
+	const [useBreakpointsContext, _provideBreakpointsContext] = createContext(namespace);
+	const { mobileBreakpoint, breakpoints } = /* @__PURE__ */ mergeDeep(createDefaultBreakpoints(), options);
+	const sorted = Object.entries(breakpoints).sort((a, b) => a[1] - b[1]);
+	const names = sorted.map(([n]) => n);
+	const mb = typeof mobileBreakpoint === "number" ? mobileBreakpoint : breakpoints[mobileBreakpoint] ?? breakpoints.md;
+	const 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;
+	}
+	if (getCurrentInstance()) onMounted(() => {
+		const { isHydrated } = useHydration();
+		if (isHydrated.value) update();
+		watch(isHydrated, (hydrated) => {
+			if (hydrated) update();
+		}, { immediate: true });
+	});
+	if (IN_BROWSER) {
+		function listener() {
+			update();
+		}
+		window.addEventListener("resize", listener, { passive: true });
+		onScopeDispose(() => window.removeEventListener("resize", listener), true);
+	}
+	const context = {
+		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
+	};
+	function provideBreakpointsContext(_context = context, app) {
+		return _provideBreakpointsContext(_context, app);
+	}
+	return createTrinity(useBreakpointsContext, provideBreakpointsContext, context);
+}
+/**
+* Returns the current breakpoints instance.
+*
+* @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() {
+	return useContext("v0:breakpoints");
+}
+/**
+* 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({
+*     mobileBreakpoint: 'sm',
+*     breakpoints: {
+*       xs: 0,
+*       sm: 680,
+*       md: 1024,
+*       lg: 1280,
+*       xl: 1920,
+*       xxl: 2560,
+*     },
+*   })
+* )
+*
+* app.mount('#app')
+* ```
+*/
+function createBreakpointsPlugin(options = {}) {
+	const [, provideBreakpointsContext, context] = createBreakpoints("v0:breakpoints", options);
+	return createPlugin({
+		namespace: "v0:breakpoints",
+		provide: (app) => {
+			provideBreakpointsContext(context, app);
+		},
+		setup: (app) => {
+			app.mixin({ mounted() {
+				context.update();
+			} });
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useEventListener/index.ts
+/**
+* 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 && typeof args[0] === "object" && args[0] !== null) return {
+			...args[0],
+			msg: message
+		};
+		return {
+			msg: message,
+			args
+		};
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/adapters/v0.ts
+/**
+* Vuetify0.x logger adapter implementation
+*
+* This adapter provides console-based logging with proper formatting,
+* color coding, timestamps, and log level filtering for development
+* and production environments.
+*/
+var Vuetify0LoggerAdapter = class {
+	prefix;
+	colors;
+	timestamps;
+	constructor(options = {}) {
+		this.prefix = options.prefix || "v0";
+		this.colors = options.colors !== false;
+		this.timestamps = options.timestamps !== false;
+	}
+	debug(message, ...args) {
+		this.log("debug", "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log("info", "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log("warn", "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log("error", "error", message, ...args);
+	}
+	trace(message, ...args) {
+		this.log("trace", "trace", message, ...args);
+	}
+	fatal(message, ...args) {
+		this.log("fatal", "error", message, ...args);
+	}
+	format(level, message, ...args) {
+		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 && typeof console[method] === "function") console[method](`%c${formattedMessage}`, style, ...restArgs);
+		else if (typeof console[method] === "function") console[method](formattedMessage, ...restArgs);
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/index.ts
+const [useLoggerContext, provideLoggerContext] = createContext("v0:logger");
+/**
+* Creates a 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
+*/
+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: () => {}
+	};
+}
+/**
+* Uses an existing or creates a new logger instance.
+*
+* @param namespace The namespace for the logger context.
+* @returns The logger instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*/
+function useLogger(namespace) {
+	if (getCurrentInstance()) try {
+		return useLoggerContext(namespace);
+	} catch (error) {
+		if (process.env.NODE_ENV !== "production" && IN_BROWSER && namespace) console.warn(error);
+	}
+	return createFallbackLogger(namespace);
+}
+/**
+* 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
+*/
+function createLoggerPlugin(options = {}) {
+	const context = createLogger(options);
+	return createPlugin({
+		namespace: "v0:logger",
+		provide: (app) => {
+			provideLoggerContext(context, app);
+		},
+		setup: (_app) => {
+			if (process.env.NODE_ENV !== "production" && IN_BROWSER) window.__v0Logger__ = context;
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useRegistry/index.ts
+/**
+* Creates a 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
+*
+* @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 (cached != void 0) return cached;
+		const values$1 = Array.from(collection.values());
+		cache.set("values", values$1);
+		return values$1;
+	}
+	function entries() {
+		const cached = cache.get("entries");
+		if (cached != void 0) return cached;
+		const entries$1 = Array.from(collection.entries());
+		cache.set("entries", entries$1);
+		return entries$1;
+	}
+	function clear() {
+		if (collection.size > 0) collection.clear();
+		if (catalog.size > 0) catalog.clear();
+		if (directory.size > 0) directory.clear();
+		invalidate();
+		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();
+		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++;
+		}
+		invalidate();
+	}
+	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 index = registration.index ?? size;
+		const value = registration.value === void 0 ? index : registration.value;
+		const valueIsIndex = registration.value === void 0;
+		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.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-registry
+*
+* @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(namespace, options) {
+	const [useRegistryContext, _provideRegistryContext] = createContext(namespace);
+	const context = useRegistry(options);
+	function provideRegistryContext(_context = context, app) {
+		return _provideRegistryContext(_context, app);
+	}
+	return createTrinity(useRegistryContext, provideRegistryContext, context);
+}
+
+//#endregion
+//#region src/composables/useSelection/index.ts
+/**
+* Creates a new selection instance.
+*
+* @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.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-selection
+*
+* @example
+* ```ts
+* import { useSelection } from '@vuetify/v0'
+*
+* const selection = useSelection({ 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' }
+* ```
+*/
+function useSelection(options) {
+	const registry = useRegistry(options);
+	const selectedIds = shallowReactive(/* @__PURE__ */ new Set());
+	const enroll = options?.enroll ?? false;
+	const mandatory = options?.mandatory ?? false;
+	const selectedItems = computed(() => {
+		return new Set(Array.from(selectedIds).map((id) => registry.get(id)));
+	});
+	const selectedValues = computed(() => {
+		return new Set(Array.from(selectedItems.value).map((item) => item?.value));
+	});
+	function seek(direction = "first", from) {
+		return registry.seek(direction, from, (ticket) => !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 || item.disabled) return;
+		selectedIds.add(id);
+	}
+	function unselect(id) {
+		if (mandatory && selectedIds.size === 1) return;
+		selectedIds.delete(id);
+	}
+	function toggle(id) {
+		if (selectedIds.has(id)) unselect(id);
+		else select(id);
+	}
+	function selected(id) {
+		return selectedIds.has(id);
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ genId();
+		const item = {
+			disabled: false,
+			...registration,
+			id,
+			isSelected: toRef(() => selectedIds.has(id)),
+			select: () => select(id),
+			unselect: () => unselect(id),
+			toggle: () => toggle(id)
+		};
+		const ticket = registry.register(item);
+		if (enroll && !item.disabled) selectedIds.add(ticket.id);
+		if (mandatory === "force") mandate();
+		return ticket;
+	}
+	function unregister(id) {
+		selectedIds.delete(id);
+		registry.unregister(id);
+	}
+	function reset() {
+		registry.clear();
+		selectedIds.clear();
+		mandate();
+	}
+	return {
+		...registry,
+		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(namespace, options) {
+	const [useSelectionContext, _provideSelectionContext] = createContext(namespace);
+	const context = useSelection(options);
+	function provideSelectionContext(_context = context, app) {
+		return _provideSelectionContext(_context, app);
+	}
+	return createTrinity(useSelectionContext, provideSelectionContext, context);
+}
+
+//#endregion
+//#region src/composables/useGroup/index.ts
+/**
+* Creates a new group instance.
+*
+* @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.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-group
+*
+* @example
+* ```ts
+* import { useGroup } from '@vuetify/v0'
+*
+* const group = useGroup()
+*
+* group.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2' },
+*   { id: 'item-3', value: 'Item 3' },
+* ])
+*
+* group.select(['item-1', 'item-2'])
+*
+* console.log(group.selectedIds) // Set { 'item-1', 'item-2' }
+* ```
+*/
+function useGroup(options) {
+	const registry = useSelection(options);
+	const selectedIndexes = computed(() => {
+		return new Set(Array.from(registry.selectedItems.value).map((item) => item?.index));
+	});
+	function select(ids) {
+		for (const id of toArray(ids)) registry.select(id);
+	}
+	function unselect(ids) {
+		for (const id of toArray(ids)) registry.unselect(id);
+	}
+	function toggle(ids) {
+		for (const id of toArray(ids)) registry.toggle(id);
+	}
+	return {
+		...registry,
+		select,
+		unselect,
+		toggle,
+		selectedIndexes,
+		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(namespace, options) {
+	const [useGroupContext, _provideGroupContext] = createContext(namespace);
+	const context = useGroup(options);
+	function provideGroupContext(_context = context, app) {
+		return _provideGroupContext(_context, app);
+	}
+	return createTrinity(useGroupContext, provideGroupContext, context);
+}
+
+//#endregion
+//#region src/composables/useTokens/index.ts
+/**
+* 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 useTokens(tokens = {}, options = {}) {
+	const logger = useLogger();
+	const registry = useRegistry();
+	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) {
+		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);
+		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);
+			result = inner;
+		} else if (/* @__PURE__ */ isString(current) && isAlias(current)) return resolve(current);
+		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'
+*
+* const myTokens = {
+*   spacing: {
+*     sm: '8px',
+*     md: '16px',
+*     lg: '24px',
+*   },
+* }
+*
+* export const [useDesignTokens, provideDesignTokens, designTokens] = createTokensContext('design-tokens', myTokens)
+*
+* // In a parent component:
+* provideDesignTokens()
+*
+* // In a child component:
+* const tokens = useDesignTokens()
+*
+* console.log(tokens.resolve('{spacing.md}')) // '16px'
+* ```
+*/
+function createTokensContext(namespace, tokens = {}) {
+	const [useTokensContext, _provideTokensContext] = createContext(namespace);
+	const context = useTokens(tokens);
+	function provideTokensContext(_context = context, app) {
+		return _provideTokensContext(_context, app);
+	}
+	return createTrinity(useTokensContext, provideTokensContext, context);
+}
+/**
+* Flattens a nested collection of tokens into a flat array of tokens.
+* Each token is represented by an object containing its ID & value.
+* @param tokens The collection of tokens to flatten.
+* @param prefix An optional prefix to prepend to each token ID.
+* @returns An array of flattened tokens, each with an ID and value.
+*/
+function flatten(tokens, prefix = "", 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
+/**
+* Creates a new features instance.
+*
+* @param namespace The namespace to use for the 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/create-features
+*
+* @example
+* ```ts
+* import { createFeatures } from '@vuetify/v0'
+*
+* const [useFeatures, provideFeaturesContext] = createFeatures('v0:features', {
+*   features: {
+*     'dark-mode': true,
+*     'theme-color': { $variation: 'blue' },
+*   },
+* })
+* ```
+*/
+function createFeatures(namespace = "v0:features", options = {}) {
+	const [useFeaturesContext, _provideFeaturesContext] = createContext(namespace);
+	const tokens = useTokens(options.features, { flat: true });
+	const registry = useGroup();
+	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;
+	}
+	const context = {
+		...registry,
+		variation,
+		register,
+		get size() {
+			return registry.size;
+		}
+	};
+	function provideFeaturesContext(_context = context, app) {
+		return _provideFeaturesContext(_context, app);
+	}
+	return createTrinity(useFeaturesContext, provideFeaturesContext, context);
+}
+/**
+* Returns the current features instance.
+*
+* @template Z The type of the feature ticket.
+* @returns The current features instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/create-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() {
+	return useContext("v0:features");
+}
+/**
+* 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/create-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 [, provideFeaturesContext, context] = createFeatures("v0:features", options);
+	return createPlugin({
+		namespace: "v0:features",
+		provide: (app) => {
+			provideFeaturesContext(context, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useFilter/index.ts
+function defaultFilter(query, item, keys, mode = "some") {
+	const queries = Array.isArray(query) ? query.map((q) => String(q).toLowerCase()) : [String(query).toLowerCase()];
+	function match(value, q) {
+		return String(value).toLowerCase().includes(q);
+	}
+	const stringValues = (typeof item === "object" && item !== null ? 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
+/**
+* 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 { useForm } from '@vuetify/v0'
+*
+* const form = useForm()
+*
+* 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 useForm(options) {
+	const registry = useRegistry(options);
+	const validateOn = options?.validateOn || "submit";
+	function parse(value) {
+		return value.toLowerCase().split(/\s+/);
+	}
+	function validatesOn(event) {
+		return parse(validateOn).includes(event);
+	}
+	const isValidating = computed(() => {
+		for (const ticket of registry.collection.values()) if (ticket.isValidating.value) return true;
+		return false;
+	});
+	const isValid = computed(() => {
+		let hasFields = false;
+		for (const ticket of registry.values()) {
+			hasFields = true;
+			if (ticket.isValid.value === false) return false;
+			if (ticket.isValid.value === null) return null;
+		}
+		return hasFields ? true : null;
+	});
+	function reset() {
+		for (const ticket of registry.values()) ticket.reset();
+	}
+	async function submit() {
+		return validate(registry.keys());
+	}
+	async function validate(id) {
+		const validating = toArray(id);
+		if (validatesOn("submit")) 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 true;
+			isValidating$1.value = true;
+			try {
+				const errorMessages = (await Promise.all(rules.map((rule) => rule(model.value)))).filter((result) => typeof result === "string");
+				if (!silent) {
+					errors.value = errorMessages;
+					isValid$1.value = errorMessages.length === 0;
+					isPristine.value = toValue(model) === initialValue;
+				}
+				return errorMessages.length === 0;
+			} finally {
+				isValidating$1.value = false;
+			}
+		}
+		const item = {
+			...registration,
+			rules,
+			errors,
+			disabled: registration.disabled || false,
+			validateOn: triggers,
+			isValidating: isValidating$1,
+			isPristine,
+			isValid: isValid$1,
+			reset: _reset,
+			validate: validate$1
+		};
+		const ticket = registry.register(item);
+		Object.defineProperty(ticket, "value", {
+			get() {
+				return model.value;
+			},
+			set(val) {
+				model.value = val;
+				isPristine.value = val === initialValue;
+				isValid$1.value = null;
+				if (_validatesOn("change")) validate$1();
+			},
+			enumerable: true,
+			configurable: true
+		});
+		return ticket;
+	}
+	return {
+		...registry,
+		register,
+		reset,
+		submit,
+		validateOn,
+		isValid,
+		isValidating,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+
+//#endregion
+//#region src/composables/useIntersectionObserver/index.ts
+/**
+* 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
+/**
+* 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
+/**
+* Creates a new single selection instance.
+*
+* @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.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-single
+*
+* @example
+* ```ts
+* import { useSingle } from '@vuetify/v0'
+*
+* const single = useSingle()
+*
+* single.onboard([
+*   { id: 'option-1', value: 'Option 1' },
+*   { id: 'option-2', value: 'Option 2' },
+* ])
+*
+* single.select('option-1')
+*
+* console.log(single.selectedId.value) // 'option-1'
+* ```
+*/
+function useSingle(options) {
+	const registry = useSelection(options);
+	const mandatory = options?.mandatory ?? false;
+	const selectedId = computed(() => registry.selectedIds.values().next().value);
+	const selectedItem = computed(() => registry.selectedItems.value.values().next().value);
+	const selectedIndex = computed(() => selectedItem.value?.index ?? -1);
+	const selectedValue = computed(() => selectedItem.value?.value);
+	function select(id) {
+		const item = registry.get(id);
+		if (!item || item.disabled) return;
+		registry.selectedIds.clear();
+		registry.select(id);
+	}
+	function unselect(id) {
+		if (mandatory && registry.selectedIds.size === 1) return;
+		registry.selectedIds.delete(id);
+	}
+	function toggle(id) {
+		if (registry.selectedIds.has(id)) unselect(id);
+		else select(id);
+	}
+	return {
+		...registry,
+		selectedId,
+		selectedItem,
+		selectedIndex,
+		selectedValue,
+		select,
+		unselect,
+		toggle,
+		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(namespace, options) {
+	const [useSingleContext, _provideSingleContext] = createContext(namespace);
+	const context = useSingle(options);
+	function provideSingleContext(_context = context, app) {
+		return _provideSingleContext(_context, app);
+	}
+	return createTrinity(useSingleContext, provideSingleContext, context);
+}
+
+//#endregion
+//#region src/composables/useLocale/adapters/v0.ts
+/**
+* Vuetify0.x locale adapter implementation
+*
+* This adapter provides translation and number formatting
+* capabilities using the Intl API and supports both
+* numbered and named variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && typeof params[0] === "object" && params[0] !== null && !Array.isArray(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return variables[name] === void 0 ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (params[idx] !== void 0) return String(params[idx]);
+			return match;
+		});
+		return resolvedMessage;
+	}
+	n(value, locale, ...params) {
+		if (!IN_BROWSER || !locale) return value.toString();
+		const options = params[0];
+		return new Intl.NumberFormat(String(locale), options).format(value);
+	}
+};
+
+//#endregion
+//#region src/composables/useLocale/index.ts
+/**
+* Creates a new locale instance.
+*
+* @param namespace The namespace for the 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(namespace = "v0:locale", options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [useLocaleContext, _provideLocaleContext] = createContext(namespace);
+	const registry = useSingle();
+	for (const id in messages) {
+		registry.register({
+			value: messages[id],
+			id
+		});
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	function t(key, ...params) {
+		const locale = registry.selectedId.value;
+		if (!locale) return key;
+		const message = messages[locale]?.[key];
+		const template = typeof message === "string" ? resolve(locale, message) : key;
+		return adapter.t(template, ...params);
+	}
+	function n(value, ...params) {
+		return adapter.n(value, registry.selectedId.value, ...params);
+	}
+	function resolve(locale, str) {
+		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, linkedKey) => {
+			const [linkedLocale, ...rest] = linkedKey.split(".");
+			const keyPath = rest.join(".");
+			const targetLocale = messages[linkedLocale] ? linkedLocale : locale;
+			const targetKey = messages[linkedLocale] ? keyPath : linkedKey;
+			const resolved = messages[targetLocale]?.[targetKey];
+			return typeof resolved === "string" ? resolve(targetLocale, resolved) : match;
+		});
+	}
+	const context = {
+		...registry,
+		t,
+		n,
+		get size() {
+			return registry.size;
+		}
+	};
+	function provideLocaleContext(_context = context, app) {
+		return _provideLocaleContext(_context, app);
+	}
+	return createTrinity(useLocaleContext, provideLocaleContext, context);
+}
+/**
+* Returns the current locale instance.
+*
+* @returns The current locale instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-locale
+*/
+function useLocale() {
+	return useContext("v0:locale");
+}
+/**
+* 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 { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [, provideLocaleTokenContext, tokensContext] = createTokensContext("v0:locale:tokens", messages);
+	const [, provideLocaleContext, localeContext] = createLocale("v0:locale", {
+		adapter,
+		messages
+	});
+	return createPlugin({
+		namespace: "v0:locale",
+		provide: (app) => {
+			provideLocaleContext(localeContext, app);
+			provideLocaleTokenContext(tokensContext, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useMutationObserver/index.ts
+/**
+* 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
+/**
+* Creates a new permissions instance.
+*
+* @param namespace The namespace for the 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/create-permissions
+*
+* @example
+* ```ts
+* import { createPermissions } from '@vuetify/v0'
+*
+* const [usePermissions, providePermissions] = createPermissions('v0:permissions', {
+*   permissions: {
+*     admin: [['read', 'users']],
+*     editor: [['edit', 'posts']],
+*   },
+* })
+* ```
+*/
+function createPermissions(namespace = "v0:permissions", options = {}) {
+	const { adapter = new Vuetify0PermissionAdapter(), permissions = {} } = options;
+	const [usePermissionsContext, _providePermissionsContext] = createContext(namespace);
+	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 = useTokens(record);
+	function can(id, action, subject, context$1 = {}) {
+		return adapter.can(id, action, subject, context$1, tokens);
+	}
+	const context = {
+		...tokens,
+		can
+	};
+	function providePermissionsContext(_context = context, app) {
+		return _providePermissionsContext(_context, app);
+	}
+	return createTrinity(usePermissionsContext, providePermissionsContext, context);
+}
+/**
+* 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() {
+	return useContext("v0:permissions");
+}
+/**
+* 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 [, providePermissionContext, context] = createPermissions("v0:permissions", options);
+	return createPlugin({
+		namespace: "v0:permissions",
+		provide: (app) => {
+			providePermissionContext(context, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* Creates a proxy model that can be used to bind to a selection.
+*
+* @param registry The selection registry to bind to.
+* @param initial The initial value of the model.
+* @param options The options for the proxy model.
+* @param transformIn A function to transform the value before setting it.
+* @param transformOut A function to transform the value before getting it.
+* @template Z The type of the selection ticket.
+* @returns A proxy model that can be used to bind to a selection.
+*
+* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
+*
+* @example
+* ```ts
+* import { useSelection, useProxyModel } from '@vuetify/v0'
+*
+* const registry = useSelection({ events: true })
+* registry.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2' },
+* ])
+*
+* const model = useProxyModel(registry, 'Item 1')
+* ```
+*/
+function useProxyModel(registry, initial, options, _transformIn, _transformOut) {
+	const internal = (options?.deep ? ref : shallowRef)(initial ? toArray(initial) : []);
+	const isModelArray = /* @__PURE__ */ isArray(initial);
+	function transformIn(val) {
+		return /* @__PURE__ */ isFunction(_transformIn) ? _transformIn(val) : toArray(val);
+	}
+	function transformOut(val) {
+		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
+		return isModelArray ? val : val[0];
+	}
+	const model = computed({
+		get() {
+			return transformOut(internal.value);
+		},
+		set(val) {
+			internal.value = transformIn(val);
+		}
+	});
+	const registryWatcher = watch(registry.selectedValues, (val) => {
+		modelWatcher.pause();
+		model.value = Array.from(toValue(val));
+		modelWatcher.resume();
+	});
+	const modelWatcher = watch(model, (val) => {
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of toArray(val)) {
+			const ids = registry.browse(value);
+			if (/* @__PURE__ */ isArray(ids)) for (const single of ids) targetIds.add(single);
+			else if (ids) targetIds.add(ids);
+		}
+		registryWatcher.pause();
+		if (isModelArray) {
+			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
+			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
+		} else {
+			const next = targetIds.values().next().value;
+			const last = currentIds.values().next().value;
+			if (last !== void 0) registry.unselect(last);
+			if (next !== void 0) registry.select(next);
+		}
+		registryWatcher.resume();
+	});
+	function onRegister(ticket) {
+		if (!internal.value.includes(ticket.value)) return;
+		registryWatcher.pause();
+		modelWatcher.pause();
+		registry.select(ticket.id);
+		registryWatcher.resume();
+		modelWatcher.resume();
+	}
+	function onUnregister(ticket) {
+		if (!internal.value.includes(ticket.value)) return;
+		registryWatcher.pause();
+		modelWatcher.pause();
+		registry.unselect(ticket.id);
+		registryWatcher.resume();
+		modelWatcher.resume();
+	}
+	function onUpdate(ticket) {
+		const hasValue = internal.value.includes(ticket.value);
+		const isSelected = toValue(registry.selectedIds).has(ticket.id);
+		if (!hasValue && isSelected) onUnregister(ticket);
+		else if (hasValue && !isSelected) onRegister(ticket);
+	}
+	function onClear() {
+		registryWatcher.pause();
+		modelWatcher.pause();
+		registry.selectedIds.clear();
+		registryWatcher.resume();
+		modelWatcher.resume();
+	}
+	registry.on("register:ticket", onRegister);
+	registry.on("unregister:ticket", onUnregister);
+	registry.on("update:ticket", onUpdate);
+	registry.on("clear:registry", onClear);
+	onScopeDispose(() => {
+		registryWatcher();
+		modelWatcher();
+		registry.off("register:item", onRegister);
+		registry.off("unregister:ticket", onUnregister);
+		registry.off("update:ticket", onUpdate);
+		registry.off("clear:registry", onClear);
+	}, true);
+	return model;
+}
+
+//#endregion
+//#region src/composables/useProxyRegistry/index.ts
+/**
+* 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:item", 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
+/**
+* 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 useQueue(_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;
+		}
+	};
+}
+
+//#endregion
+//#region src/composables/useResizeObserver/index.ts
+/**
+* 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
+/**
+* Creates a new step instance.
+*
+* @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.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-step
+*
+* @example
+* ```ts
+* import { useStep } from '@vuetify/v0'
+*
+* const stepper = useStep()
+*
+* stepper.onboard([
+*   { id: 'step-1', value: 'Account Info' },
+*   { id: 'step-2', value: 'Payment' },
+*   { id: 'step-3', value: 'Confirmation' },
+* ])
+*
+* stepper.first()
+* stepper.next() // Move to step-2
+*
+* console.log(stepper.selectedIndex.value) // 1
+* ```
+*/
+function useStep(options) {
+	const registry = useSingle(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 direction = Math.sign(count || 1);
+		let hops = 0;
+		let index = wrapped(length, registry.selectedIndex.value + count);
+		let id = registry.lookup(index);
+		while (id !== void 0 && registry.get(id)?.disabled && hops < length) {
+			index = wrapped(length, index + direction);
+			id = registry.lookup(index);
+			hops++;
+		}
+		if (id === void 0 || hops === length) return;
+		registry.selectedIds.clear();
+		registry.select(id);
+	}
+	return {
+		...registry,
+		first,
+		last,
+		next,
+		prev,
+		step,
+		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(namespace, options) {
+	const [useStepContext, _provideStepContext] = createContext(namespace);
+	const context = useStep(options);
+	function provideStepContext(_context = context, app) {
+		return _provideStepContext(_context, app);
+	}
+	return createTrinity(useStepContext, provideStepContext, context);
+}
+
+//#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
+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
+	};
+}
+/**
+* Returns the current storage instance.
+*
+* @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() {
+	return useStorageContext();
+}
+/**
+* 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 context = createStorage(options);
+	return createPlugin({
+		namespace: "v0:storage",
+		provide: (app) => {
+			provideStorageContext(context, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useTheme/adapters/adapter.ts
+var ThemeAdapter = class {
+	stylesheetId = "v0-theme-stylesheet";
+	prefix;
+	constructor(prefix) {
+		this.prefix = prefix;
+	}
+	generate(colors) {
+		let css = "";
+		for (const theme in colors) {
+			const themeColors = colors[theme];
+			if (!themeColors) continue;
+			const vars = Object.entries(themeColors).map(([key, val]) => `  --${this.prefix}-${key}: ${val};`).join("\n");
+			css += `.${this.prefix}-theme--${theme} {\n${vars}\n}\n`;
+		}
+		return css;
+	}
+};
+
+//#endregion
+//#region src/composables/useTheme/adapters/v0.ts
+/**
+* Theme adapter implementation for Vuetify v0 design system.
+* This adapter generates CSS custom properties and injects them into the DOM
+* as a stylesheet, allowing themes to be applied globally.
+*/
+var Vuetify0ThemeAdapter = class extends ThemeAdapter {
+	cspNonce;
+	constructor(options = {}) {
+		super(options.prefix ?? "v0");
+		this.cspNonce = options.cspNonce;
+		this.stylesheetId = options.stylesheetId ?? this.stylesheetId;
+	}
+	update(colors) {
+		if (!IN_BROWSER) return;
+		this.upsert(this.generate(colors));
+	}
+	upsert(styles) {
+		if (!IN_BROWSER) return;
+		let styleEl = document.querySelector(`#${this.stylesheetId}`);
+		if (!styleEl) {
+			styleEl = document.createElement("style");
+			styleEl.id = this.stylesheetId.startsWith("#") ? this.stylesheetId.slice(1) : this.stylesheetId;
+			if (this.cspNonce) styleEl.setAttribute("nonce", this.cspNonce);
+			document.head.append(styleEl);
+		}
+		styleEl.textContent = styles;
+	}
+};
+
+//#endregion
+//#region src/composables/useTheme/index.ts
+/**
+* Creates a new theme instance.
+*
+* @param namespace The namespace for the 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('v0:theme', {
+*   default: 'light',
+*   themes: {
+*     light: {
+*       dark: false,
+*       colors: {
+*         primary: '#3b82f6',
+*       },
+*     },
+*     dark: {
+*       dark: true,
+*       colors: {
+*         primary: '#675496',
+*       },
+*     },
+*   },
+* })
+* ```
+*/
+function createTheme(namespace = "v0:theme", options = {}) {
+	const { themes = {}, palette = {} } = options;
+	const [useThemeContext, _provideThemeContext] = createContext(namespace);
+	const tokens = useTokens({
+		palette,
+		...themes
+	}, { flat: true });
+	const registry = useSingle();
+	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;
+	});
+	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);
+	}
+	const context = {
+		...registry,
+		colors,
+		register,
+		cycle,
+		get size() {
+			return registry.size;
+		}
+	};
+	function provideThemeContext(_context = context, app) {
+		return _provideThemeContext(_context, app);
+	}
+	return createTrinity(useThemeContext, provideThemeContext, context);
+}
+/**
+* Returns the current theme instance.
+*
+* @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() {
+	return useContext("v0:theme");
+}
+/**
+* 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(), palette = {}, themes = {}, target,...options } = _options;
+	const [, provideThemeContext, themeContext] = createTheme("v0:theme", {
+		...options,
+		themes,
+		palette
+	});
+	return createPlugin({
+		namespace: "v0:theme",
+		provide: (app) => {
+			provideThemeContext(themeContext, app);
+		},
+		setup: (app) => {
+			if (IN_BROWSER) {
+				onScopeDispose(watch(themeContext.colors, (colors) => {
+					adapter.update(colors);
+				}, { immediate: true }), true);
+				if (target === null) return;
+				const targetEl = target instanceof HTMLElement ? target : typeof target === "string" ? document.querySelector(target) : app._container || document.querySelector("#app") || document.body;
+				if (!targetEl) return;
+				let prevClass = "";
+				onScopeDispose(watch(themeContext.selectedId, (id) => {
+					if (!id) return;
+					const themeClass = `${adapter.prefix}-theme--${id}`;
+					if (prevClass) targetEl.classList.remove(prevClass);
+					targetEl.classList.add(themeClass);
+					prevClass = themeClass;
+				}, { immediate: true }), true);
+			} else {
+				const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
+				if (head?.push) {
+					const id = themeContext.selectedId.value;
+					head.push({
+						htmlAttrs: { class: id ? `${adapter.prefix}-theme--${id}` : "" },
+						style: [{
+							innerHTML: adapter.generate(themeContext.colors.value),
+							id: adapter.stylesheetId
+						}]
+					});
+				}
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useTimeline/index.ts
+/**
+* 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 useTimeline(_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;
+		}
+	};
+}
+
+//#endregion
+export { useEventListener as $, useKeydown as A, createGroupContext as B, useMutationObserver as C, Vuetify0LocaleAdapter as D, useLocale as E, createFeatures as F, useRegistry as G, createSelectionContext as H, createFeaturesPlugin as I, useLogger as J, createLogger as K, useFeatures as L, useIntersectionObserver as M, useForm as N, createSingleContext as O, useFilter as P, useDocumentEventListener as Q, createTokensContext as R, PermissionAdapter as S, createLocalePlugin as T, useSelection as U, useGroup as V, createRegistryContext as W, PinoLoggerAdapter as X, Vuetify0LoggerAdapter as Y, ConsolaLoggerAdapter as Z, useProxyRegistry as _, Vuetify0ThemeAdapter as a, createHydrationPlugin as at, createPermissionsPlugin as b, provideStorageContext as c, useHydrationContext as ct, MemoryAdapter as d, createTrinity as dt, useWindowEventListener as et, createStepContext as f, createPlugin as ft, useQueue as g, useResizeObserver as h, useContext as ht, useTheme as i, createHydration as it, useElementIntersection as j, useSingle as k, useStorage as l, toReactive as lt, useElementSize as m, provideContext as mt, createTheme as n, createBreakpointsPlugin as nt, createStorage as o, provideHydrationContext as ot, useStep as p, createContext as pt, createLoggerPlugin as q, createThemePlugin as r, useBreakpoints as rt, createStoragePlugin as s, useHydration as st, useTimeline as t, createBreakpoints as tt, useStorageContext as u, toArray as ut, useProxyModel as v, createLocale as w, usePermissions as x, createPermissions as y, useTokens as z };