`, so it can be styled via any CSS solution you prefer.
* @see https://floating-ui.com/docs/FloatingOverlay
*/ const $56b436271f6666d1$export$a35954495955337b = /*#__PURE__*/ $63SH6.forwardRef(function FloatingOverlay(_ref, ref) {
let { lockScroll: lockScroll = false, ...rest } = _ref;
const lockId = $56b436271f6666d1$export$f680877a34711e37();
$56b436271f6666d1$var$index(()=>{
if (!lockScroll) return;
$56b436271f6666d1$var$activeLocks.add(lockId);
const isIOS = /iP(hone|ad|od)|iOS/.test((0, $d8YHU.getPlatform)());
const bodyStyle = document.body.style;
// RTL scrollbar
const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;
const paddingProp = scrollbarX ? "paddingLeft" : "paddingRight";
const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.pageXOffset;
const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.pageYOffset;
bodyStyle.overflow = "hidden";
if (scrollbarWidth) bodyStyle[paddingProp] = scrollbarWidth + "px";
// Only iOS doesn't respect `overflow: hidden` on document.body, and this
// technique has fewer side effects.
if (isIOS) {
var _window$visualViewpor, _window$visualViewpor2;
// iOS 12 does not support `visualViewport`.
const offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;
const offsetTop = ((_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetTop) || 0;
Object.assign(bodyStyle, {
position: "fixed",
top: -(scrollY - Math.floor(offsetTop)) + "px",
left: -(scrollX - Math.floor(offsetLeft)) + "px",
right: "0"
});
}
return ()=>{
$56b436271f6666d1$var$activeLocks.delete(lockId);
if ($56b436271f6666d1$var$activeLocks.size === 0) {
Object.assign(bodyStyle, {
overflow: "",
[paddingProp]: ""
});
if (isIOS) {
Object.assign(bodyStyle, {
position: "",
top: "",
left: "",
right: ""
});
window.scrollTo(scrollX, scrollY);
}
}
};
}, [
lockId,
lockScroll
]);
return /*#__PURE__*/ $63SH6.createElement("div", $56b436271f6666d1$var$_extends({
ref: ref
}, rest, {
style: {
position: "fixed",
overflow: "auto",
top: 0,
right: 0,
bottom: 0,
left: 0,
...rest.style
}
}));
});
function $56b436271f6666d1$var$isButtonTarget(event) {
return (0, $8Xnp2.isHTMLElement)(event.target) && event.target.tagName === "BUTTON";
}
function $56b436271f6666d1$var$isSpaceIgnored(element) {
return (0, $d8YHU.isTypeableElement)(element);
}
/**
* Opens or closes the floating element when clicking the reference element.
* @see https://floating-ui.com/docs/useClick
*/ function $56b436271f6666d1$export$98524f11226063fc(context, props) {
if (props === void 0) props = {};
const { open: open, onOpenChange: onOpenChange, dataRef: dataRef, elements: { domReference: domReference } } = context;
const { enabled: enabled = true, event: eventOption = "click", toggle: toggle = true, ignoreMouse: ignoreMouse = false, keyboardHandlers: keyboardHandlers = true } = props;
const pointerTypeRef = $63SH6.useRef();
const didKeyDownRef = $63SH6.useRef(false);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
return {
reference: {
onPointerDown (event) {
pointerTypeRef.current = event.pointerType;
},
onMouseDown (event) {
// Ignore all buttons except for the "main" button.
// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
if (event.button !== 0) return;
if ((0, $d8YHU.isMouseLikePointerType)(pointerTypeRef.current, true) && ignoreMouse) return;
if (eventOption === "click") return;
if (open && toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === "mousedown" : true)) onOpenChange(false, event.nativeEvent);
else {
// Prevent stealing focus from the floating element
event.preventDefault();
onOpenChange(true, event.nativeEvent);
}
},
onClick (event) {
if (eventOption === "mousedown" && pointerTypeRef.current) {
pointerTypeRef.current = undefined;
return;
}
if ((0, $d8YHU.isMouseLikePointerType)(pointerTypeRef.current, true) && ignoreMouse) return;
if (open && toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === "click" : true)) onOpenChange(false, event.nativeEvent);
else onOpenChange(true, event.nativeEvent);
},
onKeyDown (event) {
pointerTypeRef.current = undefined;
if (event.defaultPrevented || !keyboardHandlers || $56b436271f6666d1$var$isButtonTarget(event)) return;
if (event.key === " " && !$56b436271f6666d1$var$isSpaceIgnored(domReference)) {
// Prevent scrolling
event.preventDefault();
didKeyDownRef.current = true;
}
if (event.key === "Enter") {
if (open && toggle) onOpenChange(false, event.nativeEvent);
else onOpenChange(true, event.nativeEvent);
}
},
onKeyUp (event) {
if (event.defaultPrevented || !keyboardHandlers || $56b436271f6666d1$var$isButtonTarget(event) || $56b436271f6666d1$var$isSpaceIgnored(domReference)) return;
if (event.key === " " && didKeyDownRef.current) {
didKeyDownRef.current = false;
if (open && toggle) onOpenChange(false, event.nativeEvent);
else onOpenChange(true, event.nativeEvent);
}
}
}
};
}, [
enabled,
dataRef,
eventOption,
ignoreMouse,
keyboardHandlers,
domReference,
toggle,
open,
onOpenChange
]);
}
function $56b436271f6666d1$var$createVirtualElement(domRef, data) {
let offsetX = null;
let offsetY = null;
let isAutoUpdateEvent = false;
return {
contextElement: domRef.current || undefined,
getBoundingClientRect () {
var _domRef$current, _data$dataRef$current;
const domRect = ((_domRef$current = domRef.current) == null ? void 0 : _domRef$current.getBoundingClientRect()) || {
width: 0,
height: 0,
x: 0,
y: 0
};
const isXAxis = data.axis === "x" || data.axis === "both";
const isYAxis = data.axis === "y" || data.axis === "both";
const canTrackCursorOnAutoUpdate = [
"mouseenter",
"mousemove"
].includes(((_data$dataRef$current = data.dataRef.current.openEvent) == null ? void 0 : _data$dataRef$current.type) || "") && data.pointerType !== "touch";
let width = domRect.width;
let height = domRect.height;
let x = domRect.x;
let y = domRect.y;
if (offsetX == null && data.x && isXAxis) offsetX = domRect.x - data.x;
if (offsetY == null && data.y && isYAxis) offsetY = domRect.y - data.y;
x -= offsetX || 0;
y -= offsetY || 0;
width = 0;
height = 0;
if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {
width = data.axis === "y" ? domRect.width : 0;
height = data.axis === "x" ? domRect.height : 0;
x = isXAxis && data.x != null ? data.x : x;
y = isYAxis && data.y != null ? data.y : y;
} else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {
height = data.axis === "x" ? domRect.height : height;
width = data.axis === "y" ? domRect.width : width;
}
isAutoUpdateEvent = true;
return {
width: width,
height: height,
x: x,
y: y,
top: y,
right: x + width,
bottom: y + height,
left: x
};
}
};
}
function $56b436271f6666d1$var$isMouseBasedEvent(event) {
return event != null && event.clientX != null;
}
/**
* Positions the floating element relative to a client point (in the viewport),
* such as the mouse position. By default, it follows the mouse cursor.
* @see https://floating-ui.com/docs/useClientPoint
*/ function $56b436271f6666d1$export$7fe170a73a621816(context, props) {
if (props === void 0) props = {};
const { open: open, refs: refs, dataRef: dataRef, elements: { floating: floating } } = context;
const { enabled: enabled = true, axis: axis = "both", x: x = null, y: y = null } = props;
const initialRef = $63SH6.useRef(false);
const cleanupListenerRef = $63SH6.useRef(null);
const [pointerType, setPointerType] = $63SH6.useState();
const [reactive, setReactive] = $63SH6.useState([]);
const setReference = $56b436271f6666d1$var$useEffectEvent((x, y)=>{
if (initialRef.current) return;
// Prevent setting if the open event was not a mouse-like one
// (e.g. focus to open, then hover over the reference element).
// Only apply if the event exists.
if (dataRef.current.openEvent && !$56b436271f6666d1$var$isMouseBasedEvent(dataRef.current.openEvent)) return;
refs.setPositionReference($56b436271f6666d1$var$createVirtualElement(refs.domReference, {
x: x,
y: y,
axis: axis,
dataRef: dataRef,
pointerType: pointerType
}));
});
const handleReferenceEnterOrMove = $56b436271f6666d1$var$useEffectEvent((event)=>{
if (x != null || y != null) return;
if (!open) setReference(event.clientX, event.clientY);
else if (!cleanupListenerRef.current) // If there's no cleanup, there's no listener, but we want to ensure
// we add the listener if the cursor landed on the floating element and
// then back on the reference (i.e. it's interactive).
setReactive([]);
});
// If the pointer is a mouse-like pointer, we want to continue following the
// mouse even if the floating element is transitioning out. On touch
// devices, this is undesirable because the floating element will move to
// the dismissal touch point.
const openCheck = (0, $d8YHU.isMouseLikePointerType)(pointerType) ? floating : open;
const addListener = $63SH6.useCallback(()=>{
// Explicitly specified `x`/`y` coordinates shouldn't add a listener.
if (!openCheck || !enabled || x != null || y != null) return;
const win = (0, $8Xnp2.getWindow)(refs.floating.current);
function handleMouseMove(event) {
const target = (0, $d8YHU.getTarget)(event);
if (!(0, $d8YHU.contains)(refs.floating.current, target)) setReference(event.clientX, event.clientY);
else {
win.removeEventListener("mousemove", handleMouseMove);
cleanupListenerRef.current = null;
}
}
if (!dataRef.current.openEvent || $56b436271f6666d1$var$isMouseBasedEvent(dataRef.current.openEvent)) {
win.addEventListener("mousemove", handleMouseMove);
const cleanup = ()=>{
win.removeEventListener("mousemove", handleMouseMove);
cleanupListenerRef.current = null;
};
cleanupListenerRef.current = cleanup;
return cleanup;
}
refs.setPositionReference(refs.domReference.current);
}, [
dataRef,
enabled,
openCheck,
refs,
setReference,
x,
y
]);
$63SH6.useEffect(()=>{
return addListener();
}, [
addListener,
reactive
]);
$63SH6.useEffect(()=>{
if (enabled && !floating) initialRef.current = false;
}, [
enabled,
floating
]);
$63SH6.useEffect(()=>{
if (!enabled && open) initialRef.current = true;
}, [
enabled,
open
]);
$56b436271f6666d1$var$index(()=>{
if (enabled && (x != null || y != null)) {
initialRef.current = false;
setReference(x, y);
}
}, [
enabled,
x,
y,
setReference
]);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
function setPointerTypeRef(_ref) {
let { pointerType: pointerType } = _ref;
setPointerType(pointerType);
}
return {
reference: {
onPointerDown: setPointerTypeRef,
onPointerEnter: setPointerTypeRef,
onMouseMove: handleReferenceEnterOrMove,
onMouseEnter: handleReferenceEnterOrMove
}
};
}, [
enabled,
handleReferenceEnterOrMove
]);
}
const $56b436271f6666d1$var$bubbleHandlerKeys = {
pointerdown: "onPointerDown",
mousedown: "onMouseDown",
click: "onClick"
};
const $56b436271f6666d1$var$captureHandlerKeys = {
pointerdown: "onPointerDownCapture",
mousedown: "onMouseDownCapture",
click: "onClickCapture"
};
const $56b436271f6666d1$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
};
};
/**
* Closes the floating element when a dismissal is requested — by default, when
* the user presses the `escape` key or outside of the floating element.
* @see https://floating-ui.com/docs/useDismiss
*/ function $56b436271f6666d1$export$fcdf1ba5fafc089b(context, props) {
if (props === void 0) props = {};
const { open: open, onOpenChange: onOpenChange, events: events, nodeId: nodeId, elements: { reference: reference, domReference: domReference, floating: floating }, dataRef: dataRef } = context;
const { enabled: enabled = true, escapeKey: escapeKey = true, outsidePress: unstable_outsidePress = true, outsidePressEvent: outsidePressEvent = "pointerdown", referencePress: referencePress = false, referencePressEvent: referencePressEvent = "pointerdown", ancestorScroll: ancestorScroll = false, bubbles: bubbles, capture: capture } = props;
const tree = $56b436271f6666d1$export$db0c2a7c7a2a4f69();
const nested = $56b436271f6666d1$export$165209eae06d3488() != null;
const outsidePressFn = $56b436271f6666d1$var$useEffectEvent(typeof unstable_outsidePress === "function" ? unstable_outsidePress : ()=>false);
const outsidePress = typeof unstable_outsidePress === "function" ? outsidePressFn : unstable_outsidePress;
const insideReactTreeRef = $63SH6.useRef(false);
const endedOrStartedInsideRef = $63SH6.useRef(false);
const { escapeKey: escapeKeyBubbles, outsidePress: outsidePressBubbles } = $56b436271f6666d1$var$normalizeProp(bubbles);
const { escapeKey: escapeKeyCapture, outsidePress: outsidePressCapture } = $56b436271f6666d1$var$normalizeProp(capture);
const closeOnEscapeKeyDown = $56b436271f6666d1$var$useEffectEvent((event)=>{
if (!open || !enabled || !escapeKey || event.key !== "Escape") return;
const children = tree ? $56b436271f6666d1$var$getChildren(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;
}
}
events.emit("dismiss", {
type: "escapeKey",
data: {
returnFocus: {
preventScroll: false
}
}
});
onOpenChange(false, (0, $d8YHU.isReactEvent)(event) ? event.nativeEvent : event);
});
const closeOnEscapeKeyDownCapture = $56b436271f6666d1$var$useEffectEvent((event)=>{
var _getTarget2;
const callback = ()=>{
var _getTarget;
closeOnEscapeKeyDown(event);
(_getTarget = (0, $d8YHU.getTarget)(event)) == null || _getTarget.removeEventListener("keydown", callback);
};
(_getTarget2 = (0, $d8YHU.getTarget)(event)) == null || _getTarget2.addEventListener("keydown", callback);
});
const closeOnPressOutside = $56b436271f6666d1$var$useEffectEvent((event)=>{
// Given developers can stop the propagation of the synthetic event,
// we can only be confident with a positive value.
const insideReactTree = insideReactTreeRef.current;
insideReactTreeRef.current = false;
// When click outside is lazy (`click` event), handle dragging.
// Don't close if:
// - The click started inside the floating element.
// - The click ended inside the floating element.
const endedOrStartedInside = endedOrStartedInsideRef.current;
endedOrStartedInsideRef.current = false;
if (outsidePressEvent === "click" && endedOrStartedInside) return;
if (insideReactTree) return;
if (typeof outsidePress === "function" && !outsidePress(event)) return;
const target = (0, $d8YHU.getTarget)(event);
const inertSelector = "[" + $56b436271f6666d1$var$createAttribute("inert") + "]";
const markers = (0, $d8YHU.getDocument)(floating).querySelectorAll(inertSelector);
let targetRootAncestor = (0, $8Xnp2.isElement)(target) ? target : null;
while(targetRootAncestor && !(0, $8Xnp2.isLastTraversableNode)(targetRootAncestor)){
const nextParent = (0, $8Xnp2.getParentNode)(targetRootAncestor);
if (nextParent === (0, $d8YHU.getDocument)(floating).body || !(0, $8Xnp2.isElement)(nextParent)) break;
else targetRootAncestor = nextParent;
}
// Check if the click occurred on a third-party element injected after the
// floating element rendered.
if (markers.length && (0, $8Xnp2.isElement)(target) && !(0, $d8YHU.isRootElement)(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
!(0, $d8YHU.contains)(target, floating) && // If the target root element contains none of the markers, then the
// element was injected after the floating element rendered.
Array.from(markers).every((marker)=>!(0, $d8YHU.contains)(targetRootAncestor, marker))) return;
// Check if the click occurred on the scrollbar
if ((0, $8Xnp2.isHTMLElement)(target) && floating) {
// In Firefox, `target.scrollWidth > target.clientWidth` for inline
// elements.
const canScrollX = target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
const canScrollY = target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
let xCond = canScrollY && event.offsetX > target.clientWidth;
// In some browsers it is possible to change the (or window)
// scrollbar to the left side, but is very rare and is difficult to
// check for. Plus, for modal dialogs with backdrops, it is more
// important that the backdrop is checked but not so much the window.
if (canScrollY) {
const isRTL = (0, $8Xnp2.getComputedStyle)(target).direction === "rtl";
if (isRTL) xCond = event.offsetX <= target.offsetWidth - target.clientWidth;
}
if (xCond || canScrollX && event.offsetY > target.clientHeight) return;
}
const targetIsInsideChildren = tree && $56b436271f6666d1$var$getChildren(tree.nodesRef.current, nodeId).some((node)=>{
var _node$context;
return (0, $d8YHU.isEventTargetWithin)(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);
});
if ((0, $d8YHU.isEventTargetWithin)(event, floating) || (0, $d8YHU.isEventTargetWithin)(event, domReference) || targetIsInsideChildren) return;
const children = tree ? $56b436271f6666d1$var$getChildren(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;
}
events.emit("dismiss", {
type: "outsidePress",
data: {
returnFocus: nested ? {
preventScroll: true
} : (0, $d8YHU.isVirtualClick)(event) || (0, $d8YHU.isVirtualPointerEvent)(event)
}
});
onOpenChange(false, event);
});
const closeOnPressOutsideCapture = $56b436271f6666d1$var$useEffectEvent((event)=>{
var _getTarget4;
const callback = ()=>{
var _getTarget3;
closeOnPressOutside(event);
(_getTarget3 = (0, $d8YHU.getTarget)(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);
};
(_getTarget4 = (0, $d8YHU.getTarget)(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);
});
$63SH6.useEffect(()=>{
if (!open || !enabled) return;
dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
dataRef.current.__outsidePressBubbles = outsidePressBubbles;
function onScroll(event) {
onOpenChange(false, event);
}
const doc = (0, $d8YHU.getDocument)(floating);
escapeKey && doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
let ancestors = [];
if (ancestorScroll) {
if ((0, $8Xnp2.isElement)(domReference)) ancestors = (0, $8Xnp2.getOverflowAncestors)(domReference);
if ((0, $8Xnp2.isElement)(floating)) ancestors = ancestors.concat((0, $8Xnp2.getOverflowAncestors)(floating));
if (!(0, $8Xnp2.isElement)(reference) && reference && reference.contextElement) ancestors = ancestors.concat((0, $8Xnp2.getOverflowAncestors)(reference.contextElement));
}
// Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)
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 ()=>{
escapeKey && doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
ancestors.forEach((ancestor)=>{
ancestor.removeEventListener("scroll", onScroll);
});
};
}, [
dataRef,
floating,
domReference,
reference,
escapeKey,
outsidePress,
outsidePressEvent,
open,
onOpenChange,
ancestorScroll,
enabled,
escapeKeyBubbles,
outsidePressBubbles,
closeOnEscapeKeyDown,
escapeKeyCapture,
closeOnEscapeKeyDownCapture,
closeOnPressOutside,
outsidePressCapture,
closeOnPressOutsideCapture
]);
$63SH6.useEffect(()=>{
insideReactTreeRef.current = false;
}, [
outsidePress,
outsidePressEvent
]);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
return {
reference: {
onKeyDown: closeOnEscapeKeyDown,
[$56b436271f6666d1$var$bubbleHandlerKeys[referencePressEvent]]: (event)=>{
if (referencePress) {
events.emit("dismiss", {
type: "referencePress",
data: {
returnFocus: false
}
});
onOpenChange(false, event.nativeEvent);
}
}
},
floating: {
onKeyDown: closeOnEscapeKeyDown,
onMouseDown () {
endedOrStartedInsideRef.current = true;
},
onMouseUp () {
endedOrStartedInsideRef.current = true;
},
[$56b436271f6666d1$var$captureHandlerKeys[outsidePressEvent]]: ()=>{
insideReactTreeRef.current = true;
}
}
};
}, [
enabled,
events,
referencePress,
outsidePressEvent,
referencePressEvent,
onOpenChange,
closeOnEscapeKeyDown
]);
}
let $56b436271f6666d1$var$devMessageSet;
/**
* Provides data to position a floating element and context to add interactions.
* @see https://floating-ui.com/docs/react
*/ function $56b436271f6666d1$export$4e02a5c1d08bac65(options) {
var _options$elements2;
if (options === void 0) options = {};
const { open: open = false, onOpenChange: unstable_onOpenChange, nodeId: nodeId } = options;
var _options$elements, _devMessageSet, _devMessageSet2;
const [_domReference, setDomReference] = $63SH6.useState(null);
const domReference = ((_options$elements2 = options.elements) == null ? void 0 : _options$elements2.reference) || _domReference;
const position = (0, $2Dcmu.useFloating)(options);
const tree = $56b436271f6666d1$export$db0c2a7c7a2a4f69();
const onOpenChange = $56b436271f6666d1$var$useEffectEvent((open, event)=>{
if (open) dataRef.current.openEvent = event;
unstable_onOpenChange == null || unstable_onOpenChange(open, event);
});
const domReferenceRef = $63SH6.useRef(null);
const dataRef = $63SH6.useRef({});
const events = $63SH6.useState(()=>$56b436271f6666d1$var$createPubSub())[0];
const floatingId = $56b436271f6666d1$export$f680877a34711e37();
const setPositionReference = $63SH6.useCallback((node)=>{
const positionReference = (0, $8Xnp2.isElement)(node) ? {
getBoundingClientRect: ()=>node.getBoundingClientRect(),
contextElement: node
} : node;
position.refs.setReference(positionReference);
}, [
position.refs
]);
const setReference = $63SH6.useCallback((node)=>{
if ((0, $8Xnp2.isElement)(node) || node === null) {
domReferenceRef.current = node;
setDomReference(node);
}
// Backwards-compatibility for passing a virtual element to `reference`
// after it has set the DOM reference.
if ((0, $8Xnp2.isElement)(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
// `null` to support `positionReference` + an unstable `reference`
// callback ref.
node !== null && !(0, $8Xnp2.isElement)(node)) position.refs.setReference(node);
}, [
position.refs
]);
const refs = $63SH6.useMemo(()=>({
...position.refs,
setReference: setReference,
setPositionReference: setPositionReference,
domReference: domReferenceRef
}), [
position.refs,
setReference,
setPositionReference
]);
const elements = $63SH6.useMemo(()=>({
...position.elements,
domReference: domReference
}), [
position.elements,
domReference
]);
const context = $63SH6.useMemo(()=>({
...position,
refs: refs,
elements: elements,
dataRef: dataRef,
nodeId: nodeId,
floatingId: floatingId,
events: events,
open: open,
onOpenChange: onOpenChange
}), [
position,
nodeId,
floatingId,
events,
open,
onOpenChange,
refs,
elements
]);
$56b436271f6666d1$var$index(()=>{
const node = tree == null ? void 0 : tree.nodesRef.current.find((node)=>node.id === nodeId);
if (node) node.context = context;
});
return $63SH6.useMemo(()=>({
...position,
context: context,
refs: refs,
elements: elements
}), [
position,
refs,
elements,
context
]);
}
/**
* Opens the floating element while the reference element has focus, like CSS
* `:focus`.
* @see https://floating-ui.com/docs/useFocus
*/ function $56b436271f6666d1$export$f8168d8dd8fd66e6(context, props) {
if (props === void 0) props = {};
const { open: open, onOpenChange: onOpenChange, events: events, refs: refs, elements: { floating: floating, domReference: domReference } } = context;
const { enabled: enabled = true, visibleOnly: visibleOnly = true } = props;
const blockFocusRef = $63SH6.useRef(false);
const timeoutRef = $63SH6.useRef();
const keyboardModalityRef = $63SH6.useRef(true);
$63SH6.useEffect(()=>{
if (!enabled) return;
const win = (0, $8Xnp2.getWindow)(domReference);
// If the reference was focused and the user left the tab/window, and the
// floating element was not open, the focus should be blocked when they
// return to the tab/window.
function onBlur() {
if (!open && (0, $8Xnp2.isHTMLElement)(domReference) && domReference === (0, $d8YHU.activeElement)((0, $d8YHU.getDocument)(domReference))) blockFocusRef.current = true;
}
function onKeyDown() {
keyboardModalityRef.current = true;
}
win.addEventListener("blur", onBlur);
win.addEventListener("keydown", onKeyDown, true);
return ()=>{
win.removeEventListener("blur", onBlur);
win.removeEventListener("keydown", onKeyDown, true);
};
}, [
floating,
domReference,
open,
enabled
]);
$63SH6.useEffect(()=>{
if (!enabled) return;
function onDismiss(payload) {
if (payload.type === "referencePress" || payload.type === "escapeKey") blockFocusRef.current = true;
}
events.on("dismiss", onDismiss);
return ()=>{
events.off("dismiss", onDismiss);
};
}, [
events,
enabled
]);
$63SH6.useEffect(()=>{
return ()=>{
clearTimeout(timeoutRef.current);
};
}, []);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
return {
reference: {
onPointerDown (event) {
if ((0, $d8YHU.isVirtualPointerEvent)(event.nativeEvent)) return;
keyboardModalityRef.current = false;
},
onMouseLeave () {
blockFocusRef.current = false;
},
onFocus (event) {
if (blockFocusRef.current) return;
const target = (0, $d8YHU.getTarget)(event.nativeEvent);
if (visibleOnly && (0, $8Xnp2.isElement)(target)) try {
// Mac Safari unreliably matches `:focus-visible` on the reference
// if focus was outside the page initially - use the fallback
// instead.
if ((0, $d8YHU.isSafari)() && (0, $d8YHU.isMac)()) throw Error();
if (!target.matches(":focus-visible")) return;
} catch (e) {
// Old browsers will throw an error when using `:focus-visible`.
if (!keyboardModalityRef.current && !(0, $d8YHU.isTypeableElement)(target)) return;
}
onOpenChange(true, event.nativeEvent);
},
onBlur (event) {
blockFocusRef.current = false;
const relatedTarget = event.relatedTarget;
// Hit the non-modal focus management portal guard. Focus will be
// moved into the floating element immediately after.
const movedToFocusGuard = (0, $8Xnp2.isElement)(relatedTarget) && relatedTarget.hasAttribute($56b436271f6666d1$var$createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
// Wait for the window blur listener to fire.
timeoutRef.current = window.setTimeout(()=>{
const activeEl = (0, $d8YHU.activeElement)(domReference ? domReference.ownerDocument : document);
// Focus left the page, keep it open.
if (!relatedTarget && activeEl === domReference) return;
// When focusing the reference element (e.g. regular click), then
// clicking into the floating element, prevent it from hiding.
// Note: it must be focusable, e.g. `tabindex="-1"`.
if ((0, $d8YHU.contains)(refs.floating.current, relatedTarget) || (0, $d8YHU.contains)(domReference, relatedTarget) || movedToFocusGuard) return;
onOpenChange(false, event.nativeEvent);
});
}
}
};
}, [
enabled,
visibleOnly,
domReference,
refs,
onOpenChange
]);
}
function $56b436271f6666d1$var$mergeProps(userProps, propsList, elementKey) {
const map = new Map();
return {
...elementKey === "floating" && {
tabIndex: -1
},
...userProps,
...propsList.map((value)=>value ? value[elementKey] : null).concat(userProps).reduce((acc, props)=>{
if (!props) return acc;
Object.entries(props).forEach((_ref)=>{
let [key, value] = _ref;
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 !== undefined);
};
}
} else acc[key] = value;
});
return acc;
}, {})
};
}
/**
* Merges an array of interaction hooks' props into prop getters, allowing
* event handler functions to be composed together without overwriting one
* another.
* @see https://floating-ui.com/docs/react#interaction-hooks
*/ function $56b436271f6666d1$export$a519f7794e446ddd(propsList) {
if (propsList === void 0) propsList = [];
// The dependencies are a dynamic array, so we can't use the linter's
// suggestion to add it to the deps array.
const deps = propsList;
const getReferenceProps = $63SH6.useCallback((userProps)=>$56b436271f6666d1$var$mergeProps(userProps, propsList, "reference"), // eslint-disable-next-line react-hooks/exhaustive-deps
deps);
const getFloatingProps = $63SH6.useCallback((userProps)=>$56b436271f6666d1$var$mergeProps(userProps, propsList, "floating"), // eslint-disable-next-line react-hooks/exhaustive-deps
deps);
const getItemProps = $63SH6.useCallback((userProps)=>$56b436271f6666d1$var$mergeProps(userProps, propsList, "item"), // Granularly check for `item` changes, because the `getItemProps` getter
// should be as referentially stable as possible since it may be passed as
// a prop to many components. All `item` key values must therefore be
// memoized.
// eslint-disable-next-line react-hooks/exhaustive-deps
propsList.map((key)=>key == null ? void 0 : key.item));
return $63SH6.useMemo(()=>({
getReferenceProps: getReferenceProps,
getFloatingProps: getFloatingProps,
getItemProps: getItemProps
}), [
getReferenceProps,
getFloatingProps,
getItemProps
]);
}
let $56b436271f6666d1$var$isPreventScrollSupported = false;
function $56b436271f6666d1$var$doSwitch(orientation, vertical, horizontal) {
switch(orientation){
case "vertical":
return vertical;
case "horizontal":
return horizontal;
default:
return vertical || horizontal;
}
}
function $56b436271f6666d1$var$isMainOrientationKey(key, orientation) {
const vertical = key === $56b436271f6666d1$var$ARROW_UP || key === $56b436271f6666d1$var$ARROW_DOWN;
const horizontal = key === $56b436271f6666d1$var$ARROW_LEFT || key === $56b436271f6666d1$var$ARROW_RIGHT;
return $56b436271f6666d1$var$doSwitch(orientation, vertical, horizontal);
}
function $56b436271f6666d1$var$isMainOrientationToEndKey(key, orientation, rtl) {
const vertical = key === $56b436271f6666d1$var$ARROW_DOWN;
const horizontal = rtl ? key === $56b436271f6666d1$var$ARROW_LEFT : key === $56b436271f6666d1$var$ARROW_RIGHT;
return $56b436271f6666d1$var$doSwitch(orientation, vertical, horizontal) || key === "Enter" || key == " " || key === "";
}
function $56b436271f6666d1$var$isCrossOrientationOpenKey(key, orientation, rtl) {
const vertical = rtl ? key === $56b436271f6666d1$var$ARROW_LEFT : key === $56b436271f6666d1$var$ARROW_RIGHT;
const horizontal = key === $56b436271f6666d1$var$ARROW_DOWN;
return $56b436271f6666d1$var$doSwitch(orientation, vertical, horizontal);
}
function $56b436271f6666d1$var$isCrossOrientationCloseKey(key, orientation, rtl) {
const vertical = rtl ? key === $56b436271f6666d1$var$ARROW_RIGHT : key === $56b436271f6666d1$var$ARROW_LEFT;
const horizontal = key === $56b436271f6666d1$var$ARROW_UP;
return $56b436271f6666d1$var$doSwitch(orientation, vertical, horizontal);
}
/**
* Adds arrow key-based navigation of a list of items, either using real DOM
* focus or virtual focus.
* @see https://floating-ui.com/docs/useListNavigation
*/ function $56b436271f6666d1$export$b5d22cac4ad33f40(context, props) {
const { open: open, onOpenChange: onOpenChange, refs: refs, elements: { domReference: domReference, floating: floating } } = context;
const { listRef: listRef, activeIndex: activeIndex, onNavigate: unstable_onNavigate = ()=>{}, enabled: enabled = true, selectedIndex: selectedIndex = null, allowEscape: allowEscape = false, loop: loop = false, nested: nested = false, rtl: rtl = false, virtual: virtual = false, focusItemOnOpen: focusItemOnOpen = "auto", focusItemOnHover: focusItemOnHover = true, openOnArrowKeyDown: openOnArrowKeyDown = true, disabledIndices: disabledIndices, orientation: orientation = "vertical", cols: cols = 1, scrollItemIntoView: scrollItemIntoView = true, virtualItemRef: virtualItemRef } = props;
const parentId = $56b436271f6666d1$export$165209eae06d3488();
const tree = $56b436271f6666d1$export$db0c2a7c7a2a4f69();
const onNavigate = $56b436271f6666d1$var$useEffectEvent(unstable_onNavigate);
const focusItemOnOpenRef = $63SH6.useRef(focusItemOnOpen);
const indexRef = $63SH6.useRef(selectedIndex != null ? selectedIndex : -1);
const keyRef = $63SH6.useRef(null);
const isPointerModalityRef = $63SH6.useRef(true);
const previousOnNavigateRef = $63SH6.useRef(onNavigate);
const previousMountedRef = $63SH6.useRef(!!floating);
const forceSyncFocus = $63SH6.useRef(false);
const forceScrollIntoViewRef = $63SH6.useRef(false);
const disabledIndicesRef = $56b436271f6666d1$var$useLatestRef(disabledIndices);
const latestOpenRef = $56b436271f6666d1$var$useLatestRef(open);
const scrollItemIntoViewRef = $56b436271f6666d1$var$useLatestRef(scrollItemIntoView);
const [activeId, setActiveId] = $63SH6.useState();
const [virtualId, setVirtualId] = $63SH6.useState();
const focusItem = $56b436271f6666d1$var$useEffectEvent(function(listRef, indexRef, forceScrollIntoView) {
if (forceScrollIntoView === void 0) forceScrollIntoView = false;
const item = listRef.current[indexRef.current];
if (!item) return;
if (virtual) {
setActiveId(item.id);
tree == null || tree.events.emit("virtualfocus", item);
if (virtualItemRef) virtualItemRef.current = item;
} else $56b436271f6666d1$var$enqueueFocus(item, {
preventScroll: true,
// Mac Safari does not move the virtual cursor unless the focus call
// is sync. However, for the very first focus call, we need to wait
// for the position to be ready in order to prevent unwanted
// scrolling. This means the virtual cursor will not move to the first
// item when first opening the floating element, but will on
// subsequent calls. `preventScroll` is supported in modern Safari,
// so we can use that instead.
// iOS Safari must be async or the first item will not be focused.
sync: (0, $d8YHU.isMac)() && (0, $d8YHU.isSafari)() ? $56b436271f6666d1$var$isPreventScrollSupported || forceSyncFocus.current : false
});
requestAnimationFrame(()=>{
const scrollIntoViewOptions = scrollItemIntoViewRef.current;
const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current);
if (shouldScrollIntoView) // JSDOM doesn't support `.scrollIntoView()` but it's widely supported
// by all browsers.
item.scrollIntoView == null || item.scrollIntoView(typeof scrollIntoViewOptions === "boolean" ? {
block: "nearest",
inline: "nearest"
} : scrollIntoViewOptions);
});
});
$56b436271f6666d1$var$index(()=>{
document.createElement("div").focus({
get preventScroll () {
$56b436271f6666d1$var$isPreventScrollSupported = true;
return false;
}
});
}, []);
// Sync `selectedIndex` to be the `activeIndex` upon opening the floating
// element. Also, reset `activeIndex` upon closing the floating element.
$56b436271f6666d1$var$index(()=>{
if (!enabled) return;
if (open && floating) {
if (focusItemOnOpenRef.current && selectedIndex != null) {
// Regardless of the pointer modality, we want to ensure the selected
// item comes into view when the floating element is opened.
forceScrollIntoViewRef.current = true;
onNavigate(selectedIndex);
}
} else if (previousMountedRef.current) {
// Since the user can specify `onNavigate` conditionally
// (onNavigate: open ? setActiveIndex : setSelectedIndex),
// we store and call the previous function.
indexRef.current = -1;
previousOnNavigateRef.current(null);
}
}, [
enabled,
open,
floating,
selectedIndex,
onNavigate
]);
// Sync `activeIndex` to be the focused item while the floating element is
// open.
$56b436271f6666d1$var$index(()=>{
if (!enabled) return;
if (open && floating) {
if (activeIndex == null) {
forceSyncFocus.current = false;
if (selectedIndex != null) return;
// Reset while the floating element was open (e.g. the list changed).
if (previousMountedRef.current) {
indexRef.current = -1;
focusItem(listRef, indexRef);
}
// Initial sync.
if (!previousMountedRef.current && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {
let runs = 0;
const waitForListPopulated = ()=>{
if (listRef.current[0] == null) {
// Avoid letting the browser paint if possible on the first try,
// otherwise use rAF. Don't try more than twice, since something
// is wrong otherwise.
if (runs < 2) {
const scheduler = runs ? requestAnimationFrame : queueMicrotask;
scheduler(waitForListPopulated);
}
runs++;
} else {
indexRef.current = keyRef.current == null || $56b436271f6666d1$var$isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? $56b436271f6666d1$var$getMinIndex(listRef, disabledIndicesRef.current) : $56b436271f6666d1$var$getMaxIndex(listRef, disabledIndicesRef.current);
keyRef.current = null;
onNavigate(indexRef.current);
}
};
waitForListPopulated();
}
} else if (!$56b436271f6666d1$var$isIndexOutOfBounds(listRef, activeIndex)) {
indexRef.current = activeIndex;
focusItem(listRef, indexRef, forceScrollIntoViewRef.current);
forceScrollIntoViewRef.current = false;
}
}
}, [
enabled,
open,
floating,
activeIndex,
selectedIndex,
nested,
listRef,
orientation,
rtl,
onNavigate,
focusItem,
disabledIndicesRef
]);
// Ensure the parent floating element has focus when a nested child closes
// to allow arrow key navigation to work after the pointer leaves the child.
$56b436271f6666d1$var$index(()=>{
var _nodes$find, _nodes$find$context;
if (!enabled || floating || !tree || virtual || !previousMountedRef.current) return;
const nodes = tree.nodesRef.current;
const parent = (_nodes$find = nodes.find((node)=>node.id === parentId)) == null ? void 0 : (_nodes$find$context = _nodes$find.context) == null ? void 0 : _nodes$find$context.elements.floating;
const activeEl = (0, $d8YHU.activeElement)((0, $d8YHU.getDocument)(floating));
const treeContainsActiveEl = nodes.some((node)=>node.context && (0, $d8YHU.contains)(node.context.elements.floating, activeEl));
if (parent && !treeContainsActiveEl && isPointerModalityRef.current) parent.focus({
preventScroll: true
});
}, [
enabled,
floating,
tree,
parentId,
virtual
]);
$56b436271f6666d1$var$index(()=>{
if (!enabled || !tree || !virtual || parentId) return;
function handleVirtualFocus(item) {
setVirtualId(item.id);
if (virtualItemRef) virtualItemRef.current = item;
}
tree.events.on("virtualfocus", handleVirtualFocus);
return ()=>{
tree.events.off("virtualfocus", handleVirtualFocus);
};
}, [
enabled,
tree,
virtual,
parentId,
virtualItemRef
]);
$56b436271f6666d1$var$index(()=>{
previousOnNavigateRef.current = onNavigate;
previousMountedRef.current = !!floating;
});
$56b436271f6666d1$var$index(()=>{
if (!open) keyRef.current = null;
}, [
open
]);
const hasActiveIndex = activeIndex != null;
const item = $63SH6.useMemo(()=>{
function syncCurrentTarget(currentTarget) {
if (!open) return;
const index = listRef.current.indexOf(currentTarget);
if (index !== -1) onNavigate(index);
}
const props = {
onFocus (_ref) {
let { currentTarget: currentTarget } = _ref;
syncCurrentTarget(currentTarget);
},
onClick: (_ref2)=>{
let { currentTarget: currentTarget } = _ref2;
return currentTarget.focus({
preventScroll: true
});
},
// Safari
...focusItemOnHover && {
onMouseMove (_ref3) {
let { currentTarget: currentTarget } = _ref3;
syncCurrentTarget(currentTarget);
},
onPointerLeave (_ref4) {
let { pointerType: pointerType } = _ref4;
if (!isPointerModalityRef.current || pointerType === "touch") return;
indexRef.current = -1;
focusItem(listRef, indexRef);
onNavigate(null);
if (!virtual) $56b436271f6666d1$var$enqueueFocus(refs.floating.current, {
preventScroll: true
});
}
}
};
return props;
}, [
open,
refs,
focusItem,
focusItemOnHover,
listRef,
onNavigate,
virtual
]);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
const disabledIndices = disabledIndicesRef.current;
function onKeyDown(event) {
isPointerModalityRef.current = false;
forceSyncFocus.current = true;
// If the floating element is animating out, ignore navigation. Otherwise,
// the `activeIndex` gets set to 0 despite not being open so the next time
// the user ArrowDowns, the first item won't be focused.
if (!latestOpenRef.current && event.currentTarget === refs.floating.current) return;
if (nested && $56b436271f6666d1$var$isCrossOrientationCloseKey(event.key, orientation, rtl)) {
(0, $d8YHU.stopEvent)(event);
onOpenChange(false, event.nativeEvent);
if ((0, $8Xnp2.isHTMLElement)(domReference) && !virtual) domReference.focus();
return;
}
const currentIndex = indexRef.current;
const minIndex = $56b436271f6666d1$var$getMinIndex(listRef, disabledIndices);
const maxIndex = $56b436271f6666d1$var$getMaxIndex(listRef, disabledIndices);
if (event.key === "Home") {
(0, $d8YHU.stopEvent)(event);
indexRef.current = minIndex;
onNavigate(indexRef.current);
}
if (event.key === "End") {
(0, $d8YHU.stopEvent)(event);
indexRef.current = maxIndex;
onNavigate(indexRef.current);
}
// Grid navigation.
if (cols > 1) {
indexRef.current = $56b436271f6666d1$var$getGridNavigatedIndex(listRef, {
event: event,
orientation: orientation,
loop: loop,
cols: cols,
disabledIndices: disabledIndices,
minIndex: minIndex,
maxIndex: maxIndex,
prevIndex: indexRef.current,
stopEvent: true
});
onNavigate(indexRef.current);
if (orientation === "both") return;
}
if ($56b436271f6666d1$var$isMainOrientationKey(event.key, orientation)) {
(0, $d8YHU.stopEvent)(event);
// Reset the index if no item is focused.
if (open && !virtual && (0, $d8YHU.activeElement)(event.currentTarget.ownerDocument) === event.currentTarget) {
indexRef.current = $56b436271f6666d1$var$isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;
onNavigate(indexRef.current);
return;
}
if ($56b436271f6666d1$var$isMainOrientationToEndKey(event.key, orientation, rtl)) {
if (loop) indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : $56b436271f6666d1$var$findNonDisabledIndex(listRef, {
startingIndex: currentIndex,
disabledIndices: disabledIndices
});
else indexRef.current = Math.min(maxIndex, $56b436271f6666d1$var$findNonDisabledIndex(listRef, {
startingIndex: currentIndex,
disabledIndices: disabledIndices
}));
} else if (loop) indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : $56b436271f6666d1$var$findNonDisabledIndex(listRef, {
startingIndex: currentIndex,
decrement: true,
disabledIndices: disabledIndices
});
else indexRef.current = Math.max(minIndex, $56b436271f6666d1$var$findNonDisabledIndex(listRef, {
startingIndex: currentIndex,
decrement: true,
disabledIndices: disabledIndices
}));
if ($56b436271f6666d1$var$isIndexOutOfBounds(listRef, indexRef.current)) onNavigate(null);
else onNavigate(indexRef.current);
}
}
function checkVirtualMouse(event) {
if (focusItemOnOpen === "auto" && (0, $d8YHU.isVirtualClick)(event.nativeEvent)) focusItemOnOpenRef.current = true;
}
function checkVirtualPointer(event) {
// `pointerdown` fires first, reset the state then perform the checks.
focusItemOnOpenRef.current = focusItemOnOpen;
if (focusItemOnOpen === "auto" && (0, $d8YHU.isVirtualPointerEvent)(event.nativeEvent)) focusItemOnOpenRef.current = true;
}
const ariaActiveDescendantProp = virtual && open && hasActiveIndex && {
"aria-activedescendant": virtualId || activeId
};
const activeItem = listRef.current.find((item)=>(item == null ? void 0 : item.id) === activeId);
return {
reference: {
...ariaActiveDescendantProp,
onKeyDown (event) {
isPointerModalityRef.current = false;
const isArrowKey = event.key.indexOf("Arrow") === 0;
const isCrossOpenKey = $56b436271f6666d1$var$isCrossOrientationOpenKey(event.key, orientation, rtl);
const isCrossCloseKey = $56b436271f6666d1$var$isCrossOrientationCloseKey(event.key, orientation, rtl);
const isMainKey = $56b436271f6666d1$var$isMainOrientationKey(event.key, orientation);
const isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === "Enter" || event.key.trim() === "";
if (virtual && open) {
const rootNode = tree == null ? void 0 : tree.nodesRef.current.find((node)=>node.parentId == null);
const deepestNode = tree && rootNode ? $56b436271f6666d1$var$getDeepestNode(tree.nodesRef.current, rootNode.id) : null;
if (isArrowKey && deepestNode && virtualItemRef) {
const eventObject = new KeyboardEvent("keydown", {
key: event.key,
bubbles: true
});
if (isCrossOpenKey || isCrossCloseKey) {
var _deepestNode$context, _deepestNode$context2;
const isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;
const dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? activeItem : null;
if (dispatchItem) {
(0, $d8YHU.stopEvent)(event);
dispatchItem.dispatchEvent(eventObject);
setVirtualId(undefined);
}
}
if (isMainKey && deepestNode.context) {
if (deepestNode.context.open && deepestNode.parentId && event.currentTarget !== deepestNode.context.elements.domReference) {
var _deepestNode$context$;
(0, $d8YHU.stopEvent)(event);
(_deepestNode$context$ = deepestNode.context.elements.domReference) == null || _deepestNode$context$.dispatchEvent(eventObject);
return;
}
}
}
return onKeyDown(event);
}
// If a floating element should not open on arrow key down, avoid
// setting `activeIndex` while it's closed.
if (!open && !openOnArrowKeyDown && isArrowKey) return;
if (isNavigationKey) keyRef.current = nested && isMainKey ? null : event.key;
if (nested) {
if (isCrossOpenKey) {
(0, $d8YHU.stopEvent)(event);
if (open) {
indexRef.current = $56b436271f6666d1$var$getMinIndex(listRef, disabledIndices);
onNavigate(indexRef.current);
} else onOpenChange(true, event.nativeEvent);
}
return;
}
if (isMainKey) {
if (selectedIndex != null) indexRef.current = selectedIndex;
(0, $d8YHU.stopEvent)(event);
if (!open && openOnArrowKeyDown) onOpenChange(true, event.nativeEvent);
else onKeyDown(event);
if (open) onNavigate(indexRef.current);
}
},
onFocus () {
if (open) onNavigate(null);
},
onPointerDown: checkVirtualPointer,
onMouseDown: checkVirtualMouse,
onClick: checkVirtualMouse
},
floating: {
"aria-orientation": orientation === "both" ? undefined : orientation,
...ariaActiveDescendantProp,
onKeyDown: onKeyDown,
onPointerMove () {
isPointerModalityRef.current = true;
}
},
item: item
};
}, [
domReference,
refs,
activeId,
virtualId,
disabledIndicesRef,
latestOpenRef,
listRef,
enabled,
orientation,
rtl,
virtual,
open,
hasActiveIndex,
nested,
selectedIndex,
openOnArrowKeyDown,
allowEscape,
cols,
loop,
focusItemOnOpen,
onNavigate,
onOpenChange,
item,
tree,
virtualItemRef
]);
}
/**
* Adds base screen reader props to the reference and floating elements for a
* given floating element `role`.
* @see https://floating-ui.com/docs/useRole
*/ function $56b436271f6666d1$export$f66572793fa256a1(context, props) {
if (props === void 0) props = {};
const { open: open, floatingId: floatingId } = context;
const { enabled: enabled = true, role: role = "dialog" } = props;
const referenceId = $56b436271f6666d1$export$f680877a34711e37();
return $63SH6.useMemo(()=>{
const floatingProps = {
id: floatingId,
role: role
};
if (!enabled) return {};
if (role === "tooltip") return {
reference: {
"aria-describedby": open ? floatingId : undefined
},
floating: floatingProps
};
return {
reference: {
"aria-expanded": open ? "true" : "false",
"aria-haspopup": role === "alertdialog" ? "dialog" : role,
"aria-controls": open ? floatingId : undefined,
...role === "listbox" && {
role: "combobox"
},
...role === "menu" && {
id: referenceId
}
},
floating: {
...floatingProps,
...role === "menu" && {
"aria-labelledby": referenceId
}
}
};
}, [
enabled,
role,
open,
floatingId,
referenceId
]);
}
// Converts a JS style key like `backgroundColor` to a CSS transition-property
// like `background-color`.
const $56b436271f6666d1$var$camelCaseToKebabCase = (str)=>str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs)=>(ofs ? "-" : "") + $.toLowerCase());
function $56b436271f6666d1$var$execWithArgsOrReturn(valueOrFn, args) {
return typeof valueOrFn === "function" ? valueOrFn(args) : valueOrFn;
}
function $56b436271f6666d1$var$useDelayUnmount(open, durationMs) {
const [isMounted, setIsMounted] = $63SH6.useState(open);
if (open && !isMounted) setIsMounted(true);
$63SH6.useEffect(()=>{
if (!open) {
const timeout = setTimeout(()=>setIsMounted(false), durationMs);
return ()=>clearTimeout(timeout);
}
}, [
open,
durationMs
]);
return isMounted;
}
/**
* Provides a status string to apply CSS transitions to a floating element,
* correctly handling placement-aware transitions.
* @see https://floating-ui.com/docs/useTransition#usetransitionstatus
*/ function $56b436271f6666d1$export$b2ef21706733f7e5(context, props) {
if (props === void 0) props = {};
const { open: open, elements: { floating: floating } } = context;
const { duration: duration = 250 } = props;
const isNumberDuration = typeof duration === "number";
const closeDuration = (isNumberDuration ? duration : duration.close) || 0;
const [initiated, setInitiated] = $63SH6.useState(false);
const [status, setStatus] = $63SH6.useState("unmounted");
const isMounted = $56b436271f6666d1$var$useDelayUnmount(open, closeDuration);
// `initiated` check prevents this `setState` call from breaking
//
. This call is necessary to ensure subsequent opens
// after the initial one allows the correct side animation to play when the
// placement has changed.
$56b436271f6666d1$var$index(()=>{
if (initiated && !isMounted) setStatus("unmounted");
}, [
initiated,
isMounted
]);
$56b436271f6666d1$var$index(()=>{
if (!floating) return;
if (open) {
setStatus("initial");
const frame = requestAnimationFrame(()=>{
setStatus("open");
});
return ()=>{
cancelAnimationFrame(frame);
};
} else {
setInitiated(true);
setStatus("close");
}
}, [
open,
floating
]);
return {
isMounted: isMounted,
status: status
};
}
/**
* Provides styles to apply CSS transitions to a floating element, correctly
* handling placement-aware transitions. Wrapper around `useTransitionStatus`.
* @see https://floating-ui.com/docs/useTransition#usetransitionstyles
*/ function $56b436271f6666d1$export$769fba13884bc2f4(context, props) {
if (props === void 0) props = {};
const { initial: unstable_initial = {
opacity: 0
}, open: unstable_open, close: unstable_close, common: unstable_common, duration: duration = 250 } = props;
const placement = context.placement;
const side = placement.split("-")[0];
const fnArgs = $63SH6.useMemo(()=>({
side: side,
placement: placement
}), [
side,
placement
]);
const isNumberDuration = typeof duration === "number";
const openDuration = (isNumberDuration ? duration : duration.open) || 0;
const closeDuration = (isNumberDuration ? duration : duration.close) || 0;
const [styles, setStyles] = $63SH6.useState(()=>({
...$56b436271f6666d1$var$execWithArgsOrReturn(unstable_common, fnArgs),
...$56b436271f6666d1$var$execWithArgsOrReturn(unstable_initial, fnArgs)
}));
const { isMounted: isMounted, status: status } = $56b436271f6666d1$export$b2ef21706733f7e5(context, {
duration: duration
});
const initialRef = $56b436271f6666d1$var$useLatestRef(unstable_initial);
const openRef = $56b436271f6666d1$var$useLatestRef(unstable_open);
const closeRef = $56b436271f6666d1$var$useLatestRef(unstable_close);
const commonRef = $56b436271f6666d1$var$useLatestRef(unstable_common);
$56b436271f6666d1$var$index(()=>{
const initialStyles = $56b436271f6666d1$var$execWithArgsOrReturn(initialRef.current, fnArgs);
const closeStyles = $56b436271f6666d1$var$execWithArgsOrReturn(closeRef.current, fnArgs);
const commonStyles = $56b436271f6666d1$var$execWithArgsOrReturn(commonRef.current, fnArgs);
const openStyles = $56b436271f6666d1$var$execWithArgsOrReturn(openRef.current, fnArgs) || Object.keys(initialStyles).reduce((acc, key)=>{
acc[key] = "";
return acc;
}, {});
if (status === "initial") setStyles((styles)=>({
transitionProperty: styles.transitionProperty,
...commonStyles,
...initialStyles
}));
if (status === "open") setStyles({
transitionProperty: Object.keys(openStyles).map($56b436271f6666d1$var$camelCaseToKebabCase).join(","),
transitionDuration: openDuration + "ms",
...commonStyles,
...openStyles
});
if (status === "close") {
const styles = closeStyles || initialStyles;
setStyles({
transitionProperty: Object.keys(styles).map($56b436271f6666d1$var$camelCaseToKebabCase).join(","),
transitionDuration: closeDuration + "ms",
...commonStyles,
...styles
});
}
}, [
closeDuration,
closeRef,
initialRef,
openRef,
commonRef,
openDuration,
status,
fnArgs
]);
return {
isMounted: isMounted,
styles: styles
};
}
/**
* Provides a matching callback that can be used to focus an item as the user
* types, often used in tandem with `useListNavigation()`.
* @see https://floating-ui.com/docs/useTypeahead
*/ function $56b436271f6666d1$export$d8d674d50b73ba93(context, props) {
var _ref;
const { open: open, dataRef: dataRef } = context;
const { listRef: listRef, activeIndex: activeIndex, onMatch: unstable_onMatch, onTypingChange: unstable_onTypingChange, enabled: enabled = true, findMatch: findMatch = null, resetMs: resetMs = 750, ignoreKeys: ignoreKeys = [], selectedIndex: selectedIndex = null } = props;
const timeoutIdRef = $63SH6.useRef();
const stringRef = $63SH6.useRef("");
const prevIndexRef = $63SH6.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);
const matchIndexRef = $63SH6.useRef(null);
const onMatch = $56b436271f6666d1$var$useEffectEvent(unstable_onMatch);
const onTypingChange = $56b436271f6666d1$var$useEffectEvent(unstable_onTypingChange);
const findMatchRef = $56b436271f6666d1$var$useLatestRef(findMatch);
const ignoreKeysRef = $56b436271f6666d1$var$useLatestRef(ignoreKeys);
$56b436271f6666d1$var$index(()=>{
if (open) {
clearTimeout(timeoutIdRef.current);
matchIndexRef.current = null;
stringRef.current = "";
}
}, [
open
]);
$56b436271f6666d1$var$index(()=>{
// Sync arrow key navigation but not typeahead navigation.
if (open && stringRef.current === "") {
var _ref2;
prevIndexRef.current = (_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1;
}
}, [
open,
selectedIndex,
activeIndex
]);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
function setTypingChange(value) {
if (value) {
if (!dataRef.current.typing) {
dataRef.current.typing = value;
onTypingChange(value);
}
} else if (dataRef.current.typing) {
dataRef.current.typing = value;
onTypingChange(value);
}
}
function getMatchingIndex(list, orderedList, string) {
const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find((text)=>(text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);
return str ? list.indexOf(str) : -1;
}
function onKeyDown(event) {
const listContent = listRef.current;
if (stringRef.current.length > 0 && stringRef.current[0] !== " ") {
if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) setTypingChange(false);
else if (event.key === " ") (0, $d8YHU.stopEvent)(event);
}
if (listContent == null || ignoreKeysRef.current.includes(event.key) || // Character key.
event.key.length !== 1 || // Modifier key.
event.ctrlKey || event.metaKey || event.altKey) return;
if (open && event.key !== " ") {
(0, $d8YHU.stopEvent)(event);
setTypingChange(true);
}
// Bail out if the list contains a word like "llama" or "aaron". TODO:
// allow it in this case, too.
const allowRapidSuccessionOfFirstLetter = listContent.every((text)=>{
var _text$, _text$2;
return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;
});
// Allows the user to cycle through items that start with the same letter
// in rapid succession.
if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {
stringRef.current = "";
prevIndexRef.current = matchIndexRef.current;
}
stringRef.current += event.key;
clearTimeout(timeoutIdRef.current);
timeoutIdRef.current = setTimeout(()=>{
stringRef.current = "";
prevIndexRef.current = matchIndexRef.current;
setTypingChange(false);
}, resetMs);
const prevIndex = prevIndexRef.current;
const index = getMatchingIndex(listContent, [
...listContent.slice((prevIndex || 0) + 1),
...listContent.slice(0, (prevIndex || 0) + 1)
], stringRef.current);
if (index !== -1) {
onMatch(index);
matchIndexRef.current = index;
} else if (event.key !== " ") {
stringRef.current = "";
setTypingChange(false);
}
}
return {
reference: {
onKeyDown: onKeyDown
},
floating: {
onKeyDown: onKeyDown,
onKeyUp (event) {
if (event.key === " ") setTypingChange(false);
}
}
};
}, [
enabled,
open,
dataRef,
listRef,
resetMs,
ignoreKeysRef,
findMatchRef,
onMatch,
onTypingChange
]);
}
function $56b436271f6666d1$var$getArgsWithCustomFloatingHeight(state, height) {
return {
...state,
rects: {
...state.rects,
floating: {
...state.rects.floating,
height: height
}
}
};
}
/**
* Positions the floating element such that an inner element inside
* of it is anchored to the reference element.
* @see https://floating-ui.com/docs/inner
*/ const $56b436271f6666d1$export$4ae363f1d88fb658 = (props)=>({
name: "inner",
options: props,
async fn (state) {
const { listRef: listRef, overflowRef: overflowRef, onFallbackChange: onFallbackChange, offset: innerOffset = 0, index: index = 0, minItemsVisible: minItemsVisible = 4, referenceOverflowThreshold: referenceOverflowThreshold = 0, scrollRef: scrollRef, ...detectOverflowOptions } = props;
const { rects: rects, elements: { floating: floating } } = state;
const item = listRef.current[index];
if (!item) return {};
const nextArgs = {
...state,
...await (0, $l2jTt.offset)(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state)
};
const el = (scrollRef == null ? void 0 : scrollRef.current) || floating;
const overflow = await (0, $l2jTt.detectOverflow)($56b436271f6666d1$var$getArgsWithCustomFloatingHeight(nextArgs, el.scrollHeight), detectOverflowOptions);
const refOverflow = await (0, $l2jTt.detectOverflow)(nextArgs, {
...detectOverflowOptions,
elementContext: "reference"
});
const diffY = Math.max(0, overflow.top);
const nextY = nextArgs.y + diffY;
const maxHeight = Math.max(0, el.scrollHeight - diffY - Math.max(0, overflow.bottom));
el.style.maxHeight = maxHeight + "px";
el.scrollTop = diffY;
// There is not enough space, fallback to standard anchored positioning
if (onFallbackChange) {
if (el.offsetHeight < item.offsetHeight * Math.min(minItemsVisible, listRef.current.length - 1) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold) (0, $grDIR.flushSync)(()=>onFallbackChange(true));
else (0, $grDIR.flushSync)(()=>onFallbackChange(false));
}
if (overflowRef) overflowRef.current = await (0, $l2jTt.detectOverflow)($56b436271f6666d1$var$getArgsWithCustomFloatingHeight({
...nextArgs,
y: nextY
}, el.offsetHeight), detectOverflowOptions);
return {
y: nextY
};
}
});
/**
* Changes the `inner` middleware's `offset` upon a `wheel` event to
* expand the floating element's height, revealing more list items.
* @see https://floating-ui.com/docs/inner
*/ function $56b436271f6666d1$export$3d74b0dda7cc82ff(context, props) {
const { open: open, elements: elements } = context;
const { enabled: enabled = true, overflowRef: overflowRef, scrollRef: scrollRef, onChange: unstable_onChange } = props;
const onChange = $56b436271f6666d1$var$useEffectEvent(unstable_onChange);
const controlledScrollingRef = $63SH6.useRef(false);
const prevScrollTopRef = $63SH6.useRef(null);
const initialOverflowRef = $63SH6.useRef(null);
$63SH6.useEffect(()=>{
if (!enabled) return;
function onWheel(e) {
if (e.ctrlKey || !el || overflowRef.current == null) return;
const dY = e.deltaY;
const isAtTop = overflowRef.current.top >= -0.5;
const isAtBottom = overflowRef.current.bottom >= -0.5;
const remainingScroll = el.scrollHeight - el.clientHeight;
const sign = dY < 0 ? -1 : 1;
const method = dY < 0 ? "max" : "min";
if (el.scrollHeight <= el.clientHeight) return;
if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {
e.preventDefault();
(0, $grDIR.flushSync)(()=>{
onChange((d)=>d + Math[method](dY, remainingScroll * sign));
});
} else if (/firefox/i.test((0, $d8YHU.getUserAgent)())) // Needed to propagate scrolling during momentum scrolling phase once
// it gets limited by the boundary. UX improvement, not critical.
el.scrollTop += dY;
}
const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;
if (open && el) {
el.addEventListener("wheel", onWheel);
// Wait for the position to be ready.
requestAnimationFrame(()=>{
prevScrollTopRef.current = el.scrollTop;
if (overflowRef.current != null) initialOverflowRef.current = {
...overflowRef.current
};
});
return ()=>{
prevScrollTopRef.current = null;
initialOverflowRef.current = null;
el.removeEventListener("wheel", onWheel);
};
}
}, [
enabled,
open,
elements.floating,
overflowRef,
scrollRef,
onChange
]);
return $63SH6.useMemo(()=>{
if (!enabled) return {};
return {
floating: {
onKeyDown () {
controlledScrollingRef.current = true;
},
onWheel () {
controlledScrollingRef.current = false;
},
onPointerMove () {
controlledScrollingRef.current = false;
},
onScroll () {
const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;
if (!overflowRef.current || !el || !controlledScrollingRef.current) return;
if (prevScrollTopRef.current !== null) {
const scrollDiff = el.scrollTop - prevScrollTopRef.current;
if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) (0, $grDIR.flushSync)(()=>onChange((d)=>d + scrollDiff));
}
// [Firefox] Wait for the height change to have been applied.
requestAnimationFrame(()=>{
prevScrollTopRef.current = el.scrollTop;
});
}
}
};
}, [
enabled,
overflowRef,
elements.floating,
scrollRef,
onChange
]);
}
function $56b436271f6666d1$var$isPointInPolygon(point, polygon) {
const [x, y] = point;
let isInside = false;
const length = polygon.length;
for(let i = 0, j = length - 1; i < length; j = i++){
const [xi, yi] = polygon[i] || [
0,
0
];
const [xj, yj] = polygon[j] || [
0,
0
];
const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;
if (intersect) isInside = !isInside;
}
return isInside;
}
function $56b436271f6666d1$var$isInside(point, rect) {
return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;
}
/**
* Generates a safe polygon area that the user can traverse without closing the
* floating element once leaving the reference element.
* @see https://floating-ui.com/docs/useHover#safePolygon
*/ function $56b436271f6666d1$export$7484214ab62358d2(options) {
if (options === void 0) options = {};
const { buffer: buffer = 0.5, blockPointerEvents: blockPointerEvents = false, requireIntent: requireIntent = true } = options;
let timeoutId;
let hasLanded = false;
let lastX = null;
let lastY = null;
let lastCursorTime = performance.now();
function getCursorSpeed(x, y) {
const currentTime = performance.now();
const elapsedTime = currentTime - lastCursorTime;
if (lastX === null || lastY === null || elapsedTime === 0) {
lastX = x;
lastY = y;
lastCursorTime = currentTime;
return null;
}
const deltaX = x - lastX;
const deltaY = y - lastY;
const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
const speed = distance / elapsedTime; // px / ms
lastX = x;
lastY = y;
lastCursorTime = currentTime;
return speed;
}
const fn = (_ref)=>{
let { x: x, y: y, placement: placement, elements: elements, onClose: onClose, nodeId: nodeId, tree: tree } = _ref;
return function onMouseMove(event) {
function close() {
clearTimeout(timeoutId);
onClose();
}
clearTimeout(timeoutId);
if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) return;
const { clientX: clientX, clientY: clientY } = event;
const clientPoint = [
clientX,
clientY
];
const target = (0, $d8YHU.getTarget)(event);
const isLeave = event.type === "mouseleave";
const isOverFloatingEl = (0, $d8YHU.contains)(elements.floating, target);
const isOverReferenceEl = (0, $d8YHU.contains)(elements.domReference, target);
const refRect = elements.domReference.getBoundingClientRect();
const rect = elements.floating.getBoundingClientRect();
const side = placement.split("-")[0];
const cursorLeaveFromRight = x > rect.right - rect.width / 2;
const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;
const isOverReferenceRect = $56b436271f6666d1$var$isInside(clientPoint, refRect);
const isFloatingWider = rect.width > refRect.width;
const isFloatingTaller = rect.height > refRect.height;
const left = (isFloatingWider ? refRect : rect).left;
const right = (isFloatingWider ? refRect : rect).right;
const top = (isFloatingTaller ? refRect : rect).top;
const bottom = (isFloatingTaller ? refRect : rect).bottom;
if (isOverFloatingEl) {
hasLanded = true;
if (!isLeave) return;
}
if (isOverReferenceEl) hasLanded = false;
if (isOverReferenceEl && !isLeave) {
hasLanded = true;
return;
}
// Prevent overlapping floating element from being stuck in an open-close
// loop: https://github.com/floating-ui/floating-ui/issues/1910
if (isLeave && (0, $8Xnp2.isElement)(event.relatedTarget) && (0, $d8YHU.contains)(elements.floating, event.relatedTarget)) return;
// If any nested child is open, abort.
if (tree && $56b436271f6666d1$var$getChildren(tree.nodesRef.current, nodeId).some((_ref2)=>{
let { context: context } = _ref2;
return context == null ? void 0 : context.open;
})) return;
// If the pointer is leaving from the opposite side, the "buffer" logic
// creates a point where the floating element remains open, but should be
// ignored.
// A constant of 1 handles floating point rounding errors.
if (side === "top" && y >= refRect.bottom - 1 || side === "bottom" && y <= refRect.top + 1 || side === "left" && x >= refRect.right - 1 || side === "right" && x <= refRect.left + 1) return close();
// Ignore when the cursor is within the rectangular trough between the
// two elements. Since the triangle is created from the cursor point,
// which can start beyond the ref element's edge, traversing back and
// forth from the ref to the floating element can cause it to close. This
// ensures it always remains open in that case.
let rectPoly = [];
switch(side){
case "top":
rectPoly = [
[
left,
refRect.top + 1
],
[
left,
rect.bottom - 1
],
[
right,
rect.bottom - 1
],
[
right,
refRect.top + 1
]
];
break;
case "bottom":
rectPoly = [
[
left,
rect.top + 1
],
[
left,
refRect.bottom - 1
],
[
right,
refRect.bottom - 1
],
[
right,
rect.top + 1
]
];
break;
case "left":
rectPoly = [
[
rect.right - 1,
bottom
],
[
rect.right - 1,
top
],
[
refRect.left + 1,
top
],
[
refRect.left + 1,
bottom
]
];
break;
case "right":
rectPoly = [
[
refRect.right - 1,
bottom
],
[
refRect.right - 1,
top
],
[
rect.left + 1,
top
],
[
rect.left + 1,
bottom
]
];
break;
}
function getPolygon(_ref3) {
let [x, y] = _ref3;
switch(side){
case "top":
{
const cursorPointOne = [
isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4,
y + buffer + 1
];
const cursorPointTwo = [
isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4,
y + buffer + 1
];
const commonPoints = [
[
rect.left,
cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top
],
[
rect.right,
cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer
]
];
return [
cursorPointOne,
cursorPointTwo,
...commonPoints
];
}
case "bottom":
{
const cursorPointOne = [
isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4,
y - buffer
];
const cursorPointTwo = [
isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4,
y - buffer
];
const commonPoints = [
[
rect.left,
cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom
],
[
rect.right,
cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer
]
];
return [
cursorPointOne,
cursorPointTwo,
...commonPoints
];
}
case "left":
{
const cursorPointOne = [
x + buffer + 1,
isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4
];
const cursorPointTwo = [
x + buffer + 1,
isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4
];
const commonPoints = [
[
cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left,
rect.top
],
[
cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer,
rect.bottom
]
];
return [
...commonPoints,
cursorPointOne,
cursorPointTwo
];
}
case "right":
{
const cursorPointOne = [
x - buffer,
isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4
];
const cursorPointTwo = [
x - buffer,
isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4
];
const commonPoints = [
[
cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right,
rect.top
],
[
cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer,
rect.bottom
]
];
return [
cursorPointOne,
cursorPointTwo,
...commonPoints
];
}
}
}
if ($56b436271f6666d1$var$isPointInPolygon([
clientX,
clientY
], rectPoly)) return;
else if (hasLanded && !isOverReferenceRect) return close();
if (!isLeave && requireIntent) {
const cursorSpeed = getCursorSpeed(event.clientX, event.clientY);
const cursorSpeedThreshold = 0.1;
if (cursorSpeed !== null && cursorSpeed < cursorSpeedThreshold) return close();
}
if (!$56b436271f6666d1$var$isPointInPolygon([
clientX,
clientY
], getPolygon([
x,
y
]))) close();
else if (!hasLanded && requireIntent) timeoutId = window.setTimeout(close, 40);
};
};
fn.__options = {
blockPointerEvents: blockPointerEvents
};
return fn;
}
});
parcelRegister("d8YHU", function(module, exports) {
$parcel$export(module.exports, "activeElement", () => $991b1cebdd128441$export$da980962bd2147a4);
$parcel$export(module.exports, "contains", () => $991b1cebdd128441$export$2344b14b097df817);
$parcel$export(module.exports, "getPlatform", () => $991b1cebdd128441$export$867a782338812cb4);
$parcel$export(module.exports, "getUserAgent", () => $991b1cebdd128441$export$7935961ef7719cb0);
$parcel$export(module.exports, "isVirtualClick", () => $991b1cebdd128441$export$60278871457622de);
$parcel$export(module.exports, "isVirtualPointerEvent", () => $991b1cebdd128441$export$29bf1b5f2c56cf63);
$parcel$export(module.exports, "isSafari", () => $991b1cebdd128441$export$95df08bae54cb4df);
$parcel$export(module.exports, "isMac", () => $991b1cebdd128441$export$9ac100e40613ea10);
$parcel$export(module.exports, "isMouseLikePointerType", () => $991b1cebdd128441$export$81cf264172d31e51);
$parcel$export(module.exports, "isReactEvent", () => $991b1cebdd128441$export$94781ce41a161222);
$parcel$export(module.exports, "isRootElement", () => $991b1cebdd128441$export$7b296c28e0fa3aed);
$parcel$export(module.exports, "getDocument", () => $991b1cebdd128441$export$f65ca476c09acec0);
$parcel$export(module.exports, "isEventTargetWithin", () => $991b1cebdd128441$export$43c3154d5bf2c6c2);
$parcel$export(module.exports, "getTarget", () => $991b1cebdd128441$export$c22522a4dfa48e9c);
$parcel$export(module.exports, "isTypeableElement", () => $991b1cebdd128441$export$42ad131c32f0fb8d);
$parcel$export(module.exports, "stopEvent", () => $991b1cebdd128441$export$7ae4cd3a66c1e050);
var $8Xnp2 = parcelRequire("8Xnp2");
function $991b1cebdd128441$export$da980962bd2147a4(doc) {
let activeElement = doc.activeElement;
while(((_activeElement = activeElement) == null ? void 0 : (_activeElement$shadow = _activeElement.shadowRoot) == null ? void 0 : _activeElement$shadow.activeElement) != null){
var _activeElement, _activeElement$shadow;
activeElement = activeElement.shadowRoot.activeElement;
}
return activeElement;
}
function $991b1cebdd128441$export$2344b14b097df817(parent, child) {
if (!parent || !child) return false;
const rootNode = child.getRootNode && child.getRootNode();
// First, attempt with faster native method
if (parent.contains(child)) return true;
// then fallback to custom implementation with Shadow DOM support
if (rootNode && (0, $8Xnp2.isShadowRoot)(rootNode)) {
let next = child;
while(next){
if (parent === next) return true;
// @ts-ignore
next = next.parentNode || next.host;
}
}
// Give up, the result is false
return false;
}
// Avoid Chrome DevTools blue warning.
function $991b1cebdd128441$export$867a782338812cb4() {
const uaData = navigator.userAgentData;
if (uaData != null && uaData.platform) return uaData.platform;
return navigator.platform;
}
function $991b1cebdd128441$export$7935961ef7719cb0() {
const uaData = navigator.userAgentData;
if (uaData && Array.isArray(uaData.brands)) return uaData.brands.map((_ref)=>{
let { brand: brand, version: version } = _ref;
return brand + "/" + version;
}).join(" ");
return navigator.userAgent;
}
// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts
function $991b1cebdd128441$export$60278871457622de(event) {
// FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.
// Try to find a workaround for this. `react-aria` source still has the check.
if (event.mozInputSource === 0 && event.isTrusted) return true;
if ($991b1cebdd128441$export$a11b0059900ceec8() && event.pointerType) return event.type === "click" && event.buttons === 1;
return event.detail === 0 && !event.pointerType;
}
function $991b1cebdd128441$export$29bf1b5f2c56cf63(event) {
return !$991b1cebdd128441$export$a11b0059900ceec8() && event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || // iOS VoiceOver returns 0.333• for width/height.
event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0;
}
function $991b1cebdd128441$export$95df08bae54cb4df() {
// Chrome DevTools does not complain about navigator.vendor
return /apple/i.test(navigator.vendor);
}
function $991b1cebdd128441$export$a11b0059900ceec8() {
const re = /android/i;
return re.test($991b1cebdd128441$export$867a782338812cb4()) || re.test($991b1cebdd128441$export$7935961ef7719cb0());
}
function $991b1cebdd128441$export$9ac100e40613ea10() {
return $991b1cebdd128441$export$867a782338812cb4().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
}
function $991b1cebdd128441$export$81cf264172d31e51(pointerType, strict) {
// On some Linux machines with Chromium, mouse inputs return a `pointerType`
// of "pen": https://github.com/floating-ui/floating-ui/issues/2015
const values = [
"mouse",
"pen"
];
if (!strict) values.push("", undefined);
return values.includes(pointerType);
}
function $991b1cebdd128441$export$94781ce41a161222(event) {
return "nativeEvent" in event;
}
function $991b1cebdd128441$export$7b296c28e0fa3aed(element) {
return element.matches("html,body");
}
function $991b1cebdd128441$export$f65ca476c09acec0(node) {
return (node == null ? void 0 : node.ownerDocument) || document;
}
function $991b1cebdd128441$export$43c3154d5bf2c6c2(event, node) {
if (node == null) return false;
if ("composedPath" in event) return event.composedPath().includes(node);
// TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't
const e = event;
return e.target != null && node.contains(e.target);
}
function $991b1cebdd128441$export$c22522a4dfa48e9c(event) {
if ("composedPath" in event) return event.composedPath()[0];
// TS thinks `event` is of type never as it assumes all browsers support
// `composedPath()`, but browsers without shadow DOM don't.
return event.target;
}
const $991b1cebdd128441$export$78b3d091ff376bc = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
function $991b1cebdd128441$export$42ad131c32f0fb8d(element) {
return (0, $8Xnp2.isHTMLElement)(element) && element.matches($991b1cebdd128441$export$78b3d091ff376bc);
}
function $991b1cebdd128441$export$7ae4cd3a66c1e050(event) {
event.preventDefault();
event.stopPropagation();
}
});
parcelRegister("8Xnp2", function(module, exports) {
$parcel$export(module.exports, "getNodeName", () => $6855fcb605b0f44b$export$651544f548703224);
$parcel$export(module.exports, "getWindow", () => $6855fcb605b0f44b$export$38b2d434cce3ea22);
$parcel$export(module.exports, "getDocumentElement", () => $6855fcb605b0f44b$export$e495491855dc5418);
$parcel$export(module.exports, "isElement", () => $6855fcb605b0f44b$export$45a5e7f76e0caa8d);
$parcel$export(module.exports, "isHTMLElement", () => $6855fcb605b0f44b$export$1b3bfaa9684536aa);
$parcel$export(module.exports, "isShadowRoot", () => $6855fcb605b0f44b$export$af51f0f06c0f328a);
$parcel$export(module.exports, "isOverflowElement", () => $6855fcb605b0f44b$export$989e911fa9af580a);
$parcel$export(module.exports, "getComputedStyle", () => $6855fcb605b0f44b$export$3735103072e4a80);
$parcel$export(module.exports, "isTableElement", () => $6855fcb605b0f44b$export$71535ffaa902797f);
$parcel$export(module.exports, "isContainingBlock", () => $6855fcb605b0f44b$export$d6c4e8150c35fed1);
$parcel$export(module.exports, "isWebKit", () => $6855fcb605b0f44b$export$78551043582a6a98);
$parcel$export(module.exports, "getContainingBlock", () => $6855fcb605b0f44b$export$940d8225183e1404);
$parcel$export(module.exports, "getParentNode", () => $6855fcb605b0f44b$export$4e12058fc4d51d56);
$parcel$export(module.exports, "isLastTraversableNode", () => $6855fcb605b0f44b$export$d1162fb0b6d4cd51);
$parcel$export(module.exports, "getNodeScroll", () => $6855fcb605b0f44b$export$dc8fc79fa2800137);
$parcel$export(module.exports, "getOverflowAncestors", () => $6855fcb605b0f44b$export$3b57c1601291186b);
function $6855fcb605b0f44b$export$651544f548703224(node) {
if ($6855fcb605b0f44b$export$8ee0fc9ee280b4ee(node)) return (node.nodeName || "").toLowerCase();
// Mocked nodes in testing environments may not be instances of Node. By
// returning `#document` an infinite loop won't occur.
// https://github.com/floating-ui/floating-ui/issues/2317
return "#document";
}
function $6855fcb605b0f44b$export$38b2d434cce3ea22(node) {
var _node$ownerDocument;
return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
}
function $6855fcb605b0f44b$export$e495491855dc5418(node) {
var _ref;
return (_ref = ($6855fcb605b0f44b$export$8ee0fc9ee280b4ee(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
}
function $6855fcb605b0f44b$export$8ee0fc9ee280b4ee(value) {
return value instanceof Node || value instanceof $6855fcb605b0f44b$export$38b2d434cce3ea22(value).Node;
}
function $6855fcb605b0f44b$export$45a5e7f76e0caa8d(value) {
return value instanceof Element || value instanceof $6855fcb605b0f44b$export$38b2d434cce3ea22(value).Element;
}
function $6855fcb605b0f44b$export$1b3bfaa9684536aa(value) {
return value instanceof HTMLElement || value instanceof $6855fcb605b0f44b$export$38b2d434cce3ea22(value).HTMLElement;
}
function $6855fcb605b0f44b$export$af51f0f06c0f328a(value) {
// Browsers without `ShadowRoot` support.
if (typeof ShadowRoot === "undefined") return false;
return value instanceof ShadowRoot || value instanceof $6855fcb605b0f44b$export$38b2d434cce3ea22(value).ShadowRoot;
}
function $6855fcb605b0f44b$export$989e911fa9af580a(element) {
const { overflow: overflow, overflowX: overflowX, overflowY: overflowY, display: display } = $6855fcb605b0f44b$export$3735103072e4a80(element);
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && ![
"inline",
"contents"
].includes(display);
}
function $6855fcb605b0f44b$export$71535ffaa902797f(element) {
return [
"table",
"td",
"th"
].includes($6855fcb605b0f44b$export$651544f548703224(element));
}
function $6855fcb605b0f44b$export$d6c4e8150c35fed1(element) {
const webkit = $6855fcb605b0f44b$export$78551043582a6a98();
const css = $6855fcb605b0f44b$export$3735103072e4a80(element);
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || [
"transform",
"perspective",
"filter"
].some((value)=>(css.willChange || "").includes(value)) || [
"paint",
"layout",
"strict",
"content"
].some((value)=>(css.contain || "").includes(value));
}
function $6855fcb605b0f44b$export$940d8225183e1404(element) {
let currentNode = $6855fcb605b0f44b$export$4e12058fc4d51d56(element);
while($6855fcb605b0f44b$export$1b3bfaa9684536aa(currentNode) && !$6855fcb605b0f44b$export$d1162fb0b6d4cd51(currentNode)){
if ($6855fcb605b0f44b$export$d6c4e8150c35fed1(currentNode)) return currentNode;
else currentNode = $6855fcb605b0f44b$export$4e12058fc4d51d56(currentNode);
}
return null;
}
function $6855fcb605b0f44b$export$78551043582a6a98() {
if (typeof CSS === "undefined" || !CSS.supports) return false;
return CSS.supports("-webkit-backdrop-filter", "none");
}
function $6855fcb605b0f44b$export$d1162fb0b6d4cd51(node) {
return [
"html",
"body",
"#document"
].includes($6855fcb605b0f44b$export$651544f548703224(node));
}
function $6855fcb605b0f44b$export$3735103072e4a80(element) {
return $6855fcb605b0f44b$export$38b2d434cce3ea22(element).getComputedStyle(element);
}
function $6855fcb605b0f44b$export$dc8fc79fa2800137(element) {
if ($6855fcb605b0f44b$export$45a5e7f76e0caa8d(element)) return {
scrollLeft: element.scrollLeft,
scrollTop: element.scrollTop
};
return {
scrollLeft: element.pageXOffset,
scrollTop: element.pageYOffset
};
}
function $6855fcb605b0f44b$export$4e12058fc4d51d56(node) {
if ($6855fcb605b0f44b$export$651544f548703224(node) === "html") return node;
const result = // Step into the shadow DOM of the parent of a slotted node.
node.assignedSlot || // DOM Element detected.
node.parentNode || // ShadowRoot detected.
$6855fcb605b0f44b$export$af51f0f06c0f328a(node) && node.host || // Fallback.
$6855fcb605b0f44b$export$e495491855dc5418(node);
return $6855fcb605b0f44b$export$af51f0f06c0f328a(result) ? result.host : result;
}
function $6855fcb605b0f44b$export$7cd01a57c8ca906c(node) {
const parentNode = $6855fcb605b0f44b$export$4e12058fc4d51d56(node);
if ($6855fcb605b0f44b$export$d1162fb0b6d4cd51(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
if ($6855fcb605b0f44b$export$1b3bfaa9684536aa(parentNode) && $6855fcb605b0f44b$export$989e911fa9af580a(parentNode)) return parentNode;
return $6855fcb605b0f44b$export$7cd01a57c8ca906c(parentNode);
}
function $6855fcb605b0f44b$export$3b57c1601291186b(node, list, traverseIframes) {
var _node$ownerDocument2;
if (list === void 0) list = [];
if (traverseIframes === void 0) traverseIframes = true;
const scrollableAncestor = $6855fcb605b0f44b$export$7cd01a57c8ca906c(node);
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
const win = $6855fcb605b0f44b$export$38b2d434cce3ea22(scrollableAncestor);
if (isBody) return list.concat(win, win.visualViewport || [], $6855fcb605b0f44b$export$989e911fa9af580a(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? $6855fcb605b0f44b$export$3b57c1601291186b(win.frameElement) : []);
return list.concat(scrollableAncestor, $6855fcb605b0f44b$export$3b57c1601291186b(scrollableAncestor, [], traverseIframes));
}
});
parcelRegister("fvpw6", function(module, exports) {
$parcel$export(module.exports, "sides", () => $b49d8b63aada88c5$export$832b6fa47fa053d2);
$parcel$export(module.exports, "placements", () => $b49d8b63aada88c5$export$803cd8101b6c182b);
$parcel$export(module.exports, "min", () => $b49d8b63aada88c5$export$96ec731ed4dcb222);
$parcel$export(module.exports, "max", () => $b49d8b63aada88c5$export$8960430cfd85939f);
$parcel$export(module.exports, "round", () => $b49d8b63aada88c5$export$2077e0241d6afd3c);
$parcel$export(module.exports, "floor", () => $b49d8b63aada88c5$export$a3fe094919f356fd);
$parcel$export(module.exports, "createCoords", () => $b49d8b63aada88c5$export$a397704b5e280835);
$parcel$export(module.exports, "clamp", () => $b49d8b63aada88c5$export$7d15b64cf5a3a4c4);
$parcel$export(module.exports, "evaluate", () => $b49d8b63aada88c5$export$fef61f332f2c0afc);
$parcel$export(module.exports, "getSide", () => $b49d8b63aada88c5$export$3c915306cb7fc97a);
$parcel$export(module.exports, "getAlignment", () => $b49d8b63aada88c5$export$f0989780f32bfcda);
$parcel$export(module.exports, "getOppositeAxis", () => $b49d8b63aada88c5$export$8a000a963141ac32);
$parcel$export(module.exports, "getAxisLength", () => $b49d8b63aada88c5$export$320bd9d53520c68a);
$parcel$export(module.exports, "getSideAxis", () => $b49d8b63aada88c5$export$f28e8f882010718a);
$parcel$export(module.exports, "getAlignmentAxis", () => $b49d8b63aada88c5$export$2b57e0052a6d6d4c);
$parcel$export(module.exports, "getAlignmentSides", () => $b49d8b63aada88c5$export$be42861551f17911);
$parcel$export(module.exports, "getOppositePlacement", () => $b49d8b63aada88c5$export$9c5e28bad23365fa);
$parcel$export(module.exports, "getExpandedPlacements", () => $b49d8b63aada88c5$export$496432a3699e50b1);
$parcel$export(module.exports, "getOppositeAlignmentPlacement", () => $b49d8b63aada88c5$export$2b182c584985588b);
$parcel$export(module.exports, "getOppositeAxisPlacements", () => $b49d8b63aada88c5$export$a9b6fb18fd92c3ec);
$parcel$export(module.exports, "getPaddingObject", () => $b49d8b63aada88c5$export$598c291c29bc2e71);
$parcel$export(module.exports, "rectToClientRect", () => $b49d8b63aada88c5$export$ee05aea0aeecbad4);
const $b49d8b63aada88c5$export$832b6fa47fa053d2 = [
"top",
"right",
"bottom",
"left"
];
const $b49d8b63aada88c5$export$27b07d8a310ed8b5 = [
"start",
"end"
];
const $b49d8b63aada88c5$export$803cd8101b6c182b = /*#__PURE__*/ $b49d8b63aada88c5$export$832b6fa47fa053d2.reduce((acc, side)=>acc.concat(side, side + "-" + $b49d8b63aada88c5$export$27b07d8a310ed8b5[0], side + "-" + $b49d8b63aada88c5$export$27b07d8a310ed8b5[1]), []);
const $b49d8b63aada88c5$export$96ec731ed4dcb222 = Math.min;
const $b49d8b63aada88c5$export$8960430cfd85939f = Math.max;
const $b49d8b63aada88c5$export$2077e0241d6afd3c = Math.round;
const $b49d8b63aada88c5$export$a3fe094919f356fd = Math.floor;
const $b49d8b63aada88c5$export$a397704b5e280835 = (v)=>({
x: v,
y: v
});
const $b49d8b63aada88c5$var$oppositeSideMap = {
left: "right",
right: "left",
bottom: "top",
top: "bottom"
};
const $b49d8b63aada88c5$var$oppositeAlignmentMap = {
start: "end",
end: "start"
};
function $b49d8b63aada88c5$export$7d15b64cf5a3a4c4(start, value, end) {
return $b49d8b63aada88c5$export$8960430cfd85939f(start, $b49d8b63aada88c5$export$96ec731ed4dcb222(value, end));
}
function $b49d8b63aada88c5$export$fef61f332f2c0afc(value, param) {
return typeof value === "function" ? value(param) : value;
}
function $b49d8b63aada88c5$export$3c915306cb7fc97a(placement) {
return placement.split("-")[0];
}
function $b49d8b63aada88c5$export$f0989780f32bfcda(placement) {
return placement.split("-")[1];
}
function $b49d8b63aada88c5$export$8a000a963141ac32(axis) {
return axis === "x" ? "y" : "x";
}
function $b49d8b63aada88c5$export$320bd9d53520c68a(axis) {
return axis === "y" ? "height" : "width";
}
function $b49d8b63aada88c5$export$f28e8f882010718a(placement) {
return [
"top",
"bottom"
].includes($b49d8b63aada88c5$export$3c915306cb7fc97a(placement)) ? "y" : "x";
}
function $b49d8b63aada88c5$export$2b57e0052a6d6d4c(placement) {
return $b49d8b63aada88c5$export$8a000a963141ac32($b49d8b63aada88c5$export$f28e8f882010718a(placement));
}
function $b49d8b63aada88c5$export$be42861551f17911(placement, rects, rtl) {
if (rtl === void 0) rtl = false;
const alignment = $b49d8b63aada88c5$export$f0989780f32bfcda(placement);
const alignmentAxis = $b49d8b63aada88c5$export$2b57e0052a6d6d4c(placement);
const length = $b49d8b63aada88c5$export$320bd9d53520c68a(alignmentAxis);
let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = $b49d8b63aada88c5$export$9c5e28bad23365fa(mainAlignmentSide);
return [
mainAlignmentSide,
$b49d8b63aada88c5$export$9c5e28bad23365fa(mainAlignmentSide)
];
}
function $b49d8b63aada88c5$export$496432a3699e50b1(placement) {
const oppositePlacement = $b49d8b63aada88c5$export$9c5e28bad23365fa(placement);
return [
$b49d8b63aada88c5$export$2b182c584985588b(placement),
oppositePlacement,
$b49d8b63aada88c5$export$2b182c584985588b(oppositePlacement)
];
}
function $b49d8b63aada88c5$export$2b182c584985588b(placement) {
return placement.replace(/start|end/g, (alignment)=>$b49d8b63aada88c5$var$oppositeAlignmentMap[alignment]);
}
function $b49d8b63aada88c5$var$getSideList(side, isStart, rtl) {
const lr = [
"left",
"right"
];
const rl = [
"right",
"left"
];
const tb = [
"top",
"bottom"
];
const bt = [
"bottom",
"top"
];
switch(side){
case "top":
case "bottom":
if (rtl) return isStart ? rl : lr;
return isStart ? lr : rl;
case "left":
case "right":
return isStart ? tb : bt;
default:
return [];
}
}
function $b49d8b63aada88c5$export$a9b6fb18fd92c3ec(placement, flipAlignment, direction, rtl) {
const alignment = $b49d8b63aada88c5$export$f0989780f32bfcda(placement);
let list = $b49d8b63aada88c5$var$getSideList($b49d8b63aada88c5$export$3c915306cb7fc97a(placement), direction === "start", rtl);
if (alignment) {
list = list.map((side)=>side + "-" + alignment);
if (flipAlignment) list = list.concat(list.map($b49d8b63aada88c5$export$2b182c584985588b));
}
return list;
}
function $b49d8b63aada88c5$export$9c5e28bad23365fa(placement) {
return placement.replace(/left|right|bottom|top/g, (side)=>$b49d8b63aada88c5$var$oppositeSideMap[side]);
}
function $b49d8b63aada88c5$export$1c66dbf1a9e34223(padding) {
return {
top: 0,
right: 0,
bottom: 0,
left: 0,
...padding
};
}
function $b49d8b63aada88c5$export$598c291c29bc2e71(padding) {
return typeof padding !== "number" ? $b49d8b63aada88c5$export$1c66dbf1a9e34223(padding) : {
top: padding,
right: padding,
bottom: padding,
left: padding
};
}
function $b49d8b63aada88c5$export$ee05aea0aeecbad4(rect) {
return {
...rect,
top: rect.y,
left: rect.x,
right: rect.x + rect.width,
bottom: rect.y + rect.height
};
}
});
parcelRegister("2Dcmu", function(module, exports) {
$parcel$export(module.exports, "arrow", () => $1ea8d0139225f984$export$f2120bbfa5450bd2);
$parcel$export(module.exports, "useFloating", () => $1ea8d0139225f984$export$4e02a5c1d08bac65);
var $l2jTt = parcelRequire("l2jTt");
var $91fsP = parcelRequire("91fsP");
var $8Xnp2 = parcelRequire("8Xnp2");
var $63SH6 = parcelRequire("63SH6");
var $grDIR = parcelRequire("grDIR");
/**
* Provides data to position an inner element of the floating element so that it
* appears centered to the reference element.
* This wraps the core `arrow` middleware to allow React refs as the element.
* @see https://floating-ui.com/docs/arrow
*/ const $1ea8d0139225f984$export$f2120bbfa5450bd2 = (options)=>{
function isRef(value) {
return ({}).hasOwnProperty.call(value, "current");
}
return {
name: "arrow",
options: options,
fn (state) {
const { element: element, padding: padding } = typeof options === "function" ? options(state) : options;
if (element && isRef(element)) {
if (element.current != null) return (0, $l2jTt.arrow)({
element: element.current,
padding: padding
}).fn(state);
return {};
} else if (element) return (0, $l2jTt.arrow)({
element: element,
padding: padding
}).fn(state);
return {};
}
};
};
var $1ea8d0139225f984$var$index = typeof document !== "undefined" ? (0, $63SH6.useLayoutEffect) : (0, $63SH6.useEffect);
// Fork of `fast-deep-equal` that only does the comparisons we need and compares
// functions
function $1ea8d0139225f984$var$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, i, 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 (!$1ea8d0139225f984$var$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 (!$1ea8d0139225f984$var$deepEqual(a[key], b[key])) return false;
}
return true;
}
return a !== a && b !== b;
}
function $1ea8d0139225f984$var$getDPR(element) {
if (typeof window === "undefined") return 1;
const win = element.ownerDocument.defaultView || window;
return win.devicePixelRatio || 1;
}
function $1ea8d0139225f984$var$roundByDPR(element, value) {
const dpr = $1ea8d0139225f984$var$getDPR(element);
return Math.round(value * dpr) / dpr;
}
function $1ea8d0139225f984$var$useLatestRef(value) {
const ref = $63SH6.useRef(value);
$1ea8d0139225f984$var$index(()=>{
ref.current = value;
});
return ref;
}
/**
* Provides data to position a floating element.
* @see https://floating-ui.com/docs/react
*/ function $1ea8d0139225f984$export$4e02a5c1d08bac65(options) {
if (options === void 0) options = {};
const { placement: placement = "bottom", strategy: strategy = "absolute", middleware: middleware = [], platform: platform, elements: { reference: externalReference, floating: externalFloating } = {}, transform: transform = true, whileElementsMounted: whileElementsMounted, open: open } = options;
const [data, setData] = $63SH6.useState({
x: 0,
y: 0,
strategy: strategy,
placement: placement,
middlewareData: {},
isPositioned: false
});
const [latestMiddleware, setLatestMiddleware] = $63SH6.useState(middleware);
if (!$1ea8d0139225f984$var$deepEqual(latestMiddleware, middleware)) setLatestMiddleware(middleware);
const [_reference, _setReference] = $63SH6.useState(null);
const [_floating, _setFloating] = $63SH6.useState(null);
const setReference = $63SH6.useCallback((node)=>{
if (node != referenceRef.current) {
referenceRef.current = node;
_setReference(node);
}
}, [
_setReference
]);
const setFloating = $63SH6.useCallback((node)=>{
if (node !== floatingRef.current) {
floatingRef.current = node;
_setFloating(node);
}
}, [
_setFloating
]);
const referenceEl = externalReference || _reference;
const floatingEl = externalFloating || _floating;
const referenceRef = $63SH6.useRef(null);
const floatingRef = $63SH6.useRef(null);
const dataRef = $63SH6.useRef(data);
const whileElementsMountedRef = $1ea8d0139225f984$var$useLatestRef(whileElementsMounted);
const platformRef = $1ea8d0139225f984$var$useLatestRef(platform);
const update = $63SH6.useCallback(()=>{
if (!referenceRef.current || !floatingRef.current) return;
const config = {
placement: placement,
strategy: strategy,
middleware: latestMiddleware
};
if (platformRef.current) config.platform = platformRef.current;
(0, $91fsP.computePosition)(referenceRef.current, floatingRef.current, config).then((data)=>{
const fullData = {
...data,
isPositioned: true
};
if (isMountedRef.current && !$1ea8d0139225f984$var$deepEqual(dataRef.current, fullData)) {
dataRef.current = fullData;
$grDIR.flushSync(()=>{
setData(fullData);
});
}
});
}, [
latestMiddleware,
placement,
strategy,
platformRef
]);
$1ea8d0139225f984$var$index(()=>{
if (open === false && dataRef.current.isPositioned) {
dataRef.current.isPositioned = false;
setData((data)=>({
...data,
isPositioned: false
}));
}
}, [
open
]);
const isMountedRef = $63SH6.useRef(false);
$1ea8d0139225f984$var$index(()=>{
isMountedRef.current = true;
return ()=>{
isMountedRef.current = false;
};
}, []);
$1ea8d0139225f984$var$index(()=>{
if (referenceEl) referenceRef.current = referenceEl;
if (floatingEl) floatingRef.current = floatingEl;
if (referenceEl && floatingEl) {
if (whileElementsMountedRef.current) return whileElementsMountedRef.current(referenceEl, floatingEl, update);
else update();
}
}, [
referenceEl,
floatingEl,
update,
whileElementsMountedRef
]);
const refs = $63SH6.useMemo(()=>({
reference: referenceRef,
floating: floatingRef,
setReference: setReference,
setFloating: setFloating
}), [
setReference,
setFloating
]);
const elements = $63SH6.useMemo(()=>({
reference: referenceEl,
floating: floatingEl
}), [
referenceEl,
floatingEl
]);
const floatingStyles = $63SH6.useMemo(()=>{
const initialStyles = {
position: strategy,
left: 0,
top: 0
};
if (!elements.floating) return initialStyles;
const x = $1ea8d0139225f984$var$roundByDPR(elements.floating, data.x);
const y = $1ea8d0139225f984$var$roundByDPR(elements.floating, data.y);
if (transform) return {
...initialStyles,
transform: "translate(" + x + "px, " + y + "px)",
...$1ea8d0139225f984$var$getDPR(elements.floating) >= 1.5 && {
willChange: "transform"
}
};
return {
position: strategy,
left: x,
top: y
};
}, [
strategy,
transform,
elements.floating,
data.x,
data.y
]);
return $63SH6.useMemo(()=>({
...data,
update: update,
refs: refs,
elements: elements,
floatingStyles: floatingStyles
}), [
data,
update,
refs,
elements,
floatingStyles
]);
}
});
parcelRegister("l2jTt", function(module, exports) {
$parcel$export(module.exports, "computePosition", () => $f50937607e0de9ef$export$48a53dcb22e581d0);
$parcel$export(module.exports, "detectOverflow", () => $f50937607e0de9ef$export$37b6bde19b108ecc);
$parcel$export(module.exports, "arrow", () => $f50937607e0de9ef$export$f2120bbfa5450bd2);
$parcel$export(module.exports, "flip", () => $f50937607e0de9ef$export$8a83211c878a3f1f);
$parcel$export(module.exports, "offset", () => $f50937607e0de9ef$export$cc800923e997bb8);
$parcel$export(module.exports, "shift", () => $f50937607e0de9ef$export$fba63a578e423eb);
$parcel$export(module.exports, "rectToClientRect", () => (parcelRequire("fvpw6")).rectToClientRect);
var $fvpw6 = parcelRequire("fvpw6");
function $f50937607e0de9ef$var$computeCoordsFromPlacement(_ref, placement, rtl) {
let { reference: reference, floating: floating } = _ref;
const sideAxis = (0, $fvpw6.getSideAxis)(placement);
const alignmentAxis = (0, $fvpw6.getAlignmentAxis)(placement);
const alignLength = (0, $fvpw6.getAxisLength)(alignmentAxis);
const side = (0, $fvpw6.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((0, $fvpw6.getAlignment)(placement)){
case "start":
coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
break;
case "end":
coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
break;
}
return coords;
}
/**
* Computes the `x` and `y` coordinates that will place the floating element
* next to a reference element when it is given a certain positioning strategy.
*
* This export does not have any `platform` interface logic. You will need to
* write one for the platform you are using Floating UI with.
*/ const $f50937607e0de9ef$export$48a53dcb22e581d0 = async (reference, floating, config)=>{
const { placement: placement = "bottom", strategy: strategy = "absolute", middleware: middleware = [], platform: platform } = config;
const validMiddleware = middleware.filter(Boolean);
const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
let rects = await platform.getElementRects({
reference: reference,
floating: floating,
strategy: strategy
});
let { x: x, y: y } = $f50937607e0de9ef$var$computeCoordsFromPlacement(rects, placement, rtl);
let statefulPlacement = placement;
let middlewareData = {};
let resetCount = 0;
for(let i = 0; i < validMiddleware.length; i++){
const { name: name, fn: fn } = validMiddleware[i];
const { x: nextX, y: nextY, data: data, reset: reset } = await fn({
x: x,
y: y,
initialPlacement: placement,
placement: statefulPlacement,
strategy: strategy,
middlewareData: middlewareData,
rects: rects,
platform: platform,
elements: {
reference: reference,
floating: 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.getElementRects({
reference: reference,
floating: floating,
strategy: strategy
}) : reset.rects;
({ x: x, y: y } = $f50937607e0de9ef$var$computeCoordsFromPlacement(rects, statefulPlacement, rtl));
}
i = -1;
continue;
}
}
return {
x: x,
y: y,
placement: statefulPlacement,
strategy: strategy,
middlewareData: middlewareData
};
};
/**
* Resolves with an object of overflow side offsets that determine how much the
* element is overflowing a given clipping boundary on each side.
* - positive = overflowing the boundary by that number of pixels
* - negative = how many pixels left before it will overflow
* - 0 = lies flush with the boundary
* @see https://floating-ui.com/docs/detectOverflow
*/ async function $f50937607e0de9ef$export$37b6bde19b108ecc(state, options) {
var _await$platform$isEle;
if (options === void 0) options = {};
const { x: x, y: y, platform: platform, rects: rects, elements: elements, strategy: strategy } = state;
const { boundary: boundary = "clippingAncestors", rootBoundary: rootBoundary = "viewport", elementContext: elementContext = "floating", altBoundary: altBoundary = false, padding: padding = 0 } = (0, $fvpw6.evaluate)(options, state);
const paddingObject = (0, $fvpw6.getPaddingObject)(padding);
const altContext = elementContext === "floating" ? "reference" : "floating";
const element = elements[altBoundary ? altContext : elementContext];
const clippingClientRect = (0, $fvpw6.rectToClientRect)(await platform.getClippingRect({
element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
boundary: boundary,
rootBoundary: rootBoundary,
strategy: strategy
}));
const rect = elementContext === "floating" ? {
...rects.floating,
x: x,
y: y
} : rects.reference;
const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
x: 1,
y: 1
} : {
x: 1,
y: 1
};
const elementClientRect = (0, $fvpw6.rectToClientRect)(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
rect: rect,
offsetParent: offsetParent,
strategy: 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
};
}
/**
* Provides data to position an inner element of the floating element so that it
* appears centered to the reference element.
* @see https://floating-ui.com/docs/arrow
*/ const $f50937607e0de9ef$export$f2120bbfa5450bd2 = (options)=>({
name: "arrow",
options: options,
async fn (state) {
const { x: x, y: y, placement: placement, rects: rects, platform: platform, elements: elements, middlewareData: middlewareData } = state;
// Since `element` is required, we don't Partial<> the type.
const { element: element, padding: padding = 0 } = (0, $fvpw6.evaluate)(options, state) || {};
if (element == null) return {};
const paddingObject = (0, $fvpw6.getPaddingObject)(padding);
const coords = {
x: x,
y: y
};
const axis = (0, $fvpw6.getAlignmentAxis)(placement);
const length = (0, $fvpw6.getAxisLength)(axis);
const arrowDimensions = await platform.getDimensions(element);
const isYAxis = axis === "y";
const minProp = isYAxis ? "top" : "left";
const maxProp = isYAxis ? "bottom" : "right";
const clientProp = isYAxis ? "clientHeight" : "clientWidth";
const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
const startDiff = coords[axis] - rects.reference[axis];
const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
// DOM platform can return `window` as the `offsetParent`.
if (!clientSize || !await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent))) clientSize = elements.floating[clientProp] || rects.floating[length];
const centerToReference = endDiff / 2 - startDiff / 2;
// If the padding is large enough that it causes the arrow to no longer be
// centered, modify the padding so that it is centered.
const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
const minPadding = (0, $fvpw6.min)(paddingObject[minProp], largestPossiblePadding);
const maxPadding = (0, $fvpw6.min)(paddingObject[maxProp], largestPossiblePadding);
// Make sure the arrow doesn't overflow the floating element if the center
// point is outside the floating element's bounds.
const min$1 = minPadding;
const max = clientSize - arrowDimensions[length] - maxPadding;
const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
const offset = (0, $fvpw6.clamp)(min$1, center, max);
// If the reference is small enough that the arrow's padding causes it to
// to point to nothing for an aligned placement, adjust the offset of the
// floating element itself. To ensure `shift()` continues to take action,
// a single reset is performed when this is true.
const shouldAddOffset = !middlewareData.arrow && (0, $fvpw6.getAlignment)(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
return {
[axis]: coords[axis] + alignmentOffset,
data: {
[axis]: offset,
centerOffset: center - offset - alignmentOffset,
...shouldAddOffset && {
alignmentOffset: alignmentOffset
}
},
reset: shouldAddOffset
};
}
});
function $f50937607e0de9ef$var$getPlacementList(alignment, autoAlignment, allowedPlacements) {
const allowedPlacementsSortedByAlignment = alignment ? [
...allowedPlacements.filter((placement)=>(0, $fvpw6.getAlignment)(placement) === alignment),
...allowedPlacements.filter((placement)=>(0, $fvpw6.getAlignment)(placement) !== alignment)
] : allowedPlacements.filter((placement)=>(0, $fvpw6.getSide)(placement) === placement);
return allowedPlacementsSortedByAlignment.filter((placement)=>{
if (alignment) return (0, $fvpw6.getAlignment)(placement) === alignment || (autoAlignment ? (0, $fvpw6.getOppositeAlignmentPlacement)(placement) !== placement : false);
return true;
});
}
/**
* Optimizes the visibility of the floating element by choosing the placement
* that has the most space available automatically, without needing to specify a
* preferred placement. Alternative to `flip`.
* @see https://floating-ui.com/docs/autoPlacement
*/ const $f50937607e0de9ef$export$91fb6ecbd551914 = function(options) {
if (options === void 0) options = {};
return {
name: "autoPlacement",
options: options,
async fn (state) {
var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
const { rects: rects, middlewareData: middlewareData, placement: placement, platform: platform, elements: elements } = state;
const { crossAxis: crossAxis = false, alignment: alignment, allowedPlacements: allowedPlacements = (0, $fvpw6.placements), autoAlignment: autoAlignment = true, ...detectOverflowOptions } = (0, $fvpw6.evaluate)(options, state);
const placements$1 = alignment !== undefined || allowedPlacements === (0, $fvpw6.placements) ? $f50937607e0de9ef$var$getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
const overflow = await $f50937607e0de9ef$export$37b6bde19b108ecc(state, detectOverflowOptions);
const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
const currentPlacement = placements$1[currentIndex];
if (currentPlacement == null) return {};
const alignmentSides = (0, $fvpw6.getAlignmentSides)(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
// Make `computeCoords` start from the right place.
if (placement !== currentPlacement) return {
reset: {
placement: placements$1[0]
}
};
const currentOverflows = [
overflow[(0, $fvpw6.getSide)(currentPlacement)],
overflow[alignmentSides[0]],
overflow[alignmentSides[1]]
];
const allOverflows = [
...((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || [],
{
placement: currentPlacement,
overflows: currentOverflows
}
];
const nextPlacement = placements$1[currentIndex + 1];
// There are more placements to check.
if (nextPlacement) return {
data: {
index: currentIndex + 1,
overflows: allOverflows
},
reset: {
placement: nextPlacement
}
};
const placementsSortedByMostSpace = allOverflows.map((d)=>{
const alignment = (0, $fvpw6.getAlignment)(d.placement);
return [
d.placement,
alignment && crossAxis ? // Check along the mainAxis and main crossAxis side.
d.overflows.slice(0, 2).reduce((acc, v)=>acc + v, 0) : // Check only the mainAxis.
d.overflows[0],
d.overflows
];
}).sort((a, b)=>a[1] - b[1]);
const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter((d)=>d[2].slice(0, // Aligned placements should not check their opposite crossAxis
// side.
(0, $fvpw6.getAlignment)(d[0]) ? 2 : 3).every((v)=>v <= 0));
const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
if (resetPlacement !== placement) return {
data: {
index: currentIndex + 1,
overflows: allOverflows
},
reset: {
placement: resetPlacement
}
};
return {};
}
};
};
/**
* Optimizes the visibility of the floating element by flipping the `placement`
* in order to keep it in view when the preferred placement(s) will overflow the
* clipping boundary. Alternative to `autoPlacement`.
* @see https://floating-ui.com/docs/flip
*/ const $f50937607e0de9ef$export$8a83211c878a3f1f = function(options) {
if (options === void 0) options = {};
return {
name: "flip",
options: options,
async fn (state) {
var _middlewareData$arrow, _middlewareData$flip;
const { placement: placement, middlewareData: middlewareData, rects: rects, initialPlacement: initialPlacement, platform: platform, elements: elements } = state;
const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy: fallbackStrategy = "bestFit", fallbackAxisSideDirection: fallbackAxisSideDirection = "none", flipAlignment: flipAlignment = true, ...detectOverflowOptions } = (0, $fvpw6.evaluate)(options, state);
// If a reset by the arrow was caused due to an alignment offset being
// added, we should skip any logic now since `flip()` has already done its
// work.
// https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
const side = (0, $fvpw6.getSide)(placement);
const isBasePlacement = (0, $fvpw6.getSide)(initialPlacement) === initialPlacement;
const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [
(0, $fvpw6.getOppositePlacement)(initialPlacement)
] : (0, $fvpw6.getExpandedPlacements)(initialPlacement));
if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== "none") fallbackPlacements.push(...(0, $fvpw6.getOppositeAxisPlacements)(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
const placements = [
initialPlacement,
...fallbackPlacements
];
const overflow = await $f50937607e0de9ef$export$37b6bde19b108ecc(state, detectOverflowOptions);
const overflows = [];
let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
if (checkMainAxis) overflows.push(overflow[side]);
if (checkCrossAxis) {
const sides = (0, $fvpw6.getAlignmentSides)(placement, rects, rtl);
overflows.push(overflow[sides[0]], overflow[sides[1]]);
}
overflowsData = [
...overflowsData,
{
placement: placement,
overflows: overflows
}
];
// One or more sides is overflowing.
if (!overflows.every((side)=>side <= 0)) {
var _middlewareData$flip2, _overflowsData$filter;
const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
const nextPlacement = placements[nextIndex];
if (nextPlacement) // Try next placement and re-run the lifecycle.
return {
data: {
index: nextIndex,
overflows: overflowsData
},
reset: {
placement: nextPlacement
}
};
// First, find the candidates that fit on the mainAxis side of overflow,
// then find the placement that fits the best on the main crossAxis side.
let resetPlacement = (_overflowsData$filter = overflowsData.filter((d)=>d.overflows[0] <= 0).sort((a, b)=>a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
// Otherwise fallback.
if (!resetPlacement) switch(fallbackStrategy){
case "bestFit":
{
var _overflowsData$map$so;
const placement = (_overflowsData$map$so = overflowsData.map((d)=>[
d.placement,
d.overflows.filter((overflow)=>overflow > 0).reduce((acc, overflow)=>acc + overflow, 0)
]).sort((a, b)=>a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
if (placement) resetPlacement = placement;
break;
}
case "initialPlacement":
resetPlacement = initialPlacement;
break;
}
if (placement !== resetPlacement) return {
reset: {
placement: resetPlacement
}
};
}
return {};
}
};
};
function $f50937607e0de9ef$var$getSideOffsets(overflow, rect) {
return {
top: overflow.top - rect.height,
right: overflow.right - rect.width,
bottom: overflow.bottom - rect.height,
left: overflow.left - rect.width
};
}
function $f50937607e0de9ef$var$isAnySideFullyClipped(overflow) {
return (0, $fvpw6.sides).some((side)=>overflow[side] >= 0);
}
/**
* Provides data to hide the floating element in applicable situations, such as
* when it is not in the same clipping context as the reference element.
* @see https://floating-ui.com/docs/hide
*/ const $f50937607e0de9ef$export$fe8985bb6374093c = function(options) {
if (options === void 0) options = {};
return {
name: "hide",
options: options,
async fn (state) {
const { rects: rects } = state;
const { strategy: strategy = "referenceHidden", ...detectOverflowOptions } = (0, $fvpw6.evaluate)(options, state);
switch(strategy){
case "referenceHidden":
{
const overflow = await $f50937607e0de9ef$export$37b6bde19b108ecc(state, {
...detectOverflowOptions,
elementContext: "reference"
});
const offsets = $f50937607e0de9ef$var$getSideOffsets(overflow, rects.reference);
return {
data: {
referenceHiddenOffsets: offsets,
referenceHidden: $f50937607e0de9ef$var$isAnySideFullyClipped(offsets)
}
};
}
case "escaped":
{
const overflow = await $f50937607e0de9ef$export$37b6bde19b108ecc(state, {
...detectOverflowOptions,
altBoundary: true
});
const offsets = $f50937607e0de9ef$var$getSideOffsets(overflow, rects.floating);
return {
data: {
escapedOffsets: offsets,
escaped: $f50937607e0de9ef$var$isAnySideFullyClipped(offsets)
}
};
}
default:
return {};
}
}
};
};
function $f50937607e0de9ef$var$getBoundingRect(rects) {
const minX = (0, $fvpw6.min)(...rects.map((rect)=>rect.left));
const minY = (0, $fvpw6.min)(...rects.map((rect)=>rect.top));
const maxX = (0, $fvpw6.max)(...rects.map((rect)=>rect.right));
const maxY = (0, $fvpw6.max)(...rects.map((rect)=>rect.bottom));
return {
x: minX,
y: minY,
width: maxX - minX,
height: maxY - minY
};
}
function $f50937607e0de9ef$var$getRectsByLine(rects) {
const sortedRects = rects.slice().sort((a, b)=>a.y - b.y);
const groups = [];
let prevRect = null;
for(let i = 0; i < sortedRects.length; i++){
const rect = sortedRects[i];
if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) groups.push([
rect
]);
else groups[groups.length - 1].push(rect);
prevRect = rect;
}
return groups.map((rect)=>(0, $fvpw6.rectToClientRect)($f50937607e0de9ef$var$getBoundingRect(rect)));
}
/**
* Provides improved positioning for inline reference elements that can span
* over multiple lines, such as hyperlinks or range selections.
* @see https://floating-ui.com/docs/inline
*/ const $f50937607e0de9ef$export$18c8ad048e32c7d5 = function(options) {
if (options === void 0) options = {};
return {
name: "inline",
options: options,
async fn (state) {
const { placement: placement, elements: elements, rects: rects, platform: platform, strategy: strategy } = state;
// A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
// ClientRect's bounds, despite the event listener being triggered. A
// padding of 2 seems to handle this issue.
const { padding: padding = 2, x: x, y: y } = (0, $fvpw6.evaluate)(options, state);
const nativeClientRects = Array.from(await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference)) || []);
const clientRects = $f50937607e0de9ef$var$getRectsByLine(nativeClientRects);
const fallback = (0, $fvpw6.rectToClientRect)($f50937607e0de9ef$var$getBoundingRect(nativeClientRects));
const paddingObject = (0, $fvpw6.getPaddingObject)(padding);
function getBoundingClientRect() {
// There are two rects and they are disjoined.
if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) // Find the first rect in which the point is fully inside.
return clientRects.find((rect)=>x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
// There are 2 or more connected rects.
if (clientRects.length >= 2) {
if ((0, $fvpw6.getSideAxis)(placement) === "y") {
const firstRect = clientRects[0];
const lastRect = clientRects[clientRects.length - 1];
const isTop = (0, $fvpw6.getSide)(placement) === "top";
const top = firstRect.top;
const bottom = lastRect.bottom;
const left = isTop ? firstRect.left : lastRect.left;
const right = isTop ? firstRect.right : lastRect.right;
const width = right - left;
const height = bottom - top;
return {
top: top,
bottom: bottom,
left: left,
right: right,
width: width,
height: height,
x: left,
y: top
};
}
const isLeftSide = (0, $fvpw6.getSide)(placement) === "left";
const maxRight = (0, $fvpw6.max)(...clientRects.map((rect)=>rect.right));
const minLeft = (0, $fvpw6.min)(...clientRects.map((rect)=>rect.left));
const measureRects = clientRects.filter((rect)=>isLeftSide ? rect.left === minLeft : rect.right === maxRight);
const top = measureRects[0].top;
const bottom = measureRects[measureRects.length - 1].bottom;
const left = minLeft;
const right = maxRight;
const width = right - left;
const height = bottom - top;
return {
top: top,
bottom: bottom,
left: left,
right: right,
width: width,
height: height,
x: left,
y: top
};
}
return fallback;
}
const resetRects = await platform.getElementRects({
reference: {
getBoundingClientRect: getBoundingClientRect
},
floating: elements.floating,
strategy: strategy
});
if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) return {
reset: {
rects: resetRects
}
};
return {};
}
};
};
// For type backwards-compatibility, the `OffsetOptions` type was also
// Derivable.
async function $f50937607e0de9ef$var$convertValueToCoords(state, options) {
const { placement: placement, platform: platform, elements: elements } = state;
const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
const side = (0, $fvpw6.getSide)(placement);
const alignment = (0, $fvpw6.getAlignment)(placement);
const isVertical = (0, $fvpw6.getSideAxis)(placement) === "y";
const mainAxisMulti = [
"left",
"top"
].includes(side) ? -1 : 1;
const crossAxisMulti = rtl && isVertical ? -1 : 1;
const rawValue = (0, $fvpw6.evaluate)(options, state);
// eslint-disable-next-line prefer-const
let { mainAxis: mainAxis, crossAxis: crossAxis, alignmentAxis: alignmentAxis } = typeof rawValue === "number" ? {
mainAxis: rawValue,
crossAxis: 0,
alignmentAxis: null
} : {
mainAxis: 0,
crossAxis: 0,
alignmentAxis: null,
...rawValue
};
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
};
}
/**
* Modifies the placement by translating the floating element along the
* specified axes.
* A number (shorthand for `mainAxis` or distance), or an axes configuration
* object may be passed.
* @see https://floating-ui.com/docs/offset
*/ const $f50937607e0de9ef$export$cc800923e997bb8 = function(options) {
if (options === void 0) options = 0;
return {
name: "offset",
options: options,
async fn (state) {
const { x: x, y: y } = state;
const diffCoords = await $f50937607e0de9ef$var$convertValueToCoords(state, options);
return {
x: x + diffCoords.x,
y: y + diffCoords.y,
data: diffCoords
};
}
};
};
/**
* Optimizes the visibility of the floating element by shifting it in order to
* keep it in view when it will overflow the clipping boundary.
* @see https://floating-ui.com/docs/shift
*/ const $f50937607e0de9ef$export$fba63a578e423eb = function(options) {
if (options === void 0) options = {};
return {
name: "shift",
options: options,
async fn (state) {
const { x: x, y: y, placement: placement } = state;
const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter: limiter = {
fn: (_ref)=>{
let { x: x, y: y } = _ref;
return {
x: x,
y: y
};
}
}, ...detectOverflowOptions } = (0, $fvpw6.evaluate)(options, state);
const coords = {
x: x,
y: y
};
const overflow = await $f50937607e0de9ef$export$37b6bde19b108ecc(state, detectOverflowOptions);
const crossAxis = (0, $fvpw6.getSideAxis)((0, $fvpw6.getSide)(placement));
const mainAxis = (0, $fvpw6.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 = mainAxisCoord + overflow[minSide];
const max = mainAxisCoord - overflow[maxSide];
mainAxisCoord = (0, $fvpw6.clamp)(min, mainAxisCoord, max);
}
if (checkCrossAxis) {
const minSide = crossAxis === "y" ? "top" : "left";
const maxSide = crossAxis === "y" ? "bottom" : "right";
const min = crossAxisCoord + overflow[minSide];
const max = crossAxisCoord - overflow[maxSide];
crossAxisCoord = (0, $fvpw6.clamp)(min, crossAxisCoord, max);
}
const limitedCoords = limiter.fn({
...state,
[mainAxis]: mainAxisCoord,
[crossAxis]: crossAxisCoord
});
return {
...limitedCoords,
data: {
x: limitedCoords.x - x,
y: limitedCoords.y - y
}
};
}
};
};
/**
* Built-in `limiter` that will stop `shift()` at a certain point.
*/ const $f50937607e0de9ef$export$7bf07e38f3dc4b69 = function(options) {
if (options === void 0) options = {};
return {
options: options,
fn (state) {
const { x: x, y: y, placement: placement, rects: rects, middlewareData: middlewareData } = state;
const { offset: offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true } = (0, $fvpw6.evaluate)(options, state);
const coords = {
x: x,
y: y
};
const crossAxis = (0, $fvpw6.getSideAxis)(placement);
const mainAxis = (0, $fvpw6.getOppositeAxis)(crossAxis);
let mainAxisCoord = coords[mainAxis];
let crossAxisCoord = coords[crossAxis];
const rawOffset = (0, $fvpw6.evaluate)(offset, state);
const computedOffset = typeof rawOffset === "number" ? {
mainAxis: rawOffset,
crossAxis: 0
} : {
mainAxis: 0,
crossAxis: 0,
...rawOffset
};
if (checkMainAxis) {
const len = mainAxis === "y" ? "height" : "width";
const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
if (mainAxisCoord < limitMin) mainAxisCoord = limitMin;
else if (mainAxisCoord > limitMax) mainAxisCoord = limitMax;
}
if (checkCrossAxis) {
var _middlewareData$offse, _middlewareData$offse2;
const len = mainAxis === "y" ? "width" : "height";
const isOriginSide = [
"top",
"left"
].includes((0, $fvpw6.getSide)(placement));
const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
if (crossAxisCoord < limitMin) crossAxisCoord = limitMin;
else if (crossAxisCoord > limitMax) crossAxisCoord = limitMax;
}
return {
[mainAxis]: mainAxisCoord,
[crossAxis]: crossAxisCoord
};
}
};
};
/**
* Provides data that allows you to change the size of the floating element —
* for instance, prevent it from overflowing the clipping boundary or match the
* width of the reference element.
* @see https://floating-ui.com/docs/size
*/ const $f50937607e0de9ef$export$346677f925de839c = function(options) {
if (options === void 0) options = {};
return {
name: "size",
options: options,
async fn (state) {
const { placement: placement, rects: rects, platform: platform, elements: elements } = state;
const { apply: apply = ()=>{}, ...detectOverflowOptions } = (0, $fvpw6.evaluate)(options, state);
const overflow = await $f50937607e0de9ef$export$37b6bde19b108ecc(state, detectOverflowOptions);
const side = (0, $fvpw6.getSide)(placement);
const alignment = (0, $fvpw6.getAlignment)(placement);
const isYAxis = (0, $fvpw6.getSideAxis)(placement) === "y";
const { width: width, height: height } = rects.floating;
let heightSide;
let widthSide;
if (side === "top" || side === "bottom") {
heightSide = side;
widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
} else {
widthSide = side;
heightSide = alignment === "end" ? "top" : "bottom";
}
const overflowAvailableHeight = height - overflow[heightSide];
const overflowAvailableWidth = width - overflow[widthSide];
const noShift = !state.middlewareData.shift;
let availableHeight = overflowAvailableHeight;
let availableWidth = overflowAvailableWidth;
if (isYAxis) {
const maximumClippingWidth = width - overflow.left - overflow.right;
availableWidth = alignment || noShift ? (0, $fvpw6.min)(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
} else {
const maximumClippingHeight = height - overflow.top - overflow.bottom;
availableHeight = alignment || noShift ? (0, $fvpw6.min)(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
}
if (noShift && !alignment) {
const xMin = (0, $fvpw6.max)(overflow.left, 0);
const xMax = (0, $fvpw6.max)(overflow.right, 0);
const yMin = (0, $fvpw6.max)(overflow.top, 0);
const yMax = (0, $fvpw6.max)(overflow.bottom, 0);
if (isYAxis) availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : (0, $fvpw6.max)(overflow.left, overflow.right));
else availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : (0, $fvpw6.max)(overflow.top, overflow.bottom));
}
await apply({
...state,
availableWidth: availableWidth,
availableHeight: availableHeight
});
const nextDimensions = await platform.getDimensions(elements.floating);
if (width !== nextDimensions.width || height !== nextDimensions.height) return {
reset: {
rects: true
}
};
return {};
}
};
};
});
parcelRegister("91fsP", function(module, exports) {
$parcel$export(module.exports, "platform", () => $691033dc47d95db1$export$722a64dea1b767dc);
$parcel$export(module.exports, "autoUpdate", () => $691033dc47d95db1$export$deee3a793edee05f);
$parcel$export(module.exports, "computePosition", () => $691033dc47d95db1$export$48a53dcb22e581d0);
$parcel$export(module.exports, "getOverflowAncestors", () => (parcelRequire("8Xnp2")).getOverflowAncestors);
parcelRequire("l2jTt");
var $fvpw6 = parcelRequire("fvpw6");
var $l2jTt = parcelRequire("l2jTt");
var $fvpw6 = parcelRequire("fvpw6");
var $8Xnp2 = parcelRequire("8Xnp2");
function $691033dc47d95db1$var$getCssDimensions(element) {
const css = (0, $8Xnp2.getComputedStyle)(element);
// In testing environments, the `width` and `height` properties are empty
// strings for SVG elements, returning NaN. Fallback to `0` in this case.
let width = parseFloat(css.width) || 0;
let height = parseFloat(css.height) || 0;
const hasOffset = (0, $8Xnp2.isHTMLElement)(element);
const offsetWidth = hasOffset ? element.offsetWidth : width;
const offsetHeight = hasOffset ? element.offsetHeight : height;
const shouldFallback = (0, $fvpw6.round)(width) !== offsetWidth || (0, $fvpw6.round)(height) !== offsetHeight;
if (shouldFallback) {
width = offsetWidth;
height = offsetHeight;
}
return {
width: width,
height: height,
$: shouldFallback
};
}
function $691033dc47d95db1$var$unwrapElement(element) {
return !(0, $8Xnp2.isElement)(element) ? element.contextElement : element;
}
function $691033dc47d95db1$var$getScale(element) {
const domElement = $691033dc47d95db1$var$unwrapElement(element);
if (!(0, $8Xnp2.isHTMLElement)(domElement)) return (0, $fvpw6.createCoords)(1);
const rect = domElement.getBoundingClientRect();
const { width: width, height: height, $: $ } = $691033dc47d95db1$var$getCssDimensions(domElement);
let x = ($ ? (0, $fvpw6.round)(rect.width) : rect.width) / width;
let y = ($ ? (0, $fvpw6.round)(rect.height) : rect.height) / height;
// 0, NaN, or Infinity should always fallback to 1.
if (!x || !Number.isFinite(x)) x = 1;
if (!y || !Number.isFinite(y)) y = 1;
return {
x: x,
y: y
};
}
const $691033dc47d95db1$var$noOffsets = /*#__PURE__*/ (0, $fvpw6.createCoords)(0);
function $691033dc47d95db1$var$getVisualOffsets(element) {
const win = (0, $8Xnp2.getWindow)(element);
if (!(0, $8Xnp2.isWebKit)() || !win.visualViewport) return $691033dc47d95db1$var$noOffsets;
return {
x: win.visualViewport.offsetLeft,
y: win.visualViewport.offsetTop
};
}
function $691033dc47d95db1$var$shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
if (isFixed === void 0) isFixed = false;
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== (0, $8Xnp2.getWindow)(element)) return false;
return isFixed;
}
function $691033dc47d95db1$var$getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
if (includeScale === void 0) includeScale = false;
if (isFixedStrategy === void 0) isFixedStrategy = false;
const clientRect = element.getBoundingClientRect();
const domElement = $691033dc47d95db1$var$unwrapElement(element);
let scale = (0, $fvpw6.createCoords)(1);
if (includeScale) {
if (offsetParent) {
if ((0, $8Xnp2.isElement)(offsetParent)) scale = $691033dc47d95db1$var$getScale(offsetParent);
} else scale = $691033dc47d95db1$var$getScale(element);
}
const visualOffsets = $691033dc47d95db1$var$shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? $691033dc47d95db1$var$getVisualOffsets(domElement) : (0, $fvpw6.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 = (0, $8Xnp2.getWindow)(domElement);
const offsetWin = offsetParent && (0, $8Xnp2.isElement)(offsetParent) ? (0, $8Xnp2.getWindow)(offsetParent) : offsetParent;
let currentIFrame = win.frameElement;
while(currentIFrame && offsetParent && offsetWin !== win){
const iframeScale = $691033dc47d95db1$var$getScale(currentIFrame);
const iframeRect = currentIFrame.getBoundingClientRect();
const css = (0, $8Xnp2.getComputedStyle)(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;
currentIFrame = (0, $8Xnp2.getWindow)(currentIFrame).frameElement;
}
}
return (0, $fvpw6.rectToClientRect)({
width: width,
height: height,
x: x,
y: y
});
}
function $691033dc47d95db1$var$convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
let { rect: rect, offsetParent: offsetParent, strategy: strategy } = _ref;
const isOffsetParentAnElement = (0, $8Xnp2.isHTMLElement)(offsetParent);
const documentElement = (0, $8Xnp2.getDocumentElement)(offsetParent);
if (offsetParent === documentElement) return rect;
let scroll = {
scrollLeft: 0,
scrollTop: 0
};
let scale = (0, $fvpw6.createCoords)(1);
const offsets = (0, $fvpw6.createCoords)(0);
if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
if ((0, $8Xnp2.getNodeName)(offsetParent) !== "body" || (0, $8Xnp2.isOverflowElement)(documentElement)) scroll = (0, $8Xnp2.getNodeScroll)(offsetParent);
if ((0, $8Xnp2.isHTMLElement)(offsetParent)) {
const offsetRect = $691033dc47d95db1$var$getBoundingClientRect(offsetParent);
scale = $691033dc47d95db1$var$getScale(offsetParent);
offsets.x = offsetRect.x + offsetParent.clientLeft;
offsets.y = offsetRect.y + offsetParent.clientTop;
}
}
return {
width: rect.width * scale.x,
height: rect.height * scale.y,
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
};
}
function $691033dc47d95db1$var$getClientRects(element) {
return Array.from(element.getClientRects());
}
function $691033dc47d95db1$var$getWindowScrollBarX(element) {
// If has a CSS width greater than the viewport, then this will be
// incorrect for RTL.
return $691033dc47d95db1$var$getBoundingClientRect((0, $8Xnp2.getDocumentElement)(element)).left + (0, $8Xnp2.getNodeScroll)(element).scrollLeft;
}
// Gets the entire size of the scrollable document area, even extending outside
// of the `` and `` rect bounds if horizontally scrollable.
function $691033dc47d95db1$var$getDocumentRect(element) {
const html = (0, $8Xnp2.getDocumentElement)(element);
const scroll = (0, $8Xnp2.getNodeScroll)(element);
const body = element.ownerDocument.body;
const width = (0, $fvpw6.max)(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
const height = (0, $fvpw6.max)(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
let x = -scroll.scrollLeft + $691033dc47d95db1$var$getWindowScrollBarX(element);
const y = -scroll.scrollTop;
if ((0, $8Xnp2.getComputedStyle)(body).direction === "rtl") x += (0, $fvpw6.max)(html.clientWidth, body.clientWidth) - width;
return {
width: width,
height: height,
x: x,
y: y
};
}
function $691033dc47d95db1$var$getViewportRect(element, strategy) {
const win = (0, $8Xnp2.getWindow)(element);
const html = (0, $8Xnp2.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 = (0, $8Xnp2.isWebKit)();
if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
x = visualViewport.offsetLeft;
y = visualViewport.offsetTop;
}
}
return {
width: width,
height: height,
x: x,
y: y
};
}
// Returns the inner client rect, subtracting scrollbars if present.
function $691033dc47d95db1$var$getInnerBoundingClientRect(element, strategy) {
const clientRect = $691033dc47d95db1$var$getBoundingClientRect(element, true, strategy === "fixed");
const top = clientRect.top + element.clientTop;
const left = clientRect.left + element.clientLeft;
const scale = (0, $8Xnp2.isHTMLElement)(element) ? $691033dc47d95db1$var$getScale(element) : (0, $fvpw6.createCoords)(1);
const width = element.clientWidth * scale.x;
const height = element.clientHeight * scale.y;
const x = left * scale.x;
const y = top * scale.y;
return {
width: width,
height: height,
x: x,
y: y
};
}
function $691033dc47d95db1$var$getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
let rect;
if (clippingAncestor === "viewport") rect = $691033dc47d95db1$var$getViewportRect(element, strategy);
else if (clippingAncestor === "document") rect = $691033dc47d95db1$var$getDocumentRect((0, $8Xnp2.getDocumentElement)(element));
else if ((0, $8Xnp2.isElement)(clippingAncestor)) rect = $691033dc47d95db1$var$getInnerBoundingClientRect(clippingAncestor, strategy);
else {
const visualOffsets = $691033dc47d95db1$var$getVisualOffsets(element);
rect = {
...clippingAncestor,
x: clippingAncestor.x - visualOffsets.x,
y: clippingAncestor.y - visualOffsets.y
};
}
return (0, $fvpw6.rectToClientRect)(rect);
}
function $691033dc47d95db1$var$hasFixedPositionAncestor(element, stopNode) {
const parentNode = (0, $8Xnp2.getParentNode)(element);
if (parentNode === stopNode || !(0, $8Xnp2.isElement)(parentNode) || (0, $8Xnp2.isLastTraversableNode)(parentNode)) return false;
return (0, $8Xnp2.getComputedStyle)(parentNode).position === "fixed" || $691033dc47d95db1$var$hasFixedPositionAncestor(parentNode, stopNode);
}
// A "clipping ancestor" is an `overflow` element with the characteristic of
// clipping (or hiding) child elements. This returns all clipping ancestors
// of the given element up the tree.
function $691033dc47d95db1$var$getClippingElementAncestors(element, cache) {
const cachedResult = cache.get(element);
if (cachedResult) return cachedResult;
let result = (0, $8Xnp2.getOverflowAncestors)(element, [], false).filter((el)=>(0, $8Xnp2.isElement)(el) && (0, $8Xnp2.getNodeName)(el) !== "body");
let currentContainingBlockComputedStyle = null;
const elementIsFixed = (0, $8Xnp2.getComputedStyle)(element).position === "fixed";
let currentNode = elementIsFixed ? (0, $8Xnp2.getParentNode)(element) : element;
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
while((0, $8Xnp2.isElement)(currentNode) && !(0, $8Xnp2.isLastTraversableNode)(currentNode)){
const computedStyle = (0, $8Xnp2.getComputedStyle)(currentNode);
const currentNodeIsContaining = (0, $8Xnp2.isContainingBlock)(currentNode);
if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && [
"absolute",
"fixed"
].includes(currentContainingBlockComputedStyle.position) || (0, $8Xnp2.isOverflowElement)(currentNode) && !currentNodeIsContaining && $691033dc47d95db1$var$hasFixedPositionAncestor(element, currentNode);
if (shouldDropCurrentNode) // Drop non-containing blocks.
result = result.filter((ancestor)=>ancestor !== currentNode);
else // Record last containing block for next iteration.
currentContainingBlockComputedStyle = computedStyle;
currentNode = (0, $8Xnp2.getParentNode)(currentNode);
}
cache.set(element, result);
return result;
}
// Gets the maximum area that the element is visible in due to any number of
// clipping ancestors.
function $691033dc47d95db1$var$getClippingRect(_ref) {
let { element: element, boundary: boundary, rootBoundary: rootBoundary, strategy: strategy } = _ref;
const elementClippingAncestors = boundary === "clippingAncestors" ? $691033dc47d95db1$var$getClippingElementAncestors(element, this._c) : [].concat(boundary);
const clippingAncestors = [
...elementClippingAncestors,
rootBoundary
];
const firstClippingAncestor = clippingAncestors[0];
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor)=>{
const rect = $691033dc47d95db1$var$getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
accRect.top = (0, $fvpw6.max)(rect.top, accRect.top);
accRect.right = (0, $fvpw6.min)(rect.right, accRect.right);
accRect.bottom = (0, $fvpw6.min)(rect.bottom, accRect.bottom);
accRect.left = (0, $fvpw6.max)(rect.left, accRect.left);
return accRect;
}, $691033dc47d95db1$var$getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
return {
width: clippingRect.right - clippingRect.left,
height: clippingRect.bottom - clippingRect.top,
x: clippingRect.left,
y: clippingRect.top
};
}
function $691033dc47d95db1$var$getDimensions(element) {
return $691033dc47d95db1$var$getCssDimensions(element);
}
function $691033dc47d95db1$var$getRectRelativeToOffsetParent(element, offsetParent, strategy) {
const isOffsetParentAnElement = (0, $8Xnp2.isHTMLElement)(offsetParent);
const documentElement = (0, $8Xnp2.getDocumentElement)(offsetParent);
const isFixed = strategy === "fixed";
const rect = $691033dc47d95db1$var$getBoundingClientRect(element, true, isFixed, offsetParent);
let scroll = {
scrollLeft: 0,
scrollTop: 0
};
const offsets = (0, $fvpw6.createCoords)(0);
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
if ((0, $8Xnp2.getNodeName)(offsetParent) !== "body" || (0, $8Xnp2.isOverflowElement)(documentElement)) scroll = (0, $8Xnp2.getNodeScroll)(offsetParent);
if (isOffsetParentAnElement) {
const offsetRect = $691033dc47d95db1$var$getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
offsets.x = offsetRect.x + offsetParent.clientLeft;
offsets.y = offsetRect.y + offsetParent.clientTop;
} else if (documentElement) offsets.x = $691033dc47d95db1$var$getWindowScrollBarX(documentElement);
}
return {
x: rect.left + scroll.scrollLeft - offsets.x,
y: rect.top + scroll.scrollTop - offsets.y,
width: rect.width,
height: rect.height
};
}
function $691033dc47d95db1$var$getTrueOffsetParent(element, polyfill) {
if (!(0, $8Xnp2.isHTMLElement)(element) || (0, $8Xnp2.getComputedStyle)(element).position === "fixed") return null;
if (polyfill) return polyfill(element);
return element.offsetParent;
}
// Gets the closest ancestor positioned element. Handles some edge cases,
// such as table ancestors and cross browser bugs.
function $691033dc47d95db1$var$getOffsetParent(element, polyfill) {
const window = (0, $8Xnp2.getWindow)(element);
if (!(0, $8Xnp2.isHTMLElement)(element)) return window;
let offsetParent = $691033dc47d95db1$var$getTrueOffsetParent(element, polyfill);
while(offsetParent && (0, $8Xnp2.isTableElement)(offsetParent) && (0, $8Xnp2.getComputedStyle)(offsetParent).position === "static")offsetParent = $691033dc47d95db1$var$getTrueOffsetParent(offsetParent, polyfill);
if (offsetParent && ((0, $8Xnp2.getNodeName)(offsetParent) === "html" || (0, $8Xnp2.getNodeName)(offsetParent) === "body" && (0, $8Xnp2.getComputedStyle)(offsetParent).position === "static" && !(0, $8Xnp2.isContainingBlock)(offsetParent))) return window;
return offsetParent || (0, $8Xnp2.getContainingBlock)(element) || window;
}
const $691033dc47d95db1$var$getElementRects = async function(_ref) {
let { reference: reference, floating: floating, strategy: strategy } = _ref;
const getOffsetParentFn = this.getOffsetParent || $691033dc47d95db1$var$getOffsetParent;
const getDimensionsFn = this.getDimensions;
return {
reference: $691033dc47d95db1$var$getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
floating: {
x: 0,
y: 0,
...await getDimensionsFn(floating)
}
};
};
function $691033dc47d95db1$var$isRTL(element) {
return (0, $8Xnp2.getComputedStyle)(element).direction === "rtl";
}
const $691033dc47d95db1$export$722a64dea1b767dc = {
convertOffsetParentRelativeRectToViewportRelativeRect: $691033dc47d95db1$var$convertOffsetParentRelativeRectToViewportRelativeRect,
getDocumentElement: $8Xnp2.getDocumentElement,
getClippingRect: $691033dc47d95db1$var$getClippingRect,
getOffsetParent: $691033dc47d95db1$var$getOffsetParent,
getElementRects: $691033dc47d95db1$var$getElementRects,
getClientRects: $691033dc47d95db1$var$getClientRects,
getDimensions: $691033dc47d95db1$var$getDimensions,
getScale: $691033dc47d95db1$var$getScale,
isElement: $8Xnp2.isElement,
isRTL: $691033dc47d95db1$var$isRTL
};
// https://samthor.au/2021/observing-dom/
function $691033dc47d95db1$var$observeMove(element, onMove) {
let io = null;
let timeoutId;
const root = (0, $8Xnp2.getDocumentElement)(element);
function cleanup() {
clearTimeout(timeoutId);
io && io.disconnect();
io = null;
}
function refresh(skip, threshold) {
if (skip === void 0) skip = false;
if (threshold === void 0) threshold = 1;
cleanup();
const { left: left, top: top, width: width, height: height } = element.getBoundingClientRect();
if (!skip) onMove();
if (!width || !height) return;
const insetTop = (0, $fvpw6.floor)(top);
const insetRight = (0, $fvpw6.floor)(root.clientWidth - (left + width));
const insetBottom = (0, $fvpw6.floor)(root.clientHeight - (top + height));
const insetLeft = (0, $fvpw6.floor)(left);
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
const options = {
rootMargin: rootMargin,
threshold: (0, $fvpw6.max)(0, (0, $fvpw6.min)(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);
}, 100);
else refresh(false, ratio);
}
isFirstUpdate = false;
}
// Older browsers don't support a `document` as the root and will throw an
// error.
try {
io = new IntersectionObserver(handleObserve, {
...options,
// Handle