@vuetify/v0 0.2.1 → 1.0.0-alpha.1

package/dist/{useClickOutside-BjO3Nty9.mjs → useClickOutside-B9a6Jext.mjs}

@@ -1,22 +1,22 @@
-import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-BrRJkuSY.mjs";
+import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-Berkg6mP.mjs";
 import { clamp, instanceExists, isArray, isElement, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isString, isUndefined, mergeDeep, range, resolveIds, resolveIndexes, useId as useId$1 } from "./utilities/index.mjs";
-import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-vvXk0ARD.mjs";
-import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-Daz-Zr0z.mjs";
-import { a as createRegistry } from "./createTokens-CHTawmud.mjs";
-import { i as createModel, t as createSelection } from "./createSelection-Dsb3I0zm.mjs";
-import { t as createSingle } from "./createSingle-C7IGUjP6.mjs";
-import { t as toArray } from "./toArray-doLQVI56.mjs";
-import { n as createFilter } from "./adapter-CCIeOzqr.mjs";
-import { t as createGroup } from "./createGroup-CzRZ9COh.mjs";
-import { a as useLocale } from "./useLocale-BRQTt3Ka.mjs";
-import "./createPagination-Tp4C4He8.mjs";
-import "./createDataTable-DKE5QsMe.mjs";
-import { a as useRules, o as isStandardSchema } from "./useRules-BFPH7q8w.mjs";
-import "./useFeatures-D9bGOvh4.mjs";
-import "./usePermissions-Yp3guoLH.mjs";
+import { i as useContext, t as createTrinity } from "./createTrinity-BTCs1pYx.mjs";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-DFIRqm-N.mjs";
+import { a as createRegistry } from "./createTokens-oJAeh262.mjs";
+import { i as createModel, t as createSelection } from "./createSelection-BA9guLah.mjs";
+import { t as createSingle } from "./createSingle-BHxHLZeg.mjs";
+import { a as useLocale } from "./useLocale-qMmVnAwS.mjs";
+import { t as toArray } from "./toArray-BA_JxFPv.mjs";
+import { n as createFilter } from "./adapter-CDpOQ8sn.mjs";
+import { t as createGroup } from "./createGroup-BC2nfttd.mjs";
+import "./createPagination-qvJkcTUY.mjs";
+import "./createDataTable-B4UflKnT.mjs";
+import { a as useRules, o as isStandardSchema } from "./useRules-D3UXEtu7.mjs";
+import "./useFeatures-wgMwaQ5W.mjs";
+import "./usePermissions-tZhkBJmq.mjs";
 import { t as MemoryAdapter } from "./memory-XCMtkld1.mjs";
-import "./useTheme-zRa0Nh_g.mjs";
-import { computed, effectScope, isRef, nextTick, onMounted, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
+import "./useTheme-BeD__R8t.mjs";
+import { computed, effectScope, hasInjectionContext, isRef, nextTick, onMounted, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 //#region src/composables/createBreadcrumbs/index.ts
 /**
 * @module createBreadcrumbs
@@ -33,6 +33,16 @@ import { computed, effectScope, isRef, nextTick, onMounted, onScopeDispose, reac
 * - Trinity pattern for dependency injection
 *
 * Inheritance chain: createRegistry → createSelection → createSingle → createBreadcrumbs
+*
+* @example
+* ```ts
+* import { createBreadcrumbs } from '@vuetify/v0'
+*
+* const crumbs = createBreadcrumbs()
+* crumbs.register({ text: 'Home' })
+* crumbs.register({ text: 'Docs' })
+* console.log(crumbs.depth.value) // 2
+* ```
 */
 /**
 * Creates a breadcrumbs navigation model.
@@ -63,6 +73,7 @@ function createBreadcrumbs(options = {}) {
 	const single = createSingle({
 		...options,
 		reactive: true,
+		events: true,
 		enroll: true
 	});
 	const depth = toRef(() => single.size);
@@ -129,12 +140,7 @@ function createBreadcrumbs(options = {}) {
 */
 function createBreadcrumbsContext(_options = {}) {
 	const { namespace = "v0:breadcrumbs", ...options } = _options;
-	const [useBreadcrumbsContext, _provideBreadcrumbsContext] = createContext(namespace);
-	const context = createBreadcrumbs(options);
-	function provideBreadcrumbsContext(_context = context, app) {
-		return _provideBreadcrumbsContext(_context, app);
-	}
-	return createTrinity(useBreadcrumbsContext, provideBreadcrumbsContext, context);
+	return createTrinity(namespace, createBreadcrumbs(options));
 }
 /**
 * Returns the current breadcrumbs instance from context.
@@ -178,6 +184,14 @@ function useBreadcrumbs(namespace = "v0:breadcrumbs") {
 * - One-shot (default) or repeating mode
 * - Automatic cleanup on scope disposal
 * - SSR-safe
+*
+* @example
+* ```ts
+* import { useTimer } from '@vuetify/v0'
+*
+* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
+* timer.start()
+* ```
 */
 /**
 * Creates a reactive timer with pause/resume support.
@@ -311,6 +325,15 @@ function useTimer(handler, options = {}) {
 *
 * Perfect for building select, combobox, tooltip, and menu components
 * without wrapping the Popover compound component.
+*
+* @example
+* ```ts
+* import { usePopover } from '@vuetify/v0'
+*
+* const popover = usePopover()
+* popover.open()
+* popover.toggle()
+* ```
 */
 function usePopover(options = {}) {
 	const { id: _id, positionArea = "bottom", positionTry = "most-width bottom", showDelay = 0, hideDelay = 0 } = options;
@@ -392,6 +415,15 @@ function usePopover(options = {}) {
 * useRovingFocus and useVirtualFocus.
 *
 * Not exported from the package barrel — consumed only by sibling composables.
+*
+* @example
+* ```ts
+* import { createFocusTraversal } from '#v0/composables/createFocusTraversal'
+*
+* const items = () => [{ id: 'a' }, { id: 'b' }, { id: 'c' }]
+* const traversal = createFocusTraversal(items, id => console.log(id))
+* traversal.next()
+* ```
 */
 function mod(length, index) {
 	return (index % length + length) % length;
@@ -574,6 +606,15 @@ function createFocusTraversal(items, activate, options = {}) {
 *
 * Perfect for comboboxes, autocompletes, listboxes, and other widgets
 * where DOM focus must remain on the control element.
+*
+* @example
+* ```ts
+* import { useVirtualFocus } from '@vuetify/v0'
+*
+* const items = () => [{ id: 'a' }, { id: 'b' }, { id: 'c' }]
+* const cursor = useVirtualFocus(items)
+* cursor.next()
+* ```
 */
 function useVirtualFocus(items, options) {
 	const { control, target, orientation, circular, columns, onHighlight } = options;
@@ -616,6 +657,9 @@ function useVirtualFocus(items, options) {
 	}
 	const listener = target ?? control;
 	if (listener) useEventListener(listener, "keydown", traversal.onKeydown);
+	onScopeDispose(() => {
+		clear();
+	});
 	return {
 		highlightedId: traversal.activeId,
 		highlight,
@@ -709,6 +753,16 @@ var ServerAdapter = class {
 * - Strict mode: reverts query to selected value on close if no match
 * - Popover-based dropdown positioning
 * - Context DI via createComboboxContext / useCombobox
+*
+* @example
+* ```ts
+* import { createCombobox } from '@vuetify/v0'
+*
+* const combobox = createCombobox({ strict: true })
+* combobox.selection.register({ value: 'Apple' })
+* combobox.selection.register({ value: 'Banana' })
+* combobox.open()
+* ```
 */
 /**
 * Creates a combobox context that orchestrates selection, popover, virtual
@@ -778,7 +832,7 @@ function createCombobox(options = {}) {
 	const isOpen = popover.isOpen;
 	const cursor = useVirtualFocus(() => selection.values().filter((ticket) => filtered.value.has(ticket.id) && !toValue(ticket.disabled)).map((ticket) => ({
 		id: ticket.id,
-		el: () => document.querySelector(`#${CSS.escape(`${id}-option-${ticket.id}`)}`),
+		el: () => IN_BROWSER ? document.querySelector(`#${CSS.escape(`${id}-option-${ticket.id}`)}`) : null,
 		disabled: ticket.disabled
 	})), {
 		control: inputEl,
@@ -879,12 +933,7 @@ function createCombobox(options = {}) {
 */
 function createComboboxContext(options = {}) {
 	const { namespace = "v0:combobox", ...rest } = options;
-	const [useCombobox, _provideCombobox] = createContext(namespace);
-	const context = createCombobox(rest);
-	function provideCombobox(_context = context, app) {
-		return _provideCombobox(_context, app);
-	}
-	return createTrinity(useCombobox, provideCombobox, context);
+	return createTrinity(namespace, createCombobox(rest));
 }
 /**
 * Injects the current combobox context from a parent provider.
@@ -924,6 +973,15 @@ function useCombobox(namespace = "v0:combobox") {
 *
 * Per-field validation logic lives in createValidation.
 * createForm is the mothership — it coordinates, not creates.
+*
+* @example
+* ```ts
+* import { createForm } from '@vuetify/v0'
+*
+* const form = createForm()
+* const isValid = await form.validate()
+* if (isValid) form.submit()
+* ```
 */
 /**
 * Creates a new form instance.
@@ -1023,12 +1081,7 @@ function createForm(options = {}) {
 */
 function createFormContext(_options = {}) {
 	const { namespace = "v0:form", ...options } = _options;
-	const [useFormContext, _provideFormContext] = createContext(namespace);
-	const context = createForm(options);
-	function provideFormContext(_context = context, app) {
-		return _provideFormContext(_context, app);
-	}
-	return createTrinity(useFormContext, provideFormContext, context);
+	return createTrinity(namespace, createForm(options));
 }
 /**
 * Returns the current form instance.
@@ -1048,6 +1101,7 @@ function createFormContext(_options = {}) {
 * ```
 */
 function useForm(namespace = "v0:form") {
+	if (!hasInjectionContext()) return void 0;
 	try {
 		return useContext(namespace);
 	} catch {
@@ -1073,8 +1127,18 @@ function useForm(namespace = "v0:form") {
 * - Tri-state isValid (null/true/false)
 *
 * Uses useRules() to resolve alias strings via shared context.
+*
+* @example
+* ```ts
+* import { createValidation } from '@vuetify/v0'
+*
+* const validation = createValidation({
+*   rules: [v => !!v || 'Required'],
+* })
+* await validation.validate('hello')
+* ```
 */
-const UNSET = Symbol("unset");
+const UNSET = /* @__PURE__ */ Symbol("unset");
 /**
 * Creates a per-input validation instance.
 *
@@ -1146,6 +1210,13 @@ function createValidation(_options = {}) {
 				isValid.value = errorMessages.length === 0;
 			}
 			return errorMessages.length === 0;
+		} catch (error) {
+			if (gen !== generation) return isValid.value ?? false;
+			if (!silent) {
+				errors.value = [error instanceof Error ? error.message : "Validation error"];
+				isValid.value = false;
+			}
+			return false;
 		} finally {
 			if (gen === generation && !silent) isValidating.value = false;
 		}
@@ -1191,6 +1262,16 @@ function createValidation(_options = {}) {
 *
 * No event handling — composables never bind DOM events. Components call
 * validate() and write isFocused/isTouched when they choose.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { createInput } from '@vuetify/v0'
+*
+* const value = shallowRef('')
+* const input = createInput({ value, label: 'Name', rules: ['required'] })
+* await input.validate()
+* ```
 */
 function createInput(options) {
 	const { value, id = /* @__PURE__ */ useId$1(), label, name, form, required, disabled = false, readonly: _readonly = false, rules = [], error = false, errorMessages, dirty: dirtyFn, equals = (a, b) => a === b } = options;
@@ -1268,48 +1349,6 @@ function createInput(options) {
 	};
 }
 //#endregion
-//#region src/composables/createNested/strategies.ts
-/**
-* Multiple open strategy: allows multiple nodes to be open simultaneously.
-*
-* @remarks
-* Perfect for tree views, file explorers, and nested menus where users expect
-* to keep multiple sections expanded at once.
-*
-* @example
-* ```ts
-* const tree = createNested({ openStrategy: multipleOpenStrategy })
-* tree.open('node-1')
-* tree.open('node-2')
-* // Both nodes are now open
-* ```
-*/
-const multipleOpenStrategy = {
-	onOpen: void 0,
-	onClose: void 0
-};
-/**
-* Single open strategy: only one node can be open at a time (accordion behavior).
-*
-* @remarks
-* Perfect for accordions, single-select navigation, and contexts where only
-* one section should be visible at a time.
-*
-* @example
-* ```ts
-* const tree = createNested({ openStrategy: singleOpenStrategy })
-* tree.open('node-1') // node-1 opens
-* tree.open('node-2') // node-1 closes, node-2 opens
-* ```
-*/
-const singleOpenStrategy = {
-	onOpen: (id, context) => {
-		const toClose = [...context.openedIds].filter((openedId) => openedId !== id);
-		for (const openedId of toClose) context.openedIds.delete(openedId);
-	},
-	onClose: void 0
-};
-//#endregion
 //#region src/composables/createNested/index.ts
 /**
 * @module createNested
@@ -1323,17 +1362,20 @@ const singleOpenStrategy = {
 * - Tree traversal utilities (getPath, getDescendants, etc.)
 * - Cascade selection propagation through nested registers
 * - `rootIds` tracking for top-level item detection
-* - Pluggable open strategies
 *
 * Inheritance chain: createSelection → createGroup → createNested
+*
+* @example
+* ```ts
+* import { createNested } from '@vuetify/v0'
+*
+* const tree = createNested()
+* const root = tree.register({ value: 'root' })
+* tree.register({ value: 'child', parentId: root.id })
+* tree.open(root.id)
+* ```
 */
 /**
-* Resolves open mode to an OpenStrategy.
-*/
-function resolveOpenStrategy(open = "multiple") {
-	return open === "single" ? singleOpenStrategy : multipleOpenStrategy;
-}
-/**
 * Creates a new nested tree instance with hierarchical management.
 *
 * Extends `createGroup` to support parent-child relationships, tree traversal,
@@ -1372,10 +1414,9 @@ function resolveOpenStrategy(open = "multiple") {
 * ```
 */
 function createNested(_options = {}) {
-	const { open: openMode = "multiple", openAll = false, reveal: revealOnOpen = false, selection: selectionMode = "cascade", active: activeMode = "single", openStrategy, ...options } = _options;
+	const { open: openMode = "multiple", openAll = false, reveal: revealOnOpen = false, selection: selectionMode = "cascade", active: activeMode = "single", ...options } = _options;
 	const mandatoryOption = _options.mandatory ?? false;
 	const multipleOption = _options.multiple ?? true;
-	const resolvedOpenStrategy = openStrategy ?? resolveOpenStrategy(openMode);
 	const group = createGroup(options);
 	const logger = useLogger();
 	const children = shallowReactive(/* @__PURE__ */ new Map());
@@ -1407,7 +1448,9 @@ function createNested(_options = {}) {
 			const item = group.get(id);
 			if (!item || toValue(item.disabled)) continue;
 			openedIds.add(id);
-			resolvedOpenStrategy.onOpen?.(id, context);
+			if (openMode === "single") {
+				for (const openedId of openedIds) if (openedId !== id) openedIds.delete(openedId);
+			}
 			if (revealOnOpen) {
 				let parentId = parents.get(id);
 				while (!/* @__PURE__ */ isUndefined(parentId)) {
@@ -1424,7 +1467,6 @@ function createNested(_options = {}) {
 			const item = group.get(id);
 			if (!item || toValue(item.disabled)) continue;
 			openedIds.delete(id);
-			resolvedOpenStrategy.onClose?.(id, context);
 		}
 	}
 	function flip(ids) {
@@ -1508,7 +1550,13 @@ function createNested(_options = {}) {
 	function getPath(id) {
 		const path = [];
 		let currentId = id;
+		const visited = /* @__PURE__ */ new Set();
 		while (!/* @__PURE__ */ isUndefined(currentId)) {
+			if (visited.has(currentId)) {
+				logger.warn(`Circular parent reference detected at "${currentId}".`);
+				break;
+			}
+			visited.add(currentId);
 			path.unshift(currentId);
 			currentId = parents.get(currentId);
 		}
@@ -1867,7 +1915,7 @@ function createNested(_options = {}) {
 		rootIds.clear();
 		group.reset();
 	}
-	const context = {
+	return {
 		...group,
 		children,
 		parents,
@@ -1903,7 +1951,6 @@ function createNested(_options = {}) {
 		deactivateAll,
 		toFlat,
 		multiple: toValue(multipleOption),
-		openStrategy: resolvedOpenStrategy,
 		select,
 		unselect,
 		toggle,
@@ -1920,7 +1967,6 @@ function createNested(_options = {}) {
 			return group.size;
 		}
 	};
-	return context;
 }
 /**
 * Creates a new nested context with provide/inject pattern.
@@ -1942,12 +1988,7 @@ function createNested(_options = {}) {
 */
 function createNestedContext(_options = {}) {
 	const { namespace = "v0:nested", ...options } = _options;
-	const [useNestedContext, _provideNestedContext] = createContext(namespace);
-	const context = createNested(options);
-	function provideNestedContext(_context = context, app) {
-		return _provideNestedContext(_context, app);
-	}
-	return createTrinity(useNestedContext, provideNestedContext, context);
+	return createTrinity(namespace, createNested(options));
 }
 /**
 * Returns the current nested instance from context.
@@ -1973,6 +2014,15 @@ function useNested(namespace = "v0:nested") {
 *
 * Used by createSlider, createNumberField, and other numeric composables.
 * Handles floating-point precision correction internally.
+*
+* @example
+* ```ts
+* import { createNumeric } from '@vuetify/v0'
+*
+* const numeric = createNumeric({ min: 0, max: 10, step: 1 })
+* console.log(numeric.snap(3.7)) // 4
+* console.log(numeric.toPercent(5)) // 0.5
+* ```
 */
 function decimalPlaces(n) {
 	const s = String(n);
@@ -1984,6 +2034,7 @@ function createNumeric(options = {}) {
 	const extent = max - min;
 	const decimals = Math.max(decimalPlaces(step), Number.isFinite(min) ? decimalPlaces(min) : 0);
 	function snap(value) {
+		if (!Number.isFinite(value)) return min;
 		if (step <= 0 || !Number.isFinite(min)) return /* @__PURE__ */ clamp(value, min, max);
 		const result = min + Math.round((/* @__PURE__ */ clamp(value, min, max) - min) / step) * step;
 		return /* @__PURE__ */ clamp(decimals > 0 ? +result.toFixed(decimals) : result, min, max);
@@ -2046,6 +2097,15 @@ function createNumeric(options = {}) {
 * @remarks
 * Orchestrator composable that composes createInput + createNumeric + Intl.NumberFormat.
 * Manages a numeric value with formatting, parsing, stepping, and field state.
+*
+* @example
+* ```ts
+* import { createNumberField } from '@vuetify/v0'
+*
+* const field = createNumberField({ min: 0, max: 100, step: 5 })
+* field.increment()
+* console.log(field.value.value) // 5
+* ```
 */
 function createNumberField(options = {}) {
 	const { value = ref(null), locale = "en-US", format: formatOptions, clamp: shouldClamp = true, disabled = false, readonly: _readonly = false, min, max, step, leap, wrap, id, label, name, rules, error, errorMessages } = options;
@@ -2170,6 +2230,16 @@ function createNumberField(options = {}) {
 * - Perfect for hydration-safe rendering
 *
 * Essential for composables that need to behave differently during SSR vs client-side.
+*
+* @example
+* ```ts
+* import { useHydration } from '@vuetify/v0'
+*
+* const { isHydrated } = useHydration()
+* if (isHydrated.value) {
+*   // safe for client-only logic
+* }
+* ```
 */
 /**
 * Creates a new hydration instance.
@@ -2258,6 +2328,15 @@ const [createHydrationContext, createHydrationPlugin, useHydration] = createPlug
 * Accepts refs, getters, raw DOM elements, or Vue component instances
 * and normalizes them to a plain Element. Uses structural typing to
 * avoid cross-version Vue Ref incompatibilities.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { toElement } from '@vuetify/v0'
+*
+* const el = shallowRef<HTMLElement | null>(null)
+* const resolved = toElement(el) // HTMLElement | undefined
+* ```
 */
 /**
 * Resolves a {@link MaybeElementRef} to a DOM Element or undefined.
@@ -2305,6 +2384,19 @@ function toElement(target) {
 * - `undefined` — not yet created
 * - `null` — permanently stopped (`stop()` was called; `setup()` is a no-op)
 * - instance — active observer
+*
+* @example
+* ```ts
+* import { createObserver } from '#v0/composables/createObserver'
+*
+* const observer = createObserver(target, entries => {
+*   console.log(entries)
+* }, {
+*   supports: true,
+*   create: cb => new ResizeObserver(cb),
+*   observe: (o, el) => o.observe(el),
+* })
+* ```
 */
 function createObserver(target, userCallback, config) {
 	const { isHydrated } = useHydration();
@@ -2397,6 +2489,17 @@ function createObserver(target, userCallback, config) {
 * - Box model options (content-box/border-box)
 *
 * Perfect for responsive components and size-based rendering.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { useResizeObserver } from '@vuetify/v0'
+*
+* const target = useTemplateRef('target')
+* useResizeObserver(target, entries => {
+*   console.log(entries[0].contentRect.width)
+* })
+* ```
 */
 /**
 * A composable that uses the Resize Observer API to detect when an element's
@@ -2508,8 +2611,8 @@ function useElementSize(target) {
 		_pause();
 	}
 	return {
-		width,
-		height,
+		width: shallowReadonly(width),
+		height: shallowReadonly(height),
 		isActive,
 		isPaused: shallowReadonly(isPaused),
 		pause,
@@ -2537,6 +2640,16 @@ function useElementSize(target) {
 *
 * Use variable mode (default) for items with different widths like Breadcrumbs.
 * Use uniform mode (itemWidth option) for same-width items like Pagination buttons.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { createOverflow } from '@vuetify/v0'
+*
+* const el = useTemplateRef('container')
+* const overflow = createOverflow({ container: el })
+* console.log(overflow.capacity.value) // number of items that fit
+* ```
 */
 /**
 * Creates a new overflow context for computing how many items fit in a container.
@@ -2625,7 +2738,7 @@ function createOverflow(options = {}) {
 			if (available <= 0) return 0;
 			const g = toValue(gap);
 			const uniformWidth = toValue(itemWidth) ?? 0;
-			if (itemWidth !== void 0 && uniformWidth <= 0) return Infinity;
+			if (!/* @__PURE__ */ isUndefined(itemWidth) && uniformWidth <= 0) return Infinity;
 			if (uniformWidth > 0) {
 				const subsequent = uniformWidth + g;
 				if (available < uniformWidth) return 0;
@@ -2676,12 +2789,7 @@ function createOverflow(options = {}) {
 */
 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);
+	return createTrinity(namespace, createOverflow(options));
 }
 /**
 * Returns the current overflow context from dependency injection.
@@ -2725,6 +2833,15 @@ function useOverflow(namespace = "v0:overflow") {
 * All segments stay selected (multiple: true, enroll: true) so
 * selectedValues always reflects the full set of segment values.
 * Compatible with useProxyModel for v-model bridging.
+*
+* @example
+* ```ts
+* import { createProgress } from '@vuetify/v0'
+*
+* const progress = createProgress({ min: 0, max: 100, value: 25 })
+* progress.register({ value: 50 })
+* console.log(progress.percent.value)
+* ```
 */
 /**
 * Creates a progress instance with model-based segment tracking.
@@ -2818,12 +2935,7 @@ function createProgress(options = {}) {
 */
 function createProgressContext(_options = {}) {
 	const { namespace = "v0:progress", ...options } = _options;
-	const [use, _provide] = createContext(namespace);
-	const context = createProgress(options);
-	function provide(_context = context, app) {
-		return _provide(_context, app);
-	}
-	return createTrinity(use, provide, context);
+	return createTrinity(namespace, createProgress(options));
 }
 /**
 * Returns the current progress instance from context.
@@ -2852,6 +2964,15 @@ function useProgress(namespace = "v0:progress") {
 * Built on top of createRegistry, the queue automatically manages timeouts for tickets,
 * ensuring only the first ticket in the queue is active at any time. When a ticket
 * expires or is removed, the next ticket in the queue automatically becomes active.
+*
+* @example
+* ```ts
+* import { createQueue } from '@vuetify/v0'
+*
+* const queue = createQueue()
+* queue.register({ value: 'Notification 1', timeout: 3000 })
+* queue.register({ value: 'Notification 2', timeout: 3000 })
+* ```
 */
 /**
 * Creates a new queue instance
@@ -3002,12 +3123,7 @@ function createQueue(_options = {}) {
 */
 function createQueueContext(_options = {}) {
 	const { namespace = "v0:queue", ...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);
+	return createTrinity(namespace, createQueue(options));
 }
 /**
 * Returns the current queue instance.
@@ -3050,6 +3166,15 @@ function useQueue(namespace = "v0:queue") {
 * Unlike registry-based composables, rating tracks a single number
 * within a range with computed item states, making it efficient
 * for any star/icon rating use case.
+*
+* @example
+* ```ts
+* import { createRating } from '@vuetify/v0'
+*
+* const rating = createRating({ size: 5, value: 3 })
+* rating.select(4)
+* console.log(rating.value.value) // 4
+* ```
 */
 /**
 * Creates a rating instance.
@@ -3147,12 +3272,7 @@ function createRating(_options = {}) {
 */
 function createRatingContext(_options = {}) {
 	const { namespace = "v0:rating", ...options } = _options;
-	const [useRatingContext, _provideRatingContext] = createContext(namespace);
-	const context = createRating(options);
-	function provideRatingContext(_context = context, app) {
-		return _provideRatingContext(_context, app);
-	}
-	return createTrinity(useRatingContext, provideRatingContext, context);
+	return createTrinity(namespace, createRating(options));
 }
 /**
 * Returns the current rating instance from context.
@@ -3198,6 +3318,16 @@ function useRating(namespace = "v0:rating") {
 * Designed for single-thumb, range, and multi-thumb sliders.
 * Also reusable for color picker tracks, media scrubbers,
 * gradient editors, and other 1D value-on-track controls.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { createSlider } from '@vuetify/v0'
+*
+* const slider = createSlider({ min: 0, max: 100, step: 5 })
+* slider.register({ value: shallowRef(25) })
+* slider.set(0, 60)
+* ```
 */
 /**
 * Creates slider state with value math, step snapping, and multi-thumb support.
@@ -3385,6 +3515,16 @@ function createSlider(options = {}) {
 * - Perfect for wizards, carousels, pagination, onboarding flows
 *
 * Inheritance chain: createRegistry → createSelection → createSingle → createStep
+*
+* @example
+* ```ts
+* import { createStep } from '@vuetify/v0'
+*
+* const wizard = createStep({ circular: false })
+* wizard.register({ value: 'step-1' })
+* wizard.register({ value: 'step-2' })
+* wizard.next()
+* ```
 */
 /**
 * Creates a new step instance with navigation through items.
@@ -3533,12 +3673,7 @@ function createStep(_options = {}) {
 */
 function createStepContext(_options = {}) {
 	const { namespace = "v0:step", ...options } = _options;
-	const [useStepContext, _provideStepContext] = createContext(namespace);
-	const context = createStep(options);
-	function provideStepContext(_context = context, app) {
-		return _provideStepContext(_context, app);
-	}
-	return createTrinity(useStepContext, provideStepContext, context);
+	return createTrinity(namespace, createStep(options));
 }
 /**
 * Returns the current step instance.
@@ -3588,6 +3723,16 @@ function useStep(namespace = "v0:step") {
 * - Perfect for command pattern, history tracking
 *
 * Extends createRegistry with temporal navigation capabilities.
+*
+* @example
+* ```ts
+* import { createTimeline } from '@vuetify/v0'
+*
+* const timeline = createTimeline({ size: 5 })
+* timeline.register({ value: 'action-1' })
+* timeline.register({ value: 'action-2' })
+* timeline.undo()
+* ```
 */
 /**
 * Creates a new timeline instance.
@@ -3699,12 +3844,7 @@ function createTimeline(_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);
+	return createTrinity(namespace, createTimeline(options));
 }
 /**
 * Returns the current timeline instance.
@@ -3748,6 +3888,16 @@ function useTimeline(namespace = "v0:timeline") {
 * - Configurable overscan (extra items rendered for smooth scrolling)
 *
 * Perfect for large data sets, chat apps, and infinite scroll implementations.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { createVirtual } from '@vuetify/v0'
+*
+* const items = shallowRef(Array.from({ length: 10000 }, (_, i) => ({ id: i })))
+* const virtual = createVirtual(items, { itemHeight: 40 })
+* console.log(virtual.items.value)
+* ```
 */
 /**
 * Virtual scrolling composable for efficiently rendering large lists
@@ -4040,12 +4190,7 @@ function createVirtual(items, _options = {}) {
 */
 function createVirtualContext(items, _options = {}) {
 	const { namespace = "v0:virtual", ...options } = _options;
-	const [useVirtualContext, _provideVirtualContext] = createContext(namespace);
-	const context = createVirtual(items, options);
-	function provideVirtualContext(_context = context, app) {
-		return _provideVirtualContext(_context, app);
-	}
-	return createTrinity(useVirtualContext, provideVirtualContext, context);
+	return createTrinity(namespace, createVirtual(items, options));
 }
 /**
 * Returns the current virtual context from dependency injection.
@@ -4095,6 +4240,16 @@ function useVirtual(namespace = "v0:virtual") {
 * - Type preservation
 *
 * Perfect for creating reactive versions of plain objects while automatically unwrapping refs.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { toReactive } from '@vuetify/v0'
+*
+* const source = { name: shallowRef('Alice'), age: 30 }
+* const reactive = toReactive(source)
+* console.log(reactive.name) // 'Alice' (auto-unwrapped)
+* ```
 */
 function createMapProxy(refObject) {
 	let mapProxy;
@@ -4252,6 +4407,14 @@ function toReactive(objectRef) {
 * - Custom breakpoint configuration
 *
 * Perfect for responsive layouts and conditional rendering based on screen size.
+*
+* @example
+* ```ts
+* import { useBreakpoints } from '@vuetify/v0'
+*
+* const { current, isMobile, smAndUp } = useBreakpoints()
+* console.log(current.value) // 'md'
+* ```
 */
 /**
 * Creates default breakpoint configuration.
@@ -4590,12 +4753,7 @@ function createDate(options) {
 */
 function createDateContext(options) {
 	const { namespace = "v0:date", ...dateOptions } = options;
-	const [useDateContext, _provideDateContext] = createContext(namespace);
-	const context = createDate(dateOptions);
-	function provideDateContext(_context = context, app) {
-		return _provideDateContext(_context, app);
-	}
-	return createTrinity(useDateContext, provideDateContext, context);
+	return createTrinity(namespace, createDate(dateOptions));
 }
 /**
 * Creates a new date plugin.
@@ -4703,7 +4861,7 @@ function normalizeKey(key) {
 }
 //#endregion
 //#region src/composables/useHotkey/parsing.ts
-const logger = useLogger();
+const logger = /* @__PURE__ */ useLogger();
 const MODIFIERS = [
 	"ctrl",
 	"shift",
@@ -4879,6 +5037,14 @@ function splitKeySequence(str) {
 * - SSR-safe (no-op when not in browser)
 *
 * Builds on useEventListener for lifecycle-managed keyboard events.
+*
+* @example
+* ```ts
+* import { useHotkey } from '@vuetify/v0'
+*
+* useHotkey('ctrl+k', () => console.log('opened palette'))
+* useHotkey('g-h', () => console.log('go home'))
+* ```
 */
 const isMac = IN_BROWSER && /mac|iphone|ipad|ipod/i.test(navigator?.userAgent ?? "");
 /**
@@ -4922,6 +5088,7 @@ function useHotkey(keys, callback, options = {}, _platform) {
 	let isSequence = false;
 	let groupIndex = 0;
 	function isInputFocused() {
+		if (!IN_BROWSER) return false;
 		if (toValue(inputs)) return false;
 		const activeElement = document.activeElement;
 		if (!activeElement) return false;
@@ -5050,6 +5217,115 @@ function matchesKeyGroup(e, group, platformIsMac) {
 	return modifiersMatch && e.key.toLowerCase() === actualKey.toLowerCase();
 }
 //#endregion
+//#region src/composables/useImage/index.ts
+/**
+* @module useImage
+*
+* @see https://0.vuetifyjs.com/composables/system/use-image
+*
+* @remarks
+* Image loading state machine with deferred loading support.
+*
+* Key features:
+* - State machine: idle → loading → loaded | error
+* - Reactive `eager` gate withholds the source until ready
+* - Automatic reset when `src` changes
+* - Manual `retry()` to re-attempt after error
+* - Bind-ready handlers and gated source
+* - SSR-safe
+*
+* Perfect for image components, lightboxes, lazy-loaded galleries,
+* and any UI that needs to react to image load state.
+*
+* @example
+* ```ts
+* import { useImage } from '@vuetify/v0'
+*
+* const { status, source, onLoad, onError } = useImage({
+*   src: 'https://example.com/img.png',
+* })
+* ```
+*/
+/**
+* Tracks image loading state as a reactive state machine.
+*
+* @param options Configuration options
+* @returns Image context with state refs and event handlers
+*
+* @see https://0.vuetifyjs.com/composables/system/use-image
+*
+* @example
+* ```ts
+* import { toRef } from 'vue'
+* import { useImage } from '@vuetify/v0'
+*
+* const props = defineProps<{ src: string }>()
+*
+* const { source, isLoaded, onLoad, onError, retry } = useImage({
+*   src: toRef(() => props.src),
+* })
+* ```
+*
+* @example
+* Composed with `useIntersectionObserver` for lazy loading:
+* ```ts
+* const target = shallowRef<HTMLElement>()
+* const { isIntersecting } = useIntersectionObserver(target, () => {}, {
+*   once: true,
+*   rootMargin: '200px',
+* })
+*
+* const { source, onLoad, onError } = useImage({
+*   src: toRef(() => props.src),
+*   eager: isIntersecting,
+* })
+* ```
+*/
+function useImage(options) {
+	const { src, eager = true } = options;
+	const status = shallowRef(toValue(eager) ? "loading" : "idle");
+	const isIdle = toRef(() => status.value === "idle");
+	const isLoading = toRef(() => status.value === "loading");
+	const isLoaded = toRef(() => status.value === "loaded");
+	const isError = toRef(() => status.value === "error");
+	const source = toRef(() => status.value === "idle" ? void 0 : toValue(src));
+	function onLoad() {
+		status.value = "loaded";
+	}
+	function onError() {
+		status.value = "error";
+	}
+	function retry() {
+		const resumeAs = toValue(eager) ? "loading" : "idle";
+		status.value = "idle";
+		nextTick(() => {
+			status.value = resumeAs;
+		});
+	}
+	const stopEager = watch(() => toValue(eager), (value) => {
+		if (value && status.value === "idle") status.value = "loading";
+		else if (!value && status.value !== "loaded" && status.value !== "error") status.value = "idle";
+	});
+	const stopSrc = watch(() => toValue(src), () => {
+		status.value = toValue(eager) ? "loading" : "idle";
+	});
+	onScopeDispose(() => {
+		stopEager();
+		stopSrc();
+	}, true);
+	return {
+		status: shallowReadonly(status),
+		isIdle,
+		isLoading,
+		isLoaded,
+		isError,
+		source,
+		onLoad,
+		onError,
+		retry
+	};
+}
+//#endregion
 //#region src/composables/useIntersectionObserver/index.ts
 /**
 * @module useIntersectionObserver
@@ -5070,6 +5346,17 @@ function matchesKeyGroup(e, group, platformIsMac) {
 * - Immediate callback option
 *
 * Perfect for lazy loading, infinite scroll, and visibility detection.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { useIntersectionObserver } from '@vuetify/v0'
+*
+* const target = useTemplateRef('target')
+* useIntersectionObserver(target, entries => {
+*   console.log(entries[0].isIntersecting)
+* })
+* ```
 */
 /**
 * A composable that uses the Intersection Observer API to detect when an element
@@ -5230,6 +5517,15 @@ function useElementIntersection(target, options = {}) {
 *
 * Perfect for dialogs, menus, tooltips, and any component with
 * conditionally rendered content.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { useLazy } from '@vuetify/v0'
+*
+* const isOpen = shallowRef(false)
+* const { hasContent, onAfterLeave } = useLazy(isOpen)
+* ```
 */
 /**
 * Deferred content rendering for performance optimization.
@@ -5320,6 +5616,14 @@ function useLazy(active, options = {}) {
 * - Supports both static and dynamic queries
 *
 * Perfect for responsive conditionals beyond breakpoint detection.
+*
+* @example
+* ```ts
+* import { useMediaQuery } from '@vuetify/v0'
+*
+* const { matches } = useMediaQuery('(prefers-color-scheme: dark)')
+* console.log(matches.value) // true/false
+* ```
 */
 /**
 * Reactive media query matching.
@@ -5440,6 +5744,17 @@ function usePrefersContrast() {
 * - Configurable observation options (childList, attributes, characterData, etc.)
 *
 * Perfect for detecting DOM changes and responding to mutations.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { useMutationObserver } from '@vuetify/v0'
+*
+* const target = useTemplateRef('target')
+* useMutationObserver(target, records => {
+*   console.log(records)
+* }, { childList: true })
+* ```
 */
 /**
 * A composable that uses the Mutation Observer API to detect changes in the DOM.
@@ -5551,6 +5866,14 @@ function useMutationObserver(target, callback, options = {}) {
 * - Toast queue with pause/resume and auto-dismiss
 * - Adapter integration via event system
 * - Plugin installation via createNotificationsPlugin
+*
+* @example
+* ```ts
+* import { useNotifications } from '@vuetify/v0'
+*
+* const notifications = useNotifications()
+* notifications.send({ subject: 'Saved', severity: 'success' })
+* ```
 */
 function createNotifications(options = {}) {
 	const { timeout = 3e3, ...registryOptions } = options;
@@ -6072,6 +6395,15 @@ const [createNotificationsContext, createNotificationsPlugin, useNotifications]
 * - Re-entry during leave: cancels exit, stays mounted
 * - Immediate mode: auto-unmounts if done() not called (fast path)
 * - SSR-safe: starts unmounted
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { usePresence } from '@vuetify/v0'
+*
+* const isOpen = shallowRef(false)
+* const { isMounted, state, done } = usePresence({ present: isOpen })
+* ```
 */
 /**
 * Animation-agnostic mount lifecycle management.
@@ -6183,6 +6515,16 @@ function usePresence(options) {
 * - Works with any ModelContext (Selection, Slider, etc.)
 *
 * Bridges the gap between model composables and Vue's v-model.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { createSelection, useProxyModel } from '@vuetify/v0'
+*
+* const selection = createSelection({ events: true })
+* const model = shallowRef<string[]>([])
+* useProxyModel(selection, model, { multiple: true })
+* ```
 */
 /**
 * Syncs a ref with a model context bidirectionally.
@@ -6287,6 +6629,16 @@ function useProxyModel(context, model, options) {
 * - Callable function with cancel method
 *
 * Perfect for throttling updates to the next animation frame.
+*
+* @example
+* ```ts
+* import { useRaf } from '@vuetify/v0'
+*
+* const update = useRaf(timestamp => {
+*   // runs on next animation frame
+* })
+* update()
+* ```
 */
 /**
 * Scope-disposed safe requestAnimationFrame.
@@ -6355,6 +6707,15 @@ function useRaf(callback) {
 * - Auto-attaches keydown listener when target is provided
 *
 * Perfect for toolbars, menus, tree items, grids, and other composite widgets.
+*
+* @example
+* ```ts
+* import { useRovingFocus } from '@vuetify/v0'
+*
+* const items = () => [{ id: 'a' }, { id: 'b' }, { id: 'c' }]
+* const focus = useRovingFocus(items, { orientation: 'horizontal' })
+* focus.next()
+* ```
 */
 function useRovingFocus(items, options = {}) {
 	const { orientation, circular, columns, onFocus, target } = options;
@@ -6432,6 +6793,14 @@ var Vuetify0RtlAdapter = class {
 * - Subtree overrides via context provision
 *
 * Independent from useLocale — Vuetify connects them via adapter.
+*
+* @example
+* ```ts
+* import { useRtl } from '@vuetify/v0'
+*
+* const { isRtl, toggle } = useRtl()
+* toggle() // flip direction
+* ```
 */
 /**
 * Creates a new RTL direction instance.
@@ -6483,6 +6852,15 @@ const [createRtlContext, createRtlPlugin, useRtl] = createPluginContext("v0:rtl"
 * - Auto-cleanup when registered within component setup
 *
 * Built on createSelection for consistent ticket-based management.
+*
+* @example
+* ```ts
+* import { useStack } from '@vuetify/v0'
+*
+* const stack = useStack()
+* const ticket = stack.register({ onDismiss: () => console.log('dismissed') })
+* ticket.select()
+* ```
 */
 /**
 * Creates a new stack instance for managing overlay z-indexes.
@@ -6600,12 +6978,7 @@ function createStack(_options = {}) {
 */
 function createStackContext(_options = {}) {
 	const { namespace = "v0:stack", ...options } = _options;
-	const [useStackContext, _provideStackContext] = createContext(namespace);
-	const context = createStack(options);
-	function provideStackContext(_context = context, app) {
-		return _provideStackContext(_context, app);
-	}
-	return createTrinity(useStackContext, provideStackContext, context);
+	return createTrinity(namespace, createStack(options));
 }
 /**
 * Creates a Vue plugin to provide stack context at app level.
@@ -6712,6 +7085,15 @@ function useStack(namespace = "v0:stack") {
 * - Automatic cleanup on remove/clear
 *
 * Uses adapter pattern to abstract storage implementation details.
+*
+* @example
+* ```ts
+* import { useStorage } from '@vuetify/v0'
+*
+* const storage = useStorage()
+* const theme = storage.get('theme', 'light')
+* theme.value = 'dark' // persists automatically
+* ```
 */
 /**
 * Creates a new storage instance.
@@ -6753,7 +7135,7 @@ function createStorage(options = {}) {
 		if (/* @__PURE__ */ isNullOrUndefined(raw)) return void 0;
 		try {
 			const parsed = serializer.read(raw);
-			if (ttl && /* @__PURE__ */ isObject(parsed) && "__ttl" in parsed && "__v" in parsed) {
+			if (ttl && /* @__PURE__ */ isObject(parsed) && "__v0" in parsed && "__v" in parsed) {
 				const envelope = parsed;
 				if (Date.now() - envelope.__t > ttl) {
 					adapter?.removeItem(prefixedKey);
@@ -6769,7 +7151,7 @@ function createStorage(options = {}) {
 	}
 	function writeStored(prefixedKey, value) {
 		const wrapped = ttl ? {
-			__ttl: 1,
+			__v0: 1,
 			__v: value,
 			__t: Date.now()
 		} : value;
@@ -6859,6 +7241,17 @@ const [createStorageContext, createStoragePlugin, useStorage] = createPluginCont
 *
 * Perfect for conditional side effects, feature flags, and performance optimization
 * by only running reactive effects when needed.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { useToggleScope } from '@vuetify/v0'
+*
+* const isEnabled = shallowRef(false)
+* const { isActive } = useToggleScope(isEnabled, () => {
+*   // effects run while isEnabled is true
+* })
+* ```
 */
 /**
 * Conditionally manages an effect scope based on a reactive boolean source.
@@ -6954,6 +7347,15 @@ function useToggleScope(source, fn) {
 * - Multiple overloads for type safety
 *
 * Perfect for safely managing event listeners in Vue components.
+*
+* @example
+* ```ts
+* import { useEventListener } from '@vuetify/v0'
+*
+* useEventListener(window, 'resize', () => {
+*   console.log('window resized')
+* })
+* ```
 */
 /**
 * Attaches an event listener to a target.
@@ -7050,6 +7452,15 @@ function useDocumentEventListener(event, listener, options) {
 * Accessibility: This composable handles pointer interactions only. For accessible
 * components (dialogs, popovers, menus), pair with `useHotkey` for Escape key
 * dismissal per WCAG/APG requirements.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { useClickOutside } from '@vuetify/v0'
+*
+* const target = useTemplateRef('popover')
+* useClickOutside(target, () => console.log('clicked outside'))
+* ```
 */
 /**
 * Detects clicks outside of the specified element(s).
@@ -7237,6 +7648,7 @@ function useClickOutside(target, handler, options = {}) {
 	* Handle window blur - detect focus moving to iframe.
 	*/
 	function onBlur(event) {
+		if (!IN_BROWSER) return;
 		if (isPaused.value) return;
 		if (event.defaultPrevented) return;
 		if (document.activeElement instanceof HTMLIFrameElement) {
@@ -7287,4 +7699,4 @@ function useClickOutside(target, handler, options = {}) {
 	};
 }
 //#endregion
-export { createStepContext as $, usePrefersContrast as A, createValidation as At, useDate as B, usePopover as Bt, usePresence as C, createNumeric as Ct, useNotifications as D, multipleOpenStrategy as Dt, createNotificationsPlugin as E, useNested as Et, useIntersectionObserver as F, createComboboxContext as Ft, toReactive as G, createBreakpointsContext as H, createBreadcrumbs as Ht, useHotkey as I, useCombobox as It, useVirtual as J, createVirtual as K, createDate as L, ServerAdapter as Lt, usePrefersReducedMotion as M, createFormContext as Mt, useLazy as N, useForm as Nt, useMutationObserver as O, singleOpenStrategy as Ot, useElementIntersection as P, createCombobox as Pt, createStep as Q, createDateContext as R, ClientAdapter as Rt, useProxyModel as S, createNumberField as St, createNotificationsContext as T, createNestedContext as Tt, createBreakpointsPlugin as U, createBreadcrumbsContext as Ut, createBreakpoints as V, useTimer as Vt, useBreakpoints as W, useBreadcrumbs as Wt, createTimelineContext as X, createTimeline as Y, useTimeline as Z, createRtlPlugin as _, createFallbackHydration as _t, useToggleScope as a, createQueue as at, useRovingFocus as b, createHydrationPlugin as bt, createStoragePlugin as c, createProgress as ct, createStackContext as d, createOverflow as dt, useStep as et, createStackPlugin as f, createOverflowContext as ft, createRtlFallback as g, toElement as gt, createRtlContext as h, useResizeObserver as ht, useWindowEventListener as i, useRating as it, usePrefersDark as j, createForm as jt, useMediaQuery as k, createInput as kt, useStorage as l, createProgressContext as lt, createRtl as m, useElementSize as mt, useDocumentEventListener as n, createRating as nt, createStorage as o, createQueueContext as ot, useStack as p, useOverflow as pt, createVirtualContext as q, useEventListener as r, createRatingContext as rt, createStorageContext as s, useQueue as st, useClickOutside as t, createSlider as tt, createStack as u, useProgress as ut, useRtl as v, createHydration as vt, createNotifications as w, createNested as wt, useRaf as x, useHydration as xt, Vuetify0RtlAdapter as y, createHydrationContext as yt, createDatePlugin as z, useVirtualFocus as zt };
+export { createStep as $, usePrefersContrast as A, createForm as At, createDatePlugin as B, useTimer as Bt, usePresence as C, createNumberField as Ct, useNotifications as D, useNested as Dt, createNotificationsPlugin as E, createNestedContext as Et, useIntersectionObserver as F, useCombobox as Ft, useBreakpoints as G, createBreakpoints as H, createBreadcrumbsContext as Ht, useImage as I, ServerAdapter as It, createVirtualContext as J, toReactive as K, useHotkey as L, ClientAdapter as Lt, usePrefersReducedMotion as M, useForm as Mt, useLazy as N, createCombobox as Nt, useMutationObserver as O, createInput as Ot, useElementIntersection as P, createComboboxContext as Pt, useTimeline as Q, createDate as R, useVirtualFocus as Rt, useProxyModel as S, useHydration as St, createNotificationsContext as T, createNested as Tt, createBreakpointsContext as U, useBreadcrumbs as Ut, useDate as V, createBreadcrumbs as Vt, createBreakpointsPlugin as W, createTimeline as X, useVirtual as Y, createTimelineContext as Z, createRtlPlugin as _, toElement as _t, useToggleScope as a, useRating as at, useRovingFocus as b, createHydrationContext as bt, createStoragePlugin as c, useQueue as ct, createStackContext as d, useProgress as dt, createStepContext as et, createStackPlugin as f, createOverflow as ft, createRtlFallback as g, useResizeObserver as gt, createRtlContext as h, useElementSize as ht, useWindowEventListener as i, createRatingContext as it, usePrefersDark as j, createFormContext as jt, useMediaQuery as k, createValidation as kt, useStorage as l, createProgress as lt, createRtl as m, useOverflow as mt, useDocumentEventListener as n, createSlider as nt, createStorage as o, createQueue as ot, useStack as p, createOverflowContext as pt, createVirtual as q, useEventListener as r, createRating as rt, createStorageContext as s, createQueueContext as st, useClickOutside as t, useStep as tt, createStack as u, createProgressContext as ut, useRtl as v, createFallbackHydration as vt, createNotifications as w, createNumeric as wt, useRaf as x, createHydrationPlugin as xt, Vuetify0RtlAdapter as y, createHydration as yt, createDateContext as z, usePopover as zt };