@youcan/celeste 0.7.3 → 0.9.0

package/dist/cjs/chunks/range-calendar.cjs

@@ -0,0 +1,1170 @@
+require("./chunk.cjs");
+const require_clsx = require("./clsx.cjs");
+const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useCalendar = require("./useCalendar.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_useForwardPropsEmits = require("./useForwardPropsEmits.cjs");
+const require_useKbd = require("./useKbd.cjs");
+const require_useLocale = require("./useLocale.cjs");
+const require_usePrimitiveElement = require("./usePrimitiveElement.cjs");
+const require_use_delegated_props = require("../use-delegated-props.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/useRangeCalendar.js
+function useRangeCalendarState(props) {
+	const isStartInvalid = (0, vue.computed)(() => {
+		if (!props.start.value) return false;
+		if (props.isDateDisabled(props.start.value)) return true;
+		return false;
+	});
+	const isEndInvalid = (0, vue.computed)(() => {
+		if (!props.end.value) return false;
+		if (props.isDateDisabled(props.end.value)) return true;
+		return false;
+	});
+	const isInvalid = (0, vue.computed)(() => {
+		if (isStartInvalid.value || isEndInvalid.value) return true;
+		if (props.start.value && props.end.value && require_useCalendar.isBefore(props.end.value, props.start.value)) return true;
+		return false;
+	});
+	const isSelectionStart = (date) => {
+		if (!props.start.value) return false;
+		return require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.start.value, date);
+	};
+	const isSelectionEnd = (date) => {
+		if (!props.end.value) return false;
+		return require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.end.value, date);
+	};
+	const isSelected = (date) => {
+		if (props.start.value && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.start.value, date)) return true;
+		if (props.end.value && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.end.value, date)) return true;
+		if (props.end.value && props.start.value) return require_useCalendar.isBetween(date, props.start.value, props.end.value);
+		return false;
+	};
+	const rangeIsDateDisabled = (date) => {
+		if (props.isDateDisabled(date)) return true;
+		if (props.maximumDays?.value) {
+			if (props.start.value && props.end.value) {
+				if (props.fixedDate.value) {
+					const diff = require_useCalendar.getDaysBetween(props.start.value, props.end.value).length;
+					if (diff <= props.maximumDays.value) {
+						const daysLeft = props.maximumDays.value - diff - 1;
+						return !require_useCalendar.isBetween(date, props.start.value.subtract({ days: daysLeft }), props.end.value.add({ days: daysLeft }));
+					}
+				}
+				return false;
+			}
+			if (props.start.value) {
+				const maxDate = props.start.value.add({ days: props.maximumDays.value });
+				return !require_useCalendar.isBetween(date, props.start.value.subtract({ days: props.maximumDays.value }), maxDate);
+			}
+		}
+		return false;
+	};
+	const isDateHighlightable = (date) => {
+		if (props.isDateHighlightable?.(date)) return true;
+		return false;
+	};
+	const highlightedRange = (0, vue.computed)(() => {
+		if (props.start.value && props.end.value && !props.fixedDate.value) return null;
+		if (!props.start.value || !props.focusedValue.value) return null;
+		const isStartBeforeFocused = require_useCalendar.isBefore(props.start.value, props.focusedValue.value);
+		const start = isStartBeforeFocused ? props.start.value : props.focusedValue.value;
+		const end = isStartBeforeFocused ? props.focusedValue.value : props.start.value;
+		if (require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(start, end)) return {
+			start,
+			end
+		};
+		if (props.maximumDays?.value && !props.end.value) {
+			const maximumDays = props.maximumDays.value;
+			const anchor = props.start.value;
+			const focused = props.focusedValue.value;
+			if (!require_useCalendar.isBefore(focused, anchor)) return {
+				start: anchor,
+				end: anchor.add({ days: maximumDays - 1 })
+			};
+			return {
+				start: anchor.subtract({ days: maximumDays - 1 }),
+				end: anchor
+			};
+		}
+		if (require_useCalendar.areAllDaysBetweenValid(start, end, props.allowNonContiguousRanges.value ? () => false : props.isDateUnavailable, rangeIsDateDisabled, props.isDateHighlightable)) return {
+			start,
+			end
+		};
+		return null;
+	});
+	const isHighlightedStart = (date) => {
+		if (!highlightedRange.value || !highlightedRange.value.start) return false;
+		return require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(highlightedRange.value.start, date);
+	};
+	const isHighlightedEnd = (date) => {
+		if (!highlightedRange.value || !highlightedRange.value.end) return false;
+		return require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(highlightedRange.value.end, date);
+	};
+	const hasSelectedDate = (0, vue.computed)(() => {
+		return !!(props.start.value || props.end.value);
+	});
+	const isStartDateDisabled = (0, vue.computed)(() => {
+		return !!(props.start.value && props.isDateDisabled(props.start.value));
+	});
+	const isEndDateDisabled = (0, vue.computed)(() => {
+		return !!(props.end.value && props.isDateDisabled(props.end.value));
+	});
+	return {
+		isInvalid,
+		isSelected,
+		isDateHighlightable,
+		highlightedRange,
+		isSelectionStart,
+		isSelectionEnd,
+		isHighlightedStart,
+		isHighlightedEnd,
+		isDateDisabled: rangeIsDateDisabled,
+		hasSelectedDate,
+		isSelectedDisabled: (0, vue.computed)(() => {
+			const hasStart = !!props.start.value;
+			const hasEnd = !!props.end.value;
+			if (!hasStart && !hasEnd) return false;
+			if (hasStart && hasEnd) return isStartDateDisabled.value && isEndDateDisabled.value;
+			return hasStart && isStartDateDisabled.value || hasEnd && isEndDateDisabled.value;
+		}),
+		selectedFocusableDate: (0, vue.computed)(() => {
+			if (props.start.value && !isStartDateDisabled.value) return props.start.value;
+			if (props.end.value && !isEndDateDisabled.value) return props.end.value;
+		})
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarRoot.js
+var _hoisted_1$1 = { style: {
+	"border": "0px",
+	"clip": "rect(0px, 0px, 0px, 0px)",
+	"clip-path": "inset(50%)",
+	"height": "1px",
+	"margin": "-1px",
+	"overflow": "hidden",
+	"padding": "0px",
+	"position": "absolute",
+	"white-space": "nowrap",
+	"width": "1px"
+} };
+var _hoisted_2$1 = {
+	role: "heading",
+	"aria-level": "2"
+};
+var [injectRangeCalendarRootContext, provideRangeCalendarRootContext] = /* @__PURE__ */ require_createContext.createContext("RangeCalendarRoot");
+var RangeCalendarRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarRoot",
+	props: {
+		defaultPlaceholder: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: Object,
+			required: false,
+			default: () => ({
+				start: void 0,
+				end: void 0
+			})
+		},
+		modelValue: {
+			type: [Object, null],
+			required: false
+		},
+		placeholder: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		allowNonContiguousRanges: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		pagedNavigation: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		preventDeselect: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		maximumDays: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		weekStartsOn: {
+			type: Number,
+			required: false
+		},
+		weekdayFormat: {
+			type: String,
+			required: false,
+			default: "narrow"
+		},
+		calendarLabel: {
+			type: String,
+			required: false
+		},
+		fixedWeeks: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		maxValue: {
+			type: null,
+			required: false
+		},
+		minValue: {
+			type: null,
+			required: false
+		},
+		locale: {
+			type: String,
+			required: false
+		},
+		numberOfMonths: {
+			type: Number,
+			required: false,
+			default: 1
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		readonly: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		initialFocus: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		isDateDisabled: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		isDateUnavailable: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		isDateHighlightable: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		nextPage: {
+			type: Function,
+			required: false
+		},
+		prevPage: {
+			type: Function,
+			required: false
+		},
+		disableDaysOutsideCurrentView: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		fixedDate: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"update:validModelValue",
+		"update:placeholder",
+		"update:startValue"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { disabled, readonly, initialFocus, pagedNavigation, weekdayFormat, fixedWeeks, numberOfMonths, preventDeselect, isDateUnavailable: propsIsDateUnavailable, isDateHighlightable: propsIsDateHighlightable, isDateDisabled: propsIsDateDisabled, calendarLabel, maxValue, minValue, dir: propDir, locale: propLocale, nextPage: propsNextPage, prevPage: propsPrevPage, allowNonContiguousRanges, disableDaysOutsideCurrentView, fixedDate, maximumDays } = (0, vue.toRefs)(props);
+		const { primitiveElement, currentElement: parentElement } = require_usePrimitiveElement.usePrimitiveElement();
+		const dir = require_useDirection.useDirection(propDir);
+		const locale = require_useLocale.useLocale(propLocale);
+		const weekStartsOn = (0, vue.computed)(() => props.weekStartsOn ?? require_useCalendar.getWeekStartsOn(locale.value));
+		const lastPressedDateValue = (0, vue.ref)();
+		const focusedValue = (0, vue.ref)();
+		const isEditing = (0, vue.ref)(false);
+		const modelValue = require_dist.useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue ?? {
+				start: void 0,
+				end: void 0
+			},
+			passive: props.modelValue === void 0
+		});
+		const normalizeRange = (value) => value ?? {
+			start: void 0,
+			end: void 0
+		};
+		const normalizedModelValue = (0, vue.computed)(() => normalizeRange(modelValue.value));
+		const validModelValue = (0, vue.ref)(normalizeRange(modelValue.value));
+		(0, vue.watch)(validModelValue, (value) => {
+			emits("update:validModelValue", value);
+		});
+		const defaultDate = require_useCalendar.getDefaultDate({
+			defaultPlaceholder: props.placeholder,
+			defaultValue: normalizeRange(modelValue.value).start,
+			locale: props.locale
+		});
+		const startValue = (0, vue.ref)(normalizeRange(modelValue.value).start);
+		const endValue = (0, vue.ref)(normalizeRange(modelValue.value).end);
+		const placeholder = require_dist.useVModel(props, "placeholder", emits, {
+			defaultValue: props.defaultPlaceholder ?? defaultDate.copy(),
+			passive: props.placeholder === void 0
+		});
+		function onPlaceholderChange(value) {
+			placeholder.value = value.copy();
+		}
+		const { fullCalendarLabel, headingValue, isDateDisabled, isDateUnavailable, isNextButtonDisabled, isPrevButtonDisabled, grid, weekdays, isOutsideVisibleView, nextPage, prevPage, formatter, isPlaceholderFocusable, firstFocusableDate } = require_useCalendar.useCalendar({
+			locale,
+			placeholder,
+			weekStartsOn,
+			fixedWeeks,
+			numberOfMonths,
+			minValue,
+			maxValue,
+			disabled,
+			weekdayFormat,
+			pagedNavigation,
+			isDateDisabled: propsIsDateDisabled.value,
+			isDateUnavailable: propsIsDateUnavailable.value,
+			calendarLabel,
+			nextPage: propsNextPage,
+			prevPage: propsPrevPage
+		});
+		const { isInvalid, isSelected, isDateHighlightable, highlightedRange, isSelectionStart, isSelectionEnd, isHighlightedStart, isHighlightedEnd, isDateDisabled: rangeIsDateDisabled, hasSelectedDate, isSelectedDisabled, selectedFocusableDate } = useRangeCalendarState({
+			start: startValue,
+			end: endValue,
+			isDateDisabled,
+			isDateUnavailable,
+			isDateHighlightable: propsIsDateHighlightable.value,
+			focusedValue,
+			allowNonContiguousRanges,
+			fixedDate,
+			maximumDays
+		});
+		(0, vue.watch)(modelValue, (_modelValue) => {
+			const next = normalizeRange(_modelValue);
+			if (!(!next.start && !startValue.value || !!next.start && !!startValue.value && require_useCalendar.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(next.start, startValue.value))) startValue.value = next.start?.copy?.();
+			if (!(!next.end && !endValue.value || !!next.end && !!endValue.value && require_useCalendar.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(next.end, endValue.value))) endValue.value = next.end?.copy?.();
+		});
+		(0, vue.watch)(startValue, (_startValue) => {
+			if (_startValue && !require_useCalendar.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(_startValue, placeholder.value)) onPlaceholderChange(_startValue);
+			emits("update:startValue", _startValue);
+		});
+		(0, vue.watch)([startValue, endValue], ([_startValue, _endValue]) => {
+			const value = modelValue.value;
+			if (value && value.start && value.end && _startValue && _endValue && require_useCalendar.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(value.start, _startValue) && require_useCalendar.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(value.end, _endValue)) return;
+			isEditing.value = true;
+			if (_endValue && _startValue) {
+				const nextValue = require_useCalendar.isBefore(_endValue, _startValue) ? {
+					start: _endValue.copy(),
+					end: _startValue.copy()
+				} : {
+					start: _startValue.copy(),
+					end: _endValue.copy()
+				};
+				modelValue.value = {
+					start: nextValue.start,
+					end: nextValue.end
+				};
+				isEditing.value = false;
+				validModelValue.value = {
+					start: nextValue.start.copy(),
+					end: nextValue.end.copy()
+				};
+			} else modelValue.value = _startValue ? {
+				start: _startValue.copy(),
+				end: void 0
+			} : {
+				start: _endValue?.copy(),
+				end: void 0
+			};
+		});
+		const kbd = require_useKbd.useKbd();
+		require_dist.useEventListener(parentElement, "keydown", (ev) => {
+			if (ev.key === kbd.ESCAPE && isEditing.value) {
+				startValue.value = validModelValue.value.start?.copy();
+				endValue.value = validModelValue.value.end?.copy();
+			}
+		});
+		provideRangeCalendarRootContext({
+			isDateUnavailable,
+			isDateHighlightable,
+			startValue,
+			endValue,
+			formatter,
+			modelValue: normalizedModelValue,
+			placeholder,
+			disabled,
+			initialFocus,
+			pagedNavigation,
+			grid,
+			weekDays: weekdays,
+			weekStartsOn,
+			weekdayFormat,
+			fixedWeeks,
+			numberOfMonths,
+			readonly,
+			preventDeselect,
+			fullCalendarLabel,
+			headingValue,
+			isInvalid,
+			isDateDisabled: rangeIsDateDisabled,
+			allowNonContiguousRanges,
+			highlightedRange,
+			focusedValue,
+			lastPressedDateValue,
+			isSelected,
+			isSelectionEnd,
+			isSelectionStart,
+			isNextButtonDisabled,
+			isPrevButtonDisabled,
+			isOutsideVisibleView,
+			nextPage,
+			prevPage,
+			parentElement,
+			onPlaceholderChange,
+			locale,
+			dir,
+			isHighlightedStart,
+			isHighlightedEnd,
+			disableDaysOutsideCurrentView,
+			fixedDate,
+			maximumDays,
+			minValue,
+			maxValue,
+			isPlaceholderFocusable,
+			firstFocusableDate,
+			hasSelectedDate,
+			isSelectedDisabled,
+			selectedFocusableDate
+		});
+		(0, vue.onMounted)(() => {
+			if (initialFocus.value) require_useCalendar.handleCalendarInitialFocus(parentElement.value);
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				ref_key: "primitiveElement",
+				ref: primitiveElement,
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				"aria-label": (0, vue.unref)(fullCalendarLabel),
+				"data-readonly": (0, vue.unref)(readonly) ? "" : void 0,
+				"data-disabled": (0, vue.unref)(disabled) ? "" : void 0,
+				"data-invalid": (0, vue.unref)(isInvalid) ? "" : void 0,
+				dir: (0, vue.unref)(dir)
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", _hoisted_1$1, [(0, vue.createElementVNode)("div", _hoisted_2$1, (0, vue.toDisplayString)((0, vue.unref)(fullCalendarLabel)), 1)]), (0, vue.renderSlot)(_ctx.$slots, "default", {
+					date: (0, vue.unref)(placeholder),
+					grid: (0, vue.unref)(grid),
+					weekDays: (0, vue.unref)(weekdays),
+					weekStartsOn: weekStartsOn.value,
+					locale: (0, vue.unref)(locale),
+					fixedWeeks: (0, vue.unref)(fixedWeeks),
+					modelValue: normalizedModelValue.value
+				})]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"aria-label",
+				"data-readonly",
+				"data-disabled",
+				"data-invalid",
+				"dir"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarCell.js
+var RangeCalendarCell_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarCell",
+	props: {
+		date: {
+			type: null,
+			required: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "td"
+		}
+	},
+	setup(__props) {
+		const rootContext = injectRangeCalendarRootContext();
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				role: "gridcell",
+				"aria-selected": (0, vue.unref)(rootContext).isSelected(_ctx.date) ? true : void 0,
+				"aria-disabled": (0, vue.unref)(rootContext).isDateDisabled(_ctx.date) || (0, vue.unref)(rootContext).isDateUnavailable?.(_ctx.date) || (0, vue.unref)(rootContext).disableDaysOutsideCurrentView.value,
+				"data-disabled": (0, vue.unref)(rootContext).isDateDisabled(_ctx.date) || (0, vue.unref)(rootContext).disableDaysOutsideCurrentView.value ? "" : void 0
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"aria-selected",
+				"aria-disabled",
+				"data-disabled"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarCellTrigger.js
+var RangeCalendarCellTrigger_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarCellTrigger",
+	props: {
+		day: {
+			type: null,
+			required: true
+		},
+		month: {
+			type: null,
+			required: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectRangeCalendarRootContext();
+		const kbd = require_useKbd.useKbd();
+		const { primitiveElement, currentElement } = require_usePrimitiveElement.usePrimitiveElement();
+		const labelText = (0, vue.computed)(() => rootContext.formatter.custom(require_useCalendar.toDate(props.day), {
+			weekday: "long",
+			month: "long",
+			day: "numeric",
+			year: "numeric"
+		}));
+		const isUnavailable = (0, vue.computed)(() => rootContext.isDateUnavailable?.(props.day) ?? false);
+		const isSelectedDate = (0, vue.computed)(() => rootContext.isSelected(props.day));
+		const isSelectionStart = (0, vue.computed)(() => rootContext.isSelectionStart(props.day));
+		const isSelectionEnd = (0, vue.computed)(() => rootContext.isSelectionEnd(props.day));
+		const isHighlightStart = (0, vue.computed)(() => rootContext.isHighlightedStart(props.day));
+		const isHighlightEnd = (0, vue.computed)(() => rootContext.isHighlightedEnd(props.day));
+		const isHighlighted = (0, vue.computed)(() => rootContext.highlightedRange.value ? require_useCalendar.isBetweenInclusive(props.day, rootContext.highlightedRange.value.start, rootContext.highlightedRange.value.end) : false);
+		const allowNonContiguousRanges = (0, vue.computed)(() => rootContext.allowNonContiguousRanges.value);
+		const isDateToday = (0, vue.computed)(() => {
+			return require_useCalendar.$14e0f24ef4ac5c92$export$629b0a497aa65267(props.day, require_useCalendar.$14e0f24ef4ac5c92$export$aa8b41735afcabd2());
+		});
+		const isOutsideView = (0, vue.computed)(() => {
+			return !require_useCalendar.$14e0f24ef4ac5c92$export$a18c89cbd24170ff(props.day, props.month);
+		});
+		const isOutsideVisibleView = (0, vue.computed)(() => rootContext.isOutsideVisibleView(props.day));
+		const isDisabled = (0, vue.computed)(() => rootContext.isDateDisabled(props.day) || rootContext.disableDaysOutsideCurrentView.value && isOutsideView.value);
+		const dayValue = (0, vue.computed)(() => props.day.day.toLocaleString(rootContext.locale.value));
+		const isFocusedDate = (0, vue.computed)(() => {
+			if (isOutsideView.value || isDisabled.value) return false;
+			if (!rootContext.disabled.value && rootContext.isPlaceholderFocusable.value && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.placeholder.value)) return true;
+			if (!rootContext.disabled.value && rootContext.selectedFocusableDate.value && !rootContext.isPlaceholderFocusable.value) return require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.selectedFocusableDate.value);
+			if (!rootContext.disabled.value && (!rootContext.hasSelectedDate.value || rootContext.isSelectedDisabled.value) && !rootContext.isPlaceholderFocusable.value) return rootContext.firstFocusableDate.value && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.firstFocusableDate.value);
+			return false;
+		});
+		function changeDate(e, date) {
+			if (rootContext.readonly.value) return;
+			if (rootContext.isDateDisabled(date) || rootContext.isDateUnavailable?.(date)) return;
+			if (rootContext.startValue.value && rootContext.highlightedRange.value === null) {
+				if (require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(date, rootContext.startValue.value) && !rootContext.preventDeselect.value && !rootContext.endValue.value) {
+					rootContext.startValue.value = void 0;
+					rootContext.onPlaceholderChange(date);
+					rootContext.lastPressedDateValue.value = date.copy();
+					return;
+				} else if (!rootContext.endValue.value) {
+					e.preventDefault();
+					if (rootContext.lastPressedDateValue.value && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(rootContext.lastPressedDateValue.value, date)) rootContext.startValue.value = date.copy();
+					rootContext.lastPressedDateValue.value = date.copy();
+					return;
+				}
+			}
+			rootContext.lastPressedDateValue.value = date.copy();
+			if (rootContext.startValue.value && rootContext.endValue.value && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(rootContext.startValue.value, rootContext.endValue.value) && require_useCalendar.$14e0f24ef4ac5c92$export$ea39ec197993aef0(rootContext.startValue.value, date) && !rootContext.preventDeselect.value) {
+				rootContext.startValue.value = void 0;
+				rootContext.endValue.value = void 0;
+				rootContext.onPlaceholderChange(date);
+				return;
+			}
+			if (!rootContext.startValue.value) rootContext.startValue.value = date.copy();
+			else if (!rootContext.endValue.value) rootContext.endValue.value = date.copy();
+			else if (rootContext.endValue.value && rootContext.startValue.value) {
+				if (!rootContext.fixedDate.value) {
+					rootContext.endValue.value = void 0;
+					rootContext.startValue.value = date.copy();
+				} else if (rootContext.fixedDate.value === "start") if (date.compare(rootContext.startValue.value) < 0) rootContext.startValue.value = date.copy();
+				else rootContext.endValue.value = date.copy();
+				else if (rootContext.fixedDate.value === "end") if (date.compare(rootContext.endValue.value) > 0) rootContext.endValue.value = date.copy();
+				else rootContext.startValue.value = date.copy();
+			}
+		}
+		function handleClick(e) {
+			if (isDisabled.value) return;
+			changeDate(e, props.day);
+		}
+		function handleFocus() {
+			if (isDisabled.value || rootContext.isDateUnavailable?.(props.day)) return;
+			rootContext.focusedValue.value = props.day.copy();
+		}
+		function handleArrowKey(e) {
+			if (isDisabled.value) return;
+			if ((e.code === kbd.ENTER || e.code === kbd.SPACE_CODE) && (e.ctrlKey || e.metaKey || e.altKey)) return;
+			e.preventDefault();
+			e.stopPropagation();
+			const parentElement = rootContext.parentElement.value;
+			const indexIncrementation = 7;
+			const sign = rootContext.dir.value === "rtl" ? -1 : 1;
+			switch (e.code) {
+				case kbd.ARROW_RIGHT:
+					shiftFocus(props.day, sign);
+					break;
+				case kbd.ARROW_LEFT:
+					shiftFocus(props.day, -sign);
+					break;
+				case kbd.ARROW_UP:
+					shiftFocus(props.day, -indexIncrementation);
+					break;
+				case kbd.ARROW_DOWN:
+					shiftFocus(props.day, indexIncrementation);
+					break;
+				case kbd.ENTER:
+				case kbd.SPACE_CODE: changeDate(e, props.day);
+			}
+			function shiftFocus(day, add) {
+				const candidateDayValue = day.add({ days: add });
+				if (rootContext.minValue.value && candidateDayValue.compare(rootContext.minValue.value) < 0 || rootContext.maxValue.value && candidateDayValue.compare(rootContext.maxValue.value) > 0) return;
+				const candidateDay = parentElement.querySelector(`[data-value='${candidateDayValue.toString()}']:not([data-outside-view])`);
+				if (!candidateDay) {
+					if (add > 0) {
+						if (rootContext.isNextButtonDisabled()) return;
+						rootContext.nextPage();
+					} else {
+						if (rootContext.isPrevButtonDisabled()) return;
+						rootContext.prevPage();
+					}
+					(0, vue.nextTick)(() => {
+						shiftFocus(day, add);
+					});
+					return;
+				}
+				if (candidateDay && candidateDay.hasAttribute("data-disabled")) return shiftFocus(candidateDayValue, add);
+				rootContext.onPlaceholderChange(candidateDayValue);
+				candidateDay?.focus();
+			}
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				ref_key: "primitiveElement",
+				ref: primitiveElement,
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				role: "button",
+				"aria-label": labelText.value,
+				"data-reka-calendar-cell-trigger": "",
+				"aria-pressed": isSelectedDate.value && (allowNonContiguousRanges.value || !isUnavailable.value) ? true : void 0,
+				"aria-disabled": isDisabled.value || isUnavailable.value ? true : void 0,
+				"data-highlighted": isHighlighted.value && (allowNonContiguousRanges.value || !isUnavailable.value) ? "" : void 0,
+				"data-selection-start": isSelectionStart.value ? true : void 0,
+				"data-selection-end": isSelectionEnd.value ? true : void 0,
+				"data-highlighted-start": isHighlightStart.value ? true : void 0,
+				"data-highlighted-end": isHighlightEnd.value ? true : void 0,
+				"data-selected": isSelectedDate.value && (allowNonContiguousRanges.value || !isUnavailable.value) ? true : void 0,
+				"data-outside-visible-view": isOutsideVisibleView.value ? "" : void 0,
+				"data-value": _ctx.day.toString(),
+				"data-disabled": isDisabled.value ? "" : void 0,
+				"data-unavailable": isUnavailable.value ? "" : void 0,
+				"data-today": isDateToday.value ? "" : void 0,
+				"data-outside-view": isOutsideView.value ? "" : void 0,
+				"data-focused": isFocusedDate.value ? "" : void 0,
+				tabindex: isFocusedDate.value ? 0 : isOutsideView.value || isDisabled.value ? void 0 : -1,
+				onClick: handleClick,
+				onFocusin: handleFocus,
+				onMouseenter: handleFocus,
+				onKeydown: (0, vue.withKeys)(handleArrowKey, [
+					"up",
+					"down",
+					"left",
+					"right",
+					"enter",
+					"space"
+				])
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {
+					dayValue: dayValue.value,
+					disabled: isDisabled.value,
+					today: isDateToday.value,
+					selected: isSelectedDate.value,
+					outsideView: isOutsideView.value,
+					outsideVisibleView: isOutsideVisibleView.value,
+					unavailable: isUnavailable.value,
+					highlighted: isHighlighted.value && (allowNonContiguousRanges.value || !isUnavailable.value),
+					highlightedStart: isHighlightStart.value,
+					highlightedEnd: isHighlightEnd.value,
+					selectionStart: isSelectionStart.value,
+					selectionEnd: isSelectionEnd.value
+				}, () => [(0, vue.createTextVNode)((0, vue.toDisplayString)(dayValue.value), 1)])]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"aria-label",
+				"aria-pressed",
+				"aria-disabled",
+				"data-highlighted",
+				"data-selection-start",
+				"data-selection-end",
+				"data-highlighted-start",
+				"data-highlighted-end",
+				"data-selected",
+				"data-outside-visible-view",
+				"data-value",
+				"data-disabled",
+				"data-unavailable",
+				"data-today",
+				"data-outside-view",
+				"data-focused",
+				"tabindex"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarGrid.js
+var RangeCalendarGrid_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarGrid",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "table"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectRangeCalendarRootContext();
+		const disabled = (0, vue.computed)(() => rootContext.disabled.value ? true : void 0);
+		const readonly = (0, vue.computed)(() => rootContext.readonly.value ? true : void 0);
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)(props, {
+				tabindex: "-1",
+				role: "application",
+				"aria-readonly": readonly.value,
+				"aria-disabled": disabled.value,
+				"data-readonly": readonly.value && "",
+				"data-disabled": disabled.value && "",
+				onMouseleave: _cache[0] || (_cache[0] = ($event) => (0, vue.unref)(rootContext).focusedValue.value = void 0)
+			}), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, [
+				"aria-readonly",
+				"aria-disabled",
+				"data-readonly",
+				"data-disabled"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarGridBody.js
+var RangeCalendarGridBody_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarGridBody",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "tbody"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarGridHead.js
+var RangeCalendarGridHead_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarGridHead",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "thead"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)(props, { "aria-hidden": "true" }), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarGridRow.js
+var RangeCalendarGridRow_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarGridRow",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "tr"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarHeadCell.js
+var RangeCalendarHeadCell_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarHeadCell",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "th"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarNext.js
+var RangeCalendarNext_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarNext",
+	props: {
+		nextPage: {
+			type: Function,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const disabled = (0, vue.computed)(() => rootContext.disabled.value || rootContext.isNextButtonDisabled(props.nextPage));
+		const rootContext = injectRangeCalendarRootContext();
+		function handleClick() {
+			if (disabled.value) return;
+			rootContext.nextPage(props.nextPage);
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				as: props.as,
+				"as-child": props.asChild,
+				"aria-label": "Next page",
+				type: props.as === "button" ? "button" : void 0,
+				"aria-disabled": disabled.value || void 0,
+				"data-disabled": disabled.value || void 0,
+				disabled: disabled.value,
+				onClick: handleClick
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { disabled: disabled.value }, () => [_cache[0] || (_cache[0] = (0, vue.createTextVNode)(" Next page "))])]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"type",
+				"aria-disabled",
+				"data-disabled",
+				"disabled"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RangeCalendar/RangeCalendarPrev.js
+var RangeCalendarPrev_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RangeCalendarPrev",
+	props: {
+		prevPage: {
+			type: Function,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const disabled = (0, vue.computed)(() => rootContext.disabled.value || rootContext.isPrevButtonDisabled(props.prevPage));
+		const rootContext = injectRangeCalendarRootContext();
+		function handleClick() {
+			if (disabled.value) return;
+			rootContext.prevPage(props.prevPage);
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				as: props.as,
+				"as-child": props.asChild,
+				"aria-label": "Previous page",
+				type: props.as === "button" ? "button" : void 0,
+				"aria-disabled": disabled.value || void 0,
+				"data-disabled": disabled.value || void 0,
+				disabled: disabled.value,
+				onClick: handleClick
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { disabled: disabled.value }, () => [_cache[0] || (_cache[0] = (0, vue.createTextVNode)(" Prev page "))])]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"type",
+				"aria-disabled",
+				"data-disabled",
+				"disabled"
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/range-calendar/range-calendar.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "celeste-range-calendar-months" };
+var _hoisted_2 = { class: "celeste-range-calendar-header" };
+var _hoisted_3 = { class: "celeste-range-calendar-heading" };
+var _hoisted_4 = { class: "celeste-range-calendar-day-number" };
+var range_calendar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "range-calendar",
+	props: {
+		class: {},
+		markedDates: {},
+		defaultPlaceholder: {},
+		defaultValue: {},
+		modelValue: {},
+		placeholder: {},
+		allowNonContiguousRanges: { type: Boolean },
+		pagedNavigation: { type: Boolean },
+		preventDeselect: { type: Boolean },
+		maximumDays: {},
+		weekStartsOn: { default: 1 },
+		weekdayFormat: { default: "short" },
+		calendarLabel: {},
+		fixedWeeks: {
+			type: Boolean,
+			default: true
+		},
+		maxValue: {},
+		minValue: {},
+		locale: {},
+		numberOfMonths: { default: 2 },
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		initialFocus: { type: Boolean },
+		isDateDisabled: {},
+		isDateUnavailable: {},
+		isDateHighlightable: {},
+		dir: {},
+		nextPage: {},
+		prevPage: {},
+		disableDaysOutsideCurrentView: { type: Boolean },
+		fixedDate: {},
+		asChild: { type: Boolean },
+		as: {}
+	},
+	emits: [
+		"update:modelValue",
+		"update:validModelValue",
+		"update:placeholder",
+		"update:startValue"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(require_use_delegated_props.useDelegatedProps(props, ["class", "markedDates"]), emits);
+		const monthFormatter = (0, vue.computed)(() => new require_useCalendar.$fb18d541ea1ad717$export$ad991b66133851cf(props.locale ?? "en-US", {
+			month: "long",
+			year: "numeric"
+		}));
+		function formatMonth(date) {
+			return monthFormatter.value.format(date.toDate(require_useCalendar.$14e0f24ef4ac5c92$export$aa8b41735afcabd2()));
+		}
+		function isMarked(date) {
+			return props.markedDates?.some((marked) => require_useCalendar.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(marked, date)) ?? false;
+		}
+		function weekdayLabel(day) {
+			return /^[a-z]/i.test(day.trim()) ? day.slice(0, 2) : day;
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(RangeCalendarRoot_default), (0, vue.mergeProps)((0, vue.unref)(forwarded), { class: (0, vue.unref)(require_clsx.clsx)("celeste-range-calendar", props.class) }), {
+				default: (0, vue.withCtx)(({ weekDays, grid }) => [(0, vue.createElementVNode)("div", _hoisted_1, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(grid, (month) => {
+					return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+						key: month.value.toString(),
+						class: "celeste-range-calendar-month"
+					}, [(0, vue.createElementVNode)("div", _hoisted_2, [
+						(0, vue.createVNode)((0, vue.unref)(RangeCalendarPrev_default), { "as-child": "" }, {
+							default: (0, vue.withCtx)(() => _cache[0] || (_cache[0] = [(0, vue.createElementVNode)("button", {
+								type: "button",
+								class: "celeste-range-calendar-nav"
+							}, [(0, vue.createElementVNode)("i", { class: "i-celeste-arrow-left-s-line" })], -1)])),
+							_: 1
+						}),
+						(0, vue.createElementVNode)("span", _hoisted_3, (0, vue.toDisplayString)(formatMonth(month.value)), 1),
+						(0, vue.createVNode)((0, vue.unref)(RangeCalendarNext_default), { "as-child": "" }, {
+							default: (0, vue.withCtx)(() => _cache[1] || (_cache[1] = [(0, vue.createElementVNode)("button", {
+								type: "button",
+								class: "celeste-range-calendar-nav"
+							}, [(0, vue.createElementVNode)("i", { class: "i-celeste-arrow-right-s-line" })], -1)])),
+							_: 1
+						})
+					]), (0, vue.createVNode)((0, vue.unref)(RangeCalendarGrid_default), { class: "celeste-range-calendar-grid" }, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(RangeCalendarGridHead_default), null, {
+							default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(RangeCalendarGridRow_default), { class: "celeste-range-calendar-week" }, {
+								default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(weekDays, (day) => {
+									return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(RangeCalendarHeadCell_default), {
+										key: day,
+										class: "celeste-range-calendar-weekday"
+									}, {
+										default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(weekdayLabel(day)), 1)]),
+										_: 2
+									}, 1024);
+								}), 128))]),
+								_: 2
+							}, 1024)]),
+							_: 2
+						}, 1024), (0, vue.createVNode)((0, vue.unref)(RangeCalendarGridBody_default), { class: "celeste-range-calendar-body" }, {
+							default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(month.rows, (weekDates, index) => {
+								return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(RangeCalendarGridRow_default), {
+									key: `week-${index}`,
+									class: "celeste-range-calendar-week"
+								}, {
+									default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(weekDates, (weekDate) => {
+										return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(RangeCalendarCell_default), {
+											key: weekDate.toString(),
+											date: weekDate,
+											class: "celeste-range-calendar-cell"
+										}, {
+											default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(RangeCalendarCellTrigger_default), {
+												day: weekDate,
+												month: month.value,
+												class: "celeste-range-calendar-day",
+												"data-marked": isMarked(weekDate) ? "" : void 0
+											}, {
+												default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("span", _hoisted_4, (0, vue.toDisplayString)(weekDate.day), 1)]),
+												_: 2
+											}, 1032, [
+												"day",
+												"month",
+												"data-marked"
+											])]),
+											_: 2
+										}, 1032, ["date"]);
+									}), 128))]),
+									_: 2
+								}, 1024);
+							}), 128))]),
+							_: 2
+						}, 1024)]),
+						_: 2
+					}, 1024)]);
+				}), 128))])]),
+				_: 1
+			}, 16, ["class"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/range-calendar/range-calendar.vue
+var range_calendar_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(range_calendar_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-dc79fc39"]]);
+//#endregion
+Object.defineProperty(exports, "range_calendar_default", {
+	enumerable: true,
+	get: function() {
+		return range_calendar_default;
+	}
+});