@vuetify/v0 0.0.20 → 0.0.21

package/dist/browser/index.js

@@ -335,18 +335,24 @@ function isNaN(item) {
 * mergeDeep({ arr: [1, 2] }, { arr: [3] }) // { arr: [3] }
 * ```
 */
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 /* @__NO_SIDE_EFFECTS__ */
 function mergeDeep(target, ...sources) {
 	if (sources.length === 0) return target;
 	const source = sources.shift();
-	if (/* @__PURE__ */ isObject(target) && /* @__PURE__ */ isObject(source)) {
-		for (const key in source) if (Object.prototype.hasOwnProperty.call(source, key)) {
-			const sourceValue = source[key];
-			const targetValue = target[key];
-			if (/* @__PURE__ */ isObject(sourceValue)) {
-				if (!/* @__PURE__ */ isObject(targetValue)) Object.assign(target, { [key]: {} });
-			} else Object.assign(target, { [key]: sourceValue });
-		}
+	if (/* @__PURE__ */ isObject(target) && /* @__PURE__ */ isObject(source)) for (const key in source) {
+		if (UNSAFE_KEYS.has(key)) continue;
+		if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (/* @__PURE__ */ isObject(sourceValue)) {
+			if (!/* @__PURE__ */ isObject(targetValue)) Object.assign(target, { [key]: {} });
+			target[key];
+		} else Object.assign(target, { [key]: sourceValue });
 	}
 	return /* @__PURE__ */ mergeDeep(target, ...sources);
 }
@@ -440,6 +446,27 @@ function debounce(fn, delay) {
 
 //#endregion
 //#region src/components/Atom/Atom.vue
+/**
+* @module Atom
+*
+* @remarks
+* Foundation component providing polymorphic rendering with three modes:
+* 1. **Element Mode** (default): Renders as any HTML element via the `as` prop
+* 2. **Renderless Mode**: Renders slot content directly without wrapper
+* 3. **Null Mode**: Equivalent to renderless when `as={null}`
+*
+* Key features:
+* - Polymorphic element rendering (div, button, span, etc.)
+* - Self-closing tag detection (img, input, br, hr, etc.)
+* - Automatic attribute forwarding to rendered element
+* - Generic slot props typing for type-safe attribute passing
+* - Template ref exposure for DOM element access
+* - Renderless mode for maximum flexibility
+*
+* The Atom component is the lowest-level primitive in the component system,
+* serving as the foundation for all other components that need polymorphic
+* rendering capabilities.
+*/
 const _sfc_main$27 = /* @__PURE__ */ defineComponent({
 	name: "Atom",
 	__name: "Atom",
@@ -476,6 +503,22 @@ var Atom_default = _sfc_main$27;
 //#endregion
 //#region src/composables/createContext/index.ts
 /**
+* @module createContext
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*
+* @remarks
+* Factory for creating type-safe Vue dependency injection contexts.
+*
+* Provides a wrapper around Vue's provide/inject that throws errors when context is not found,
+* eliminating silent failures and improving developer experience. Supports both app-level and
+* component-level provision.
+*
+* Supports two modes:
+* - **Static key**: `createContext('my-key')` - key is fixed at creation time
+* - **Dynamic key**: `createContext()` or `createContext({ suffix: 'item' })` - key provided at runtime
+*/
+/**
 * Injects a context provided by an ancestor component.
 *
 * @param key The key of the context to inject.
@@ -602,6 +645,18 @@ function createTrinity(useContext$1, provideContext$1, context) {
 	];
 }
 
+//#endregion
+//#region src/constants/globals.ts
+const IN_BROWSER = typeof window !== "undefined";
+const SUPPORTS_TOUCH = IN_BROWSER && ("ontouchstart" in window || window.navigator.maxTouchPoints > 0);
+const SUPPORTS_MATCH_MEDIA = IN_BROWSER && "matchMedia" in window && typeof window.matchMedia === "function";
+const SUPPORTS_OBSERVER = IN_BROWSER && "ResizeObserver" in window;
+const SUPPORTS_INTERSECTION_OBSERVER = IN_BROWSER && "IntersectionObserver" in window;
+const SUPPORTS_MUTATION_OBSERVER = IN_BROWSER && "MutationObserver" in window;
+const version = "0.0.21";
+/* v8 ignore next -- build-time constant, __DEV__ short-circuits in tests */
+const __LOGGER_ENABLED__ = false;
+
 //#endregion
 //#region src/composables/createPlugin/index.ts
 /**
@@ -713,17 +768,6 @@ var PinoLoggerAdapter = class {
 	}
 };
 
-//#endregion
-//#region src/constants/globals.ts
-const IN_BROWSER = typeof window !== "undefined";
-const SUPPORTS_TOUCH = IN_BROWSER && ("ontouchstart" in window || window.navigator.maxTouchPoints > 0);
-const SUPPORTS_MATCH_MEDIA = IN_BROWSER && "matchMedia" in window && typeof window.matchMedia === "function";
-const SUPPORTS_OBSERVER = IN_BROWSER && "ResizeObserver" in window;
-const SUPPORTS_INTERSECTION_OBSERVER = IN_BROWSER && "IntersectionObserver" in window;
-const SUPPORTS_MUTATION_OBSERVER = IN_BROWSER && "MutationObserver" in window;
-const version = "0.0.20";
-const __LOGGER_ENABLED__ = false;
-
 //#endregion
 //#region src/composables/useLogger/adapters/v0.ts
 /**
@@ -769,10 +813,12 @@ var Vuetify0LoggerAdapter = class {
 	}
 	timestamp() {
 		if (!IN_BROWSER) return (/* @__PURE__ */ new Date()).toISOString();
+		/* v8 ignore next -- defensive fallback, toTimeString always returns valid format */
 		return (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0] ?? "";
 	}
 	style(level) {
 		if (!this.colors || !IN_BROWSER) return "";
+		/* v8 ignore next -- LogLevel union is exhaustive */
 		return {
 			trace: "color: #64748b",
 			debug: "color: #3b82f6",
@@ -1023,6 +1069,23 @@ function useLogger(namespace = "v0:logger") {
 //#endregion
 //#region src/composables/useRegistry/index.ts
 /**
+* @module useRegistry
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-registry
+*
+* @remarks
+* A foundational composable for managing collections of items (tickets) with:
+* - Unique ID-based access
+* - Index-based ordering
+* - Value-based reverse lookup
+* - Automatic reindexing
+* - Optional event emission
+* - Performance-optimized caching
+*
+* The registry serves as the base for many other composables in the system,
+* including useSelection, useForm, useTimeline, and more.
+*/
+/**
 * Creates a new registry instance.
 *
 * @param options The options for the registry instance.
@@ -1295,7 +1358,7 @@ function useRegistry(options) {
 			return direction === "first" ? tickets$1[0] : tickets$1.at(-1);
 		}
 		const tickets = values();
-		const index = /* @__PURE__ */ isUndefined(from) ? void 0 : Math.max(0, Math.min(from, tickets.length - 1));
+		const index = /* @__PURE__ */ isUndefined(from) ? void 0 : /* @__PURE__ */ clamp(from, 0, tickets.length - 1);
 		if (direction === "last") {
 			const start = /* @__PURE__ */ isUndefined(index) ? tickets.length - 1 : index;
 			for (let i = start; i >= 0; i--) {
@@ -1380,6 +1443,21 @@ function createRegistryContext(_options = {}) {
 //#endregion
 //#region src/composables/useSelection/index.ts
 /**
+* @module useSelection
+*
+* @remarks
+* Base composable for managing selected items in a collection with Set-based tracking.
+*
+* Key features:
+* - Set-based selectedIds for O(1) selection checks
+* - Mandatory selection mode (prevents deselecting last item)
+* - Auto-enrollment option (selects non-disabled items on register)
+* - Disabled item filtering
+* - Computed selectedItems and selectedValues Sets
+*
+* Extends useRegistry and serves as the base for useSingle, useGroup, useStep, and useFeatures.
+*/
+/**
 * Creates a new selection instance for managing multiple selected items.
 *
 * Extends `useRegistry` with selection tracking via a reactive `Set` of selected IDs.
@@ -1749,12 +1827,26 @@ const Avatar = {
 * ```
 */
 function toArray(value) {
-	return /* @__PURE__ */ isNullOrUndefined(value) ? [] : Array.isArray(value) ? value : [value];
+	return /* @__PURE__ */ isNullOrUndefined(value) ? [] : /* @__PURE__ */ isArray(value) ? value : [value];
 }
 
 //#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.
@@ -2090,6 +2182,21 @@ const ExpansionPanel = {
 //#endregion
 //#region src/composables/useProxyRegistry/index.ts
 /**
+* @module useProxyRegistry
+*
+* @remarks
+* Proxy composable for reactive registry keys, values, entries, and size.
+*
+* Key features:
+* - Reactive proxy for registry data
+* - Deep or shallow reactivity options
+* - Event-based updates
+* - Automatic cleanup on scope disposal
+* - Transforms Map-based registry into reactive refs
+*
+* Perfect for exposing registry data as reactive computed properties.
+*/
+/**
 * Creates a proxy registry that provides reactive objects for registry data.
 *
 * @param registry The registry instance to proxy.
@@ -2139,6 +2246,26 @@ function useProxyRegistry(registry, options) {
 //#endregion
 //#region src/composables/useGroup/index.ts
 /**
+* @module useGroup
+*
+* @remarks
+* Multi-selection composable that extends useSelection with batch operations and tri-state support.
+*
+* Key features:
+* - Batch operations (select/unselect/toggle accept ID | ID[])
+* - Tri-state support via mixed/indeterminate state (mix/unmix)
+* - selectedIndexes computed Set for position-based tracking
+* - Perfect for checkbox trees, multi-select dropdowns, filter panels
+*
+* Tri-state behavior:
+* - Items can be selected, mixed (indeterminate), or unselected
+* - select() clears mixed state, mix() clears selected state (mutually exclusive)
+* - toggle() on a mixed item selects it (resolves positively)
+*
+* Inheritance chain: useRegistry → useSelection → useGroup
+* Extended by: useFeatures
+*/
+/**
 * Creates a new group instance with batch selection and tri-state support.
 *
 * Extends `createSelection` to support selecting, unselecting, and toggling multiple items
@@ -2523,40 +2650,20 @@ const Group = {
 };
 
 //#endregion
-//#region src/composables/useLocale/adapters/v0.ts
+//#region src/composables/useSingle/index.ts
 /**
-* Vuetify0.x locale adapter implementation
+* @module useSingle
 *
-* This adapter provides translation and number formatting
-* capabilities using the Intl API and supports both
-* numbered ({0}, {1}) and named ({name}) variables in translation strings.
+* @remarks
+* Single-selection composable that extends useSelection to enforce only one selected item.
+*
+* Key features:
+* - Auto-clears previous selection when selecting new item
+* - Singular computed properties (selectedId, selectedItem, selectedIndex, selectedValue)
+* - Perfect for tabs, radio buttons, theme selectors
+*
+* Inheritance chain: useRegistry → useSelection → useSingle
 */
-var Vuetify0LocaleAdapter = class {
-	t(message, ...params) {
-		let resolvedMessage = message;
-		if (params.length > 0 && /* @__PURE__ */ isObject(params[0])) {
-			const variables = params[0];
-			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
-				return /* @__PURE__ */ isUndefined(variables[name]) ? match : String(variables[name]);
-			});
-			params = params.slice(1);
-		}
-		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
-			const idx = Number.parseInt(index, 10);
-			if (!/* @__PURE__ */ isUndefined(params[idx])) return String(params[idx]);
-			return match;
-		});
-		return resolvedMessage;
-	}
-	n(value, locale, ...params) {
-		if (!IN_BROWSER || !locale) return value.toString();
-		const options = params[0];
-		return new Intl.NumberFormat(String(locale), options).format(value);
-	}
-};
-
-//#endregion
-//#region src/composables/useSingle/index.ts
 /**
 * Creates a new single selection instance that enforces only one selected item at a time.
 *
@@ -2703,6 +2810,23 @@ function useSingle(namespace = "v0:single") {
 //#endregion
 //#region src/composables/useTokens/index.ts
 /**
+* @module useTokens
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-tokens
+*
+* @remarks
+* Design token registry with alias resolution and W3C Design Tokens format support.
+*
+* Key features:
+* - Alias resolution with circular reference detection
+* - Nested token flattening with dot notation
+* - W3C Design Tokens format ($value, $type, $description, $extensions)
+* - Path-based resolution (e.g., {colors}.blue.500)
+* - Resolution caching for performance (~28,590 ops/sec)
+*
+* Used by useTheme, useLocale, and useFeatures for token-based configuration.
+*/
+/**
 * Creates a new token instance.
 *
 * @param tokens The tokens to use.
@@ -2940,9 +3064,57 @@ function flatten(tokens, prefix = "", flat = false) {
 	return flattened;
 }
 
+//#endregion
+//#region src/composables/useLocale/adapters/v0.ts
+/**
+* Vuetify0.x locale adapter implementation
+*
+* This adapter provides translation and number formatting
+* capabilities using the Intl API and supports both
+* numbered ({0}, {1}) and named ({name}) variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && /* @__PURE__ */ isObject(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return /* @__PURE__ */ isUndefined(variables[name]) ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (!/* @__PURE__ */ isUndefined(params[idx])) return String(params[idx]);
+			return match;
+		});
+		return resolvedMessage;
+	}
+	n(value, locale, ...params) {
+		if (!IN_BROWSER || !locale) return value.toString();
+		const options = params[0];
+		return new Intl.NumberFormat(String(locale), options).format(value);
+	}
+};
+
 //#endregion
 //#region src/composables/useLocale/index.ts
 /**
+* @module useLocale
+*
+* @remarks
+* Internationalization (i18n) composable with adapter pattern for message translation.
+*
+* Key features:
+* - Locale selection with createSingle
+* - Token-based message storage with useTokens
+* - Numbered and named placeholder support ({0}, {name})
+* - Number formatting with Intl.NumberFormat
+* - Adapter pattern for integration with i18n providers
+*
+* Integrates with createSingle for locale selection and useTokens for message resolution.
+*/
+/**
 * Creates a new locale instance.
 *
 * @param options The options for the locale instance.
@@ -3084,6 +3256,23 @@ function useLocale(namespace = "v0:locale") {
 //#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.
@@ -3178,7 +3367,7 @@ function createHydrationPlugin(_options = {}) {
 		},
 		setup: (app) => {
 			app.mixin({ mounted() {
-				if (this.$parent !== null) return;
+				if (!/* @__PURE__ */ isNull(this.$parent)) return;
 				context.hydrate();
 			} });
 		}
@@ -3220,6 +3409,22 @@ function useHydration(namespace = "v0:hydration") {
 //#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.
 *
@@ -3266,7 +3471,7 @@ function useResizeObserver(target, callback, options = {}) {
 	const isPaused = shallowRef(false);
 	const isActive = toRef(() => !!observer.value);
 	function setup() {
-		if (observer.value === null) return;
+		if (/* @__PURE__ */ isNull(observer.value)) return;
 		if (!isHydrated.value || !SUPPORTS_OBSERVER || !target.value || isPaused.value) return;
 		observer.value = new ResizeObserver((entries) => {
 			callback(entries.map((entry) => ({
@@ -3379,6 +3584,23 @@ function useElementSize(target) {
 //#endregion
 //#region src/composables/useOverflow/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
@@ -3548,6 +3770,22 @@ function useOverflow(namespace = "v0:overflow") {
 //#endregion
 //#region src/composables/usePagination/index.ts
 /**
+* @module usePagination
+*
+* @remarks
+* Lightweight pagination composable for navigating through pages.
+*
+* Key features:
+* - No registry overhead - just a bounded integer
+* - Direct ref support for v-model compatibility
+* - Navigation methods: next, prev, first, last
+* - Computed visible items with ellipsis
+* - Trinity pattern for dependency injection
+*
+* Unlike registry-based composables, pagination tracks a single number
+* within a range, making it efficient for large page counts.
+*/
+/**
 * Creates a pagination instance.
 *
 * @param options The options for the pagination instance.
@@ -4653,6 +4891,20 @@ const Single = {
 //#endregion
 //#region src/composables/useStep/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
@@ -4948,6 +5200,21 @@ const Step = {
 //#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.
@@ -5068,6 +5335,21 @@ function toReactive(objectRef) {
 //#endregion
 //#region src/composables/useEventListener/index.ts
 /**
+* @module useEventListener
+*
+* @remarks
+* Event listener composable with automatic cleanup on scope disposal.
+*
+* Key features:
+* - Supports Window, Document, and HTMLElement targets
+* - Reactive targets, events, and listeners
+* - Event options support (capture, passive, once)
+* - Automatic removeEventListener on unmount
+* - Multiple overloads for type safety
+*
+* Perfect for safely managing event listeners in Vue components.
+*/
+/**
 * Attaches an event listener to a target.
 *
 * @param target The target to attach the event listener to.
@@ -5142,6 +5424,24 @@ function useDocumentEventListener(event, listener, options) {
 //#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.
@@ -5341,7 +5641,7 @@ function createBreakpointsPlugin(_options = {}) {
 		},
 		setup: (app) => {
 			app.mixin({ mounted() {
-				if (this.$parent !== null) return;
+				if (!/* @__PURE__ */ isNull(this.$parent)) return;
 				const hydration = useHydration();
 				function listener() {
 					context.update();
@@ -5389,6 +5689,26 @@ function useBreakpoints(namespace = "v0:breakpoints") {
 //#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 `useKeydown` 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
@@ -5455,7 +5775,7 @@ function useClickOutside(target, handler, options = {}) {
 	* Resolve target(s) to an array of HTMLElements.
 	*/
 	function getTargets() {
-		return (Array.isArray(target) ? target : [target]).map((source) => toValue(source)).filter((el) => !/* @__PURE__ */ isNullOrUndefined(el));
+		return toArray(target).map((source) => toValue(source)).filter((el) => !/* @__PURE__ */ isNullOrUndefined(el));
 	}
 	/**
 	* Resolve ignore targets to a tuple of [selectors, elements].
@@ -5599,6 +5919,24 @@ function useClickOutside(target, handler, options = {}) {
 //#endregion
 //#region src/composables/useFeatures/index.ts
 /**
+* @module useFeatures
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-features
+*
+* @remarks
+* Feature flag system with boolean and token-based features.
+*
+* Key features:
+* - Boolean features (true/false activation)
+* - Token features with $variation support
+* - Auto-selection of enabled features
+* - Multi-select support for feature combinations
+* - Perfect for A/B testing, progressive rollout, feature toggles
+*
+* Inheritance chain: useRegistry → createSelection → createGroup → createFeatures
+* Integrates with useTokens for token-based features.
+*/
+/**
 * Creates a new features instance.
 *
 * @param options The options for the features instance.
@@ -5758,8 +6096,24 @@ function useFeatures(namespace = "v0:features") {
 
 //#endregion
 //#region src/composables/useFilter/index.ts
+/**
+* @module useFilter
+*
+* @remarks
+* Reactive array filtering composable with multiple filter modes.
+*
+* Key features:
+* - Four filter modes: some, every, union, intersection
+* - Case-insensitive filtering
+* - Custom filter functions
+* - Reactive updates
+* - Context-based DI support
+* - Perfect for search, multi-criteria filtering
+*
+* Filters arrays based on query strings with configurable matching strategies.
+*/
 function defaultFilter(query, item, keys, mode = "some") {
-	const queries = Array.isArray(query) ? query.map((q) => String(q).toLowerCase()) : [String(query).toLowerCase()];
+	const queries = toArray(query).map((q) => String(q).toLowerCase());
 	function match(value, q) {
 		return String(value).toLowerCase().includes(q);
 	}
@@ -5802,7 +6156,7 @@ function createFilter(options = {}) {
 		return { items: computed(() => {
 			const q = toValue(queryRef);
 			query.value = q;
-			const queries = (Array.isArray(q) ? q : [q]).filter((q$1) => String(q$1).trim());
+			const queries = toArray(q).filter((q$1) => String(q$1).trim());
 			if (queries.length === 0) return itemsRef.value;
 			const queryParam = queries.length === 1 ? queries[0] : queries;
 			return itemsRef.value.filter((item) => filterFunction(queryParam, item));
@@ -5911,6 +6265,22 @@ function useFilterContext(namespace = "v0:filter") {
 //#endregion
 //#region src/composables/useForm/index.ts
 /**
+* @module useForm
+*
+* @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.
@@ -5949,7 +6319,7 @@ function createForm(options) {
 		return parse(validateOn).includes(event);
 	}
 	const isValidating = computed(() => {
-		for (const ticket of registry.collection.values()) if (ticket.isValidating.value) return true;
+		for (const ticket of registry.values()) if (ticket.isValidating.value) return true;
 		return false;
 	});
 	const isValid = computed(() => {
@@ -5957,7 +6327,7 @@ function createForm(options) {
 		for (const ticket of registry.values()) {
 			hasFields = true;
 			if (ticket.isValid.value === false) return false;
-			if (ticket.isValid.value === null) return null;
+			if (/* @__PURE__ */ isNull(ticket.isValid.value)) return null;
 		}
 		return hasFields ? true : null;
 	});
@@ -5973,7 +6343,7 @@ function createForm(options) {
 		return validating.map((id$1) => registry.get(id$1)).filter(Boolean).every((ticket) => ticket.isValid.value === true);
 	}
 	function register(registration) {
-		const model = shallowRef(registration.value == null ? "" : toValue(registration.value));
+		const model = shallowRef(/* @__PURE__ */ isNullOrUndefined(registration.value) ? "" : toValue(registration.value));
 		const rules = registration.rules || [];
 		const errors = shallowRef([]);
 		const isValidating$1 = shallowRef(false);
@@ -6116,6 +6486,22 @@ function useForm(namespace = "v0:form") {
 //#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.
 *
@@ -6162,7 +6548,7 @@ function useIntersectionObserver(target, callback, options = {}) {
 	const isIntersecting = shallowRef(false);
 	const isActive = toRef(() => !!observer.value);
 	function setup() {
-		if (observer.value === null) return;
+		if (/* @__PURE__ */ isNull(observer.value)) return;
 		if (!isHydrated.value || !SUPPORTS_INTERSECTION_OBSERVER || !targetRef.value || isPaused.value) return;
 		observer.value = new IntersectionObserver((entries) => {
 			const transformedEntries = entries.map((entry) => ({
@@ -6289,6 +6675,20 @@ function useElementIntersection(target, options = {}) {
 //#endregion
 //#region src/composables/useKeydown/index.ts
 /**
+* @module useKeydown
+*
+* @remarks
+* Keydown event listener composable with key filtering.
+*
+* Key features:
+* - Key-specific event handling
+* - preventDefault and stopPropagation options
+* - Automatic cleanup on scope disposal
+* - Built on useEventListener for consistent event handling
+*
+* Simplified wrapper around useEventListener for keyboard interactions.
+*/
+/**
 * A composable that adds a keydown event listener to the document.
 *
 * @param handlers The key handlers to add.
@@ -6319,8 +6719,7 @@ function useKeydown(handlers) {
 	let cleanup = null;
 	const isActive = toRef(() => !!cleanup);
 	function onKeydown(event) {
-		const handlerList = toValue(handlers);
-		const handler = (Array.isArray(handlerList) ? handlerList : [handlerList]).find((h) => h.key === event.key);
+		const handler = toArray(toValue(handlers)).find((h) => h.key === event.key);
 		if (handler) {
 			if (handler.preventDefault) event.preventDefault();
 			if (handler.stopPropagation) event.stopPropagation();
@@ -6348,6 +6747,22 @@ function useKeydown(handlers) {
 //#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.
@@ -6405,7 +6820,7 @@ function useMutationObserver(target, callback, options = {}) {
 		attributeFilter: options.attributeFilter
 	};
 	function setup() {
-		if (observer.value === null) return;
+		if (/* @__PURE__ */ isNull(observer.value)) return;
 		if (!isHydrated.value || !SUPPORTS_MUTATION_OBSERVER || !target.value || isPaused.value) return;
 		observer.value = new MutationObserver((mutations) => {
 			callback(mutations.map((mutation) => ({
@@ -6498,6 +6913,23 @@ var Vuetify0PermissionAdapter = class extends PermissionAdapter {
 //#endregion
 //#region src/composables/usePermissions/index.ts
 /**
+* @module usePermissions
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @remarks
+* Permission management composable with support for RBAC and ABAC patterns.
+*
+* Key features:
+* - Role-Based Access Control (RBAC) support
+* - Attribute-Based Access Control (ABAC) with context
+* - Functional permission conditions
+* - Token-based permission storage
+* - Adapter pattern for custom permission systems
+*
+* Built on useTokens for flexible permission configuration.
+*/
+/**
 * Creates a new permissions instance.
 *
 * @param options The options for the permissions instance.
@@ -6644,6 +7076,21 @@ function usePermissions(namespace = "v0:permissions") {
 //#endregion
 //#region src/composables/useQueue/index.ts
 /**
+* @module useQueue
+*
+* @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 useRegistry, the queue automatically manages timeouts for tickets,
+* ensuring only the first ticket in the queue is active at any time. When an 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
@@ -6845,6 +7292,21 @@ var MemoryAdapter = class {
 //#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.
@@ -7067,10 +7529,12 @@ var Vuetify0ThemeAdapter = class extends ThemeAdapter {
 	}
 	upsert(styles) {
 		if (!IN_BROWSER) return;
-		let styleEl = document.querySelector(`#${this.stylesheetId}`);
+		const selector = this.stylesheetId.startsWith("#") ? this.stylesheetId : `#${this.stylesheetId}`;
+		const id = this.stylesheetId.startsWith("#") ? this.stylesheetId.slice(1) : this.stylesheetId;
+		let styleEl = document.querySelector(selector);
 		if (!styleEl) {
 			styleEl = document.createElement("style");
-			styleEl.id = this.stylesheetId.startsWith("#") ? this.stylesheetId.slice(1) : this.stylesheetId;
+			styleEl.id = id;
 			if (this.cspNonce) styleEl.setAttribute("nonce", this.cspNonce);
 			document.head.append(styleEl);
 		}
@@ -7081,6 +7545,24 @@ var Vuetify0ThemeAdapter = class extends ThemeAdapter {
 //#endregion
 //#region src/composables/useTheme/index.ts
 /**
+* @module useTheme
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-theme
+*
+* @remarks
+* Theme management composable with token resolution and CSS variable injection.
+*
+* Key features:
+* - Single-selection theme switching (extends createSingle)
+* - Token alias resolution via useTokens
+* - Lazy theme loading (compute colors only when selected)
+* - CSS variable generation via adapter pattern
+* - SSR support with head integration
+* - Theme cycling
+*
+* Integrates with createSingle for selection and useTokens for color resolution.
+*/
+/**
 * Creates a new theme instance.
 *
 * @param options The options for the theme instance.
@@ -7301,6 +7783,21 @@ function useTheme(namespace = "v0:theme") {
 //#endregion
 //#region src/composables/useTimeline/index.ts
 /**
+* @module useTimeline
+*
+* @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 useRegistry with temporal navigation capabilities.
+*/
+/**
 * Creates a new timeline instance.
 *
 * @param _options The options for the timeline instance.
@@ -7435,6 +7932,24 @@ function useTimeline(namespace = "v0:timeline") {
 //#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
@@ -7516,6 +8031,24 @@ function useToggleScope(source, fn) {
 //#endregion
 //#region src/composables/useVirtual/index.ts
 /**
+* @module useVirtual
+*
+* @remarks
+* Virtual scrolling composable for efficiently rendering large lists.
+*
+* Key features:
+* - Renders only visible items (viewport + overscan)
+* - Dynamic or fixed item heights
+* - SSR-safe (checks IN_BROWSER)
+* - Bidirectional scrolling (forward/reverse for chat apps)
+* - Scroll anchoring (maintains position across data changes)
+* - Edge detection for infinite scroll
+* - iOS momentum and elastic scrolling
+* - Configurable overscan (extra items rendered for smooth scrolling)
+*
+* Perfect for large data sets, chat apps, and infinite scroll implementations.
+*/
+/**
 * Virtual scrolling composable for efficiently rendering large lists
 *
 * @param items Reactive array of items to virtualize