@youcan/celeste 0.7.3 → 0.9.0

package/dist/es/chunks/calendar.js

@@ -0,0 +1,916 @@
+import { t as clsx } from "./clsx.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { t as createContext } from "./createContext.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { a as handleCalendarInitialFocus, d as toDate, g as $14e0f24ef4ac5c92$export$aa8b41735afcabd2, h as $14e0f24ef4ac5c92$export$a18c89cbd24170ff, i as getWeekStartsOn, m as $14e0f24ef4ac5c92$export$91b62ebf2ba703ee, n as useCalendarState, p as $14e0f24ef4ac5c92$export$629b0a497aa65267, s as getDefaultDate, t as useCalendar, v as $14e0f24ef4ac5c92$export$ea39ec197993aef0 } from "./useCalendar.js";
+import { t as useDirection } from "./useDirection.js";
+import { t as useForwardPropsEmits } from "./useForwardPropsEmits.js";
+import { t as useKbd } from "./useKbd.js";
+import { t as useLocale } from "./useLocale.js";
+import { t as usePrimitiveElement } from "./usePrimitiveElement.js";
+import { useDelegatedProps } from "../use-delegated-props.js";
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, guardReactiveProps, mergeProps, nextTick, normalizeProps, onMounted, openBlock, renderList, renderSlot, toDisplayString, toRefs, unref, watch, withCtx, withKeys } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Calendar/CalendarRoot.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 [injectCalendarRootContext, provideCalendarRootContext] = /* @__PURE__ */ createContext("CalendarRoot");
+var CalendarRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarRoot",
+	props: {
+		defaultValue: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		defaultPlaceholder: {
+			type: null,
+			required: false
+		},
+		placeholder: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		pagedNavigation: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		preventDeselect: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		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
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		nextPage: {
+			type: Function,
+			required: false
+		},
+		prevPage: {
+			type: Function,
+			required: false
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		disableDaysOutsideCurrentView: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		}
+	},
+	emits: ["update:modelValue", "update:placeholder"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { disabled, readonly, initialFocus, pagedNavigation, weekdayFormat, fixedWeeks, multiple, minValue, maxValue, numberOfMonths, preventDeselect, isDateDisabled: propsIsDateDisabled, isDateUnavailable: propsIsDateUnavailable, calendarLabel, defaultValue, nextPage: propsNextPage, prevPage: propsPrevPage, dir: propDir, locale: propLocale, disableDaysOutsideCurrentView } = toRefs(props);
+		const { primitiveElement, currentElement: parentElement } = usePrimitiveElement();
+		const locale = useLocale(propLocale);
+		const dir = useDirection(propDir);
+		const weekStartsOn = computed(() => props.weekStartsOn ?? getWeekStartsOn(locale.value));
+		const modelValue = useVModel(props, "modelValue", emits, {
+			defaultValue: defaultValue.value,
+			passive: props.modelValue === void 0
+		});
+		const defaultDate = getDefaultDate({
+			defaultPlaceholder: props.placeholder,
+			defaultValue: modelValue.value,
+			locale: props.locale
+		});
+		const placeholder = 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, weekdays, isOutsideVisibleView, nextPage, prevPage, formatter, grid, isPlaceholderFocusable, firstFocusableDate } = useCalendar({
+			locale,
+			placeholder,
+			weekStartsOn,
+			fixedWeeks,
+			numberOfMonths,
+			minValue,
+			maxValue,
+			disabled,
+			weekdayFormat,
+			pagedNavigation,
+			isDateDisabled: propsIsDateDisabled.value,
+			isDateUnavailable: propsIsDateUnavailable.value,
+			calendarLabel,
+			nextPage: propsNextPage,
+			prevPage: propsPrevPage
+		});
+		const { isInvalid, isDateSelected, hasSelectedDate, isSelectedDateDisabled } = useCalendarState({
+			date: modelValue,
+			isDateDisabled,
+			isDateUnavailable
+		});
+		watch(modelValue, (_modelValue) => {
+			if (Array.isArray(_modelValue) && _modelValue.length) {
+				const lastValue = _modelValue.at(-1);
+				if (lastValue && !$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(placeholder.value, lastValue)) onPlaceholderChange(lastValue);
+			} else if (!Array.isArray(_modelValue) && _modelValue && !$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(placeholder.value, _modelValue)) onPlaceholderChange(_modelValue);
+		});
+		function onDateChange(value) {
+			if (!multiple.value) {
+				if (!modelValue.value) {
+					modelValue.value = value.copy();
+					return;
+				}
+				if (!preventDeselect.value && $14e0f24ef4ac5c92$export$91b62ebf2ba703ee(modelValue.value, value)) {
+					placeholder.value = value.copy();
+					modelValue.value = void 0;
+				} else modelValue.value = value.copy();
+			} else if (!modelValue.value) modelValue.value = [value.copy()];
+			else if (Array.isArray(modelValue.value)) {
+				if (modelValue.value.findIndex((date) => $14e0f24ef4ac5c92$export$ea39ec197993aef0(date, value)) === -1) modelValue.value = [...modelValue.value, value];
+				else if (!preventDeselect.value) {
+					const next = modelValue.value.filter((date) => !$14e0f24ef4ac5c92$export$ea39ec197993aef0(date, value));
+					if (!next.length) {
+						placeholder.value = value.copy();
+						modelValue.value = void 0;
+						return;
+					}
+					modelValue.value = next.map((date) => date.copy());
+				}
+			}
+		}
+		onMounted(() => {
+			if (initialFocus.value) handleCalendarInitialFocus(parentElement.value);
+		});
+		provideCalendarRootContext({
+			isDateUnavailable,
+			dir,
+			isDateDisabled,
+			locale,
+			formatter,
+			modelValue,
+			placeholder,
+			disabled,
+			initialFocus,
+			pagedNavigation,
+			grid,
+			weekDays: weekdays,
+			weekStartsOn,
+			weekdayFormat,
+			fixedWeeks,
+			multiple,
+			numberOfMonths,
+			readonly,
+			preventDeselect,
+			fullCalendarLabel,
+			headingValue,
+			isInvalid,
+			isDateSelected,
+			isNextButtonDisabled,
+			isPrevButtonDisabled,
+			isOutsideVisibleView,
+			nextPage,
+			prevPage,
+			parentElement,
+			onPlaceholderChange,
+			onDateChange,
+			disableDaysOutsideCurrentView,
+			minValue,
+			maxValue,
+			isPlaceholderFocusable,
+			firstFocusableDate,
+			hasSelectedDate,
+			isSelectedDateDisabled
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				ref_key: "primitiveElement",
+				ref: primitiveElement,
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				"aria-label": unref(fullCalendarLabel),
+				"data-readonly": unref(readonly) ? "" : void 0,
+				"data-disabled": unref(disabled) ? "" : void 0,
+				"data-invalid": unref(isInvalid) ? "" : void 0,
+				dir: unref(dir)
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {
+					date: unref(placeholder),
+					grid: unref(grid),
+					weekDays: unref(weekdays),
+					weekStartsOn: weekStartsOn.value,
+					locale: unref(locale),
+					fixedWeeks: unref(fixedWeeks),
+					modelValue: unref(modelValue)
+				}), createElementVNode("div", _hoisted_1$1, [createElementVNode("div", _hoisted_2$1, toDisplayString(unref(fullCalendarLabel)), 1)])]),
+				_: 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/Calendar/CalendarCell.js
+var CalendarCell_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarCell",
+	props: {
+		date: {
+			type: null,
+			required: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "td"
+		}
+	},
+	setup(__props) {
+		const rootContext = injectCalendarRootContext();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				role: "gridcell",
+				"aria-selected": unref(rootContext).isDateSelected(_ctx.date) ? true : void 0,
+				"aria-disabled": unref(rootContext).isDateDisabled(_ctx.date) || unref(rootContext).isDateUnavailable?.(_ctx.date) || unref(rootContext).disableDaysOutsideCurrentView.value,
+				"data-disabled": unref(rootContext).isDateDisabled(_ctx.date) || unref(rootContext).disableDaysOutsideCurrentView.value ? "" : void 0
+			}, {
+				default: withCtx(() => [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/Calendar/CalendarCellTrigger.js
+var CalendarCellTrigger_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarCellTrigger",
+	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 kbd = useKbd();
+		const rootContext = injectCalendarRootContext();
+		const { primitiveElement, currentElement } = usePrimitiveElement();
+		const dayValue = computed(() => props.day.day.toLocaleString(rootContext.locale.value));
+		const labelText = computed(() => {
+			return rootContext.formatter.custom(toDate(props.day), {
+				weekday: "long",
+				month: "long",
+				day: "numeric",
+				year: "numeric"
+			});
+		});
+		const isUnavailable = computed(() => rootContext.isDateUnavailable?.(props.day) ?? false);
+		const isDateToday = computed(() => {
+			return $14e0f24ef4ac5c92$export$629b0a497aa65267(props.day, $14e0f24ef4ac5c92$export$aa8b41735afcabd2());
+		});
+		const isOutsideView = computed(() => {
+			return !$14e0f24ef4ac5c92$export$a18c89cbd24170ff(props.day, props.month);
+		});
+		const isOutsideVisibleView = computed(() => rootContext.isOutsideVisibleView(props.day));
+		const isDisabled = computed(() => rootContext.isDateDisabled(props.day) || rootContext.disableDaysOutsideCurrentView.value && isOutsideView.value);
+		const isFocusedDate = computed(() => {
+			if (isOutsideView.value || isDisabled.value) return false;
+			if (!rootContext.disabled.value && rootContext.isPlaceholderFocusable.value && $14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.placeholder.value)) return true;
+			if ((!rootContext.hasSelectedDate.value || rootContext.isSelectedDateDisabled.value) && !rootContext.isPlaceholderFocusable.value) return rootContext.firstFocusableDate.value && $14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.firstFocusableDate.value);
+			return false;
+		});
+		const isSelectedDate = computed(() => rootContext.isDateSelected(props.day));
+		function changeDate(date) {
+			if (rootContext.readonly.value) return;
+			if (rootContext.isDateDisabled(date) || rootContext.isDateUnavailable?.(date)) return;
+			rootContext.onDateChange(date);
+		}
+		function handleClick() {
+			if (isDisabled.value) return;
+			changeDate(props.day);
+		}
+		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(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();
+					}
+					nextTick(() => {
+						shiftFocus(day, add);
+					});
+					return;
+				}
+				if (candidateDay && candidateDay.hasAttribute("data-disabled")) return shiftFocus(candidateDayValue, add);
+				rootContext.onPlaceholderChange(candidateDayValue);
+				candidateDay?.focus();
+			}
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				ref_key: "primitiveElement",
+				ref: primitiveElement,
+				as: props.as,
+				"as-child": props.asChild,
+				role: "button",
+				"aria-label": labelText.value,
+				"data-reka-calendar-cell-trigger": "",
+				"aria-disabled": isDisabled.value || isUnavailable.value ? true : void 0,
+				"data-selected": isSelectedDate.value ? true : 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-outside-visible-view": isOutsideVisibleView.value ? "" : void 0,
+				"data-focused": isFocusedDate.value ? "" : void 0,
+				tabindex: isFocusedDate.value ? 0 : isOutsideView.value || isDisabled.value ? void 0 : -1,
+				onClick: handleClick,
+				onKeydown: withKeys(handleArrowKey, [
+					"up",
+					"down",
+					"left",
+					"right",
+					"space",
+					"enter"
+				])
+			}, {
+				default: withCtx(() => [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
+				}, () => [createTextVNode(toDisplayString(dayValue.value), 1)])]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"aria-label",
+				"aria-disabled",
+				"data-selected",
+				"data-value",
+				"data-disabled",
+				"data-unavailable",
+				"data-today",
+				"data-outside-view",
+				"data-outside-visible-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/Calendar/CalendarGrid.js
+var CalendarGrid_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarGrid",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "table"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectCalendarRootContext();
+		const disabled = computed(() => rootContext.disabled.value ? true : void 0);
+		const readonly = computed(() => rootContext.readonly.value ? true : void 0);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+				tabindex: "-1",
+				role: "application",
+				"aria-readonly": readonly.value,
+				"aria-disabled": disabled.value,
+				"data-readonly": readonly.value && "",
+				"data-disabled": disabled.value && ""
+			}), {
+				default: withCtx(() => [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/Calendar/CalendarGridBody.js
+var CalendarGridBody_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarGridBody",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "tbody"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), normalizeProps(guardReactiveProps(props)), {
+				default: withCtx(() => [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/Calendar/CalendarGridHead.js
+var CalendarGridHead_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarGridHead",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "thead"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps(props, { "aria-hidden": "true" }), {
+				default: withCtx(() => [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/Calendar/CalendarGridRow.js
+var CalendarGridRow_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarGridRow",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "tr"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), normalizeProps(guardReactiveProps(props)), {
+				default: withCtx(() => [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/Calendar/CalendarHeadCell.js
+var CalendarHeadCell_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarHeadCell",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "th"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), normalizeProps(guardReactiveProps(props)), {
+				default: withCtx(() => [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/Calendar/CalendarHeading.js
+var CalendarHeading_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarHeading",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectCalendarRootContext();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps(props, { "data-disabled": unref(rootContext).disabled.value ? "" : void 0 }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { headingValue: unref(rootContext).headingValue.value }, () => [createTextVNode(toDisplayString(unref(rootContext).headingValue.value), 1)])]),
+				_: 3
+			}, 16, ["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/Calendar/CalendarNext.js
+var CalendarNext_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarNext",
+	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 = computed(() => rootContext.disabled.value || rootContext.isNextButtonDisabled(props.nextPage));
+		const rootContext = injectCalendarRootContext();
+		function handleClick() {
+			if (disabled.value) return;
+			rootContext.nextPage(props.nextPage);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(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: withCtx(() => [renderSlot(_ctx.$slots, "default", { disabled: disabled.value }, () => [_cache[0] || (_cache[0] = 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/Calendar/CalendarPrev.js
+var CalendarPrev_default = /* @__PURE__ */ defineComponent({
+	__name: "CalendarPrev",
+	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 = computed(() => rootContext.disabled.value || rootContext.isPrevButtonDisabled(props.prevPage));
+		const rootContext = injectCalendarRootContext();
+		function handleClick() {
+			if (disabled.value) return;
+			rootContext.prevPage(props.prevPage);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				"aria-label": "Previous page",
+				as: props.as,
+				"as-child": props.asChild,
+				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: withCtx(() => [renderSlot(_ctx.$slots, "default", { disabled: disabled.value }, () => [_cache[0] || (_cache[0] = createTextVNode(" Prev page "))])]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"type",
+				"aria-disabled",
+				"data-disabled",
+				"disabled"
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/calendar/calendar.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "celeste-calendar-header" };
+var _hoisted_2 = { class: "celeste-calendar-months" };
+var _hoisted_3 = { class: "celeste-calendar-day-number" };
+//#endregion
+//#region src/components/calendar/calendar.vue
+var calendar_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "calendar",
+	props: {
+		class: {},
+		markedDates: {},
+		defaultValue: {},
+		defaultPlaceholder: {},
+		placeholder: {},
+		pagedNavigation: { type: Boolean },
+		preventDeselect: { type: Boolean },
+		weekStartsOn: { default: 1 },
+		weekdayFormat: { default: "short" },
+		calendarLabel: {},
+		fixedWeeks: {
+			type: Boolean,
+			default: true
+		},
+		maxValue: {},
+		minValue: {},
+		locale: {},
+		numberOfMonths: {},
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		initialFocus: { type: Boolean },
+		isDateDisabled: {},
+		isDateUnavailable: {},
+		dir: {},
+		nextPage: {},
+		prevPage: {},
+		modelValue: {},
+		multiple: { type: Boolean },
+		disableDaysOutsideCurrentView: { type: Boolean },
+		asChild: { type: Boolean },
+		as: {}
+	},
+	emits: ["update:modelValue", "update:placeholder"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const forwarded = useForwardPropsEmits(useDelegatedProps(props, ["class", "markedDates"]), emits);
+		function isMarked(date) {
+			return props.markedDates?.some((marked) => $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 openBlock(), createBlock(unref(CalendarRoot_default), mergeProps(unref(forwarded), { class: unref(clsx)("celeste-calendar", props.class) }), {
+				default: withCtx(({ weekDays, grid }) => [createElementVNode("div", _hoisted_1, [
+					createVNode(unref(CalendarPrev_default), { "as-child": "" }, {
+						default: withCtx(() => _cache[0] || (_cache[0] = [createElementVNode("button", {
+							type: "button",
+							class: "celeste-calendar-nav"
+						}, [createElementVNode("i", { class: "i-celeste-arrow-left-s-line" })], -1)])),
+						_: 1
+					}),
+					createVNode(unref(CalendarHeading_default), { class: "celeste-calendar-heading" }),
+					createVNode(unref(CalendarNext_default), { "as-child": "" }, {
+						default: withCtx(() => _cache[1] || (_cache[1] = [createElementVNode("button", {
+							type: "button",
+							class: "celeste-calendar-nav"
+						}, [createElementVNode("i", { class: "i-celeste-arrow-right-s-line" })], -1)])),
+						_: 1
+					})
+				]), createElementVNode("div", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(grid, (month) => {
+					return openBlock(), createBlock(unref(CalendarGrid_default), {
+						key: month.value.toString(),
+						class: "celeste-calendar-grid"
+					}, {
+						default: withCtx(() => [createVNode(unref(CalendarGridHead_default), null, {
+							default: withCtx(() => [createVNode(unref(CalendarGridRow_default), { class: "celeste-calendar-week" }, {
+								default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(weekDays, (day) => {
+									return openBlock(), createBlock(unref(CalendarHeadCell_default), {
+										key: day,
+										class: "celeste-calendar-weekday"
+									}, {
+										default: withCtx(() => [createTextVNode(toDisplayString(weekdayLabel(day)), 1)]),
+										_: 2
+									}, 1024);
+								}), 128))]),
+								_: 2
+							}, 1024)]),
+							_: 2
+						}, 1024), createVNode(unref(CalendarGridBody_default), { class: "celeste-calendar-body" }, {
+							default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(month.rows, (weekDates, index) => {
+								return openBlock(), createBlock(unref(CalendarGridRow_default), {
+									key: `week-${index}`,
+									class: "celeste-calendar-week"
+								}, {
+									default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(weekDates, (weekDate) => {
+										return openBlock(), createBlock(unref(CalendarCell_default), {
+											key: weekDate.toString(),
+											date: weekDate,
+											class: "celeste-calendar-cell"
+										}, {
+											default: withCtx(() => [createVNode(unref(CalendarCellTrigger_default), {
+												day: weekDate,
+												month: month.value,
+												class: "celeste-calendar-day",
+												"data-marked": isMarked(weekDate) ? "" : void 0
+											}, {
+												default: withCtx(() => [createElementVNode("span", _hoisted_3, 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"]);
+		};
+	}
+}), [["__scopeId", "data-v-b0c6d2f8"]]);
+//#endregion
+export { calendar_default as t };