@vuetify/v0 0.0.13 → 0.0.15

package/dist/browser/index.js

@@ -1,4 +1,4 @@
-import { computed, createBlock, createCommentVNode, createPropsRestProxy, defineComponent, getCurrentInstance, getCurrentScope, guardReactiveProps, inject, isRef, mergeModels, mergeProps, normalizeProps, normalizeStyle, onMounted, onScopeDispose, onUnmounted, openBlock, provide, reactive, readonly, ref, renderSlot, resolveDynamicComponent, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, useAttrs, useId, useModel, useTemplateRef, vShow, watch, withCtx, withDirectives } from "vue";
+import { computed, createBlock, createCommentVNode, createPropsRestProxy, createTextVNode, defineComponent, effectScope, getCurrentInstance, guardReactiveProps, inject, isRef, mergeModels, mergeProps, normalizeProps, normalizeStyle, onBeforeUnmount, onMounted, onScopeDispose, onUnmounted, openBlock, provide, reactive, readonly, ref, renderSlot, resolveDynamicComponent, shallowReactive, shallowReadonly, shallowRef, toDisplayString, toRef, toValue, unref, useAttrs, useId, useModel, useTemplateRef, vShow, watch, withCtx, withDirectives } from "vue";
 
 //#region src/constants/htmlElements.ts
 const selfClosingTags = [
@@ -119,6 +119,10 @@ function isPrimitive(item) {
 	return typeof item === "string" || typeof item === "number" || typeof item === "boolean";
 }
 /* @__NO_SIDE_EFFECTS__ */
+function isNaN(item) {
+	return /* @__PURE__ */ isNumber(item) && Number.isNaN(item);
+}
+/* @__NO_SIDE_EFFECTS__ */
 function mergeDeep(target, ...sources) {
 	if (sources.length === 0) return target;
 	const source = sources.shift();
@@ -137,10 +141,78 @@ function mergeDeep(target, ...sources) {
 function genId() {
 	return Math.random().toString(36).slice(2, 9);
 }
+/**
+* Clamps a value between a minimum and maximum
+*
+* @param value The value to clamp
+* @param min The minimum value (default: 0)
+* @param max The maximum value (default: 1)
+* @returns The clamped value
+*
+* @example
+* ```ts
+* clamp(5, 0, 10)  // 5
+* clamp(-5, 0, 10) // 0
+* clamp(15, 0, 10) // 10
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function clamp(value, min = 0, max = 1) {
+	return Math.max(min, Math.min(max, value));
+}
+/**
+* Creates an array of sequential numbers
+*
+* @param length The length of the array to create
+* @param start The starting index (default: 0)
+* @returns An array of sequential numbers
+*
+* @example
+* ```ts
+* range(3)     // [0, 1, 2]
+* range(3, 1)  // [1, 2, 3]
+* range(5, 10) // [10, 11, 12, 13, 14]
+* range(0)     // []
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function range(length, start = 0) {
+	return Array.from({ length }, (_, index) => start + index);
+}
+/**
+* Debounces a function call by the specified delay
+*
+* @param fn The function to debounce
+* @param delay The delay in milliseconds
+* @returns A debounced function with clear and immediate methods
+*
+* @example
+* ```ts
+* const debouncedFn = debounce(() => console.log('called'), 500)
+* debouncedFn()        // Will call after 500ms
+* debouncedFn.clear()  // Cancel pending call
+* debouncedFn.immediate() // Call immediately
+* ```
+*/
+function debounce(fn, delay) {
+	let timeoutId;
+	function debounced(...args) {
+		if (!/* @__PURE__ */ isUndefined(timeoutId)) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => fn(...args), delay);
+	}
+	debounced.clear = () => {
+		if (!/* @__PURE__ */ isUndefined(timeoutId)) clearTimeout(timeoutId);
+	};
+	debounced.immediate = (...args) => {
+		debounced.clear();
+		fn(...args);
+	};
+	return debounced;
+}
 
 //#endregion
 //#region src/components/Atom/Atom.vue
-const _sfc_main$18 = /* @__PURE__ */ defineComponent({
+const _sfc_main$25 = /* @__PURE__ */ defineComponent({
 	name: "Atom",
 	__name: "Atom",
 	props: {
@@ -171,7 +243,7 @@ const _sfc_main$18 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var Atom_default = _sfc_main$18;
+var Atom_default = _sfc_main$25;
 
 //#endregion
 //#region src/composables/createContext/index.ts
@@ -210,7 +282,7 @@ var Atom_default = _sfc_main$18;
 */
 function useContext(key, defaultValue) {
 	const context = inject(key, defaultValue);
-	if (context === void 0) throw new Error(`Context "${String(key)}" not found. Ensure it's provided by an ancestor.`);
+	if (/* @__PURE__ */ isUndefined(context)) throw new Error(`Context "${String(key)}" not found. Ensure it's provided by an ancestor.`);
 	return context;
 }
 /**
@@ -528,6 +600,95 @@ function toReactive(objectRef) {
 	}));
 }
 
+//#endregion
+//#region src/composables/useEventListener/index.ts
+/**
+* @module useEventListener
+*
+* @remarks
+* Event listener composable with automatic cleanup on scope disposal.
+*
+* Key features:
+* - Supports Window, Document, and HTMLElement targets
+* - Reactive targets, events, and listeners
+* - Event options support (capture, passive, once)
+* - Automatic removeEventListener on unmount
+* - Multiple overloads for type safety
+*
+* Perfect for safely managing event listeners in Vue components.
+*/
+/**
+* Attaches an event listener to a target.
+*
+* @param target The target to attach the event listener to.
+* @param event The event to listen for.
+* @param listener The event listener.
+* @param options The event listener options.
+* @returns A function to remove the event listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-event-listener
+*/
+function useEventListener(target, event, listener, options) {
+	const cleanups = [];
+	function cleanup() {
+		for (const fn of cleanups) fn();
+		cleanups.length = 0;
+	}
+	function register(el, event$1, listener$1, options$1) {
+		el.addEventListener(event$1, listener$1, options$1);
+		return () => el.removeEventListener(event$1, listener$1, options$1);
+	}
+	const stopWatcher = watch(() => [
+		toValue(target),
+		toValue(event),
+		unref(listener),
+		toValue(options)
+	], ([el, events, listeners, opts]) => {
+		cleanup();
+		if (!el) return;
+		const eventList = toArray(events);
+		const listenerList = toArray(listeners);
+		for (const event$1 of eventList) for (const listenerFn of listenerList) cleanups.push(register(el, event$1, listenerFn, opts));
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	function stop() {
+		stopWatcher();
+		cleanup();
+	}
+	onScopeDispose(stop, true);
+	return stop;
+}
+/**
+* Attaches an event listener to the window.
+*
+* @param event The event to listen for.
+* @param listener The event listener.
+* @param options The event listener options.
+* @template E The event type.
+* @returns A function to remove the event listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-event-listener
+*/
+function useWindowEventListener(event, listener, options) {
+	return useEventListener(window, event, listener, options);
+}
+/**
+* Attaches an event listener to the document.
+*
+* @param event The event to listen for.
+* @param listener The event listener.
+* @param options The event listener options.
+* @template E The event type.
+* @returns A function to remove the event listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-event-listener
+*/
+function useDocumentEventListener(event, listener, options) {
+	return useEventListener(document, event, listener, options);
+}
+
 //#endregion
 //#region src/composables/useHydration/index.ts
 /**
@@ -574,6 +735,12 @@ function createHydration() {
 		hydrate
 	};
 }
+function createFallbackHydration() {
+	return {
+		isHydrated: shallowReadonly(shallowRef(true)),
+		hydrate: () => {}
+	};
+}
 /**
 * Creates a new hydration context trinity.
 *
@@ -666,7 +833,13 @@ function createHydrationPlugin(_options = {}) {
 * ```
 */
 function useHydration(namespace = "v0:hydration") {
-	return useContext(namespace);
+	const fallback = createFallbackHydration();
+	if (!getCurrentInstance()) return fallback;
+	try {
+		return useContext(namespace, fallback);
+	} catch {
+		return fallback;
+	}
 }
 
 //#endregion
@@ -677,7 +850,7 @@ const SUPPORTS_MATCH_MEDIA = IN_BROWSER && "matchMedia" in window && typeof wind
 const SUPPORTS_OBSERVER = IN_BROWSER && "ResizeObserver" in window;
 const SUPPORTS_INTERSECTION_OBSERVER = IN_BROWSER && "IntersectionObserver" in window;
 const SUPPORTS_MUTATION_OBSERVER = IN_BROWSER && "MutationObserver" in window;
-const version = "0.0.13";
+const version = "0.0.15";
 const __LOGGER_ENABLED__ = false;
 
 //#endregion
@@ -908,9 +1081,9 @@ function createBreakpointsPlugin(_options = {}) {
 				const unwatch = watch(hydration.isHydrated, (hydrated) => {
 					if (hydrated) listener();
 				}, { immediate: true });
-				window.addEventListener("resize", listener, { passive: true });
+				const cleanup = useWindowEventListener("resize", listener, { passive: true });
 				onScopeDispose(() => {
-					window.removeEventListener("resize", listener);
+					cleanup();
 					unwatch();
 				}, true);
 			} });
@@ -945,95 +1118,6 @@ function useBreakpoints(namespace = "v0:breakpoints") {
 	return useContext(namespace);
 }
 
-//#endregion
-//#region src/composables/useEventListener/index.ts
-/**
-* @module useEventListener
-*
-* @remarks
-* Event listener composable with automatic cleanup on scope disposal.
-*
-* Key features:
-* - Supports Window, Document, and HTMLElement targets
-* - Reactive targets, events, and listeners
-* - Event options support (capture, passive, once)
-* - Automatic removeEventListener on unmount
-* - Multiple overloads for type safety
-*
-* Perfect for safely managing event listeners in Vue components.
-*/
-/**
-* Attaches an event listener to a target.
-*
-* @param target The target to attach the event listener to.
-* @param event The event to listen for.
-* @param listener The event listener.
-* @param options The event listener options.
-* @returns A function to remove the event listener.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-event-listener
-*/
-function useEventListener(target, event, listener, options) {
-	const cleanups = [];
-	function cleanup() {
-		for (const fn of cleanups) fn();
-		cleanups.length = 0;
-	}
-	function register(el, event$1, listener$1, options$1) {
-		el.addEventListener(event$1, listener$1, options$1);
-		return () => el.removeEventListener(event$1, listener$1, options$1);
-	}
-	const stopWatcher = watch(() => [
-		toValue(target),
-		toValue(event),
-		unref(listener),
-		toValue(options)
-	], ([el, events, listeners, opts]) => {
-		cleanup();
-		if (!el) return;
-		const eventList = toArray(events);
-		const listenerList = toArray(listeners);
-		for (const event$1 of eventList) for (const listenerFn of listenerList) cleanups.push(register(el, event$1, listenerFn, opts));
-	}, {
-		immediate: true,
-		flush: "post"
-	});
-	function stop() {
-		stopWatcher();
-		cleanup();
-	}
-	onScopeDispose(stop, true);
-	return stop;
-}
-/**
-* Attaches an event listener to the window.
-*
-* @param event The event to listen for.
-* @param listener The event listener.
-* @param options The event listener options.
-* @template E The event type.
-* @returns A function to remove the event listener.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-event-listener
-*/
-function useWindowEventListener(event, listener, options) {
-	return useEventListener(window, event, listener, options);
-}
-/**
-* Attaches an event listener to the document.
-*
-* @param event The event to listen for.
-* @param listener The event listener.
-* @param options The event listener options.
-* @template E The event type.
-* @returns A function to remove the event listener.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-event-listener
-*/
-function useDocumentEventListener(event, listener, options) {
-	return useEventListener(document, event, listener, options);
-}
-
 //#endregion
 //#region src/composables/useLogger/adapters/consola.ts
 var ConsolaLoggerAdapter = class {
@@ -1454,6 +1538,9 @@ function useRegistry(options) {
 	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);
@@ -1488,13 +1575,15 @@ function useRegistry(options) {
 		let value = existing.value;
 		let valueIsIndex = existing.valueIsIndex;
 		if (hasValue) {
-			if (patch.value === void 0) {
+			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);
@@ -1514,9 +1603,11 @@ function useRegistry(options) {
 		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) {
@@ -1566,25 +1657,39 @@ function useRegistry(options) {
 		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() {
-		if (catalog.size > 0) catalog.clear();
-		if (directory.size > 0) directory.clear();
+		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 values()) {
-			if (ticket.index !== index) {
-				ticket.index = index;
-				if (ticket.valueIsIndex) ticket.value = index;
+		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);
-			assign(ticket.value, ticket.id);
 			index++;
 		}
+		needsReindex = false;
+		minDirtyIndex = Infinity;
 		emit("reindex:registry");
 	}
 	function register(registration = {}) {
@@ -1598,6 +1703,7 @@ function useRegistry(options) {
 		const index = registration.index ?? size;
 		const value = valueIsUndefined ? index : registration.value;
 		const valueIsIndex = valueIsUndefined;
+		if (valueIsIndex) indexDependentCount++;
 		const ticket = {
 			...registration,
 			id,
@@ -1615,15 +1721,40 @@ function useRegistry(options) {
 	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);
-		reindex();
+		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") {
@@ -1660,8 +1791,9 @@ function useRegistry(options) {
 		reindex,
 		seek,
 		onboard(registrations) {
-			return registrations.map((registration) => this.register(registration));
+			return registrations.map((registration) => register(registration));
 		},
+		offboard,
 		get size() {
 			return collection.size;
 		}
@@ -1682,7 +1814,11 @@ function useRegistry(options) {
 * ```ts
 * import { createRegistryContext } from '@vuetify/v0'
 *
-* export const [useItems, provideItems, items] = createRegistryContext('items')
+* // 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()
@@ -1692,8 +1828,8 @@ function useRegistry(options) {
 * items.register({ id: 'item-1', value: 'Value 1' })
 * ```
 */
-function createRegistryContext(_options) {
-	const { namespace,...options } = _options;
+function createRegistryContext(_options = {}) {
+	const { namespace = "v0:registry",...options } = _options;
 	const [useRegistryContext, _provideRegistryContext] = createContext(namespace);
 	const context = useRegistry(options);
 	function provideRegistryContext(_context = context, app) {
@@ -1804,12 +1940,12 @@ function createSelection(_options = {}) {
 		const id = registration.id ?? /* @__PURE__ */ genId();
 		const item = {
 			disabled: false,
-			...registration,
-			id,
-			isSelected: toRef(() => selected(id)),
 			select: () => select(id),
 			unselect: () => unselect(id),
-			toggle: () => toggle(id)
+			toggle: () => toggle(id),
+			isSelected: toRef(() => selected(id)),
+			...registration,
+			id
 		};
 		const ticket = registry.register(item);
 		if (enroll && !toValue(item.disabled)) selectedIds.add(ticket.id);
@@ -1820,6 +1956,13 @@ function createSelection(_options = {}) {
 		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();
@@ -1833,6 +1976,8 @@ function createSelection(_options = {}) {
 		selectedValues,
 		register,
 		unregister,
+		onboard,
+		offboard,
 		reset,
 		mandate,
 		seek,
@@ -1848,7 +1993,6 @@ function createSelection(_options = {}) {
 /**
 * Creates a new selection context.
 *
-* @param namespace The namespace for the selection context.
 * @param options The options for the selection context.
 * @template Z The type of the selection ticket.
 * @template E The type of the selection context.
@@ -1860,7 +2004,11 @@ function createSelection(_options = {}) {
 * ```ts
 * import { createSelectionContext } from '@vuetify/v0'
 *
-* export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext('checkboxes')
+* // 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()
@@ -1870,8 +2018,8 @@ function createSelection(_options = {}) {
 * checkboxes.select('checkbox-1')
 * ```
 */
-function createSelectionContext(_options) {
-	const { namespace,...options } = _options;
+function createSelectionContext(_options = {}) {
+	const { namespace = "v0:selection",...options } = _options;
 	const [useSelectionContext, _provideSelectionContext] = createContext(namespace);
 	const context = createSelection(options);
 	function provideSelectionContext(_context = context, app) {
@@ -1907,31 +2055,102 @@ function useSelection(namespace = "v0:selection") {
 }
 
 //#endregion
-//#region src/composables/useGroup/index.ts
+//#region src/composables/useProxyRegistry/index.ts
 /**
-* @module useGroup
+* @module useProxyRegistry
 *
 * @remarks
-* Multi-selection composable that extends useSelection with batch operation support.
+* Proxy composable for reactive registry keys, values, entries, and size.
 *
 * Key features:
-* - Batch operations (select/unselect/toggle accept ID | ID[])
-* - selectedIndexes computed Set for position-based tracking
-* - Perfect for checkboxes, multi-select dropdowns, filter panels
+* - 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
 *
-* Inheritance chain: useRegistry → useSelection → useGroup
-* Extended by: useFeatures
+* Perfect for exposing registry data as reactive computed properties.
 */
 /**
-* Creates a new group instance with batch selection operations.
+* 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 `selectedIndexes` computed property.
+* 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 support.
+* @returns A new group instance with batch selection and tri-state support.
 *
 * @remarks
 * **Key Differences from `createSelection`:**
@@ -1939,13 +2158,22 @@ function useSelection(namespace = "v0:selection") {
 * - `unselect()` accepts `ID | ID[]` for batch operations
 * - `toggle()` accepts `ID | ID[]` for batch operations
 * - Adds `selectedIndexes` computed Set for getting selected item indexes
-* - Perfect for checkboxes, multi-select dropdowns, and bulk operations
+* - 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 batch operations
+* - Disabled items are automatically skipped in select operations
 * - Non-existent IDs are silently ignored
 *
 * **Inheritance Chain:**
@@ -1974,45 +2202,148 @@ function useSelection(namespace = "v0:selection") {
 * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
 * console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
 *
-* // Toggle operations
-* checkboxes.toggle(['option-a', 'option-b'])
-* console.log(checkboxes.selectedIds) // Set { 'option-b', 'option-c' }
+* // 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 registry = createSelection({
+	const selection = createSelection({
 		...options,
 		mandatory,
-		multiple
+		multiple,
+		events: true
 	});
+	const proxy = useProxyRegistry(selection);
+	const mixedIds = shallowReactive(/* @__PURE__ */ new Set());
 	const selectedIndexes = computed(() => {
-		return new Set(Array.from(registry.selectedItems.value).map((item) => item?.index));
+		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)) registry.select(id);
+		for (const id of toArray(ids)) {
+			mixedIds.delete(id);
+			selection.select(id);
+		}
 	}
 	function unselect(ids) {
-		for (const id of toArray(ids)) registry.unselect(id);
+		for (const id of toArray(ids)) selection.unselect(id);
 	}
 	function toggle(ids) {
-		for (const id of toArray(ids)) registry.toggle(id);
+		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 {
-		...registry,
+		...selection,
+		mixed,
+		mix,
+		unmix,
 		select,
 		unselect,
 		toggle,
+		register,
+		unregister,
+		offboard,
+		onboard,
+		reset,
+		selectAll,
+		unselectAll,
+		toggleAll,
+		mixedIds,
+		mixedItems,
 		selectedIndexes,
+		isNoneSelected,
+		isAllSelected,
+		isMixed,
 		get size() {
-			return registry.size;
+			return selection.size;
 		}
 	};
 }
 /**
 * Creates a new group context.
 *
-* @param namespace The namespace for the group context.
 * @param options The options for the group context.
 * @template Z The type of the group ticket.
 * @template E The type of the group context.
@@ -2024,7 +2355,11 @@ function createGroup(_options = {}) {
 * ```ts
 * import { createGroupContext } from '@vuetify/v0'
 *
-* export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext('my-group')
+* // 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()
@@ -2033,8 +2368,8 @@ function createGroup(_options = {}) {
 * const group = useMyGroup()
 * ```
 */
-function createGroupContext(_options) {
-	const { namespace,...options } = _options;
+function createGroupContext(_options = {}) {
+	const { namespace = "v0:group",...options } = _options;
 	const [useGroupContext, _provideGroupContext] = createContext(namespace);
 	const context = createGroup(options);
 	function provideGroupContext(_context = context, app) {
@@ -2065,7 +2400,7 @@ function createGroupContext(_options) {
 * </template>
 * ```
 */
-function useGroup(namespace) {
+function useGroup(namespace = "v0:group") {
 	return useContext(namespace);
 }
 
@@ -2129,9 +2464,10 @@ function createTokens(tokens = {}, options = {}) {
 	function resolve(token, visited = /* @__PURE__ */ new Set()) {
 		const cacheKey = /* @__PURE__ */ isString(token) ? token : JSON.stringify(token);
 		const cached = cache.get(cacheKey);
-		if (cached !== void 0) return cached;
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
 		const reference = isTokenAlias(token) ? token.$value : token;
-		const clean = /* @__PURE__ */ isString(reference) && isAlias(reference) ? reference.slice(1, -1) : String(reference);
+		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);
@@ -2146,15 +2482,15 @@ function createTokens(tokens = {}, options = {}) {
 				const prefix = parts.slice(0, i).join(".");
 				const suffix = parts.slice(i);
 				const candidate = registry.get(prefix);
-				if (candidate?.value !== void 0) {
+				if (!/* @__PURE__ */ isUndefined(candidate?.value)) {
 					found = candidate;
 					segments = suffix;
 					break;
 				}
 			}
 		}
-		if (found?.value === void 0) {
-			logger.warn(`Alias not found for "${String(reference)}"`);
+		if (/* @__PURE__ */ isUndefined(found?.value)) {
+			if (isAliasReference) logger.warn(`Alias not found for "${String(reference)}"`);
 			cache.set(cacheKey, void 0);
 			return;
 		}
@@ -2170,7 +2506,7 @@ function createTokens(tokens = {}, options = {}) {
 				current = current[segment];
 				if (isTokenAlias(current)) current = current.$value;
 			}
-			if (current === void 0) {
+			if (/* @__PURE__ */ isUndefined(current)) {
 				logger.warn(`Path not found inside "${clean}": ${segments.join(".")}`);
 				cache.set(cacheKey, void 0);
 				return;
@@ -2221,7 +2557,7 @@ function createTokens(tokens = {}, options = {}) {
 * ```
 */
 function createTokensContext(_options) {
-	const { namespace, tokens = {},...options } = _options;
+	const { namespace = "v0:tokens", tokens = {},...options } = _options;
 	const [useTokensContext, _provideTokensContext] = createContext(namespace);
 	const context = createTokens(tokens, options);
 	function provideTokensContext(_context = context, app) {
@@ -2541,7 +2877,7 @@ function defaultFilter(query, item, keys, mode = "some") {
 * @template Z The type of the items.
 * @returns The filtered items.
 *
-* @see https://0.vuetifyjs.com/composables/selection/use-filter
+* @see https://0.vuetifyjs.com/composables/utilities/use-filter
 *
 * @example
 * ```ts
@@ -2641,7 +2977,7 @@ function createForm(options) {
 			if (ticket.isValid.value === false) return false;
 			if (ticket.isValid.value === null) return null;
 		}
-		return hasFields || null;
+		return hasFields ? true : null;
 	});
 	function reset() {
 		for (const ticket of registry.values()) ticket.reset();
@@ -2731,7 +3067,6 @@ function createForm(options) {
 /**
 * Creates a new form context.
 *
-* @param namespace The namespace for the form context.
 * @param options The options for the form context.
 * @template Z The type of the form ticket.
 * @template E The type of the form context.
@@ -2743,7 +3078,12 @@ function createForm(options) {
 * ```ts
 * import { createFormContext } from '@vuetify/v0'
 *
-* export const [useMyForm, provideMyForm, myForm] = createFormContext('my-form', {
+* // With default namespace 'v0:form'
+* export const [useMyForm, provideMyForm, myForm] = createFormContext({ validateOn: 'change' })
+*
+* // Or with custom namespace
+* export const [useMyForm, provideMyForm, myForm] = createFormContext({
+*   namespace: 'my-form',
 *   validateOn: 'change',
 * })
 *
@@ -2755,8 +3095,8 @@ function createForm(options) {
 * form.register({ id: 'field', value: ref(''), rules: [...] })
 * ```
 */
-function createFormContext(_options) {
-	const { namespace,...options } = _options;
+function createFormContext(_options = {}) {
+	const { namespace = "v0:form",...options } = _options;
 	const [useFormContext, _provideFormContext] = createContext(namespace);
 	const context = createForm(options);
 	function provideFormContext(_context = context, app) {
@@ -2853,6 +3193,7 @@ function useIntersectionObserver(target, callback, options = {}) {
 	const observer = shallowRef();
 	const isPaused = shallowRef(false);
 	const isIntersecting = shallowRef(false);
+	const isActive = toRef(() => !!observer.value);
 	function setup() {
 		if (!isHydrated.value || !SUPPORTS_INTERSECTION_OBSERVER || !target.value || isPaused.value) return;
 		observer.value = new IntersectionObserver((entries) => {
@@ -2906,10 +3247,11 @@ function useIntersectionObserver(target, callback, options = {}) {
 	function stop() {
 		cleanup();
 	}
-	onUnmounted(stop);
+	onScopeDispose(stop, true);
 	return {
-		isIntersecting: readonly(isIntersecting),
-		isPaused: readonly(isPaused),
+		isActive: shallowReadonly(isActive),
+		isIntersecting: shallowReadonly(isIntersecting),
+		isPaused: shallowReadonly(isPaused),
 		pause,
 		resume,
 		stop
@@ -2946,7 +3288,7 @@ function useIntersectionObserver(target, callback, options = {}) {
 function useElementIntersection(target, options = {}) {
 	const isIntersecting = shallowRef(false);
 	const intersectionRatio = shallowRef(0);
-	const { pause: _pause, resume, stop, isPaused } = useIntersectionObserver(target, (entries) => {
+	const { pause: _pause, resume, stop, isActive, isPaused } = useIntersectionObserver(target, (entries) => {
 		const entry = entries.at(-1);
 		if (entry) {
 			isIntersecting.value = entry.isIntersecting;
@@ -2962,8 +3304,9 @@ function useElementIntersection(target, options = {}) {
 		_pause();
 	}
 	return {
-		isIntersecting: readonly(isIntersecting),
-		intersectionRatio: readonly(intersectionRatio),
+		isIntersecting: shallowReadonly(isIntersecting),
+		intersectionRatio: shallowReadonly(intersectionRatio),
+		isActive,
 		isPaused,
 		pause,
 		resume,
@@ -2983,7 +3326,7 @@ function useElementIntersection(target, options = {}) {
 * - Key-specific event handling
 * - preventDefault and stopPropagation options
 * - Automatic cleanup on scope disposal
-* - Auto-starts when in component scope
+* - Built on useEventListener for consistent event handling
 *
 * Simplified wrapper around useEventListener for keyboard interactions.
 */
@@ -2999,36 +3342,44 @@ function useElementIntersection(target, options = {}) {
 * ```ts
 * import { useKeydown } from '@vuetify/v0'
 *
-* const { startListening, stopListening } = useKeydown([
+* const { isActive, start, stop } = useKeydown([
 *   { key: 'Enter', handler: () => console.log('Enter pressed') },
 *   { key: 'Escape', handler: () => console.log('Escape pressed'), preventDefault: true },
 * ])
 *
-* startListening()
-* stopListening()
+* // Listener is automatically active when called in component setup
+* // Manually control if needed:
+* stop()
+* start()
 * ```
 */
 function useKeydown(handlers) {
-	const keyHandlers = Array.isArray(handlers) ? handlers : [handlers];
+	let cleanup = null;
+	const isActive = toRef(() => !!cleanup);
 	function onKeydown(event) {
-		const handler = keyHandlers.find((h) => h.key === event.key);
+		const handlerList = toValue(handlers);
+		const handler = (Array.isArray(handlerList) ? handlerList : [handlerList]).find((h) => h.key === event.key);
 		if (handler) {
 			if (handler.preventDefault) event.preventDefault();
 			if (handler.stopPropagation) event.stopPropagation();
 			handler.handler(event);
 		}
 	}
-	function startListening() {
-		document.addEventListener("keydown", onKeydown);
+	function start() {
+		if (cleanup) return;
+		cleanup = useDocumentEventListener("keydown", onKeydown);
 	}
-	function stopListening() {
-		document.removeEventListener("keydown", onKeydown);
+	function stop() {
+		if (!cleanup) return;
+		cleanup();
+		cleanup = null;
 	}
-	if (getCurrentScope()) onMounted(startListening);
-	onScopeDispose(stopListening, true);
+	cleanup = useDocumentEventListener("keydown", onKeydown);
+	onScopeDispose(stop);
 	return {
-		startListening,
-		stopListening
+		isActive,
+		start,
+		stop
 	};
 }
 
@@ -3132,7 +3483,6 @@ function createSingle(_options = {}) {
 /**
 * Creates a new single selection context.
 *
-* @param namespace The namespace for the single selection context.
 * @param options The options for the single selection context.
 * @template Z The type of the single selection ticket.
 * @template E The type of the single selection context.
@@ -3144,18 +3494,19 @@ function createSingle(_options = {}) {
 * ```ts
 * import { createSingleContext } from '@vuetify/v0'
 *
-* export const [useTabs, provideTabs, tabs] = createSingleContext('tabs', { mandatory: true })
+* // With default namespace 'v0:single'
+* export const [useSingle, provideSingle, context] = createSingleContext()
 *
 * // In a parent component:
-* provideTabs()
+* provideSingle()
 *
 * // In a child component:
-* const tabs = useTabs()
-* tabs.select('tab-1')
+* const single = useSingle()
+* single.select('tab-1')
 * ```
 */
-function createSingleContext(_options) {
-	const { namespace,...options } = _options;
+function createSingleContext(_options = {}) {
+	const { namespace = "v0:single",...options } = _options;
 	const [useSingleContext, _provideSingleContext] = createContext(namespace);
 	const context = createSingle(options);
 	function provideSingleContext(_context = context, app) {
@@ -3197,7 +3548,7 @@ function useSingle(namespace = "v0:single") {
 *
 * This adapter provides translation and number formatting
 * capabilities using the Intl API and supports both
-* numbered and named variables in translation strings.
+* numbered ({0}, {1}) and named ({name}) variables in translation strings.
 */
 var Vuetify0LocaleAdapter = class {
 	t(message, ...params) {
@@ -3205,13 +3556,13 @@ var Vuetify0LocaleAdapter = class {
 		if (params.length > 0 && /* @__PURE__ */ isObject(params[0])) {
 			const variables = params[0];
 			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
-				return variables[name] === void 0 ? match : String(variables[name]);
+				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 (params[idx] !== void 0) return String(params[idx]);
+			if (!/* @__PURE__ */ isUndefined(params[idx])) return String(params[idx]);
 			return match;
 		});
 		return resolvedMessage;
@@ -3252,21 +3603,20 @@ var Vuetify0LocaleAdapter = class {
 */
 function createLocale(_options = {}) {
 	const { adapter = new Vuetify0LocaleAdapter(), messages = {},...options } = _options;
-	const tokens = createTokens(messages, { flat: true });
+	const tokens = createTokens(messages);
 	const registry = createSingle(options);
 	for (const id in messages) {
-		registry.register({
-			id,
-			value: messages[id]
-		});
+		registry.register({ id });
 		if (id === options.default && !registry.selectedId.value) registry.select(id);
 	}
-	function t(key, ...params) {
+	function t(key, params, fallback) {
 		const locale = registry.selectedId.value;
-		if (!locale) return key;
-		const message = (registry.get(locale)?.value)?.[key];
-		const template = /* @__PURE__ */ isString(message) ? resolve(locale, message) : key;
-		return adapter.t(template, ...params);
+		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);
@@ -3274,17 +3624,10 @@ function createLocale(_options = {}) {
 	function resolve(locale, str) {
 		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, key) => {
 			const [prefix, ...rest] = key.split(".");
-			const path = rest.join(".");
-			const prefixTicket = registry.get(prefix);
-			const target = prefixTicket ? prefix : locale;
-			const name = prefixTicket ? path : key;
-			const resolved = (registry.get(target)?.value)?.[name];
+			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);
-			const alias = `{${key}}`;
-			if (tokens.isAlias(alias)) {
-				const result = tokens.resolve(alias);
-				return /* @__PURE__ */ isString(result) ? result : match;
-			}
 			return match;
 		});
 	}
@@ -3297,6 +3640,13 @@ function createLocale(_options = {}) {
 		}
 	};
 }
+function createLocaleFallback() {
+	return {
+		size: 0,
+		t: (key, _params, fallback) => fallback ?? key,
+		n: String
+	};
+}
 /**
 * Creates a new locale context.
 *
@@ -3371,7 +3721,13 @@ function createLocalePlugin(_options = {}) {
 * @see https://0.vuetifyjs.com/composables/plugins/use-locale
 */
 function useLocale(namespace = "v0:locale") {
-	return useContext(namespace);
+	const fallback = createLocaleFallback();
+	if (!getCurrentInstance()) return fallback;
+	try {
+		return useContext(namespace, fallback);
+	} catch {
+		return fallback;
+	}
 }
 
 //#endregion
@@ -3439,6 +3795,7 @@ function useMutationObserver(target, callback, options = {}) {
 	const { isHydrated } = useHydration();
 	const observer = shallowRef();
 	const isPaused = shallowRef(false);
+	const isActive = computed(() => !!observer.value);
 	const observerOptions = {
 		childList: options.childList ?? true,
 		attributes: options.attributes ?? false,
@@ -3505,9 +3862,10 @@ function useMutationObserver(target, callback, options = {}) {
 	function stop() {
 		cleanup();
 	}
-	onUnmounted(stop);
+	onScopeDispose(stop, true);
 	return {
-		isPaused: readonly(isPaused),
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(isPaused),
 		pause,
 		resume,
 		stop
@@ -3515,360 +3873,881 @@ function useMutationObserver(target, callback, options = {}) {
 }
 
 //#endregion
-//#region src/composables/usePermissions/adapters/adapter.ts
-var PermissionAdapter = class {};
-
-//#endregion
-//#region src/composables/usePermissions/adapters/v0.ts
-var Vuetify0PermissionAdapter = class extends PermissionAdapter {
-	constructor() {
-		super();
-	}
-	can(role, action, subject, context, permissions) {
-		const access = `${role}.${action}.${subject}`;
-		const ticket = permissions.get(access);
-		if (!ticket || !ticket.value) return false;
-		return /* @__PURE__ */ isFunction(ticket.value) ? ticket.value(context) : ticket.value;
-	}
-};
-
-//#endregion
-//#region src/composables/usePermissions/index.ts
+//#region src/composables/useResizeObserver/index.ts
 /**
-* @module usePermissions
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+* @module useResizeObserver
 *
 * @remarks
-* Permission management composable with support for RBAC and ABAC patterns.
+* ResizeObserver composable with lifecycle management.
 *
 * Key features:
-* - Role-Based Access Control (RBAC) support
-* - Attribute-Based Access Control (ABAC) with context
-* - Functional permission conditions
-* - Token-based permission storage
-* - Adapter pattern for custom permission systems
+* - 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)
 *
-* Built on useTokens for flexible permission configuration.
+* Perfect for responsive components and size-based rendering.
 */
 /**
-* Creates a new permissions instance.
+* A composable that uses the Resize Observer API to detect when an element's
+* size changes.
 *
-* @param options The options for the permissions instance.
-* @template Z The type of the permission ticket.
-* @template E The type of the permission context.
-* @returns A new permissions instance.
+* @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://0.vuetifyjs.com/composables/plugins/use-permissions
+* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+* @see https://0.vuetifyjs.com/composables/system/use-resize-observer
 *
 * @example
 * ```ts
-* import { createPermissions } from '@vuetify/v0'
+* import { ref } from 'vue'
+* import { useResizeObserver } from '@vuetify/v0'
 *
-* const [usePermissions, providePermissions] = createPermissions({
-*   namespace: 'v0:permissions',
-*   permissions: {
-*     admin: [['read', 'users']],
-*     editor: [['edit', 'posts']],
+* 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 createPermissions(_options = {}) {
-	const { adapter = new Vuetify0PermissionAdapter(), permissions = {},...options } = _options;
-	const record = {};
-	for (const role in permissions) {
-		if (!record[role]) record[role] = {};
-		for (const [actions, subjects, condition = true] of permissions[role]) for (const action of toArray(actions)) for (const subject of toArray(subjects)) {
-			if (!record[role][action]) record[role][action] = {};
-			record[role][action][subject] = condition;
+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
+			}]);
 		}
 	}
-	const tokens = createTokens(record, options);
-	function can(id, action, subject, context = {}) {
-		return adapter.can(id, action, subject, context, tokens);
+	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 {
-		...tokens,
-		can
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(isPaused),
+		pause,
+		resume,
+		stop
 	};
 }
 /**
-* Creates a new permissions context.
+* A convenience composable that uses the Resize Observer API to track an
+* element's size.
 *
-* @param options The options for the permissions context.
-* @template Z The type of the permission ticket.
-* @template E The type of the permission context.
-* @returns A new permissions context.
+* @param target The element to observe.
+* @returns An object with the element's width and height.
 *
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+* @see https://0.vuetifyjs.com/composables/system/use-resize-observer#use-element-size
 *
 * @example
 * ```ts
-* import { createPermissionsContext } from '@vuetify/v0'
+* import { ref, watchEffect } from 'vue'
+* import { useElementSize } from '@vuetify/v0'
 *
-* export const [usePermissions, providePermissions, context] = createPermissionsContext({
-*   namespace: 'app:permissions',
-*   permissions: {
-*     admin: [['read', 'users'], ['edit', 'users']],
-*     editor: [['edit', 'posts']],
-*   },
+* 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 createPermissionsContext(_options = {}) {
-	const { namespace = "v0:permissions",...options } = _options;
-	const [usePermissionsContext, _providePermissionsContext] = createContext(namespace);
-	const context = createPermissions(options);
-	function providePermissionsContext(_context = context, app) {
-		return _providePermissionsContext(_context, app);
+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 createTrinity(usePermissionsContext, providePermissionsContext, context);
+	return {
+		width,
+		height,
+		isActive,
+		isPaused,
+		pause,
+		resume,
+		stop
+	};
 }
+
+//#endregion
+//#region src/composables/useOverflow/index.ts
 /**
-* Creates a new permissions plugin.
-*
-* @param options The options for the permissions plugin.
-* @template Z The type of the permission ticket.
-* @template E The type of the permission context.
-* @returns A new permissions plugin.
+* @module useOverflow
 *
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+* @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.
 *
-* @example
-* ```ts
-* import { createApp } from 'vue'
-* import { createPermissionsPlugin } from '@vuetify/v0'
-* import App from './App.vue'
+* 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.
 *
-* const app = createApp(App)
+* @param options Configuration options
+* @returns Overflow context with container ref, capacity, and measurement functions
 *
-* app.use(
-*   createPermissionsPlugin({
-*     permissions: {
-*       admin: [['read', 'users']],
-*       editor: [['edit', 'posts']],
-*     },
+* @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>
 *
-* app.mount('#app')
+* <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 createPermissionsPlugin(_options = {}) {
-	const { namespace = "v0:permissions",...options } = _options;
-	const [, providePermissionContext, context] = createPermissionsContext({
-		...options,
-		namespace
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			providePermissionContext(context, app);
+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
+	};
 }
 /**
-* Returns the current permissions instance.
+* Creates an overflow context with dependency injection support.
 *
-* @template Z The type of the permission ticket.
-* @returns The current permissions instance.
+* @param options Configuration options including namespace
+* @returns Trinity tuple: [useContext, provideContext, defaultContext]
 *
-* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+* @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 setup lang="ts">
-*   import { usePermissions } from '@vuetify/v0'
+* <script lang="ts" setup>
+*   import { useOverflow } from '@vuetify/v0'
 *
-*   const { can } = usePermissions()
+*   // Inject overflow context provided by parent
+*   const overflow = useOverflow()
 * <\/script>
 *
 * <template>
 *   <div>
-*     <p v-if="can('admin', 'read', 'users')">Admin access</p>
+*     <p>Capacity: {{ overflow.capacity.value }}</p>
 *   </div>
 * </template>
 * ```
 */
-function usePermissions(namespace = "v0:permissions") {
+function useOverflow(namespace = "v0:overflow") {
 	return useContext(namespace);
 }
 
 //#endregion
-//#region src/composables/useProxyModel/index.ts
+//#region src/composables/usePagination/index.ts
 /**
-* @module useProxyModel
+* @module usePagination
 *
 * @remarks
-* Proxy composable for bidirectional sync between selection registry and v-model.
+* Lightweight pagination composable for navigating through pages.
 *
 * 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.
+* - 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.
 */
 /**
-* 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.
+* Creates a pagination instance.
 *
-* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
+* @param options The options for the pagination instance.
+* @returns A pagination context with navigation methods.
 *
 * @example
 * ```ts
-* import { createSelection, useProxyModel } from '@vuetify/v0'
+* import { createPagination } 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' },
-* ])
+* // Basic usage
+* const pagination = createPagination({ size: 100 })
+* pagination.next()
+* pagination.items.value // [{ type: 'page', value: 1 }, { type: 'page', value: 2 }, ...]
 *
-* const stop = useProxyModel(registry, model)
+* // 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 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 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 transformOut(val) {
-		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
-		return multiple ? val : val[0];
+	function last() {
+		page.value = pages.value;
 	}
-	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);
-		}
+	function next() {
+		if (page.value < pages.value) page.value++;
 	}
-	const registryWatch = watch(registry.selectedValues, (val) => {
-		modelWatch.pause();
-		model.value = transformOut(Array.from(toValue(val)));
-		modelWatch.resume();
-	}, { flush: "sync" });
-	const modelWatch = watch(model, (val) => {
-		registryWatch.pause();
-		const currentIds = new Set(toValue(registry.selectedIds));
-		const targetIds = /* @__PURE__ */ new Set();
-		for (const value of transformIn(val)) {
-			const ids = registry.browse(value);
-			if (/* @__PURE__ */ isArray(ids)) for (const single of ids) targetIds.add(single);
-			else if (ids) targetIds.add(ids);
-		}
-		if (multiple) {
-			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
-			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
-		} else {
-			const next = targetIds.values().next().value;
-			const last = currentIds.values().next().value;
-			if (last !== void 0) registry.unselect(last);
-			if (next !== void 0) registry.select(next);
-		}
-		registryWatch.resume();
-	}, {
-		flush: "sync",
-		deep: multiple
-	});
-	function onRegister(ticket) {
-		if (!pending.has(ticket.value) || ticket.disabled) return;
-		registryWatch.pause();
-		modelWatch.pause();
-		registry.select(ticket.id);
-		pending.delete(ticket.value);
-		modelWatch.resume();
-		registryWatch.resume();
+	function prev() {
+		if (page.value > 1) page.value--;
+	}
+	function select(value) {
+		if (value < 1) page.value = 1;
+		else if (value > pages.value) page.value = 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
+		};
 	}
-	registry.on("register:ticket", onRegister);
-	function stop() {
-		registryWatch();
-		modelWatch();
-		registry.off("register:ticket", onRegister);
+	function toEllipsis() {
+		return ellipsis === false ? false : {
+			type: "ellipsis",
+			value: ellipsis
+		};
 	}
-	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
+	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.
 *
-* Perfect for exposing registry data as reactive computed properties.
+* @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);
+}
 /**
-* Creates a proxy registry that provides reactive objects for registry data.
+* Returns the current pagination instance from context.
 *
-* @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.
+* @param namespace The namespace. @default 'v0:pagination'
+* @returns The pagination context.
 *
-* @see https://0.vuetifyjs.com/composables/registration/use-proxy-registry
+* @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/usePermissions/adapters/adapter.ts
+var PermissionAdapter = class {};
+
+//#endregion
+//#region src/composables/usePermissions/adapters/v0.ts
+var Vuetify0PermissionAdapter = class extends PermissionAdapter {
+	constructor() {
+		super();
+	}
+	can(role, action, subject, context, permissions) {
+		const access = `${role}.${action}.${subject}`;
+		const ticket = permissions.get(access);
+		if (!ticket || !ticket.value) return false;
+		return /* @__PURE__ */ isFunction(ticket.value) ? ticket.value(context) : ticket.value;
+	}
+};
+
+//#endregion
+//#region src/composables/usePermissions/index.ts
+/**
+* @module usePermissions
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @remarks
+* Permission management composable with support for RBAC and ABAC patterns.
+*
+* Key features:
+* - Role-Based Access Control (RBAC) support
+* - Attribute-Based Access Control (ABAC) with context
+* - Functional permission conditions
+* - Token-based permission storage
+* - Adapter pattern for custom permission systems
+*
+* Built on useTokens for flexible permission configuration.
+*/
+/**
+* Creates a new permissions instance.
+*
+* @param options The options for the permissions instance.
+* @template Z The type of the permission ticket.
+* @template E The type of the permission context.
+* @returns A new permissions instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
 *
 * @example
 * ```ts
-* import { useRegistry, useProxyRegistry } from '@vuetify/v0'
+* import { createPermissions } from '@vuetify/v0'
 *
-* const registry = useRegistry({ events: true })
-* const proxy = useProxyRegistry(registry)
+* const [usePermissions, providePermissions] = createPermissions({
+*   namespace: 'v0:permissions',
+*   permissions: {
+*     admin: [['read', 'users']],
+*     editor: [['edit', 'posts']],
+*   },
+* })
+* ```
+*/
+function createPermissions(_options = {}) {
+	const { adapter = new Vuetify0PermissionAdapter(), permissions = {},...options } = _options;
+	const record = {};
+	for (const role in permissions) {
+		if (!record[role]) record[role] = {};
+		for (const [actions, subjects, condition = true] of permissions[role]) for (const action of toArray(actions)) for (const subject of toArray(subjects)) {
+			if (!record[role][action]) record[role][action] = {};
+			record[role][action][subject] = condition;
+		}
+	}
+	const tokens = createTokens(record, options);
+	function can(id, action, subject, context = {}) {
+		return adapter.can(id, action, subject, context, tokens);
+	}
+	return {
+		...tokens,
+		can
+	};
+}
+/**
+* Creates a new permissions context.
 *
-* registry.register({ value: 'Item 1' })
-* console.log(proxy.size) // 1
+* @param options The options for the permissions context.
+* @template Z The type of the permission ticket.
+* @template E The type of the permission context.
+* @returns A new permissions context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @example
+* ```ts
+* import { createPermissionsContext } from '@vuetify/v0'
+*
+* export const [usePermissions, providePermissions, context] = createPermissionsContext({
+*   namespace: 'app:permissions',
+*   permissions: {
+*     admin: [['read', 'users'], ['edit', 'users']],
+*     editor: [['edit', 'posts']],
+*   },
+* })
 * ```
 */
-function useProxyRegistry(registry, options) {
-	const state = (options?.deep ? reactive : shallowReactive)({
-		keys: registry.keys(),
-		values: registry.values(),
-		entries: registry.entries(),
-		size: registry.size
+function createPermissionsContext(_options = {}) {
+	const { namespace = "v0:permissions",...options } = _options;
+	const [usePermissionsContext, _providePermissionsContext] = createContext(namespace);
+	const context = createPermissions(options);
+	function providePermissionsContext(_context = context, app) {
+		return _providePermissionsContext(_context, app);
+	}
+	return createTrinity(usePermissionsContext, providePermissionsContext, context);
+}
+/**
+* Creates a new permissions plugin.
+*
+* @param options The options for the permissions plugin.
+* @template Z The type of the permission ticket.
+* @template E The type of the permission context.
+* @returns A new permissions plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @example
+* ```ts
+* import { createApp } from 'vue'
+* import { createPermissionsPlugin } from '@vuetify/v0'
+* import App from './App.vue'
+*
+* const app = createApp(App)
+*
+* app.use(
+*   createPermissionsPlugin({
+*     permissions: {
+*       admin: [['read', 'users']],
+*       editor: [['edit', 'posts']],
+*     },
+*   })
+* )
+*
+* app.mount('#app')
+* ```
+*/
+function createPermissionsPlugin(_options = {}) {
+	const { namespace = "v0:permissions",...options } = _options;
+	const [, providePermissionContext, context] = createPermissionsContext({
+		...options,
+		namespace
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			providePermissionContext(context, app);
+		}
+	});
+}
+/**
+* Returns the current permissions instance.
+*
+* @template Z The type of the permission ticket.
+* @returns The current permissions instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { usePermissions } from '@vuetify/v0'
+*
+*   const { can } = usePermissions()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p v-if="can('admin', 'read', 'users')">Admin access</p>
+*   </div>
+* </template>
+* ```
+*/
+function usePermissions(namespace = "v0:permissions") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* @module useProxyModel
+*
+* @remarks
+* Proxy composable for bidirectional sync between selection registry and v-model.
+*
+* Key features:
+* - Bidirectional synchronization
+* - Array and single-value modes
+* - Automatic cleanup on scope disposal
+* - Perfect for form controls with selection backing
+*
+* Bridges the gap between selection composables and Vue's v-model.
+*/
+/**
+* Syncs a ref with a selection registry bidirectionally.
+*
+* @param registry The selection registry to bind to.
+* @param model The ref to sync.
+* @param options The options for the proxy model.
+* @template Z The type of the selection ticket.
+* @returns A function to stop the sync.
+*
+* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
+*
+* @example
+* ```ts
+* import { createSelection, useProxyModel } from '@vuetify/v0'
+*
+* const model = ref()
+* const registry = createSelection({ events: true })
+* registry.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2' },
+* ])
+*
+* const stop = useProxyModel(registry, model)
+* ```
+*/
+function useProxyModel(registry, model, options) {
+	const multiple = options?.multiple ?? false;
+	const _transformIn = options?.transformIn;
+	const _transformOut = options?.transformOut;
+	function transformIn(val) {
+		const value = toValue(val);
+		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
+	}
+	function transformOut(val) {
+		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
+		return multiple ? val : val[0];
+	}
+	const modelAsArray = transformIn(model);
+	const pending = new Set(modelAsArray);
+	for (const value of modelAsArray) {
+		const ids = registry.browse(value);
+		if (/* @__PURE__ */ isArray(ids)) {
+			for (const id of ids) registry.select(id);
+			pending.delete(value);
+		} else if (ids) {
+			registry.select(ids);
+			pending.delete(value);
+		}
+	}
+	const registryWatch = watch(registry.selectedValues, (val) => {
+		modelWatch.pause();
+		model.value = transformOut(Array.from(toValue(val)));
+		modelWatch.resume();
+	}, { flush: "sync" });
+	const modelWatch = watch(model, (val) => {
+		registryWatch.pause();
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of transformIn(val)) {
+			const ids = registry.browse(value);
+			if (/* @__PURE__ */ isArray(ids)) for (const single of ids) targetIds.add(single);
+			else if (ids) targetIds.add(ids);
+		}
+		if (multiple) {
+			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
+			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
+		} else {
+			const next = targetIds.values().next().value;
+			const last = currentIds.values().next().value;
+			if (!/* @__PURE__ */ isUndefined(last)) registry.unselect(last);
+			if (!/* @__PURE__ */ isUndefined(next)) registry.select(next);
+		}
+		registryWatch.resume();
+	}, {
+		flush: "sync",
+		deep: multiple
 	});
-	function update() {
-		state.keys = registry.keys();
-		state.values = registry.values();
-		state.entries = registry.entries();
-		state.size = registry.size;
+	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", 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;
+	registry.on("register:ticket", onRegister);
+	function stop() {
+		registryWatch();
+		modelWatch();
+		registry.off("register:ticket", onRegister);
+	}
+	onScopeDispose(stop, true);
+	return stop;
 }
 
 //#endregion
@@ -3922,300 +4801,144 @@ function useProxyRegistry(registry, options) {
 function createQueue(_options = {}) {
 	const { timeout: _timeout = 3e3,...options } = _options;
 	const registry = useRegistry({
-		...options,
-		events: true
-	});
-	const timeouts = /* @__PURE__ */ new Map();
-	function startTimeout(ticket) {
-		if (ticket.timeout === void 0 || ticket.timeout === -1 || ticket.isPaused) return;
-		const timeout = setTimeout(() => {
-			timeouts.delete(ticket.id);
-			registry.unregister(ticket.id);
-			resume();
-		}, ticket.timeout);
-		timeouts.set(ticket.id, timeout);
-	}
-	function clearTimeout(id) {
-		const timeout = timeouts.get(id);
-		if (timeout) {
-			globalThis.clearTimeout(timeout);
-			timeouts.delete(id);
-		}
-	}
-	function register(registration = {}) {
-		const id = registration.id ?? /* @__PURE__ */ genId();
-		const timeout = Object.prototype.hasOwnProperty.call(registration, "timeout") ? registration.timeout : _timeout;
-		const ticket = {
-			...registration,
-			id,
-			timeout,
-			isPaused: registry.size > 0,
-			dismiss: () => unregister(id)
-		};
-		const registered = registry.register(ticket);
-		startTimeout(registered);
-		return registered;
-	}
-	function unregister(id) {
-		const ticket = id === void 0 ? registry.seek("first") : registry.get(id);
-		if (!ticket) return void 0;
-		const wasFirst = ticket.index === 0;
-		clearTimeout(ticket.id);
-		registry.unregister(ticket.id);
-		if (wasFirst) resume();
-		return ticket;
-	}
-	function pause() {
-		const ticket = registry.seek("first");
-		if (!ticket || ticket.isPaused) return void 0;
-		clearTimeout(ticket.id);
-		registry.upsert(ticket.id, { isPaused: true });
-		return ticket;
-	}
-	function resume() {
-		const ticket = registry.seek("first");
-		if (!ticket || ticket.index !== 0 || !ticket.isPaused) return void 0;
-		registry.upsert(ticket.id, { isPaused: false });
-		startTimeout(ticket);
-		return ticket;
-	}
-	function clear() {
-		for (const id of timeouts.keys()) clearTimeout(id);
-		registry.clear();
-	}
-	function dispose() {
-		clear();
-		registry.dispose();
-	}
-	onScopeDispose(dispose, true);
-	return {
-		...registry,
-		register,
-		unregister,
-		pause,
-		resume,
-		clear,
-		dispose,
-		get size() {
-			return registry.size;
-		}
-	};
-}
-/**
-* Creates a new queue context.
-*
-* @param namespace The namespace for the queue context.
-* @param options The options for the queue context.
-* @template Z The type of the queue ticket.
-* @template E The type of the queue context.
-* @returns A new queue context.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-queue
-*
-* @example
-* ```ts
-* import { createQueueContext } from '@vuetify/v0'
-*
-* export const [useQueue, provideQueue] = createQueueContext('v0:queue', {
-*   timeout: 5000,
-* })
-* ```
-*/
-function createQueueContext(_options) {
-	const { namespace,...options } = _options;
-	const [useQueueContext, _provideQueueContext] = createContext(namespace);
-	const context = createQueue(options);
-	function provideQueueContext(_context = context, app) {
-		return _provideQueueContext(_context, app);
-	}
-	return createTrinity(useQueueContext, provideQueueContext, context);
-}
-/**
-* Returns the current queue instance.
-*
-* @param namespace The namespace for the queue context. Defaults to `'v0:queue'`.
-* @returns The current queue instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-queue
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useQueue } from '@vuetify/v0'
-*
-*   const queue = useQueue()
-* <\/script>
-* ```
-*/
-function useQueue(namespace = "v0:queue") {
-	return useContext(namespace);
-}
-
-//#endregion
-//#region src/composables/useResizeObserver/index.ts
-/**
-* @module useResizeObserver
-*
-* @remarks
-* ResizeObserver composable with lifecycle management.
-*
-* Key features:
-* - ResizeObserver API wrapper
-* - Pause/resume/stop functionality
-* - Automatic cleanup on unmount
-* - SSR-safe (checks SUPPORTS_OBSERVER)
-* - Hydration-aware
-* - Box model options (content-box/border-box)
-*
-* Perfect for responsive components and size-based rendering.
-*/
-/**
-* A composable that uses the Resize Observer API to detect when an element's
-* size changes.
-*
-* @param target The element to observe.
-* @param callback The callback to execute when the element's size changes.
-* @param options The options for the Resize Observer.
-* @returns An object with methods to control the observer.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
-* @see https://0.vuetifyjs.com/composables/system/use-resize-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useResizeObserver } from '@vuetify/v0'
-*
-* const el = ref<HTMLElement>()
-* const width = ref(0)
-* const height = ref(0)
-*
-* const { pause, resume, isPaused } = useResizeObserver(
-*   el,
-*   (entries) => {
-*     const entry = entries[0]
-*     if (entry) {
-*       width.value = entry.contentRect.width
-*       height.value = entry.contentRect.height
-*       console.log('Size changed:', width.value, 'x', height.value)
-*     }
-*   },
-*   { immediate: true }
-* )
-*
-* // Pause observation
-* pause()
-*
-* // Resume observation
-* resume()
-* ```
-*/
-function useResizeObserver(target, callback, options = {}) {
-	const { isHydrated } = useHydration();
-	const observer = shallowRef();
-	const isPaused = shallowRef(false);
-	function setup() {
-		if (!isHydrated.value || !SUPPORTS_OBSERVER || !target.value || isPaused.value) return;
-		observer.value = new ResizeObserver((entries) => {
-			callback(entries.map((entry) => ({
-				contentRect: {
-					width: entry.contentRect.width,
-					height: entry.contentRect.height,
-					top: entry.contentRect.top,
-					left: entry.contentRect.left
-				},
-				target: entry.target
-			})));
-		});
-		observer.value.observe(target.value, { box: options.box || "content-box" });
-		if (options.immediate) {
-			const rect = target.value.getBoundingClientRect();
-			callback([{
-				contentRect: {
-					width: rect.width,
-					height: rect.height,
-					top: rect.top,
-					left: rect.left
-				},
-				target: target.value
-			}]);
+		...options,
+		events: true
+	});
+	const timeouts = /* @__PURE__ */ new Map();
+	function startTimeout(ticket) {
+		if (/* @__PURE__ */ isUndefined(ticket.timeout) || ticket.timeout < 0 || ticket.isPaused) return;
+		const timeout = setTimeout(() => {
+			timeouts.delete(ticket.id);
+			registry.unregister(ticket.id);
+			resume();
+		}, ticket.timeout);
+		timeouts.set(ticket.id, timeout);
+	}
+	function clearTimeout$1(id) {
+		const timeout = timeouts.get(id);
+		if (timeout) {
+			globalThis.clearTimeout(timeout);
+			timeouts.delete(id);
 		}
 	}
-	watch([isHydrated, target], () => {
-		cleanup();
-		setup();
-	}, { immediate: true });
-	function cleanup() {
-		if (observer.value) {
-			observer.value.disconnect();
-			observer.value = void 0;
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ genId();
+		const timeout = Object.prototype.hasOwnProperty.call(registration, "timeout") ? registration.timeout : _timeout;
+		const ticket = {
+			...registration,
+			id,
+			timeout,
+			isPaused: registry.size > 0,
+			dismiss: () => unregister(id)
+		};
+		const registered = registry.register(ticket);
+		startTimeout(registered);
+		return registered;
+	}
+	function unregister(id) {
+		const ticket = /* @__PURE__ */ isUndefined(id) ? registry.seek("first") : registry.get(id);
+		if (!ticket) return void 0;
+		const wasFirst = ticket.index === 0;
+		clearTimeout$1(ticket.id);
+		registry.unregister(ticket.id);
+		if (wasFirst) resume();
+		return ticket;
+	}
+	function offboard(ids) {
+		let hadFirst = false;
+		for (const id of ids) {
+			const ticket = registry.get(id);
+			if (!ticket) continue;
+			if (ticket.index === 0) hadFirst = true;
+			clearTimeout$1(ticket.id);
 		}
+		registry.offboard(ids);
+		if (hadFirst) resume();
 	}
 	function pause() {
-		isPaused.value = true;
-		observer.value?.disconnect();
+		const ticket = registry.seek("first");
+		if (!ticket || ticket.isPaused) return void 0;
+		clearTimeout$1(ticket.id);
+		return registry.upsert(ticket.id, { isPaused: true });
 	}
 	function resume() {
-		isPaused.value = false;
-		setup();
+		const ticket = registry.seek("first");
+		if (!ticket || ticket.index !== 0 || !ticket.isPaused) return void 0;
+		const updated = registry.upsert(ticket.id, { isPaused: false });
+		startTimeout(updated);
+		return updated;
 	}
-	function stop() {
-		cleanup();
+	function clear() {
+		for (const id of timeouts.keys()) clearTimeout$1(id);
+		registry.clear();
+	}
+	function dispose() {
+		clear();
+		registry.dispose();
 	}
-	onUnmounted(stop);
+	onScopeDispose(dispose, true);
 	return {
-		isPaused: readonly(isPaused),
+		...registry,
+		register,
+		unregister,
+		offboard,
 		pause,
 		resume,
-		stop
+		clear,
+		dispose,
+		get size() {
+			return registry.size;
+		}
 	};
 }
 /**
-* A convenience composable that uses the Resize Observer API to track an
-* element's size.
+* Creates a new queue context.
 *
-* @param target The element to observe.
-* @returns An object with the element's width and height.
+* @param namespace The namespace for the queue context.
+* @param options The options for the queue context.
+* @template Z The type of the queue ticket.
+* @template E The type of the queue context.
+* @returns A new queue context.
 *
-* @see https://0.vuetifyjs.com/composables/system/use-resize-observer#use-element-size
+* @see https://0.vuetifyjs.com/composables/registration/use-queue
 *
 * @example
 * ```ts
-* import { ref, watchEffect } from 'vue'
-* import { useElementSize } from '@vuetify/v0'
-*
-* const box = ref<HTMLElement>()
-* const { width, height } = useElementSize(box)
+* import { createQueueContext } from '@vuetify/v0'
 *
-* // Width and height are reactive refs
-* watchEffect(() => {
-*   console.log('Box size:', width.value, 'x', height.value)
+* export const [useQueue, provideQueue] = createQueueContext('v0:queue', {
+*   timeout: 5000,
 * })
 * ```
 */
-function useElementSize(target) {
-	const width = shallowRef(0);
-	const height = shallowRef(0);
-	const { pause: _pause, resume, stop, isPaused } = useResizeObserver(target, (entries) => {
-		const entry = entries[0];
-		if (entry) {
-			width.value = entry.contentRect.width;
-			height.value = entry.contentRect.height;
-		}
-	}, { immediate: true });
-	function pause() {
-		width.value = 0;
-		height.value = 0;
-		_pause();
+function createQueueContext(_options) {
+	const { namespace,...options } = _options;
+	const [useQueueContext, _provideQueueContext] = createContext(namespace);
+	const context = createQueue(options);
+	function provideQueueContext(_context = context, app) {
+		return _provideQueueContext(_context, app);
 	}
-	return {
-		width,
-		height,
-		isPaused,
-		pause,
-		resume,
-		stop
-	};
+	return createTrinity(useQueueContext, provideQueueContext, context);
+}
+/**
+* Returns the current queue instance.
+*
+* @param namespace The namespace for the queue context. Defaults to `'v0:queue'`.
+* @returns The current queue instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-queue
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useQueue } from '@vuetify/v0'
+*
+*   const queue = useQueue()
+* <\/script>
+* ```
+*/
+function useQueue(namespace = "v0:queue") {
+	return useContext(namespace);
 }
 
 //#endregion
@@ -4331,13 +5054,13 @@ function createStep(_options = {}) {
 		let index = circular ? wrapped(length, currentIndex + count) : currentIndex + count;
 		if (!circular && (index < 0 || index >= length)) return;
 		let id = registry.lookup(index);
-		while (id !== void 0 && toValue(registry.get(id)?.disabled) && hops < length) {
+		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 (id === void 0 || hops === length) return;
+		if (/* @__PURE__ */ isUndefined(id) || hops === length) return;
 		registry.selectedIds.clear();
 		registry.select(id);
 	}
@@ -4356,7 +5079,6 @@ function createStep(_options = {}) {
 /**
 * Creates a new step context.
 *
-* @param namespace The namespace for the step context.
 * @param options The options for the step context.
 * @template Z The type of the step ticket.
 * @template E The type of the step context.
@@ -4368,18 +5090,19 @@ function createStep(_options = {}) {
 * ```ts
 * import { createStepContext } from '@vuetify/v0'
 *
-* export const [useWizard, provideWizard, wizard] = createStepContext('wizard')
+* // With default namespace 'v0:step'
+* export const [useStep, provideStep, context] = createStepContext()
 *
 * // In a parent component:
-* provideWizard()
+* provideStep()
 *
 * // In a child component:
-* const wizard = useWizard()
-* wizard.next() // Progress to next step
+* const context = useStep()
+* context.next() // Progress to next step
 * ```
 */
-function createStepContext(_options) {
-	const { namespace,...options } = _options;
+function createStepContext(_options = {}) {
+	const { namespace = "v0:step",...options } = _options;
 	const [useStepContext, _provideStepContext] = createContext(namespace);
 	const context = createStep(options);
 	function provideStepContext(_context = context, app) {
@@ -4458,7 +5181,6 @@ var MemoryAdapter = class {
 *
 * Uses adapter pattern to abstract storage implementation details.
 */
-const [useStorageContext, provideStorageContext] = createContext("v0:storage");
 /**
 * Creates a new storage instance.
 *
@@ -4506,7 +5228,7 @@ function createStorage(options = {}) {
 		}
 		const valueRef = ref(initialValue);
 		const stop = watch(valueRef, (newValue) => {
-			if (newValue === void 0 || newValue === null) adapter?.removeItem(prefixedKey);
+			if (/* @__PURE__ */ isNullOrUndefined(newValue)) adapter?.removeItem(prefixedKey);
 			else adapter?.setItem(prefixedKey, serializer.write(newValue));
 		}, { deep: true });
 		watchers.set(prefixedKey, stop);
@@ -4546,12 +5268,12 @@ function createStorage(options = {}) {
 }
 function createStorageContext(_options = {}) {
 	const { namespace = "v0:storage",...options } = _options;
-	const [useStorageContext$1, _provideStorageContext] = createContext(namespace);
+	const [useStorageContext, _provideStorageContext] = createContext(namespace);
 	const context = createStorage(options);
-	function provideStorageContext$1(_context = context, app) {
+	function provideStorageContext(_context = context, app) {
 		return _provideStorageContext(_context, app);
 	}
-	return createTrinity(useStorageContext$1, provideStorageContext$1, context);
+	return createTrinity(useStorageContext, provideStorageContext, context);
 }
 /**
 * Creates a new storage plugin.
@@ -4576,14 +5298,14 @@ function createStorageContext(_options = {}) {
 */
 function createStoragePlugin(_options = {}) {
 	const { namespace = "v0:storage",...options } = _options;
-	const [, provideStorageContext$1, context] = createStorageContext({
+	const [, provideStorageContext, context] = createStorageContext({
 		...options,
 		namespace
 	});
 	return createPlugin({
 		namespace,
 		provide: (app) => {
-			provideStorageContext$1(context, app);
+			provideStorageContext(context, app);
 		}
 	});
 }
@@ -4631,7 +5353,7 @@ var ThemeAdapter = class {
 			const vars = Object.entries(themeColors).map(([key, val]) => `  --${this.prefix}-${key}: ${val};`).join("\n");
 			css += `[data-theme="${theme}"] {\n${vars}\n}\n`;
 		}
-		if (isDark !== void 0) css += `:root {\n  color-scheme: ${isDark ? "dark" : "light"};\n}\n`;
+		if (!/* @__PURE__ */ isUndefined(isDark)) css += `:root {\n  color-scheme: ${isDark ? "dark" : "light"};\n}\n`;
 		return css;
 	}
 };
@@ -5023,13 +5745,12 @@ function createTimeline(_options = {}) {
 	};
 }
 /**
-* Creates a new timeline plugin.
+* Creates a new timeline context.
 *
-* @param namespace The namespace for the timeline plugin.
-* @param options The options for the timeline plugin.
+* @param options The options for the timeline context.
 * @template Z The type of the timeline ticket.
 * @template E The type of the timeline context.
-* @returns A new timeline plugin.
+* @returns A new timeline context.
 *
 * @see https://0.vuetifyjs.com/composables/registration/use-timeline
 *
@@ -5037,7 +5758,9 @@ function createTimeline(_options = {}) {
 * ```ts
 * import { createTimelineContext } from '@vuetify/v0'
 *
-* export const [useTimeline, provideTimeline, context] = createTimelineContext('v0:timeline', { size: 5 })
+* // With default namespace 'v0:timeline'
+* export const [useTimeline, provideTimeline, context] = createTimelineContext({ size: 5 })
+*
 * context.register({ id: 'example' })
 *
 * // In a parent component
@@ -5049,39 +5772,409 @@ function createTimeline(_options = {}) {
 * console.log(timeline.values()) // [{ id: 'example' }]
 * ```
 */
-function createTimelineContext(_options) {
-	const { namespace,...options } = _options;
+function createTimelineContext(_options = {}) {
+	const { namespace = "v0:timeline",...options } = _options;
 	const [useTimelineContext, _provideTimelineContext] = createContext(namespace);
 	const context = createTimeline(options);
 	function provideTimelineContext(_context = context, app) {
 		return _provideTimelineContext(_context, app);
 	}
-	return createTrinity(useTimelineContext, provideTimelineContext, context);
-}
-/**
-* Returns the current timeline instance.
-*
-* @param namespace The namespace for the timeline context. Defaults to `'v0:timeline'`.
-* @returns The current timeline instance.
-*
-* @see https://0.vuetifyjs.com/composables/registration/use-timeline
-*
-* @example
-* ```vue
-* <script setup lang="ts">
-*   import { useTimeline } from '@vuetify/v0'
-*
-*   const timeline = useTimeline()
-* <\/script>
-* ```
-*/
-function useTimeline(namespace = "v0:timeline") {
-	return useContext(namespace);
+	return createTrinity(useTimelineContext, provideTimelineContext, context);
+}
+/**
+* Returns the current timeline instance.
+*
+* @param namespace The namespace for the timeline context. Defaults to `'v0:timeline'`.
+* @returns The current timeline instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-timeline
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useTimeline } from '@vuetify/v0'
+*
+*   const timeline = useTimeline()
+* <\/script>
+* ```
+*/
+function useTimeline(namespace = "v0:timeline") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useToggleScope/index.ts
+/**
+* @module useToggleScope
+*
+* @remarks
+* Conditionally manages an effect scope based on a reactive boolean condition.
+* When the source becomes true, creates and runs an effect scope. When false, stops the scope.
+* All reactive effects created within the scoped function are automatically cleaned up on deactivation.
+*
+* Key features:
+* - Uses Vue's effectScope for efficient reactive effect lifecycle management
+* - Automatic cleanup when condition becomes false
+* - Supports optional reset callback for scope restart capability
+* - Handles rapid toggling and parent scope disposal safely
+* - SSR-safe (effectScope is part of Vue core)
+*
+* Perfect for conditional side effects, feature flags, and performance optimization
+* by only running reactive effects when needed.
+*/
+/**
+* Conditionally manages an effect scope based on a reactive boolean source.
+*
+* @param source A reactive boolean value or getter that controls the scope lifecycle
+* @param fn The function to run within the effect scope. Can optionally receive controls for manual scope management.
+* @returns Controls object with isActive state and start/stop/reset methods
+*
+* @see https://vuejs.org/api/reactivity-advanced.html#effectscope
+* @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useToggleScope } from '@vuetify/v0'
+*
+* const isEnabled = ref(false)
+*
+* const { isActive } = useToggleScope(isEnabled, () => {
+*   // This code runs when isEnabled becomes true
+*   const unwatch = watch(someRef, () => {
+*     console.log('Watching...')
+*   })
+*
+*   // Cleanup happens automatically when isEnabled becomes false
+* })
+*
+* // Toggle the scope on/off
+* isEnabled.value = true  // Starts the scope
+* console.log(isActive.value) // true
+* isEnabled.value = false // Stops and cleans up
+* console.log(isActive.value) // false
+* ```
+*
+* @example
+* With manual controls:
+* ```ts
+* const isEnabled = ref(true)
+*
+* useToggleScope(isEnabled, (controls) => {
+*   // Access controls inside the scope
+*   console.log('Active:', controls.isActive.value)
+*
+*   // Manually reset the scope if needed
+*   someEvent.on('reset', () => controls.reset())
+* })
+* ```
+*/
+function useToggleScope(source, fn) {
+	const scope = shallowRef();
+	const isActive = toRef(() => !!scope.value);
+	function start() {
+		if (scope.value) return;
+		scope.value = effectScope();
+		scope.value.run(() => fn.length > 0 ? fn(controls) : fn());
+	}
+	function stop() {
+		scope.value?.stop();
+		scope.value = void 0;
+	}
+	function reset() {
+		stop();
+		start();
+	}
+	const controls = {
+		isActive: shallowReadonly(isActive),
+		start,
+		stop,
+		reset
+	};
+	watch(source, (active) => {
+		if (active && !scope.value) start();
+		else if (!active) stop();
+	}, { immediate: true });
+	onScopeDispose(() => {
+		stop();
+	});
+	return controls;
+}
+
+//#endregion
+//#region src/composables/useVirtual/index.ts
+/**
+* @module useVirtual
+*
+* @remarks
+* Virtual scrolling composable for efficiently rendering large lists.
+*
+* Key features:
+* - Renders only visible items (viewport + overscan)
+* - Dynamic or fixed item heights
+* - SSR-safe (checks IN_BROWSER)
+* - Bidirectional scrolling (forward/reverse for chat apps)
+* - Scroll anchoring (maintains position across data changes)
+* - Edge detection for infinite scroll
+* - iOS momentum and elastic scrolling
+* - Configurable overscan (extra items rendered for smooth scrolling)
+*
+* Perfect for large data sets, chat apps, and infinite scroll implementations.
+*/
+/**
+* Virtual scrolling composable for efficiently rendering large lists
+*
+* @param items Reactive array of items to virtualize
+* @param options Configuration options
+* @returns Virtual scrolling context
+*
+* @see https://0.vuetifyjs.com/composables/utilities/use-virtual
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useVirtual } from '@vuetify/v0'
+*
+*   const items = ref(Array.from({ length: 10000 }, (_, i) => ({ id: i, name: `Item ${i}` })))
+* <\/script>
+*
+* <template>
+*   <div
+*     ref="element"
+*     style="height: 600px; overflow-y: auto;"
+*     @scroll="scroll"
+*   >
+*     <div :style="{ height: `${offset}px` }" />
+*
+*     <div v-for="item in items" :key="item.index">
+*       {{ item.raw.name }}
+*     </div>
+*
+*     <div :style="{ height: `${size}px` }" />
+*   </div>
+* </template>
+* ```
+*/
+function useVirtual(items, _options = {}) {
+	const { itemHeight: _itemHeight, height, overscan = 5, direction = "forward", anchor = "auto", anchorSmooth = true, onStartReached, onEndReached, startThreshold = 0, endThreshold = 0, momentum: momentumOption, elastic: elasticOption } = _options;
+	const element = ref();
+	const itemHeight = shallowRef(Number.parseFloat(String(_itemHeight || 0)));
+	const heights = shallowRef([]);
+	const offsets = shallowRef([]);
+	const first = shallowRef(0);
+	const last = shallowRef(0);
+	const offset = shallowRef(0);
+	const size = shallowRef(0);
+	const viewportHeight = shallowRef(0);
+	const state = shallowRef("ok");
+	const isIOS = IN_BROWSER && /iPad|iPhone|iPod/.test(navigator.userAgent);
+	const momentum = momentumOption ?? isIOS;
+	const elastic = elasticOption ?? isIOS;
+	let raf = -1;
+	let rebuildRaf = -1;
+	let edgeRaf = -1;
+	const cachedViewport = Number.parseInt(String(height)) || 0;
+	let anchorIndex = -1;
+	let anchorOffset = 0;
+	const computedItems = computed(() => items.value.slice(first.value, last.value).map((item, i) => ({
+		raw: item,
+		index: i + first.value
+	})));
+	watch(element, (el) => {
+		if (!IN_BROWSER || !el?.style) return;
+		if (momentum) el.style.webkitOverflowScrolling = "touch";
+		if (!elastic) el.style.overscrollBehavior = "none";
+	});
+	useResizeObserver(element, (entries) => {
+		if (!entries[0]) return;
+		viewportHeight.value = entries[0].contentRect.height;
+		update();
+	});
+	watch(items, (newItems) => {
+		captureAnchor();
+		const length = newItems.length;
+		const newHeights = heights.value.length === length ? heights.value : Array.from({ length }, () => null);
+		if (heights.value !== newHeights) heights.value = newHeights;
+		rebuild();
+	}, { immediate: true });
+	watch(element, () => {
+		if (!element.value) return;
+		if (direction === "reverse" && items.value.length > 0) {
+			const lastIndex = items.value.length - 1;
+			const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || itemHeight.value);
+			element.value.scrollTop = totalHeight;
+		}
+		update();
+	});
+	function captureAnchor() {
+		if (!element.value || anchor === "auto") return;
+		if (anchor === "start") {
+			anchorIndex = 0;
+			anchorOffset = 0;
+		} else if (anchor === "end") {
+			anchorIndex = items.value.length - 1;
+			anchorOffset = 0;
+		} else if (/* @__PURE__ */ isFunction(anchor)) {
+			const result = anchor(items.value);
+			if (/* @__PURE__ */ isNumber(result)) {
+				anchorIndex = result;
+				anchorOffset = element.value.scrollTop - (offsets.value[result] || 0);
+			}
+		} else {
+			anchorIndex = first.value;
+			anchorOffset = element.value.scrollTop - (offsets.value[first.value] || 0);
+		}
+	}
+	function restoreAnchor() {
+		if (!element.value || anchorIndex < 0) return;
+		const newScrollTop = (offsets.value[anchorIndex] || 0) + anchorOffset;
+		if (anchorSmooth && direction === "forward") element.value.scrollTo({
+			top: newScrollTop,
+			behavior: "smooth"
+		});
+		else element.value.scrollTop = newScrollTop;
+		anchorIndex = -1;
+		anchorOffset = 0;
+	}
+	function rebuild() {
+		const length = items.value.length;
+		const newOffsets = offsets.value.length === length ? offsets.value : Array.from({ length });
+		let offset$1 = 0;
+		for (let i = 0; i < length; i++) {
+			newOffsets[i] = offset$1;
+			offset$1 += heights.value[i] || itemHeight.value;
+		}
+		if (offsets.value !== newOffsets) offsets.value = newOffsets;
+		update();
+		restoreAnchor();
+	}
+	function findIndex(scrollTop) {
+		const arr = offsets.value;
+		if (arr.length === 0) return 0;
+		let low = 0;
+		let high = arr.length - 1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			if (arr[mid] <= scrollTop) low = mid + 1;
+			else high = mid - 1;
+		}
+		return Math.max(0, high);
+	}
+	function update() {
+		if (!element.value) return;
+		const viewport = viewportHeight.value || cachedViewport;
+		if (!viewport || !itemHeight.value) return;
+		const scrollTop = element.value.scrollTop || 0;
+		const length = items.value.length;
+		const visibleStart = findIndex(scrollTop);
+		const visibleEnd = findIndex(scrollTop + viewport) + 1;
+		const start = /* @__PURE__ */ clamp(visibleStart - overscan, 0, length);
+		const end = /* @__PURE__ */ clamp(visibleEnd + overscan, start, length);
+		first.value = start;
+		last.value = end;
+		offset.value = offsets.value[start] || 0;
+		const lastIndex = length - 1;
+		const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || itemHeight.value);
+		size.value = totalHeight - (offsets.value[end] || totalHeight);
+	}
+	function checkEdges() {
+		if (!element.value) return;
+		const scrollTop = element.value.scrollTop;
+		const scrollHeight = element.value.scrollHeight;
+		const clientHeight = element.value.clientHeight;
+		const distanceFromStart = scrollTop;
+		const distanceFromEnd = scrollHeight - (scrollTop + clientHeight);
+		if (IN_BROWSER) {
+			cancelAnimationFrame(edgeRaf);
+			edgeRaf = requestAnimationFrame(() => {
+				if (onStartReached && distanceFromStart <= startThreshold) onStartReached(distanceFromStart);
+				if (onEndReached && distanceFromEnd <= endThreshold) onEndReached(distanceFromEnd);
+			});
+		} else {
+			if (onStartReached && distanceFromStart <= startThreshold) onStartReached(distanceFromStart);
+			if (onEndReached && distanceFromEnd <= endThreshold) onEndReached(distanceFromEnd);
+		}
+	}
+	function resize(index, height$1) {
+		if (heights.value[index] === height$1) return;
+		heights.value[index] = height$1;
+		if (!itemHeight.value) itemHeight.value = height$1;
+		if (IN_BROWSER) {
+			cancelAnimationFrame(rebuildRaf);
+			rebuildRaf = requestAnimationFrame(rebuild);
+		} else rebuild();
+	}
+	function scroll() {
+		if (IN_BROWSER) {
+			cancelAnimationFrame(raf);
+			raf = requestAnimationFrame(update);
+			checkEdges();
+		} else update();
+	}
+	function scrollTo(index, scrollOptions) {
+		if (!element.value) return;
+		const targetOffset = offsets.value[index] || 0;
+		const behavior = scrollOptions?.behavior ?? "auto";
+		const block = scrollOptions?.block ?? "start";
+		const extraOffset = scrollOptions?.offset ?? 0;
+		let scrollTop = targetOffset + extraOffset;
+		switch (block) {
+			case "center": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const itemH = heights.value[index] || itemHeight.value;
+				scrollTop = targetOffset - viewport / 2 + itemH / 2 + extraOffset;
+				break;
+			}
+			case "end": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const itemH = heights.value[index] || itemHeight.value;
+				scrollTop = targetOffset - viewport + itemH + extraOffset;
+				break;
+			}
+			case "nearest": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const currentScroll = element.value.scrollTop;
+				const itemH = heights.value[index] || itemHeight.value;
+				if (targetOffset < currentScroll) scrollTop = targetOffset + extraOffset;
+				else if (targetOffset + itemH > currentScroll + viewport) scrollTop = targetOffset - viewport + itemH + extraOffset;
+				else return;
+				break;
+			}
+		}
+		if (behavior === "smooth") element.value.scrollTo({
+			top: scrollTop,
+			behavior: "smooth"
+		});
+		else element.value.scrollTop = scrollTop;
+		update();
+	}
+	function reset() {
+		state.value = "ok";
+		anchorIndex = -1;
+		anchorOffset = 0;
+		if (element.value && direction === "reverse" && items.value.length > 0) {
+			const lastIndex = items.value.length - 1;
+			const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || itemHeight.value);
+			element.value.scrollTop = totalHeight;
+		}
+	}
+	return {
+		element,
+		items: computedItems,
+		offset: readonly(offset),
+		size: readonly(size),
+		state,
+		scrollTo,
+		scroll,
+		scrollend: scroll,
+		resize,
+		reset
+	};
 }
 
 //#endregion
 //#region src/components/Avatar/AvatarFallback.vue
-const _sfc_main$17 = /* @__PURE__ */ defineComponent({
+const _sfc_main$24 = /* @__PURE__ */ defineComponent({
 	name: "AvatarFallback",
 	__name: "AvatarFallback",
 	props: {
@@ -5107,11 +6200,11 @@ const _sfc_main$17 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var AvatarFallback_default = _sfc_main$17;
+var AvatarFallback_default = _sfc_main$24;
 
 //#endregion
 //#region src/components/Avatar/AvatarImage.vue
-const _sfc_main$16 = /* @__PURE__ */ defineComponent({
+const _sfc_main$23 = /* @__PURE__ */ defineComponent({
 	name: "AvatarImage",
 	inheritAttrs: false,
 	__name: "AvatarImage",
@@ -5168,11 +6261,11 @@ const _sfc_main$16 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var AvatarImage_default = _sfc_main$16;
+var AvatarImage_default = _sfc_main$23;
 
 //#endregion
 //#region src/components/Avatar/AvatarRoot.vue
-const _sfc_main$15 = /* @__PURE__ */ defineComponent({
+const _sfc_main$22 = /* @__PURE__ */ defineComponent({
 	name: "AvatarRoot",
 	__name: "AvatarRoot",
 	props: {
@@ -5198,7 +6291,7 @@ const _sfc_main$15 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var AvatarRoot_default = _sfc_main$15;
+var AvatarRoot_default = _sfc_main$22;
 
 //#endregion
 //#region src/components/Avatar/index.ts
@@ -5210,7 +6303,7 @@ const Avatar = {
 
 //#endregion
 //#region src/components/ExpansionPanel/ExpansionPanelActivator.vue
-const _sfc_main$14 = /* @__PURE__ */ defineComponent({
+const _sfc_main$21 = /* @__PURE__ */ defineComponent({
 	name: "ExpansionPanelActivator",
 	__name: "ExpansionPanelActivator",
 	props: {
@@ -5226,7 +6319,7 @@ const _sfc_main$14 = /* @__PURE__ */ defineComponent({
 				context.ticket.toggle();
 			}
 		}
-		const bindableProps = computed(() => ({
+		const slotProps = toRef(() => ({
 			"id": context.headerId.value,
 			"role": "button",
 			"tabindex": context.isDisabled.value ? -1 : 0,
@@ -5238,20 +6331,24 @@ const _sfc_main$14 = /* @__PURE__ */ defineComponent({
 			"onClick": context.ticket.toggle,
 			onKeydown
 		}));
+		const isExpanded = toRef(() => context.ticket.isSelected.value);
+		const isDisabled = toRef(() => context.isDisabled.value);
 		return (_ctx, _cache) => {
 			return openBlock(), createBlock(unref(Atom_default), {
-				id: bindableProps.value.id,
-				"aria-controls": bindableProps.value["aria-controls"],
-				"aria-disabled": bindableProps.value["aria-disabled"],
-				"aria-expanded": bindableProps.value["aria-expanded"],
+				id: slotProps.value.id,
+				"aria-controls": slotProps.value["aria-controls"],
+				"aria-disabled": slotProps.value["aria-disabled"],
+				"aria-expanded": slotProps.value["aria-expanded"],
 				as: __props.as,
+				"data-disabled": isDisabled.value ? "" : void 0,
+				"data-expanded": isExpanded.value ? "" : void 0,
 				renderless: __props.renderless,
-				role: bindableProps.value.role,
-				tabindex: bindableProps.value.tabindex,
+				role: slotProps.value.role,
+				tabindex: slotProps.value.tabindex,
 				onClick: unref(context).ticket.toggle,
 				onKeydown
 			}, {
-				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
 				_: 3
 			}, 8, [
 				"id",
@@ -5259,6 +6356,8 @@ const _sfc_main$14 = /* @__PURE__ */ defineComponent({
 				"aria-disabled",
 				"aria-expanded",
 				"as",
+				"data-disabled",
+				"data-expanded",
 				"renderless",
 				"role",
 				"tabindex",
@@ -5267,51 +6366,54 @@ const _sfc_main$14 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var ExpansionPanelActivator_default = _sfc_main$14;
+var ExpansionPanelActivator_default = _sfc_main$21;
 
 //#endregion
 //#region src/components/ExpansionPanel/ExpansionPanelContent.vue
-const _sfc_main$13 = /* @__PURE__ */ defineComponent({
+const _sfc_main$20 = /* @__PURE__ */ defineComponent({
 	name: "ExpansionPanelContent",
 	__name: "ExpansionPanelContent",
 	props: {
 		itemNamespace: { default: "v0:expansion-panel-item" },
-		as: {},
+		as: { default: "div" },
 		renderless: { type: Boolean }
 	},
 	setup(__props) {
 		const context = useContext(__props.itemNamespace);
-		const bindableProps = computed(() => ({
+		const slotProps = toRef(() => ({
 			"id": context.contentId.value,
 			"role": "region",
 			"aria-labelledby": context.headerId.value,
 			"isSelected": context.ticket.isSelected.value
 		}));
+		const isExpanded = toRef(() => context.ticket.isSelected.value);
 		return (_ctx, _cache) => {
 			return openBlock(), createBlock(unref(Atom_default), {
-				id: bindableProps.value.id,
-				"aria-labelledby": bindableProps.value["aria-labelledby"],
+				id: slotProps.value.id,
+				"aria-labelledby": slotProps.value["aria-labelledby"],
 				as: __props.as,
+				"data-expanded": isExpanded.value ? "" : void 0,
 				renderless: __props.renderless,
-				role: bindableProps.value.role
+				role: slotProps.value.role
 			}, {
-				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
 				_: 3
 			}, 8, [
 				"id",
 				"aria-labelledby",
 				"as",
+				"data-expanded",
 				"renderless",
 				"role"
 			]);
 		};
 	}
 });
-var ExpansionPanelContent_default = _sfc_main$13;
+var ExpansionPanelContent_default = _sfc_main$20;
 
 //#endregion
 //#region src/components/ExpansionPanel/ExpansionPanelItem.vue
-const _sfc_main$12 = /* @__PURE__ */ defineComponent({
+const _sfc_main$19 = /* @__PURE__ */ defineComponent({
 	name: "ExpansionPanelItem",
 	__name: "ExpansionPanelItem",
 	props: {
@@ -5354,11 +6456,11 @@ const _sfc_main$12 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var ExpansionPanelItem_default = _sfc_main$12;
+var ExpansionPanelItem_default = _sfc_main$19;
 
 //#endregion
 //#region src/components/ExpansionPanel/ExpansionPanelRoot.vue
-const _sfc_main$11 = /* @__PURE__ */ defineComponent({
+const _sfc_main$18 = /* @__PURE__ */ defineComponent({
 	name: "ExpansionPanelRoot",
 	__name: "ExpansionPanelRoot",
 	props: /* @__PURE__ */ mergeModels({
@@ -5432,7 +6534,7 @@ const _sfc_main$11 = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var ExpansionPanelRoot_default = _sfc_main$11;
+var ExpansionPanelRoot_default = _sfc_main$18;
 
 //#endregion
 //#region src/components/ExpansionPanel/index.ts
@@ -5445,13 +6547,14 @@ const ExpansionPanel = {
 
 //#endregion
 //#region src/components/Group/GroupItem.vue
-const _sfc_main$10 = /* @__PURE__ */ defineComponent({
+const _sfc_main$17 = /* @__PURE__ */ defineComponent({
 	name: "GroupItem",
 	__name: "GroupItem",
 	props: {
 		label: {},
 		id: {},
 		disabled: {},
+		indeterminate: { default: false },
 		value: {},
 		namespace: { default: "v0:group" }
 	},
@@ -5460,9 +6563,10 @@ const _sfc_main$10 = /* @__PURE__ */ defineComponent({
 		const ticket = group.register({
 			id: __props.id,
 			value: __props.value,
-			disabled: __props.disabled
+			disabled: __props.disabled,
+			indeterminate: __props.indeterminate
 		});
-		const isDisabled = toRef(() => ticket.disabled || group.disabled);
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(group.disabled));
 		onUnmounted(() => {
 			group.unregister(ticket.id);
 		});
@@ -5472,21 +6576,24 @@ const _sfc_main$10 = /* @__PURE__ */ defineComponent({
 				ariaDisabled: toValue(isDisabled.value),
 				ariaSelected: toValue(unref(ticket).isSelected),
 				disabled: toValue(isDisabled.value),
+				isMixed: toValue(unref(ticket).isMixed),
 				isSelected: toValue(unref(ticket).isSelected),
 				label: __props.label,
+				mix: unref(ticket).mix,
 				select: unref(ticket).select,
 				toggle: unref(ticket).toggle,
+				unmix: unref(ticket).unmix,
 				unselect: unref(ticket).unselect,
 				value: __props.value
 			});
 		};
 	}
 });
-var GroupItem_default = _sfc_main$10;
+var GroupItem_default = _sfc_main$17;
 
 //#endregion
 //#region src/components/Group/GroupRoot.vue
-const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+const _sfc_main$16 = /* @__PURE__ */ defineComponent({
 	name: "GroupRoot",
 	__name: "GroupRoot",
 	props: /* @__PURE__ */ mergeModels({
@@ -5523,14 +6630,20 @@ const _sfc_main$9 = /* @__PURE__ */ defineComponent({
 			return renderSlot(_ctx.$slots, "default", {
 				ariaMultiselectable: true,
 				disabled: toValue(unref(context).disabled),
+				isAllSelected: unref(context).isAllSelected.value,
+				isMixed: unref(context).isMixed.value,
+				isNoneSelected: unref(context).isNoneSelected.value,
 				select: unref(context).select,
+				selectAll: unref(context).selectAll,
 				toggle: unref(context).toggle,
-				unselect: unref(context).unselect
+				toggleAll: unref(context).toggleAll,
+				unselect: unref(context).unselect,
+				unselectAll: unref(context).unselectAll
 			});
 		};
 	}
 });
-var GroupRoot_default = _sfc_main$9;
+var GroupRoot_default = _sfc_main$16;
 
 //#endregion
 //#region src/components/Group/index.ts
@@ -5539,6 +6652,512 @@ const Group = {
 	Item: GroupItem_default
 };
 
+//#endregion
+//#region src/components/Pagination/PaginationRoot.vue
+function usePaginationControls(namespace) {
+	return useContext(`${namespace}:controls`);
+}
+function usePaginationItems(namespace) {
+	return useContext(`${namespace}:items`);
+}
+const _sfc_main$15 = /* @__PURE__ */ defineComponent({
+	name: "PaginationRoot",
+	__name: "PaginationRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:pagination" },
+		size: { default: 1 },
+		totalVisible: {},
+		itemsPerPage: { default: 10 },
+		ellipsis: {
+			type: [String, Boolean],
+			default: "..."
+		},
+		as: { default: "nav" },
+		renderless: { type: Boolean }
+	}, {
+		"modelValue": { default: 1 },
+		"modelModifiers": {}
+	}),
+	emits: /* @__PURE__ */ mergeModels(["update:model-value"], ["update:modelValue"]),
+	setup(__props) {
+		const page = useModel(__props, "modelValue");
+		const itemWidth = shallowRef(0);
+		const itemGap = shallowRef(0);
+		const atom = useTemplateRef("atom");
+		const locale = useLocale();
+		const [, provideControlContext, controls] = createRegistryContext({ namespace: `${__props.namespace}:controls` });
+		const [, provideItemContext, items] = createRegistryContext({ namespace: `${__props.namespace}:items` });
+		const overflow = createOverflow({
+			container: () => atom.value?.element,
+			itemWidth,
+			gap: itemGap
+		});
+		watch([() => items.size, () => overflow.width.value], () => {
+			const el = items.seek("first")?.value;
+			const root = overflow.container.value;
+			if (!el || !root) return;
+			const rootStyle = getComputedStyle(root);
+			const style = getComputedStyle(el);
+			const marginX = Number.parseFloat(style.marginLeft) + Number.parseFloat(style.marginRight);
+			const gapX = Number.parseFloat(rootStyle.gap) || 0;
+			itemWidth.value = el.offsetWidth + marginX;
+			itemGap.value = gapX;
+		}, { flush: "post" });
+		const visible = computed(() => {
+			const totalCap = overflow.capacity.value;
+			if (totalCap === Infinity) return __props.totalVisible ?? Infinity;
+			const pageCap = Math.max(0, totalCap - controls.size);
+			const noVisible = /* @__PURE__ */ isNullOrUndefined(__props.totalVisible);
+			if (pageCap > 0) return noVisible ? pageCap : Math.min(__props.totalVisible, pageCap);
+			return noVisible ? 1 : __props.totalVisible;
+		});
+		const [, providePaginationContext, pagination] = createPaginationContext({
+			namespace: __props.namespace,
+			page,
+			visible,
+			ellipsis: __props.ellipsis,
+			size: () => __props.size,
+			itemsPerPage: () => __props.itemsPerPage
+		});
+		const slotProps = toRef(() => ({
+			ariaLabel: locale.t("Pagination.label", void 0, "Pagination"),
+			page: pagination.page.value,
+			size: pagination.size,
+			pages: pagination.pages,
+			itemsPerPage: pagination.itemsPerPage,
+			items: pagination.items.value,
+			pageStart: pagination.pageStart.value,
+			pageStop: pagination.pageStop.value,
+			isFirst: pagination.isFirst.value,
+			isLast: pagination.isLast.value,
+			first: pagination.first,
+			last: pagination.last,
+			next: pagination.next,
+			prev: pagination.prev,
+			select: pagination.select
+		}));
+		providePaginationContext();
+		provideControlContext();
+		provideItemContext();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-label": slotProps.value.ariaLabel,
+				as: __props.as,
+				renderless: __props.renderless
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-label",
+				"as",
+				"renderless"
+			]);
+		};
+	}
+});
+var PaginationRoot_default = _sfc_main$15;
+
+//#endregion
+//#region src/components/Pagination/PaginationEllipsis.vue
+const _sfc_main$14 = /* @__PURE__ */ defineComponent({
+	name: "PaginationEllipsis",
+	__name: "PaginationEllipsis",
+	props: {
+		namespace: { default: "v0:pagination" },
+		ellipsis: {},
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "span" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const pagination = usePagination(__props.namespace);
+		const items = usePaginationItems(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			items.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => items.unregister(__props.id));
+		const resolvedEllipsis = toRef(() => __props.ellipsis ?? pagination.ellipsis);
+		const slotProps = toRef(() => ({
+			ariaHidden: "true",
+			ellipsis: resolvedEllipsis.value
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-hidden": slotProps.value.ariaHidden,
+				as: __props.as,
+				renderless: __props.renderless
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)), () => [createTextVNode(toDisplayString(resolvedEllipsis.value), 1)])]),
+				_: 3
+			}, 8, [
+				"aria-hidden",
+				"as",
+				"renderless"
+			]);
+		};
+	}
+});
+var PaginationEllipsis_default = _sfc_main$14;
+
+//#endregion
+//#region src/components/Pagination/PaginationFirst.vue
+const _sfc_main$13 = /* @__PURE__ */ defineComponent({
+	name: "PaginationFirst",
+	__name: "PaginationFirst",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePagination(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		const isDisabled = toRef(() => __props.disabled || pagination.isFirst.value);
+		function onClick() {
+			if (isDisabled.value) return;
+			pagination.first();
+		}
+		const slotProps = toRef(() => ({
+			ariaLabel: locale.t("Pagination.first", void 0, "Go to first page"),
+			disabled: isDisabled.value,
+			onClick
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-disabled": slotProps.value.disabled,
+				"aria-label": slotProps.value.ariaLabel,
+				as: __props.as,
+				"data-disabled": slotProps.value.disabled || void 0,
+				disabled: __props.as === "button" ? slotProps.value.disabled : void 0,
+				renderless: __props.renderless,
+				type: __props.as === "button" ? "button" : void 0,
+				onClick: slotProps.value.onClick
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-disabled",
+				"aria-label",
+				"as",
+				"data-disabled",
+				"disabled",
+				"renderless",
+				"type",
+				"onClick"
+			]);
+		};
+	}
+});
+var PaginationFirst_default = _sfc_main$13;
+
+//#endregion
+//#region src/components/Pagination/PaginationItem.vue
+const _sfc_main$12 = /* @__PURE__ */ defineComponent({
+	name: "PaginationItem",
+	__name: "PaginationItem",
+	props: {
+		namespace: { default: "v0:pagination" },
+		value: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePagination(__props.namespace);
+		const items = usePaginationItems(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			items.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => items.unregister(__props.id));
+		const isSelected = toRef(() => pagination.page.value === __props.value);
+		const ariaLabel = toRef(() => {
+			return isSelected.value ? locale.t("Pagination.currentPage", { page: __props.value }, `Page ${__props.value}, current page`) : locale.t("Pagination.goToPage", { page: __props.value }, `Go to page ${__props.value}`);
+		});
+		const slotProps = toRef(() => ({
+			ariaLabel: ariaLabel.value,
+			ariaCurrent: isSelected.value ? "page" : void 0,
+			page: __props.value,
+			isSelected: isSelected.value,
+			dataSelected: isSelected.value,
+			disabled: __props.disabled,
+			select
+		}));
+		function select() {
+			if (__props.disabled) return;
+			pagination.select(__props.value);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-current": slotProps.value.ariaCurrent,
+				"aria-label": slotProps.value.ariaLabel,
+				as: __props.as,
+				"data-disabled": slotProps.value.disabled || void 0,
+				"data-selected": slotProps.value.dataSelected || void 0,
+				disabled: __props.as === "button" ? slotProps.value.disabled : void 0,
+				renderless: __props.renderless,
+				type: __props.as === "button" ? "button" : void 0,
+				onClick: slotProps.value.select
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-current",
+				"aria-label",
+				"as",
+				"data-disabled",
+				"data-selected",
+				"disabled",
+				"renderless",
+				"type",
+				"onClick"
+			]);
+		};
+	}
+});
+var PaginationItem_default = _sfc_main$12;
+
+//#endregion
+//#region src/components/Pagination/PaginationLast.vue
+const _sfc_main$11 = /* @__PURE__ */ defineComponent({
+	name: "PaginationLast",
+	__name: "PaginationLast",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePagination(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		const isDisabled = toRef(() => __props.disabled || pagination.isLast.value);
+		function onClick() {
+			if (isDisabled.value) return;
+			pagination.last();
+		}
+		const slotProps = toRef(() => ({
+			ariaLabel: locale.t("Pagination.last", void 0, "Go to last page"),
+			disabled: isDisabled.value,
+			onClick
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-disabled": slotProps.value.disabled,
+				"aria-label": slotProps.value.ariaLabel,
+				as: __props.as,
+				"data-disabled": slotProps.value.disabled || void 0,
+				disabled: __props.as === "button" ? slotProps.value.disabled : void 0,
+				renderless: __props.renderless,
+				type: __props.as === "button" ? "button" : void 0,
+				onClick: slotProps.value.onClick
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-disabled",
+				"aria-label",
+				"as",
+				"data-disabled",
+				"disabled",
+				"renderless",
+				"type",
+				"onClick"
+			]);
+		};
+	}
+});
+var PaginationLast_default = _sfc_main$11;
+
+//#endregion
+//#region src/components/Pagination/PaginationNext.vue
+const _sfc_main$10 = /* @__PURE__ */ defineComponent({
+	name: "PaginationNext",
+	__name: "PaginationNext",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePagination(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		const isDisabled = toRef(() => __props.disabled || pagination.isLast.value);
+		function onClick() {
+			if (isDisabled.value) return;
+			pagination.next();
+		}
+		const slotProps = toRef(() => ({
+			ariaLabel: locale.t("Pagination.next", void 0, "Go to next page"),
+			disabled: isDisabled.value,
+			onClick
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-disabled": slotProps.value.disabled,
+				"aria-label": slotProps.value.ariaLabel,
+				as: __props.as,
+				"data-disabled": slotProps.value.disabled || void 0,
+				disabled: __props.as === "button" ? slotProps.value.disabled : void 0,
+				renderless: __props.renderless,
+				type: __props.as === "button" ? "button" : void 0,
+				onClick: slotProps.value.onClick
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-disabled",
+				"aria-label",
+				"as",
+				"data-disabled",
+				"disabled",
+				"renderless",
+				"type",
+				"onClick"
+			]);
+		};
+	}
+});
+var PaginationNext_default = _sfc_main$10;
+
+//#endregion
+//#region src/components/Pagination/PaginationPrev.vue
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+	name: "PaginationPrev",
+	__name: "PaginationPrev",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePagination(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		const isDisabled = toRef(() => __props.disabled || pagination.isFirst.value);
+		function onClick() {
+			if (isDisabled.value) return;
+			pagination.prev();
+		}
+		const slotProps = toRef(() => ({
+			ariaLabel: locale.t("Pagination.prev", void 0, "Go to previous page"),
+			disabled: isDisabled.value,
+			onClick
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				ref_key: "atom",
+				ref: atom,
+				"aria-disabled": slotProps.value.disabled,
+				"aria-label": slotProps.value.ariaLabel,
+				as: __props.as,
+				"data-disabled": slotProps.value.disabled || void 0,
+				disabled: __props.as === "button" ? slotProps.value.disabled : void 0,
+				renderless: __props.renderless,
+				type: __props.as === "button" ? "button" : void 0,
+				onClick: slotProps.value.onClick
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-disabled",
+				"aria-label",
+				"as",
+				"data-disabled",
+				"disabled",
+				"renderless",
+				"type",
+				"onClick"
+			]);
+		};
+	}
+});
+var PaginationPrev_default = _sfc_main$9;
+
+//#endregion
+//#region src/components/Pagination/index.ts
+const Pagination = {
+	Root: PaginationRoot_default,
+	Item: PaginationItem_default,
+	First: PaginationFirst_default,
+	Prev: PaginationPrev_default,
+	Ellipsis: PaginationEllipsis_default,
+	Next: PaginationNext_default,
+	Last: PaginationLast_default
+};
+
 //#endregion
 //#region src/components/Popover/PopoverRoot.vue
 const [usePopoverContext, providePopoverContext] = createContext("Popover");
@@ -5705,7 +7324,7 @@ const _sfc_main$5 = /* @__PURE__ */ defineComponent({
 			value: __props.value,
 			disabled: __props.disabled
 		});
-		const isDisabled = toRef(() => ticket.disabled || selection.disabled);
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(selection.disabled));
 		onUnmounted(() => {
 			selection.unregister(ticket.id);
 		});
@@ -5807,7 +7426,7 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
 			value: __props.value,
 			disabled: __props.disabled
 		});
-		const isDisabled = toRef(() => ticket.disabled || single.disabled);
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(single.disabled));
 		onUnmounted(() => {
 			single.unregister(ticket.id);
 		});
@@ -5903,7 +7522,7 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
 			value: __props.value,
 			disabled: __props.disabled
 		});
-		const isDisabled = toRef(() => ticket.disabled || step.disabled);
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(step.disabled));
 		onUnmounted(() => {
 			step.unregister(ticket.id);
 		});
@@ -5986,4 +7605,4 @@ const Step = {
 };
 
 //#endregion
-export { Atom_default as Atom, Avatar, COMMON_ELEMENTS, ConsolaLoggerAdapter, ExpansionPanel, Group, IN_BROWSER, MemoryAdapter, PermissionAdapter, PinoLoggerAdapter, Popover, SELF_CLOSING_TAGS, SUPPORTS_INTERSECTION_OBSERVER, SUPPORTS_MATCH_MEDIA, SUPPORTS_MUTATION_OBSERVER, SUPPORTS_OBSERVER, SUPPORTS_TOUCH, Selection, Single, Step, Vuetify0LocaleAdapter, Vuetify0LoggerAdapter, Vuetify0ThemeAdapter, __LOGGER_ENABLED__, createBreakpoints, createBreakpointsContext, createBreakpointsPlugin, createContext, createFeatures, createFeaturesContext, createFeaturesPlugin, createForm, createFormContext, createGroup, createGroupContext, createHydration, createHydrationContext, createHydrationPlugin, createLocale, createLocaleContext, createLocalePlugin, createLogger, createLoggerContext, createLoggerPlugin, createPermissions, createPermissionsContext, createPermissionsPlugin, createPlugin, createQueue, createQueueContext, createRegistryContext, createSelection, createSelectionContext, createSingle, createSingleContext, createStep, createStepContext, createStorage, createStorageContext, createStoragePlugin, createTheme, createThemeContext, createThemePlugin, createTimeline, createTimelineContext, createTokens, createTokensContext, createTrinity, genId, isArray, isBoolean, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isSelfClosingTag, isString, isUndefined, mergeDeep, provideContext, providePopoverContext, provideStorageContext, toArray, toReactive, useBreakpoints, useContext, useDocumentEventListener, useElementIntersection, useElementSize, useEventListener, useFeatures, useFilter, useForm, useGroup, useHydration, useIntersectionObserver, useKeydown, useLocale, useLogger, useMutationObserver, usePermissions, usePopoverContext, useProxyModel, useProxyRegistry, useQueue, useRegistry, useResizeObserver, useSelection, useSingle, useStep, useStorage, useStorageContext, useTheme, useTimeline, useTokens, useWindowEventListener, version };
+export { Atom_default as Atom, Avatar, COMMON_ELEMENTS, ConsolaLoggerAdapter, ExpansionPanel, Group, IN_BROWSER, MemoryAdapter, Pagination, PermissionAdapter, PinoLoggerAdapter, Popover, SELF_CLOSING_TAGS, SUPPORTS_INTERSECTION_OBSERVER, SUPPORTS_MATCH_MEDIA, SUPPORTS_MUTATION_OBSERVER, SUPPORTS_OBSERVER, SUPPORTS_TOUCH, Selection, Single, Step, Vuetify0LocaleAdapter, Vuetify0LoggerAdapter, Vuetify0ThemeAdapter, __LOGGER_ENABLED__, clamp, createBreakpoints, createBreakpointsContext, createBreakpointsPlugin, createContext, createFallbackHydration, createFeatures, createFeaturesContext, createFeaturesPlugin, createForm, createFormContext, createGroup, createGroupContext, createHydration, createHydrationContext, createHydrationPlugin, createLocale, createLocaleContext, createLocaleFallback, createLocalePlugin, createLogger, createLoggerContext, createLoggerPlugin, createOverflow, createOverflowContext, createPagination, createPaginationContext, createPermissions, createPermissionsContext, createPermissionsPlugin, createPlugin, createQueue, createQueueContext, createRegistryContext, createSelection, createSelectionContext, createSingle, createSingleContext, createStep, createStepContext, createStorage, createStorageContext, createStoragePlugin, createTheme, createThemeContext, createThemePlugin, createTimeline, createTimelineContext, createTokens, createTokensContext, createTrinity, debounce, genId, isArray, isBoolean, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isSelfClosingTag, isString, isUndefined, mergeDeep, provideContext, providePopoverContext, range, toArray, toReactive, useBreakpoints, useContext, useDocumentEventListener, useElementIntersection, useElementSize, useEventListener, useFeatures, useFilter, useForm, useGroup, useHydration, useIntersectionObserver, useKeydown, useLocale, useLogger, useMutationObserver, useOverflow, usePagination, usePaginationControls, usePaginationItems, usePermissions, usePopoverContext, useProxyModel, useProxyRegistry, useQueue, useRegistry, useResizeObserver, useSelection, useSingle, useStep, useStorage, useTheme, useTimeline, useToggleScope, useTokens, useVirtual, useWindowEventListener, version };