@vuetify/v0 0.0.23 → 0.0.24

package/dist/{useClickOutside-B47X8X6-.mjs → useClickOutside-w-Y2QxHh.mjs}

@@ -1,7 +1,6 @@
-import { _ as isUndefined, a as genId, c as isFunction, d as isNullOrUndefined, f as isNumber, g as isSymbol, h as isString, l as isNaN, o as isArray, p as isObject, r as clamp, s as isBoolean, t as instanceExists, u as isNull, v as mergeDeep, y as range } from "./utilities-9i1hJnMd.mjs";
-import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-WKdFmgwy.mjs";
-import { computed, effectScope, inject, isRef, onScopeDispose, provide, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
-import { Temporal } from "@js-temporal/polyfill";
+import { _ as useId$1, a as isFunction, c as isNullOrUndefined, f as isString, g as range, h as mergeDeep, i as isBoolean, l as isNumber, m as isUndefined, o as isNaN, p as isSymbol, r as isArray, s as isNull, t as clamp, u as isObject, v as instanceExists } from "./utilities-B58TiS_S.mjs";
+import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-BhNI7no7.mjs";
+import { computed, effectScope, inject, isRef, nextTick, onScopeDispose, provide, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 
 //#region src/composables/createContext/index.ts
 /**
@@ -787,7 +786,7 @@ function createRegistry(options) {
 	}
 	function register(registration = {}) {
 		const size = collection.size;
-		const id = registration.id ?? /* @__PURE__ */ genId();
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
 		if (has(id)) {
 			logger$1.warn(`Ticket "${id}" already exists. Use \`upsert()\` to update or check \`has()\` before registering.`);
 			return get(id);
@@ -1034,7 +1033,7 @@ function createSelection(_options = {}) {
 		return selectedIds.has(id);
 	}
 	function register(registration = {}) {
-		const id = registration.id ?? /* @__PURE__ */ genId();
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
 		const item = {
 			disabled: false,
 			select: () => select(id),
@@ -1388,7 +1387,7 @@ function createGroup(_options = {}) {
 		else selection.toggle(id);
 	}
 	function register(registration = {}) {
-		const id = registration.id ?? /* @__PURE__ */ genId();
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
 		const item = {
 			...registration,
 			id,
@@ -1819,18 +1818,26 @@ function toReactive(objectRef) {
 */
 function createHydration() {
 	const isHydrated = shallowRef(false);
+	const isSettled = shallowRef(false);
 	function hydrate() {
 		isHydrated.value = true;
 	}
+	function settle() {
+		isSettled.value = true;
+	}
 	return {
 		isHydrated: shallowReadonly(isHydrated),
-		hydrate
+		isSettled: shallowReadonly(isSettled),
+		hydrate,
+		settle
 	};
 }
 function createFallbackHydration() {
 	return {
 		isHydrated: shallowReadonly(shallowRef(true)),
-		hydrate: () => {}
+		isSettled: shallowReadonly(shallowRef(true)),
+		hydrate: () => {},
+		settle: () => {}
 	};
 }
 /**
@@ -1894,9 +1901,11 @@ function createHydrationPlugin(_options = {}) {
 			provideHydrationContext(context, app);
 		},
 		setup: (app) => {
-			app.mixin({ mounted() {
+			app.mixin({ async mounted() {
 				if (!/* @__PURE__ */ isNull(this.$parent)) return;
 				context.hydrate();
+				await nextTick();
+				context.settle();
 			} });
 		}
 	});
@@ -1914,13 +1923,16 @@ function createHydrationPlugin(_options = {}) {
 * <script setup lang="ts">
 *   import { useHydration } from '@vuetify/v0'
 *
-*   const hydration = useHydration()
+*   const { isHydrated, isSettled } = useHydration()
+*
+*   // Use isSettled to gate animations after state restoration
+*   const transition = computed(() => isSettled.value ? 'fade' : undefined)
 * <\/script>
 *
 * <template>
-*   <div>
-*     <p>Is hydrated: {{ hydration.isHydrated.value }}</p>
-*   </div>
+*   <Transition :name="transition">
+*     <div v-if="show">Animates only after hydration settles</div>
+*   </Transition>
 * </template>
 * ```
 */
@@ -2803,585 +2815,6 @@ function useLocale(namespace = "v0:locale") {
 	}
 }
 
-//#endregion
-//#region src/composables/useDate/adapters/v0.ts
-/**
-* @module Vuetify0DateAdapter
-*
-* @remarks
-* Default DateAdapter for v0, built on the Temporal API.
-* Uses Temporal.PlainDateTime as the primary date type.
-*
-* Implements the full date-io IUtils interface for industry compatibility.
-*
-* Requires native Temporal support or @js-temporal/polyfill.
-*
-* @see https://tc39.es/proposal-temporal/docs/
-* @see https://github.com/dmtrKovalenko/date-io
-*/
-/** Single regex for token replacement in formatByString */
-const FORMAT_TOKEN_REGEX = /YYYY|YY|MMMM|MMM|MM|M|dddd|ddd|DD|D|HH|H|hh|h|mm|m|ss|s|A|a/g;
-/** Maximum cache size to prevent memory leaks */
-const MAX_CACHE_SIZE = 50;
-var Vuetify0DateAdapter = class {
-	_locale;
-	/** Cache for Intl.DateTimeFormat instances, keyed by locale + options */
-	formatCache = /* @__PURE__ */ new Map();
-	/** Cache for Intl.NumberFormat instances, keyed by locale */
-	numberFormatCache = /* @__PURE__ */ new Map();
-	constructor(locale = "en-US") {
-		this._locale = locale;
-	}
-	/** Current locale. Setting a new locale clears format caches. */
-	get locale() {
-		return this._locale;
-	}
-	set locale(value) {
-		if (this._locale !== value) {
-			this._locale = value;
-			this.formatCache.clear();
-			this.numberFormatCache.clear();
-		}
-	}
-	/**
-	* Create a date from various input types.
-	*
-	* @param value - Date value (PlainDateTime, PlainDate, ZonedDateTime, Date, ISO string, timestamp)
-	* @returns PlainDateTime or null if invalid
-	*
-	* @remarks
-	* **SSR Safety:** When called without arguments:
-	* - Browser: Returns current time via `Temporal.Now.plainDateTimeISO()`
-	* - Server: Returns epoch (1970-01-01T00:00:00) for deterministic rendering
-	*
-	* For SSR apps needing current time, pass `Date.now()` explicitly and handle
-	* hydration via `<ClientOnly>` (Nuxt) or `v-if` + `onMounted` pattern.
-	*/
-	date(value) {
-		if (/* @__PURE__ */ isNullOrUndefined(value)) return IN_BROWSER ? Temporal.Now.plainDateTimeISO() : Temporal.PlainDateTime.from({
-			year: 1970,
-			month: 1,
-			day: 1,
-			hour: 0,
-			minute: 0,
-			second: 0
-		});
-		if (value instanceof Temporal.PlainDateTime) return value;
-		if (value instanceof Temporal.PlainDate) return value.toPlainDateTime();
-		if (value instanceof Temporal.ZonedDateTime) return value.toPlainDateTime();
-		if (value instanceof Date) return Temporal.PlainDateTime.from({
-			year: value.getFullYear(),
-			month: value.getMonth() + 1,
-			day: value.getDate(),
-			hour: value.getHours(),
-			minute: value.getMinutes(),
-			second: value.getSeconds(),
-			millisecond: value.getMilliseconds()
-		});
-		if (/* @__PURE__ */ isString(value)) try {
-			return Temporal.PlainDateTime.from(value);
-		} catch {
-			try {
-				return this.parseISO(value);
-			} catch {
-				return null;
-			}
-		}
-		if (/* @__PURE__ */ isNumber(value)) {
-			const date = new Date(value);
-			return Temporal.PlainDateTime.from({
-				year: date.getFullYear(),
-				month: date.getMonth() + 1,
-				day: date.getDate(),
-				hour: date.getHours(),
-				minute: date.getMinutes(),
-				second: date.getSeconds(),
-				millisecond: date.getMilliseconds()
-			});
-		}
-		return null;
-	}
-	toJsDate(value) {
-		return new Date(value.year, value.month - 1, value.day, value.hour, value.minute, value.second, value.millisecond);
-	}
-	parseISO(dateString) {
-		if (/^\d{4}-\d{2}-\d{2}$/.test(dateString)) return Temporal.PlainDate.from(dateString).toPlainDateTime();
-		if (dateString.includes("Z") || /[+-]\d{2}:\d{2}$/.test(dateString)) return Temporal.Instant.from(dateString).toZonedDateTimeISO("UTC").toPlainDateTime();
-		return Temporal.PlainDateTime.from(dateString);
-	}
-	toISO(date) {
-		return date.toString();
-	}
-	/**
-	* Parses a date string into a PlainDateTime.
-	*
-	* **Known limitation**: The `format` parameter is currently ignored.
-	* Temporal API doesn't provide built-in format parsing, and implementing
-	* full format string parsing (e.g., 'MM/DD/YYYY') would require a
-	* substantial custom parser. This method delegates to `date()` which
-	* handles ISO 8601 strings and common formats.
-	*
-	* For custom format parsing, consider using a library like date-fns or
-	* luxon with a custom adapter.
-	*
-	* @param value - The date string to parse
-	* @param _format - Format hint (currently ignored)
-	* @returns Parsed PlainDateTime or null if invalid
-	*/
-	parse(value, _format) {
-		try {
-			return this.date(value);
-		} catch {
-			return null;
-		}
-	}
-	isValid(date) {
-		if (/* @__PURE__ */ isNullOrUndefined(date)) return false;
-		if (date instanceof Temporal.PlainDateTime) return true;
-		if (date instanceof Temporal.PlainDate) return true;
-		if (date instanceof Temporal.ZonedDateTime) return true;
-		if (date instanceof Date) return !Number.isNaN(date.getTime());
-		if (/* @__PURE__ */ isString(date)) try {
-			Temporal.PlainDateTime.from(date);
-			return true;
-		} catch {
-			try {
-				Temporal.PlainDate.from(date);
-				return true;
-			} catch {
-				return false;
-			}
-		}
-		return false;
-	}
-	isNull(value) {
-		return /* @__PURE__ */ isNullOrUndefined(value);
-	}
-	getCurrentLocaleCode() {
-		return this.locale;
-	}
-	is12HourCycleInCurrentLocale() {
-		return new Intl.DateTimeFormat(this.locale, { hour: "numeric" }).resolvedOptions().hour12 ?? false;
-	}
-	format(date, formatString) {
-		const jsDate = this.toJsDate(date);
-		const options = {
-			fullDate: { dateStyle: "full" },
-			fullDateWithWeekday: {
-				weekday: "long",
-				year: "numeric",
-				month: "long",
-				day: "numeric"
-			},
-			normalDate: { dateStyle: "medium" },
-			shortDate: { dateStyle: "short" },
-			year: { year: "numeric" },
-			month: { month: "long" },
-			monthShort: { month: "short" },
-			monthAndYear: {
-				year: "numeric",
-				month: "long"
-			},
-			monthAndDate: {
-				month: "long",
-				day: "numeric"
-			},
-			weekday: { weekday: "long" },
-			weekdayShort: { weekday: "short" },
-			dayOfMonth: { day: "numeric" },
-			hours12h: {
-				hour: "numeric",
-				hour12: true
-			},
-			hours24h: {
-				hour: "numeric",
-				hour12: false
-			},
-			minutes: { minute: "numeric" },
-			seconds: { second: "numeric" },
-			fullTime: { timeStyle: "medium" },
-			fullTime12h: {
-				hour: "numeric",
-				minute: "numeric",
-				second: "numeric",
-				hour12: true
-			},
-			fullTime24h: {
-				hour: "numeric",
-				minute: "numeric",
-				second: "numeric",
-				hour12: false
-			},
-			fullDateTime: {
-				dateStyle: "full",
-				timeStyle: "short"
-			},
-			fullDateTime12h: {
-				dateStyle: "full",
-				hour: "numeric",
-				minute: "numeric",
-				hour12: true
-			},
-			fullDateTime24h: {
-				dateStyle: "full",
-				hour: "numeric",
-				minute: "numeric",
-				hour12: false
-			},
-			keyboardDate: {
-				year: "numeric",
-				month: "2-digit",
-				day: "2-digit"
-			},
-			keyboardDateTime: {
-				year: "numeric",
-				month: "2-digit",
-				day: "2-digit",
-				hour: "numeric",
-				minute: "numeric"
-			},
-			keyboardDateTime12h: {
-				year: "numeric",
-				month: "2-digit",
-				day: "2-digit",
-				hour: "numeric",
-				minute: "numeric",
-				hour12: true
-			},
-			keyboardDateTime24h: {
-				year: "numeric",
-				month: "2-digit",
-				day: "2-digit",
-				hour: "numeric",
-				minute: "numeric",
-				hour12: false
-			}
-		}[formatString];
-		if (options) return this.getFormatter(options).format(jsDate);
-		return this.getFormatter({}).format(jsDate);
-	}
-	formatByString(date, formatString) {
-		const jsDate = this.toJsDate(date);
-		const getTokenValue = (token) => {
-			switch (token) {
-				case "YYYY": return String(date.year);
-				case "YY": return String(date.year).slice(-2);
-				case "MM": return String(date.month).padStart(2, "0");
-				case "M": return String(date.month);
-				case "DD": return String(date.day).padStart(2, "0");
-				case "D": return String(date.day);
-				case "HH": return String(date.hour).padStart(2, "0");
-				case "H": return String(date.hour);
-				case "hh": return String(date.hour % 12 || 12).padStart(2, "0");
-				case "h": return String(date.hour % 12 || 12);
-				case "mm": return String(date.minute).padStart(2, "0");
-				case "m": return String(date.minute);
-				case "ss": return String(date.second).padStart(2, "0");
-				case "s": return String(date.second);
-				case "A": return date.hour < 12 ? "AM" : "PM";
-				case "a": return date.hour < 12 ? "am" : "pm";
-				case "MMMM": return this.getFormatter({ month: "long" }).format(jsDate);
-				case "MMM": return this.getFormatter({ month: "short" }).format(jsDate);
-				case "dddd": return this.getFormatter({ weekday: "long" }).format(jsDate);
-				case "ddd": return this.getFormatter({ weekday: "short" }).format(jsDate);
-				default: return token;
-			}
-		};
-		return formatString.replace(FORMAT_TOKEN_REGEX, (match) => getTokenValue(match));
-	}
-	getFormatHelperText(format) {
-		return {
-			keyboardDate: "mm/dd/yyyy",
-			keyboardDateTime: "mm/dd/yyyy hh:mm",
-			keyboardDateTime12h: "mm/dd/yyyy hh:mm am/pm",
-			keyboardDateTime24h: "mm/dd/yyyy hh:mm"
-		}[format] ?? format.replace(/YYYY/g, "yyyy").replace(/MM/g, "mm").replace(/DD/g, "dd").replace(/HH/g, "hh").replace(/mm/g, "mm").replace(/ss/g, "ss");
-	}
-	formatNumber(numberToFormat) {
-		return this.getNumberFormatter().format(Number(numberToFormat));
-	}
-	getMeridiemText(ampm) {
-		const date = ampm === "am" ? new Date(2020, 0, 1, 9, 0) : new Date(2020, 0, 1, 15, 0);
-		const match = this.getFormatter({
-			hour: "numeric",
-			hour12: true
-		}).format(date).match(/[AP]M|[ap]m|午前|午後|上午|下午/i);
-		return match ? match[0] : ampm.toUpperCase();
-	}
-	startOfDay(date) {
-		return date.with({
-			hour: 0,
-			minute: 0,
-			second: 0,
-			millisecond: 0,
-			microsecond: 0,
-			nanosecond: 0
-		});
-	}
-	endOfDay(date) {
-		return date.with({
-			hour: 23,
-			minute: 59,
-			second: 59,
-			millisecond: 999,
-			microsecond: 999,
-			nanosecond: 999
-		});
-	}
-	startOfWeek(date, firstDayOfWeek = 0) {
-		const diff = (date.dayOfWeek % 7 - firstDayOfWeek + 7) % 7;
-		return this.startOfDay(date.subtract({ days: diff }));
-	}
-	endOfWeek(date, firstDayOfWeek = 0) {
-		const start = this.startOfWeek(date, firstDayOfWeek);
-		return this.endOfDay(start.add({ days: 6 }));
-	}
-	startOfMonth(date) {
-		return this.startOfDay(date.with({ day: 1 }));
-	}
-	endOfMonth(date) {
-		return this.endOfDay(date.with({ day: date.daysInMonth }));
-	}
-	startOfYear(date) {
-		return this.startOfDay(date.with({
-			month: 1,
-			day: 1
-		}));
-	}
-	endOfYear(date) {
-		return this.endOfDay(date.with({
-			month: 12,
-			day: 31
-		}));
-	}
-	addSeconds(date, amount) {
-		return date.add({ seconds: amount });
-	}
-	addMinutes(date, amount) {
-		return date.add({ minutes: amount });
-	}
-	addHours(date, amount) {
-		return date.add({ hours: amount });
-	}
-	addDays(date, amount) {
-		return date.add({ days: amount });
-	}
-	addWeeks(date, amount) {
-		return date.add({ weeks: amount });
-	}
-	addMonths(date, amount) {
-		return date.add({ months: amount });
-	}
-	addYears(date, amount) {
-		return date.add({ years: amount });
-	}
-	isAfter(date, comparing) {
-		return Temporal.PlainDateTime.compare(date, comparing) > 0;
-	}
-	isAfterDay(date, comparing) {
-		return Temporal.PlainDate.compare(date.toPlainDate(), comparing.toPlainDate()) > 0;
-	}
-	isAfterMonth(date, comparing) {
-		if (date.year !== comparing.year) return date.year > comparing.year;
-		return date.month > comparing.month;
-	}
-	isAfterYear(date, comparing) {
-		return date.year > comparing.year;
-	}
-	isBefore(date, comparing) {
-		return Temporal.PlainDateTime.compare(date, comparing) < 0;
-	}
-	isBeforeDay(date, comparing) {
-		return Temporal.PlainDate.compare(date.toPlainDate(), comparing.toPlainDate()) < 0;
-	}
-	isBeforeMonth(date, comparing) {
-		if (date.year !== comparing.year) return date.year < comparing.year;
-		return date.month < comparing.month;
-	}
-	isBeforeYear(date, comparing) {
-		return date.year < comparing.year;
-	}
-	isEqual(date, comparing) {
-		return Temporal.PlainDateTime.compare(date, comparing) === 0;
-	}
-	isSameDay(date, comparing) {
-		return Temporal.PlainDate.compare(date.toPlainDate(), comparing.toPlainDate()) === 0;
-	}
-	isSameMonth(date, comparing) {
-		return date.year === comparing.year && date.month === comparing.month;
-	}
-	isSameYear(date, comparing) {
-		return date.year === comparing.year;
-	}
-	isSameHour(date, comparing) {
-		return date.year === comparing.year && date.month === comparing.month && date.day === comparing.day && date.hour === comparing.hour;
-	}
-	isWithinRange(date, [start, end]) {
-		return Temporal.PlainDateTime.compare(date, start) >= 0 && Temporal.PlainDateTime.compare(date, end) <= 0;
-	}
-	getYear(date) {
-		return date.year;
-	}
-	getMonth(date) {
-		return date.month - 1;
-	}
-	getDate(date) {
-		return date.day;
-	}
-	getHours(date) {
-		return date.hour;
-	}
-	getMinutes(date) {
-		return date.minute;
-	}
-	getSeconds(date) {
-		return date.second;
-	}
-	getDiff(date, comparing, unit) {
-		const unitKey = unit ?? "days";
-		const comp = /* @__PURE__ */ isString(comparing) ? this.date(comparing) : comparing;
-		if (/* @__PURE__ */ isNull(comp)) return 0;
-		const duration = date.since(comp, { largestUnit: unitKey });
-		switch (unitKey) {
-			case "years": return duration.years;
-			case "months": return duration.months + duration.years * 12;
-			case "weeks": return duration.weeks + Math.floor(duration.days / 7);
-			case "days": return duration.days + duration.weeks * 7;
-			case "hours": return Math.round(duration.total({ unit: "hours" }));
-			case "minutes": return Math.round(duration.total({ unit: "minutes" }));
-			case "seconds": return Math.round(duration.total({ unit: "seconds" }));
-			default: return duration.days;
-		}
-	}
-	getWeek(date, firstDayOfWeek = 0, minimalDays = 1) {
-		const startOfYear = this.startOfYear(date);
-		const startOfFirstWeek = this.startOfWeek(startOfYear, firstDayOfWeek);
-		let firstWeekStart = startOfFirstWeek;
-		if (startOfYear.day - startOfFirstWeek.day < minimalDays) firstWeekStart = startOfFirstWeek.add({ weeks: 1 });
-		const startOfCurrentWeek = this.startOfWeek(date, firstDayOfWeek);
-		const diff = this.getDiff(startOfCurrentWeek, firstWeekStart, "weeks");
-		return Math.max(1, diff + 1);
-	}
-	getDaysInMonth(date) {
-		return date.daysInMonth;
-	}
-	setYear(date, year) {
-		return date.with({ year });
-	}
-	setMonth(date, month) {
-		return date.with({ month: month + 1 });
-	}
-	setDate(date, day) {
-		return date.with({ day });
-	}
-	setHours(date, hours) {
-		return date.with({ hour: hours });
-	}
-	setMinutes(date, minutes) {
-		return date.with({ minute: minutes });
-	}
-	setSeconds(date, seconds) {
-		return date.with({ second: seconds });
-	}
-	getWeekdays(firstDayOfWeek = 0, format = "short") {
-		const weekdays = [];
-		const refDate = Temporal.PlainDate.from("2015-01-04");
-		const formatter = this.getFormatter({ weekday: format });
-		for (let i = 0; i < 7; i++) {
-			const day = refDate.add({ days: (i + firstDayOfWeek) % 7 });
-			const jsDate = new Date(day.year, day.month - 1, day.day);
-			weekdays.push(formatter.format(jsDate));
-		}
-		return weekdays;
-	}
-	getWeekArray(date, firstDayOfWeek = 0) {
-		const weeks = [];
-		const monthStart = this.startOfMonth(date);
-		const monthEnd = this.endOfMonth(date);
-		let current = this.startOfWeek(monthStart, firstDayOfWeek);
-		const end = this.endOfWeek(monthEnd);
-		while (Temporal.PlainDateTime.compare(current, end) <= 0) {
-			const week = [];
-			for (let i = 0; i < 7; i++) {
-				week.push(current);
-				current = current.add({ days: 1 });
-			}
-			weeks.push(week);
-		}
-		return weeks;
-	}
-	getMonthArray(date) {
-		const year = date.year;
-		const months = [];
-		for (let month = 1; month <= 12; month++) months.push(Temporal.PlainDateTime.from({
-			year,
-			month,
-			day: 1
-		}));
-		return months;
-	}
-	getYearRange(start, end) {
-		const years = [];
-		let current = start.year;
-		while (current <= end.year) {
-			years.push(Temporal.PlainDateTime.from({
-				year: current,
-				month: 1,
-				day: 1
-			}));
-			current++;
-		}
-		return years;
-	}
-	getNextMonth(date) {
-		return this.startOfMonth(date.add({ months: 1 }));
-	}
-	getPreviousMonth(date) {
-		return this.startOfMonth(date.subtract({ months: 1 }));
-	}
-	mergeDateAndTime(date, time) {
-		return date.with({
-			hour: time.hour,
-			minute: time.minute,
-			second: time.second,
-			millisecond: time.millisecond
-		});
-	}
-	/**
-	* Gets a cached Intl.DateTimeFormat instance or creates one if not cached.
-	* Cache is limited to MAX_CACHE_SIZE entries to prevent memory leaks.
-	*/
-	getFormatter(options) {
-		const key = `${this.locale}:${JSON.stringify(options)}`;
-		let formatter = this.formatCache.get(key);
-		if (!formatter) {
-			if (this.formatCache.size >= MAX_CACHE_SIZE) {
-				const firstKey = this.formatCache.keys().next().value;
-				if (firstKey) this.formatCache.delete(firstKey);
-			}
-			formatter = new Intl.DateTimeFormat(this.locale, options);
-			this.formatCache.set(key, formatter);
-		}
-		return formatter;
-	}
-	/**
-	* Gets a cached Intl.NumberFormat instance or creates one if not cached.
-	* Cache is limited to MAX_CACHE_SIZE entries to prevent memory leaks.
-	*/
-	getNumberFormatter() {
-		let formatter = this.numberFormatCache.get(this.locale);
-		if (!formatter) {
-			if (this.numberFormatCache.size >= MAX_CACHE_SIZE) {
-				const firstKey = this.numberFormatCache.keys().next().value;
-				if (firstKey) this.numberFormatCache.delete(firstKey);
-			}
-			formatter = new Intl.NumberFormat(this.locale);
-			this.numberFormatCache.set(this.locale, formatter);
-		}
-		return formatter;
-	}
-};
-
 //#endregion
 //#region src/composables/useDate/index.ts
 /**
@@ -3392,16 +2825,16 @@ var Vuetify0DateAdapter = class {
 *
 * Key features:
 * - Adapter pattern for date library abstraction
-* - Temporal API as default adapter (modern, immutable dates)
 * - Locale-aware formatting via Intl.DateTimeFormat
 * - Integration with useLocale for automatic locale sync
 *
-* @example
+* @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())
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
 *
 * // In a component:
 * const { adapter } = useDate()
@@ -3417,7 +2850,7 @@ var Vuetify0DateAdapter = class {
 *   // ... implementation
 * }
 *
-* const context = createDate({ adapter: new DateFnsAdapter() })
+* app.use(createDatePlugin({ adapter: new DateFnsAdapter() }))
 * ```
 */
 /**
@@ -3440,7 +2873,8 @@ const defaultLocales = {
 /**
 * Creates a new date context.
 *
-* @param options Optional adapter and locale configuration.
+* @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.
 *
@@ -3448,18 +2882,20 @@ const defaultLocales = {
 *
 * @example
 * ```ts
-* const { adapter } = createDate()
-* const today = adapter.date() // Temporal.PlainDateTime
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
 *
-* // With locale options
-* const { adapter: deAdapter } = createDate({ locale: 'de-DE' })
+* const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
+* const today = adapter.date()
 *
-* // With custom adapter
-* const { adapter } = createDate({ adapter: new DateFnsAdapter() })
+* // With locale options
+* const { adapter } = createDate({
+*   adapter: new Vuetify0DateAdapter(),
+*   locale: 'de-DE',
+* })
 * ```
 */
-function createDate(options = {}) {
-	const { locales = defaultLocales, adapter = new Vuetify0DateAdapter(), locale: initialLocale } = options;
+function createDate(options) {
+	const { locales = defaultLocales, adapter, locale: initialLocale } = options;
 	let selectedId;
 	try {
 		if (instanceExists()) selectedId = useLocale().selectedId;
@@ -3487,22 +2923,10 @@ function createDate(options = {}) {
 	};
 }
 /**
-* Creates a fallback date context for when useDate is called outside of a Vue component.
-*
-* @returns A fallback date context with Vuetify0DateAdapter.
-* @internal
-*/
-function createDateFallback() {
-	const adapter = new Vuetify0DateAdapter();
-	return {
-		adapter,
-		locale: computed(() => adapter.locale ?? "en-US")
-	};
-}
-/**
 * Creates a new date context trinity.
 *
-* @param options Optional adapter, locale, and namespace configuration.
+* @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].
 *
@@ -3510,18 +2934,15 @@ function createDateFallback() {
 *
 * @example
 * ```ts
-* const [useAppDate, provideAppDate] = createDateContext({
-*   namespace: 'app:date',
-* })
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
 *
-* // With custom adapter
 * const [useAppDate, provideAppDate] = createDateContext({
-*   adapter: new DateFnsAdapter(),
+*   adapter: new Vuetify0DateAdapter(),
 *   namespace: 'app:date',
 * })
 * ```
 */
-function createDateContext(options = {}) {
+function createDateContext(options) {
 	const { namespace = "v0:date", ...dateOptions } = options;
 	const [useDateContext, _provideDateContext] = createContext(namespace);
 	const context = createDate(dateOptions);
@@ -3533,7 +2954,8 @@ function createDateContext(options = {}) {
 /**
 * Creates a new date plugin.
 *
-* @param options Optional adapter, locale, and namespace configuration.
+* @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.
 *
@@ -3541,17 +2963,19 @@ function createDateContext(options = {}) {
 *
 * @example
 * ```ts
-* const app = createApp(App)
-* app.use(createDatePlugin())
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
 *
-* // With options
-* app.use(createDatePlugin({ locale: 'de-DE' }))
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
 *
-* // With custom adapter
-* app.use(createDatePlugin({ adapter: new DateFnsAdapter() }))
+* // With locale options
+* app.use(createDatePlugin({
+*   adapter: new Vuetify0DateAdapter(),
+*   locale: 'de-DE',
+* }))
 * ```
 */
-function createDatePlugin(options = {}) {
+function createDatePlugin(options) {
 	const { namespace = "v0:date", ...dateOptions } = options;
 	const [, provideDateContext, context] = createDateContext({
 		namespace,
@@ -3567,16 +2991,26 @@ function createDatePlugin(options = {}) {
 /**
 * Returns the current date context.
 *
-* When called inside a component with a provided date context (via plugin or provider),
-* returns that context. Otherwise, returns a fallback context with Vuetify0DateAdapter.
+* 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'
@@ -3587,13 +3021,8 @@ function createDatePlugin(options = {}) {
 * ```
 */
 function useDate(namespace = "v0:date") {
-	const fallback = createDateFallback();
-	if (!instanceExists()) return fallback;
-	try {
-		return useContext(namespace, fallback);
-	} catch {
-		return fallback;
-	}
+	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
@@ -4593,7 +4022,7 @@ function matchesKeyGroup(e, group, platformIsMac) {
 */
 function useIntersectionObserver(target, callback, options = {}) {
 	const { isHydrated } = useHydration();
-	const targetRef = isRef(target) ? target : shallowRef(target);
+	const targetRef = toRef(target);
 	const observer = shallowRef();
 	const isPaused = shallowRef(false);
 	const isIntersecting = shallowRef(false);
@@ -4994,6 +4423,7 @@ function usePrefersContrast() {
 */
 function useMutationObserver(target, callback, options = {}) {
 	const { isHydrated } = useHydration();
+	const targetRef = toRef(target);
 	const observer = shallowRef();
 	const isPaused = shallowRef(false);
 	const isActive = toRef(() => !!observer.value);
@@ -5008,7 +4438,7 @@ function useMutationObserver(target, callback, options = {}) {
 	};
 	function setup() {
 		if (/* @__PURE__ */ isNull(observer.value)) return;
-		if (!isHydrated.value || !SUPPORTS_MUTATION_OBSERVER || !target.value || isPaused.value) return;
+		if (!isHydrated.value || !SUPPORTS_MUTATION_OBSERVER || !targetRef.value || isPaused.value) return;
 		observer.value = new MutationObserver((mutations) => {
 			callback(mutations.map((mutation) => ({
 				type: mutation.type,
@@ -5023,7 +4453,7 @@ function useMutationObserver(target, callback, options = {}) {
 			})));
 			if (options.once) stop();
 		});
-		observer.value.observe(target.value, observerOptions);
+		observer.value.observe(targetRef.value, observerOptions);
 		if (options.immediate) {
 			const emptyNodeList = {
 				length: 0,
@@ -5033,7 +4463,7 @@ function useMutationObserver(target, callback, options = {}) {
 			};
 			callback([{
 				type: "childList",
-				target: target.value,
+				target: targetRef.value,
 				addedNodes: emptyNodeList,
 				removedNodes: emptyNodeList,
 				previousSibling: null,
@@ -5045,13 +4475,13 @@ function useMutationObserver(target, callback, options = {}) {
 			if (options.once) stop();
 		}
 	}
-	watch(() => target.value, (el, oldEl) => {
+	watch(() => targetRef.value, (el, oldEl) => {
 		if (oldEl) cleanup();
 		if (isHydrated.value && el) setup();
 	}, { immediate: true });
 	if (!isHydrated.value) {
 		const stopHydrationWatch = watch(() => isHydrated.value, (hydrated) => {
-			if (hydrated && target.value && !observer.value) {
+			if (hydrated && targetRef.value && !observer.value) {
 				setup();
 				stopHydrationWatch();
 			}
@@ -5085,6 +4515,509 @@ function useMutationObserver(target, callback, options = {}) {
 	};
 }
 
+//#endregion
+//#region src/composables/createNested/strategies.ts
+/**
+* Multiple open strategy: allows multiple nodes to be open simultaneously.
+*
+* @remarks
+* Perfect for tree views, file explorers, and nested menus where users expect
+* to keep multiple sections expanded at once.
+*
+* @example
+* ```ts
+* const tree = createNested({ openStrategy: multipleOpenStrategy })
+* tree.open('node-1')
+* tree.open('node-2')
+* // Both nodes are now open
+* ```
+*/
+const multipleOpenStrategy = {
+	onOpen: void 0,
+	onClose: void 0
+};
+/**
+* Single open strategy: only one node can be open at a time (accordion behavior).
+*
+* @remarks
+* Perfect for accordions, single-select navigation, and contexts where only
+* one section should be visible at a time.
+*
+* @example
+* ```ts
+* const tree = createNested({ openStrategy: singleOpenStrategy })
+* tree.open('node-1') // node-1 opens
+* tree.open('node-2') // node-1 closes, node-2 opens
+* ```
+*/
+const singleOpenStrategy = {
+	onOpen: (id, context) => {
+		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", openStrategy, ...options } = _options;
+	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 openedItems = computed(() => {
+		return new Set(Array.from(openedIds).map((id) => group.get(id)).filter((item) => !/* @__PURE__ */ isUndefined(item)));
+	});
+	const roots = computed(() => {
+		return group.values().filter((item) => /* @__PURE__ */ isUndefined(parents.get(item.id)));
+	});
+	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 of group.keys()) if (!isLeaf(id)) openedIds.add(id);
+	}
+	function collapseAll() {
+		openedIds.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 queue = [...children.get(id) ?? []];
+		let index = 0;
+		while (index < queue.length) {
+			const currentId = queue[index++];
+			descendants.push(currentId);
+			queue.push(...children.get(currentId) ?? []);
+		}
+		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 ancestorIds = getAncestors(id).toReversed();
+		for (const aid of ancestorIds) {
+			const childIds = children.get(aid) ?? [];
+			if (childIds.length === 0) continue;
+			const allSelected = childIds.every((cid) => group.selected(cid));
+			const someSelected = childIds.some((cid) => group.selected(cid) || group.mixed(cid));
+			if (allSelected) {
+				group.unmix(aid);
+				group.select(aid);
+			} else if (someSelected) {
+				group.unselect(aid);
+				group.mix(aid);
+			} else {
+				group.unmix(aid);
+				group.unselect(aid);
+			}
+		}
+	}
+	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 {
+				group.unmix(id);
+				group.select(id);
+				for (const did of getDescendants(id)) {
+					group.unmix(did);
+					group.select(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 {
+				group.unmix(id);
+				group.unselect(id);
+				for (const did of getDescendants(id)) {
+					group.unmix(did);
+					group.unselect(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)) {
+			parents.set(id, parentId);
+			const list = children.get(parentId);
+			if (list) list.push(id);
+			else children.set(parentId, [id]);
+			if (openAll) openedIds.add(parentId);
+		} else parents.set(id, void 0);
+		const { children: _, ...rest } = registration;
+		const item = {
+			...rest,
+			id,
+			parentId: parents.get(id),
+			isOpen: toRef(() => opened(id)),
+			isLeaf: toRef(() => isLeaf(id)),
+			depth: toRef(() => getDepth(id)),
+			open: () => open(id),
+			close: () => close(id),
+			flip: () => flip(id),
+			reveal: () => reveal(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 (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) for (const did of getDescendants(id)) {
+			parents.delete(did);
+			children.delete(did);
+			openedIds.delete(did);
+			group.unregister(did);
+		}
+		else {
+			for (const did of getDescendants(id)) openedIds.delete(did);
+			for (const cid of list) parents.set(cid, void 0);
+		}
+		parents.delete(id);
+		children.delete(id);
+		openedIds.delete(id);
+		group.unregister(id);
+	}
+	function offboard(ids, cascade = false) {
+		for (const id of ids) unregister(id, cascade);
+	}
+	function onboard(registrations) {
+		return registrations.map((registration) => register(registration));
+	}
+	function clear() {
+		children.clear();
+		parents.clear();
+		openedIds.clear();
+		group.reset();
+	}
+	function reset() {
+		clear();
+	}
+	const context = {
+		...group,
+		children,
+		parents,
+		openedIds,
+		openedItems,
+		roots,
+		leaves,
+		getPath,
+		getAncestors,
+		getDescendants,
+		isLeaf,
+		getDepth,
+		isAncestorOf,
+		hasAncestor,
+		siblings,
+		position,
+		open,
+		close,
+		flip,
+		opened,
+		unfold,
+		reveal,
+		expand,
+		expandAll,
+		collapseAll,
+		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/useResizeObserver/index.ts
 /**
@@ -5146,12 +5079,13 @@ function useMutationObserver(target, callback, options = {}) {
 */
 function useResizeObserver(target, callback, options = {}) {
 	const { isHydrated } = useHydration();
+	const targetRef = toRef(target);
 	const observer = shallowRef();
 	const isPaused = shallowRef(false);
 	const isActive = toRef(() => !!observer.value);
 	function setup() {
 		if (/* @__PURE__ */ isNull(observer.value)) return;
-		if (!isHydrated.value || !SUPPORTS_OBSERVER || !target.value || isPaused.value) return;
+		if (!isHydrated.value || !SUPPORTS_OBSERVER || !targetRef.value || isPaused.value) return;
 		observer.value = new ResizeObserver((entries) => {
 			callback(entries.map((entry) => ({
 				contentRect: {
@@ -5164,9 +5098,9 @@ function useResizeObserver(target, callback, options = {}) {
 			})));
 			if (options.once) stop();
 		});
-		observer.value.observe(target.value, { box: options.box || "content-box" });
+		observer.value.observe(targetRef.value, { box: options.box || "content-box" });
 		if (options.immediate) {
-			const rect = target.value.getBoundingClientRect();
+			const rect = targetRef.value.getBoundingClientRect();
 			callback([{
 				contentRect: {
 					width: rect.width,
@@ -5174,17 +5108,17 @@ function useResizeObserver(target, callback, options = {}) {
 					top: rect.top,
 					left: rect.left
 				},
-				target: target.value
+				target: targetRef.value
 			}]);
 		}
 	}
-	watch(() => target.value, (el, oldEl) => {
+	watch(() => targetRef.value, (el, oldEl) => {
 		if (oldEl) cleanup();
 		if (isHydrated.value && el) setup();
 	}, { immediate: true });
 	if (!isHydrated.value) {
 		const stopHydrationWatch = watch(() => isHydrated.value, (hydrated) => {
-			if (hydrated && target.value && !observer.value) {
+			if (hydrated && targetRef.value && !observer.value) {
 				setup();
 				stopHydrationWatch();
 			}
@@ -5941,7 +5875,7 @@ function createQueue(_options = {}) {
 		}
 	}
 	function register(registration = {}) {
-		const id = registration.id ?? /* @__PURE__ */ genId();
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
 		const timeout = Object.prototype.hasOwnProperty.call(registration, "timeout") ? registration.timeout : _timeout;
 		const ticket = {
 			...registration,
@@ -7653,4 +7587,4 @@ function useClickOutside(target, handler, options = {}) {
 }
 
 //#endregion
-export { useFilter as $, createContext as $t, PermissionAdapter as A, createHydrationPlugin as At, useMediaQuery as B, createSelectionContext as Bt, createQueue as C, createBreakpoints as Ct, createPermissionsContext as D, createFallbackHydration as Dt, createPermissions as E, useBreakpoints as Et, createOverflowContext as F, createGroupContext as Ft, useElementIntersection as G, createLoggerContext as Gt, usePrefersDark as H, createRegistry as Ht, useOverflow as I, useGroup as It, createForm as J, Vuetify0LoggerAdapter as Jt, useIntersectionObserver as K, createLoggerPlugin as Kt, useElementSize as L, toArray as Lt, createPaginationContext as M, toReactive as Mt, usePagination as N, useProxyModel as Nt, createPermissionsPlugin as O, createHydration as Ot, createOverflow as P, createGroup as Pt, createFilterContext as Q, createTrinity as Qt, useResizeObserver as R, useProxyRegistry as Rt, useStep as S, useSingle as St, useQueue as T, createBreakpointsPlugin as Tt, usePrefersReducedMotion as U, createRegistryContext as Ut, usePrefersContrast as V, useSelection as Vt, useLazy as W, createLogger as Wt, useForm as X, ConsolaLoggerAdapter as Xt, createFormContext as Y, PinoLoggerAdapter as Yt, createFilter as Z, createPlugin as Zt, createStoragePlugin as _, createTokens as _t, useVirtual as a, createDate as at, createStep as b, createSingle as bt, createTimelineContext as c, createDatePlugin as ct, createThemeContext as d, createLocale as dt, provideContext as en, useFilterContext as et, createThemePlugin as f, createLocaleContext as ft, createStorageContext as g, Vuetify0LocaleAdapter as gt, createStorage as h, useLocale as ht, useWindowEventListener as i, useFeatures as it, createPagination as j, useHydration as jt, usePermissions as k, createHydrationContext as kt, useTimeline as l, useDate as lt, Vuetify0ThemeAdapter as m, createLocalePlugin as mt, useDocumentEventListener as n, createFeaturesContext as nt, useToggleScope as o, createDateContext as ot, useTheme as p, createLocaleFallback as pt, useHotkey as q, useLogger as qt, useEventListener as r, createFeaturesPlugin as rt, createTimeline as s, createDateFallback as st, useClickOutside as t, useContext as tn, createFeatures as tt, createTheme as u, Vuetify0DateAdapter as ut, useStorage as v, createTokensContext as vt, createQueueContext as w, createBreakpointsContext as wt, createStepContext as x, createSingleContext as xt, MemoryAdapter as y, useTokens as yt, useMutationObserver as z, createSelection as zt };
+export { createForm as $, ConsolaLoggerAdapter as $t, PermissionAdapter as A, createFallbackHydration as At, createNestedContext as B, toArray as Bt, createQueue as C, createSingle as Ct, createPermissionsContext as D, createBreakpointsContext as Dt, createPermissions as E, createBreakpoints as Et, createOverflowContext as F, toReactive as Ft, useMediaQuery as G, createRegistry as Gt, multipleOpenStrategy as H, createSelection as Ht, useOverflow as I, useProxyModel as It, usePrefersReducedMotion as J, createLoggerContext as Jt, usePrefersContrast as K, createRegistryContext as Kt, useElementSize as L, createGroup as Lt, createPaginationContext as M, createHydrationContext as Mt, usePagination as N, createHydrationPlugin as Nt, createPermissionsPlugin as O, createBreakpointsPlugin as Ot, createOverflow as P, useHydration as Pt, useHotkey as Q, PinoLoggerAdapter as Qt, useResizeObserver as R, createGroupContext as Rt, useStep as S, useTokens as St, useQueue as T, useSingle as Tt, singleOpenStrategy as U, createSelectionContext as Ut, useNested as V, useProxyRegistry as Vt, useMutationObserver as W, useSelection as Wt, useElementIntersection as X, useLogger as Xt, useLazy as Y, createLoggerPlugin as Yt, useIntersectionObserver as Z, Vuetify0LoggerAdapter as Zt, createStoragePlugin as _, createLocalePlugin as _t, useVirtual as a, useFilterContext as at, createStep as b, createTokens as bt, createTimelineContext as c, createFeaturesPlugin as ct, createThemeContext as d, createDateContext as dt, createPlugin as en, createFormContext as et, createThemePlugin as f, createDatePlugin as ft, createStorageContext as g, createLocaleFallback as gt, createStorage as h, createLocaleContext as ht, useWindowEventListener as i, useContext as in, useFilter as it, createPagination as j, createHydration as jt, usePermissions as k, useBreakpoints as kt, useTimeline as l, useFeatures as lt, Vuetify0ThemeAdapter as m, createLocale as mt, useDocumentEventListener as n, createContext as nn, createFilter as nt, useToggleScope as o, createFeatures as ot, useTheme as p, useDate as pt, usePrefersDark as q, createLogger as qt, useEventListener as r, provideContext as rn, createFilterContext as rt, createTimeline as s, createFeaturesContext as st, useClickOutside as t, createTrinity as tn, useForm as tt, createTheme as u, createDate as ut, useStorage as v, useLocale as vt, createQueueContext as w, createSingleContext as wt, createStepContext as x, createTokensContext as xt, MemoryAdapter as y, Vuetify0LocaleAdapter as yt, createNested as z, useGroup as zt };