@datum-cloud/datum-ui 1.3.2 → 1.5.0

package/dist/picker-CRUSdzpo.mjs

@@ -0,0 +1,1945 @@
+import { t as cn } from "./utils-Bu32wN-x.mjs";
+import { t as Button } from "./button-A1qTjZ8U.mjs";
+import { t as Button$1 } from "./button-CsdF61EI.mjs";
+import { Calendar } from "./calendar/index.mjs";
+import { t as useBreakpoint } from "./use-breakpoint-CwiUJSmk.mjs";
+import { t as ResponsivePopover } from "./responsive-popover-DJZgXWIE.mjs";
+import { i as SelectItem, l as SelectTrigger, n as SelectContent, t as Select, u as SelectValue } from "./select-daE2Nn0Z.mjs";
+import { n as OptionList, t as useOptionPicker } from "./use-option-picker-CV-9CyBV.mjs";
+import { CalendarIcon, Clock, Globe, X } from "lucide-react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { formatInTimeZone, fromZonedTime, toZonedTime } from "date-fns-tz";
+import { addDays, differenceInCalendarDays, endOfDay, endOfMonth, endOfWeek, endOfYear, format, startOfDay, startOfMonth, startOfWeek, startOfYear, subDays, subHours, subMinutes } from "date-fns";
+//#region src/components/features/_shared/timezone.ts
+/**
+* Start of the calendar day (00:00:00.000) for `date`, interpreted in
+* `timezone`, returned as a real UTC instant.
+*
+* Shared canonical implementation — preset engines (picker + legacy
+* time-range-picker) build tz-aware day boundaries on top of this.
+*/
+function startOfDayInTz(date, timezone) {
+	const zoned = toZonedTime(date, timezone);
+	zoned.setHours(0, 0, 0, 0);
+	return fromZonedTime(zoned, timezone);
+}
+/**
+* End of the calendar day (23:59:59.999) for `date`, interpreted in
+* `timezone`, returned as a real UTC instant.
+*/
+function endOfDayInTz(date, timezone) {
+	const zoned = toZonedTime(date, timezone);
+	zoned.setHours(23, 59, 59, 999);
+	return fromZonedTime(zoned, timezone);
+}
+//#endregion
+//#region src/components/base/date-picker/use-date-constraints.ts
+function useDateConstraints({ minDate, maxDate, disablePast, disableFuture }) {
+	const today = useMemo(() => /* @__PURE__ */ new Date(), []);
+	const effectiveMinDate = useMemo(() => {
+		let min = minDate;
+		if (disablePast) {
+			const todayStart = startOfDay(today);
+			min = min ? min > todayStart ? min : todayStart : todayStart;
+		}
+		return min;
+	}, [
+		minDate,
+		disablePast,
+		today
+	]);
+	const effectiveMaxDate = useMemo(() => {
+		let max = maxDate;
+		if (disableFuture) {
+			const todayEnd = endOfDay(today);
+			max = max ? max < todayEnd ? max : todayEnd : todayEnd;
+		}
+		return max;
+	}, [
+		maxDate,
+		disableFuture,
+		today
+	]);
+	return {
+		effectiveMinDate,
+		effectiveMaxDate,
+		isDateDisabled: useCallback((date) => {
+			if (effectiveMinDate && date < effectiveMinDate) return true;
+			if (effectiveMaxDate && date > effectiveMaxDate) return true;
+			return false;
+		}, [effectiveMinDate, effectiveMaxDate])
+	};
+}
+//#endregion
+//#region src/components/features/picker/types.ts
+const RANGE_MODES = [
+	"date-range",
+	"time-range",
+	"datetime-range",
+	"date-range-time"
+];
+const TIME_BEARING_MODES = [
+	"time",
+	"time-range",
+	"datetime",
+	"datetime-range",
+	"date-range-time"
+];
+const DATE_BEARING_MODES = [
+	"date",
+	"date-range",
+	"datetime",
+	"datetime-range",
+	"date-range-time"
+];
+function isRangeMode(mode) {
+	return RANGE_MODES.includes(mode);
+}
+function isTimeBearingMode(mode) {
+	return TIME_BEARING_MODES.includes(mode);
+}
+function isDateBearingMode(mode) {
+	return DATE_BEARING_MODES.includes(mode);
+}
+const ALLOWED_STEPS = [
+	1,
+	5,
+	10,
+	15,
+	30,
+	60
+];
+//#endregion
+//#region src/components/features/picker/utils/timezone.ts
+/** Browser-detected IANA timezone, falling back to UTC if unavailable. */
+function getBrowserTimezone() {
+	try {
+		return Intl.DateTimeFormat().resolvedOptions().timeZone;
+	} catch {
+		return "UTC";
+	}
+}
+/**
+* UTC offset for a timezone in `±HH:MM` format.
+* Returns `+00:00` for UTC or any timezone the runtime cannot resolve.
+*/
+function getTimezoneOffset(timezone) {
+	try {
+		const offsetPart = new Intl.DateTimeFormat("en-US", {
+			timeZone: timezone,
+			timeZoneName: "shortOffset"
+		}).formatToParts(/* @__PURE__ */ new Date()).find((p) => p.type === "timeZoneName");
+		if (!offsetPart) return "+00:00";
+		const match = /GMT([+-])(\d+)(?::(\d+))?/.exec(offsetPart.value);
+		if (match) return `${match[1]}${match[2].padStart(2, "0")}:${match[3]?.padStart(2, "0") ?? "00"}`;
+		if (offsetPart.value === "GMT") return "+00:00";
+		return "+00:00";
+	} catch {
+		return "+00:00";
+	}
+}
+/**
+* Human-readable timezone label.
+* Example: `'Asia/Jakarta'` → `'Asia/Jakarta (UTC+07:00)'`.
+*/
+function formatTimezoneLabel(timezone) {
+	const offset = getTimezoneOffset(timezone);
+	return `${timezone.replace(/_/g, " ")} (UTC${offset})`;
+}
+/**
+* Convert a UTC ISO string to a Date object whose wall-clock components
+* (year/month/day/hours/minutes) reflect the value as seen in `timezone`.
+*
+* Use this to feed Calendar / time slot UI that reads `getHours()` etc.
+*
+* Round-trips exactly outside DST transition windows:
+* `zonedDateToIso(isoToZonedDate(iso, tz), tz) === iso`. Inside a DST
+* fall-back the wall-clock hour is ambiguous (it occurs twice), so the
+* round-trip may shift the resulting instant by the DST offset. Callers that
+* must survive the ambiguous hour should key off the original ISO, not the
+* re-encoded one.
+*/
+function isoToZonedDate(iso, timezone) {
+	return toZonedTime(new Date(iso), timezone);
+}
+/**
+* Date-input variant of `isoToZonedDate`. Skips the ISO round-trip when the
+* caller already has a Date instance (e.g. preset `getRange(tz)` results).
+*/
+function dateToZoned(date, timezone) {
+	return toZonedTime(date, timezone);
+}
+/**
+* Inverse of `isoToZonedDate`. Treat the Date's wall-clock components
+* as `timezone`-local and convert back to a UTC ISO instant.
+*/
+function zonedDateToIso(date, timezone) {
+	return fromZonedTime(date, timezone).toISOString();
+}
+/**
+* Format a UTC ISO string in the given timezone using a date-fns format pattern.
+* Returns empty string if the input is not a valid date.
+*/
+function formatInTimezone(iso, timezone, pattern) {
+	try {
+		const d = new Date(iso);
+		if (Number.isNaN(d.getTime())) return "";
+		return formatInTimeZone(d, timezone, pattern);
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/components/features/picker/components/context.ts
+const PickerContext = createContext(null);
+/** Throws when used outside `<Picker.Root>` — enforces compound-component discipline. */
+function usePickerContext() {
+	const ctx = useContext(PickerContext);
+	if (!ctx) throw new Error("Picker primitives must be rendered inside <Picker.Root>");
+	return ctx;
+}
+//#endregion
+//#region src/components/features/picker/components/calendar.tsx
+/**
+* Override the base Calendar's default `w-fit` root so the calendar fills the
+* mobile sheet width (cells flex via the underlying day-picker) and reverts to
+* intrinsic width on `md` and above.
+*/
+const CALENDAR_RESPONSIVE_CLASSNAMES = { root: "w-full md:w-fit" };
+/**
+* react-day-picker hands back the clicked day cell at midnight, discarding any
+* time-of-day the user already chose via the time input. Re-apply the previous
+* wall-clock time (read from the pending ISO in the display timezone) onto the
+* newly clicked day so selecting a different date keeps the time (BUG-033).
+*/
+function mergeTimeFromIso(day, prevIso, timezone) {
+	const merged = new Date(day);
+	if (typeof prevIso === "string") {
+		const prev = isoToZonedDate(prevIso, timezone);
+		if (!Number.isNaN(prev.getTime())) merged.setHours(prev.getHours(), prev.getMinutes(), prev.getSeconds(), prev.getMilliseconds());
+	}
+	return merged;
+}
+function PickerCalendar({ numberOfMonths = 1, className, minDate, maxDate, disablePast, disableFuture }) {
+	const { mode, timezone, state, actions } = usePickerContext();
+	const { effectiveMinDate, effectiveMaxDate, isDateDisabled } = useDateConstraints({
+		minDate,
+		maxDate,
+		disablePast,
+		disableFuture
+	});
+	if (!isDateBearingMode(mode)) return null;
+	const month = state.monthFrom ?? (() => {
+		if (mode === "date" && state.pendingValue instanceof Date) return state.pendingValue;
+		if (mode === "datetime" && typeof state.pendingValue === "string") return isoToZonedDate(state.pendingValue, timezone);
+	})();
+	if (mode === "date-range" || mode === "date-range-time" || mode === "datetime-range") {
+		const v = state.pendingValue;
+		return /* @__PURE__ */ jsx(Calendar, {
+			mode: "range",
+			selected: v ? mode === "date-range" ? {
+				from: v.from,
+				to: v.to
+			} : {
+				from: isoToZonedDate(v.from, timezone),
+				to: isoToZonedDate(v.to, timezone)
+			} : void 0,
+			onSelect: (range) => {
+				if (!range?.from || !range?.to) return;
+				if (mode === "date-range") actions.setRange({
+					from: range.from,
+					to: range.to
+				});
+				else {
+					const prev = v;
+					actions.setDatetimeRange({
+						from: zonedDateToIso(mergeTimeFromIso(range.from, prev?.from, timezone), timezone),
+						to: zonedDateToIso(mergeTimeFromIso(range.to, prev?.to, timezone), timezone)
+					});
+				}
+			},
+			defaultMonth: month,
+			month,
+			onMonthChange: actions.setMonthFrom,
+			numberOfMonths,
+			disabled: isDateDisabled,
+			startMonth: effectiveMinDate,
+			endMonth: effectiveMaxDate,
+			className,
+			classNames: CALENDAR_RESPONSIVE_CLASSNAMES
+		});
+	}
+	return /* @__PURE__ */ jsx(Calendar, {
+		mode: "single",
+		selected: state.pendingValue instanceof Date ? state.pendingValue : mode === "datetime" && typeof state.pendingValue === "string" ? isoToZonedDate(state.pendingValue, timezone) : void 0,
+		onSelect: (d) => {
+			if (!d) return;
+			if (mode === "date") actions.setSingleDate(d);
+			else if (mode === "datetime") {
+				const merged = mergeTimeFromIso(d, state.pendingValue, timezone);
+				actions.setSingleDatetime(zonedDateToIso(merged, timezone));
+			}
+		},
+		defaultMonth: month,
+		month,
+		onMonthChange: actions.setMonthFrom,
+		disabled: isDateDisabled,
+		startMonth: effectiveMinDate,
+		endMonth: effectiveMaxDate,
+		className,
+		classNames: CALENDAR_RESPONSIVE_CLASSNAMES
+	});
+}
+PickerCalendar.displayName = "Picker.Calendar";
+//#endregion
+//#region src/components/features/picker/components/content.tsx
+function PickerContent({ trigger, sheetTitle, sheetDescription, footer, align = "start", side = "bottom", modal, contentClassName, children }) {
+	const { state, actions, effectiveCommit, responsive, breakpoint } = usePickerContext();
+	const isMobileSheet = responsive && breakpoint === "mobile";
+	const desktopFooter = !isMobileSheet && effectiveCommit === "apply" ? footer : null;
+	const sheetFooter = isMobileSheet ? footer : void 0;
+	return /* @__PURE__ */ jsx(ResponsivePopover, {
+		open: state.open,
+		onOpenChange: (open) => open ? actions.open() : actions.close(),
+		trigger,
+		sheetTitle,
+		sheetDescription,
+		sheetFooter,
+		align,
+		side,
+		modal,
+		responsive,
+		contentClassName: cn("w-auto", contentClassName),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col",
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "flex flex-col",
+				children
+			}), desktopFooter && /* @__PURE__ */ jsx("div", {
+				className: "border-t p-3",
+				children: desktopFooter
+			})]
+		})
+	});
+}
+PickerContent.displayName = "Picker.Content";
+//#endregion
+//#region src/components/features/picker/components/footer.tsx
+function PickerFooter({ children, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex items-center justify-end gap-2", className),
+		children
+	});
+}
+PickerFooter.displayName = "Picker.Footer";
+function PickerApply({ children = "Apply" }) {
+	const { state, actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "primary",
+		theme: "solid",
+		size: "xs",
+		disabled: state.pendingValue === null || state.pendingValue === void 0,
+		onClick: actions.apply,
+		children
+	});
+}
+PickerApply.displayName = "Picker.Apply";
+function PickerReset({ children = "Reset" }) {
+	const { actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "quaternary",
+		theme: "outline",
+		size: "xs",
+		onClick: actions.reset,
+		children
+	});
+}
+PickerReset.displayName = "Picker.Reset";
+function PickerCancel({ children = "Cancel" }) {
+	const { actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "quaternary",
+		theme: "borderless",
+		size: "xs",
+		onClick: actions.cancel,
+		children
+	});
+}
+PickerCancel.displayName = "Picker.Cancel";
+function PickerClear({ children = "Clear" }) {
+	const { actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "primary",
+		theme: "borderless",
+		size: "xs",
+		onClick: actions.clear,
+		children
+	});
+}
+PickerClear.displayName = "Picker.Clear";
+//#endregion
+//#region src/components/features/picker/components/presets.tsx
+function PickerPresets({ className }) {
+	const { presets, state, actions, timezone } = usePickerContext();
+	if (presets.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("border-border hidden flex-col gap-1 border-r p-2 md:flex", className),
+		children: presets.map((preset) => {
+			return /* @__PURE__ */ jsxs(Button$1, {
+				type: "button",
+				variant: state.selectedPresetKey === preset.key ? "default" : "ghost",
+				size: "sm",
+				className: "justify-start font-normal",
+				onClick: () => {
+					const range = preset.getRange(timezone);
+					actions.selectPreset(range, preset.key);
+				},
+				children: [/* @__PURE__ */ jsx("span", { children: preset.label }), preset.shortcut && /* @__PURE__ */ jsx("kbd", {
+					className: "bg-muted ml-auto hidden rounded border px-1.5 font-mono text-[10px] sm:inline-flex",
+					children: preset.shortcut
+				})]
+			}, preset.key);
+		})
+	});
+}
+PickerPresets.displayName = "Picker.Presets";
+//#endregion
+//#region src/components/features/picker/hooks/use-keyboard-shortcuts.ts
+/** True when the event target is a text-editable control we must not hijack. */
+function isEditableTarget(target) {
+	if (!(target instanceof HTMLElement)) return false;
+	const tag = target.tagName;
+	return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || target.isContentEditable;
+}
+/**
+* Bind preset keyboard shortcuts while the picker is open.
+*
+* The listener is attached to `document` rather than the picker root, because
+* the popover content is portaled to `document.body` and is therefore outside
+* the root's DOM subtree — a root-scoped listener never sees those keydowns
+* once focus moves into the popover (BUG-078).
+*
+* To keep the legacy footgun fixed (presets firing while the user types in an
+* input), keydowns originating from editable controls are ignored. Modifier
+* keys (Ctrl, Meta, Alt) are also ignored to avoid colliding with browser/OS
+* shortcuts.
+*/
+function useKeyboardShortcuts({ presets, onSelect, enabled }) {
+	useEffect(() => {
+		if (!enabled) return;
+		function handler(e) {
+			if (e.ctrlKey || e.metaKey || e.altKey) return;
+			if (isEditableTarget(e.target)) return;
+			const matched = presets.find((p) => p.shortcut && p.shortcut.toLowerCase() === e.key.toLowerCase());
+			if (matched) {
+				e.preventDefault();
+				onSelect(matched);
+			}
+		}
+		document.addEventListener("keydown", handler);
+		return () => document.removeEventListener("keydown", handler);
+	}, [
+		presets,
+		onSelect,
+		enabled
+	]);
+}
+//#endregion
+//#region src/components/features/picker/utils/commit.ts
+/**
+* Resolves the effective commit semantics for a picker.
+*
+* - Date + time combined modes (`datetime` / `datetime-range` /
+*   `date-range-time`) **always** commit on Apply, regardless of the
+*   caller-supplied override. Picking a date alone shouldn't publish a
+*   value with an unconfirmed 00:00 time — the user needs to set the
+*   time too, then explicitly Apply. The wrappers don't expose a
+*   `commit` prop for these modes; primitive consumers can still pass
+*   one through `Picker.Root` but it's silently overridden here.
+* - Range modes (`date-range`, `time-range`) default to `'apply'`.
+* - Everything else defaults to `'immediate'`.
+*/
+function resolveCommit(mode, commit) {
+	if (isDateBearingMode(mode) && isTimeBearingMode(mode)) return "apply";
+	return commit ?? (isRangeMode(mode) ? "apply" : "immediate");
+}
+//#endregion
+//#region src/components/features/picker/utils/format.ts
+/**
+* Format a Date as YYYY-MM-DD using local-time components.
+*
+* Note: this is the consumer-friendly format for date-only modes.
+* It does NOT round-trip through timezones; that's intentional —
+* a calendar day has no timezone.
+*/
+function dateToYYYYMMDD(d) {
+	return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+/**
+* Extract `"HH:mm"` from a Date using its wall-clock components.
+*
+* Caller is responsible for ensuring those components reflect the
+* intended timezone (typically via `dateToZoned` / `isoToZonedDate`
+* upstream). Pads single-digit hour/minute to two characters.
+*/
+function dateToHHmm(d) {
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+const TIME_REGEX = /^(\d{2}):(\d{2})$/;
+/**
+* Strict HH:mm validation. Rejects single-digit components,
+* out-of-range hours/minutes, and any non-numeric content.
+*/
+function isValidTimeString(s) {
+	const match = TIME_REGEX.exec(s);
+	if (!match) return false;
+	const h = Number(match[1]);
+	const m = Number(match[2]);
+	return h >= 0 && h <= 23 && m >= 0 && m <= 59;
+}
+/**
+* Parse a HH:mm string. Returns null for invalid input.
+*/
+function parseTimeString(s) {
+	if (!isValidTimeString(s)) return null;
+	const match = TIME_REGEX.exec(s);
+	return {
+		h: Number(match[1]),
+		m: Number(match[2])
+	};
+}
+/**
+* Format a HH:mm string for user display, respecting hour cycle.
+*
+* - `'24'`: returns the input as-is (`"14:30"`)
+* - `'12'`: returns `"2:30 PM"` style with AM/PM and no leading zero on hour
+*
+* Returns empty string for invalid input — callers should validate first.
+*/
+function formatTimeLabel(time, hourCycle) {
+	const parsed = parseTimeString(time);
+	if (!parsed) return "";
+	if (hourCycle === "24") return time;
+	const period = parsed.h >= 12 ? "PM" : "AM";
+	return `${parsed.h === 0 ? 12 : parsed.h > 12 ? parsed.h - 12 : parsed.h}:${String(parsed.m).padStart(2, "0")} ${period}`;
+}
+//#endregion
+//#region src/components/features/picker/hooks/use-picker-state.ts
+function reducer(state, action) {
+	switch (action.type) {
+		case "SET_SINGLE_DATE":
+		case "SET_SINGLE_TIME":
+		case "SET_SINGLE_DATETIME":
+		case "SET_RANGE":
+		case "SET_TIME_RANGE":
+		case "SET_DATETIME_RANGE": return {
+			...state,
+			pendingValue: action.payload,
+			selectedPresetKey: void 0
+		};
+		case "SELECT_PRESET": return {
+			...state,
+			pendingValue: action.payload.pendingValue,
+			selectedPresetKey: action.payload.key,
+			monthFrom: action.payload.monthFrom,
+			monthTo: action.payload.monthTo
+		};
+		case "SET_MONTH_FROM": return {
+			...state,
+			monthFrom: action.payload
+		};
+		case "SET_MONTH_TO": return {
+			...state,
+			monthTo: action.payload
+		};
+		case "OPEN": return {
+			...state,
+			open: true
+		};
+		case "CLOSE": return {
+			...state,
+			open: false
+		};
+		case "RESET_TO": return {
+			...state,
+			pendingValue: action.payload,
+			selectedPresetKey: void 0
+		};
+		case "CLEAR_PRESET": return {
+			...state,
+			selectedPresetKey: void 0
+		};
+		default: return state;
+	}
+}
+/**
+* Convert a preset's `{ from: Date, to: Date }` (real UTC instants) into the
+* value shape that the picker's `mode` actually emits.
+*
+* - `date-range`: pass through (Dates).
+* - `datetime-range` / `date-range-time`: `.toISOString()` — instants already match.
+* - `time-range`: extract wall-clock `HH:mm` in the active timezone.
+* - single `date` / `datetime` / `time`: collapse the preset window to its
+*   end instant (`range.to`, typically "now") — a preset in single mode should
+*   set that instant, never wipe the value to `null`.
+*/
+function presetValueForMode(mode, range, key, timezone) {
+	switch (mode) {
+		case "date-range": return {
+			from: range.from,
+			to: range.to,
+			preset: key
+		};
+		case "datetime-range":
+		case "date-range-time": return {
+			from: range.from.toISOString(),
+			to: range.to.toISOString(),
+			preset: key
+		};
+		case "time-range": return {
+			from: dateToHHmm(dateToZoned(range.from, timezone)),
+			to: dateToHHmm(dateToZoned(range.to, timezone)),
+			preset: key
+		};
+		case "date": return range.to;
+		case "datetime": return range.to.toISOString();
+		case "time": return dateToHHmm(dateToZoned(range.to, timezone));
+		default: return null;
+	}
+}
+/**
+* Structural equality for picker value shapes (null, Date, `HH:mm` string,
+* ISO string, or `{ from, to, preset? }`). Lets prop→pending sync compare by
+* content rather than object identity.
+*/
+function isSameValue(a, b) {
+	if (a === b) return true;
+	if (a == null || b == null) return a === b;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (typeof a === "object" && typeof b === "object") {
+		const av = a;
+		const bv = b;
+		return isSameValue(av.from, bv.from) && isSameValue(av.to, bv.to) && av.preset === bv.preset;
+	}
+	return false;
+}
+function usePickerState({ mode, value, onChange, commit, timezone }) {
+	const effectiveCommit = resolveCommit(mode, commit);
+	const [state, dispatch] = useReducer(reducer, void 0, () => ({
+		pendingValue: value,
+		open: false,
+		selectedPresetKey: void 0,
+		monthFrom: void 0,
+		monthTo: void 0
+	}));
+	const lastSyncedValueRef = useRef(value);
+	useEffect(() => {
+		if (isSameValue(lastSyncedValueRef.current, value)) return;
+		const hasUncommittedEdits = !isSameValue(state.pendingValue, lastSyncedValueRef.current);
+		if (state.open && hasUncommittedEdits) return;
+		lastSyncedValueRef.current = value;
+		dispatch({
+			type: "RESET_TO",
+			payload: value
+		});
+	}, [
+		value,
+		state.open,
+		state.pendingValue
+	]);
+	const onChangeRef = useRef(onChange);
+	const valueRef = useRef(value);
+	const pendingValueRef = useRef(state.pendingValue);
+	const effectiveCommitRef = useRef(effectiveCommit);
+	const modeRef = useRef(mode);
+	const timezoneRef = useRef(timezone);
+	useEffect(() => {
+		onChangeRef.current = onChange;
+		valueRef.current = value;
+		pendingValueRef.current = state.pendingValue;
+		effectiveCommitRef.current = effectiveCommit;
+		modeRef.current = mode;
+		timezoneRef.current = timezone;
+	});
+	const commitValue = useCallback((next) => {
+		onChangeRef.current(next);
+	}, []);
+	const actions = useMemo(() => {
+		const setSingleValue = (action) => {
+			dispatch(action);
+			if (effectiveCommitRef.current === "immediate") {
+				commitValue(action.payload);
+				dispatch({ type: "CLOSE" });
+			}
+		};
+		return {
+			setSingleDate: (d) => setSingleValue({
+				type: "SET_SINGLE_DATE",
+				payload: d
+			}),
+			setSingleTime: (t) => setSingleValue({
+				type: "SET_SINGLE_TIME",
+				payload: t
+			}),
+			setSingleDatetime: (iso) => setSingleValue({
+				type: "SET_SINGLE_DATETIME",
+				payload: iso
+			}),
+			setRange: (r) => {
+				dispatch({
+					type: "SET_RANGE",
+					payload: r
+				});
+				if (effectiveCommitRef.current === "immediate" && r !== null && r.from.getTime() !== r.to.getTime()) {
+					commitValue(r);
+					dispatch({ type: "CLOSE" });
+				}
+			},
+			setTimeRange: (r) => {
+				dispatch({
+					type: "SET_TIME_RANGE",
+					payload: r
+				});
+				if (effectiveCommitRef.current === "immediate" && r !== null) {
+					commitValue(r);
+					dispatch({ type: "CLOSE" });
+				}
+			},
+			setDatetimeRange: (r) => {
+				dispatch({
+					type: "SET_DATETIME_RANGE",
+					payload: r
+				});
+				if (effectiveCommitRef.current === "immediate" && r !== null) {
+					commitValue(r);
+					dispatch({ type: "CLOSE" });
+				}
+			},
+			selectPreset: (range, key) => {
+				const pendingValue = presetValueForMode(modeRef.current, range, key, timezoneRef.current);
+				dispatch({
+					type: "SELECT_PRESET",
+					payload: {
+						pendingValue,
+						key,
+						monthFrom: range.from,
+						monthTo: range.to
+					}
+				});
+				commitValue(pendingValue);
+				dispatch({ type: "CLOSE" });
+			},
+			setMonthFrom: (d) => dispatch({
+				type: "SET_MONTH_FROM",
+				payload: d
+			}),
+			setMonthTo: (d) => dispatch({
+				type: "SET_MONTH_TO",
+				payload: d
+			}),
+			open: () => dispatch({ type: "OPEN" }),
+			close: () => dispatch({ type: "CLOSE" }),
+			apply: () => {
+				commitValue(pendingValueRef.current);
+				dispatch({ type: "CLOSE" });
+			},
+			reset: () => dispatch({
+				type: "RESET_TO",
+				payload: valueRef.current
+			}),
+			cancel: () => {
+				dispatch({
+					type: "RESET_TO",
+					payload: valueRef.current
+				});
+				dispatch({ type: "CLOSE" });
+			},
+			clear: () => {
+				dispatch({
+					type: "RESET_TO",
+					payload: null
+				});
+				commitValue(null);
+			}
+		};
+	}, [commitValue]);
+	return {
+		state: {
+			pendingValue: state.pendingValue,
+			open: state.open,
+			selectedPresetKey: state.selectedPresetKey,
+			monthFrom: state.monthFrom,
+			monthTo: state.monthTo
+		},
+		actions
+	};
+}
+//#endregion
+//#region src/components/features/picker/presets/defaults.ts
+/**
+* Compute a `{ from, to }` window in `tz` wall-clock space using date-fns
+* boundary helpers, then project both ends back to real UTC instants. Keeps
+* calendar-unit presets (week/month/year) timezone-aware, matching the
+* day-granularity presets.
+*/
+function zonedWindow(tz, start, end) {
+	const zonedNow = toZonedTime(/* @__PURE__ */ new Date(), tz);
+	return {
+		from: fromZonedTime(start(zonedNow), tz),
+		to: fromZonedTime(end(zonedNow), tz)
+	};
+}
+/**
+* Date-bearing presets. Operate on calendar days; ignore time-of-day.
+*/
+const DATE_PRESETS = [
+	{
+		key: "today",
+		label: "Today",
+		shortcut: "D",
+		getRange: (tz) => ({
+			from: startOfDayInTz(/* @__PURE__ */ new Date(), tz),
+			to: endOfDayInTz(/* @__PURE__ */ new Date(), tz)
+		})
+	},
+	{
+		key: "yesterday",
+		label: "Yesterday",
+		shortcut: "Y",
+		getRange: (tz) => {
+			const y = subDays(/* @__PURE__ */ new Date(), 1);
+			return {
+				from: startOfDayInTz(y, tz),
+				to: endOfDayInTz(y, tz)
+			};
+		}
+	},
+	{
+		key: "this-week",
+		label: "This Week",
+		getRange: (tz) => zonedWindow(tz, (d) => startOfWeek(d, { weekStartsOn: 1 }), (d) => endOfWeek(d, { weekStartsOn: 1 }))
+	},
+	{
+		key: "last-7-days",
+		label: "Last 7 Days",
+		shortcut: "W",
+		getRange: (tz) => ({
+			from: startOfDayInTz(subDays(/* @__PURE__ */ new Date(), 6), tz),
+			to: endOfDayInTz(/* @__PURE__ */ new Date(), tz)
+		})
+	},
+	{
+		key: "this-month",
+		label: "This Month",
+		getRange: (tz) => zonedWindow(tz, startOfMonth, endOfMonth)
+	},
+	{
+		key: "last-30-days",
+		label: "Last 30 Days",
+		shortcut: "M",
+		getRange: (tz) => ({
+			from: startOfDayInTz(subDays(/* @__PURE__ */ new Date(), 29), tz),
+			to: endOfDayInTz(/* @__PURE__ */ new Date(), tz)
+		})
+	},
+	{
+		key: "this-year",
+		label: "This Year",
+		getRange: (tz) => zonedWindow(tz, startOfYear, endOfYear)
+	}
+];
+/**
+* Datetime-bearing presets. Use "now" as the upper bound for past windows
+* (so the picker doesn't propose future timestamps).
+*/
+const DATETIME_PRESETS = [
+	{
+		key: "last-15m",
+		label: "Last 15 minutes",
+		shortcut: "1",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subMinutes(now, 15),
+				to: now
+			};
+		}
+	},
+	{
+		key: "last-1h",
+		label: "Last hour",
+		shortcut: "H",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subHours(now, 1),
+				to: now
+			};
+		}
+	},
+	{
+		key: "last-24h",
+		label: "Last 24 hours",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subHours(now, 24),
+				to: now
+			};
+		}
+	},
+	{
+		key: "today",
+		label: "Today",
+		shortcut: "D",
+		getRange: (tz) => ({
+			from: startOfDayInTz(/* @__PURE__ */ new Date(), tz),
+			to: /* @__PURE__ */ new Date()
+		})
+	},
+	{
+		key: "last-7-days",
+		label: "Last 7 days",
+		shortcut: "W",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subDays(now, 7),
+				to: now
+			};
+		}
+	},
+	{
+		key: "last-30-days",
+		label: "Last 30 days",
+		shortcut: "M",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subDays(now, 30),
+				to: now
+			};
+		}
+	}
+];
+const EMPTY = [];
+/**
+* Default preset set for a given mode. Time-only modes return empty —
+* presets rarely make sense for picking a wall-clock time.
+*/
+function getDefaultPresets(mode) {
+	switch (mode) {
+		case "date":
+		case "date-range": return DATE_PRESETS;
+		case "datetime":
+		case "datetime-range":
+		case "date-range-time": return DATETIME_PRESETS;
+		default: return EMPTY;
+	}
+}
+//#endregion
+//#region src/components/features/picker/hooks/use-presets.ts
+/**
+* Resolve the effective list of presets for a picker.
+*
+* Resolution order:
+*   1. If `custom` is provided, use it as-is (no exclusion, no constraint check).
+*   2. Otherwise: defaults for `mode`, minus `excludeKeys`, minus presets
+*      whose `getRange(timezone).from` or `.to` is rejected by `isDateDisabled`.
+*
+* Returns a memoized array; identity-stable when inputs haven't changed.
+*/
+function usePresets({ mode, timezone, custom, excludeKeys, isDateDisabled }) {
+	return useMemo(() => {
+		if (custom) return custom;
+		const base = getDefaultPresets(mode);
+		const excludeSet = new Set(excludeKeys ?? []);
+		return base.filter((preset) => {
+			if (excludeSet.has(preset.key)) return false;
+			const range = preset.getRange(timezone);
+			if (isDateDisabled(range.from)) return false;
+			if (isDateDisabled(range.to)) return false;
+			return true;
+		});
+	}, [
+		mode,
+		timezone,
+		custom,
+		excludeKeys,
+		isDateDisabled
+	]);
+}
+//#endregion
+//#region src/components/features/picker/components/root.tsx
+function detectHourCycle() {
+	try {
+		const opts = new Intl.DateTimeFormat(void 0, { hour: "numeric" }).resolvedOptions();
+		if (opts.hourCycle === "h23" || opts.hourCycle === "h24") return "24";
+		return "12";
+	} catch {
+		return "24";
+	}
+}
+function PickerRoot({ mode, value, onChange, commit, timezone: timezoneProp, step = 15, hourCycle: hourCycleProp, hideTimezone = false, responsive = true, presets: customPresets, excludePresets, minDate, maxDate, disablePast, disableFuture, children }) {
+	const rootRef = useRef(null);
+	const breakpoint = useBreakpoint();
+	const timezone = timezoneProp ?? getBrowserTimezone();
+	const hourCycle = hourCycleProp ?? detectHourCycle();
+	const { isDateDisabled } = useDateConstraints({
+		minDate,
+		maxDate,
+		disablePast,
+		disableFuture
+	});
+	const presets = usePresets({
+		mode,
+		timezone,
+		custom: customPresets,
+		excludeKeys: excludePresets,
+		isDateDisabled
+	});
+	const { state, actions } = usePickerState({
+		mode,
+		value,
+		onChange,
+		commit,
+		timezone
+	});
+	const effectiveCommit = resolveCommit(mode, commit);
+	useKeyboardShortcuts({
+		rootRef,
+		presets,
+		onSelect: useCallback((preset) => {
+			const range = preset.getRange(timezone);
+			actions.selectPreset(range, preset.key);
+		}, [timezone, actions]),
+		enabled: state.open
+	});
+	const ctx = useMemo(() => ({
+		mode,
+		timezone,
+		effectiveCommit,
+		hourCycle,
+		step,
+		hideTimezone,
+		responsive,
+		presets,
+		rootRef,
+		breakpoint,
+		state,
+		actions
+	}), [
+		mode,
+		timezone,
+		effectiveCommit,
+		hourCycle,
+		step,
+		hideTimezone,
+		responsive,
+		presets,
+		breakpoint,
+		state,
+		actions
+	]);
+	return /* @__PURE__ */ jsx(PickerContext.Provider, {
+		value: ctx,
+		children: /* @__PURE__ */ jsx("div", {
+			ref: rootRef,
+			children
+		})
+	});
+}
+PickerRoot.displayName = "Picker.Root";
+/**
+* Public namespace export. Subsequent tasks add Trigger, Content, etc.
+*/
+const Picker$1 = { Root: PickerRoot };
+//#endregion
+//#region src/components/features/picker/hooks/use-time-slots.ts
+function timeToMinutes(t) {
+	const parsed = parseTimeString(t);
+	return parsed ? parsed.h * 60 + parsed.m : null;
+}
+function minutesToTime(total) {
+	const h = Math.floor(total / 60);
+	const m = total % 60;
+	return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+/**
+* Generate an `OptionPickerOption[]` of HH:mm slots for the slot-dropdown UI.
+*
+* Slots are produced in pure minute arithmetic — DST is not considered (slots
+* are wall-clock times of day, independent of any specific calendar date).
+*/
+function useTimeSlots({ min, max, step = 15, hourCycle = "24" }) {
+	return useMemo(() => {
+		const minMinutes = min ? timeToMinutes(min) ?? 0 : 0;
+		const maxMinutes = max ? timeToMinutes(max) ?? 1439 : 1439;
+		const slots = [];
+		for (let m = minMinutes; m <= maxMinutes; m += step) {
+			if (m >= 1440) break;
+			const value = minutesToTime(m);
+			slots.push({
+				value,
+				label: formatTimeLabel(value, hourCycle)
+			});
+		}
+		return slots;
+	}, [
+		min,
+		max,
+		step,
+		hourCycle
+	]);
+}
+//#endregion
+//#region src/components/features/picker/components/time-input.tsx
+function combineDateAndTime(dateIso, time, timezone) {
+	const d = isoToZonedDate(dateIso, timezone);
+	const parsed = parseTimeString(time);
+	if (!parsed) return dateIso;
+	d.setHours(parsed.h, parsed.m, 0, 0);
+	return zonedDateToIso(d, timezone);
+}
+function PickerTimeInput({ target, min, max, className }) {
+	const { mode, timezone, hourCycle, step, state, actions } = usePickerContext();
+	let effectiveMin = min;
+	if (target === "range-to" && mode === "time-range") {
+		const fromValue = state.pendingValue?.from;
+		if (fromValue) effectiveMin = min && min > fromValue ? min : fromValue;
+	}
+	const slots = useTimeSlots({
+		min: effectiveMin,
+		max,
+		step,
+		hourCycle
+	});
+	let currentValue;
+	let embeddedDisabled = false;
+	if (target === "single" && mode === "time") currentValue = state.pendingValue ?? void 0;
+	else if ((target === "range-from" || target === "range-to") && mode === "time-range") {
+		const v = state.pendingValue;
+		currentValue = target === "range-from" ? v?.from : v?.to;
+	} else if (target === "embedded-from" || target === "embedded-to") {
+		if (mode === "datetime-range" || mode === "date-range-time") {
+			const v = state.pendingValue;
+			const iso = target === "embedded-from" ? v?.from : v?.to;
+			currentValue = iso ? dateToHHmm(isoToZonedDate(iso, timezone)) : void 0;
+			embeddedDisabled = v === null;
+		} else if (mode === "datetime") {
+			const iso = state.pendingValue;
+			currentValue = iso ? dateToHHmm(isoToZonedDate(iso, timezone)) : void 0;
+			embeddedDisabled = iso === null;
+		}
+	}
+	const handleSelect = (newTime) => {
+		if (target === "single" && mode === "time") {
+			actions.setSingleTime(newTime);
+			return;
+		}
+		if (mode === "time-range") {
+			const v = state.pendingValue ?? {
+				from: "00:00",
+				to: "23:59"
+			};
+			const next = target === "range-from" ? {
+				from: newTime,
+				to: v.to
+			} : {
+				from: v.from,
+				to: newTime
+			};
+			actions.setTimeRange(next);
+			return;
+		}
+		if (mode === "datetime-range" || mode === "date-range-time") {
+			const v = state.pendingValue;
+			if (!v) return;
+			const next = target === "embedded-from" ? {
+				from: combineDateAndTime(v.from, newTime, timezone),
+				to: v.to
+			} : {
+				from: v.from,
+				to: combineDateAndTime(v.to, newTime, timezone)
+			};
+			actions.setDatetimeRange(next);
+			return;
+		}
+		if (mode === "datetime" && (target === "embedded-from" || target === "embedded-to")) {
+			const v = state.pendingValue;
+			if (!v) return;
+			actions.setSingleDatetime(combineDateAndTime(v, newTime, timezone));
+		}
+	};
+	if (target === "single" || target === "range-from" || target === "range-to") return /* @__PURE__ */ jsx(InlineSlotList, {
+		slots,
+		value: currentValue,
+		onSelect: handleSelect,
+		className
+	});
+	return /* @__PURE__ */ jsx(EmbeddedSlotInput, {
+		label: currentValue ? formatTimeLabel(currentValue, hourCycle) : "— : —",
+		slots,
+		value: currentValue,
+		onSelect: handleSelect,
+		disabled: embeddedDisabled,
+		className
+	});
+}
+PickerTimeInput.displayName = "Picker.TimeInput";
+function InlineSlotList({ slots, value, onSelect, className }) {
+	const [open, setOpen] = useState(true);
+	return /* @__PURE__ */ jsx(OptionList, {
+		picker: useOptionPicker({
+			multiple: false,
+			options: slots,
+			value,
+			onValueChange: (next) => {
+				if (typeof next === "string") onSelect(next);
+			},
+			open,
+			onOpenChange: setOpen
+		}),
+		disableSearch: slots.length <= 48,
+		searchPlaceholder: "Search time...",
+		listClassName: cn("max-h-[240px]", className)
+	});
+}
+function EmbeddedSlotInput({ label, slots, value, onSelect, disabled = false, className }) {
+	const [open, setOpen] = useState(false);
+	const picker = useOptionPicker({
+		multiple: false,
+		options: slots,
+		value,
+		onValueChange: (next) => {
+			if (typeof next === "string") {
+				onSelect(next);
+				setOpen(false);
+			}
+		},
+		open,
+		onOpenChange: disabled ? () => {} : setOpen
+	});
+	return /* @__PURE__ */ jsx(ResponsivePopover, {
+		open,
+		onOpenChange: disabled ? () => {} : setOpen,
+		sheetTitle: "Select time",
+		trigger: /* @__PURE__ */ jsxs(Button$1, {
+			type: "button",
+			variant: "outline",
+			disabled,
+			className: cn("h-8 gap-1.5 px-2 text-xs font-normal", className),
+			children: [/* @__PURE__ */ jsx(Clock, { className: "size-3.5 opacity-60" }), /* @__PURE__ */ jsx("span", { children: label })]
+		}),
+		align: "start",
+		contentClassName: "w-[200px]",
+		children: /* @__PURE__ */ jsx(OptionList, {
+			picker,
+			disableSearch: slots.length <= 48,
+			searchPlaceholder: "Search time...",
+			listClassName: "max-h-[240px]"
+		})
+	});
+}
+//#endregion
+//#region src/components/features/picker/components/timezone-indicator.tsx
+function PickerTimezoneIndicator({ className, variant = "full" }) {
+	const { mode, timezone, hideTimezone } = usePickerContext();
+	if (hideTimezone) return null;
+	if (!isTimeBearingMode(mode)) return null;
+	if (variant === "compact") return /* @__PURE__ */ jsx("span", {
+		"data-slot": "picker-tz-indicator",
+		className: cn("text-muted-foreground text-xs", className),
+		children: timezone
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "picker-tz-indicator",
+		className: cn("text-muted-foreground bg-muted/30 flex items-center gap-2 px-3 py-2 text-xs", className),
+		children: [/* @__PURE__ */ jsx(Globe, { className: "size-3.5" }), /* @__PURE__ */ jsxs("span", { children: [
+			"Times shown in",
+			" ",
+			formatTimezoneLabel(timezone)
+		] })]
+	});
+}
+PickerTimezoneIndicator.displayName = "Picker.TimezoneIndicator";
+//#endregion
+//#region src/components/features/picker/components/timezone-select.tsx
+function PickerTimezoneSelect({ options, onChange, className, placeholder = "Select timezone" }) {
+	const { mode, timezone } = usePickerContext();
+	if (!isTimeBearingMode(mode)) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "picker-tz-select",
+		className: cn("flex items-center gap-2 px-3 py-2", className),
+		children: [/* @__PURE__ */ jsx(Globe, { className: "text-muted-foreground size-4 shrink-0" }), /* @__PURE__ */ jsxs(Select, {
+			value: timezone,
+			onValueChange: onChange,
+			children: [/* @__PURE__ */ jsx(SelectTrigger, {
+				className: "hover:bg-accent h-8 min-w-[180px] border-0 bg-transparent px-2 text-xs shadow-none",
+				children: /* @__PURE__ */ jsx(SelectValue, { placeholder })
+			}), /* @__PURE__ */ jsx(SelectContent, { children: options.map((opt) => /* @__PURE__ */ jsx(SelectItem, {
+				value: opt.value,
+				className: "text-xs",
+				children: opt.label
+			}, opt.value)) })]
+		})]
+	});
+}
+PickerTimezoneSelect.displayName = "Picker.TimezoneSelect";
+//#endregion
+//#region src/components/features/picker/components/trigger.tsx
+const DEFAULT_ICON = /* @__PURE__ */ jsx(CalendarIcon, { className: "text-muted-foreground size-4 shrink-0" });
+function PickerTrigger({ placeholder = "Pick a date", clearable = false, disabled = false, children, className, triggerClassName, id, icon, onClick, ...slotProps }) {
+	const { state, actions } = usePickerContext();
+	const hasValue = state.pendingValue !== null && state.pendingValue !== void 0;
+	const renderedIcon = icon === false ? null : icon ?? DEFAULT_ICON;
+	return /* @__PURE__ */ jsxs(Button$1, {
+		id,
+		type: "button",
+		variant: "outline",
+		role: "combobox",
+		"aria-label": hasValue ? void 0 : placeholder,
+		"aria-expanded": state.open,
+		disabled,
+		onClick: (e) => {
+			onClick?.(e);
+			if (state.open) actions.close();
+			else actions.open();
+		},
+		className: cn("w-full justify-between gap-2 font-normal", triggerClassName, className),
+		...slotProps,
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: "flex flex-1 items-center gap-2 truncate",
+			children: [renderedIcon, /* @__PURE__ */ jsx("span", {
+				className: cn("truncate", !hasValue && "text-muted-foreground"),
+				children: hasValue ? children ? children(state.pendingValue) : String(state.pendingValue) : placeholder
+			})]
+		}), clearable && hasValue && /* @__PURE__ */ jsx("button", {
+			type: "button",
+			"aria-label": "Clear",
+			onClick: (e) => {
+				e.stopPropagation();
+				actions.clear();
+			},
+			className: "text-muted-foreground hover:text-destructive shrink-0 rounded-sm p-0.5 transition-colors",
+			children: /* @__PURE__ */ jsx(X, { className: "size-3.5" })
+		})]
+	});
+}
+PickerTrigger.displayName = "Picker.Trigger";
+//#endregion
+//#region src/components/features/picker/components/index.ts
+const Picker = Object.assign(Picker$1, {
+	Trigger: PickerTrigger,
+	Content: PickerContent,
+	Calendar: PickerCalendar,
+	TimeInput: PickerTimeInput,
+	Presets: PickerPresets,
+	Footer: PickerFooter,
+	Apply: PickerApply,
+	Reset: PickerReset,
+	Cancel: PickerCancel,
+	Clear: PickerClear,
+	TimezoneIndicator: PickerTimezoneIndicator,
+	TimezoneSelect: PickerTimezoneSelect
+});
+//#endregion
+//#region src/components/features/picker/utils/compare.ts
+/** Strict equality of two nullable Date references by millisecond value. */
+function isSameDate(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	return a.getTime() === b.getTime();
+}
+/** Equality of two nullable date ranges. Compares from, to (by ms), and preset. */
+function isSameDateRange(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	return a.from.getTime() === b.from.getTime() && a.to.getTime() === b.to.getTime() && a.preset === b.preset;
+}
+/**
+* Equality of two nullable string ranges. Used for time-of-day, time-range,
+* and datetime-range value shapes (all structurally identical).
+* Compares from, to, and optional preset.
+*/
+function isSameStringRange(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	return a.from === b.from && a.to === b.to && a.preset === b.preset;
+}
+//#endregion
+//#region src/components/features/picker/utils/format-value.ts
+const DATE_OPTS = {
+	year: "numeric",
+	month: "short",
+	day: "2-digit"
+};
+function safeDate(input) {
+	if (input instanceof Date && !Number.isNaN(input.getTime())) return input;
+	return null;
+}
+function safeIso(input, timezone) {
+	if (typeof input !== "string") return null;
+	try {
+		const d = isoToZonedDate(input, timezone);
+		return Number.isNaN(d.getTime()) ? null : d;
+	} catch {
+		return null;
+	}
+}
+/**
+* Deterministic equivalent of `DATE_OPTS` rendered via date-fns (which pins
+* its own default locale). Used when no explicit `locale` is supplied so that
+* SSR and client produce identical text (no `toLocaleDateString(undefined)`
+* hydration mismatch).
+*/
+const DEFAULT_DATE_FORMAT = "MMM dd, yyyy";
+function formatDate(d, locale, dateFormat) {
+	if (dateFormat) return format(d, dateFormat);
+	if (locale) return d.toLocaleDateString(locale, DATE_OPTS);
+	return format(d, DEFAULT_DATE_FORMAT);
+}
+/** Renders `HH:mm` from a Date whose wall-clock fields are already in the target timezone. */
+function formatZonedTimeOfDay$1(d, hourCycle, timeFormat) {
+	if (timeFormat) return format(d, timeFormat);
+	return formatTimeLabel(dateToHHmm(d), hourCycle);
+}
+/**
+* Renders a `"HH:mm"` time-of-day string. Honors `timeFormat` (date-fns pattern)
+* by lifting the value into a Date and formatting; falls back to `formatTimeLabel`
+* (hourCycle-aware) otherwise.
+*/
+function formatTimeOfDayString(value, hourCycle, timeFormat) {
+	if (!timeFormat) return formatTimeLabel(value, hourCycle);
+	const parsed = parseTimeString(value);
+	if (!parsed) return "";
+	const d = /* @__PURE__ */ new Date();
+	d.setHours(parsed.h, parsed.m, 0, 0);
+	return format(d, timeFormat);
+}
+function isSameZonedDay(a, b) {
+	return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+/**
+* Renders a human-readable trigger label for any picker mode.
+* Returns the empty string when the value is null/undefined or unparseable.
+*/
+function formatPickerValue(value, mode, opts = {}) {
+	if (value === null || value === void 0) return "";
+	const timezone = opts.timezone ?? getBrowserTimezone();
+	const hourCycle = opts.hourCycle ?? "24";
+	const locale = opts.locale;
+	const dateFormat = opts.dateFormat;
+	const timeFormat = opts.timeFormat;
+	if (mode === "date") {
+		const d = safeDate(value);
+		return d ? formatDate(d, locale, dateFormat) : "";
+	}
+	if (mode === "date-range") {
+		const v = value;
+		const from = safeDate(v?.from);
+		const to = safeDate(v?.to);
+		if (!from || !to) return "";
+		return `${formatDate(from, locale, dateFormat)} - ${formatDate(to, locale, dateFormat)}`;
+	}
+	if (mode === "time") return typeof value === "string" ? formatTimeOfDayString(value, hourCycle, timeFormat) : "";
+	if (mode === "time-range") {
+		const v = value;
+		if (typeof v?.from !== "string" || typeof v?.to !== "string") return "";
+		return `${formatTimeOfDayString(v.from, hourCycle, timeFormat)} - ${formatTimeOfDayString(v.to, hourCycle, timeFormat)}`;
+	}
+	if (mode === "datetime") {
+		const d = safeIso(value, timezone);
+		return d ? `${formatDate(d, locale, dateFormat)} ${formatZonedTimeOfDay$1(d, hourCycle, timeFormat)}` : "";
+	}
+	if (mode === "datetime-range") {
+		const v = value;
+		const from = safeIso(v?.from, timezone);
+		const to = safeIso(v?.to, timezone);
+		if (!from || !to) return "";
+		if (isSameZonedDay(from, to)) return `${formatDate(from, locale, dateFormat)} ${formatZonedTimeOfDay$1(from, hourCycle, timeFormat)} - ${formatZonedTimeOfDay$1(to, hourCycle, timeFormat)}`;
+		return `${formatDate(from, locale, dateFormat)} ${formatZonedTimeOfDay$1(from, hourCycle, timeFormat)} - ${formatDate(to, locale, dateFormat)} ${formatZonedTimeOfDay$1(to, hourCycle, timeFormat)}`;
+	}
+	if (mode === "date-range-time") {
+		const v = value;
+		const from = safeIso(v?.from, timezone);
+		const to = safeIso(v?.to, timezone);
+		if (!from || !to) return "";
+		return `${formatDate(from, locale, dateFormat)} - ${formatDate(to, locale, dateFormat)} (${formatZonedTimeOfDay$1(from, hourCycle, timeFormat)})`;
+	}
+	return "";
+}
+//#endregion
+//#region src/components/features/picker/utils/range.ts
+/**
+* Number of calendar days between two dates. Always non-negative.
+*
+* Uses calendar-day boundaries (not 24-hour windows), so a range from
+* 23:59 today to 00:00 tomorrow counts as 1 day, not 0.
+*/
+function getDaysDifference(from, to) {
+	return Math.abs(differenceInCalendarDays(to, from));
+}
+/**
+* Validate a range against a maximum span (inclusive).
+*
+* - Returns `true` when `maxRange` is undefined.
+* - Returns `true` when the range spans at most `maxRange` days.
+*/
+function isRangeValid(from, to, maxRange) {
+	if (maxRange === void 0) return true;
+	return getDaysDifference(from, to) <= maxRange;
+}
+/**
+* Clamp a range to fit within `maxRange` days.
+*
+* If the range already fits, returns the original `{from, to}`.
+* Otherwise, holds `from` and clamps `to` forward to exactly `maxRange`
+* days after `from`.
+*/
+function clampRange(from, to, maxRange) {
+	if (isRangeValid(from, to, maxRange)) return {
+		from,
+		to
+	};
+	return {
+		from,
+		to: addDays(from, maxRange)
+	};
+}
+//#endregion
+//#region src/components/features/picker/wrappers/internal/default-footer.tsx
+/**
+* The standard Cancel / Reset / Apply footer used by every wrapper.
+* `Picker.Content` decides whether to render it - desktop popover renders
+* it only when `commit === 'apply'`; mobile sheet always renders it.
+*/
+function DefaultFooter() {
+	return /* @__PURE__ */ jsxs(PickerFooter, { children: [
+		/* @__PURE__ */ jsx(PickerCancel, {}),
+		/* @__PURE__ */ jsx(PickerReset, {}),
+		/* @__PURE__ */ jsx(PickerApply, {})
+	] });
+}
+//#endregion
+//#region src/components/features/picker/wrappers/date-picker.tsx
+function DatePicker({ value, onChange, placeholder = "Pick a date", clearable = true, responsive = true, sheetTitle = "Pick a date", numberOfMonths = 1, triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, commit, disablePast, disableFuture, minDate, maxDate, dateFormat }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "date",
+		value,
+		onChange,
+		commit,
+		responsive,
+		presets: [],
+		disablePast,
+		disableFuture,
+		minDate,
+		maxDate,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "date", { dateFormat })
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsx(PickerCalendar, {
+				numberOfMonths,
+				minDate,
+				maxDate,
+				disablePast,
+				disableFuture
+			})
+		})
+	});
+}
+DatePicker.displayName = "DatePicker";
+//#endregion
+//#region src/components/features/picker/wrappers/date-range-picker.tsx
+function DateRangePicker({ value, onChange, placeholder = "Pick a date range", clearable = true, responsive = true, sheetTitle = "Pick a date range", numberOfMonths = 2, triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, commit, disablePast, disableFuture, minDate, maxDate, presets, excludePresets, dateFormat }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "date-range",
+		value,
+		onChange,
+		commit,
+		responsive,
+		presets,
+		excludePresets,
+		disablePast,
+		disableFuture,
+		minDate,
+		maxDate,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "date-range", { dateFormat })
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col md:flex-row",
+				children: [/* @__PURE__ */ jsx(PickerPresets, {}), /* @__PURE__ */ jsx(PickerCalendar, {
+					numberOfMonths,
+					minDate,
+					maxDate,
+					disablePast,
+					disableFuture
+				})]
+			})
+		})
+	});
+}
+DateRangePicker.displayName = "DateRangePicker";
+//#endregion
+//#region src/components/features/picker/wrappers/date-range-time-picker.tsx
+function DateRangeTimePicker({ value, onChange, placeholder = "Pick a date range with time", clearable = true, responsive = true, sheetTitle = "Pick a date range with time", timezone, step = 15, hourCycle, numberOfMonths = 2, hideTimezone = false, triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, disablePast, disableFuture, minDate, maxDate, presets, excludePresets, dateFormat, timeFormat }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "date-range-time",
+		value,
+		onChange,
+		responsive,
+		timezone,
+		step,
+		hourCycle,
+		hideTimezone,
+		presets,
+		excludePresets,
+		disablePast,
+		disableFuture,
+		minDate,
+		maxDate,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "date-range-time", {
+					timezone,
+					hourCycle,
+					dateFormat,
+					timeFormat
+				})
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col md:flex-row",
+				children: [/* @__PURE__ */ jsx(PickerPresets, {}), /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col",
+					children: [
+						/* @__PURE__ */ jsx(PickerCalendar, {
+							numberOfMonths,
+							minDate,
+							maxDate,
+							disablePast,
+							disableFuture
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "border-t p-3",
+							children: [/* @__PURE__ */ jsx("div", {
+								className: "text-muted-foreground mb-1 text-xs",
+								children: "Time of day"
+							}), /* @__PURE__ */ jsx(PickerTimeInput, { target: "embedded-from" })]
+						}),
+						/* @__PURE__ */ jsx(PickerTimezoneIndicator, {})
+					]
+				})]
+			})
+		})
+	});
+}
+DateRangeTimePicker.displayName = "DateRangeTimePicker";
+//#endregion
+//#region src/components/features/picker/components/time-input-field.tsx
+function formatZonedTimeOfDay(iso, tz) {
+	try {
+		const d = isoToZonedDate(iso, tz);
+		if (Number.isNaN(d.getTime())) return "";
+		return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+	} catch {
+		return "";
+	}
+}
+function PickerTimeInputField({ className, ariaLabel = "Select time", id }) {
+	const { mode, timezone, state, actions } = usePickerContext();
+	const isoValue = mode === "datetime" ? state.pendingValue : null;
+	const externalTimeValue = isoValue ? formatZonedTimeOfDay(isoValue, timezone) : "";
+	const [localValue, setLocalValue] = useState(externalTimeValue);
+	useEffect(() => {
+		setLocalValue(externalTimeValue);
+	}, [externalTimeValue]);
+	if (mode !== "datetime") return null;
+	const disabled = isoValue === null;
+	const handleChange = (e) => {
+		const next = e.target.value;
+		setLocalValue(next);
+		if (!isoValue) return;
+		const parsed = parseTimeString(next);
+		if (!parsed) return;
+		const d = isoToZonedDate(isoValue, timezone);
+		d.setHours(parsed.h, parsed.m, 0, 0);
+		actions.setSingleDatetime(zonedDateToIso(d, timezone));
+	};
+	return /* @__PURE__ */ jsx("input", {
+		type: "text",
+		id,
+		"aria-label": ariaLabel,
+		value: localValue,
+		onChange: handleChange,
+		disabled,
+		className: cn("border-input-border bg-input-background/50 h-10 w-full rounded-lg border px-3 text-sm", "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50", className)
+	});
+}
+PickerTimeInputField.displayName = "Picker.TimeInputField";
+//#endregion
+//#region src/components/features/picker/wrappers/date-time-picker.tsx
+function DateTimePicker({ value, onChange, placeholder = "Pick a date & time", clearable = true, responsive = true, sheetTitle = "Pick a date & time", timezone, step = 15, hourCycle, numberOfMonths = 1, hideTimezone = false, timeInputMode = "slot", timezoneIndicatorVariant = "full", triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, disablePast, disableFuture, minDate, maxDate, dateFormat, timeFormat }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "datetime",
+		value,
+		onChange,
+		responsive,
+		timezone,
+		step,
+		hourCycle,
+		hideTimezone,
+		presets: [],
+		disablePast,
+		disableFuture,
+		minDate,
+		maxDate,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "datetime", {
+					timezone,
+					hourCycle,
+					dateFormat,
+					timeFormat
+				})
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col",
+				children: [
+					/* @__PURE__ */ jsx(PickerCalendar, {
+						numberOfMonths,
+						minDate,
+						maxDate,
+						disablePast,
+						disableFuture
+					}),
+					/* @__PURE__ */ jsx("div", {
+						className: "border-t p-3",
+						children: timeInputMode === "input" ? /* @__PURE__ */ jsx(PickerTimeInputField, {}) : /* @__PURE__ */ jsx(PickerTimeInput, { target: "embedded-from" })
+					}),
+					/* @__PURE__ */ jsx(PickerTimezoneIndicator, { variant: timezoneIndicatorVariant })
+				]
+			})
+		})
+	});
+}
+DateTimePicker.displayName = "DateTimePicker";
+//#endregion
+//#region src/components/features/picker/wrappers/date-time-range-picker.tsx
+function DateTimeRangePicker({ value, onChange, placeholder = "Pick a date & time range", clearable = true, responsive = true, sheetTitle = "Pick a date & time range", timezone, step = 15, hourCycle, numberOfMonths = 2, hideTimezone = false, triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, disablePast, disableFuture, minDate, maxDate, presets, excludePresets, dateFormat, timeFormat }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "datetime-range",
+		value,
+		onChange,
+		responsive,
+		timezone,
+		step,
+		hourCycle,
+		hideTimezone,
+		presets,
+		excludePresets,
+		disablePast,
+		disableFuture,
+		minDate,
+		maxDate,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "datetime-range", {
+					timezone,
+					hourCycle,
+					dateFormat,
+					timeFormat
+				})
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col md:flex-row",
+				children: [/* @__PURE__ */ jsx(PickerPresets, {}), /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col",
+					children: [
+						/* @__PURE__ */ jsx(PickerCalendar, {
+							numberOfMonths,
+							minDate,
+							maxDate,
+							disablePast,
+							disableFuture
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "flex gap-2 border-t p-3",
+							children: [/* @__PURE__ */ jsxs("div", {
+								className: "flex-1",
+								children: [/* @__PURE__ */ jsx("div", {
+									className: "text-muted-foreground mb-1 text-xs",
+									children: "From"
+								}), /* @__PURE__ */ jsx(PickerTimeInput, { target: "embedded-from" })]
+							}), /* @__PURE__ */ jsxs("div", {
+								className: "flex-1",
+								children: [/* @__PURE__ */ jsx("div", {
+									className: "text-muted-foreground mb-1 text-xs",
+									children: "To"
+								}), /* @__PURE__ */ jsx(PickerTimeInput, { target: "embedded-to" })]
+							})]
+						}),
+						/* @__PURE__ */ jsx(PickerTimezoneIndicator, {})
+					]
+				})]
+			})
+		})
+	});
+}
+DateTimeRangePicker.displayName = "DateTimeRangePicker";
+//#endregion
+//#region src/components/features/picker/wrappers/time-picker.tsx
+const DEFAULT_TIME_ICON$1 = /* @__PURE__ */ jsx(Clock, { className: "text-muted-foreground size-4 shrink-0" });
+function TimePicker({ value, onChange, placeholder = "Pick a time", clearable = true, responsive = true, sheetTitle = "Pick a time", step = 15, hourCycle, minTime, maxTime, timeFormat, triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, commit }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "time",
+		value,
+		onChange,
+		commit,
+		responsive,
+		step,
+		hourCycle,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon: icon ?? DEFAULT_TIME_ICON$1,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "time", {
+					hourCycle,
+					timeFormat
+				})
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsx(PickerTimeInput, {
+				target: "single",
+				min: minTime,
+				max: maxTime
+			})
+		})
+	});
+}
+TimePicker.displayName = "TimePicker";
+//#endregion
+//#region src/components/features/picker/wrappers/time-range-picker.tsx
+const DEFAULT_TIME_ICON = /* @__PURE__ */ jsx(Clock, { className: "text-muted-foreground size-4 shrink-0" });
+function TimeRangePicker({ value, onChange, placeholder = "Pick a time range", clearable = true, responsive = true, sheetTitle = "Pick a time range", step = 15, hourCycle, timeFormat, triggerLabel, icon, disabled, className, triggerClassName, popoverClassName, id, sheetDescription, modal, commit }) {
+	return /* @__PURE__ */ jsx(Picker$1.Root, {
+		mode: "time-range",
+		value,
+		onChange,
+		commit,
+		responsive,
+		step,
+		hourCycle,
+		children: /* @__PURE__ */ jsx(PickerContent, {
+			trigger: /* @__PURE__ */ jsx(PickerTrigger, {
+				placeholder,
+				clearable,
+				disabled,
+				className,
+				triggerClassName,
+				id,
+				icon: icon ?? DEFAULT_TIME_ICON,
+				children: (v) => triggerLabel ? triggerLabel(v) : formatPickerValue(v, "time-range", {
+					hourCycle,
+					timeFormat
+				})
+			}),
+			sheetTitle,
+			sheetDescription,
+			modal,
+			contentClassName: popoverClassName,
+			footer: /* @__PURE__ */ jsx(DefaultFooter, {}),
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "flex gap-2 p-3",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex-1",
+					children: [/* @__PURE__ */ jsx("div", {
+						className: "text-muted-foreground mb-1 text-xs",
+						children: "From"
+					}), /* @__PURE__ */ jsx(PickerTimeInput, { target: "range-from" })]
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "flex-1",
+					children: [/* @__PURE__ */ jsx("div", {
+						className: "text-muted-foreground mb-1 text-xs",
+						children: "To"
+					}), /* @__PURE__ */ jsx(PickerTimeInput, { target: "range-to" })]
+				})]
+			})
+		})
+	});
+}
+TimeRangePicker.displayName = "TimeRangePicker";
+//#endregion
+export { isRangeMode as $, resolveCommit as A, PickerContext as B, DATE_PRESETS as C, formatTimeLabel as D, dateToYYYYMMDD as E, PickerClear as F, getTimezoneOffset as G, formatInTimezone as H, PickerFooter as I, ALLOWED_STEPS as J, isoToZonedDate as K, PickerReset as L, PickerPresets as M, PickerApply as N, isValidTimeString as O, PickerCancel as P, isDateBearingMode as Q, PickerContent as R, DATETIME_PRESETS as S, usePickerState as T, formatTimezoneLabel as U, usePickerContext as V, getBrowserTimezone as W, RANGE_MODES as X, DATE_BEARING_MODES as Y, TIME_BEARING_MODES as Z, PickerTimezoneSelect as _, DateRangeTimePicker as a, useTimeSlots as b, clampRange as c, formatPickerValue as d, isTimeBearingMode as et, isSameDate as f, PickerTrigger as g, Picker as h, DateTimePicker as i, useKeyboardShortcuts as j, parseTimeString as k, getDaysDifference as l, isSameStringRange as m, TimePicker as n, startOfDayInTz as nt, DateRangePicker as o, isSameDateRange as p, zonedDateToIso as q, DateTimeRangePicker as r, DatePicker as s, TimeRangePicker as t, endOfDayInTz as tt, isRangeValid as u, PickerTimezoneIndicator as v, getDefaultPresets as w, usePresets as x, PickerTimeInput as y, PickerCalendar as z };