uomtiles 0.1.0

package/.output/server/chunks/build/Slider-D-n8Y0CX.mjs

@@ -0,0 +1,1087 @@
+import { d as useComponentProps, f as useAppConfig, g as useForwardProps, r as reactivePick, i as useFormField, t as tv, v as useForwardExpose, B as useCollection, w as useVModel, P as Primitive, A as createContext, K as useMounted } from '../virtual/entry.mjs';
+import { u as useFormControl, V as VisuallyHiddenInput_default } from './Alert-0ngTJXxP.mjs';
+import { a as useDirection } from './DashboardSidebarToggle-pncTaIJq.mjs';
+import { d as useSize } from './PopperArrow-Bqfdf2Et.mjs';
+import { _ as _sfc_main$1 } from './Tooltip-CkpSktvJ.mjs';
+import { useModel, computed, unref, mergeProps, withCtx, createVNode, openBlock, createBlock, Fragment, renderList, mergeModels, defineComponent, toRefs, ref, resolveDynamicComponent, renderSlot, createCommentVNode, normalizeStyle, toRaw, useSSRContext } from 'vue';
+import { ssrRenderComponent, ssrRenderList } from 'vue/server-renderer';
+
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/shared/clamp.js
+/**
+* The `clamp` function restricts a number within a specified range by returning the value itself if it
+* falls within the range, or the closest boundary value if it exceeds the range.
+* @param {number} value - The `value` parameter represents the number that you want to clamp within
+* the specified range defined by `min` and `max` values.
+* @param {number} min - If the `value` parameter is less than the `min` value, the
+* function will return the `min` value.
+* @param {number} max - If the `value` parameter is greater than the `max` value,
+* the function will return `max`.
+* @returns The `clamp` function returns the value of `value` constrained within the range defined by
+* `min` and `max`.
+*/
+function clamp(value, min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY) {
+	return Math.min(max, Math.max(min, value));
+}
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/utils.js
+function getNextSortedValues(prevValues = [], nextValue, atIndex) {
+	const nextValues = [...prevValues];
+	nextValues[atIndex] = nextValue;
+	return nextValues.sort((a, b) => a - b);
+}
+function convertValueToPercentage(value, min, max) {
+	return clamp(100 / (max - min) * (value - min), 0, 100);
+}
+/**
+* Returns a label for each thumb when there are two or more thumbs
+*/
+function getLabel(index, totalValues) {
+	if (totalValues > 2) return `Value ${index + 1} of ${totalValues}`;
+	else if (totalValues === 2) return ["Minimum", "Maximum"][index];
+	else return void 0;
+}
+/**
+* Given a `values` array and a `nextValue`, determine which value in
+* the array is closest to `nextValue` and return its index.
+*
+* @example
+* // returns 1
+* getClosestValueIndex([10, 30], 25);
+*/
+function getClosestValueIndex(values, nextValue) {
+	if (values.length === 1) return 0;
+	const distances = values.map((value) => Math.abs(value - nextValue));
+	const closestDistance = Math.min(...distances);
+	return distances.indexOf(closestDistance);
+}
+/**
+* Offsets the thumb centre point while sliding to ensure it remains
+* within the bounds of the slider when reaching the edges
+*/
+function getThumbInBoundsOffset(width, left, direction) {
+	const halfWidth = width / 2;
+	return (halfWidth - linearScale([0, 50], [0, halfWidth])(left) * direction) * direction;
+}
+/**
+* Gets an array of steps between each value.
+*
+* @example
+* // returns [1, 9]
+* getStepsBetweenValues([10, 11, 20]);
+*/
+function getStepsBetweenValues(values) {
+	return values.slice(0, -1).map((value, index) => values[index + 1] - value);
+}
+/**
+* Verifies the minimum steps between all values is greater than or equal
+* to the expected minimum steps.
+*
+* @example
+* // returns false
+* hasMinStepsBetweenValues([1,2,3], 2);
+*
+* @example
+* // returns true
+* hasMinStepsBetweenValues([1,2,3], 1);
+*/
+function hasMinStepsBetweenValues(values, minStepsBetweenValues) {
+	if (minStepsBetweenValues > 0) {
+		const stepsBetweenValues = getStepsBetweenValues(values);
+		return Math.min(...stepsBetweenValues) >= minStepsBetweenValues;
+	}
+	return true;
+}
+function linearScale(input, output) {
+	return (value) => {
+		if (input[0] === input[1] || output[0] === output[1]) return output[0];
+		const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+		return output[0] + ratio * (value - input[0]);
+	};
+}
+function getDecimalCount(value) {
+	return (String(value).split(".")[1] || "").length;
+}
+function roundValue(value, decimalCount) {
+	const rounder = 10 ** decimalCount;
+	return Math.round(value * rounder) / rounder;
+}
+var PAGE_KEYS = ["PageUp", "PageDown"];
+var ARROW_KEYS = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight"
+];
+var BACK_KEYS = {
+	"from-left": [
+		"Home",
+		"PageDown",
+		"ArrowDown",
+		"ArrowLeft"
+	],
+	"from-right": [
+		"Home",
+		"PageDown",
+		"ArrowDown",
+		"ArrowRight"
+	],
+	"from-bottom": [
+		"Home",
+		"PageDown",
+		"ArrowDown",
+		"ArrowLeft"
+	],
+	"from-top": [
+		"Home",
+		"PageUp",
+		"ArrowUp",
+		"ArrowLeft"
+	]
+};
+var [injectSliderOrientationContext, provideSliderOrientationContext] = /*#__PURE__*/ createContext(["SliderVertical", "SliderHorizontal"]);
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderHorizontal.js
+var SliderHorizontal_default = /* @__PURE__ */ defineComponent({
+	__name: "SliderHorizontal",
+	props: {
+		dir: {
+			type: String,
+			required: false
+		},
+		min: {
+			type: Number,
+			required: true
+		},
+		max: {
+			type: Number,
+			required: true
+		},
+		inverted: {
+			type: Boolean,
+			required: true
+		}
+	},
+	emits: [
+		"slideEnd",
+		"slideStart",
+		"slideMove",
+		"homeKeyDown",
+		"endKeyDown",
+		"stepKeyDown"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { max, min, dir, inverted } = toRefs(props);
+		const { forwardRef, currentElement: sliderElement } = useForwardExpose();
+		const rootContext = injectSliderRootContext();
+		const offsetPosition = ref();
+		const rectRef = ref();
+		const isSlidingFromLeft = computed(() => dir?.value !== "rtl" && !inverted.value || dir?.value !== "ltr" && inverted.value);
+		function getValueFromPointerEvent(event, slideStart) {
+			const rect = rectRef.value || sliderElement.value.getBoundingClientRect();
+			const thumb = [...rootContext.thumbElements.value][rootContext.valueIndexToChangeRef.value];
+			const thumbWidth = rootContext.thumbAlignment.value === "contain" ? thumb.clientWidth : 0;
+			if (!offsetPosition.value && !slideStart && rootContext.thumbAlignment.value === "contain") offsetPosition.value = event.clientX - thumb.getBoundingClientRect().left;
+			const value = linearScale([0, rect.width - thumbWidth], isSlidingFromLeft.value ? [min.value, max.value] : [max.value, min.value]);
+			rectRef.value = rect;
+			return value(slideStart ? event.clientX - rect.left - thumbWidth / 2 : event.clientX - rect.left - (offsetPosition.value ?? 0));
+		}
+		provideSliderOrientationContext({
+			startEdge: computed(() => isSlidingFromLeft.value ? "left" : "right"),
+			endEdge: computed(() => isSlidingFromLeft.value ? "right" : "left"),
+			direction: computed(() => isSlidingFromLeft.value ? 1 : -1),
+			size: "width"
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(SliderImpl_default, {
+				ref: unref(forwardRef),
+				dir: unref(dir),
+				"data-orientation": "horizontal",
+				style: normalizeStyle({ ["--reka-slider-thumb-transform"]: !isSlidingFromLeft.value && unref(rootContext).thumbAlignment.value === "overflow" ? "translateX(50%)" : "translateX(-50%)" }),
+				onSlideStart: _cache[0] || (_cache[0] = (event) => {
+					const value = getValueFromPointerEvent(event, true);
+					emits("slideStart", value);
+				}),
+				onSlideMove: _cache[1] || (_cache[1] = (event) => {
+					const value = getValueFromPointerEvent(event);
+					emits("slideMove", value);
+				}),
+				onSlideEnd: _cache[2] || (_cache[2] = () => {
+					rectRef.value = void 0;
+					offsetPosition.value = void 0;
+					emits("slideEnd");
+				}),
+				onStepKeyDown: _cache[3] || (_cache[3] = (event) => {
+					const slideDirection = isSlidingFromLeft.value ? "from-left" : "from-right";
+					const isBackKey = unref(BACK_KEYS)[slideDirection].includes(event.key);
+					emits("stepKeyDown", event, isBackKey ? -1 : 1);
+				}),
+				onEndKeyDown: _cache[4] || (_cache[4] = ($event) => emits("endKeyDown", $event)),
+				onHomeKeyDown: _cache[5] || (_cache[5] = ($event) => emits("homeKeyDown", $event))
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["dir", "style"]);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderVertical.js
+var SliderVertical_default = /* @__PURE__ */ defineComponent({
+	__name: "SliderVertical",
+	props: {
+		min: {
+			type: Number,
+			required: true
+		},
+		max: {
+			type: Number,
+			required: true
+		},
+		inverted: {
+			type: Boolean,
+			required: true
+		}
+	},
+	emits: [
+		"slideEnd",
+		"slideStart",
+		"slideMove",
+		"homeKeyDown",
+		"endKeyDown",
+		"stepKeyDown"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { max, min, inverted } = toRefs(props);
+		const rootContext = injectSliderRootContext();
+		const { forwardRef, currentElement: sliderElement } = useForwardExpose();
+		const offsetPosition = ref();
+		const rectRef = ref();
+		const isSlidingFromBottom = computed(() => !inverted.value);
+		function getValueFromPointerEvent(event, slideStart) {
+			const rect = rectRef.value || sliderElement.value.getBoundingClientRect();
+			const thumb = [...rootContext.thumbElements.value][rootContext.valueIndexToChangeRef.value];
+			const thumbHeight = rootContext.thumbAlignment.value === "contain" ? thumb.clientHeight : 0;
+			if (!offsetPosition.value && !slideStart && rootContext.thumbAlignment.value === "contain") offsetPosition.value = event.clientY - thumb.getBoundingClientRect().top;
+			const value = linearScale([0, rect.height - thumbHeight], isSlidingFromBottom.value ? [max.value, min.value] : [min.value, max.value]);
+			const position = slideStart ? event.clientY - rect.top - thumbHeight / 2 : event.clientY - rect.top - (offsetPosition.value ?? 0);
+			rectRef.value = rect;
+			return value(position);
+		}
+		provideSliderOrientationContext({
+			startEdge: computed(() => isSlidingFromBottom.value ? "bottom" : "top"),
+			endEdge: computed(() => isSlidingFromBottom.value ? "top" : "bottom"),
+			direction: computed(() => isSlidingFromBottom.value ? 1 : -1),
+			size: "height"
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(SliderImpl_default, {
+				ref: unref(forwardRef),
+				"data-orientation": "vertical",
+				style: normalizeStyle({ ["--reka-slider-thumb-transform"]: !isSlidingFromBottom.value && unref(rootContext).thumbAlignment.value === "overflow" ? "translateY(-50%)" : "translateY(50%)" }),
+				onSlideStart: _cache[0] || (_cache[0] = (event) => {
+					const value = getValueFromPointerEvent(event, true);
+					emits("slideStart", value);
+				}),
+				onSlideMove: _cache[1] || (_cache[1] = (event) => {
+					const value = getValueFromPointerEvent(event);
+					emits("slideMove", value);
+				}),
+				onSlideEnd: _cache[2] || (_cache[2] = () => {
+					rectRef.value = void 0;
+					offsetPosition.value = void 0;
+					emits("slideEnd");
+				}),
+				onStepKeyDown: _cache[3] || (_cache[3] = (event) => {
+					const slideDirection = isSlidingFromBottom.value ? "from-bottom" : "from-top";
+					const isBackKey = unref(BACK_KEYS)[slideDirection].includes(event.key);
+					emits("stepKeyDown", event, isBackKey ? -1 : 1);
+				}),
+				onEndKeyDown: _cache[4] || (_cache[4] = ($event) => emits("endKeyDown", $event)),
+				onHomeKeyDown: _cache[5] || (_cache[5] = ($event) => emits("homeKeyDown", $event))
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["style"]);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderRoot.js
+var [injectSliderRootContext, provideSliderRootContext] = /*#__PURE__*/ createContext("SliderRoot");
+var SliderRoot_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "SliderRoot",
+	props: {
+		defaultValue: {
+			type: Array,
+			required: false,
+			default: () => [0]
+		},
+		modelValue: {
+			type: [Array, null],
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: "horizontal"
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		inverted: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		min: {
+			type: Number,
+			required: false,
+			default: 0
+		},
+		max: {
+			type: Number,
+			required: false,
+			default: 100
+		},
+		step: {
+			type: Number,
+			required: false,
+			default: 1
+		},
+		minStepsBetweenThumbs: {
+			type: Number,
+			required: false,
+			default: 0
+		},
+		thumbAlignment: {
+			type: String,
+			required: false,
+			default: "contain"
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		}
+	},
+	emits: ["update:modelValue", "valueCommit"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { min, max, step, minStepsBetweenThumbs, orientation, disabled, thumbAlignment, dir: propDir } = toRefs(props);
+		const dir = useDirection(propDir);
+		const { forwardRef, currentElement } = useForwardExpose();
+		const isFormControl = useFormControl(currentElement);
+		const { CollectionSlot } = useCollection({ isProvider: true });
+		const modelValue = useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue,
+			passive: props.modelValue === void 0
+		});
+		const currentModelValue = computed(() => Array.isArray(modelValue.value) ? [...modelValue.value] : []);
+		const valueIndexToChangeRef = ref(0);
+		const valuesBeforeSlideStartRef = ref(currentModelValue.value);
+		function handleSlideStart(value) {
+			updateValues(value, getClosestValueIndex(currentModelValue.value, value));
+		}
+		function handleSlideMove(value) {
+			updateValues(value, valueIndexToChangeRef.value);
+		}
+		function handleSlideEnd() {
+			const prevValue = valuesBeforeSlideStartRef.value[valueIndexToChangeRef.value];
+			if (currentModelValue.value[valueIndexToChangeRef.value] !== prevValue) emits("valueCommit", toRaw(currentModelValue.value));
+		}
+		function updateValues(value, atIndex, { commit } = { commit: false }) {
+			const decimalCount = getDecimalCount(step.value);
+			const nextValue = clamp(roundValue(Math.round((value - min.value) / step.value) * step.value + min.value, decimalCount), min.value, max.value);
+			const nextValues = getNextSortedValues(currentModelValue.value, nextValue, atIndex);
+			if (hasMinStepsBetweenValues(nextValues, minStepsBetweenThumbs.value * step.value)) {
+				valueIndexToChangeRef.value = nextValues.indexOf(nextValue);
+				const hasChanged = String(nextValues) !== String(modelValue.value);
+				if (hasChanged && commit) emits("valueCommit", nextValues);
+				if (hasChanged) {
+					thumbElements.value[valueIndexToChangeRef.value]?.focus();
+					modelValue.value = nextValues;
+				}
+			}
+		}
+		const thumbElements = ref([]);
+		provideSliderRootContext({
+			modelValue,
+			currentModelValue,
+			valueIndexToChangeRef,
+			thumbElements,
+			orientation,
+			min,
+			max,
+			disabled,
+			thumbAlignment
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(CollectionSlot), null, {
+				default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(unref(orientation) === "horizontal" ? SliderHorizontal_default : SliderVertical_default), mergeProps(_ctx.$attrs, {
+					ref: unref(forwardRef),
+					"as-child": _ctx.asChild,
+					as: _ctx.as,
+					min: unref(min),
+					max: unref(max),
+					dir: unref(dir),
+					inverted: _ctx.inverted,
+					"aria-disabled": unref(disabled),
+					"data-disabled": unref(disabled) ? "" : void 0,
+					onPointerdown: _cache[0] || (_cache[0] = () => {
+						if (!unref(disabled)) valuesBeforeSlideStartRef.value = currentModelValue.value;
+					}),
+					onSlideStart: _cache[1] || (_cache[1] = ($event) => !unref(disabled) && handleSlideStart($event)),
+					onSlideMove: _cache[2] || (_cache[2] = ($event) => !unref(disabled) && handleSlideMove($event)),
+					onSlideEnd: _cache[3] || (_cache[3] = ($event) => !unref(disabled) && handleSlideEnd()),
+					onHomeKeyDown: _cache[4] || (_cache[4] = ($event) => !unref(disabled) && updateValues(unref(min), 0, { commit: true })),
+					onEndKeyDown: _cache[5] || (_cache[5] = ($event) => !unref(disabled) && updateValues(unref(max), currentModelValue.value.length - 1, { commit: true })),
+					onStepKeyDown: _cache[6] || (_cache[6] = (event, direction) => {
+						if (!unref(disabled)) {
+							const multiplier = unref(PAGE_KEYS).includes(event.key) || event.shiftKey && unref(ARROW_KEYS).includes(event.key) ? 10 : 1;
+							const atIndex = valueIndexToChangeRef.value;
+							const value = currentModelValue.value[atIndex];
+							updateValues(value + unref(step) * multiplier * direction, atIndex, { commit: true });
+						}
+					})
+				}), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) }), unref(isFormControl) && _ctx.name ? (openBlock(), createBlock(unref(VisuallyHiddenInput_default), {
+						key: 0,
+						type: "number",
+						value: unref(modelValue),
+						name: _ctx.name,
+						required: _ctx.required,
+						disabled: unref(disabled),
+						step: unref(step)
+					}, null, 8, [
+						"value",
+						"name",
+						"required",
+						"disabled",
+						"step"
+					])) : createCommentVNode("v-if", true)]),
+					_: 3
+				}, 16, [
+					"as-child",
+					"as",
+					"min",
+					"max",
+					"dir",
+					"inverted",
+					"aria-disabled",
+					"data-disabled"
+				]))]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderImpl.js
+var SliderImpl_default = /* @__PURE__ */ defineComponent({
+	__name: "SliderImpl",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		}
+	},
+	emits: [
+		"slideStart",
+		"slideMove",
+		"slideEnd",
+		"homeKeyDown",
+		"endKeyDown",
+		"stepKeyDown"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rootContext = injectSliderRootContext();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps({ "data-slider-impl": "" }, props, {
+				onKeydown: _cache[0] || (_cache[0] = (event) => {
+					if (event.key === "Home") {
+						emits("homeKeyDown", event);
+						event.preventDefault();
+					} else if (event.key === "End") {
+						emits("endKeyDown", event);
+						event.preventDefault();
+					} else if (unref(PAGE_KEYS).concat(unref(ARROW_KEYS)).includes(event.key)) {
+						emits("stepKeyDown", event);
+						event.preventDefault();
+					}
+				}),
+				onPointerdown: _cache[1] || (_cache[1] = (event) => {
+					const target = event.target;
+					target.setPointerCapture(event.pointerId);
+					event.preventDefault();
+					if (unref(rootContext).thumbElements.value.includes(target)) target.focus();
+					else emits("slideStart", event);
+				}),
+				onPointermove: _cache[2] || (_cache[2] = (event) => {
+					if (event.target.hasPointerCapture(event.pointerId)) emits("slideMove", event);
+				}),
+				onPointerup: _cache[3] || (_cache[3] = (event) => {
+					const target = event.target;
+					if (target.hasPointerCapture(event.pointerId)) {
+						target.releasePointerCapture(event.pointerId);
+						emits("slideEnd", event);
+					}
+				})
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderRange.js
+var SliderRange_default = /* @__PURE__ */ defineComponent({
+	__name: "SliderRange",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		}
+	},
+	setup(__props) {
+		const rootContext = injectSliderRootContext();
+		const orientation = injectSliderOrientationContext();
+		useForwardExpose();
+		const percentages = computed(() => rootContext.currentModelValue.value.map((value) => convertValueToPercentage(value, rootContext.min.value, rootContext.max.value)));
+		const offsetStart = computed(() => rootContext.currentModelValue.value.length > 1 ? Math.min(...percentages.value) : 0);
+		const offsetEnd = computed(() => 100 - Math.max(...percentages.value, 0));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				"data-disabled": unref(rootContext).disabled.value ? "" : void 0,
+				"data-orientation": unref(rootContext).orientation.value,
+				"as-child": _ctx.asChild,
+				as: _ctx.as,
+				style: normalizeStyle({
+					[unref(orientation).startEdge.value]: `${offsetStart.value}%`,
+					[unref(orientation).endEdge.value]: `${offsetEnd.value}%`
+				})
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"data-disabled",
+				"data-orientation",
+				"as-child",
+				"as",
+				"style"
+			]);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderThumbImpl.js
+var SliderThumbImpl_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "SliderThumbImpl",
+	props: {
+		index: {
+			type: Number,
+			required: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectSliderRootContext();
+		const orientation = injectSliderOrientationContext();
+		const { forwardRef} = useForwardExpose();
+		const { CollectionItem } = useCollection();
+		const value = computed(() => rootContext.modelValue?.value?.[props.index]);
+		const percent = computed(() => value.value === void 0 ? 0 : convertValueToPercentage(value.value, rootContext.min.value ?? 0, rootContext.max.value ?? 100));
+		const label = computed(() => getLabel(props.index, rootContext.modelValue?.value?.length ?? 0));
+		const size = useSize();
+		const orientationSize = computed(() => size[orientation.size].value);
+		const thumbInBoundsOffset = computed(() => {
+			if (rootContext.thumbAlignment.value === "overflow" || !orientationSize.value) return 0;
+			else return getThumbInBoundsOffset(orientationSize.value, percent.value, orientation.direction.value);
+		});
+		const isMounted = useMounted();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(CollectionItem), null, {
+				default: withCtx(() => [createVNode(unref(Primitive), mergeProps(_ctx.$attrs, {
+					ref: unref(forwardRef),
+					role: "slider",
+					tabindex: unref(rootContext).disabled.value ? void 0 : 0,
+					"aria-label": _ctx.$attrs["aria-label"] || label.value,
+					"data-disabled": unref(rootContext).disabled.value ? "" : void 0,
+					"data-orientation": unref(rootContext).orientation.value,
+					"aria-valuenow": value.value,
+					"aria-valuemin": unref(rootContext).min.value,
+					"aria-valuemax": unref(rootContext).max.value,
+					"aria-orientation": unref(rootContext).orientation.value,
+					"as-child": _ctx.asChild,
+					as: _ctx.as,
+					style: {
+						transform: "var(--reka-slider-thumb-transform)",
+						position: "absolute",
+						[unref(orientation).startEdge.value]: `calc(${percent.value}% + ${thumbInBoundsOffset.value}px)`,
+						display: !unref(isMounted) && value.value === void 0 ? "none" : void 0
+					},
+					onFocus: _cache[0] || (_cache[0] = () => {
+						unref(rootContext).valueIndexToChangeRef.value = _ctx.index;
+					})
+				}), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, [
+					"tabindex",
+					"aria-label",
+					"data-disabled",
+					"data-orientation",
+					"aria-valuenow",
+					"aria-valuemin",
+					"aria-valuemax",
+					"aria-orientation",
+					"as-child",
+					"as",
+					"style"
+				])]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderThumb.js
+var SliderThumb_default = /* @__PURE__ */ defineComponent({
+	__name: "SliderThumb",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const { getItems } = useCollection();
+		const { forwardRef, currentElement: thumbElement } = useForwardExpose();
+		const index = computed(() => thumbElement.value ? getItems(true).findIndex((i) => i.ref === thumbElement.value) : -1);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(SliderThumbImpl_default, mergeProps({ ref: unref(forwardRef) }, props, { index: index.value }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["index"]);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Slider/SliderTrack.js
+var SliderTrack_default = /* @__PURE__ */ defineComponent({
+	__name: "SliderTrack",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		}
+	},
+	setup(__props) {
+		const rootContext = injectSliderRootContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				"as-child": _ctx.asChild,
+				as: _ctx.as,
+				"data-disabled": unref(rootContext).disabled.value ? "" : void 0,
+				"data-orientation": unref(rootContext).orientation.value
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as-child",
+				"as",
+				"data-disabled",
+				"data-orientation"
+			]);
+		};
+	}
+});
+//#endregion
+//#region virtual:nuxt:node_modules%2F.cache%2Fnuxt%2F.nuxt%2Fui%2Fslider.ts
+var virtual_nuxt_node_modules_2F_cache_2Fnuxt_2F_nuxt_2Fui_2Fslider_default = {
+	"slots": {
+		"root": "relative flex items-center select-none touch-none",
+		"track": "relative bg-accented overflow-hidden rounded-full grow",
+		"range": "absolute rounded-full",
+		"thumb": "rounded-full bg-default ring-2 focus-visible:outline-3 focus-visible:outline-offset-2"
+	},
+	"variants": {
+		"color": {
+			"primary": {
+				"range": "bg-primary",
+				"thumb": "ring-primary outline-primary/25"
+			},
+			"secondary": {
+				"range": "bg-secondary",
+				"thumb": "ring-secondary outline-secondary/25"
+			},
+			"success": {
+				"range": "bg-success",
+				"thumb": "ring-success outline-success/25"
+			},
+			"info": {
+				"range": "bg-info",
+				"thumb": "ring-info outline-info/25"
+			},
+			"warning": {
+				"range": "bg-warning",
+				"thumb": "ring-warning outline-warning/25"
+			},
+			"error": {
+				"range": "bg-error",
+				"thumb": "ring-error outline-error/25"
+			},
+			"neutral": {
+				"range": "bg-inverted",
+				"thumb": "ring-inverted outline-inverted/25"
+			}
+		},
+		"size": {
+			"xs": { "thumb": "size-3" },
+			"sm": { "thumb": "size-3.5" },
+			"md": { "thumb": "size-4" },
+			"lg": { "thumb": "size-4.5" },
+			"xl": { "thumb": "size-5" }
+		},
+		"orientation": {
+			"horizontal": {
+				"root": "w-full",
+				"range": "h-full"
+			},
+			"vertical": {
+				"root": "flex-col h-full",
+				"range": "w-full"
+			}
+		},
+		"disabled": { "true": { "root": "opacity-75 cursor-not-allowed" } }
+	},
+	"compoundVariants": [
+		{
+			"orientation": "horizontal",
+			"size": "xs",
+			"class": { "track": "h-[6px]" }
+		},
+		{
+			"orientation": "horizontal",
+			"size": "sm",
+			"class": { "track": "h-[7px]" }
+		},
+		{
+			"orientation": "horizontal",
+			"size": "md",
+			"class": { "track": "h-[8px]" }
+		},
+		{
+			"orientation": "horizontal",
+			"size": "lg",
+			"class": { "track": "h-[9px]" }
+		},
+		{
+			"orientation": "horizontal",
+			"size": "xl",
+			"class": { "track": "h-[10px]" }
+		},
+		{
+			"orientation": "vertical",
+			"size": "xs",
+			"class": { "track": "w-[6px]" }
+		},
+		{
+			"orientation": "vertical",
+			"size": "sm",
+			"class": { "track": "w-[7px]" }
+		},
+		{
+			"orientation": "vertical",
+			"size": "md",
+			"class": { "track": "w-[8px]" }
+		},
+		{
+			"orientation": "vertical",
+			"size": "lg",
+			"class": { "track": "w-[9px]" }
+		},
+		{
+			"orientation": "vertical",
+			"size": "xl",
+			"class": { "track": "w-[10px]" }
+		}
+	],
+	"defaultVariants": {
+		"size": "md",
+		"color": "primary"
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@nuxt+ui@4.10.0_e299f0a9b209424c2a6c150f5a1a8167/node_modules/@nuxt/ui/dist/runtime/components/Slider.vue
+var _sfc_main = {
+	__name: "USlider",
+	__ssrInlineRender: true,
+	props: /*@__PURE__*/ mergeModels({
+		as: {
+			type: null,
+			required: false
+		},
+		size: {
+			type: null,
+			required: false
+		},
+		color: {
+			type: null,
+			required: false
+		},
+		orientation: {
+			type: null,
+			required: false,
+			default: "horizontal"
+		},
+		tooltip: {
+			type: [Boolean, Object],
+			required: false
+		},
+		defaultValue: {
+			type: [Number, Array],
+			required: false
+		},
+		class: {
+			type: null,
+			required: false
+		},
+		ui: {
+			type: Object,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		inverted: {
+			type: Boolean,
+			required: false
+		},
+		min: {
+			type: Number,
+			required: false,
+			default: 0
+		},
+		max: {
+			type: Number,
+			required: false,
+			default: 100
+		},
+		step: {
+			type: Number,
+			required: false,
+			default: 1
+		},
+		minStepsBetweenThumbs: {
+			type: Number,
+			required: false
+		}
+	}, {
+		"modelValue": { type: null },
+		"modelModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["change"], ["update:modelValue"]),
+	setup(__props, { emit: __emit }) {
+		const _props = __props;
+		const emits = __emit;
+		const props = useComponentProps("slider", _props);
+		const modelValue = useModel(__props, "modelValue");
+		const appConfig = useAppConfig();
+		const rootProps = useForwardProps(reactivePick(props, "as", "orientation", "min", "max", "step", "minStepsBetweenThumbs", "inverted"), emits);
+		const { id, emitFormChange, emitFormInput, size, color, name, disabled, ariaAttrs } = useFormField(_props);
+		const defaultSliderValue = computed(() => {
+			if (typeof props.defaultValue === "number") return [props.defaultValue];
+			return props.defaultValue;
+		});
+		const sliderValue = computed({
+			get() {
+				if (typeof modelValue.value === "number") return [modelValue.value];
+				return modelValue.value ?? defaultSliderValue.value;
+			},
+			set(value) {
+				modelValue.value = value?.length !== 1 ? value : value[0];
+			}
+		});
+		const thumbs = computed(() => sliderValue.value?.length ?? 1);
+		const ui = computed(() => tv({
+			extend: virtual_nuxt_node_modules_2F_cache_2Fnuxt_2F_nuxt_2Fui_2Fslider_default,
+			...appConfig.ui?.slider || {}
+		})({
+			disabled: disabled.value,
+			size: size.value ?? props.size,
+			color: color.value ?? props.color,
+			orientation: props.orientation
+		}));
+		function onChange(value) {
+			const event = new Event("change", { target: { value } });
+			emits("change", event);
+			emitFormChange();
+		}
+		return (_ctx, _push, _parent, _attrs) => {
+			_push(ssrRenderComponent(unref(SliderRoot_default), mergeProps({
+				...unref(rootProps),
+				...unref(ariaAttrs)
+			}, {
+				id: unref(id),
+				modelValue: sliderValue.value,
+				"onUpdate:modelValue": [($event) => sliderValue.value = $event, ($event) => unref(emitFormInput)()],
+				name: unref(name),
+				disabled: unref(disabled),
+				"data-slot": "root",
+				class: ui.value.root({ class: [unref(props).ui?.root, unref(props).class] }),
+				"default-value": defaultSliderValue.value,
+				onValueCommit: onChange
+			}, _attrs), {
+				default: withCtx((_, _push, _parent, _scopeId) => {
+					if (_push) {
+						_push(ssrRenderComponent(unref(SliderTrack_default), {
+							"data-slot": "track",
+							class: ui.value.track({ class: unref(props).ui?.track })
+						}, {
+							default: withCtx((_, _push, _parent, _scopeId) => {
+								if (_push) _push(ssrRenderComponent(unref(SliderRange_default), {
+									"data-slot": "range",
+									class: ui.value.range({ class: unref(props).ui?.range })
+								}, null, _parent, _scopeId));
+								else return [createVNode(unref(SliderRange_default), {
+									"data-slot": "range",
+									class: ui.value.range({ class: unref(props).ui?.range })
+								}, null, 8, ["class"])];
+							}),
+							_: 1
+						}, _parent, _scopeId));
+						_push(`<!--[-->`);
+						ssrRenderList(thumbs.value, (thumb) => {
+							_push(`<!--[-->`);
+							if (!!unref(props).tooltip) _push(ssrRenderComponent(_sfc_main$1, mergeProps({
+								text: thumbs.value > 1 ? String(sliderValue.value?.[thumb - 1]) : String(sliderValue.value),
+								"disable-closing-trigger": ""
+							}, { ref_for: true }, typeof unref(props).tooltip === "object" ? unref(props).tooltip : {}), {
+								default: withCtx((_, _push, _parent, _scopeId) => {
+									if (_push) _push(ssrRenderComponent(unref(SliderThumb_default), {
+										"data-slot": "thumb",
+										class: ui.value.thumb({ class: unref(props).ui?.thumb }),
+										"aria-label": thumbs.value === 1 ? "Thumb" : `Thumb ${thumb} of ${thumbs.value}`
+									}, null, _parent, _scopeId));
+									else return [createVNode(unref(SliderThumb_default), {
+										"data-slot": "thumb",
+										class: ui.value.thumb({ class: unref(props).ui?.thumb }),
+										"aria-label": thumbs.value === 1 ? "Thumb" : `Thumb ${thumb} of ${thumbs.value}`
+									}, null, 8, ["class", "aria-label"])];
+								}),
+								_: 2
+							}, _parent, _scopeId));
+							else _push(ssrRenderComponent(unref(SliderThumb_default), {
+								"data-slot": "thumb",
+								class: ui.value.thumb({ class: unref(props).ui?.thumb }),
+								"aria-label": thumbs.value === 1 ? "Thumb" : `Thumb ${thumb} of ${thumbs.value}`
+							}, null, _parent, _scopeId));
+							_push(`<!--]-->`);
+						});
+						_push(`<!--]-->`);
+					} else return [createVNode(unref(SliderTrack_default), {
+						"data-slot": "track",
+						class: ui.value.track({ class: unref(props).ui?.track })
+					}, {
+						default: withCtx(() => [createVNode(unref(SliderRange_default), {
+							"data-slot": "range",
+							class: ui.value.range({ class: unref(props).ui?.range })
+						}, null, 8, ["class"])]),
+						_: 1
+					}, 8, ["class"]), (openBlock(true), createBlock(Fragment, null, renderList(thumbs.value, (thumb) => {
+						return openBlock(), createBlock(Fragment, { key: thumb }, [!!unref(props).tooltip ? (openBlock(), createBlock(_sfc_main$1, mergeProps({
+							key: 0,
+							text: thumbs.value > 1 ? String(sliderValue.value?.[thumb - 1]) : String(sliderValue.value),
+							"disable-closing-trigger": ""
+						}, { ref_for: true }, typeof unref(props).tooltip === "object" ? unref(props).tooltip : {}), {
+							default: withCtx(() => [createVNode(unref(SliderThumb_default), {
+								"data-slot": "thumb",
+								class: ui.value.thumb({ class: unref(props).ui?.thumb }),
+								"aria-label": thumbs.value === 1 ? "Thumb" : `Thumb ${thumb} of ${thumbs.value}`
+							}, null, 8, ["class", "aria-label"])]),
+							_: 2
+						}, 1040, ["text"])) : (openBlock(), createBlock(unref(SliderThumb_default), {
+							key: 1,
+							"data-slot": "thumb",
+							class: ui.value.thumb({ class: unref(props).ui?.thumb }),
+							"aria-label": thumbs.value === 1 ? "Thumb" : `Thumb ${thumb} of ${thumbs.value}`
+						}, null, 8, ["class", "aria-label"]))], 64);
+					}), 128))];
+				}),
+				_: 1
+			}, _parent));
+		};
+	}
+};
+var _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+	const ssrContext = useSSRContext();
+	(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("../node_modules/.pnpm/@nuxt+ui@4.10.0_e299f0a9b209424c2a6c150f5a1a8167/node_modules/@nuxt/ui/dist/runtime/components/Slider.vue");
+	return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+
+export { _sfc_main as _ };
+//# sourceMappingURL=Slider-D-n8Y0CX.mjs.map