@vuetify/v0 0.1.4 → 0.1.6

package/dist/{useClickOutside-p8HP07At.mjs → useClickOutside-Bm_3mbcT.mjs}

@@ -1,15 +1,15 @@
-import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-B_GVfG06.mjs";
-import { a as isElement, c as isNull, g as mergeDeep, h as isUndefined, l as isNullOrUndefined, o as isFunction, p as isString, t as clamp, u as isNumber, v as useId$1, y as instanceExists } from "./utilities-BqS1sC1W.mjs";
-import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-EeHQSsb6.mjs";
-import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
-import { i as createRegistry } from "./createTokens-BlhLdHXE.mjs";
-import { t as createSelection } from "./createSelection-uqEbFgha.mjs";
-import { t as createSingle } from "./createSingle-B59ya3aa.mjs";
-import { t as createGroup } from "./createGroup-CPhp6FUh.mjs";
-import { t as toArray } from "./toArray-DIeXVX1C.mjs";
-import { a as useLocale } from "./useLocale-DlbShzF-.mjs";
+import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-D6FBsWDI.mjs";
+import { a as isElement, c as isNull, d as isObject, g as mergeDeep, h as isUndefined, l as isNullOrUndefined, o as isFunction, p as isString, t as clamp, u as isNumber, v as useId$1, y as instanceExists } from "./utilities-CcJtp9Gx.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-Cii8-B2r.mjs";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-C8G5jgNk.mjs";
+import { i as createRegistry } from "./createTokens-Cu1efg9Z.mjs";
+import { i as createModel, t as createSelection } from "./createSelection-Zo4RQpYe.mjs";
+import { t as createSingle } from "./createSingle-BH9wNDrS.mjs";
+import { t as createGroup } from "./createGroup-CCb7Zfyw.mjs";
+import { t as toArray } from "./toArray-BBZH-G2X.mjs";
+import { a as useLocale } from "./useLocale-DJJmg-wv.mjs";
 import { t as MemoryAdapter } from "./memory-BsZGbGnG.mjs";
-import { computed, effectScope, isRef, nextTick, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toValue, unref, watch, watchEffect } from "vue";
+import { computed, effectScope, isRef, nextTick, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 
 //#region src/composables/createBreadcrumbs/index.ts
 /**
@@ -245,6 +245,41 @@ const [createHydrationContext, createHydrationPlugin, useHydration] = createPlug
 	}
 });
 
+//#endregion
+//#region src/composables/toElement/index.ts
+/**
+* Resolves a {@link MaybeElementRef} to a DOM Element or undefined.
+*
+* Handles:
+* - `Ref<Element>`, `ShallowRef<HTMLElement>`, getter functions
+* - Vue component instances (extracts `$el`)
+* - Raw DOM elements (pass-through)
+* - null/undefined (returns undefined)
+*
+* @param target The element ref, getter, or raw value to resolve
+* @returns The resolved DOM Element, or undefined if not available
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-element
+*
+* @example
+* ```ts
+* import { toElement } from '@vuetify/v0'
+*
+* const el = shallowRef<HTMLElement | null>(null)
+* toElement(el) // HTMLElement | undefined
+*
+* const component = ref<ComponentPublicInstance>()
+* toElement(component) // Element | undefined (from $el)
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function toElement(target) {
+	const raw = typeof target === "function" ? target() : target && typeof target === "object" && "value" in target ? target.value : target;
+	if (!raw) return void 0;
+	if (raw instanceof Element) return raw;
+	if ("$el" in raw) return raw.$el;
+}
+
 //#endregion
 //#region src/composables/createObserver/index.ts
 /**
@@ -262,7 +297,7 @@ const [createHydrationContext, createHydrationPlugin, useHydration] = createPlug
 */
 function createObserver(target, userCallback, config) {
 	const { isHydrated } = useHydration();
-	const targetRef = toRef(target);
+	const resolved = toRef(() => /* @__PURE__ */ toElement(target));
 	const observer = shallowRef(void 0);
 	const isPaused = shallowRef(false);
 	const isActive = toRef(() => !!observer.value);
@@ -275,11 +310,12 @@ function createObserver(target, userCallback, config) {
 	}
 	function setup() {
 		if (/* @__PURE__ */ isNull(observer.value)) return;
-		if (!isHydrated.value || !config.supports || !/* @__PURE__ */ isElement(targetRef.value) || isPaused.value) return;
+		const el = resolved.value;
+		if (!isHydrated.value || !config.supports || !/* @__PURE__ */ isElement(el) || isPaused.value) return;
 		observer.value = config.create(invoke);
-		config.observe(observer.value, targetRef.value);
+		config.observe(observer.value, el);
 		if (config.immediate) {
-			const entries = config.immediate(targetRef.value);
+			const entries = config.immediate(el);
 			if (config.onceIncludesImmediate) invoke(entries);
 			else {
 				config.onEntry?.(entries);
@@ -287,13 +323,13 @@ function createObserver(target, userCallback, config) {
 			}
 		}
 	}
-	watch(() => targetRef.value, (el, oldEl) => {
+	watch(resolved, (el, oldEl) => {
 		if (oldEl || observer.value) cleanup();
 		if (isHydrated.value && /* @__PURE__ */ isElement(el)) setup();
 	}, { immediate: true });
 	let stopHydrationWatch;
 	if (!isHydrated.value) stopHydrationWatch = watch(() => isHydrated.value, (hydrated) => {
-		if (hydrated && /* @__PURE__ */ isElement(targetRef.value) && !observer.value) {
+		if (hydrated && /* @__PURE__ */ isElement(resolved.value) && !observer.value) {
 			setup();
 			stopHydrationWatch?.();
 			stopHydrationWatch = void 0;
@@ -667,23 +703,22 @@ function useOverflow(namespace = "v0:overflow") {
 * @module useProxyModel
 *
 * @remarks
-* Proxy composable for bidirectional sync between selection registry and v-model.
+* Proxy composable for bidirectional sync between a model context and v-model.
 *
 * Key features:
 * - Bidirectional synchronization
 * - Array and single-value modes
 * - Automatic cleanup on scope disposal
-* - Perfect for form controls with selection backing
+* - Works with any ModelContext (Selection, Slider, etc.)
 *
-* Bridges the gap between selection composables and Vue's v-model.
+* Bridges the gap between model composables and Vue's v-model.
 */
 /**
-* Syncs a ref with a selection registry bidirectionally.
+* Syncs a ref with a model context bidirectionally.
 *
-* @param registry The selection registry to bind to.
+* @param context The model context to bind to.
 * @param model The ref to sync.
 * @param options The options for the proxy model.
-* @template Z The type of the selection ticket.
 * @returns A function to stop the sync.
 *
 * @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
@@ -702,8 +737,8 @@ function useOverflow(namespace = "v0:overflow") {
 * const stop = useProxyModel(registry, model)
 * ```
 */
-function useProxyModel(registry, model, options) {
-	const multiple = options?.multiple ?? false;
+function useProxyModel(context, model, options) {
+	const multiple = options?.multiple ?? context.multiple ?? false;
 	const _transformIn = options?.transformIn;
 	const _transformOut = options?.transformOut;
 	function transformIn(val) {
@@ -714,39 +749,20 @@ function useProxyModel(registry, model, options) {
 		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
 		return toValue(multiple) ? val : val[0];
 	}
+	const applyOptions = toValue(multiple) === toValue(context.multiple ?? false) ? void 0 : { multiple: toValue(multiple) };
 	const modelAsArray = transformIn(model);
 	const pending = new Set(modelAsArray);
-	for (const value of modelAsArray) {
-		const ids = registry.browse(value);
-		/* v8 ignore start -- edge case: value exists in registry at init */
-		if (ids) {
-			for (const id of ids) registry.select(id);
-			pending.delete(value);
-		}
-	}
-	const registryWatch = watch(registry.selectedValues, (val) => {
+	context.apply(modelAsArray, applyOptions);
+	for (const value of modelAsArray) if (Array.from(context.selectedValues.value).includes(value)) pending.delete(value);
+	const contextWatch = watch(context.selectedValues, (val) => {
 		modelWatch.pause();
 		model.value = transformOut(Array.from(toValue(val)));
 		modelWatch.resume();
 	}, { flush: "sync" });
 	const modelWatch = watch(model, (val) => {
-		registryWatch.pause();
-		const currentIds = new Set(toValue(registry.selectedIds));
-		const targetIds = /* @__PURE__ */ new Set();
-		for (const value of transformIn(val)) {
-			const ids = registry.browse(toRaw(value));
-			if (ids) for (const id of ids) targetIds.add(id);
-		}
-		if (toValue(multiple)) {
-			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
-			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
-		} else {
-			const next = targetIds.values().next().value;
-			const last = currentIds.values().next().value;
-			if (!/* @__PURE__ */ isUndefined(last)) registry.unselect(last);
-			if (!/* @__PURE__ */ isUndefined(next)) registry.select(next);
-		}
-		registryWatch.resume();
+		contextWatch.pause();
+		context.apply(transformIn(val), applyOptions);
+		contextWatch.resume();
 	}, {
 		flush: "sync",
 		deep: toValue(multiple)
@@ -754,18 +770,18 @@ function useProxyModel(registry, model, options) {
 	function onRegister(data) {
 		const ticket = data;
 		if (!pending.has(ticket.value) || toValue(ticket.disabled)) return;
-		registryWatch.pause();
+		contextWatch.pause();
 		modelWatch.pause();
-		registry.select(ticket.id);
+		context.select?.(ticket.id);
 		pending.delete(ticket.value);
 		modelWatch.resume();
-		registryWatch.resume();
+		contextWatch.resume();
 	}
-	registry.on("register:ticket", onRegister);
+	context.on?.("register:ticket", onRegister);
 	function stop() {
-		registryWatch();
+		contextWatch();
 		modelWatch();
-		registry.off("register:ticket", onRegister);
+		context.off?.("register:ticket", onRegister);
 	}
 	onScopeDispose(stop, true);
 	return stop;
@@ -972,30 +988,42 @@ function createDefaultBreakpoints() {
 * ```
 */
 function createBreakpoints(_options = {}) {
-	const { mobileBreakpoint, breakpoints } = /* @__PURE__ */ mergeDeep(createDefaultBreakpoints(), _options);
+	const { ssr, ...options } = _options;
+	const { mobileBreakpoint, breakpoints } = /* @__PURE__ */ mergeDeep(createDefaultBreakpoints(), options);
 	const sorted = Object.entries(breakpoints).toSorted((a, b) => a[1] - b[1]);
 	const names = sorted.map(([n]) => n);
 	const mb = /* @__PURE__ */ isNumber(mobileBreakpoint) ? mobileBreakpoint : breakpoints[mobileBreakpoint] ?? breakpoints.md;
-	const name = shallowRef("xs");
-	const width = shallowRef(0);
-	const height = shallowRef(0);
-	const isMobile = shallowRef(true);
-	const xs = shallowRef(true);
-	const sm = shallowRef(false);
-	const md = shallowRef(false);
-	const lg = shallowRef(false);
-	const xl = shallowRef(false);
-	const xxl = shallowRef(false);
-	const smAndUp = shallowRef(false);
-	const mdAndUp = shallowRef(false);
-	const lgAndUp = shallowRef(false);
-	const xlAndUp = shallowRef(false);
-	const xxlAndUp = shallowRef(false);
-	const smAndDown = shallowRef(true);
-	const mdAndDown = shallowRef(true);
-	const lgAndDown = shallowRef(true);
-	const xlAndDown = shallowRef(true);
-	const xxlAndDown = shallowRef(true);
+	const isSSR = !IN_BROWSER && !!ssr;
+	const initialWidth = isSSR ? ssr.clientWidth : 0;
+	const initialHeight = isSSR ? ssr.clientHeight ?? 0 : 0;
+	let initialName = "xs";
+	if (isSSR) {
+		for (let i = sorted.length - 1; i >= 0; i--) if (initialWidth >= sorted[i][1]) {
+			initialName = sorted[i][0];
+			break;
+		}
+	}
+	const initialIndex = names.indexOf(initialName);
+	const name = shallowRef(initialName);
+	const width = shallowRef(initialWidth);
+	const height = shallowRef(initialHeight);
+	const isMobile = shallowRef(isSSR ? initialWidth < mb : true);
+	const xs = shallowRef(initialIndex === 0);
+	const sm = shallowRef(initialIndex === 1);
+	const md = shallowRef(initialIndex === 2);
+	const lg = shallowRef(initialIndex === 3);
+	const xl = shallowRef(initialIndex === 4);
+	const xxl = shallowRef(initialIndex === 5);
+	const smAndUp = shallowRef(initialIndex >= 1);
+	const mdAndUp = shallowRef(initialIndex >= 2);
+	const lgAndUp = shallowRef(initialIndex >= 3);
+	const xlAndUp = shallowRef(initialIndex >= 4);
+	const xxlAndUp = shallowRef(initialIndex >= 5);
+	const smAndDown = shallowRef(initialIndex <= 1);
+	const mdAndDown = shallowRef(initialIndex <= 2);
+	const lgAndDown = shallowRef(initialIndex <= 3);
+	const xlAndDown = shallowRef(initialIndex <= 4);
+	const xxlAndDown = shallowRef(initialIndex <= 5);
 	function update() {
 		if (!IN_BROWSER) return;
 		width.value = window.innerWidth;
@@ -1047,10 +1075,12 @@ function createBreakpoints(_options = {}) {
 		lgAndDown: readonly(lgAndDown),
 		xlAndDown: readonly(xlAndDown),
 		xxlAndDown: readonly(xxlAndDown),
+		ssr: isSSR,
 		update
 	};
 }
-function createBreakpointsFallback() {
+function createBreakpointsFallback(options = {}) {
+	if (options.ssr) return createBreakpoints(options);
 	return {
 		breakpoints: createDefaultBreakpoints().breakpoints,
 		name: readonly(shallowRef("xs")),
@@ -1073,12 +1103,14 @@ function createBreakpointsFallback() {
 		lgAndDown: readonly(shallowRef(false)),
 		xlAndDown: readonly(shallowRef(false)),
 		xxlAndDown: readonly(shallowRef(false)),
+		ssr: false,
 		update: () => {}
 	};
 }
 const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = createPluginContext("v0:breakpoints", (options) => createBreakpoints(options), {
 	fallback: () => createBreakpointsFallback(),
 	setup: (context, app, _options) => {
+		if (IN_BROWSER) context.update();
 		app.mixin({ mounted() {
 			if (!/* @__PURE__ */ isNull(this.$parent)) return;
 			const hydration = useHydration();
@@ -1555,6 +1587,9 @@ const keyAliasMap = {
 	space: " ",
 	return: "enter",
 	del: "delete",
+	plus: "+",
+	slash: "/",
+	underscore: "_",
 	minus: "-",
 	hyphen: "-"
 };
@@ -1600,7 +1635,7 @@ function splitKeyCombination(combination, isInternal = false) {
 		"++",
 		"//",
 		"__"
-	].some((v) => combination.startsWith(v)) || combination.includes("++") || combination.includes("__") || combination === "+" || combination === "_" || combination.length > 1 && (combination.endsWith("+") || combination.endsWith("_")) && combination.at(-2) !== combination.at(-1) || combination === "++" || combination === "--" || combination === "__") {
+	].some((v) => combination.startsWith(v)) || combination.includes("++") || combination.includes("//") || combination.includes("__") || combination === "+" || combination === "/" || combination === "_" || combination.length > 1 && (combination.endsWith("+") || combination.endsWith("/") || combination.endsWith("_")) && combination.at(-2) !== combination.at(-1) || combination === "++" || combination === "--" || combination === "__") {
 		if (!isInternal) logger.warn(`Invalid hotkey combination: "${combination}" has invalid structure`);
 		return emptyResult;
 	}
@@ -1666,7 +1701,11 @@ function splitKeySequence(str) {
 		logger.warn("Invalid hotkey sequence: empty string provided");
 		return [];
 	}
-	const hasInvalidStart = str.startsWith("-") && !["---", "--+"].includes(str);
+	const hasInvalidStart = str.startsWith("-") && ![
+		"-",
+		"---",
+		"--+"
+	].includes(str);
 	const hasInvalidEnd = str.endsWith("-") && !str.endsWith("+-") && !str.endsWith("_-") && str !== "-" && str !== "---";
 	if (hasInvalidStart || hasInvalidEnd) {
 		logger.warn(`Invalid hotkey sequence: "${str}" contains invalid combinations`);
@@ -2892,10 +2931,15 @@ function createNested(_options = {}) {
 		openedIds.clear();
 		activeIds.clear();
 		rootIds.clear();
-		group.reset();
+		group.clear();
 	}
 	function reset() {
-		clear();
+		children.clear();
+		parents.clear();
+		openedIds.clear();
+		activeIds.clear();
+		rootIds.clear();
+		group.reset();
 	}
 	const context = {
 		...group,
@@ -3180,6 +3224,191 @@ function useQueue(namespace = "v0:queue") {
 	return useContext(namespace);
 }
 
+//#endregion
+//#region src/composables/createSlider/index.ts
+/**
+* @module createSlider
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-slider
+*
+* @remarks
+* Composable for managing slider state: value math, step snapping,
+* percentage conversion, and multi-thumb value operations.
+*
+* Extends createModel for useProxyModel compatibility:
+* - createRegistry → createModel → createSlider (ticket-per-thumb)
+*
+* Each thumb is a model ticket with a `shallowRef<number>` value.
+* Values are derived from ordered tickets, not a standalone ref.
+*
+* Designed for single-thumb, range, and multi-thumb sliders.
+* Also reusable for color picker tracks, media scrubbers,
+* gradient editors, and other 1D value-on-track controls.
+*/
+/**
+* Creates slider state with value math, step snapping, and multi-thumb support.
+*
+* Extends createModel for useProxyModel compatibility. Each thumb is a model
+* ticket with a shallowRef<number> value. Values are derived from the ordered
+* tickets, enabling proper registration/unregistration lifecycle.
+*
+* @param options Slider configuration.
+* @returns Slider context with values, math functions, and thumb operations.
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-slider
+* @see {@link createModel} for the base model composable.
+*
+* @example Single thumb
+* ```ts
+* import { createSlider } from '@vuetify/v0'
+*
+* const slider = createSlider({ min: 0, max: 100, step: 5 })
+* const ticket = slider.register({ value: 50 })
+* slider.up(0)           // values: [55]
+* slider.fromValue(50)   // 50
+* ```
+*
+* @example Range slider
+* ```ts
+* import { createSlider } from '@vuetify/v0'
+*
+* const slider = createSlider({ min: 0, max: 100, step: 1, range: true })
+* slider.register({ value: 25 })
+* slider.register({ value: 75 })
+* slider.set(0, 30)      // values: [30, 75]
+* slider.set(1, 60)      // values: [30, 60]
+* ```
+*
+* @example Custom pointer interaction (media scrubber)
+* ```ts
+* import { createSlider } from '@vuetify/v0'
+*
+* const slider = createSlider({ min: 0, max: 217, step: 0.1 })
+* slider.register({ value: 0 })
+*
+* // pointer → fromPercent → set → fromValue → UI
+* const percent = (clientX - rect.left) / rect.width * 100
+* slider.set(0, slider.fromPercent(percent))
+* const position = slider.fromValue(slider.values.value[0])
+* ```
+*/
+function createSlider(options = {}) {
+	const { min = 0, max = 100, step = 1, disabled: disabledProp = false, readonly: readonlyProp = false, orientation: orientationProp = "horizontal", inverted: invertedProp = false, minStepsBetweenThumbs = 0, crossover = false, range = false } = options;
+	const model = createModel({
+		disabled: disabledProp,
+		multiple: true,
+		events: true
+	});
+	const disabled = toRef(() => toValue(disabledProp));
+	const readonly$1 = toRef(() => toValue(readonlyProp));
+	const orientation = toRef(() => toValue(orientationProp));
+	const inverted = toRef(() => toValue(invertedProp));
+	const extent = max - min;
+	let pending = null;
+	const thumbs = computed(() => Array.from(model.selectedItems.value).toSorted((a, b) => a.index - b.index));
+	const values = computed(() => thumbs.value.map((t) => toValue(t.value)));
+	const selectedValues = computed(() => values.value);
+	function snap(value) {
+		if (step <= 0) return /* @__PURE__ */ clamp(value, min, max);
+		const clamped = /* @__PURE__ */ clamp(value, min, max);
+		return /* @__PURE__ */ clamp(min + Math.round((clamped - min) / step) * step, min, max);
+	}
+	function fromValue(value) {
+		if (extent === 0) return 0;
+		const p = (value - min) / extent * 100;
+		return inverted.value ? 100 - p : p;
+	}
+	function fromPercent(p) {
+		return snap(min + (inverted.value ? 100 - p : p) / 100 * extent);
+	}
+	function register(input) {
+		const initialValue = /* @__PURE__ */ isObject(input) ? input.value : input;
+		const thumbIndex = thumbs.value.length;
+		const pendingValue = pending?.[thumbIndex];
+		const val = /* @__PURE__ */ isUndefined(pendingValue) ? snap(initialValue ?? min) : snap(pendingValue);
+		const ticket = model.register({ value: shallowRef(val) });
+		if (!model.selectedIds.has(ticket.id)) model.selectedIds.add(ticket.id);
+		if (pending && thumbs.value.length >= pending.length) pending = null;
+		return ticket;
+	}
+	function apply(incoming, _options) {
+		const snapped = incoming.map((v) => snap(Number(v)));
+		if (thumbs.value.length === 0) {
+			pending = snapped;
+			return;
+		}
+		for (let index = 0; index < snapped.length; index++) {
+			const ticket = thumbs.value[index];
+			if (!ticket || !isRef(ticket.value)) continue;
+			let constrained = snapped[index];
+			if (!crossover) {
+				const gap = minStepsBetweenThumbs * step;
+				const prev = index > 0 ? snapped[index - 1] : void 0;
+				const following = index < snapped.length - 1 ? snapped[index + 1] : void 0;
+				if (!/* @__PURE__ */ isUndefined(prev)) constrained = Math.max(constrained, prev + gap);
+				if (!/* @__PURE__ */ isUndefined(following)) constrained = Math.min(constrained, following - gap);
+			}
+			ticket.value.value = /* @__PURE__ */ clamp(constrained, min, max);
+		}
+	}
+	function set(index, value) {
+		if (readonly$1.value) return;
+		const snapped = snap(value);
+		const current = values.value;
+		let constrained = snapped;
+		if (!crossover) {
+			const gap = minStepsBetweenThumbs * step;
+			const prev = current[index - 1];
+			const following = current[index + 1];
+			if (index > 0 && !/* @__PURE__ */ isUndefined(prev)) constrained = Math.max(constrained, prev + gap);
+			if (index < current.length - 1 && !/* @__PURE__ */ isUndefined(following)) constrained = Math.min(constrained, following - gap);
+		}
+		constrained = /* @__PURE__ */ clamp(constrained, min, max);
+		const ticket = thumbs.value[index];
+		if (ticket && isRef(ticket.value)) ticket.value.value = constrained;
+	}
+	function up(index, multiplier = 1) {
+		set(index, (values.value[index] ?? min) + step * multiplier);
+	}
+	function down(index, multiplier = 1) {
+		set(index, (values.value[index] ?? min) - step * multiplier);
+	}
+	function floor(index) {
+		set(index, min);
+	}
+	function ceil(index) {
+		set(index, max);
+	}
+	return {
+		...model,
+		values,
+		selectedValues,
+		apply,
+		range,
+		min,
+		max,
+		step,
+		minStepsBetweenThumbs,
+		crossover,
+		disabled,
+		readonly: readonly$1,
+		orientation,
+		inverted,
+		register,
+		snap,
+		fromValue,
+		fromPercent,
+		set,
+		up,
+		down,
+		floor,
+		ceil,
+		get size() {
+			return model.size;
+		}
+	};
+}
+
 //#endregion
 //#region src/composables/useStack/index.ts
 /**
@@ -3653,31 +3882,50 @@ function createStorage(options = {}) {
 	const { adapter = IN_BROWSER ? window.localStorage : new MemoryAdapter(), prefix = "v0:", serializer = {
 		read: JSON.parse,
 		write: JSON.stringify
-	} } = options;
+	}, ttl } = options;
 	const cache = /* @__PURE__ */ new Map();
 	const watchers = /* @__PURE__ */ new Map();
 	function has(key) {
 		const prefixedKey = `${prefix}${key}`;
 		return cache.has(prefixedKey);
 	}
-	function get(key, defaultValue) {
-		const prefixedKey = `${prefix}${key}`;
-		if (cache.has(prefixedKey)) return cache.get(prefixedKey);
-		const storedValue = adapter?.getItem(prefixedKey);
-		let initialValue = defaultValue;
-		if (storedValue) try {
-			initialValue = serializer.read(storedValue);
+	function readStored(prefixedKey) {
+		const raw = adapter?.getItem(prefixedKey);
+		if (!raw) return void 0;
+		try {
+			const parsed = serializer.read(raw);
+			if (ttl && parsed && typeof parsed === "object" && "__ttl" in parsed && "__v" in parsed) {
+				if (Date.now() - parsed.__t > ttl) {
+					adapter?.removeItem(prefixedKey);
+					return;
+				}
+				return parsed.__v;
+			}
+			return parsed;
 		} catch (error) {
 			console.error(`[v0:storage] Failed to parse stored value for key "${prefixedKey}":`, error);
+			return;
+		}
+	}
+	function writeStored(prefixedKey, value) {
+		const wrapped = ttl ? {
+			__ttl: 1,
+			__v: value,
+			__t: Date.now()
+		} : value;
+		try {
+			adapter?.setItem(prefixedKey, serializer.write(wrapped));
+		} catch (error) {
+			console.error(`[v0:storage] Failed to write key "${prefixedKey}":`, error);
 		}
-		const valueRef = ref(initialValue);
+	}
+	function get(key, defaultValue) {
+		const prefixedKey = `${prefix}${key}`;
+		if (cache.has(prefixedKey)) return cache.get(prefixedKey);
+		const valueRef = ref(readStored(prefixedKey) ?? defaultValue);
 		const stop = watch(valueRef, (newValue) => {
 			if (/* @__PURE__ */ isNullOrUndefined(newValue)) adapter?.removeItem(prefixedKey);
-			else try {
-				adapter?.setItem(prefixedKey, serializer.write(newValue));
-			} catch (error) {
-				console.error(`[v0:storage] Failed to write key "${prefixedKey}":`, error);
-			}
+			else writeStored(prefixedKey, newValue);
 		}, { deep: true });
 		watchers.set(prefixedKey, stop);
 		cache.set(prefixedKey, valueRef);
@@ -3711,14 +3959,10 @@ function createStorage(options = {}) {
 		const valueRef = cache.get(e.key);
 		if (!valueRef) return;
 		watchers.get(e.key)?.();
-		valueRef.value = e.newValue == null ? void 0 : serializer.read(e.newValue);
+		valueRef.value = e.newValue == null ? void 0 : readStored(e.key);
 		const stop = watch(valueRef, (newValue) => {
 			if (/* @__PURE__ */ isNullOrUndefined(newValue)) adapter?.removeItem(e.key);
-			else try {
-				adapter?.setItem(e.key, serializer.write(newValue));
-			} catch (error) {
-				console.error(`[v0:storage] Failed to write key "${e.key}":`, error);
-			}
+			else writeStored(e.key, newValue);
 		}, { deep: true });
 		watchers.set(e.key, stop);
 	});
@@ -4677,4 +4921,4 @@ function useClickOutside(target, handler, options = {}) {
 }
 
 //#endregion
-export { createOverflow as $, singleOpenStrategy as A, createForm as B, createQueue as C, createNestedContext as D, createNested as E, usePrefersReducedMotion as F, createDatePlugin as G, useForm as H, useLazy as I, createBreakpointsContext as J, useDate as K, useElementIntersection as L, useMediaQuery as M, usePrefersContrast as N, useNested as O, usePrefersDark as P, useProxyModel as Q, useIntersectionObserver as R, useStack as S, useQueue as T, createDate as U, createFormContext as V, createDateContext as W, useBreakpoints as X, createBreakpointsPlugin as Y, toReactive as Z, createStepContext as _, createVirtual as a, createHydration as at, createStackContext as b, useToggleScope as c, useHydration as ct, useTimeline as d, useBreadcrumbs as dt, createOverflowContext as et, createStorage as f, createStep as g, useStorage as h, useWindowEventListener as i, createFallbackHydration as it, useMutationObserver as j, multipleOpenStrategy as k, createTimeline as l, createBreadcrumbs as lt, createStoragePlugin as m, useDocumentEventListener as n, useElementSize as nt, createVirtualContext as o, createHydrationContext as ot, createStorageContext as p, createBreakpoints as q, useEventListener as r, useResizeObserver as rt, useVirtual as s, createHydrationPlugin as st, useClickOutside as t, useOverflow as tt, createTimelineContext as u, createBreadcrumbsContext as ut, useStep as v, createQueueContext as w, createStackPlugin as x, createStack as y, useHotkey as z };
+export { useProxyModel as $, multipleOpenStrategy as A, useHotkey as B, createSlider as C, createNested as D, useQueue as E, usePrefersDark as F, createDateContext as G, createFormContext as H, usePrefersReducedMotion as I, createBreakpoints as J, createDatePlugin as K, useLazy as L, useMutationObserver as M, useMediaQuery as N, createNestedContext as O, usePrefersContrast as P, toReactive as Q, useElementIntersection as R, useStack as S, createQueueContext as T, useForm as U, createForm as V, createDate as W, createBreakpointsPlugin as X, createBreakpointsContext as Y, useBreakpoints as Z, createStepContext as _, createVirtual as a, toElement as at, createStackContext as b, useToggleScope as c, createHydrationContext as ct, useTimeline as d, createBreadcrumbs as dt, createOverflow as et, createStorage as f, createBreadcrumbsContext as ft, createStep as g, useStorage as h, useWindowEventListener as i, useResizeObserver as it, singleOpenStrategy as j, useNested as k, createTimeline as l, createHydrationPlugin as lt, createStoragePlugin as m, useDocumentEventListener as n, useOverflow as nt, createVirtualContext as o, createFallbackHydration as ot, createStorageContext as p, useBreadcrumbs as pt, useDate as q, useEventListener as r, useElementSize as rt, useVirtual as s, createHydration as st, useClickOutside as t, createOverflowContext as tt, createTimelineContext as u, useHydration as ut, useStep as v, createQueue as w, createStackPlugin as x, createStack as y, useIntersectionObserver as z };

package/dist/{useFeatures-C4JF3Hgr.mjs → useFeatures-BS4mit8z.mjs}

@@ -1,7 +1,7 @@
-import { d as isObject, i as isBoolean, o as isFunction, r as isArray } from "./utilities-BqS1sC1W.mjs";
-import { o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
-import { t as createTokens } from "./createTokens-BlhLdHXE.mjs";
-import { t as createGroup } from "./createGroup-CPhp6FUh.mjs";
+import { d as isObject, i as isBoolean, o as isFunction, r as isArray } from "./utilities-CcJtp9Gx.mjs";
+import { o as createPluginContext } from "./useLogger-C8G5jgNk.mjs";
+import { t as createTokens } from "./createTokens-Cu1efg9Z.mjs";
+import { t as createGroup } from "./createGroup-CCb7Zfyw.mjs";
 
 //#region src/composables/useFeatures/adapters/generic/index.ts
 var FeaturesAdapter = class {};

package/dist/{useLocale-DlbShzF-.mjs → useLocale-DJJmg-wv.mjs}

@@ -1,9 +1,9 @@
-import { p as isString } from "./utilities-BqS1sC1W.mjs";
-import { o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
-import { t as createTokens } from "./createTokens-BlhLdHXE.mjs";
-import { t as createSingle } from "./createSingle-B59ya3aa.mjs";
-import { t as toArray } from "./toArray-DIeXVX1C.mjs";
-import { t as Vuetify0LocaleAdapter } from "./v0-BtQCSBOG.mjs";
+import { p as isString } from "./utilities-CcJtp9Gx.mjs";
+import { o as createPluginContext } from "./useLogger-C8G5jgNk.mjs";
+import { t as createTokens } from "./createTokens-Cu1efg9Z.mjs";
+import { t as createSingle } from "./createSingle-BH9wNDrS.mjs";
+import { t as toArray } from "./toArray-BBZH-G2X.mjs";
+import { t as Vuetify0LocaleAdapter } from "./v0-BWBSVkew.mjs";
 
 //#region src/composables/useLocale/index.ts
 /**