@povio/ui 3.4.0-rc.9 → 4.0.0-rc.2

package/dist/DateRangePicker-CS69o2pD.js

@@ -0,0 +1,1858 @@
+import { t as UIConfig } from "./uiConfig.context-BvBsrMFI.js";
+import { t as ChevronDown } from "./chevron-down-RksSwG1O.js";
+import { t as ChevronLeft } from "./chevron-left-Dem1_TuL.js";
+import { t as ChevronRight } from "./chevron-right-DXbvvsay.js";
+import { n as ChevronsLeft, t as ChevronsRight } from "./chevrons-right--HrJEes-.js";
+import { a as CalendarGrid, c as $dd602d3c757202f2$export$4f5203c0d889109e, d as $dd602d3c757202f2$export$f4a51ff076cc9a09, i as $1697a7ad3db7b79f$re_export$useDateFormatter, l as $dd602d3c757202f2$export$a1d3911297b952d7, n as renderDatePickerTodayIcon, o as $f11fb0bcf1b2687a$export$61c6a8c84e605fb6, r as datePickerInputContentRowDefinition, s as $ea0ea6e62ae0d7ca$export$6d095e787d2b5e1f, t as DatePickerInput, u as $dd602d3c757202f2$export$eac50920cf2fd59a } from "./DatePickerInput-B9Z_AUkC.js";
+import { t as clsx } from "./clsx-CnD0nOiA.js";
+import { n as $7705c033048f6da7$export$353f5b6fc5456de1 } from "./Button-CRlZqaJq.js";
+import { t as Switch } from "./Switch-BaNEe9Nx.js";
+import { t as UIOverrides } from "./uiOverrides.context-Bfm2n-n8.js";
+import { n as $23f2114a1b82827e$export$4282f70798064fe0 } from "./useLayoutEffect-DN7Dbrb9.js";
+import { a as $390e54f620492c70$export$f680877a34711e37, r as $bbaa08b3cd72f041$export$9d1611c77c2fe928 } from "./useSyncRef-Dsn4Ybiw.js";
+import { c as $191c9b6d48a0a4e2$export$294aa081a6c6f55d, m as $cf2482eff2eeeec2$export$f12b703ca79dfbb1, r as $fd2148440a13ec26$export$fc1a364ae1f3ff10, s as $2c9edc598a03d523$export$420e68273165f4ec } from "./useFormValidationState-Dl-Nh0G1.js";
+import { n as $8e9d2fae0ecb9001$export$457c3d6518dd4c6f, r as $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7, t as $3e6197669829fe11$export$40bfa8c7b0832715 } from "./useControlledState-BMVd3AOQ.js";
+import { C as $0014db39426443c5$exports, S as $6a440d0e2d99dd46$export$4a931266a3838b86, f as $8b141f2f71e88f85$export$2440da353cedad43, h as $8b141f2f71e88f85$export$c5221a78ef73c5e9, i as getStaticDateTimeFocusTarget, m as $8b141f2f71e88f85$export$80ff8fc0ae339c13, o as DateTimeDialogFooter, p as $8b141f2f71e88f85$export$7e319ea407e63bc0, r as getStaticDateRangeSegments, s as DateTimeDialog, v as $7541913c0284d84b$export$300019f83c56d282, w as $121970af65029459$export$f8aeda7b10753fa1, x as $7541913c0284d84b$export$7b3062cd49e80452 } from "./staticDateTimeSegments-B9kkwiDz.js";
+import { n as $535772f9d2c1f38d$export$c5251b9e124bf29 } from "./FocusScope-CNjWJz3s.js";
+import { t as Typography } from "./Typography-AcUd9df8.js";
+import { InlineIconButton } from "./components/inline-icon-button.js";
+import { PillButton } from "./components/pill-button.js";
+import { r as $a8ea2faf2ebe4d2f$re_export$mergeRefs } from "./import-DDGNxVX8.js";
+import { t as FieldController } from "./form.binding-DLM7NA2s.js";
+import { t as FormField } from "./FormField-BHPdCLEV.js";
+import "./i18n-BDjNuy4Z.js";
+import { t as TooltipWrapper } from "./TooltipWrapper-DYfZF2Ly.js";
+import { i as InputFrame, n as useStaticInputHandoff } from "./useStaticInputHandoff-Denoy4V_.js";
+import { t as DateTimeUtils } from "./date-time.utils-0F9qduim.js";
+import { t as Select } from "./Select-O9dprkTa.js";
+import { memo, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { DateFormatter, GregorianCalendar, createCalendar, endOfMonth, endOfWeek, endOfYear, getLocalTimeZone, maxDate, minDate, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, today } from "@internationalized/date";
+import { DEFAULT_VALIDATION_RESULT, mergeValidation, privateValidationStateProp } from "react-stately/private/form/useFormValidationState";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useTranslation } from "react-i18next";
+import { useRangeCalendar } from "@react-aria/calendar";
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/datepicker/useDateRangePicker.mjs
+function $parcel$interopDefault(a) {
+	return a && a.__esModule ? a.default : a;
+}
+function $cccdba1b2bb08448$export$12fd5f0e9f4bb192(props, state, ref) {
+	let stringFormatter = $cf2482eff2eeeec2$export$f12b703ca79dfbb1($parcel$interopDefault($0014db39426443c5$exports), "@react-aria/datepicker");
+	let { isInvalid, validationErrors, validationDetails } = state.displayValidation;
+	let { labelProps, fieldProps, descriptionProps, errorMessageProps } = $191c9b6d48a0a4e2$export$294aa081a6c6f55d({
+		...props,
+		labelElementType: "span",
+		isInvalid,
+		errorMessage: props.errorMessage || validationErrors
+	});
+	let labelledBy = fieldProps["aria-labelledby"] || fieldProps.id;
+	let { locale } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+	let range = state.formatValue(locale, { month: "long" });
+	let description = range ? stringFormatter.format("selectedRangeDescription", {
+		startDate: range.start,
+		endDate: range.end
+	}) : "";
+	let descProps = $121970af65029459$export$f8aeda7b10753fa1(description);
+	let startFieldProps = {
+		"aria-label": stringFormatter.format("startDate"),
+		"aria-labelledby": labelledBy
+	};
+	let endFieldProps = {
+		"aria-label": stringFormatter.format("endDate"),
+		"aria-labelledby": labelledBy
+	};
+	let buttonId = $390e54f620492c70$export$f680877a34711e37();
+	let dialogId = $390e54f620492c70$export$f680877a34711e37();
+	let groupProps = $6a440d0e2d99dd46$export$4a931266a3838b86(state, ref);
+	let ariaDescribedBy = [descProps["aria-describedby"], fieldProps["aria-describedby"]].filter(Boolean).join(" ") || void 0;
+	let focusManager = useMemo(() => $535772f9d2c1f38d$export$c5251b9e124bf29(ref, { accept: (element) => element.id !== buttonId }), [ref, buttonId]);
+	let commonFieldProps = {
+		[$7541913c0284d84b$export$7b3062cd49e80452]: focusManager,
+		[$7541913c0284d84b$export$300019f83c56d282]: "presentation",
+		"aria-describedby": ariaDescribedBy,
+		placeholderValue: props.placeholderValue,
+		hideTimeZone: props.hideTimeZone,
+		hourCycle: props.hourCycle,
+		granularity: props.granularity,
+		shouldForceLeadingZeros: props.shouldForceLeadingZeros,
+		isDisabled: props.isDisabled,
+		isReadOnly: props.isReadOnly,
+		isRequired: props.isRequired,
+		validationBehavior: props.validationBehavior
+	};
+	let domProps = $8e9d2fae0ecb9001$export$457c3d6518dd4c6f(props);
+	let isFocused = useRef(false);
+	let { focusWithinProps } = $2c9edc598a03d523$export$420e68273165f4ec({
+		...props,
+		isDisabled: state.isOpen,
+		onBlurWithin: (e) => {
+			let dialog = document.getElementById(dialogId);
+			if (!$23f2114a1b82827e$export$4282f70798064fe0(dialog, e.relatedTarget)) {
+				isFocused.current = false;
+				props.onBlur?.(e);
+				props.onFocusChange?.(false);
+			}
+		},
+		onFocusWithin: (e) => {
+			if (!isFocused.current) {
+				isFocused.current = true;
+				props.onFocus?.(e);
+				props.onFocusChange?.(true);
+			}
+		}
+	});
+	let startFieldValidation = useRef(DEFAULT_VALIDATION_RESULT);
+	let endFieldValidation = useRef(DEFAULT_VALIDATION_RESULT);
+	return {
+		groupProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928(domProps, groupProps, fieldProps, descProps, focusWithinProps, {
+			role: "group",
+			"aria-disabled": props.isDisabled || null,
+			"aria-describedby": ariaDescribedBy,
+			onKeyDown(e) {
+				if (state.isOpen) return;
+				if (props.onKeyDown) props.onKeyDown(e);
+			},
+			onKeyUp(e) {
+				if (state.isOpen) return;
+				if (props.onKeyUp) props.onKeyUp(e);
+			}
+		}),
+		labelProps: {
+			...labelProps,
+			onClick: () => {
+				focusManager.focusFirst();
+			}
+		},
+		buttonProps: {
+			...descProps,
+			id: buttonId,
+			"aria-haspopup": "dialog",
+			"aria-label": stringFormatter.format("calendar"),
+			"aria-labelledby": `${buttonId} ${labelledBy}`,
+			"aria-describedby": ariaDescribedBy,
+			"aria-expanded": state.isOpen,
+			isDisabled: props.isDisabled || props.isReadOnly,
+			onPress: () => state.setOpen(true)
+		},
+		dialogProps: {
+			id: dialogId,
+			"aria-labelledby": `${buttonId} ${labelledBy}`
+		},
+		startFieldProps: {
+			...startFieldProps,
+			...commonFieldProps,
+			value: state.value?.start ?? null,
+			defaultValue: state.defaultValue?.start,
+			onChange: (start) => state.setDateTime("start", start),
+			autoFocus: props.autoFocus,
+			name: props.startName,
+			form: props.form,
+			[privateValidationStateProp]: {
+				realtimeValidation: state.realtimeValidation,
+				displayValidation: state.displayValidation,
+				updateValidation(e) {
+					startFieldValidation.current = e;
+					state.updateValidation(mergeValidation(e, endFieldValidation.current));
+				},
+				resetValidation: state.resetValidation,
+				commitValidation: state.commitValidation
+			}
+		},
+		endFieldProps: {
+			...endFieldProps,
+			...commonFieldProps,
+			value: state.value?.end ?? null,
+			defaultValue: state.defaultValue?.end,
+			onChange: (end) => state.setDateTime("end", end),
+			name: props.endName,
+			form: props.form,
+			[privateValidationStateProp]: {
+				realtimeValidation: state.realtimeValidation,
+				displayValidation: state.displayValidation,
+				updateValidation(e) {
+					endFieldValidation.current = e;
+					state.updateValidation(mergeValidation(startFieldValidation.current, e));
+				},
+				resetValidation: state.resetValidation,
+				commitValidation: state.commitValidation
+			}
+		},
+		descriptionProps,
+		errorMessageProps,
+		calendarProps: {
+			autoFocus: true,
+			value: state.dateRange?.start && state.dateRange.end ? state.dateRange : null,
+			onChange: state.setDateRange,
+			minValue: props.minValue,
+			maxValue: props.maxValue,
+			isDisabled: props.isDisabled,
+			isReadOnly: props.isReadOnly,
+			isDateUnavailable: props.isDateUnavailable,
+			allowsNonContiguousRanges: props.allowsNonContiguousRanges,
+			defaultFocusedValue: state.dateRange ? void 0 : props.placeholderValue,
+			isInvalid: state.isInvalid,
+			errorMessage: typeof props.errorMessage === "function" ? props.errorMessage(state.displayValidation) : props.errorMessage || state.displayValidation.validationErrors.join(" "),
+			firstDayOfWeek: props.firstDayOfWeek,
+			pageBehavior: props.pageBehavior
+		},
+		isInvalid,
+		validationErrors,
+		validationDetails
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/react-stately@3.49.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/calendar/useRangeCalendarState.mjs
+function $a0a87fb6fcfb22ec$export$9a987164d97ecc90(props) {
+	let { value: valueProp, defaultValue, onChange, createCalendar, locale, visibleDuration = { months: 1 }, minValue, maxValue, ...calendarProps } = props;
+	let [value, setValue] = $3e6197669829fe11$export$40bfa8c7b0832715(valueProp, defaultValue || null, onChange);
+	let [anchorDate, setAnchorDate] = useState(null);
+	let alignment = "center";
+	if (value && value.start && value.end) {
+		let end = $dd602d3c757202f2$export$f4a51ff076cc9a09(toCalendarDate(value.start), visibleDuration, locale, minValue, maxValue).add(visibleDuration).subtract({ days: 1 });
+		if (value.end.compare(end) > 0) alignment = "start";
+	}
+	let isDateUnavailable = useMemo(() => {
+		let isDateUnavailable = props.isDateUnavailable;
+		if (!isDateUnavailable) return void 0;
+		return (date) => isDateUnavailable(date, anchorDate);
+	}, [props.isDateUnavailable, anchorDate]);
+	let getAvailableRange = useCallback((anchorDate) => {
+		if (anchorDate && isDateUnavailable && !props.allowsNonContiguousRanges) return {
+			start: $a0a87fb6fcfb22ec$var$nextUnavailableDate(anchorDate, isDateUnavailable, visibleDuration, -1),
+			end: $a0a87fb6fcfb22ec$var$nextUnavailableDate(anchorDate, isDateUnavailable, visibleDuration, 1)
+		};
+		else return null;
+	}, [
+		isDateUnavailable,
+		visibleDuration,
+		props.allowsNonContiguousRanges
+	]);
+	let availableRange = useMemo(() => getAvailableRange(anchorDate), [getAvailableRange, anchorDate]);
+	let min = useMemo(() => maxDate(minValue, availableRange?.start), [minValue, availableRange]);
+	let max = useMemo(() => minDate(maxValue, availableRange?.end), [maxValue, availableRange]);
+	let calendar = $ea0ea6e62ae0d7ca$export$6d095e787d2b5e1f({
+		...calendarProps,
+		value: value && value.start,
+		createCalendar,
+		locale,
+		visibleDuration,
+		minValue: min,
+		maxValue: max,
+		selectionAlignment: props.selectionAlignment || alignment,
+		isDateUnavailable
+	});
+	let highlightedRange = anchorDate ? $a0a87fb6fcfb22ec$var$makeRange(anchorDate, calendar.focusedDate) : value && $a0a87fb6fcfb22ec$var$makeRange(value.start, value.end);
+	let selectDate = (date) => {
+		if (props.isReadOnly) return;
+		const constrainedDate = $dd602d3c757202f2$export$4f5203c0d889109e(date, min, max);
+		const previousAvailableConstrainedDate = $dd602d3c757202f2$export$a1d3911297b952d7(constrainedDate, calendar.visibleRange.start, isDateUnavailable);
+		if (!previousAvailableConstrainedDate) return;
+		if (!anchorDate) setAnchorDate(previousAvailableConstrainedDate);
+		else {
+			let range = $a0a87fb6fcfb22ec$var$makeRange(anchorDate, previousAvailableConstrainedDate);
+			if (range) setValue({
+				start: $a0a87fb6fcfb22ec$var$convertValue(range.start, value?.start),
+				end: $a0a87fb6fcfb22ec$var$convertValue(range.end, value?.end)
+			});
+			setAnchorDate(null);
+		}
+	};
+	let [isDragging, setDragging] = useState(false);
+	let isInvalidSelection = useMemo(() => {
+		if (!value || anchorDate) return false;
+		if (isDateUnavailable && (isDateUnavailable(value.start) || isDateUnavailable(value.end))) return true;
+		return $dd602d3c757202f2$export$eac50920cf2fd59a(value.start, minValue, maxValue) || $dd602d3c757202f2$export$eac50920cf2fd59a(value.end, minValue, maxValue);
+	}, [
+		isDateUnavailable,
+		value,
+		anchorDate,
+		minValue,
+		maxValue
+	]);
+	let isValueInvalid = props.isInvalid || props.validationState === "invalid" || isInvalidSelection;
+	let validationState = isValueInvalid ? "invalid" : null;
+	return {
+		...calendar,
+		value,
+		setValue,
+		anchorDate,
+		setAnchorDate,
+		highlightedRange,
+		validationState,
+		isValueInvalid,
+		selectFocusedDate() {
+			if (!calendar.isCellUnavailable(calendar.focusedDate)) selectDate(calendar.focusedDate);
+		},
+		commitSelection() {
+			selectDate(calendar.focusedDate);
+		},
+		selectDate,
+		highlightDate(date) {
+			if (anchorDate) calendar.setFocusedDate(date);
+		},
+		isSelected(date) {
+			return Boolean(highlightedRange && date.compare(highlightedRange.start) >= 0 && date.compare(highlightedRange.end) <= 0 && !calendar.isCellDisabled(date) && !calendar.isCellUnavailable(date));
+		},
+		isInvalid(date) {
+			return calendar.isInvalid(date) || $dd602d3c757202f2$export$eac50920cf2fd59a(date, availableRange?.start, availableRange?.end);
+		},
+		isDragging,
+		setDragging,
+		clearSelection() {
+			setAnchorDate(null);
+			setValue(null);
+		},
+		focusNearestAvailableDate(anchorDate) {
+			let availableRange = getAvailableRange(anchorDate);
+			let isDateInvalid = (date) => this.isInvalid(date) || $dd602d3c757202f2$export$eac50920cf2fd59a(date, availableRange?.start, availableRange?.end);
+			let nextDay = anchorDate.add({ days: 1 });
+			if (isDateInvalid(nextDay)) nextDay = anchorDate.subtract({ days: 1 });
+			if (!isDateInvalid(nextDay)) {
+				this.setFocusedDate(nextDay);
+				this.setFocused(true);
+			}
+		}
+	};
+}
+function $a0a87fb6fcfb22ec$var$makeRange(start, end) {
+	if (!start || !end) return null;
+	if (end.compare(start) < 0) [start, end] = [end, start];
+	return {
+		start: toCalendarDate(start),
+		end: toCalendarDate(end)
+	};
+}
+function $a0a87fb6fcfb22ec$var$convertValue(newValue, oldValue) {
+	newValue = toCalendar(newValue, oldValue?.calendar || new GregorianCalendar());
+	if (oldValue && "hour" in oldValue) return oldValue.set(newValue);
+	return newValue;
+}
+function $a0a87fb6fcfb22ec$var$nextUnavailableDate(anchorDate, isDateUnavailable, visibleDuration, dir) {
+	let nextDate = anchorDate.add({ days: dir });
+	let minDate = anchorDate.subtract(visibleDuration);
+	let maxDate = anchorDate.add(visibleDuration);
+	while ((dir < 0 ? nextDate.compare(minDate) >= 0 : nextDate.compare(maxDate) <= 0) && !isDateUnavailable(nextDate)) nextDate = nextDate.add({ days: dir });
+	if (isDateUnavailable(nextDate)) return nextDate.add({ days: -dir });
+}
+//#endregion
+//#region ../../node_modules/.bun/react-stately@3.49.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/datepicker/useDateRangePickerState.mjs
+function $6de3e3f1a7663217$export$e50a61c1de9f574(props) {
+	let overlayState = $f11fb0bcf1b2687a$export$61c6a8c84e605fb6(props);
+	let [controlledValue, setControlledValue] = $3e6197669829fe11$export$40bfa8c7b0832715(props.value, props.defaultValue || null, props.onChange);
+	let [initialValue] = useState(controlledValue);
+	let [placeholderValue, setPlaceholderValue] = useState(() => controlledValue || {
+		start: null,
+		end: null
+	});
+	if (controlledValue == null && placeholderValue.start && placeholderValue.end) {
+		placeholderValue = {
+			start: null,
+			end: null
+		};
+		setPlaceholderValue(placeholderValue);
+	}
+	let value = controlledValue || placeholderValue;
+	let setValue = (newValue) => {
+		value = newValue || {
+			start: null,
+			end: null
+		};
+		setPlaceholderValue(value);
+		if ($6de3e3f1a7663217$var$isCompleteRange(value)) setControlledValue(value);
+		else setControlledValue(null);
+	};
+	let v = value?.start || value?.end || props.placeholderValue || null;
+	let [granularity, defaultTimeZone] = $8b141f2f71e88f85$export$2440da353cedad43(v, props.granularity);
+	let hasTime = granularity === "hour" || granularity === "minute" || granularity === "second";
+	let shouldCloseOnSelect = props.shouldCloseOnSelect ?? true;
+	let [dateRange, setSelectedDateRange] = useState(null);
+	let [timeRange, setSelectedTimeRange] = useState(null);
+	if (value && $6de3e3f1a7663217$var$isCompleteRange(value)) {
+		dateRange = value;
+		if ("hour" in value.start) timeRange = value;
+	}
+	let commitValue = (dateRange, timeRange) => {
+		setValue({
+			start: "timeZone" in timeRange.start ? timeRange.start.set(toCalendarDate(dateRange.start)) : toCalendarDateTime(dateRange.start, timeRange.start),
+			end: "timeZone" in timeRange.end ? timeRange.end.set(toCalendarDate(dateRange.end)) : toCalendarDateTime(dateRange.end, timeRange.end)
+		});
+		setSelectedDateRange(null);
+		setSelectedTimeRange(null);
+		validation.commitValidation();
+	};
+	let setDateRange = (range) => {
+		let shouldClose = typeof shouldCloseOnSelect === "function" ? shouldCloseOnSelect() : shouldCloseOnSelect;
+		if (hasTime) {
+			if ($6de3e3f1a7663217$var$isCompleteRange(range) && (shouldClose || timeRange?.start && timeRange?.end)) commitValue(range, {
+				start: timeRange?.start || $8b141f2f71e88f85$export$c5221a78ef73c5e9(props.placeholderValue),
+				end: timeRange?.end || $8b141f2f71e88f85$export$c5221a78ef73c5e9(props.placeholderValue)
+			});
+			else setSelectedDateRange(range);
+		} else if ($6de3e3f1a7663217$var$isCompleteRange(range)) {
+			setValue(range);
+			validation.commitValidation();
+		} else setSelectedDateRange(range);
+		if (shouldClose) overlayState.setOpen(false);
+	};
+	let setTimeRange = (range) => {
+		if ($6de3e3f1a7663217$var$isCompleteRange(dateRange) && $6de3e3f1a7663217$var$isCompleteRange(range)) commitValue(dateRange, range);
+		else setSelectedTimeRange(range);
+	};
+	let showEra = value?.start?.calendar.identifier === "gregory" && value.start.era === "BC" || value?.end?.calendar.identifier === "gregory" && value.end.era === "BC";
+	let formatOpts = useMemo(() => ({
+		granularity,
+		timeZone: defaultTimeZone,
+		hideTimeZone: props.hideTimeZone,
+		hourCycle: props.hourCycle,
+		shouldForceLeadingZeros: props.shouldForceLeadingZeros,
+		showEra
+	}), [
+		granularity,
+		props.hourCycle,
+		props.shouldForceLeadingZeros,
+		defaultTimeZone,
+		props.hideTimeZone,
+		showEra
+	]);
+	let { minValue, maxValue, isDateUnavailable } = props;
+	let builtinValidation = useMemo(() => $8b141f2f71e88f85$export$80ff8fc0ae339c13(value, minValue, maxValue, isDateUnavailable ? (date) => isDateUnavailable(date, null) : void 0, formatOpts), [
+		value,
+		minValue,
+		maxValue,
+		isDateUnavailable,
+		formatOpts
+	]);
+	let validation = $fd2148440a13ec26$export$fc1a364ae1f3ff10({
+		...props,
+		value: controlledValue,
+		name: useMemo(() => [props.startName, props.endName].filter((n) => n != null), [props.startName, props.endName]),
+		builtinValidation
+	});
+	let isValueInvalid = validation.displayValidation.isInvalid;
+	let validationState = props.validationState || (isValueInvalid ? "invalid" : null);
+	return {
+		...validation,
+		value,
+		defaultValue: props.defaultValue ?? initialValue,
+		setValue,
+		dateRange,
+		timeRange,
+		granularity,
+		hasTime,
+		setDate(part, date) {
+			if (part === "start") setDateRange({
+				start: date,
+				end: dateRange?.end ?? null
+			});
+			else setDateRange({
+				start: dateRange?.start ?? null,
+				end: date
+			});
+		},
+		setTime(part, time) {
+			if (part === "start") setTimeRange({
+				start: time,
+				end: timeRange?.end ?? null
+			});
+			else setTimeRange({
+				start: timeRange?.start ?? null,
+				end: time
+			});
+		},
+		setDateTime(part, dateTime) {
+			if (part === "start") setValue({
+				start: dateTime,
+				end: value?.end ?? null
+			});
+			else setValue({
+				start: value?.start ?? null,
+				end: dateTime
+			});
+		},
+		setDateRange,
+		setTimeRange,
+		...overlayState,
+		setOpen(isOpen) {
+			if (!isOpen && !(value?.start && value?.end) && $6de3e3f1a7663217$var$isCompleteRange(dateRange) && hasTime) commitValue(dateRange, {
+				start: timeRange?.start || $8b141f2f71e88f85$export$c5221a78ef73c5e9(props.placeholderValue),
+				end: timeRange?.end || $8b141f2f71e88f85$export$c5221a78ef73c5e9(props.placeholderValue)
+			});
+			overlayState.setOpen(isOpen);
+		},
+		validationState,
+		isInvalid: isValueInvalid,
+		formatValue(locale, fieldOptions) {
+			if (!value || !value.start || !value.end) return null;
+			let startTimeZone = "timeZone" in value.start ? value.start.timeZone : void 0;
+			let startGranularity = props.granularity || (value.start && "minute" in value.start ? "minute" : "day");
+			let endTimeZone = "timeZone" in value.end ? value.end.timeZone : void 0;
+			let endGranularity = props.granularity || (value.end && "minute" in value.end ? "minute" : "day");
+			let startOptions = $8b141f2f71e88f85$export$7e319ea407e63bc0(fieldOptions, {
+				granularity: startGranularity,
+				timeZone: startTimeZone,
+				hideTimeZone: props.hideTimeZone,
+				hourCycle: props.hourCycle,
+				showEra: value.start.calendar.identifier === "gregory" && value.start.era === "BC" || value.end.calendar.identifier === "gregory" && value.end.era === "BC"
+			});
+			let startDate = value.start.toDate(startTimeZone || "UTC");
+			let endDate = value.end.toDate(endTimeZone || "UTC");
+			let startFormatter = new DateFormatter(locale, startOptions);
+			let endFormatter;
+			if (startTimeZone === endTimeZone && startGranularity === endGranularity && value.start.compare(value.end) !== 0) {
+				try {
+					let parts = startFormatter.formatRangeToParts(startDate, endDate);
+					let separatorIndex = -1;
+					for (let i = 0; i < parts.length; i++) {
+						let part = parts[i];
+						if (part.source === "shared" && part.type === "literal") separatorIndex = i;
+						else if (part.source === "endRange") break;
+					}
+					let start = "";
+					let end = "";
+					for (let i = 0; i < parts.length; i++) if (i < separatorIndex) start += parts[i].value;
+					else if (i > separatorIndex) end += parts[i].value;
+					return {
+						start,
+						end
+					};
+				} catch {}
+				endFormatter = startFormatter;
+			} else {
+				let endOptions = $8b141f2f71e88f85$export$7e319ea407e63bc0(fieldOptions, {
+					granularity: endGranularity,
+					timeZone: endTimeZone,
+					hideTimeZone: props.hideTimeZone,
+					hourCycle: props.hourCycle
+				});
+				endFormatter = new DateFormatter(locale, endOptions);
+			}
+			return {
+				start: startFormatter.format(startDate),
+				end: endFormatter.format(endDate)
+			};
+		},
+		getDateFormatter(locale, formatOptions) {
+			let newOptions = {
+				...formatOpts,
+				...formatOptions
+			};
+			let newFormatOptions = $8b141f2f71e88f85$export$7e319ea407e63bc0({}, newOptions);
+			return new DateFormatter(locale, newFormatOptions);
+		}
+	};
+}
+function $6de3e3f1a7663217$var$isCompleteRange(value) {
+	return value?.start != null && value.end != null;
+}
+//#endregion
+//#region src/components/inputs/DateTime/shared/CalendarSelectHeader.tsx
+const CalendarSelectHeader = ({ state, isPrevMonthDisabled, isPrevYearDisabled, isNextMonthDisabled, isNextYearDisabled, offset = { months: 0 }, onNavigate, maxDate, minDate }) => {
+	const { t } = useTranslation("ui");
+	const displayDate = state.visibleRange.start.add(offset);
+	const currentMonth = displayDate.month - 1;
+	const currentYear = displayDate.year;
+	const formatter = $1697a7ad3db7b79f$re_export$useDateFormatter({
+		month: "long",
+		timeZone: state.timeZone
+	});
+	const numMonths = state.focusedDate.calendar.getMonthsInYear(state.focusedDate);
+	const MONTHS = useMemo(() => {
+		const months = [];
+		for (let i = 1; i <= numMonths; i++) {
+			const date = state.focusedDate.set({ month: i });
+			months.push(formatter.format(date.toDate(state.timeZone)));
+		}
+		return months;
+	}, [
+		formatter,
+		numMonths,
+		state.focusedDate,
+		state.timeZone
+	]);
+	const years = Array.from({ length: 201 }, (_, i) => currentYear - 100 + i);
+	const getAvailableMonths = () => {
+		return MONTHS.map((month, i) => {
+			const monthDate = displayDate.set({ month: i + 1 });
+			let isDisabled = false;
+			if (maxDate) isDisabled = monthDate.year > maxDate.year || monthDate.year === maxDate.year && monthDate.month >= maxDate.month;
+			if (minDate) isDisabled = monthDate.year < minDate.year || monthDate.year === minDate.year && monthDate.month <= minDate.month;
+			return {
+				month,
+				value: i,
+				isDisabled
+			};
+		});
+	};
+	const getAvailableYears = () => {
+		return years.map((year) => {
+			let isDisabled = false;
+			if (maxDate) isDisabled = year > maxDate.year || year === maxDate.year && displayDate.month >= maxDate.month;
+			if (minDate && !isDisabled) isDisabled = year < minDate.year || year === minDate.year && displayDate.month <= minDate.month;
+			return {
+				year,
+				isDisabled
+			};
+		});
+	};
+	const availableMonths = getAvailableMonths();
+	const availableYears = getAvailableYears();
+	const handleMonthChange = (value) => {
+		if (value === null) return;
+		const newDate = displayDate.set({ month: value + 1 });
+		onNavigate?.(newDate);
+	};
+	const handleYearChange = (value) => {
+		if (value === null) return;
+		const newDate = displayDate.set({ year: value });
+		onNavigate?.(newDate);
+	};
+	const handlePrevMonth = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		const newDate = displayDate.subtract({ months: 1 });
+		onNavigate?.(newDate);
+	};
+	const handleNextMonth = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		const newDate = displayDate.add({ months: 1 });
+		onNavigate?.(newDate);
+	};
+	const handlePrevYear = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		const newDate = displayDate.subtract({ years: 1 });
+		onNavigate?.(newDate);
+	};
+	const handleNextYear = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		const newDate = displayDate.add({ years: 1 });
+		onNavigate?.(newDate);
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex w-full items-center justify-between gap-3 border-elevation-outline-default-1 border-b border-solid px-3 py-2-5",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center",
+				children: [/* @__PURE__ */ jsx(InlineIconButton, {
+					color: "secondary",
+					isDisabled: isPrevYearDisabled,
+					onClick: handlePrevYear,
+					icon: ChevronsLeft,
+					label: t(($) => $.ui.datePicker.navigation.previousYear)
+				}), /* @__PURE__ */ jsx(InlineIconButton, {
+					color: "secondary",
+					isDisabled: isPrevMonthDisabled,
+					onClick: handlePrevMonth,
+					icon: ChevronLeft,
+					label: t(($) => $.ui.datePicker.navigation.previousMonth)
+				})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex gap-2",
+				children: [/* @__PURE__ */ jsx(Select, {
+					label: "Month",
+					hideLabel: true,
+					customTrigger: /* @__PURE__ */ jsx(PillButton, {
+						color: "secondary",
+						variant: "subtle",
+						iconPosition: "right",
+						icon: ChevronDown,
+						children: MONTHS[currentMonth].slice(0, 3)
+					}),
+					ignoreTriggerWidth: true,
+					items: availableMonths.map(({ month, value, isDisabled }) => ({
+						label: month,
+						id: value,
+						isDisabled
+					})).filter(({ isDisabled }) => !isDisabled),
+					value: currentMonth,
+					onChange: handleMonthChange
+				}), /* @__PURE__ */ jsx(Select, {
+					label: "Year",
+					hideLabel: true,
+					customTrigger: /* @__PURE__ */ jsx(PillButton, {
+						color: "secondary",
+						variant: "subtle",
+						iconPosition: "right",
+						icon: ChevronDown,
+						children: currentYear.toString()
+					}),
+					items: availableYears.map(({ year, isDisabled }) => ({
+						label: year.toString(),
+						id: year,
+						isDisabled
+					})).filter(({ isDisabled }) => !isDisabled),
+					value: currentYear,
+					onChange: handleYearChange
+				})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center",
+				children: [/* @__PURE__ */ jsx(InlineIconButton, {
+					color: "secondary",
+					isDisabled: isNextMonthDisabled,
+					onClick: handleNextMonth,
+					icon: ChevronRight,
+					label: t(($) => $.ui.datePicker.navigation.nextMonth)
+				}), /* @__PURE__ */ jsx(InlineIconButton, {
+					color: "secondary",
+					isDisabled: isNextYearDisabled,
+					onClick: handleNextYear,
+					icon: ChevronsRight,
+					label: t(($) => $.ui.datePicker.navigation.nextYear)
+				})]
+			})
+		]
+	});
+};
+//#endregion
+//#region src/components/inputs/DateTime/shared/RangeCalendar.tsx
+const RangeCalendar = ({ className, leftCalendarState, rightCalendarState, calendarProps, onApply, onRangeChange: _onRangeChange, onDateSelection, onDateHover, rangeSelection, hoverDate, onKeyboardNavigation, isRangeSelectionDisabled }) => {
+	const leftRef = useRef(null);
+	const rightRef = useRef(null);
+	const { calendarProps: leftCalendarAriaProps } = useRangeCalendar(calendarProps, leftCalendarState, leftRef);
+	const { calendarProps: rightCalendarAriaProps } = useRangeCalendar(calendarProps, rightCalendarState, rightRef);
+	const leftDate = leftCalendarState.visibleRange.start;
+	const rightDate = rightCalendarState.visibleRange.start;
+	const handleLeftKeyboardNavigation = (event, date) => {
+		return onKeyboardNavigation?.(event, date, "left") ?? false;
+	};
+	const handleRightKeyboardNavigation = (event, date) => {
+		return onKeyboardNavigation?.(event, date, "right") ?? false;
+	};
+	const handleLeftNavigate = (newDate) => {
+		const rightCurrentDate = rightCalendarState.visibleRange.start;
+		if (newDate.year < rightCurrentDate.year || newDate.year === rightCurrentDate.year && newDate.month < rightCurrentDate.month) leftCalendarState.setFocusedDate(newDate);
+		else {
+			const closestValidDate = rightCurrentDate.subtract({ months: 1 });
+			leftCalendarState.setFocusedDate(closestValidDate);
+		}
+	};
+	const handleRightNavigate = (newDate) => {
+		const leftCurrentDate = leftCalendarState.visibleRange.start;
+		if (newDate.year > leftCurrentDate.year || newDate.year === leftCurrentDate.year && newDate.month > leftCurrentDate.month) rightCalendarState.setFocusedDate(newDate);
+		else {
+			const closestValidDate = leftCurrentDate.add({ months: 1 });
+			rightCalendarState.setFocusedDate(closestValidDate);
+		}
+	};
+	const isNextDisabled = useMemo(() => {
+		const leftNextDate = leftDate.add({ months: 1 });
+		return leftNextDate.year > rightDate.year || leftNextDate.year === rightDate.year && leftNextDate.month === rightDate.month;
+	}, [leftDate, rightDate]);
+	const isPrevDisabled = useMemo(() => {
+		const rightPrevDate = rightDate.subtract({ months: 1 });
+		return rightPrevDate.year < leftDate.year || rightPrevDate.year === leftDate.year && rightPrevDate.month === leftDate.month;
+	}, [leftDate, rightDate]);
+	return /* @__PURE__ */ jsx("div", {
+		className: clsx("flex w-fit flex-col items-center bg-elevation-fill-default-1", className),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex",
+			children: [/* @__PURE__ */ jsxs("div", {
+				...leftCalendarAriaProps,
+				ref: leftRef,
+				className: "flex flex-col items-center",
+				children: [/* @__PURE__ */ jsx(CalendarSelectHeader, {
+					state: leftCalendarState,
+					isNextMonthDisabled: isNextDisabled,
+					isNextYearDisabled: isNextDisabled,
+					onNavigate: handleLeftNavigate,
+					maxDate: rightDate
+				}), /* @__PURE__ */ jsx(CalendarGrid, {
+					state: leftCalendarState,
+					onApply,
+					shouldCloseOnSelect: false,
+					onDateSelection,
+					rangeSelection,
+					onDateHover,
+					hoverDate,
+					onKeyboardNavigation: handleLeftKeyboardNavigation,
+					className: clsx("h-64 w-[304px]!", isRangeSelectionDisabled && "pointer-events-none opacity-50"),
+					calendarSide: "left",
+					isSelectionDisabled: isRangeSelectionDisabled
+				})]
+			}), /* @__PURE__ */ jsxs("div", {
+				...rightCalendarAriaProps,
+				ref: rightRef,
+				className: "hidden flex-col items-center md:flex",
+				children: [/* @__PURE__ */ jsx(CalendarSelectHeader, {
+					state: rightCalendarState,
+					isPrevMonthDisabled: isPrevDisabled,
+					isPrevYearDisabled: isPrevDisabled,
+					onNavigate: handleRightNavigate,
+					minDate: leftDate
+				}), /* @__PURE__ */ jsx(CalendarGrid, {
+					state: rightCalendarState,
+					onApply,
+					shouldCloseOnSelect: false,
+					onDateSelection,
+					rangeSelection,
+					onDateHover,
+					hoverDate,
+					onKeyboardNavigation: handleRightKeyboardNavigation,
+					className: clsx("h-64 w-[304px]!", isRangeSelectionDisabled && "pointer-events-none opacity-50"),
+					calendarSide: "right",
+					isSelectionDisabled: isRangeSelectionDisabled
+				})]
+			})]
+		})
+	});
+};
+//#endregion
+//#region src/components/inputs/DateTime/DateRangePicker/dateRangePreset.utils.ts
+const dateRangePresetValues = [
+	"thisWeek",
+	"lastWeek",
+	"thisAndLastWeek",
+	"thisMonth",
+	"thisAndLastMonth",
+	"thisYear",
+	"lastYear",
+	"thisAndLastYear",
+	"soFar"
+];
+const isStoredRelativeDateRangeValue = (value) => typeof value === "object" && value !== null && typeof value.relativeValue === "string";
+const isRelativeDateRangeValue = (value) => isStoredRelativeDateRangeValue(value) && typeof value.resolvedValue === "object";
+const isDateRangePresetValue = (value) => dateRangePresetValues.some((preset) => preset === value);
+const getDateRangePreset = (value, currentDate = today(getLocalTimeZone()), locale = "en-GB") => {
+	if (!isDateRangePresetValue(value)) return;
+	const previousYear = currentDate.subtract({ years: 1 });
+	switch (value) {
+		case "thisWeek": return {
+			start: startOfWeek(currentDate, locale),
+			end: endOfWeek(currentDate, locale)
+		};
+		case "lastWeek": {
+			const thisWeekStart = startOfWeek(currentDate, locale);
+			return {
+				start: thisWeekStart.subtract({ weeks: 1 }),
+				end: thisWeekStart.subtract({ days: 1 })
+			};
+		}
+		case "thisAndLastWeek": return {
+			start: startOfWeek(currentDate, locale).subtract({ weeks: 1 }),
+			end: endOfWeek(currentDate, locale)
+		};
+		case "thisMonth": return {
+			start: startOfMonth(currentDate),
+			end: endOfMonth(currentDate)
+		};
+		case "thisAndLastMonth": return {
+			start: startOfMonth(currentDate).subtract({ months: 1 }),
+			end: endOfMonth(currentDate)
+		};
+		case "thisYear":
+		case "soFar": return {
+			start: startOfYear(currentDate),
+			end: currentDate
+		};
+		case "lastYear": return {
+			start: startOfYear(previousYear),
+			end: endOfYear(previousYear)
+		};
+		case "thisAndLastYear": return {
+			start: startOfYear(previousYear),
+			end: currentDate
+		};
+	}
+};
+const resolveDateRangePreset = (value, currentDate = today(getLocalTimeZone()), locale = "en-GB") => {
+	const range = getDateRangePreset(value, currentDate, locale);
+	if (!range) return;
+	return {
+		start: DateTimeUtils.fromCalendarDateToUTCISO(range.start),
+		end: DateTimeUtils.fromCalendarDateToUTCISO(range.end, { endOfDay: true })
+	};
+};
+const hydrateRelativeDateRangeValue = (value, currentDate = today(getLocalTimeZone()), locale = "en-GB") => {
+	if (isRelativeDateRangeValue(value)) return value;
+	const resolvedValue = resolveDateRangePreset(value.relativeValue, currentDate, locale);
+	return resolvedValue ? {
+		relativeValue: value.relativeValue,
+		resolvedValue
+	} : void 0;
+};
+//#endregion
+//#region src/components/inputs/DateTime/DateRangePicker/DateRangePicker.tsx
+const DateRangePickerBase = (props) => {
+	const ui = UIConfig.useConfig();
+	const { t } = useTranslation();
+	const { ref, label, tooltipText, helperText, isRequired, rightContent, isDisabled, isDirty, headerClassName, errorClassName, isHeaderHidden, error, onChange, onBlur, onValueCommit, value, disableDropdown, className, hideSidebar, placeholder, inputClassName, hideLabel: hideLabelProp, variant: variantProp, as: asProp, size: sizeProp, isClearable: isClearableProp, isClearableIfDisabled, todayIcon: todayIconProp, todayIconButtonSize: todayIconButtonSizeProp, todayIconButtonComponent: todayIconButtonComponentProp, todayIconPlacement: todayIconPlacementProp, shouldForceLeadingZeros: shouldForceLeadingZerosProp, disableManualEntry: disableManualEntryProp, autoFixYear: autoFixYearProp, allowPartialRange: allowPartialRangeProp, mode = "absolute", relativeValue, relativeOptions = [], onRelativeChange, enableRelativeMode, onModeChange, minValue, maxValue, ...rest } = props;
+	const hideLabel = hideLabelProp ?? ui.input.hideLabel;
+	const variant = variantProp ?? ui.input.variant;
+	const as = asProp ?? ui.input.as;
+	const size = sizeProp ?? ui.input.size;
+	const isClearable = isClearableProp ?? ui.input.isClearable;
+	const todayIcon = todayIconProp ?? ui.dateInput.todayIcon;
+	const todayIconButtonSize = todayIconButtonSizeProp ?? ui.dateInput.todayIconButtonSize;
+	const todayIconButtonComponent = todayIconButtonComponentProp ?? ui.dateInput.todayIconButtonComponent;
+	const todayIconPlacement = todayIconPlacementProp ?? ui.dateInput.todayIconPlacement;
+	const shouldForceLeadingZeros = shouldForceLeadingZerosProp ?? ui.dateInput.shouldForceLeadingZeros;
+	const disableManualEntry = disableManualEntryProp ?? ui.dateInput.disableManualEntry;
+	const autoFixYear = autoFixYearProp ?? ui.dateInput.autoFixYear;
+	const allowPartialRange = allowPartialRangeProp ?? ui.dateInput.allowPartialRange;
+	const timeZone = ui.dateInput.timeZone;
+	let effectiveTimeZone = getLocalTimeZone();
+	if (timeZone !== "clientLocal") effectiveTimeZone = timeZone;
+	const [validationRangeError, setValidationRangeError] = useState();
+	const datePickerInputRef = useRef(null);
+	const dateRangePickerRef = useMemo(() => ({ get current() {
+		return datePickerInputRef.current?.getContainer?.() || null;
+	} }), []);
+	const normalizedValue = value ?? null;
+	const fieldRangeRef = useRef(normalizedValue);
+	fieldRangeRef.current = normalizedValue;
+	const dialogState = $6de3e3f1a7663217$export$e50a61c1de9f574({
+		...rest,
+		value: normalizedValue,
+		shouldCloseOnSelect: false,
+		shouldForceLeadingZeros,
+		minValue,
+		maxValue
+	});
+	const state = $6de3e3f1a7663217$export$e50a61c1de9f574({
+		...rest,
+		shouldForceLeadingZeros,
+		value: normalizedValue,
+		minValue,
+		maxValue,
+		onChange: (newValue) => {
+			if (allowPartialRange && newValue === null) return;
+			fieldRangeRef.current = newValue;
+			const isInvalidRange = isValidRange(newValue);
+			onChange?.(newValue);
+			if (isInvalidRange) return;
+			handleCalendarStatesChange(newValue);
+		},
+		shouldCloseOnSelect: false
+	});
+	const { groupProps, labelProps, startFieldProps, endFieldProps, buttonProps, dialogProps } = $cccdba1b2bb08448$export$12fd5f0e9f4bb192({
+		...rest,
+		label,
+		shouldForceLeadingZeros,
+		minValue,
+		maxValue
+	}, state, dateRangePickerRef);
+	const { calendarProps } = $cccdba1b2bb08448$export$12fd5f0e9f4bb192({
+		...rest,
+		label,
+		shouldForceLeadingZeros,
+		minValue,
+		maxValue
+	}, dialogState, dateRangePickerRef);
+	const emitPartialRangeChange = (part, date) => {
+		if (!allowPartialRange) return;
+		const partialRange = {
+			start: part === "start" ? date : fieldRangeRef.current?.start ?? null,
+			end: part === "end" ? date : fieldRangeRef.current?.end ?? null
+		};
+		fieldRangeRef.current = partialRange;
+		if (partialRange.start && partialRange.end) return;
+		const newValue = partialRange.start || partialRange.end ? partialRange : null;
+		onChange?.(newValue);
+	};
+	const { locale } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+	useImperativeHandle(ref, () => ({
+		clear: () => {
+			datePickerInputRef.current?.clear();
+		},
+		getContainer: () => datePickerInputRef.current?.getContainer?.() ?? null
+	}));
+	const handleBlur = (newValue) => {
+		onBlur?.({ target: { value: newValue } });
+	};
+	const formFieldProps = {
+		error: error || validationRangeError,
+		label,
+		tooltipText,
+		helperText,
+		isRequired,
+		rightContent,
+		isHeaderHidden: isHeaderHidden || as === "inline" || as === "filter" || as === "floating",
+		hideLabel,
+		isDisabled,
+		headerClassName,
+		errorClassName
+	};
+	const leftCalendarState = $a0a87fb6fcfb22ec$export$9a987164d97ecc90({
+		...calendarProps,
+		locale,
+		createCalendar,
+		pageBehavior: "single",
+		visibleDuration: { months: 1 },
+		minValue,
+		maxValue
+	});
+	const rightCalendarState = $a0a87fb6fcfb22ec$export$9a987164d97ecc90({
+		...calendarProps,
+		locale,
+		createCalendar,
+		pageBehavior: "single",
+		visibleDuration: { months: 1 },
+		defaultFocusedValue: today(effectiveTimeZone).add({ months: 1 }),
+		minValue,
+		maxValue
+	});
+	const [activePreset, setActivePreset] = useState(mode === "relative" ? relativeValue ?? null : null);
+	const handledRelativeValueRef = useRef(relativeValue);
+	useEffect(() => {
+		setActivePreset(mode === "relative" ? relativeValue ?? null : null);
+	}, [mode, relativeValue]);
+	const [rangeSelection, setRangeSelection] = useState({
+		start: value?.start || null,
+		end: value?.end || null,
+		isSelecting: false
+	});
+	const [hoverDate, setHoverDate] = useState(null);
+	const headerProps = {
+		label,
+		tooltipText,
+		helperText,
+		isRequired,
+		rightContent,
+		isHeaderHidden: hideLabel || isHeaderHidden,
+		isDisabled,
+		className: headerClassName,
+		labelProps
+	};
+	const isDateOutsideBounds = useCallback((date) => {
+		if (minValue && date.compare(minValue) < 0) return true;
+		if (maxValue && date.compare(maxValue) > 0) return true;
+		return false;
+	}, [minValue, maxValue]);
+	const clampRangeToBounds = useCallback((range) => {
+		if (range === null) return null;
+		if (minValue && maxValue && minValue.compare(maxValue) > 0) return null;
+		let startDate = range.start;
+		let endDate = range.end;
+		if (minValue && endDate.compare(minValue) < 0 || maxValue && startDate.compare(maxValue) > 0) return null;
+		if (minValue && startDate.compare(minValue) < 0) startDate = minValue;
+		if (maxValue && startDate.compare(maxValue) > 0) startDate = maxValue;
+		if (minValue && endDate.compare(minValue) < 0) endDate = minValue;
+		if (maxValue && endDate.compare(maxValue) > 0) endDate = maxValue;
+		if (startDate.compare(endDate) > 0) return null;
+		return {
+			start: startDate,
+			end: endDate
+		};
+	}, [minValue, maxValue]);
+	const isRangeWithinBounds = useCallback((range) => {
+		if (minValue && range.start.compare(minValue) < 0) return false;
+		if (maxValue && range.end.compare(maxValue) > 0) return false;
+		return true;
+	}, [minValue, maxValue]);
+	const isValidRange = useCallback((newValue) => {
+		if (newValue?.start && newValue?.end) {
+			const startDate = newValue.start;
+			if (newValue.end.compare(startDate) < 0) {
+				setValidationRangeError(t(($) => $.ui.datePicker.errors.endDateBeforeStart, { ns: "ui" }));
+				return true;
+			}
+			setValidationRangeError(void 0);
+		} else setValidationRangeError(void 0);
+		return false;
+	}, [t]);
+	const handleCalendarStatesChange = (newValue) => {
+		if (newValue) {
+			const clampedValue = clampRangeToBounds(newValue);
+			if (!clampedValue) return;
+			if (isValidRange(clampedValue)) return;
+			dialogState.setValue(clampedValue);
+			const startDate = clampedValue.start;
+			const endDate = clampedValue.end;
+			leftCalendarState.setFocusedDate(startDate);
+			if (startDate.year === endDate.year && startDate.month === endDate.month) rightCalendarState.setFocusedDate(startDate.add({ months: 1 }));
+			else rightCalendarState.setFocusedDate(endDate);
+			leftCalendarState.setValue(clampedValue);
+			rightCalendarState.setValue(clampedValue);
+			setRangeSelection({
+				start: clampedValue.start,
+				end: clampedValue.end,
+				isSelecting: false
+			});
+			setHoverDate(null);
+			setActivePreset(null);
+		} else {
+			setValidationRangeError(void 0);
+			dialogState.setValue(null);
+			leftCalendarState.setValue(null);
+			rightCalendarState.setValue(null);
+			setRangeSelection({
+				start: null,
+				end: null,
+				isSelecting: false
+			});
+			setHoverDate(null);
+			setActivePreset(null);
+		}
+	};
+	const throttledSetHoverDate = useCallback((date) => {
+		requestAnimationFrame(() => {
+			setHoverDate(date);
+		});
+	}, []);
+	const handleDateHover = useCallback((date) => {
+		if (rangeSelection.isSelecting && rangeSelection.start) throttledSetHoverDate(date);
+	}, [
+		rangeSelection.isSelecting,
+		rangeSelection.start,
+		throttledSetHoverDate
+	]);
+	const handleDateSelection = useCallback((date, calendarSide) => {
+		if (calendarSide) {
+			const currentVisibleMonth = (calendarSide === "left" ? leftCalendarState : rightCalendarState).visibleRange.start;
+			if (date.month !== currentVisibleMonth.month || date.year !== currentVisibleMonth.year) {
+				if (calendarSide === "left") {
+					leftCalendarState.setFocusedDate(date);
+					rightCalendarState.setFocusedDate(date.add({ months: 1 }));
+				} else {
+					rightCalendarState.setFocusedDate(date);
+					leftCalendarState.setFocusedDate(date.subtract({ months: 1 }));
+				}
+			}
+		}
+		if (isDateOutsideBounds(date)) return;
+		if (!rangeSelection.isSelecting || !rangeSelection.start) {
+			setRangeSelection({
+				start: date,
+				end: null,
+				isSelecting: true
+			});
+			setHoverDate(null);
+			leftCalendarState.setValue(null);
+			rightCalendarState.setValue(null);
+		} else {
+			const { start } = rangeSelection;
+			const end = date;
+			const newRange = {
+				start: start.compare(end) <= 0 ? start : end,
+				end: start.compare(end) <= 0 ? end : start
+			};
+			const clampedRange = clampRangeToBounds(newRange);
+			if (!clampedRange) return;
+			leftCalendarState.setValue(clampedRange);
+			rightCalendarState.setValue(clampedRange);
+			dialogState.setValue(clampedRange);
+			setRangeSelection({
+				start: clampedRange.start,
+				end: clampedRange.end,
+				isSelecting: false
+			});
+			setHoverDate(null);
+			setActivePreset(null);
+		}
+	}, [
+		rangeSelection,
+		leftCalendarState,
+		rightCalendarState,
+		dialogState,
+		isDateOutsideBounds,
+		clampRangeToBounds
+	]);
+	const handleKeyboardNavigation = useCallback((event, date, calendarSide) => {
+		const currentState = calendarSide === "left" ? leftCalendarState : rightCalendarState;
+		const otherState = calendarSide === "left" ? rightCalendarState : leftCalendarState;
+		let shouldPreventDefault = false;
+		switch (event.key) {
+			case "ArrowRight": {
+				const nextDate = date.add({ days: 1 });
+				const currentMonth = currentState.visibleRange.start;
+				const otherMonth = otherState.visibleRange.start;
+				if (calendarSide === "left" && nextDate.month !== currentMonth.month) {
+					if (nextDate.year === otherMonth.year && nextDate.month === otherMonth.month) {
+						otherState.setFocusedDate(nextDate);
+						shouldPreventDefault = true;
+					} else {
+						rightCalendarState.setFocusedDate(nextDate);
+						shouldPreventDefault = true;
+					}
+				}
+				break;
+			}
+			case "ArrowLeft": {
+				const prevDate = date.subtract({ days: 1 });
+				const currentMonth = currentState.visibleRange.start;
+				const otherMonth = otherState.visibleRange.start;
+				if (calendarSide === "right" && prevDate.month !== currentMonth.month) {
+					if (prevDate.year === otherMonth.year && prevDate.month === otherMonth.month) {
+						otherState.setFocusedDate(prevDate);
+						shouldPreventDefault = true;
+					} else {
+						leftCalendarState.setFocusedDate(prevDate);
+						shouldPreventDefault = true;
+					}
+				}
+				break;
+			}
+			case "ArrowDown": {
+				const nextWeekDate = date.add({ weeks: 1 });
+				const currentMonth = currentState.visibleRange.start;
+				const otherMonth = otherState.visibleRange.start;
+				if (calendarSide === "left" && nextWeekDate.month !== currentMonth.month) {
+					if (nextWeekDate.year === otherMonth.year && nextWeekDate.month === otherMonth.month) {
+						otherState.setFocusedDate(nextWeekDate);
+						shouldPreventDefault = true;
+					} else {
+						rightCalendarState.setFocusedDate(nextWeekDate);
+						shouldPreventDefault = true;
+					}
+				}
+				break;
+			}
+			case "ArrowUp": {
+				const prevWeekDate = date.subtract({ weeks: 1 });
+				const currentMonth = currentState.visibleRange.start;
+				const otherMonth = otherState.visibleRange.start;
+				if (calendarSide === "right" && prevWeekDate.month !== currentMonth.month) {
+					if (prevWeekDate.year === otherMonth.year && prevWeekDate.month === otherMonth.month) {
+						otherState.setFocusedDate(prevWeekDate);
+						shouldPreventDefault = true;
+					} else {
+						leftCalendarState.setFocusedDate(prevWeekDate);
+						shouldPreventDefault = true;
+					}
+				}
+				break;
+			}
+			case "Enter":
+			case " ":
+				handleDateSelection(date);
+				shouldPreventDefault = true;
+				break;
+			case "Escape":
+				setRangeSelection({
+					start: null,
+					end: null,
+					isSelecting: false
+				});
+				setHoverDate(null);
+				shouldPreventDefault = true;
+		}
+		if (shouldPreventDefault) {
+			event.preventDefault();
+			event.stopPropagation();
+		}
+		return shouldPreventDefault;
+	}, [
+		leftCalendarState,
+		rightCalendarState,
+		handleDateSelection
+	]);
+	const syncCalendarStates = useCallback((newValue) => {
+		if (newValue === null) {
+			setValidationRangeError(void 0);
+			leftCalendarState.setValue(null);
+			rightCalendarState.setValue(null);
+			dialogState.setValue(null);
+			setRangeSelection({
+				start: null,
+				end: null,
+				isSelecting: false
+			});
+			setHoverDate(null);
+			return;
+		}
+		const clampedValue = clampRangeToBounds(newValue);
+		if (!clampedValue) return;
+		if (isValidRange(clampedValue)) return;
+		leftCalendarState.setValue(clampedValue);
+		rightCalendarState.setValue(clampedValue);
+		dialogState.setValue(clampedValue);
+		setRangeSelection({
+			start: clampedValue.start,
+			end: clampedValue.end,
+			isSelecting: false
+		});
+		setHoverDate(null);
+	}, [
+		isValidRange,
+		leftCalendarState,
+		rightCalendarState,
+		dialogState,
+		clampRangeToBounds
+	]);
+	const onApply = () => {
+		if (mode === "relative") {
+			const preset = presets.find((option) => option.value === activePreset);
+			handledRelativeValueRef.current = activePreset;
+			onRelativeChange?.(activePreset, preset?.clampedValue ?? null);
+			onValueCommit?.();
+			state.toggle();
+			return;
+		}
+		let valueToApply = dialogState.value;
+		if (rangeSelection.start && rangeSelection.end) valueToApply = {
+			start: rangeSelection.start,
+			end: rangeSelection.end
+		};
+		if (valueToApply) {
+			const clampedValue = clampRangeToBounds(valueToApply);
+			if (clampedValue) {
+				valueToApply = clampedValue;
+				state.setValue(clampedValue);
+			}
+		}
+		state.toggle();
+		onValueCommit?.();
+	};
+	const onTodayPress = () => {
+		const todayDate = today(effectiveTimeZone);
+		const clampedTodayRange = clampRangeToBounds({
+			start: todayDate,
+			end: todayDate
+		});
+		if (!clampedTodayRange) return;
+		const startDate = clampedTodayRange.start;
+		const endDate = clampedTodayRange.end;
+		leftCalendarState.setFocusedDate(startDate);
+		if (startDate.year === endDate.year && startDate.month === endDate.month) rightCalendarState.setFocusedDate(startDate.add({ months: 1 }));
+		else rightCalendarState.setFocusedDate(endDate);
+		syncCalendarStates(clampedTodayRange);
+	};
+	const onInputClear = () => {
+		if (mode === "relative") {
+			setActivePreset(null);
+			handledRelativeValueRef.current = null;
+			onRelativeChange?.(null, null);
+			onValueCommit?.();
+			return;
+		}
+		fieldRangeRef.current = null;
+		onChange?.(null);
+		dialogState.setValue(null);
+		leftCalendarState.setValue(null);
+		rightCalendarState.setValue(null);
+		setRangeSelection({
+			start: null,
+			end: null,
+			isSelecting: false
+		});
+		setHoverDate(null);
+		onValueCommit?.();
+	};
+	const syncSelectionFromControlledValue = () => {
+		if (mode === "relative") {
+			setActivePreset(relativeValue ?? null);
+			return;
+		}
+		const currentValue = state.value;
+		if (!(currentValue != null && currentValue.start != null && currentValue.end != null)) {
+			syncCalendarStates(null);
+			return;
+		}
+		syncCalendarStates(currentValue);
+		const startDate = currentValue.start;
+		const endDate = currentValue.end;
+		leftCalendarState.setFocusedDate(startDate);
+		if (startDate.year === endDate.year && startDate.month === endDate.month) {
+			rightCalendarState.setFocusedDate(startDate.add({ months: 1 }));
+			return;
+		}
+		rightCalendarState.setFocusedDate(endDate);
+	};
+	useEffect(() => {
+		if (!state.isOpen) return;
+		syncSelectionFromControlledValue();
+	}, [state.isOpen]);
+	const onOpenChange = (_isOpen) => {
+		state.toggle();
+		syncSelectionFromControlledValue();
+	};
+	const onOpenDropdown = () => {
+		syncSelectionFromControlledValue();
+		state.toggle();
+	};
+	const todayDate = today(effectiveTimeZone);
+	const getPresetRange = (value) => () => getDateRangePreset(value, todayDate, locale);
+	const createPreset = (params) => {
+		let clampedValue = clampRangeToBounds(params.getValue());
+		let isDisabled = false;
+		if (params.keepEnabledUnlessFutureMin) {
+			let minDateIsInFuture = false;
+			if (minValue && minValue.compare(todayDate) > 0) minDateIsInFuture = true;
+			if (minDateIsInFuture) {
+				isDisabled = true;
+				clampedValue = null;
+			} else if (!clampedValue && maxValue) clampedValue = {
+				start: maxValue,
+				end: maxValue
+			};
+		}
+		if (!clampedValue) isDisabled = true;
+		if (clampedValue && !isRangeWithinBounds(clampedValue)) isDisabled = true;
+		return {
+			value: params.value,
+			label: params.label,
+			getValue: params.getValue,
+			clampedValue,
+			isDisabled
+		};
+	};
+	const presets = [
+		createPreset({
+			value: "thisWeek",
+			label: t(($) => $.ui.datePicker.presets.thisWeek, { ns: "ui" }),
+			getValue: getPresetRange("thisWeek")
+		}),
+		createPreset({
+			value: "lastWeek",
+			label: t(($) => $.ui.datePicker.presets.lastWeek, { ns: "ui" }),
+			getValue: getPresetRange("lastWeek")
+		}),
+		createPreset({
+			value: "thisAndLastWeek",
+			label: t(($) => $.ui.datePicker.presets.thisAndLastWeek, { ns: "ui" }),
+			getValue: getPresetRange("thisAndLastWeek")
+		}),
+		createPreset({
+			value: "thisMonth",
+			label: t(($) => $.ui.datePicker.presets.thisMonth, { ns: "ui" }),
+			getValue: getPresetRange("thisMonth")
+		}),
+		createPreset({
+			value: "thisAndLastMonth",
+			label: t(($) => $.ui.datePicker.presets.thisAndLastMonth, { ns: "ui" }),
+			getValue: getPresetRange("thisAndLastMonth")
+		}),
+		createPreset({
+			value: "thisYear",
+			label: t(($) => $.ui.datePicker.presets.thisYear, { ns: "ui" }),
+			getValue: getPresetRange("thisYear")
+		}),
+		createPreset({
+			value: "lastYear",
+			label: t(($) => $.ui.datePicker.presets.lastYear, { ns: "ui" }),
+			getValue: getPresetRange("lastYear")
+		}),
+		createPreset({
+			value: "thisAndLastYear",
+			label: t(($) => $.ui.datePicker.presets.thisAndLastYear, { ns: "ui" }),
+			getValue: getPresetRange("thisAndLastYear")
+		}),
+		createPreset({
+			value: "soFar",
+			label: t(($) => $.ui.datePicker.presets.soFar, { ns: "ui" }),
+			getValue: getPresetRange("soFar"),
+			keepEnabledUnlessFutureMin: true
+		}),
+		...relativeOptions.map((option) => {
+			const resolvedValue = option.getValue();
+			const range = {
+				start: DateTimeUtils.fromUTCISOToCalendarDate(resolvedValue.start),
+				end: DateTimeUtils.fromUTCISOToCalendarDate(resolvedValue.end)
+			};
+			const clampedValue = clampRangeToBounds(range);
+			return {
+				value: option.value,
+				label: option.label,
+				getValue: () => range,
+				clampedValue,
+				isDisabled: (option.isDisabled ?? false) || !clampedValue
+			};
+		})
+	];
+	const selectPreset = (preset) => {
+		if (preset.isDisabled || mode !== "relative" && !preset.clampedValue) return;
+		setActivePreset(mode === "relative" ? preset.value : preset.label);
+		if (!preset.clampedValue) return;
+		const presetValue = preset.clampedValue;
+		syncCalendarStates(presetValue);
+		const startDate = presetValue.start;
+		leftCalendarState.setFocusedDate(startDate);
+		const endDate = presetValue.end;
+		if ((endDate.year - startDate.year) * 12 + (endDate.month - startDate.month) > 2) rightCalendarState.setFocusedDate(endDate);
+		else {
+			const rightCalendarMonth = startDate.add({ months: 1 });
+			rightCalendarState.setFocusedDate(rightCalendarMonth);
+		}
+		if (mode === "relative") setActivePreset(preset.value);
+	};
+	const activeRelativeOption = mode === "relative" ? presets.find((preset) => preset.value === relativeValue) : void 0;
+	useEffect(() => {
+		if (mode !== "relative" || handledRelativeValueRef.current === relativeValue) return;
+		handledRelativeValueRef.current = relativeValue;
+		onChange?.(activeRelativeOption?.clampedValue ?? null);
+	}, [
+		activeRelativeOption?.clampedValue,
+		mode,
+		onChange,
+		relativeValue
+	]);
+	const relativeDisplayValue = activeRelativeOption ? /* @__PURE__ */ jsx(Typography, {
+		size: "label-1",
+		children: activeRelativeOption.label
+	}) : void 0;
+	return /* @__PURE__ */ jsx(TooltipWrapper, {
+		as,
+		error,
+		triggerTabIndex: as === "inline" ? -1 : void 0,
+		children: /* @__PURE__ */ jsxs(FormField, {
+			...formFieldProps,
+			as,
+			labelProps,
+			className: clsx("group relative inline-flex w-full flex-col text-left", className),
+			tabIndex: as === "inline" ? -1 : void 0,
+			children: [/* @__PURE__ */ jsx(DatePickerInput, {
+				ref: $a8ea2faf2ebe4d2f$re_export$mergeRefs(ref, datePickerInputRef),
+				as,
+				groupProps,
+				fieldProps: {
+					...startFieldProps,
+					onChange: (date) => {
+						startFieldProps.onChange?.(date);
+						emitPartialRangeChange("start", date);
+					},
+					onBlur: (event) => {
+						startFieldProps.onBlur?.(event);
+						handleBlur(state.value);
+					}
+				},
+				endFieldProps: {
+					...endFieldProps,
+					onChange: (date) => {
+						endFieldProps.onChange?.(date);
+						emitPartialRangeChange("end", date);
+					},
+					onBlur: (event) => {
+						endFieldProps.onBlur?.(event);
+						handleBlur(state.value);
+					}
+				},
+				fieldValue: normalizedValue?.start ?? null,
+				endFieldValue: normalizedValue?.end ?? null,
+				isValueControlled: true,
+				hasValue: mode === "relative" ? !!relativeValue : normalizedValue?.start != null || normalizedValue?.end != null,
+				buttonProps,
+				isDisabled,
+				isInvalid: !!error,
+				disableDropdown,
+				variant,
+				size,
+				isClearable,
+				isClearableIfDisabled,
+				headerProps,
+				todayIcon,
+				todayIconButtonSize,
+				todayIconButtonComponent,
+				todayIconPlacement,
+				isDirty,
+				isRequired,
+				disableManualEntry: mode === "relative" || disableManualEntry,
+				displayContent: relativeDisplayValue,
+				autoFixYear,
+				placeholder,
+				className: inputClassName,
+				onOpenDropdown,
+				timeZone: effectiveTimeZone,
+				onClear: onInputClear,
+				onValueCommit
+			}), /* @__PURE__ */ jsx(DateTimeDialog, {
+				hideSidebar,
+				sidebar: /* @__PURE__ */ jsxs("div", {
+					className: "flex w-full flex-row overflow-auto border-elevation-outline-default-1 border-solid [-ms-overflow-style:none] [scrollbar-width:none] md:w-[156px] md:flex-col md:border-r [&::-webkit-scrollbar]:hidden",
+					children: [enableRelativeMode && /* @__PURE__ */ jsx(Switch, {
+						isSelected: mode === "relative",
+						onChange: onModeChange,
+						className: "shrink-0 px-2 py-2 md:px-list-side-item-left",
+						children: t(($) => $.ui.datePicker.relativeMode, { ns: "ui" })
+					}), presets.map((preset) => /* @__PURE__ */ jsx($7705c033048f6da7$export$353f5b6fc5456de1, {
+						isDisabled: preset.isDisabled,
+						onClick: () => selectPreset(preset),
+						className: clsx("w-full px-2 py-1 text-left md:px-list-side-item-left md:py-list-height-item disabled:text-interactive-text-secondary-disabled!", activePreset !== (mode === "relative" ? preset.value : preset.label) && "text-interactive-text-secondary-idle hover:text-interactive-text-secondary-hover", activePreset === (mode === "relative" ? preset.value : preset.label) && "bg-interactive-contained-primary-idle text-interactive-text-secondary-idle-inverted"),
+						children: /* @__PURE__ */ jsx(Typography, {
+							size: "label-2",
+							sizeMobile: "label-3",
+							as: "span",
+							className: "whitespace-nowrap",
+							children: preset.label
+						})
+					}, mode === "relative" ? preset.value : preset.label))]
+				}),
+				footer: /* @__PURE__ */ jsx(DateTimeDialogFooter, {
+					isDisabled,
+					isValid: mode === "relative" ? !!activePreset : !dialogState.isInvalid && !!dialogState.value,
+					onTodayPress: mode === "relative" ? void 0 : onTodayPress,
+					onApply
+				}),
+				label,
+				triggerRef: dateRangePickerRef,
+				dialogProps,
+				isOpen: state.isOpen,
+				onOpenChange,
+				children: /* @__PURE__ */ jsx("div", {
+					className: "mb-4 flex max-w-[804px] md:mb-0",
+					children: /* @__PURE__ */ jsx("div", {
+						className: "flex flex-1 justify-center",
+						children: /* @__PURE__ */ jsx(RangeCalendar, {
+							leftCalendarState,
+							rightCalendarState,
+							calendarProps,
+							onApply,
+							onRangeChange: syncCalendarStates,
+							onDateSelection: mode === "relative" ? void 0 : handleDateSelection,
+							onDateHover: handleDateHover,
+							rangeSelection,
+							hoverDate,
+							onKeyboardNavigation: mode === "relative" ? void 0 : handleKeyboardNavigation,
+							isRangeSelectionDisabled: mode === "relative"
+						})
+					})
+				})
+			})]
+		})
+	});
+};
+const DateRangePickerInner = ({ fullIso = true, minValue, maxValue, renderStaticInput, isFormControlDisabled, ...props }) => {
+	const ui = UIConfig.useConfig();
+	const { t } = useTranslation();
+	const datePickerInputContentRowCva = UIOverrides.useCva("datePickerInput.contentRowCva", datePickerInputContentRowDefinition);
+	const { locale } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+	const shouldForceLeadingZeros = props.shouldForceLeadingZeros ?? ui.dateInput.shouldForceLeadingZeros;
+	const allowPartialRange = props.allowPartialRange ?? ui.dateInput.allowPartialRange;
+	const [renderInput, setRenderInput] = useState(!(renderStaticInput ?? ui.renderStaticInput));
+	const inputRef = useRef(null);
+	const { renderRealInput, replayStaticInputPress } = useStaticInputHandoff({
+		inputRef,
+		renderInput,
+		setRenderInput,
+		getFocusTarget: (input, staticTarget, fromEnd) => {
+			const container = input.getContainer?.() ?? input;
+			return container instanceof HTMLElement ? getStaticDateTimeFocusTarget(container, staticTarget, fromEnd) : null;
+		},
+		getPressTarget: (input) => {
+			const container = input.getContainer?.() ?? input;
+			if (!(container instanceof HTMLElement)) return null;
+			return container.querySelector("[data-static-press-action]");
+		}
+	});
+	const normalizedValue = props.value ?? null;
+	const [isRelativeMode, setIsRelativeMode] = useState(props.enableRelativeMode === true && props.relativeValue != null);
+	const mode = isRelativeMode ? "relative" : "absolute";
+	useEffect(() => {
+		if (!props.enableRelativeMode) setIsRelativeMode(false);
+		else if (props.relativeValue != null) setIsRelativeMode(true);
+	}, [props.enableRelativeMode, props.relativeValue]);
+	const formatDateRange = (range) => {
+		if (!range || !range.start && !range.end || !allowPartialRange && (!range.start || !range.end)) return null;
+		if (fullIso) return {
+			start: range.start ? DateTimeUtils.fromCalendarDateToUTCISO(range.start) : null,
+			end: range.end ? DateTimeUtils.fromCalendarDateToUTCISO(range.end, { endOfDay: true }) : null
+		};
+		const startDate = range.start ? DateTimeUtils.fromDateValueToLocal(range.start, "UTC") : null;
+		const endDate = range.end ? DateTimeUtils.fromDateValueToLocal(range.end, "UTC") : null;
+		return {
+			start: startDate ? startDate.toISOString().slice(0, 10) : null,
+			end: endDate ? endDate.toISOString().slice(0, 10) : null
+		};
+	};
+	const parseDateRange = (formattedRange) => {
+		if (!formattedRange || !formattedRange.start && !formattedRange.end || !allowPartialRange && (!formattedRange.start || !formattedRange.end)) return null;
+		if (fullIso) return {
+			start: formattedRange.start ? DateTimeUtils.fromUTCISOToCalendarDate(formattedRange.start) : null,
+			end: formattedRange.end ? DateTimeUtils.fromUTCISOToCalendarDate(formattedRange.end) : null
+		};
+		const startDate = formattedRange.start ? /* @__PURE__ */ new Date(`${formattedRange.start}T00:00:00.000Z`) : null;
+		const endDate = formattedRange.end ? /* @__PURE__ */ new Date(`${formattedRange.end}T00:00:00.000Z`) : null;
+		const startZonedDateTime = startDate ? DateTimeUtils.fromLocalToZonedDateTime(startDate, "UTC") : null;
+		const endZonedDateTime = endDate ? DateTimeUtils.fromLocalToZonedDateTime(endDate, "UTC") : null;
+		return {
+			start: startZonedDateTime ? toCalendarDate(startZonedDateTime) : null,
+			end: endZonedDateTime ? toCalendarDate(endZonedDateTime) : null
+		};
+	};
+	const parseCalendarDate = useCallback((formattedDate) => {
+		if (formattedDate == null) return null;
+		if (fullIso) return DateTimeUtils.fromUTCISOToCalendarDate(formattedDate);
+		const date = /* @__PURE__ */ new Date(`${formattedDate}T00:00:00.000Z`);
+		const zonedDateTime = DateTimeUtils.fromLocalToZonedDateTime(date, "UTC");
+		return toCalendarDate(zonedDateTime);
+	}, [fullIso]);
+	const dateLimits = useMemo(() => ({
+		minValue: typeof minValue === "string" ? parseCalendarDate(minValue) : minValue,
+		maxValue: typeof maxValue === "string" ? parseCalendarDate(maxValue) : maxValue
+	}), [
+		minValue,
+		maxValue,
+		parseCalendarDate
+	]);
+	const normalizedRange = normalizedValue;
+	if (!renderInput) {
+		const relativeOptions = [
+			{
+				value: "thisWeek",
+				label: t(($) => $.ui.datePicker.presets.thisWeek, { ns: "ui" })
+			},
+			{
+				value: "lastWeek",
+				label: t(($) => $.ui.datePicker.presets.lastWeek, { ns: "ui" })
+			},
+			{
+				value: "thisAndLastWeek",
+				label: t(($) => $.ui.datePicker.presets.thisAndLastWeek, { ns: "ui" })
+			},
+			{
+				value: "thisMonth",
+				label: t(($) => $.ui.datePicker.presets.thisMonth, { ns: "ui" })
+			},
+			{
+				value: "thisAndLastMonth",
+				label: t(($) => $.ui.datePicker.presets.thisAndLastMonth, { ns: "ui" })
+			},
+			{
+				value: "thisYear",
+				label: t(($) => $.ui.datePicker.presets.thisYear, { ns: "ui" })
+			},
+			{
+				value: "lastYear",
+				label: t(($) => $.ui.datePicker.presets.lastYear, { ns: "ui" })
+			},
+			{
+				value: "thisAndLastYear",
+				label: t(($) => $.ui.datePicker.presets.thisAndLastYear, { ns: "ui" })
+			},
+			{
+				value: "soFar",
+				label: t(($) => $.ui.datePicker.presets.soFar, { ns: "ui" })
+			},
+			...ui.dateInput.dateRangeOptions
+		];
+		const relativeLabel = mode === "relative" ? relativeOptions.find((option) => option.value === props.relativeValue)?.label : void 0;
+		const startDateValue = parseCalendarDate(normalizedRange?.start ?? null);
+		const endDateValue = parseCalendarDate(normalizedRange?.end ?? null);
+		const hasProvidedRangeValue = mode === "relative" ? !!relativeLabel : !!(normalizedRange?.start || normalizedRange?.end);
+		const as = props.as ?? ui.input.as;
+		const size = props.size ?? ui.input.size;
+		const isDisabled = isFormControlDisabled || !!props.isDisabled;
+		const todayIcon = props.todayIcon ?? ui.dateInput.todayIcon;
+		const todayIconButtonSize = props.todayIconButtonSize ?? ui.dateInput.todayIconButtonSize;
+		const todayIconButtonComponent = props.todayIconButtonComponent ?? ui.dateInput.todayIconButtonComponent;
+		const todayIconPlacement = props.todayIconPlacement ?? ui.dateInput.todayIconPlacement;
+		const staticTodayIcon = renderDatePickerTodayIcon(todayIcon, {
+			isDisabled,
+			renderStatic: true,
+			size: todayIconButtonSize,
+			todayIconButtonComponent
+		});
+		const disableManualEntry = mode === "relative" || (props.disableManualEntry ?? ui.dateInput.disableManualEntry);
+		const showDropdown = !props.disableDropdown || disableManualEntry;
+		const staticSegments = getStaticDateRangeSegments({
+			start: startDateValue,
+			end: endDateValue,
+			locale,
+			shouldForceLeadingZeros,
+			isDisabled,
+			hidePlaceholder: as === "floating" && !hasProvidedRangeValue,
+			disableManualEntry,
+			placeholder: props.placeholder
+		});
+		return /* @__PURE__ */ jsx(InputFrame, {
+			...props,
+			onClear: () => {
+				props.onChange?.(null);
+				props.onRelativeChange?.(null);
+				props.onValueCommit?.();
+			},
+			isDisabled,
+			className: clsx("group relative inline-flex w-full flex-col text-left", props.className),
+			inputClassName: clsx("min-w-input-width-min-width", props.inputClassName),
+			contentClassName: "pr-0!",
+			contentWrapperClassName: datePickerInputContentRowCva({ size }),
+			contentGroup: "date-picker",
+			labelPlacement: "content-row",
+			dataAttributes: {
+				dataIsEmpty: !hasProvidedRangeValue,
+				dataIsFilled: hasProvidedRangeValue,
+				dataIsDirty: props.isDirty,
+				dataIsRequired: props.isRequired,
+				dataIsDisabled: isDisabled,
+				dataDisabled: isDisabled,
+				dataInvalid: !!props.error,
+				dataHasSelection: hasProvidedRangeValue
+			},
+			onStaticInteract: renderRealInput,
+			onStaticPress: replayStaticInputPress,
+			staticPressTarget: "action",
+			actionContent: staticTodayIcon,
+			actionContentPlacement: todayIconPlacement === "fieldLabel" ? "content-row" : "content-wrapper",
+			showClear: hasProvidedRangeValue,
+			wrapContentAndTrailing: true,
+			contentAndTrailingClassName: "gap-2!",
+			trailingClassName: "py-0! pl-0!",
+			action: showDropdown ? {
+				icon: ui.dateInput.calendarIcon,
+				onClick: () => {},
+				altText: ""
+			} : void 0,
+			children: relativeLabel ? /* @__PURE__ */ jsx(Typography, {
+				size: "label-1",
+				children: relativeLabel
+			}) : staticSegments
+		});
+	}
+	return /* @__PURE__ */ jsx(DateRangePickerBase, {
+		...props,
+		...dateLimits,
+		ref: $a8ea2faf2ebe4d2f$re_export$mergeRefs(props.ref, inputRef),
+		mode,
+		enableRelativeMode: props.enableRelativeMode,
+		onModeChange: (relative) => {
+			setIsRelativeMode(relative);
+			props.onChange?.(null);
+			props.onRelativeChange?.(null);
+		},
+		relativeValue: mode === "relative" ? props.relativeValue : null,
+		relativeOptions: mode === "relative" ? ui.dateInput.dateRangeOptions : [],
+		onRelativeChange: (relativeValue, resolvedValue) => {
+			const formattedResolvedValue = formatDateRange(resolvedValue);
+			if (!relativeValue || !formattedResolvedValue?.start || !formattedResolvedValue.end) {
+				props.onChange?.(null);
+				props.onRelativeChange?.(null);
+				return;
+			}
+			props.onChange?.({
+				start: formattedResolvedValue.start,
+				end: formattedResolvedValue.end
+			});
+			props.onRelativeChange?.(relativeValue);
+		},
+		value: mode === "relative" ? null : parseDateRange(normalizedRange),
+		onChange: (value) => props.onChange?.(formatDateRange(value))
+	});
+};
+const DateRangePickerComponent = ({ fullIso = true, minValue, maxValue, renderStaticInput, ...props }) => {
+	if ("field" in props && props.field) {
+		const { field, ref, ...innerProps } = props;
+		const controlWithOptions = field.form;
+		return /* @__PURE__ */ jsx(FieldController, {
+			control: field.form,
+			name: field.name,
+			render: ({ field, fieldState: { error, isDirty } }) => /* @__PURE__ */ jsx(DateRangePickerInner, {
+				...innerProps,
+				ref: $a8ea2faf2ebe4d2f$re_export$mergeRefs(ref, field.ref),
+				value: field.value ?? null,
+				onChange: (value) => field.onChange(value ?? null),
+				onBlur: field.onBlur,
+				onValueCommit: field.onBlur,
+				isDirty,
+				isDisabled: field.disabled || props.isDisabled,
+				isFormControlDisabled: !!controlWithOptions._options?.disabled,
+				error: props.error ?? error?.message,
+				fullIso,
+				minValue,
+				maxValue,
+				renderStaticInput
+			})
+		});
+	}
+	return /* @__PURE__ */ jsx(DateRangePickerInner, {
+		...props,
+		fullIso,
+		minValue,
+		maxValue,
+		renderStaticInput
+	});
+};
+const DateRangePicker = memo(DateRangePickerComponent);
+//#endregion
+export { isDateRangePresetValue as a, resolveDateRangePreset as c, hydrateRelativeDateRangeValue as i, dateRangePresetValues as n, isRelativeDateRangeValue as o, getDateRangePreset as r, isStoredRelativeDateRangeValue as s, DateRangePicker as t };