@vuetify/v0 0.0.2-beta.4 → 0.0.3

package/dist/composables-yeVk-ULz.js

@@ -0,0 +1,1270 @@
+import { createContext, createPlugin, createTrinity, useContext } from "./factories-BEpawPUw.js";
+import { createTokensContext, useHydration, useLogger, useRegistry, useSelection, useSingle, useTokens } from "./useTheme-DCXkw_kv.js";
+import { isArray, isBoolean, isFunction, isObject } from "./utilities-D9rWEgQK.js";
+import { IN_BROWSER, SUPPORTS_INTERSECTION_OBSERVER, SUPPORTS_MUTATION_OBSERVER, SUPPORTS_OBSERVER } from "./globals-DZvNEOB4.js";
+import { toArray } from "./transformers-CWrxLIkw.js";
+import { computed, getCurrentScope, isRef, onMounted, onScopeDispose, onUnmounted, readonly, ref, shallowRef, toRaw, toRef, toValue, unref, watch } from "vue";
+
+//#region src/composables/useEventListener/index.ts
+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;
+}
+/**
+* Convenience function for attaching event listeners to the window object.
+* This function provides a simplified API by pre-binding the window target,
+* making it easier to handle window-specific events with automatic cleanup.
+*
+* @param event Event name(s) to listen for from WindowEventMap.
+* @param listener Event handler function(s) with proper window event typing.
+* @param options Optional event listener configuration.
+* @returns Function to manually remove all attached listeners.
+*/
+function useWindowEventListener(event, listener, options) {
+	return useEventListener(window, event, listener, options);
+}
+/**
+* Convenience function for attaching event listeners to the document object.
+* This function provides a simplified API by pre-binding the document target,
+* making it easier to handle document-specific events with automatic cleanup.
+*
+* @param event Event name(s) to listen for from DocumentEventMap.
+* @param listener Event handler function(s) with proper document event typing.
+* @param options Optional event listener configuration.
+* @returns Function to manually remove all attached listeners.
+*/
+function useDocumentEventListener(event, listener, options) {
+	return useEventListener(document, event, listener, options);
+}
+
+//#endregion
+//#region src/composables/useGroup/index.ts
+/**
+* Creates a group selection context for managing collections of items where multiple selections can be made.
+* This function extends the selection functionality with group selection capabilities.
+*
+* @param options Optional configuration for group selection behavior.
+* @template Z The type of items managed by the group selection.
+* @template E The type of the group selection context.
+* @returns The group selection context object.
+*/
+function useGroup(options) {
+	const registry = useSelection(options);
+	const selectedIndexes = computed(() => {
+		return new Set(Array.from(registry.selectedItems.value).map((item) => item?.index));
+	});
+	function select(ids) {
+		for (const id of toArray(ids)) registry.select(id);
+	}
+	function unselect(ids) {
+		for (const id of toArray(ids)) registry.unselect(id);
+	}
+	function toggle(ids) {
+		for (const id of toArray(ids)) registry.toggle(id);
+	}
+	return {
+		...registry,
+		select,
+		unselect,
+		toggle,
+		selectedIndexes
+	};
+}
+/**
+* Creates a group selection registry context with full injection/provision control.
+* Returns the complete trinity for advanced usage scenarios.
+*
+* @param namespace The namespace for the group selection registry context
+* @param options Optional configuration for group selection behavior.
+* @template Z The structure of the registry group selection items.
+* @template E The available methods for the group's context.
+* @returns A tuple containing the inject function, provide function, and the group selection context.
+*/
+function createGroupContext(namespace, options) {
+	const [useGroupContext, _provideGroupContext] = createContext(namespace);
+	const context = useGroup(options);
+	function provideGroupContext(_context = context, app) {
+		return _provideGroupContext(_context, app);
+	}
+	return createTrinity(useGroupContext, provideGroupContext, context);
+}
+
+//#endregion
+//#region src/composables/useFeatures/index.ts
+/**
+*
+* @param namespace The namespace for the feature context
+* @param options Configure initial features to register
+* @template Z The type of feature ticket
+* @template E The type of feature context
+* @returns A context trinity for the features context
+*
+* @see https://0.vuetifyjs.com/composables/plugins/create-features
+*/
+function createFeatures(namespace = "v0:features", options = {}) {
+	const [useFeaturesContext, _provideFeaturesContext] = createContext(namespace);
+	const tokens = useTokens(options.features, { flat: true });
+	const registry = useGroup();
+	for (const [id, { value }] of tokens.entries()) register({
+		id,
+		value
+	});
+	function variation(id, fallback = null) {
+		const ticket = registry.get(id);
+		if (!ticket) return fallback;
+		return isObject(ticket.value) ? ticket.value.$variation ?? fallback : fallback;
+	}
+	function register(registration = {}) {
+		const item = {
+			value: false,
+			...registration
+		};
+		const ticket = registry.register(item);
+		if (isBoolean(ticket.value) || isObject(ticket.value) && isBoolean(ticket.value.$value) && ticket.value.$value === true) registry.select(ticket.id);
+		return ticket;
+	}
+	const context = {
+		...registry,
+		variation,
+		register
+	};
+	function provideFeaturesContext(_context = context, app) {
+		return _provideFeaturesContext(_context, app);
+	}
+	return createTrinity(useFeaturesContext, provideFeaturesContext, context);
+}
+/**
+* Simple hook to access the theme context.
+*
+* @returns The features context containing current theme state and utilities.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/create-features
+*/
+function useFeatures() {
+	return useContext("v0:features");
+}
+/**
+* Creates a Vue plugin for feature management with variation support.
+*
+* @param options Configuration for initial features to register.
+* @template Z The type of feature ticket.
+* @template E The type of feature context.
+* @returns A Vue plugin object with install method.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/create-features
+*/
+function createFeaturesPlugin(options = {}) {
+	const [, provideFeaturesContext, context] = createFeatures("v0:features", options);
+	return createPlugin({
+		namespace: "v0:features",
+		provide: (app) => {
+			provideFeaturesContext(context, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useFilter/index.ts
+function defaultFilter(query, item, keys, mode = "some") {
+	const queries = Array.isArray(query) ? query.map((q) => String(q).toLowerCase()) : [String(query).toLowerCase()];
+	function match(value, q) {
+		return String(value).toLowerCase().includes(q);
+	}
+	const stringValues = (typeof item === "object" && item !== null ? keys?.length ? keys.map((k) => item[k]) : Object.values(item) : [item]).map((v) => String(v).toLowerCase());
+	if (mode === "some") return stringValues.some((val) => match(val, queries[0]));
+	if (mode === "every") return stringValues.every((val) => match(val, queries[0]));
+	if (mode === "union") return queries.some((q) => stringValues.some((val) => match(val, q)));
+	if (mode === "intersection") return queries.every((q) => stringValues.some((val) => match(val, q)));
+	return false;
+}
+function toRefOrGetter(value) {
+	return isRef(value) ? value : typeof value === "function" ? toRef(value) : toRef(() => value);
+}
+/**
+* Creates a reactive filter for arrays based on query matching with configurable search modes.
+* Supports 'some' (any field matches), 'every' (all fields match), 'union' (any query matches),
+* and 'intersection' (all queries match) filtering strategies.
+*
+* @param query Filter query to match against items.
+* @param items Collection of items to filter.
+* @param options Optional configuration for the filter behavior.
+* @template Z The type of the items being filtered.
+* @returns A computed reference to the filtered items based on the query and options.
+*/
+function useFilter(query, items, options = {}) {
+	const { customFilter, keys, mode = "some" } = options;
+	const filterFunction = customFilter ?? ((q, i) => defaultFilter(q, i, keys, mode));
+	const itemsRef = isRef(items) ? items : toRef(() => items);
+	const queryRef = toRefOrGetter(query);
+	return { items: computed(() => {
+		const q = toValue(queryRef);
+		const queries = (Array.isArray(q) ? q : [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));
+	}) };
+}
+
+//#endregion
+//#region src/composables/useForm/index.ts
+function useForm(options) {
+	const registry = useRegistry(options);
+	const validateOn = options?.validateOn || "submit";
+	function parse(value) {
+		return value.toLowerCase().split(/\s+/);
+	}
+	function validatesOn(event) {
+		return parse(validateOn).includes(event);
+	}
+	const isValidating = computed(() => {
+		for (const ticket of registry.collection.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 (ticket.isValid.value === null) 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);
+		if (validatesOn("submit")) return (await Promise.all(validating.map(async (id$1) => await registry.get(id$1)?.validate() ?? true))).every(Boolean);
+		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 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;
+		}
+		async function validate$1(silent = false) {
+			if (rules.length === 0) return true;
+			isValidating$1.value = true;
+			try {
+				const errorMessages = (await Promise.all(rules.map((rule) => rule(model.value)))).filter((result) => typeof result === "string");
+				if (!silent) {
+					errors.value = errorMessages;
+					isValid$1.value = errorMessages.length === 0;
+					isPristine.value = toValue(model) === initialValue;
+				}
+				return errorMessages.length === 0;
+			} finally {
+				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;
+	}
+	return {
+		...registry,
+		register,
+		reset,
+		submit,
+		validateOn,
+		isValid,
+		isValidating
+	};
+}
+
+//#endregion
+//#region src/composables/useIntersectionObserver/index.ts
+/**
+* Composable for observing element intersection with viewport or ancestor
+*
+* @param target - Element ref to observe
+* @param callback - Callback fired on intersection change
+* @param options - Observer options
+* @returns Observer controls and intersection state
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
+*/
+function useIntersectionObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	const isIntersecting = shallowRef(false);
+	watch([isHydrated, target], ([hydrated, el]) => {
+		cleanup();
+		if (!hydrated || !SUPPORTS_INTERSECTION_OBSERVER || !el) return;
+		observer.value = new IntersectionObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				boundingClientRect: entry.boundingClientRect,
+				intersectionRatio: entry.intersectionRatio,
+				intersectionRect: entry.intersectionRect,
+				isIntersecting: entry.isIntersecting,
+				rootBounds: entry.rootBounds,
+				target: entry.target,
+				time: entry.time
+			}));
+			const latestEntry = transformedEntries.at(-1);
+			if (latestEntry) isIntersecting.value = latestEntry.isIntersecting;
+			callback(transformedEntries);
+		}, {
+			root: options.root || null,
+			rootMargin: options.rootMargin || "0px",
+			threshold: options.threshold || 0
+		});
+		observer.value.observe(el);
+		if (options.immediate) {
+			const syntheticEntry = {
+				boundingClientRect: el.getBoundingClientRect(),
+				intersectionRatio: 0,
+				intersectionRect: new DOMRect(0, 0, 0, 0),
+				isIntersecting: false,
+				rootBounds: null,
+				target: el,
+				time: performance.now()
+			};
+			callback([syntheticEntry]);
+		}
+	});
+	function setup() {
+		if (!isHydrated.value || !SUPPORTS_INTERSECTION_OBSERVER || !target.value || isPaused.value) return;
+		observer.value = new IntersectionObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				boundingClientRect: entry.boundingClientRect,
+				intersectionRatio: entry.intersectionRatio,
+				intersectionRect: entry.intersectionRect,
+				isIntersecting: entry.isIntersecting,
+				rootBounds: entry.rootBounds,
+				target: entry.target,
+				time: entry.time
+			}));
+			const latestEntry = transformedEntries.at(-1);
+			if (latestEntry) isIntersecting.value = latestEntry.isIntersecting;
+			callback(transformedEntries);
+		}, {
+			root: options.root || null,
+			rootMargin: options.rootMargin || "0px",
+			threshold: options.threshold || 0
+		});
+		observer.value.observe(target.value);
+		if (options.immediate) {
+			const syntheticEntry = {
+				boundingClientRect: target.value.getBoundingClientRect(),
+				intersectionRatio: 0,
+				intersectionRect: new DOMRect(0, 0, 0, 0),
+				isIntersecting: false,
+				rootBounds: null,
+				target: target.value,
+				time: performance.now()
+			};
+			callback([syntheticEntry]);
+		}
+	}
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		cleanup();
+	}
+	onUnmounted(stop);
+	return {
+		isIntersecting: readonly(isIntersecting),
+		isPaused: readonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+/**
+* Convenience composable for simple intersection detection
+*
+* @param target - Element ref to observe
+* @param options - Observer options
+* @returns Reactive intersection state
+*/
+function useElementIntersection(target, options = {}) {
+	const isIntersecting = shallowRef(false);
+	const intersectionRatio = shallowRef(0);
+	useIntersectionObserver(target, (entries) => {
+		const entry = entries.at(-1);
+		if (entry) {
+			isIntersecting.value = entry.isIntersecting;
+			intersectionRatio.value = entry.intersectionRatio;
+		}
+	}, {
+		immediate: true,
+		...options
+	});
+	return {
+		isIntersecting: readonly(isIntersecting),
+		intersectionRatio: readonly(intersectionRatio)
+	};
+}
+
+//#endregion
+//#region src/composables/useKeydown/index.ts
+/**
+* Sets up global keyboard event listeners for specified key handlers with automatic cleanup.
+* This composable automatically starts listening when mounted and cleans up when the scope
+* is disposed, providing a clean way to handle global keyboard interactions.
+*
+* @param handlers A single handler or array of handlers to register for keydown events.
+* @returns Object with methods to manually start and stop listening for keydown events.
+*/
+function useKeydown(handlers) {
+	const keyHandlers = Array.isArray(handlers) ? handlers : [handlers];
+	function onKeydown(event) {
+		const handler = keyHandlers.find((h$1) => h$1.key === event.key);
+		if (handler) {
+			if (handler.preventDefault) event.preventDefault();
+			if (handler.stopPropagation) event.stopPropagation();
+			handler.handler(event);
+		}
+	}
+	function startListening() {
+		document.addEventListener("keydown", onKeydown);
+	}
+	function stopListening() {
+		document.removeEventListener("keydown", onKeydown);
+	}
+	if (getCurrentScope()) onMounted(startListening);
+	onScopeDispose(stopListening, true);
+	return {
+		startListening,
+		stopListening
+	};
+}
+
+//#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 and named variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && typeof params[0] === "object" && params[0] !== null && !Array.isArray(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return variables[name] === void 0 ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (params[idx] !== void 0) 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
+/**
+* Creates a locale registry for managing internationalization with translations and number formatting.
+* Supports message resolution with token references and locale-specific number formatting.
+*
+* @param namespace The namespace for the locale context.
+* @param options Configuration including adapter and messages.
+* @template Z The type of the locale context.
+* @template E The type of the locale items managed by the registry.
+* @returns An array containing the inject function, provide function, and the locale context.
+*/
+function createLocale(namespace = "v0:locale", options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [useLocaleContext, _provideLocaleContext] = createContext(namespace);
+	const registry = useSingle();
+	for (const id in messages) {
+		registry.register({
+			value: messages[id],
+			id
+		});
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	function t(key, ...params) {
+		const locale = registry.selectedId.value;
+		if (!locale) return key;
+		const message = messages[locale]?.[key];
+		const template = typeof message === "string" ? resolve(locale, message) : key;
+		return adapter.t(template, ...params);
+	}
+	function n(value, ...params) {
+		return adapter.n(value, registry.selectedId.value, ...params);
+	}
+	function resolve(locale, str) {
+		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, linkedKey) => {
+			const [linkedLocale, ...rest] = linkedKey.split(".");
+			const keyPath = rest.join(".");
+			const targetLocale = messages[linkedLocale] ? linkedLocale : locale;
+			const targetKey = messages[linkedLocale] ? keyPath : linkedKey;
+			const resolved = messages[targetLocale]?.[targetKey];
+			return typeof resolved === "string" ? resolve(targetLocale, resolved) : match;
+		});
+	}
+	const context = {
+		...registry,
+		t,
+		n
+	};
+	function provideLocaleContext(_context = context, app) {
+		return _provideLocaleContext(_context, app);
+	}
+	return createTrinity(useLocaleContext, provideLocaleContext, context);
+}
+/**
+* Simple hook to access the locale context.
+*
+* @returns The locale context containing translation and formatting functions.
+*/
+function useLocale() {
+	return useContext("v0:locale");
+}
+/**
+* Creates a Vue plugin for internationalization with locale management and translation support.
+* Integrates with token system for message resolution and provides app-wide locale context.
+*
+* @param options Configuration for adapter, default locale, and messages.
+* @template Z The type of the locale context.
+* @template E The type of the locale items managed by the registry.
+* @template R The type of the token context.
+* @template O The type of the token items managed by the registry.
+* @returns Vue install function for the plugin
+*/
+function createLocalePlugin(options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [, provideLocaleTokenContext, tokensContext] = createTokensContext("v0:locale:tokens", messages);
+	const [, provideLocaleContext, localeContext] = createLocale("v0:locale", {
+		adapter,
+		messages
+	});
+	return createPlugin({
+		namespace: "v0:locale",
+		provide: (app) => {
+			provideLocaleContext(localeContext, app);
+			provideLocaleTokenContext(tokensContext, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useMutationObserver/index.ts
+/**
+* Composable for observing DOM mutations
+*
+* @param target - Element ref to observe
+* @param callback - Callback fired on mutation
+* @param options - Observer options
+* @returns Observer controls
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+*/
+function useMutationObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	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
+	};
+	watch([isHydrated, target], ([hydrated, el]) => {
+		cleanup();
+		if (!hydrated || !SUPPORTS_MUTATION_OBSERVER || !el) return;
+		observer.value = new MutationObserver((mutations) => {
+			const transformedEntries = mutations.map((mutation) => ({
+				type: mutation.type,
+				target: mutation.target,
+				addedNodes: mutation.addedNodes,
+				removedNodes: mutation.removedNodes,
+				previousSibling: mutation.previousSibling,
+				nextSibling: mutation.nextSibling,
+				attributeName: mutation.attributeName,
+				attributeNamespace: mutation.attributeNamespace,
+				oldValue: mutation.oldValue
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(el, observerOptions);
+		if (options.immediate) {
+			const emptyNodeList = {
+				length: 0,
+				item: () => null,
+				forEach: () => {},
+				*[Symbol.iterator]() {}
+			};
+			callback([{
+				type: "childList",
+				target: el,
+				addedNodes: emptyNodeList,
+				removedNodes: emptyNodeList,
+				previousSibling: null,
+				nextSibling: null,
+				attributeName: null,
+				attributeNamespace: null,
+				oldValue: null
+			}]);
+		}
+	}, { immediate: true });
+	function setup() {
+		if (!isHydrated.value || !SUPPORTS_MUTATION_OBSERVER || !target.value || isPaused.value) return;
+		observer.value = new MutationObserver((mutations) => {
+			const transformedEntries = mutations.map((mutation) => ({
+				type: mutation.type,
+				target: mutation.target,
+				addedNodes: mutation.addedNodes,
+				removedNodes: mutation.removedNodes,
+				previousSibling: mutation.previousSibling,
+				nextSibling: mutation.nextSibling,
+				attributeName: mutation.attributeName,
+				attributeNamespace: mutation.attributeNamespace,
+				oldValue: mutation.oldValue
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(target.value, observerOptions);
+		if (options.immediate) {
+			const emptyNodeList = {
+				length: 0,
+				item: () => null,
+				forEach: () => {},
+				*[Symbol.iterator]() {}
+			};
+			const syntheticEntry = {
+				type: "childList",
+				target: target.value,
+				addedNodes: emptyNodeList,
+				removedNodes: emptyNodeList,
+				previousSibling: null,
+				nextSibling: null,
+				attributeName: null,
+				attributeNamespace: null,
+				oldValue: null
+			};
+			callback([syntheticEntry]);
+		}
+	}
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		cleanup();
+	}
+	onUnmounted(stop);
+	return {
+		isPaused: readonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+
+//#endregion
+//#region src/composables/usePermissions/adapters/adapter.ts
+var PermissionAdapter = class {};
+
+//#endregion
+//#region src/composables/usePermissions/adapters/v0.ts
+var Vuetify0PermissionAdapter = class extends PermissionAdapter {
+	constructor() {
+		super();
+	}
+	can(role, action, subject, context, permissions) {
+		const access = `${role}.${action}.${subject}`;
+		const ticket = permissions.get(access);
+		if (!ticket || !ticket.value) return false;
+		return isFunction(ticket.value) ? ticket.value(context) : ticket.value;
+	}
+};
+
+//#endregion
+//#region src/composables/usePermissions/index.ts
+/**
+*
+* @param namespace The namespace for the permissions context
+* @param options Configure initial permissions and adapter
+* @template Z The type of permission ticket
+* @template E The type of permission context
+* @returns A context trinity for the permissions context
+*
+* @see https://0.vuetifyjs.com/composables/plugins/create-permissions
+*/
+function createPermissions(namespace = "v0:permissions", options = {}) {
+	const { adapter = new Vuetify0PermissionAdapter(), permissions = {} } = options;
+	const [usePermissionsContext, _providePermissionsContext] = createContext(namespace);
+	const record = {};
+	for (const role in permissions) {
+		if (!record[role]) record[role] = {};
+		for (const [actions, subjects, condition = true] of permissions[role]) for (const action of toArray(actions)) for (const subject of toArray(subjects)) {
+			if (!record[role][action]) record[role][action] = {};
+			record[role][action][subject] = condition;
+		}
+	}
+	const tokens = useTokens(record);
+	function can(id, action, subject, context$1 = {}) {
+		return adapter.can(id, action, subject, context$1, tokens);
+	}
+	const context = {
+		...tokens,
+		can
+	};
+	function providePermissionsContext(_context = context, app) {
+		return _providePermissionsContext(_context, app);
+	}
+	return createTrinity(usePermissionsContext, providePermissionsContext, context);
+}
+/**
+* Simple hook to access the permissions context
+*
+* @returns The permissions context
+* @template Z The type of permission ticket
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*/
+function usePermissions() {
+	return useContext("v0:permissions");
+}
+/**
+* Factory function to create a permissions plugin
+*
+* @param options Configuration options for the permissions plugin
+* @template Z The type of permission ticket
+* @template E The type of permission context
+* @returns A Vue plugin object for permissions management
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*/
+function createPermissionsPlugin(options = {}) {
+	const [, providePermissionContext, context] = createPermissions("v0:permissions", options);
+	return createPlugin({
+		namespace: "v0:permissions",
+		provide: (app) => {
+			providePermissionContext(context, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* Creates a proxy model for two-way binding with a selection context.
+*
+* @param registry SelectionContext | GroupContext | SingleContext | StepContext
+* @template Z The type of items managed by the selection.
+* @template E The type of the selection context.
+* @returns The proxy model for two-way binding with the selection context.
+*/
+function useProxyModel(registry, initial, options, _transformIn, _transformOut) {
+	const logger = useLogger();
+	const internal = (options?.deep ? ref : shallowRef)(initial ? toArray(initial) : []);
+	const isModelArray = isArray(initial);
+	function transformIn(val) {
+		if (isFunction(_transformIn)) return _transformIn(val);
+		return toArray(val);
+	}
+	function transformOut(val) {
+		if (isFunction(_transformOut)) return _transformOut(val);
+		return isModelArray ? val : val[0];
+	}
+	const model = computed({
+		get() {
+			return transformOut(internal.value);
+		},
+		set(val) {
+			internal.value = transformIn(val);
+		}
+	});
+	const watcher = watch(registry.selectedIds, (val, oldVal) => {
+		if (toRaw(val).symmetricDifference(toRaw(oldVal)).size === 0) return;
+		if (val.size === 0) {
+			model.value = [];
+			return;
+		}
+		model.value = Array.from(registry.selectedValues.value);
+	});
+	watch(model, (val) => {
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of toArray(val)) {
+			const ids = registry.browse(value);
+			if (isArray(ids)) for (const single of ids) targetIds.add(single);
+			else if (ids) targetIds.add(ids);
+			else logger.warn("Unable to find id for value", value);
+		}
+		watcher.pause();
+		if (isModelArray) {
+			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;
+			registry.selectedIds.delete(last);
+			registry.selectedIds.add(next);
+		}
+		watcher.resume();
+	});
+	return model;
+}
+
+//#endregion
+//#region src/composables/useResizeObserver/index.ts
+/**
+* Composable for observing element resize events
+*
+* @param target - Element ref to observe
+* @param callback - Callback fired on resize
+* @param options - Observer options
+* @returns Observer controls
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+*/
+function useResizeObserver(target, callback, options = {}) {
+	const { isHydrated } = useHydration();
+	const observer = shallowRef();
+	const isPaused = shallowRef(false);
+	watch([isHydrated, target], ([hydrated, el]) => {
+		cleanup();
+		if (!hydrated || !SUPPORTS_OBSERVER || !el) return;
+		observer.value = new ResizeObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				contentRect: {
+					width: entry.contentRect.width,
+					height: entry.contentRect.height,
+					top: entry.contentRect.top,
+					left: entry.contentRect.left
+				},
+				target: entry.target
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(el, { box: options.box || "content-box" });
+		if (options.immediate) {
+			const rect = el.getBoundingClientRect();
+			callback([{
+				contentRect: {
+					width: rect.width,
+					height: rect.height,
+					top: rect.top,
+					left: rect.left
+				},
+				target: el
+			}]);
+		}
+	});
+	function setup() {
+		if (!isHydrated.value || !SUPPORTS_OBSERVER || !target.value || isPaused.value) return;
+		observer.value = new ResizeObserver((entries) => {
+			const transformedEntries = entries.map((entry) => ({
+				contentRect: {
+					width: entry.contentRect.width,
+					height: entry.contentRect.height,
+					top: entry.contentRect.top,
+					left: entry.contentRect.left
+				},
+				target: entry.target
+			}));
+			callback(transformedEntries);
+		});
+		observer.value.observe(target.value, { box: options.box || "content-box" });
+		if (options.immediate) {
+			const rect = target.value.getBoundingClientRect();
+			callback([{
+				contentRect: {
+					width: rect.width,
+					height: rect.height,
+					top: rect.top,
+					left: rect.left
+				},
+				target: target.value
+			}]);
+		}
+	}
+	function cleanup() {
+		if (observer.value) {
+			observer.value.disconnect();
+			observer.value = void 0;
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+		observer.value?.disconnect();
+	}
+	function resume() {
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		cleanup();
+	}
+	onUnmounted(stop);
+	return {
+		isPaused: readonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+/**
+* Convenience composable for tracking element dimensions
+*
+* @param target - Element ref to observe
+* @returns Reactive width and height
+*/
+function useElementSize(target) {
+	const width = shallowRef(0);
+	const height = shallowRef(0);
+	useResizeObserver(target, (entries) => {
+		const entry = entries[0];
+		if (entry) {
+			width.value = entry.contentRect.width;
+			height.value = entry.contentRect.height;
+		}
+	}, { immediate: true });
+	return {
+		width,
+		height
+	};
+}
+
+//#endregion
+//#region src/composables/useStep/index.ts
+/**
+* Creates a step selection context for managing collections where users can navigate through items sequentially.
+* This function extends the single selection functionality with stepping navigation.
+*
+* @param options Optional configuration for step behavior.
+* @template Z The type of items managed by the step selection.
+* @template E The type of the step selection context.
+* @returns The step selection context object.
+*/
+function useStep(options) {
+	const registry = useSingle(options);
+	function first() {
+		if (registry.size === 0) return;
+		registry.selectedIds.clear();
+		registry.select(registry.lookup(0));
+	}
+	function last() {
+		const size = registry.size;
+		if (size === 0) return;
+		registry.selectedIds.clear();
+		registry.select(registry.lookup(size - 1));
+	}
+	function next() {
+		step(1);
+	}
+	function prev() {
+		step(-1);
+	}
+	function wrapped(length, index) {
+		return (index + length) % length;
+	}
+	function step(count = 1) {
+		const length = registry.size;
+		if (!length) return;
+		const direction = Math.sign(count || 1);
+		let hops = 0;
+		let index = wrapped(length, registry.selectedIndex.value + count);
+		let id = registry.lookup(index);
+		while (id !== void 0 && registry.get(id)?.disabled && hops < length) {
+			index = wrapped(length, index + direction);
+			id = registry.lookup(index);
+			hops++;
+		}
+		if (id === void 0 || hops === length) return;
+		registry.selectedIds.clear();
+		registry.select(id);
+	}
+	return {
+		...registry,
+		first,
+		last,
+		next,
+		prev,
+		step
+	};
+}
+/**
+* Creates a step selection registry context with full injection/provision control.
+* Returns the complete trinity for advanced usage scenarios.
+*
+* @param namespace The namespace for the step selection registry context
+* @param options Optional configuration for step selection behavior.
+* @template Z The structure of the registry step selection items.
+* @template E The available methods for the step's context.
+* @returns A tuple containing the inject function, provide function, and the step selection context.
+*/
+function createStepContext(namespace, options) {
+	const [useStepContext, _provideStepContext] = createContext(namespace);
+	const context = useStep(options);
+	function provideStepContext(_context = context, app) {
+		return _provideStepContext(_context, app);
+	}
+	return createTrinity(useStepContext, provideStepContext, context);
+}
+
+//#endregion
+//#region src/composables/useStorage/adapters/memory.ts
+/**
+* In-memory storage adapter that implements the StorageAdapter interface.
+* This adapter provides temporary storage that persists only for the current
+* session and is useful for testing or when persistent storage is not available.
+*/
+var MemoryAdapter = class {
+	store = /* @__PURE__ */ new Map();
+	get length() {
+		return this.store.size;
+	}
+	getItem(key) {
+		return this.store.get(key) ?? null;
+	}
+	setItem(key, value) {
+		this.store.set(key, value);
+	}
+	removeItem(key) {
+		this.store.delete(key);
+	}
+	key(index) {
+		return String(Array.from(this.store.keys())[index] ?? "");
+	}
+};
+
+//#endregion
+//#region src/composables/useStorage/index.ts
+const [useStorageContext, provideStorageContext] = createContext("v0:storage");
+/**
+* Creates a reactive storage system with automatic persistence and cross-adapter support.
+* This function provides a consistent interface for storing and retrieving reactive values
+* that automatically sync with the underlying storage adapter (localStorage, memory, etc.).
+*
+* @param options Optional configuration for storage adapter, prefix, and serialization.
+* @template E The type of the storage context.
+* @returns A storage context object with get, set, remove, and clear methods.
+*/
+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();
+	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);
+		watch(valueRef, (newValue) => {
+			if (newValue === void 0 || newValue === null) adapter?.removeItem(prefixedKey);
+			else adapter?.setItem(prefixedKey, serializer.write(newValue));
+		}, { deep: true });
+		cache.set(prefixedKey, valueRef);
+		return valueRef;
+	}
+	function set(key, value) {
+		const valueRef = get(key);
+		valueRef.value = value;
+	}
+	function remove(key) {
+		const prefixedKey = `${prefix}${key}`;
+		adapter?.removeItem(prefixedKey);
+		cache.delete(prefixedKey);
+	}
+	function clear() {
+		for (const key of cache.keys()) adapter?.removeItem(key);
+		cache.clear();
+	}
+	return {
+		get,
+		set,
+		remove,
+		clear
+	};
+}
+/**
+* Simple hook to access the storage context.
+*
+* @returns The storage context containing reactive storage methods.
+*/
+function useStorage() {
+	return useStorageContext();
+}
+/**
+* Creates a Vue plugin for reactive storage capabilities with automatic persistence.
+* Provides app-wide access to reactive storage that syncs with the configured adapter.
+*
+* @param options Optional configuration for the storage system.
+* @returns A Vue plugin object with install method.
+*/
+function createStoragePlugin(options = {}) {
+	const context = createStorage(options);
+	return createPlugin({
+		namespace: "v0:storage",
+		provide: (app) => {
+			provideStorageContext(context, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useTimeline/index.ts
+/**
+* Creates a registry with timeline capabilities (undo/redo)
+*
+* @param _options Optional configuration for timeline
+* @template Z The type of ticket to be stored in the timeline
+* @template E The type of the timeline context
+* @returns The timeline context object
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-timeline
+*/
+function useTimeline(_options = {}) {
+	const { size = 10,...options } = _options;
+	const registry = useRegistry(options);
+	const undoTimeline = [];
+	const redoTimeline = [];
+	function register(item) {
+		if (registry.size < size) return registry.register({ ...item });
+		const id = registry.lookup(0);
+		const removing = registry.get(id);
+		if (redoTimeline.length === size) redoTimeline.shift();
+		redoTimeline.push(removing);
+		registry.unregister(id);
+		const ticket = registry.register({ ...item });
+		registry.reindex();
+		return ticket;
+	}
+	function redo() {
+		if (undoTimeline.length === 0) return;
+		registry.register(undoTimeline.pop());
+		registry.reindex();
+	}
+	function undo() {
+		const id = registry.lookup(registry.size - 1);
+		if (!id) return;
+		undoTimeline.push(registry.get(id));
+		registry.unregister(id);
+		restore();
+	}
+	function restore() {
+		const value = redoTimeline.pop();
+		const restored = value ? [value, ...registry.values()] : [...registry.values()];
+		registry.clear();
+		registry.onboard(restored);
+		registry.reindex();
+	}
+	return {
+		...registry,
+		register,
+		undo,
+		redo
+	};
+}
+
+//#endregion
+export { createFeatures, createFeaturesPlugin, createGroupContext, createLocale, createLocalePlugin, createPermissions, createPermissionsPlugin, createStepContext, createStorage, createStoragePlugin, provideStorageContext, useDocumentEventListener, useElementIntersection, useElementSize, useEventListener, useFeatures, useFilter, useForm, useGroup, useIntersectionObserver, useKeydown, useLocale, useMutationObserver, usePermissions, useProxyModel, useResizeObserver, useStep, useStorage, useStorageContext, useTimeline, useWindowEventListener };