@vuetify/v0 0.0.14 → 0.0.16

package/dist/useStep-Bqhi_DDs.mjs

@@ -0,0 +1,3159 @@
+import { _ as range, d as isObject, h as isUndefined, i as isArray, l as isNullOrUndefined, m as isSymbol, o as isFunction, p as isString, r as genId, s as isNaN } from "./utilities-DQWf_4V_.mjs";
+import { a as SUPPORTS_OBSERVER, s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-Rnihe4SF.mjs";
+import { computed, getCurrentInstance, inject, isRef, onScopeDispose, provide, reactive, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, watch } from "vue";
+
+//#region src/composables/createContext/index.ts
+/**
+* @module createContext
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*
+* @remarks
+* Factory for creating type-safe Vue dependency injection contexts.
+*
+* Provides a wrapper around Vue's provide/inject that throws errors when context is not found,
+* eliminating silent failures and improving developer experience. Supports both app-level and
+* component-level provision.
+*
+* Supports two modes:
+* - **Static key**: `createContext('my-key')` - key is fixed at creation time
+* - **Dynamic key**: `createContext()` or `createContext({ suffix: 'item' })` - key provided at runtime
+*/
+/**
+* Injects a context provided by an ancestor component.
+*
+* @param key The key of the context to inject.
+* @param defaultValue Optional default value if context is not found.
+* @template Z The type of the context.
+* @returns The injected context.
+* @throws An error if the context is not found and no default is provided.
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+* @see https://0.vuetifyjs.com/composables/foundation/create-context#use-context
+*
+* @example
+* ```ts
+* // Without default value
+* const context = useContext<MyContext>('my-context')
+*
+* // With default value
+* const context = useContext<MyContext>('my-context', defaultContext)
+* ```
+*/
+function useContext(key, defaultValue) {
+	const context = inject(key, defaultValue);
+	if (/* @__PURE__ */ isUndefined(context)) throw new Error(`Context "${String(key)}" not found. Ensure it's provided by an ancestor.`);
+	return context;
+}
+/**
+* Provides a context to all descendant components.
+*
+* @param key The key of the context to provide.
+* @param context The context to provide.
+* @param app Optional Vue app instance to provide the context at app level instead of component level.
+* @template Z The type of the context.
+* @returns The provided context.
+*
+* @remarks
+* When `app` parameter is provided, the context is made available to all components in the app.
+* When omitted, the context is provided at the current component level and available to descendants only.
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+* @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
+*
+* @example
+* ```ts
+* // Component-level provision
+* provideContext<MyContext>('my-context', context)
+*
+* // App-level provision (typically used in plugins)
+* const app = createApp()
+* provideContext<MyContext>('my-context', context, app)
+* ```
+*/
+function provideContext(key, context, app) {
+	if (app) app.provide(key, context);
+	else provide(key, context);
+	return context;
+}
+function createContext(keyOrOptions, defaultValue) {
+	if (/* @__PURE__ */ isString(keyOrOptions) || /* @__PURE__ */ isSymbol(keyOrOptions)) {
+		const _key = keyOrOptions;
+		function _provideContext$1(context, app) {
+			return provideContext(_key, context, app);
+		}
+		function _useContext$1() {
+			return useContext(_key, defaultValue);
+		}
+		return [_useContext$1, _provideContext$1];
+	}
+	const suffix = /* @__PURE__ */ isObject(keyOrOptions) ? keyOrOptions.suffix : void 0;
+	function _provideContext(key, context, app) {
+		return provideContext(suffix ? `${key}:${suffix}` : key, context, app);
+	}
+	function _useContext(key, defaultValue$1) {
+		return useContext(suffix ? `${key}:${suffix}` : key, defaultValue$1);
+	}
+	return [_useContext, _provideContext];
+}
+
+//#endregion
+//#region src/composables/createTrinity/index.ts
+/**
+* Creates a new trinity for a context composable and its provider.
+*
+* @param useContext The function that retrieves/uses the context (typically named `useContext`).
+* @param provideContext The function that provides the context to descendants.
+* @param context The default context instance to use when no custom context is provided.
+* @template Z The type of the context.
+* @returns A readonly tuple containing: [useContext function, provideContext wrapper function, default context instance].
+*
+* @remarks The trinity pattern is a foundational pattern used throughout the codebase for creating reusable context systems. It provides three related elements:
+*
+* 1. A function to retrieve/use the context
+* 2. A function to provide the context (with default value support)
+* 3. The default context instance
+*
+* The returned tuple is readonly (using `as const`) to ensure proper type inference.
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-trinity#create-trinity
+*
+* @example
+* ```ts
+* interface MyContext {
+*   foo: string
+*   bar: number
+* }
+*
+* export function createMyFeature<E extends MyContext = MyContext>() {
+*   const [useContext, _provideContext] = createContext<E>('my-context')
+*
+*   const context = { foo: 'hello', bar: 42 }
+*
+*   function provideContext (_context: E = context, app?: App): E {
+*     return _provideContext(_context, app)
+*   }
+*
+*   return createTrinity<E>(useContext, provideContext, context)
+* }
+* ```
+*/
+function createTrinity(useContext$1, provideContext$1, context) {
+	return [
+		useContext$1,
+		(_context = context, app) => provideContext$1(_context, app),
+		context
+	];
+}
+
+//#endregion
+//#region src/composables/createPlugin/index.ts
+/**
+* Creates a new Vue plugin.
+*
+* @param options The plugin options.
+* @returns A new Vue plugin.
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-plugin#create-plugin
+*
+* @example
+* ```ts
+* export const [useContext, provideContext] = createContext<MyContext>('my-plugin')
+*
+* const context = {}
+*
+* export const MyPlugin = createPlugin({
+*   namespace: 'my-plugin',
+*   provide: (app) => {
+*     provideContext(context, app)
+*   },
+*   setup: (app) => {
+*     // Optional setup logic
+*   },
+* })
+*/
+function createPlugin(options) {
+	return { install(app) {
+		app.runWithContext(() => {
+			options.provide(app);
+			options.setup?.(app);
+		});
+	} };
+}
+
+//#endregion
+//#region src/composables/useLogger/adapters/consola.ts
+var ConsolaLoggerAdapter = class {
+	consola;
+	constructor(consolaInstance) {
+		if (!consolaInstance) throw new Error("Consola instance is required for ConsolaLoggerAdapter");
+		this.consola = consolaInstance;
+	}
+	debug(message, ...args) {
+		this.consola.debug(message, ...args);
+	}
+	info(message, ...args) {
+		this.consola.info(message, ...args);
+	}
+	warn(message, ...args) {
+		this.consola.warn(message, ...args);
+	}
+	error(message, ...args) {
+		this.consola.error(message, ...args);
+	}
+	trace(message, ...args) {
+		if (this.consola.trace) this.consola.trace(message, ...args);
+		else this.consola.debug(message, ...args);
+	}
+	fatal(message, ...args) {
+		if (this.consola.fatal) this.consola.fatal(message, ...args);
+		else this.consola.error("[FATAL]", message, ...args);
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/adapters/pino.ts
+/**
+* Pino logger adapter implementation
+*
+* This adapter integrates with the Pino logging library,
+* providing high-performance structured logging optimized
+* for Node.js applications with minimal overhead.
+*/
+var PinoLoggerAdapter = class {
+	pino;
+	constructor(pinoInstance) {
+		if (!pinoInstance) throw new Error("Pino instance is required for PinoLoggerAdapter");
+		this.pino = pinoInstance;
+	}
+	debug(message, ...args) {
+		this.pino.debug(this.format(message, ...args));
+	}
+	info(message, ...args) {
+		this.pino.info(this.format(message, ...args));
+	}
+	warn(message, ...args) {
+		this.pino.warn(this.format(message, ...args));
+	}
+	error(message, ...args) {
+		this.pino.error(this.format(message, ...args));
+	}
+	trace(message, ...args) {
+		this.pino.trace(this.format(message, ...args));
+	}
+	fatal(message, ...args) {
+		this.pino.fatal(this.format(message, ...args));
+	}
+	format(message, ...args) {
+		if (args.length === 0) return { msg: message };
+		if (args.length === 1 && /* @__PURE__ */ isObject(args[0])) return {
+			...args[0],
+			msg: message
+		};
+		return {
+			msg: message,
+			args
+		};
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/adapters/v0.ts
+/**
+* Vuetify0.x logger adapter implementation
+*
+* This adapter provides console-based logging with proper formatting,
+* color coding, timestamps, and log level filtering for development
+* and production environments.
+*/
+var Vuetify0LoggerAdapter = class {
+	prefix;
+	colors;
+	timestamps;
+	constructor(options = {}) {
+		this.prefix = options.prefix || "v0";
+		this.colors = options.colors !== false;
+		this.timestamps = options.timestamps !== false;
+	}
+	debug(message, ...args) {
+		this.log("debug", "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log("info", "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log("warn", "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log("error", "error", message, ...args);
+	}
+	trace(message, ...args) {
+		this.log("trace", "trace", message, ...args);
+	}
+	fatal(message, ...args) {
+		this.log("fatal", "error", message, ...args);
+	}
+	format(level, message, ...args) {
+		return [[
+			this.timestamps ? this.timestamp() : "",
+			`[${this.prefix} ${level.toLowerCase()}]`,
+			message
+		].filter(Boolean).join(" "), ...args];
+	}
+	timestamp() {
+		if (!IN_BROWSER) return (/* @__PURE__ */ new Date()).toISOString();
+		return (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0] ?? "";
+	}
+	style(level) {
+		if (!this.colors || !IN_BROWSER) return "";
+		return {
+			trace: "color: #64748b",
+			debug: "color: #3b82f6",
+			info: "color: #10b981",
+			warn: "color: #f59e0b",
+			error: "color: #ef4444",
+			fatal: "color: #dc2626; font-weight: bold",
+			silent: ""
+		}[level] || "";
+	}
+	log(level, method, message, ...args) {
+		const [formattedMessage, ...restArgs] = this.format(level, message, ...args);
+		const style = this.style(level);
+		if (IN_BROWSER && style && /* @__PURE__ */ isFunction(console[method])) console[method](`%c${formattedMessage}`, style, ...restArgs);
+		else if (/* @__PURE__ */ isFunction(console[method])) console[method](formattedMessage, ...restArgs);
+	}
+};
+
+//#endregion
+//#region src/composables/useLogger/index.ts
+/**
+* @module useLogger
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @remarks
+* Logging composable with adapter pattern supporting console, consola, and pino.
+*
+* Key features:
+* - Multiple log levels (trace, debug, info, warn, error, fatal)
+* - Adapter pattern for console/consola/pino integration
+* - Enable/disable logging
+* - Fallback logger for undefined loggers
+* - Context logging support
+*
+* Uses adapter pattern to abstract logging implementation.
+*/
+/**
+* Creates a new logger instance.
+*
+* @param options The options for the logger instance.
+* @returns A new logger instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @example
+* ```ts
+* import { createLogger } from '@vuetify/v0'
+*
+* const logger = createLogger({
+*   level: 'debug',
+*   prefix: '[MyApp]',
+* })
+*
+* logger.info('This is an info message')
+* logger.debug('This is a debug message')
+* logger.error('This is an error message')
+* logger.level('debug')
+* logger.debug('This debug message will now be logged')
+* ```
+*/
+function createLogger(options = {}) {
+	const { adapter = new Vuetify0LoggerAdapter({ prefix: options.prefix }), level: initialLevel = "info", enabled: initialEnabled = __LOGGER_ENABLED__ } = options;
+	const currentLevel = shallowRef(initialLevel);
+	const isEnabled = shallowRef(initialEnabled);
+	function value(level$1) {
+		return {
+			trace: 0,
+			debug: 1,
+			info: 2,
+			warn: 3,
+			error: 4,
+			fatal: 5,
+			silent: 6
+		}[level$1] ?? 2;
+	}
+	function can(level$1) {
+		if (!isEnabled.value) return false;
+		return value(level$1) >= value(currentLevel.value);
+	}
+	function format(message) {
+		return message;
+	}
+	function debug(message, ...args) {
+		if (can("debug")) adapter.debug(format(message), ...args);
+	}
+	function info(message, ...args) {
+		if (can("info")) adapter.info(format(message), ...args);
+	}
+	function warn(message, ...args) {
+		if (can("warn")) adapter.warn(format(message), ...args);
+	}
+	function error(message, ...args) {
+		if (can("error")) adapter.error(format(message), ...args);
+	}
+	function trace(message, ...args) {
+		if (can("trace")) adapter.trace?.(format(message), ...args);
+	}
+	function fatal(message, ...args) {
+		if (can("fatal")) adapter.fatal?.(format(message), ...args);
+	}
+	function level(newLevel) {
+		currentLevel.value = newLevel;
+	}
+	function current() {
+		return currentLevel.value;
+	}
+	function enabled() {
+		return isEnabled.value;
+	}
+	function enable() {
+		isEnabled.value = true;
+	}
+	function disable() {
+		isEnabled.value = false;
+	}
+	return {
+		debug,
+		info,
+		warn,
+		error,
+		trace,
+		fatal,
+		level,
+		current,
+		enabled,
+		enable,
+		disable
+	};
+}
+function createFallbackLogger(namespace = "v0:logger") {
+	function format(message, type) {
+		return `[${namespace} ${type}] ${message}`;
+	}
+	return {
+		debug: (message, ...args) => console.log(format(message, "debug"), ...args),
+		info: (message, ...args) => console.log(format(message, "info"), ...args),
+		warn: (message, ...args) => console.log(format(message, "warn"), ...args),
+		error: (message, ...args) => console.log(format(message, "error"), ...args),
+		trace: (message, ...args) => console.log(format(message, "trace"), ...args),
+		fatal: (message, ...args) => console.log(format(message, "fatal"), ...args),
+		level: () => {},
+		current: () => "info",
+		enabled: () => true,
+		enable: () => {},
+		disable: () => {}
+	};
+}
+/**
+* Creates a new logger context.
+*
+* @param options The options for the logger context.
+* @template E The type of the logger context.
+* @returns A new logger context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @example
+* ```ts
+* import { createLoggerContext } from '@vuetify/v0'
+*
+* export const [useAppLogger, provideAppLogger, appLogger] = createLoggerContext({
+*   namespace: 'app:logger',
+*   level: 'debug',
+* })
+* ```
+*/
+function createLoggerContext(_options = {}) {
+	const { namespace = "v0:logger",...options } = _options;
+	const [useLoggerContext, _provideLoggerContext] = createContext(namespace);
+	const context = createLogger(options);
+	function provideLoggerContext(_context = context, app) {
+		return _provideLoggerContext(_context, app);
+	}
+	return createTrinity(useLoggerContext, provideLoggerContext, context);
+}
+/**
+* Creates a new logger plugin.
+*
+* @param options The options for the logger plugin.
+* @returns A new logger plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @example
+* ```ts
+* import { createApp } from 'vue'
+* import { createLoggerPlugin } from '@vuetify/v0'
+* import App from './App.vue'
+*
+* const app = createApp(App)
+*
+* app.use(
+*  createLoggerPlugin({
+*    level: 'debug',
+*    prefix: '[MyApp]',
+*  })
+* )
+*
+* app.mount('#app')
+* ```
+*/
+function createLoggerPlugin(_options = {}) {
+	const { namespace = "v0:logger",...options } = _options;
+	const [, provideLoggerContext, context] = createLoggerContext({
+		...options,
+		namespace
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			provideLoggerContext(context, app);
+		},
+		setup: (_app) => {
+			if (process.env.NODE_ENV !== "production" && IN_BROWSER) window.__v0Logger__ = context;
+		}
+	});
+}
+/**
+* Uses an existing or creates a new logger instance.
+*
+* @param namespace The namespace for the logger context. Defaults to `'v0:logger'`.
+* @returns The logger instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @example
+* ```ts
+* import { useLogger } from '@vuetify/v0'
+*
+* const logger = useLogger()
+*
+* logger.info('This is an info message')
+* logger.debug('This is a debug message')
+* logger.error('This is an error message')
+* logger.level('debug')
+* logger.debug('This debug message will now be logged')
+* ```
+*/
+function useLogger(namespace = "v0:logger") {
+	const fallback = createFallbackLogger(namespace);
+	if (!getCurrentInstance()) return fallback;
+	try {
+		return useContext(namespace, fallback);
+	} catch {
+		return fallback;
+	}
+}
+
+//#endregion
+//#region src/composables/useRegistry/index.ts
+/**
+* @module useRegistry
+*
+* @remarks
+* A foundational composable for managing collections of items (tickets) with:
+* - Unique ID-based access
+* - Index-based ordering
+* - Value-based reverse lookup
+* - Automatic reindexing
+* - Optional event emission
+* - Performance-optimized caching
+*
+* The registry serves as the base for many other composables in the system,
+* including useSelection, useForm, useTimeline, and more.
+*/
+/**
+* Creates a new registry instance.
+*
+* @param options The options for the registry instance.
+* @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+* @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+* @returns A new registry instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-registry#use-registry
+*
+* @example
+* ```ts
+* import { useRegistry } from '@vuetify/v0'
+*
+* const registry = useRegistry()
+*
+* const ticket1 = registry.register({ id: 'user-1', value: { name: 'John' } })
+* const ticket2 = registry.register({ id: 'user-2', value: { name: 'Jane' } })
+*
+* console.log(registry.size) // 2
+* console.log(registry.get('user-1')) // { id: 'user-1', index: 0, value: { name: 'John' }, ... }
+* ```
+*/
+function useRegistry(options) {
+	const logger = useLogger();
+	const collection = /* @__PURE__ */ new Map();
+	const catalog = /* @__PURE__ */ new Map();
+	const directory = /* @__PURE__ */ new Map();
+	const cache = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	const events = options?.events ?? false;
+	let indexDependentCount = 0;
+	let needsReindex = false;
+	let minDirtyIndex = Infinity;
+	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 (/* @__PURE__ */ isUndefined(patch.value)) {
+				value = existing.index;
+				valueIsIndex = true;
+			} else {
+				value = patch.value;
+				valueIsIndex = false;
+			}
+			if (valueIsIndex !== existing.valueIsIndex) if (valueIsIndex) indexDependentCount++;
+			else indexDependentCount--;
+			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) {
+		if (indexDependentCount > 0 && needsReindex) reindex();
+		return catalog.get(value);
+	}
+	function lookup(index) {
+		if (needsReindex) reindex();
+		return directory.get(index);
+	}
+	function has(id) {
+		return collection.has(id);
+	}
+	function assign(value, id) {
+		const bucket = catalog.get(value);
+		if (bucket) {
+			if (/* @__PURE__ */ isArray(bucket)) {
+				if (!bucket.includes(id)) bucket.push(id);
+			} else if (bucket !== id) catalog.set(value, [bucket, id]);
+		} else catalog.set(value, id);
+	}
+	function unassign(value, id) {
+		const bucket = catalog.get(value);
+		if (!bucket) return;
+		if (/* @__PURE__ */ isArray(bucket)) {
+			const next = bucket.filter((v) => v !== id);
+			if (next.length === 0) catalog.delete(value);
+			else if (next.length === 1) catalog.set(value, next[0]);
+			else catalog.set(value, next);
+		} else if (bucket === id) catalog.delete(value);
+	}
+	function keys() {
+		const cached = cache.get("keys");
+		if (cached != void 0) return cached;
+		const keys$1 = Array.from(collection.keys());
+		cache.set("keys", keys$1);
+		return keys$1;
+	}
+	function values() {
+		const cached = cache.get("values");
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const values$1 = Array.from(collection.values());
+		cache.set("values", values$1);
+		return values$1;
+	}
+	function entries() {
+		const cached = cache.get("entries");
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const entries$1 = Array.from(collection.entries());
+		cache.set("entries", entries$1);
+		return entries$1;
+	}
+	function clear() {
+		if (collection.size > 0) collection.clear();
+		if (catalog.size > 0) catalog.clear();
+		if (directory.size > 0) directory.clear();
+		invalidate();
+		indexDependentCount = 0;
+		needsReindex = false;
+		minDirtyIndex = Infinity;
+		emit("clear:registry");
+	}
+	function invalidate() {
+		if (cache.size > 0) cache.clear();
+	}
+	function reindex() {
+		const startIndex = minDirtyIndex === Infinity ? 0 : minDirtyIndex;
+		if (startIndex === 0) {
+			if (catalog.size > 0) catalog.clear();
+			if (directory.size > 0) directory.clear();
+		}
+		invalidate();
+		let index = 0;
+		for (const ticket of collection.values()) {
+			if (index < startIndex) {
+				index++;
+				continue;
+			}
+			if (startIndex > 0) directory.delete(ticket.index);
+			if (ticket.valueIsIndex) {
+				if (startIndex > 0) unassign(ticket.value, ticket.id);
+				ticket.value = index;
+				assign(ticket.value, ticket.id);
+			} else if (startIndex === 0) assign(ticket.value, ticket.id);
+			ticket.index = index;
+			directory.set(index, ticket.id);
+			index++;
+		}
+		needsReindex = false;
+		minDirtyIndex = Infinity;
+		emit("reindex:registry");
+	}
+	function register(registration = {}) {
+		const size = collection.size;
+		const id = registration.id ?? /* @__PURE__ */ genId();
+		if (has(id)) {
+			logger.warn(`Ticket with id "${id}" already exists in the registry. Skipping registration.`);
+			return get(id);
+		}
+		const valueIsUndefined = /* @__PURE__ */ isUndefined(registration.value);
+		const index = registration.index ?? size;
+		const value = valueIsUndefined ? index : registration.value;
+		const valueIsIndex = valueIsUndefined;
+		if (valueIsIndex) indexDependentCount++;
+		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;
+		if (ticket.valueIsIndex) indexDependentCount--;
+		collection.delete(ticket.id);
+		directory.delete(ticket.index);
+		unassign(ticket.value, ticket.id);
+		invalidate();
+		emit("unregister:ticket", ticket);
+		if (indexDependentCount > 0 && ticket.index < collection.size) {
+			minDirtyIndex = Math.min(minDirtyIndex, ticket.index);
+			reindex();
+		} else {
+			minDirtyIndex = Math.min(minDirtyIndex, ticket.index);
+			needsReindex = true;
+		}
+	}
+	function offboard(ids) {
+		const removed = [];
+		for (const id of ids) {
+			const ticket = collection.get(id);
+			if (!ticket) continue;
+			if (ticket.valueIsIndex) indexDependentCount--;
+			minDirtyIndex = Math.min(minDirtyIndex, ticket.index);
+			collection.delete(ticket.id);
+			directory.delete(ticket.index);
+			unassign(ticket.value, ticket.id);
+			removed.push(ticket);
+		}
+		if (removed.length === 0) return;
+		invalidate();
+		if (events) for (const ticket of removed) emit("unregister:ticket", ticket);
+		needsReindex = true;
+	}
+	function seek(direction = "first", from, predicate) {
+		if (collection.size === 0) return void 0;
+		if (needsReindex) reindex();
+		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) => register(registration));
+		},
+		offboard,
+		get size() {
+			return collection.size;
+		}
+	};
+}
+/**
+* Creates a new registry context.
+*
+* @param namespace The namespace for the registry context.
+* @param options The options for the registry context.
+* @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+* @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+* @returns A new registry context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-registry#create-registry-context
+*
+* @example
+* ```ts
+* import { createRegistryContext } from '@vuetify/v0'
+*
+* // With default namespace 'v0:registry'
+* export const [useItems, provideItems, items] = createRegistryContext()
+*
+* // Or with custom namespace
+* export const [useItems, provideItems, items] = createRegistryContext({ namespace: 'my-items' })
+*
+* // In a parent component:
+* provideItems()
+*
+* // In a child component:
+* const items = useItems()
+* items.register({ id: 'item-1', value: 'Value 1' })
+* ```
+*/
+function createRegistryContext(_options = {}) {
+	const { namespace = "v0:registry",...options } = _options;
+	const [useRegistryContext, _provideRegistryContext] = createContext(namespace);
+	const context = useRegistry(options);
+	function provideRegistryContext(_context = context, app) {
+		return _provideRegistryContext(_context, app);
+	}
+	return createTrinity(useRegistryContext, provideRegistryContext, context);
+}
+
+//#endregion
+//#region src/composables/useSelection/index.ts
+/**
+* @module useSelection
+*
+* @remarks
+* Base composable for managing selected items in a collection with Set-based tracking.
+*
+* Key features:
+* - Set-based selectedIds for O(1) selection checks
+* - Mandatory selection mode (prevents deselecting last item)
+* - Auto-enrollment option (selects non-disabled items on register)
+* - Disabled item filtering
+* - Computed selectedItems and selectedValues Sets
+*
+* Extends useRegistry and serves as the base for useSingle, useGroup, useStep, and useFeatures.
+*/
+/**
+* Creates a new selection instance for managing multiple selected items.
+*
+* Extends `useRegistry` with selection tracking via a reactive `Set` of selected IDs.
+* Supports disabled items, mandatory selection enforcement, and auto-enrollment.
+*
+* @param options The options for the selection instance.
+* @template Z The type of the selection ticket.
+* @template E The type of the selection context.
+* @returns A new selection instance with selection management methods.
+*
+* @remarks
+* **Key Features:**
+* - Multi-selection support (unlike `useSingle` which enforces single selection)
+* - Set-based `selectedIds` tracking for efficient lookups
+* - Computed `selectedItems` and `selectedValues` for reactive access
+* - Each ticket gets `isSelected`, `select()`, `unselect()`, and `toggle()` methods
+* - Disabled items cannot be selected
+* - Mandatory mode prevents deselecting the last item
+* - Force mode auto-selects first non-disabled item on registration
+* - Enroll option auto-selects all non-disabled items on registration
+*
+* **Inheritance Chain:**
+* `useRegistry` → `createSelection` → `createSingle`/`createGroup` → `createStep`
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-selection
+*
+* @example
+* ```ts
+* import { createSelection } from '@vuetify/v0'
+*
+* const selection = createSelection({ mandatory: true })
+*
+* selection.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2', disabled: true },
+*   { id: 'item-3', value: 'Item 3' },
+* ])
+*
+* selection.select('item-1')
+* selection.select('item-3')
+*
+* console.log(selection.selectedIds) // Set { 'item-1', 'item-3' }
+* console.log(Array.from(selection.selectedValues.value)) // ['Item 1', 'Item 3']
+* ```
+*/
+function createSelection(_options = {}) {
+	const { disabled = false, enroll = false, mandatory = false, multiple = false,...options } = _options;
+	const registry = useRegistry(options);
+	const selectedIds = shallowReactive(/* @__PURE__ */ new Set());
+	const selectedItems = computed(() => {
+		return new Set(Array.from(selectedIds).map((id) => registry.get(id)));
+	});
+	const selectedValues = computed(() => {
+		return new Set(Array.from(selectedItems.value).map((item) => item?.value));
+	});
+	function seek(direction = "first", from) {
+		return registry.seek(direction, from, (ticket) => !toValue(ticket.disabled));
+	}
+	function mandate() {
+		if (!mandatory || registry.size === 0 || selectedIds.size > 0) return;
+		const ticket = seek("first");
+		if (ticket) select(ticket.id);
+	}
+	function select(id) {
+		const item = registry.get(id);
+		if (!item || toValue(item.disabled)) return;
+		if (!multiple) selectedIds.clear();
+		selectedIds.add(id);
+	}
+	function unselect(id) {
+		if (mandatory && selectedIds.size === 1) return;
+		selectedIds.delete(id);
+	}
+	function toggle(id) {
+		if (selected(id)) unselect(id);
+		else select(id);
+	}
+	function selected(id) {
+		return selectedIds.has(id);
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ genId();
+		const item = {
+			disabled: false,
+			select: () => select(id),
+			unselect: () => unselect(id),
+			toggle: () => toggle(id),
+			isSelected: toRef(() => selected(id)),
+			...registration,
+			id
+		};
+		const ticket = registry.register(item);
+		if (enroll && !toValue(item.disabled)) selectedIds.add(ticket.id);
+		if (mandatory === "force") mandate();
+		return ticket;
+	}
+	function unregister(id) {
+		selectedIds.delete(id);
+		registry.unregister(id);
+	}
+	function offboard(ids) {
+		for (const id of ids) selectedIds.delete(id);
+		registry.offboard(ids);
+	}
+	function onboard(registrations) {
+		return registrations.map((registration) => register(registration));
+	}
+	function reset() {
+		registry.clear();
+		selectedIds.clear();
+		mandate();
+	}
+	return {
+		...registry,
+		disabled,
+		selectedIds,
+		selectedItems,
+		selectedValues,
+		register,
+		unregister,
+		onboard,
+		offboard,
+		reset,
+		mandate,
+		seek,
+		select,
+		unselect,
+		toggle,
+		selected,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new 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'
+*
+* // With default namespace 'v0:selection'
+* export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext()
+*
+* // Or with custom namespace
+* export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext({ namespace: 'checkboxes' })
+*
+* // In a parent component:
+* provideCheckboxes()
+*
+* // In a child component:
+* const checkboxes = useCheckboxes()
+* checkboxes.select('checkbox-1')
+* ```
+*/
+function createSelectionContext(_options = {}) {
+	const { namespace = "v0:selection",...options } = _options;
+	const [useSelectionContext, _provideSelectionContext] = createContext(namespace);
+	const context = createSelection(options);
+	function provideSelectionContext(_context = context, app) {
+		return _provideSelectionContext(_context, app);
+	}
+	return createTrinity(useSelectionContext, provideSelectionContext, context);
+}
+/**
+* Returns the current selection instance.
+*
+* @param namespace The namespace for the selection context. Defaults to `'v0:selection'`.
+* @returns The current selection instance.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-selection
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useSelection } from '@vuetify/v0'
+*
+*   const selection = useSelection()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Selected: {{ selection.selectedIds.size }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useSelection(namespace = "v0:selection") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/toArray/index.ts
+/**
+* @module toArray
+*
+* @remarks
+* Utility function to normalize single values and arrays into arrays.
+*
+* Converts single values into single-element arrays, passes arrays through unchanged,
+* and handles null/undefined by returning empty arrays. Perfect for functions that
+* accept both single values and arrays as input (e.g., ID | ID[]).
+*/
+/**
+* Converts a value to an array.
+*
+* @param value The value to convert.
+* @template Z The type of the value.
+* @returns The converted array.
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-array
+*
+* @example
+* ```ts
+* import { toArray } from '@vuetify/v0'
+*
+* const value = 'Example Value'
+* const valueAsArray = toArray(value)
+*
+* console.log(valueAsArray) // ['Example Value']
+* ```
+*/
+function toArray(value) {
+	return /* @__PURE__ */ isNullOrUndefined(value) ? [] : Array.isArray(value) ? value : [value];
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* @module useProxyModel
+*
+* @remarks
+* Proxy composable for bidirectional sync between selection registry and v-model.
+*
+* Key features:
+* - Bidirectional synchronization
+* - Array and single-value modes
+* - Automatic cleanup on scope disposal
+* - Perfect for form controls with selection backing
+*
+* Bridges the gap between selection composables and Vue's v-model.
+*/
+/**
+* Syncs a ref with a selection registry bidirectionally.
+*
+* @param registry The selection registry to bind to.
+* @param model The ref to sync.
+* @param options The options for the proxy model.
+* @template Z The type of the selection ticket.
+* @returns A function to stop the sync.
+*
+* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
+*
+* @example
+* ```ts
+* import { createSelection, useProxyModel } from '@vuetify/v0'
+*
+* const model = ref()
+* const registry = createSelection({ events: true })
+* registry.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2' },
+* ])
+*
+* const stop = useProxyModel(registry, model)
+* ```
+*/
+function useProxyModel(registry, model, options) {
+	const multiple = options?.multiple ?? false;
+	const _transformIn = options?.transformIn;
+	const _transformOut = options?.transformOut;
+	function transformIn(val) {
+		const value = toValue(val);
+		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
+	}
+	function transformOut(val) {
+		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
+		return multiple ? val : val[0];
+	}
+	const modelAsArray = transformIn(model);
+	const pending = new Set(modelAsArray);
+	for (const value of modelAsArray) {
+		const ids = registry.browse(value);
+		if (/* @__PURE__ */ isArray(ids)) {
+			for (const id of ids) registry.select(id);
+			pending.delete(value);
+		} else if (ids) {
+			registry.select(ids);
+			pending.delete(value);
+		}
+	}
+	const registryWatch = watch(registry.selectedValues, (val) => {
+		modelWatch.pause();
+		model.value = transformOut(Array.from(toValue(val)));
+		modelWatch.resume();
+	}, { flush: "sync" });
+	const modelWatch = watch(model, (val) => {
+		registryWatch.pause();
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of transformIn(val)) {
+			const ids = registry.browse(value);
+			if (/* @__PURE__ */ isArray(ids)) for (const single of ids) targetIds.add(single);
+			else if (ids) targetIds.add(ids);
+		}
+		if (multiple) {
+			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
+			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
+		} else {
+			const next = targetIds.values().next().value;
+			const last = currentIds.values().next().value;
+			if (!/* @__PURE__ */ isUndefined(last)) registry.unselect(last);
+			if (!/* @__PURE__ */ isUndefined(next)) registry.select(next);
+		}
+		registryWatch.resume();
+	}, {
+		flush: "sync",
+		deep: multiple
+	});
+	function onRegister(ticket) {
+		if (!pending.has(ticket.value) || ticket.disabled) return;
+		registryWatch.pause();
+		modelWatch.pause();
+		registry.select(ticket.id);
+		pending.delete(ticket.value);
+		modelWatch.resume();
+		registryWatch.resume();
+	}
+	registry.on("register:ticket", onRegister);
+	function stop() {
+		registryWatch();
+		modelWatch();
+		registry.off("register:ticket", onRegister);
+	}
+	onScopeDispose(stop, true);
+	return stop;
+}
+
+//#endregion
+//#region src/composables/useProxyRegistry/index.ts
+/**
+* @module useProxyRegistry
+*
+* @remarks
+* Proxy composable for reactive registry keys, values, entries, and size.
+*
+* Key features:
+* - Reactive proxy for registry data
+* - Deep or shallow reactivity options
+* - Event-based updates
+* - Automatic cleanup on scope disposal
+* - Transforms Map-based registry into reactive refs
+*
+* Perfect for exposing registry data as reactive computed properties.
+*/
+/**
+* Creates a proxy registry that provides reactive objects for registry data.
+*
+* @param registry The registry instance to proxy.
+* @param options The options for the proxy registry.
+* @template Z The type of the registry ticket.
+* @returns A proxy registry with reactive objects.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-proxy-registry
+*
+* @example
+* ```ts
+* import { useRegistry, useProxyRegistry } from '@vuetify/v0'
+*
+* const registry = useRegistry({ events: true })
+* const proxy = useProxyRegistry(registry)
+*
+* registry.register({ value: 'Item 1' })
+* console.log(proxy.size) // 1
+* ```
+*/
+function useProxyRegistry(registry, options) {
+	const state = (options?.deep ? reactive : shallowReactive)({
+		keys: registry.keys(),
+		values: registry.values(),
+		entries: registry.entries(),
+		size: registry.size
+	});
+	function update() {
+		state.keys = registry.keys();
+		state.values = registry.values();
+		state.entries = registry.entries();
+		state.size = registry.size;
+	}
+	registry.on("register:ticket", update);
+	registry.on("unregister:ticket", update);
+	registry.on("update:ticket", update);
+	registry.on("clear:registry", update);
+	onScopeDispose(() => {
+		registry.off("register:ticket", update);
+		registry.off("unregister:ticket", update);
+		registry.off("update:ticket", update);
+		registry.off("clear:registry", update);
+	}, true);
+	return state;
+}
+
+//#endregion
+//#region src/composables/useGroup/index.ts
+/**
+* @module useGroup
+*
+* @remarks
+* Multi-selection composable that extends useSelection with batch operations and tri-state support.
+*
+* Key features:
+* - Batch operations (select/unselect/toggle accept ID | ID[])
+* - Tri-state support via mixed/indeterminate state (mix/unmix)
+* - selectedIndexes computed Set for position-based tracking
+* - Perfect for checkbox trees, multi-select dropdowns, filter panels
+*
+* Tri-state behavior:
+* - Items can be selected, mixed (indeterminate), or unselected
+* - select() clears mixed state, mix() clears selected state (mutually exclusive)
+* - toggle() on a mixed item selects it (resolves positively)
+*
+* Inheritance chain: useRegistry → useSelection → useGroup
+* Extended by: useFeatures
+*/
+/**
+* Creates a new group instance with batch selection and tri-state support.
+*
+* Extends `createSelection` to support selecting, unselecting, and toggling multiple items
+* at once by passing an array of IDs. Adds tri-state (mixed/indeterminate) support for
+* checkbox trees and similar use cases.
+*
+* @param options The options for the group instance.
+* @template Z The type of the group ticket.
+* @template E The type of the group context.
+* @returns A new group instance with batch selection and tri-state support.
+*
+* @remarks
+* **Key Differences from `createSelection`:**
+* - `select()` accepts `ID | ID[]` for batch operations
+* - `unselect()` accepts `ID | ID[]` for batch operations
+* - `toggle()` accepts `ID | ID[]` for batch operations
+* - Adds `selectedIndexes` computed Set for getting selected item indexes
+* - Adds tri-state support via `mix()`, `unmix()`, `mixed()`, `mixedIds`, `mixedItems`
+* - Perfect for checkbox trees, multi-select dropdowns, and bulk operations
+*
+* **Tri-State Support:**
+* - Items can be in one of three states: selected, mixed (indeterminate), or unselected
+* - `mix(id)` sets item to mixed state (clears selected if set)
+* - `unmix(id)` clears mixed state
+* - `select(id)` clears mixed state before selecting
+* - `toggle(id)` on a mixed item selects it (resolves the indeterminate state positively)
+* - Mixed state works on disabled items (it's a computed state, not user action)
+*
+* **Batch Operations:**
+* - Single ID: `group.select('item-1')`
+* - Array of IDs: `group.select(['item-1', 'item-2', 'item-3'])`
+* - Uses `toArray()` utility internally to normalize input
+* - Disabled items are automatically skipped in select operations
+* - Non-existent IDs are silently ignored
+*
+* **Inheritance Chain:**
+* `useRegistry` → `createSelection` → `createGroup`
+*
+* **Used By:**
+* - `createFeatures` for feature flag management with multiple selections
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-group
+*
+* @example
+* ```ts
+* import { createGroup } from '@vuetify/v0'
+*
+* const checkboxes = createGroup()
+*
+* checkboxes.onboard([
+*   { id: 'option-a', value: 'Option A' },
+*   { id: 'option-b', value: 'Option B' },
+*   { id: 'option-c', value: 'Option C' },
+* ])
+*
+* // Select multiple items at once
+* checkboxes.select(['option-a', 'option-c'])
+*
+* console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
+* console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
+*
+* // Set item to mixed/indeterminate state
+* checkboxes.mix('option-a')
+* console.log(checkboxes.mixedIds) // Set { 'option-a' }
+* console.log(checkboxes.selectedIds) // Set { 'option-c' } (option-a removed)
+*
+* // Toggle a mixed item selects it
+* checkboxes.toggle('option-a')
+* console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
+* console.log(checkboxes.mixedIds) // Set {} (cleared)
+* ```
+*/
+function createGroup(_options = {}) {
+	const { mandatory = false, multiple = true,...options } = _options;
+	const selection = createSelection({
+		...options,
+		mandatory,
+		multiple,
+		events: true
+	});
+	const proxy = useProxyRegistry(selection);
+	const mixedIds = shallowReactive(/* @__PURE__ */ new Set());
+	const selectedIndexes = computed(() => {
+		return new Set(Array.from(selection.selectedItems.value).map((item) => item?.index));
+	});
+	const mixedItems = computed(() => {
+		return new Set(Array.from(mixedIds).map((id) => selection.get(id)));
+	});
+	function mixed(id) {
+		return mixedIds.has(id);
+	}
+	function mix(ids) {
+		for (const id of toArray(ids)) {
+			if (!selection.has(id)) continue;
+			selection.selectedIds.delete(id);
+			mixedIds.add(id);
+		}
+	}
+	function unmix(ids) {
+		for (const id of toArray(ids)) mixedIds.delete(id);
+	}
+	function select(ids) {
+		for (const id of toArray(ids)) {
+			mixedIds.delete(id);
+			selection.select(id);
+		}
+	}
+	function unselect(ids) {
+		for (const id of toArray(ids)) selection.unselect(id);
+	}
+	function toggle(ids) {
+		for (const id of toArray(ids)) if (mixed(id)) select(id);
+		else selection.toggle(id);
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ genId();
+		const item = {
+			...registration,
+			id,
+			isMixed: toRef(() => mixed(id)),
+			select: () => select(id),
+			unselect: () => unselect(id),
+			toggle: () => toggle(id),
+			mix: () => mix(id),
+			unmix: () => unmix(id)
+		};
+		const ticket = selection.register(item);
+		if (toValue(registration.indeterminate)) mix(id);
+		return ticket;
+	}
+	function unregister(id) {
+		mixedIds.delete(id);
+		selection.unregister(id);
+	}
+	function offboard(ids) {
+		for (const id of ids) mixedIds.delete(id);
+		selection.offboard(ids);
+	}
+	function onboard(registrations) {
+		return registrations.map((registration) => register(registration));
+	}
+	function reset() {
+		mixedIds.clear();
+		selection.reset();
+	}
+	const selectableItems = computed(() => {
+		return proxy.values.filter((item) => !toValue(item.disabled));
+	});
+	const isAllSelected = computed(() => {
+		const items = selectableItems.value;
+		if (items.length === 0) return false;
+		return items.every((item) => selection.selectedIds.has(item.id));
+	});
+	const isMixed = toRef(() => {
+		return mixedIds.size > 0 || !isNoneSelected.value && !isAllSelected.value;
+	});
+	const isNoneSelected = toRef(() => selection.selectedIds.size === 0);
+	function selectAll() {
+		for (const item of selectableItems.value) {
+			mixedIds.delete(item.id);
+			selection.select(item.id);
+		}
+	}
+	function unselectAll() {
+		const first = selection.selectedIds.values().next().value;
+		selection.selectedIds.clear();
+		if (!mandatory || !first) return;
+		selection.select(first);
+	}
+	function toggleAll() {
+		if (isAllSelected.value) unselectAll();
+		else selectAll();
+	}
+	return {
+		...selection,
+		mixed,
+		mix,
+		unmix,
+		select,
+		unselect,
+		toggle,
+		register,
+		unregister,
+		offboard,
+		onboard,
+		reset,
+		selectAll,
+		unselectAll,
+		toggleAll,
+		mixedIds,
+		mixedItems,
+		selectedIndexes,
+		isNoneSelected,
+		isAllSelected,
+		isMixed,
+		get size() {
+			return selection.size;
+		}
+	};
+}
+/**
+* Creates a new 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'
+*
+* // With default namespace 'v0:group'
+* export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext()
+*
+* // Or with custom namespace
+* export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext({ namespace: 'my-group' })
+*
+* // In a parent component:
+* provideMyGroup()
+*
+* // In a child component:
+* const group = useMyGroup()
+* ```
+*/
+function createGroupContext(_options = {}) {
+	const { namespace = "v0:group",...options } = _options;
+	const [useGroupContext, _provideGroupContext] = createContext(namespace);
+	const context = createGroup(options);
+	function provideGroupContext(_context = context, app) {
+		return _provideGroupContext(_context, app);
+	}
+	return createTrinity(useGroupContext, provideGroupContext, context);
+}
+/**
+* Returns the current group instance.
+*
+* @param namespace The namespace for the group context. Defaults to `'v0:group'`.
+* @returns The current group instance.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-group
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useGroup } from '@vuetify/v0'
+*
+*   const group = useGroup()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Selected: {{ group.selectedIds.size }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useGroup(namespace = "v0:group") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useHydration/index.ts
+/**
+* @module useHydration
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @remarks
+* SSR hydration state management composable.
+*
+* Key features:
+* - Hydration state detection (browser vs SSR)
+* - Root component detection
+* - Readonly hydration state refs
+* - Plugin installation support
+* - Perfect for hydration-safe rendering
+*
+* Essential for composables that need to behave differently during SSR vs client-side.
+*/
+/**
+* Creates a new hydration instance.
+*
+* @returns A new hydration instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @example
+* ```ts
+* import { createHydration } from '@vuetify/v0'
+*
+* const hydration = createHydration()
+* console.log(hydration.isHydrated.value) // false
+* hydration.hydrate()
+* console.log(hydration.isHydrated.value) // true
+* ```
+*/
+function createHydration() {
+	const isHydrated = shallowRef(false);
+	function hydrate() {
+		isHydrated.value = true;
+	}
+	return {
+		isHydrated: shallowReadonly(isHydrated),
+		hydrate
+	};
+}
+function createFallbackHydration() {
+	return {
+		isHydrated: shallowReadonly(shallowRef(true)),
+		hydrate: () => {}
+	};
+}
+/**
+* Creates a new hydration context trinity.
+*
+* @param options Options for creating the hydration context.
+* @template E The type of the hydration context.
+* @returns A new hydration context trinity.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @example
+* ```ts
+* import { createHydrationContext } from '@vuetify/v0'
+*
+* export const [useHydrationContext, provideHydrationContext, context] = createHydrationContext({
+*   namespace: 'app:hydration',
+* })
+* ```
+*/
+function createHydrationContext(_options = {}) {
+	const { namespace = "v0:hydration" } = _options;
+	const [useHydrationContext, _provideHydrationContext] = createContext(namespace);
+	const context = createHydration();
+	function provideHydrationContext(_context = context, app) {
+		return _provideHydrationContext(_context, app);
+	}
+	return createTrinity(useHydrationContext, provideHydrationContext, context);
+}
+/**
+* Creates a new hydration plugin.
+*
+* @param options The options for the hydration plugin.
+* @template E The type of the hydration context.
+* @returns A new hydration plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @example
+* ```ts
+* import { createApp } from 'vue'
+* import { createHydrationPlugin } from '@vuetify/v0'
+* import App from './App.vue'
+*
+* const app = createApp(App)
+*
+* app.use(createHydrationPlugin())
+*
+* app.mount('#app')
+* ```
+*/
+function createHydrationPlugin(_options = {}) {
+	const { namespace = "v0:hydration",...options } = _options;
+	const [, provideHydrationContext, context] = createHydrationContext({
+		...options,
+		namespace
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			provideHydrationContext(context, app);
+		},
+		setup: (app) => {
+			app.mixin({ mounted() {
+				if (this.$parent !== null) return;
+				context.hydrate();
+			} });
+		}
+	});
+}
+/**
+* Returns the current hydration instance.
+*
+* @param namespace The namespace for the hydration context. Defaults to `v0:hydration`.
+* @returns The current hydration instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useHydration } from '@vuetify/v0'
+*
+*   const hydration = useHydration()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Is hydrated: {{ hydration.isHydrated.value }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useHydration(namespace = "v0:hydration") {
+	const fallback = createFallbackHydration();
+	if (!getCurrentInstance()) return fallback;
+	try {
+		return useContext(namespace, fallback);
+	} catch {
+		return fallback;
+	}
+}
+
+//#endregion
+//#region src/composables/useResizeObserver/index.ts
+/**
+* @module useResizeObserver
+*
+* @remarks
+* ResizeObserver composable with lifecycle management.
+*
+* Key features:
+* - ResizeObserver API wrapper
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_OBSERVER)
+* - Hydration-aware
+* - Box model options (content-box/border-box)
+*
+* Perfect for responsive components and size-based rendering.
+*/
+/**
+* A composable that uses the Resize Observer API to detect when an element's
+* size changes.
+*
+* @param target The element to observe.
+* @param callback The callback to execute when the element's size changes.
+* @param options The options for the Resize Observer.
+* @returns An object with methods to control the observer.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+* @see https://0.vuetifyjs.com/composables/system/use-resize-observer
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useResizeObserver } from '@vuetify/v0'
+*
+* const el = ref<HTMLElement>()
+* const width = ref(0)
+* const height = ref(0)
+*
+* const { pause, resume, isPaused } = useResizeObserver(
+*   el,
+*   (entries) => {
+*     const entry = entries[0]
+*     if (entry) {
+*       width.value = entry.contentRect.width
+*       height.value = entry.contentRect.height
+*       console.log('Size changed:', width.value, 'x', height.value)
+*     }
+*   },
+*   { immediate: true }
+* )
+*
+* // Pause observation
+* pause()
+*
+* // Resume observation
+* resume()
+* ```
+*/
+function useResizeObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	const isActive = toRef(() => !!observer.value);
+	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();
+	}
+	onScopeDispose(stop, true);
+	return {
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(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, isActive, 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,
+		isActive,
+		isPaused,
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+//#region src/composables/useOverflow/index.ts
+/**
+* @module useOverflow
+*
+* @remarks
+* Composable for computing how many items fit in a container based on available width.
+* Enables responsive truncation logic for Pagination, Breadcrumbs, and similar components.
+*
+* Key features:
+* - Container width tracking via ResizeObserver
+* - Two modes: variable-width (per-item) or uniform-width (sample-based)
+* - Computes capacity (how many items fit)
+* - SSR-safe with Infinity fallback
+* - Supports reserved space for nav buttons, ellipsis, etc.
+*
+* Use variable mode (default) for items with different widths like Breadcrumbs.
+* Use uniform mode (itemWidth option) for same-width items like Pagination buttons.
+*/
+/**
+* Creates a new overflow context for computing how many items fit in a container.
+*
+* @param options Configuration options
+* @returns Overflow context with container ref, capacity, and measurement functions
+*
+* @example Variable-width mode (Breadcrumbs)
+* ```vue
+* <script lang="ts" setup>
+*   import { useTemplateRef } from 'vue'
+*   import { createOverflow } from '@vuetify/v0'
+*
+*   const containerRef = useTemplateRef('container')
+*   const overflow = createOverflow({
+*     container: containerRef,
+*     gap: 8,
+*     reserved: 40,
+*   })
+* <\/script>
+*
+* <template>
+*   <div ref="container">
+*     <span
+*       v-for="(item, i) in items.slice(0, overflow.capacity.value)"
+*       :key="i"
+*       :ref="el => overflow.measure(i, el)"
+*     >
+*       {{ item }}
+*     </span>
+*     <span v-if="overflow.isOverflowing.value">...</span>
+*   </div>
+* </template>
+* ```
+*
+* @example Uniform-width mode (Pagination)
+* ```ts
+* const overflow = createOverflow({
+*   container: () => atom.value?.element,
+*   itemWidth: buttonWidth,
+*   reserved: () => buttonWidth.value * 4,
+* })
+* ```
+*/
+function createOverflow(options = {}) {
+	const { container: _container, gap = 0, reserved = 0, itemWidth, reverse } = options;
+	const container = /* @__PURE__ */ isUndefined(_container) ? shallowRef() : toRef(_container);
+	const widths = shallowRef(/* @__PURE__ */ new Map());
+	const { width } = useElementSize(container);
+	function measure(index, el) {
+		if (!el) {
+			if (widths.value.has(index)) {
+				const next = new Map(widths.value);
+				next.delete(index);
+				widths.value = next;
+			}
+			return;
+		}
+		const style = getComputedStyle(el);
+		const marginX = Number.parseFloat(style.marginLeft) + Number.parseFloat(style.marginRight);
+		const w = el.offsetWidth + marginX;
+		if (widths.value.get(index) !== w) widths.value = new Map(widths.value).set(index, w);
+	}
+	function reset() {
+		widths.value = /* @__PURE__ */ new Map();
+	}
+	const total = computed(() => {
+		const g = toValue(gap);
+		let sum = 0;
+		let count = 0;
+		for (const w of widths.value.values()) {
+			sum += w + (count > 0 ? g : 0);
+			count++;
+		}
+		return sum;
+	});
+	return {
+		container,
+		width,
+		capacity: computed(() => {
+			const available = width.value - toValue(reserved);
+			if (width.value === 0) return Infinity;
+			if (available <= 0) return 0;
+			const g = toValue(gap);
+			const uniformWidth = toValue(itemWidth);
+			if (uniformWidth && uniformWidth > 0) {
+				const first = uniformWidth;
+				const subsequent = uniformWidth + g;
+				if (available < first) return 0;
+				return Math.max(1, Math.floor((available - first) / subsequent) + 1);
+			}
+			const entries = [...widths.value.entries()].toSorted((a, b) => a[0] - b[0]);
+			if (toValue(reverse)) entries.reverse();
+			let sum = 0;
+			let count = 0;
+			for (const [, w] of entries) {
+				const next = sum + w + (count > 0 ? g : 0);
+				if (next > available) break;
+				sum = next;
+				count++;
+			}
+			return count;
+		}),
+		total,
+		isOverflowing: toRef(() => {
+			return total.value > width.value - toValue(reserved);
+		}),
+		measure,
+		reset
+	};
+}
+/**
+* Creates an overflow context with dependency injection support.
+*
+* @param options Configuration options including namespace
+* @returns Trinity tuple: [useContext, provideContext, defaultContext]
+*
+* @example
+* ```ts
+* // Create injectable context
+* const [useOverflow, provideOverflow, overflow] = createOverflowContext({
+*   namespace: 'my-overflow',
+*   gap: 8,
+*   reserved: 160,
+* })
+*
+* // In parent component
+* provideOverflow()
+*
+* // In child component
+* const overflow = useOverflow()
+* ```
+*/
+function createOverflowContext(_options = {}) {
+	const { namespace = "v0:overflow",...options } = _options;
+	const [useOverflowContext, _provideOverflowContext] = createContext(namespace);
+	const context = createOverflow(options);
+	function provideOverflowContext(_context = context, app) {
+		return _provideOverflowContext(_context, app);
+	}
+	return createTrinity(useOverflowContext, provideOverflowContext, context);
+}
+/**
+* Returns the current overflow context from dependency injection.
+*
+* @param namespace The namespace for the overflow context. Defaults to `v0:overflow`.
+* @returns The current overflow context.
+*
+* @example
+* ```vue
+* <script lang="ts" setup>
+*   import { useOverflow } from '@vuetify/v0'
+*
+*   // Inject overflow context provided by parent
+*   const overflow = useOverflow()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Capacity: {{ overflow.capacity.value }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useOverflow(namespace = "v0:overflow") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/usePagination/index.ts
+/**
+* @module usePagination
+*
+* @remarks
+* Lightweight pagination composable for navigating through pages.
+*
+* Key features:
+* - No registry overhead - just a bounded integer
+* - Direct ref support for v-model compatibility
+* - Navigation methods: next, prev, first, last
+* - Computed visible items with ellipsis
+* - Trinity pattern for dependency injection
+*
+* Unlike registry-based composables, pagination tracks a single number
+* within a range, making it efficient for large page counts.
+*/
+/**
+* Creates a pagination instance.
+*
+* @param options The options for the pagination instance.
+* @returns A pagination context with navigation methods.
+*
+* @example
+* ```ts
+* import { createPagination } from '@vuetify/v0'
+*
+* // Basic usage
+* const pagination = createPagination({ size: 100 })
+* pagination.next()
+* pagination.items.value // [{ type: 'page', value: 1 }, { type: 'page', value: 2 }, ...]
+*
+* // With v-model (pass a ref)
+* const page = ref(1)
+* const pagination = createPagination({ page, size: 100 })
+* // Mutating pagination.page or the passed ref syncs both
+* ```
+*/
+function createPagination(_options = {}) {
+	const { page: _page = 1, itemsPerPage: _itemsPerPage = 10, size: _size = 0, visible: _visible = 7, ellipsis = "..." } = _options;
+	const page = isRef(_page) ? _page : shallowRef(_page);
+	const pages = computed(() => {
+		const size = toValue(_size);
+		const perPage = toValue(_itemsPerPage);
+		if (size <= 0 || /* @__PURE__ */ isNaN(size)) return 0;
+		return Math.ceil(size / perPage);
+	});
+	function first() {
+		page.value = 1;
+	}
+	function last() {
+		page.value = Math.max(1, pages.value);
+	}
+	function next() {
+		if (page.value < pages.value) page.value++;
+	}
+	function prev() {
+		if (page.value > 1) page.value--;
+	}
+	function select(value) {
+		if (value < 1) page.value = 1;
+		else if (value > pages.value) page.value = Math.max(1, pages.value);
+		else page.value = value;
+	}
+	const isFirst = computed(() => page.value <= 1);
+	const isLast = computed(() => page.value >= pages.value);
+	const pageStart = computed(() => (page.value - 1) * toValue(_itemsPerPage));
+	const pageStop = computed(() => Math.min(pageStart.value + toValue(_itemsPerPage), toValue(_size)));
+	function toPage(value) {
+		return {
+			type: "page",
+			value
+		};
+	}
+	function toEllipsis() {
+		return ellipsis === false ? false : {
+			type: "ellipsis",
+			value: ellipsis
+		};
+	}
+	function filter(array) {
+		return array.filter(Boolean);
+	}
+	return {
+		page,
+		ellipsis,
+		items: computed(() => {
+			const pageCount = pages.value;
+			const visible = toValue(_visible);
+			const current = page.value;
+			if (pageCount <= 0 || /* @__PURE__ */ isNaN(pageCount) || pageCount > Number.MAX_SAFE_INTEGER) return [];
+			if (visible <= 0) return [];
+			if (visible <= 2) return [toPage(current)];
+			if (pageCount <= visible) return (/* @__PURE__ */ range(pageCount, 1)).map(toPage);
+			if (visible === 3) {
+				const mid = current <= 1 ? 2 : current >= pageCount ? pageCount - 1 : current;
+				return [
+					toPage(1),
+					toPage(mid),
+					toPage(pageCount)
+				];
+			}
+			const boundary = visible - 2;
+			const middle = visible - 4;
+			if (middle <= 0) {
+				if (current <= boundary) return filter([
+					...(/* @__PURE__ */ range(boundary, 1)).map(toPage),
+					toEllipsis(),
+					toPage(pageCount)
+				]);
+				if (current > pageCount - boundary) return filter([
+					toPage(1),
+					toEllipsis(),
+					...(/* @__PURE__ */ range(boundary, pageCount - boundary + 1)).map(toPage)
+				]);
+				return current <= Math.ceil(pageCount / 2) ? filter([
+					toPage(1),
+					toPage(current),
+					toEllipsis(),
+					toPage(pageCount)
+				]) : filter([
+					toPage(1),
+					toEllipsis(),
+					toPage(current),
+					toPage(pageCount)
+				]);
+			}
+			const leftThreshold = boundary - 1;
+			const rightThreshold = pageCount - boundary + 2;
+			if (current <= leftThreshold) return filter([
+				...(/* @__PURE__ */ range(boundary, 1)).map(toPage),
+				toEllipsis(),
+				toPage(pageCount)
+			]);
+			else if (current >= rightThreshold) return filter([
+				toPage(1),
+				toEllipsis(),
+				...(/* @__PURE__ */ range(boundary, pageCount - boundary + 1)).map(toPage)
+			]);
+			else {
+				const start = current - Math.floor(middle / 2);
+				return filter([
+					toPage(1),
+					toEllipsis(),
+					...(/* @__PURE__ */ range(middle, start)).map(toPage),
+					toEllipsis(),
+					toPage(pageCount)
+				]);
+			}
+		}),
+		pageStart,
+		pageStop,
+		isFirst,
+		isLast,
+		first,
+		last,
+		next,
+		prev,
+		select,
+		get itemsPerPage() {
+			return toValue(_itemsPerPage);
+		},
+		get size() {
+			return toValue(_size);
+		},
+		get pages() {
+			return pages.value;
+		}
+	};
+}
+/**
+* Creates a pagination context for dependency injection.
+*
+* @param options The options including namespace.
+* @returns A trinity: [usePagination, providePagination, defaultContext]
+*
+* @example
+* ```ts
+* // With default namespace 'v0:pagination'
+* const [usePagination, providePaginationContext] = createPaginationContext({ size: 50 })
+*
+* // Or with custom namespace
+* const [usePagination, providePaginationContext] = createPaginationContext({
+*   namespace: 'my-pagination',
+*   size: 50,
+* })
+*
+* // Parent component
+* providePaginationContext()
+*
+* // Child component
+* const pagination = usePagination()
+* pagination.next()
+* ```
+*/
+function createPaginationContext(_options = {}) {
+	const { namespace = "v0:pagination",...options } = _options;
+	const [usePaginationContext, _providePaginationContext] = createContext(namespace);
+	const context = createPagination(options);
+	function providePaginationContext(_context = context, app) {
+		return _providePaginationContext(_context, app);
+	}
+	return createTrinity(usePaginationContext, providePaginationContext, context);
+}
+/**
+* Returns the current pagination instance from context.
+*
+* @param namespace The namespace. @default 'v0:pagination'
+* @returns The pagination context.
+*
+* @example
+* ```vue
+* <script setup>
+*  import { usePagination } from '@vuetify/v0'
+*
+*  const pagination = usePagination()
+* <\/script>
+*
+* <template>
+*   <button @click="pagination.prev()" :disabled="pagination.isFirst.value">Prev</button>
+*   <button @click="pagination.next()" :disabled="pagination.isLast.value">Next</button>
+* </template>
+* ```
+*/
+function usePagination(namespace = "v0:pagination") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useSingle/index.ts
+/**
+* @module useSingle
+*
+* @remarks
+* Single-selection composable that extends useSelection to enforce only one selected item.
+*
+* Key features:
+* - Auto-clears previous selection when selecting new item
+* - Singular computed properties (selectedId, selectedItem, selectedIndex, selectedValue)
+* - Perfect for tabs, radio buttons, theme selectors
+*
+* Inheritance chain: useRegistry → useSelection → useSingle
+*/
+/**
+* Creates a new single selection instance that enforces only one selected item at a time.
+*
+* Extends `createSelection` by automatically clearing previous selections when a new item is selected.
+* Adds computed singular properties: `selectedId`, `selectedItem`, `selectedIndex`, `selectedValue`.
+*
+* @param options The options for the single selection instance.
+* @template Z The type of the single selection ticket.
+* @template E The type of the single selection context.
+* @returns A new single selection instance with single-selection enforcement.
+*
+* @remarks
+* **Key Differences from `createSelection`:**
+* - Automatically clears `selectedIds` before selecting a new item (enforces single selection)
+* - Provides singular computed properties instead of plural sets
+* - Perfect for tabs, radio buttons, theme selectors, and other single-choice UI components
+*
+* **Computed Properties:**
+* - `selectedId`: The ID of the selected item (undefined if none selected)
+* - `selectedItem`: The selected ticket object (undefined if none selected)
+* - `selectedIndex`: The index of the selected item (-1 if none selected)
+* - `selectedValue`: The value of the selected item (undefined if none selected)
+*
+* **Inheritance Chain:**
+* `useRegistry` → `createSelection` → `createSingle` → `createStep`
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-single
+*
+* @example
+* ```ts
+* import { createSingle } from '@vuetify/v0'
+*
+* const tabs = createSingle({ mandatory: true })
+*
+* tabs.onboard([
+*   { id: 'home', value: 'Home' },
+*   { id: 'about', value: 'About' },
+*   { id: 'contact', value: 'Contact' },
+* ])
+*
+* tabs.first() // Select first tab
+*
+* console.log(tabs.selectedId.value) // 'home'
+* console.log(tabs.selectedIndex.value) // 0
+*
+* tabs.select('about') // Switch to about tab
+* console.log(tabs.selectedId.value) // 'about'
+* console.log(tabs.selectedIds.size) // 1 (always enforces single selection)
+* ```
+*/
+function createSingle(_options = {}) {
+	const { mandatory = false, multiple = false,...options } = _options;
+	const registry = createSelection({
+		...options,
+		mandatory,
+		multiple
+	});
+	const selectedId = computed(() => registry.selectedIds.values().next().value);
+	const selectedItem = computed(() => registry.selectedItems.value.values().next().value);
+	const selectedIndex = computed(() => selectedItem.value?.index ?? -1);
+	const selectedValue = computed(() => selectedItem.value?.value);
+	function unselect(id) {
+		if (mandatory && registry.selectedIds.size === 1) return;
+		registry.selectedIds.delete(id);
+	}
+	function toggle(id) {
+		if (registry.selectedIds.has(id)) unselect(id);
+		else registry.select(id);
+	}
+	return {
+		...registry,
+		selectedId,
+		selectedItem,
+		selectedIndex,
+		selectedValue,
+		unselect,
+		toggle,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new single selection context.
+*
+* @param 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'
+*
+* // With default namespace 'v0:single'
+* export const [useSingle, provideSingle, context] = createSingleContext()
+*
+* // In a parent component:
+* provideSingle()
+*
+* // In a child component:
+* const single = useSingle()
+* single.select('tab-1')
+* ```
+*/
+function createSingleContext(_options = {}) {
+	const { namespace = "v0:single",...options } = _options;
+	const [useSingleContext, _provideSingleContext] = createContext(namespace);
+	const context = createSingle(options);
+	function provideSingleContext(_context = context, app) {
+		return _provideSingleContext(_context, app);
+	}
+	return createTrinity(useSingleContext, provideSingleContext, context);
+}
+/**
+* Returns the current single selection instance.
+*
+* @param namespace The namespace for the single selection context. Defaults to `'v0:single'`.
+* @returns The current single selection instance.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-single
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useSingle } from '@vuetify/v0'
+*
+*   const tabs = useSingle()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Selected: {{ tabs.selectedId }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useSingle(namespace = "v0:single") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useTokens/index.ts
+/**
+* @module useTokens
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-tokens
+*
+* @remarks
+* Design token registry with alias resolution and W3C Design Tokens format support.
+*
+* Key features:
+* - Alias resolution with circular reference detection
+* - Nested token flattening with dot notation
+* - W3C Design Tokens format ($value, $type, $description, $extensions)
+* - Path-based resolution (e.g., {colors}.blue.500)
+* - Resolution caching for performance (~28,590 ops/sec)
+*
+* Used by useTheme, useLocale, and useFeatures for token-based configuration.
+*/
+/**
+* Creates a new token instance.
+*
+* @param tokens The tokens to use.
+* @param options The options for the token instance.
+* @template Z The type of the token ticket.
+* @template E The type of the token context.
+* @returns A new token instance.
+*
+* @see https://www.designtokens.org/tr/drafts/format/
+* @see https://0.vuetifyjs.com/composables/registration/use-tokens
+*
+* @example
+* ```ts
+* import { useTokens } from '@vuetify/v0'
+*
+* const tokens = useTokens({
+*   colors: {
+*     primary: '#3b82f6',
+*     secondary: '{colors.primary}', // Alias reference
+*   },
+* })
+*
+* console.log(tokens.resolve('{colors.primary}')) // '#3b82f6'
+* console.log(tokens.resolve('{colors.secondary}')) // '#3b82f6'
+* ```
+*/
+function createTokens(tokens = {}, options = {}) {
+	const logger = useLogger();
+	const registry = useRegistry(options);
+	const cache = /* @__PURE__ */ new Map();
+	registry.onboard(flatten(tokens, options.prefix, !!options.flat));
+	function isAlias(token) {
+		return /* @__PURE__ */ isString(token) && token.length > 2 && token[0] === "{" && token.at(-1) === "}";
+	}
+	function isTokenAlias(value) {
+		return /* @__PURE__ */ isObject(value) && "$value" in value;
+	}
+	function resolve(token, visited = /* @__PURE__ */ new Set()) {
+		const cacheKey = /* @__PURE__ */ isString(token) ? token : JSON.stringify(token);
+		const cached = cache.get(cacheKey);
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const reference = isTokenAlias(token) ? token.$value : token;
+		const isAliasReference = /* @__PURE__ */ isString(reference) && isAlias(reference);
+		const clean = isAliasReference ? reference.slice(1, -1) : String(reference);
+		if (visited.has(clean)) {
+			logger.warn(`Circular alias detected for "${clean}"`);
+			cache.set(cacheKey, void 0);
+			return;
+		}
+		visited.add(clean);
+		let found = registry.get(clean);
+		let segments = [];
+		if (!found && clean.includes(".")) {
+			const parts = clean.split(".");
+			for (let i = parts.length - 1; i > 0; i--) {
+				const prefix = parts.slice(0, i).join(".");
+				const suffix = parts.slice(i);
+				const candidate = registry.get(prefix);
+				if (!/* @__PURE__ */ isUndefined(candidate?.value)) {
+					found = candidate;
+					segments = suffix;
+					break;
+				}
+			}
+		}
+		if (/* @__PURE__ */ isUndefined(found?.value)) {
+			if (isAliasReference) 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 (/* @__PURE__ */ isUndefined(current)) {
+				logger.warn(`Path not found inside "${clean}": ${segments.join(".")}`);
+				cache.set(cacheKey, void 0);
+				return;
+			}
+			result = current;
+		} else if (isTokenAlias(current)) {
+			const inner = current.$value;
+			if (/* @__PURE__ */ isString(inner) && isAlias(inner)) return resolve(inner, visited);
+			result = inner;
+		} else if (/* @__PURE__ */ isString(current) && isAlias(current)) return resolve(current, visited);
+		else result = current;
+		cache.set(cacheKey, result);
+		return result;
+	}
+	return {
+		...registry,
+		resolve,
+		isAlias,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new token context.
+*
+* @param namespace The namespace for the token context.
+* @param tokens The tokens to use.
+* @template Z The type of the token ticket.
+* @template E The type of the token context.
+* @returns A new token context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-tokens
+*
+* @example
+* ```ts
+* import { createTokensContext } from '@vuetify/v0'
+*
+* export const [useTokens, provideTokens, context] = createTokensContext({
+*  namespace: 'v0:tokens',
+*  tokens: {
+*    colors: {
+*      primary: '#3b82f6',
+*      secondary: '{colors.primary}', // Alias reference
+*    },
+*  },
+* })
+* ```
+*/
+function createTokensContext(_options) {
+	const { namespace = "v0:tokens", tokens = {},...options } = _options;
+	const [useTokensContext, _provideTokensContext] = createContext(namespace);
+	const context = createTokens(tokens, options);
+	function provideTokensContext(_context = context, app) {
+		return _provideTokensContext(_context, app);
+	}
+	return createTrinity(useTokensContext, provideTokensContext, context);
+}
+/**
+* Returns the current tokens instance.
+*
+* @param namespace The namespace for the tokens context. Defaults to `'v0:tokens'`.
+* @returns The current tokens instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-tokens
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useTokens } from '@vuetify/v0'
+*
+*   const tokens = useTokens()
+* <\/script>
+* ```
+*/
+function useTokens(namespace = "v0:tokens") {
+	return useContext(namespace);
+}
+/**
+* Flattens a nested collection of tokens into a flat array of tokens.
+* Each token is represented by an object containing its ID & value.
+* @param tokens The collection of tokens to flatten.
+* @param prefix An optional prefix to prepend to each token ID.
+* @returns An array of flattened tokens, each with an ID and value.
+*/
+function flatten(tokens, prefix = "", flat = false) {
+	const flattened = [];
+	const stack = [{
+		tokens,
+		prefix,
+		flat
+	}];
+	while (stack.length > 0) {
+		const { tokens: currentTokens, prefix: currentPrefix, flat: flat$1 } = stack.pop();
+		const meta = {};
+		for (const k in currentTokens) if (k.startsWith("$")) meta[k] = currentTokens[k];
+		if (Object.keys(meta).length > 0 && currentPrefix) flattened.push({
+			id: currentPrefix,
+			value: meta
+		});
+		for (const key in currentTokens) {
+			if (key.startsWith("$")) continue;
+			const value = currentTokens[key];
+			const id = currentPrefix ? `${currentPrefix}.${key}` : key;
+			if (!/* @__PURE__ */ isObject(value)) {
+				flattened.push({
+					id,
+					value
+				});
+				continue;
+			}
+			if ("$value" in value) {
+				flattened.push({
+					id,
+					value
+				});
+				const inner = value.$value;
+				if (/* @__PURE__ */ isObject(inner) && !flat$1) for (const innerKey in inner) {
+					if (innerKey.startsWith("$")) continue;
+					const child = inner[innerKey];
+					const childId = `${id}.${innerKey}`;
+					if (!/* @__PURE__ */ isObject(child)) flattened.push({
+						id: childId,
+						value: child
+					});
+					else if ("$value" in child) flattened.push({
+						id: childId,
+						value: child
+					});
+					else stack.push({
+						tokens: child,
+						prefix: childId,
+						flat: flat$1
+					});
+				}
+				continue;
+			}
+			if (flat$1) {
+				flattened.push({
+					id,
+					value
+				});
+				continue;
+			}
+			stack.push({
+				tokens: value,
+				prefix: id,
+				flat: flat$1
+			});
+		}
+	}
+	return flattened;
+}
+
+//#endregion
+//#region src/composables/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 ({0}, {1}) and named ({name}) variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && /* @__PURE__ */ isObject(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return /* @__PURE__ */ isUndefined(variables[name]) ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (!/* @__PURE__ */ isUndefined(params[idx])) return String(params[idx]);
+			return match;
+		});
+		return resolvedMessage;
+	}
+	n(value, locale, ...params) {
+		if (!IN_BROWSER || !locale) return value.toString();
+		const options = params[0];
+		return new Intl.NumberFormat(String(locale), options).format(value);
+	}
+};
+
+//#endregion
+//#region src/composables/useLocale/index.ts
+/**
+* @module useLocale
+*
+* @remarks
+* Internationalization (i18n) composable with adapter pattern for message translation.
+*
+* Key features:
+* - Locale selection with createSingle
+* - Token-based message storage with useTokens
+* - Numbered and named placeholder support ({0}, {name})
+* - Number formatting with Intl.NumberFormat
+* - Adapter pattern for integration with i18n providers
+*
+* Integrates with createSingle for locale selection and useTokens for message resolution.
+*/
+/**
+* Creates a new locale instance.
+*
+* @param options The options for the locale instance.
+* @template Z The type of the locale ticket.
+* @template E The type of the locale context.
+* @returns A new locale instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-locale
+*/
+function createLocale(_options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {},...options } = _options;
+	const tokens = createTokens(messages);
+	const registry = createSingle(options);
+	for (const id in messages) {
+		registry.register({ id });
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	function t(key, params, fallback) {
+		const locale = registry.selectedId.value;
+		const args = toArray(params);
+		if (!locale) return adapter.t(fallback ?? key, ...args);
+		const path = `${locale}.${key}`;
+		const message = tokens.get(path)?.value;
+		const template = /* @__PURE__ */ isString(message) ? resolve(locale, message) : fallback ?? key;
+		return adapter.t(template, ...args);
+	}
+	function n(value, ...params) {
+		return adapter.n(value, registry.selectedId.value, ...params);
+	}
+	function resolve(locale, str) {
+		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, key) => {
+			const [prefix, ...rest] = key.split(".");
+			const target = registry.has(prefix) ? prefix : locale;
+			const path = `${target}.${registry.has(prefix) ? rest.join(".") : key}`;
+			const resolved = tokens.get(path)?.value;
+			if (/* @__PURE__ */ isString(resolved)) return resolve(target, resolved);
+			return match;
+		});
+	}
+	return {
+		...registry,
+		t,
+		n,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+function createLocaleFallback() {
+	return {
+		size: 0,
+		t: (key, _params, fallback) => fallback ?? key,
+		n: String
+	};
+}
+/**
+* Creates a new locale context.
+*
+* @param options The options for the locale context.
+* @template Z The type of the locale ticket.
+* @template E The type of the locale context.
+* @returns A new locale context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-locale
+*
+* @example
+* ```ts
+* import { createLocaleContext } from '@vuetify/v0'
+*
+* export const [useAppLocale, provideAppLocale, appLocale] = createLocaleContext({
+*   namespace: 'app:locale',
+*   messages: {
+*     en: { hello: 'Hello' },
+*     es: { hello: 'Hola' },
+*   },
+* })
+*
+* // In a parent component:
+* provideAppLocale()
+*
+* // In a child component:
+* const locale = useAppLocale()
+* locale.select('es')
+* ```
+*/
+function createLocaleContext(_options = {}) {
+	const { namespace = "v0:locale",...options } = _options;
+	const [useLocaleContext, _provideLocaleContext] = createContext(namespace);
+	const context = createLocale(options);
+	function provideLocaleContext(_context = context, app) {
+		return _provideLocaleContext(_context, app);
+	}
+	return createTrinity(useLocaleContext, provideLocaleContext, context);
+}
+/**
+* Creates a new locale plugin.
+*
+* @param options The options for the locale plugin.
+* @template Z The type of the locale ticket.
+* @template E The type of the locale context.
+* @template R The type of the token ticket.
+* @template O The type of the token context.
+* @returns A new locale plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-locale
+*/
+function createLocalePlugin(_options = {}) {
+	const { namespace = "v0:locale", adapter = new Vuetify0LocaleAdapter(), messages = {},...options } = _options;
+	const [, provideLocaleContext, context] = createLocaleContext({
+		...options,
+		namespace,
+		adapter,
+		messages
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			provideLocaleContext(context, app);
+		}
+	});
+}
+/**
+* Returns the current locale instance.
+*
+* @returns The current locale instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-locale
+*/
+function useLocale(namespace = "v0:locale") {
+	const fallback = createLocaleFallback();
+	if (!getCurrentInstance()) return fallback;
+	try {
+		return useContext(namespace, fallback);
+	} catch {
+		return fallback;
+	}
+}
+
+//#endregion
+//#region src/composables/useStep/index.ts
+/**
+* @module useStep
+*
+* @remarks
+* Navigation composable that extends useSingle with first/last/next/prev/step methods.
+*
+* Key features:
+* - Configurable circular or bounded navigation
+* - Automatic disabled item skipping
+* - Arbitrary step counts (positive/negative)
+* - Perfect for wizards, carousels, pagination, onboarding flows
+*
+* Inheritance chain: useRegistry → useSelection → useSingle → useStep
+*/
+/**
+* Creates a new step instance with navigation through items.
+*
+* Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
+* for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
+*
+* @param options The options for the step instance.
+* @template Z The type of the step ticket.
+* @template E The type of the step context.
+* @returns A new step instance with navigation methods.
+*
+* @remarks
+* **Key Features:**
+* - **Configurable Navigation**: `circular: true` for wrapping, `false` for bounded (default: false)
+* - **Disabled Item Skipping**: Automatically skips disabled items during navigation
+* - **Bidirectional**: Forward (`next`, positive `step`) and backward (`prev`, negative `step`)
+* - **Safe Edge Cases**: Handles empty registries and all-disabled scenarios gracefully
+*
+* **Navigation Methods:**
+* - `first()`: Select first non-disabled item
+* - `last()`: Select last non-disabled item
+* - `next()`: Move to next item (wraps if circular, stops at end if bounded)
+* - `prev()`: Move to previous item (wraps if circular, stops at start if bounded)
+* - `step(count)`: Move by `count` positions (negative for backward)
+*
+* **Circular Mode (`circular: true`):**
+* - Uses modulo arithmetic for wrapping: `((index % length) + length) % length`
+* - Works correctly with negative indexes and large step counts
+* - Perfect for carousels, theme switchers, infinite scrolling
+*
+* **Bounded Mode (`circular: false`, default):**
+* - Navigation stops at boundaries (no wrapping)
+* - `next()` on last item does nothing
+* - `prev()` on first item does nothing
+* - Perfect for pagination, wizards with explicit completion, forms
+*
+* **Inheritance Chain:**
+* `useRegistry` → `createSelection` → `createSingle` → `createStep`
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-step
+*
+* @example
+* ```ts
+* import { createStep } from '@vuetify/v0'
+*
+* // Bounded navigation (default) - for pagination
+* const pagination = createStep({ circular: false })
+* pagination.onboard([
+*   { id: 'page-1', value: 1 },
+*   { id: 'page-2', value: 2 },
+*   { id: 'page-3', value: 3 },
+* ])
+* pagination.first() // Select page 1
+* pagination.prev() // Does nothing (already at first)
+* pagination.next() // Select page 2
+*
+* // Circular navigation - for carousels
+* const carousel = createStep({ circular: true })
+* carousel.onboard([
+*   { id: 'slide-1', value: 'First' },
+*   { id: 'slide-2', value: 'Second' },
+*   { id: 'slide-3', value: 'Third' },
+* ])
+* carousel.first()
+* carousel.prev() // Wraps to 'slide-3'
+* carousel.next() // Wraps to 'slide-1'
+* ```
+*/
+function createStep(_options = {}) {
+	const { circular = false,...options } = _options;
+	const registry = createSingle(options);
+	function first() {
+		const ticket = registry.seek("first");
+		if (ticket) registry.select(ticket.id);
+	}
+	function last() {
+		const ticket = registry.seek("last");
+		if (ticket) registry.select(ticket.id);
+	}
+	function next() {
+		step(1);
+	}
+	function prev() {
+		step(-1);
+	}
+	function wrapped(length, index) {
+		return (index % length + length) % length;
+	}
+	function step(count = 1) {
+		const length = registry.size;
+		if (!length) return;
+		const currentIndex = registry.selectedIndex.value;
+		const direction = Math.sign(count || 1);
+		let hops = 0;
+		let index = circular ? wrapped(length, currentIndex + count) : currentIndex + count;
+		if (!circular && (index < 0 || index >= length)) return;
+		let id = registry.lookup(index);
+		while (!/* @__PURE__ */ isUndefined(id) && toValue(registry.get(id)?.disabled) && hops < length) {
+			index = circular ? wrapped(length, index + direction) : index + direction;
+			if (!circular && (index < 0 || index >= length)) return;
+			id = registry.lookup(index);
+			hops++;
+		}
+		if (/* @__PURE__ */ isUndefined(id) || 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 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'
+*
+* // With default namespace 'v0:step'
+* export const [useStep, provideStep, context] = createStepContext()
+*
+* // In a parent component:
+* provideStep()
+*
+* // In a child component:
+* const context = useStep()
+* context.next() // Progress to next step
+* ```
+*/
+function createStepContext(_options = {}) {
+	const { namespace = "v0:step",...options } = _options;
+	const [useStepContext, _provideStepContext] = createContext(namespace);
+	const context = createStep(options);
+	function provideStepContext(_context = context, app) {
+		return _provideStepContext(_context, app);
+	}
+	return createTrinity(useStepContext, provideStepContext, context);
+}
+/**
+* Returns the current step instance.
+*
+* @param namespace The namespace for the step context. Defaults to `'v0:step'`.
+* @returns The current step instance.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-step
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useStep } from '@vuetify/v0'
+*
+*   const wizard = useStep()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Current step: {{ wizard.selectedIndex }}</p>
+*     <button @click="wizard.next()">Next</button>
+*   </div>
+* </template>
+* ```
+*/
+function useStep(namespace = "v0:step") {
+	return useContext(namespace);
+}
+
+//#endregion
+export { createGroupContext as A, createLogger as B, useResizeObserver as C, createHydrationPlugin as D, createHydrationContext as E, createSelection as F, PinoLoggerAdapter as G, createLoggerPlugin as H, createSelectionContext as I, createTrinity as J, ConsolaLoggerAdapter as K, useSelection as L, useProxyRegistry as M, useProxyModel as N, useHydration as O, toArray as P, createRegistryContext as R, useElementSize as S, createHydration as T, useLogger as U, createLoggerContext as V, Vuetify0LoggerAdapter as W, provideContext as X, createContext as Y, useContext as Z, createPaginationContext as _, createLocaleContext as a, createOverflowContext as b, useLocale as c, createTokensContext as d, useTokens as f, createPagination as g, useSingle as h, createLocale as i, useGroup as j, createGroup as k, Vuetify0LocaleAdapter as l, createSingleContext as m, createStepContext as n, createLocaleFallback as o, createSingle as p, createPlugin as q, useStep as r, createLocalePlugin as s, createStep as t, createTokens as u, usePagination as v, createFallbackHydration as w, useOverflow as x, createOverflow as y, useRegistry as z };