ropav 0.0.7 → 0.0.9

package/dist/slider.js

@@ -1,30 +1,11 @@
 import './slider.css';
 import { t as bem } from "./bem.js";
+import { n as getComponentColorValue, t as componentColors } from "./componentColors.js";
 import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
 import { t as useControlState } from "./useControlState.js";
 import { n as useDelayedOpen, t as tooltip_default } from "./tooltip.js";
-import { child, computed, createComponent, createFor, createIf, createInvoker, createSlot, defineVaporComponent, delegateEvents, next, on, renderEffect, setAttr, setClass, setClassName, setInsertionState, setProp, setStyle, setText, setValue, template, toDisplayString, txt, unref } from "vue";
-//#region src/components/slider/types.ts
-var sliderColors = [
-	"primary",
-	"secondary",
-	"success",
-	"warning",
-	"danger",
-	"info",
-	"neutral"
-];
-var sliderSizes = [
-	"xs",
-	"sm",
-	"md",
-	"lg",
-	"xl"
-];
-var sliderOrientations = ["horizontal", "vertical"];
-//#endregion
+import { child, computed, createComponent, createFor, createIf, createInvoker, createSlot, createTemplateRefSetter, defineVaporComponent, delegateEvents, next, nextTick, on, onBeforeUnmount, onMounted, onUpdated, ref, renderEffect, setAttr, setClass, setClassName, setInsertionState, setProp, setStyle, setText, setValue, template, toDisplayString, txt, unref, useId, useSlots, watch } from "vue";
 //#region src/components/slider/useSlider.ts
-var sliderColorNames = new Set(sliderColors);
 var sliderMarkColorProperties = [
 	"--_rp-slider-mark-color",
 	"--_rp-slider-mark-label-color",
@@ -61,15 +42,10 @@ function getSliderValuePercent(value, min, max) {
 	return Math.min(100, Math.max(0, percent));
 }
 function getSliderMarkColorValue(color) {
-	if (!color) return void 0;
-	return sliderColorNames.has(color) ? `var(--rp-color-${color})` : color;
+	return getComponentColorValue(color);
 }
-function isSliderPresetColor(color) {
-	return Boolean(color && sliderColorNames.has(color));
-}
-function getSliderCustomColorValue(color) {
-	if (!color || isSliderPresetColor(color)) return void 0;
-	return color;
+function getSliderColorValue(color) {
+	return getComponentColorValue(color);
 }
 function setSliderStyleValue(style, property, value) {
 	if (value) style[property] = value;
@@ -132,7 +108,7 @@ function getSliderTrackStyle(props, valuePercent) {
 		"--_rp-slider-percent": `${valuePercent}%`,
 		"--_rp-slider-ratio": `${valuePercent / 100}`
 	};
-	setSliderStyleValue(style, "--_rp-slider-custom-color", getSliderCustomColorValue(props.color));
+	setSliderStyleValue(style, "--_rp-slider-color", getSliderColorValue(props.color));
 	for (const [property, propName, getValue] of sliderThumbStyleProps) setSliderStyleValue(style, property, getValue(props.thumbStyle?.[propName]));
 	return style;
 }
@@ -179,7 +155,6 @@ function useSlider(props, emitUpdate) {
 	const tooltipArrow = computed(() => tooltipOptions.value.arrow ?? false);
 	const tooltipContent = computed(() => String(formattedValue.value));
 	const rootClass = computed(() => bem("rp-slider", {
-		[`color-${props.color}`]: isSliderPresetColor(props.color),
 		[`size-${props.size}`]: Boolean(props.size),
 		vertical: props.orientation === "vertical",
 		marked: markItems.value.length > 0,
@@ -233,14 +208,14 @@ function useSlider(props, emitUpdate) {
 }
 //#endregion
 //#region src/components/slider/slider.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0 = template("<span data-v-c9655b1d class=rp-slider__label>");
-var t1 = template("<span data-v-c9655b1d class=rp-slider__value aria-hidden=true>");
-var t2 = template("<span data-v-c9655b1d class=rp-slider__header>");
-var t3 = template("<span data-v-c9655b1d class=rp-slider__mark-label> ");
-var t4 = template("<span data-v-c9655b1d><span data-v-c9655b1d class=rp-slider__mark-dot></span>");
-var t5 = template("<span data-v-c9655b1d class=rp-slider__marks aria-hidden=true>");
-var t6 = template("<span data-v-c9655b1d class=rp-slider__thumb aria-hidden=true><span data-v-c9655b1d class=rp-slider__thumb-content>");
-var t7 = template("<span data-v-c9655b1d class=rp-slider__tooltip-anchor aria-hidden=true>", 2);
+var t0$1 = template("<span data-v-c9655b1d class=rp-slider__label>");
+var t1$1 = template("<span data-v-c9655b1d class=rp-slider__value aria-hidden=true>");
+var t2$1 = template("<span data-v-c9655b1d class=rp-slider__header>");
+var t3$1 = template("<span data-v-c9655b1d class=rp-slider__mark-label> ");
+var t4$1 = template("<span data-v-c9655b1d><span data-v-c9655b1d class=rp-slider__mark-dot></span>");
+var t5$1 = template("<span data-v-c9655b1d class=rp-slider__marks aria-hidden=true>");
+var t6$1 = template("<span data-v-c9655b1d class=rp-slider__thumb aria-hidden=true><span data-v-c9655b1d class=rp-slider__thumb-content>");
+var t7$1 = template("<span data-v-c9655b1d class=rp-slider__tooltip-anchor aria-hidden=true>", 2);
 var t8 = template("<label data-v-c9655b1d><span data-v-c9655b1d class=rp-slider__track><span data-v-c9655b1d class=rp-slider__bar aria-hidden=true></span><input data-v-c9655b1d class=rp-slider__native type=range>", 1);
 delegateEvents("input", "focusin", "focusout", "keydown");
 //#endregion
@@ -307,17 +282,17 @@ var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE_
 		});
 		setInsertionState(n31, 0, 0);
 		createIf(() => $slots.default || $slots.value, () => {
-			const n10 = t2();
+			const n10 = t2$1();
 			setInsertionState(n10, null, 0);
 			createIf(() => $slots.default, () => {
-				const n5 = t0();
+				const n5 = t0$1();
 				setInsertionState(n5, null, 0);
 				createSlot("default", null, null, 1);
 				return n5;
 			});
 			setInsertionState(n10, null, 1);
 			createIf(() => $slots.value, () => {
-				const n9 = t1();
+				const n9 = t1$1();
 				setInsertionState(n9, null, 0);
 				createSlot("value", {
 					value: () => unref(normalizedValue),
@@ -351,10 +326,10 @@ var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE_
 		});
 		setInsertionState(n30, null, 2);
 		createIf(() => unref(markItems).length, () => {
-			const n20 = t5();
+			const n20 = t5$1();
 			setInsertionState(n20, null, 0);
 			createFor(() => unref(markItems), (_for_item0) => {
-				const n19 = t4();
+				const n19 = t4$1();
 				renderEffect(() => {
 					const _mark = _for_item0.value;
 					setClassName(n19, _mark.filled ? 1 : 0, " rp-slider__mark--filled", "rp-slider__mark");
@@ -362,7 +337,7 @@ var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE_
 				});
 				setInsertionState(n19, null, 1);
 				createIf(() => _for_item0.value.hasLabel, () => {
-					const n18 = t3();
+					const n18 = t3$1();
 					const x18 = txt(n18);
 					renderEffect(() => setText(x18, toDisplayString(_for_item0.value.label)));
 					return n18;
@@ -373,7 +348,7 @@ var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE_
 		});
 		setInsertionState(n30, null, 3);
 		createIf(() => $slots.thumb, () => {
-			const n25 = t6();
+			const n25 = t6$1();
 			setInsertionState(child(n25), null, 0);
 			createSlot("thumb", {
 				value: () => unref(normalizedValue),
@@ -396,7 +371,7 @@ var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE_
 				arrow: () => unref(tooltipArrow),
 				decorative: ""
 			}, () => {
-				return t7();
+				return t7$1();
 			});
 		});
 		on(n30, "mouseenter", (e) => unref(openTooltip)(e));
@@ -408,6 +383,1103 @@ var slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE_
 	}
 }), [["__scopeId", "data-v-c9655b1d"]]);
 //#endregion
-export { sliderSizes as i, sliderColors as n, sliderOrientations as r, slider_default as t };
-
-//# sourceMappingURL=slider.js.map
+//#region src/components/slider/useRangeSlider.ts
+var rangeSliderMarkColorProperties = [
+	"--_rp-range-slider-mark-color",
+	"--_rp-range-slider-mark-label-color",
+	"--_rp-range-slider-mark-filled-label-color",
+	"--_rp-range-slider-mark-ring-color"
+];
+function roundSliderNumber(value) {
+	return Number(value.toFixed(10));
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+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 setRangeSliderStyleValue(style, property, value) {
+	if (value) style[property] = value;
+}
+function getRangeSliderLengthValue(value) {
+	if (value == null || value === "") return void 0;
+	if (typeof value === "number") return Number.isFinite(value) ? `${value}px` : void 0;
+	return value;
+}
+function getRangeSliderBorderValue(value) {
+	if (value == null || value === "") return void 0;
+	if (typeof value === "number") return Number.isFinite(value) ? `${value}px solid var(--_rp-range-slider-thumb-border)` : void 0;
+	return value;
+}
+var rangeSliderThumbStyleProps = [
+	[
+		"--_rp-range-slider-thumb-size",
+		"size",
+		getRangeSliderLengthValue
+	],
+	[
+		"--_rp-range-slider-thumb-border-style",
+		"border",
+		getRangeSliderBorderValue
+	],
+	[
+		"--_rp-range-slider-thumb-padding",
+		"padding",
+		getRangeSliderLengthValue
+	]
+];
+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}%`
+	};
+	setRangeSliderStyleValue(style, "--_rp-range-slider-color", getComponentColorValue(props.color));
+	for (const [property, propName, getValue] of rangeSliderThumbStyleProps) setRangeSliderStyleValue(style, property, getValue(props.thumbStyle?.[propName]));
+	return style;
+}
+function getRangeSliderMarkStyle(percent, color) {
+	const style = { "--_rp-range-slider-mark-position": `${percent}%` };
+	const colorValue = getComponentColorValue(color);
+	for (const property of rangeSliderMarkColorProperties) setRangeSliderStyleValue(style, property, colorValue);
+	return style;
+}
+function normalizeRangeSliderMark(mark) {
+	return typeof mark === "number" ? { value: mark } : mark;
+}
+function normalizeRangeSliderMarks(marks, min, max, value) {
+	return (marks ?? []).flatMap((markInput, index) => {
+		const mark = normalizeRangeSliderMark(markInput);
+		if (mark.hidden) return [];
+		const markValue = Number(mark.value);
+		if (!Number.isFinite(markValue)) return [];
+		const percent = getSliderValuePercent(markValue, min, max);
+		return {
+			key: `${markValue}-${index}`,
+			value: markValue,
+			label: mark.label,
+			hasLabel: mark.label != null,
+			filled: markValue >= value[0] && markValue <= value[1],
+			style: getRangeSliderMarkStyle(percent, mark.color)
+		};
+	});
+}
+function getFormattedRangeSliderValue(value, formatter) {
+	return formatter ? [formatter(value[0]), formatter(value[1])] : value;
+}
+function getRangeSliderEndpointValueText(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 getRangeSliderAriaValueText(value, ariaValueText, formatter) {
+	const endpointValues = Array.isArray(ariaValueText) ? ariaValueText : [ariaValueText, ariaValueText];
+	return [getRangeSliderEndpointValueText(value[0], endpointValues[0], formatter), getRangeSliderEndpointValueText(value[1], endpointValues[1], formatter)];
+}
+function getRangeSliderTooltipOptions(tooltip) {
+	return typeof tooltip === "object" ? tooltip : {};
+}
+function getRangeSliderTooltipMode(tooltip) {
+	if (tooltip === false) return false;
+	if (typeof tooltip === "object") return tooltip.mode ?? "hover";
+	return tooltip;
+}
+function getThumbIndex(thumb) {
+	return thumb === "lower" ? 0 : 1;
+}
+function getOppositeThumb(thumb) {
+	return thumb === "lower" ? "upper" : "lower";
+}
+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 useRangeSlider(props, emitUpdate) {
+	const control = useControlState(props);
+	const activeThumb = ref();
+	const bounds = computed(() => normalizeSliderBounds(props.min, props.max));
+	const valueStep = computed(() => normalizeSliderStep(props.step));
+	const nativeStep = computed(() => {
+		const step = valueStep.value;
+		if (step === "any") return step;
+		return isSliderStepAligned(bounds.value.min, bounds.value.max, step) ? step : "any";
+	});
+	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(props.modelValue, bounds.value.min, bounds.value.max, valueStep.value, normalizedMinRange.value));
+	const valuePercent = computed(() => [getSliderValuePercent(normalizedValue.value[0], bounds.value.min, bounds.value.max), getSliderValuePercent(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 nativeMin = computed(() => {
+		if (normalizedMinRange.value === 0) return [bounds.value.min, bounds.value.min];
+		return [bounds.value.min, clamp(getStepValueAtOrAbove(normalizedValue.value[0] + normalizedMinRange.value, bounds.value.min, valueStep.value), bounds.value.min, bounds.value.max)];
+	});
+	const nativeMax = computed(() => {
+		if (normalizedMinRange.value === 0) return [bounds.value.max, bounds.value.max];
+		return [clamp(getStepValueAtOrBelow(normalizedValue.value[1] - normalizedMinRange.value, bounds.value.min, valueStep.value), bounds.value.min, bounds.value.max), bounds.value.max];
+	});
+	const markItems = computed(() => normalizeRangeSliderMarks(props.marks, bounds.value.min, bounds.value.max, normalizedValue.value));
+	const hasMarkLabels = computed(() => markItems.value.some((mark) => mark.hasLabel));
+	const trackStyle = computed(() => getRangeSliderTrackStyle(props, valuePercent.value));
+	const tooltipOptions = computed(() => getRangeSliderTooltipOptions(props.tooltip));
+	const tooltipMode = computed(() => getRangeSliderTooltipMode(props.tooltip));
+	const tooltipOpenDelay = computed(() => tooltipOptions.value.openDelay ?? 0);
+	const delayedTooltip = useDelayedOpen({
+		openDelay: () => tooltipOpenDelay.value,
+		disabled: () => tooltipMode.value !== "hover" || control.disabled
+	});
+	const tooltipInteractionReasons = ref({
+		lower: {
+			focus: false,
+			drag: false
+		},
+		upper: {
+			focus: false,
+			drag: false
+		}
+	});
+	const tooltipTrackHovered = ref(false);
+	const tooltipDismissed = ref(false);
+	const tooltipVisible = computed(() => tooltipMode.value !== false);
+	const tooltipAlwaysVisible = computed(() => tooltipMode.value === "always");
+	const tooltipOpen = computed(() => tooltipAlwaysVisible.value || tooltipMode.value === "hover" && delayedTooltip.isOpen.value && hasAnyTooltipInteractionReason() && !tooltipDismissed.value && !control.disabled);
+	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 tooltipOffset = computed(() => tooltipOptions.value.offset);
+	const tooltipArrow = computed(() => tooltipOptions.value.arrow ?? false);
+	const tooltipContent = computed(() => [String(formattedValue.value[0]), String(formattedValue.value[1])]);
+	const mergedTooltipContent = computed(() => `${tooltipContent.value[0]}–${tooltipContent.value[1]}`);
+	const rootClass = computed(() => bem("rp-range-slider", {
+		[`size-${props.size}`]: Boolean(props.size),
+		vertical: props.orientation === "vertical",
+		marked: markItems.value.length > 0,
+		"marks-with-labels": hasMarkLabels.value,
+		"tooltip-always-visible": tooltipAlwaysVisible.value,
+		disabled: control.disabled,
+		invalid: control.invalid,
+		valid: control.valid && !control.invalid
+	}));
+	function getThumbUpdate(thumb, value, anchorValue = normalizedValue.value[getThumbIndex(getOppositeThumb(thumb))]) {
+		const safeValue = normalizeSliderValue(value, bounds.value.min, bounds.value.max, valueStep.value);
+		if (normalizedMinRange.value > 0) {
+			const nextValue = [...normalizedValue.value];
+			nextValue[getThumbIndex(thumb)] = thumb === "lower" ? Math.min(safeValue, nativeMax.value[0]) : Math.max(safeValue, nativeMin.value[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 updateThumb(thumb, value, anchorValue) {
+		if (control.disabled) return thumb;
+		const update = getThumbUpdate(thumb, value, anchorValue);
+		activeThumb.value = update.thumb;
+		emitUpdate(update.value);
+		return update.thumb;
+	}
+	function onInput(thumb, event) {
+		const input = event.target;
+		transferFocusedThumb(input, thumb, updateThumb(thumb, input.valueAsNumber));
+	}
+	function hasThumbTooltipInteractionReason(thumb) {
+		const reasons = tooltipInteractionReasons.value[thumb];
+		return reasons.focus || reasons.drag;
+	}
+	function hasAnyTooltipInteractionReason() {
+		return tooltipTrackHovered.value || hasThumbTooltipInteractionReason("lower") || hasThumbTooltipInteractionReason("upper");
+	}
+	function syncTooltip() {
+		if (tooltipMode.value === "hover" && !control.disabled && hasAnyTooltipInteractionReason() && !tooltipDismissed.value) {
+			delayedTooltip.open();
+			return;
+		}
+		delayedTooltip.closeImmediate();
+	}
+	function startTooltipInteraction(thumb, reason) {
+		activeThumb.value = thumb;
+		const wasActive = hasAnyTooltipInteractionReason();
+		const wasDismissed = tooltipDismissed.value;
+		tooltipInteractionReasons.value[thumb][reason] = true;
+		tooltipDismissed.value = false;
+		if (!wasActive || wasDismissed) syncTooltip();
+	}
+	function endTooltipInteraction(thumb, reason) {
+		tooltipInteractionReasons.value[thumb][reason] = false;
+		if (!hasAnyTooltipInteractionReason()) syncTooltip();
+	}
+	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;
+		const currentReasons = tooltipInteractionReasons.value[thumb];
+		if (currentReasons.focus) {
+			currentReasons.focus = false;
+			tooltipInteractionReasons.value[nextThumb].focus = true;
+		}
+		nextInput.focus({ preventScroll: true });
+	}
+	function resetTooltipInteractionReasons(thumb) {
+		const reasons = tooltipInteractionReasons.value[thumb];
+		reasons.focus = false;
+		reasons.drag = false;
+	}
+	function clearTooltipInteractions(thumb) {
+		resetTooltipInteractionReasons(thumb);
+		syncTooltip();
+	}
+	function resumeDismissedTooltip(thumb) {
+		activeThumb.value = thumb;
+		if (!tooltipDismissed.value) return;
+		tooltipDismissed.value = false;
+		syncTooltip();
+	}
+	function dismissTooltip() {
+		tooltipDismissed.value = true;
+		delayedTooltip.closeImmediate();
+	}
+	function onTooltipFocus(thumb) {
+		startTooltipInteraction(thumb, "focus");
+	}
+	function onTooltipBlur(thumb) {
+		endTooltipInteraction(thumb, "focus");
+	}
+	function onTooltipTrackMouseEnter() {
+		const wasActive = hasAnyTooltipInteractionReason();
+		const wasDismissed = tooltipDismissed.value;
+		tooltipTrackHovered.value = true;
+		tooltipDismissed.value = false;
+		if (!wasActive || wasDismissed) syncTooltip();
+	}
+	function onTooltipTrackMouseLeave() {
+		tooltipTrackHovered.value = false;
+		if (!hasAnyTooltipInteractionReason()) syncTooltip();
+	}
+	function openTooltip(thumb) {
+		startTooltipInteraction(thumb, "focus");
+	}
+	function closeTooltip(thumb) {
+		if (thumb) {
+			clearTooltipInteractions(thumb);
+			return;
+		}
+		resetTooltipInteractionReasons("lower");
+		resetTooltipInteractionReasons("upper");
+		tooltipTrackHovered.value = false;
+		syncTooltip();
+	}
+	function onTooltipKeydown(thumb, event) {
+		activeThumb.value = thumb;
+		if (event.key === "Escape") {
+			dismissTooltip();
+			return;
+		}
+		resumeDismissedTooltip(thumb);
+		if (!hasManualNativeKeyboard.value || valueStep.value === "any") return;
+		const index = getThumbIndex(thumb);
+		const currentValue = normalizedValue.value[index];
+		const pageStep = valueStep.value * 10;
+		let nextValue;
+		switch (event.key) {
+			case "ArrowRight":
+			case "ArrowUp":
+				nextValue = currentValue + valueStep.value;
+				break;
+			case "ArrowLeft":
+			case "ArrowDown":
+				nextValue = currentValue - valueStep.value;
+				break;
+			case "PageUp":
+				nextValue = currentValue + pageStep;
+				break;
+			case "PageDown":
+				nextValue = currentValue - pageStep;
+				break;
+			case "Home":
+				nextValue = nativeMin.value[index];
+				break;
+			case "End":
+				nextValue = nativeMax.value[index];
+				break;
+		}
+		if (nextValue == null) return;
+		event.preventDefault();
+		const nextThumb = updateThumb(thumb, nextValue);
+		transferFocusedThumb(event.target, thumb, nextThumb);
+	}
+	function getValueFromPointer(event, track) {
+		const vertical = props.orientation === "vertical";
+		const trackRect = track.getBoundingClientRect();
+		const thumbsRect = track.querySelector(".rp-range-slider__thumbs")?.getBoundingClientRect();
+		const rect = thumbsRect && (vertical ? thumbsRect.height > 0 : thumbsRect.width > 0) ? thumbsRect : trackRect;
+		const length = vertical ? rect.height : rect.width;
+		if (length <= 0) return void 0;
+		const ratio = clamp((vertical ? rect.bottom - event.clientY : event.clientX - rect.left) / length, 0, 1);
+		return bounds.value.min + ratio * (bounds.value.max - bounds.value.min);
+	}
+	let dragWindow = null;
+	let dragTrack = null;
+	let dragThumb = null;
+	let dragAnchorValue = null;
+	let dragPointerId;
+	function stopDragging() {
+		const stoppedThumb = dragThumb;
+		if (dragWindow) {
+			dragWindow.removeEventListener("pointermove", onPointerMove);
+			dragWindow.removeEventListener("pointerup", onPointerEnd);
+			dragWindow.removeEventListener("pointercancel", onPointerEnd);
+		}
+		dragWindow = null;
+		dragTrack = null;
+		dragThumb = null;
+		dragAnchorValue = null;
+		dragPointerId = void 0;
+		if (stoppedThumb) endTooltipInteraction(stoppedThumb, "drag");
+	}
+	function switchDraggingThumb(track, nextThumb) {
+		const previousThumb = dragThumb;
+		if (!previousThumb || previousThumb === nextThumb) return;
+		tooltipInteractionReasons.value[previousThumb].drag = false;
+		tooltipInteractionReasons.value[nextThumb].drag = true;
+		dragThumb = nextThumb;
+		activeThumb.value = nextThumb;
+		const previousInput = getThumbInput(track, previousThumb);
+		if (previousInput) transferFocusedThumb(previousInput, previousThumb, nextThumb);
+	}
+	function updateFromPointer(event, track) {
+		const value = getValueFromPointer(event, track);
+		if (value == null || !dragThumb) return;
+		switchDraggingThumb(track, updateThumb(dragThumb, value, dragAnchorValue ?? normalizedValue.value[getThumbIndex(getOppositeThumb(dragThumb))]));
+	}
+	function onPointerMove(event) {
+		if (dragPointerId !== void 0 && event.pointerId !== dragPointerId) return;
+		if (!dragTrack || !dragThumb) {
+			stopDragging();
+			return;
+		}
+		updateFromPointer(event, dragTrack);
+	}
+	function onPointerEnd(event) {
+		if (dragPointerId !== void 0 && event.pointerId !== dragPointerId) return;
+		stopDragging();
+	}
+	function onTrackPointerDown(event) {
+		if (control.disabled || event.button !== 0 || event.isPrimary === false) return;
+		const track = event.currentTarget;
+		if (!track) return;
+		const pointerValue = getValueFromPointer(event, track);
+		if (pointerValue == null) return;
+		const thumb = getThumbFromTarget(event.target) ?? getClosestRangeSliderThumb(pointerValue, normalizedValue.value, activeThumb.value);
+		event.preventDefault();
+		stopDragging();
+		activeThumb.value = thumb;
+		focusThumb(track, thumb);
+		dragTrack = track;
+		dragThumb = thumb;
+		dragAnchorValue = normalizedValue.value[getThumbIndex(getOppositeThumb(thumb))];
+		dragPointerId = Number.isFinite(event.pointerId) ? event.pointerId : void 0;
+		dragWindow = track.ownerDocument.defaultView;
+		startTooltipInteraction(thumb, "drag");
+		updateFromPointer(event, track);
+		dragWindow?.addEventListener("pointermove", onPointerMove);
+		dragWindow?.addEventListener("pointerup", onPointerEnd);
+		dragWindow?.addEventListener("pointercancel", onPointerEnd);
+	}
+	watch([tooltipMode, () => control.disabled], () => {
+		syncTooltip();
+	});
+	onBeforeUnmount(stopDragging);
+	return {
+		control,
+		nativeMin,
+		nativeMax,
+		nativeStep,
+		nativeNames,
+		nativeIds,
+		rootClass,
+		normalizedValue,
+		valuePercent,
+		formattedValue,
+		ariaLabels,
+		ariaValueText,
+		markItems,
+		trackStyle,
+		activeThumb,
+		tooltipVisible,
+		tooltipOpen,
+		tooltipPlacement,
+		tooltipIds,
+		mergedTooltipId,
+		tooltipColor,
+		tooltipOffset,
+		tooltipOpenDelay,
+		tooltipArrow,
+		tooltipContent,
+		mergedTooltipContent,
+		onInput,
+		onTrackPointerDown,
+		onTooltipFocus,
+		onTooltipBlur,
+		onTooltipTrackMouseEnter,
+		onTooltipTrackMouseLeave,
+		openTooltip,
+		closeTooltip,
+		onTooltipKeydown
+	};
+}
+//#endregion
+//#region src/components/slider/useRangeSliderTooltipCollision.ts
+var TOOLTIP_COLLISION_GAP = 4;
+var TOOLTIP_COLLISION_RELEASE_GAP = 8;
+var TOOLTIP_CONTENT_SELECTOR$1 = ".rp-tooltip__content";
+function areRangeSliderTooltipRectsOverlapping(lower, upper, gap = TOOLTIP_COLLISION_GAP) {
+	if (lower.width <= 0 || lower.height <= 0 || upper.width <= 0 || upper.height <= 0) return false;
+	return lower.left < upper.right + gap && lower.right + gap > upper.left && lower.top < upper.bottom + gap && lower.bottom + gap > upper.top;
+}
+function useRangeSliderTooltipCollision(root) {
+	const tooltipsOverlapping = ref(false);
+	const observedElements = /* @__PURE__ */ new Set();
+	let resizeObserver;
+	let frameWindow;
+	let frameId;
+	let microtaskQueued = false;
+	let destroyed = false;
+	function setOverlapping(value) {
+		if (tooltipsOverlapping.value !== value) tooltipsOverlapping.value = value;
+	}
+	function getTooltipContents(el) {
+		return [el.querySelector(`.rp-range-slider__tooltip--lower ${TOOLTIP_CONTENT_SELECTOR$1}`), el.querySelector(`.rp-range-slider__tooltip--upper ${TOOLTIP_CONTENT_SELECTOR$1}`)];
+	}
+	function measure() {
+		if (destroyed) return;
+		const el = root.value;
+		if (!el) {
+			setOverlapping(false);
+			return;
+		}
+		const [lower, upper] = getTooltipContents(el);
+		if (!lower || !upper) {
+			setOverlapping(false);
+			return;
+		}
+		const view = el.ownerDocument.defaultView;
+		if (!view || view.getComputedStyle(lower).display === "none" || view.getComputedStyle(upper).display === "none") {
+			setOverlapping(false);
+			return;
+		}
+		setOverlapping(areRangeSliderTooltipRectsOverlapping(lower.getBoundingClientRect(), upper.getBoundingClientRect(), tooltipsOverlapping.value ? TOOLTIP_COLLISION_RELEASE_GAP : TOOLTIP_COLLISION_GAP));
+	}
+	function scheduleMeasure() {
+		if (destroyed || frameId != null || microtaskQueued) return;
+		const view = root.value?.ownerDocument.defaultView;
+		if (view?.requestAnimationFrame) {
+			frameWindow = view;
+			frameId = view.requestAnimationFrame(() => {
+				frameId = void 0;
+				frameWindow = void 0;
+				measure();
+			});
+			return;
+		}
+		microtaskQueued = true;
+		queueMicrotask(() => {
+			microtaskQueued = false;
+			measure();
+		});
+	}
+	function refreshObservedElements() {
+		if (!resizeObserver) return;
+		const el = root.value;
+		const nextElements = /* @__PURE__ */ new Set();
+		if (el) {
+			nextElements.add(el);
+			for (const tooltip of getTooltipContents(el)) if (tooltip) nextElements.add(tooltip);
+		}
+		for (const observed of observedElements) if (!nextElements.has(observed)) resizeObserver.unobserve(observed);
+		for (const next of nextElements) if (!observedElements.has(next)) resizeObserver.observe(next);
+		observedElements.clear();
+		for (const next of nextElements) observedElements.add(next);
+	}
+	function onWindowResize() {
+		scheduleMeasure();
+	}
+	onMounted(() => {
+		const view = root.value?.ownerDocument.defaultView;
+		if (view?.ResizeObserver) resizeObserver = new view.ResizeObserver(scheduleMeasure);
+		view?.addEventListener("resize", onWindowResize);
+		refreshObservedElements();
+		scheduleMeasure();
+	});
+	onUpdated(() => {
+		refreshObservedElements();
+		scheduleMeasure();
+	});
+	onBeforeUnmount(() => {
+		destroyed = true;
+		(root.value?.ownerDocument.defaultView)?.removeEventListener("resize", onWindowResize);
+		resizeObserver?.disconnect();
+		observedElements.clear();
+		if (frameId != null) frameWindow?.cancelAnimationFrame(frameId);
+	});
+	return { tooltipsOverlapping };
+}
+//#endregion
+//#region src/components/slider/useRangeSliderTooltipTransition.ts
+var DEFAULT_TRANSITION_DURATION = 150;
+var DEFAULT_TRANSITION_EASING = "ease";
+var TOOLTIP_CONTENT_SELECTOR = ".rp-tooltip__content";
+var TRANSITION_EASING_PATTERN = /(?:cubic-bezier|linear|steps)\([^)]*\)|\b(?:ease-in-out|ease-in|ease-out|ease|linear|step-end|step-start)\b/;
+function getTooltip(root, kind) {
+	return root.querySelector(`.rp-range-slider__tooltip--${kind}`);
+}
+function getTooltipCenter(tooltip) {
+	const content = tooltip.querySelector(TOOLTIP_CONTENT_SELECTOR);
+	if (!content) return;
+	const rect = content.getBoundingClientRect();
+	if (rect.width <= 0 || rect.height <= 0) return;
+	return {
+		x: rect.left + rect.width / 2,
+		y: rect.top + rect.height / 2
+	};
+}
+function getTooltipSnapshot(tooltip) {
+	const center = getTooltipCenter(tooltip);
+	if (!center) return;
+	const opacity = Number.parseFloat(tooltip.ownerDocument.defaultView.getComputedStyle(tooltip).opacity);
+	return {
+		center,
+		opacity: Number.isFinite(opacity) ? opacity : 0
+	};
+}
+function getCarrierKind(root) {
+	return root.dataset.activeThumb === "lower" ? "upper" : "lower";
+}
+function getTransitionOptions(root) {
+	const transition = root.ownerDocument.defaultView.getComputedStyle(root).getPropertyValue("--rp-transition-fast").trim();
+	const durationMatch = transition.match(/([\d.]+)(ms|s)/);
+	if (!durationMatch) return {
+		duration: DEFAULT_TRANSITION_DURATION,
+		easing: DEFAULT_TRANSITION_EASING
+	};
+	const durationValue = Number.parseFloat(durationMatch[1]);
+	return {
+		duration: durationMatch[2] === "s" ? durationValue * 1e3 : durationValue,
+		easing: transition.match(TRANSITION_EASING_PATTERN)?.[0] ?? DEFAULT_TRANSITION_EASING
+	};
+}
+function prefersReducedMotion(root) {
+	return root.ownerDocument.defaultView?.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+}
+function getTranslate(from, base) {
+	return `translate3d(${from.x - base.x}px, ${from.y - base.y}px, 0)`;
+}
+function useRangeSliderTooltipTransition(root, tooltipsOverlapping, value, activeThumb) {
+	const animations = /* @__PURE__ */ new Set();
+	let inferredCarrier;
+	let frozenMergedContent;
+	let frozenMergedTooltip;
+	let heldSplitOpacity = [];
+	let transitionId = 0;
+	watch(activeThumb, () => {
+		inferredCarrier = void 0;
+	}, { flush: "sync" });
+	watch(value, (next, previous) => {
+		const lowerMoved = next[0] !== previous[0];
+		if (lowerMoved !== (next[1] !== previous[1])) inferredCarrier = lowerMoved ? "upper" : "lower";
+		else inferredCarrier = void 0;
+	}, { flush: "sync" });
+	function clearFrozenMergedPosition() {
+		if (frozenMergedTooltip) {
+			frozenMergedTooltip.style.removeProperty("left");
+			frozenMergedTooltip.style.removeProperty("top");
+		}
+		if (frozenMergedContent) {
+			const { element, height, width } = frozenMergedContent;
+			if (width) element.style.width = width;
+			else element.style.removeProperty("width");
+			if (height) element.style.height = height;
+			else element.style.removeProperty("height");
+		}
+		frozenMergedTooltip = void 0;
+		frozenMergedContent = void 0;
+	}
+	function freezeMergedPosition(merged) {
+		const style = merged.ownerDocument.defaultView.getComputedStyle(merged);
+		const content = merged.querySelector(TOOLTIP_CONTENT_SELECTOR);
+		merged.style.left = style.left;
+		merged.style.top = style.top;
+		frozenMergedTooltip = merged;
+		if (content) {
+			const rect = content.getBoundingClientRect();
+			frozenMergedContent = {
+				element: content,
+				height: content.style.height,
+				width: content.style.width
+			};
+			content.style.width = `${rect.width}px`;
+			content.style.height = `${rect.height}px`;
+		}
+	}
+	function clearHeldSplitOpacity() {
+		for (const { element, opacity } of heldSplitOpacity) if (opacity) element.style.opacity = opacity;
+		else element.style.removeProperty("opacity");
+		heldSplitOpacity = [];
+	}
+	function holdSplitOpacity(merged, endpoints) {
+		heldSplitOpacity = [merged, ...endpoints].map((element) => ({
+			element,
+			opacity: element.style.opacity
+		}));
+		merged.style.opacity = "1";
+		for (const endpoint of endpoints) endpoint.style.opacity = "0";
+	}
+	function cancelAnimations() {
+		for (const animation of animations) animation.cancel();
+		animations.clear();
+	}
+	function animate(element, keyframes, options, onComplete) {
+		let animation;
+		try {
+			animation = element.animate(keyframes, options);
+		} catch {
+			try {
+				animation = element.animate(keyframes, {
+					duration: DEFAULT_TRANSITION_DURATION,
+					easing: DEFAULT_TRANSITION_EASING
+				});
+			} catch {
+				onComplete?.();
+				return;
+			}
+		}
+		animations.add(animation);
+		let completed = false;
+		const removeAnimation = () => {
+			if (completed) return;
+			completed = true;
+			animations.delete(animation);
+			onComplete?.();
+		};
+		animation.addEventListener("cancel", removeAnimation, { once: true });
+		animation.addEventListener("finish", removeAnimation, { once: true });
+	}
+	watch(tooltipsOverlapping, async (overlapping) => {
+		const el = root.value;
+		if (!el) return;
+		const lower = getTooltip(el, "lower");
+		const upper = getTooltip(el, "upper");
+		const merged = getTooltip(el, "merged");
+		const carrier = getTooltip(el, inferredCarrier ?? getCarrierKind(el));
+		inferredCarrier = void 0;
+		if (!lower || !upper || !merged || !carrier) return;
+		const snapshots = /* @__PURE__ */ new Map();
+		for (const tooltip of [
+			lower,
+			upper,
+			merged
+		]) {
+			const snapshot = getTooltipSnapshot(tooltip);
+			if (snapshot) snapshots.set(tooltip, snapshot);
+		}
+		const carrierSnapshot = snapshots.get(carrier);
+		const mergedSnapshot = snapshots.get(merged);
+		const currentTransitionId = ++transitionId;
+		await nextTick();
+		if (currentTransitionId !== transitionId || root.value !== el) return;
+		cancelAnimations();
+		clearFrozenMergedPosition();
+		clearHeldSplitOpacity();
+		if (typeof merged.animate !== "function" || prefersReducedMotion(el)) return;
+		const { duration, easing } = getTransitionOptions(el);
+		if (duration <= 0) return;
+		if (!overlapping) {
+			freezeMergedPosition(merged);
+			holdSplitOpacity(merged, [lower, upper]);
+		}
+		const mergedBaseCenter = getTooltipCenter(merged);
+		const carrierCenter = getTooltipCenter(carrier);
+		if (!mergedBaseCenter || !carrierCenter) {
+			clearFrozenMergedPosition();
+			clearHeldSplitOpacity();
+			return;
+		}
+		const options = {
+			duration,
+			easing
+		};
+		const releaseFrozenPosition = overlapping ? void 0 : () => {
+			if (currentTransitionId !== transitionId) return;
+			clearFrozenMergedPosition();
+			clearHeldSplitOpacity();
+		};
+		const mergedStartCenter = mergedSnapshot && mergedSnapshot.opacity > 0 ? mergedSnapshot.center : carrierSnapshot?.center ?? carrierCenter;
+		const mergedEndCenter = overlapping ? mergedBaseCenter : carrierCenter;
+		animate(merged, [{ transform: getTranslate(mergedStartCenter, mergedBaseCenter) }, { transform: getTranslate(mergedEndCenter, mergedBaseCenter) }], options, releaseFrozenPosition);
+	}, { flush: "pre" });
+	onBeforeUnmount(() => {
+		transitionId += 1;
+		cancelAnimations();
+		clearFrozenMergedPosition();
+		clearHeldSplitOpacity();
+	});
+}
+//#endregion
+//#region src/components/slider/range-slider.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span data-v-3fdd312a class=rp-range-slider__label>");
+var t1 = template("<span data-v-3fdd312a class=rp-range-slider__value aria-hidden=true>");
+var t2 = template("<span data-v-3fdd312a class=rp-range-slider__header>");
+var t3 = template("<span data-v-3fdd312a class=rp-range-slider__mark-label> ");
+var t4 = template("<span data-v-3fdd312a><span data-v-3fdd312a class=rp-range-slider__mark-dot></span>");
+var t5 = template("<span data-v-3fdd312a class=rp-range-slider__marks aria-hidden=true>");
+var t6 = template("<span data-v-3fdd312a class=rp-range-slider__tooltip-anchor>", 2);
+var t7 = template("<div data-v-3fdd312a role=group><span data-v-3fdd312a class=rp-range-slider__track><span data-v-3fdd312a class=rp-range-slider__bar aria-hidden=true></span><input data-v-3fdd312a class=\"rp-range-slider__native rp-range-slider__native--lower\"type=range><input data-v-3fdd312a class=\"rp-range-slider__native rp-range-slider__native--upper\"type=range><!><span data-v-3fdd312a class=rp-range-slider__thumbs aria-hidden=true><span data-v-3fdd312a class=\"rp-range-slider__thumb rp-range-slider__thumb--lower\"data-range-slider-thumb=lower><span data-v-3fdd312a class=rp-range-slider__thumb-content></span></span><span data-v-3fdd312a class=\"rp-range-slider__thumb rp-range-slider__thumb--upper\"data-range-slider-thumb=upper><span data-v-3fdd312a class=rp-range-slider__thumb-content>", 1);
+delegateEvents("input", "keydown", "pointerdown");
+//#endregion
+//#region src/components/slider/range-slider.vue
+var range_slider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpRangeSlider",
+	__name: "range-slider",
+	props: {
+		modelValue: {},
+		minRange: { default: 0 },
+		name: {},
+		ariaLabel: { default: () => ["Minimum", "Maximum"] },
+		ariaValueText: {},
+		id: {},
+		min: { default: 0 },
+		max: { default: 100 },
+		step: { default: 1 },
+		marks: { default: () => [] },
+		thumbStyle: {},
+		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
+		},
+		valid: {
+			type: Boolean,
+			default: void 0
+		},
+		describedby: {},
+		labelledby: {}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit, slots: $slots }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const generatedId = useId();
+		const rangeSliderRef = ref(null);
+		const labelId = computed(() => `${props.id ?? generatedId}-label`);
+		const { control, nativeMin, nativeMax, nativeStep, nativeNames, nativeIds, rootClass, normalizedValue, valuePercent, formattedValue, ariaLabels, ariaValueText, markItems, trackStyle, activeThumb, tooltipVisible, tooltipOpen, tooltipPlacement, tooltipIds, mergedTooltipId, tooltipColor, tooltipOffset, tooltipOpenDelay, tooltipArrow, tooltipContent, mergedTooltipContent, onInput, onTrackPointerDown, onTooltipFocus, onTooltipBlur, onTooltipTrackMouseEnter, onTooltipTrackMouseLeave, onTooltipKeydown } = useRangeSlider(props, (value) => {
+			emit("update:modelValue", value);
+		});
+		const { tooltipsOverlapping } = useRangeSliderTooltipCollision(rangeSliderRef);
+		useRangeSliderTooltipTransition(rangeSliderRef, tooltipsOverlapping, normalizedValue, activeThumb);
+		const groupLabelledby = computed(() => {
+			const values = [control.ariaLabelledby, slots.default ? labelId.value : void 0].flatMap((value) => value?.split(/\s+/) ?? []).filter(Boolean);
+			return values.length ? Array.from(new Set(values)).join(" ") : void 0;
+		});
+		const _setTemplateRef = createTemplateRefSetter();
+		const n43 = t7();
+		const n42 = child(n43, 1);
+		const n11 = next(child(n42), 1);
+		const n12 = next(n11, 2);
+		const n41 = next(n12, 3);
+		const n40 = next(n41, 4);
+		const n28 = child(n40);
+		const n23 = child(n28);
+		const n35 = next(n28, 1);
+		const n30 = child(n35);
+		renderEffect(() => {
+			const _control = unref(control);
+			setClass(n43, [unref(rootClass), {
+				"rp-range-slider--custom-thumb": $slots.thumb,
+				"rp-range-slider--tooltips-overlapping": unref(tooltipsOverlapping)
+			}]);
+			setAttr(n43, "data-active-thumb", unref(activeThumb));
+			setAttr(n43, "data-disabled", _control.disabled || void 0);
+			setStyle(n43, unref(trackStyle));
+			setAttr(n43, "aria-labelledby", groupLabelledby.value);
+			setAttr(n43, "aria-describedby", _control.ariaDescribedby);
+			setAttr(n43, "aria-invalid", _control.invalid || void 0);
+			setAttr(n43, "aria-required", _control.required || void 0);
+		});
+		setInsertionState(n43, 0, 0);
+		createIf(() => $slots.default || $slots.value, () => {
+			const n10 = t2();
+			setInsertionState(n10, null, 0);
+			createIf(() => $slots.default, () => {
+				const n5 = t0();
+				renderEffect(() => setProp(n5, "id", labelId.value));
+				setInsertionState(n5, null, 0);
+				createSlot("default", null, null, 1);
+				return n5;
+			});
+			setInsertionState(n10, null, 1);
+			createIf(() => $slots.value, () => {
+				const n9 = t1();
+				setInsertionState(n9, null, 0);
+				createSlot("value", {
+					value: () => unref(normalizedValue),
+					formattedValue: () => unref(formattedValue),
+					percent: () => unref(valuePercent)
+				}, null, 1);
+				return n9;
+			});
+			return n10;
+		});
+		n11.$evtinput = createInvoker(($event) => unref(onInput)("lower", $event));
+		on(n11, "focus", () => unref(onTooltipFocus)("lower"));
+		on(n11, "blur", () => unref(onTooltipBlur)("lower"));
+		n11.$evtkeydown = createInvoker(($event) => unref(onTooltipKeydown)("lower", $event));
+		n12.$evtinput = createInvoker(($event) => unref(onInput)("upper", $event));
+		on(n12, "focus", () => unref(onTooltipFocus)("upper"));
+		on(n12, "blur", () => unref(onTooltipBlur)("upper"));
+		n12.$evtkeydown = createInvoker(($event) => unref(onTooltipKeydown)("upper", $event));
+		renderEffect(() => {
+			const _nativeIds = unref(nativeIds);
+			const _nativeNames = unref(nativeNames);
+			const _normalizedValue = unref(normalizedValue);
+			const _nativeMin = unref(nativeMin);
+			const _nativeMax = unref(nativeMax);
+			const _nativeStep = unref(nativeStep);
+			const _control = unref(control);
+			const _ariaLabels = unref(ariaLabels);
+			const _ariaValueText = unref(ariaValueText);
+			const _control_disabled = _control.disabled;
+			const _control_required = _control.required;
+			const _control_ariaDescribedby = _control.ariaDescribedby;
+			const _control_invalid = _control.invalid;
+			setProp(n11, "id", _nativeIds[0]);
+			setProp(n11, "name", _nativeNames[0]);
+			setValue(n11, _normalizedValue[0]);
+			setProp(n11, "min", _nativeMin[0]);
+			setProp(n11, "max", _nativeMax[0]);
+			setProp(n11, "step", _nativeStep);
+			setProp(n11, "orient", __props.orientation === "vertical" ? "vertical" : void 0);
+			setProp(n11, "disabled", _control_disabled || void 0);
+			setProp(n11, "required", _control_required || void 0);
+			setAttr(n11, "aria-label", _ariaLabels[0]);
+			setAttr(n11, "aria-describedby", _control_ariaDescribedby);
+			setAttr(n11, "aria-orientation", __props.orientation === "vertical" ? "vertical" : void 0);
+			setAttr(n11, "aria-invalid", _control_invalid || void 0);
+			setAttr(n11, "aria-required", _control_required || void 0);
+			setAttr(n11, "aria-valuetext", _ariaValueText[0]);
+			setProp(n12, "id", _nativeIds[1]);
+			setProp(n12, "name", _nativeNames[1]);
+			setValue(n12, _normalizedValue[1]);
+			setProp(n12, "min", _nativeMin[1]);
+			setProp(n12, "max", _nativeMax[1]);
+			setProp(n12, "step", _nativeStep);
+			setProp(n12, "orient", __props.orientation === "vertical" ? "vertical" : void 0);
+			setProp(n12, "disabled", _control_disabled || void 0);
+			setProp(n12, "required", _control_required || void 0);
+			setAttr(n12, "aria-label", _ariaLabels[1]);
+			setAttr(n12, "aria-describedby", _control_ariaDescribedby);
+			setAttr(n12, "aria-orientation", __props.orientation === "vertical" ? "vertical" : void 0);
+			setAttr(n12, "aria-invalid", _control_invalid || void 0);
+			setAttr(n12, "aria-required", _control_required || void 0);
+			setAttr(n12, "aria-valuetext", _ariaValueText[1]);
+		});
+		setInsertionState(n42, n41, 3);
+		createIf(() => unref(markItems).length, () => {
+			const n21 = t5();
+			setInsertionState(n21, null, 0);
+			createFor(() => unref(markItems), (_for_item0) => {
+				const n20 = t4();
+				renderEffect(() => {
+					const _mark = _for_item0.value;
+					setClassName(n20, _mark.filled ? 1 : 0, " rp-range-slider__mark--filled", "rp-range-slider__mark");
+					setStyle(n20, _mark.style);
+				});
+				setInsertionState(n20, null, 1);
+				createIf(() => _for_item0.value.hasLabel, () => {
+					const n19 = t3();
+					const x19 = txt(n19);
+					renderEffect(() => setText(x19, toDisplayString(_for_item0.value.label)));
+					return n19;
+				});
+				return n20;
+			}, (mark) => mark.key, 9);
+			return n21;
+		});
+		setInsertionState(n23, null, 0);
+		createSlot("thumb", {
+			thumb: "lower",
+			index: "0",
+			value: () => unref(normalizedValue)[0],
+			formattedValue: () => unref(formattedValue)[0],
+			percent: () => unref(valuePercent)[0]
+		}, null, 1);
+		setInsertionState(n28, null, 1);
+		createIf(() => unref(tooltipVisible), () => {
+			return createComponent(tooltip_default, {
+				id: () => unref(tooltipIds)[0],
+				class: "rp-range-slider__tooltip rp-range-slider__tooltip--lower",
+				content: () => unref(tooltipContent)[0],
+				placement: () => unref(tooltipPlacement),
+				color: () => unref(tooltipColor),
+				offset: () => unref(tooltipOffset),
+				open: () => unref(tooltipOpen),
+				"open-delay": () => unref(tooltipOpenDelay),
+				arrow: () => unref(tooltipArrow),
+				decorative: ""
+			}, () => {
+				return t6();
+			});
+		});
+		setInsertionState(n30, null, 0);
+		createSlot("thumb", {
+			thumb: "upper",
+			index: "1",
+			value: () => unref(normalizedValue)[1],
+			formattedValue: () => unref(formattedValue)[1],
+			percent: () => unref(valuePercent)[1]
+		}, null, 1);
+		setInsertionState(n35, null, 1);
+		createIf(() => unref(tooltipVisible), () => {
+			return createComponent(tooltip_default, {
+				id: () => unref(tooltipIds)[1],
+				class: "rp-range-slider__tooltip rp-range-slider__tooltip--upper",
+				content: () => unref(tooltipContent)[1],
+				placement: () => unref(tooltipPlacement),
+				color: () => unref(tooltipColor),
+				offset: () => unref(tooltipOffset),
+				open: () => unref(tooltipOpen),
+				"open-delay": () => unref(tooltipOpenDelay),
+				arrow: () => unref(tooltipArrow),
+				decorative: ""
+			}, () => {
+				return t6();
+			});
+		});
+		setInsertionState(n40, null, 2);
+		createIf(() => unref(tooltipVisible), () => {
+			return createComponent(tooltip_default, {
+				id: () => unref(mergedTooltipId),
+				class: "rp-range-slider__tooltip rp-range-slider__tooltip--merged",
+				content: () => unref(mergedTooltipContent),
+				placement: () => unref(tooltipPlacement),
+				color: () => unref(tooltipColor),
+				offset: () => unref(tooltipOffset),
+				open: () => unref(tooltipOpen),
+				"open-delay": () => unref(tooltipOpenDelay),
+				arrow: () => unref(tooltipArrow),
+				decorative: ""
+			}, () => {
+				return t6();
+			});
+		});
+		n42.$evtpointerdown = createInvoker((e) => unref(onTrackPointerDown)(e));
+		on(n42, "mouseenter", (e) => unref(onTooltipTrackMouseEnter)(e));
+		on(n42, "mouseleave", (e) => unref(onTooltipTrackMouseLeave)(e));
+		_setTemplateRef(n43, rangeSliderRef, null, "rangeSliderRef");
+		return n43;
+	}
+}), [["__scopeId", "data-v-3fdd312a"]]);
+//#endregion
+//#region src/components/slider/types.ts
+var sliderColors = componentColors;
+var sliderSizes = [
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl"
+];
+var sliderOrientations = ["horizontal", "vertical"];
+//#endregion
+export { slider_default as a, range_slider_default as i, sliderOrientations as n, sliderSizes as r, sliderColors as t };