ropav 0.2.0 → 0.3.0

package/dist/slider.js

@@ -1,2076 +0,0 @@
-import './slider.css';
-import { t as useControllableValue } from "./useControllableValue.js";
-import { t as useStylesApi } from "./styles-api.js";
-import { n as toPresenceAttribute } from "./attributes.js";
-import { t as bem } from "./bem.js";
-import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
-import { n as getValuePercent, t as clamp } from "./number.js";
-import { i as getComponentColorValue, r as getComponentColorRoles, t as componentColors } from "./componentColors.js";
-import { i as useFormControl } from "./useFormControl.js";
-import { o as splitCompatibilityAttributes, t as composeEventHandlers } from "./attributes2.js";
-import { n as mergeAriaIdRefs } from "./aria.js";
-import { t as useControlState } from "./useControlState.js";
-import { t as toCssLength } from "./css.js";
-import { t as createRafScheduler } from "./rafScheduler.js";
-import { t as createPointerSession } from "./pointerSession.js";
-import { t as getFloatingOffsetStyle } from "./floatingOffset.js";
-import { n as resolveTooltipColorStyleWithContrast, r as useDelayedOpen, t as tooltip_default } from "./tooltip.js";
-import { applyVShow, child, computed, createComponent, createFor, createIf, createSlot, createTemplateRefSetter, defineVaporComponent, extend, next, nextTick, on, onBeforeUnmount, onMounted, ref, renderEffect, setClass, setDynamicProps, setInsertionState, setProp, setStyle, setText, template, toDisplayString, toRef, txt, unref, useId, useSlots, watch } from "vue";
-//#region src/components/slider/sliderModel.ts
-function normalizeSliderBounds(min, max) {
-	const safeMin = Number.isFinite(min) ? min : 0;
-	const safeMax = Number.isFinite(max) ? max : safeMin;
-	return safeMax >= safeMin ? {
-		min: safeMin,
-		max: safeMax
-	} : {
-		min: safeMax,
-		max: safeMin
-	};
-}
-function normalizeSliderStep(step) {
-	return step === "any" || Number.isFinite(step) && step > 0 ? step : "any";
-}
-function normalizeSliderValue(value, min, max, step) {
-	const bounds = normalizeSliderBounds(min, max);
-	const safeStep = normalizeSliderStep(step);
-	const clamped = clamp(Number.isFinite(value) ? value : bounds.min, bounds.min, bounds.max);
-	if (safeStep === "any") return clamped;
-	const steps = Math.round((clamped - bounds.min) / safeStep);
-	const snapped = bounds.min + steps * safeStep;
-	return clamp(Number(snapped.toFixed(10)), bounds.min, bounds.max);
-}
-function setSliderStyleValue(style, property, value) {
-	if (value) style[property] = value;
-}
-function getSliderLengthValue(value) {
-	return toCssLength(value);
-}
-function getSliderBorderValue(value, borderColorProperty) {
-	if (value == null || value === "") return void 0;
-	if (typeof value === "number") return Number.isFinite(value) ? `${value}px solid var(${borderColorProperty})` : void 0;
-	return value;
-}
-function applySliderThumbStyle(style, thumb, properties) {
-	setSliderStyleValue(style, properties.size, getSliderLengthValue(thumb?.size));
-	setSliderStyleValue(style, properties.border, getSliderBorderValue(thumb?.border, properties.borderColor));
-	setSliderStyleValue(style, properties.padding, getSliderLengthValue(thumb?.padding));
-}
-function getSliderThumbOptions(thumb) {
-	return typeof thumb === "object" ? thumb : {};
-}
-function getSliderThumbMode(thumb) {
-	if (thumb === false) return false;
-	if (typeof thumb === "object") return thumb.visibility ?? "always";
-	return thumb;
-}
-function getSliderMarkStyle(percent, color, properties) {
-	const style = { [properties.position]: `${percent}%` };
-	const colorValue = getComponentColorValue(color);
-	const foreground = getComponentColorRoles(color)?.foreground;
-	for (const property of properties.decorativeColors) setSliderStyleValue(style, property, colorValue);
-	for (const property of properties.foregroundColors) setSliderStyleValue(style, property, foreground);
-	return style;
-}
-function createSliderMarkItems(marks, min, max, isFilled, properties) {
-	return (marks ?? []).flatMap((markInput, index) => {
-		const mark = typeof markInput === "number" ? { value: markInput } : markInput;
-		if (mark.hidden) return [];
-		const value = Number(mark.value);
-		if (!Number.isFinite(value)) return [];
-		const percent = getValuePercent(value, min, max);
-		return {
-			key: `${value}-${index}`,
-			value,
-			label: mark.label,
-			hasLabel: mark.label != null,
-			filled: isFilled(value, percent),
-			style: getSliderMarkStyle(percent, mark.color, properties)
-		};
-	});
-}
-function getFormattedSliderValue(value, formatter) {
-	return formatter ? formatter(value) : value;
-}
-function getSliderAriaValueText(value, ariaValueText, formatter) {
-	if (typeof ariaValueText === "function") return String(ariaValueText(value));
-	if (ariaValueText != null && ariaValueText !== "") return String(ariaValueText);
-	if (formatter) return String(formatter(value));
-}
-function getSliderTooltipOptions(tooltip) {
-	return typeof tooltip === "object" ? tooltip : {};
-}
-function getSliderTooltipMode(tooltip) {
-	if (tooltip === false) return false;
-	if (typeof tooltip === "object") {
-		if ("anchor" in tooltip && tooltip.anchor === "pointer") return "hover";
-		return tooltip.mode ?? "hover";
-	}
-	return tooltip;
-}
-function getSliderTooltipAnchor(tooltip) {
-	return typeof tooltip === "object" && tooltip.anchor === "pointer" ? "pointer" : "thumb";
-}
-//#endregion
-//#region src/components/slider/useSliderPointer.ts
-function readPointerGeometry(track, orientation) {
-	const vertical = orientation === "vertical";
-	const thumbTravelRect = track.querySelector(".rp-slider__thumb")?.getBoundingClientRect();
-	const rect = thumbTravelRect && (vertical ? thumbTravelRect.height > 0 : thumbTravelRect.width > 0) ? thumbTravelRect : track.getBoundingClientRect();
-	const length = vertical ? rect.height : rect.width;
-	if (length <= 0) return;
-	return {
-		length,
-		start: vertical ? rect.bottom : rect.left,
-		vertical
-	};
-}
-function getPointerValue(event, geometry, bounds, step) {
-	const pointerPosition = geometry.vertical ? event.clientY : event.clientX;
-	const ratio = clamp((geometry.vertical ? geometry.start - pointerPosition : pointerPosition - geometry.start) / geometry.length, 0, 1);
-	return normalizeSliderValue(bounds.min + ratio * (bounds.max - bounds.min), bounds.min, bounds.max, step);
-}
-function useSliderPointer(options) {
-	function refreshGeometry(currentSession) {
-		const geometry = readPointerGeometry(currentSession.track, options.orientation());
-		if (!geometry) return false;
-		currentSession.geometry = geometry;
-		return true;
-	}
-	function updateFromPointer(event, currentSession) {
-		options.updateValue(getPointerValue(event, currentSession.geometry, options.bounds.value, options.step.value));
-	}
-	const pointerSession = createPointerSession({
-		onStart(event, currentSession) {
-			event.preventDefault();
-			options.inputRef.value?.focus({ preventScroll: true });
-			updateFromPointer(event, currentSession);
-		},
-		onUpdate: updateFromPointer,
-		refreshGeometry
-	});
-	function onPointerDown(event) {
-		return pointerSession.start(event, () => {
-			if (options.disabled()) return;
-			const track = event.currentTarget;
-			if (!track) return;
-			const geometry = readPointerGeometry(track, options.orientation());
-			if (!geometry) return;
-			return {
-				state: {
-					geometry,
-					track
-				},
-				target: track
-			};
-		});
-	}
-	onBeforeUnmount(pointerSession.stop);
-	return { onPointerDown };
-}
-//#endregion
-//#region src/components/slider/useSliderPointerPreview.ts
-function getPreviewRect(track, vertical) {
-	const travelRect = track.querySelector(".rp-slider__travel")?.getBoundingClientRect();
-	if (travelRect && (vertical ? travelRect.height > 0 : travelRect.width > 0)) return travelRect;
-	return track.getBoundingClientRect();
-}
-function useSliderPointerPreview(options) {
-	const dragging = ref(false);
-	const previewAvailable = ref(false);
-	const previewValue = ref(options.initialValue);
-	let disposing = false;
-	let pendingPreview;
-	const previewScheduler = createRafScheduler(applyScheduledPreview, () => pendingPreview?.track.ownerDocument.defaultView);
-	function updateFromPointer(pointer, track) {
-		if (!options.enabled() || options.disabled()) return false;
-		const vertical = options.orientation() === "vertical";
-		const rect = getPreviewRect(track, vertical);
-		const length = vertical ? rect.height : rect.width;
-		if (length <= 0) return false;
-		const ratio = clamp((vertical ? rect.bottom - pointer.clientY : pointer.clientX - rect.left) / length, 0, 1);
-		const bounds = options.bounds.value;
-		const rawValue = bounds.min + ratio * (bounds.max - bounds.min);
-		previewValue.value = normalizeSliderValue(rawValue, bounds.min, bounds.max, options.step.value);
-		previewAvailable.value = true;
-		return true;
-	}
-	function applyScheduledPreview() {
-		const pending = pendingPreview;
-		pendingPreview = void 0;
-		if (pending && updateFromPointer(pending, pending.track)) options.onStateChange();
-	}
-	function schedulePreview(event, track) {
-		if (!options.enabled() || options.disabled()) return;
-		pendingPreview = {
-			clientX: event.clientX,
-			clientY: event.clientY,
-			track
-		};
-		previewScheduler.schedule();
-	}
-	function cancelScheduledPreview() {
-		previewScheduler.cancel();
-		pendingPreview = void 0;
-	}
-	const pointerSession = createPointerSession({
-		endUpdate: "event",
-		onStart(event, track) {
-			cancelScheduledPreview();
-			dragging.value = true;
-			updateFromPointer(event, track);
-		},
-		onStop() {
-			dragging.value = false;
-			if (!disposing) options.onStateChange();
-		},
-		onUpdate(event, track) {
-			if (updateFromPointer(event, track) && event.type === "pointermove") options.onStateChange();
-		}
-	});
-	function onPointerMove(event) {
-		if (dragging.value) return;
-		const track = event.currentTarget;
-		if (track) schedulePreview(event, track);
-	}
-	function onPointerDown(event) {
-		return pointerSession.start(event, () => {
-			if (options.disabled()) return;
-			const track = event.currentTarget;
-			if (!track) return;
-			return {
-				state: track,
-				target: track
-			};
-		});
-	}
-	function onTrackEnter(event) {
-		if (!options.enabled()) return;
-		cancelScheduledPreview();
-		previewAvailable.value = false;
-		const track = event.currentTarget;
-		if (track) updateFromPointer(event, track);
-	}
-	function onTrackLeave() {
-		if (!dragging.value && options.enabled()) cancelScheduledPreview();
-	}
-	onBeforeUnmount(() => {
-		disposing = true;
-		pointerSession.stop();
-		cancelScheduledPreview();
-	});
-	return {
-		dragging,
-		previewAvailable,
-		previewValue,
-		onPointerDown,
-		onPointerMove,
-		onTrackEnter,
-		onTrackLeave
-	};
-}
-//#endregion
-//#region src/components/slider/useSliderTooltipState.ts
-function useSliderTooltipState(options) {
-	const tooltipOptions = computed(() => getSliderTooltipOptions(options.tooltip()));
-	const tooltipAnchor = computed(() => getSliderTooltipAnchor(options.tooltip()));
-	const tooltipMode = computed(() => getSliderTooltipMode(options.tooltip()));
-	const tooltipOpenDelay = computed(() => tooltipOptions.value.openDelay ?? 0);
-	const delayedTooltip = useDelayedOpen({
-		openDelay: () => tooltipOpenDelay.value,
-		disabled: () => tooltipMode.value !== "hover" || options.disabled()
-	});
-	const trackHovered = ref(false);
-	const focusWithin = ref(false);
-	let dismissed = false;
-	const pointerPreview = useSliderPointerPreview({
-		enabled: () => tooltipAnchor.value === "pointer",
-		disabled: options.disabled,
-		orientation: options.orientation,
-		bounds: options.bounds,
-		step: options.step,
-		initialValue: options.value.value,
-		onStateChange: syncTooltip
-	});
-	function hasTooltipInteraction() {
-		if (tooltipAnchor.value === "pointer") return pointerPreview.previewAvailable.value && (trackHovered.value || pointerPreview.dragging.value);
-		return trackHovered.value || focusWithin.value || pointerPreview.dragging.value;
-	}
-	function syncTooltip() {
-		if (tooltipMode.value === "hover" && !options.disabled() && hasTooltipInteraction() && !dismissed) {
-			delayedTooltip.open();
-			return;
-		}
-		delayedTooltip.closeImmediate();
-	}
-	function onTooltipTrackEnter(event) {
-		if (options.disabled()) return;
-		pointerPreview.onTrackEnter(event);
-		trackHovered.value = true;
-		dismissed = false;
-		syncTooltip();
-	}
-	function onTooltipTrackLeave() {
-		trackHovered.value = false;
-		pointerPreview.onTrackLeave();
-		syncTooltip();
-	}
-	function onTooltipFocusIn() {
-		focusWithin.value = true;
-		dismissed = false;
-		syncTooltip();
-	}
-	function onTooltipFocusOut() {
-		focusWithin.value = false;
-		syncTooltip();
-	}
-	function onTooltipPointerDown(event) {
-		if (!pointerPreview.onPointerDown(event)) return;
-		dismissed = false;
-		syncTooltip();
-	}
-	function onTooltipKeydown(event) {
-		if (event.key !== "Escape") return;
-		dismissed = true;
-		delayedTooltip.closeImmediate();
-	}
-	const tooltipVisible = computed(() => tooltipMode.value !== false);
-	const tooltipAlwaysVisible = computed(() => tooltipMode.value === "always");
-	const tooltipOpen = computed(() => tooltipAlwaysVisible.value || tooltipMode.value === "hover" && delayedTooltip.isOpen.value && !options.disabled());
-	const tooltipPlacement = computed(() => tooltipOptions.value.placement ?? (options.orientation() === "vertical" ? "left" : "top"));
-	const tooltipId = computed(() => tooltipOptions.value.id);
-	const tooltipColor = computed(() => tooltipOptions.value.color);
-	const tooltipAutoContrast = computed(() => tooltipOptions.value.autoContrast);
-	const tooltipContrastColor = computed(() => tooltipOptions.value.contrastColor);
-	const tooltipOffset = computed(() => tooltipOptions.value.offset);
-	const tooltipArrow = computed(() => tooltipOptions.value.arrow ?? false);
-	const tooltipValue = computed(() => tooltipAnchor.value === "pointer" && pointerPreview.previewAvailable.value ? pointerPreview.previewValue.value : options.value.value);
-	const tooltipPercent = computed(() => getValuePercent(tooltipValue.value, options.bounds.value.min, options.bounds.value.max));
-	const tooltipFormattedValue = computed(() => getFormattedSliderValue(tooltipValue.value, options.formatValue()));
-	const tooltipContent = computed(() => String(tooltipFormattedValue.value));
-	return {
-		trackHovered,
-		dragging: pointerPreview.dragging,
-		tooltipVisible,
-		tooltipOpen,
-		tooltipAlwaysVisible,
-		tooltipAnchor,
-		tooltipPlacement,
-		tooltipId,
-		tooltipColor,
-		tooltipAutoContrast,
-		tooltipContrastColor,
-		tooltipOffset,
-		tooltipOpenDelay,
-		tooltipArrow,
-		tooltipValue,
-		tooltipPercent,
-		tooltipFormattedValue,
-		tooltipContent,
-		onTooltipPointerDown,
-		onTooltipPointerMove: pointerPreview.onPointerMove,
-		onTooltipTrackEnter,
-		onTooltipTrackLeave,
-		onTooltipFocusIn,
-		onTooltipFocusOut,
-		onTooltipKeydown
-	};
-}
-//#endregion
-//#region src/components/slider/useSliderValueState.ts
-function useSliderValueState(props, onChange) {
-	const inputRef = ref(null);
-	const controllable = useControllableValue({
-		modelValue: () => props.modelValue,
-		defaultValue: () => props.defaultValue ?? props.min,
-		onChange
-	});
-	const control = useControlState(props);
-	const bounds = computed(() => normalizeSliderBounds(props.min, props.max));
-	const nativeMin = computed(() => bounds.value.min);
-	const nativeMax = computed(() => bounds.value.max);
-	const nativeStep = computed(() => normalizeSliderStep(props.step));
-	const normalizedValue = computed(() => normalizeSliderValue(controllable.value.value, bounds.value.min, bounds.value.max, nativeStep.value));
-	const valuePercent = computed(() => getValuePercent(normalizedValue.value, bounds.value.min, bounds.value.max));
-	const formattedValue = computed(() => getFormattedSliderValue(normalizedValue.value, props.formatValue));
-	const ariaValueText = computed(() => getSliderAriaValueText(normalizedValue.value, props.ariaValueText, props.formatValue));
-	const markItems = computed(() => createSliderMarkItems(props.marks, bounds.value.min, bounds.value.max, (_value, percent) => percent <= valuePercent.value, {
-		position: "--_rp-slider-mark-position",
-		decorativeColors: ["--_rp-slider-mark-color", "--_rp-slider-mark-ring-color"],
-		foregroundColors: ["--_rp-slider-mark-label-color", "--_rp-slider-mark-filled-label-color"]
-	}));
-	const hasMarkLabels = computed(() => markItems.value.some((mark) => mark.hasLabel));
-	const trackSlotProps = computed(() => ({
-		value: normalizedValue.value,
-		formattedValue: formattedValue.value,
-		percent: valuePercent.value,
-		min: bounds.value.min,
-		max: bounds.value.max,
-		orientation: props.orientation,
-		getPercent(value) {
-			return getValuePercent(value, bounds.value.min, bounds.value.max);
-		}
-	}));
-	function onInput(event) {
-		if (control.disabled) return;
-		const input = event.target;
-		updateValue(input.valueAsNumber);
-	}
-	function updateValue(value) {
-		if (control.disabled) return;
-		controllable.setValue(normalizeSliderValue(value, bounds.value.min, bounds.value.max, nativeStep.value));
-	}
-	useFormControl({
-		elements: () => [inputRef.value],
-		isControlled: () => controllable.isControlled.value,
-		initializeDefault(element) {
-			element.defaultValue = String(normalizeSliderValue(controllable.initialValue, nativeMin.value, nativeMax.value, nativeStep.value));
-		},
-		validationMessage: () => props.validationMessage,
-		readResetValue(elements) {
-			controllable.resetValue(elements[0].valueAsNumber);
-		},
-		syncControlledValue(elements) {
-			elements[0].value = String(normalizedValue.value);
-		}
-	});
-	function focus(options) {
-		inputRef.value?.focus(options);
-	}
-	return {
-		inputRef,
-		focus,
-		control,
-		bounds,
-		nativeMin,
-		nativeMax,
-		nativeStep,
-		normalizedValue,
-		valuePercent,
-		formattedValue,
-		ariaValueText,
-		markItems,
-		hasMarkLabels,
-		trackSlotProps,
-		onInput,
-		updateValue
-	};
-}
-//#endregion
-//#region src/components/slider/useSlider.ts
-function getSliderTrackStyle(props, valuePercent, tooltipPercent) {
-	const style = {
-		"--_rp-slider-percent": `${valuePercent}%`,
-		"--_rp-slider-ratio": `${valuePercent / 100}`,
-		"--_rp-slider-tooltip-percent": `${tooltipPercent}%`,
-		"--_rp-slider-tooltip-ratio": `${tooltipPercent / 100}`
-	};
-	setSliderStyleValue(style, "--_rp-slider-color", getComponentColorValue(props.color));
-	applySliderThumbStyle(style, getSliderThumbOptions(props.thumb), {
-		size: "--rp-slider-thumb-size",
-		border: "--_rp-slider-thumb-border-style",
-		padding: "--rp-slider-thumb-padding",
-		borderColor: "--_rp-slider-thumb-border"
-	});
-	return style;
-}
-function useSlider(props, onChange) {
-	const valueState = useSliderValueState(props, onChange);
-	const tooltipState = useSliderTooltipState({
-		tooltip: () => props.tooltip,
-		orientation: () => props.orientation,
-		disabled: () => valueState.control.disabled,
-		value: valueState.normalizedValue,
-		bounds: valueState.bounds,
-		step: valueState.nativeStep,
-		formatValue: () => props.formatValue
-	});
-	const thumbMode = computed(() => getSliderThumbMode(props.thumb));
-	const rootClass = computed(() => bem("rp-slider", {
-		[`size-${props.size}`]: Boolean(props.size),
-		vertical: props.orientation === "vertical",
-		marked: valueState.markItems.value.length > 0,
-		"marks-with-labels": valueState.hasMarkLabels.value,
-		"tooltip-always-visible": tooltipState.tooltipAlwaysVisible.value,
-		"thumb-interaction": thumbMode.value === "interaction",
-		"thumb-hidden": thumbMode.value === false,
-		disabled: valueState.control.disabled,
-		invalid: valueState.control.invalid
-	}));
-	const trackStyle = computed(() => getSliderTrackStyle(props, valueState.valuePercent.value, tooltipState.tooltipPercent.value));
-	const pointerState = useSliderPointer({
-		bounds: valueState.bounds,
-		disabled: () => valueState.control.disabled,
-		inputRef: valueState.inputRef,
-		orientation: () => props.orientation,
-		step: valueState.nativeStep,
-		updateValue: valueState.updateValue
-	});
-	function onTrackPointerDown(event) {
-		const started = pointerState.onPointerDown(event);
-		tooltipState.onTooltipPointerDown(event);
-		return started;
-	}
-	return {
-		inputRef: valueState.inputRef,
-		focus: valueState.focus,
-		control: valueState.control,
-		nativeMin: valueState.nativeMin,
-		nativeMax: valueState.nativeMax,
-		nativeStep: valueState.nativeStep,
-		rootClass,
-		normalizedValue: valueState.normalizedValue,
-		valuePercent: valueState.valuePercent,
-		formattedValue: valueState.formattedValue,
-		ariaValueText: valueState.ariaValueText,
-		markItems: valueState.markItems,
-		thumbMode,
-		trackSlotProps: valueState.trackSlotProps,
-		trackStyle,
-		trackHovered: tooltipState.trackHovered,
-		dragging: tooltipState.dragging,
-		tooltipVisible: tooltipState.tooltipVisible,
-		tooltipOpen: tooltipState.tooltipOpen,
-		tooltipAnchor: tooltipState.tooltipAnchor,
-		tooltipPlacement: tooltipState.tooltipPlacement,
-		tooltipId: tooltipState.tooltipId,
-		tooltipColor: tooltipState.tooltipColor,
-		tooltipAutoContrast: tooltipState.tooltipAutoContrast,
-		tooltipContrastColor: tooltipState.tooltipContrastColor,
-		tooltipOffset: tooltipState.tooltipOffset,
-		tooltipOpenDelay: tooltipState.tooltipOpenDelay,
-		tooltipArrow: tooltipState.tooltipArrow,
-		tooltipValue: tooltipState.tooltipValue,
-		tooltipPercent: tooltipState.tooltipPercent,
-		tooltipFormattedValue: tooltipState.tooltipFormattedValue,
-		tooltipContent: tooltipState.tooltipContent,
-		onInput: valueState.onInput,
-		onTrackPointerDown,
-		onTooltipPointerMove: tooltipState.onTooltipPointerMove,
-		onTooltipTrackEnter: tooltipState.onTooltipTrackEnter,
-		onTooltipTrackLeave: tooltipState.onTooltipTrackLeave,
-		onTooltipFocusIn: tooltipState.onTooltipFocusIn,
-		onTooltipFocusOut: tooltipState.onTooltipFocusOut,
-		onTooltipKeydown: tooltipState.onTooltipKeydown
-	};
-}
-//#endregion
-//#region src/components/slider/slider.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0$2 = template("<span data-v-0fbfb274>");
-var t1$2 = template("<span data-v-0fbfb274 class=rp-slider__header>");
-var t2$2 = template("<span data-v-0fbfb274 class=\"rp-slider__track-layer rp-slider__track-underlay\"aria-hidden=true>");
-var t3$2 = template("<span data-v-0fbfb274 class=\"rp-slider__track-layer rp-slider__track-overlay\"aria-hidden=true>");
-var t4$2 = template("<span data-v-0fbfb274 class=rp-slider__travel aria-hidden=true>", 2);
-var t5$1 = template("<span data-v-0fbfb274> ");
-var t6$1 = template("<span data-v-0fbfb274><span data-v-0fbfb274 class=rp-slider__mark-dot></span>");
-var t7$1 = template("<span data-v-0fbfb274 class=rp-slider__marks aria-hidden=true>");
-var t8$1 = template("<span data-v-0fbfb274 class=rp-slider__tooltip-anchor aria-hidden=true></span>", 2);
-var t9$1 = template(" ");
-var t10 = template("<label data-v-0fbfb274><span data-v-0fbfb274><span data-v-0fbfb274 class=rp-slider__rail aria-hidden=true></span><!><span data-v-0fbfb274></span><!><input data-v-0fbfb274><!><span data-v-0fbfb274><span data-v-0fbfb274 class=rp-slider__thumb-content>", 1);
-//#endregion
-//#region src/components/slider/slider.vue
-var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
-	name: "RpSlider",
-	inheritAttrs: false,
-	__name: "slider",
-	props: {
-		id: {},
-		name: {},
-		form: {},
-		modelValue: { default: void 0 },
-		defaultValue: { default: void 0 },
-		min: { default: 0 },
-		max: { default: 100 },
-		step: { default: 1 },
-		marks: { default: () => [] },
-		thumb: {
-			type: [
-				Boolean,
-				String,
-				Object
-			],
-			default: "always"
-		},
-		tooltip: {
-			type: [
-				Boolean,
-				String,
-				Object
-			],
-			default: "hover"
-		},
-		formatValue: {},
-		color: {},
-		size: {},
-		orientation: { default: "horizontal" },
-		disabled: {
-			type: Boolean,
-			default: void 0
-		},
-		required: {
-			type: Boolean,
-			default: void 0
-		},
-		invalid: {
-			type: Boolean,
-			default: void 0
-		},
-		ariaLabel: {},
-		ariaValueText: {},
-		describedby: {},
-		labelledby: {},
-		inputAttrs: {},
-		validationMessage: {},
-		classNames: {},
-		styles: {}
-	},
-	emits: ["update:modelValue"],
-	setup(__props, { expose: __expose, emit: __emit, slots: $slots }) {
-		const slots = useSlots();
-		const props = __props;
-		const emit = __emit;
-		const { inputRef, focus, control, nativeMin, nativeMax, nativeStep, rootClass, normalizedValue, valuePercent, formattedValue, ariaValueText, markItems, thumbMode, trackSlotProps, trackStyle, trackHovered, dragging, tooltipVisible, tooltipOpen, tooltipAnchor, tooltipPlacement, tooltipId, tooltipColor, tooltipAutoContrast, tooltipContrastColor, tooltipOffset, tooltipOpenDelay, tooltipArrow, tooltipValue, tooltipPercent, tooltipFormattedValue, tooltipContent, onInput, onTrackPointerDown, onTooltipPointerMove, onTooltipTrackEnter, onTooltipTrackLeave, onTooltipFocusIn, onTooltipFocusOut, onTooltipKeydown } = useSlider(props, (value) => emit("update:modelValue", value));
-		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
-		const rootAttrs = computed(() => getRootAttrs({
-			class: [rootClass.value, { "rp-slider--custom-thumb": Boolean(slots.thumb) }],
-			style: trackStyle.value,
-			"data-disabled": toPresenceAttribute(control.disabled),
-			"data-invalid": toPresenceAttribute(control.invalid),
-			"data-orientation": props.orientation,
-			"data-track-hovered": toPresenceAttribute(trackHovered.value),
-			"data-dragging": toPresenceAttribute(dragging.value),
-			"data-thumb-visibility": thumbMode.value === false ? "hidden" : thumbMode.value
-		}));
-		const tooltipClassNames = computed(() => ({
-			root: ["rp-slider__tooltip", props.classNames?.tooltip],
-			content: "rp-slider__tooltip-content"
-		}));
-		const tooltipStyles = computed(() => ({ root: props.styles?.tooltip }));
-		const nativeInputAttrs = computed(() => {
-			const inputAttrs = props.inputAttrs ?? {};
-			const { compatibilityClass, compatibilityStyle, forwardedAttributes } = splitCompatibilityAttributes(inputAttrs);
-			return {
-				...forwardedAttributes,
-				...getPartAttrs("input", {
-					class: "rp-slider__native",
-					compatibilityClass,
-					compatibilityStyle
-				}),
-				onInput: composeEventHandlers(onInput, inputAttrs.onInput)
-			};
-		});
-		__expose({
-			nativeElement: inputRef,
-			focus
-		});
-		const _setTemplateRef = createTemplateRefSetter();
-		const n48 = t10();
-		const n45 = child(n48, 1);
-		const n44 = next(child(n45), 1);
-		const n15 = next(n44, 2);
-		const n46 = next(n15, 3);
-		const n23 = next(n46, 5);
-		const n47 = next(n23, 6);
-		const n35 = next(n47, 7);
-		const n34 = child(n35);
-		renderEffect(() => setDynamicProps(n48, [rootAttrs.value]));
-		setInsertionState(n48, 0);
-		createIf(() => $slots.default || $slots.value, () => {
-			const n10 = t1$2();
-			setInsertionState(n10, null, 0);
-			createIf(() => $slots.default, () => {
-				const n5 = t0$2();
-				renderEffect(() => setDynamicProps(n5, [unref(getPartAttrs)("label", { class: "rp-slider__label" })]));
-				setInsertionState(n5, null, 0);
-				createSlot("default", null, null, 1);
-				return n5;
-			});
-			setInsertionState(n10, null, 1);
-			createIf(() => $slots.value, () => {
-				const n9 = t0$2();
-				renderEffect(() => setDynamicProps(n9, [unref(getPartAttrs)("value", { class: "rp-slider__value" }), { "aria-hidden": "true" }]));
-				setInsertionState(n9, null, 0);
-				createSlot("value", {
-					value: () => unref(normalizedValue),
-					formattedValue: () => unref(formattedValue),
-					percent: () => unref(valuePercent)
-				}, null, 1);
-				return n9;
-			});
-			return n10;
-		});
-		renderEffect(() => setDynamicProps(n45, [unref(getPartAttrs)("track", { class: "rp-slider__track" })]));
-		setInsertionState(n45, n44, 1);
-		createIf(() => $slots["track-underlay"], () => {
-			const n14 = t2$2();
-			setInsertionState(n14, null, 0);
-			createSlot("track-underlay", { $: [() => unref(trackSlotProps)] }, null, 1);
-			return n14;
-		});
-		renderEffect(() => setDynamicProps(n15, [unref(getPartAttrs)("range", { class: "rp-slider__bar" }), { "aria-hidden": "true" }]));
-		setInsertionState(n45, n46, 3);
-		createIf(() => $slots["track-overlay"], () => {
-			const n19 = t3$2();
-			setInsertionState(n19, null, 0);
-			createSlot("track-overlay", { $: [() => unref(trackSlotProps)] }, null, 1);
-			return n19;
-		});
-		setInsertionState(n45, n46, 4);
-		createIf(() => unref(tooltipAnchor) === "pointer", () => {
-			return t4$2();
-		}, null, 33);
-		_setTemplateRef(n23, inputRef, null, "inputRef");
-		renderEffect(() => {
-			const _nativeInputAttrs = nativeInputAttrs.value;
-			const _control = unref(control);
-			const _props = props;
-			const _props_required_nativeInputAttrs_required = _props.required ?? _nativeInputAttrs.required;
-			setDynamicProps(n23, [_nativeInputAttrs, {
-				id: _control.id,
-				name: __props.name,
-				form: _control.form ?? _nativeInputAttrs.form,
-				type: "range",
-				value: unref(normalizedValue),
-				min: unref(nativeMin),
-				max: unref(nativeMax),
-				step: unref(nativeStep),
-				orient: __props.orientation === "vertical" ? "vertical" : void 0,
-				disabled: _control.disabled || void 0,
-				required: _props_required_nativeInputAttrs_required,
-				"aria-label": __props.ariaLabel || void 0,
-				"aria-labelledby": _control.ariaLabelledby,
-				"aria-describedby": _control.ariaDescribedby,
-				"aria-orientation": __props.orientation === "vertical" ? "vertical" : void 0,
-				"aria-valuetext": unref(ariaValueText),
-				"aria-invalid": _props.invalid === void 0 ? _nativeInputAttrs["aria-invalid"] : _control.invalid || void 0,
-				"aria-required": _props_required_nativeInputAttrs_required,
-				"data-disabled": unref(toPresenceAttribute)(_control.disabled),
-				"data-invalid": unref(toPresenceAttribute)(_control.invalid)
-			}]);
-		});
-		setInsertionState(n45, n47, 6);
-		createIf(() => unref(markItems).length, () => {
-			const n32 = t7$1();
-			setInsertionState(n32, null, 0);
-			createFor(() => unref(markItems), (_for_item0) => {
-				const n31 = t6$1();
-				renderEffect(() => {
-					const _mark = _for_item0.value;
-					setDynamicProps(n31, [unref(getPartAttrs)("mark", {
-						class: ["rp-slider__mark", { "rp-slider__mark--filled": _mark.filled }],
-						style: _mark.style
-					}), { "data-filled": unref(toPresenceAttribute)(_mark.filled) }]);
-				});
-				setInsertionState(n31, null, 1);
-				createIf(() => _for_item0.value.hasLabel, () => {
-					const n30 = t5$1();
-					const x30 = txt(n30);
-					renderEffect(() => {
-						setDynamicProps(n30, [unref(getPartAttrs)("markLabel", { class: "rp-slider__mark-label" })]);
-						setText(x30, toDisplayString(_for_item0.value.label));
-					});
-					return n30;
-				});
-				return n31;
-			}, (mark) => mark.key, 9);
-			return n32;
-		});
-		renderEffect(() => setDynamicProps(n35, [unref(getPartAttrs)("thumb", { class: "rp-slider__thumb" }), { "aria-hidden": "true" }]));
-		setInsertionState(n34, null, 0);
-		createSlot("thumb", {
-			value: () => unref(normalizedValue),
-			formattedValue: () => unref(formattedValue),
-			percent: () => unref(valuePercent)
-		}, null, 1);
-		setInsertionState(n45, null, 8);
-		createIf(() => unref(tooltipVisible), () => {
-			return createComponent(tooltip_default, {
-				id: () => unref(tooltipId),
-				"class-names": () => tooltipClassNames.value,
-				styles: () => tooltipStyles.value,
-				content: () => unref(tooltipContent),
-				placement: () => unref(tooltipPlacement),
-				color: () => unref(tooltipColor),
-				"auto-contrast": () => unref(tooltipAutoContrast),
-				"contrast-color": () => unref(tooltipContrastColor),
-				offset: () => unref(tooltipOffset),
-				open: () => unref(tooltipOpen),
-				"open-delay": () => unref(tooltipOpenDelay),
-				arrow: () => unref(tooltipArrow),
-				decorative: ""
-			}, {
-				"content": extend(() => {
-					return createSlot("tooltip-content", {
-						value: () => unref(tooltipValue),
-						formattedValue: () => unref(tooltipFormattedValue),
-						percent: () => unref(tooltipPercent),
-						anchor: () => unref(tooltipAnchor)
-					}, () => {
-						const n41 = t9$1();
-						renderEffect(() => setText(n41, toDisplayString(unref(tooltipContent))));
-						return n41;
-					}, 1);
-				}, { _: 8 }),
-				"default": () => {
-					return t8$1();
-				}
-			});
-		});
-		on(n45, "pointerdown", (e) => unref(onTrackPointerDown)(e));
-		on(n45, "pointerenter", (e) => unref(onTooltipTrackEnter)(e));
-		on(n45, "pointerleave", (e) => unref(onTooltipTrackLeave)(e));
-		on(n45, "pointermove", (e) => unref(onTooltipPointerMove)(e));
-		on(n45, "focusin", (e) => unref(onTooltipFocusIn)(e));
-		on(n45, "focusout", (e) => unref(onTooltipFocusOut)(e));
-		on(n45, "keydown", (e) => unref(onTooltipKeydown)(e));
-		return n48;
-	}
-}), [["__scopeId", "data-v-0fbfb274"]]);
-//#endregion
-//#region src/components/slider/useRangeSliderTooltipCollision.ts
-var TOOLTIP_COLLISION_GAP = 4;
-function getAxisSize(size, orientation) {
-	return orientation === "horizontal" ? size.width : size.height;
-}
-function getTooltipInterval(anchor, size, orientation, placement) {
-	const axisSize = getAxisSize(size, orientation);
-	if (orientation === "horizontal" ? placement === "top" || placement === "bottom" : placement === "left" || placement === "right") return {
-		start: anchor - axisSize / 2,
-		end: anchor + axisSize / 2
-	};
-	return (orientation === "horizontal" ? placement === "left" : placement === "top") ? {
-		start: anchor - axisSize,
-		end: anchor
-	} : {
-		start: anchor,
-		end: anchor + axisSize
-	};
-}
-function areTooltipIntervalsOverlapping(lower, upper, gap) {
-	return lower.start < upper.end + gap && lower.end + gap > upper.start;
-}
-function areRangeSliderTooltipLayoutsOverlapping({ gap = TOOLTIP_COLLISION_GAP, lowerPercent, lowerSize, orientation, placement, trackLength, upperPercent, upperSize }) {
-	if (trackLength <= 0 || lowerSize.width <= 0 || lowerSize.height <= 0 || upperSize.width <= 0 || upperSize.height <= 0) return false;
-	const getAnchor = (percent) => {
-		const ratio = percent / 100;
-		return orientation === "vertical" ? trackLength * (1 - ratio) : trackLength * ratio;
-	};
-	return areTooltipIntervalsOverlapping(getTooltipInterval(getAnchor(lowerPercent), lowerSize, orientation, placement), getTooltipInterval(getAnchor(upperPercent), upperSize, orientation, placement), gap);
-}
-function getObservedSize(entry) {
-	const borderBoxSize = Array.isArray(entry.borderBoxSize) ? entry.borderBoxSize[0] : entry.borderBoxSize;
-	if (borderBoxSize) return {
-		width: borderBoxSize.inlineSize,
-		height: borderBoxSize.blockSize
-	};
-	return {
-		width: entry.contentRect.width,
-		height: entry.contentRect.height
-	};
-}
-function getElementSize(element) {
-	const rect = element.getBoundingClientRect();
-	return {
-		width: rect.width,
-		height: rect.height
-	};
-}
-function useRangeSliderTooltipCollision({ enabled, lower, orientation, placement, root, sizeDependencies = [], upper, valuePercent }) {
-	const tooltipsOverlapping = ref(false);
-	const rootSize = ref({
-		width: 0,
-		height: 0
-	});
-	const lowerSize = ref({
-		width: 0,
-		height: 0
-	});
-	const upperSize = ref({
-		width: 0,
-		height: 0
-	});
-	let resizeObserver;
-	let destroyed = false;
-	function setOverlapping(value) {
-		if (tooltipsOverlapping.value !== value) tooltipsOverlapping.value = value;
-	}
-	function updateCollision() {
-		if (!enabled.value) {
-			setOverlapping(false);
-			return;
-		}
-		const trackLength = orientation.value === "horizontal" ? rootSize.value.width : rootSize.value.height;
-		setOverlapping(areRangeSliderTooltipLayoutsOverlapping({
-			gap: TOOLTIP_COLLISION_GAP,
-			lowerPercent: valuePercent.value[0],
-			lowerSize: lowerSize.value,
-			orientation: orientation.value,
-			placement: placement.value,
-			trackLength,
-			upperPercent: valuePercent.value[1],
-			upperSize: upperSize.value
-		}));
-	}
-	function measureSizes() {
-		if (destroyed) return;
-		rootSize.value = root.value ? getElementSize(root.value) : {
-			width: 0,
-			height: 0
-		};
-		lowerSize.value = lower.value ? getElementSize(lower.value) : {
-			width: 0,
-			height: 0
-		};
-		upperSize.value = upper.value ? getElementSize(upper.value) : {
-			width: 0,
-			height: 0
-		};
-		updateCollision();
-	}
-	const measureScheduler = createRafScheduler(measureSizes, () => root.value?.ownerDocument.defaultView);
-	function scheduleMeasure() {
-		if (!destroyed) measureScheduler.schedule();
-	}
-	function refreshObservedElements() {
-		if (!resizeObserver) return;
-		resizeObserver.disconnect();
-		for (const element of [
-			root.value,
-			lower.value,
-			upper.value
-		]) if (element) resizeObserver.observe(element);
-	}
-	function onResize(entries) {
-		for (const entry of entries) {
-			const size = getObservedSize(entry);
-			if (entry.target === root.value) rootSize.value = size;
-			else if (entry.target === lower.value) lowerSize.value = size;
-			else if (entry.target === upper.value) upperSize.value = size;
-		}
-		updateCollision();
-	}
-	function onWindowResize() {
-		scheduleMeasure();
-	}
-	onMounted(() => {
-		const view = root.value?.ownerDocument.defaultView;
-		if (view?.ResizeObserver) resizeObserver = new view.ResizeObserver(onResize);
-		view?.addEventListener("resize", onWindowResize);
-		refreshObservedElements();
-		if (!resizeObserver) scheduleMeasure();
-	});
-	watch([
-		root,
-		lower,
-		upper
-	], () => {
-		refreshObservedElements();
-		if (!resizeObserver) scheduleMeasure();
-	}, { flush: "post" });
-	watch([
-		valuePercent,
-		orientation,
-		placement,
-		enabled
-	], updateCollision, { flush: "sync" });
-	watch(sizeDependencies, () => {
-		if (!resizeObserver) scheduleMeasure();
-	}, { flush: "post" });
-	const arrowAlongTrackAxis = computed(() => orientation.value === "horizontal" ? placement.value === "top" || placement.value === "bottom" : placement.value === "left" || placement.value === "right");
-	const trackAxisLength = computed(() => orientation.value === "horizontal" ? rootSize.value.width : rootSize.value.height);
-	const thumbDistance = computed(() => {
-		const [lowerPercent, upperPercent] = valuePercent.value;
-		return Math.abs(upperPercent - lowerPercent) / 100 * trackAxisLength.value;
-	});
-	const mergedArrowOffset = computed(() => {
-		if (trackAxisLength.value <= 0 || !arrowAlongTrackAxis.value) return 0;
-		return thumbDistance.value * .5;
-	});
-	const mergedMinSize = computed(() => {
-		if (!tooltipsOverlapping.value || trackAxisLength.value <= 0 || !arrowAlongTrackAxis.value) return 0;
-		const maxEndpoint = Math.max(getAxisSize(lowerSize.value, orientation.value), getAxisSize(upperSize.value, orientation.value));
-		return thumbDistance.value + maxEndpoint;
-	});
-	onBeforeUnmount(() => {
-		destroyed = true;
-		(root.value?.ownerDocument.defaultView)?.removeEventListener("resize", onWindowResize);
-		resizeObserver?.disconnect();
-		measureScheduler.cancel();
-	});
-	return {
-		tooltipsOverlapping,
-		mergedArrowOffset,
-		mergedMinSize
-	};
-}
-//#endregion
-//#region src/components/slider/range-slider-tooltip.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0$1 = template("<span data-v-da6906b9 class=rp-range-slider__tooltip-merged-value> </span>");
-var t1$1 = template("<span data-v-da6906b9 class=rp-range-slider__tooltip-merged-value> ");
-var t2$1 = template("<span data-v-da6906b9 class=rp-range-slider__tooltip-merged-separator>–</span>", 2);
-var t3$1 = template(" ");
-var t4$1 = template("<span data-v-da6906b9 aria-hidden=true><span data-v-da6906b9 data-thumb=lower><span data-v-da6906b9 class=rp-range-slider__tooltip-anchor></span><span data-v-da6906b9 class=rp-tooltip__content aria-hidden=true> </span></span><span data-v-da6906b9 data-thumb=upper><span data-v-da6906b9 class=rp-range-slider__tooltip-anchor></span><span data-v-da6906b9 class=rp-tooltip__content aria-hidden=true> </span></span><span data-v-da6906b9 data-thumb=merged><span data-v-da6906b9 class=rp-range-slider__tooltip-anchor></span><span data-v-da6906b9 class=rp-tooltip__content aria-hidden=true>", 1);
-//#endregion
-//#region src/components/slider/range-slider-tooltip.vue
-var range_slider_tooltip_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
-	name: "RpRangeSliderTooltip",
-	__name: "range-slider-tooltip",
-	props: {
-		arrow: {
-			type: Boolean,
-			default: false
-		},
-		color: { default: void 0 },
-		autoContrast: {
-			type: Boolean,
-			default: true
-		},
-		contrastColor: { default: void 0 },
-		content: {},
-		ids: {},
-		mergedContent: {},
-		mergedId: { default: void 0 },
-		offset: { default: void 0 },
-		open: { type: Boolean },
-		orientation: {},
-		placement: {},
-		valuePercent: {},
-		tooltipClass: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] },
-		tooltipStyle: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] }
-	},
-	emits: ["update:overlapping"],
-	setup(__props, { emit: __emit }) {
-		const TOOLTIP_OFFSET_PROPERTIES = {
-			mainAxis: "--_rp-tooltip-main-axis-offset",
-			crossAxis: "--_rp-tooltip-cross-axis-offset"
-		};
-		const props = __props;
-		const emit = __emit;
-		const generatedId = useId();
-		const tooltipLayerRef = ref(null);
-		const lowerContentRef = ref(null);
-		const upperContentRef = ref(null);
-		const resolvedIds = computed(() => [props.ids[0] ?? `${generatedId}-lower-tooltip`, props.ids[1] ?? `${generatedId}-upper-tooltip`]);
-		const resolvedMergedId = computed(() => props.mergedId ?? `${generatedId}-merged-tooltip`);
-		const tooltipRootClass = computed(() => bem("rp-tooltip", {
-			[`placement-${props.placement}`]: true,
-			arrow: props.arrow,
-			open: props.open
-		}));
-		const contentStyle = computed(() => ({
-			...getFloatingOffsetStyle(props.offset, TOOLTIP_OFFSET_PROPERTIES),
-			...resolveTooltipColorStyleWithContrast(props.color, props.autoContrast, props.contrastColor)
-		}));
-		const { tooltipsOverlapping, mergedArrowOffset, mergedMinSize } = useRangeSliderTooltipCollision({
-			enabled: toRef(props, "open"),
-			lower: lowerContentRef,
-			orientation: toRef(props, "orientation"),
-			placement: toRef(props, "placement"),
-			root: tooltipLayerRef,
-			sizeDependencies: [() => props.content],
-			upper: upperContentRef,
-			valuePercent: toRef(props, "valuePercent")
-		});
-		const layerStyle = computed(() => ({
-			"--_rp-range-slider-tooltip-merged-arrow-offset": `${mergedArrowOffset.value}px`,
-			"--_rp-range-slider-tooltip-merged-min-size": `${mergedMinSize.value}px`
-		}));
-		watch(tooltipsOverlapping, (overlapping) => {
-			emit("update:overlapping", overlapping);
-		}, { immediate: true });
-		onBeforeUnmount(() => {
-			emit("update:overlapping", false);
-		});
-		const _setTemplateRef = createTemplateRefSetter();
-		const n16 = t4$1();
-		const n1 = child(n16);
-		const n0 = next(child(n1), 1);
-		const n3 = next(n1, 1);
-		const n2 = next(child(n3), 1);
-		const n15 = next(n3, 2);
-		const n14 = next(child(n15), 1);
-		const x0 = txt(n0);
-		applyVShow(n0, () => __props.open);
-		_setTemplateRef(n0, lowerContentRef, null, "lowerContentRef");
-		const x2 = txt(n2);
-		applyVShow(n2, () => __props.open);
-		_setTemplateRef(n2, upperContentRef, null, "upperContentRef");
-		renderEffect(() => {
-			const _tooltipStyle = __props.tooltipStyle;
-			const _resolvedIds = resolvedIds.value;
-			const _contentStyle = contentStyle.value;
-			const _content = __props.content;
-			setClass(n16, [
-				"rp-range-slider__tooltips",
-				`rp-range-slider__tooltips--placement-${__props.placement}`,
-				{
-					"rp-range-slider__tooltips--overlapping": unref(tooltipsOverlapping),
-					"rp-range-slider__tooltips--vertical": __props.orientation === "vertical"
-				}
-			]);
-			setStyle(n16, layerStyle.value);
-			setClass(n1, [
-				tooltipRootClass.value,
-				"rp-range-slider__tooltip",
-				"rp-range-slider__tooltip--lower",
-				__props.tooltipClass
-			]);
-			setStyle(n1, _tooltipStyle);
-			setProp(n0, "id", _resolvedIds[0]);
-			setStyle(n0, _contentStyle);
-			setText(x0, toDisplayString(_content[0]));
-			setClass(n3, [
-				tooltipRootClass.value,
-				"rp-range-slider__tooltip",
-				"rp-range-slider__tooltip--upper",
-				__props.tooltipClass
-			]);
-			setStyle(n3, _tooltipStyle);
-			setProp(n2, "id", _resolvedIds[1]);
-			setStyle(n2, _contentStyle);
-			setText(x2, toDisplayString(_content[1]));
-			setClass(n15, [
-				tooltipRootClass.value,
-				"rp-range-slider__tooltip",
-				"rp-range-slider__tooltip--merged",
-				__props.tooltipClass
-			]);
-			setStyle(n15, _tooltipStyle);
-			setProp(n14, "id", resolvedMergedId.value);
-			setStyle(n14, _contentStyle);
-		});
-		setInsertionState(n14, null, 0);
-		createIf(() => __props.orientation === "vertical" && __props.content[0] !== __props.content[1], () => {
-			const n6 = t0$1();
-			const n7 = t1$1();
-			const x6 = txt(n6);
-			const x7 = txt(n7);
-			renderEffect(() => {
-				const _content = __props.content;
-				setText(x6, toDisplayString(_content[1]));
-				setText(x7, toDisplayString(_content[0]));
-			});
-			return [n6, n7];
-		}, () => createIf(() => __props.content[0] !== __props.content[1], () => {
-			const n9 = t0$1();
-			const n10 = t2$1();
-			const n11 = t1$1();
-			const x9 = txt(n9);
-			const x11 = txt(n11);
-			renderEffect(() => {
-				const _content = __props.content;
-				setText(x9, toDisplayString(_content[0]));
-				setText(x11, toDisplayString(_content[1]));
-			});
-			return [
-				n9,
-				n10,
-				n11
-			];
-		}, () => {
-			const n13 = t3$1();
-			renderEffect(() => setText(n13, toDisplayString(__props.mergedContent)));
-			return n13;
-		}, 518), 262);
-		applyVShow(n14, () => __props.open);
-		_setTemplateRef(n16, tooltipLayerRef, null, "tooltipLayerRef");
-		return n16;
-	}
-}), [["__scopeId", "data-v-da6906b9"]]);
-//#endregion
-//#region src/components/slider/rangeSliderModel.ts
-function roundSliderNumber(value) {
-	return Number(value.toFixed(10));
-}
-function getStepValueAtOrAbove(value, min, step) {
-	if (step === "any") return value;
-	return roundSliderNumber(min + Math.ceil((value - min) / step - 1e-10) * step);
-}
-function getStepValueAtOrBelow(value, min, step) {
-	if (step === "any") return value;
-	return roundSliderNumber(min + Math.floor((value - min) / step + 1e-10) * step);
-}
-function isSliderStepAligned(min, max, step) {
-	const stepCount = (max - min) / step;
-	return Math.abs(stepCount - Math.round(stepCount)) <= 1e-10;
-}
-function normalizeRangeSliderMinRange(minRange, min, max) {
-	const bounds = normalizeSliderBounds(min, max);
-	const domain = bounds.max - bounds.min;
-	return Math.min(domain, Number.isFinite(minRange) && minRange > 0 ? minRange : 0);
-}
-function normalizeRangeSliderValue(value, min, max, step, minRange = 0) {
-	const bounds = normalizeSliderBounds(min, max);
-	const safeStep = normalizeSliderStep(step);
-	const safeMinRange = normalizeRangeSliderMinRange(minRange, bounds.min, bounds.max);
-	const first = normalizeSliderValue(Array.isArray(value) ? Number(value[0]) : NaN, bounds.min, bounds.max, safeStep);
-	const second = normalizeSliderValue(Array.isArray(value) ? Number(value[1]) : NaN, bounds.min, bounds.max, safeStep);
-	const lower = Math.min(first, second);
-	const upper = Math.max(first, second);
-	if (upper - lower >= safeMinRange) return [lower, upper];
-	if (safeMinRange >= bounds.max - bounds.min) return [bounds.min, bounds.max];
-	const expandedUpper = getStepValueAtOrAbove(lower + safeMinRange, bounds.min, safeStep);
-	if (expandedUpper <= bounds.max) return [lower, expandedUpper];
-	const expandedLower = getStepValueAtOrBelow(bounds.max - safeMinRange, bounds.min, safeStep);
-	return [Math.max(bounds.min, expandedLower), bounds.max];
-}
-function getClosestRangeSliderThumb(value, range, activeThumb) {
-	const [lower, upper] = range;
-	if (value < lower) return "lower";
-	if (value > upper) return "upper";
-	const lowerDistance = Math.abs(value - lower);
-	const upperDistance = Math.abs(value - upper);
-	if (lowerDistance < upperDistance) return "lower";
-	if (upperDistance < lowerDistance) return "upper";
-	return activeThumb ?? "upper";
-}
-function getRangeSliderNativeStep(bounds, step) {
-	if (step === "any") return step;
-	return isSliderStepAligned(bounds.min, bounds.max, step) ? step : "any";
-}
-function getRangeSliderNativeLimits(value, bounds, step, minRange) {
-	if (minRange === 0) return {
-		min: [bounds.min, bounds.min],
-		max: [bounds.max, bounds.max]
-	};
-	return {
-		min: [bounds.min, clamp(getStepValueAtOrAbove(value[0] + minRange, bounds.min, step), bounds.min, bounds.max)],
-		max: [clamp(getStepValueAtOrBelow(value[1] - minRange, bounds.min, step), bounds.min, bounds.max), bounds.max]
-	};
-}
-function getRangeSliderThumbUpdate({ thumb, value, currentValue, bounds, step, minRange, nativeMin, nativeMax, anchorValue = currentValue[getRangeSliderThumbIndex(getOppositeRangeSliderThumb(thumb))] }) {
-	const safeValue = normalizeSliderValue(value, bounds.min, bounds.max, step);
-	if (minRange > 0) {
-		const nextValue = [...currentValue];
-		nextValue[getRangeSliderThumbIndex(thumb)] = thumb === "lower" ? Math.min(safeValue, nativeMax[0]) : Math.max(safeValue, nativeMin[1]);
-		return {
-			thumb,
-			value: nextValue
-		};
-	}
-	if (safeValue < anchorValue) return {
-		thumb: "lower",
-		value: [safeValue, anchorValue]
-	};
-	if (safeValue > anchorValue) return {
-		thumb: "upper",
-		value: [anchorValue, safeValue]
-	};
-	return {
-		thumb,
-		value: [safeValue, safeValue]
-	};
-}
-function getFormattedRangeSliderValue(value, formatter) {
-	return [getFormattedSliderValue(value[0], formatter), getFormattedSliderValue(value[1], formatter)];
-}
-function getRangeSliderAriaValueText(value, ariaValueText, formatter) {
-	const endpointValues = Array.isArray(ariaValueText) ? ariaValueText : [ariaValueText, ariaValueText];
-	return [getSliderAriaValueText(value[0], endpointValues[0], formatter), getSliderAriaValueText(value[1], endpointValues[1], formatter)];
-}
-function getRangeSliderThumbIndex(thumb) {
-	return thumb === "lower" ? 0 : 1;
-}
-function getOppositeRangeSliderThumb(thumb) {
-	return thumb === "lower" ? "upper" : "lower";
-}
-function getRangeSliderKeyboardValue(key, currentValue, step, min, max) {
-	switch (key) {
-		case "ArrowRight":
-		case "ArrowUp": return currentValue + step;
-		case "ArrowLeft":
-		case "ArrowDown": return currentValue - step;
-		case "PageUp": return currentValue + step * 10;
-		case "PageDown": return currentValue - step * 10;
-		case "Home": return min;
-		case "End": return max;
-		default: return;
-	}
-}
-function getRangeSliderPointerValue(pointer, geometry, bounds) {
-	const pointerPosition = geometry.vertical ? pointer.clientY : pointer.clientX;
-	const ratio = clamp((geometry.vertical ? geometry.start - pointerPosition : pointerPosition - geometry.start) / geometry.length, 0, 1);
-	return bounds.min + ratio * (bounds.max - bounds.min);
-}
-//#endregion
-//#region src/components/slider/useRangeSliderPointer.ts
-function useRangeSliderPointer(options) {
-	function refreshGeometry(currentSession) {
-		const geometry = options.getPointerGeometry(currentSession.track);
-		if (geometry === void 0) return false;
-		currentSession.geometry = geometry;
-		return true;
-	}
-	function switchDraggingThumb(currentSession, nextThumb) {
-		if (currentSession.thumb === nextThumb) return;
-		const previousThumb = currentSession.thumb;
-		currentSession.thumb = nextThumb;
-		options.transferDrag(previousThumb, nextThumb);
-		options.setActiveThumb(nextThumb);
-		options.transferFocusedThumb(currentSession.track, previousThumb, nextThumb);
-	}
-	function updateFromPointer(event, currentSession) {
-		const value = options.getPointerValue(event, currentSession.geometry);
-		if (value == null) return;
-		switchDraggingThumb(currentSession, options.updateThumb(currentSession.thumb, value, currentSession.anchorValue));
-	}
-	const pointerSession = createPointerSession({
-		onStart(event, currentSession) {
-			event.preventDefault();
-			options.setActiveThumb(currentSession.thumb);
-			options.focusThumb(currentSession.track, currentSession.thumb);
-			options.startDrag(currentSession.thumb);
-			switchDraggingThumb(currentSession, options.updateThumb(currentSession.thumb, currentSession.initialValue, currentSession.anchorValue));
-		},
-		onStop(currentSession) {
-			options.endDrag(currentSession.thumb);
-		},
-		onUpdate: updateFromPointer,
-		refreshGeometry
-	});
-	function onTrackPointerDown(event) {
-		return pointerSession.start(event, () => {
-			if (options.disabled()) return;
-			const track = event.currentTarget;
-			if (!track) return;
-			const geometry = options.getPointerGeometry(track);
-			if (geometry === void 0) return;
-			const initialValue = options.getPointerValue(event, geometry);
-			if (initialValue == null) return;
-			const thumb = options.getThumb(event, initialValue);
-			return {
-				state: {
-					anchorValue: options.getAnchorValue(thumb),
-					geometry,
-					initialValue,
-					thumb,
-					track
-				},
-				target: track
-			};
-		});
-	}
-	onBeforeUnmount(pointerSession.stop);
-	return { onTrackPointerDown };
-}
-//#endregion
-//#region src/components/slider/useRangeSliderTooltipState.ts
-function useRangeSliderTooltipState(options) {
-	const delayedTooltip = useDelayedOpen({
-		openDelay: () => options.openDelay.value,
-		disabled: () => options.mode.value !== "hover" || options.disabled()
-	});
-	const interactionReasons = ref({
-		lower: {
-			focus: false,
-			drag: false
-		},
-		upper: {
-			focus: false,
-			drag: false
-		}
-	});
-	const trackHovered = ref(false);
-	const dismissed = ref(false);
-	function hasThumbInteraction(thumb) {
-		const reasons = interactionReasons.value[thumb];
-		return reasons.focus || reasons.drag;
-	}
-	function hasAnyInteraction() {
-		return trackHovered.value || hasThumbInteraction("lower") || hasThumbInteraction("upper");
-	}
-	function sync() {
-		if (options.mode.value === "hover" && !options.disabled() && hasAnyInteraction() && !dismissed.value) {
-			delayedTooltip.open();
-			return;
-		}
-		delayedTooltip.closeImmediate();
-	}
-	function startInteraction(thumb, reason) {
-		options.setActiveThumb(thumb);
-		const wasActive = hasAnyInteraction();
-		const wasDismissed = dismissed.value;
-		interactionReasons.value[thumb][reason] = true;
-		dismissed.value = false;
-		if (!wasActive || wasDismissed) sync();
-	}
-	function endInteraction(thumb, reason) {
-		interactionReasons.value[thumb][reason] = false;
-		if (!hasAnyInteraction()) sync();
-	}
-	function transferInteraction(from, to, reason) {
-		if (!interactionReasons.value[from][reason]) return;
-		interactionReasons.value[from][reason] = false;
-		interactionReasons.value[to][reason] = true;
-	}
-	function onFocus(thumb) {
-		startInteraction(thumb, "focus");
-	}
-	function onBlur(thumb) {
-		endInteraction(thumb, "focus");
-	}
-	function onTrackMouseEnter() {
-		const wasActive = hasAnyInteraction();
-		const wasDismissed = dismissed.value;
-		trackHovered.value = true;
-		dismissed.value = false;
-		if (!wasActive || wasDismissed) sync();
-	}
-	function onTrackMouseLeave() {
-		trackHovered.value = false;
-		if (!hasAnyInteraction()) sync();
-	}
-	function onKeydown(thumb, event) {
-		options.setActiveThumb(thumb);
-		if (event.key === "Escape") {
-			dismissed.value = true;
-			delayedTooltip.closeImmediate();
-			return true;
-		}
-		if (dismissed.value) {
-			dismissed.value = false;
-			sync();
-		}
-		return false;
-	}
-	const visible = computed(() => options.mode.value !== false);
-	const alwaysVisible = computed(() => options.mode.value === "always");
-	const open = computed(() => alwaysVisible.value || options.mode.value === "hover" && delayedTooltip.isOpen.value && hasAnyInteraction() && !dismissed.value && !options.disabled());
-	watch([options.mode, options.disabled], sync);
-	return {
-		visible,
-		alwaysVisible,
-		open,
-		startInteraction,
-		endInteraction,
-		transferInteraction,
-		onFocus,
-		onBlur,
-		onTrackMouseEnter,
-		onTrackMouseLeave,
-		onKeydown
-	};
-}
-//#endregion
-//#region src/components/slider/useRangeSliderValueState.ts
-function useRangeSliderValueState(props, onChange, setActiveThumb) {
-	const lowerInputRef = ref(null);
-	const upperInputRef = ref(null);
-	const controllable = useControllableValue({
-		modelValue: () => props.modelValue,
-		defaultValue: () => props.defaultValue ?? [props.min, props.max],
-		onChange
-	});
-	const control = useControlState(props);
-	const bounds = computed(() => normalizeSliderBounds(props.min, props.max));
-	const valueStep = computed(() => normalizeSliderStep(props.step));
-	const nativeStep = computed(() => getRangeSliderNativeStep(bounds.value, valueStep.value));
-	const hasManualNativeKeyboard = computed(() => valueStep.value !== "any" && nativeStep.value === "any");
-	const normalizedMinRange = computed(() => normalizeRangeSliderMinRange(props.minRange, bounds.value.min, bounds.value.max));
-	const normalizedValue = computed(() => normalizeRangeSliderValue(controllable.value.value, bounds.value.min, bounds.value.max, valueStep.value, normalizedMinRange.value));
-	const nativeLimits = computed(() => getRangeSliderNativeLimits(normalizedValue.value, bounds.value, valueStep.value, normalizedMinRange.value));
-	const nativeMin = computed(() => nativeLimits.value.min);
-	const nativeMax = computed(() => nativeLimits.value.max);
-	const valuePercent = computed(() => [getValuePercent(normalizedValue.value[0], bounds.value.min, bounds.value.max), getValuePercent(normalizedValue.value[1], bounds.value.min, bounds.value.max)]);
-	const formattedValue = computed(() => getFormattedRangeSliderValue(normalizedValue.value, props.formatValue));
-	const ariaLabels = computed(() => props.ariaLabel ?? ["Minimum", "Maximum"]);
-	const ariaValueText = computed(() => getRangeSliderAriaValueText(normalizedValue.value, props.ariaValueText, props.formatValue));
-	const nativeNames = computed(() => Array.isArray(props.name) ? props.name : [props.name, props.name]);
-	const nativeIds = computed(() => [control.id, control.id ? `${control.id}-upper` : void 0]);
-	const validationMessages = computed(() => Array.isArray(props.validationMessage) ? props.validationMessage : [props.validationMessage, props.validationMessage]);
-	const markItems = computed(() => createSliderMarkItems(props.marks, bounds.value.min, bounds.value.max, (value) => value >= normalizedValue.value[0] && value <= normalizedValue.value[1], {
-		position: "--_rp-range-slider-mark-position",
-		decorativeColors: ["--_rp-range-slider-mark-color", "--_rp-range-slider-mark-ring-color"],
-		foregroundColors: ["--_rp-range-slider-mark-label-color", "--_rp-range-slider-mark-filled-label-color"]
-	}));
-	const hasMarkLabels = computed(() => markItems.value.some((mark) => mark.hasLabel));
-	const trackSlotProps = computed(() => ({
-		value: normalizedValue.value,
-		formattedValue: formattedValue.value,
-		percent: valuePercent.value,
-		min: bounds.value.min,
-		max: bounds.value.max,
-		orientation: props.orientation,
-		getPercent(value) {
-			return getValuePercent(value, bounds.value.min, bounds.value.max);
-		}
-	}));
-	function normalizeInitialValue(value = controllable.initialValue) {
-		return normalizeRangeSliderValue(value, props.min, props.max, props.step, props.minRange);
-	}
-	useFormControl({
-		elements: () => [lowerInputRef.value, upperInputRef.value],
-		isControlled: () => controllable.isControlled.value,
-		initializeDefault(element, index) {
-			const initialValue = normalizeInitialValue();
-			element.defaultValue = String(initialValue[index]);
-		},
-		validationMessage: (_element, index) => validationMessages.value[index],
-		readResetValue(elements) {
-			const resetValue = [normalizedValue.value[0], normalizedValue.value[1]];
-			for (const element of elements) {
-				const index = element === upperInputRef.value ? 1 : 0;
-				resetValue[index] = Number(element.defaultValue);
-			}
-			const nextValue = normalizeInitialValue(resetValue);
-			controllable.resetValue(nextValue);
-			nextTick(() => {
-				if (lowerInputRef.value) lowerInputRef.value.value = String(nextValue[0]);
-				if (upperInputRef.value) upperInputRef.value.value = String(nextValue[1]);
-			});
-		},
-		syncControlledValue(elements) {
-			for (const element of elements) {
-				const index = element === upperInputRef.value ? 1 : 0;
-				element.value = String(normalizedValue.value[index]);
-			}
-		}
-	});
-	function updateThumb(thumb, value, anchorValue) {
-		if (control.disabled) return thumb;
-		const update = getRangeSliderThumbUpdate({
-			thumb,
-			value,
-			currentValue: normalizedValue.value,
-			bounds: bounds.value,
-			step: valueStep.value,
-			minRange: normalizedMinRange.value,
-			nativeMin: nativeMin.value,
-			nativeMax: nativeMax.value,
-			anchorValue
-		});
-		setActiveThumb(update.thumb);
-		controllable.setValue(update.value);
-		return update.thumb;
-	}
-	const nativeElements = computed(() => [lowerInputRef.value, upperInputRef.value]);
-	function setInputRef(index, element) {
-		const input = element instanceof HTMLInputElement ? element : null;
-		if (index === 0) lowerInputRef.value = input;
-		else upperInputRef.value = input;
-	}
-	function focus(options) {
-		lowerInputRef.value?.focus(options);
-	}
-	return {
-		nativeElements,
-		setInputRef,
-		focus,
-		control,
-		bounds,
-		valueStep,
-		hasManualNativeKeyboard,
-		nativeMin,
-		nativeMax,
-		nativeStep,
-		nativeNames,
-		nativeIds,
-		normalizedValue,
-		valuePercent,
-		formattedValue,
-		ariaLabels,
-		ariaValueText,
-		markItems,
-		hasMarkLabels,
-		trackSlotProps,
-		updateThumb
-	};
-}
-//#endregion
-//#region src/components/slider/useRangeSlider.ts
-function getRangeSliderTrackStyle(props, valuePercent) {
-	const [lowerPercent, upperPercent] = valuePercent;
-	const style = {
-		"--_rp-range-slider-lower-percent": `${lowerPercent}%`,
-		"--_rp-range-slider-upper-percent": `${upperPercent}%`,
-		"--_rp-range-slider-lower-ratio": `${lowerPercent / 100}`,
-		"--_rp-range-slider-upper-ratio": `${upperPercent / 100}`,
-		"--_rp-range-slider-tooltip-merged-percent": `${(lowerPercent + upperPercent) / 2}%`
-	};
-	setSliderStyleValue(style, "--_rp-range-slider-color", getComponentColorValue(props.color));
-	applySliderThumbStyle(style, props.thumb, {
-		size: "--rp-slider-thumb-size",
-		border: "--_rp-range-slider-thumb-border-style",
-		padding: "--rp-slider-thumb-padding",
-		borderColor: "--_rp-range-slider-thumb-border"
-	});
-	return style;
-}
-function getThumbFromTarget(target) {
-	const thumb = target?.closest?.("[data-range-slider-thumb]")?.getAttribute("data-range-slider-thumb");
-	return thumb === "lower" || thumb === "upper" ? thumb : void 0;
-}
-function getThumbInput(track, thumb) {
-	return track.querySelector(`.rp-range-slider__native--${thumb}, input[data-range-slider-thumb="${thumb}"]`);
-}
-function focusThumb(track, thumb) {
-	getThumbInput(track, thumb)?.focus({ preventScroll: true });
-}
-function readRangeSliderPointerGeometry(track, orientation) {
-	const vertical = orientation === "vertical";
-	const thumbsRect = track.querySelector(".rp-range-slider__thumbs")?.getBoundingClientRect();
-	const rect = thumbsRect && (vertical ? thumbsRect.height > 0 : thumbsRect.width > 0) ? thumbsRect : track.getBoundingClientRect();
-	const length = vertical ? rect.height : rect.width;
-	if (length <= 0) return void 0;
-	return {
-		length,
-		start: vertical ? rect.bottom : rect.left,
-		vertical
-	};
-}
-function useRangeSlider(props, onChange) {
-	const activeThumb = ref();
-	const valueState = useRangeSliderValueState(props, onChange, (thumb) => {
-		activeThumb.value = thumb;
-	});
-	const tooltipOptions = computed(() => getSliderTooltipOptions(props.tooltip));
-	const tooltipMode = computed(() => getSliderTooltipMode(props.tooltip));
-	const tooltipOpenDelay = computed(() => tooltipOptions.value.openDelay ?? 0);
-	const tooltipState = useRangeSliderTooltipState({
-		mode: tooltipMode,
-		openDelay: tooltipOpenDelay,
-		disabled: () => valueState.control.disabled,
-		setActiveThumb: (thumb) => {
-			activeThumb.value = thumb;
-		}
-	});
-	const tooltipVisible = tooltipState.visible;
-	const tooltipAlwaysVisible = tooltipState.alwaysVisible;
-	const tooltipOpen = tooltipState.open;
-	const tooltipPlacement = computed(() => tooltipOptions.value.placement ?? (props.orientation === "vertical" ? "left" : "top"));
-	const tooltipIds = computed(() => {
-		const baseId = tooltipOptions.value.id;
-		return baseId ? [`${baseId}-lower`, `${baseId}-upper`] : [void 0, void 0];
-	});
-	const mergedTooltipId = computed(() => {
-		const baseId = tooltipOptions.value.id;
-		return baseId ? `${baseId}-merged` : void 0;
-	});
-	const tooltipColor = computed(() => tooltipOptions.value.color);
-	const tooltipAutoContrast = computed(() => tooltipOptions.value.autoContrast);
-	const tooltipContrastColor = computed(() => tooltipOptions.value.contrastColor);
-	const tooltipOffset = computed(() => tooltipOptions.value.offset);
-	const tooltipArrow = computed(() => tooltipOptions.value.arrow ?? false);
-	const tooltipContent = computed(() => [String(valueState.formattedValue.value[0]), String(valueState.formattedValue.value[1])]);
-	const mergedTooltipContent = computed(() => {
-		const [lower, upper] = tooltipContent.value;
-		return lower === upper ? lower : `${lower}–${upper}`;
-	});
-	const rootClass = computed(() => bem("rp-range-slider", {
-		[`size-${props.size}`]: Boolean(props.size),
-		vertical: props.orientation === "vertical",
-		marked: valueState.markItems.value.length > 0,
-		"marks-with-labels": valueState.hasMarkLabels.value,
-		"tooltip-always-visible": tooltipAlwaysVisible.value,
-		disabled: valueState.control.disabled,
-		invalid: valueState.control.invalid
-	}));
-	const trackStyle = computed(() => getRangeSliderTrackStyle(props, valueState.valuePercent.value));
-	function transferFocusedThumb(input, thumb, nextThumb) {
-		if (thumb === nextThumb || input.ownerDocument.activeElement !== input) return;
-		const track = input.closest(".rp-range-slider__track");
-		if (!track) return;
-		const nextInput = getThumbInput(track, nextThumb);
-		if (!nextInput) return;
-		tooltipState.transferInteraction(thumb, nextThumb, "focus");
-		nextInput.focus({ preventScroll: true });
-	}
-	function onInput(thumb, event) {
-		const input = event.target;
-		transferFocusedThumb(input, thumb, valueState.updateThumb(thumb, input.valueAsNumber));
-	}
-	function onTooltipKeydown(thumb, event) {
-		if (tooltipState.onKeydown(thumb, event)) return;
-		if (!valueState.hasManualNativeKeyboard.value || valueState.valueStep.value === "any") return;
-		const index = getRangeSliderThumbIndex(thumb);
-		const nextValue = getRangeSliderKeyboardValue(event.key, valueState.normalizedValue.value[index], valueState.valueStep.value, valueState.nativeMin.value[index], valueState.nativeMax.value[index]);
-		if (nextValue == null) return;
-		event.preventDefault();
-		const nextThumb = valueState.updateThumb(thumb, nextValue);
-		transferFocusedThumb(event.target, thumb, nextThumb);
-	}
-	const { onTrackPointerDown } = useRangeSliderPointer({
-		disabled: () => valueState.control.disabled,
-		getPointerGeometry: (track) => readRangeSliderPointerGeometry(track, props.orientation),
-		getPointerValue: (event, geometry) => getRangeSliderPointerValue(event, geometry, valueState.bounds.value),
-		getThumb: (event, value) => getThumbFromTarget(event.target) ?? getClosestRangeSliderThumb(value, valueState.normalizedValue.value, activeThumb.value),
-		getAnchorValue: (thumb) => valueState.normalizedValue.value[getRangeSliderThumbIndex(getOppositeRangeSliderThumb(thumb))],
-		setActiveThumb: (thumb) => {
-			activeThumb.value = thumb;
-		},
-		focusThumb,
-		updateThumb: valueState.updateThumb,
-		transferFocusedThumb: (track, from, to) => {
-			const input = getThumbInput(track, from);
-			if (input) transferFocusedThumb(input, from, to);
-		},
-		startDrag: (thumb) => tooltipState.startInteraction(thumb, "drag"),
-		endDrag: (thumb) => tooltipState.endInteraction(thumb, "drag"),
-		transferDrag: (from, to) => tooltipState.transferInteraction(from, to, "drag")
-	});
-	return {
-		nativeElements: valueState.nativeElements,
-		setInputRef: valueState.setInputRef,
-		focus: valueState.focus,
-		control: valueState.control,
-		nativeMin: valueState.nativeMin,
-		nativeMax: valueState.nativeMax,
-		nativeStep: valueState.nativeStep,
-		nativeNames: valueState.nativeNames,
-		nativeIds: valueState.nativeIds,
-		rootClass,
-		normalizedValue: valueState.normalizedValue,
-		valuePercent: valueState.valuePercent,
-		formattedValue: valueState.formattedValue,
-		ariaLabels: valueState.ariaLabels,
-		ariaValueText: valueState.ariaValueText,
-		markItems: valueState.markItems,
-		trackSlotProps: valueState.trackSlotProps,
-		trackStyle,
-		activeThumb,
-		tooltipVisible,
-		tooltipOpen,
-		tooltipPlacement,
-		tooltipIds,
-		mergedTooltipId,
-		tooltipColor,
-		tooltipAutoContrast,
-		tooltipContrastColor,
-		tooltipOffset,
-		tooltipOpenDelay,
-		tooltipArrow,
-		tooltipContent,
-		mergedTooltipContent,
-		onInput,
-		onTrackPointerDown,
-		onTooltipFocus: tooltipState.onFocus,
-		onTooltipBlur: tooltipState.onBlur,
-		onTooltipTrackMouseEnter: tooltipState.onTrackMouseEnter,
-		onTooltipTrackMouseLeave: tooltipState.onTrackMouseLeave,
-		onTooltipKeydown
-	};
-}
-//#endregion
-//#region src/components/slider/range-slider.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0 = template("<span data-v-e27ae1af>");
-var t1 = template("<span data-v-e27ae1af class=rp-range-slider__header>");
-var t2 = template("<span data-v-e27ae1af class=\"rp-range-slider__track-layer rp-range-slider__track-underlay\"aria-hidden=true>");
-var t3 = template("<span data-v-e27ae1af class=\"rp-range-slider__track-layer rp-range-slider__track-overlay\"aria-hidden=true>");
-var t4 = template("<input data-v-e27ae1af>");
-var t5 = template("<span data-v-e27ae1af> ");
-var t6 = template("<span data-v-e27ae1af><span data-v-e27ae1af class=rp-range-slider__mark-dot></span>");
-var t7 = template("<span data-v-e27ae1af class=rp-range-slider__marks aria-hidden=true>");
-var t8 = template("<span data-v-e27ae1af><span data-v-e27ae1af class=rp-range-slider__thumb-content>");
-var t9 = template("<div data-v-e27ae1af><span data-v-e27ae1af><span data-v-e27ae1af class=rp-range-slider__rail aria-hidden=true></span><!><span data-v-e27ae1af></span><!><span data-v-e27ae1af class=rp-range-slider__thumbs aria-hidden=true>", 1);
-//#endregion
-//#region src/components/slider/range-slider.vue
-var range_slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
-	name: "RpRangeSlider",
-	inheritAttrs: false,
-	__name: "range-slider",
-	props: {
-		modelValue: { default: void 0 },
-		defaultValue: { default: void 0 },
-		minRange: { default: 0 },
-		thumb: {},
-		tooltip: {
-			type: [
-				Boolean,
-				String,
-				Object
-			],
-			default: "hover"
-		},
-		name: {},
-		ariaLabel: { default: () => ["Minimum", "Maximum"] },
-		ariaValueText: {},
-		inputAttrs: {},
-		validationMessage: {},
-		id: {},
-		form: {},
-		min: { default: 0 },
-		max: { default: 100 },
-		step: { default: 1 },
-		marks: { default: () => [] },
-		formatValue: {},
-		color: {},
-		size: {},
-		orientation: { default: "horizontal" },
-		disabled: {
-			type: Boolean,
-			default: void 0
-		},
-		required: {
-			type: Boolean,
-			default: void 0
-		},
-		invalid: {
-			type: Boolean,
-			default: void 0
-		},
-		describedby: {},
-		labelledby: {},
-		classNames: {},
-		styles: {}
-	},
-	emits: ["update:modelValue"],
-	setup(__props, { expose: __expose, emit: __emit, slots: $slots }) {
-		const slots = useSlots();
-		const props = __props;
-		const emit = __emit;
-		const generatedId = useId();
-		const tooltipsOverlapping = ref(false);
-		const rangeSliderThumbs = ["lower", "upper"];
-		const labelId = computed(() => `${props.id ?? generatedId}-label`);
-		const { nativeElements, setInputRef, focus, control, nativeMin, nativeMax, nativeStep, nativeNames, nativeIds, rootClass, normalizedValue, valuePercent, formattedValue, ariaLabels, ariaValueText, markItems, trackSlotProps, trackStyle, activeThumb, tooltipVisible, tooltipOpen, tooltipPlacement, tooltipIds, mergedTooltipId, tooltipColor, tooltipAutoContrast, tooltipContrastColor, tooltipOffset, tooltipArrow, tooltipContent, mergedTooltipContent, onInput, onTrackPointerDown, onTooltipFocus, onTooltipBlur, onTooltipTrackMouseEnter, onTooltipTrackMouseLeave, onTooltipKeydown } = useRangeSlider(props, (value) => emit("update:modelValue", value));
-		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
-		const rootAttrs = computed(() => getRootAttrs({
-			class: [rootClass.value, {
-				"rp-range-slider--custom-thumb": Boolean(slots.thumb),
-				"rp-range-slider--tooltips-overlapping": tooltipsOverlapping.value
-			}],
-			style: trackStyle.value,
-			role: "group",
-			"data-active-thumb": activeThumb.value || void 0,
-			"data-disabled": toPresenceAttribute(control.disabled),
-			"data-invalid": toPresenceAttribute(control.invalid),
-			"data-orientation": props.orientation,
-			"aria-labelledby": groupLabelledby.value,
-			"aria-describedby": control.ariaDescribedby,
-			"aria-invalid": control.invalid || void 0,
-			"aria-required": control.required || void 0
-		}));
-		const inputAttrsByThumb = computed(() => {
-			if (Array.isArray(props.inputAttrs)) return props.inputAttrs;
-			return [props.inputAttrs, props.inputAttrs];
-		});
-		const nativeInputAttrs = computed(() => rangeSliderThumbs.map((thumb, index) => {
-			const inputAttrs = inputAttrsByThumb.value[index] ?? {};
-			const { compatibilityClass, compatibilityStyle, forwardedAttributes } = splitCompatibilityAttributes(inputAttrs);
-			return Object.assign({}, forwardedAttributes, {
-				...getPartAttrs("input", {
-					class: ["rp-range-slider__native", `rp-range-slider__native--${thumb}`],
-					compatibilityClass,
-					compatibilityStyle
-				}),
-				onInput: composeEventHandlers((event) => onInput(thumb, event), inputAttrs.onInput),
-				onFocus: composeEventHandlers(() => onTooltipFocus(thumb), inputAttrs.onFocus),
-				onBlur: composeEventHandlers(() => onTooltipBlur(thumb), inputAttrs.onBlur),
-				onKeydown: composeEventHandlers((event) => onTooltipKeydown(thumb, event), inputAttrs.onKeydown)
-			});
-		}));
-		const groupLabelledby = computed(() => mergeAriaIdRefs(control.ariaLabelledby, slots.default ? labelId.value : void 0));
-		__expose({
-			nativeElements,
-			focus
-		});
-		const _setTemplateRef = createTemplateRefSetter();
-		const n44 = t9();
-		const n42 = child(n44, 1);
-		const n41 = next(child(n42), 1);
-		const n15 = next(n41, 2);
-		const n43 = next(n15, 3);
-		const n40 = next(n43, 6);
-		renderEffect(() => setDynamicProps(n44, [rootAttrs.value]));
-		setInsertionState(n44, 0);
-		createIf(() => $slots.default || $slots.value, () => {
-			const n10 = t1();
-			setInsertionState(n10, null, 0);
-			createIf(() => $slots.default, () => {
-				const n5 = t0();
-				renderEffect(() => setDynamicProps(n5, [{ id: labelId.value }, unref(getPartAttrs)("label", { class: "rp-range-slider__label" })]));
-				setInsertionState(n5, null, 0);
-				createSlot("default", null, null, 1);
-				return n5;
-			});
-			setInsertionState(n10, null, 1);
-			createIf(() => $slots.value, () => {
-				const n9 = t0();
-				renderEffect(() => setDynamicProps(n9, [unref(getPartAttrs)("value", { class: "rp-range-slider__value" }), { "aria-hidden": "true" }]));
-				setInsertionState(n9, null, 0);
-				createSlot("value", {
-					value: () => unref(normalizedValue),
-					formattedValue: () => unref(formattedValue),
-					percent: () => unref(valuePercent)
-				}, null, 1);
-				return n9;
-			});
-			return n10;
-		});
-		renderEffect(() => setDynamicProps(n42, [unref(getPartAttrs)("track", { class: "rp-range-slider__track" })]));
-		setInsertionState(n42, n41, 1);
-		createIf(() => $slots["track-underlay"], () => {
-			const n14 = t2();
-			setInsertionState(n14, null, 0);
-			createSlot("track-underlay", { $: [() => unref(trackSlotProps)] }, null, 1);
-			return n14;
-		});
-		renderEffect(() => setDynamicProps(n15, [unref(getPartAttrs)("range", { class: "rp-range-slider__bar" }), { "aria-hidden": "true" }]));
-		setInsertionState(n42, n43, 3);
-		createIf(() => $slots["track-overlay"], () => {
-			const n19 = t3();
-			setInsertionState(n19, null, 0);
-			createSlot("track-overlay", { $: [() => unref(trackSlotProps)] }, null, 1);
-			return n19;
-		});
-		setInsertionState(n42, n43, 4);
-		createFor(() => rangeSliderThumbs, (_for_item0, _for_key0) => {
-			const n22 = t4();
-			renderEffect(() => {
-				const _nativeInputAttrs = nativeInputAttrs.value;
-				const _index = _for_key0.value;
-				const _control = unref(control);
-				const _props = props;
-				const _nativeInputAttrs_index = _nativeInputAttrs[_index];
-				const _props_required_nativeInputAttrs_index_required = _props.required ?? _nativeInputAttrs_index?.required;
-				setDynamicProps(n22, [_nativeInputAttrs_index, {
-					id: unref(nativeIds)[_index],
-					name: unref(nativeNames)[_index],
-					form: _control.form ?? _nativeInputAttrs_index?.form,
-					type: "range",
-					value: unref(normalizedValue)[_index],
-					min: unref(nativeMin)[_index],
-					max: unref(nativeMax)[_index],
-					step: unref(nativeStep),
-					orient: __props.orientation === "vertical" ? "vertical" : void 0,
-					disabled: _control.disabled || void 0,
-					required: _props_required_nativeInputAttrs_index_required,
-					"aria-label": unref(ariaLabels)[_index],
-					"aria-describedby": _control.ariaDescribedby,
-					"aria-orientation": __props.orientation === "vertical" ? "vertical" : void 0,
-					"aria-valuetext": unref(ariaValueText)[_index],
-					"aria-invalid": _props.invalid === void 0 ? _nativeInputAttrs_index?.["aria-invalid"] : _control.invalid || void 0,
-					"aria-required": _props_required_nativeInputAttrs_index_required,
-					"data-thumb": _for_item0.value,
-					"data-disabled": unref(toPresenceAttribute)(_control.disabled),
-					"data-invalid": unref(toPresenceAttribute)(_control.invalid)
-				}]);
-				_setTemplateRef(n22, (element) => unref(setInputRef)(_index, element), true);
-			});
-			return n22;
-		}, (thumb, index) => thumb, 8);
-		setInsertionState(n42, n43, 5);
-		createIf(() => unref(markItems).length, () => {
-			const n31 = t7();
-			setInsertionState(n31, null, 0);
-			createFor(() => unref(markItems), (_for_item0) => {
-				const n30 = t6();
-				renderEffect(() => {
-					const _mark = _for_item0.value;
-					setDynamicProps(n30, [unref(getPartAttrs)("mark", {
-						class: ["rp-range-slider__mark", { "rp-range-slider__mark--filled": _mark.filled }],
-						style: _mark.style
-					}), { "data-filled": unref(toPresenceAttribute)(_mark.filled) }]);
-				});
-				setInsertionState(n30, null, 1);
-				createIf(() => _for_item0.value.hasLabel, () => {
-					const n29 = t5();
-					const x29 = txt(n29);
-					renderEffect(() => {
-						setDynamicProps(n29, [unref(getPartAttrs)("markLabel", { class: "rp-range-slider__mark-label" })]);
-						setText(x29, toDisplayString(_for_item0.value.label));
-					});
-					return n29;
-				});
-				return n30;
-			}, (mark) => mark.key, 9);
-			return n31;
-		});
-		setInsertionState(n40, null, 0);
-		createFor(() => rangeSliderThumbs, (_for_item0, _for_key0) => {
-			const n36 = t8();
-			const n35 = child(n36);
-			renderEffect(() => {
-				const _thumb = _for_item0.value;
-				setDynamicProps(n36, [unref(getPartAttrs)("thumb", { class: ["rp-range-slider__thumb", `rp-range-slider__thumb--${_thumb}`] }), {
-					"data-range-slider-thumb": _thumb,
-					"data-thumb": _thumb
-				}]);
-			});
-			setInsertionState(n35, null, 0);
-			createSlot("thumb", {
-				thumb: () => _for_item0.value,
-				index: () => _for_key0.value,
-				value: () => unref(normalizedValue)[_for_key0.value],
-				formattedValue: () => unref(formattedValue)[_for_key0.value],
-				percent: () => unref(valuePercent)[_for_key0.value]
-			}, null, 1);
-			return n36;
-		}, (thumb, index) => thumb, 8);
-		setInsertionState(n40, null, 1);
-		createIf(() => unref(tooltipVisible), () => {
-			const _on_update_overlapping = ($event) => tooltipsOverlapping.value = $event;
-			return createComponent(range_slider_tooltip_default, {
-				arrow: () => unref(tooltipArrow),
-				color: () => unref(tooltipColor),
-				"auto-contrast": () => unref(tooltipAutoContrast),
-				"contrast-color": () => unref(tooltipContrastColor),
-				content: () => unref(tooltipContent),
-				ids: () => unref(tooltipIds),
-				"merged-content": () => unref(mergedTooltipContent),
-				"merged-id": () => unref(mergedTooltipId),
-				offset: () => unref(tooltipOffset),
-				open: () => unref(tooltipOpen),
-				orientation: () => __props.orientation,
-				placement: () => unref(tooltipPlacement),
-				"value-percent": () => unref(valuePercent),
-				"tooltip-class": () => __props.classNames?.tooltip,
-				"tooltip-style": () => __props.styles?.tooltip,
-				"onUpdate:overlapping": () => _on_update_overlapping
-			});
-		});
-		on(n42, "pointerdown", (e) => unref(onTrackPointerDown)(e));
-		on(n42, "mouseenter", (e) => unref(onTooltipTrackMouseEnter)(e));
-		on(n42, "mouseleave", (e) => unref(onTooltipTrackMouseLeave)(e));
-		return n44;
-	}
-}), [["__scopeId", "data-v-e27ae1af"]]);
-//#endregion
-//#region src/components/slider/types.ts
-var sliderParts = [
-	"root",
-	"label",
-	"value",
-	"track",
-	"range",
-	"input",
-	"thumb",
-	"mark",
-	"markLabel",
-	"tooltip"
-];
-var rangeSliderParts = [
-	"root",
-	"label",
-	"value",
-	"track",
-	"range",
-	"input",
-	"thumb",
-	"mark",
-	"markLabel",
-	"tooltip"
-];
-var sliderColors = componentColors;
-var sliderSizes = [
-	"xs",
-	"sm",
-	"md",
-	"lg",
-	"xl"
-];
-var sliderOrientations = ["horizontal", "vertical"];
-//#endregion
-export { sliderSizes as a, sliderParts as i, sliderColors as n, range_slider_default as o, sliderOrientations as r, slider_default as s, rangeSliderParts as t };