@vuetify/v0 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/{useClickOutside-CY4U2J9W.mjs → useClickOutside-DbOLg1uw.mjs}

@@ -1,24 +1,23 @@
-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-zEjWBKCr.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 { 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-BRdxsC2M.mjs";
+import { clamp, instanceExists, isArray, isElement, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isString, isThenable, isUndefined, mergeDeep, range, resolveIds, resolveIndexes, useId as useId$1 } from "./utilities/index.mjs";
 import { i as useContext, t as createTrinity } from "./createTrinity-BTCs1pYx.mjs";
-import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-DvdRTrqC.mjs";
-import { t as createRegistry } from "./createRegistry-BXzdXAjq.mjs";
-import { i as createModel, t as createSelection } from "./createSelection-B3HJEPNg.mjs";
-import { t as createSingle } from "./createSingle-Dql8mRi-.mjs";
-import "./createTokens-DgFYsOrv.mjs";
-import { a as useLocale } from "./useLocale-BV8e3imF.mjs";
-import { c as useTimer } from "./useNotifications-vSJE6z6t.mjs";
-import { t as toArray } from "./toArray-as9BWxBK.mjs";
-import { n as createFilter } from "./adapter-gQ2SNKZq.mjs";
-import { t as createGroup } from "./createGroup-CGk6hY_Y.mjs";
-import "./createPagination-CHF7SmmK.mjs";
-import "./createDataTable-iODP6aKB.mjs";
-import { a as useRules, o as isStandardSchema } from "./useRules-BT6cgoTj.mjs";
-import "./useFeatures-BPOke6iP.mjs";
-import "./usePermissions-D3zPwKQc.mjs";
-import { t as MemoryAdapter } from "./memory-oYBvtkgx.mjs";
-import "./useTheme-cUZb2A9O.mjs";
-import { computed, effectScope, hasInjectionContext, isRef, nextTick, onMounted, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-1_ZeBY12.mjs";
+import { t as createRegistry } from "./createRegistry-CWpvSbCe.mjs";
+import { i as createModel, t as createSelection } from "./createSelection-MRyUZyW2.mjs";
+import { t as createSingle } from "./createSingle-BSciC9EJ.mjs";
+import "./createTokens-CQ9C7GTV.mjs";
+import { a as useLocale } from "./useLocale-Sh-2sNiG.mjs";
+import { c as useTimer } from "./useNotifications-CAVQ7hK6.mjs";
+import { t as toArray } from "./toArray-CD2-OxAz.mjs";
+import { a as createFilter } from "./adapter-BFSJsyv7.mjs";
+import { t as createGroup } from "./createGroup-aHt_kvtU.mjs";
+import "./createDataTable-H-PuVigU.mjs";
+import { a as useRules, o as isStandardSchema } from "./useRules-DK4AeNeC.mjs";
+import "./useFeatures-Dhnr-Lg2.mjs";
+import "./usePermissions-D9Oituwy.mjs";
+import { t as MemoryStorageAdapter } from "./memory-BMpJcQjQ.mjs";
+import "./useTheme-FMDQC81h.mjs";
+import { computed, effectScope, hasInjectionContext, isReadonly, isRef, nextTick, onMounted, onScopeDispose, onWatcherCleanup, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 //#region src/composables/createBreadcrumbs/index.ts
 /**
 * @module createBreadcrumbs
@@ -351,6 +350,7 @@ function createFocusTraversal(items, activate, options = {}) {
 	}
 	/** Focus first non-disabled item in the current row (grid mode) */
 	function rowFirst() {
+		/* v8 ignore next 2 -- defensive: rowFirst is only invoked in grid mode (cols > 0) */
 		const cols = toValue(_columns) ?? 0;
 		if (!cols) return first();
 		const all = items();
@@ -367,6 +367,7 @@ function createFocusTraversal(items, activate, options = {}) {
 	}
 	/** Focus last non-disabled item in the current row (grid mode) */
 	function rowLast() {
+		/* v8 ignore next 2 -- defensive: rowLast is only invoked in grid mode (cols > 0) */
 		const cols = toValue(_columns) ?? 0;
 		if (!cols) return last();
 		const all = items();
@@ -538,6 +539,9 @@ function useVirtualFocus(items, options) {
 	};
 }
 //#endregion
+//#region src/composables/createCombobox/adapters/adapter.ts
+var ComboboxAdapter = class {};
+//#endregion
 //#region src/composables/createCombobox/adapters/client.ts
 /**
 * @module createCombobox/adapters/client
@@ -546,9 +550,10 @@ function useVirtualFocus(items, options) {
 * Default combobox adapter. Filters items client-side using createFilter.
 * Synchronous, zero debounce — items update immediately as the user types.
 */
-var ClientAdapter = class {
+var ClientComboboxAdapter = class extends ComboboxAdapter {
 	options;
 	constructor(options = {}) {
+		super();
 		this.options = options;
 	}
 	setup(context) {
@@ -588,7 +593,7 @@ var ClientAdapter = class {
 * The consumer watches `query` via useComboboxContext() or slot props
 * and provides filtered items reactively.
 */
-var ServerAdapter = class {
+var ServerComboboxAdapter = class extends ComboboxAdapter {
 	setup(context) {
 		const isLoading = shallowRef(false);
 		return {
@@ -613,7 +618,7 @@ var ServerAdapter = class {
 * chain — it composes existing primitives instead.
 *
 * Key features:
-* - Adapter-based filtering (client-side or server-side via ClientAdapter/ServerAdapter)
+* - Adapter-based filtering (client-side or server-side via ClientComboboxAdapter/ServerComboboxAdapter)
 * - Single or multi-select mode
 * - Virtual focus keyboard navigation (aria-activedescendant pattern)
 * - Strict mode: reverts query to selected value on close if no match
@@ -690,7 +695,7 @@ function createCombobox(options = {}) {
 		version.value;
 		return [...selection.values()];
 	});
-	const { filtered, isLoading, isEmpty } = (adapter ?? new ClientAdapter()).setup({
+	const { filtered, isLoading, isEmpty } = (adapter ?? new ClientComboboxAdapter()).setup({
 		query,
 		items
 	});
@@ -1215,6 +1220,327 @@ function createInput(options) {
 	};
 }
 //#endregion
+//#region src/composables/createSortable/index.ts
+/**
+* @module createSortable
+*
+* @see https://0.vuetifyjs.com/composables/data/create-sortable
+*
+* @remarks
+* Headless ordered-list primitive. Extends `createModel` with mutation primitives
+* (`swap`, `reorder`) and an enriched `move:ticket` event on the registry event
+* bus. Honors `disabled` as a real mutation gate at both root and per-ticket scope.
+*
+* Pure logical composable — no DnD, no DOM, no keyboard. Drag-and-drop integration
+* composes with `useDragDrop`; keyboard reorder composes with `useVirtualFocus`.
+*
+* @example
+* ```ts
+* import { createSortable } from '@vuetify/v0'
+* import type { SortableTicketInput } from '@vuetify/v0'
+*
+* interface TaskTicket extends SortableTicketInput {
+*   value: { id: number; label: string }
+* }
+*
+* const sortable = createSortable<TaskTicket>()
+* const a = sortable.register({ value: { id: 1, label: 'A' } })
+* const b = sortable.register({ value: { id: 2, label: 'B' } })
+*
+* sortable.move(a.id, 1)
+* sortable.on('move:ticket', ({ ticket, from, to }) => {
+*   console.log(`${ticket.value.label} moved ${from} → ${to}`)
+* })
+* ```
+*/
+/**
+* Create an ordered-list state primitive.
+*
+* @param options Sortable options.
+* @returns A {@link SortableContext} that extends {@link ModelContext}.
+*
+* @example
+* ```ts
+* const sortable = createSortable<Todo>()
+* sortable.onboard(todos.value.map(value => ({ value })))
+* ```
+*/
+function createSortable(_options = {}) {
+	const { disabled, ...options } = _options;
+	const model = createModel({
+		...options,
+		events: true,
+		disabled
+	});
+	const logger = useLogger();
+	function move(id, toIndex) {
+		if (toValue(disabled)) return void 0;
+		const ticket = model.get(id);
+		if (!ticket) return void 0;
+		if (toValue(ticket.disabled)) return void 0;
+		const from = ticket.index;
+		const result = model.move(id, toIndex);
+		if (result && result.index !== from) model.emit("move:ticket", {
+			ticket: result,
+			from,
+			to: result.index
+		});
+		return result;
+	}
+	function swap(a, b) {
+		if (toValue(disabled)) return;
+		if (a === b) return;
+		const ta = model.get(a);
+		const tb = model.get(b);
+		if (!ta || !tb) return;
+		if (toValue(ta.disabled) || toValue(tb.disabled)) return;
+		const indexA = ta.index;
+		const indexB = tb.index;
+		model.batch(() => {
+			const ra = model.move(a, indexB);
+			if (ra && ra.index !== indexA) model.emit("move:ticket", {
+				ticket: ra,
+				from: indexA,
+				to: ra.index
+			});
+			const rb = model.move(b, indexA);
+			if (rb && rb.index !== indexB) model.emit("move:ticket", {
+				ticket: rb,
+				from: indexB,
+				to: rb.index
+			});
+		});
+	}
+	function reorder(ids) {
+		if (toValue(disabled)) return;
+		const currentSize = model.size;
+		if (ids.length !== currentSize) {
+			logger.warn(`Reorder expected ${currentSize} ids, got ${ids.length}.`);
+			return;
+		}
+		const known = new Set(model.keys());
+		const seen = /* @__PURE__ */ new Set();
+		for (const id of ids) {
+			if (!known.has(id)) {
+				logger.warn(`Reorder contains unknown id "${String(id)}".`);
+				return;
+			}
+			if (seen.has(id)) {
+				logger.warn(`Reorder contains duplicate id "${String(id)}".`);
+				return;
+			}
+			seen.add(id);
+		}
+		const froms = /* @__PURE__ */ new Map();
+		for (const id of ids) {
+			const ticket = model.get(id);
+			if (ticket) froms.set(id, ticket.index);
+		}
+		model.batch(() => {
+			model.reorder(ids);
+			for (const [index, id] of ids.entries()) {
+				const from = froms.get(id);
+				if (from === index) continue;
+				const ticket = model.get(id);
+				if (ticket) model.emit("move:ticket", {
+					ticket,
+					from,
+					to: index
+				});
+			}
+		});
+	}
+	return {
+		...model,
+		move,
+		swap,
+		reorder,
+		get size() {
+			return model.size;
+		}
+	};
+}
+//#endregion
+//#region src/composables/createKanban/index.ts
+/**
+* @module createKanban
+*
+* @see https://0.vuetifyjs.com/composables/data/create-kanban
+*
+* @remarks
+* Headless data-flow management for two-level sortable boards. Wraps a column
+* sortable; each column ticket carries its own inner sortable on `column.items`.
+* Adds a `transfer` primitive for cross-column moves with reused `disabled`
+* gating and a destination-side `accept` predicate. Pure logic — no DnD, no DOM.
+*
+* @example
+* ```ts
+* import { createKanban } from '@vuetify/v0'
+* import type { SortableTicketInput } from '@vuetify/v0'
+*
+* interface CardTicket extends SortableTicketInput {
+*   value: { title: string }
+* }
+*
+* const kanban = createKanban<CardTicket>()
+*
+* const todo = kanban.columns.register({ value: { title: 'Todo' } })
+* const done = kanban.columns.register({ value: { title: 'Done' } })
+*
+* const card = todo.items.register({ value: { title: 'Write spec' } })
+*
+* kanban.on('transfer:ticket', ({ ticket, from, to }) => {
+*   console.log(ticket.value.title, from, '→', to)
+* })
+*
+* kanban.transfer(card.id, done.id, 0)
+* ```
+*/
+/**
+* Create a headless two-level sortable orchestrator.
+*
+* @param options Kanban options (currently only `disabled`).
+* @returns A {@link KanbanContext}.
+*
+* @example
+* ```ts
+* import { createKanban } from '@vuetify/v0'
+* import type { KanbanColumnTicketInput, SortableTicketInput } from '@vuetify/v0'
+*
+* interface CardTicket extends SortableTicketInput {
+*   value: { title: string }
+* }
+*
+* interface BoardColumn extends KanbanColumnTicketInput<CardTicket> {
+*   value: { title: string }
+* }
+*
+* const kanban = createKanban<CardTicket, BoardColumn>()
+*
+* const todo = kanban.columns.register({ value: { title: 'Todo' } })
+* const review = kanban.columns.register({
+*   value: { title: 'Review' },
+*   accept: card => card.value.title.length > 0,
+* })
+*
+* const spec = todo.items.register({ value: { title: 'Write spec' } })
+* kanban.transfer(spec.id, review.id, 0)
+* ```
+*/
+function createKanban(_options = {}) {
+	const { disabled, ...options } = _options;
+	const logger = useLogger();
+	const _columns = createSortable({
+		...options,
+		disabled
+	});
+	const lookup = createRegistry({ events: true });
+	const bus = createRegistry({ events: true });
+	const on = bus.on;
+	const off = bus.off;
+	const columns = {
+		..._columns,
+		register(registration) {
+			let ticket;
+			const items = createSortable({ disabled: () => !!toValue(disabled) || !!toValue(ticket?.disabled) });
+			items.on("register:ticket", (t) => {
+				lookup.upsert(t.id, { value: ticket.id });
+			});
+			items.on("unregister:ticket", (t) => {
+				lookup.get(t.id)?.unregister();
+			});
+			ticket = _columns.register({
+				...registration,
+				items
+			});
+			return ticket;
+		},
+		onboard(registrations) {
+			return _columns.batch(() => registrations.map((reg) => columns.register(reg)));
+		},
+		upsert(id, patch = {}, event) {
+			return /* @__PURE__ */ isUndefined(_columns.get(id)) ? columns.register({
+				...patch,
+				id
+			}) : _columns.upsert(id, patch, event);
+		},
+		get size() {
+			return _columns.size;
+		}
+	};
+	function isAccepted(accept, ticket, from, toIndex) {
+		if (/* @__PURE__ */ isUndefined(accept)) return true;
+		try {
+			const result = accept(ticket, from, toIndex);
+			if (/* @__PURE__ */ isThenable(result)) {
+				logger.warn("accept predicate returned a thenable; async predicates are not supported — treating as reject");
+				return false;
+			}
+			return Boolean(result);
+		} catch (error) {
+			logger.error("accept predicate threw; treating as reject", error);
+			return false;
+		}
+	}
+	columns.on("unregister:ticket", (column) => {
+		column.items.dispose();
+		for (const t of lookup.values()) if (t.value === column.id) t.unregister();
+	});
+	function transfer(id, toColumnId, toIndex) {
+		const fromColumnId = lookup.get(id)?.value;
+		if (/* @__PURE__ */ isUndefined(fromColumnId)) {
+			logger.warn(`unknown ticket id "${String(id)}"`);
+			return;
+		}
+		const source = columns.get(fromColumnId);
+		if (!source) {
+			logger.warn(`unknown source column id "${String(fromColumnId)}"`);
+			return;
+		}
+		const destination = columns.get(toColumnId);
+		if (!destination) {
+			logger.warn(`unknown destination column id "${String(toColumnId)}"`);
+			return;
+		}
+		const ticket = source.items.get(id);
+		if (!ticket) {
+			logger.warn(`ticket "${String(id)}" missing from source column "${String(fromColumnId)}"`);
+			return;
+		}
+		const fromIndex = ticket.index;
+		if (toColumnId === fromColumnId) return source.items.move(id, toIndex);
+		if (toValue(disabled) || toValue(source.disabled) || toValue(destination.disabled) || toValue(ticket.disabled)) return;
+		if (!isAccepted(destination.accept, ticket, fromColumnId, toIndex)) return void 0;
+		if (!/* @__PURE__ */ isUndefined(destination.items.get(id))) {
+			logger.warn(`id "${String(id)}" already exists in destination column "${String(toColumnId)}"`);
+			return;
+		}
+		let registered;
+		let moved;
+		destination.items.batch(() => {
+			const [input] = source.items.offboard([id]);
+			if (/* @__PURE__ */ isUndefined(input)) return;
+			registered = destination.items.register(input);
+			moved = registered.index === toIndex ? registered : destination.items.move(registered.id, toIndex);
+		});
+		const final = moved ?? registered;
+		if (final) bus.emit("transfer:ticket", {
+			ticket: final,
+			from: fromColumnId,
+			to: toColumnId,
+			fromIndex,
+			toIndex: final.index
+		});
+		return final;
+	}
+	return {
+		columns,
+		transfer,
+		on,
+		off
+	};
+}
+//#endregion
 //#region src/composables/createNested/index.ts
 /**
 * @module createNested
@@ -2079,6 +2405,193 @@ function createNumberField(options = {}) {
 	};
 }
 //#endregion
+//#region src/composables/createOtp/index.ts
+/**
+* @module createOtp
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-otp
+*
+* @remarks
+* Headless state for a fixed-length one-time-password / verification-code value.
+* Owns the joined string, per-character pattern matching, length contract,
+* completion edge detection with a decisional async `onComplete` hook, and
+* validation through `createInput`. Rendering, focus, and per-element event
+* wiring are the consumer's responsibility.
+*
+* @example
+* ```ts
+* import { createOtp } from '@vuetify/v0'
+*
+* const otp = createOtp({
+*   length: 6,
+*   pattern: 'numeric',
+*   onComplete: async value => {
+*     const ok = await verify(value)
+*     return ok
+*   },
+* })
+*
+* otp.write(0, '4')
+* otp.distribute('12345', 1) // returns 5; value becomes '412345'
+* otp.isComplete.value  // true
+* ```
+*/
+const PRESETS = {
+	numeric: /^[0-9]$/,
+	alphanumeric: /^[a-zA-Z0-9]$/,
+	alphabetic: /^[a-zA-Z]$/
+};
+const WARNED_PATTERNS = /* @__PURE__ */ new WeakSet();
+function createOtp(options = {}) {
+	const { value = shallowRef(""), length = 6, pattern = "numeric", disabled = false, readonly: _readonly = false, onComplete, ...inputOptions } = options;
+	const logger = useLogger();
+	const errorRef = shallowRef(false);
+	const errorMessagesRef = shallowRef(void 0);
+	const input = createInput({
+		...inputOptions,
+		value,
+		disabled,
+		readonly: _readonly,
+		error: errorRef,
+		errorMessages: errorMessagesRef
+	});
+	const lengthRef = toRef(() => toValue(length));
+	let lastCompleted = "";
+	function compile(resolved) {
+		if (/* @__PURE__ */ isString(resolved)) return PRESETS[resolved];
+		if (process.env.NODE_ENV !== "production" && !WARNED_PATTERNS.has(resolved)) {
+			WARNED_PATTERNS.add(resolved);
+			if (resolved.test("aa") || resolved.test("00")) logger.warn("createOtp: pattern matches multi-character input; per-character matching may behave unexpectedly");
+		}
+		return resolved;
+	}
+	function accepts(char) {
+		if (char.length !== 1) return false;
+		return compile(toValue(pattern)).test(char);
+	}
+	function filterAccepted(text) {
+		let out = "";
+		for (const ch of text) if (accepts(ch)) out += ch;
+		return out;
+	}
+	const isPending = shallowRef(false);
+	function isLocked() {
+		return toValue(disabled) || toValue(_readonly) || isPending.value;
+	}
+	function clearRejection() {
+		if (errorRef.value || errorMessagesRef.value) {
+			errorRef.value = false;
+			errorMessagesRef.value = void 0;
+		}
+	}
+	function write(index, char) {
+		if (isLocked()) return;
+		const max = toValue(lengthRef);
+		if (index < 0 || index >= max) return;
+		if (char === "") {
+			clearRejection();
+			value.value = value.value.slice(0, index);
+			return;
+		}
+		const first = char[0];
+		if (!accepts(first)) return;
+		clearRejection();
+		const current = value.value;
+		const head = current.slice(0, index);
+		const tail = current.slice(index + 1);
+		value.value = (head + first + tail).slice(0, max);
+	}
+	function distribute(text, index = 0) {
+		if (isLocked()) return 0;
+		const max = toValue(lengthRef);
+		const start = /* @__PURE__ */ clamp(index, 0, max);
+		const filtered = filterAccepted(text);
+		if (filtered.length === 0) return 0;
+		clearRejection();
+		const head = value.value.slice(0, start);
+		const next = (head + filtered).slice(0, max);
+		value.value = next;
+		return next.length - head.length;
+	}
+	function clear() {
+		if (isLocked()) return;
+		clearRejection();
+		lastCompleted = "";
+		value.value = "";
+	}
+	function fill(text) {
+		if (isLocked()) return;
+		const max = toValue(lengthRef);
+		const filtered = filterAccepted(text).slice(0, max);
+		if (text.length === 0 || filtered.length > 0) clearRejection();
+		value.value = filtered;
+	}
+	function reject() {
+		errorRef.value = true;
+		errorMessagesRef.value = ["Invalid code"];
+		lastCompleted = "";
+		value.value = "";
+	}
+	const isComplete = toRef(() => {
+		const max = toValue(lengthRef);
+		const v = value.value;
+		if (v.length !== max) return false;
+		const re = compile(toValue(pattern));
+		for (const ch of v) if (!re.test(ch)) return false;
+		return true;
+	});
+	watch(value, (next) => {
+		if (!isComplete.value) {
+			lastCompleted = "";
+			return;
+		}
+		if (!onComplete) return;
+		if (isLocked()) return;
+		if (next === lastCompleted) return;
+		lastCompleted = next;
+		let result;
+		try {
+			result = onComplete(next);
+		} catch (error) {
+			logger.warn("createOtp: onComplete threw", error);
+			reject();
+			return;
+		}
+		if (/* @__PURE__ */ isThenable(result)) {
+			isPending.value = true;
+			result.then((ok) => {
+				isPending.value = false;
+				if (ok === false) reject();
+			}, (error) => {
+				isPending.value = false;
+				logger.warn("createOtp: onComplete rejected", error);
+				reject();
+			});
+			return;
+		}
+		if (result === false) reject();
+	});
+	return {
+		value,
+		length: lengthRef,
+		input: {
+			...input,
+			reset() {
+				clearRejection();
+				lastCompleted = "";
+				input.reset();
+			}
+		},
+		isComplete,
+		isValidating: isPending,
+		write,
+		distribute,
+		clear,
+		fill,
+		accepts
+	};
+}
+//#endregion
 //#region src/composables/useHydration/index.ts
 /**
 * @module useHydration
@@ -2468,6 +2981,7 @@ function useElementSize(target) {
 	const height = shallowRef(0);
 	const { pause: _pause, resume, stop, isActive, isPaused } = useResizeObserver(target, (entries) => {
 		const entry = entries[0];
+		/* v8 ignore next 4 -- defensive: ResizeObserver always passes an entry array with at least one entry */
 		if (entry) {
 			width.value = entry.contentRect.width;
 			height.value = entry.contentRect.height;
@@ -2481,7 +2995,7 @@ function useElementSize(target) {
 	return {
 		width: shallowReadonly(width),
 		height: shallowReadonly(height),
-		isActive,
+		isActive: shallowReadonly(isActive),
 		isPaused: shallowReadonly(isPaused),
 		pause,
 		resume,
@@ -2626,6 +3140,7 @@ function createOverflow(options = {}) {
 		}),
 		total,
 		isOverflowing: toRef(() => {
+			if (width.value === 0) return false;
 			return total.value > width.value - toValue(reserved);
 		}),
 		measure,
@@ -2778,7 +3293,7 @@ function createProgress(options = {}) {
 		}
 		for (const [index, element] of clamped.entries()) {
 			const ticket = segments.value[index];
-			if (!ticket || !isRef(ticket.value)) continue;
+			if (!ticket || !isRef(ticket.value) || isReadonly(ticket.value)) continue;
 			ticket.value.value = element;
 		}
 	}
@@ -3636,6 +4151,7 @@ function createVirtual(items, _options = {}) {
 		/* v8 ignore stop */
 	});
 	useResizeObserver(element, (entries) => {
+		/* v8 ignore next -- defensive: ResizeObserver always emits at least one entry */
 		if (!entries[0]) return;
 		viewportHeight.value = entries[0].contentRect.height;
 		update();
@@ -3648,6 +4164,7 @@ function createVirtual(items, _options = {}) {
 		rebuild();
 	}, { immediate: true });
 	watch(element, () => {
+		/* v8 ignore next -- defensive: watch fires only when element is present */
 		if (!element.value) return;
 		if (direction === "reverse" && items.value.length > 0) {
 			const lastIndex = items.value.length - 1;
@@ -3666,6 +4183,7 @@ function createVirtual(items, _options = {}) {
 			anchorOffset = 0;
 		} else if (/* @__PURE__ */ isFunction(anchor)) {
 			const result = anchor(items.value);
+			/* v8 ignore next 4 -- function-anchor: tested with valid number return; non-number rejection branch is implicit */
 			if (/* @__PURE__ */ isNumber(result)) {
 				anchorIndex = result;
 				anchorOffset = element.value.scrollTop - (offsets.value[result] || 0);
@@ -3749,8 +4267,10 @@ function createVirtual(items, _options = {}) {
 		/* v8 ignore stop */
 	}
 	function resize(index, height) {
+		/* v8 ignore next -- early bail when height is already correct */
 		if (heights.value[index] === height) return;
 		heights.value[index] = height;
+		/* v8 ignore next -- first-call only: itemHeight bootstrapped from initial measurement */
 		if (!itemHeight.value) itemHeight.value = height;
 		if (IN_BROWSER) {
 			cancelAnimationFrame(rebuildRaf);
@@ -3767,6 +4287,7 @@ function createVirtual(items, _options = {}) {
 		/* v8 ignore stop */
 	}
 	function scrollTo(index, scrollOptions) {
+		/* v8 ignore next -- defensive: scrollTo only invoked after element mounts */
 		if (!element.value) return;
 		const targetOffset = offsets.value[index] || 0;
 		const behavior = scrollOptions?.behavior ?? "auto";
@@ -3892,6 +4413,124 @@ function useVirtual(namespace = "v0:virtual") {
 	return useContext(namespace);
 }
 //#endregion
+//#region src/composables/toHighlight/index.ts
+/**
+* @module toHighlight
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-highlight
+*
+* @remarks
+* Pure transformer — no DOM, no state, no registry, no reactivity. Splits text
+* into matched and unmatched chunks given a query string, an array of query
+* strings, or pre-computed `[start, end]` match ranges (e.g., from createFilter).
+* Returns a plain array; wrap the call in `computed()` for reactive recomputation.
+*
+* @example
+* ```ts
+* import { toHighlight } from '@vuetify/v0'
+*
+* const chunks = toHighlight('Hello World', 'World')
+* // [{ text: 'Hello ', match: false }, { text: 'World', match: true }]
+* ```
+*/
+function merge(ranges) {
+	const sorted = ranges.filter((span) => span[0] < span[1]).toSorted((a, b) => a[0] - b[0]);
+	const merged = [];
+	for (const span of sorted) {
+		const last = merged.at(-1);
+		if (last && span[0] <= last[1]) last[1] = Math.max(last[1], span[1]);
+		else merged.push([span[0], span[1]]);
+	}
+	return merged;
+}
+function chunk(text, ranges) {
+	const chunks = [];
+	let cursor = 0;
+	for (const [start, end] of ranges) {
+		if (cursor < start) chunks.push({
+			text: text.slice(cursor, start),
+			match: false
+		});
+		chunks.push({
+			text: text.slice(start, end),
+			match: true
+		});
+		cursor = end;
+	}
+	if (cursor < text.length) chunks.push({
+		text: text.slice(cursor),
+		match: false
+	});
+	return chunks;
+}
+function find(text, query, matchAll, ignoreCase) {
+	const terms = (/* @__PURE__ */ toArray(query)).filter(Boolean);
+	const haystack = ignoreCase ? text.toLocaleLowerCase() : text;
+	const spans = [];
+	for (const term of terms) {
+		const needle = ignoreCase ? term.toLocaleLowerCase() : term;
+		let index = haystack.indexOf(needle);
+		if (index !== -1) {
+			spans.push([index, index + term.length]);
+			if (matchAll) {
+				index = haystack.indexOf(needle, index + term.length);
+				while (index !== -1) {
+					spans.push([index, index + term.length]);
+					index = haystack.indexOf(needle, index + term.length);
+				}
+			}
+		}
+	}
+	return merge(spans);
+}
+/**
+* Splits text into matched and unmatched chunks.
+*
+* Pure transformer — returns a plain array. Wrap the call in `computed()` for
+* reactive recomputation.
+*
+* Priority: `options.matches` (when non-empty) → `query` → no-match fallback.
+*
+* @param text The source string to split.
+* @param query One or more search terms. Empty strings are ignored. Case sensitivity controlled by `options.ignoreCase`.
+* @param options Optional `matches`, `matchAll`, `ignoreCase`.
+* @returns A `HighlightChunk[]` array.
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-highlight
+*
+* @example
+* ```ts
+* import { computed, shallowRef } from 'vue'
+* import { toHighlight } from '@vuetify/v0'
+*
+* const query = shallowRef('World')
+* const chunks = computed(() => toHighlight('Hello World', query))
+*
+* console.log(chunks.value)
+* // [{ text: 'Hello ', match: false }, { text: 'World', match: true }]
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function toHighlight(text, query, options = {}) {
+	const _text = toValue(text);
+	const _query = toValue(query);
+	const _matches = toValue(options.matches);
+	const matchAll = toValue(options.matchAll) ?? false;
+	const ignoreCase = toValue(options.ignoreCase) ?? false;
+	if (_matches?.length) return chunk(_text, merge(_matches));
+	if (_query) {
+		const ranges = find(_text, _query, matchAll, ignoreCase);
+		return ranges.length > 0 ? chunk(_text, ranges) : [{
+			text: _text,
+			match: false
+		}];
+	}
+	return [{
+		text: _text,
+		match: false
+	}];
+}
+//#endregion
 //#region src/composables/toReactive/index.ts
 /**
 * @module toReactive
@@ -4286,11 +4925,11 @@ const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = crea
 *
 * @example Using the built-in Temporal adapter
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 * import { createDatePlugin } from '@vuetify/v0'
 *
 * const app = createApp(App)
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
 *
 * // In a component:
 * const { adapter } = useDate()
@@ -4300,9 +4939,9 @@ const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = crea
 *
 * @example Custom adapter
 * ```ts
-* import type { DateAdapter } from '@vuetify/v0'
+* import { DateAdapter } from '@vuetify/v0'
 *
-* class DateFnsAdapter implements DateAdapter<Date> {
+* class DateFnsAdapter extends DateAdapter<Date> {
 *   // ... implementation
 * }
 *
@@ -4333,6 +4972,7 @@ const defaultLocales = {
 function deriveFirstDayOfWeek(locale) {
 	try {
 		const info = new Intl.Locale(locale).getWeekInfo?.();
+		/* v8 ignore next -- defensive: getWeekInfo always returns info in Node 22+ */
 		return info ? info.firstDay % 7 : 0;
 	} catch {
 		return 0;
@@ -4350,14 +4990,14 @@ function deriveFirstDayOfWeek(locale) {
 *
 * @example
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 *
-* const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
+* const { adapter } = createDate({ adapter: new V0DateAdapter() })
 * const today = adapter.date()
 *
 * // With locale options
 * const { adapter } = createDate({
-*   adapter: new Vuetify0DateAdapter(),
+*   adapter: new V0DateAdapter(),
 *   locale: 'de-DE',
 * })
 * ```
@@ -4412,10 +5052,10 @@ function createDate(options) {
 *
 * @example
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 *
 * const [useAppDate, provideAppDate] = createDateContext({
-*   adapter: new Vuetify0DateAdapter(),
+*   adapter: new V0DateAdapter(),
 *   namespace: 'app:date',
 * })
 * ```
@@ -4436,14 +5076,14 @@ function createDateContext(options) {
 *
 * @example
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 *
 * const app = createApp(App)
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
 *
 * // With locale options
 * app.use(createDatePlugin({
-*   adapter: new Vuetify0DateAdapter(),
+*   adapter: new V0DateAdapter(),
 *   locale: 'de-DE',
 * }))
 * ```
@@ -4477,10 +5117,10 @@ function createDatePlugin(options) {
 * @example
 * ```ts
 * // main.ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 * import { createDatePlugin } from '@vuetify/v0'
 *
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
 * ```
 *
 * @example
@@ -4494,7 +5134,7 @@ function createDatePlugin(options) {
 * ```
 */
 function useDate(namespace = "v0:date") {
-	if (!/* @__PURE__ */ instanceExists()) throw new Error("[v0] useDate() must be called inside a Vue component with createDatePlugin installed.\n\nExample:\n  import { Vuetify0DateAdapter } from '@vuetify/v0/date'\n  import { createDatePlugin } from '@vuetify/v0'\n\n  app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))");
+	if (!/* @__PURE__ */ instanceExists()) throw new Error("[v0] useDate() must be called inside a Vue component with createDatePlugin installed.\n\nExample:\n  import { V0DateAdapter } from '@vuetify/v0/date'\n  import { createDatePlugin } from '@vuetify/v0'\n\n  app.use(createDatePlugin({ adapter: new V0DateAdapter() }))");
 	return useContext(namespace);
 }
 //#endregion
@@ -4615,18 +5255,790 @@ function useDelay(callback, options = {}) {
 	};
 }
 //#endregion
-//#region src/composables/useHotkey/aliases.ts
+//#region src/composables/useMutationObserver/index.ts
 /**
-* Key alias mapping for consistent key normalization across the hotkey system.
+* @module useMutationObserver
 *
-* Maps user-friendly aliases to canonical key names that match
-* KeyboardEvent.key values (in lowercase) where possible.
+* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+*
+* @remarks
+* MutationObserver composable with lifecycle management.
+*
+* Key features:
+* - MutationObserver API wrapper
+* - `isActive` reactive flag
+* - `once` option for single-fire observation
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_MUTATION_OBSERVER)
+* - Hydration-aware
+* - Configurable observation options (childList, attributes, characterData, etc.)
+*
+* Perfect for detecting DOM changes and responding to mutations.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { useMutationObserver } from '@vuetify/v0'
+*
+* const target = useTemplateRef('target')
+* useMutationObserver(target, records => {
+*   console.log(records)
+* }, { childList: true })
+* ```
 */
-const keyAliasMap = {
-	control: "ctrl",
-	command: "cmd",
-	option: "alt",
-	up: "arrowup",
+/**
+* A composable that uses the Mutation Observer API to detect changes in the DOM.
+*
+* @param target The element to observe.
+* @param callback The callback to execute when a mutation is observed.
+* @param options The options for the Mutation Observer.
+* @returns An object with methods to control the observer.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useMutationObserver } from '@vuetify/v0'
+*
+* const container = ref<HTMLElement>()
+*
+* const { pause, resume, isPaused } = useMutationObserver(
+*   container,
+*   (mutations) => {
+*     mutations.forEach((mutation) => {
+*       if (mutation.type === 'childList') {
+*         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
+*       } else if (mutation.type === 'attributes') {
+*         console.log('Attribute changed:', mutation.attributeName)
+*       }
+*     })
+*   },
+*   {
+*     childList: true,
+*     attributes: true,
+*     subtree: true
+*   }
+* )
+*
+* // Pause observation
+* pause()
+*
+* // Resume observation
+* resume()
+* ```
+*/
+function useMutationObserver(target, callback, options = {}) {
+	const observerOptions = {
+		childList: options.childList ?? true,
+		attributes: options.attributes ?? false,
+		characterData: options.characterData ?? false,
+		subtree: options.subtree ?? false,
+		attributeOldValue: options.attributeOldValue ?? false,
+		characterDataOldValue: options.characterDataOldValue ?? false,
+		attributeFilter: options.attributeFilter
+	};
+	return createObserver(target, callback, {
+		supports: SUPPORTS_MUTATION_OBSERVER,
+		once: options.once,
+		create: (cb) => new MutationObserver((mutations) => {
+			cb(mutations.map((m) => ({
+				type: m.type,
+				target: m.target,
+				addedNodes: m.addedNodes,
+				removedNodes: m.removedNodes,
+				previousSibling: m.previousSibling,
+				nextSibling: m.nextSibling,
+				attributeName: m.attributeName,
+				attributeNamespace: m.attributeNamespace,
+				oldValue: m.oldValue
+			})));
+		}),
+		observe: (obs, el) => obs.observe(el, observerOptions),
+		immediate: options.immediate ? (el) => {
+			const emptyNodeList = {
+				length: 0,
+				item: () => null,
+				forEach: () => {},
+				*[Symbol.iterator]() {}
+			};
+			return [{
+				type: "childList",
+				target: el,
+				addedNodes: emptyNodeList,
+				removedNodes: emptyNodeList,
+				previousSibling: null,
+				nextSibling: null,
+				attributeName: null,
+				attributeNamespace: null,
+				oldValue: null
+			}];
+		} : void 0,
+		onceIncludesImmediate: true
+	});
+}
+//#endregion
+//#region src/composables/useDragDrop/adapters/adapter.ts
+/**
+* @module useDragDrop/adapters/adapter
+*
+* @remarks
+* Adapter contract and abstract base for useDragDrop. Concrete adapters extend
+* `DragDropAdapter<Z>` to share the `cleanup` field, `dispose()` lifecycle, and
+* the `locate()` DOM-walk helper.
+*/
+/**
+* Abstract base class for useDragDrop adapters. Provides a `cleanup` slot, a
+* `dispose()` lifecycle, and a `locate()` helper that walks the DOM to find the
+* draggable ticket whose `el` ancestors a given event target.
+*
+* @example
+* ```ts
+* import { DragDropAdapter, type DragDropAdapterContext } from '@vuetify/v0'
+*
+* class MyAdapter extends DragDropAdapter {
+*   setup (context: DragDropAdapterContext) {
+*     const stop = useEventListener(document, 'mousedown', event => {
+*       const ticket = this.locate(event.target, context)
+*       if (ticket) context.emit.start(ticket, { x: event.clientX, y: event.clientY }, 'pointer')
+*     })
+*     this.cleanup = () => stop()
+*   }
+* }
+* ```
+*/
+var DragDropAdapter = class {
+	cleanup = null;
+	dispose() {
+		this.cleanup?.();
+		this.cleanup = null;
+	}
+	locate(target, context) {
+		let element = /* @__PURE__ */ isElement(target) ? target : null;
+		while (element) {
+			for (const ticket of context.draggables.values()) if (ticket.el.value === element) return ticket;
+			element = element.parentElement;
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/composables/useDragDrop/adapters/pointer.ts
+/**
+* @module useDragDrop/adapters/pointer
+*
+* @remarks
+* Default pointer adapter for useDragDrop. Listens for `pointerdown` /
+* `pointermove` / `pointerup` / `pointercancel` on the document and emits the
+* drag lifecycle. Activation distance is configurable via `threshold`.
+*/
+/**
+* Default pointer adapter. Wires `pointerdown` / `pointermove` / `pointerup` /
+* `pointercancel` on the document and converts them into drag lifecycle calls.
+*
+* @example
+* ```ts
+* import { PointerAdapter, useDragDrop } from '@vuetify/v0'
+*
+* useDragDrop({ adapters: [new PointerAdapter({ threshold: 10 })] })
+* ```
+*/
+var PointerAdapter = class extends DragDropAdapter {
+	threshold;
+	constructor(options = {}) {
+		super();
+		this.threshold = options.threshold ?? 0;
+	}
+	setup(context) {
+		const logger = useLogger();
+		if (this.cleanup) {
+			logger.warn("PointerAdapter setup called twice; previous registration will be replaced");
+			this.dispose();
+		}
+		if (!IN_BROWSER) return;
+		let downSource = null;
+		let downOrigin = null;
+		let downId = null;
+		let started = false;
+		function reset() {
+			downSource = null;
+			downOrigin = null;
+			downId = null;
+			started = false;
+		}
+		const onDown = (event) => {
+			if (event.button !== 0) return;
+			if (downSource) return;
+			const ticket = this.locate(event.target, context);
+			if (!ticket) return;
+			downSource = ticket;
+			downOrigin = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			downId = event.pointerId;
+			started = false;
+		};
+		const onMove = (event) => {
+			if (!downSource || !downOrigin || event.pointerId !== downId) return;
+			const point = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			if (!started) {
+				const dx = point.x - downOrigin.x;
+				const dy = point.y - downOrigin.y;
+				if (this.threshold > 0 && Math.hypot(dx, dy) < this.threshold) return;
+				context.emit.start(downSource, downOrigin, "pointer");
+				started = true;
+			}
+			context.emit.move(point);
+		};
+		function onUp(event) {
+			if (event.pointerId !== downId) return;
+			if (downSource && started) context.emit.drop();
+			reset();
+		}
+		function onCancel(event) {
+			if (event.pointerId !== downId) return;
+			if (downSource && started) context.emit.cancel();
+			reset();
+		}
+		const stopDown = useEventListener(document, "pointerdown", onDown);
+		const stopMove = useEventListener(document, "pointermove", onMove);
+		const stopUp = useEventListener(document, "pointerup", onUp);
+		const stopCancel = useEventListener(document, "pointercancel", onCancel);
+		this.cleanup = () => {
+			stopDown();
+			stopMove();
+			stopUp();
+			stopCancel();
+		};
+	}
+};
+//#endregion
+//#region src/composables/useDragDrop/adapters/keyboard.ts
+/**
+* @module useDragDrop/adapters/keyboard
+*
+* @remarks
+* Default keyboard adapter for useDragDrop. Listens for `keydown` on the
+* document. Activation keys (default Space and Enter) start and drop drags;
+* arrow keys nudge the drag point by `step` px; Escape cancels.
+*/
+function isEditable(element) {
+	if (/* @__PURE__ */ isNull(element)) return false;
+	const tag = element.tagName;
+	if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+	if (element.isContentEditable) return true;
+	const role = element.getAttribute("role");
+	return role === "textbox" || role === "searchbox" || role === "combobox" || role === "spinbutton";
+}
+/**
+* Default keyboard adapter. Listens for `keydown` on the document; activation
+* keys start/drop drags, arrow keys nudge the drag point, Escape cancels.
+*
+* @example
+* ```ts
+* import { KeyboardAdapter, useDragDrop } from '@vuetify/v0'
+*
+* useDragDrop({ adapters: [new KeyboardAdapter({ activate: ['x'], step: 32 })] })
+* ```
+*/
+var KeyboardAdapter = class extends DragDropAdapter {
+	activate;
+	step;
+	constructor(options = {}) {
+		super();
+		this.activate = options.activate ?? [" ", "Enter"];
+		this.step = options.step ?? 16;
+	}
+	setup(context) {
+		const logger = useLogger();
+		if (this.cleanup) {
+			logger.warn("KeyboardAdapter setup called twice; previous registration will be replaced");
+			this.dispose();
+		}
+		if (!IN_BROWSER) return;
+		const onKeyDown = (event) => {
+			const focused = document.activeElement;
+			if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) return;
+			if (isEditable(focused)) return;
+			const ticket = this.locate(focused, context);
+			const isActive = !/* @__PURE__ */ isNull(context.active.value);
+			if (this.activate.includes(event.key)) {
+				if (isActive) {
+					event.preventDefault();
+					context.emit.drop();
+				} else if (ticket) {
+					const el = ticket.el.value;
+					if (!el) {
+						logger.warn("KeyboardAdapter: cannot start drag — element is not mounted");
+						return;
+					}
+					event.preventDefault();
+					const rect = el.getBoundingClientRect();
+					context.emit.start(ticket, {
+						x: rect.left + rect.width / 2,
+						y: rect.top + rect.height / 2
+					}, "keyboard");
+				}
+				return;
+			}
+			if (event.key === "Escape" && isActive) {
+				event.preventDefault();
+				context.emit.cancel();
+				return;
+			}
+			if (isActive && event.key.startsWith("Arrow")) {
+				const active = context.active.value;
+				if (/* @__PURE__ */ isNull(active)) return;
+				const current = active.current;
+				let point = null;
+				switch (event.key) {
+					case "ArrowUp":
+						point = {
+							x: current.x,
+							y: current.y - this.step
+						};
+						break;
+					case "ArrowDown":
+						point = {
+							x: current.x,
+							y: current.y + this.step
+						};
+						break;
+					case "ArrowLeft":
+						point = {
+							x: current.x - this.step,
+							y: current.y
+						};
+						break;
+					case "ArrowRight":
+						point = {
+							x: current.x + this.step,
+							y: current.y
+						};
+						break;
+				}
+				if (point) {
+					event.preventDefault();
+					context.emit.move(point);
+				}
+			}
+		};
+		const stop = useEventListener(document, "keydown", onKeyDown);
+		this.cleanup = () => stop();
+	}
+};
+//#endregion
+//#region src/composables/useDragDrop/index.ts
+/**
+* @module useDragDrop
+*
+* @see https://0.vuetifyjs.com/composables/system/use-drag-drop
+*
+* @remarks
+* Headless drag-and-drop primitive. Owns two registries (draggables and zones)
+* plus the active-drag state. Pointer and keyboard adapters ship by default;
+* lifecycle hooks and a plugin array provide extension points.
+*
+* @example
+* ```ts
+* import { useDragDrop } from '@vuetify/v0'
+*
+* const dnd = useDragDrop()
+* ```
+*/
+/**
+* Pure math for resolving where in an oriented zone a pointer would drop.
+* Internal — consumers rely on the `position.index` / `position.indicator`
+* fields delivered to `onDrop`.
+*/
+function resolveDropPosition(point, rects, orientation) {
+	if (rects.length === 0) return null;
+	const axis = orientation === "vertical" ? "y" : "x";
+	const start = orientation === "vertical" ? "top" : "left";
+	const end = orientation === "vertical" ? "bottom" : "right";
+	const coord = point[axis];
+	if (coord < rects[0][start]) return {
+		index: 0,
+		edge: "before",
+		rect: rects[0]
+	};
+	const last = rects.at(-1);
+	if (coord > last[end]) return {
+		index: rects.length,
+		edge: "after",
+		rect: last
+	};
+	for (const [index, rect] of rects.entries()) if (coord >= rect[start] && coord <= rect[end]) {
+		if (coord < rect[start] + (rect[end] - rect[start]) / 2) return {
+			index,
+			edge: "before",
+			rect
+		};
+		return {
+			index: index + 1,
+			edge: "after",
+			rect
+		};
+	}
+	for (let index = 0; index < rects.length - 1; index++) {
+		const a = rects[index];
+		const b = rects[index + 1];
+		if (coord > a[end] && coord < b[start]) {
+			if (coord <= (a[end] + b[start]) / 2) return {
+				index: index + 1,
+				edge: "after",
+				rect: a
+			};
+			return {
+				index: index + 1,
+				edge: "before",
+				rect: b
+			};
+		}
+	}
+	return {
+		index: rects.length,
+		edge: "after",
+		rect: last
+	};
+}
+/**
+* Create a headless drag-and-drop context.
+*
+* @param options - Adapters, plugins, and lifecycle hooks. All optional.
+* @returns A `DragDropContext<Z>` exposing `draggables` / `zones` registries,
+*   the `active` drag, the `isDragging` boolean, and a programmatic `cancel()`.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-drag-drop
+*
+* @example
+* ```ts
+* import { useDragDrop } from '@vuetify/v0'
+* import { useTemplateRef } from 'vue'
+*
+* const dnd = useDragDrop<{ type: 'card', value: string }>()
+*
+* const draggable = useTemplateRef<HTMLElement>('draggable')
+* const dropzone = useTemplateRef<HTMLElement>('dropzone')
+*
+* dnd.draggables.register({ el: draggable, type: 'card', value: 'card-1' })
+* dnd.zones.register({
+*   el: dropzone,
+*   accept: ['card'],
+*   onDrop: (drag, position) => console.log(drag.value, position.index),
+* })
+* ```
+*/
+function useDragDrop(options = {}) {
+	const { plugins = [] } = options;
+	const logger = useLogger();
+	const _draggables = createRegistry({ events: true });
+	const _zones = createRegistry({ events: true });
+	const active = shallowRef(null);
+	const isDragging = toRef(() => !/* @__PURE__ */ isNull(active.value));
+	const scopes = /* @__PURE__ */ new Map();
+	const nodes = /* @__PURE__ */ new Map();
+	function next(fn, ...args) {
+		if (/* @__PURE__ */ isUndefined(fn)) return;
+		try {
+			fn(...args);
+		} catch (error) {
+			logger.error("useDragDrop hook threw", error);
+		}
+	}
+	function safeAccept(accept, drag) {
+		try {
+			if (/* @__PURE__ */ isNull(drag)) return false;
+			if (/* @__PURE__ */ isUndefined(accept)) return true;
+			if (/* @__PURE__ */ isArray(accept)) return accept.includes(drag.type);
+			const result = accept(drag);
+			if (/* @__PURE__ */ isThenable(result)) {
+				logger.warn("useDragDrop accept predicate returned a thenable; async predicates are not supported — treating as reject");
+				return false;
+			}
+			return Boolean(result);
+		} catch (error) {
+			logger.error("useDragDrop accept predicate threw; treating as reject", error);
+			return false;
+		}
+	}
+	const draggables = {
+		..._draggables,
+		register(registration) {
+			const id = registration.id ?? /* @__PURE__ */ useId$1();
+			const el = toRef(() => toValue(registration.el));
+			const dragging = toRef(() => active.value?.id === id);
+			const input = {
+				...registration,
+				id,
+				el,
+				isDragging: dragging
+			};
+			return _draggables.register(input);
+		}
+	};
+	const zones = {
+		..._zones,
+		register(registration) {
+			const id = registration.id ?? /* @__PURE__ */ useId$1();
+			const el = toRef(() => toValue(registration.el));
+			const isOver = toRef(() => active.value?.over === id);
+			const willAccept = toRef(() => safeAccept(registration.accept, active.value));
+			const rects = shallowRef([]);
+			function refresh() {
+				const zoneEl = el.value;
+				rects.value = zoneEl ? Array.from(zoneEl.children).map((child) => child.getBoundingClientRect()) : [];
+			}
+			const scope = effectScope();
+			scopes.set(id, scope);
+			scope.run(() => {
+				if (registration.orientation) {
+					watch(el, refresh, {
+						immediate: true,
+						flush: "post"
+					});
+					useResizeObserver(el, refresh);
+					useMutationObserver(el, refresh, { childList: true });
+					watch(() => active.value?.id, (id) => {
+						if (id) refresh();
+					});
+				}
+				watch(el, (current) => {
+					if (/* @__PURE__ */ isNull(current)) return;
+					nodes.set(current, id);
+					onWatcherCleanup(() => nodes.delete(current));
+				}, { immediate: true });
+			});
+			const indicator = computed(() => {
+				if (!registration.orientation || !isOver.value || !active.value) return null;
+				return resolveDropPosition(active.value.current, rects.value, registration.orientation);
+			});
+			const input = {
+				...registration,
+				id,
+				el,
+				isOver,
+				willAccept,
+				indicator
+			};
+			return _zones.register(input);
+		}
+	};
+	function at(point) {
+		if (!IN_BROWSER) return null;
+		let element = document.elementFromPoint(point.x, point.y);
+		while (element) {
+			const id = nodes.get(element);
+			if (!/* @__PURE__ */ isUndefined(id)) {
+				const zone = _zones.get(id);
+				if (zone && !toValue(zone.disabled)) return id;
+			}
+			element = element.parentElement;
+		}
+		return null;
+	}
+	function position(zoneId, drag) {
+		const zone = _zones.get(zoneId);
+		const out = { pointer: drag.current };
+		if (zone?.orientation) {
+			const resolved = zone.indicator?.value ?? null;
+			if (resolved) {
+				out.index = resolved.index;
+				out.indicator = resolved;
+			} else out.index = 0;
+		}
+		return out;
+	}
+	function bail(drag, reason = "cancel") {
+		active.value = null;
+		if (!/* @__PURE__ */ isNull(drag.over)) next(_zones.get(drag.over)?.onLeave, drag);
+		next(_draggables.get(drag.id)?.onCancel, drag, reason);
+		next(options.onCancel, drag, reason);
+	}
+	function onStart(source, origin, via) {
+		if (toValue(_draggables.get(source.id)?.disabled)) return;
+		const draft = {
+			id: source.id,
+			type: source.type,
+			value: source.value,
+			origin,
+			current: origin,
+			delta: {
+				x: 0,
+				y: 0
+			},
+			over: null,
+			willAccept: false,
+			via
+		};
+		try {
+			if (_draggables.get(source.id)?.onBeforeStart?.(draft) === false) return;
+		} catch (error) {
+			logger.error("useDragDrop onBeforeStart threw; treating as veto", error);
+			return;
+		}
+		try {
+			if (options.onBeforeStart?.(draft) === false) return;
+		} catch (error) {
+			logger.error("useDragDrop onBeforeStart threw; treating as veto", error);
+			return;
+		}
+		active.value = draft;
+	}
+	function onMove(point) {
+		if (!active.value) return;
+		const over = at(point);
+		const draft = {
+			...active.value,
+			current: point,
+			delta: {
+				x: point.x - active.value.origin.x,
+				y: point.y - active.value.origin.y
+			},
+			over,
+			willAccept: false
+		};
+		draft.willAccept = !/* @__PURE__ */ isNull(over) && safeAccept(_zones.get(over)?.accept, draft);
+		const previous = active.value.over;
+		active.value = draft;
+		if (previous !== over) {
+			if (!/* @__PURE__ */ isNull(previous)) next(_zones.get(previous)?.onLeave, draft);
+			if (!/* @__PURE__ */ isNull(over)) next(_zones.get(over)?.onEnter, draft);
+		}
+		next(_draggables.get(draft.id)?.onMove, draft);
+		next(options.onMove, draft);
+	}
+	function onDrop() {
+		if (!active.value) return;
+		const drag = active.value;
+		const zoneId = drag.over;
+		if (/* @__PURE__ */ isNull(zoneId)) {
+			bail(drag);
+			return;
+		}
+		const dropAt = position(zoneId, drag);
+		const zone = _zones.get(zoneId);
+		function vetoed(fn, label) {
+			if (!fn) return false;
+			try {
+				return fn(drag, dropAt) === false;
+			} catch (error) {
+				logger.error(`useDragDrop ${label} threw; treating as veto`, error);
+				return true;
+			}
+		}
+		if (vetoed(zone?.onBeforeDrop, "zone onBeforeDrop") || vetoed(options.onBeforeDrop, "options onBeforeDrop")) {
+			bail(drag, "reject");
+			return;
+		}
+		active.value = null;
+		next(zone?.onDrop, drag, dropAt);
+		next(options.onDrop, drag, dropAt);
+	}
+	function cancel() {
+		if (!active.value) return;
+		bail(active.value);
+	}
+	const context = {
+		draggables,
+		zones,
+		active: shallowReadonly(active),
+		isDragging,
+		cancel
+	};
+	const disposers = [];
+	const adapters = options.adapters ?? [new PointerAdapter(), new KeyboardAdapter()];
+	const emit = {
+		start: (source, origin, via) => onStart(source, origin, via),
+		move: (point) => onMove(point),
+		drop: () => onDrop(),
+		cancel: () => cancel()
+	};
+	const adapterContext = {
+		...context,
+		emit
+	};
+	for (const adapter of adapters) try {
+		adapter.setup(adapterContext);
+		disposers.push(() => adapter.dispose());
+	} catch (error) {
+		logger.error("useDragDrop adapter setup threw; skipping adapter", error);
+		try {
+			adapter.dispose();
+		} catch (disposeError) {
+			logger.error("useDragDrop adapter dispose threw after setup failure", disposeError);
+		}
+	}
+	for (const plugin of plugins) try {
+		const dispose = plugin(context);
+		if (/* @__PURE__ */ isFunction(dispose)) disposers.push(dispose);
+	} catch (error) {
+		logger.error("useDragDrop plugin install threw; skipping plugin", error);
+	}
+	_draggables.on("unregister:ticket", (ticket) => {
+		if (active.value?.id === ticket.id) cancel();
+	});
+	_zones.on("unregister:ticket", (ticket) => {
+		const scope = scopes.get(ticket.id);
+		if (scope) {
+			scope.stop();
+			scopes.delete(ticket.id);
+		}
+		if (active.value?.over === ticket.id) {
+			next(ticket.onLeave, active.value);
+			active.value = {
+				...active.value,
+				over: null,
+				willAccept: false
+			};
+		}
+	});
+	onScopeDispose(() => {
+		if (!/* @__PURE__ */ isNull(active.value)) cancel();
+		for (const dispose of disposers.toReversed()) try {
+			dispose();
+		} catch (error) {
+			logger.error("useDragDrop disposer threw", error);
+		}
+		for (const scope of scopes.values()) try {
+			scope.stop();
+		} catch (error) {
+			logger.error("useDragDrop zone scope dispose threw", error);
+		}
+		scopes.clear();
+		nodes.clear();
+		try {
+			_draggables.dispose();
+		} catch (error) {
+			logger.error("useDragDrop draggables dispose threw", error);
+		}
+		try {
+			_zones.dispose();
+		} catch (error) {
+			logger.error("useDragDrop zones dispose threw", error);
+		}
+	}, true);
+	return context;
+}
+//#endregion
+//#region src/composables/useHotkey/aliases.ts
+/**
+* Key alias mapping for consistent key normalization across the hotkey system.
+*
+* Maps user-friendly aliases to canonical key names that match
+* KeyboardEvent.key values (in lowercase) where possible.
+*/
+const keyAliasMap = {
+	control: "ctrl",
+	command: "cmd",
+	option: "alt",
+	up: "arrowup",
 	down: "arrowdown",
 	left: "arrowleft",
 	right: "arrowright",
@@ -4875,9 +6287,11 @@ function useHotkey(keys, callback, options = {}, _platform) {
 	let isSequence = false;
 	let groupIndex = 0;
 	function isInputFocused() {
+		/* v8 ignore next -- IN_BROWSER always true in happy-dom test env */
 		if (!IN_BROWSER) return false;
 		if (toValue(inputs)) return false;
 		const activeElement = document.activeElement;
+		/* v8 ignore next -- defensive: document.activeElement is always set in happy-dom */
 		if (!activeElement) return false;
 		const role = activeElement.getAttribute("role");
 		if (role === "textbox" || role === "searchbox" || role === "combobox" || role === "spinbutton") return true;
@@ -4931,6 +6345,7 @@ function useHotkey(keys, callback, options = {}, _platform) {
 		const currentKeys = toValue(keys);
 		if (!currentKeys) return;
 		const groups = splitKeySequence(currentKeys.toLowerCase());
+		/* v8 ignore next -- defensive: splitKeySequence rejects empty strings earlier */
 		if (groups.length === 0) return;
 		isSequence = groups.length > 1;
 		keyGroups = groups;
@@ -4983,6 +6398,7 @@ function isModifier(key) {
 function parseKeyGroup(group) {
 	const { keys: parts } = splitKeyCombination(group.toLowerCase());
 	const modifiers = Object.fromEntries(MODIFIERS.map((m) => [m, false]));
+	/* v8 ignore next 3 -- defensive: parseKeyGroup is not invoked with empty parts */
 	if (parts.length === 0) return {
 		modifiers,
 		actualKey: void 0
@@ -5208,11 +6624,13 @@ function useIntersectionObserver(target, callback, options = {}) {
 			observe: (obs, el) => obs.observe(el),
 			onEntry: (entries) => {
 				const latest = entries.at(-1);
+				/* v8 ignore next -- defensive: IntersectionObserver always emits at least one entry */
 				if (latest) isIntersecting.value = latest.isIntersecting;
 			},
 			onPause: () => {
 				isIntersecting.value = false;
 			},
+			/* v8 ignore next -- defensive nullish coalesce: entries always populated when shouldStop fires */
 			shouldStop: (entries) => entries.at(-1)?.isIntersecting ?? false,
 			immediate: options.immediate ? (el) => {
 				return [{
@@ -5262,6 +6680,7 @@ function useElementIntersection(target, options = {}) {
 	const intersectionRatio = shallowRef(0);
 	const { pause: _pause, resume, stop, isActive, isPaused } = useIntersectionObserver(target, (entries) => {
 		const entry = entries.at(-1);
+		/* v8 ignore next 4 -- defensive: IntersectionObserver always emits at least one entry */
 		if (entry) {
 			isIntersecting.value = entry.isIntersecting;
 			intersectionRatio.value = entry.intersectionRatio;
@@ -5511,131 +6930,6 @@ function usePrefersContrast() {
 	return useMediaQuery("(prefers-contrast: more)");
 }
 //#endregion
-//#region src/composables/useMutationObserver/index.ts
-/**
-* @module useMutationObserver
-*
-* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
-*
-* @remarks
-* MutationObserver composable with lifecycle management.
-*
-* Key features:
-* - MutationObserver API wrapper
-* - `isActive` reactive flag
-* - `once` option for single-fire observation
-* - Pause/resume/stop functionality
-* - Automatic cleanup on unmount
-* - SSR-safe (checks SUPPORTS_MUTATION_OBSERVER)
-* - Hydration-aware
-* - Configurable observation options (childList, attributes, characterData, etc.)
-*
-* Perfect for detecting DOM changes and responding to mutations.
-*
-* @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.
-*
-* @param target The element to observe.
-* @param callback The callback to execute when a mutation is observed.
-* @param options The options for the Mutation Observer.
-* @returns An object with methods to control the observer.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
-* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useMutationObserver } from '@vuetify/v0'
-*
-* const container = ref<HTMLElement>()
-*
-* const { pause, resume, isPaused } = useMutationObserver(
-*   container,
-*   (mutations) => {
-*     mutations.forEach((mutation) => {
-*       if (mutation.type === 'childList') {
-*         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
-*       } else if (mutation.type === 'attributes') {
-*         console.log('Attribute changed:', mutation.attributeName)
-*       }
-*     })
-*   },
-*   {
-*     childList: true,
-*     attributes: true,
-*     subtree: true
-*   }
-* )
-*
-* // Pause observation
-* pause()
-*
-* // Resume observation
-* resume()
-* ```
-*/
-function useMutationObserver(target, callback, options = {}) {
-	const observerOptions = {
-		childList: options.childList ?? true,
-		attributes: options.attributes ?? false,
-		characterData: options.characterData ?? false,
-		subtree: options.subtree ?? false,
-		attributeOldValue: options.attributeOldValue ?? false,
-		characterDataOldValue: options.characterDataOldValue ?? false,
-		attributeFilter: options.attributeFilter
-	};
-	return createObserver(target, callback, {
-		supports: SUPPORTS_MUTATION_OBSERVER,
-		once: options.once,
-		create: (cb) => new MutationObserver((mutations) => {
-			cb(mutations.map((m) => ({
-				type: m.type,
-				target: m.target,
-				addedNodes: m.addedNodes,
-				removedNodes: m.removedNodes,
-				previousSibling: m.previousSibling,
-				nextSibling: m.nextSibling,
-				attributeName: m.attributeName,
-				attributeNamespace: m.attributeNamespace,
-				oldValue: m.oldValue
-			})));
-		}),
-		observe: (obs, el) => obs.observe(el, observerOptions),
-		immediate: options.immediate ? (el) => {
-			const emptyNodeList = {
-				length: 0,
-				item: () => null,
-				forEach: () => {},
-				*[Symbol.iterator]() {}
-			};
-			return [{
-				type: "childList",
-				target: el,
-				addedNodes: emptyNodeList,
-				removedNodes: emptyNodeList,
-				previousSibling: null,
-				nextSibling: null,
-				attributeName: null,
-				attributeNamespace: null,
-				oldValue: null
-			}];
-		} : void 0,
-		onceIncludesImmediate: true
-	});
-}
-//#endregion
 //#region src/composables/usePresence/index.ts
 /**
 * @module usePresence
@@ -6019,8 +7313,11 @@ function useRovingFocus(items, options = {}) {
 	};
 }
 //#endregion
+//#region src/composables/useRtl/adapters/adapter.ts
+var RtlAdapter = class {};
+//#endregion
 //#region src/composables/useRtl/adapters/v0.ts
-var Vuetify0RtlAdapter = class {
+var V0RtlAdapter = class extends RtlAdapter {
 	setup(app, context, target) {
 		if (IN_BROWSER) {
 			if (/* @__PURE__ */ isNull(target)) return;
@@ -6088,7 +7385,7 @@ function createRtlFallback() {
 }
 const [createRtlContext, createRtlPlugin, useRtl] = createPluginContext("v0:rtl", (options) => createRtl(options), {
 	fallback: () => createRtlFallback(),
-	setup: (context, app, { adapter = new Vuetify0RtlAdapter(), target }) => {
+	setup: (context, app, { adapter = new V0RtlAdapter(), target }) => {
 		adapter.setup(app, context, target);
 	},
 	persist: (ctx) => ctx.isRtl.value,
@@ -6380,7 +7677,7 @@ function useStack(namespace = "v0:stack") {
 * ```
 */
 function createStorage(options = {}) {
-	const { adapter = IN_BROWSER ? window.localStorage : new MemoryAdapter(), prefix = "v0:", serializer = {
+	const { adapter = IN_BROWSER ? window.localStorage : new MemoryStorageAdapter(), prefix = "v0:", serializer = {
 		read: JSON.parse,
 		write: JSON.stringify
 	}, ttl } = options;
@@ -6395,9 +7692,9 @@ function createStorage(options = {}) {
 		if (/* @__PURE__ */ isNullOrUndefined(raw)) return void 0;
 		try {
 			const parsed = serializer.read(raw);
-			if (ttl && /* @__PURE__ */ isObject(parsed) && "__v0" in parsed && "__v" in parsed) {
+			if (/* @__PURE__ */ isObject(parsed) && "__v0" in parsed && "__v" in parsed) {
 				const envelope = parsed;
-				if (Date.now() - envelope.__t > ttl) {
+				if (ttl && Date.now() - envelope.__t > ttl) {
 					adapter?.removeItem(prefixedKey);
 					return;
 				}
@@ -6477,7 +7774,7 @@ function createStorage(options = {}) {
 	};
 }
 function createStorageFallback() {
-	return createStorage({ adapter: new MemoryAdapter() });
+	return createStorage({ adapter: new MemoryStorageAdapter() });
 }
 const [createStorageContext, createStoragePlugin, useStorage] = createPluginContext("v0:storage", (options) => createStorage(options), { fallback: () => createStorageFallback() });
 //#endregion
@@ -6824,6 +8121,7 @@ function useClickOutside(target, handler, options = {}) {
 	* Check if an element matches resolved ignore targets.
 	*/
 	function isIgnored(el, selectors, elements) {
+		/* v8 ignore next -- defensive guard, callers always pass an Element */
 		if (!el) return false;
 		for (const selector of selectors) try {
 			if (el.matches(selector) || !/* @__PURE__ */ isNull(el.closest(selector))) return true;
@@ -6850,6 +8148,7 @@ function useClickOutside(target, handler, options = {}) {
 		const targets = getTargets();
 		if (targets.length === 0) return false;
 		return targets.every((el) => {
+			/* v8 ignore next -- defensive: getTargets filters to Element-typed values */
 			if (/* @__PURE__ */ isNullOrUndefined(el) || !/* @__PURE__ */ isFunction(el.contains)) return false;
 			return el !== eventTarget && !el.contains(eventTarget);
 		});
@@ -6859,6 +8158,7 @@ function useClickOutside(target, handler, options = {}) {
 	*/
 	function isOutsideBounds(x, y) {
 		const targets = getTargets();
+		/* v8 ignore next -- edge case: bounds check only invoked when targets exist */
 		if (targets.length === 0) return false;
 		return targets.every((el) => {
 			const { left, right, top, bottom } = el.getBoundingClientRect();
@@ -6869,6 +8169,7 @@ function useClickOutside(target, handler, options = {}) {
 	* Validate that the target is still in the DOM.
 	*/
 	function isValidTarget(eventTarget) {
+		/* v8 ignore next -- type guard for non-Element targets (e.g., document, window) */
 		if (!/* @__PURE__ */ isElement(eventTarget)) return false;
 		if (!eventTarget.isConnected) return false;
 		return true;
@@ -6961,4 +8262,4 @@ function useClickOutside(target, handler, options = {}) {
 	};
 }
 //#endregion
-export { createSlider as $, useElementIntersection as A, ServerAdapter as At, createBreakpointsContext as B, usePresence as C, createValidation as Ct, usePrefersDark as D, createCombobox as Dt, usePrefersContrast as E, useForm as Et, createDate as F, createBreadcrumbsContext as Ft, createVirtualContext as G, useBreakpoints as H, createDateContext as I, useBreadcrumbs as It, createTimelineContext as J, useVirtual as K, createDatePlugin as L, useImage as M, useVirtualFocus as Mt, useHotkey as N, usePopover as Nt, usePrefersReducedMotion as O, createComboboxContext as Ot, useDelay as P, createBreadcrumbs as Pt, useStep as Q, useDate as R, useProxyModel as S, createInput as St, useMediaQuery as T, createFormContext as Tt, toReactive as U, createBreakpointsPlugin as V, createVirtual as W, createStep as X, useTimeline as Y, createStepContext as Z, createRtlPlugin as _, createNumberField as _t, useToggleScope as a, useProgress as at, useRovingFocus as b, createNestedContext as bt, createStoragePlugin as c, useOverflow as ct, createStackContext as d, toElement as dt, createRating as et, createStackPlugin as f, createFallbackHydration as ft, createRtlFallback as g, useHydration as gt, createRtlContext as h, createHydrationPlugin as ht, useWindowEventListener as i, createProgressContext as it, useIntersectionObserver as j, ClientAdapter as jt, useLazy as k, useCombobox as kt, useStorage as l, useElementSize as lt, createRtl as m, createHydrationContext as mt, useDocumentEventListener as n, useRating as nt, createStorage as o, createOverflow as ot, useStack as p, createHydration as pt, createTimeline as q, useEventListener as r, createProgress as rt, createStorageContext as s, createOverflowContext as st, useClickOutside as t, createRatingContext as tt, createStack as u, useResizeObserver as ut, useRtl as v, createNumeric as vt, useMutationObserver as w, createForm as wt, useRaf as x, useNested as xt, Vuetify0RtlAdapter as y, createNested as yt, createBreakpoints as z };
+export { createTimelineContext as $, useIntersectionObserver as A, createInput as At, createDateContext as B, ComboboxAdapter as Bt, usePresence as C, createNumberField as Ct, usePrefersReducedMotion as D, useNested as Dt, usePrefersDark as E, createNestedContext as Et, PointerAdapter as F, createCombobox as Ft, createBreakpointsPlugin as G, useBreadcrumbs as Gt, useDate as H, usePopover as Ht, DragDropAdapter as I, createComboboxContext as It, toHighlight as J, useBreakpoints as K, useMutationObserver as L, useCombobox as Lt, useHotkey as M, createForm as Mt, useDragDrop as N, createFormContext as Nt, useLazy as O, createKanban as Ot, KeyboardAdapter as P, useForm as Pt, createTimeline as Q, useDelay as R, ServerComboboxAdapter as Rt, useProxyModel as S, createOtp as St, usePrefersContrast as T, createNested as Tt, createBreakpoints as U, createBreadcrumbs as Ut, createDatePlugin as V, useVirtualFocus as Vt, createBreakpointsContext as W, createBreadcrumbsContext as Wt, createVirtualContext as X, createVirtual as Y, useVirtual as Z, createRtlPlugin as _, createFallbackHydration as _t, useToggleScope as a, createRating as at, useRovingFocus as b, createHydrationPlugin as bt, createStoragePlugin as c, createProgress as ct, createStackContext as d, createOverflow as dt, useTimeline as et, createStackPlugin as f, createOverflowContext as ft, createRtlFallback as g, toElement as gt, createRtlContext as h, useResizeObserver as ht, useWindowEventListener as i, createSlider as it, useImage as j, createValidation as jt, useElementIntersection as k, createSortable as kt, useStorage as l, createProgressContext as lt, createRtl as m, useElementSize as mt, useDocumentEventListener as n, createStepContext as nt, createStorage as o, createRatingContext as ot, useStack as p, useOverflow as pt, toReactive as q, useEventListener as r, useStep as rt, createStorageContext as s, useRating as st, useClickOutside as t, createStep as tt, createStack as u, useProgress as ut, useRtl as v, createHydration as vt, useMediaQuery as w, createNumeric as wt, useRaf as x, useHydration as xt, V0RtlAdapter as y, createHydrationContext as yt, createDate as z, ClientComboboxAdapter as zt };