@helsenorge/datepicker 13.4.0 → 13.6.0

package/lib/components/Unsafe_DatePicker/index.js

@@ -0,0 +1,3702 @@
+import { i as CaptionLabel, n as useDayPicker, r as MonthGrid, t as DayPicker } from "../../DayPicker.js";
+import * as React$1 from "react";
+import React, { cloneElement, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { format, formatISO, isSameDay, isValid, parse } from "date-fns";
+import { nb } from "date-fns/locale";
+import Button from "@helsenorge/designsystem-react/components/Button";
+import Icon, { IconSize } from "@helsenorge/designsystem-react/components/Icon";
+import Calendar from "@helsenorge/designsystem-react/components/Icons/Calendar";
+import { useLanguage } from "@helsenorge/designsystem-react/utils/language";
+import { mergeRefs } from "@helsenorge/designsystem-react/utils/refs";
+import classNames from "classnames";
+import reactdaypickerstyles from "react-day-picker/dist/style.module.css";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { IconSize as IconSize$1, KeyboardEventKey, LanguageLocales, useKeyboardEvent, useOutsideEvent, usePseudoClasses, useToggle } from "@helsenorge/designsystem-react";
+import ErrorWrapper from "@helsenorge/designsystem-react/components/ErrorWrapper";
+import { isComponent } from "@helsenorge/designsystem-react/utils/component";
+import Loader from "@helsenorge/designsystem-react/components/Loader";
+import ChevronDown from "@helsenorge/designsystem-react/components/Icons/ChevronDown";
+import ChevronLeft from "@helsenorge/designsystem-react/components/Icons/ChevronLeft";
+import ChevronRight from "@helsenorge/designsystem-react/components/Icons/ChevronRight";
+import { useIsMobileBreakpoint } from "@helsenorge/designsystem-react/hooks/useIsMobileBreakpoint";
+import customstyles from "./BaseDayPicker/BaseDayPicker.module.scss";
+import Label from "@helsenorge/designsystem-react/components/Label";
+import X from "@helsenorge/designsystem-react/components/Icons/X";
+import styles from "./DatePicker.module.scss";
+import * as ReactDOM from "react-dom";
+import styles$1 from "./Unsafe_DateAndTime.module.scss";
+const CustomPreviousButton = (props) => {
+	const buttonRef = React.useRef(null);
+	const { isHovered } = usePseudoClasses(buttonRef);
+	const isMobile = useIsMobileBreakpoint();
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		ref: buttonRef,
+		className: classNames(props.className, customstyles["custom_nav_button"]),
+		children: /* @__PURE__ */ jsx("div", {
+			className: customstyles["custom_nav_button__circle"],
+			children: /* @__PURE__ */ jsx(Icon, {
+				svgIcon: ChevronLeft,
+				isHovered: !props.disabled && !props["aria-disabled"] && isHovered,
+				className: classNames(customstyles["custom_chevron"]),
+				size: isMobile ? IconSize$1.XXSmall : IconSize$1.XSmall
+			})
+		})
+	});
+};
+const CustomNextButton = (props) => {
+	const buttonRef = React.useRef(null);
+	const { isHovered } = usePseudoClasses(buttonRef);
+	const isMobile = useIsMobileBreakpoint();
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		ref: buttonRef,
+		className: classNames(props.className, customstyles["custom_nav_button"]),
+		children: /* @__PURE__ */ jsx("div", {
+			className: customstyles["custom_nav_button__circle"],
+			children: /* @__PURE__ */ jsx(Icon, {
+				svgIcon: ChevronRight,
+				isHovered: !props.disabled && !props["aria-disabled"] && isHovered,
+				className: classNames(customstyles["custom_chevron"]),
+				size: isMobile ? IconSize$1.XXSmall : IconSize$1.XSmall
+			})
+		})
+	});
+};
+const CustomDropdown = (props) => {
+	const { options, classNames: rdpClassnameProp, ...dropdownProps } = props;
+	const { components, classNames: rdpClassnames } = useDayPicker();
+	const ref = useRef(null);
+	const { isHovered } = usePseudoClasses(ref);
+	const selectedOption = options?.find(({ value }) => value === dropdownProps.value);
+	return /* @__PURE__ */ jsxs("span", {
+		"data-disabled": dropdownProps.disabled,
+		className: classNames(rdpClassnames["dropdown_root"], customstyles["dropdown_root_custom"]),
+		ref,
+		children: [/* @__PURE__ */ jsx(components.Select, {
+			...dropdownProps,
+			className: classNames(rdpClassnames["dropdown"]),
+			children: options?.map(({ value, label, disabled }) => /* @__PURE__ */ jsx(components.Option, {
+				value,
+				disabled,
+				children: label
+			}, value))
+		}), /* @__PURE__ */ jsxs("span", {
+			className: classNames(rdpClassnames["caption_label"], customstyles["dropdown_container"]),
+			"aria-hidden": true,
+			children: [/* @__PURE__ */ jsx("span", {
+				className: customstyles["dropdown_label"],
+				children: selectedOption?.label
+			}), /* @__PURE__ */ jsx(Icon, {
+				svgIcon: ChevronDown,
+				isHovered,
+				size: IconSize$1.XSmall,
+				className: customstyles["dropdown_chevron"]
+			})]
+		})]
+	});
+};
+const CustomCaptionLabel = (props) => {
+	const { classNames: rdpClassnames } = useDayPicker();
+	return /* @__PURE__ */ jsx(CaptionLabel, {
+		...props,
+		className: classNames(rdpClassnames["caption_label"], customstyles["custom_caption-label"])
+	});
+};
+var HN_Designsystem_Unsafe_DatePicker_nb_NO_default = {
+	dateButtonAriaLabel: "Åpne datovelger",
+	dayButtonBase: "{date}",
+	dayButtonToday: "I dag, {date}",
+	dayButtonSelected: "{date} valgt",
+	nextMonth: "Neste måned",
+	previousMonth: "Forrige måned",
+	monthDropdown: "Velg måned",
+	yearDropdown: "Velg år",
+	goToToday: "Gå til i dag",
+	loadingText: "Henter info. Vennligst vent.",
+	dayFormatPlaceholder: "dd",
+	monthFormatPlaceholder: "mm",
+	yearFormatPlaceholder: "åååå",
+	calendarButtonAriaLabel: "Åpne datovelger",
+	validateDefaultMessageYear: "År må være et tall med 4 siffer",
+	validateDefaultMessageMonth: "Måned må være et tall mellom 01 og 12",
+	validateDefaultMessageDay: "Dag må være et tall mellom 01 og 31",
+	clearButtonAriaLabel: "Nullstill dato",
+	ariaLabelInputDay: "Dag",
+	ariaLabelInputMonth: "Måned",
+	ariaLabelInputYear: "År",
+	validateDefaultMessageHour: "Time må være et tall mellom 00 og 23",
+	validateDefaultMessageMinute: "Minutt må være et tall mellom 00 og 59",
+	hourFormatPlaceholder: "tt",
+	minuteFormatPlaceholder: "mm",
+	ariaLabelInputHour: "Time",
+	ariaLabelInputMinute: "Minutt"
+};
+const getResources = (language) => {
+	switch (language) {
+		case LanguageLocales.NORWEGIAN:
+		default: return HN_Designsystem_Unsafe_DatePicker_nb_NO_default;
+	}
+};
+var BaseDayPicker = (props) => {
+	const { selectedDate, onDateChange, isLoading, modifiers, showGoToTodayButton = false, footer, resources, localeForCalendar = nb, labelsForCalendar, ...rdpProps } = props;
+	const { language } = useLanguage(LanguageLocales.NORWEGIAN);
+	const mergedResources = {
+		...getResources(language),
+		...resources
+	};
+	const customLocale = {
+		...localeForCalendar,
+		localize: {
+			...localeForCalendar.localize,
+			month: (n, options) => localeForCalendar.localize.month(n, {
+				...options,
+				width: rdpProps.captionLayout === "dropdown" ? "abbreviated" : "wide"
+			})
+		}
+	};
+	const datePickerClassNames = {
+		...reactdaypickerstyles,
+		...customstyles,
+		root: classNames(reactdaypickerstyles.root, customstyles["root_override"]),
+		day: classNames(reactdaypickerstyles.day, customstyles["date--default"]),
+		month_caption: classNames(reactdaypickerstyles["month_caption"], customstyles["custom_month_caption"])
+	};
+	const [selected, setSelected] = useState(selectedDate);
+	const [month, setMonth$1] = useState(selectedDate || /* @__PURE__ */ new Date());
+	React.useEffect(() => {
+		setSelected(selectedDate);
+	}, [selectedDate]);
+	const handleSelect = (date) => {
+		if (date && selected && isSameDay(date, selected)) {
+			setSelected(void 0);
+			onDateChange?.(void 0);
+			return;
+		}
+		setSelected(date);
+		onDateChange?.(date);
+	};
+	const modifiersExtended = { ...modifiers };
+	const handleDayButtonClick = (day, modifiers$1) => {
+		if (modifiers$1.selected) {
+			setSelected(void 0);
+			onDateChange?.(void 0);
+		} else if (!modifiers$1.disabled) {
+			setSelected(day.date);
+			onDateChange?.(day.date);
+		}
+	};
+	return /* @__PURE__ */ jsx(DayPicker, {
+		...rdpProps,
+		navLayout: "around",
+		mode: "single",
+		selected,
+		month,
+		onMonthChange: setMonth$1,
+		onSelect: handleSelect,
+		classNames: datePickerClassNames,
+		locale: customLocale,
+		modifiers: modifiersExtended,
+		labels: labelsForCalendar,
+		footer: showGoToTodayButton ? /* @__PURE__ */ jsxs("div", {
+			className: classNames(customstyles["datepicker-footer"], customstyles["datepicker-footer--with-today-button"]),
+			children: [/* @__PURE__ */ jsx(Button, {
+				variant: "borderless",
+				onClick: () => {
+					setMonth$1(/* @__PURE__ */ new Date());
+				},
+				children: mergedResources.goToToday
+			}), footer]
+		}) : footer && /* @__PURE__ */ jsx("div", {
+			className: classNames(customstyles["datepicker-footer"]),
+			children: footer
+		}),
+		modifiersClassNames: {
+			emphasized: customstyles["date--emphasized"],
+			disabled: customstyles["date--disabled"],
+			today: customstyles["date--today"],
+			selected: customstyles["date--selected"],
+			partiallyBooked: customstyles["date--partial"],
+			fullyBooked: customstyles["date--fully"]
+		},
+		components: {
+			DayButton: (props$1) => {
+				const { day, modifiers: modifiers$1, ...buttonProps } = props$1;
+				const { classNames: rdpClassnames } = useDayPicker();
+				const buttonRef = React.useRef(null);
+				const handleClick = () => {
+					handleDayButtonClick(day, modifiers$1);
+				};
+				React.useEffect(() => {
+					if (modifiers$1.focused) buttonRef.current?.focus();
+				}, [modifiers$1.focused]);
+				return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("button", {
+					...buttonProps,
+					disabled: buttonProps.disabled,
+					className: classNames(rdpClassnames["day_button"], customstyles["custom_day_button"]),
+					ref: buttonRef,
+					onClick: handleClick
+				}) });
+			},
+			NextMonthButton: (props$1) => /* @__PURE__ */ jsx(CustomNextButton, { ...props$1 }),
+			PreviousMonthButton: (props$1) => /* @__PURE__ */ jsx(CustomPreviousButton, { ...props$1 }),
+			MonthGrid: isLoading ? (props$1) => /* @__PURE__ */ jsxs("div", {
+				style: { position: "relative" },
+				children: [/* @__PURE__ */ jsx(MonthGrid, { ...props$1 }), /* @__PURE__ */ jsxs("div", {
+					className: customstyles["loading-overlay"],
+					children: [/* @__PURE__ */ jsx(Loader, {
+						size: "small",
+						color: "blueberry"
+					}), /* @__PURE__ */ jsx("p", {
+						style: { whiteSpace: "pre-line" },
+						"aria-live": "polite",
+						children: mergedResources.loadingText
+					})]
+				})]
+			}) : MonthGrid,
+			Dropdown: CustomDropdown,
+			CaptionLabel: CustomCaptionLabel
+		}
+	});
+};
+var BaseDayPicker_default = BaseDayPicker;
+var TimeInputInternal = ({ value, onChange, onBlur, id, setErrorText, resources, withClearButton, ["aria-describedby"]: ariaDescribedBy, ["aria-labelledby"]: ariaLabelledBy }) => {
+	const [errorTextHh, setErrorTextHh] = useState("");
+	const [errorTextMm, setErrorTextMm] = useState("");
+	const [hh, setHh] = useState("");
+	const [mm, setMm] = useState("");
+	const hasValue = hh !== "" || mm !== "";
+	const hhRef = useRef(null);
+	const mmRef = useRef(null);
+	const inputRefs = [hhRef, mmRef];
+	const clearButtonRef = useRef(null);
+	const [isClearButtonFocused, setIsClearButtonFocused] = useState(false);
+	useEffect(() => {
+		if (!value || value === "") return;
+		const match = value.match(/^(\d{2}):(\d{2})$/);
+		if (match) {
+			const [_, newDd, newMm] = match;
+			if (hh !== newDd) setHh(newDd);
+			if (mm !== newMm) setMm(newMm);
+		}
+	}, [value]);
+	const combinedValue = hh && mm ? `${hh}:${mm}` : "";
+	useEffect(() => {
+		if (onChange) onChange(combinedValue);
+	}, [combinedValue]);
+	const validateHh = (newHh) => {
+		if (newHh === "") {
+			setErrorTextHh("");
+			return true;
+		}
+		if (/^\d{0,2}$/.test(newHh)) {
+			const hourNum = parseInt(newHh, 10);
+			if (hourNum < 0 || hourNum >= 24) {
+				setErrorTextHh(resources?.validateDefaultMessageHour || "Time må være et tall mellom 00 og 23");
+				return false;
+			} else {
+				setErrorTextHh("");
+				return true;
+			}
+		} else {
+			setErrorTextHh(resources?.validateDefaultMessageHour || "Time må være et tall mellom 00 og 23");
+			return false;
+		}
+	};
+	const handleHhChange = (e) => {
+		const newHh = e.target.value;
+		setHh(newHh);
+		if (validateHh(newHh)) {
+			if (newHh.length === 2) mmRef.current?.focus();
+		}
+	};
+	const validateMm = (newMm) => {
+		if (newMm === "") {
+			setErrorTextMm("");
+			return true;
+		}
+		if (/^\d{0,2}$/.test(newMm)) {
+			const minNum = parseInt(newMm, 10);
+			if (minNum < 0 || minNum >= 60) {
+				setErrorTextMm(resources?.validateDefaultMessageMinute || "Minutter må være et tall mellom 00 og 59");
+				return false;
+			} else {
+				setErrorTextMm("");
+				return true;
+			}
+		} else {
+			setErrorTextMm(resources?.validateDefaultMessageMinute || "Minutter må være et tall mellom 00 og 59");
+			return false;
+		}
+	};
+	const handleMmChange = (e) => {
+		const newMm = e.target.value;
+		setMm(newMm);
+		validateMm(newMm);
+	};
+	const handleBlurOnSegment = () => {
+		validateHh(hh);
+		validateMm(mm);
+	};
+	useEffect(() => {
+		const combinedErrors = [errorTextHh, errorTextMm].filter((err) => err !== "").join(". ");
+		if (setErrorText) setErrorText(combinedErrors);
+	}, [errorTextHh, errorTextMm]);
+	const segmentClass = styles["date-segment"];
+	const errorClass = styles["date-segment--error"];
+	const hourSegmentClassNames = classNames(segmentClass, errorTextHh && errorClass);
+	const minuteSegmentClassNames = classNames(segmentClass, errorTextMm && errorClass);
+	const handleGroupBlur = () => {
+		setTimeout(() => {
+			if (!inputRefs.some((ref) => ref.current && ref.current === document.activeElement)) onBlur?.(combinedValue);
+		}, 0);
+	};
+	const handleGroupClick = () => {
+		if (hhRef.current && document.activeElement !== hhRef.current && mmRef.current && document.activeElement !== mmRef.current && document.activeElement !== clearButtonRef.current) {
+			if (hh === "") hhRef.current.focus();
+			else if (mm === "") mmRef.current.focus();
+		}
+	};
+	const handleClear = () => {
+		setHh("");
+		setMm("");
+		setErrorTextHh("");
+		setErrorTextMm("");
+		if (onChange) onChange("");
+		hhRef.current?.focus();
+	};
+	const moveFocusLeft = () => {
+		const activeElement$1 = document.activeElement;
+		if (!activeElement$1) return;
+		if (mmRef.current === activeElement$1) {
+			if (activeElement$1.selectionStart === 0 && activeElement$1.selectionEnd === 0) setTimeout(() => {
+				hhRef.current?.focus();
+			}, 0);
+		}
+	};
+	const moveFocusRight = () => {
+		const activeElement$1 = document.activeElement;
+		if (!activeElement$1) return;
+		if (hhRef.current === activeElement$1) {
+			if (activeElement$1.selectionStart === activeElement$1.value.length && activeElement$1.selectionEnd === activeElement$1.value.length) setTimeout(() => {
+				mmRef.current?.focus();
+			}, 0);
+		}
+	};
+	const moveFocusOnBackspaceInEmptyField = () => {
+		if (mmRef.current === document.activeElement && mm === "") setTimeout(() => {
+			hhRef.current?.focus();
+		}, 0);
+	};
+	useKeyboardEvent(mmRef, moveFocusOnBackspaceInEmptyField, [KeyboardEventKey.Backspace]);
+	useKeyboardEvent(mmRef, moveFocusLeft, [KeyboardEventKey.ArrowLeft]);
+	useKeyboardEvent(hhRef, moveFocusRight, [KeyboardEventKey.ArrowRight]);
+	return /* @__PURE__ */ jsxs("div", {
+		role: "group",
+		className: classNames(styles["date-picker"], styles["date-picker--time"], {
+			[styles["date-picker--time--with-clear-button"]]: withClearButton,
+			[styles["date-picker--clear-button-focused"]]: isClearButtonFocused
+		}),
+		id,
+		"aria-labelledby": ariaLabelledBy,
+		"aria-describedby": ariaDescribedBy,
+		onBlurCapture: handleGroupBlur,
+		onClickCapture: handleGroupClick,
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: styles["date-picker__inputs"],
+			children: [
+				/* @__PURE__ */ jsx("input", {
+					ref: hhRef,
+					type: "text",
+					enterKeyHint: "next",
+					inputMode: "numeric",
+					pattern: "[0-9]*",
+					maxLength: 2,
+					value: hh,
+					onChange: handleHhChange,
+					onBlur: handleBlurOnSegment,
+					placeholder: resources?.hourFormatPlaceholder || "tt",
+					"aria-label": resources?.ariaLabelInputHour || "Time",
+					className: hourSegmentClassNames
+				}),
+				/* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					children: ":"
+				}),
+				/* @__PURE__ */ jsx("input", {
+					ref: mmRef,
+					type: "text",
+					enterKeyHint: "next",
+					inputMode: "numeric",
+					pattern: "[0-9]*",
+					maxLength: 2,
+					value: mm,
+					onChange: handleMmChange,
+					onBlur: handleBlurOnSegment,
+					placeholder: resources?.minuteFormatPlaceholder || "mm",
+					"aria-label": resources?.ariaLabelInputMinute || "Minutt",
+					className: minuteSegmentClassNames
+				})
+			]
+		}), withClearButton && (hasValue ? /* @__PURE__ */ jsx("button", {
+			type: "button",
+			onClick: handleClear,
+			onFocus: () => setIsClearButtonFocused(true),
+			onBlur: () => setIsClearButtonFocused(false),
+			ref: clearButtonRef,
+			className: styles["clear-button"],
+			"aria-label": resources?.clearButtonAriaLabel || "Nullstill dato",
+			children: /* @__PURE__ */ jsx(Icon, {
+				svgIcon: X,
+				size: IconSize.XXSmall
+			})
+		}) : /* @__PURE__ */ jsx("div", { className: styles["clear-button__placeholder"] }))]
+	});
+};
+var TimeInputInternal_default = TimeInputInternal;
+var Unsafe_TimeInput = ({ value, onChange, onBlur, errorText, id, label, resources, withClearButton = true, ["aria-describedby"]: ariaDescribedBy, ["aria-labelledby"]: ariaLabelledBy }) => {
+	const [softErrorText, setSoftErrorText] = useState("");
+	const labelGivenAsPropIsValidLabelComponent = isComponent(label, Label);
+	const legend = label && labelGivenAsPropIsValidLabelComponent ? cloneElement(label, {
+		htmlMarkup: "legend",
+		labelId: label.props.labelId || "date-legend"
+	}) : null;
+	const legendId = labelGivenAsPropIsValidLabelComponent && label.props.labelId ? label.props.labelId : "date-legend";
+	return /* @__PURE__ */ jsx(ErrorWrapper, {
+		errorText,
+		children: /* @__PURE__ */ jsxs("fieldset", {
+			className: styles["date-field"],
+			"aria-labelledby": legendId,
+			children: [
+				legend,
+				/* @__PURE__ */ jsx(TimeInputInternal_default, {
+					id,
+					value,
+					onChange,
+					withClearButton,
+					resources,
+					"aria-labelledby": ariaLabelledBy,
+					"aria-describedby": ariaDescribedBy,
+					onBlur,
+					setErrorText: setSoftErrorText
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: styles["date-field__soft-error-text"],
+					role: "status",
+					children: softErrorText
+				})
+			]
+		})
+	});
+};
+var Unsafe_TimeInput_default = Unsafe_TimeInput;
+function hasWindow() {
+	return typeof window !== "undefined";
+}
+function getNodeName(node) {
+	if (isNode(node)) return (node.nodeName || "").toLowerCase();
+	return "#document";
+}
+function getWindow(node) {
+	var _node$ownerDocument;
+	return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+	var _ref;
+	return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+	if (!hasWindow() || typeof ShadowRoot === "undefined") return false;
+	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(element) {
+	const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
+	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+}
+var tableElements = /* @__PURE__ */ new Set([
+	"table",
+	"td",
+	"th"
+]);
+function isTableElement(element) {
+	return tableElements.has(getNodeName(element));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(element) {
+	return topLayerSelectors.some((selector) => {
+		try {
+			return element.matches(selector);
+		} catch (_e) {
+			return false;
+		}
+	});
+}
+var transformProperties = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective"
+];
+var willChangeValues = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective",
+	"filter"
+];
+var containValues = [
+	"paint",
+	"layout",
+	"strict",
+	"content"
+];
+function isContainingBlock(elementOrCss) {
+	const webkit = isWebKit();
+	const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+	return transformProperties.some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+	let currentNode = getParentNode(element);
+	while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		if (isContainingBlock(currentNode)) return currentNode;
+		else if (isTopLayer(currentNode)) return null;
+		currentNode = getParentNode(currentNode);
+	}
+	return null;
+}
+function isWebKit() {
+	if (typeof CSS === "undefined" || !CSS.supports) return false;
+	return CSS.supports("-webkit-backdrop-filter", "none");
+}
+var lastTraversableNodeNames = /* @__PURE__ */ new Set([
+	"html",
+	"body",
+	"#document"
+]);
+function isLastTraversableNode(node) {
+	return lastTraversableNodeNames.has(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+	return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+	if (isElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+	const parentNode = getParentNode(node);
+	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+	return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+	var _node$ownerDocument2;
+	if (list === void 0) list = [];
+	if (traverseIframes === void 0) traverseIframes = true;
+	const scrollableAncestor = getNearestOverflowAncestor(node);
+	const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+	const win = getWindow(scrollableAncestor);
+	if (isBody) {
+		const frameElement = getFrameElement(win);
+		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+	}
+	return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+var min$1 = Math.min;
+var max$1 = Math.max;
+var round = Math.round;
+var floor = Math.floor;
+var createCoords = (v) => ({
+	x: v,
+	y: v
+});
+function clamp(start, value, end) {
+	return max$1(start, min$1(value, end));
+}
+function evaluate(value, param) {
+	return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+	return placement.split("-")[0];
+}
+function getAlignment(placement) {
+	return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+	return axis === "y" ? "height" : "width";
+}
+var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+	return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+	return getOppositeAxis(getSideAxis(placement));
+}
+function expandPaddingObject(padding) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...padding
+	};
+}
+function getPaddingObject(padding) {
+	return typeof padding !== "number" ? expandPaddingObject(padding) : {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+}
+function rectToClientRect(rect) {
+	const { x, y, width, height } = rect;
+	return {
+		width,
+		height,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		x,
+		y
+	};
+}
+var candidateSelector = /* @__PURE__ */ [
+	"input:not([inert]):not([inert] *)",
+	"select:not([inert]):not([inert] *)",
+	"textarea:not([inert]):not([inert] *)",
+	"a[href]:not([inert]):not([inert] *)",
+	"button:not([inert]):not([inert] *)",
+	"[tabindex]:not(slot):not([inert]):not([inert] *)",
+	"audio[controls]:not([inert]):not([inert] *)",
+	"video[controls]:not([inert]):not([inert] *)",
+	"[contenteditable]:not([contenteditable=\"false\"]):not([inert]):not([inert] *)",
+	"details>summary:first-of-type:not([inert]):not([inert] *)",
+	"details:not([inert]):not([inert] *)"
+].join(",");
+var NoElement = typeof Element === "undefined";
+var matches = NoElement ? function() {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+	var _element$getRootNode;
+	return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+} : function(element) {
+	return element === null || element === void 0 ? void 0 : element.ownerDocument;
+};
+var _isInert = function isInert(node, lookUp) {
+	var _node$getAttribute;
+	if (lookUp === void 0) lookUp = true;
+	var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
+	return inertAtt === "" || inertAtt === "true" || lookUp && node && (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
+};
+var isContentEditable = function isContentEditable$1(node) {
+	var _node$getAttribute2;
+	var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+	return attValue === "" || attValue === "true";
+};
+var getCandidates = function getCandidates$1(el, includeContainer, filter) {
+	if (_isInert(el)) return [];
+	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
+	candidates = candidates.filter(filter);
+	return candidates;
+};
+var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+	var candidates = [];
+	var elementsToCheck = Array.from(elements);
+	while (elementsToCheck.length) {
+		var element = elementsToCheck.shift();
+		if (_isInert(element, false)) continue;
+		if (element.tagName === "SLOT") {
+			var assigned = element.assignedElements();
+			var nestedCandidates = _getCandidatesIteratively(assigned.length ? assigned : element.children, true, options);
+			if (options.flatten) candidates.push.apply(candidates, nestedCandidates);
+			else candidates.push({
+				scopeParent: element,
+				candidates: nestedCandidates
+			});
+		} else {
+			if (matches.call(element, candidateSelector) && options.filter(element) && (includeContainer || !elements.includes(element))) candidates.push(element);
+			var shadowRoot = element.shadowRoot || typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+			var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+			if (shadowRoot && validShadowRoot) {
+				var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+				if (options.flatten) candidates.push.apply(candidates, _nestedCandidates);
+				else candidates.push({
+					scopeParent: element,
+					candidates: _nestedCandidates
+				});
+			} else elementsToCheck.unshift.apply(elementsToCheck, element.children);
+		}
+	}
+	return candidates;
+};
+var hasTabIndex = function hasTabIndex$1(node) {
+	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+var getTabIndex = function getTabIndex$1(node) {
+	if (!node) throw new Error("No node provided");
+	if (node.tabIndex < 0) {
+		if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+};
+var getSortOrderTabIndex = function getSortOrderTabIndex$1(node, isScope) {
+	var tabIndex = getTabIndex(node);
+	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
+	return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables$1(a, b) {
+	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput$1(node) {
+	return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput$1(node) {
+	return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary$1(node) {
+	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+		return child.tagName === "SUMMARY";
+	});
+};
+var getCheckedRadio = function getCheckedRadio$1(nodes, form) {
+	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
+};
+var isTabbableRadio = function isTabbableRadio$1(node) {
+	if (!node.name) return true;
+	var radioScope = node.form || getRootNode(node);
+	var queryRadios = function queryRadios$1(name) {
+		return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
+	};
+	var radioSet;
+	if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") radioSet = queryRadios(window.CSS.escape(node.name));
+	else try {
+		radioSet = queryRadios(node.name);
+	} catch (err) {
+		console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+		return false;
+	}
+	var checked = getCheckedRadio(radioSet, node.form);
+	return !checked || checked === node;
+};
+var isRadio = function isRadio$1(node) {
+	return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio$1(node) {
+	return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached$1(node) {
+	var _nodeRoot;
+	var nodeRoot = node && getRootNode(node);
+	var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+	var attached = false;
+	if (nodeRoot && nodeRoot !== node) {
+		var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+		attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+		while (!attached && nodeRootHost) {
+			var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+			nodeRoot = getRootNode(nodeRootHost);
+			nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+			attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+		}
+	}
+	return attached;
+};
+var isZeroArea = function isZeroArea$1(node) {
+	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+	return width === 0 && height === 0;
+};
+var isHidden = function isHidden$1(node, _ref) {
+	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+	if (displayCheck === "full-native") {
+		if ("checkVisibility" in node) return !node.checkVisibility({
+			checkOpacity: false,
+			opacityProperty: false,
+			contentVisibilityAuto: true,
+			visibilityProperty: true,
+			checkVisibilityCSS: true
+		});
+	}
+	if (getComputedStyle(node).visibility === "hidden") return true;
+	var nodeUnderDetails = matches.call(node, "details>summary:first-of-type") ? node.parentElement : node;
+	if (matches.call(nodeUnderDetails, "details:not([open]) *")) return true;
+	if (!displayCheck || displayCheck === "full" || displayCheck === "full-native" || displayCheck === "legacy-full") {
+		if (typeof getShadowRoot === "function") {
+			var originalNode = node;
+			while (node) {
+				var parentElement = node.parentElement;
+				var rootNode = getRootNode(node);
+				if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) return isZeroArea(node);
+				else if (node.assignedSlot) node = node.assignedSlot;
+				else if (!parentElement && rootNode !== node.ownerDocument) node = rootNode.host;
+				else node = parentElement;
+			}
+			node = originalNode;
+		}
+		if (isNodeAttached(node)) return !node.getClientRects().length;
+		if (displayCheck !== "legacy-full") return true;
+	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
+	return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset$1(node) {
+	if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+		var parentNode = node.parentElement;
+		while (parentNode) {
+			if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+				for (var i = 0; i < parentNode.children.length; i++) {
+					var child = parentNode.children.item(i);
+					if (child.tagName === "LEGEND") return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+				}
+				return true;
+			}
+			parentNode = parentNode.parentElement;
+		}
+	}
+	return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable$1(options, node) {
+	if (node.disabled || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
+	return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable$1(options, node) {
+	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
+	return true;
+};
+var isShadowRootTabbable = function isShadowRootTabbable$1(shadowHostNode) {
+	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+	if (isNaN(tabIndex) || tabIndex >= 0) return true;
+	return false;
+};
+var _sortByOrder = function sortByOrder(candidates) {
+	var regularTabbables = [];
+	var orderedTabbables = [];
+	candidates.forEach(function(item, i) {
+		var isScope = !!item.scopeParent;
+		var element = isScope ? item.scopeParent : item;
+		var candidateTabindex = getSortOrderTabIndex(element, isScope);
+		var elements = isScope ? _sortByOrder(item.candidates) : element;
+		if (candidateTabindex === 0) isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+		else orderedTabbables.push({
+			documentOrder: i,
+			tabIndex: candidateTabindex,
+			item,
+			isScope,
+			content: elements
+		});
+	});
+	return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+		sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+		return acc;
+	}, []).concat(regularTabbables);
+};
+var tabbable = function tabbable$1(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorTabbable.bind(null, options),
+		flatten: false,
+		getShadowRoot: options.getShadowRoot,
+		shadowRootFilter: isShadowRootTabbable
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+	return _sortByOrder(candidates);
+};
+var focusable = function focusable$1(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorFocusable.bind(null, options),
+		flatten: true,
+		getShadowRoot: options.getShadowRoot
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+	return candidates;
+};
+var isTabbable = function isTabbable$1(node, options) {
+	options = options || {};
+	if (!node) throw new Error("No node provided");
+	if (matches.call(node, candidateSelector) === false) return false;
+	return isNodeMatchingSelectorTabbable(options, node);
+};
+function getPlatform() {
+	const uaData = navigator.userAgentData;
+	if (uaData != null && uaData.platform) return uaData.platform;
+	return navigator.platform;
+}
+function getUserAgent() {
+	const uaData = navigator.userAgentData;
+	if (uaData && Array.isArray(uaData.brands)) return uaData.brands.map((_ref) => {
+		let { brand, version } = _ref;
+		return brand + "/" + version;
+	}).join(" ");
+	return navigator.userAgent;
+}
+function isSafari() {
+	return /apple/i.test(navigator.vendor);
+}
+function isAndroid() {
+	const re = /android/i;
+	return re.test(getPlatform()) || re.test(getUserAgent());
+}
+function isJSDOM() {
+	return getUserAgent().includes("jsdom/");
+}
+var FOCUSABLE_ATTRIBUTE$1 = "data-floating-ui-focusable";
+var TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function activeElement(doc) {
+	let activeElement$1 = doc.activeElement;
+	while (((_activeElement = activeElement$1) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {
+		var _activeElement;
+		activeElement$1 = activeElement$1.shadowRoot.activeElement;
+	}
+	return activeElement$1;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+	if (parent.contains(child)) return true;
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getTarget(event) {
+	if ("composedPath" in event) return event.composedPath()[0];
+	return event.target;
+}
+function isEventTargetWithin(event, node) {
+	if (node == null) return false;
+	if ("composedPath" in event) return event.composedPath().includes(node);
+	const e = event;
+	return e.target != null && node.contains(e.target);
+}
+function isRootElement(element) {
+	return element.matches("html,body");
+}
+function getDocument(node) {
+	return (node == null ? void 0 : node.ownerDocument) || document;
+}
+function isTypeableElement(element) {
+	return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function isTypeableCombobox(element) {
+	if (!element) return false;
+	return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function getFloatingFocusElement(floatingElement) {
+	if (!floatingElement) return null;
+	return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE$1) ? floatingElement : floatingElement.querySelector("[" + FOCUSABLE_ATTRIBUTE$1 + "]") || floatingElement;
+}
+function getNodeChildren(nodes, id, onlyOpenChildren) {
+	if (onlyOpenChildren === void 0) onlyOpenChildren = true;
+	return nodes.filter((node) => {
+		var _node$context;
+		return node.parentId === id && (!onlyOpenChildren || ((_node$context = node.context) == null ? void 0 : _node$context.open));
+	}).flatMap((child) => [child, ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+}
+function getNodeAncestors(nodes, id) {
+	var _nodes$find;
+	let allAncestors = [];
+	let currentParentId = (_nodes$find = nodes.find((node) => node.id === id)) == null ? void 0 : _nodes$find.parentId;
+	while (currentParentId) {
+		const currentNode = nodes.find((node) => node.id === currentParentId);
+		currentParentId = currentNode == null ? void 0 : currentNode.parentId;
+		if (currentNode) allAncestors = allAncestors.concat(currentNode);
+	}
+	return allAncestors;
+}
+function stopEvent(event) {
+	event.preventDefault();
+	event.stopPropagation();
+}
+function isReactEvent(event) {
+	return "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+	if (event.mozInputSource === 0 && event.isTrusted) return true;
+	if (isAndroid() && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+	if (isJSDOM()) return false;
+	return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+function isMouseLikePointerType(pointerType, strict) {
+	const values = ["mouse", "pen"];
+	if (!strict) values.push("", void 0);
+	return values.includes(pointerType);
+}
+var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+var SafeReact$1 = { ...React$1 };
+function useLatestRef(value) {
+	const ref = React$1.useRef(value);
+	index(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+var useSafeInsertionEffect = SafeReact$1.useInsertionEffect || ((fn) => fn());
+function useEffectEvent(callback) {
+	const ref = React$1.useRef(() => {
+		if (process.env.NODE_ENV !== "production") throw new Error("Cannot call an event handler while rendering.");
+	});
+	useSafeInsertionEffect(() => {
+		ref.current = callback;
+	});
+	return React$1.useCallback(function() {
+		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+		return ref.current == null ? void 0 : ref.current(...args);
+	}, []);
+}
+var getTabbableOptions = () => ({
+	getShadowRoot: true,
+	displayCheck: typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+});
+function getTabbableIn(container, dir) {
+	const list = tabbable(container, getTabbableOptions());
+	const len = list.length;
+	if (len === 0) return;
+	const active = activeElement(getDocument(container));
+	const index$2 = list.indexOf(active);
+	return list[index$2 === -1 ? dir === 1 ? 0 : len - 1 : index$2 + dir];
+}
+function getNextTabbable(referenceElement) {
+	return getTabbableIn(getDocument(referenceElement).body, 1) || referenceElement;
+}
+function getPreviousTabbable(referenceElement) {
+	return getTabbableIn(getDocument(referenceElement).body, -1) || referenceElement;
+}
+function isOutsideEvent(event, container) {
+	const containerElement = container || event.currentTarget;
+	const relatedTarget = event.relatedTarget;
+	return !relatedTarget || !contains(containerElement, relatedTarget);
+}
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+	let { reference, floating } = _ref;
+	const sideAxis = getSideAxis(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const alignLength = getAxisLength(alignmentAxis);
+	const side = getSide(placement);
+	const isVertical = sideAxis === "y";
+	const commonX = reference.x + reference.width / 2 - floating.width / 2;
+	const commonY = reference.y + reference.height / 2 - floating.height / 2;
+	const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+	let coords;
+	switch (side) {
+		case "top":
+			coords = {
+				x: commonX,
+				y: reference.y - floating.height
+			};
+			break;
+		case "bottom":
+			coords = {
+				x: commonX,
+				y: reference.y + reference.height
+			};
+			break;
+		case "right":
+			coords = {
+				x: reference.x + reference.width,
+				y: commonY
+			};
+			break;
+		case "left":
+			coords = {
+				x: reference.x - floating.width,
+				y: commonY
+			};
+			break;
+		default: coords = {
+			x: reference.x,
+			y: reference.y
+		};
+	}
+	switch (getAlignment(placement)) {
+		case "start":
+			coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+		case "end":
+			coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+	}
+	return coords;
+}
+async function detectOverflow$1(state, options) {
+	var _await$platform$isEle;
+	if (options === void 0) options = {};
+	const { x, y, platform: platform$1, rects, elements, strategy } = state;
+	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = evaluate(options, state);
+	const paddingObject = getPaddingObject(padding);
+	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
+	const clippingClientRect = rectToClientRect(await platform$1.getClippingRect({
+		element: ((_await$platform$isEle = await (platform$1.isElement == null ? void 0 : platform$1.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform$1.getDocumentElement == null ? void 0 : platform$1.getDocumentElement(elements.floating)),
+		boundary,
+		rootBoundary,
+		strategy
+	}));
+	const rect = elementContext === "floating" ? {
+		x,
+		y,
+		width: rects.floating.width,
+		height: rects.floating.height
+	} : rects.reference;
+	const offsetParent = await (platform$1.getOffsetParent == null ? void 0 : platform$1.getOffsetParent(elements.floating));
+	const offsetScale = await (platform$1.isElement == null ? void 0 : platform$1.isElement(offsetParent)) ? await (platform$1.getScale == null ? void 0 : platform$1.getScale(offsetParent)) || {
+		x: 1,
+		y: 1
+	} : {
+		x: 1,
+		y: 1
+	};
+	const elementClientRect = rectToClientRect(platform$1.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform$1.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements,
+		rect,
+		offsetParent,
+		strategy
+	}) : rect);
+	return {
+		top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+		bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+		left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+		right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+	};
+}
+var computePosition$1 = async (reference, floating, config) => {
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1 } = config;
+	const validMiddleware = middleware.filter(Boolean);
+	const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(floating));
+	let rects = await platform$1.getElementRects({
+		reference,
+		floating,
+		strategy
+	});
+	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
+	let statefulPlacement = placement;
+	let middlewareData = {};
+	let resetCount = 0;
+	for (let i = 0; i < validMiddleware.length; i++) {
+		var _platform$detectOverf;
+		const { name, fn } = validMiddleware[i];
+		const { x: nextX, y: nextY, data, reset } = await fn({
+			x,
+			y,
+			initialPlacement: placement,
+			placement: statefulPlacement,
+			strategy,
+			middlewareData,
+			rects,
+			platform: {
+				...platform$1,
+				detectOverflow: (_platform$detectOverf = platform$1.detectOverflow) != null ? _platform$detectOverf : detectOverflow$1
+			},
+			elements: {
+				reference,
+				floating
+			}
+		});
+		x = nextX != null ? nextX : x;
+		y = nextY != null ? nextY : y;
+		middlewareData = {
+			...middlewareData,
+			[name]: {
+				...middlewareData[name],
+				...data
+			}
+		};
+		if (reset && resetCount <= 50) {
+			resetCount++;
+			if (typeof reset === "object") {
+				if (reset.placement) statefulPlacement = reset.placement;
+				if (reset.rects) rects = reset.rects === true ? await platform$1.getElementRects({
+					reference,
+					floating,
+					strategy
+				}) : reset.rects;
+				({x, y} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+			}
+			i = -1;
+		}
+	}
+	return {
+		x,
+		y,
+		placement: statefulPlacement,
+		strategy,
+		middlewareData
+	};
+};
+var originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+	const { placement, platform: platform$1, elements } = state;
+	const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(elements.floating));
+	const side = getSide(placement);
+	const alignment = getAlignment(placement);
+	const isVertical = getSideAxis(placement) === "y";
+	const mainAxisMulti = originSides.has(side) ? -1 : 1;
+	const crossAxisMulti = rtl && isVertical ? -1 : 1;
+	const rawValue = evaluate(options, state);
+	let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === "number" ? {
+		mainAxis: rawValue,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: rawValue.mainAxis || 0,
+		crossAxis: rawValue.crossAxis || 0,
+		alignmentAxis: rawValue.alignmentAxis
+	};
+	if (alignment && typeof alignmentAxis === "number") crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+	return isVertical ? {
+		x: crossAxis * crossAxisMulti,
+		y: mainAxis * mainAxisMulti
+	} : {
+		x: mainAxis * mainAxisMulti,
+		y: crossAxis * crossAxisMulti
+	};
+}
+var offset$2 = function(options) {
+	if (options === void 0) options = 0;
+	return {
+		name: "offset",
+		options,
+		async fn(state) {
+			var _middlewareData$offse, _middlewareData$arrow;
+			const { x, y, placement, middlewareData } = state;
+			const diffCoords = await convertValueToCoords(state, options);
+			if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			return {
+				x: x + diffCoords.x,
+				y: y + diffCoords.y,
+				data: {
+					...diffCoords,
+					placement
+				}
+			};
+		}
+	};
+};
+var shift$2 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "shift",
+		options,
+		async fn(state) {
+			const { x, y, placement, platform: platform$1 } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
+				let { x: x$1, y: y$1 } = _ref;
+				return {
+					x: x$1,
+					y: y$1
+				};
+			} }, ...detectOverflowOptions } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const overflow = await platform$1.detectOverflow(state, detectOverflowOptions);
+			const crossAxis = getSideAxis(getSide(placement));
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			if (checkMainAxis) {
+				const minSide = mainAxis === "y" ? "top" : "left";
+				const maxSide = mainAxis === "y" ? "bottom" : "right";
+				const min$2 = mainAxisCoord + overflow[minSide];
+				const max$2 = mainAxisCoord - overflow[maxSide];
+				mainAxisCoord = clamp(min$2, mainAxisCoord, max$2);
+			}
+			if (checkCrossAxis) {
+				const minSide = crossAxis === "y" ? "top" : "left";
+				const maxSide = crossAxis === "y" ? "bottom" : "right";
+				const min$2 = crossAxisCoord + overflow[minSide];
+				const max$2 = crossAxisCoord - overflow[maxSide];
+				crossAxisCoord = clamp(min$2, crossAxisCoord, max$2);
+			}
+			const limitedCoords = limiter.fn({
+				...state,
+				[mainAxis]: mainAxisCoord,
+				[crossAxis]: crossAxisCoord
+			});
+			return {
+				...limitedCoords,
+				data: {
+					x: limitedCoords.x - x,
+					y: limitedCoords.y - y,
+					enabled: {
+						[mainAxis]: checkMainAxis,
+						[crossAxis]: checkCrossAxis
+					}
+				}
+			};
+		}
+	};
+};
+function getCssDimensions(element) {
+	const css = getComputedStyle$1(element);
+	let width = parseFloat(css.width) || 0;
+	let height = parseFloat(css.height) || 0;
+	const hasOffset = isHTMLElement(element);
+	const offsetWidth = hasOffset ? element.offsetWidth : width;
+	const offsetHeight = hasOffset ? element.offsetHeight : height;
+	const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+	if (shouldFallback) {
+		width = offsetWidth;
+		height = offsetHeight;
+	}
+	return {
+		width,
+		height,
+		$: shouldFallback
+	};
+}
+function unwrapElement(element) {
+	return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+	const domElement = unwrapElement(element);
+	if (!isHTMLElement(domElement)) return createCoords(1);
+	const rect = domElement.getBoundingClientRect();
+	const { width, height, $ } = getCssDimensions(domElement);
+	let x = ($ ? round(rect.width) : rect.width) / width;
+	let y = ($ ? round(rect.height) : rect.height) / height;
+	if (!x || !Number.isFinite(x)) x = 1;
+	if (!y || !Number.isFinite(y)) y = 1;
+	return {
+		x,
+		y
+	};
+}
+var noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+	const win = getWindow(element);
+	if (!isWebKit() || !win.visualViewport) return noOffsets;
+	return {
+		x: win.visualViewport.offsetLeft,
+		y: win.visualViewport.offsetTop
+	};
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+	if (isFixed === void 0) isFixed = false;
+	if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
+	return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+	if (includeScale === void 0) includeScale = false;
+	if (isFixedStrategy === void 0) isFixedStrategy = false;
+	const clientRect = element.getBoundingClientRect();
+	const domElement = unwrapElement(element);
+	let scale = createCoords(1);
+	if (includeScale) if (offsetParent) {
+		if (isElement(offsetParent)) scale = getScale(offsetParent);
+	} else scale = getScale(element);
+	const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+	let x = (clientRect.left + visualOffsets.x) / scale.x;
+	let y = (clientRect.top + visualOffsets.y) / scale.y;
+	let width = clientRect.width / scale.x;
+	let height = clientRect.height / scale.y;
+	if (domElement) {
+		const win = getWindow(domElement);
+		const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+		let currentWin = win;
+		let currentIFrame = getFrameElement(currentWin);
+		while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+			const iframeScale = getScale(currentIFrame);
+			const iframeRect = currentIFrame.getBoundingClientRect();
+			const css = getComputedStyle$1(currentIFrame);
+			const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+			const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+			x *= iframeScale.x;
+			y *= iframeScale.y;
+			width *= iframeScale.x;
+			height *= iframeScale.y;
+			x += left;
+			y += top;
+			currentWin = getWindow(currentIFrame);
+			currentIFrame = getFrameElement(currentWin);
+		}
+	}
+	return rectToClientRect({
+		width,
+		height,
+		x,
+		y
+	});
+}
+function getWindowScrollBarX(element, rect) {
+	const leftScroll = getNodeScroll(element).scrollLeft;
+	if (!rect) return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+	return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+	const htmlRect = documentElement.getBoundingClientRect();
+	return {
+		x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
+		y: htmlRect.top + scroll.scrollTop
+	};
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+	let { elements, rect, offsetParent, strategy } = _ref;
+	const isFixed = strategy === "fixed";
+	const documentElement = getDocumentElement(offsetParent);
+	const topLayer = elements ? isTopLayer(elements.floating) : false;
+	if (offsetParent === documentElement || topLayer && isFixed) return rect;
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	let scale = createCoords(1);
+	const offsets = createCoords(0);
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isHTMLElement(offsetParent)) {
+			const offsetRect = getBoundingClientRect(offsetParent);
+			scale = getScale(offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		}
+	}
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		width: rect.width * scale.x,
+		height: rect.height * scale.y,
+		x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+		y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+	};
+}
+function getClientRects(element) {
+	return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+	const html = getDocumentElement(element);
+	const scroll = getNodeScroll(element);
+	const body = element.ownerDocument.body;
+	const width = max$1(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+	const height = max$1(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+	let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+	const y = -scroll.scrollTop;
+	if (getComputedStyle$1(body).direction === "rtl") x += max$1(html.clientWidth, body.clientWidth) - width;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+var SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+	const win = getWindow(element);
+	const html = getDocumentElement(element);
+	const visualViewport = win.visualViewport;
+	let width = html.clientWidth;
+	let height = html.clientHeight;
+	let x = 0;
+	let y = 0;
+	if (visualViewport) {
+		width = visualViewport.width;
+		height = visualViewport.height;
+		const visualViewportBased = isWebKit();
+		if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+			x = visualViewport.offsetLeft;
+			y = visualViewport.offsetTop;
+		}
+	}
+	const windowScrollbarX = getWindowScrollBarX(html);
+	if (windowScrollbarX <= 0) {
+		const doc = html.ownerDocument;
+		const body = doc.body;
+		const bodyStyles = getComputedStyle(body);
+		const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+		const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+		if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
+	} else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+var absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function getInnerBoundingClientRect(element, strategy) {
+	const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+	const top = clientRect.top + element.clientTop;
+	const left = clientRect.left + element.clientLeft;
+	const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+	return {
+		width: element.clientWidth * scale.x,
+		height: element.clientHeight * scale.y,
+		x: left * scale.x,
+		y: top * scale.y
+	};
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+	let rect;
+	if (clippingAncestor === "viewport") rect = getViewportRect(element, strategy);
+	else if (clippingAncestor === "document") rect = getDocumentRect(getDocumentElement(element));
+	else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+	else {
+		const visualOffsets = getVisualOffsets(element);
+		rect = {
+			x: clippingAncestor.x - visualOffsets.x,
+			y: clippingAncestor.y - visualOffsets.y,
+			width: clippingAncestor.width,
+			height: clippingAncestor.height
+		};
+	}
+	return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+	const parentNode = getParentNode(element);
+	if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
+	return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+	const cachedResult = cache.get(element);
+	if (cachedResult) return cachedResult;
+	let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+	let currentContainingBlockComputedStyle = null;
+	const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+	let currentNode = elementIsFixed ? getParentNode(element) : element;
+	while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		const computedStyle = getComputedStyle$1(currentNode);
+		const currentNodeIsContaining = isContainingBlock(currentNode);
+		if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
+		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
+		else currentContainingBlockComputedStyle = computedStyle;
+		currentNode = getParentNode(currentNode);
+	}
+	cache.set(element, result);
+	return result;
+}
+function getClippingRect(_ref) {
+	let { element, boundary, rootBoundary, strategy } = _ref;
+	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
+	const firstClippingAncestor = clippingAncestors[0];
+	const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+		const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+		accRect.top = max$1(rect.top, accRect.top);
+		accRect.right = min$1(rect.right, accRect.right);
+		accRect.bottom = min$1(rect.bottom, accRect.bottom);
+		accRect.left = max$1(rect.left, accRect.left);
+		return accRect;
+	}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+	return {
+		width: clippingRect.right - clippingRect.left,
+		height: clippingRect.bottom - clippingRect.top,
+		x: clippingRect.left,
+		y: clippingRect.top
+	};
+}
+function getDimensions(element) {
+	const { width, height } = getCssDimensions(element);
+	return {
+		width,
+		height
+	};
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	const documentElement = getDocumentElement(offsetParent);
+	const isFixed = strategy === "fixed";
+	const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	const offsets = createCoords(0);
+	function setLeftRTLScrollbarOffset() {
+		offsets.x = getWindowScrollBarX(documentElement);
+	}
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isOffsetParentAnElement) {
+			const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		} else if (documentElement) setLeftRTLScrollbarOffset();
+	}
+	if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		x: rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x,
+		y: rect.top + scroll.scrollTop - offsets.y - htmlOffset.y,
+		width: rect.width,
+		height: rect.height
+	};
+}
+function isStaticPositioned(element) {
+	return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+	if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") return null;
+	if (polyfill) return polyfill(element);
+	let rawOffsetParent = element.offsetParent;
+	if (getDocumentElement(element) === rawOffsetParent) rawOffsetParent = rawOffsetParent.ownerDocument.body;
+	return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+	const win = getWindow(element);
+	if (isTopLayer(element)) return win;
+	if (!isHTMLElement(element)) {
+		let svgOffsetParent = getParentNode(element);
+		while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+			if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) return svgOffsetParent;
+			svgOffsetParent = getParentNode(svgOffsetParent);
+		}
+		return win;
+	}
+	let offsetParent = getTrueOffsetParent(element, polyfill);
+	while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+	if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) return win;
+	return offsetParent || getContainingBlock(element) || win;
+}
+var getElementRects = async function(data) {
+	const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+	const getDimensionsFn = this.getDimensions;
+	const floatingDimensions = await getDimensionsFn(data.floating);
+	return {
+		reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+		floating: {
+			x: 0,
+			y: 0,
+			width: floatingDimensions.width,
+			height: floatingDimensions.height
+		}
+	};
+};
+function isRTL(element) {
+	return getComputedStyle$1(element).direction === "rtl";
+}
+var platform = {
+	convertOffsetParentRelativeRectToViewportRelativeRect,
+	getDocumentElement,
+	getClippingRect,
+	getOffsetParent,
+	getElementRects,
+	getClientRects,
+	getDimensions,
+	getScale,
+	isElement,
+	isRTL
+};
+function rectsAreEqual(a, b) {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function observeMove(element, onMove) {
+	let io = null;
+	let timeoutId;
+	const root = getDocumentElement(element);
+	function cleanup() {
+		var _io;
+		clearTimeout(timeoutId);
+		(_io = io) == null || _io.disconnect();
+		io = null;
+	}
+	function refresh(skip, threshold) {
+		if (skip === void 0) skip = false;
+		if (threshold === void 0) threshold = 1;
+		cleanup();
+		const elementRectForRootMargin = element.getBoundingClientRect();
+		const { left, top, width, height } = elementRectForRootMargin;
+		if (!skip) onMove();
+		if (!width || !height) return;
+		const insetTop = floor(top);
+		const insetRight = floor(root.clientWidth - (left + width));
+		const insetBottom = floor(root.clientHeight - (top + height));
+		const insetLeft = floor(left);
+		const options = {
+			rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
+			threshold: max$1(0, min$1(1, threshold)) || 1
+		};
+		let isFirstUpdate = true;
+		function handleObserve(entries) {
+			const ratio = entries[0].intersectionRatio;
+			if (ratio !== threshold) {
+				if (!isFirstUpdate) return refresh();
+				if (!ratio) timeoutId = setTimeout(() => {
+					refresh(false, 1e-7);
+				}, 1e3);
+				else refresh(false, ratio);
+			}
+			if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
+			isFirstUpdate = false;
+		}
+		try {
+			io = new IntersectionObserver(handleObserve, {
+				...options,
+				root: root.ownerDocument
+			});
+		} catch (_e) {
+			io = new IntersectionObserver(handleObserve, options);
+		}
+		io.observe(element);
+	}
+	refresh(true);
+	return cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+	if (options === void 0) options = {};
+	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
+	const referenceEl = unwrapElement(reference);
+	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+	ancestors.forEach((ancestor) => {
+		ancestorScroll && ancestor.addEventListener("scroll", update, { passive: true });
+		ancestorResize && ancestor.addEventListener("resize", update);
+	});
+	const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+	let reobserveFrame = -1;
+	let resizeObserver = null;
+	if (elementResize) {
+		resizeObserver = new ResizeObserver((_ref) => {
+			let [firstEntry] = _ref;
+			if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+				resizeObserver.unobserve(floating);
+				cancelAnimationFrame(reobserveFrame);
+				reobserveFrame = requestAnimationFrame(() => {
+					var _resizeObserver;
+					(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+				});
+			}
+			update();
+		});
+		if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
+		resizeObserver.observe(floating);
+	}
+	let frameId;
+	let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+	if (animationFrame) frameLoop();
+	function frameLoop() {
+		const nextRefRect = getBoundingClientRect(reference);
+		if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) update();
+		prevRefRect = nextRefRect;
+		frameId = requestAnimationFrame(frameLoop);
+	}
+	update();
+	return () => {
+		var _resizeObserver2;
+		ancestors.forEach((ancestor) => {
+			ancestorScroll && ancestor.removeEventListener("scroll", update);
+			ancestorResize && ancestor.removeEventListener("resize", update);
+		});
+		cleanupIo?.();
+		(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+		resizeObserver = null;
+		if (animationFrame) cancelAnimationFrame(frameId);
+	};
+}
+var offset$1 = offset$2;
+var shift$1 = shift$2;
+var computePosition = (reference, floating, options) => {
+	const cache = /* @__PURE__ */ new Map();
+	const mergedOptions = {
+		platform,
+		...options
+	};
+	const platformWithCache = {
+		...mergedOptions.platform,
+		_c: cache
+	};
+	return computePosition$1(reference, floating, {
+		...mergedOptions,
+		platform: platformWithCache
+	});
+};
+var index$1 = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "function" && a.toString() === b.toString()) return true;
+	let length;
+	let i;
+	let keys;
+	if (a && b && typeof a === "object") {
+		if (Array.isArray(a)) {
+			length = a.length;
+			if (length !== b.length) return false;
+			for (i = length; i-- !== 0;) if (!deepEqual(a[i], b[i])) return false;
+			return true;
+		}
+		keys = Object.keys(a);
+		length = keys.length;
+		if (length !== Object.keys(b).length) return false;
+		for (i = length; i-- !== 0;) if (!{}.hasOwnProperty.call(b, keys[i])) return false;
+		for (i = length; i-- !== 0;) {
+			const key = keys[i];
+			if (key === "_owner" && a.$$typeof) continue;
+			if (!deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return a !== a && b !== b;
+}
+function getDPR(element) {
+	if (typeof window === "undefined") return 1;
+	return (element.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+	const dpr = getDPR(element);
+	return Math.round(value * dpr) / dpr;
+}
+function useLatestRef$1(value) {
+	const ref = React$1.useRef(value);
+	index$1(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+function useFloating$1(options) {
+	if (options === void 0) options = {};
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1, elements: { reference: externalReference, floating: externalFloating } = {}, transform = true, whileElementsMounted, open } = options;
+	const [data, setData] = React$1.useState({
+		x: 0,
+		y: 0,
+		strategy,
+		placement,
+		middlewareData: {},
+		isPositioned: false
+	});
+	const [latestMiddleware, setLatestMiddleware] = React$1.useState(middleware);
+	if (!deepEqual(latestMiddleware, middleware)) setLatestMiddleware(middleware);
+	const [_reference, _setReference] = React$1.useState(null);
+	const [_floating, _setFloating] = React$1.useState(null);
+	const setReference = React$1.useCallback((node) => {
+		if (node !== referenceRef.current) {
+			referenceRef.current = node;
+			_setReference(node);
+		}
+	}, []);
+	const setFloating = React$1.useCallback((node) => {
+		if (node !== floatingRef.current) {
+			floatingRef.current = node;
+			_setFloating(node);
+		}
+	}, []);
+	const referenceEl = externalReference || _reference;
+	const floatingEl = externalFloating || _floating;
+	const referenceRef = React$1.useRef(null);
+	const floatingRef = React$1.useRef(null);
+	const dataRef = React$1.useRef(data);
+	const hasWhileElementsMounted = whileElementsMounted != null;
+	const whileElementsMountedRef = useLatestRef$1(whileElementsMounted);
+	const platformRef = useLatestRef$1(platform$1);
+	const openRef = useLatestRef$1(open);
+	const update = React$1.useCallback(() => {
+		if (!referenceRef.current || !floatingRef.current) return;
+		const config = {
+			placement,
+			strategy,
+			middleware: latestMiddleware
+		};
+		if (platformRef.current) config.platform = platformRef.current;
+		computePosition(referenceRef.current, floatingRef.current, config).then((data$1) => {
+			const fullData = {
+				...data$1,
+				isPositioned: openRef.current !== false
+			};
+			if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+				dataRef.current = fullData;
+				ReactDOM.flushSync(() => {
+					setData(fullData);
+				});
+			}
+		});
+	}, [
+		latestMiddleware,
+		placement,
+		strategy,
+		platformRef,
+		openRef
+	]);
+	index$1(() => {
+		if (open === false && dataRef.current.isPositioned) {
+			dataRef.current.isPositioned = false;
+			setData((data$1) => ({
+				...data$1,
+				isPositioned: false
+			}));
+		}
+	}, [open]);
+	const isMountedRef = React$1.useRef(false);
+	index$1(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+		};
+	}, []);
+	index$1(() => {
+		if (referenceEl) referenceRef.current = referenceEl;
+		if (floatingEl) floatingRef.current = floatingEl;
+		if (referenceEl && floatingEl) {
+			if (whileElementsMountedRef.current) return whileElementsMountedRef.current(referenceEl, floatingEl, update);
+			update();
+		}
+	}, [
+		referenceEl,
+		floatingEl,
+		update,
+		whileElementsMountedRef,
+		hasWhileElementsMounted
+	]);
+	const refs = React$1.useMemo(() => ({
+		reference: referenceRef,
+		floating: floatingRef,
+		setReference,
+		setFloating
+	}), [setReference, setFloating]);
+	const elements = React$1.useMemo(() => ({
+		reference: referenceEl,
+		floating: floatingEl
+	}), [referenceEl, floatingEl]);
+	const floatingStyles = React$1.useMemo(() => {
+		const initialStyles = {
+			position: strategy,
+			left: 0,
+			top: 0
+		};
+		if (!elements.floating) return initialStyles;
+		const x = roundByDPR(elements.floating, data.x);
+		const y = roundByDPR(elements.floating, data.y);
+		if (transform) return {
+			...initialStyles,
+			transform: "translate(" + x + "px, " + y + "px)",
+			...getDPR(elements.floating) >= 1.5 && { willChange: "transform" }
+		};
+		return {
+			position: strategy,
+			left: x,
+			top: y
+		};
+	}, [
+		strategy,
+		transform,
+		elements.floating,
+		data.x,
+		data.y
+	]);
+	return React$1.useMemo(() => ({
+		...data,
+		update,
+		refs,
+		elements,
+		floatingStyles
+	}), [
+		data,
+		update,
+		refs,
+		elements,
+		floatingStyles
+	]);
+}
+var offset = (options, deps) => ({
+	...offset$1(options),
+	options: [options, deps]
+});
+var shift = (options, deps) => ({
+	...shift$1(options),
+	options: [options, deps]
+});
+var FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
+var ACTIVE_KEY = "active";
+var SELECTED_KEY = "selected";
+var ARROW_LEFT = "ArrowLeft";
+var ARROW_RIGHT = "ArrowRight";
+var ARROW_UP = "ArrowUp";
+var ARROW_DOWN = "ArrowDown";
+var horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];
+var verticalKeys = [ARROW_UP, ARROW_DOWN];
+[...horizontalKeys, ...verticalKeys];
+var SafeReact = { ...React$1 };
+var serverHandoffComplete = false;
+var count = 0;
+var genId = () => "floating-ui-" + Math.random().toString(36).slice(2, 6) + count++;
+function useFloatingId() {
+	const [id, setId] = React$1.useState(() => serverHandoffComplete ? genId() : void 0);
+	index(() => {
+		if (id == null) setId(genId());
+	}, []);
+	React$1.useEffect(() => {
+		serverHandoffComplete = true;
+	}, []);
+	return id;
+}
+var useId$1 = SafeReact.useId || useFloatingId;
+var devMessageSet;
+if (process.env.NODE_ENV !== "production") devMessageSet = /* @__PURE__ */ new Set();
+function error() {
+	var _devMessageSet3;
+	for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) messages[_key2] = arguments[_key2];
+	const message = "Floating UI: " + messages.join(" ");
+	if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {
+		var _devMessageSet4;
+		(_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);
+		console.error(message);
+	}
+}
+function createEventEmitter() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		emit(event, data) {
+			var _map$get;
+			(_map$get = map.get(event)) == null || _map$get.forEach((listener) => listener(data));
+		},
+		on(event, listener) {
+			if (!map.has(event)) map.set(event, /* @__PURE__ */ new Set());
+			map.get(event).add(listener);
+		},
+		off(event, listener) {
+			var _map$get2;
+			(_map$get2 = map.get(event)) == null || _map$get2.delete(listener);
+		}
+	};
+}
+var FloatingNodeContext = /* @__PURE__ */ React$1.createContext(null);
+var FloatingTreeContext = /* @__PURE__ */ React$1.createContext(null);
+var useFloatingParentNodeId = () => {
+	var _React$useContext;
+	return ((_React$useContext = React$1.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
+};
+var useFloatingTree = () => React$1.useContext(FloatingTreeContext);
+function createAttribute(name) {
+	return "data-floating-ui-" + name;
+}
+function clearTimeoutIfSet(timeoutRef) {
+	if (timeoutRef.current !== -1) {
+		clearTimeout(timeoutRef.current);
+		timeoutRef.current = -1;
+	}
+}
+var rafId = 0;
+function enqueueFocus(el, options) {
+	if (options === void 0) options = {};
+	const { preventScroll = false, cancelPrevious = true, sync = false } = options;
+	cancelPrevious && cancelAnimationFrame(rafId);
+	const exec = () => el == null ? void 0 : el.focus({ preventScroll });
+	if (sync) exec();
+	else rafId = requestAnimationFrame(exec);
+}
+function getDocument$1(node) {
+	return (node == null ? void 0 : node.ownerDocument) || document;
+}
+var counters = {
+	inert: /* @__PURE__ */ new WeakMap(),
+	"aria-hidden": /* @__PURE__ */ new WeakMap(),
+	none: /* @__PURE__ */ new WeakMap()
+};
+function getCounterMap(control) {
+	if (control === "inert") return counters.inert;
+	if (control === "aria-hidden") return counters["aria-hidden"];
+	return counters.none;
+}
+var uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
+var markerMap = {};
+var lockCount$1 = 0;
+var supportsInert = () => typeof HTMLElement !== "undefined" && "inert" in HTMLElement.prototype;
+var unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+var correctElements = (parent, targets) => targets.map((target) => {
+	if (parent.contains(target)) return target;
+	const correctedTarget = unwrapHost(target);
+	if (parent.contains(correctedTarget)) return correctedTarget;
+	return null;
+}).filter((x) => x != null);
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {
+	const markerName = "data-floating-ui-inert";
+	const controlAttribute = inert ? "inert" : ariaHidden ? "aria-hidden" : null;
+	const avoidElements = correctElements(body, uncorrectedAvoidElements);
+	const elementsToKeep = /* @__PURE__ */ new Set();
+	const elementsToStop = new Set(avoidElements);
+	const hiddenElements = [];
+	if (!markerMap[markerName]) markerMap[markerName] = /* @__PURE__ */ new WeakMap();
+	const markerCounter = markerMap[markerName];
+	avoidElements.forEach(keep);
+	deep(body);
+	elementsToKeep.clear();
+	function keep(el) {
+		if (!el || elementsToKeep.has(el)) return;
+		elementsToKeep.add(el);
+		el.parentNode && keep(el.parentNode);
+	}
+	function deep(parent) {
+		if (!parent || elementsToStop.has(parent)) return;
+		[].forEach.call(parent.children, (node) => {
+			if (getNodeName(node) === "script") return;
+			if (elementsToKeep.has(node)) deep(node);
+			else {
+				const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;
+				const alreadyHidden = attr !== null && attr !== "false";
+				const counterMap = getCounterMap(controlAttribute);
+				const counterValue = (counterMap.get(node) || 0) + 1;
+				const markerValue = (markerCounter.get(node) || 0) + 1;
+				counterMap.set(node, counterValue);
+				markerCounter.set(node, markerValue);
+				hiddenElements.push(node);
+				if (counterValue === 1 && alreadyHidden) uncontrolledElementsSet.add(node);
+				if (markerValue === 1) node.setAttribute(markerName, "");
+				if (!alreadyHidden && controlAttribute) node.setAttribute(controlAttribute, controlAttribute === "inert" ? "" : "true");
+			}
+		});
+	}
+	lockCount$1++;
+	return () => {
+		hiddenElements.forEach((element) => {
+			const counterMap = getCounterMap(controlAttribute);
+			const counterValue = (counterMap.get(element) || 0) - 1;
+			const markerValue = (markerCounter.get(element) || 0) - 1;
+			counterMap.set(element, counterValue);
+			markerCounter.set(element, markerValue);
+			if (!counterValue) {
+				if (!uncontrolledElementsSet.has(element) && controlAttribute) element.removeAttribute(controlAttribute);
+				uncontrolledElementsSet.delete(element);
+			}
+			if (!markerValue) element.removeAttribute(markerName);
+		});
+		lockCount$1--;
+		if (!lockCount$1) {
+			counters.inert = /* @__PURE__ */ new WeakMap();
+			counters["aria-hidden"] = /* @__PURE__ */ new WeakMap();
+			counters.none = /* @__PURE__ */ new WeakMap();
+			uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
+			markerMap = {};
+		}
+	};
+}
+function markOthers(avoidElements, ariaHidden, inert) {
+	if (ariaHidden === void 0) ariaHidden = false;
+	if (inert === void 0) inert = false;
+	const body = getDocument$1(avoidElements[0]).body;
+	return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll("[aria-live],[role=\"status\"],output"))), body, ariaHidden, inert);
+}
+var HIDDEN_STYLES = {
+	border: 0,
+	clip: "rect(0 0 0 0)",
+	height: "1px",
+	margin: "-1px",
+	overflow: "hidden",
+	padding: 0,
+	position: "fixed",
+	whiteSpace: "nowrap",
+	width: "1px",
+	top: 0,
+	left: 0
+};
+var FocusGuard = /* @__PURE__ */ React$1.forwardRef(function FocusGuard$1(props, ref) {
+	const [role, setRole] = React$1.useState();
+	index(() => {
+		if (isSafari()) setRole("button");
+	}, []);
+	const restProps = {
+		ref,
+		tabIndex: 0,
+		role,
+		"aria-hidden": role ? void 0 : true,
+		[createAttribute("focus-guard")]: "",
+		style: HIDDEN_STYLES
+	};
+	return /* @__PURE__ */ jsx("span", {
+		...props,
+		...restProps
+	});
+});
+var PortalContext = /* @__PURE__ */ React$1.createContext(null);
+var usePortalContext = () => React$1.useContext(PortalContext);
+function useLiteMergeRefs(refs) {
+	return React$1.useMemo(() => {
+		return (value) => {
+			refs.forEach((ref) => {
+				if (ref) ref.current = value;
+			});
+		};
+	}, refs);
+}
+var LIST_LIMIT = 20;
+var previouslyFocusedElements = [];
+function clearDisconnectedPreviouslyFocusedElements() {
+	previouslyFocusedElements = previouslyFocusedElements.filter((el) => el.isConnected);
+}
+function addPreviouslyFocusedElement(element) {
+	clearDisconnectedPreviouslyFocusedElements();
+	if (element && getNodeName(element) !== "body") {
+		previouslyFocusedElements.push(element);
+		if (previouslyFocusedElements.length > LIST_LIMIT) previouslyFocusedElements = previouslyFocusedElements.slice(-20);
+	}
+}
+function getPreviouslyFocusedElement() {
+	clearDisconnectedPreviouslyFocusedElements();
+	return previouslyFocusedElements[previouslyFocusedElements.length - 1];
+}
+function getFirstTabbableElement(container) {
+	const tabbableOptions = getTabbableOptions();
+	if (isTabbable(container, tabbableOptions)) return container;
+	return tabbable(container, tabbableOptions)[0] || container;
+}
+function handleTabIndex(floatingFocusElement, orderRef) {
+	var _floatingFocusElement;
+	if (!orderRef.current.includes("floating") && !((_floatingFocusElement = floatingFocusElement.getAttribute("role")) != null && _floatingFocusElement.includes("dialog"))) return;
+	const options = getTabbableOptions();
+	const tabbableContent = focusable(floatingFocusElement, options).filter((element) => {
+		const dataTabIndex = element.getAttribute("data-tabindex") || "";
+		return isTabbable(element, options) || element.hasAttribute("data-tabindex") && !dataTabIndex.startsWith("-");
+	});
+	const tabIndex = floatingFocusElement.getAttribute("tabindex");
+	if (orderRef.current.includes("floating") || tabbableContent.length === 0) {
+		if (tabIndex !== "0") floatingFocusElement.setAttribute("tabindex", "0");
+	} else if (tabIndex !== "-1" || floatingFocusElement.hasAttribute("data-tabindex") && floatingFocusElement.getAttribute("data-tabindex") !== "-1") {
+		floatingFocusElement.setAttribute("tabindex", "-1");
+		floatingFocusElement.setAttribute("data-tabindex", "-1");
+	}
+}
+var VisuallyHiddenDismiss = /* @__PURE__ */ React$1.forwardRef(function VisuallyHiddenDismiss$1(props, ref) {
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		type: "button",
+		ref,
+		tabIndex: -1,
+		style: HIDDEN_STYLES
+	});
+});
+function FloatingFocusManager(props) {
+	const { context, children, disabled = false, order = ["content"], guards: _guards = true, initialFocus = 0, returnFocus = true, restoreFocus = false, modal = true, visuallyHiddenDismiss = false, closeOnFocusOut = true, outsideElementsInert = false, getInsideElements: _getInsideElements = () => [] } = props;
+	const { open, onOpenChange, events, dataRef, elements: { domReference, floating } } = context;
+	const getNodeId = useEffectEvent(() => {
+		var _dataRef$current$floa;
+		return (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;
+	});
+	const getInsideElements = useEffectEvent(_getInsideElements);
+	const ignoreInitialFocus = typeof initialFocus === "number" && initialFocus < 0;
+	const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
+	const inertSupported = supportsInert();
+	const guards = inertSupported ? _guards : true;
+	const useInert = !guards || inertSupported && outsideElementsInert;
+	const orderRef = useLatestRef(order);
+	const initialFocusRef = useLatestRef(initialFocus);
+	const returnFocusRef = useLatestRef(returnFocus);
+	const tree = useFloatingTree();
+	const portalContext = usePortalContext();
+	const startDismissButtonRef = React$1.useRef(null);
+	const endDismissButtonRef = React$1.useRef(null);
+	const preventReturnFocusRef = React$1.useRef(false);
+	const isPointerDownRef = React$1.useRef(false);
+	const tabbableIndexRef = React$1.useRef(-1);
+	const blurTimeoutRef = React$1.useRef(-1);
+	const isInsidePortal = portalContext != null;
+	const floatingFocusElement = getFloatingFocusElement(floating);
+	const getTabbableContent = useEffectEvent(function(container) {
+		if (container === void 0) container = floatingFocusElement;
+		return container ? tabbable(container, getTabbableOptions()) : [];
+	});
+	const getTabbableElements = useEffectEvent((container) => {
+		const content = getTabbableContent(container);
+		return orderRef.current.map((type) => {
+			if (domReference && type === "reference") return domReference;
+			if (floatingFocusElement && type === "floating") return floatingFocusElement;
+			return content;
+		}).filter(Boolean).flat();
+	});
+	React$1.useEffect(() => {
+		if (disabled) return;
+		if (!modal) return;
+		function onKeyDown(event) {
+			if (event.key === "Tab") {
+				if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) stopEvent(event);
+				const els = getTabbableElements();
+				const target = getTarget(event);
+				if (orderRef.current[0] === "reference" && target === domReference) {
+					stopEvent(event);
+					if (event.shiftKey) enqueueFocus(els[els.length - 1]);
+					else enqueueFocus(els[1]);
+				}
+				if (orderRef.current[1] === "floating" && target === floatingFocusElement && event.shiftKey) {
+					stopEvent(event);
+					enqueueFocus(els[0]);
+				}
+			}
+		}
+		const doc = getDocument(floatingFocusElement);
+		doc.addEventListener("keydown", onKeyDown);
+		return () => {
+			doc.removeEventListener("keydown", onKeyDown);
+		};
+	}, [
+		disabled,
+		domReference,
+		floatingFocusElement,
+		modal,
+		orderRef,
+		isUntrappedTypeableCombobox,
+		getTabbableContent,
+		getTabbableElements
+	]);
+	React$1.useEffect(() => {
+		if (disabled) return;
+		if (!floating) return;
+		function handleFocusIn(event) {
+			const target = getTarget(event);
+			const tabbableIndex = getTabbableContent().indexOf(target);
+			if (tabbableIndex !== -1) tabbableIndexRef.current = tabbableIndex;
+		}
+		floating.addEventListener("focusin", handleFocusIn);
+		return () => {
+			floating.removeEventListener("focusin", handleFocusIn);
+		};
+	}, [
+		disabled,
+		floating,
+		getTabbableContent
+	]);
+	React$1.useEffect(() => {
+		if (disabled) return;
+		if (!closeOnFocusOut) return;
+		function handlePointerDown() {
+			isPointerDownRef.current = true;
+			setTimeout(() => {
+				isPointerDownRef.current = false;
+			});
+		}
+		function handleFocusOutside(event) {
+			const relatedTarget = event.relatedTarget;
+			const currentTarget = event.currentTarget;
+			const target = getTarget(event);
+			queueMicrotask(() => {
+				const nodeId = getNodeId();
+				const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute("focus-guard")) || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find((node) => {
+					var _node$context, _node$context2;
+					return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);
+				}) || getNodeAncestors(tree.nodesRef.current, nodeId).find((node) => {
+					var _node$context3, _node$context4, _node$context5;
+					return [(_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating, getFloatingFocusElement((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.floating)].includes(relatedTarget) || ((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.domReference) === relatedTarget;
+				})));
+				if (currentTarget === domReference && floatingFocusElement) handleTabIndex(floatingFocusElement, orderRef);
+				if (restoreFocus && currentTarget !== domReference && !(target != null && target.isConnected) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {
+					if (isHTMLElement(floatingFocusElement)) floatingFocusElement.focus();
+					const prevTabbableIndex = tabbableIndexRef.current;
+					const tabbableContent = getTabbableContent();
+					const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
+					if (isHTMLElement(nodeToFocus)) nodeToFocus.focus();
+				}
+				if (dataRef.current.insideReactTree) {
+					dataRef.current.insideReactTree = false;
+					return;
+				}
+				if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && relatedTarget !== getPreviouslyFocusedElement()) {
+					preventReturnFocusRef.current = true;
+					onOpenChange(false, event, "focus-out");
+				}
+			});
+		}
+		const shouldHandleBlurCapture = Boolean(!tree && portalContext);
+		function markInsideReactTree() {
+			clearTimeoutIfSet(blurTimeoutRef);
+			dataRef.current.insideReactTree = true;
+			blurTimeoutRef.current = window.setTimeout(() => {
+				dataRef.current.insideReactTree = false;
+			});
+		}
+		if (floating && isHTMLElement(domReference)) {
+			domReference.addEventListener("focusout", handleFocusOutside);
+			domReference.addEventListener("pointerdown", handlePointerDown);
+			floating.addEventListener("focusout", handleFocusOutside);
+			if (shouldHandleBlurCapture) floating.addEventListener("focusout", markInsideReactTree, true);
+			return () => {
+				domReference.removeEventListener("focusout", handleFocusOutside);
+				domReference.removeEventListener("pointerdown", handlePointerDown);
+				floating.removeEventListener("focusout", handleFocusOutside);
+				if (shouldHandleBlurCapture) floating.removeEventListener("focusout", markInsideReactTree, true);
+			};
+		}
+	}, [
+		disabled,
+		domReference,
+		floating,
+		floatingFocusElement,
+		modal,
+		tree,
+		portalContext,
+		onOpenChange,
+		closeOnFocusOut,
+		restoreFocus,
+		getTabbableContent,
+		isUntrappedTypeableCombobox,
+		getNodeId,
+		orderRef,
+		dataRef
+	]);
+	const beforeGuardRef = React$1.useRef(null);
+	const afterGuardRef = React$1.useRef(null);
+	const mergedBeforeGuardRef = useLiteMergeRefs([beforeGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef]);
+	const mergedAfterGuardRef = useLiteMergeRefs([afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef]);
+	React$1.useEffect(() => {
+		var _portalContext$portal, _ancestors$find;
+		if (disabled) return;
+		if (!floating) return;
+		const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll("[" + createAttribute("portal") + "]")) || []);
+		const insideElements = [
+			floating,
+			(_ancestors$find = (tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : []).find((node) => {
+				var _node$context6;
+				return isTypeableCombobox(((_node$context6 = node.context) == null ? void 0 : _node$context6.elements.domReference) || null);
+			})) == null || (_ancestors$find = _ancestors$find.context) == null ? void 0 : _ancestors$find.elements.domReference,
+			...portalNodes,
+			...getInsideElements(),
+			startDismissButtonRef.current,
+			endDismissButtonRef.current,
+			beforeGuardRef.current,
+			afterGuardRef.current,
+			portalContext == null ? void 0 : portalContext.beforeOutsideRef.current,
+			portalContext == null ? void 0 : portalContext.afterOutsideRef.current,
+			orderRef.current.includes("reference") || isUntrappedTypeableCombobox ? domReference : null
+		].filter((x) => x != null);
+		const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, !useInert, useInert) : markOthers(insideElements);
+		return () => {
+			cleanup();
+		};
+	}, [
+		disabled,
+		domReference,
+		floating,
+		modal,
+		orderRef,
+		portalContext,
+		isUntrappedTypeableCombobox,
+		guards,
+		useInert,
+		tree,
+		getNodeId,
+		getInsideElements
+	]);
+	index(() => {
+		if (disabled || !isHTMLElement(floatingFocusElement)) return;
+		const previouslyFocusedElement = activeElement(getDocument(floatingFocusElement));
+		queueMicrotask(() => {
+			const focusableElements = getTabbableElements(floatingFocusElement);
+			const initialFocusValue = initialFocusRef.current;
+			const elToFocus = (typeof initialFocusValue === "number" ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusElement;
+			const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);
+			if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) enqueueFocus(elToFocus, { preventScroll: elToFocus === floatingFocusElement });
+		});
+	}, [
+		disabled,
+		open,
+		floatingFocusElement,
+		ignoreInitialFocus,
+		getTabbableElements,
+		initialFocusRef
+	]);
+	index(() => {
+		if (disabled || !floatingFocusElement) return;
+		const doc = getDocument(floatingFocusElement);
+		addPreviouslyFocusedElement(activeElement(doc));
+		function onOpenChange$1(_ref) {
+			let { reason, event, nested } = _ref;
+			if (["hover", "safe-polygon"].includes(reason) && event.type === "mouseleave") preventReturnFocusRef.current = true;
+			if (reason !== "outside-press") return;
+			if (nested) preventReturnFocusRef.current = false;
+			else if (isVirtualClick(event) || isVirtualPointerEvent(event)) preventReturnFocusRef.current = false;
+			else {
+				let isPreventScrollSupported = false;
+				document.createElement("div").focus({ get preventScroll() {
+					isPreventScrollSupported = true;
+					return false;
+				} });
+				if (isPreventScrollSupported) preventReturnFocusRef.current = false;
+				else preventReturnFocusRef.current = true;
+			}
+		}
+		events.on("openchange", onOpenChange$1);
+		const fallbackEl = doc.createElement("span");
+		fallbackEl.setAttribute("tabindex", "-1");
+		fallbackEl.setAttribute("aria-hidden", "true");
+		Object.assign(fallbackEl.style, HIDDEN_STYLES);
+		if (isInsidePortal && domReference) domReference.insertAdjacentElement("afterend", fallbackEl);
+		function getReturnElement() {
+			if (typeof returnFocusRef.current === "boolean") {
+				const el = domReference || getPreviouslyFocusedElement();
+				return el && el.isConnected ? el : fallbackEl;
+			}
+			return returnFocusRef.current.current || fallbackEl;
+		}
+		return () => {
+			events.off("openchange", onOpenChange$1);
+			const activeEl = activeElement(doc);
+			const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node) => {
+				var _node$context7;
+				return contains((_node$context7 = node.context) == null ? void 0 : _node$context7.elements.floating, activeEl);
+			});
+			const returnElement = getReturnElement();
+			queueMicrotask(() => {
+				const tabbableReturnElement = getFirstTabbableElement(returnElement);
+				if (returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) tabbableReturnElement.focus({ preventScroll: true });
+				fallbackEl.remove();
+			});
+		};
+	}, [
+		disabled,
+		floating,
+		floatingFocusElement,
+		returnFocusRef,
+		dataRef,
+		events,
+		tree,
+		isInsidePortal,
+		domReference,
+		getNodeId
+	]);
+	React$1.useEffect(() => {
+		queueMicrotask(() => {
+			preventReturnFocusRef.current = false;
+		});
+		return () => {
+			queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
+		};
+	}, [disabled]);
+	index(() => {
+		if (disabled) return;
+		if (!portalContext) return;
+		portalContext.setFocusManagerState({
+			modal,
+			closeOnFocusOut,
+			open,
+			onOpenChange,
+			domReference
+		});
+		return () => {
+			portalContext.setFocusManagerState(null);
+		};
+	}, [
+		disabled,
+		portalContext,
+		modal,
+		open,
+		onOpenChange,
+		closeOnFocusOut,
+		domReference
+	]);
+	index(() => {
+		if (disabled) return;
+		if (!floatingFocusElement) return;
+		handleTabIndex(floatingFocusElement, orderRef);
+	}, [
+		disabled,
+		floatingFocusElement,
+		orderRef
+	]);
+	function renderDismissButton(location) {
+		if (disabled || !visuallyHiddenDismiss || !modal) return null;
+		return /* @__PURE__ */ jsx(VisuallyHiddenDismiss, {
+			ref: location === "start" ? startDismissButtonRef : endDismissButtonRef,
+			onClick: (event) => onOpenChange(false, event.nativeEvent),
+			children: typeof visuallyHiddenDismiss === "string" ? visuallyHiddenDismiss : "Dismiss"
+		});
+	}
+	const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
+			"data-type": "inside",
+			ref: mergedBeforeGuardRef,
+			onFocus: (event) => {
+				if (modal) {
+					const els = getTabbableElements();
+					enqueueFocus(order[0] === "reference" ? els[0] : els[els.length - 1]);
+				} else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {
+					preventReturnFocusRef.current = false;
+					if (isOutsideEvent(event, portalContext.portalNode)) getNextTabbable(domReference)?.focus();
+					else {
+						var _portalContext$before;
+						(_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();
+					}
+				}
+			}
+		}),
+		!isUntrappedTypeableCombobox && renderDismissButton("start"),
+		children,
+		renderDismissButton("end"),
+		shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
+			"data-type": "inside",
+			ref: mergedAfterGuardRef,
+			onFocus: (event) => {
+				if (modal) enqueueFocus(getTabbableElements()[0]);
+				else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {
+					if (closeOnFocusOut) preventReturnFocusRef.current = true;
+					if (isOutsideEvent(event, portalContext.portalNode)) getPreviousTabbable(domReference)?.focus();
+					else {
+						var _portalContext$afterO;
+						(_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();
+					}
+				}
+			}
+		})
+	] });
+}
+function isButtonTarget(event) {
+	return isHTMLElement(event.target) && event.target.tagName === "BUTTON";
+}
+function isAnchorTarget(event) {
+	return isHTMLElement(event.target) && event.target.tagName === "A";
+}
+function isSpaceIgnored(element) {
+	return isTypeableElement(element);
+}
+function useClick(context, props) {
+	if (props === void 0) props = {};
+	const { open, onOpenChange, dataRef, elements: { domReference } } = context;
+	const { enabled = true, event: eventOption = "click", toggle = true, ignoreMouse = false, keyboardHandlers = true, stickIfOpen = true } = props;
+	const pointerTypeRef = React$1.useRef();
+	const didKeyDownRef = React$1.useRef(false);
+	const reference = React$1.useMemo(() => ({
+		onPointerDown(event) {
+			pointerTypeRef.current = event.pointerType;
+		},
+		onMouseDown(event) {
+			const pointerType = pointerTypeRef.current;
+			if (event.button !== 0) return;
+			if (eventOption === "click") return;
+			if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;
+			if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === "mousedown" : true)) onOpenChange(false, event.nativeEvent, "click");
+			else {
+				event.preventDefault();
+				onOpenChange(true, event.nativeEvent, "click");
+			}
+		},
+		onClick(event) {
+			const pointerType = pointerTypeRef.current;
+			if (eventOption === "mousedown" && pointerTypeRef.current) {
+				pointerTypeRef.current = void 0;
+				return;
+			}
+			if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;
+			if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === "click" : true)) onOpenChange(false, event.nativeEvent, "click");
+			else onOpenChange(true, event.nativeEvent, "click");
+		},
+		onKeyDown(event) {
+			pointerTypeRef.current = void 0;
+			if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) return;
+			if (event.key === " " && !isSpaceIgnored(domReference)) {
+				event.preventDefault();
+				didKeyDownRef.current = true;
+			}
+			if (isAnchorTarget(event)) return;
+			if (event.key === "Enter") if (open && toggle) onOpenChange(false, event.nativeEvent, "click");
+			else onOpenChange(true, event.nativeEvent, "click");
+		},
+		onKeyUp(event) {
+			if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) return;
+			if (event.key === " " && didKeyDownRef.current) {
+				didKeyDownRef.current = false;
+				if (open && toggle) onOpenChange(false, event.nativeEvent, "click");
+				else onOpenChange(true, event.nativeEvent, "click");
+			}
+		}
+	}), [
+		dataRef,
+		domReference,
+		eventOption,
+		ignoreMouse,
+		keyboardHandlers,
+		onOpenChange,
+		open,
+		stickIfOpen,
+		toggle
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
+}
+var bubbleHandlerKeys = {
+	pointerdown: "onPointerDown",
+	mousedown: "onMouseDown",
+	click: "onClick"
+};
+var captureHandlerKeys = {
+	pointerdown: "onPointerDownCapture",
+	mousedown: "onMouseDownCapture",
+	click: "onClickCapture"
+};
+var normalizeProp = (normalizable) => {
+	var _normalizable$escapeK, _normalizable$outside;
+	return {
+		escapeKey: typeof normalizable === "boolean" ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,
+		outsidePress: typeof normalizable === "boolean" ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true
+	};
+};
+function useDismiss(context, props) {
+	if (props === void 0) props = {};
+	const { open, onOpenChange, elements, dataRef } = context;
+	const { enabled = true, escapeKey = true, outsidePress: unstable_outsidePress = true, outsidePressEvent = "pointerdown", referencePress = false, referencePressEvent = "pointerdown", ancestorScroll = false, bubbles, capture } = props;
+	const tree = useFloatingTree();
+	const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === "function" ? unstable_outsidePress : () => false);
+	const outsidePress = typeof unstable_outsidePress === "function" ? outsidePressFn : unstable_outsidePress;
+	const endedOrStartedInsideRef = React$1.useRef(false);
+	const { escapeKey: escapeKeyBubbles, outsidePress: outsidePressBubbles } = normalizeProp(bubbles);
+	const { escapeKey: escapeKeyCapture, outsidePress: outsidePressCapture } = normalizeProp(capture);
+	const isComposingRef = React$1.useRef(false);
+	const closeOnEscapeKeyDown = useEffectEvent((event) => {
+		var _dataRef$current$floa;
+		if (!open || !enabled || !escapeKey || event.key !== "Escape") return;
+		if (isComposingRef.current) return;
+		const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;
+		const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+		if (!escapeKeyBubbles) {
+			event.stopPropagation();
+			if (children.length > 0) {
+				let shouldDismiss = true;
+				children.forEach((child) => {
+					var _child$context;
+					if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {
+						shouldDismiss = false;
+						return;
+					}
+				});
+				if (!shouldDismiss) return;
+			}
+		}
+		onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, "escape-key");
+	});
+	const closeOnEscapeKeyDownCapture = useEffectEvent((event) => {
+		var _getTarget2;
+		const callback = () => {
+			var _getTarget;
+			closeOnEscapeKeyDown(event);
+			(_getTarget = getTarget(event)) == null || _getTarget.removeEventListener("keydown", callback);
+		};
+		(_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener("keydown", callback);
+	});
+	const closeOnPressOutside = useEffectEvent((event) => {
+		var _dataRef$current$floa2;
+		const insideReactTree = dataRef.current.insideReactTree;
+		dataRef.current.insideReactTree = false;
+		const endedOrStartedInside = endedOrStartedInsideRef.current;
+		endedOrStartedInsideRef.current = false;
+		if (outsidePressEvent === "click" && endedOrStartedInside) return;
+		if (insideReactTree) return;
+		if (typeof outsidePress === "function" && !outsidePress(event)) return;
+		const target = getTarget(event);
+		const inertSelector = "[" + createAttribute("inert") + "]";
+		const markers = getDocument(elements.floating).querySelectorAll(inertSelector);
+		let targetRootAncestor = isElement(target) ? target : null;
+		while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
+			const nextParent = getParentNode(targetRootAncestor);
+			if (isLastTraversableNode(nextParent) || !isElement(nextParent)) break;
+			targetRootAncestor = nextParent;
+		}
+		if (markers.length && isElement(target) && !isRootElement(target) && !contains(target, elements.floating) && Array.from(markers).every((marker) => !contains(targetRootAncestor, marker))) return;
+		if (isHTMLElement(target) && floating) {
+			const lastTraversableNode = isLastTraversableNode(target);
+			const style = getComputedStyle$1(target);
+			const scrollRe = /auto|scroll/;
+			const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
+			const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
+			const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
+			const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
+			const isRTL$1 = style.direction === "rtl";
+			const pressedVerticalScrollbar = canScrollY && (isRTL$1 ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
+			const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
+			if (pressedVerticalScrollbar || pressedHorizontalScrollbar) return;
+		}
+		const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa2.nodeId;
+		const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node) => {
+			var _node$context;
+			return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);
+		});
+		if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) return;
+		const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+		if (children.length > 0) {
+			let shouldDismiss = true;
+			children.forEach((child) => {
+				var _child$context2;
+				if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {
+					shouldDismiss = false;
+					return;
+				}
+			});
+			if (!shouldDismiss) return;
+		}
+		onOpenChange(false, event, "outside-press");
+	});
+	const closeOnPressOutsideCapture = useEffectEvent((event) => {
+		var _getTarget4;
+		const callback = () => {
+			var _getTarget3;
+			closeOnPressOutside(event);
+			(_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);
+		};
+		(_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);
+	});
+	React$1.useEffect(() => {
+		if (!open || !enabled) return;
+		dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
+		dataRef.current.__outsidePressBubbles = outsidePressBubbles;
+		let compositionTimeout = -1;
+		function onScroll(event) {
+			onOpenChange(false, event, "ancestor-scroll");
+		}
+		function handleCompositionStart() {
+			window.clearTimeout(compositionTimeout);
+			isComposingRef.current = true;
+		}
+		function handleCompositionEnd() {
+			compositionTimeout = window.setTimeout(() => {
+				isComposingRef.current = false;
+			}, isWebKit() ? 5 : 0);
+		}
+		const doc = getDocument(elements.floating);
+		if (escapeKey) {
+			doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+			doc.addEventListener("compositionstart", handleCompositionStart);
+			doc.addEventListener("compositionend", handleCompositionEnd);
+		}
+		outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+		let ancestors = [];
+		if (ancestorScroll) {
+			if (isElement(elements.domReference)) ancestors = getOverflowAncestors(elements.domReference);
+			if (isElement(elements.floating)) ancestors = ancestors.concat(getOverflowAncestors(elements.floating));
+			if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));
+		}
+		ancestors = ancestors.filter((ancestor) => {
+			var _doc$defaultView;
+			return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);
+		});
+		ancestors.forEach((ancestor) => {
+			ancestor.addEventListener("scroll", onScroll, { passive: true });
+		});
+		return () => {
+			if (escapeKey) {
+				doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+				doc.removeEventListener("compositionstart", handleCompositionStart);
+				doc.removeEventListener("compositionend", handleCompositionEnd);
+			}
+			outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+			ancestors.forEach((ancestor) => {
+				ancestor.removeEventListener("scroll", onScroll);
+			});
+			window.clearTimeout(compositionTimeout);
+		};
+	}, [
+		dataRef,
+		elements,
+		escapeKey,
+		outsidePress,
+		outsidePressEvent,
+		open,
+		onOpenChange,
+		ancestorScroll,
+		enabled,
+		escapeKeyBubbles,
+		outsidePressBubbles,
+		closeOnEscapeKeyDown,
+		escapeKeyCapture,
+		closeOnEscapeKeyDownCapture,
+		closeOnPressOutside,
+		outsidePressCapture,
+		closeOnPressOutsideCapture
+	]);
+	React$1.useEffect(() => {
+		dataRef.current.insideReactTree = false;
+	}, [
+		dataRef,
+		outsidePress,
+		outsidePressEvent
+	]);
+	const reference = React$1.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		...referencePress && {
+			[bubbleHandlerKeys[referencePressEvent]]: (event) => {
+				onOpenChange(false, event.nativeEvent, "reference-press");
+			},
+			...referencePressEvent !== "click" && { onClick(event) {
+				onOpenChange(false, event.nativeEvent, "reference-press");
+			} }
+		}
+	}), [
+		closeOnEscapeKeyDown,
+		onOpenChange,
+		referencePress,
+		referencePressEvent
+	]);
+	const floating = React$1.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		onMouseDown() {
+			endedOrStartedInsideRef.current = true;
+		},
+		onMouseUp() {
+			endedOrStartedInsideRef.current = true;
+		},
+		[captureHandlerKeys[outsidePressEvent]]: () => {
+			dataRef.current.insideReactTree = true;
+		}
+	}), [
+		closeOnEscapeKeyDown,
+		outsidePressEvent,
+		dataRef
+	]);
+	return React$1.useMemo(() => enabled ? {
+		reference,
+		floating
+	} : {}, [
+		enabled,
+		reference,
+		floating
+	]);
+}
+function useFloatingRootContext(options) {
+	const { open = false, onOpenChange: onOpenChangeProp, elements: elementsProp } = options;
+	const floatingId = useId$1();
+	const dataRef = React$1.useRef({});
+	const [events] = React$1.useState(() => createEventEmitter());
+	const nested = useFloatingParentNodeId() != null;
+	if (process.env.NODE_ENV !== "production") {
+		const optionDomReference = elementsProp.reference;
+		if (optionDomReference && !isElement(optionDomReference)) error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+	}
+	const [positionReference, setPositionReference] = React$1.useState(elementsProp.reference);
+	const onOpenChange = useEffectEvent((open$1, event, reason) => {
+		dataRef.current.openEvent = open$1 ? event : void 0;
+		events.emit("openchange", {
+			open: open$1,
+			event,
+			reason,
+			nested
+		});
+		onOpenChangeProp?.(open$1, event, reason);
+	});
+	const refs = React$1.useMemo(() => ({ setPositionReference }), []);
+	const elements = React$1.useMemo(() => ({
+		reference: positionReference || elementsProp.reference || null,
+		floating: elementsProp.floating || null,
+		domReference: elementsProp.reference
+	}), [
+		positionReference,
+		elementsProp.reference,
+		elementsProp.floating
+	]);
+	return React$1.useMemo(() => ({
+		dataRef,
+		open,
+		onOpenChange,
+		elements,
+		events,
+		floatingId,
+		refs
+	}), [
+		open,
+		onOpenChange,
+		elements,
+		events,
+		floatingId,
+		refs
+	]);
+}
+function useFloating(options) {
+	if (options === void 0) options = {};
+	const { nodeId } = options;
+	const internalRootContext = useFloatingRootContext({
+		...options,
+		elements: {
+			reference: null,
+			floating: null,
+			...options.elements
+		}
+	});
+	const rootContext = options.rootContext || internalRootContext;
+	const computedElements = rootContext.elements;
+	const [_domReference, setDomReference] = React$1.useState(null);
+	const [positionReference, _setPositionReference] = React$1.useState(null);
+	const domReference = (computedElements == null ? void 0 : computedElements.domReference) || _domReference;
+	const domReferenceRef = React$1.useRef(null);
+	const tree = useFloatingTree();
+	index(() => {
+		if (domReference) domReferenceRef.current = domReference;
+	}, [domReference]);
+	const position = useFloating$1({
+		...options,
+		elements: {
+			...computedElements,
+			...positionReference && { reference: positionReference }
+		}
+	});
+	const setPositionReference = React$1.useCallback((node) => {
+		const computedPositionReference = isElement(node) ? {
+			getBoundingClientRect: () => node.getBoundingClientRect(),
+			getClientRects: () => node.getClientRects(),
+			contextElement: node
+		} : node;
+		_setPositionReference(computedPositionReference);
+		position.refs.setReference(computedPositionReference);
+	}, [position.refs]);
+	const setReference = React$1.useCallback((node) => {
+		if (isElement(node) || node === null) {
+			domReferenceRef.current = node;
+			setDomReference(node);
+		}
+		if (isElement(position.refs.reference.current) || position.refs.reference.current === null || node !== null && !isElement(node)) position.refs.setReference(node);
+	}, [position.refs]);
+	const refs = React$1.useMemo(() => ({
+		...position.refs,
+		setReference,
+		setPositionReference,
+		domReference: domReferenceRef
+	}), [
+		position.refs,
+		setReference,
+		setPositionReference
+	]);
+	const elements = React$1.useMemo(() => ({
+		...position.elements,
+		domReference
+	}), [position.elements, domReference]);
+	const context = React$1.useMemo(() => ({
+		...position,
+		...rootContext,
+		refs,
+		elements,
+		nodeId
+	}), [
+		position,
+		refs,
+		elements,
+		nodeId,
+		rootContext
+	]);
+	index(() => {
+		rootContext.dataRef.current.floatingContext = context;
+		const node = tree == null ? void 0 : tree.nodesRef.current.find((node$1) => node$1.id === nodeId);
+		if (node) node.context = context;
+	});
+	return React$1.useMemo(() => ({
+		...position,
+		context,
+		refs,
+		elements
+	}), [
+		position,
+		refs,
+		elements,
+		context
+	]);
+}
+function mergeProps(userProps, propsList, elementKey) {
+	const map = /* @__PURE__ */ new Map();
+	const isItem = elementKey === "item";
+	let domUserProps = userProps;
+	if (isItem && userProps) {
+		const { [ACTIVE_KEY]: _, [SELECTED_KEY]: __, ...validProps } = userProps;
+		domUserProps = validProps;
+	}
+	return {
+		...elementKey === "floating" && {
+			tabIndex: -1,
+			[FOCUSABLE_ATTRIBUTE]: ""
+		},
+		...domUserProps,
+		...propsList.map((value) => {
+			const propsOrGetProps = value ? value[elementKey] : null;
+			if (typeof propsOrGetProps === "function") return userProps ? propsOrGetProps(userProps) : null;
+			return propsOrGetProps;
+		}).concat(userProps).reduce((acc, props) => {
+			if (!props) return acc;
+			Object.entries(props).forEach((_ref) => {
+				let [key, value] = _ref;
+				if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) return;
+				if (key.indexOf("on") === 0) {
+					if (!map.has(key)) map.set(key, []);
+					if (typeof value === "function") {
+						var _map$get;
+						(_map$get = map.get(key)) == null || _map$get.push(value);
+						acc[key] = function() {
+							var _map$get2;
+							for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+							return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
+						};
+					}
+				} else acc[key] = value;
+			});
+			return acc;
+		}, {})
+	};
+}
+function useInteractions(propsList) {
+	if (propsList === void 0) propsList = [];
+	const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
+	const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
+	const itemDeps = propsList.map((key) => key == null ? void 0 : key.item);
+	const getReferenceProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, "reference"), referenceDeps);
+	const getFloatingProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, "floating"), floatingDeps);
+	const getItemProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, "item"), itemDeps);
+	return React$1.useMemo(() => ({
+		getReferenceProps,
+		getFloatingProps,
+		getItemProps
+	}), [
+		getReferenceProps,
+		getFloatingProps,
+		getItemProps
+	]);
+}
+var DateInputInternal = ({ value, onChange, onBlur, inputId, legendId, setErrorText, resources, withClearButton, ["aria-describedby"]: ariaDescribedBy, ["aria-labelledby"]: ariaLabelledBy }) => {
+	const [errorTextDd, setErrorTextDd] = useState("");
+	const [errorTextMm, setErrorTextMm] = useState("");
+	const [errorTextYyyy, setErrorTextYyyy] = useState("");
+	const [dd, setDd] = useState("");
+	const [mm, setMm] = useState("");
+	const [yyyy, setYyyy] = useState("");
+	const hasValue = dd !== "" || mm !== "" || yyyy !== "";
+	const ddRef = useRef(null);
+	const mmRef = useRef(null);
+	const yyyyRef = useRef(null);
+	const inputRefs = [
+		ddRef,
+		mmRef,
+		yyyyRef
+	];
+	const clearButtonRef = useRef(null);
+	const [isClearButtonFocused, setIsClearButtonFocused] = useState(false);
+	useEffect(() => {
+		if (!value || value === "") return;
+		const match = value.match(/^(\d{2})\.(\d{2})\.(\d{4})$/);
+		if (match) {
+			const [_, newDd, newMm, newYyyy] = match;
+			if (dd !== newDd) setDd(newDd);
+			if (mm !== newMm) setMm(newMm);
+			if (yyyy !== newYyyy) setYyyy(newYyyy);
+		}
+	}, [value]);
+	const combinedValue = dd && mm && yyyy ? `${dd}.${mm}.${yyyy}` : "";
+	useEffect(() => {
+		if (onChange) onChange(combinedValue);
+	}, [combinedValue]);
+	const validateDd = (newDd) => {
+		if (newDd === "") {
+			setErrorTextDd("");
+			return true;
+		}
+		if (/^\d{0,2}$/.test(newDd)) {
+			const dayNum = parseInt(newDd, 10);
+			if (dayNum < 0 || dayNum > 31) {
+				setErrorTextDd(resources?.validateDefaultMessageDay || "Dag må være et tall mellom 01 og 31");
+				return false;
+			} else {
+				setErrorTextDd("");
+				return true;
+			}
+		} else {
+			setErrorTextDd(resources?.validateDefaultMessageDay || "Dag må være et tall mellom 01 og 31");
+			return false;
+		}
+	};
+	const handleDdChange = (e) => {
+		const newDd = e.target.value;
+		setDd(newDd);
+		if (validateDd(newDd)) {
+			if (newDd.length === 2) mmRef.current?.focus();
+		}
+	};
+	const validateMm = (newMm) => {
+		if (newMm === "") {
+			setErrorTextMm("");
+			return true;
+		}
+		if (/^\d{0,2}$/.test(newMm)) {
+			const dayNum = parseInt(newMm, 10);
+			if (dayNum < 0 || dayNum > 12) {
+				setErrorTextMm(resources?.validateDefaultMessageMonth || "Måned må være et tall mellom 01 og 12");
+				return false;
+			} else {
+				setErrorTextMm("");
+				return true;
+			}
+		} else {
+			setErrorTextMm(resources?.validateDefaultMessageMonth || "Måned må være et tall mellom 01 og 12");
+			return false;
+		}
+	};
+	const handleMmChange = (e) => {
+		const newMm = e.target.value;
+		setMm(newMm);
+		if (validateMm(newMm)) {
+			if (newMm.length === 2) yyyyRef.current?.focus();
+		}
+	};
+	const validateYyyy = (newYyyy, strict) => {
+		if (newYyyy === "") {
+			setErrorTextYyyy("");
+			return true;
+		}
+		if (/^\d{0,4}$/.test(newYyyy)) {
+			const dayNum = parseInt(newYyyy, 10);
+			let minValue = 0;
+			if (strict) minValue = 1e3;
+			if (dayNum < minValue || dayNum > 9999) {
+				setErrorTextYyyy(resources?.validateDefaultMessageYear || "År må være et tall med 4 siffer");
+				return false;
+			} else {
+				setErrorTextYyyy("");
+				return true;
+			}
+		} else {
+			setErrorTextYyyy(resources?.validateDefaultMessageYear || "År må være et tall med 4 siffer");
+			return false;
+		}
+	};
+	const handleYyyyChange = (e) => {
+		const newYyyy = e.target.value;
+		setYyyy(newYyyy);
+		validateYyyy(newYyyy);
+	};
+	const handleBlurOnSegment = () => {
+		validateDd(dd);
+		validateMm(mm);
+		validateYyyy(yyyy, true);
+	};
+	useEffect(() => {
+		const combinedErrors = [
+			errorTextDd,
+			errorTextMm,
+			errorTextYyyy
+		].filter((err) => err !== "").join(". ");
+		if (setErrorText) setErrorText(combinedErrors);
+	}, [
+		errorTextDd,
+		errorTextMm,
+		errorTextYyyy
+	]);
+	const segmentClass = styles["date-segment"];
+	const errorClass = styles["date-segment--error"];
+	const daySegmentClassNames = classNames(segmentClass, errorTextDd && errorClass);
+	const monthSegmentClassNames = classNames(segmentClass, errorTextMm && errorClass);
+	const yearSegmentClassNames = classNames(segmentClass, errorTextYyyy && errorClass, styles["date-segment--year"]);
+	const handleGroupBlur = () => {
+		setTimeout(() => {
+			if (!inputRefs.some((ref) => ref.current && ref.current === document.activeElement)) onBlur?.(combinedValue);
+		}, 0);
+	};
+	const handleGroupClick = () => {
+		if (ddRef.current && document.activeElement !== ddRef.current && mmRef.current && document.activeElement !== mmRef.current && yyyyRef.current && document.activeElement !== yyyyRef.current && document.activeElement !== clearButtonRef.current) if (dd === "") ddRef.current.focus();
+		else if (mm === "") mmRef.current.focus();
+		else yyyyRef.current.focus();
+	};
+	const handleClear = () => {
+		setDd("");
+		setMm("");
+		setYyyy("");
+		setErrorTextDd("");
+		setErrorTextMm("");
+		setErrorTextYyyy("");
+		if (onChange) onChange("");
+		ddRef.current?.focus();
+	};
+	const moveFocusLeft = () => {
+		const activeElement$1 = document.activeElement;
+		if (!activeElement$1) return;
+		if (mmRef.current === activeElement$1) {
+			if (activeElement$1.selectionStart === 0 && activeElement$1.selectionEnd === 0) setTimeout(() => {
+				ddRef.current?.focus();
+			}, 0);
+		} else if (yyyyRef.current === activeElement$1) {
+			if (activeElement$1.selectionStart === 0 && activeElement$1.selectionEnd === 0) setTimeout(() => {
+				mmRef.current?.focus();
+			}, 0);
+		}
+	};
+	const moveFocusRight = () => {
+		const activeElement$1 = document.activeElement;
+		if (!activeElement$1) return;
+		if (mmRef.current === activeElement$1) {
+			if (activeElement$1.selectionStart === activeElement$1.value.length && activeElement$1.selectionEnd === activeElement$1.value.length) setTimeout(() => {
+				yyyyRef.current?.focus();
+			}, 0);
+		} else if (ddRef.current === activeElement$1) {
+			if (activeElement$1.selectionStart === activeElement$1.value.length && activeElement$1.selectionEnd === activeElement$1.value.length) setTimeout(() => {
+				mmRef.current?.focus();
+			}, 0);
+		}
+	};
+	const moveFocusOnBackspaceInEmptyField = () => {
+		if (yyyyRef.current === document.activeElement && yyyy === "") setTimeout(() => {
+			mmRef.current?.focus();
+		}, 0);
+		else if (mmRef.current === document.activeElement && mm === "") setTimeout(() => {
+			ddRef.current?.focus();
+		}, 0);
+	};
+	useKeyboardEvent(yyyyRef, moveFocusOnBackspaceInEmptyField, [KeyboardEventKey.Backspace]);
+	useKeyboardEvent(mmRef, moveFocusOnBackspaceInEmptyField, [KeyboardEventKey.Backspace]);
+	useKeyboardEvent(mmRef, moveFocusLeft, [KeyboardEventKey.ArrowLeft]);
+	useKeyboardEvent(yyyyRef, moveFocusLeft, [KeyboardEventKey.ArrowLeft]);
+	useKeyboardEvent(ddRef, moveFocusRight, [KeyboardEventKey.ArrowRight]);
+	useKeyboardEvent(mmRef, moveFocusRight, [KeyboardEventKey.ArrowRight]);
+	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs("div", {
+		role: "group",
+		className: classNames(styles["date-picker"], {
+			[styles["date-picker--with-clear-button"]]: withClearButton,
+			[styles["date-picker--clear-button-focused"]]: isClearButtonFocused
+		}),
+		id: inputId,
+		"aria-labelledby": ariaLabelledBy ?? legendId,
+		"aria-describedby": ariaDescribedBy,
+		onBlurCapture: handleGroupBlur,
+		onClickCapture: handleGroupClick,
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: styles["date-picker__inputs"],
+			children: [
+				/* @__PURE__ */ jsx("input", {
+					ref: ddRef,
+					type: "text",
+					enterKeyHint: "next",
+					inputMode: "numeric",
+					pattern: "[0-9]*",
+					maxLength: 2,
+					value: dd,
+					onChange: handleDdChange,
+					onBlur: handleBlurOnSegment,
+					placeholder: resources?.dayFormatPlaceholder || "dd",
+					"aria-label": resources?.ariaLabelInputDay || "Dag",
+					className: daySegmentClassNames
+				}),
+				/* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					children: "."
+				}),
+				/* @__PURE__ */ jsx("input", {
+					ref: mmRef,
+					type: "text",
+					enterKeyHint: "next",
+					inputMode: "numeric",
+					pattern: "[0-9]*",
+					maxLength: 2,
+					value: mm,
+					onChange: handleMmChange,
+					onBlur: handleBlurOnSegment,
+					placeholder: resources?.monthFormatPlaceholder || "mm",
+					"aria-label": resources?.ariaLabelInputMonth || "Måned",
+					className: monthSegmentClassNames
+				}),
+				/* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					children: "."
+				}),
+				/* @__PURE__ */ jsx("input", {
+					ref: yyyyRef,
+					type: "text",
+					enterKeyHint: "next",
+					inputMode: "numeric",
+					pattern: "[0-9]*",
+					maxLength: 4,
+					value: yyyy,
+					onChange: handleYyyyChange,
+					onBlur: handleBlurOnSegment,
+					placeholder: resources?.yearFormatPlaceholder || "åååå",
+					"aria-label": resources?.ariaLabelInputYear || "År",
+					className: yearSegmentClassNames
+				})
+			]
+		}), withClearButton && (hasValue ? /* @__PURE__ */ jsx("button", {
+			type: "button",
+			onClick: handleClear,
+			onFocus: () => setIsClearButtonFocused(true),
+			onBlur: () => setIsClearButtonFocused(false),
+			ref: clearButtonRef,
+			className: styles["clear-button"],
+			"aria-label": resources?.clearButtonAriaLabel || "Nullstill dato",
+			children: /* @__PURE__ */ jsx(Icon, {
+				svgIcon: X,
+				size: IconSize.XXSmall
+			})
+		}) : /* @__PURE__ */ jsx("div", { className: styles["clear-button__placeholder"] }))]
+	}) });
+};
+DateInputInternal.displayName = "DateInputInternal";
+var DateInputInternal_default = DateInputInternal;
+var Unsafe_DatePicker = ({ value, onChange, onBlur, label, id, errorText, withClearButton = true, ["aria-describedby"]: ariaDescribedBy, ["aria-labelledby"]: ariaLabelledBy, resources, ...baseDayPickerProps }) => {
+	const dateToString = (date) => {
+		if (!isValid(date) || !date) return "";
+		return format(date, "P", { locale: nb });
+	};
+	const [dateString, setDateString] = useState(dateToString(value) || "");
+	const [dateDate, setDateDate] = useState(value || void 0);
+	const [softErrorText, setSoftErrorText] = useState("");
+	const containerRef = useRef(null);
+	const calendarButtonRef = useRef(null);
+	const internalChangeRef = useRef(false);
+	useEffect(() => {
+		if (!internalChangeRef.current) {
+			setDateString(dateToString(value) || "");
+			setDateDate(value || void 0);
+		}
+		internalChangeRef.current = false;
+	}, [value]);
+	const { language } = useLanguage(LanguageLocales.NORWEGIAN);
+	const mergedResources = {
+		...getResources(language),
+		...resources
+	};
+	const { value: isPopupOpen, toggleValue: toggleIsPopupOpen } = useToggle(false);
+	const { refs, floatingStyles, context, middlewareData } = useFloating({
+		placement: "bottom-start",
+		middleware: [offset(8), shift({
+			mainAxis: false,
+			padding: 8
+		})],
+		whileElementsMounted: autoUpdate,
+		elements: { reference: containerRef.current }
+	});
+	const dayPickerPopupRef = useRef(null);
+	const { getFloatingProps } = useInteractions([useClick(context), useDismiss(context)]);
+	const isVisible = isPopupOpen && !middlewareData.hide?.referenceHidden;
+	const setFocusToCalendarButton = () => {
+		calendarButtonRef.current?.focus();
+	};
+	const handleDayPickerSelect = (date) => {
+		internalChangeRef.current = true;
+		if (!date) {
+			setDateString("");
+			setDateDate(void 0);
+			if (onChange) onChange(void 0);
+		} else {
+			setDateDate(date);
+			setDateString(format(date, "P", { locale: nb }));
+			if (onChange) onChange(date);
+			if (isPopupOpen) toggleIsPopupOpen();
+			setFocusToCalendarButton();
+		}
+	};
+	const handleEscapeKeyDown = () => {
+		if (isPopupOpen) {
+			toggleIsPopupOpen();
+			setFocusToCalendarButton();
+		}
+	};
+	useKeyboardEvent(dayPickerPopupRef, handleEscapeKeyDown, [KeyboardEventKey.Escape]);
+	useKeyboardEvent(calendarButtonRef, handleEscapeKeyDown, [KeyboardEventKey.Escape]);
+	useOutsideEvent([calendarButtonRef, dayPickerPopupRef], (e) => {
+		if (calendarButtonRef.current && dayPickerPopupRef.current && !e?.composedPath().includes(calendarButtonRef.current) && !e?.composedPath().includes(dayPickerPopupRef.current)) {
+			if (isPopupOpen) toggleIsPopupOpen();
+		}
+	}, [
+		"mousedown",
+		"focusin",
+		"blur"
+	]);
+	const handleInputChange = (date) => {
+		internalChangeRef.current = true;
+		setDateString(date);
+		const parsedDate = parse(date, "P", /* @__PURE__ */ new Date(), { locale: nb });
+		if (isValid(parsedDate)) {
+			setDateDate(parsedDate);
+			if (onChange) onChange(parsedDate);
+		} else {
+			setDateDate(void 0);
+			if (onChange) onChange(void 0);
+		}
+	};
+	const handleBlur = (date) => {
+		const parsedDate = parse(date, "P", /* @__PURE__ */ new Date(), { locale: nb });
+		if (isValid(parsedDate)) {
+			if (onBlur) onBlur(parsedDate);
+		} else if (onBlur) onBlur(void 0);
+	};
+	const labelGivenAsPropIsValidLabelComponent = isComponent(label, Label);
+	const legend = label && labelGivenAsPropIsValidLabelComponent ? cloneElement(label, {
+		htmlMarkup: "legend",
+		labelId: label.props.labelId || "date-legend"
+	}) : null;
+	const legendId = labelGivenAsPropIsValidLabelComponent && label.props.labelId ? label.props.labelId : "date-legend";
+	const popupId = isPopupOpen ? "calendar-popup" : void 0;
+	return /* @__PURE__ */ jsxs(ErrorWrapper, {
+		errorText,
+		children: [/* @__PURE__ */ jsxs("fieldset", {
+			className: styles["date-field"],
+			"aria-labelledby": legendId,
+			children: [
+				legend,
+				/* @__PURE__ */ jsxs("div", {
+					ref: containerRef,
+					children: [/* @__PURE__ */ jsx(DateInputInternal_default, {
+						inputId: id,
+						"aria-describedby": ariaDescribedBy,
+						"aria-labelledby": ariaLabelledBy,
+						value: dateString,
+						onChange: handleInputChange,
+						onBlur: handleBlur,
+						legendId,
+						setErrorText: setSoftErrorText,
+						withClearButton,
+						resources: mergedResources
+					}), /* @__PURE__ */ jsx("button", {
+						type: "button",
+						ref: calendarButtonRef,
+						onClick: toggleIsPopupOpen,
+						"aria-label": mergedResources.calendarButtonAriaLabel,
+						"aria-controls": popupId,
+						"aria-expanded": isPopupOpen,
+						className: styles["calendar-button"],
+						children: /* @__PURE__ */ jsx(Icon, {
+							svgIcon: Calendar,
+							size: IconSize$1.XSmall
+						})
+					})]
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: styles["date-field__soft-error-text"],
+					role: "status",
+					children: softErrorText
+				})
+			]
+		}), isPopupOpen && /* @__PURE__ */ jsx(FloatingFocusManager, {
+			context,
+			modal: false,
+			children: /* @__PURE__ */ jsx("div", {
+				id: popupId,
+				ref: mergeRefs([refs.setFloating, dayPickerPopupRef]),
+				style: {
+					...floatingStyles,
+					visibility: isVisible ? "visible" : "hidden",
+					zIndex: 1e4
+				},
+				...getFloatingProps(),
+				children: /* @__PURE__ */ jsx(BaseDayPicker_default, {
+					...baseDayPickerProps,
+					resources: mergedResources,
+					selectedDate: dateDate,
+					onDateChange: handleDayPickerSelect
+				})
+			})
+		})]
+	});
+};
+Unsafe_DatePicker.displayName = "DateInput";
+var Unsafe_DatePicker_default = Unsafe_DatePicker;
+var toTimeString = (date) => {
+	if (!date || !isValid(date)) return;
+	return `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;
+};
+var mergeDateAndTime = (date, time) => {
+	if (!date || !isValid(date)) return;
+	const merged = new Date(date);
+	if (!time) {
+		merged.setHours(0, 0, 0, 0);
+		return merged;
+	}
+	const [hoursStr, minutesStr] = time.split(":");
+	const hours = parseInt(hoursStr, 10);
+	const minutes = parseInt(minutesStr, 10);
+	if (isNaN(hours) || isNaN(minutes)) {
+		merged.setHours(0, 0, 0, 0);
+		return merged;
+	}
+	merged.setHours(hours, minutes, 0, 0);
+	return merged;
+};
+var Unsafe_DateAndTime = ({ value, onChange, legend, errorText, datepickerProps, timeInputProps }) => {
+	const internalDate = value;
+	const hasMeaningfulTime = (date) => {
+		if (!date) return false;
+		return date.getHours() !== 0 || date.getMinutes() !== 0;
+	};
+	const [internalTime, setInternalTime] = useState(hasMeaningfulTime(value) ? toTimeString(value) : void 0);
+	const isTypingTimeRef = useRef(false);
+	const hasUserTimeRef = useRef(hasMeaningfulTime(value));
+	useEffect(() => {
+		if (!isTypingTimeRef.current && hasUserTimeRef.current) {
+			const newTimeString = toTimeString(value);
+			if (hasMeaningfulTime(value)) setInternalTime(newTimeString);
+		}
+		isTypingTimeRef.current = false;
+	}, [value]);
+	const handleDateChange = (newDate) => {
+		const merged = mergeDateAndTime(newDate, internalTime);
+		onChange?.(merged);
+	};
+	const handleTimeChange = (newTime) => {
+		hasUserTimeRef.current = !!newTime;
+		isTypingTimeRef.current = true;
+		setInternalTime(newTime);
+		const merged = mergeDateAndTime(value, newTime);
+		onChange?.(merged);
+	};
+	return /* @__PURE__ */ jsx(ErrorWrapper, {
+		errorText,
+		children: /* @__PURE__ */ jsxs("fieldset", {
+			className: styles$1["date-and-time--fieldset"],
+			children: [legend, /* @__PURE__ */ jsxs("div", {
+				className: styles$1["date-and-time__fields"],
+				children: [/* @__PURE__ */ jsx(Unsafe_DatePicker_default, {
+					...datepickerProps,
+					value: internalDate,
+					onChange: handleDateChange
+				}), /* @__PURE__ */ jsx(Unsafe_TimeInput_default, {
+					...timeInputProps,
+					value: internalTime,
+					onChange: handleTimeChange
+				})]
+			})]
+		})
+	});
+};
+var Unsafe_DateAndTime_default = Unsafe_DateAndTime;
+var Unsafe_ISODatePicker = ({ value, onChange, ...baseDateInputProps }) => {
+	const [internalDate, setInternalDate] = useState(value ? new Date(value) : void 0);
+	const dateToIso = (date) => {
+		if (!isValid(date) || !date) return "";
+		return formatISO(date, { representation: "date" });
+	};
+	const isoToDate = (iso) => {
+		const date = new Date(iso);
+		if (!isValid(date)) return;
+		return date;
+	};
+	useEffect(() => {
+		if (value) setInternalDate(isoToDate(value));
+		else setInternalDate(void 0);
+	}, [value]);
+	useEffect(() => {
+		if (!internalDate) {
+			onChange?.("");
+			return;
+		}
+		const iso = dateToIso(internalDate);
+		onChange?.(iso);
+	}, [internalDate]);
+	return /* @__PURE__ */ jsx(Unsafe_DatePicker_default, {
+		...baseDateInputProps,
+		value: internalDate,
+		onChange: setInternalDate
+	});
+};
+var Unsafe_ISODatePicker_default = Unsafe_ISODatePicker;
+var Unsafe_DatePicker_default$1 = Unsafe_DatePicker_default;
+export { Unsafe_DateAndTime_default as Unsafe_DateAndTime, Unsafe_DatePicker_default as Unsafe_DatePicker, BaseDayPicker_default as Unsafe_DatePickerStandalone, Unsafe_ISODatePicker_default as Unsafe_ISODatePicker, Unsafe_TimeInput_default as Unsafe_TimeInput, Unsafe_DatePicker_default$1 as default };
+
+//# sourceMappingURL=index.js.map