@vuetify/v0 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/composables-DxKmYiTj.mjs

@@ -0,0 +1,4077 @@
+import { i as SUPPORTS_MUTATION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-C1X-9O7K.mjs";
+import { V0Error, clamp, instanceExists, isArray, isElement, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isString, isThenable, isUndefined, mergeDeep, useId as useId$1 } from "./utilities/index.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-z-3q9QWR.mjs";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-D7_hm4e8.mjs";
+import { t as createRegistry } from "./createRegistry-Cb6ftNMU.mjs";
+import { i as createModel } from "./createSelection-BMvXj84C.mjs";
+import { a as useLocale } from "./useLocale-CTwn8uZk.mjs";
+import { t as toArray } from "./toArray-C89ZaEuF.mjs";
+import { n as useEventListener, r as useWindowEventListener } from "./useEventListener-BK_uaXZv.mjs";
+import { J as useResizeObserver, M as ComboboxAdapter, Y as createObserver, b as createInput, nt as useToggleScope, tt as useHydration } from "./useRovingFocus-BdnSUVrD.mjs";
+import { t as createGroup } from "./createGroup-BTG6xcyp.mjs";
+import { a as extractLeaves, t as createDataTable } from "./createDataTable-CBfnCUKU.mjs";
+import { computed, effectScope, isRef, onScopeDispose, onWatcherCleanup, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
+//#region src/composables/createCombobox/adapters/server.ts
+/**
+* @module createCombobox/adapters/server
+*
+* @remarks
+* Server-side combobox adapter. All filtering is performed externally.
+* The adapter is a pass-through — it shows all registered items and
+* exposes loading state for the consumer to control.
+*
+* The consumer watches `query` via useComboboxContext() or slot props
+* and provides filtered items reactively.
+*/
+var ServerComboboxAdapter = class extends ComboboxAdapter {
+	setup(context) {
+		const isLoading = shallowRef(false);
+		return {
+			filtered: toRef(() => {
+				return new Set(context.items.value.map((t) => t.id));
+			}),
+			isLoading,
+			isEmpty: toRef(() => context.items.value.length === 0)
+		};
+	}
+};
+//#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/createDataGrid/editing.ts
+/**
+* @module createDataGrid/editing
+*
+* @remarks
+* Cell editing state management. Tracks active cell, validation errors,
+* and dirty (staged but uncommitted) edits. Does not mutate source data —
+* commit fires a callback for the consumer to handle.
+*
+* When a `registry` is provided, editing state for rows that get
+* unregistered (or wiped via `clear`) is pruned automatically so consumers
+* can never observe `active` pointing at a phantom row or stale entries
+* lingering in `dirty`.
+*
+* @internal Consumed only by `createDataGrid`. This is a fully decoupled 2D
+* cell-edit primitive — it imports nothing from `createDataGrid` /
+* `createDataTable` (only `#v0/utilities`, `#v0/types`, and Vue), so it is a
+* latent composable. It is parameterized over a row type `T` (defaulting to
+* `unknown`), but a type parameter is not an import — the primitive stays
+* fully decoupled from the grid's concrete ticket types and deliberately
+* row-agnostic: `T` is intentionally unconstrained, so do not narrow it to
+* the grid's `Record<string, unknown>` when promoting. Promote it to a
+* standalone `createCellEditing/`
+* composable the moment a second consumer appears (e.g. an editable
+* `createDataTable`). See `.claude/rules/composables.md` §"Sub-modules:
+* inline, private sibling, or promote".
+*/
+/**
+* Creates cell editing state for a data grid.
+*
+* @param options Cell editing configuration including columns and commit callback
+* @returns Cell editing state and controls
+*
+* @example
+* ```ts
+* const editing = createCellEditing({
+*   columns: [{ id: 'name', editable: true }],
+*   registry: table,
+*   onEdit (row, column, value) { ... },
+* })
+*
+* editing.edit(1, 'name')
+* editing.commit('Alice')
+* ```
+*/
+function createCellEditing(options) {
+	const { columns, onEdit, lookup, registry } = options;
+	function resolveColumn(column) {
+		for (const col of toValue(columns)) if (col.id === column) return col;
+	}
+	const active = shallowRef(null);
+	const error = shallowRef(null);
+	const dirty = shallowReactive(/* @__PURE__ */ new Map());
+	function edit(row, column) {
+		const col = resolveColumn(column);
+		if (!col) return;
+		if (/* @__PURE__ */ isFunction(col.editable)) {
+			const item = lookup?.(row);
+			if (/* @__PURE__ */ isUndefined(item) || !col.editable(item)) return;
+		} else if (col.editable !== true) return;
+		error.value = null;
+		active.value = {
+			row,
+			column
+		};
+	}
+	function commit(value) {
+		const cell = active.value;
+		if (!cell) return;
+		const col = resolveColumn(cell.column);
+		if (col?.validate) {
+			const result = col.validate(value, lookup?.(cell.row));
+			if (result !== true && /* @__PURE__ */ isString(result) && result.length > 0) {
+				error.value = result;
+				return;
+			}
+		}
+		const entry = dirty.get(cell.row);
+		if (entry) {
+			entry.delete(cell.column);
+			if (entry.size === 0) dirty.delete(cell.row);
+		}
+		error.value = null;
+		active.value = null;
+		onEdit?.(cell.row, cell.column, value);
+	}
+	function cancel() {
+		const cell = active.value;
+		if (cell) {
+			const entry = dirty.get(cell.row);
+			if (entry) {
+				entry.delete(cell.column);
+				if (entry.size === 0) dirty.delete(cell.row);
+			}
+		}
+		error.value = null;
+		active.value = null;
+	}
+	function onUnregister(data) {
+		const ticket = data;
+		if (active.value?.row === ticket.id) {
+			active.value = null;
+			error.value = null;
+		}
+		dirty.delete(ticket.id);
+	}
+	function onClear() {
+		active.value = null;
+		error.value = null;
+		dirty.clear();
+	}
+	if (registry) {
+		registry.on("unregister:ticket", onUnregister);
+		registry.on("clear:registry", onClear);
+		onScopeDispose(() => {
+			registry.off("unregister:ticket", onUnregister);
+			registry.off("clear:registry", onClear);
+		}, true);
+	}
+	return {
+		active,
+		edit,
+		commit,
+		cancel,
+		error,
+		dirty
+	};
+}
+//#endregion
+//#region src/composables/createDataGrid/layout.ts
+/**
+* @module createDataGrid/layout
+*
+* @remarks
+* Manages column layout state for data grids: sizing (percentages 0-100),
+* pinning (left/right/scrollable regions), delta-based resizing compatible
+* with the Splitter two-panel model, column reordering, and visibility.
+*
+* Column existence, display order, AND grid layout config (size, pin,
+* min/max, resizable, reorderable) all live on the table's columns registry
+* (passed in as the only argument). `createRegistry` preserves the extra
+* grid fields on each ticket, so layout reads its config straight off the
+* registered ticket — there is no separate defs array. Columns onboarded
+* before OR after the layout is built are picked up identically: an initial
+* loop seeds the already-registered set and a `register:ticket` handler seeds
+* the rest. Removed columns have their pin/size/visibility state pruned via
+* unregister events.
+*
+* Sizing uses percentages so it is compatible with the Splitter component.
+* Offsets are computed per-region (left, scrollable, right) independently
+* and over visible columns only — hidden columns are excluded from the
+* render set without auto-redistribution (headless: the consumer rebalances
+* via `distribute()` or CSS).
+*
+* @internal Private sibling of `createDataGrid`, and intentionally NOT a
+* promotion candidate: it is bound to the table's `DataTableColumnTicket`
+* types, so it is parent-specific glue rather than a reusable primitive. See
+* `.claude/rules/composables.md` §"Sub-modules: inline, private sibling, or
+* promote".
+*/
+const DEFAULT_EXTRAS = {
+	minSize: 2,
+	maxSize: 100,
+	resizable: true,
+	reorderable: true
+};
+function offsets(cols, reverse = false) {
+	let offset = 0;
+	const start = reverse ? cols.length - 1 : 0;
+	const step = reverse ? -1 : 1;
+	const end = reverse ? -1 : cols.length;
+	for (let i = start; i !== end; i += step) {
+		cols[i].offset = offset;
+		offset += cols[i].size;
+	}
+}
+/**
+* Creates a column layout manager for a data grid.
+*
+* Reads column existence, display order, AND grid layout config (size, pin,
+* min/max, resizable, reorderable) from the table's columns registry. The
+* grid fields ride on each ticket — `createRegistry` preserves them — so
+* there is no separate defs array. Visibility is layout-local view state
+* (not a ticket field) kept here and reconciled via register / unregister /
+* clear events.
+*
+* Generic over the registry's input/output ticket types so the caller's
+* concrete grid column ticket (`DataGridColumnTicket`) flows through. Layout
+* only ever reads from the registry (`values`, `keys`, `on`, `reorder`,
+* `move`, `lookup`) — it never registers — so the output ticket need only be
+* readable as a {@link GridColumnDef}.
+*
+* @param cols The table's columns registry — source of truth for which
+*             columns exist, in what order, and their layout config
+* @returns Column layout state and mutation methods
+*/
+function createColumnLayout(cols) {
+	const logger = useLogger();
+	const configs = /* @__PURE__ */ new Map();
+	const group = createGroup({ multiple: true });
+	const sizes = shallowReactive(/* @__PURE__ */ new Map());
+	const hidden = shallowReactive(/* @__PURE__ */ new Set());
+	const order = [];
+	function record(id) {
+		if (!order.includes(id)) order.push(id);
+	}
+	/** Even share over the currently-registered leaves: explicit sizes are
+	*  honored, unsized columns split the remaining percentage. */
+	function share(id) {
+		const leaves = /* @__PURE__ */ extractLeaves(cols.values());
+		let used = 0;
+		let unsized = 0;
+		for (const leaf of leaves) {
+			const size = configs.get(String(leaf.id))?.size;
+			if (/* @__PURE__ */ isUndefined(size)) unsized++;
+			else used += size;
+		}
+		const own = configs.get(id)?.size;
+		if (!/* @__PURE__ */ isUndefined(own)) return own;
+		const remainder = Math.max(0, 100 - used);
+		return unsized > 0 ? remainder / unsized : 0;
+	}
+	function seedLeaf(leaf) {
+		const id = String(leaf.id);
+		if (!configs.has(id)) configs.set(id, {
+			size: leaf.size,
+			minSize: leaf.minSize ?? DEFAULT_EXTRAS.minSize,
+			maxSize: leaf.maxSize ?? DEFAULT_EXTRAS.maxSize,
+			resizable: leaf.resizable ?? DEFAULT_EXTRAS.resizable,
+			reorderable: leaf.reorderable ?? DEFAULT_EXTRAS.reorderable,
+			pinned: leaf.pinned ?? false
+		});
+		if (!group.has(id)) group.register({
+			id,
+			value: id
+		});
+		if (!sizes.has(id)) sizes.set(id, share(id));
+		for (const other of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const otherId = String(other.id);
+			if (configs.has(otherId) && /* @__PURE__ */ isUndefined(configs.get(otherId)?.size)) sizes.set(otherId, share(otherId));
+		}
+		const config = configs.get(id);
+		if (config.pinned === "left") group.select(id);
+		else if (config.pinned === "right") group.mix(id);
+	}
+	function dropLeaf(id) {
+		group.unregister(id);
+		configs.delete(id);
+		sizes.delete(id);
+		hidden.delete(id);
+	}
+	function leavesOf(ticket) {
+		return /* @__PURE__ */ extractLeaves([ticket]);
+	}
+	for (const ticket of cols.values()) {
+		record(String(ticket.id));
+		for (const leaf of leavesOf(ticket)) seedLeaf(leaf);
+	}
+	cols.on("register:ticket", (ticket) => {
+		record(String(ticket.id));
+		for (const leaf of leavesOf(ticket)) seedLeaf(leaf);
+	});
+	cols.on("unregister:ticket", (ticket) => {
+		const top = order.indexOf(String(ticket.id));
+		if (top !== -1) order.splice(top, 1);
+		for (const leaf of leavesOf(ticket)) dropLeaf(String(leaf.id));
+	});
+	cols.on("clear:registry", () => {
+		group.clear();
+		configs.clear();
+		sizes.clear();
+		hidden.clear();
+		order.length = 0;
+	});
+	function position(id) {
+		if (group.selectedIds.has(id)) return "left";
+		if (group.mixed(id)) return "right";
+		return false;
+	}
+	function resolve(includeHidden) {
+		const resolved = [];
+		let index = 0;
+		for (const ticket of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const id = String(ticket.id);
+			const visible = !hidden.has(id);
+			if (!includeHidden && !visible) continue;
+			const meta = configs.get(id) ?? DEFAULT_EXTRAS;
+			resolved.push({
+				id,
+				index: index++,
+				size: sizes.get(id) ?? 0,
+				offset: 0,
+				pinned: position(id),
+				resizable: meta.resizable,
+				reorderable: meta.reorderable,
+				minSize: meta.minSize,
+				maxSize: meta.maxSize,
+				visible
+			});
+		}
+		return resolved;
+	}
+	function split(resolved) {
+		const left = [];
+		const scrollable = [];
+		const right = [];
+		for (const col of resolved) if (col.pinned === "left") left.push(col);
+		else if (col.pinned === "right") right.push(col);
+		else scrollable.push(col);
+		offsets(left);
+		offsets(scrollable);
+		offsets(right, true);
+		return {
+			left,
+			scrollable,
+			right
+		};
+	}
+	const pinned = computed(() => split(resolve(false)));
+	const columns = computed(() => {
+		const { left, scrollable, right } = pinned.value;
+		return [
+			...left,
+			...scrollable,
+			...right
+		];
+	});
+	const allColumns = computed(() => resolve(true));
+	function pin(id, pos) {
+		if (!group.has(id)) return;
+		group.unselect(id);
+		group.unmix(id);
+		if (pos === "left") group.select(id);
+		else if (pos === "right") group.mix(id);
+	}
+	function resize(id, delta) {
+		const { left, scrollable, right } = pinned.value;
+		const all = [
+			...left,
+			...scrollable,
+			...right
+		];
+		const target = all.find((c) => c.id === id);
+		if (!target || !target.resizable) return;
+		const allIndex = all.findIndex((c) => c.id === id);
+		if (allIndex === -1 || allIndex === all.length - 1) return;
+		const neighbor = all[allIndex + 1];
+		const total = target.size + neighbor.size;
+		const lower = Math.max(target.minSize, total - neighbor.maxSize);
+		const upper = Math.min(target.maxSize, total - neighbor.minSize);
+		const clamped = /* @__PURE__ */ clamp(target.size + delta, lower, upper);
+		sizes.set(id, clamped);
+		sizes.set(neighbor.id, total - clamped);
+	}
+	function reorder(from, to) {
+		if (from === to) return;
+		const tops = [...cols.values()];
+		const ids = [];
+		const leafToTop = [];
+		for (const [top, ticket] of tops.entries()) for (const leaf of /* @__PURE__ */ extractLeaves([ticket])) {
+			ids.push(String(leaf.id));
+			leafToTop.push(top);
+		}
+		const visible = ids.filter((id) => !hidden.has(id));
+		const fromId = visible[from];
+		const toId = visible[to];
+		if (/* @__PURE__ */ isUndefined(fromId) || /* @__PURE__ */ isUndefined(toId)) return;
+		const fromTop = leafToTop[ids.indexOf(fromId)];
+		const toTop = leafToTop[ids.indexOf(toId)];
+		if (/* @__PURE__ */ isUndefined(fromTop) || /* @__PURE__ */ isUndefined(toTop) || fromTop === toTop) return;
+		if (tops[fromTop]?.reorderable === false) return;
+		const id = cols.lookup(fromTop);
+		if (/* @__PURE__ */ isUndefined(id)) return;
+		cols.move(id, toTop);
+	}
+	function distribute(incoming) {
+		const tickets = /* @__PURE__ */ extractLeaves(cols.values());
+		if (incoming.length !== tickets.length) {
+			logger.warn(`createDataGrid: distribute() expected ${tickets.length} sizes but received ${incoming.length}; ignoring.`);
+			return;
+		}
+		const sum = incoming.reduce((acc, value) => acc + value, 0);
+		if (sum <= 0) {
+			logger.warn(`createDataGrid: distribute() received sizes summing to ${sum}; expected a positive total.`);
+			return;
+		}
+		const metas = tickets.map((ticket) => configs.get(String(ticket.id)) ?? DEFAULT_EXTRAS);
+		let current = incoming.map((value, i) => /* @__PURE__ */ clamp(value / sum * 100, metas[i].minSize, metas[i].maxSize));
+		let residual = 100 - current.reduce((acc, value) => acc + value, 0);
+		const max = tickets.length * 2;
+		for (let pass = 0; pass < max && Math.abs(residual) >= 1e-6; pass++) {
+			const room = current.map((value, i) => residual > 0 ? metas[i].maxSize - value : value - metas[i].minSize);
+			const available = room.reduce((acc, value) => acc + Math.max(0, value), 0);
+			if (available <= 0) break;
+			current = current.map((value, i) => room[i] <= 0 ? value : value + residual * (room[i] / available));
+			residual = 100 - current.reduce((acc, value) => acc + value, 0);
+		}
+		if (Math.abs(residual) >= 1e-6) logger.warn(`createDataGrid: distribute() could not reach 100 within min/max constraints (off by ${residual.toFixed(2)})`);
+		for (const [i, ticket] of tickets.entries()) sizes.set(String(ticket.id), current[i]);
+	}
+	function show(id) {
+		hidden.delete(id);
+	}
+	function hide(id) {
+		hidden.add(id);
+	}
+	function toggle(id) {
+		if (hidden.has(id)) hidden.delete(id);
+		else hidden.add(id);
+	}
+	function reset() {
+		for (const ticket of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const id = String(ticket.id);
+			sizes.set(id, share(id));
+		}
+		cols.reorder([...order]);
+		hidden.clear();
+		for (const ticket of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const id = String(ticket.id);
+			group.unselect(id);
+			group.unmix(id);
+		}
+		for (const [id, config] of configs) if (config.pinned === "left") group.select(id);
+		else if (config.pinned === "right") group.mix(id);
+	}
+	return {
+		pinned,
+		columns,
+		all: allColumns,
+		pin,
+		resize,
+		reorder,
+		distribute,
+		show,
+		hide,
+		toggle,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/createDataGrid/spanning.ts
+/**
+* @module createDataGrid/spanning
+*
+* @remarks
+* Computes a row span map from visible items. For each cell, determines
+* rowSpan and whether it's hidden (covered by a span from a previous row).
+* Spans do not cross page boundaries. Each row is addressed by a key: either a
+* `key(item, index)` projection (the grid passes the registry ticket id) or,
+* absent that, the row's `itemKey` value. Rows whose resolved key is
+* `undefined` cannot be addressed in the resulting map and are skipped.
+*
+* @internal Consumed only by `createDataGrid`. Fully decoupled (items ref +
+* columns + key + span fn — no grid/table types), so it is a latent composable.
+* Promote it to a standalone `createRowSpanning/` composable on a second
+* consumer. See `.claude/rules/composables.md` §"Sub-modules: inline, private
+* sibling, or promote".
+*/
+/**
+* Computes a row span map from visible items.
+*
+* @param options Row spanning configuration
+* @returns A computed map of item ID to column to SpanEntry
+*
+* @example
+* ```ts
+* const spans = createRowSpanning({
+*   items: computed(() => grid.items.value),
+*   columns: ['group', 'ticker', 'value'],
+*   span: (item, column) => column === 'group' ? 3 : 1,
+* })
+*
+* spans.value.get(id)?.get('group') // { rowSpan: 3, hidden: false }
+* ```
+*/
+function createRowSpanning(options) {
+	const { items, columns, key, itemKey = "id", span } = options;
+	return computed(() => {
+		const result = /* @__PURE__ */ new Map();
+		if (!span) return result;
+		const list = items.value;
+		const resolved = toValue(columns);
+		const covered = Array.from({ length: resolved.length }).fill(0);
+		for (let row = 0; row < list.length; row++) {
+			const item = list[row];
+			const id = key ? key(item, row) : item[itemKey];
+			if (/* @__PURE__ */ isUndefined(id)) continue;
+			const cells = /* @__PURE__ */ new Map();
+			for (const [col, column] of resolved.entries()) if (covered[col] > 0) {
+				cells.set(column, {
+					rowSpan: 1,
+					hidden: true
+				});
+				covered[col]--;
+			} else {
+				const raw = span(item, column);
+				const rowSpan = Math.min(Math.max(1, /* @__PURE__ */ isNaN(raw) ? 1 : raw), list.length - row);
+				cells.set(column, {
+					rowSpan,
+					hidden: false
+				});
+				if (rowSpan > 1) covered[col] = rowSpan - 1;
+			}
+			result.set(id, cells);
+		}
+		return result;
+	});
+}
+//#endregion
+//#region src/composables/createDataGrid/index.ts
+/**
+* @module createDataGrid
+*
+* @see https://0.vuetifyjs.com/composables/data/create-data-grid
+*
+* @remarks
+* Main factory that wires together column layout, cell editing, row ordering,
+* and row spanning on top of a createDataTable pipeline. Row ordering is
+* provided by a createSortable instance synced to the table's row registry
+* via register / unregister events; the ordered ids are applied post-sort,
+* pre-pagination by overriding the `items` projection.
+*
+* Rows are registered through the inherited registry surface (`register`,
+* `onboard`, `unregister`, `clear`) — they are not passed as an `items`
+* option to the factory.
+*
+* Follows the trinity pattern for dependency injection.
+*
+* @example
+* ```ts
+* const grid = createDataGrid()
+*
+* grid.columns.onboard([
+*   { id: 'name', sortable: true },
+*   { id: 'progress', editable: true },
+* ])
+*
+* grid.onboard(rows.map(value => ({ id: value.id, value })))
+* grid.layout.pin('name', 'left')
+* grid.editing.edit(row.id, 'progress')
+* ```
+*/
+/**
+* Creates a data grid instance with layout, editing, row ordering, and spanning
+* layered on top of the createDataTable pipeline.
+*
+* Rows live on the inherited registry surface — register them with
+* `grid.onboard(rows.map(value => ({ id: value.id, value })))` or
+* `grid.register({ id, value })`.
+*
+* @param options Data grid options
+* @returns Data grid context
+*
+* @example
+* ```ts
+* const grid = createDataGrid({ pagination: { initial: 1 } })
+*
+* grid.columns.onboard([
+*   { id: 'name', sortable: true },
+*   { id: 'progress', editable: true, validate: v => Number(v) >= 0 || 'must be positive' },
+* ])
+*
+* grid.onboard(rows.map(value => ({ id: value.id, value })))
+* grid.layout.pin('name', 'left')
+* grid.rows.move(rowId, 0)
+* grid.editing.edit(row.id, 'progress')
+* ```
+*/
+function createDataGrid(_options = {}) {
+	const { editing: editingOptions, preserveRowOrder = false, rowSpanning, ...options } = _options;
+	const table = createDataTable(options);
+	const sortable = createSortable({ reactive: true });
+	const dirty = shallowRef(false);
+	table.on("register:ticket", (ticket) => {
+		sortable.register({
+			id: ticket.id,
+			value: ticket.id
+		});
+	});
+	table.on("unregister:ticket", (ticket) => {
+		sortable.unregister(ticket.id);
+	});
+	table.on("clear:registry", () => {
+		sortable.clear();
+		dirty.value = false;
+	});
+	const order = toRef(() => sortable.keys());
+	const sortedIds = computed(() => {
+		const buckets = /* @__PURE__ */ new Map();
+		for (const ticket of table.values()) {
+			const value = ticket.value;
+			const queue = buckets.get(value);
+			if (queue) queue.push(ticket.id);
+			else buckets.set(value, [ticket.id]);
+		}
+		const ids = [];
+		for (const value of table.sortedItems.value) {
+			const id = buckets.get(value)?.shift();
+			if (!/* @__PURE__ */ isUndefined(id)) ids.push(id);
+		}
+		return ids;
+	});
+	function move(id, toIndex) {
+		if (!dirty.value) {
+			const sorted = sortedIds.value;
+			const seen = new Set(sorted);
+			const rest = sortable.keys().filter((key) => !seen.has(key));
+			sortable.reorder([...sorted, ...rest]);
+		}
+		sortable.move(id, toIndex);
+		dirty.value = true;
+	}
+	function reset() {
+		if (sortable.size > 0) sortable.reorder(table.keys());
+		dirty.value = false;
+	}
+	useToggleScope(() => !toValue(preserveRowOrder), () => {
+		watch(table.sort.columns, reset, { flush: "sync" });
+	});
+	const page = computed(() => {
+		if (!dirty.value) {
+			const start = table.pagination.pageStart.value;
+			return {
+				items: table.items.value,
+				ids: table.total.value > table.sortedItems.value.length ? sortedIds.value : sortedIds.value.slice(start, start + table.items.value.length)
+			};
+		}
+		const sorted = table.sortedItems.value;
+		const ids = sortedIds.value;
+		const byId = /* @__PURE__ */ new Map();
+		for (let i = 0; i < sorted.length; i++) byId.set(ids[i], sorted[i]);
+		const seen = new Set(order.value);
+		const items = [];
+		const ordered = [];
+		for (const id of order.value) {
+			const value = byId.get(id);
+			if (!/* @__PURE__ */ isUndefined(value)) {
+				items.push(value);
+				ordered.push(id);
+			}
+		}
+		for (const [i, element] of sorted.entries()) {
+			const id = ids[i];
+			if (!seen.has(id)) {
+				items.push(element);
+				ordered.push(id);
+			}
+		}
+		if (table.total.value > sorted.length) return {
+			items,
+			ids: ordered
+		};
+		const start = table.pagination.pageStart.value;
+		const stop = table.pagination.pageStop.value;
+		return {
+			items: items.slice(start, stop),
+			ids: ordered.slice(start, stop)
+		};
+	});
+	const pageOrderedItems = toRef(() => page.value.items);
+	const layout = createColumnLayout(table.columns);
+	function lookup(row) {
+		return table.get(row)?.value;
+	}
+	const editing = createCellEditing({
+		columns: () => table.leaves.value.filter((col) => col.editable === true || /* @__PURE__ */ isFunction(col.editable)).map((col) => ({
+			id: String(col.id),
+			editable: col.editable,
+			validate: col.validate
+		})),
+		lookup,
+		registry: table,
+		onEdit: editingOptions?.onEdit ? (row, column, value) => {
+			const item = lookup(row);
+			if (!/* @__PURE__ */ isUndefined(item)) editingOptions.onEdit(row, column, value, item);
+		} : void 0
+	});
+	const spans = createRowSpanning({
+		items: pageOrderedItems,
+		columns: () => table.leaves.value.map((col) => col.id),
+		key: (_item, index) => page.value.ids[index],
+		span(item, column) {
+			const col = table.leaves.value.find((leaf) => String(leaf.id) === column);
+			if (col && /* @__PURE__ */ isFunction(col.span)) return col.span(item);
+			return rowSpanning?.(item, column) ?? 1;
+		}
+	});
+	return {
+		...table,
+		items: pageOrderedItems,
+		layout,
+		rows: {
+			order,
+			move,
+			reset
+		},
+		editing,
+		spans,
+		get size() {
+			return table.size;
+		}
+	};
+}
+/**
+* Creates a data grid context with dependency injection support.
+*
+* @param options Data grid context options including namespace
+* @returns A trinity tuple: [useDataGridContext, provideDataGridContext, defaultContext]
+*
+* @example
+* ```ts
+* const [useDataGrid, provideDataGrid, grid] = createDataGridContext({
+*   namespace: 'v0:projects',
+* })
+*
+* grid.columns.onboard(columns)
+* grid.onboard(rows.map(value => ({ id: value.id, value })))
+* provideDataGrid()
+* const ctx = useDataGrid()
+* ```
+*/
+function createDataGridContext(_options = {}) {
+	const { namespace = "v0:data-grid", ...options } = _options;
+	const [useDataGridContext, _provideDataGridContext] = createContext(namespace);
+	const context = createDataGrid(options);
+	function provideDataGridContext(_context = context, app) {
+		return _provideDataGridContext(_context, app);
+	}
+	return createTrinity(useDataGridContext, provideDataGridContext, context);
+}
+/**
+* Returns the current data grid context from dependency injection.
+*
+* @param namespace The namespace for the data grid context. @default 'v0:data-grid'
+* @returns The current data grid context
+*
+* @example
+* ```ts
+* const grid = useDataGrid<Project>()
+*
+* grid.layout.pin('id', 'left')
+* grid.rows.reset()
+* ```
+*/
+function useDataGrid(namespace = "v0:data-grid") {
+	return useContext(namespace);
+}
+//#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,
+				id
+			});
+			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/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, ...options } = _options;
+	const logger = useLogger();
+	const errorRef = shallowRef(false);
+	const errorMessagesRef = shallowRef(void 0);
+	const input = createInput({
+		...options,
+		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/createTimeline/index.ts
+/**
+* @module createTimeline
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-timeline
+*
+* @remarks
+* Bounded undo/redo system with overflow management.
+*
+* Key features:
+* - Fixed-size history (default: 10 items)
+* - Undo/redo stack management
+* - Overflow queue (preserves oldest items)
+* - Automatic reindexing after operations
+* - 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.
+*
+* @param options The options for the timeline instance.
+* @template Z The type of the timeline ticket.
+* @template E The type of the timeline context.
+* @returns A new timeline instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-timeline
+*
+* @example
+* ```ts
+* import { useTimeline } from '@vuetify/v0'
+*
+* const timeline = useTimeline({ size: 3 })
+*
+* timeline.onboard([{ id: 'one' }, { id: 'two' }, { id: 'three' }])
+*
+* console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }, { id: 'three' }]
+*
+* timeline.undo()
+* console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }]
+*
+* timeline.redo()
+* console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }, { id: 'three' }]
+* ```
+*/
+function createTimeline(_options = {}) {
+	const { size: _size = 10, ...options } = _options;
+	const size = /* @__PURE__ */ isNaN(_size) ? 10 : Math.max(1, Math.floor(_size));
+	const registry = createRegistry(options);
+	const stack = [];
+	const overflow = [];
+	function register(item) {
+		stack.length = 0;
+		if (registry.size < size) return registry.register({ ...item });
+		const removing = registry.seek("first");
+		if (overflow.length === size) overflow.shift();
+		overflow.push(removing);
+		registry.unregister(removing.id);
+		const ticket = registry.register({ ...item });
+		registry.reindex();
+		return ticket;
+	}
+	function undo() {
+		const item = registry.seek("last");
+		if (!item) return void 0;
+		stack.push(item);
+		registry.unregister(item.id);
+		const restored = overflow.pop();
+		if (restored) {
+			const remaining = registry.values();
+			registry.clear();
+			registry.onboard([restored, ...remaining]);
+			registry.reindex();
+		}
+		return item;
+	}
+	function redo() {
+		if (stack.length === 0) return void 0;
+		const item = stack.pop();
+		if (registry.size >= size) {
+			const oldest = registry.seek("first");
+			if (overflow.length === size) overflow.shift();
+			overflow.push(oldest);
+			registry.unregister(oldest.id);
+		}
+		const ticket = registry.register(item);
+		registry.reindex();
+		return ticket;
+	}
+	return {
+		...registry,
+		register,
+		undo,
+		redo,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new timeline context.
+*
+* @param options The options for the timeline context.
+* @template Z The type of the timeline ticket.
+* @template E The type of the timeline context.
+* @returns A new timeline context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-timeline
+*
+* @example
+* ```ts
+* import { createTimelineContext } from '@vuetify/v0'
+*
+* // With default namespace 'v0:timeline'
+* export const [useTimeline, provideTimeline, context] = createTimelineContext({ size: 5 })
+*
+* context.register({ id: 'example' })
+*
+* // In a parent component
+* provideTimeline()
+*
+* // In a child component
+* const timeline = useTimeline()
+*
+* console.log(timeline.values()) // [{ id: 'example' }]
+* ```
+*/
+function createTimelineContext(_options = {}) {
+	const { namespace = "v0:timeline", ...options } = _options;
+	return createTrinity(namespace, createTimeline(options));
+}
+/**
+* Returns the current timeline instance.
+*
+* @param namespace The namespace for the timeline context. Defaults to `'v0:timeline'`.
+* @returns The current timeline instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-timeline
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useTimeline } from '@vuetify/v0'
+*
+*   const timeline = useTimeline()
+* <\/script>
+* ```
+*/
+function useTimeline(namespace = "v0:timeline") {
+	return useContext(namespace);
+}
+//#endregion
+//#region src/composables/createVirtual/index.ts
+/**
+* @module createVirtual
+*
+* @see https://0.vuetifyjs.com/composables/data/create-virtual
+*
+* @remarks
+* Virtual scrolling composable for efficiently rendering large lists.
+*
+* Key features:
+* - Trinity pattern for dependency injection (`createVirtualContext`, `useVirtual`)
+* - Renders only visible items (viewport + overscan)
+* - Dynamic or fixed item heights
+* - SSR-safe (checks IN_BROWSER)
+* - Bidirectional scrolling (forward/reverse for chat apps)
+* - Scroll anchoring (maintains position across data changes)
+* - Edge detection for infinite scroll
+* - iOS momentum and elastic scrolling
+* - Configurable overscan (extra items rendered for smooth scrolling)
+*
+* Perfect for large data sets, chat apps, and infinite scroll implementations.
+*
+* @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
+*
+* @param items Reactive array of items to virtualize
+* @param options Configuration options
+* @returns Virtual scrolling context
+*
+* @see https://0.vuetifyjs.com/composables/data/create-virtual
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { createVirtual } from '@vuetify/v0'
+*
+*   const items = ref(Array.from({ length: 10000 }, (_, i) => ({ id: i, name: `Item ${i}` })))
+*   const virtual = createVirtual(items)
+* <\/script>
+*
+* <template>
+*   <div
+*     ref="virtual.element"
+*     style="height: 600px; overflow-y: auto;"
+*     @scroll="virtual.scroll"
+*   >
+*     <div :style="{ height: `${virtual.offset.value}px` }" />
+*
+*     <div v-for="item in virtual.items.value" :key="item.index">
+*       {{ item.raw.name }}
+*     </div>
+*
+*     <div :style="{ height: `${virtual.size.value}px` }" />
+*   </div>
+* </template>
+* ```
+*/
+const FALLBACK_HEIGHT = 40;
+function createVirtual(items, _options = {}) {
+	const { itemHeight: _itemHeight, height, overscan = 5, direction = "forward", anchor = "auto", anchorSmooth = true, onStartReached, onEndReached, startThreshold = 0, endThreshold = 0, momentum: momentumOption, elastic: elasticOption } = _options;
+	const element = ref();
+	const itemHeight = shallowRef(Number.parseFloat(String(_itemHeight || 0)));
+	function estimate() {
+		return itemHeight.value || FALLBACK_HEIGHT;
+	}
+	const heights = shallowRef([]);
+	const offsets = shallowRef([]);
+	const first = shallowRef(0);
+	const last = shallowRef(0);
+	const offset = shallowRef(0);
+	const size = shallowRef(0);
+	const viewportHeight = shallowRef(0);
+	const state = shallowRef("ok");
+	const isIOS = IN_BROWSER && /iPad|iPhone|iPod/.test(navigator.userAgent);
+	const momentum = momentumOption ?? isIOS;
+	const elastic = elasticOption ?? isIOS;
+	let raf = -1;
+	let rebuildRaf = -1;
+	let edgeRaf = -1;
+	const cachedViewport = Number.parseInt(String(height)) || 0;
+	let anchorIndex = -1;
+	let anchorOffset = 0;
+	const computedItems = computed(() => items.value.slice(first.value, last.value).map((item, i) => ({
+		raw: item,
+		index: i + first.value
+	})));
+	watch(element, (el) => {
+		if (!IN_BROWSER || !el?.style) return;
+		/* v8 ignore start -- browser-only style assignments */
+		if (momentum) el.style.webkitOverflowScrolling = "touch";
+		if (!elastic) el.style.overscrollBehavior = "none";
+		/* 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();
+	});
+	watch(items, (newItems) => {
+		captureAnchor();
+		const length = newItems.length;
+		const old = heights.value;
+		const newHeights = old.length === length ? old : Array.from({ length }, (_, i) => i < old.length ? old[i] : null);
+		if (heights.value !== newHeights) heights.value = newHeights;
+		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;
+			const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || estimate());
+			element.value.scrollTop = totalHeight;
+		}
+		update();
+	});
+	function captureAnchor() {
+		if (!element.value || anchor === "auto") return;
+		if (anchor === "start") {
+			anchorIndex = 0;
+			anchorOffset = 0;
+		} else if (anchor === "end") {
+			anchorIndex = items.value.length - 1;
+			anchorOffset = 0;
+		} else if (/* @__PURE__ */ isFunction(anchor)) {
+			const result = anchor(items.value);
+			/* 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);
+			}
+		} else {
+			/* v8 ignore start -- default anchor capture */
+			anchorIndex = first.value;
+			anchorOffset = element.value.scrollTop - (offsets.value[first.value] || 0);
+		}
+	}
+	function restoreAnchor() {
+		if (!element.value || anchorIndex < 0) return;
+		const newScrollTop = (offsets.value[anchorIndex] || 0) + anchorOffset;
+		if (anchorSmooth && direction === "forward") element.value.scrollTo({
+			top: newScrollTop,
+			behavior: "smooth"
+		});
+		else element.value.scrollTop = newScrollTop;
+		/* v8 ignore stop */
+		anchorIndex = -1;
+		anchorOffset = 0;
+	}
+	function rebuild() {
+		const length = items.value.length;
+		const newOffsets = offsets.value.length === length ? offsets.value : Array.from({ length });
+		let offset = 0;
+		for (let i = 0; i < length; i++) {
+			newOffsets[i] = offset;
+			offset += heights.value[i] || estimate();
+		}
+		if (offsets.value !== newOffsets) offsets.value = newOffsets;
+		update();
+		restoreAnchor();
+	}
+	function findIndex(scrollTop) {
+		const arr = offsets.value;
+		if (arr.length === 0) return 0;
+		let low = 0;
+		let high = arr.length - 1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			if (arr[mid] <= scrollTop) low = mid + 1;
+			else high = mid - 1;
+		}
+		return Math.max(0, high);
+	}
+	function update() {
+		if (!element.value) return;
+		const viewport = viewportHeight.value || cachedViewport;
+		if (!viewport) return;
+		const scrollTop = element.value.scrollTop || 0;
+		const length = items.value.length;
+		const visibleStart = findIndex(scrollTop);
+		const visibleEnd = findIndex(scrollTop + viewport) + 1;
+		const start = /* @__PURE__ */ clamp(visibleStart - overscan, 0, length);
+		const end = /* @__PURE__ */ clamp(visibleEnd + overscan, start, length);
+		first.value = start;
+		last.value = end;
+		offset.value = offsets.value[start] || 0;
+		const lastIndex = length - 1;
+		const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || estimate());
+		size.value = totalHeight - (offsets.value[end] || totalHeight);
+	}
+	function checkEdges() {
+		if (!element.value) return;
+		const scrollTop = element.value.scrollTop;
+		const scrollHeight = element.value.scrollHeight;
+		const clientHeight = element.value.clientHeight;
+		const distanceFromStart = scrollTop;
+		const distanceFromEnd = scrollHeight - (scrollTop + clientHeight);
+		if (IN_BROWSER) {
+			cancelAnimationFrame(edgeRaf);
+			edgeRaf = requestAnimationFrame(() => {
+				if (onStartReached && distanceFromStart <= startThreshold) onStartReached(distanceFromStart);
+				if (onEndReached && distanceFromEnd <= endThreshold) onEndReached(distanceFromEnd);
+			});
+		} else {
+			if (onStartReached && distanceFromStart <= startThreshold) onStartReached(distanceFromStart);
+			if (onEndReached && distanceFromEnd <= endThreshold) onEndReached(distanceFromEnd);
+		}
+		/* 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);
+			rebuildRaf = requestAnimationFrame(rebuild);
+		} else rebuild();
+		/* v8 ignore stop */
+	}
+	function scroll() {
+		if (IN_BROWSER) {
+			cancelAnimationFrame(raf);
+			raf = requestAnimationFrame(update);
+			checkEdges();
+		} else update();
+		/* 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";
+		const block = scrollOptions?.block ?? "start";
+		const extraOffset = scrollOptions?.offset ?? 0;
+		let scrollTop = targetOffset + extraOffset;
+		switch (block) {
+			case "center": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const itemH = heights.value[index] || estimate();
+				scrollTop = targetOffset - viewport / 2 + itemH / 2 + extraOffset;
+				break;
+			}
+			case "end": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const itemH = heights.value[index] || estimate();
+				scrollTop = targetOffset - viewport + itemH + extraOffset;
+				break;
+			}
+			case "nearest": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const currentScroll = element.value.scrollTop;
+				const itemH = heights.value[index] || estimate();
+				if (targetOffset < currentScroll) scrollTop = targetOffset + extraOffset;
+				else if (targetOffset + itemH > currentScroll + viewport) scrollTop = targetOffset - viewport + itemH + extraOffset;
+				else return;
+				break;
+			}
+		}
+		if (behavior === "smooth") element.value.scrollTo({
+			top: scrollTop,
+			behavior: "smooth"
+		});
+		else element.value.scrollTop = scrollTop;
+		update();
+	}
+	function reset() {
+		state.value = "ok";
+		anchorIndex = -1;
+		anchorOffset = 0;
+		if (element.value && direction === "reverse" && items.value.length > 0) {
+			const lastIndex = items.value.length - 1;
+			const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || estimate());
+			element.value.scrollTop = totalHeight;
+		}
+	}
+	onScopeDispose(() => {
+		if (!IN_BROWSER) return;
+		cancelAnimationFrame(raf);
+		cancelAnimationFrame(rebuildRaf);
+		cancelAnimationFrame(edgeRaf);
+	}, true);
+	return {
+		element,
+		items: computedItems,
+		offset: readonly(offset),
+		size: readonly(size),
+		state,
+		scrollTo,
+		scroll,
+		scrollend: scroll,
+		resize,
+		reset
+	};
+}
+/**
+* Creates a virtual scrolling context with dependency injection support.
+*
+* @param items Reactive array of items to virtualize
+* @param options Configuration options including namespace
+* @template T The type of the items
+* @returns Trinity tuple: [useVirtual, provideVirtual, defaultVirtual]
+*
+* @see https://0.vuetifyjs.com/composables/data/create-virtual
+*
+* @example
+* ```ts
+* // Create injectable context
+* const [useVirtual, provideVirtual, virtual] = createVirtualContext(items, {
+*   namespace: 'my-virtual',
+*   overscan: 10,
+* })
+*
+* // In parent component
+* provideVirtual()
+*
+* // In child component
+* const virtual = useVirtual()
+* ```
+*/
+function createVirtualContext(items, _options = {}) {
+	const { namespace = "v0:virtual", ...options } = _options;
+	return createTrinity(namespace, createVirtual(items, options));
+}
+/**
+* Returns the current virtual context from dependency injection.
+*
+* @param namespace The namespace for the virtual context. Defaults to `v0:virtual`.
+* @template T The type of the items
+* @returns The current virtual context.
+*
+* @throws An error if the virtual context is not found and no default is provided.
+*
+* @see https://0.vuetifyjs.com/composables/data/create-virtual
+*
+* @example
+* ```vue
+* <script lang="ts" setup>
+*   import { createVirtual } from '@vuetify/v0'
+*
+*   // Inject virtual context provided by parent
+*   const virtual = useVirtual()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Visible items: {{ virtual.items.value.length }}</p>
+*   </div>
+* </template>
+* ```
+*/
+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
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-reactive
+*
+* @remarks
+* Utility function to convert values and refs into reactive proxies with ref unwrapping.
+*
+* Key features:
+* - Automatic ref unwrapping
+* - Deep reactive proxying
+* - Map and Set support with ref unwrapping
+* - Nested object/array reactivity
+* - 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;
+	const mapHandlers = {
+		get: (key) => unref(refObject.value.get(key)),
+		set: (key, value) => {
+			const map = refObject.value;
+			const existingValue = map.get(key);
+			if (isRef(existingValue)) existingValue.value = unref(value);
+			else map.set(key, value);
+			return mapProxy;
+		},
+		has: (key) => refObject.value.has(key),
+		delete: (key) => refObject.value.delete(key),
+		clear: () => refObject.value.clear(),
+		keys: () => refObject.value.keys(),
+		*values() {
+			for (const value of refObject.value.values()) yield unref(value);
+		},
+		*entries() {
+			for (const [key, value] of refObject.value.entries()) yield [key, unref(value)];
+		},
+		forEach: (callback, thisArg) => {
+			for (const [key, value] of refObject.value.entries()) callback.call(thisArg, unref(value), key, mapProxy);
+		}
+	};
+	mapHandlers[Symbol.iterator] = mapHandlers.entries;
+	mapProxy = new Proxy(/* @__PURE__ */ new Map(), { get(_, p) {
+		if (p === "size") return refObject.value.size;
+		if (Object.prototype.hasOwnProperty.call(mapHandlers, p)) return mapHandlers[p];
+		const map = refObject.value;
+		const value = Reflect.get(map, p);
+		return /* @__PURE__ */ isFunction(value) ? value.bind(map) : value;
+	} });
+	return reactive(mapProxy);
+}
+function createSetProxy(refObject) {
+	let setProxy;
+	const setHandlers = {
+		add: (value) => {
+			refObject.value.add(value);
+			return setProxy;
+		},
+		has: (value) => refObject.value.has(value),
+		delete: (value) => refObject.value.delete(value),
+		clear: () => refObject.value.clear(),
+		*keys() {
+			for (const value of refObject.value.values()) yield unref(value);
+		},
+		*values() {
+			for (const value of refObject.value.values()) yield unref(value);
+		},
+		*entries() {
+			for (const value of refObject.value.values()) {
+				const unreffedValue = unref(value);
+				yield [unreffedValue, unreffedValue];
+			}
+		},
+		forEach: (callback, thisArg) => {
+			for (const value of refObject.value) {
+				const unreffedValue = unref(value);
+				callback.call(thisArg, unreffedValue, unreffedValue, setProxy);
+			}
+		}
+	};
+	setHandlers[Symbol.iterator] = setHandlers.values;
+	setProxy = new Proxy(/* @__PURE__ */ new Set(), { get(_, p) {
+		if (p === "size") return refObject.value.size;
+		if (Object.prototype.hasOwnProperty.call(setHandlers, p)) return setHandlers[p];
+		const set = refObject.value;
+		const value = Reflect.get(set, p);
+		return /* @__PURE__ */ isFunction(value) ? value.bind(set) : value;
+	} });
+	return reactive(setProxy);
+}
+function createObjectProxy(refObject) {
+	return reactive(new Proxy({}, {
+		get(_, p, receiver) {
+			return unref(Reflect.get(refObject.value, p, receiver));
+		},
+		set(_, p, value) {
+			return Reflect.set(refObject.value, p, value);
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(refObject.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(refObject.value, p);
+		},
+		ownKeys() {
+			return Reflect.ownKeys(refObject.value);
+		},
+		getOwnPropertyDescriptor(_, p) {
+			const desc = Reflect.getOwnPropertyDescriptor(refObject.value, p);
+			if (!desc) return;
+			const newDesc = {
+				configurable: true,
+				enumerable: desc.enumerable
+			};
+			if ("value" in desc) {
+				newDesc.value = unref(desc.value);
+				newDesc.writable = desc.writable;
+			} else {
+				newDesc.get = desc.get;
+				newDesc.set = desc.set;
+			}
+			return newDesc;
+		}
+	}));
+}
+/**
+* Converts a `MaybeRef` to a `UnwrapNestedRefs`.
+*
+* @param objectRef The object to convert.
+* @template Z The type of the object.
+* @returns The converted object.
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-reactive
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { toReactive } from '@vuetify/v0'
+*
+* const state = ref({ name: 'John', age: 30 })
+* const rstate = toReactive(state)
+*
+* console.log(rstate.name) // John
+* ```
+*/
+function toReactive(objectRef) {
+	if (!isRef(objectRef)) return reactive(objectRef);
+	const refObject = objectRef;
+	const target = refObject.value;
+	if (target instanceof Map) return createMapProxy(refObject);
+	if (target instanceof Set) return createSetProxy(refObject);
+	return createObjectProxy(refObject);
+}
+//#endregion
+//#region src/composables/useBreakpoints/index.ts
+/**
+* @module useBreakpoints
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+*
+* @remarks
+* Responsive breakpoint detection composable with window resize handling.
+*
+* Key features:
+* - matchMedia-based detection for zoom-accurate breakpoints
+* - Six built-in breakpoints (xs, sm, md, lg, xl, xxl) with Vuetify 4 default widths
+* - `isMobile` flag and configurable `mobileBreakpoint`
+* - Automatic resize listener with cleanup
+* - SSR-safe with hydration flush
+* - 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.
+*
+* @returns The default breakpoint configuration object.
+*/
+function createDefaultBreakpoints() {
+	return {
+		mobileBreakpoint: "lg",
+		breakpoints: {
+			xs: 0,
+			sm: 600,
+			md: 840,
+			lg: 1145,
+			xl: 1545,
+			xxl: 2138
+		}
+	};
+}
+/**
+* Creates a new breakpoints instance.
+*
+* @param options The options for the breakpoints instance.
+* @returns A new breakpoints instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+*
+* @example
+* ```ts
+* import { createBreakpoints } from '@vuetify/v0'
+*
+* const breakpoints = createBreakpoints({
+*   namespace: 'v0:breakpoints',
+*   mobileBreakpoint: 'md',
+*   breakpoints: {
+*     xs: 0,
+*     sm: 600,
+*     md: 840,
+*     lg: 1145,
+*     xl: 1545,
+*     xxl: 2138,
+*   },
+* })
+* ```
+*/
+function createBreakpoints(_options = {}) {
+	const { ssr, ...options } = _options;
+	const { mobileBreakpoint, breakpoints } = /* @__PURE__ */ mergeDeep(createDefaultBreakpoints(), options);
+	const sorted = Object.entries(breakpoints).toSorted((a, b) => a[1] - b[1]);
+	const names = sorted.map(([n]) => n);
+	const mb = /* @__PURE__ */ isNumber(mobileBreakpoint) ? mobileBreakpoint : breakpoints[mobileBreakpoint] ?? breakpoints.md;
+	const initialWidth = ssr ? ssr.clientWidth : IN_BROWSER ? window.innerWidth : 0;
+	const initialHeight = ssr ? ssr.clientHeight ?? 0 : IN_BROWSER ? window.innerHeight : 0;
+	let initialName = "xs";
+	for (let i = sorted.length - 1; i >= 0; i--) if (initialWidth >= sorted[i][1]) {
+		initialName = sorted[i][0];
+		break;
+	}
+	const initialIndex = names.indexOf(initialName);
+	const name = shallowRef(initialName);
+	const width = shallowRef(initialWidth);
+	const height = shallowRef(initialHeight);
+	const isMobile = shallowRef(initialWidth < mb);
+	const xs = shallowRef(initialIndex === 0);
+	const sm = shallowRef(initialIndex === 1);
+	const md = shallowRef(initialIndex === 2);
+	const lg = shallowRef(initialIndex === 3);
+	const xl = shallowRef(initialIndex === 4);
+	const xxl = shallowRef(initialIndex === 5);
+	const smAndUp = shallowRef(initialIndex >= 1);
+	const mdAndUp = shallowRef(initialIndex >= 2);
+	const lgAndUp = shallowRef(initialIndex >= 3);
+	const xlAndUp = shallowRef(initialIndex >= 4);
+	const smAndDown = shallowRef(initialIndex <= 1);
+	const mdAndDown = shallowRef(initialIndex <= 2);
+	const lgAndDown = shallowRef(initialIndex <= 3);
+	const xlAndDown = shallowRef(initialIndex <= 4);
+	function update() {
+		if (!IN_BROWSER) return;
+		width.value = window.innerWidth;
+		height.value = window.innerHeight;
+		let current = "xs";
+		for (let i = sorted.length - 1; i >= 0; i--) {
+			const px = sorted[i][1];
+			if (SUPPORTS_MATCH_MEDIA ? window.matchMedia(`(min-width: ${px}px)`).matches : width.value >= px) {
+				current = sorted[i][0];
+				break;
+			}
+		}
+		name.value = current;
+		const index = names.indexOf(current);
+		isMobile.value = /* @__PURE__ */ isNumber(mb) ? SUPPORTS_MATCH_MEDIA ? !window.matchMedia(`(min-width: ${mb}px)`).matches : width.value < mb : index < names.indexOf(mobileBreakpoint);
+		xs.value = index === 0;
+		sm.value = index === 1;
+		md.value = index === 2;
+		lg.value = index === 3;
+		xl.value = index === 4;
+		xxl.value = index === 5;
+		smAndUp.value = index >= 1;
+		mdAndUp.value = index >= 2;
+		lgAndUp.value = index >= 3;
+		xlAndUp.value = index >= 4;
+		smAndDown.value = index <= 1;
+		mdAndDown.value = index <= 2;
+		lgAndDown.value = index <= 3;
+		xlAndDown.value = index <= 4;
+	}
+	return {
+		breakpoints,
+		mobileBreakpoint,
+		name: readonly(name),
+		width: readonly(width),
+		height: readonly(height),
+		isMobile: readonly(isMobile),
+		xs: readonly(xs),
+		sm: readonly(sm),
+		md: readonly(md),
+		lg: readonly(lg),
+		xl: readonly(xl),
+		xxl: readonly(xxl),
+		smAndUp: readonly(smAndUp),
+		mdAndUp: readonly(mdAndUp),
+		lgAndUp: readonly(lgAndUp),
+		xlAndUp: readonly(xlAndUp),
+		smAndDown: readonly(smAndDown),
+		mdAndDown: readonly(mdAndDown),
+		lgAndDown: readonly(lgAndDown),
+		xlAndDown: readonly(xlAndDown),
+		ssr: !!ssr,
+		update
+	};
+}
+function createBreakpointsFallback(options = {}) {
+	if (options.ssr) return createBreakpoints(options);
+	const defaults = createDefaultBreakpoints();
+	return {
+		breakpoints: defaults.breakpoints,
+		mobileBreakpoint: defaults.mobileBreakpoint,
+		name: readonly(shallowRef("xs")),
+		width: readonly(shallowRef(0)),
+		height: readonly(shallowRef(0)),
+		isMobile: readonly(shallowRef(true)),
+		xs: readonly(shallowRef(true)),
+		sm: readonly(shallowRef(false)),
+		md: readonly(shallowRef(false)),
+		lg: readonly(shallowRef(false)),
+		xl: readonly(shallowRef(false)),
+		xxl: readonly(shallowRef(false)),
+		smAndUp: readonly(shallowRef(false)),
+		mdAndUp: readonly(shallowRef(false)),
+		lgAndUp: readonly(shallowRef(false)),
+		xlAndUp: readonly(shallowRef(false)),
+		smAndDown: readonly(shallowRef(true)),
+		mdAndDown: readonly(shallowRef(true)),
+		lgAndDown: readonly(shallowRef(true)),
+		xlAndDown: readonly(shallowRef(true)),
+		ssr: false,
+		update: () => {}
+	};
+}
+const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = createPluginContext("v0:breakpoints", (options) => createBreakpoints(options), {
+	fallback: () => createBreakpointsFallback(),
+	setup: (context, app, _options) => {
+		if (IN_BROWSER && !_options?.ssr) context.update();
+		const { mount } = app;
+		app.mount = (...args) => {
+			const vm = mount(...args);
+			const hydration = useHydration();
+			function listener() {
+				context.update();
+			}
+			const unwatch = watch(hydration.isHydrated, (hydrated) => {
+				if (hydrated) listener();
+			}, { immediate: true });
+			const cleanup = useWindowEventListener("resize", listener, { passive: true });
+			onScopeDispose(() => {
+				cleanup();
+				unwatch();
+			}, true);
+			app.mount = mount;
+			return vm;
+		};
+	}
+});
+//#endregion
+//#region src/composables/useDate/index.ts
+/**
+* @module useDate
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @remarks
+* Date manipulation composable with adapter pattern for date operations.
+*
+* Key features:
+* - Adapter pattern for date library abstraction
+* - Locale-aware formatting via Intl.DateTimeFormat
+* - `firstDayOfWeek` derived from locale and propagated to adapter
+* - Integration with useLocale for automatic locale sync
+*
+* @example Using the built-in Temporal adapter
+* ```ts
+* import { V0DateAdapter } from '@vuetify/v0/date'
+* import { createDatePlugin } from '@vuetify/v0'
+*
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
+*
+* // In a component:
+* const { adapter } = useDate()
+* const today = adapter.date()
+* const formatted = adapter.format(today, 'fullDate')
+* ```
+*
+* @example Custom adapter
+* ```ts
+* import { DateAdapter } from '@vuetify/v0'
+*
+* class DateFnsAdapter extends DateAdapter<Date> {
+*   // ... implementation
+* }
+*
+* app.use(createDatePlugin({ adapter: new DateFnsAdapter() }))
+* ```
+*/
+/**
+* Default short locale codes mapped to full Intl locale strings.
+* Used when useLocale provides a short code without region (e.g., 'en' instead of 'en-US').
+*/
+const defaultLocales = {
+	en: "en-US",
+	es: "es-ES",
+	fr: "fr-FR",
+	de: "de-DE",
+	it: "it-IT",
+	pt: "pt-BR",
+	ja: "ja-JP",
+	ko: "ko-KR",
+	zh: "zh-CN",
+	ru: "ru-RU",
+	ar: "ar-SA"
+};
+/**
+* Derive firstDayOfWeek from an Intl locale string.
+* Returns 0-6 (0=Sun) or 0 as fallback.
+*/
+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;
+	}
+}
+/**
+* Creates a new date context.
+*
+* @param options Adapter and locale configuration.
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns A date context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* import { V0DateAdapter } from '@vuetify/v0/date'
+*
+* const { adapter } = createDate({ adapter: new V0DateAdapter() })
+* const today = adapter.date()
+*
+* // With locale options
+* const { adapter } = createDate({
+*   adapter: new V0DateAdapter(),
+*   locale: 'de-DE',
+* })
+* ```
+*/
+function createDate(options) {
+	const { locales = defaultLocales, adapter, locale: initialLocale, firstDayOfWeek: explicitFirstDay } = options;
+	let selectedId;
+	try {
+		if (/* @__PURE__ */ instanceExists()) selectedId = useLocale().selectedId;
+	} catch {}
+	const locale = computed(() => {
+		const selected = selectedId?.value;
+		if (!/* @__PURE__ */ isNullOrUndefined(selected)) {
+			const str = String(selected);
+			return str.includes("-") ? str : locales[str] ?? str;
+		}
+		const fallback = initialLocale ?? adapter.locale ?? "en-US";
+		return fallback.includes("-") ? fallback : locales[fallback] ?? fallback;
+	});
+	const firstDayOfWeek = computed(() => {
+		if (!/* @__PURE__ */ isUndefined(explicitFirstDay)) return explicitFirstDay;
+		const loc = locale.value;
+		return loc ? deriveFirstDayOfWeek(loc) : 0;
+	});
+	if (/* @__PURE__ */ instanceExists()) onScopeDispose(watchEffect(() => {
+		const loc = locale.value;
+		if (loc && adapter.locale !== loc) adapter.locale = loc;
+		const fdow = firstDayOfWeek.value;
+		if (adapter.firstDayOfWeek !== fdow) adapter.firstDayOfWeek = fdow;
+	}));
+	else {
+		const loc = locale.value;
+		if (loc && adapter.locale !== loc) adapter.locale = loc;
+		const fdow = firstDayOfWeek.value;
+		if (adapter.firstDayOfWeek !== fdow) adapter.firstDayOfWeek = fdow;
+	}
+	return {
+		adapter,
+		locale,
+		firstDayOfWeek
+	};
+}
+/**
+* Creates a new date context trinity.
+*
+* @param options Adapter, locale, and namespace configuration.
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns A trinity [useContext, provideContext, defaultContext].
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* import { V0DateAdapter } from '@vuetify/v0/date'
+*
+* const [useAppDate, provideAppDate] = createDateContext({
+*   adapter: new V0DateAdapter(),
+*   namespace: 'app:date',
+* })
+* ```
+*/
+function createDateContext(_options) {
+	const { namespace = "v0:date", ...options } = _options;
+	return createTrinity(namespace, createDate(options));
+}
+/**
+* Creates a new date plugin.
+*
+* @param options Adapter, locale, and namespace configuration.
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns A Vue plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* import { V0DateAdapter } from '@vuetify/v0/date'
+*
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
+*
+* // With locale options
+* app.use(createDatePlugin({
+*   adapter: new V0DateAdapter(),
+*   locale: 'de-DE',
+* }))
+* ```
+*/
+function createDatePlugin(_options) {
+	const { namespace = "v0:date", ...options } = _options;
+	const [, provideDateContext, context] = createDateContext({
+		namespace,
+		...options
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			provideDateContext(context, app);
+		}
+	});
+}
+/**
+* Returns the current date context.
+*
+* Requires `createDatePlugin` to be installed with an adapter.
+*
+* @param namespace The namespace to look up (defaults to 'v0:date').
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns The current date context.
+* @throws If called outside a component or without a date plugin installed.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* // main.ts
+* import { V0DateAdapter } from '@vuetify/v0/date'
+* import { createDatePlugin } from '@vuetify/v0'
+*
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
+* ```
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+* import { useDate } from '@vuetify/v0'
+*
+* const { adapter, locale } = useDate()
+* const today = adapter.date()
+* <\/script>
+* ```
+*/
+function useDate(namespace = "v0:date") {
+	if (!/* @__PURE__ */ instanceExists()) throw new V0Error("[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() }))", {
+		code: "V0_PLUGIN_MISSING",
+		plugin: "createDatePlugin"
+	});
+	return useContext(namespace);
+}
+//#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/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();
+			if (_zones.has(id)) return _zones.register(registration);
+			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",
+	esc: "escape",
+	spacebar: " ",
+	space: " ",
+	return: "enter",
+	del: "delete",
+	plus: "+",
+	slash: "/",
+	underscore: "_",
+	minus: "-",
+	hyphen: "-"
+};
+/* @__NO_SIDE_EFFECTS__ */
+function normalizeKey(key) {
+	const lowerKey = key.toLowerCase();
+	return keyAliasMap[lowerKey] ?? lowerKey;
+}
+//#endregion
+//#region src/composables/useHotkey/parsing.ts
+const logger = /* @__PURE__ */ useLogger();
+const MODIFIERS = [
+	"ctrl",
+	"shift",
+	"alt",
+	"meta",
+	"cmd"
+];
+/**
+* Splits a single combination string into individual key parts.
+*
+* A combination is a set of keys that must be pressed simultaneously.
+* e.g. `ctrl+k`, `shift+-`
+*
+* @param combination - The combination string to parse
+* @param isInternal - Whether this is an internal call (suppresses warnings)
+* @returns Object with keys array and separators array
+*/
+function splitKeyCombination(combination, isInternal = false) {
+	const emptyResult = {
+		keys: [],
+		separators: []
+	};
+	if (!combination) {
+		if (!isInternal) logger.warn("Invalid hotkey combination: empty string provided");
+		return emptyResult;
+	}
+	if (combination.length > 1 && [
+		"+",
+		"/",
+		"_"
+	].some((v) => combination.startsWith(v)) && ![
+		"++",
+		"//",
+		"__"
+	].some((v) => combination.startsWith(v)) || combination.includes("++") || combination.includes("//") || combination.includes("__") || combination === "+" || combination === "/" || combination === "_" || combination.length > 1 && (combination.endsWith("+") || combination.endsWith("/") || combination.endsWith("_")) && combination.at(-2) !== combination.at(-1) || combination === "++" || combination === "--" || combination === "__") {
+		if (!isInternal) logger.warn(`Invalid hotkey combination: "${combination}" has invalid structure`);
+		return emptyResult;
+	}
+	const keys = [];
+	const separators = [];
+	let buffer = "";
+	function flushBuffer(separator) {
+		if (buffer) {
+			if (separator) separators.push(separator);
+			keys.push(/* @__PURE__ */ normalizeKey(buffer));
+			buffer = "";
+		}
+	}
+	for (let i = 0; i < combination.length; i++) {
+		const char = combination[i];
+		const nextChar = combination[i + 1];
+		if ([
+			"+",
+			"/",
+			"_",
+			"-"
+		].includes(char))
+ /* v8 ignore start -- edge case: doubled special chars */
+		if (char === nextChar) {
+			flushBuffer(char);
+			keys.push(char);
+			i++;
+		} else if ([
+			"+",
+			"/",
+			"_"
+		].includes(char)) flushBuffer(char);
+		else buffer += char;
+		else buffer += char;
+	}
+	flushBuffer();
+	/* v8 ignore start -- edge case: invalid minus in combination */
+	if (keys.some((key) => key.length > 1 && key.includes("-") && key !== "--")) {
+		if (!isInternal) logger.warn(`Invalid hotkey combination: "${combination}" has invalid structure`);
+		return emptyResult;
+	}
+	if (keys.length === 0 && combination) return {
+		keys: [/* @__PURE__ */ normalizeKey(combination)],
+		separators
+	};
+	/* v8 ignore stop */
+	return {
+		keys,
+		separators
+	};
+}
+/**
+* Splits a hotkey string into its constituent combination groups.
+*
+* A sequence is a series of combinations that must be pressed in order.
+* e.g. `a-b`, `ctrl+k-p`
+*
+* @param str - The sequence string to parse
+* @returns Array of combination strings
+*/
+function splitKeySequence(str) {
+	if (!str) {
+		logger.warn("Invalid hotkey sequence: empty string provided");
+		return [];
+	}
+	const hasInvalidStart = str.startsWith("-") && ![
+		"-",
+		"---",
+		"--+"
+	].includes(str);
+	const hasInvalidEnd = str.endsWith("-") && !str.endsWith("+-") && !str.endsWith("_-") && str !== "-" && str !== "---";
+	if (hasInvalidStart || hasInvalidEnd) {
+		logger.warn(`Invalid hotkey sequence: "${str}" contains invalid combinations`);
+		return [];
+	}
+	const result = [];
+	let buffer = "";
+	let i = 0;
+	while (i < str.length) {
+		const char = str[i];
+		if (char === "-") {
+			const prevChar = str[i - 1] ?? "";
+			const prevPrevChar = i > 1 ? str[i - 2] : void 0;
+			if (["+", "_"].includes(prevChar) && !["+", "/"].includes(prevPrevChar ?? "")) {
+				buffer += char;
+				i++;
+			} else {
+				if (buffer) {
+					result.push(buffer);
+					buffer = "";
+				} else result.push("-");
+				i++;
+			}
+		} else {
+			buffer += char;
+			i++;
+		}
+	}
+	if (buffer) result.push(buffer);
+	const collapsed = [];
+	let minusCount = 0;
+	for (const part of result)
+ /* v8 ignore start -- edge case: minus collapsing */
+	if (part === "-") {
+		if (minusCount % 2 === 0) collapsed.push("-");
+		minusCount++;
+	} else {
+		minusCount = 0;
+		collapsed.push(part);
+	}
+	/* v8 ignore start -- edge case: invalid combination in sequence */
+	if (!collapsed.every((s) => splitKeyCombination(s, true).keys.length > 0)) {
+		logger.warn(`Invalid hotkey sequence: "${str}" contains invalid combinations`);
+		return [];
+	}
+	/* v8 ignore stop */
+	return collapsed;
+}
+//#endregion
+//#region src/composables/useHotkey/index.ts
+/**
+* @module useHotkey
+*
+* @see https://0.vuetifyjs.com/composables/system/use-hotkey
+*
+* @remarks
+* Hotkey listener composable with key combination and sequence support.
+*
+* Key features:
+* - Key combination support (`ctrl+k`, `shift+enter`)
+* - Key sequence support (`g-h` for GitHub-style shortcuts)
+* - Platform-aware modifiers (Mac: cmd→meta, others: cmd→ctrl)
+* - Input focus detection (skip when typing in inputs)
+* - Sequence timeout with automatic reset
+* - Key and symbol word alias normalization (`plus` → `+`, `esc` → `escape`, etc.)
+* - Pause/resume/stop functionality
+* - Automatic cleanup on scope disposal
+* - 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 ?? "");
+/**
+* A composable that listens for hotkey combinations and sequences.
+*
+* @param keys - The hotkey string (e.g., 'ctrl+k', 'g-h')
+* @param callback - The function to call when the hotkey is triggered
+* @param options - Configuration options
+* @returns An object with state refs and control methods
+*
+* @see https://0.vuetifyjs.com/composables/system/use-hotkey
+*
+* @example
+* ```ts
+* import { useHotkey } from '@vuetify/v0'
+*
+* // Simple combination
+* const { isActive, pause, resume } = useHotkey('ctrl+k', () => {
+*   console.log('Command palette opened')
+* })
+*
+* // Key sequence (GitHub-style)
+* useHotkey('g-h', () => console.log('Go home'))
+*
+* // With options
+* useHotkey('escape', closeModal, { inputs: true })
+*
+* // Pause/resume control
+* pause()  // Temporarily disable
+* resume() // Re-enable
+* ```
+*/
+function useHotkey(keys, callback, options = {}, _platform) {
+	const platformIsMac = _platform?.isMac ?? isMac;
+	const { event = "keydown", inputs = false, preventDefault = true, stopPropagation = false, sequenceTimeout = 1e3 } = options;
+	const isPaused = shallowRef(false);
+	const cleanup = shallowRef(null);
+	const isActive = toRef(() => !/* @__PURE__ */ isNull(cleanup.value));
+	let sequenceTimer;
+	let keyGroups = [];
+	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;
+		if (activeElement.tagName === "INPUT") {
+			const type = activeElement.type?.toLowerCase();
+			return [
+				"text",
+				"email",
+				"password",
+				"search",
+				"tel",
+				"url",
+				"number",
+				"date",
+				"datetime-local",
+				"time",
+				"month",
+				"week"
+			].includes(type);
+		}
+		return activeElement.tagName === "TEXTAREA" || activeElement.isContentEditable;
+	}
+	function resetSequence() {
+		groupIndex = 0;
+		clearTimeout(sequenceTimer);
+	}
+	function handler(e) {
+		const group = keyGroups[groupIndex];
+		if (!group || isInputFocused()) return;
+		if (!matchesKeyGroup(e, group, platformIsMac)) {
+			if (isSequence) resetSequence();
+			return;
+		}
+		if (toValue(stopPropagation)) e.stopPropagation();
+		if (toValue(preventDefault)) e.preventDefault();
+		if (!isSequence) {
+			callback(e);
+			return;
+		}
+		clearTimeout(sequenceTimer);
+		groupIndex++;
+		if (groupIndex === keyGroups.length) {
+			callback(e);
+			resetSequence();
+			return;
+		}
+		sequenceTimer = setTimeout(resetSequence, toValue(sequenceTimeout));
+	}
+	function setup() {
+		if (!IN_BROWSER || isPaused.value) return;
+		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;
+		resetSequence();
+		cleanup.value = useWindowEventListener(toValue(event), handler);
+	}
+	function dispose() {
+		if (cleanup.value) {
+			cleanup.value();
+			cleanup.value = null;
+		}
+		clearTimeout(sequenceTimer);
+		keyGroups = [];
+		isSequence = false;
+		groupIndex = 0;
+	}
+	function pause() {
+		isPaused.value = true;
+		dispose();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		dispose();
+	}
+	watch(() => toValue(keys), () => {
+		if (isPaused.value) return;
+		dispose();
+		setup();
+	}, { immediate: true });
+	watch(() => toValue(event), () => {
+		if (isPaused.value || !toValue(keys)) return;
+		dispose();
+		setup();
+	});
+	onScopeDispose(stop, true);
+	return {
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+function isModifier(key) {
+	return MODIFIERS.includes(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
+	};
+	let actualKey;
+	for (const part of parts) if (isModifier(part)) modifiers[part] = true;
+	else actualKey = part;
+	return {
+		modifiers,
+		actualKey
+	};
+}
+function matchesKeyGroup(e, group, platformIsMac) {
+	const { modifiers, actualKey } = parseKeyGroup(group);
+	const expectCtrl = modifiers.ctrl || !platformIsMac && (modifiers.cmd || modifiers.meta);
+	const expectMeta = platformIsMac && (modifiers.cmd || modifiers.meta);
+	const modifiersMatch = e.ctrlKey === expectCtrl && e.metaKey === expectMeta && e.shiftKey === modifiers.shift && e.altKey === modifiers.alt;
+	if (/* @__PURE__ */ isUndefined(actualKey)) return modifiersMatch;
+	return modifiersMatch && e.key.toLowerCase() === actualKey.toLowerCase();
+}
+//#endregion
+//#region src/composables/useMediaQuery/index.ts
+/**
+* @module useMediaQuery
+*
+* @see https://0.vuetifyjs.com/composables/system/use-media-query
+*
+* @remarks
+* Reactive media query composable with automatic cleanup.
+*
+* Key features:
+* - Synchronous matchMedia read on client mount (prevents FOUC)
+* - Window matchMedia integration
+* - Reactive query string support
+* - SSR-safe (returns false on server)
+* - Hydration-aware (defers client updates until hydrated)
+* - Automatic listener cleanup on scope disposal
+* - 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.
+*
+* @param query CSS media query string (reactive).
+* @returns The media query context.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-media-query
+*
+* @example
+* ```ts
+* // Static query
+* const { matches } = useMediaQuery('(prefers-color-scheme: dark)')
+*
+* // Dynamic query
+* const minWidth = ref(768)
+* const { matches } = useMediaQuery(() => `(min-width: ${minWidth.value}px)`)
+*
+* // Manual cleanup
+* const { matches, stop } = useMediaQuery('(hover: hover)')
+* stop() // Remove listener early
+* ```
+*/
+function useMediaQuery(query) {
+	const resolvedQuery = toRef(() => toValue(query));
+	const initialQuery = toValue(query);
+	const initialMql = IN_BROWSER && SUPPORTS_MATCH_MEDIA ? window.matchMedia(initialQuery) : null;
+	const matches = shallowRef(initialMql?.matches ?? false);
+	const mediaQueryList = shallowRef(initialMql);
+	const hydration = useHydration();
+	let cleanup = null;
+	function listen() {
+		if (!IN_BROWSER || !SUPPORTS_MATCH_MEDIA) return;
+		cleanup?.();
+		cleanup = null;
+		const mql = window.matchMedia(resolvedQuery.value);
+		mediaQueryList.value = mql;
+		matches.value = mql.matches;
+		function handler(e) {
+			matches.value = e.matches;
+		}
+		mql.addEventListener("change", handler);
+		cleanup = () => mql.removeEventListener("change", handler);
+	}
+	const stopWatch = watch([resolvedQuery, () => hydration.isHydrated.value], ([_, hydrated]) => {
+		if (hydrated) listen();
+	}, { immediate: true });
+	function stop() {
+		stopWatch();
+		cleanup?.();
+		cleanup = null;
+	}
+	onScopeDispose(stop, true);
+	return {
+		matches: shallowReadonly(matches),
+		query: resolvedQuery,
+		mediaQueryList: shallowReadonly(mediaQueryList),
+		stop
+	};
+}
+/**
+* Check if the user prefers dark color scheme.
+*
+* @returns The media query context.
+*
+* @example
+* ```ts
+* const { matches: prefersDark } = usePrefersDark()
+* ```
+*/
+function usePrefersDark() {
+	return useMediaQuery("(prefers-color-scheme: dark)");
+}
+/**
+* Check if the user prefers reduced motion.
+*
+* @returns The media query context.
+*
+* @example
+* ```ts
+* const { matches: prefersReducedMotion } = usePrefersReducedMotion()
+* ```
+*/
+function usePrefersReducedMotion() {
+	return useMediaQuery("(prefers-reduced-motion: reduce)");
+}
+/**
+* Check if the user prefers more contrast.
+*
+* @returns The media query context.
+*
+* @example
+* ```ts
+* const { matches: prefersContrast } = usePrefersContrast()
+* ```
+*/
+function usePrefersContrast() {
+	return useMediaQuery("(prefers-contrast: more)");
+}
+//#endregion
+//#region src/composables/useReducedMotion/adapters/adapter.ts
+var ReducedMotionAdapter = class {
+	/**
+	* Teardown for any side-effects started in `setup`. The plugin registers this on
+	* `app.onUnmount`, so adapter effects are cleaned up even though `setup` runs
+	* outside an effect scope (where `onScopeDispose` would silently no-op). It is
+	* read lazily at app unmount, so adapters may assign it at any point during or
+	* after `setup`.
+	*/
+	dispose;
+};
+//#endregion
+//#region src/composables/useReducedMotion/adapters/v0.ts
+function payload(reduced) {
+	return reduced ? "reduce" : "no-preference";
+}
+/**
+* Default reduced-motion adapter. In the browser it writes
+* `document.body.dataset.reducedMotion`; on the server it renders the same
+* attribute through `@unhead` so the value is present in the initial HTML.
+*/
+var V0ReducedMotionAdapter = class extends ReducedMotionAdapter {
+	setup(app, context) {
+		if (IN_BROWSER) {
+			function sync(reduced) {
+				document.body.dataset.reducedMotion = payload(reduced);
+			}
+			sync(context.isReduced.value);
+			this.dispose = watch(context.isReduced, sync);
+		} else {
+			const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
+			if (head?.push) {
+				const entry = head.push({ bodyAttrs: { "data-reduced-motion": payload(context.isReduced.value) } });
+				const stop = watch(context.isReduced, (reduced) => entry.patch?.({ bodyAttrs: { "data-reduced-motion": payload(reduced) } }));
+				this.dispose = () => {
+					stop();
+					entry.dispose?.();
+				};
+			}
+		}
+	}
+};
+//#endregion
+//#region src/composables/useReducedMotion/index.ts
+/**
+* @module useReducedMotion
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-reduced-motion
+*
+* @remarks
+* Reduced-motion plugin composable for respecting or overriding the
+* `prefers-reduced-motion` media query.
+*
+* Key features:
+* - Three-way `mode`: `'system'` (honor OS setting), `'always'` (force reduce),
+*   `'never'` (force full motion)
+* - Reactive `isReduced` boolean — true when motion should be minimized
+* - When installed as a plugin, the default `V0ReducedMotionAdapter` writes
+*   `document.body.dataset.reducedMotion = 'reduce' | 'no-preference'` in the browser.
+*   On the server it renders the same attribute via `@unhead` with the configured
+*   mode — the OS preference is only readable in the browser, so in `'system'` mode
+*   the server value is always `'no-preference'` until client takeover; pair the
+*   attribute selector with a native `@media (prefers-reduced-motion: reduce)` rule
+*   for pre-hydration coverage
+* - SSR-safe: no `window`/`document` access on the server
+*
+* @example
+* ```ts
+* import { createReducedMotionPlugin, useReducedMotion } from '@vuetify/v0'
+*
+* // install once
+* app.use(createReducedMotionPlugin({ mode: 'system' }))
+*
+* // consume anywhere
+* const motion = useReducedMotion()
+* console.log(motion.isReduced.value) // true | false
+* motion.select('never') // override
+* ```
+*/
+/**
+* Creates a standalone reduced-motion context.
+*
+* @param options Initial options.
+* @returns A `ReducedMotionContext`.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-reduced-motion
+*
+* @example
+* ```ts
+* import { createReducedMotion } from '@vuetify/v0'
+*
+* const motion = createReducedMotion({ mode: 'system' })
+*
+* console.log(motion.isReduced.value) // true | false
+* motion.select('always')
+* ```
+*/
+function createReducedMotion(options = {}) {
+	const selectedMode = shallowRef(options.mode ?? "system");
+	const media = usePrefersReducedMotion();
+	const isReduced = toRef(() => {
+		if (selectedMode.value === "always") return true;
+		if (selectedMode.value === "never") return false;
+		return media.matches.value;
+	});
+	function select(value) {
+		selectedMode.value = value;
+	}
+	return {
+		selectedMode: shallowReadonly(selectedMode),
+		isReduced,
+		select,
+		dispose: media.stop
+	};
+}
+function createReducedMotionFallback() {
+	return {
+		selectedMode: shallowReadonly(shallowRef("system")),
+		isReduced: shallowReadonly(shallowRef(false)),
+		select: () => {},
+		dispose: () => {}
+	};
+}
+const [createReducedMotionContext, createReducedMotionPlugin, useReducedMotion] = createPluginContext("v0:reduced-motion", (options) => createReducedMotion(options), {
+	fallback: () => createReducedMotionFallback(),
+	persist: (context) => context.selectedMode.value,
+	restore: (context, saved) => {
+		if (saved === "system" || saved === "always" || saved === "never") context.select(saved);
+	},
+	setup: (context, app, { adapter = new V0ReducedMotionAdapter() }) => {
+		app.onUnmount(() => context.dispose());
+		adapter.setup(app, context);
+		app.onUnmount(() => adapter.dispose?.());
+	}
+});
+//#endregion
+//#region src/composables/useRtl/adapters/adapter.ts
+var RtlAdapter = class {
+	/**
+	* Teardown registered by `setup`. Called once via `app.onUnmount` on the
+	* plugin path and available as a reachable handle on standalone paths.
+	*/
+	dispose;
+};
+//#endregion
+//#region src/composables/useRtl/adapters/v0.ts
+var V0RtlAdapter = class extends RtlAdapter {
+	setup(app, context, target) {
+		if (IN_BROWSER) {
+			if (/* @__PURE__ */ isNull(target)) return;
+			const targetEl = target instanceof HTMLElement ? target : /* @__PURE__ */ isString(target) ? document.querySelector(target) : document.documentElement;
+			if (!targetEl) return;
+			targetEl.dir = context.isRtl.value ? "rtl" : "ltr";
+			this.dispose = watch(context.isRtl, (value) => {
+				targetEl.dir = value ? "rtl" : "ltr";
+			});
+		} else {
+			const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
+			if (head?.push) {
+				const entry = head.push({ htmlAttrs: { dir: context.isRtl.value ? "rtl" : "ltr" } });
+				if (entry?.dispose) this.dispose = entry.dispose;
+			}
+		}
+	}
+};
+//#endregion
+//#region src/composables/useRtl/index.ts
+/**
+* @module useRtl
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-rtl
+*
+* @remarks
+* RTL (right-to-left) direction composable with adapter pattern.
+*
+* Key features:
+* - Reactive boolean direction state
+* - Plugin trinity pattern (createRtlContext, createRtlPlugin, useRtl)
+* - Adapter pattern for DOM integration (dir attribute)
+* - 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.
+*
+* @param options The options for the RTL instance.
+* @returns A new RTL context with reactive direction state.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-rtl
+*/
+function createRtl(options = {}) {
+	const isRtl = shallowRef(options.default ?? false);
+	function toggle() {
+		isRtl.value = !isRtl.value;
+	}
+	return {
+		isRtl,
+		toggle,
+		dispose: () => {}
+	};
+}
+function createRtlFallback() {
+	return {
+		isRtl: shallowRef(false),
+		toggle: () => {},
+		dispose: () => {}
+	};
+}
+const [createRtlContext, createRtlPlugin, useRtl] = createPluginContext("v0:rtl", (options) => createRtl(options), {
+	fallback: () => createRtlFallback(),
+	setup: (context, app, { adapter = new V0RtlAdapter(), target }) => {
+		adapter.setup(app, context, target);
+		app.onUnmount(() => adapter.dispose?.());
+	},
+	persist: (ctx) => ctx.isRtl.value,
+	restore: (ctx, saved) => {
+		if (typeof saved === "boolean") ctx.isRtl.value = saved;
+	}
+});
+//#endregion
+export { createBreakpointsPlugin as A, createOtp as B, useMutationObserver as C, useDate as D, createDatePlugin as E, createVirtualContext as F, createSortable as G, createDataGrid as H, useVirtual as I, ServerComboboxAdapter as K, createTimeline as L, toReactive as M, toHighlight as N, createBreakpoints as O, createVirtual as P, createTimelineContext as R, DragDropAdapter as S, createDateContext as T, createDataGridContext as U, createKanban as V, useDataGrid as W, usePrefersReducedMotion as _, useRtl as a, KeyboardAdapter as b, createReducedMotion as c, useReducedMotion as d, V0ReducedMotionAdapter as f, usePrefersDark as g, usePrefersContrast as h, createRtlPlugin as i, useBreakpoints as j, createBreakpointsContext as k, createReducedMotionContext as l, useMediaQuery as m, createRtlContext as n, V0RtlAdapter as o, ReducedMotionAdapter as p, createRtlFallback as r, RtlAdapter as s, createRtl as t, createReducedMotionPlugin as u, useHotkey as v, createDate as w, PointerAdapter as x, useDragDrop as y, useTimeline as z };