@react-aria/overlays 3.12.1 → 3.14.0

package/dist/import.mjs

@@ -0,0 +1,1457 @@
+import $k7QOs$react, {useState as $k7QOs$useState, useCallback as $k7QOs$useCallback, useRef as $k7QOs$useRef, useEffect as $k7QOs$useEffect, useContext as $k7QOs$useContext, useMemo as $k7QOs$useMemo} from "react";
+import {useLayoutEffect as $k7QOs$useLayoutEffect, useResizeObserver as $k7QOs$useResizeObserver, clamp as $k7QOs$clamp, useId as $k7QOs$useId, isIOS as $k7QOs$isIOS, chain as $k7QOs$chain, getScrollParent as $k7QOs$getScrollParent, useLabels as $k7QOs$useLabels, mergeProps as $k7QOs$mergeProps} from "@react-aria/utils";
+import {useLocale as $k7QOs$useLocale, useLocalizedStringFormatter as $k7QOs$useLocalizedStringFormatter} from "@react-aria/i18n";
+import {isElementInChildOfActiveScope as $k7QOs$isElementInChildOfActiveScope, FocusScope as $k7QOs$FocusScope} from "@react-aria/focus";
+import {useInteractOutside as $k7QOs$useInteractOutside, useFocusWithin as $k7QOs$useFocusWithin} from "@react-aria/interactions";
+import $k7QOs$reactdom from "react-dom";
+import {useIsSSR as $k7QOs$useIsSSR} from "@react-aria/ssr";
+import {VisuallyHidden as $k7QOs$VisuallyHidden} from "@react-aria/visually-hidden";
+
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+const $edcf132a9284368a$var$AXIS = {
+    top: "top",
+    bottom: "top",
+    left: "left",
+    right: "left"
+};
+const $edcf132a9284368a$var$FLIPPED_DIRECTION = {
+    top: "bottom",
+    bottom: "top",
+    left: "right",
+    right: "left"
+};
+const $edcf132a9284368a$var$CROSS_AXIS = {
+    top: "left",
+    left: "top"
+};
+const $edcf132a9284368a$var$AXIS_SIZE = {
+    top: "height",
+    left: "width"
+};
+const $edcf132a9284368a$var$TOTAL_SIZE = {
+    width: "totalWidth",
+    height: "totalHeight"
+};
+const $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE = {};
+// @ts-ignore
+let $edcf132a9284368a$var$visualViewport = typeof window !== "undefined" && window.visualViewport;
+function $edcf132a9284368a$var$getContainerDimensions(containerNode) {
+    let width = 0, height = 0, totalWidth = 0, totalHeight = 0, top = 0, left = 0;
+    let scroll = {};
+    if (containerNode.tagName === "BODY") {
+        let documentElement = document.documentElement;
+        totalWidth = documentElement.clientWidth;
+        totalHeight = documentElement.clientHeight;
+        var _visualViewport_width;
+        width = (_visualViewport_width = $edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.width) !== null && _visualViewport_width !== void 0 ? _visualViewport_width : totalWidth;
+        var _visualViewport_height;
+        height = (_visualViewport_height = $edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.height) !== null && _visualViewport_height !== void 0 ? _visualViewport_height : totalHeight;
+        scroll.top = documentElement.scrollTop || containerNode.scrollTop;
+        scroll.left = documentElement.scrollLeft || containerNode.scrollLeft;
+    } else {
+        ({ width: width , height: height , top: top , left: left  } = $edcf132a9284368a$var$getOffset(containerNode));
+        scroll.top = containerNode.scrollTop;
+        scroll.left = containerNode.scrollLeft;
+        totalWidth = width;
+        totalHeight = height;
+    }
+    return {
+        width: width,
+        height: height,
+        totalWidth: totalWidth,
+        totalHeight: totalHeight,
+        scroll: scroll,
+        top: top,
+        left: left
+    };
+}
+function $edcf132a9284368a$var$getScroll(node) {
+    return {
+        top: node.scrollTop,
+        left: node.scrollLeft,
+        width: node.scrollWidth,
+        height: node.scrollHeight
+    };
+}
+function $edcf132a9284368a$var$getDelta(axis, offset, size, containerDimensions, padding) {
+    let containerScroll = containerDimensions.scroll[axis];
+    let containerHeight = containerDimensions[$edcf132a9284368a$var$AXIS_SIZE[axis]];
+    let startEdgeOffset = offset - padding - containerScroll;
+    let endEdgeOffset = offset + padding - containerScroll + size;
+    if (startEdgeOffset < 0) return -startEdgeOffset;
+    else if (endEdgeOffset > containerHeight) return Math.max(containerHeight - endEdgeOffset, -startEdgeOffset);
+    else return 0;
+}
+function $edcf132a9284368a$var$getMargins(node) {
+    let style = window.getComputedStyle(node);
+    return {
+        top: parseInt(style.marginTop, 10) || 0,
+        bottom: parseInt(style.marginBottom, 10) || 0,
+        left: parseInt(style.marginLeft, 10) || 0,
+        right: parseInt(style.marginRight, 10) || 0
+    };
+}
+function $edcf132a9284368a$var$parsePlacement(input) {
+    if ($edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input]) return $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input];
+    let [placement, crossPlacement] = input.split(" ");
+    let axis = $edcf132a9284368a$var$AXIS[placement] || "right";
+    let crossAxis = $edcf132a9284368a$var$CROSS_AXIS[axis];
+    if (!$edcf132a9284368a$var$AXIS[crossPlacement]) crossPlacement = "center";
+    let size = $edcf132a9284368a$var$AXIS_SIZE[axis];
+    let crossSize = $edcf132a9284368a$var$AXIS_SIZE[crossAxis];
+    $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input] = {
+        placement: placement,
+        crossPlacement: crossPlacement,
+        axis: axis,
+        crossAxis: crossAxis,
+        size: size,
+        crossSize: crossSize
+    };
+    return $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input];
+}
+function $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset) {
+    let { placement: placement , crossPlacement: crossPlacement , axis: axis , crossAxis: crossAxis , size: size , crossSize: crossSize  } = placementInfo;
+    let position = {};
+    // button position
+    position[crossAxis] = childOffset[crossAxis];
+    if (crossPlacement === "center") //  + (button size / 2) - (overlay size / 2)
+    // at this point the overlay center should match the button center
+    position[crossAxis] += (childOffset[crossSize] - overlaySize[crossSize]) / 2;
+    else if (crossPlacement !== crossAxis) //  + (button size) - (overlay size)
+    // at this point the overlay bottom should match the button bottom
+    position[crossAxis] += childOffset[crossSize] - overlaySize[crossSize];
+     /* else {
+    the overlay top should match the button top
+  } */ 
+    // add the crossOffset from props
+    position[crossAxis] += crossOffset;
+    // overlay top overlapping arrow with button bottom
+    const minPosition = childOffset[crossAxis] - overlaySize[crossSize] + arrowSize + arrowBoundaryOffset;
+    // overlay bottom overlapping arrow with button top
+    const maxPosition = childOffset[crossAxis] + childOffset[crossSize] - arrowSize - arrowBoundaryOffset;
+    position[crossAxis] = (0, $k7QOs$clamp)(position[crossAxis], minPosition, maxPosition);
+    // Floor these so the position isn't placed on a partial pixel, only whole pixels. Shouldn't matter if it was floored or ceiled, so chose one.
+    if (placement === axis) {
+        // If the container is positioned (non-static), then we use the container's actual
+        // height, as `bottom` will be relative to this height.  But if the container is static,
+        // then it can only be the `document.body`, and `bottom` will be relative to _its_
+        // container, which should be as large as boundaryDimensions.
+        const containerHeight = isContainerPositioned ? containerOffsetWithBoundary[size] : boundaryDimensions[$edcf132a9284368a$var$TOTAL_SIZE[size]];
+        position[$edcf132a9284368a$var$FLIPPED_DIRECTION[axis]] = Math.floor(containerHeight - childOffset[axis] + offset);
+    } else position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
+    return position;
+}
+function $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding) {
+    return position.top != null ? Math.max(0, boundaryDimensions.height + boundaryDimensions.top + boundaryDimensions.scroll.top // this is the bottom of the boundary
+     - (containerOffsetWithBoundary.top + position.top // this is the top of the overlay
+    ) - (margins.top + margins.bottom + padding // save additional space for margin and padding
+    )) : Math.max(0, childOffset.top + containerOffsetWithBoundary.top // this is the top of the trigger
+     - (boundaryDimensions.top + boundaryDimensions.scroll.top // this is the top of the boundary
+    ) - (margins.top + margins.bottom + padding // save additional space for margin and padding
+    ));
+}
+function $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding, placementInfo) {
+    let { placement: placement , axis: axis , size: size  } = placementInfo;
+    if (placement === axis) return Math.max(0, childOffset[axis] - boundaryDimensions[axis] - boundaryDimensions.scroll[axis] + containerOffsetWithBoundary[axis] - margins[axis] - margins[$edcf132a9284368a$var$FLIPPED_DIRECTION[axis]] - padding);
+    return Math.max(0, boundaryDimensions[size] + boundaryDimensions[axis] + boundaryDimensions.scroll[axis] - containerOffsetWithBoundary[axis] - childOffset[axis] - childOffset[size] - margins[axis] - margins[$edcf132a9284368a$var$FLIPPED_DIRECTION[axis]] - padding);
+}
+function $edcf132a9284368a$export$6839422d1f33cee9(placementInput, childOffset, overlaySize, scrollSize, margins, padding, flip, boundaryDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, userSetMaxHeight, arrowSize, arrowBoundaryOffset) {
+    let placementInfo = $edcf132a9284368a$var$parsePlacement(placementInput);
+    let { size: size , crossAxis: crossAxis , crossSize: crossSize , placement: placement , crossPlacement: crossPlacement  } = placementInfo;
+    let position = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
+    let normalizedOffset = offset;
+    let space = $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding + offset, placementInfo);
+    // Check if the scroll size of the overlay is greater than the available space to determine if we need to flip
+    if (flip && scrollSize[size] > space) {
+        let flippedPlacementInfo = $edcf132a9284368a$var$parsePlacement(`${$edcf132a9284368a$var$FLIPPED_DIRECTION[placement]} ${crossPlacement}`);
+        let flippedPosition = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, flippedPlacementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
+        let flippedSpace = $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding + offset, flippedPlacementInfo);
+        // If the available space for the flipped position is greater than the original available space, flip.
+        if (flippedSpace > space) {
+            placementInfo = flippedPlacementInfo;
+            position = flippedPosition;
+            normalizedOffset = offset;
+        }
+    }
+    let delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, padding);
+    position[crossAxis] += delta;
+    let maxHeight = $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding);
+    if (userSetMaxHeight && userSetMaxHeight < maxHeight) maxHeight = userSetMaxHeight;
+    overlaySize.height = Math.min(overlaySize.height, maxHeight);
+    position = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
+    delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, padding);
+    position[crossAxis] += delta;
+    let arrowPosition = {};
+    // All values are transformed so that 0 is at the top/left of the overlay depending on the orientation
+    // Prefer the arrow being in the center of the trigger/overlay anchor element
+    let preferredArrowPosition = childOffset[crossAxis] + .5 * childOffset[crossSize] - overlaySize[crossAxis];
+    // Min/Max position limits for the arrow with respect to the overlay
+    const arrowMinPosition = arrowSize / 2 + arrowBoundaryOffset;
+    const arrowMaxPosition = overlaySize[crossSize] - arrowSize / 2 - arrowBoundaryOffset;
+    // Min/Max position limits for the arrow with respect to the trigger/overlay anchor element
+    const arrowOverlappingChildMinEdge = childOffset[crossAxis] - overlaySize[crossAxis] + arrowSize / 2;
+    const arrowOverlappingChildMaxEdge = childOffset[crossAxis] + childOffset[crossSize] - overlaySize[crossAxis] - arrowSize / 2;
+    // Clamp the arrow positioning so that it always is within the bounds of the anchor and the overlay
+    const arrowPositionOverlappingChild = (0, $k7QOs$clamp)(preferredArrowPosition, arrowOverlappingChildMinEdge, arrowOverlappingChildMaxEdge);
+    arrowPosition[crossAxis] = (0, $k7QOs$clamp)(arrowPositionOverlappingChild, arrowMinPosition, arrowMaxPosition);
+    return {
+        position: position,
+        maxHeight: maxHeight,
+        arrowOffsetLeft: arrowPosition.left,
+        arrowOffsetTop: arrowPosition.top,
+        placement: placementInfo.placement
+    };
+}
+function $edcf132a9284368a$export$b3ceb0cbf1056d98(opts) {
+    let { placement: placement , targetNode: targetNode , overlayNode: overlayNode , scrollNode: scrollNode , padding: padding , shouldFlip: shouldFlip , boundaryElement: boundaryElement , offset: offset , crossOffset: crossOffset , maxHeight: maxHeight , arrowSize: arrowSize , arrowBoundaryOffset: arrowBoundaryOffset = 0  } = opts;
+    let container = overlayNode instanceof HTMLElement ? $edcf132a9284368a$var$getContainingBlock(overlayNode) : document.documentElement;
+    let isViewportContainer = container === document.documentElement;
+    const containerPositionStyle = window.getComputedStyle(container).position;
+    let isContainerPositioned = !!containerPositionStyle && containerPositionStyle !== "static";
+    let childOffset = isViewportContainer ? $edcf132a9284368a$var$getOffset(targetNode) : $edcf132a9284368a$var$getPosition(targetNode, container);
+    if (!isViewportContainer) {
+        let { marginTop: marginTop , marginLeft: marginLeft  } = window.getComputedStyle(targetNode);
+        childOffset.top += parseInt(marginTop, 10) || 0;
+        childOffset.left += parseInt(marginLeft, 10) || 0;
+    }
+    let overlaySize = $edcf132a9284368a$var$getOffset(overlayNode);
+    let margins = $edcf132a9284368a$var$getMargins(overlayNode);
+    overlaySize.width += margins.left + margins.right;
+    overlaySize.height += margins.top + margins.bottom;
+    let scrollSize = $edcf132a9284368a$var$getScroll(scrollNode);
+    let boundaryDimensions = $edcf132a9284368a$var$getContainerDimensions(boundaryElement);
+    let containerOffsetWithBoundary = boundaryElement.tagName === "BODY" ? $edcf132a9284368a$var$getOffset(container) : $edcf132a9284368a$var$getPosition(container, boundaryElement);
+    return $edcf132a9284368a$export$6839422d1f33cee9(placement, childOffset, overlaySize, scrollSize, margins, padding, shouldFlip, boundaryDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, maxHeight, arrowSize, arrowBoundaryOffset);
+}
+function $edcf132a9284368a$var$getOffset(node) {
+    let { top: top , left: left , width: width , height: height  } = node.getBoundingClientRect();
+    let { scrollTop: scrollTop , scrollLeft: scrollLeft , clientTop: clientTop , clientLeft: clientLeft  } = document.documentElement;
+    return {
+        top: top + scrollTop - clientTop,
+        left: left + scrollLeft - clientLeft,
+        width: width,
+        height: height
+    };
+}
+function $edcf132a9284368a$var$getPosition(node, parent) {
+    let style = window.getComputedStyle(node);
+    let offset;
+    if (style.position === "fixed") {
+        let { top: top , left: left , width: width , height: height  } = node.getBoundingClientRect();
+        offset = {
+            top: top,
+            left: left,
+            width: width,
+            height: height
+        };
+    } else {
+        offset = $edcf132a9284368a$var$getOffset(node);
+        let parentOffset = $edcf132a9284368a$var$getOffset(parent);
+        let parentStyle = window.getComputedStyle(parent);
+        parentOffset.top += (parseInt(parentStyle.borderTopWidth, 10) || 0) - parent.scrollTop;
+        parentOffset.left += (parseInt(parentStyle.borderLeftWidth, 10) || 0) - parent.scrollLeft;
+        offset.top -= parentOffset.top;
+        offset.left -= parentOffset.left;
+    }
+    offset.top -= parseInt(style.marginTop, 10) || 0;
+    offset.left -= parseInt(style.marginLeft, 10) || 0;
+    return offset;
+}
+// Returns the containing block of an element, which is the element that
+// this element will be positioned relative to.
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block
+function $edcf132a9284368a$var$getContainingBlock(node) {
+    // The offsetParent of an element in most cases equals the containing block.
+    // https://w3c.github.io/csswg-drafts/cssom-view/#dom-htmlelement-offsetparent
+    let offsetParent = node.offsetParent;
+    // The offsetParent algorithm terminates at the document body,
+    // even if the body is not a containing block. Double check that
+    // and use the documentElement if so.
+    if (offsetParent && offsetParent === document.body && window.getComputedStyle(offsetParent).position === "static" && !$edcf132a9284368a$var$isContainingBlock(offsetParent)) offsetParent = document.documentElement;
+    // TODO(later): handle table elements?
+    // The offsetParent can be null if the element has position: fixed, or a few other cases.
+    // We have to walk up the tree manually in this case because fixed positioned elements
+    // are still positioned relative to their containing block, which is not always the viewport.
+    if (offsetParent == null) {
+        offsetParent = node.parentElement;
+        while(offsetParent && !$edcf132a9284368a$var$isContainingBlock(offsetParent))offsetParent = offsetParent.parentElement;
+    }
+    // Fall back to the viewport.
+    return offsetParent || document.documentElement;
+}
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+function $edcf132a9284368a$var$isContainingBlock(node) {
+    let style = window.getComputedStyle(node);
+    return style.transform !== "none" || /transform|perspective/.test(style.willChange) || style.filter !== "none" || style.contain === "paint" || // @ts-ignore
+    "backdropFilter" in style && style.backdropFilter !== "none" || // @ts-ignore
+    "WebkitBackdropFilter" in style && style.WebkitBackdropFilter !== "none";
+}
+
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+const $dd149f63282afbbf$export$f6211563215e3b37 = new WeakMap();
+function $dd149f63282afbbf$export$18fc8428861184da(opts) {
+    let { triggerRef: triggerRef , isOpen: isOpen , onClose: onClose  } = opts;
+    (0, $k7QOs$useEffect)(()=>{
+        if (!isOpen || onClose === null) return;
+        let onScroll = (e)=>{
+            // Ignore if scrolling an scrollable region outside the trigger's tree.
+            let target = e.target;
+            // window is not a Node and doesn't have contain, but window contains everything
+            if (!triggerRef.current || target instanceof Node && !target.contains(triggerRef.current)) return;
+            let onCloseHandler = onClose || $dd149f63282afbbf$export$f6211563215e3b37.get(triggerRef.current);
+            if (onCloseHandler) onCloseHandler();
+        };
+        window.addEventListener("scroll", onScroll, true);
+        return ()=>{
+            window.removeEventListener("scroll", onScroll, true);
+        };
+    }, [
+        isOpen,
+        onClose,
+        triggerRef
+    ]);
+}
+
+
+
+
+// @ts-ignore
+let $2a41e45df1593e64$var$visualViewport = typeof window !== "undefined" && window.visualViewport;
+function $2a41e45df1593e64$export$d39e1813b3bdd0e1(props) {
+    let { direction: direction  } = (0, $k7QOs$useLocale)();
+    let { arrowSize: arrowSize = 0 , targetRef: targetRef , overlayRef: overlayRef , scrollRef: scrollRef = overlayRef , placement: placement = "bottom" , containerPadding: containerPadding = 12 , shouldFlip: shouldFlip = true , boundaryElement: boundaryElement = typeof document !== "undefined" ? document.body : null , offset: offset = 0 , crossOffset: crossOffset = 0 , shouldUpdatePosition: shouldUpdatePosition = true , isOpen: isOpen = true , onClose: onClose , maxHeight: maxHeight , arrowBoundaryOffset: arrowBoundaryOffset = 0  } = props;
+    let [position, setPosition] = (0, $k7QOs$useState)({
+        position: {},
+        arrowOffsetLeft: undefined,
+        arrowOffsetTop: undefined,
+        maxHeight: undefined,
+        placement: undefined
+    });
+    let deps = [
+        shouldUpdatePosition,
+        placement,
+        overlayRef.current,
+        targetRef.current,
+        scrollRef.current,
+        containerPadding,
+        shouldFlip,
+        boundaryElement,
+        offset,
+        crossOffset,
+        isOpen,
+        direction,
+        maxHeight,
+        arrowBoundaryOffset,
+        arrowSize
+    ];
+    let updatePosition = (0, $k7QOs$useCallback)(()=>{
+        if (shouldUpdatePosition === false || !isOpen || !overlayRef.current || !targetRef.current || !scrollRef.current || !boundaryElement) return;
+        let position = (0, $edcf132a9284368a$export$b3ceb0cbf1056d98)({
+            placement: $2a41e45df1593e64$var$translateRTL(placement, direction),
+            overlayNode: overlayRef.current,
+            targetNode: targetRef.current,
+            scrollNode: scrollRef.current,
+            padding: containerPadding,
+            shouldFlip: shouldFlip,
+            boundaryElement: boundaryElement,
+            offset: offset,
+            crossOffset: crossOffset,
+            maxHeight: maxHeight,
+            arrowSize: arrowSize,
+            arrowBoundaryOffset: arrowBoundaryOffset
+        });
+        // Modify overlay styles directly so positioning happens immediately without the need of a second render
+        // This is so we don't have to delay autoFocus scrolling or delay applying preventScroll for popovers
+        Object.keys(position.position).forEach((key)=>overlayRef.current.style[key] = position.position[key] + "px");
+        overlayRef.current.style.maxHeight = position.maxHeight != null ? position.maxHeight + "px" : undefined;
+        // Trigger a set state for a second render anyway for arrow positioning
+        setPosition(position);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+    // Update position when anything changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, $k7QOs$useLayoutEffect)(updatePosition, deps);
+    // Update position on window resize
+    $2a41e45df1593e64$var$useResize(updatePosition);
+    // Update position when the overlay changes size (might need to flip).
+    (0, $k7QOs$useResizeObserver)({
+        ref: overlayRef,
+        onResize: updatePosition
+    });
+    // Reposition the overlay and do not close on scroll while the visual viewport is resizing.
+    // This will ensure that overlays adjust their positioning when the iOS virtual keyboard appears.
+    let isResizing = (0, $k7QOs$useRef)(false);
+    (0, $k7QOs$useLayoutEffect)(()=>{
+        let timeout;
+        let onResize = ()=>{
+            isResizing.current = true;
+            clearTimeout(timeout);
+            timeout = setTimeout(()=>{
+                isResizing.current = false;
+            }, 500);
+            updatePosition();
+        };
+        $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("resize", onResize);
+        $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("scroll", onResize);
+        return ()=>{
+            $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("resize", onResize);
+            $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("scroll", onResize);
+        };
+    }, [
+        updatePosition
+    ]);
+    let close = (0, $k7QOs$useCallback)(()=>{
+        if (!isResizing.current) onClose();
+    }, [
+        onClose,
+        isResizing
+    ]);
+    // When scrolling a parent scrollable region of the trigger (other than the body),
+    // we hide the popover. Otherwise, its position would be incorrect.
+    (0, $dd149f63282afbbf$export$18fc8428861184da)({
+        triggerRef: targetRef,
+        isOpen: isOpen,
+        onClose: onClose && close
+    });
+    return {
+        overlayProps: {
+            style: {
+                position: "absolute",
+                zIndex: 100000,
+                ...position.position,
+                maxHeight: position.maxHeight
+            }
+        },
+        placement: position.placement,
+        arrowProps: {
+            style: {
+                left: position.arrowOffsetLeft,
+                top: position.arrowOffsetTop
+            }
+        },
+        updatePosition: updatePosition
+    };
+}
+function $2a41e45df1593e64$var$useResize(onResize) {
+    (0, $k7QOs$useLayoutEffect)(()=>{
+        window.addEventListener("resize", onResize, false);
+        return ()=>{
+            window.removeEventListener("resize", onResize, false);
+        };
+    }, [
+        onResize
+    ]);
+}
+function $2a41e45df1593e64$var$translateRTL(position, direction) {
+    if (direction === "rtl") return position.replace("start", "right").replace("end", "left");
+    return position.replace("start", "left").replace("end", "right");
+}
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+const $a11501f3d1d39e6c$var$visibleOverlays = [];
+function $a11501f3d1d39e6c$export$ea8f71083e90600f(props, ref) {
+    let { onClose: onClose , shouldCloseOnBlur: shouldCloseOnBlur , isOpen: isOpen , isDismissable: isDismissable = false , isKeyboardDismissDisabled: isKeyboardDismissDisabled = false , shouldCloseOnInteractOutside: shouldCloseOnInteractOutside  } = props;
+    // Add the overlay ref to the stack of visible overlays on mount, and remove on unmount.
+    (0, $k7QOs$useEffect)(()=>{
+        if (isOpen) $a11501f3d1d39e6c$var$visibleOverlays.push(ref);
+        return ()=>{
+            let index = $a11501f3d1d39e6c$var$visibleOverlays.indexOf(ref);
+            if (index >= 0) $a11501f3d1d39e6c$var$visibleOverlays.splice(index, 1);
+        };
+    }, [
+        isOpen,
+        ref
+    ]);
+    // Only hide the overlay when it is the topmost visible overlay in the stack.
+    let onHide = ()=>{
+        if ($a11501f3d1d39e6c$var$visibleOverlays[$a11501f3d1d39e6c$var$visibleOverlays.length - 1] === ref && onClose) onClose();
+    };
+    let onInteractOutsideStart = (e)=>{
+        if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.target)) {
+            if ($a11501f3d1d39e6c$var$visibleOverlays[$a11501f3d1d39e6c$var$visibleOverlays.length - 1] === ref) {
+                e.stopPropagation();
+                e.preventDefault();
+            }
+        }
+    };
+    let onInteractOutside = (e)=>{
+        if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.target)) {
+            if ($a11501f3d1d39e6c$var$visibleOverlays[$a11501f3d1d39e6c$var$visibleOverlays.length - 1] === ref) {
+                e.stopPropagation();
+                e.preventDefault();
+            }
+            onHide();
+        }
+    };
+    // Handle the escape key
+    let onKeyDown = (e)=>{
+        if (e.key === "Escape" && !isKeyboardDismissDisabled) {
+            e.stopPropagation();
+            e.preventDefault();
+            onHide();
+        }
+    };
+    // Handle clicking outside the overlay to close it
+    (0, $k7QOs$useInteractOutside)({
+        ref: ref,
+        onInteractOutside: isDismissable ? onInteractOutside : null,
+        onInteractOutsideStart: onInteractOutsideStart
+    });
+    let { focusWithinProps: focusWithinProps  } = (0, $k7QOs$useFocusWithin)({
+        isDisabled: !shouldCloseOnBlur,
+        onBlurWithin: (e)=>{
+            // If focus is moving into a child focus scope (e.g. menu inside a dialog),
+            // do not close the outer overlay. At this point, the active scope should
+            // still be the outer overlay, since blur events run before focus.
+            if (e.relatedTarget && (0, $k7QOs$isElementInChildOfActiveScope)(e.relatedTarget)) return;
+            if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.relatedTarget)) onClose();
+        }
+    });
+    let onPointerDownUnderlay = (e)=>{
+        // fixes a firefox issue that starts text selection https://bugzilla.mozilla.org/show_bug.cgi?id=1675846
+        if (e.target === e.currentTarget) e.preventDefault();
+    };
+    return {
+        overlayProps: {
+            onKeyDown: onKeyDown,
+            ...focusWithinProps
+        },
+        underlayProps: {
+            onPointerDown: onPointerDownUnderlay
+        }
+    };
+}
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+function $628037886ba31236$export$f9d5c8beee7d008d(props, state, ref) {
+    let { type: type  } = props;
+    let { isOpen: isOpen  } = state;
+    // Backward compatibility. Share state close function with useOverlayPosition so it can close on scroll
+    // without forcing users to pass onClose.
+    (0, $k7QOs$useEffect)(()=>{
+        if (ref && ref.current) (0, $dd149f63282afbbf$export$f6211563215e3b37).set(ref.current, state.close);
+    });
+    // Aria 1.1 supports multiple values for aria-haspopup other than just menus.
+    // https://www.w3.org/TR/wai-aria-1.1/#aria-haspopup
+    // However, we only add it for menus for now because screen readers often
+    // announce it as a menu even for other values.
+    let ariaHasPopup = undefined;
+    if (type === "menu") ariaHasPopup = true;
+    else if (type === "listbox") ariaHasPopup = "listbox";
+    let overlayId = (0, $k7QOs$useId)();
+    return {
+        triggerProps: {
+            "aria-haspopup": ariaHasPopup,
+            "aria-expanded": isOpen,
+            "aria-controls": isOpen ? overlayId : null,
+            onPress: state.toggle
+        },
+        overlayProps: {
+            id: overlayId
+        }
+    };
+}
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+// @ts-ignore
+const $49c51c25361d4cd2$var$visualViewport = typeof window !== "undefined" && window.visualViewport;
+// HTML input types that do not cause the software keyboard to appear.
+const $49c51c25361d4cd2$var$nonTextInputTypes = new Set([
+    "checkbox",
+    "radio",
+    "range",
+    "color",
+    "file",
+    "image",
+    "button",
+    "submit",
+    "reset"
+]);
+// The number of active usePreventScroll calls. Used to determine whether to revert back to the original page style/scroll position
+let $49c51c25361d4cd2$var$preventScrollCount = 0;
+let $49c51c25361d4cd2$var$restore;
+function $49c51c25361d4cd2$export$ee0f7cc6afcd1c18(options = {}) {
+    let { isDisabled: isDisabled  } = options;
+    (0, $k7QOs$useLayoutEffect)(()=>{
+        if (isDisabled) return;
+        $49c51c25361d4cd2$var$preventScrollCount++;
+        if ($49c51c25361d4cd2$var$preventScrollCount === 1) {
+            if ((0, $k7QOs$isIOS)()) $49c51c25361d4cd2$var$restore = $49c51c25361d4cd2$var$preventScrollMobileSafari();
+            else $49c51c25361d4cd2$var$restore = $49c51c25361d4cd2$var$preventScrollStandard();
+        }
+        return ()=>{
+            $49c51c25361d4cd2$var$preventScrollCount--;
+            if ($49c51c25361d4cd2$var$preventScrollCount === 0) $49c51c25361d4cd2$var$restore();
+        };
+    }, [
+        isDisabled
+    ]);
+}
+// For most browsers, all we need to do is set `overflow: hidden` on the root element, and
+// add some padding to prevent the page from shifting when the scrollbar is hidden.
+function $49c51c25361d4cd2$var$preventScrollStandard() {
+    return (0, $k7QOs$chain)($49c51c25361d4cd2$var$setStyle(document.documentElement, "paddingRight", `${window.innerWidth - document.documentElement.clientWidth}px`), $49c51c25361d4cd2$var$setStyle(document.documentElement, "overflow", "hidden"));
+}
+// Mobile Safari is a whole different beast. Even with overflow: hidden,
+// it still scrolls the page in many situations:
+//
+// 1. When the bottom toolbar and address bar are collapsed, page scrolling is always allowed.
+// 2. When the keyboard is visible, the viewport does not resize. Instead, the keyboard covers part of
+//    it, so it becomes scrollable.
+// 3. When tapping on an input, the page always scrolls so that the input is centered in the visual viewport.
+//    This may cause even fixed position elements to scroll off the screen.
+// 4. When using the next/previous buttons in the keyboard to navigate between inputs, the whole page always
+//    scrolls, even if the input is inside a nested scrollable element that could be scrolled instead.
+//
+// In order to work around these cases, and prevent scrolling without jankiness, we do a few things:
+//
+// 1. Prevent default on `touchmove` events that are not in a scrollable element. This prevents touch scrolling
+//    on the window.
+// 2. Prevent default on `touchmove` events inside a scrollable element when the scroll position is at the
+//    top or bottom. This avoids the whole page scrolling instead, but does prevent overscrolling.
+// 3. Prevent default on `touchend` events on input elements and handle focusing the element ourselves.
+// 4. When focusing an input, apply a transform to trick Safari into thinking the input is at the top
+//    of the page, which prevents it from scrolling the page. After the input is focused, scroll the element
+//    into view ourselves, without scrolling the whole page.
+// 5. Offset the body by the scroll position using a negative margin and scroll to the top. This should appear the
+//    same visually, but makes the actual scroll position always zero. This is required to make all of the
+//    above work or Safari will still try to scroll the page when focusing an input.
+// 6. As a last resort, handle window scroll events, and scroll back to the top. This can happen when attempting
+//    to navigate to an input with the next/previous buttons that's outside a modal.
+function $49c51c25361d4cd2$var$preventScrollMobileSafari() {
+    let scrollable;
+    let lastY = 0;
+    let onTouchStart = (e)=>{
+        // Store the nearest scrollable parent element from the element that the user touched.
+        scrollable = (0, $k7QOs$getScrollParent)(e.target);
+        if (scrollable === document.documentElement && scrollable === document.body) return;
+        lastY = e.changedTouches[0].pageY;
+    };
+    let onTouchMove = (e)=>{
+        // Prevent scrolling the window.
+        if (scrollable === document.documentElement || scrollable === document.body) {
+            e.preventDefault();
+            return;
+        }
+        // Prevent scrolling up when at the top and scrolling down when at the bottom
+        // of a nested scrollable area, otherwise mobile Safari will start scrolling
+        // the window instead. Unfortunately, this disables bounce scrolling when at
+        // the top but it's the best we can do.
+        let y = e.changedTouches[0].pageY;
+        let scrollTop = scrollable.scrollTop;
+        let bottom = scrollable.scrollHeight - scrollable.clientHeight;
+        if (scrollTop <= 0 && y > lastY || scrollTop >= bottom && y < lastY) e.preventDefault();
+        lastY = y;
+    };
+    let onTouchEnd = (e)=>{
+        let target = e.target;
+        // Apply this change if we're not already focused on the target element
+        if ($49c51c25361d4cd2$var$willOpenKeyboard(target) && target !== document.activeElement) {
+            e.preventDefault();
+            // Apply a transform to trick Safari into thinking the input is at the top of the page
+            // so it doesn't try to scroll it into view. When tapping on an input, this needs to
+            // be done before the "focus" event, so we have to focus the element ourselves.
+            target.style.transform = "translateY(-2000px)";
+            target.focus();
+            requestAnimationFrame(()=>{
+                target.style.transform = "";
+            });
+        }
+    };
+    let onFocus = (e)=>{
+        let target = e.target;
+        if ($49c51c25361d4cd2$var$willOpenKeyboard(target)) {
+            // Transform also needs to be applied in the focus event in cases where focus moves
+            // other than tapping on an input directly, e.g. the next/previous buttons in the
+            // software keyboard. In these cases, it seems applying the transform in the focus event
+            // is good enough, whereas when tapping an input, it must be done before the focus event. 🤷‍♂️
+            target.style.transform = "translateY(-2000px)";
+            requestAnimationFrame(()=>{
+                target.style.transform = "";
+                // This will have prevented the browser from scrolling the focused element into view,
+                // so we need to do this ourselves in a way that doesn't cause the whole page to scroll.
+                if ($49c51c25361d4cd2$var$visualViewport) {
+                    if ($49c51c25361d4cd2$var$visualViewport.height < window.innerHeight) // If the keyboard is already visible, do this after one additional frame
+                    // to wait for the transform to be removed.
+                    requestAnimationFrame(()=>{
+                        $49c51c25361d4cd2$var$scrollIntoView(target);
+                    });
+                    else // Otherwise, wait for the visual viewport to resize before scrolling so we can
+                    // measure the correct position to scroll to.
+                    $49c51c25361d4cd2$var$visualViewport.addEventListener("resize", ()=>$49c51c25361d4cd2$var$scrollIntoView(target), {
+                        once: true
+                    });
+                }
+            });
+        }
+    };
+    let onWindowScroll = ()=>{
+        // Last resort. If the window scrolled, scroll it back to the top.
+        // It should always be at the top because the body will have a negative margin (see below).
+        window.scrollTo(0, 0);
+    };
+    // Record the original scroll position so we can restore it.
+    // Then apply a negative margin to the body to offset it by the scroll position. This will
+    // enable us to scroll the window to the top, which is required for the rest of this to work.
+    let scrollX = window.pageXOffset;
+    let scrollY = window.pageYOffset;
+    let restoreStyles = (0, $k7QOs$chain)($49c51c25361d4cd2$var$setStyle(document.documentElement, "paddingRight", `${window.innerWidth - document.documentElement.clientWidth}px`), $49c51c25361d4cd2$var$setStyle(document.documentElement, "overflow", "hidden"), $49c51c25361d4cd2$var$setStyle(document.body, "marginTop", `-${scrollY}px`));
+    // Scroll to the top. The negative margin on the body will make this appear the same.
+    window.scrollTo(0, 0);
+    let removeEvents = (0, $k7QOs$chain)($49c51c25361d4cd2$var$addEvent(document, "touchstart", onTouchStart, {
+        passive: false,
+        capture: true
+    }), $49c51c25361d4cd2$var$addEvent(document, "touchmove", onTouchMove, {
+        passive: false,
+        capture: true
+    }), $49c51c25361d4cd2$var$addEvent(document, "touchend", onTouchEnd, {
+        passive: false,
+        capture: true
+    }), $49c51c25361d4cd2$var$addEvent(document, "focus", onFocus, true), $49c51c25361d4cd2$var$addEvent(window, "scroll", onWindowScroll));
+    return ()=>{
+        // Restore styles and scroll the page back to where it was.
+        restoreStyles();
+        removeEvents();
+        window.scrollTo(scrollX, scrollY);
+    };
+}
+// Sets a CSS property on an element, and returns a function to revert it to the previous value.
+function $49c51c25361d4cd2$var$setStyle(element, style, value) {
+    let cur = element.style[style];
+    element.style[style] = value;
+    return ()=>{
+        element.style[style] = cur;
+    };
+}
+// Adds an event listener to an element, and returns a function to remove it.
+function $49c51c25361d4cd2$var$addEvent(target, event, handler, options) {
+    target.addEventListener(event, handler, options);
+    return ()=>{
+        target.removeEventListener(event, handler, options);
+    };
+}
+function $49c51c25361d4cd2$var$scrollIntoView(target) {
+    let root = document.scrollingElement || document.documentElement;
+    while(target && target !== root){
+        // Find the parent scrollable element and adjust the scroll position if the target is not already in view.
+        let scrollable = (0, $k7QOs$getScrollParent)(target);
+        if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== target) {
+            let scrollableTop = scrollable.getBoundingClientRect().top;
+            let targetTop = target.getBoundingClientRect().top;
+            if (targetTop > scrollableTop + target.clientHeight) scrollable.scrollTop += targetTop - scrollableTop;
+        }
+        target = scrollable.parentElement;
+    }
+}
+function $49c51c25361d4cd2$var$willOpenKeyboard(target) {
+    return target instanceof HTMLInputElement && !$49c51c25361d4cd2$var$nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+}
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+const $f57aed4a881a3485$var$Context = /*#__PURE__*/ (0, $k7QOs$react).createContext(null);
+function $f57aed4a881a3485$export$178405afcd8c5eb(props) {
+    let { children: children  } = props;
+    let parent = (0, $k7QOs$useContext)($f57aed4a881a3485$var$Context);
+    let [modalCount, setModalCount] = (0, $k7QOs$useState)(0);
+    let context = (0, $k7QOs$useMemo)(()=>({
+            parent: parent,
+            modalCount: modalCount,
+            addModal () {
+                setModalCount((count)=>count + 1);
+                if (parent) parent.addModal();
+            },
+            removeModal () {
+                setModalCount((count)=>count - 1);
+                if (parent) parent.removeModal();
+            }
+        }), [
+        parent,
+        modalCount
+    ]);
+    return /*#__PURE__*/ (0, $k7QOs$react).createElement($f57aed4a881a3485$var$Context.Provider, {
+        value: context
+    }, children);
+}
+function $f57aed4a881a3485$export$d9aaed4c3ece1bc0() {
+    let context = (0, $k7QOs$useContext)($f57aed4a881a3485$var$Context);
+    return {
+        modalProviderProps: {
+            "aria-hidden": context && context.modalCount > 0 ? true : null
+        }
+    };
+}
+/**
+ * Creates a root node that will be aria-hidden if there are other modals open.
+ */ function $f57aed4a881a3485$var$OverlayContainerDOM(props) {
+    let { modalProviderProps: modalProviderProps  } = $f57aed4a881a3485$export$d9aaed4c3ece1bc0();
+    return /*#__PURE__*/ (0, $k7QOs$react).createElement("div", {
+        "data-overlay-container": true,
+        ...props,
+        ...modalProviderProps
+    });
+}
+function $f57aed4a881a3485$export$bf688221f59024e5(props) {
+    return /*#__PURE__*/ (0, $k7QOs$react).createElement($f57aed4a881a3485$export$178405afcd8c5eb, null, /*#__PURE__*/ (0, $k7QOs$react).createElement($f57aed4a881a3485$var$OverlayContainerDOM, props));
+}
+function $f57aed4a881a3485$export$b47c3594eab58386(props) {
+    let isSSR = (0, $k7QOs$useIsSSR)();
+    let { portalContainer: portalContainer = isSSR ? null : document.body , ...rest } = props;
+    (0, $k7QOs$react).useEffect(()=>{
+        if (portalContainer === null || portalContainer === void 0 ? void 0 : portalContainer.closest("[data-overlay-container]")) throw new Error("An OverlayContainer must not be inside another container. Please change the portalContainer prop.");
+    }, [
+        portalContainer
+    ]);
+    if (!portalContainer) return null;
+    let contents = /*#__PURE__*/ (0, $k7QOs$react).createElement($f57aed4a881a3485$export$bf688221f59024e5, rest);
+    return /*#__PURE__*/ (0, $k7QOs$reactdom).createPortal(contents, portalContainer);
+}
+function $f57aed4a881a3485$export$33ffd74ebf07f060(options) {
+    // Add aria-hidden to all parent providers on mount, and restore on unmount.
+    let context = (0, $k7QOs$useContext)($f57aed4a881a3485$var$Context);
+    if (!context) throw new Error("Modal is not contained within a provider");
+    (0, $k7QOs$useEffect)(()=>{
+        if ((options === null || options === void 0 ? void 0 : options.isDisabled) || !context || !context.parent) return;
+        // The immediate context is from the provider containing this modal, so we only
+        // want to trigger aria-hidden on its parents not on the modal provider itself.
+        context.parent.addModal();
+        return ()=>{
+            if (context && context.parent) context.parent.removeModal();
+        };
+    }, [
+        context,
+        context.parent,
+        options === null || options === void 0 ? void 0 : options.isDisabled
+    ]);
+    return {
+        modalProps: {
+            "data-ismodal": !(options === null || options === void 0 ? void 0 : options.isDisabled)
+        }
+    };
+}
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ var $61fe14465afefc5e$exports = {};
+var $773d5888b972f1cf$exports = {};
+$773d5888b972f1cf$exports = {
+    "dismiss": `تجاهل`
+};
+
+
+var $d11f19852b941573$exports = {};
+$d11f19852b941573$exports = {
+    "dismiss": `Отхвърляне`
+};
+
+
+var $b983974c2ee1efb3$exports = {};
+$b983974c2ee1efb3$exports = {
+    "dismiss": `Odstranit`
+};
+
+
+var $5809cc9d4e92de73$exports = {};
+$5809cc9d4e92de73$exports = {
+    "dismiss": `Luk`
+};
+
+
+var $c68c2e4fc74398d1$exports = {};
+$c68c2e4fc74398d1$exports = {
+    "dismiss": `Schließen`
+};
+
+
+var $0898b4c153db2b77$exports = {};
+$0898b4c153db2b77$exports = {
+    "dismiss": `Απόρριψη`
+};
+
+
+var $6d74810286a15183$exports = {};
+$6d74810286a15183$exports = {
+    "dismiss": `Dismiss`
+};
+
+
+var $309d73dc65f78055$exports = {};
+$309d73dc65f78055$exports = {
+    "dismiss": `Descartar`
+};
+
+
+var $44ad94f7205cf593$exports = {};
+$44ad94f7205cf593$exports = {
+    "dismiss": `Lõpeta`
+};
+
+
+var $7c28f5687f0779a9$exports = {};
+$7c28f5687f0779a9$exports = {
+    "dismiss": `Hylkää`
+};
+
+
+var $e6d75df4b68bd73a$exports = {};
+$e6d75df4b68bd73a$exports = {
+    "dismiss": `Rejeter`
+};
+
+
+var $87505c9dab186d0f$exports = {};
+$87505c9dab186d0f$exports = {
+    "dismiss": `התעלם`
+};
+
+
+var $553439c3ffb3e492$exports = {};
+$553439c3ffb3e492$exports = {
+    "dismiss": `Odbaci`
+};
+
+
+var $74cf411061b983a2$exports = {};
+$74cf411061b983a2$exports = {
+    "dismiss": `Elutasítás`
+};
+
+
+var $e933f298574dc435$exports = {};
+$e933f298574dc435$exports = {
+    "dismiss": `Ignora`
+};
+
+
+var $ac91fc9fe02f71f6$exports = {};
+$ac91fc9fe02f71f6$exports = {
+    "dismiss": `閉じる`
+};
+
+
+var $52b96f86422025af$exports = {};
+$52b96f86422025af$exports = {
+    "dismiss": `무시`
+};
+
+
+var $c0d724c3e51dafa6$exports = {};
+$c0d724c3e51dafa6$exports = {
+    "dismiss": `Atmesti`
+};
+
+
+var $c92899672a3fe72e$exports = {};
+$c92899672a3fe72e$exports = {
+    "dismiss": `Nerādīt`
+};
+
+
+var $9f576b39d8e7a9d6$exports = {};
+$9f576b39d8e7a9d6$exports = {
+    "dismiss": `Lukk`
+};
+
+
+var $9d025808aeec81a7$exports = {};
+$9d025808aeec81a7$exports = {
+    "dismiss": `Negeren`
+};
+
+
+var $fce709921e2c0fa6$exports = {};
+$fce709921e2c0fa6$exports = {
+    "dismiss": `Zignoruj`
+};
+
+
+var $2599cf0c4ab37f59$exports = {};
+$2599cf0c4ab37f59$exports = {
+    "dismiss": `Descartar`
+};
+
+
+var $3c220ae7ef8a35fd$exports = {};
+$3c220ae7ef8a35fd$exports = {
+    "dismiss": `Dispensar`
+};
+
+
+var $93562b5094072f54$exports = {};
+$93562b5094072f54$exports = {
+    "dismiss": `Revocare`
+};
+
+
+var $cd9e2abd0d06c7b4$exports = {};
+$cd9e2abd0d06c7b4$exports = {
+    "dismiss": `Пропустить`
+};
+
+
+var $45375701f409adf1$exports = {};
+$45375701f409adf1$exports = {
+    "dismiss": `Zrušiť`
+};
+
+
+var $27fab53a576de9dd$exports = {};
+$27fab53a576de9dd$exports = {
+    "dismiss": `Opusti`
+};
+
+
+var $4438748d9952e7c7$exports = {};
+$4438748d9952e7c7$exports = {
+    "dismiss": `Odbaci`
+};
+
+
+var $0936d7347ef4da4c$exports = {};
+$0936d7347ef4da4c$exports = {
+    "dismiss": `Avvisa`
+};
+
+
+var $29700c92185d38f8$exports = {};
+$29700c92185d38f8$exports = {
+    "dismiss": `Kapat`
+};
+
+
+var $662ccaf2be4c25b3$exports = {};
+$662ccaf2be4c25b3$exports = {
+    "dismiss": `Скасувати`
+};
+
+
+var $d80a27deda7cdb3c$exports = {};
+$d80a27deda7cdb3c$exports = {
+    "dismiss": `取消`
+};
+
+
+var $2b2734393847c884$exports = {};
+$2b2734393847c884$exports = {
+    "dismiss": `關閉`
+};
+
+
+$61fe14465afefc5e$exports = {
+    "ar-AE": $773d5888b972f1cf$exports,
+    "bg-BG": $d11f19852b941573$exports,
+    "cs-CZ": $b983974c2ee1efb3$exports,
+    "da-DK": $5809cc9d4e92de73$exports,
+    "de-DE": $c68c2e4fc74398d1$exports,
+    "el-GR": $0898b4c153db2b77$exports,
+    "en-US": $6d74810286a15183$exports,
+    "es-ES": $309d73dc65f78055$exports,
+    "et-EE": $44ad94f7205cf593$exports,
+    "fi-FI": $7c28f5687f0779a9$exports,
+    "fr-FR": $e6d75df4b68bd73a$exports,
+    "he-IL": $87505c9dab186d0f$exports,
+    "hr-HR": $553439c3ffb3e492$exports,
+    "hu-HU": $74cf411061b983a2$exports,
+    "it-IT": $e933f298574dc435$exports,
+    "ja-JP": $ac91fc9fe02f71f6$exports,
+    "ko-KR": $52b96f86422025af$exports,
+    "lt-LT": $c0d724c3e51dafa6$exports,
+    "lv-LV": $c92899672a3fe72e$exports,
+    "nb-NO": $9f576b39d8e7a9d6$exports,
+    "nl-NL": $9d025808aeec81a7$exports,
+    "pl-PL": $fce709921e2c0fa6$exports,
+    "pt-BR": $2599cf0c4ab37f59$exports,
+    "pt-PT": $3c220ae7ef8a35fd$exports,
+    "ro-RO": $93562b5094072f54$exports,
+    "ru-RU": $cd9e2abd0d06c7b4$exports,
+    "sk-SK": $45375701f409adf1$exports,
+    "sl-SI": $27fab53a576de9dd$exports,
+    "sr-SP": $4438748d9952e7c7$exports,
+    "sv-SE": $0936d7347ef4da4c$exports,
+    "tr-TR": $29700c92185d38f8$exports,
+    "uk-UA": $662ccaf2be4c25b3$exports,
+    "zh-CN": $d80a27deda7cdb3c$exports,
+    "zh-TW": $2b2734393847c884$exports
+};
+
+
+
+
+
+
+function $86ea4cb521eb2e37$export$2317d149ed6f78c4(props) {
+    let { onDismiss: onDismiss , ...otherProps } = props;
+    let stringFormatter = (0, $k7QOs$useLocalizedStringFormatter)((0, (/*@__PURE__*/$parcel$interopDefault($61fe14465afefc5e$exports))));
+    let labels = (0, $k7QOs$useLabels)(otherProps, stringFormatter.format("dismiss"));
+    let onClick = ()=>{
+        if (onDismiss) onDismiss();
+    };
+    return /*#__PURE__*/ (0, $k7QOs$react).createElement((0, $k7QOs$VisuallyHidden), null, /*#__PURE__*/ (0, $k7QOs$react).createElement("button", {
+        ...labels,
+        tabIndex: -1,
+        onClick: onClick
+    }));
+}
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // Keeps a ref count of all hidden elements. Added to when hiding an element, and
+// subtracted from when showing it again. When it reaches zero, aria-hidden is removed.
+let $5e3802645cc19319$var$refCountMap = new WeakMap();
+let $5e3802645cc19319$var$observerStack = [];
+function $5e3802645cc19319$export$1c3ebcada18427bf(targets, root = document.body) {
+    let visibleNodes = new Set(targets);
+    let hiddenNodes = new Set();
+    let walk = (root)=>{
+        // Keep live announcer and top layer elements (e.g. toasts) visible.
+        for (let element of root.querySelectorAll("[data-live-announcer], [data-react-aria-top-layer]"))visibleNodes.add(element);
+        let acceptNode = (node)=>{
+            // Skip this node and its children if it is one of the target nodes, or a live announcer.
+            // Also skip children of already hidden nodes, as aria-hidden is recursive. An exception is
+            // made for elements with role="row" since VoiceOver on iOS has issues hiding elements with role="row".
+            // For that case we want to hide the cells inside as well (https://bugs.webkit.org/show_bug.cgi?id=222623).
+            if (visibleNodes.has(node) || hiddenNodes.has(node.parentElement) && node.parentElement.getAttribute("role") !== "row") return NodeFilter.FILTER_REJECT;
+            // Skip this node but continue to children if one of the targets is inside the node.
+            for (let target of visibleNodes){
+                if (node.contains(target)) return NodeFilter.FILTER_SKIP;
+            }
+            return NodeFilter.FILTER_ACCEPT;
+        };
+        let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+            acceptNode: acceptNode
+        });
+        // TreeWalker does not include the root.
+        let acceptRoot = acceptNode(root);
+        if (acceptRoot === NodeFilter.FILTER_ACCEPT) hide(root);
+        if (acceptRoot !== NodeFilter.FILTER_REJECT) {
+            let node = walker.nextNode();
+            while(node != null){
+                hide(node);
+                node = walker.nextNode();
+            }
+        }
+    };
+    let hide = (node)=>{
+        var _refCountMap_get;
+        let refCount = (_refCountMap_get = $5e3802645cc19319$var$refCountMap.get(node)) !== null && _refCountMap_get !== void 0 ? _refCountMap_get : 0;
+        // If already aria-hidden, and the ref count is zero, then this element
+        // was already hidden and there's nothing for us to do.
+        if (node.getAttribute("aria-hidden") === "true" && refCount === 0) return;
+        if (refCount === 0) node.setAttribute("aria-hidden", "true");
+        hiddenNodes.add(node);
+        $5e3802645cc19319$var$refCountMap.set(node, refCount + 1);
+    };
+    // If there is already a MutationObserver listening from a previous call,
+    // disconnect it so the new on takes over.
+    if ($5e3802645cc19319$var$observerStack.length) $5e3802645cc19319$var$observerStack[$5e3802645cc19319$var$observerStack.length - 1].disconnect();
+    walk(root);
+    let observer = new MutationObserver((changes)=>{
+        for (let change of changes){
+            if (change.type !== "childList" || change.addedNodes.length === 0) continue;
+            // If the parent element of the added nodes is not within one of the targets,
+            // and not already inside a hidden node, hide all of the new children.
+            if (![
+                ...visibleNodes,
+                ...hiddenNodes
+            ].some((node)=>node.contains(change.target))) {
+                for (let node of change.removedNodes)if (node instanceof Element) {
+                    visibleNodes.delete(node);
+                    hiddenNodes.delete(node);
+                }
+                for (let node1 of change.addedNodes){
+                    if ((node1 instanceof HTMLElement || node1 instanceof SVGElement) && (node1.dataset.liveAnnouncer === "true" || node1.dataset.reactAriaTopLayer === "true")) visibleNodes.add(node1);
+                    else if (node1 instanceof Element) walk(node1);
+                }
+            }
+        }
+    });
+    observer.observe(root, {
+        childList: true,
+        subtree: true
+    });
+    let observerWrapper = {
+        observe () {
+            observer.observe(root, {
+                childList: true,
+                subtree: true
+            });
+        },
+        disconnect () {
+            observer.disconnect();
+        }
+    };
+    $5e3802645cc19319$var$observerStack.push(observerWrapper);
+    return ()=>{
+        observer.disconnect();
+        for (let node of hiddenNodes){
+            let count = $5e3802645cc19319$var$refCountMap.get(node);
+            if (count === 1) {
+                node.removeAttribute("aria-hidden");
+                $5e3802645cc19319$var$refCountMap.delete(node);
+            } else $5e3802645cc19319$var$refCountMap.set(node, count - 1);
+        }
+        // Remove this observer from the stack, and start the previous one.
+        if (observerWrapper === $5e3802645cc19319$var$observerStack[$5e3802645cc19319$var$observerStack.length - 1]) {
+            $5e3802645cc19319$var$observerStack.pop();
+            if ($5e3802645cc19319$var$observerStack.length) $5e3802645cc19319$var$observerStack[$5e3802645cc19319$var$observerStack.length - 1].observe();
+        } else $5e3802645cc19319$var$observerStack.splice($5e3802645cc19319$var$observerStack.indexOf(observerWrapper), 1);
+    };
+}
+
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
+
+function $f2f8a6077418541e$export$542a6fd13ac93354(props, state) {
+    let { triggerRef: triggerRef , popoverRef: popoverRef , isNonModal: isNonModal , isKeyboardDismissDisabled: isKeyboardDismissDisabled , ...otherProps } = props;
+    let { overlayProps: overlayProps , underlayProps: underlayProps  } = (0, $a11501f3d1d39e6c$export$ea8f71083e90600f)({
+        isOpen: state.isOpen,
+        onClose: state.close,
+        shouldCloseOnBlur: true,
+        isDismissable: !isNonModal,
+        isKeyboardDismissDisabled: isKeyboardDismissDisabled
+    }, popoverRef);
+    let { overlayProps: positionProps , arrowProps: arrowProps , placement: placement  } = (0, $2a41e45df1593e64$export$d39e1813b3bdd0e1)({
+        ...otherProps,
+        targetRef: triggerRef,
+        overlayRef: popoverRef,
+        isOpen: state.isOpen,
+        onClose: null
+    });
+    (0, $49c51c25361d4cd2$export$ee0f7cc6afcd1c18)({
+        isDisabled: isNonModal
+    });
+    (0, $k7QOs$useLayoutEffect)(()=>{
+        if (state.isOpen && !isNonModal && popoverRef.current) return (0, $5e3802645cc19319$export$1c3ebcada18427bf)([
+            popoverRef.current
+        ]);
+    }, [
+        isNonModal,
+        state.isOpen,
+        popoverRef
+    ]);
+    return {
+        popoverProps: (0, $k7QOs$mergeProps)(overlayProps, positionProps),
+        arrowProps: arrowProps,
+        underlayProps: underlayProps,
+        placement: placement
+    };
+}
+
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
+
+const $337b884510726a0d$export$a2200b96afd16271 = /*#__PURE__*/ (0, $k7QOs$react).createContext(null);
+function $337b884510726a0d$export$c6fdb837b070b4ff(props) {
+    let isSSR = (0, $k7QOs$useIsSSR)();
+    let { portalContainer: portalContainer = isSSR ? null : document.body  } = props;
+    let [contain, setContain] = (0, $k7QOs$useState)(false);
+    let contextValue = (0, $k7QOs$useMemo)(()=>({
+            contain: contain,
+            setContain: setContain
+        }), [
+        contain,
+        setContain
+    ]);
+    if (!portalContainer) return null;
+    let contents = /*#__PURE__*/ (0, $k7QOs$react).createElement($337b884510726a0d$export$a2200b96afd16271.Provider, {
+        value: contextValue
+    }, /*#__PURE__*/ (0, $k7QOs$react).createElement((0, $k7QOs$FocusScope), {
+        restoreFocus: true,
+        contain: contain
+    }, props.children));
+    return /*#__PURE__*/ (0, $k7QOs$reactdom).createPortal(contents, portalContainer);
+}
+function $337b884510726a0d$export$14c98a7594375490() {
+    let ctx = (0, $k7QOs$useContext)($337b884510726a0d$export$a2200b96afd16271);
+    let setContain = ctx === null || ctx === void 0 ? void 0 : ctx.setContain;
+    (0, $k7QOs$useLayoutEffect)(()=>{
+        setContain === null || setContain === void 0 ? void 0 : setContain(true);
+    }, [
+        setContain
+    ]);
+}
+
+
+
+function $8ac8429251c45e4b$export$dbc0f175b25fb0fb(props, state, ref) {
+    let { overlayProps: overlayProps , underlayProps: underlayProps  } = (0, $a11501f3d1d39e6c$export$ea8f71083e90600f)({
+        ...props,
+        isOpen: state.isOpen,
+        onClose: state.close
+    }, ref);
+    (0, $49c51c25361d4cd2$export$ee0f7cc6afcd1c18)({
+        isDisabled: !state.isOpen
+    });
+    (0, $337b884510726a0d$export$14c98a7594375490)();
+    (0, $k7QOs$useEffect)(()=>{
+        if (state.isOpen) return (0, $5e3802645cc19319$export$1c3ebcada18427bf)([
+            ref.current
+        ]);
+    }, [
+        state.isOpen,
+        ref
+    ]);
+    return {
+        modalProps: (0, $k7QOs$mergeProps)(overlayProps),
+        underlayProps: underlayProps
+    };
+}
+
+
+
+
+
+export {$2a41e45df1593e64$export$d39e1813b3bdd0e1 as useOverlayPosition, $a11501f3d1d39e6c$export$ea8f71083e90600f as useOverlay, $628037886ba31236$export$f9d5c8beee7d008d as useOverlayTrigger, $49c51c25361d4cd2$export$ee0f7cc6afcd1c18 as usePreventScroll, $f57aed4a881a3485$export$178405afcd8c5eb as ModalProvider, $f57aed4a881a3485$export$d9aaed4c3ece1bc0 as useModalProvider, $f57aed4a881a3485$export$bf688221f59024e5 as OverlayProvider, $f57aed4a881a3485$export$b47c3594eab58386 as OverlayContainer, $f57aed4a881a3485$export$33ffd74ebf07f060 as useModal, $86ea4cb521eb2e37$export$2317d149ed6f78c4 as DismissButton, $5e3802645cc19319$export$1c3ebcada18427bf as ariaHideOutside, $f2f8a6077418541e$export$542a6fd13ac93354 as usePopover, $8ac8429251c45e4b$export$dbc0f175b25fb0fb as useModalOverlay, $337b884510726a0d$export$c6fdb837b070b4ff as Overlay, $337b884510726a0d$export$14c98a7594375490 as useOverlayFocusContain};
+//# sourceMappingURL=module.js.map