@vuetify/v0 0.1.3 → 0.1.5

package/dist/useClickOutside-DIi0kjN5.mjs

@@ -0,0 +1,4716 @@
+import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-vN-O052q.mjs";
+import { a as isElement, c as isNull, g as mergeDeep, h as isUndefined, l as isNullOrUndefined, o as isFunction, p as isString, t as clamp, u as isNumber, v as useId$1, y as instanceExists } from "./utilities-Dx8wzGa5.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-DkwPrPRS.mjs";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-BXqiUvt2.mjs";
+import { i as createRegistry } from "./createTokens-jwf8-iGn.mjs";
+import { t as createSelection } from "./createSelection-BURpoE3p.mjs";
+import { t as createSingle } from "./createSingle-BE1vHaZy.mjs";
+import { t as createGroup } from "./createGroup-BrZPZudL.mjs";
+import { t as toArray } from "./toArray-VIn8vYt3.mjs";
+import { a as useLocale } from "./useLocale-DHjbekzS.mjs";
+import { t as MemoryAdapter } from "./memory-BsZGbGnG.mjs";
+import { computed, effectScope, isRef, nextTick, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toValue, unref, watch, watchEffect } from "vue";
+
+//#region src/composables/createBreadcrumbs/index.ts
+/**
+* @module createBreadcrumbs
+*
+* @remarks
+* Breadcrumb navigation composable built on createSingle.
+*
+* Key features:
+* - Extends createSingle for consistent registry patterns
+* - Navigation methods: first, prev, select (with truncation)
+* - Derived state: depth, isRoot, isEmpty
+* - Trinity pattern for dependency injection
+*
+* Inheritance chain: createRegistry → createSelection → createSingle → createBreadcrumbs
+*/
+/**
+* Creates a breadcrumbs navigation model.
+*
+* @param options The options for the breadcrumbs instance.
+* @returns A breadcrumbs context with navigation methods.
+*
+* @example
+* ```ts
+* import { createBreadcrumbs } from '@vuetify/v0'
+*
+* const breadcrumbs = createBreadcrumbs()
+*
+* breadcrumbs.register({ text: 'Home' })
+* breadcrumbs.register({ text: 'Products' })
+* breadcrumbs.register({ text: 'Electronics' })
+*
+* // Navigate back
+* breadcrumbs.prev() // removes Electronics
+* breadcrumbs.first() // truncates to Home
+*
+* // Derived state
+* breadcrumbs.depth.value // 1
+* breadcrumbs.isRoot.value // true
+* ```
+*/
+function createBreadcrumbs(options = {}) {
+	const single = createSingle({
+		...options,
+		reactive: true,
+		enroll: true
+	});
+	const depth = toRef(() => single.size);
+	const isRoot = toRef(() => depth.value <= 1);
+	const isEmpty = toRef(() => depth.value === 0);
+	/**
+	* Select an item and truncate everything after it.
+	*/
+	function select(id) {
+		const ticket = single.get(id);
+		if (!ticket) return;
+		const index = ticket.index;
+		const toRemove = single.values().filter((item) => item.index > index).map((item) => item.id);
+		if (toRemove.length > 0) single.offboard(toRemove);
+		single.select(id);
+	}
+	/**
+	* Navigate to root (first item).
+	*/
+	function first() {
+		const root = single.seek("first");
+		if (root) select(root.id);
+	}
+	/**
+	* Navigate up one level (select previous item, removing current).
+	*/
+	function prev() {
+		if (single.size <= 1) return;
+		const currentIndex = single.selectedIndex.value;
+		if (currentIndex <= 0) return;
+		const prevId = single.lookup(currentIndex - 1);
+		if (prevId) select(prevId);
+	}
+	return {
+		...single,
+		select,
+		first,
+		prev,
+		depth,
+		isRoot,
+		isEmpty,
+		get size() {
+			return single.size;
+		}
+	};
+}
+/**
+* Creates a breadcrumbs context for dependency injection.
+*
+* @param options The options including namespace.
+* @returns A trinity: [useBreadcrumbs, provideBreadcrumbs, defaultContext]
+*
+* @example
+* ```ts
+* const [useBreadcrumbs, provideBreadcrumbs] = createBreadcrumbsContext()
+*
+* // Parent component
+* provideBreadcrumbs()
+*
+* // Child component
+* const breadcrumbs = useBreadcrumbs()
+* breadcrumbs.register({ text: 'Details' })
+* ```
+*/
+function createBreadcrumbsContext(_options = {}) {
+	const { namespace = "v0:breadcrumbs", ...options } = _options;
+	const [useBreadcrumbsContext, _provideBreadcrumbsContext] = createContext(namespace);
+	const context = createBreadcrumbs(options);
+	function provideBreadcrumbsContext(_context = context, app) {
+		return _provideBreadcrumbsContext(_context, app);
+	}
+	return createTrinity(useBreadcrumbsContext, provideBreadcrumbsContext, context);
+}
+/**
+* Returns the current breadcrumbs instance from context.
+*
+* @param namespace The namespace. @default 'v0:breadcrumbs'
+* @returns The breadcrumbs context.
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useBreadcrumbs } from '@vuetify/v0'
+*
+*   const breadcrumbs = useBreadcrumbs()
+* <\/script>
+*
+* <template>
+*   <nav>
+*     <template v-for="ticket in breadcrumbs.values()" :key="ticket.id">
+*       <a @click="breadcrumbs.select(ticket.id)">{{ ticket.text }}</a>
+*     </template>
+*   </nav>
+* </template>
+* ```
+*/
+function useBreadcrumbs(namespace = "v0:breadcrumbs") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useHydration/index.ts
+/**
+* @module useHydration
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @remarks
+* SSR hydration state management composable.
+*
+* Key features:
+* - Hydration state detection (browser vs SSR)
+* - Root component detection
+* - Readonly hydration state refs
+* - Plugin installation support
+* - Perfect for hydration-safe rendering
+*
+* Essential for composables that need to behave differently during SSR vs client-side.
+*/
+/**
+* Creates a new hydration instance.
+*
+* @returns A new hydration instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @example
+* ```ts
+* import { createHydration } from '@vuetify/v0'
+*
+* const hydration = createHydration()
+* console.log(hydration.isHydrated.value) // false
+* hydration.hydrate()
+* console.log(hydration.isHydrated.value) // true
+* ```
+*/
+function createHydration() {
+	const isHydrated = shallowRef(false);
+	const isSettled = shallowRef(false);
+	function hydrate() {
+		isHydrated.value = true;
+	}
+	function settle() {
+		isSettled.value = true;
+	}
+	return {
+		isHydrated: shallowReadonly(isHydrated),
+		isSettled: shallowReadonly(isSettled),
+		hydrate,
+		settle
+	};
+}
+function createFallbackHydration() {
+	return {
+		isHydrated: shallowReadonly(shallowRef(true)),
+		isSettled: shallowReadonly(shallowRef(true)),
+		hydrate: () => {},
+		settle: () => {}
+	};
+}
+/**
+* Creates a new hydration context trinity.
+*
+* @param options Options for creating the hydration context.
+* @template E The type of the hydration context.
+* @returns A new hydration context trinity.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @example
+* ```ts
+* import { createHydrationContext } from '@vuetify/v0'
+*
+* export const [useHydrationContext, provideHydrationContext, context] = createHydrationContext({
+*   namespace: 'app:hydration',
+* })
+* ```
+*/
+const [createHydrationContext, createHydrationPlugin, useHydration] = createPluginContext("v0:hydration", () => createHydration(), {
+	fallback: () => createFallbackHydration(),
+	setup: (context, app, _options) => {
+		app.mixin({ async mounted() {
+			if (!/* @__PURE__ */ isNull(this.$parent)) return;
+			context.hydrate();
+			await nextTick();
+			context.settle();
+		} });
+	}
+});
+
+//#endregion
+//#region src/composables/toElement/index.ts
+/**
+* Resolves a {@link MaybeElementRef} to a DOM Element or undefined.
+*
+* Handles:
+* - `Ref<Element>`, `ShallowRef<HTMLElement>`, getter functions
+* - Vue component instances (extracts `$el`)
+* - Raw DOM elements (pass-through)
+* - null/undefined (returns undefined)
+*
+* @param target The element ref, getter, or raw value to resolve
+* @returns The resolved DOM Element, or undefined if not available
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-element
+*
+* @example
+* ```ts
+* import { toElement } from '@vuetify/v0'
+*
+* const el = shallowRef<HTMLElement | null>(null)
+* toElement(el) // HTMLElement | undefined
+*
+* const component = ref<ComponentPublicInstance>()
+* toElement(component) // Element | undefined (from $el)
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function toElement(target) {
+	const raw = typeof target === "function" ? target() : target && typeof target === "object" && "value" in target ? target.value : target;
+	if (!raw) return void 0;
+	if (raw instanceof Element) return raw;
+	if ("$el" in raw) return raw.$el;
+}
+
+//#endregion
+//#region src/composables/createObserver/index.ts
+/**
+* @module createObserver
+*
+* @remarks
+* Internal factory for browser Observer API composables. Encapsulates the
+* shared lifecycle, hydration, pause/resume/stop, and target-watch logic
+* used by useResizeObserver, useIntersectionObserver, and useMutationObserver.
+*
+* The `observer` ref uses a three-state sentinel:
+* - `undefined` — not yet created
+* - `null` — permanently stopped (`stop()` was called; `setup()` is a no-op)
+* - instance — active observer
+*/
+function createObserver(target, userCallback, config) {
+	const { isHydrated } = useHydration();
+	const resolved = toRef(() => /* @__PURE__ */ toElement(target));
+	const observer = shallowRef(void 0);
+	const isPaused = shallowRef(false);
+	const isActive = toRef(() => !!observer.value);
+	function invoke(entries) {
+		config.onEntry?.(entries);
+		userCallback(entries);
+		if (config.once) {
+			if (config.shouldStop ? config.shouldStop(entries) : true) stop();
+		}
+	}
+	function setup() {
+		if (/* @__PURE__ */ isNull(observer.value)) return;
+		const el = resolved.value;
+		if (!isHydrated.value || !config.supports || !/* @__PURE__ */ isElement(el) || isPaused.value) return;
+		observer.value = config.create(invoke);
+		config.observe(observer.value, el);
+		if (config.immediate) {
+			const entries = config.immediate(el);
+			if (config.onceIncludesImmediate) invoke(entries);
+			else {
+				config.onEntry?.(entries);
+				userCallback(entries);
+			}
+		}
+	}
+	watch(resolved, (el, oldEl) => {
+		if (oldEl || observer.value) cleanup();
+		if (isHydrated.value && /* @__PURE__ */ isElement(el)) setup();
+	}, { immediate: true });
+	let stopHydrationWatch;
+	if (!isHydrated.value) stopHydrationWatch = watch(() => isHydrated.value, (hydrated) => {
+		if (hydrated && /* @__PURE__ */ isElement(resolved.value) && !observer.value) {
+			setup();
+			stopHydrationWatch?.();
+			stopHydrationWatch = void 0;
+		}
+	});
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		config.onPause?.();
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		stopHydrationWatch?.();
+		stopHydrationWatch = void 0;
+		cleanup();
+		observer.value = null;
+	}
+	onScopeDispose(stop, true);
+	return {
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+//#region src/composables/useResizeObserver/index.ts
+/**
+* @module useResizeObserver
+*
+* @remarks
+* ResizeObserver composable with lifecycle management.
+*
+* Key features:
+* - ResizeObserver API wrapper
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_OBSERVER)
+* - Hydration-aware
+* - Box model options (content-box/border-box)
+*
+* Perfect for responsive components and size-based rendering.
+*/
+/**
+* A composable that uses the Resize Observer API to detect when an element's
+* size changes.
+*
+* @param target The element to observe.
+* @param callback The callback to execute when the element's size changes.
+* @param options The options for the Resize Observer.
+* @returns An object with methods to control the observer.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+* @see https://0.vuetifyjs.com/composables/system/use-resize-observer
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useResizeObserver } from '@vuetify/v0'
+*
+* const el = ref<HTMLElement>()
+* const width = ref(0)
+* const height = ref(0)
+*
+* const { pause, resume, isPaused } = useResizeObserver(
+*   el,
+*   (entries) => {
+*     const entry = entries[0]
+*     if (entry) {
+*       width.value = entry.contentRect.width
+*       height.value = entry.contentRect.height
+*       console.log('Size changed:', width.value, 'x', height.value)
+*     }
+*   },
+*   { immediate: true }
+* )
+*
+* // Pause observation
+* pause()
+*
+* // Resume observation
+* resume()
+* ```
+*/
+function useResizeObserver(target, callback, options = {}) {
+	return createObserver(target, callback, {
+		supports: SUPPORTS_OBSERVER,
+		once: options.once,
+		create: (cb) => new ResizeObserver((entries) => {
+			cb(entries.map((e) => ({
+				contentRect: {
+					width: e.contentRect.width,
+					height: e.contentRect.height,
+					top: e.contentRect.top,
+					left: e.contentRect.left
+				},
+				target: e.target
+			})));
+		}),
+		observe: (obs, el) => obs.observe(el, { box: options.box ?? "content-box" }),
+		immediate: options.immediate ? (el) => {
+			const rect = el.getBoundingClientRect();
+			return [{
+				contentRect: {
+					width: rect.width,
+					height: rect.height,
+					top: rect.top,
+					left: rect.left
+				},
+				target: el
+			}];
+		} : void 0
+	});
+}
+/**
+* A convenience composable that uses the Resize Observer API to track an
+* element's size.
+*
+* @param target The element to observe.
+* @returns An object with the element's width and height.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-resize-observer#use-element-size
+*
+* @example
+* ```ts
+* import { ref, watchEffect } from 'vue'
+* import { useElementSize } from '@vuetify/v0'
+*
+* const box = ref<HTMLElement>()
+* const { width, height } = useElementSize(box)
+*
+* // Width and height are reactive refs
+* watchEffect(() => {
+*   console.log('Box size:', width.value, 'x', height.value)
+* })
+* ```
+*/
+function useElementSize(target) {
+	const width = shallowRef(0);
+	const height = shallowRef(0);
+	const { pause: _pause, resume, stop, isActive, isPaused } = useResizeObserver(target, (entries) => {
+		const entry = entries[0];
+		if (entry) {
+			width.value = entry.contentRect.width;
+			height.value = entry.contentRect.height;
+		}
+	}, { immediate: true });
+	function pause() {
+		width.value = 0;
+		height.value = 0;
+		_pause();
+	}
+	return {
+		width,
+		height,
+		isActive,
+		isPaused: shallowReadonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+//#region src/composables/createOverflow/index.ts
+/**
+* @module useOverflow
+*
+* @remarks
+* Composable for computing how many items fit in a container based on available width.
+* Enables responsive truncation logic for Pagination, Breadcrumbs, and similar components.
+*
+* Key features:
+* - Container width tracking via ResizeObserver
+* - Two modes: variable-width (per-item) or uniform-width (sample-based)
+* - Computes capacity (how many items fit)
+* - SSR-safe with Infinity fallback
+* - Supports reserved space for nav buttons, ellipsis, etc.
+*
+* Use variable mode (default) for items with different widths like Breadcrumbs.
+* Use uniform mode (itemWidth option) for same-width items like Pagination buttons.
+*/
+/**
+* Creates a new overflow context for computing how many items fit in a container.
+*
+* @param options Configuration options
+* @returns Overflow context with container ref, capacity, and measurement functions
+*
+* @example Variable-width mode (Breadcrumbs)
+* ```vue
+* <script lang="ts" setup>
+*   import { useTemplateRef } from 'vue'
+*   import { createOverflow } from '@vuetify/v0'
+*
+*   const containerRef = useTemplateRef('container')
+*   const overflow = createOverflow({
+*     container: containerRef,
+*     gap: 8,
+*     reserved: 40,
+*   })
+* <\/script>
+*
+* <template>
+*   <div ref="container">
+*     <span
+*       v-for="(item, i) in items.slice(0, overflow.capacity.value)"
+*       :key="i"
+*       :ref="el => overflow.measure(i, el)"
+*     >
+*       {{ item }}
+*     </span>
+*     <span v-if="overflow.isOverflowing.value">...</span>
+*   </div>
+* </template>
+* ```
+*
+* @example Uniform-width mode (Pagination)
+* ```ts
+* const overflow = createOverflow({
+*   container: () => atom.value?.element,
+*   itemWidth: buttonWidth,
+*   reserved: () => buttonWidth.value * 4,
+* })
+* ```
+*/
+function createOverflow(options = {}) {
+	const { container: _container, gap = 0, reserved = 0, itemWidth, reverse } = options;
+	const container = /* @__PURE__ */ isUndefined(_container) ? shallowRef() : toRef(_container);
+	const widths = shallowRef(/* @__PURE__ */ new Map());
+	const { width } = useElementSize(container);
+	function measure(index, el) {
+		if (!el) {
+			if (widths.value.has(index)) {
+				const next = new Map(widths.value);
+				next.delete(index);
+				widths.value = next;
+			}
+			return;
+		}
+		/* v8 ignore start -- browser-only measurement code */
+		if (!IN_BROWSER) return;
+		const style = getComputedStyle(el);
+		const marginX = Number.parseFloat(style.marginLeft) + Number.parseFloat(style.marginRight);
+		const w = el.offsetWidth + marginX;
+		if (widths.value.get(index) !== w) widths.value = new Map(widths.value).set(index, w);
+		/* v8 ignore stop */
+	}
+	function reset() {
+		widths.value = /* @__PURE__ */ new Map();
+	}
+	const total = computed(() => {
+		const g = toValue(gap);
+		let sum = 0;
+		let count = 0;
+		for (const w of widths.value.values()) {
+			sum += w + (count > 0 ? g : 0);
+			count++;
+		}
+		return sum;
+	});
+	return {
+		container,
+		width,
+		capacity: computed(() => {
+			const available = width.value - toValue(reserved);
+			if (width.value === 0) return Infinity;
+			if (available <= 0) return 0;
+			const g = toValue(gap);
+			const uniformWidth = toValue(itemWidth) ?? 0;
+			if (itemWidth !== void 0 && uniformWidth <= 0) return Infinity;
+			if (uniformWidth > 0) {
+				const subsequent = uniformWidth + g;
+				if (available < uniformWidth) return 0;
+				return Math.max(1, Math.floor((available - uniformWidth) / subsequent) + 1);
+			}
+			const entries = [...widths.value.entries()].toSorted((a, b) => a[0] - b[0]);
+			if (toValue(reverse)) entries.reverse();
+			let sum = 0;
+			let count = 0;
+			for (const [, w] of entries) {
+				const next = sum + w + (count > 0 ? g : 0);
+				if (next > available) break;
+				sum = next;
+				count++;
+			}
+			return count;
+		}),
+		total,
+		isOverflowing: toRef(() => {
+			return total.value > width.value - toValue(reserved);
+		}),
+		measure,
+		reset
+	};
+}
+/**
+* Creates an overflow context with dependency injection support.
+*
+* @param options Configuration options including namespace
+* @template E The type of the overflow context
+* @returns Trinity tuple: [useOverflow, provideOverflow, defaultOverflow]
+*
+* @example
+* ```ts
+* // Create injectable context
+* const [useOverflow, provideOverflow, overflow] = createOverflowContext({
+*   namespace: 'my-overflow',
+*   gap: 8,
+*   reserved: 160,
+* })
+*
+* // In parent component
+* provideOverflow()
+*
+* // In child component
+* const overflow = useOverflow()
+* ```
+*/
+function createOverflowContext(_options = {}) {
+	const { namespace = "v0:overflow", ...options } = _options;
+	const [useOverflowContext, _provideOverflowContext] = createContext(namespace);
+	const context = createOverflow(options);
+	function provideOverflowContext(_context = context, app) {
+		return _provideOverflowContext(_context, app);
+	}
+	return createTrinity(useOverflowContext, provideOverflowContext, context);
+}
+/**
+* Returns the current overflow context from dependency injection.
+*
+* @param namespace The namespace for the overflow context. Defaults to `v0:overflow`.
+* @template E The type of the overflow context
+* @returns The current overflow context.
+*
+* @throws An error if the overflow context is not found and no default is provided.
+*
+* @example
+* ```vue
+* <script lang="ts" setup>
+*   import { useOverflow } from '@vuetify/v0'
+*
+*   // Inject overflow context provided by parent
+*   const overflow = useOverflow()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Capacity: {{ overflow.capacity.value }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useOverflow(namespace = "v0:overflow") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* @module useProxyModel
+*
+* @remarks
+* Proxy composable for bidirectional sync between selection registry and v-model.
+*
+* Key features:
+* - Bidirectional synchronization
+* - Array and single-value modes
+* - Automatic cleanup on scope disposal
+* - Perfect for form controls with selection backing
+*
+* Bridges the gap between selection composables and Vue's v-model.
+*/
+/**
+* Syncs a ref with a selection registry bidirectionally.
+*
+* @param registry The selection registry to bind to.
+* @param model The ref to sync.
+* @param options The options for the proxy model.
+* @template Z The type of the selection ticket.
+* @returns A function to stop the sync.
+*
+* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
+*
+* @example
+* ```ts
+* import { createSelection, useProxyModel } from '@vuetify/v0'
+*
+* const model = ref()
+* const registry = createSelection({ events: true })
+* registry.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2' },
+* ])
+*
+* const stop = useProxyModel(registry, model)
+* ```
+*/
+function useProxyModel(registry, model, options) {
+	const multiple = options?.multiple ?? false;
+	const _transformIn = options?.transformIn;
+	const _transformOut = options?.transformOut;
+	function transformIn(val) {
+		const value = toValue(val);
+		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
+	}
+	function transformOut(val) {
+		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
+		return toValue(multiple) ? val : val[0];
+	}
+	const modelAsArray = transformIn(model);
+	const pending = new Set(modelAsArray);
+	for (const value of modelAsArray) {
+		const ids = registry.browse(value);
+		/* v8 ignore start -- edge case: value exists in registry at init */
+		if (ids) {
+			for (const id of ids) registry.select(id);
+			pending.delete(value);
+		}
+	}
+	const registryWatch = watch(registry.selectedValues, (val) => {
+		modelWatch.pause();
+		model.value = transformOut(Array.from(toValue(val)));
+		modelWatch.resume();
+	}, { flush: "sync" });
+	const modelWatch = watch(model, (val) => {
+		registryWatch.pause();
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of transformIn(val)) {
+			const ids = registry.browse(toRaw(value));
+			if (ids) for (const id of ids) targetIds.add(id);
+		}
+		if (toValue(multiple)) {
+			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
+			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
+		} else {
+			const next = targetIds.values().next().value;
+			const last = currentIds.values().next().value;
+			if (!/* @__PURE__ */ isUndefined(last)) registry.unselect(last);
+			if (!/* @__PURE__ */ isUndefined(next)) registry.select(next);
+		}
+		registryWatch.resume();
+	}, {
+		flush: "sync",
+		deep: toValue(multiple)
+	});
+	function onRegister(data) {
+		const ticket = data;
+		if (!pending.has(ticket.value) || toValue(ticket.disabled)) return;
+		registryWatch.pause();
+		modelWatch.pause();
+		registry.select(ticket.id);
+		pending.delete(ticket.value);
+		modelWatch.resume();
+		registryWatch.resume();
+	}
+	registry.on("register:ticket", onRegister);
+	function stop() {
+		registryWatch();
+		modelWatch();
+		registry.off("register:ticket", onRegister);
+	}
+	onScopeDispose(stop, true);
+	return stop;
+}
+
+//#endregion
+//#region src/composables/toReactive/index.ts
+/**
+* @module toReactive
+*
+* @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.
+*/
+/**
+* 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 target = objectRef.value;
+	if (target instanceof Map) {
+		const mapProxy = new Proxy(/* @__PURE__ */ new Map(), { get(_, p) {
+			const map = objectRef.value;
+			if (p === "get") return (key) => unref(map.get(key));
+			if (p === "set") return (key, value) => {
+				const existingValue = map.get(key);
+				if (isRef(existingValue)) existingValue.value = unref(value);
+				else map.set(key, value);
+				return mapProxy;
+			};
+			if (p === "has") return (key) => map.has(key);
+			if (p === "delete") return (key) => map.delete(key);
+			if (p === "clear") return () => map.clear();
+			if (p === "size") return map.size;
+			if (p === "keys") return () => map.keys();
+			if (p === "values") return function* () {
+				for (const value of map.values()) yield unref(value);
+			};
+			if (p === "entries") return function* () {
+				for (const [key, value] of map.entries()) yield [key, unref(value)];
+			};
+			if (p === "forEach") return (callback, thisArg) => {
+				for (const [key, value] of map.entries()) callback.call(thisArg, unref(value), key, mapProxy);
+			};
+			if (p === Symbol.iterator) return function* () {
+				for (const [key, value] of map.entries()) yield [key, unref(value)];
+			};
+			return Reflect.get(map, p);
+		} });
+		return reactive(mapProxy);
+	}
+	if (target instanceof Set) {
+		const setProxy = new Proxy(/* @__PURE__ */ new Set(), { get(_, p) {
+			const set = objectRef.value;
+			if (p === "add") return (value) => {
+				set.add(value);
+				return setProxy;
+			};
+			if (p === "has") return (value) => set.has(value);
+			if (p === "delete") return (value) => set.delete(value);
+			if (p === "clear") return () => set.clear();
+			if (p === "size") return set.size;
+			if (p === "keys" || p === "values") return function* () {
+				for (const value of set.values()) yield unref(value);
+			};
+			if (p === "entries") return function* () {
+				for (const value of set.values()) {
+					const unreffedValue = unref(value);
+					yield [unreffedValue, unreffedValue];
+				}
+			};
+			if (p === "forEach") return (callback, thisArg) => {
+				for (const value of set) {
+					const unreffedValue = unref(value);
+					callback.call(thisArg, unreffedValue, unreffedValue, setProxy);
+				}
+			};
+			if (p === Symbol.iterator) return function* () {
+				for (const value of set.values()) yield unref(value);
+			};
+			return Reflect.get(set, p);
+		} });
+		return reactive(setProxy);
+	}
+	return reactive(new Proxy({}, {
+		get(_, p, receiver) {
+			return unref(Reflect.get(objectRef.value, p, receiver));
+		},
+		set(_, p, value) {
+			const currentTarget = objectRef.value;
+			currentTarget[p] = value;
+			return true;
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(objectRef.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(objectRef.value, p);
+		},
+		ownKeys() {
+			return Object.keys(objectRef.value);
+		},
+		getOwnPropertyDescriptor(_, p) {
+			const desc = Reflect.getOwnPropertyDescriptor(objectRef.value, p);
+			if (!desc) return;
+			const newDesc = {
+				...desc,
+				configurable: true
+			};
+			if ("value" in newDesc) newDesc.value = unref(newDesc.value);
+			return newDesc;
+		}
+	}));
+}
+
+//#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:
+* - Window matchMedia integration
+* - Six built-in breakpoints (xs, sm, md, lg, xl, xxl)
+* - Automatic resize listener with cleanup
+* - SSR-safe (checks IN_BROWSER)
+* - Hydration-aware
+* - Custom breakpoint configuration
+*
+* Perfect for responsive layouts and conditional rendering based on screen size.
+*/
+/**
+* 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.
+* @template E The type of the breakpoints context.
+* @returns A new breakpoints instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+*
+* @example
+* ```ts
+* import { createBreakpoints } from '@vuetify/v0'
+*
+* export const [useBreakpoints, provideBreakpoints] = createBreakpoints({
+*   namespace: 'v0:breakpoints',
+*   mobileBreakpoint: 'md',
+*   breakpoints: {
+*     xs: 0,
+*     sm: 600,
+*     md: 840,
+*     lg: 1145,
+*     xl: 1545,
+*     xxl: 2138,
+*   },
+* })
+* ```
+*/
+function createBreakpoints(_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 name = shallowRef("xs");
+	const width = shallowRef(0);
+	const height = shallowRef(0);
+	const isMobile = shallowRef(true);
+	const xs = shallowRef(true);
+	const sm = shallowRef(false);
+	const md = shallowRef(false);
+	const lg = shallowRef(false);
+	const xl = shallowRef(false);
+	const xxl = shallowRef(false);
+	const smAndUp = shallowRef(false);
+	const mdAndUp = shallowRef(false);
+	const lgAndUp = shallowRef(false);
+	const xlAndUp = shallowRef(false);
+	const xxlAndUp = shallowRef(false);
+	const smAndDown = shallowRef(true);
+	const mdAndDown = shallowRef(true);
+	const lgAndDown = shallowRef(true);
+	const xlAndDown = shallowRef(true);
+	const xxlAndDown = shallowRef(true);
+	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--) if (width.value >= sorted[i][1]) {
+			current = sorted[i][0];
+			break;
+		}
+		name.value = current;
+		const index = names.indexOf(current);
+		isMobile.value = width.value < mb;
+		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;
+		xxlAndUp.value = index >= 5;
+		smAndDown.value = index <= 1;
+		mdAndDown.value = index <= 2;
+		lgAndDown.value = index <= 3;
+		xlAndDown.value = index <= 4;
+		xxlAndDown.value = index <= 5;
+	}
+	return {
+		breakpoints,
+		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),
+		xxlAndUp: readonly(xxlAndUp),
+		smAndDown: readonly(smAndDown),
+		mdAndDown: readonly(mdAndDown),
+		lgAndDown: readonly(lgAndDown),
+		xlAndDown: readonly(xlAndDown),
+		xxlAndDown: readonly(xxlAndDown),
+		update
+	};
+}
+function createBreakpointsFallback() {
+	return {
+		breakpoints: createDefaultBreakpoints().breakpoints,
+		name: readonly(shallowRef("xs")),
+		width: readonly(shallowRef(0)),
+		height: readonly(shallowRef(0)),
+		isMobile: readonly(shallowRef(false)),
+		xs: readonly(shallowRef(false)),
+		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)),
+		xxlAndUp: readonly(shallowRef(false)),
+		smAndDown: readonly(shallowRef(false)),
+		mdAndDown: readonly(shallowRef(false)),
+		lgAndDown: readonly(shallowRef(false)),
+		xlAndDown: readonly(shallowRef(false)),
+		xxlAndDown: readonly(shallowRef(false)),
+		update: () => {}
+	};
+}
+const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = createPluginContext("v0:breakpoints", (options) => createBreakpoints(options), {
+	fallback: () => createBreakpointsFallback(),
+	setup: (context, app, _options) => {
+		app.mixin({ mounted() {
+			if (!/* @__PURE__ */ isNull(this.$parent)) return;
+			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);
+		} });
+	}
+});
+
+//#endregion
+//#region src/composables/useDate/index.ts
+/**
+* @module useDate
+*
+* @remarks
+* Date manipulation composable with adapter pattern for date operations.
+*
+* Key features:
+* - Adapter pattern for date library abstraction
+* - Locale-aware formatting via Intl.DateTimeFormat
+* - Integration with useLocale for automatic locale sync
+*
+* @example Using the built-in Temporal adapter
+* ```ts
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { createDatePlugin } from '@vuetify/v0'
+*
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+*
+* // In a component:
+* const { adapter } = useDate()
+* const today = adapter.date()
+* const formatted = adapter.format(today, 'fullDate')
+* ```
+*
+* @example Custom adapter
+* ```ts
+* import type { DateAdapter } from '@vuetify/v0'
+*
+* class DateFnsAdapter implements 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"
+};
+/**
+* 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 { Vuetify0DateAdapter } from '@vuetify/v0/date'
+*
+* const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
+* const today = adapter.date()
+*
+* // With locale options
+* const { adapter } = createDate({
+*   adapter: new Vuetify0DateAdapter(),
+*   locale: 'de-DE',
+* })
+* ```
+*/
+function createDate(options) {
+	const { locales = defaultLocales, adapter, locale: initialLocale } = options;
+	let selectedId;
+	try {
+		if (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;
+	});
+	if (instanceExists()) onScopeDispose(watchEffect(() => {
+		const loc = locale.value;
+		if (loc && adapter.locale !== loc) adapter.locale = loc;
+	}));
+	else {
+		const loc = locale.value;
+		if (loc && adapter.locale !== loc) adapter.locale = loc;
+	}
+	return {
+		adapter,
+		locale
+	};
+}
+/**
+* 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 { Vuetify0DateAdapter } from '@vuetify/v0/date'
+*
+* const [useAppDate, provideAppDate] = createDateContext({
+*   adapter: new Vuetify0DateAdapter(),
+*   namespace: 'app:date',
+* })
+* ```
+*/
+function createDateContext(options) {
+	const { namespace = "v0:date", ...dateOptions } = options;
+	const [useDateContext, _provideDateContext] = createContext(namespace);
+	const context = createDate(dateOptions);
+	function provideDateContext(_context = context, app) {
+		return _provideDateContext(_context, app);
+	}
+	return createTrinity(useDateContext, provideDateContext, context);
+}
+/**
+* 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 { Vuetify0DateAdapter } from '@vuetify/v0/date'
+*
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+*
+* // With locale options
+* app.use(createDatePlugin({
+*   adapter: new Vuetify0DateAdapter(),
+*   locale: 'de-DE',
+* }))
+* ```
+*/
+function createDatePlugin(options) {
+	const { namespace = "v0:date", ...dateOptions } = options;
+	const [, provideDateContext, context] = createDateContext({
+		namespace,
+		...dateOptions
+	});
+	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 { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { createDatePlugin } from '@vuetify/v0'
+*
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* ```
+*
+* @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 (!instanceExists()) throw new Error("[v0] useDate() must be called inside a Vue component with createDatePlugin installed.\n\nExample:\n  import { Vuetify0DateAdapter } from '@vuetify/v0/date'\n  import { createDatePlugin } from '@vuetify/v0'\n\n  app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))");
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/createForm/index.ts
+/**
+* @module createForm
+*
+* @remarks
+* Form validation composable with async rule support and multiple validation modes.
+*
+* Key features:
+* - Sync and async validation rules
+* - Multiple validation modes (submit, change, combined)
+* - Tri-state isValid (null/true/false)
+* - isPristine tracking
+* - Silent validation mode
+* - Form-level validation and reset
+*
+* Each field is registered with validation rules and tracks its own state independently.
+*/
+/**
+* Creates a new form instance.
+*
+* @param options The options for the form instance.
+* @template Z The type of the form ticket.
+* @template E The type of the form context.
+* @returns A new form instance.
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-form
+*
+* @example
+* ```ts
+* import { createForm } from '@vuetify/v0'
+*
+* const form = createForm()
+*
+* const username = form.register({
+*   id: 'username',
+*   value: '',
+*   rules: [(v) => v.length > 0 || 'Username is required'],
+* })
+*
+* await form.submit()
+*
+* console.log(username.errors.value) // ['Username is required']
+*
+* form.reset()
+* ```
+*/
+function createForm(options) {
+	const registry = createRegistry(options);
+	const validateOn = options?.validateOn || "submit";
+	function parse(value) {
+		return value.toLowerCase().split(/\s+/);
+	}
+	const isValidating = computed(() => {
+		for (const ticket of registry.values()) if (ticket.isValidating.value) return true;
+		return false;
+	});
+	const isValid = computed(() => {
+		let hasFields = false;
+		for (const ticket of registry.values()) {
+			hasFields = true;
+			if (ticket.isValid.value === false) return false;
+			if (/* @__PURE__ */ isNull(ticket.isValid.value)) return null;
+		}
+		return hasFields ? true : null;
+	});
+	function reset() {
+		for (const ticket of registry.values()) ticket.reset();
+	}
+	async function submit() {
+		return validate([...registry.keys()]);
+	}
+	async function validate(id) {
+		const validating = toArray(id);
+		return (await Promise.all(validating.map(async (id$1) => await registry.get(id$1)?.validate() ?? true))).every(Boolean);
+	}
+	function register(registration) {
+		const model = shallowRef(/* @__PURE__ */ isNullOrUndefined(registration.value) ? "" : toValue(registration.value));
+		const rules = registration.rules || [];
+		const errors = shallowRef([]);
+		const isValidating$1 = shallowRef(false);
+		const initialValue = model.value;
+		const triggers = registration.validateOn || validateOn;
+		const isPristine = shallowRef(true);
+		const isValid$1 = shallowRef(null);
+		function _validatesOn(event) {
+			return parse(triggers).includes(event);
+		}
+		function _reset() {
+			model.value = initialValue;
+			errors.value = [];
+			isPristine.value = true;
+			isValid$1.value = null;
+			isValidating$1.value = false;
+			validationGeneration++;
+		}
+		let validationGeneration = 0;
+		async function validate$1(silent = false) {
+			if (rules.length === 0) return isValid$1.value = true;
+			const generation = ++validationGeneration;
+			isValidating$1.value = true;
+			try {
+				const results = await Promise.all(rules.map((rule) => rule(model.value)));
+				if (generation !== validationGeneration) return isValid$1.value ?? false;
+				const errorMessages = results.filter((result) => /* @__PURE__ */ isString(result));
+				if (!silent) {
+					errors.value = errorMessages;
+					isValid$1.value = errorMessages.length === 0;
+					isPristine.value = toValue(model) === initialValue;
+				}
+				return errorMessages.length === 0;
+			} finally {
+				if (generation === validationGeneration) isValidating$1.value = false;
+			}
+		}
+		const item = {
+			...registration,
+			rules,
+			errors,
+			disabled: registration.disabled || false,
+			validateOn: triggers,
+			isValidating: isValidating$1,
+			isPristine,
+			isValid: isValid$1,
+			reset: _reset,
+			validate: validate$1
+		};
+		const ticket = registry.register(item);
+		Object.defineProperty(ticket, "value", {
+			get() {
+				return model.value;
+			},
+			set(val) {
+				model.value = val;
+				isPristine.value = val === initialValue;
+				isValid$1.value = null;
+				if (_validatesOn("change")) validate$1();
+			},
+			enumerable: true,
+			configurable: true
+		});
+		return ticket;
+	}
+	function onboard(registrations) {
+		return registry.batch(() => registrations.map((r) => register(r)));
+	}
+	return {
+		...registry,
+		register,
+		onboard,
+		reset,
+		submit,
+		validateOn,
+		isValid,
+		isValidating,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new form context.
+*
+* @param options The options for the form context.
+* @template Z The type of the form ticket.
+* @template E The type of the form context.
+* @returns A new form context.
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-form
+*
+* @example
+* ```ts
+* import { createFormContext } from '@vuetify/v0'
+*
+* // With default namespace 'v0:form'
+* export const [useMyForm, provideMyForm, myForm] = createFormContext({ validateOn: 'change' })
+*
+* // Or with custom namespace
+* export const [useMyForm, provideMyForm, myForm] = createFormContext({
+*   namespace: 'my-form',
+*   validateOn: 'change',
+* })
+*
+* // In a parent component:
+* provideMyForm()
+*
+* // In a child component:
+* const form = useMyForm()
+* form.register({ id: 'field', value: ref(''), rules: [...] })
+* ```
+*/
+function createFormContext(_options = {}) {
+	const { namespace = "v0:form", ...options } = _options;
+	const [useFormContext, _provideFormContext] = createContext(namespace);
+	const context = createForm(options);
+	function provideFormContext(_context = context, app) {
+		return _provideFormContext(_context, app);
+	}
+	return createTrinity(useFormContext, provideFormContext, context);
+}
+/**
+* Returns the current form instance.
+*
+* @param namespace The namespace for the form context. Defaults to `'v0:form'`.
+* @returns The current form instance.
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-form
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useForm } from '@vuetify/v0'
+*
+*   const form = useForm()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Form is {{ form.isValid.value ? 'valid' : 'invalid' }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useForm(namespace = "v0:form") {
+	return useContext(namespace);
+}
+
+//#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",
+	minus: "-",
+	hyphen: "-"
+};
+function normalizeKey(key) {
+	const lowerKey = key.toLowerCase();
+	return keyAliasMap[lowerKey] ?? lowerKey;
+}
+
+//#endregion
+//#region src/composables/useHotkey/parsing.ts
+const logger = 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 === "+" || combination === "_" || combination.length > 1 && (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(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: [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
+*
+* @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 alias normalization
+* - 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.
+*/
+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() {
+		if (toValue(inputs)) return false;
+		const activeElement = document.activeElement;
+		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());
+		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]));
+	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/useIntersectionObserver/index.ts
+/**
+* @module useIntersectionObserver
+*
+* @remarks
+* IntersectionObserver composable with lifecycle management.
+*
+* Key features:
+* - IntersectionObserver API wrapper
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_INTERSECTION_OBSERVER)
+* - Hydration-aware
+* - Immediate callback option
+*
+* Perfect for lazy loading, infinite scroll, and visibility detection.
+*/
+/**
+* A composable that uses the Intersection Observer API to detect when an element
+* is visible in the viewport.
+*
+* @param target The element to observe.
+* @param callback The callback to execute when the element's intersection changes.
+* @param options The options for the Intersection Observer.
+* @returns An object with methods to control the observer.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
+* @see https://0.vuetifyjs.com/composables/system/use-intersection-observer
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useIntersectionObserver } from '@vuetify/v0'
+*
+* const target = ref<HTMLElement>()
+* const isVisible = ref(false)
+*
+* const { isIntersecting, pause, resume } = useIntersectionObserver(
+*   target,
+*   (entries) => {
+*     const entry = entries[0]
+*     if (entry) {
+*       isVisible.value = entry.isIntersecting
+*       console.log('Element is visible:', entry.isIntersecting)
+*     }
+*   },
+*   { threshold: 0.5 }
+* )
+*
+* // Pause observation
+* pause()
+*
+* // Resume observation
+* resume()
+* ```
+*/
+function useIntersectionObserver(target, callback, options = {}) {
+	const isIntersecting = shallowRef(false);
+	return {
+		...createObserver(target, callback, {
+			supports: SUPPORTS_INTERSECTION_OBSERVER,
+			once: options.once,
+			create: (cb) => new IntersectionObserver((entries) => {
+				cb(entries.map((e) => ({
+					boundingClientRect: e.boundingClientRect,
+					intersectionRatio: e.intersectionRatio,
+					intersectionRect: e.intersectionRect,
+					isIntersecting: e.isIntersecting,
+					rootBounds: e.rootBounds,
+					target: e.target,
+					time: e.time
+				})));
+			}, {
+				root: options.root ?? null,
+				rootMargin: options.rootMargin ?? "0px",
+				threshold: options.threshold ?? 0
+			}),
+			observe: (obs, el) => obs.observe(el),
+			onEntry: (entries) => {
+				const latest = entries.at(-1);
+				if (latest) isIntersecting.value = latest.isIntersecting;
+			},
+			onPause: () => {
+				isIntersecting.value = false;
+			},
+			shouldStop: (entries) => entries.at(-1)?.isIntersecting ?? false,
+			immediate: options.immediate ? (el) => {
+				return [{
+					boundingClientRect: el.getBoundingClientRect(),
+					intersectionRatio: 0,
+					intersectionRect: new DOMRect(0, 0, 0, 0),
+					isIntersecting: false,
+					rootBounds: null,
+					target: el,
+					time: performance.now()
+				}];
+			} : void 0
+		}),
+		isIntersecting: shallowReadonly(isIntersecting)
+	};
+}
+/**
+* A convenience composable that uses the Intersection Observer API to detect
+* when an element is visible in the viewport.
+*
+* @param target The element to observe.
+* @param options The options for the Intersection Observer.
+* @returns An object with the intersection state.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-intersection-observer
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useElementIntersection } from '@vuetify/v0'
+*
+* const myElement = ref<HTMLElement>()
+* const { isIntersecting, intersectionRatio } = useElementIntersection(myElement, {
+*   threshold: 0.5
+* })
+*
+* // Use in template to conditionally render or animate
+* watchEffect(() => {
+*   if (isIntersecting.value) {
+*     console.log('Element is visible!', intersectionRatio.value)
+*   }
+* })
+* ```
+*/
+function useElementIntersection(target, options = {}) {
+	const isIntersecting = shallowRef(false);
+	const intersectionRatio = shallowRef(0);
+	const { pause: _pause, resume, stop, isActive, isPaused } = useIntersectionObserver(target, (entries) => {
+		const entry = entries.at(-1);
+		if (entry) {
+			isIntersecting.value = entry.isIntersecting;
+			intersectionRatio.value = entry.intersectionRatio;
+		}
+	}, {
+		immediate: true,
+		...options
+	});
+	function pause() {
+		isIntersecting.value = false;
+		intersectionRatio.value = 0;
+		_pause();
+	}
+	return {
+		isIntersecting: shallowReadonly(isIntersecting),
+		intersectionRatio: shallowReadonly(intersectionRatio),
+		isActive,
+		isPaused,
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+//#region src/composables/useLazy/index.ts
+/**
+* @module useLazy
+*
+* @see https://0.vuetifyjs.com/composables/system/use-lazy
+*
+* @remarks
+* Deferred content rendering composable for performance optimization.
+*
+* Key features:
+* - Content only renders after first activation (unless eager)
+* - Optional reset on deactivation for memory savings
+* - Readonly state refs for template binding
+* - Manual reset control
+* - SSR-safe
+*
+* Perfect for dialogs, menus, tooltips, and any component with
+* conditionally rendered content.
+*/
+/**
+* Deferred content rendering for performance optimization.
+*
+* @param active Reactive boolean controlling activation state
+* @param options Configuration options
+* @returns Lazy context with state refs and control functions
+*
+* @see https://0.vuetifyjs.com/composables/system/use-lazy
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useLazy } from '@vuetify/v0'
+*
+* const isOpen = ref(false)
+* const { hasContent, onAfterLeave } = useLazy(isOpen)
+*
+* // In template:
+* // <Transition @after-leave="onAfterLeave">
+* //   <div v-if="isOpen">
+* //     <template v-if="hasContent">
+* //       <!-- Heavy content here -->
+* //     </template>
+* //   </div>
+* // </Transition>
+* ```
+*
+* @example
+* Eager mode (render immediately):
+* ```ts
+* const { hasContent } = useLazy(isOpen, { eager: true })
+* // hasContent.value is always true
+* ```
+*
+* @example
+* With reactive eager prop:
+* ```ts
+* const props = defineProps<{ eager: boolean }>()
+* const { hasContent } = useLazy(isOpen, {
+*   eager: toRef(() => props.eager),
+* })
+* ```
+*/
+function useLazy(active, options = {}) {
+	const { eager = false } = options;
+	const isBooted = shallowRef(false);
+	const hasContent = toRef(() => isBooted.value || toValue(eager) || toValue(active));
+	const stop = watch(() => toValue(active), (value) => {
+		if (value) isBooted.value = true;
+	}, { immediate: true });
+	function reset() {
+		isBooted.value = false;
+	}
+	function onAfterLeave() {
+		if (!toValue(eager)) reset();
+	}
+	onScopeDispose(stop, true);
+	return {
+		isBooted: shallowReadonly(isBooted),
+		hasContent: shallowReadonly(hasContent),
+		reset,
+		onAfterLeave
+	};
+}
+
+//#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:
+* - 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.
+*/
+/**
+* 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 matches = shallowRef(false);
+	const mediaQueryList = shallowRef(null);
+	const resolvedQuery = computed(() => toValue(query));
+	const hydration = useHydration();
+	let cleanup = null;
+	function update() {
+		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) update();
+	}, { 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/useMutationObserver/index.ts
+/**
+* @module useMutationObserver
+*
+* @remarks
+* MutationObserver composable with lifecycle management.
+*
+* Key features:
+* - MutationObserver API wrapper
+* - 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.
+*/
+/**
+* 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/createNested/strategies.ts
+/**
+* Multiple open strategy: allows multiple nodes to be open simultaneously.
+*
+* @remarks
+* Perfect for tree views, file explorers, and nested menus where users expect
+* to keep multiple sections expanded at once.
+*
+* @example
+* ```ts
+* const tree = createNested({ openStrategy: multipleOpenStrategy })
+* tree.open('node-1')
+* tree.open('node-2')
+* // Both nodes are now open
+* ```
+*/
+const multipleOpenStrategy = {
+	onOpen: void 0,
+	onClose: void 0
+};
+/**
+* Single open strategy: only one node can be open at a time (accordion behavior).
+*
+* @remarks
+* Perfect for accordions, single-select navigation, and contexts where only
+* one section should be visible at a time.
+*
+* @example
+* ```ts
+* const tree = createNested({ openStrategy: singleOpenStrategy })
+* tree.open('node-1') // node-1 opens
+* tree.open('node-2') // node-1 closes, node-2 opens
+* ```
+*/
+const singleOpenStrategy = {
+	onOpen: (id, context) => {
+		for (const openedId of context.openedIds) if (openedId !== id) context.openedIds.delete(openedId);
+	},
+	onClose: void 0
+};
+
+//#endregion
+//#region src/composables/createNested/index.ts
+/**
+* @module createNested
+*
+* @remarks
+* Hierarchical tree management composable extending createGroup with:
+* - Parent-child relationship tracking (children/parents Maps)
+* - Open/close state management
+* - Tree traversal utilities (getPath, getDescendants, etc.)
+* - Pluggable open strategies
+*
+* Inheritance chain: createSelection → createGroup → createNested
+*/
+/**
+* Resolves open mode to an OpenStrategy.
+*/
+function resolveOpenStrategy(open = "multiple") {
+	return open === "single" ? singleOpenStrategy : multipleOpenStrategy;
+}
+/**
+* Creates a new nested tree instance with hierarchical management.
+*
+* Extends `createGroup` to support parent-child relationships, tree traversal,
+* and open/close state management. Perfect for tree views, nested navigation,
+* and hierarchical data structures.
+*
+* @param options The options for the nested instance.
+* @template Z The type of the nested ticket.
+* @template E The type of the nested context.
+* @returns A new nested instance with tree management capabilities.
+*
+* @remarks
+* **Key Differences from `createGroup`:**
+* - `register()` accepts `parentId` for establishing parent-child relationships
+* - `unregister()` accepts optional `cascade` parameter for cascading deletions
+* - Adds tree traversal methods: `getPath()`, `getAncestors()`, `getDescendants()`
+* - Adds computed properties: `roots`, `leaves`, `isLeaf()`, `getDepth()`
+* - Adds open state management: `open()`, `close()`, `flip()`, `opened()`
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-nested
+*
+* @example
+* ```ts
+* import { createNested } from '@vuetify/v0'
+*
+* const tree = createNested()
+*
+* const root = tree.register({ id: 'root', value: 'Root' })
+* const child1 = tree.register({ id: 'child-1', value: 'Child 1', parentId: 'root' })
+* const child2 = tree.register({ id: 'child-2', value: 'Child 2', parentId: 'root' })
+*
+* console.log(tree.getPath('child-1')) // ['root', 'child-1']
+* console.log(tree.getDescendants('root')) // ['child-1', 'child-2']
+* console.log(tree.isLeaf('child-2')) // true
+*
+* tree.open('root')
+* console.log(tree.opened('root')) // true
+* ```
+*/
+function createNested(_options = {}) {
+	const { open: openMode = "multiple", openAll = false, reveal: revealOnOpen = false, selection: selectionMode = "cascade", active: activeMode = "single", openStrategy, ...options } = _options;
+	const mandatoryOption = _options.mandatory ?? false;
+	const multipleOption = _options.multiple ?? true;
+	const resolvedOpenStrategy = openStrategy ?? resolveOpenStrategy(openMode);
+	const group = createGroup(options);
+	const logger$1 = useLogger();
+	const children = shallowReactive(/* @__PURE__ */ new Map());
+	const parents = shallowReactive(/* @__PURE__ */ new Map());
+	const openedIds = shallowReactive(/* @__PURE__ */ new Set());
+	const activeIds = shallowReactive(/* @__PURE__ */ new Set());
+	const rootIds = shallowReactive(/* @__PURE__ */ new Set());
+	let batching = false;
+	let pendingChildren;
+	let pendingParents;
+	let pendingRoots;
+	const activeItems = computed(() => {
+		return new Set(Array.from(activeIds).map((id) => group.get(id)).filter((item) => !/* @__PURE__ */ isUndefined(item)));
+	});
+	const activeIndexes = computed(() => {
+		return new Set(Array.from(activeItems.value).map((item) => item?.index).filter((index) => !/* @__PURE__ */ isUndefined(index)));
+	});
+	const openedItems = computed(() => {
+		return new Set(Array.from(openedIds).map((id) => group.get(id)).filter((item) => !/* @__PURE__ */ isUndefined(item)));
+	});
+	const roots = computed(() => {
+		return Array.from(rootIds).map((id) => group.get(id)).filter((item) => !/* @__PURE__ */ isUndefined(item));
+	});
+	const leaves = computed(() => {
+		return group.values().filter((item) => {
+			const childList = children.get(item.id);
+			return /* @__PURE__ */ isUndefined(childList) || childList.length === 0;
+		});
+	});
+	function opened(id) {
+		return openedIds.has(id);
+	}
+	function open(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			if (revealOnOpen) {
+				let parentId = parents.get(id);
+				while (!/* @__PURE__ */ isUndefined(parentId)) {
+					openedIds.add(parentId);
+					parentId = parents.get(parentId);
+				}
+			}
+			openedIds.add(id);
+			resolvedOpenStrategy.onOpen?.(id, context);
+		}
+	}
+	function close(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			openedIds.delete(id);
+			resolvedOpenStrategy.onClose?.(id, context);
+		}
+	}
+	function flip(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			if (opened(id)) close(id);
+			else open(id);
+		}
+	}
+	/**
+	* Open node(s) and their immediate non-leaf children.
+	* Useful for expanding a section with its immediate subcategories.
+	*/
+	function unfold(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			open(id);
+			const childIds = children.get(id) ?? [];
+			for (const childId of childIds) if (!isLeaf(childId)) open(childId);
+		}
+	}
+	/**
+	* Reveal a node by opening all its ancestors.
+	* Makes the node visible in a collapsed tree without opening the node itself.
+	*/
+	function reveal(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			const ancestorIds = getAncestors(id);
+			if (ancestorIds.length > 0) open(ancestorIds);
+		}
+	}
+	/**
+	* Fully expand a node and all its non-leaf descendants.
+	* Opens the entire subtree rooted at the given node.
+	*/
+	function expand(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			if (!isLeaf(id)) open(id);
+			for (const descendantId of getDescendants(id)) if (!isLeaf(descendantId)) open(descendantId);
+		}
+	}
+	function expandAll() {
+		for (const [id, childList] of children) if (childList.length > 0) openedIds.add(id);
+	}
+	function collapseAll() {
+		openedIds.clear();
+	}
+	function activated(id) {
+		return activeIds.has(id);
+	}
+	function activate(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			if (activeMode === "single") {
+				for (const activeId of activeIds) if (activeId !== id) activeIds.delete(activeId);
+			}
+			activeIds.add(id);
+		}
+	}
+	function deactivate(ids) {
+		for (const id of toArray(ids)) activeIds.delete(id);
+	}
+	function deactivateAll() {
+		activeIds.clear();
+	}
+	function getPath(id) {
+		const path = [];
+		let currentId = id;
+		while (!/* @__PURE__ */ isUndefined(currentId)) {
+			path.unshift(currentId);
+			currentId = parents.get(currentId);
+		}
+		return path;
+	}
+	function getAncestors(id) {
+		return getPath(id).slice(0, -1);
+	}
+	function getDescendants(id) {
+		const descendants = [];
+		const initial = children.get(id);
+		if (!initial) return descendants;
+		const queue = initial.slice();
+		let index = 0;
+		while (index < queue.length) {
+			const currentId = queue[index++];
+			descendants.push(currentId);
+			const childIds = children.get(currentId);
+			if (childIds) for (const cid of childIds) queue.push(cid);
+		}
+		return descendants;
+	}
+	function isLeaf(id) {
+		const childList = children.get(id);
+		return /* @__PURE__ */ isUndefined(childList) || childList.length === 0;
+	}
+	function getDepth(id) {
+		return getAncestors(id).length;
+	}
+	/**
+	* Check if `ancestorId` is an ancestor of `descendantId`.
+	* Returns false if either ID doesn't exist in the tree.
+	*/
+	function isAncestorOf(ancestorId, descendantId) {
+		if (!group.has(ancestorId) || !group.has(descendantId)) return false;
+		if (ancestorId === descendantId) return false;
+		let currentId = parents.get(descendantId);
+		while (!/* @__PURE__ */ isUndefined(currentId)) {
+			if (currentId === ancestorId) return true;
+			currentId = parents.get(currentId);
+		}
+		return false;
+	}
+	/**
+	* Check if `id` has `ancestorId` as an ancestor.
+	* Semantic alias for isAncestorOf(ancestorId, id).
+	*/
+	function hasAncestor(id, ancestorId) {
+		return isAncestorOf(ancestorId, id);
+	}
+	/**
+	* Get siblings of a node (including self).
+	* For root nodes, returns all root IDs.
+	*/
+	function siblings(id) {
+		if (!group.has(id)) return [];
+		const parentId = parents.get(id);
+		if (/* @__PURE__ */ isUndefined(parentId)) return group.values().filter((item) => /* @__PURE__ */ isUndefined(parents.get(item.id))).map((item) => item.id);
+		return children.get(parentId) ?? [];
+	}
+	/**
+	* Get 1-indexed position among siblings (for aria-posinset).
+	* Returns 0 if node not found.
+	*/
+	function position(id) {
+		const index = siblings(id).indexOf(id);
+		return index === -1 ? 0 : index + 1;
+	}
+	function updateAncestors(id) {
+		const { selectedIds, mixedIds } = group;
+		let parentId = parents.get(id);
+		while (!/* @__PURE__ */ isUndefined(parentId)) {
+			const childIds = children.get(parentId);
+			if (childIds && childIds.length > 0) {
+				const allSelected = childIds.every((cid) => selectedIds.has(cid));
+				const someSelected = !allSelected && childIds.some((cid) => selectedIds.has(cid) || mixedIds.has(cid));
+				if (allSelected) {
+					mixedIds.delete(parentId);
+					selectedIds.add(parentId);
+				} else if (someSelected) {
+					selectedIds.delete(parentId);
+					mixedIds.add(parentId);
+				} else {
+					mixedIds.delete(parentId);
+					selectedIds.delete(parentId);
+				}
+			}
+			parentId = parents.get(parentId);
+		}
+	}
+	function getLeafDescendants(id) {
+		return getDescendants(id).filter((did) => isLeaf(did));
+	}
+	function select(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			if (selectionMode === "independent") group.select(id);
+			else if (selectionMode === "leaf") if (isLeaf(id)) group.select(id);
+			else for (const lid of getLeafDescendants(id)) group.select(lid);
+			else {
+				if (!toValue(multipleOption)) {
+					group.select(id);
+					return;
+				}
+				const { selectedIds, mixedIds } = group;
+				mixedIds.delete(id);
+				selectedIds.add(id);
+				for (const did of getDescendants(id)) {
+					mixedIds.delete(did);
+					selectedIds.add(did);
+				}
+				updateAncestors(id);
+			}
+		}
+	}
+	function unselect(ids) {
+		for (const id of toArray(ids)) {
+			if (!group.has(id)) continue;
+			if (selectionMode === "independent") group.unselect(id);
+			else if (selectionMode === "leaf") if (isLeaf(id)) group.unselect(id);
+			else for (const lid of getLeafDescendants(id)) group.unselect(lid);
+			else {
+				const { selectedIds, mixedIds } = group;
+				if (toValue(mandatoryOption)) {
+					const toRemove = new Set([id, ...getDescendants(id)]);
+					if ([...selectedIds].every((sid) => toRemove.has(sid))) return;
+				}
+				mixedIds.delete(id);
+				selectedIds.delete(id);
+				for (const did of getDescendants(id)) {
+					mixedIds.delete(did);
+					selectedIds.delete(did);
+				}
+				updateAncestors(id);
+			}
+		}
+	}
+	function toggle(ids) {
+		for (const id of toArray(ids)) if (selectionMode === "independent") group.toggle(id);
+		else if (selectionMode === "leaf") if (isLeaf(id)) group.toggle(id);
+		else {
+			const leafIds = getLeafDescendants(id);
+			if (leafIds.every((lid) => group.selected(lid))) for (const lid of leafIds) group.unselect(lid);
+			else for (const lid of leafIds) group.select(lid);
+		}
+		else if (group.selected(id) || group.mixed(id)) unselect(id);
+		else select(id);
+	}
+	/**
+	* Converts the tree to a flat array with parentId references.
+	* Useful for serialization or sending to APIs/AI systems.
+	*/
+	function toFlat() {
+		return group.values().map((item) => ({
+			id: item.id,
+			parentId: parents.get(item.id),
+			value: item.value
+		}));
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
+		const parentId = registration.parentId;
+		const nested = registration.children;
+		if (!/* @__PURE__ */ isUndefined(parentId) && !group.has(parentId)) logger$1.warn(`Parent with id "${parentId}" does not exist. Registering "${id}" without parent.`);
+		if (!/* @__PURE__ */ isUndefined(parentId) && group.has(parentId)) {
+			if (batching) {
+				pendingParents.set(id, parentId);
+				const pending = pendingChildren.get(parentId);
+				if (pending) pending.push(id);
+				else {
+					const existing = children.get(parentId);
+					const list = existing ? [...existing, id] : [id];
+					pendingChildren.set(parentId, list);
+				}
+			} else {
+				parents.set(id, parentId);
+				const list = children.get(parentId);
+				children.set(parentId, list ? [...list, id] : [id]);
+			}
+			if (openAll) openedIds.add(parentId);
+		} else if (batching) {
+			pendingParents.set(id, void 0);
+			pendingRoots.add(id);
+		} else {
+			parents.set(id, void 0);
+			rootIds.add(id);
+		}
+		const { children: _, ...rest } = registration;
+		const item = {
+			...rest,
+			id,
+			parentId: batching ? pendingParents.get(id) : parents.get(id),
+			isOpen: toRef(() => opened(id)),
+			isActive: toRef(() => activated(id)),
+			isLeaf: toRef(() => isLeaf(id)),
+			depth: toRef(() => getDepth(id)),
+			open: () => open(id),
+			close: () => close(id),
+			flip: () => flip(id),
+			reveal: () => reveal(id),
+			activate: () => activate(id),
+			deactivate: () => deactivate(id),
+			getPath: () => getPath(id),
+			getAncestors: () => getAncestors(id),
+			getDescendants: () => getDescendants(id),
+			isAncestorOf: (descendantId) => isAncestorOf(id, descendantId),
+			hasAncestor: (ancestorId) => hasAncestor(id, ancestorId),
+			siblings: () => siblings(id),
+			position: () => position(id)
+		};
+		const ticket = group.register(item);
+		if (registration.active) activate(id);
+		if (nested?.length) for (const child of nested) register({
+			...child,
+			parentId: id
+		});
+		return ticket;
+	}
+	function unregister(id, cascade = false) {
+		if (!group.has(id)) return;
+		const parentId = parents.get(id);
+		if (!/* @__PURE__ */ isUndefined(parentId)) {
+			const siblings$1 = children.get(parentId);
+			if (siblings$1) {
+				const filtered = siblings$1.filter((sid) => sid !== id);
+				if (filtered.length === 0) children.delete(parentId);
+				else children.set(parentId, filtered);
+			}
+		}
+		const list = children.get(id);
+		if (list?.length) if (cascade) {
+			const descendantIds = getDescendants(id);
+			for (const did of descendantIds) {
+				parents.delete(did);
+				children.delete(did);
+				openedIds.delete(did);
+				activeIds.delete(did);
+				rootIds.delete(did);
+			}
+			group.offboard(descendantIds);
+		} else {
+			for (const did of getDescendants(id)) {
+				openedIds.delete(did);
+				activeIds.delete(did);
+			}
+			for (const cid of list) {
+				parents.set(cid, void 0);
+				rootIds.add(cid);
+			}
+		}
+		parents.delete(id);
+		children.delete(id);
+		openedIds.delete(id);
+		activeIds.delete(id);
+		rootIds.delete(id);
+		group.unregister(id);
+	}
+	function offboard(ids, cascade = false) {
+		for (const id of ids) unregister(id, cascade);
+	}
+	function onboard(registrations) {
+		batching = true;
+		pendingChildren = /* @__PURE__ */ new Map();
+		pendingParents = /* @__PURE__ */ new Map();
+		pendingRoots = /* @__PURE__ */ new Set();
+		try {
+			const result = group.batch(() => registrations.map((registration) => register(registration)));
+			for (const [id, list] of pendingChildren) children.set(id, list);
+			for (const [id, pid] of pendingParents) parents.set(id, pid);
+			for (const id of pendingRoots) rootIds.add(id);
+			return result;
+		} finally {
+			batching = false;
+			pendingChildren = void 0;
+			pendingParents = void 0;
+			pendingRoots = void 0;
+		}
+	}
+	function clear() {
+		children.clear();
+		parents.clear();
+		openedIds.clear();
+		activeIds.clear();
+		rootIds.clear();
+		group.reset();
+	}
+	function reset() {
+		clear();
+	}
+	const context = {
+		...group,
+		children,
+		parents,
+		openedIds,
+		openedItems,
+		activeIds,
+		activeItems,
+		activeIndexes,
+		roots,
+		leaves,
+		getPath,
+		getAncestors,
+		getDescendants,
+		isLeaf,
+		getDepth,
+		isAncestorOf,
+		hasAncestor,
+		siblings,
+		position,
+		open,
+		close,
+		flip,
+		opened,
+		unfold,
+		reveal,
+		expand,
+		expandAll,
+		collapseAll,
+		activate,
+		deactivate,
+		activated,
+		deactivateAll,
+		toFlat,
+		openStrategy: resolvedOpenStrategy,
+		select,
+		unselect,
+		toggle,
+		register,
+		unregister,
+		offboard,
+		onboard,
+		clear,
+		reset,
+		get size() {
+			return group.size;
+		}
+	};
+	return context;
+}
+/**
+* Creates a new nested context with provide/inject pattern.
+*
+* @param options The options for the nested context.
+* @returns A trinity tuple [useNested, provideNested, defaultNested]
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-nested
+*
+* @example
+* ```ts
+* import { createNestedContext } from '@vuetify/v0'
+*
+* export const [useTree, provideTree, tree] = createNestedContext()
+*
+* // In parent: provideTree()
+* // In child: const tree = useTree()
+* ```
+*/
+function createNestedContext(_options = {}) {
+	const { namespace = "v0:nested", ...options } = _options;
+	const [useNestedContext, _provideNestedContext] = createContext(namespace);
+	const context = createNested(options);
+	function provideNestedContext(_context = context, app) {
+		return _provideNestedContext(_context, app);
+	}
+	return createTrinity(useNestedContext, provideNestedContext, context);
+}
+/**
+* Returns the current nested instance from context.
+*
+* @param namespace The namespace for the nested context. Defaults to `'v0:nested'`.
+* @returns The current nested instance.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-nested
+*/
+function useNested(namespace = "v0:nested") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/createQueue/index.ts
+/**
+* @module createQueue
+*
+* @remarks
+* A queue composable for managing time-based collections with:
+* - Automatic timeout-based removal
+* - Pause/resume functionality
+* - FIFO (First In, First Out) ordering
+* - Manual dismissal support
+* - Queue progression management
+*
+* Built on top of createRegistry, the queue automatically manages timeouts for tickets,
+* ensuring only the first ticket in the queue is active at any time. When a ticket
+* expires or is removed, the next ticket in the queue automatically becomes active.
+*/
+/**
+* Creates a new queue instance
+*
+* @param options The options for the queue instance
+* @template Z The type of queue ticket that extends QueueTicket. Use this to add custom properties to tickets.
+* @template E The type of queue context that extends QueueContext<Z>. Use this when extending the queue with additional methods.
+* @returns A new queue instance
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @example
+* ```ts
+* import { useQueue } from '@vuetify/v0'
+*
+* const queue = useQueue()
+*
+* // Register an ticket with default timeout (3000ms)
+* const ticket1 = queue.register({ value: 'Ticket 1' })
+*
+* // Register an ticket with custom timeout
+* const ticket2 = queue.register({ value: 'Ticket 2', timeout: 5000 })
+*
+* // Register a persistent ticket that must be manually dismissed
+* const ticket3 = queue.register({ value: 'Ticket 3', timeout: -1 })
+*
+* // Dismiss an ticket using the convenience method
+* ticket3.dismiss()
+*
+* console.log(queue.size) // 2
+* ```
+*/
+function createQueue(_options = {}) {
+	const { timeout: _timeout = 3e3, ...options } = _options;
+	const registry = createRegistry({
+		...options,
+		events: true
+	});
+	const timeouts = /* @__PURE__ */ new Map();
+	function startTimeout(ticket) {
+		if (/* @__PURE__ */ isUndefined(ticket.timeout) || ticket.timeout < 0 || ticket.isPaused) return;
+		const timeout = setTimeout(() => {
+			timeouts.delete(ticket.id);
+			registry.unregister(ticket.id);
+			resume();
+		}, ticket.timeout);
+		timeouts.set(ticket.id, timeout);
+	}
+	function clearTimeout$1(id) {
+		const timeout = timeouts.get(id);
+		if (timeout) {
+			globalThis.clearTimeout(timeout);
+			timeouts.delete(id);
+		}
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
+		const timeout = Object.prototype.hasOwnProperty.call(registration, "timeout") ? registration.timeout : _timeout;
+		const ticket = {
+			...registration,
+			id,
+			timeout,
+			isPaused: registry.size > 0,
+			dismiss: () => unregister(id)
+		};
+		const registered = registry.register(ticket);
+		startTimeout(registered);
+		return registered;
+	}
+	function unregister(id) {
+		const ticket = /* @__PURE__ */ isUndefined(id) ? registry.seek("first") : registry.get(id);
+		if (!ticket) return void 0;
+		const wasFirst = ticket.index === 0;
+		clearTimeout$1(ticket.id);
+		registry.unregister(ticket.id);
+		if (wasFirst) resume();
+		return ticket;
+	}
+	function offboard(ids) {
+		let hadFirst = false;
+		for (const id of ids) {
+			const ticket = registry.get(id);
+			if (!ticket) continue;
+			if (ticket.index === 0) hadFirst = true;
+			clearTimeout$1(ticket.id);
+		}
+		registry.offboard(ids);
+		if (hadFirst) resume();
+	}
+	function pause() {
+		const ticket = registry.seek("first");
+		if (!ticket || ticket.isPaused) return void 0;
+		clearTimeout$1(ticket.id);
+		return registry.upsert(ticket.id, { isPaused: true });
+	}
+	function resume() {
+		const ticket = registry.seek("first");
+		if (!ticket || ticket.index !== 0 || !ticket.isPaused) return void 0;
+		const updated = registry.upsert(ticket.id, { isPaused: false });
+		startTimeout(updated);
+		return updated;
+	}
+	function clear() {
+		for (const id of timeouts.keys()) clearTimeout$1(id);
+		registry.clear();
+	}
+	function dispose() {
+		clear();
+		registry.dispose();
+	}
+	onScopeDispose(dispose, true);
+	function onboard(registrations) {
+		return registry.batch(() => registrations.map((registration) => register(registration)));
+	}
+	return {
+		...registry,
+		register,
+		unregister,
+		onboard,
+		offboard,
+		pause,
+		resume,
+		clear,
+		dispose,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new queue context.
+*
+* @param options The options for the queue context.
+* @template Z The type of the queue ticket.
+* @template E The type of the queue context.
+* @returns A new queue context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @example
+* ```ts
+* import { createQueueContext } from '@vuetify/v0'
+*
+* export const [useQueue, provideQueue, context] = createQueueContext({
+*   timeout: 5000,
+* })
+* ```
+*/
+function createQueueContext(_options = {}) {
+	const { namespace = "v0:queue", ...options } = _options;
+	const [useQueueContext, _provideQueueContext] = createContext(namespace);
+	const context = createQueue(options);
+	function provideQueueContext(_context = context, app) {
+		return _provideQueueContext(_context, app);
+	}
+	return createTrinity(useQueueContext, provideQueueContext, context);
+}
+/**
+* Returns the current queue instance.
+*
+* @param namespace The namespace for the queue context. Defaults to `'v0:queue'`.
+* @returns The current queue instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useQueue } from '@vuetify/v0'
+*
+*   const queue = useQueue()
+* <\/script>
+* ```
+*/
+function useQueue(namespace = "v0:queue") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useStack/index.ts
+/**
+* @module useStack
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-stack
+*
+* @remarks
+* Overlay z-index stacking composable with:
+* - Global reactive registry of active overlays
+* - Automatic z-index calculation based on selection order
+* - `globalTop` tracking - is this ticket topmost globally?
+* - Manual select/unselect for explicit control
+* - Auto-cleanup when registered within component setup
+*
+* Built on createSelection for consistent ticket-based management.
+*/
+/**
+* Creates a new stack instance for managing overlay z-indexes.
+*
+* @param options Configuration options
+* @returns Stack context with registry methods and scrim helpers
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-stack
+*
+* @example
+* ```ts
+* import { createStack } from '@vuetify/v0'
+*
+* const stack = createStack({ baseZIndex: 1000 })
+*
+* const ticket = stack.register({
+*   onDismiss: () => console.log('dismissed'),
+*   blocking: false,
+* })
+*
+* ticket.select()  // Activate overlay
+* console.log(ticket.zIndex.value)  // 1000
+*
+* ticket.unselect()  // Deactivate overlay
+* ```
+*/
+function createStack(_options = {}) {
+	const { baseZIndex = 2e3, increment = 10, ...options } = _options;
+	const selection = createSelection({
+		...options,
+		multiple: true
+	});
+	const isActive = toRef(() => selection.selectedIds.size > 0);
+	const top = toRef(() => {
+		const ids$1 = Array.from(selection.selectedIds);
+		if (ids$1.length === 0) return void 0;
+		return selection.get(ids$1.at(-1));
+	});
+	const scrimZIndex = toRef(() => {
+		const ticket = top.value;
+		return ticket ? ticket.zIndex.value - 1 : 0;
+	});
+	const isBlocking = toRef(() => top.value?.blocking ?? false);
+	function ids() {
+		return Array.from(selection.selectedIds);
+	}
+	function register(input = {}) {
+		const id = input.id ?? /* @__PURE__ */ useId$1();
+		const blocking = input.blocking ?? false;
+		const onDismiss = input.onDismiss;
+		const zIndex = computed(() => {
+			const position = ids().indexOf(id);
+			if (position === -1) return baseZIndex;
+			return baseZIndex + position * increment;
+		});
+		const globalTop = computed(() => {
+			const list = ids();
+			if (list.length === 0) return false;
+			return list.at(-1) === id;
+		});
+		function dismiss() {
+			if (blocking) return;
+			onDismiss?.();
+			selection.unselect(id);
+		}
+		const ticket = selection.register({
+			blocking,
+			onDismiss,
+			zIndex,
+			globalTop,
+			dismiss,
+			...input,
+			id
+		});
+		if (instanceExists()) onScopeDispose(() => {
+			selection.unregister(id);
+		}, true);
+		return ticket;
+	}
+	return {
+		...selection,
+		register,
+		isActive,
+		top,
+		scrimZIndex,
+		isBlocking,
+		get size() {
+			return selection.size;
+		}
+	};
+}
+/**
+* Creates a stack context trinity for provide/inject usage.
+*
+* @param options Configuration options including namespace
+* @returns Trinity of [useStackContext, provideStackContext, context]
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-stack
+*
+* @example
+* ```ts
+* import { createStackContext } from '@vuetify/v0'
+*
+* const [useMyStack, provideMyStack, myStack] = createStackContext({
+*   namespace: 'my:stack',
+*   baseZIndex: 3000,
+* })
+*
+* // In parent component:
+* provideMyStack()
+*
+* // In child component:
+* const stack = useMyStack()
+* ```
+*/
+function createStackContext(_options = {}) {
+	const { namespace = "v0:stack", ...options } = _options;
+	const [useStackContext, _provideStackContext] = createContext(namespace);
+	const context = createStack(options);
+	function provideStackContext(_context = context, app) {
+		return _provideStackContext(_context, app);
+	}
+	return createTrinity(useStackContext, provideStackContext, context);
+}
+/**
+* Creates a Vue plugin to provide stack context at app level.
+*
+* @param options Configuration options
+* @returns Vue plugin instance
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-stack
+*
+* @example
+* ```ts
+* import { createApp } from 'vue'
+* import { createStackPlugin } from '@vuetify/v0'
+*
+* const app = createApp(App)
+* app.use(createStackPlugin({ baseZIndex: 2000 }))
+* app.mount('#app')
+* ```
+*/
+function createStackPlugin(_options = {}) {
+	const { namespace = "v0:stack", ...options } = _options;
+	const [, provideStackContext, context] = createStackContext({
+		...options,
+		namespace
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			provideStackContext(context, app);
+		}
+	});
+}
+let fallbackStack;
+function getStackFallback() {
+	if (!fallbackStack) fallbackStack = createStack();
+	return fallbackStack;
+}
+/**
+* Returns the current stack context.
+*
+* @param namespace The namespace for the stack context. Defaults to 'v0:stack'.
+* @returns The stack context instance
+*
+* @remarks Falls back to an internal shared instance if no provider exists.
+* For SSR safety, use createStackPlugin to provide isolated context per app.
+*
+* Tickets registered within component setup are automatically unregistered
+* when the component is unmounted.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-stack
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { shallowRef, watch } from 'vue'
+*   import { useStack } from '@vuetify/v0'
+*
+*   const stack = useStack()
+*   const isOpen = shallowRef(false)
+*
+*   // Ticket is auto-cleaned up when component unmounts
+*   const ticket = stack.register({
+*     onDismiss: () => { isOpen.value = false },
+*   })
+*
+*   // Sync selection state with isOpen
+*   watch(isOpen, v => v ? ticket.select() : ticket.unselect())
+* <\/script>
+*
+* <template>
+*   <button @click="isOpen = true">Open</button>
+*   <div v-if="isOpen" :style="{ zIndex: ticket.zIndex.value }">
+*     <p>Dialog content</p>
+*     <button @click="ticket.dismiss()">Close</button>
+*   </div>
+* </template>
+* ```
+*/
+function useStack(namespace = "v0:stack") {
+	const fallback = getStackFallback();
+	if (!instanceExists()) return fallback;
+	try {
+		return useContext(namespace);
+	} catch {
+		return fallback;
+	}
+}
+
+//#endregion
+//#region src/composables/createStep/index.ts
+/**
+* @module useStep
+*
+* @remarks
+* Navigation composable that extends useSingle with first/last/next/prev/step methods.
+*
+* Key features:
+* - Configurable circular or bounded navigation
+* - Automatic disabled item skipping
+* - Arbitrary step counts (positive/negative)
+* - Perfect for wizards, carousels, pagination, onboarding flows
+*
+* Inheritance chain: useRegistry → useSelection → useSingle → useStep
+*/
+/**
+* Creates a new step instance with navigation through items.
+*
+* Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
+* for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
+*
+* @param options The options for the step instance.
+* @template Z The type of the step ticket.
+* @template E The type of the step context.
+* @returns A new step instance with navigation methods.
+*
+* @remarks
+* **Key Features:**
+* - **Configurable Navigation**: `circular: true` for wrapping, `false` for bounded (default: false)
+* - **Disabled Item Skipping**: Automatically skips disabled items during navigation
+* - **Bidirectional**: Forward (`next`, positive `step`) and backward (`prev`, negative `step`)
+* - **Safe Edge Cases**: Handles empty registries and all-disabled scenarios gracefully
+*
+* **Navigation Methods:**
+* - `first()`: Select first non-disabled item
+* - `last()`: Select last non-disabled item
+* - `next()`: Move to next item (wraps if circular, stops at end if bounded)
+* - `prev()`: Move to previous item (wraps if circular, stops at start if bounded)
+* - `step(count)`: Move by `count` positions (negative for backward)
+*
+* **Circular Mode (`circular: true`):**
+* - Uses modulo arithmetic for wrapping: `((index % length) + length) % length`
+* - Works correctly with negative indexes and large step counts
+* - Perfect for carousels, theme switchers, infinite scrolling
+*
+* **Bounded Mode (`circular: false`, default):**
+* - Navigation stops at boundaries (no wrapping)
+* - `next()` on last item does nothing
+* - `prev()` on first item does nothing
+* - Perfect for pagination, wizards with explicit completion, forms
+*
+* **Inheritance Chain:**
+* `useRegistry` → `createSelection` → `createSingle` → `createStep`
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-step
+*
+* @example
+* ```ts
+* import { createStep } from '@vuetify/v0'
+*
+* // Bounded navigation (default) - for pagination
+* const pagination = createStep({ circular: false })
+* pagination.onboard([
+*   { id: 'page-1', value: 1 },
+*   { id: 'page-2', value: 2 },
+*   { id: 'page-3', value: 3 },
+* ])
+* pagination.first() // Select page 1
+* pagination.prev() // Does nothing (already at first)
+* pagination.next() // Select page 2
+*
+* // Circular navigation - for carousels
+* const carousel = createStep({ circular: true })
+* carousel.onboard([
+*   { id: 'slide-1', value: 'First' },
+*   { id: 'slide-2', value: 'Second' },
+*   { id: 'slide-3', value: 'Third' },
+* ])
+* carousel.first()
+* carousel.prev() // Wraps to 'slide-3'
+* carousel.next() // Wraps to 'slide-1'
+* ```
+*/
+function createStep(_options = {}) {
+	const { circular = false, ...options } = _options;
+	const registry = createSingle(options);
+	function first() {
+		const ticket = registry.seek("first");
+		if (ticket) registry.select(ticket.id);
+	}
+	function last() {
+		const ticket = registry.seek("last");
+		if (ticket) registry.select(ticket.id);
+	}
+	function next() {
+		step(1);
+	}
+	function prev() {
+		step(-1);
+	}
+	function wrapped(length, index) {
+		return (index % length + length) % length;
+	}
+	function step(count = 1) {
+		const length = registry.size;
+		if (!length) return;
+		const currentIndex = registry.selectedIndex.value;
+		const direction = Math.sign(count || 1);
+		let hops = 0;
+		let index = circular ? wrapped(length, currentIndex + count) : currentIndex + count;
+		if (!circular && (index < 0 || index >= length)) return;
+		let id = registry.lookup(index);
+		while (!/* @__PURE__ */ isUndefined(id) && toValue(registry.get(id)?.disabled) && hops < length) {
+			index = circular ? wrapped(length, index + direction) : index + direction;
+			if (!circular && (index < 0 || index >= length)) return;
+			id = registry.lookup(index);
+			hops++;
+		}
+		if (/* @__PURE__ */ isUndefined(id) || hops === length) return;
+		registry.selectedIds.clear();
+		registry.select(id);
+	}
+	return {
+		...registry,
+		first,
+		last,
+		next,
+		prev,
+		step,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new step context.
+*
+* @param options The options for the step context.
+* @template Z The input ticket type.
+* @template E The output ticket type.
+* @template R The context type.
+* @returns A new step context.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-step
+*
+* @example
+* ```ts
+* import { createStepContext } from '@vuetify/v0'
+*
+* // With default namespace 'v0:step'
+* export const [useStep, provideStep, context] = createStepContext()
+*
+* // In a parent component:
+* provideStep()
+*
+* // In a child component:
+* const context = useStep()
+* context.next() // Progress to next step
+* ```
+*/
+function createStepContext(_options = {}) {
+	const { namespace = "v0:step", ...options } = _options;
+	const [useStepContext, _provideStepContext] = createContext(namespace);
+	const context = createStep(options);
+	function provideStepContext(_context = context, app) {
+		return _provideStepContext(_context, app);
+	}
+	return createTrinity(useStepContext, provideStepContext, context);
+}
+/**
+* Returns the current step instance.
+*
+* @param namespace The namespace for the step context. Defaults to `'v0:step'`.
+* @template Z The input ticket type.
+* @template E The output ticket type.
+* @template R The context type.
+* @returns The current step instance.
+*
+* @see https://0.vuetifyjs.com/composables/selection/use-step
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useStep } from '@vuetify/v0'
+*
+*   const wizard = useStep()
+* <\/script>
+*
+* <template>
+*   <div>
+*     <p>Current step: {{ wizard.selectedIndex }}</p>
+*     <button @click="wizard.next()">Next</button>
+*   </div>
+* </template>
+* ```
+*/
+function useStep(namespace = "v0:step") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/useStorage/index.ts
+/**
+* @module useStorage
+*
+* @remarks
+* Reactive storage composable with adapter pattern for localStorage, sessionStorage, or memory.
+*
+* Key features:
+* - Reactive refs that sync with storage
+* - localStorage, sessionStorage, and memory adapters
+* - Custom serialization support
+* - SSR fallback to memory adapter
+* - Automatic cleanup on remove/clear
+*
+* Uses adapter pattern to abstract storage implementation details.
+*/
+/**
+* Creates a new storage instance.
+*
+* @param options The options for the storage instance.
+* @template E The type of the storage context.
+* @returns A new storage instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-storage
+*
+* @example
+* ```ts
+* import { createStorage } from '@vuetify/v0'
+*
+* const storage = createStorage()
+*
+* storage.set('username', 'MyUsername')
+*
+* const username = storage.get('username')
+*
+* console.log(username.value) // MyUsername
+*
+* storage.clear()
+* ```
+*/
+function createStorage(options = {}) {
+	const { adapter = IN_BROWSER ? window.localStorage : new MemoryAdapter(), prefix = "v0:", serializer = {
+		read: JSON.parse,
+		write: JSON.stringify
+	} } = options;
+	const cache = /* @__PURE__ */ new Map();
+	const watchers = /* @__PURE__ */ new Map();
+	function has(key) {
+		const prefixedKey = `${prefix}${key}`;
+		return cache.has(prefixedKey);
+	}
+	function get(key, defaultValue) {
+		const prefixedKey = `${prefix}${key}`;
+		if (cache.has(prefixedKey)) return cache.get(prefixedKey);
+		const storedValue = adapter?.getItem(prefixedKey);
+		let initialValue = defaultValue;
+		if (storedValue) try {
+			initialValue = serializer.read(storedValue);
+		} catch (error) {
+			console.error(`[v0:storage] Failed to parse stored value for key "${prefixedKey}":`, error);
+		}
+		const valueRef = ref(initialValue);
+		const stop = watch(valueRef, (newValue) => {
+			if (/* @__PURE__ */ isNullOrUndefined(newValue)) adapter?.removeItem(prefixedKey);
+			else try {
+				adapter?.setItem(prefixedKey, serializer.write(newValue));
+			} catch (error) {
+				console.error(`[v0:storage] Failed to write key "${prefixedKey}":`, error);
+			}
+		}, { deep: true });
+		watchers.set(prefixedKey, stop);
+		cache.set(prefixedKey, valueRef);
+		return valueRef;
+	}
+	function set(key, value) {
+		const valueRef = get(key);
+		valueRef.value = value;
+	}
+	function remove(key) {
+		const prefixedKey = `${prefix}${key}`;
+		const stop = watchers.get(prefixedKey);
+		if (!stop) return;
+		stop();
+		watchers.delete(prefixedKey);
+		adapter?.removeItem(prefixedKey);
+		cache.delete(prefixedKey);
+	}
+	function clear() {
+		if (watchers.size > 0) {
+			for (const stop of watchers.values()) stop();
+			watchers.clear();
+		}
+		if (cache.size > 0) {
+			for (const key of cache.keys()) adapter?.removeItem(key);
+			cache.clear();
+		}
+	}
+	if (IN_BROWSER && adapter === window.localStorage) useWindowEventListener("storage", (e) => {
+		if (!e.key?.startsWith(prefix)) return;
+		const valueRef = cache.get(e.key);
+		if (!valueRef) return;
+		watchers.get(e.key)?.();
+		valueRef.value = e.newValue == null ? void 0 : serializer.read(e.newValue);
+		const stop = watch(valueRef, (newValue) => {
+			if (/* @__PURE__ */ isNullOrUndefined(newValue)) adapter?.removeItem(e.key);
+			else try {
+				adapter?.setItem(e.key, serializer.write(newValue));
+			} catch (error) {
+				console.error(`[v0:storage] Failed to write key "${e.key}":`, error);
+			}
+		}, { deep: true });
+		watchers.set(e.key, stop);
+	});
+	return {
+		has,
+		get,
+		set,
+		remove,
+		clear
+	};
+}
+function createStorageFallback() {
+	return createStorage({ adapter: new MemoryAdapter() });
+}
+const [createStorageContext, createStoragePlugin, useStorage] = createPluginContext("v0:storage", (options) => createStorage(options), { fallback: () => createStorageFallback() });
+
+//#endregion
+//#region src/composables/createTimeline/index.ts
+/**
+* @module createTimeline
+*
+* @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.
+*/
+/**
+* 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 = 10, ...options } = _options;
+	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();
+		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;
+	const [useTimelineContext, _provideTimelineContext] = createContext(namespace);
+	const context = createTimeline(options);
+	function provideTimelineContext(_context = context, app) {
+		return _provideTimelineContext(_context, app);
+	}
+	return createTrinity(useTimelineContext, provideTimelineContext, context);
+}
+/**
+* Returns the current timeline instance.
+*
+* @param namespace The namespace for the timeline context. Defaults to `'v0:timeline'`.
+* @returns The current timeline instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/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/useToggleScope/index.ts
+/**
+* @module useToggleScope
+*
+* @remarks
+* Conditionally manages an effect scope based on a reactive boolean condition.
+* When the source becomes true, creates and runs an effect scope. When false, stops the scope.
+* All reactive effects created within the scoped function are automatically cleaned up on deactivation.
+*
+* Key features:
+* - Uses Vue's effectScope for efficient reactive effect lifecycle management
+* - Automatic cleanup when condition becomes false
+* - Supports optional reset callback for scope restart capability
+* - Handles rapid toggling and parent scope disposal safely
+* - SSR-safe (effectScope is part of Vue core)
+*
+* Perfect for conditional side effects, feature flags, and performance optimization
+* by only running reactive effects when needed.
+*/
+/**
+* Conditionally manages an effect scope based on a reactive boolean source.
+*
+* @param source A reactive boolean value or getter that controls the scope lifecycle
+* @param fn The function to run within the effect scope. Can optionally receive controls for manual scope management.
+* @returns Controls object with isActive state and start/stop/reset methods
+*
+* @see https://vuejs.org/api/reactivity-advanced.html#effectscope
+* @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useToggleScope } from '@vuetify/v0'
+*
+* const isEnabled = ref(false)
+*
+* const { isActive } = useToggleScope(isEnabled, () => {
+*   // This code runs when isEnabled becomes true
+*   const unwatch = watch(someRef, () => {
+*     console.log('Watching...')
+*   })
+*
+*   // Cleanup happens automatically when isEnabled becomes false
+* })
+*
+* // Toggle the scope on/off
+* isEnabled.value = true  // Starts the scope
+* console.log(isActive.value) // true
+* isEnabled.value = false // Stops and cleans up
+* console.log(isActive.value) // false
+* ```
+*
+* @example
+* With manual controls:
+* ```ts
+* const isEnabled = ref(true)
+*
+* useToggleScope(isEnabled, (controls) => {
+*   // Access controls inside the scope
+*   console.log('Active:', controls.isActive.value)
+*
+*   // Manually reset the scope if needed
+*   someEvent.on('reset', () => controls.reset())
+* })
+* ```
+*/
+function useToggleScope(source, fn) {
+	const scope = shallowRef();
+	const isActive = toRef(() => !!scope.value);
+	function start() {
+		if (scope.value) return;
+		scope.value = effectScope();
+		scope.value.run(() => fn.length > 0 ? fn(controls) : fn());
+	}
+	function stop() {
+		scope.value?.stop();
+		scope.value = void 0;
+	}
+	function reset() {
+		stop();
+		start();
+	}
+	const controls = {
+		isActive: shallowReadonly(isActive),
+		start,
+		stop,
+		reset
+	};
+	watch(source, (active) => {
+		if (active && !scope.value) start();
+		else if (!active) stop();
+	}, { immediate: true });
+	onScopeDispose(stop, true);
+	return controls;
+}
+
+//#endregion
+//#region src/composables/createVirtual/index.ts
+/**
+* @module createVirtual
+*
+* @remarks
+* Virtual scrolling composable for efficiently rendering large lists.
+*
+* Key features:
+* - Renders only visible items (viewport + overscan)
+* - Dynamic or fixed item heights
+* - SSR-safe (checks IN_BROWSER)
+* - Bidirectional scrolling (forward/reverse for chat apps)
+* - Scroll anchoring (maintains position across data changes)
+* - Edge detection for infinite scroll
+* - iOS momentum and elastic scrolling
+* - Configurable overscan (extra items rendered for smooth scrolling)
+*
+* Perfect for large data sets, chat apps, and infinite scroll implementations.
+*/
+/**
+* Virtual scrolling composable for efficiently rendering large lists
+*
+* @param items Reactive array of items to virtualize
+* @param options Configuration options
+* @returns Virtual scrolling context
+*
+* @see https://0.vuetifyjs.com/composables/utilities/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>
+* ```
+*/
+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)));
+	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) => {
+		if (!entries[0]) return;
+		viewportHeight.value = entries[0].contentRect.height;
+		update();
+	});
+	watch(items, (newItems) => {
+		captureAnchor();
+		const length = newItems.length;
+		const newHeights = heights.value.length === length ? heights.value : Array.from({ length }, () => null);
+		if (heights.value !== newHeights) heights.value = newHeights;
+		rebuild();
+	}, { immediate: true });
+	watch(element, () => {
+		if (!element.value) return;
+		if (direction === "reverse" && items.value.length > 0) {
+			const lastIndex = items.value.length - 1;
+			const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || itemHeight.value);
+			element.value.scrollTop = totalHeight;
+		}
+		update();
+	});
+	function captureAnchor() {
+		if (!element.value || anchor === "auto") return;
+		if (anchor === "start") {
+			anchorIndex = 0;
+			anchorOffset = 0;
+		} else if (anchor === "end") {
+			anchorIndex = items.value.length - 1;
+			anchorOffset = 0;
+		} else if (/* @__PURE__ */ isFunction(anchor)) {
+			const result = anchor(items.value);
+			if (/* @__PURE__ */ isNumber(result)) {
+				anchorIndex = result;
+				anchorOffset = element.value.scrollTop - (offsets.value[result] || 0);
+			}
+		} else {
+			/* 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$1 = 0;
+		for (let i = 0; i < length; i++) {
+			newOffsets[i] = offset$1;
+			offset$1 += heights.value[i] || itemHeight.value;
+		}
+		if (offsets.value !== newOffsets) offsets.value = newOffsets;
+		update();
+		restoreAnchor();
+	}
+	function findIndex(scrollTop) {
+		const arr = offsets.value;
+		if (arr.length === 0) return 0;
+		let low = 0;
+		let high = arr.length - 1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			if (arr[mid] <= scrollTop) low = mid + 1;
+			else high = mid - 1;
+		}
+		return Math.max(0, high);
+	}
+	function update() {
+		if (!element.value) return;
+		const viewport = viewportHeight.value || cachedViewport;
+		if (!viewport || !itemHeight.value) return;
+		const scrollTop = element.value.scrollTop || 0;
+		const length = items.value.length;
+		const visibleStart = findIndex(scrollTop);
+		const visibleEnd = findIndex(scrollTop + viewport) + 1;
+		const start = /* @__PURE__ */ clamp(visibleStart - overscan, 0, length);
+		const end = /* @__PURE__ */ clamp(visibleEnd + overscan, start, length);
+		first.value = start;
+		last.value = end;
+		offset.value = offsets.value[start] || 0;
+		const lastIndex = length - 1;
+		const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || itemHeight.value);
+		size.value = totalHeight - (offsets.value[end] || totalHeight);
+	}
+	function checkEdges() {
+		if (!element.value) return;
+		const scrollTop = element.value.scrollTop;
+		const scrollHeight = element.value.scrollHeight;
+		const clientHeight = element.value.clientHeight;
+		const distanceFromStart = scrollTop;
+		const distanceFromEnd = scrollHeight - (scrollTop + clientHeight);
+		if (IN_BROWSER) {
+			cancelAnimationFrame(edgeRaf);
+			edgeRaf = requestAnimationFrame(() => {
+				if (onStartReached && distanceFromStart <= startThreshold) onStartReached(distanceFromStart);
+				if (onEndReached && distanceFromEnd <= endThreshold) onEndReached(distanceFromEnd);
+			});
+		} else {
+			if (onStartReached && distanceFromStart <= startThreshold) onStartReached(distanceFromStart);
+			if (onEndReached && distanceFromEnd <= endThreshold) onEndReached(distanceFromEnd);
+		}
+		/* v8 ignore stop */
+	}
+	function resize(index, height$1) {
+		if (heights.value[index] === height$1) return;
+		heights.value[index] = height$1;
+		if (!itemHeight.value) itemHeight.value = height$1;
+		if (IN_BROWSER) {
+			cancelAnimationFrame(rebuildRaf);
+			rebuildRaf = requestAnimationFrame(rebuild);
+		} else rebuild();
+		/* v8 ignore stop */
+	}
+	function scroll() {
+		if (IN_BROWSER) {
+			cancelAnimationFrame(raf);
+			raf = requestAnimationFrame(update);
+			checkEdges();
+		} else update();
+		/* v8 ignore stop */
+	}
+	function scrollTo(index, scrollOptions) {
+		if (!element.value) return;
+		const targetOffset = offsets.value[index] || 0;
+		const behavior = scrollOptions?.behavior ?? "auto";
+		const block = scrollOptions?.block ?? "start";
+		const extraOffset = scrollOptions?.offset ?? 0;
+		let scrollTop = targetOffset + extraOffset;
+		switch (block) {
+			case "center": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const itemH = heights.value[index] || itemHeight.value;
+				scrollTop = targetOffset - viewport / 2 + itemH / 2 + extraOffset;
+				break;
+			}
+			case "end": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const itemH = heights.value[index] || itemHeight.value;
+				scrollTop = targetOffset - viewport + itemH + extraOffset;
+				break;
+			}
+			case "nearest": {
+				const viewport = viewportHeight.value || cachedViewport;
+				const currentScroll = element.value.scrollTop;
+				const itemH = heights.value[index] || itemHeight.value;
+				if (targetOffset < currentScroll) scrollTop = targetOffset + extraOffset;
+				else if (targetOffset + itemH > currentScroll + viewport) scrollTop = targetOffset - viewport + itemH + extraOffset;
+				else return;
+				break;
+			}
+		}
+		if (behavior === "smooth") element.value.scrollTo({
+			top: scrollTop,
+			behavior: "smooth"
+		});
+		else element.value.scrollTop = scrollTop;
+		update();
+	}
+	function reset() {
+		state.value = "ok";
+		anchorIndex = -1;
+		anchorOffset = 0;
+		if (element.value && direction === "reverse" && items.value.length > 0) {
+			const lastIndex = items.value.length - 1;
+			const totalHeight = (offsets.value[lastIndex] || 0) + (heights.value[lastIndex] || itemHeight.value);
+			element.value.scrollTop = totalHeight;
+		}
+	}
+	onScopeDispose(() => {
+		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/utilities/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;
+	const [useVirtualContext, _provideVirtualContext] = createContext(namespace);
+	const context = createVirtual(items, options);
+	function provideVirtualContext(_context = context, app) {
+		return _provideVirtualContext(_context, app);
+	}
+	return createTrinity(useVirtualContext, provideVirtualContext, context);
+}
+/**
+* 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/utilities/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/useEventListener/index.ts
+/**
+* @module useEventListener
+*
+* @remarks
+* Event listener composable with automatic cleanup on scope disposal.
+*
+* Key features:
+* - Supports Window, Document, and HTMLElement targets
+* - Reactive targets, events, and listeners
+* - Event options support (capture, passive, once)
+* - Automatic removeEventListener on unmount
+* - Multiple overloads for type safety
+*
+* Perfect for safely managing event listeners in Vue components.
+*/
+/**
+* Attaches an event listener to a target.
+*
+* @param target The target to attach the event listener to.
+* @param event The event to listen for.
+* @param listener The event listener.
+* @param options The event listener options.
+* @returns A function to remove the event listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-event-listener
+*/
+function useEventListener(target, event, listener, options) {
+	const cleanups = [];
+	function cleanup() {
+		for (const fn of cleanups) fn();
+		cleanups.length = 0;
+	}
+	function register(el, event$1, listener$1, options$1) {
+		el.addEventListener(event$1, listener$1, options$1);
+		return () => el.removeEventListener(event$1, listener$1, options$1);
+	}
+	const stopWatcher = watch(() => [
+		toValue(target),
+		toValue(event),
+		unref(listener),
+		toValue(options)
+	], ([el, events, listeners, opts]) => {
+		cleanup();
+		if (!el) return;
+		const eventList = toArray(events);
+		const listenerList = toArray(listeners);
+		for (const event$1 of eventList) for (const listenerFn of listenerList) cleanups.push(register(el, event$1, listenerFn, opts));
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	function stop() {
+		stopWatcher();
+		cleanup();
+	}
+	onScopeDispose(stop, true);
+	return stop;
+}
+/**
+* Attaches an event listener to the window.
+*
+* @param event The event to listen for.
+* @param listener The event listener.
+* @param options The event listener options.
+* @template E The event type.
+* @returns A function to remove the event listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-event-listener
+*/
+function useWindowEventListener(event, listener, options) {
+	return IN_BROWSER ? useEventListener(window, event, listener, options) : () => {};
+}
+/**
+* Attaches an event listener to the document.
+*
+* @param event The event to listen for.
+* @param listener The event listener.
+* @param options The event listener options.
+* @template E The event type.
+* @returns A function to remove the event listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-event-listener
+*/
+function useDocumentEventListener(event, listener, options) {
+	return IN_BROWSER ? useEventListener(document, event, listener, options) : () => {};
+}
+
+//#endregion
+//#region src/composables/useClickOutside/index.ts
+/**
+* @module useClickOutside
+*
+* @remarks
+* Detects clicks outside of specified element(s) with automatic cleanup.
+*
+* Key features:
+* - Two-phase detection (pointerdown → pointerup) prevents drag-out false positives
+* - Touch scroll threshold ignores swipes/scrolls on mobile
+* - Capture phase listeners work with stopPropagation
+* - Pause/resume/stop functionality
+* - Optional iframe focus detection
+* - SSR-safe (no-op when not in browser)
+*
+* Common use cases: closing popovers, dropdowns, modals, and menus.
+*
+* Accessibility: This composable handles pointer interactions only. For accessible
+* components (dialogs, popovers, menus), pair with `useHotkey` for Escape key
+* dismissal per WCAG/APG requirements.
+*/
+/**
+* Detects clicks outside of the specified element(s).
+*
+* Uses two-phase detection (pointerdown → pointerup) to prevent false positives
+* when users drag from inside to outside an element.
+*
+* @param target Element ref(s) to detect clicks outside of. Accepts a single ref/getter or array of refs/getters.
+* @param handler Callback invoked when a click outside is detected.
+* @param options Configuration options.
+* @returns An object with methods to control the listener.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-click-outside
+*
+* @example Native element ref
+* ```ts
+* const menuRef = useTemplateRef<HTMLElement>('menu')
+*
+* useClickOutside(menuRef, () => { isOpen.value = false })
+* ```
+*
+* @example Component ref (e.g., Atom)
+* ```ts
+* const atomRef = useTemplateRef<AtomExpose>('atom')
+*
+* // Pass the exposed element TemplateRef via getter
+* useClickOutside(
+*   () => atomRef.value?.element,
+*   () => { isOpen.value = false }
+* )
+* ```
+*
+* @example Multiple targets
+* ```ts
+* const popoverRef = useTemplateRef<AtomExpose>('popover')
+* const anchorRef = useTemplateRef<HTMLElement>('anchor')
+*
+* useClickOutside(
+*   [() => popoverRef.value?.element, anchorRef],
+*   () => { isOpen.value = false }
+* )
+* ```
+*
+* @example Ignoring elements (CSS selectors or refs)
+* ```ts
+* useClickOutside(
+*  () => navRef.value?.element,
+*  () => { isOpen.value = false },
+*  { ignore: ['[data-app-bar]'] }
+* )
+* ```
+*
+* @example Native dialog with bounds detection
+* ```ts
+* // For native <dialog> elements, use bounds mode to detect backdrop clicks
+* const dialogRef = useTemplateRef<HTMLDialogElement>('dialog')
+*
+* useClickOutside(
+*   dialogRef,
+*   () => { dialogRef.value?.close() },
+*   { bounds: true }
+* )
+* ```
+*/
+function useClickOutside(target, handler, options = {}) {
+	const { capture = true, touchScrollThreshold = 30, detectIframe = false, ignore = [], bounds = false } = options;
+	const isPaused = shallowRef(false);
+	const isActive = toRef(() => !isPaused.value);
+	let initialTarget = null;
+	let startPosition = {
+		x: 0,
+		y: 0
+	};
+	let cleanupPointerDown;
+	let cleanupPointerUp;
+	let cleanupBlur;
+	/**
+	* Resolve target(s) to an array of HTMLElements.
+	*/
+	function getTargets() {
+		return toArray(target).map((source) => toValue(source)).filter((el) => !!el && /* @__PURE__ */ isFunction(el.contains));
+	}
+	/**
+	* Resolve ignore targets to a tuple of [selectors, elements].
+	* Called once per event to avoid repeated toValue() calls in hot path.
+	*/
+	function resolveIgnoreTargets() {
+		const ignoreTargets = toValue(ignore);
+		if (ignoreTargets.length === 0) return [[], []];
+		const selectors = [];
+		const elements = [];
+		for (const ignoreTarget of ignoreTargets) if (/* @__PURE__ */ isString(ignoreTarget)) selectors.push(ignoreTarget);
+		else {
+			const ignoreEl = toValue(ignoreTarget);
+			if (ignoreEl) elements.push(ignoreEl);
+		}
+		return [selectors, elements];
+	}
+	/**
+	* Check if an element matches resolved ignore targets.
+	*/
+	function isIgnored(el, selectors, elements) {
+		if (!el) return false;
+		for (const selector of selectors) try {
+			if (el.matches(selector) || !/* @__PURE__ */ isNull(el.closest(selector))) return true;
+		} catch {}
+		for (const ignoreEl of elements) if (ignoreEl === el || ignoreEl.contains(el)) return true;
+		return false;
+	}
+	/**
+	* Check if any element in the event path should be ignored.
+	*/
+	function shouldIgnore(path) {
+		const [selectors, elements] = resolveIgnoreTargets();
+		if (selectors.length === 0 && elements.length === 0) return false;
+		return path.some((node) => node instanceof Element && isIgnored(node, selectors, elements));
+	}
+	/**
+	* Check if the event target is outside all target elements (DOM containment).
+	*/
+	function isOutside(eventTarget) {
+		/* v8 ignore start -- defensive guards */
+		if (!eventTarget) return false;
+		if (!(eventTarget instanceof Node)) return false;
+		/* v8 ignore stop */
+		const targets = getTargets();
+		if (targets.length === 0) return false;
+		return targets.every((el) => {
+			if (/* @__PURE__ */ isNullOrUndefined(el) || !/* @__PURE__ */ isFunction(el.contains)) return false;
+			return el !== eventTarget && !el.contains(eventTarget);
+		});
+	}
+	/**
+	* Check if coordinates are outside all target elements' bounding rects.
+	*/
+	function isOutsideBounds(x, y) {
+		const targets = getTargets();
+		if (targets.length === 0) return false;
+		return targets.every((el) => {
+			const { left, right, top, bottom } = el.getBoundingClientRect();
+			return x < left || x > right || y < top || y > bottom;
+		});
+	}
+	/**
+	* Validate that the target is still in the DOM.
+	*/
+	function isValidTarget(eventTarget) {
+		if (!(eventTarget instanceof Element)) return false;
+		if (!eventTarget.isConnected) return false;
+		return true;
+	}
+	/* v8 ignore start -- event handlers tested via integration, not unit */
+	/**
+	* Handle pointerdown - store initial target and position.
+	*/
+	function onPointerDown(event) {
+		if (isPaused.value) return;
+		if (event.defaultPrevented) return;
+		initialTarget = event.composedPath()[0] ?? event.target;
+		startPosition = {
+			x: event.clientX,
+			y: event.clientY
+		};
+	}
+	/**
+	* Handle pointerup - check if it's an outside click.
+	*/
+	function onPointerUp(event) {
+		if (isPaused.value) return;
+		if (event.defaultPrevented) return;
+		if (!initialTarget) return;
+		const pointerdownTarget = initialTarget;
+		initialTarget = null;
+		if (!isValidTarget(pointerdownTarget)) return;
+		const path = event.composedPath();
+		const pointerupTarget = path[0] ?? event.target;
+		if (event.pointerType === "touch") {
+			const dx = Math.abs(event.clientX - startPosition.x);
+			const dy = Math.abs(event.clientY - startPosition.y);
+			if (dx >= touchScrollThreshold || dy >= touchScrollThreshold) return;
+		}
+		if ((bounds ? isOutsideBounds(startPosition.x, startPosition.y) && isOutsideBounds(event.clientX, event.clientY) : isOutside(pointerdownTarget) && isOutside(pointerupTarget)) && !shouldIgnore(path)) handler(event);
+	}
+	/**
+	* Handle window blur - detect focus moving to iframe.
+	*/
+	function onBlur(event) {
+		if (isPaused.value) return;
+		if (event.defaultPrevented) return;
+		if (document.activeElement instanceof HTMLIFrameElement) {
+			const iframeIsOutside = getTargets().every((el) => !el.contains(document.activeElement));
+			const [selectors, elements] = resolveIgnoreTargets();
+			if (iframeIsOutside && !isIgnored(document.activeElement, selectors, elements)) handler(event);
+		}
+	}
+	/* v8 ignore stop */
+	function setup() {
+		cleanupPointerDown = useDocumentEventListener("pointerdown", onPointerDown, capture);
+		cleanupPointerUp = useDocumentEventListener("pointerup", onPointerUp, capture);
+		if (!detectIframe) return;
+		cleanupBlur = useWindowEventListener("blur", onBlur, capture);
+	}
+	function cleanup() {
+		cleanupPointerDown?.();
+		cleanupPointerUp?.();
+		cleanupBlur?.();
+		cleanupPointerDown = void 0;
+		cleanupPointerUp = void 0;
+		cleanupBlur = void 0;
+	}
+	function pause() {
+		if (isPaused.value) return;
+		isPaused.value = true;
+		initialTarget = null;
+		cleanup();
+	}
+	function resume() {
+		if (!isPaused.value) return;
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		isPaused.value = true;
+		initialTarget = null;
+		cleanup();
+	}
+	setup();
+	onScopeDispose(stop, true);
+	return {
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+export { createOverflow as $, singleOpenStrategy as A, createForm as B, createQueue as C, createNestedContext as D, createNested as E, usePrefersReducedMotion as F, createDatePlugin as G, useForm as H, useLazy as I, createBreakpointsContext as J, useDate as K, useElementIntersection as L, useMediaQuery as M, usePrefersContrast as N, useNested as O, usePrefersDark as P, useProxyModel as Q, useIntersectionObserver as R, useStack as S, useQueue as T, createDate as U, createFormContext as V, createDateContext as W, useBreakpoints as X, createBreakpointsPlugin as Y, toReactive as Z, createStepContext as _, createVirtual as a, createFallbackHydration as at, createStackContext as b, useToggleScope as c, createHydrationPlugin as ct, useTimeline as d, createBreadcrumbsContext as dt, createOverflowContext as et, createStorage as f, useBreadcrumbs as ft, createStep as g, useStorage as h, useWindowEventListener as i, toElement as it, useMutationObserver as j, multipleOpenStrategy as k, createTimeline as l, useHydration as lt, createStoragePlugin as m, useDocumentEventListener as n, useElementSize as nt, createVirtualContext as o, createHydration as ot, createStorageContext as p, createBreakpoints as q, useEventListener as r, useResizeObserver as rt, useVirtual as s, createHydrationContext as st, useClickOutside as t, useOverflow as tt, createTimelineContext as u, createBreadcrumbs as ut, useStep as v, createQueueContext as w, createStackPlugin as x, createStack as y, useHotkey as z };