@react-aria/overlays 3.7.3 → 3.7.4

package/dist/module.js

@@ -1,633 +1,513 @@
-import { VisuallyHidden } from "@react-aria/visually-hidden";
-import _babelRuntimeHelpersEsmInteropRequireDefault from "@babel/runtime/helpers/esm/interopRequireDefault";
-import _reactDom from "react-dom";
-import _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import { useFocusWithin, useInteractOutside } from "@react-aria/interactions";
-import { useLocale, useMessageFormatter } from "@react-aria/i18n";
-import { useLayoutEffect, useId, chain, getScrollParent, isIOS } from "@react-aria/utils";
-import _react, { useCallback, useRef, useState, useEffect, useContext, useMemo } from "react";
-import _domHelpersOwnerDocument from "dom-helpers/ownerDocument";
-import _domHelpersQueryScrollTop from "dom-helpers/query/scrollTop";
-import _domHelpersQueryScrollLeft from "dom-helpers/query/scrollLeft";
-import _domHelpersQueryPosition from "dom-helpers/query/position";
-import _domHelpersQueryOffset from "dom-helpers/query/offset";
-import _domHelpersStyle from "dom-helpers/style";
-import _babelRuntimeHelpersEsmExtends from "@babel/runtime/helpers/esm/extends";
-const $d45e305fb90d49e7c81f49bb4afe323b$var$AXIS = {
-  top: 'top',
-  bottom: 'top',
-  left: 'left',
-  right: 'left'
+import $P78NQ$react, {useState as $P78NQ$useState, useCallback as $P78NQ$useCallback, useRef as $P78NQ$useRef, useEffect as $P78NQ$useEffect, useContext as $P78NQ$useContext, useMemo as $P78NQ$useMemo} from "react";
+import {useLayoutEffect as $P78NQ$useLayoutEffect, useId as $P78NQ$useId, isIOS as $P78NQ$isIOS, chain as $P78NQ$chain, getScrollParent as $P78NQ$getScrollParent} from "@react-aria/utils";
+import {useLocale as $P78NQ$useLocale, useMessageFormatter as $P78NQ$useMessageFormatter} from "@react-aria/i18n";
+import $P78NQ$domhelpersstyle from "dom-helpers/style";
+import $P78NQ$domhelpersqueryoffset from "dom-helpers/query/offset";
+import $P78NQ$domhelpersqueryposition from "dom-helpers/query/position";
+import $P78NQ$domhelpersqueryscrollLeft from "dom-helpers/query/scrollLeft";
+import $P78NQ$domhelpersqueryscrollTop from "dom-helpers/query/scrollTop";
+import $P78NQ$domhelpersownerDocument from "dom-helpers/ownerDocument";
+import {useInteractOutside as $P78NQ$useInteractOutside, useFocusWithin as $P78NQ$useFocusWithin} from "@react-aria/interactions";
+import $P78NQ$reactdom from "react-dom";
+import {VisuallyHidden as $P78NQ$VisuallyHidden} from "@react-aria/visually-hidden";
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+var $257fdf58e89203e8$exports = {};
+
+$parcel$export($257fdf58e89203e8$exports, "useOverlayPosition", () => $257fdf58e89203e8$export$d39e1813b3bdd0e1);
+
+
+
+
+
+
+const $9510af50157ce9d5$var$AXIS = {
+    top: 'top',
+    bottom: 'top',
+    left: 'left',
+    right: 'left'
+};
+const $9510af50157ce9d5$var$FLIPPED_DIRECTION = {
+    top: 'bottom',
+    bottom: 'top',
+    left: 'right',
+    right: 'left'
 };
-const $d45e305fb90d49e7c81f49bb4afe323b$var$FLIPPED_DIRECTION = {
-  top: 'bottom',
-  bottom: 'top',
-  left: 'right',
-  right: 'left'
+const $9510af50157ce9d5$var$CROSS_AXIS = {
+    top: 'left',
+    left: 'top'
 };
-const $d45e305fb90d49e7c81f49bb4afe323b$var$CROSS_AXIS = {
-  top: 'left',
-  left: 'top'
+const $9510af50157ce9d5$var$AXIS_SIZE = {
+    top: 'height',
+    left: 'width'
 };
-const $d45e305fb90d49e7c81f49bb4afe323b$var$AXIS_SIZE = {
-  top: 'height',
-  left: 'width'
+const $9510af50157ce9d5$var$PARSED_PLACEMENT_CACHE = {
 };
-const $d45e305fb90d49e7c81f49bb4afe323b$var$PARSED_PLACEMENT_CACHE = {}; // @ts-ignore
-
-let $d45e305fb90d49e7c81f49bb4afe323b$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
-
-function $d45e305fb90d49e7c81f49bb4afe323b$var$getContainerDimensions(containerNode) {
-  let width = 0,
-      height = 0,
-      top = 0,
-      left = 0;
-  let scroll = {};
-
-  if (containerNode.tagName === 'BODY') {
-    var _visualViewport$width, _visualViewport$heigh;
-
-    width = (_visualViewport$width = $d45e305fb90d49e7c81f49bb4afe323b$var$visualViewport == null ? void 0 : $d45e305fb90d49e7c81f49bb4afe323b$var$visualViewport.width) != null ? _visualViewport$width : document.documentElement.clientWidth;
-    height = (_visualViewport$heigh = $d45e305fb90d49e7c81f49bb4afe323b$var$visualViewport == null ? void 0 : $d45e305fb90d49e7c81f49bb4afe323b$var$visualViewport.height) != null ? _visualViewport$heigh : document.documentElement.clientHeight;
-    scroll.top = _domHelpersQueryScrollTop(_domHelpersOwnerDocument(containerNode).documentElement) || _domHelpersQueryScrollTop(containerNode);
-    scroll.left = _domHelpersQueryScrollLeft(_domHelpersOwnerDocument(containerNode).documentElement) || _domHelpersQueryScrollLeft(containerNode);
-  } else {
-    ({
-      width,
-      height,
-      top,
-      left
-    } = _domHelpersQueryOffset(containerNode));
-    scroll.top = _domHelpersQueryScrollTop(containerNode);
-    scroll.left = _domHelpersQueryScrollLeft(containerNode);
-  }
-
-  return {
-    width,
-    height,
-    scroll,
-    top,
-    left
-  };
+// @ts-ignore
+let $9510af50157ce9d5$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
+function $9510af50157ce9d5$var$getContainerDimensions(containerNode) {
+    let width = 0, height = 0, top = 0, left = 0;
+    let scroll = {
+    };
+    if (containerNode.tagName === 'BODY') {
+        width = $9510af50157ce9d5$var$visualViewport?.width ?? document.documentElement.clientWidth;
+        height = $9510af50157ce9d5$var$visualViewport?.height ?? document.documentElement.clientHeight;
+        scroll.top = $P78NQ$domhelpersqueryscrollTop($P78NQ$domhelpersownerDocument(containerNode).documentElement) || $P78NQ$domhelpersqueryscrollTop(containerNode);
+        scroll.left = $P78NQ$domhelpersqueryscrollLeft($P78NQ$domhelpersownerDocument(containerNode).documentElement) || $P78NQ$domhelpersqueryscrollLeft(containerNode);
+    } else {
+        ({ width: width , height: height , top: top , left: left  } = $P78NQ$domhelpersqueryoffset(containerNode));
+        scroll.top = $P78NQ$domhelpersqueryscrollTop(containerNode);
+        scroll.left = $P78NQ$domhelpersqueryscrollLeft(containerNode);
+    }
+    return {
+        width: width,
+        height: height,
+        scroll: scroll,
+        top: top,
+        left: left
+    };
 }
-
-function $d45e305fb90d49e7c81f49bb4afe323b$var$getScroll(node) {
-  return {
-    top: node.scrollTop,
-    left: node.scrollLeft,
-    width: node.scrollWidth,
-    height: node.scrollHeight
-  };
+function $9510af50157ce9d5$var$getScroll(node) {
+    return {
+        top: node.scrollTop,
+        left: node.scrollLeft,
+        width: node.scrollWidth,
+        height: node.scrollHeight
+    };
 }
-
-function $d45e305fb90d49e7c81f49bb4afe323b$var$getDelta(axis, offset, size, containerDimensions, padding) {
-  let containerScroll = containerDimensions.scroll[axis];
-  let containerHeight = containerDimensions[$d45e305fb90d49e7c81f49bb4afe323b$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 $9510af50157ce9d5$var$getDelta(axis, offset, size, containerDimensions, padding) {
+    let containerScroll = containerDimensions.scroll[axis];
+    let containerHeight = containerDimensions[$9510af50157ce9d5$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 $d45e305fb90d49e7c81f49bb4afe323b$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 $9510af50157ce9d5$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 $d45e305fb90d49e7c81f49bb4afe323b$var$parsePlacement(input) {
-  if ($d45e305fb90d49e7c81f49bb4afe323b$var$PARSED_PLACEMENT_CACHE[input]) {
-    return $d45e305fb90d49e7c81f49bb4afe323b$var$PARSED_PLACEMENT_CACHE[input];
-  }
-
-  let [placement, crossPlacement] = input.split(' ');
-  let axis = $d45e305fb90d49e7c81f49bb4afe323b$var$AXIS[placement] || 'right';
-  let crossAxis = $d45e305fb90d49e7c81f49bb4afe323b$var$CROSS_AXIS[axis];
-
-  if (!$d45e305fb90d49e7c81f49bb4afe323b$var$AXIS[crossPlacement]) {
-    crossPlacement = 'center';
-  }
-
-  let size = $d45e305fb90d49e7c81f49bb4afe323b$var$AXIS_SIZE[axis];
-  let crossSize = $d45e305fb90d49e7c81f49bb4afe323b$var$AXIS_SIZE[crossAxis];
-  $d45e305fb90d49e7c81f49bb4afe323b$var$PARSED_PLACEMENT_CACHE[input] = {
-    placement,
-    crossPlacement,
-    axis,
-    crossAxis,
-    size,
-    crossSize
-  };
-  return $d45e305fb90d49e7c81f49bb4afe323b$var$PARSED_PLACEMENT_CACHE[input];
+function $9510af50157ce9d5$var$parsePlacement(input) {
+    if ($9510af50157ce9d5$var$PARSED_PLACEMENT_CACHE[input]) return $9510af50157ce9d5$var$PARSED_PLACEMENT_CACHE[input];
+    let [placement, crossPlacement] = input.split(' ');
+    let axis = $9510af50157ce9d5$var$AXIS[placement] || 'right';
+    let crossAxis = $9510af50157ce9d5$var$CROSS_AXIS[axis];
+    if (!$9510af50157ce9d5$var$AXIS[crossPlacement]) crossPlacement = 'center';
+    let size = $9510af50157ce9d5$var$AXIS_SIZE[axis];
+    let crossSize = $9510af50157ce9d5$var$AXIS_SIZE[crossAxis];
+    $9510af50157ce9d5$var$PARSED_PLACEMENT_CACHE[input] = {
+        placement: placement,
+        crossPlacement: crossPlacement,
+        axis: axis,
+        crossAxis: crossAxis,
+        size: size,
+        crossSize: crossSize
+    };
+    return $9510af50157ce9d5$var$PARSED_PLACEMENT_CACHE[input];
 }
-
-function $d45e305fb90d49e7c81f49bb4afe323b$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned) {
-  let {
-    placement,
-    crossPlacement,
-    axis,
-    crossAxis,
-    size,
-    crossSize
-  } = placementInfo;
-  let position = {}; // button position
-
-  position[crossAxis] = childOffset[crossAxis];
-
-  if (crossPlacement === 'center') {
-    //  + (button size / 2) - (overlay size / 2)
+function $9510af50157ce9d5$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned) {
+    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)
+    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; // this is button center position - the overlay size + half of the button to align bottom of overlay with button center
-
-  let minViablePosition = childOffset[crossAxis] + childOffset[crossSize] / 2 - overlaySize[crossSize]; // this is button position of center, aligns top of overlay with button center
-
-  let maxViablePosition = childOffset[crossAxis] + childOffset[crossSize] / 2; // clamp it into the range of the min/max positions
-
-  position[crossAxis] = Math.min(Math.max(minViablePosition, position[crossAxis]), maxViablePosition); // 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[size];
-    position[$d45e305fb90d49e7c81f49bb4afe323b$var$FLIPPED_DIRECTION[axis]] = Math.floor(containerHeight - childOffset[axis] + offset);
-  } else {
-    position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
-  }
-
-  return position;
+     /* else {
+    the overlay top should match the button top
+  } */ 
+    // add the crossOffset from props
+    position[crossAxis] += crossOffset;
+    // this is button center position - the overlay size + half of the button to align bottom of overlay with button center
+    let minViablePosition = childOffset[crossAxis] + childOffset[crossSize] / 2 - overlaySize[crossSize];
+    // this is button position of center, aligns top of overlay with button center
+    let maxViablePosition = childOffset[crossAxis] + childOffset[crossSize] / 2;
+    // clamp it into the range of the min/max positions
+    position[crossAxis] = Math.min(Math.max(minViablePosition, position[crossAxis]), maxViablePosition);
+    // 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[size];
+        position[$9510af50157ce9d5$var$FLIPPED_DIRECTION[axis]] = Math.floor(containerHeight - childOffset[axis] + offset);
+    } else position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
+    return position;
 }
-
-function $d45e305fb90d49e7c81f49bb4afe323b$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding) {
-  return position.top != null // We want the distance between the top of the overlay to the bottom of the boundary
-  ? 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
-  ) // We want the distance between the top of the trigger to the top of the boundary
-  : 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 $9510af50157ce9d5$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding) {
+    return position.top != null ? Math.max(0, boundaryDimensions.height + boundaryDimensions.top + boundaryDimensions.scroll.top - (containerOffsetWithBoundary.top + position.top) - (margins.top + margins.bottom + padding) // save additional space for margin and padding
+    ) : Math.max(0, childOffset.top + containerOffsetWithBoundary.top - (boundaryDimensions.top + boundaryDimensions.scroll.top) - (margins.top + margins.bottom + padding) // save additional space for margin and padding
+    );
 }
-
-function $d45e305fb90d49e7c81f49bb4afe323b$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding, placementInfo) {
-  let {
-    placement,
-    axis,
-    size
-  } = placementInfo;
-
-  if (placement === axis) {
-    return Math.max(0, childOffset[axis] - boundaryDimensions[axis] - boundaryDimensions.scroll[axis] + containerOffsetWithBoundary[axis] - margins[axis] - margins[$d45e305fb90d49e7c81f49bb4afe323b$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[$d45e305fb90d49e7c81f49bb4afe323b$var$FLIPPED_DIRECTION[axis]] - padding);
+function $9510af50157ce9d5$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[$9510af50157ce9d5$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[$9510af50157ce9d5$var$FLIPPED_DIRECTION[axis]] - padding);
 }
-
-function $d45e305fb90d49e7c81f49bb4afe323b$export$calculatePositionInternal(placementInput, childOffset, overlaySize, scrollSize, margins, padding, flip, boundaryDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned) {
-  let placementInfo = $d45e305fb90d49e7c81f49bb4afe323b$var$parsePlacement(placementInput);
-  let {
-    size,
-    crossAxis,
-    crossSize,
-    placement,
-    crossPlacement
-  } = placementInfo;
-  let position = $d45e305fb90d49e7c81f49bb4afe323b$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned);
-  let normalizedOffset = offset;
-  let space = $d45e305fb90d49e7c81f49bb4afe323b$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 = $d45e305fb90d49e7c81f49bb4afe323b$var$parsePlacement($d45e305fb90d49e7c81f49bb4afe323b$var$FLIPPED_DIRECTION[placement] + " " + crossPlacement);
-    let flippedPosition = $d45e305fb90d49e7c81f49bb4afe323b$var$computePosition(childOffset, boundaryDimensions, overlaySize, flippedPlacementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned);
-    let flippedSpace = $d45e305fb90d49e7c81f49bb4afe323b$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;
+function $9510af50157ce9d5$export$6839422d1f33cee9(placementInput, childOffset, overlaySize, scrollSize, margins, padding, flip, boundaryDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, userSetMaxHeight) {
+    let placementInfo = $9510af50157ce9d5$var$parsePlacement(placementInput);
+    let { size: size , crossAxis: crossAxis , crossSize: crossSize , placement: placement , crossPlacement: crossPlacement  } = placementInfo;
+    let position = $9510af50157ce9d5$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned);
+    let normalizedOffset = offset;
+    let space = $9510af50157ce9d5$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 = $9510af50157ce9d5$var$parsePlacement(`${$9510af50157ce9d5$var$FLIPPED_DIRECTION[placement]} ${crossPlacement}`);
+        let flippedPosition = $9510af50157ce9d5$var$computePosition(childOffset, boundaryDimensions, overlaySize, flippedPlacementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned);
+        let flippedSpace = $9510af50157ce9d5$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 = $d45e305fb90d49e7c81f49bb4afe323b$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, padding);
-  position[crossAxis] += delta;
-  let maxHeight = $d45e305fb90d49e7c81f49bb4afe323b$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding);
-  overlaySize.height = Math.min(overlaySize.height, maxHeight);
-  position = $d45e305fb90d49e7c81f49bb4afe323b$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned);
-  delta = $d45e305fb90d49e7c81f49bb4afe323b$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, padding);
-  position[crossAxis] += delta;
-  let arrowPosition = {};
-  arrowPosition[crossAxis] = childOffset[crossAxis] - position[crossAxis] + childOffset[crossSize] / 2;
-  return {
-    position,
-    maxHeight: maxHeight,
-    arrowOffsetLeft: arrowPosition.left,
-    arrowOffsetTop: arrowPosition.top,
-    placement: placementInfo.placement
-  };
-}
-/**
- * Determines where to place the overlay with regards to the target and the position of an optional indicator.
- */
-
-
-function $d45e305fb90d49e7c81f49bb4afe323b$export$calculatePosition(opts) {
-  let {
-    placement,
-    targetNode,
-    overlayNode,
-    scrollNode,
-    padding,
-    shouldFlip,
-    boundaryElement,
-    offset,
-    crossOffset
-  } = opts;
-  let container = overlayNode.offsetParent || document.body;
-  let isBodyContainer = container.tagName === 'BODY';
-  const containerPositionStyle = window.getComputedStyle(container).position;
-  let isContainerPositioned = !!containerPositionStyle && containerPositionStyle !== 'static';
-  let childOffset = isBodyContainer ? _domHelpersQueryOffset(targetNode) : _domHelpersQueryPosition(targetNode, container);
-
-  if (!isBodyContainer) {
-    childOffset.top += parseInt(_domHelpersStyle(targetNode, 'marginTop'), 10) || 0;
-    childOffset.left += parseInt(_domHelpersStyle(targetNode, 'marginLeft'), 10) || 0;
-  }
-
-  let overlaySize = _domHelpersQueryOffset(overlayNode);
-
-  let margins = $d45e305fb90d49e7c81f49bb4afe323b$var$getMargins(overlayNode);
-  overlaySize.width += margins.left + margins.right;
-  overlaySize.height += margins.top + margins.bottom;
-  let scrollSize = $d45e305fb90d49e7c81f49bb4afe323b$var$getScroll(scrollNode);
-  let boundaryDimensions = $d45e305fb90d49e7c81f49bb4afe323b$var$getContainerDimensions(boundaryElement);
-  let containerOffsetWithBoundary = boundaryElement.tagName === 'BODY' ? _domHelpersQueryOffset(container) : _domHelpersQueryPosition(container, boundaryElement);
-  return $d45e305fb90d49e7c81f49bb4afe323b$export$calculatePositionInternal(placement, childOffset, overlaySize, scrollSize, margins, padding, shouldFlip, boundaryDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned);
+    let delta = $9510af50157ce9d5$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, padding);
+    position[crossAxis] += delta;
+    let maxHeight = $9510af50157ce9d5$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding);
+    if (userSetMaxHeight && userSetMaxHeight < maxHeight) maxHeight = userSetMaxHeight;
+    overlaySize.height = Math.min(overlaySize.height, maxHeight);
+    position = $9510af50157ce9d5$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned);
+    delta = $9510af50157ce9d5$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, padding);
+    position[crossAxis] += delta;
+    let arrowPosition = {
+    };
+    arrowPosition[crossAxis] = childOffset[crossAxis] - position[crossAxis] + childOffset[crossSize] / 2;
+    return {
+        position: position,
+        maxHeight: maxHeight,
+        arrowOffsetLeft: arrowPosition.left,
+        arrowOffsetTop: arrowPosition.top,
+        placement: placementInfo.placement
+    };
 }
-
-// This behavior moved from useOverlayTrigger to useOverlayPosition.
-// For backward compatibility, where useOverlayTrigger handled hiding the popover on close,
-// it sets a close function here mapped from the trigger element. This way we can avoid
-// forcing users to pass an onClose function to useOverlayPosition which could be considered
-// a breaking change.
-const $df1b2f080f58bf9e74aeb666b8c96ba$export$onCloseMap = new WeakMap();
-
-/** @private */
-function $df1b2f080f58bf9e74aeb666b8c96ba$export$useCloseOnScroll(opts) {
-  let {
-    triggerRef,
-    isOpen,
-    onClose
-  } = opts;
-  useEffect(() => {
-    if (!isOpen) {
-      return;
+function $9510af50157ce9d5$export$b3ceb0cbf1056d98(opts) {
+    let { placement: placement , targetNode: targetNode , overlayNode: overlayNode , scrollNode: scrollNode , padding: padding , shouldFlip: shouldFlip , boundaryElement: boundaryElement , offset: offset , crossOffset: crossOffset , maxHeight: maxHeight  } = opts;
+    let container = overlayNode.offsetParent || document.body;
+    let isBodyContainer = container.tagName === 'BODY';
+    const containerPositionStyle = window.getComputedStyle(container).position;
+    let isContainerPositioned = !!containerPositionStyle && containerPositionStyle !== 'static';
+    let childOffset = isBodyContainer ? $P78NQ$domhelpersqueryoffset(targetNode) : $P78NQ$domhelpersqueryposition(targetNode, container);
+    if (!isBodyContainer) {
+        childOffset.top += parseInt($P78NQ$domhelpersstyle(targetNode, 'marginTop'), 10) || 0;
+        childOffset.left += parseInt($P78NQ$domhelpersstyle(targetNode, 'marginLeft'), 10) || 0;
     }
+    let overlaySize = $P78NQ$domhelpersqueryoffset(overlayNode);
+    let margins = $9510af50157ce9d5$var$getMargins(overlayNode);
+    overlaySize.width += margins.left + margins.right;
+    overlaySize.height += margins.top + margins.bottom;
+    let scrollSize = $9510af50157ce9d5$var$getScroll(scrollNode);
+    let boundaryDimensions = $9510af50157ce9d5$var$getContainerDimensions(boundaryElement);
+    let containerOffsetWithBoundary = boundaryElement.tagName === 'BODY' ? $P78NQ$domhelpersqueryoffset(container) : $P78NQ$domhelpersqueryposition(container, boundaryElement);
+    return $9510af50157ce9d5$export$6839422d1f33cee9(placement, childOffset, overlaySize, scrollSize, margins, padding, shouldFlip, boundaryDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, maxHeight);
+}
 
-    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 || $df1b2f080f58bf9e74aeb666b8c96ba$export$onCloseMap.get(triggerRef.current);
 
-      if (onCloseHandler) {
-        onCloseHandler();
-      }
-    };
 
-    window.addEventListener('scroll', onScroll, true);
-    return () => {
-      window.removeEventListener('scroll', onScroll, true);
-    };
-  }, [isOpen, onClose, triggerRef]);
+const $e51657e17bcf89d1$export$f6211563215e3b37 = new WeakMap();
+function $e51657e17bcf89d1$export$18fc8428861184da(opts) {
+    let { triggerRef: triggerRef , isOpen: isOpen , onClose: onClose  } = opts;
+    $P78NQ$useEffect(()=>{
+        if (!isOpen) 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 || $e51657e17bcf89d1$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 $ae841ee9d3f76b31663cf0594adb0fc$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
-/**
- * Handles positioning overlays like popovers and menus relative to a trigger
- * element, and updating the position when the window resizes.
- */
-
-export function useOverlayPosition(props) {
-  let {
-    direction
-  } = useLocale();
-  let {
-    targetRef,
-    overlayRef,
-    scrollRef = overlayRef,
-    placement = 'bottom',
-    containerPadding = 12,
-    shouldFlip = true,
-    boundaryElement = typeof document !== 'undefined' ? document.body : null,
-    offset = 0,
-    crossOffset = 0,
-    shouldUpdatePosition = true,
-    isOpen = true,
-    onClose
-  } = props;
-  let [position, setPosition] = 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];
-  let updatePosition = useCallback(() => {
-    if (shouldUpdatePosition === false || !isOpen || !overlayRef.current || !targetRef.current || !scrollRef.current || !boundaryElement) {
-      return;
-    }
-
-    setPosition($d45e305fb90d49e7c81f49bb4afe323b$export$calculatePosition({
-      placement: $ae841ee9d3f76b31663cf0594adb0fc$var$translateRTL(placement, direction),
-      overlayNode: overlayRef.current,
-      targetNode: targetRef.current,
-      scrollNode: scrollRef.current,
-      padding: containerPadding,
-      shouldFlip,
-      boundaryElement,
-      offset,
-      crossOffset
-    }));
-  }, deps); // Update position when anything changes
-
-  useLayoutEffect(updatePosition, deps); // Update position on window resize
 
-  $ae841ee9d3f76b31663cf0594adb0fc$var$useResize(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 = useRef(false);
-  useLayoutEffect(() => {
-    let timeout;
 
-    let onResize = () => {
-      isResizing.current = true;
-      clearTimeout(timeout);
-      timeout = setTimeout(() => {
-        isResizing.current = false;
-      }, 500);
-      updatePosition();
-    };
-
-    $ae841ee9d3f76b31663cf0594adb0fc$var$visualViewport == null ? void 0 : $ae841ee9d3f76b31663cf0594adb0fc$var$visualViewport.addEventListener('resize', onResize);
-    return () => {
-      $ae841ee9d3f76b31663cf0594adb0fc$var$visualViewport == null ? void 0 : $ae841ee9d3f76b31663cf0594adb0fc$var$visualViewport.removeEventListener('resize', onResize);
+// @ts-ignore
+let $257fdf58e89203e8$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
+function $257fdf58e89203e8$export$d39e1813b3bdd0e1(props) {
+    let { direction: direction  } = $P78NQ$useLocale();
+    let { 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  } = props;
+    let [position, setPosition] = $P78NQ$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
+    ];
+    let updatePosition = $P78NQ$useCallback(()=>{
+        if (shouldUpdatePosition === false || !isOpen || !overlayRef.current || !targetRef.current || !scrollRef.current || !boundaryElement) return;
+        setPosition($9510af50157ce9d5$export$b3ceb0cbf1056d98({
+            placement: $257fdf58e89203e8$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
+        }));
+    }, deps);
+    // Update position when anything changes
+    $P78NQ$useLayoutEffect(updatePosition, deps);
+    // Update position on window resize
+    $257fdf58e89203e8$var$useResize(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 = $P78NQ$useRef(false);
+    $P78NQ$useLayoutEffect(()=>{
+        let timeout;
+        let onResize = ()=>{
+            isResizing.current = true;
+            clearTimeout(timeout);
+            timeout = setTimeout(()=>{
+                isResizing.current = false;
+            }, 500);
+            updatePosition();
+        };
+        $257fdf58e89203e8$var$visualViewport?.addEventListener('resize', onResize);
+        return ()=>{
+            $257fdf58e89203e8$var$visualViewport?.removeEventListener('resize', onResize);
+        };
+    }, [
+        updatePosition
+    ]);
+    let close = $P78NQ$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.
+    $e51657e17bcf89d1$export$18fc8428861184da({
+        triggerRef: targetRef,
+        isOpen: isOpen,
+        onClose: onClose ? close : undefined
+    });
+    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
     };
-  }, [updatePosition]);
-  let close = 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.
-
-  $df1b2f080f58bf9e74aeb666b8c96ba$export$useCloseOnScroll({
-    triggerRef: targetRef,
-    isOpen,
-    onClose: onClose ? close : undefined
-  });
-  return {
-    overlayProps: {
-      style: _babelRuntimeHelpersEsmExtends({
-        position: 'absolute',
-        zIndex: 100000
-      }, position.position, {
-        maxHeight: position.maxHeight
-      })
-    },
-    placement: position.placement,
-    arrowProps: {
-      style: {
-        left: position.arrowOffsetLeft,
-        top: position.arrowOffsetTop
-      }
-    },
-    updatePosition
-  };
 }
-
-function $ae841ee9d3f76b31663cf0594adb0fc$var$useResize(onResize) {
-  useLayoutEffect(() => {
-    window.addEventListener('resize', onResize, false);
-    return () => {
-      window.removeEventListener('resize', onResize, false);
-    };
-  }, [onResize]);
+function $257fdf58e89203e8$var$useResize(onResize) {
+    $P78NQ$useLayoutEffect(()=>{
+        window.addEventListener('resize', onResize, false);
+        return ()=>{
+            window.removeEventListener('resize', onResize, false);
+        };
+    }, [
+        onResize
+    ]);
 }
-
-function $ae841ee9d3f76b31663cf0594adb0fc$var$translateRTL(position, direction) {
-  if (direction === 'rtl') {
-    return position.replace('start', 'right').replace('end', 'left');
-  }
-
-  return position.replace('start', 'left').replace('end', 'right');
+function $257fdf58e89203e8$var$translateRTL(position, direction) {
+    if (direction === 'rtl') return position.replace('start', 'right').replace('end', 'left');
+    return position.replace('start', 'left').replace('end', 'right');
 }
 
-const $e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays = [];
-/**
- * Provides the behavior for overlays such as dialogs, popovers, and menus.
- * Hides the overlay when the user interacts outside it, when the Escape key is pressed,
- * or optionally, on blur. Only the top-most overlay will close at once.
- */
-
-export function useOverlay(props, ref) {
-  let {
-    onClose,
-    shouldCloseOnBlur,
-    isOpen,
-    isDismissable = false,
-    isKeyboardDismissDisabled = false,
-    shouldCloseOnInteractOutside
-  } = props; // Add the overlay ref to the stack of visible overlays on mount, and remove on unmount.
-
-  useEffect(() => {
-    if (isOpen) {
-      $e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays.push(ref);
-    }
 
-    return () => {
-      let index = $e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays.indexOf(ref);
-
-      if (index >= 0) {
-        $e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays.splice(index, 1);
-      }
+var $3e0c6adf4453f3f2$exports = {};
+
+$parcel$export($3e0c6adf4453f3f2$exports, "useOverlay", () => $3e0c6adf4453f3f2$export$ea8f71083e90600f);
+
+
+const $3e0c6adf4453f3f2$var$visibleOverlays = [];
+function $3e0c6adf4453f3f2$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.
+    $P78NQ$useEffect(()=>{
+        if (isOpen) $3e0c6adf4453f3f2$var$visibleOverlays.push(ref);
+        return ()=>{
+            let index = $3e0c6adf4453f3f2$var$visibleOverlays.indexOf(ref);
+            if (index >= 0) $3e0c6adf4453f3f2$var$visibleOverlays.splice(index, 1);
+        };
+    }, [
+        isOpen,
+        ref
+    ]);
+    // Only hide the overlay when it is the topmost visible overlay in the stack.
+    let onHide = ()=>{
+        if ($3e0c6adf4453f3f2$var$visibleOverlays[$3e0c6adf4453f3f2$var$visibleOverlays.length - 1] === ref && onClose) onClose();
     };
-  }, [isOpen, ref]); // Only hide the overlay when it is the topmost visible overlay in the stack.
-
-  let onHide = () => {
-    if ($e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays[$e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays.length - 1] === ref && onClose) {
-      onClose();
-    }
-  };
-
-  let onInteractOutsideStart = e => {
-    if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.target)) {
-      if ($e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays[$e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays.length - 1] === ref) {
-        e.stopPropagation();
-        e.preventDefault();
-      }
-    }
-  };
+    let onInteractOutsideStart = (e)=>{
+        if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.target)) {
+            if ($3e0c6adf4453f3f2$var$visibleOverlays[$3e0c6adf4453f3f2$var$visibleOverlays.length - 1] === ref) {
+                e.stopPropagation();
+                e.preventDefault();
+            }
+        }
+    };
+    let onInteractOutside = (e)=>{
+        if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.target)) {
+            if ($3e0c6adf4453f3f2$var$visibleOverlays[$3e0c6adf4453f3f2$var$visibleOverlays.length - 1] === ref) {
+                e.stopPropagation();
+                e.preventDefault();
+            }
+            onHide();
+        }
+    };
+    // Handle the escape key
+    let onKeyDown = (e)=>{
+        if (e.key === 'Escape' && !isKeyboardDismissDisabled) {
+            e.preventDefault();
+            onHide();
+        }
+    };
+    // Handle clicking outside the overlay to close it
+    $P78NQ$useInteractOutside({
+        ref: ref,
+        onInteractOutside: isDismissable ? onInteractOutside : null,
+        onInteractOutsideStart: onInteractOutsideStart
+    });
+    let { focusWithinProps: focusWithinProps  } = $P78NQ$useFocusWithin({
+        isDisabled: !shouldCloseOnBlur,
+        onBlurWithin: (e)=>{
+            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
+        }
+    };
+}
 
-  let onInteractOutside = e => {
-    if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.target)) {
-      if ($e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays[$e4d5b842fe0e1058e95712442330b88c$var$visibleOverlays.length - 1] === ref) {
-        e.stopPropagation();
-        e.preventDefault();
-      }
 
-      onHide();
-    }
-  }; // Handle the escape key
+var $090c2b640a9525fd$exports = {};
+
+$parcel$export($090c2b640a9525fd$exports, "useOverlayTrigger", () => $090c2b640a9525fd$export$f9d5c8beee7d008d);
+
+
+
+function $090c2b640a9525fd$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.
+    $P78NQ$useEffect(()=>{
+        if (ref && ref.current) $e51657e17bcf89d1$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 = $P78NQ$useId();
+    return {
+        triggerProps: {
+            'aria-haspopup': ariaHasPopup,
+            'aria-expanded': isOpen,
+            'aria-controls': isOpen ? overlayId : null
+        },
+        overlayProps: {
+            id: overlayId
+        }
+    };
+}
 
 
-  let onKeyDown = e => {
-    if (e.key === 'Escape' && !isKeyboardDismissDisabled) {
-      e.preventDefault();
-      onHide();
-    }
-  }; // Handle clicking outside the overlay to close it
-
-
-  useInteractOutside({
-    ref,
-    onInteractOutside: isDismissable ? onInteractOutside : null,
-    onInteractOutsideStart
-  });
-  let {
-    focusWithinProps
-  } = useFocusWithin({
-    isDisabled: !shouldCloseOnBlur,
-    onBlurWithin: e => {
-      if (!shouldCloseOnInteractOutside || shouldCloseOnInteractOutside(e.relatedTarget)) {
-        onClose();
-      }
-    }
-  });
+var $48168a03440bff21$exports = {};
 
-  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: _babelRuntimeHelpersEsmExtends({
-      onKeyDown
-    }, focusWithinProps),
-    underlayProps: {
-      onPointerDown: onPointerDownUnderlay
-    }
-  };
-}
+$parcel$export($48168a03440bff21$exports, "usePreventScroll", () => $48168a03440bff21$export$ee0f7cc6afcd1c18);
 
-/**
- * Handles the behavior and accessibility for an overlay trigger, e.g. a button
- * that opens a popover, menu, or other overlay that is positioned relative to the trigger.
- */
-export function useOverlayTrigger(props, state, ref) {
-  let {
-    type
-  } = props;
-  let {
-    isOpen
-  } = state; // Backward compatibility. Share state close function with useOverlayPosition so it can close on scroll
-  // without forcing users to pass onClose.
-
-  useEffect(() => {
-    if (ref && ref.current) {
-      $df1b2f080f58bf9e74aeb666b8c96ba$export$onCloseMap.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 = useId();
-  return {
-    triggerProps: {
-      'aria-haspopup': ariaHasPopup,
-      'aria-expanded': isOpen,
-      'aria-controls': isOpen ? overlayId : null
-    },
-    overlayProps: {
-      id: overlayId
-    }
-  };
-}
 // @ts-ignore
-const $ece0076f06e8a828c60ba0c94f22f89$var$visualViewport = typeof window !== 'undefined' && window.visualViewport; // HTML input types that do not cause the software keyboard to appear.
-
-const $ece0076f06e8a828c60ba0c94f22f89$var$nonTextInputTypes = new Set(['checkbox', 'radio', 'range', 'color', 'file', 'image', 'button', 'submit', 'reset']);
-/**
- * Prevents scrolling on the document body on mount, and
- * restores it on unmount. Also ensures that content does not
- * shift due to the scrollbars disappearing.
- */
-
-export function usePreventScroll(options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  let {
-    isDisabled
-  } = options;
-  useLayoutEffect(() => {
-    if (isDisabled) {
-      return;
-    }
-
-    if (isIOS()) {
-      return $ece0076f06e8a828c60ba0c94f22f89$var$preventScrollMobileSafari();
-    } else {
-      return $ece0076f06e8a828c60ba0c94f22f89$var$preventScrollStandard();
-    }
-  }, [isDisabled]);
-} // For most browsers, all we need to do is set `overflow: hidden` on the root element, and
+const $48168a03440bff21$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
+// HTML input types that do not cause the software keyboard to appear.
+const $48168a03440bff21$var$nonTextInputTypes = new Set([
+    'checkbox',
+    'radio',
+    'range',
+    'color',
+    'file',
+    'image',
+    'button',
+    'submit',
+    'reset'
+]);
+function $48168a03440bff21$export$ee0f7cc6afcd1c18(options = {
+}) {
+    let { isDisabled: isDisabled  } = options;
+    $P78NQ$useLayoutEffect(()=>{
+        if (isDisabled) return;
+        if ($P78NQ$isIOS()) return $48168a03440bff21$var$preventScrollMobileSafari();
+        else return $48168a03440bff21$var$preventScrollStandard();
+    }, [
+        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 $ece0076f06e8a828c60ba0c94f22f89$var$preventScrollStandard() {
-  return chain($ece0076f06e8a828c60ba0c94f22f89$var$setStyle(document.documentElement, 'paddingRight', window.innerWidth - document.documentElement.clientWidth + "px"), $ece0076f06e8a828c60ba0c94f22f89$var$setStyle(document.documentElement, 'overflow', 'hidden'));
-} // Mobile Safari is a whole different beast. Even with overflow: hidden,
+function $48168a03440bff21$var$preventScrollStandard() {
+    return $P78NQ$chain($48168a03440bff21$var$setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`), $48168a03440bff21$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.
@@ -653,397 +533,419 @@ function $ece0076f06e8a828c60ba0c94f22f89$var$preventScrollStandard() {
 //    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 $48168a03440bff21$var$preventScrollMobileSafari() {
+    let scrollable;
+    let lastY = 0;
+    let onTouchStart = (e)=>{
+        // Store the nearest scrollable parent element from the element that the user touched.
+        scrollable = $P78NQ$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;
+        if (target instanceof HTMLInputElement && !$48168a03440bff21$var$nonTextInputTypes.has(target.type)) {
+            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 (target instanceof HTMLInputElement && !$48168a03440bff21$var$nonTextInputTypes.has(target.type)) {
+            // 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 ($48168a03440bff21$var$visualViewport) {
+                    if ($48168a03440bff21$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(()=>{
+                        $48168a03440bff21$var$scrollIntoView(target);
+                    });
+                    else // Otherwise, wait for the visual viewport to resize before scrolling so we can
+                    // measure the correct position to scroll to.
+                    $48168a03440bff21$var$visualViewport.addEventListener('resize', ()=>$48168a03440bff21$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 = $P78NQ$chain($48168a03440bff21$var$setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`), $48168a03440bff21$var$setStyle(document.documentElement, 'overflow', 'hidden'), $48168a03440bff21$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 = $P78NQ$chain($48168a03440bff21$var$addEvent(document, 'touchstart', onTouchStart, {
+        passive: false,
+        capture: true
+    }), $48168a03440bff21$var$addEvent(document, 'touchmove', onTouchMove, {
+        passive: false,
+        capture: true
+    }), $48168a03440bff21$var$addEvent(document, 'touchend', onTouchEnd, {
+        passive: false,
+        capture: true
+    }), $48168a03440bff21$var$addEvent(document, 'focus', onFocus, true), $48168a03440bff21$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 $48168a03440bff21$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 $48168a03440bff21$var$addEvent(target, event, handler, options) {
+    target.addEventListener(event, handler, options);
+    return ()=>{
+        target.removeEventListener(event, handler, options);
+    };
+}
+function $48168a03440bff21$var$scrollIntoView(target) {
+    // Find the parent scrollable element and adjust the scroll position if the target is not already in view.
+    let scrollable = $P78NQ$getScrollParent(target);
+    if (scrollable !== document.documentElement && scrollable !== document.body) {
+        let scrollableTop = scrollable.getBoundingClientRect().top;
+        let targetTop = target.getBoundingClientRect().top;
+        if (targetTop > scrollableTop + target.clientHeight) scrollable.scrollTop += targetTop - scrollableTop;
+    }
+}
+
+
+var $698c70f6640041fb$exports = {};
+
+$parcel$export($698c70f6640041fb$exports, "ModalProvider", () => $698c70f6640041fb$export$178405afcd8c5eb);
+$parcel$export($698c70f6640041fb$exports, "useModalProvider", () => $698c70f6640041fb$export$d9aaed4c3ece1bc0);
+$parcel$export($698c70f6640041fb$exports, "OverlayProvider", () => $698c70f6640041fb$export$bf688221f59024e5);
+$parcel$export($698c70f6640041fb$exports, "OverlayContainer", () => $698c70f6640041fb$export$b47c3594eab58386);
+$parcel$export($698c70f6640041fb$exports, "useModal", () => $698c70f6640041fb$export$33ffd74ebf07f060);
+
+
+const $698c70f6640041fb$var$Context = /*#__PURE__*/ $P78NQ$react.createContext(null);
+function $698c70f6640041fb$export$178405afcd8c5eb(props) {
+    let { children: children  } = props;
+    let parent = $P78NQ$useContext($698c70f6640041fb$var$Context);
+    let [modalCount, setModalCount] = $P78NQ$useState(0);
+    let context = $P78NQ$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__*/ $P78NQ$react.createElement($698c70f6640041fb$var$Context.Provider, {
+        value: context
+    }, children));
+}
+function $698c70f6640041fb$export$d9aaed4c3ece1bc0() {
+    let context = $P78NQ$useContext($698c70f6640041fb$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 $698c70f6640041fb$var$OverlayContainerDOM(props) {
+    let { modalProviderProps: modalProviderProps  } = $698c70f6640041fb$export$d9aaed4c3ece1bc0();
+    return(/*#__PURE__*/ $P78NQ$react.createElement("div", {
+        "data-overlay-container": true,
+        ...props,
+        ...modalProviderProps
+    }));
+}
+function $698c70f6640041fb$export$bf688221f59024e5(props) {
+    return(/*#__PURE__*/ $P78NQ$react.createElement($698c70f6640041fb$export$178405afcd8c5eb, null, /*#__PURE__*/ $P78NQ$react.createElement($698c70f6640041fb$var$OverlayContainerDOM, props)));
+}
+function $698c70f6640041fb$export$b47c3594eab58386(props) {
+    let { portalContainer: portalContainer = document.body , ...rest } = props;
+    $P78NQ$react.useEffect(()=>{
+        if (portalContainer.closest('[data-overlay-container]')) throw new Error('An OverlayContainer must not be inside another container. Please change the portalContainer prop.');
+    }, [
+        portalContainer
+    ]);
+    let contents = /*#__PURE__*/ $P78NQ$react.createElement($698c70f6640041fb$export$bf688221f59024e5, rest);
+    return(/*#__PURE__*/ $P78NQ$reactdom.createPortal(contents, portalContainer));
+}
+function $698c70f6640041fb$export$33ffd74ebf07f060(options) {
+    // Add aria-hidden to all parent providers on mount, and restore on unmount.
+    let context = $P78NQ$useContext($698c70f6640041fb$var$Context);
+    if (!context) throw new Error('Modal is not contained within a provider');
+    $P78NQ$useEffect(()=>{
+        if (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?.isDisabled
+    ]);
+    return {
+        modalProps: {
+            'data-ismodal': !options?.isDisabled
+        }
+    };
+}
 
 
-function $ece0076f06e8a828c60ba0c94f22f89$var$preventScrollMobileSafari() {
-  let scrollable;
-  let lastY = 0;
+var $c675415561d15622$exports = {};
 
-  let onTouchStart = e => {
-    // Store the nearest scrollable parent element from the element that the user touched.
-    scrollable = getScrollParent(e.target);
+$parcel$export($c675415561d15622$exports, "DismissButton", () => $c675415561d15622$export$2317d149ed6f78c4);
+var $02edbce599d2a482$exports = {};
+var $894cbc4537768d91$exports = {};
+$894cbc4537768d91$exports = JSON.parse("{\"dismiss\":\"تجاهل\"}");
 
-    if (scrollable === document.documentElement && scrollable === document.body) {
-      return;
-    }
 
-    lastY = e.changedTouches[0].pageY;
-  };
+var $b3037443d6d04400$exports = {};
+$b3037443d6d04400$exports = JSON.parse("{\"dismiss\":\"Отхвърляне\"}");
 
-  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.
 
+var $a5db12f8f0b58660$exports = {};
+$a5db12f8f0b58660$exports = JSON.parse("{\"dismiss\":\"Odstranit\"}");
 
-    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();
-    }
+var $1a7841b4e06a11e8$exports = {};
+$1a7841b4e06a11e8$exports = JSON.parse("{\"dismiss\":\"Luk\"}");
 
-    lastY = y;
-  };
 
-  let onTouchEnd = e => {
-    let target = e.target;
+var $124fab0eaf782fbc$exports = {};
+$124fab0eaf782fbc$exports = JSON.parse("{\"dismiss\":\"Schließen\"}");
 
-    if (target instanceof HTMLInputElement && !$ece0076f06e8a828c60ba0c94f22f89$var$nonTextInputTypes.has(target.type)) {
-      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 (target instanceof HTMLInputElement && !$ece0076f06e8a828c60ba0c94f22f89$var$nonTextInputTypes.has(target.type)) {
-      // Transform also needs to be applied in the focus event in cases where focus moves
-      // 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 ($ece0076f06e8a828c60ba0c94f22f89$var$visualViewport) {
-          if ($ece0076f06e8a828c60ba0c94f22f89$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(() => {
-              $ece0076f06e8a828c60ba0c94f22f89$var$scrollIntoView(target);
-            });
-          } else {
-            // Otherwise, wait for the visual viewport to resize before scrolling so we can
-            // measure the correct position to scroll to.
-            $ece0076f06e8a828c60ba0c94f22f89$var$visualViewport.addEventListener('resize', () => $ece0076f06e8a828c60ba0c94f22f89$var$scrollIntoView(target), {
-              once: true
-            });
-          }
-        }
-      });
-    }
-  };
+var $19a7653b4d35790b$exports = {};
+$19a7653b4d35790b$exports = JSON.parse("{\"dismiss\":\"Απόρριψη\"}");
 
-  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 = chain($ece0076f06e8a828c60ba0c94f22f89$var$setStyle(document.documentElement, 'paddingRight', window.innerWidth - document.documentElement.clientWidth + "px"), $ece0076f06e8a828c60ba0c94f22f89$var$setStyle(document.documentElement, 'overflow', 'hidden'), $ece0076f06e8a828c60ba0c94f22f89$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 = chain($ece0076f06e8a828c60ba0c94f22f89$var$addEvent(document, 'touchstart', onTouchStart, {
-    passive: false,
-    capture: true
-  }), $ece0076f06e8a828c60ba0c94f22f89$var$addEvent(document, 'touchmove', onTouchMove, {
-    passive: false,
-    capture: true
-  }), $ece0076f06e8a828c60ba0c94f22f89$var$addEvent(document, 'touchend', onTouchEnd, {
-    passive: false,
-    capture: true
-  }), $ece0076f06e8a828c60ba0c94f22f89$var$addEvent(document, 'focus', onFocus, true), $ece0076f06e8a828c60ba0c94f22f89$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 $ece0076f06e8a828c60ba0c94f22f89$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 $ece0076f06e8a828c60ba0c94f22f89$var$addEvent(target, event, handler, options) {
-  target.addEventListener(event, handler, options);
-  return () => {
-    target.removeEventListener(event, handler, options);
-  };
-}
 
-function $ece0076f06e8a828c60ba0c94f22f89$var$scrollIntoView(target) {
-  // Find the parent scrollable element and adjust the scroll position if the target is not already in view.
-  let scrollable = getScrollParent(target);
+var $90d7e59bd6434dae$exports = {};
+$90d7e59bd6434dae$exports = JSON.parse("{\"dismiss\":\"Dismiss\"}");
 
-  if (scrollable !== document.documentElement && scrollable !== document.body) {
-    let scrollableTop = scrollable.getBoundingClientRect().top;
-    let targetTop = target.getBoundingClientRect().top;
 
-    if (targetTop > scrollableTop + target.clientHeight) {
-      scrollable.scrollTop += targetTop - scrollableTop;
-    }
-  }
-}
+var $e95dd61436d5b5c4$exports = {};
+$e95dd61436d5b5c4$exports = JSON.parse("{\"dismiss\":\"Descartar\"}");
 
-const $b876e5ac9c98db373bf726bce3d604e$var$Context = /*#__PURE__*/_react.createContext(null);
-/**
- * Each ModalProvider tracks how many modals are open in its subtree. On mount, the modals
- * trigger `addModal` to increment the count, and trigger `removeModal` on unmount to decrement it.
- * This is done recursively so that all parent providers are incremented and decremented.
- * If the modal count is greater than zero, we add `aria-hidden` to this provider to hide its
- * subtree from screen readers. This is done using React context in order to account for things
- * like portals, which can cause the React tree and the DOM tree to differ significantly in structure.
- */
-
-
-export function ModalProvider(props) {
-  let {
-    children
-  } = props;
-  let parent = useContext($b876e5ac9c98db373bf726bce3d604e$var$Context);
-  let [modalCount, setModalCount] = useState(0);
-  let context = useMemo(() => ({
-    parent,
-    modalCount,
-
-    addModal() {
-      setModalCount(count => count + 1);
-
-      if (parent) {
-        parent.addModal();
-      }
-    },
-
-    removeModal() {
-      setModalCount(count => count - 1);
-
-      if (parent) {
-        parent.removeModal();
-      }
-    }
 
-  }), [parent, modalCount]);
-  return /*#__PURE__*/_react.createElement($b876e5ac9c98db373bf726bce3d604e$var$Context.Provider, {
-    value: context
-  }, children);
-}
+var $9aca3d8aa936d4a2$exports = {};
+$9aca3d8aa936d4a2$exports = JSON.parse("{\"dismiss\":\"Lõpeta\"}");
 
-/**
- * Used to determine if the tree should be aria-hidden based on how many
- * modals are open.
- */
-export function useModalProvider() {
-  let context = useContext($b876e5ac9c98db373bf726bce3d604e$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 $b876e5ac9c98db373bf726bce3d604e$var$OverlayContainerDOM(props) {
-  let {
-    modalProviderProps
-  } = useModalProvider();
-  return /*#__PURE__*/_react.createElement("div", _babelRuntimeHelpersEsmExtends({
-    "data-overlay-container": true
-  }, props, modalProviderProps));
-}
-/**
- * An OverlayProvider acts as a container for the top-level application.
- * Any application that uses modal dialogs or other overlays should
- * be wrapped in a `<OverlayProvider>`. This is used to ensure that
- * the main content of the application is hidden from screen readers
- * if a modal or other overlay is opened. Only the top-most modal or
- * overlay should be accessible at once.
- */
 
+var $bfb31bf6ed15a4f3$exports = {};
+$bfb31bf6ed15a4f3$exports = JSON.parse("{\"dismiss\":\"Hylkää\"}");
 
-export function OverlayProvider(props) {
-  return /*#__PURE__*/_react.createElement(ModalProvider, null, /*#__PURE__*/_react.createElement($b876e5ac9c98db373bf726bce3d604e$var$OverlayContainerDOM, props));
-}
 
-/**
- * A container for overlays like modals and popovers. Renders the overlay
- * into a Portal which is placed at the end of the document body.
- * Also ensures that the overlay is hidden from screen readers if a
- * nested modal is opened. Only the top-most modal or overlay should
- * be accessible at once.
- */
-export function OverlayContainer(props) {
-  let {
-    portalContainer = document.body
-  } = props,
-      rest = _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose(props, ["portalContainer"]);
-
-  _react.useEffect(() => {
-    if (portalContainer.closest('[data-overlay-container]')) {
-      throw new Error('An OverlayContainer must not be inside another container. Please change the portalContainer prop.');
-    }
-  }, [portalContainer]);
+var $10892de272a1fe06$exports = {};
+$10892de272a1fe06$exports = JSON.parse("{\"dismiss\":\"Rejeter\"}");
 
-  let contents = /*#__PURE__*/_react.createElement(OverlayProvider, rest);
 
-  return /*#__PURE__*/_reactDom.createPortal(contents, portalContainer);
-}
+var $251aad704c8cbc16$exports = {};
+$251aad704c8cbc16$exports = JSON.parse("{\"dismiss\":\"התעלם\"}");
 
-/**
- * Hides content outside the current `<OverlayContainer>` from screen readers
- * on mount and restores it on unmount. Typically used by modal dialogs and
- * other types of overlays to ensure that only the top-most modal is
- * accessible at once.
- */
-export function useModal(options) {
-  // Add aria-hidden to all parent providers on mount, and restore on unmount.
-  let context = useContext($b876e5ac9c98db373bf726bce3d604e$var$Context);
-
-  if (!context) {
-    throw new Error('Modal is not contained within a provider');
-  }
-
-  useEffect(() => {
-    if (options != null && 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();
-      }
+
+var $c140b094f285049b$exports = {};
+$c140b094f285049b$exports = JSON.parse("{\"dismiss\":\"Odbaci\"}");
+
+
+var $4bd0dfd4cee040e8$exports = {};
+$4bd0dfd4cee040e8$exports = JSON.parse("{\"dismiss\":\"Elutasítás\"}");
+
+
+var $2a30a145c02426ca$exports = {};
+$2a30a145c02426ca$exports = JSON.parse("{\"dismiss\":\"Ignora\"}");
+
+
+var $0932316666a118a6$exports = {};
+$0932316666a118a6$exports = JSON.parse("{\"dismiss\":\"閉じる\"}");
+
+
+var $c92bdb70c994b117$exports = {};
+$c92bdb70c994b117$exports = JSON.parse("{\"dismiss\":\"무시\"}");
+
+
+var $48bd32e18c2de957$exports = {};
+$48bd32e18c2de957$exports = JSON.parse("{\"dismiss\":\"Atmesti\"}");
+
+
+var $9a989803d24f2269$exports = {};
+$9a989803d24f2269$exports = JSON.parse("{\"dismiss\":\"Nerādīt\"}");
+
+
+var $91107aa294d0e39b$exports = {};
+$91107aa294d0e39b$exports = JSON.parse("{\"dismiss\":\"Lukk\"}");
+
+
+var $ca7a4e64db50d2a5$exports = {};
+$ca7a4e64db50d2a5$exports = JSON.parse("{\"dismiss\":\"Negeren\"}");
+
+
+var $5b67223cfb013804$exports = {};
+$5b67223cfb013804$exports = JSON.parse("{\"dismiss\":\"Zignoruj\"}");
+
+
+var $34b24f6ab11b3a53$exports = {};
+$34b24f6ab11b3a53$exports = JSON.parse("{\"dismiss\":\"Descartar\"}");
+
+
+var $e5da89c3e1b61eb4$exports = {};
+$e5da89c3e1b61eb4$exports = JSON.parse("{\"dismiss\":\"Dispensar\"}");
+
+
+var $54e1bea854d55a99$exports = {};
+$54e1bea854d55a99$exports = JSON.parse("{\"dismiss\":\"Revocare\"}");
+
+
+var $525921cc6bb2c07d$exports = {};
+$525921cc6bb2c07d$exports = JSON.parse("{\"dismiss\":\"Пропустить\"}");
+
+
+var $5844db859c817f4e$exports = {};
+$5844db859c817f4e$exports = JSON.parse("{\"dismiss\":\"Zrušiť\"}");
+
+
+var $cbfffeb7cdbe3dff$exports = {};
+$cbfffeb7cdbe3dff$exports = JSON.parse("{\"dismiss\":\"Opusti\"}");
+
+
+var $2d9ef1a359230bec$exports = {};
+$2d9ef1a359230bec$exports = JSON.parse("{\"dismiss\":\"Odbaci\"}");
+
+
+var $d8ad4c5a678a9175$exports = {};
+$d8ad4c5a678a9175$exports = JSON.parse("{\"dismiss\":\"Avvisa\"}");
+
+
+var $09b94e3fac869f85$exports = {};
+$09b94e3fac869f85$exports = JSON.parse("{\"dismiss\":\"Kapat\"}");
+
+
+var $f1804546d19a547d$exports = {};
+$f1804546d19a547d$exports = JSON.parse("{\"dismiss\":\"Скасувати\"}");
+
+
+var $68e45e9a239e137d$exports = {};
+$68e45e9a239e137d$exports = JSON.parse("{\"dismiss\":\"取消\"}");
+
+
+var $8a8b95d8ded2c350$exports = {};
+$8a8b95d8ded2c350$exports = JSON.parse("{\"dismiss\":\"關閉\"}");
+
+
+$02edbce599d2a482$exports = {
+    "ar-AE": $894cbc4537768d91$exports,
+    "bg-BG": $b3037443d6d04400$exports,
+    "cs-CZ": $a5db12f8f0b58660$exports,
+    "da-DK": $1a7841b4e06a11e8$exports,
+    "de-DE": $124fab0eaf782fbc$exports,
+    "el-GR": $19a7653b4d35790b$exports,
+    "en-US": $90d7e59bd6434dae$exports,
+    "es-ES": $e95dd61436d5b5c4$exports,
+    "et-EE": $9aca3d8aa936d4a2$exports,
+    "fi-FI": $bfb31bf6ed15a4f3$exports,
+    "fr-FR": $10892de272a1fe06$exports,
+    "he-IL": $251aad704c8cbc16$exports,
+    "hr-HR": $c140b094f285049b$exports,
+    "hu-HU": $4bd0dfd4cee040e8$exports,
+    "it-IT": $2a30a145c02426ca$exports,
+    "ja-JP": $0932316666a118a6$exports,
+    "ko-KR": $c92bdb70c994b117$exports,
+    "lt-LT": $48bd32e18c2de957$exports,
+    "lv-LV": $9a989803d24f2269$exports,
+    "nb-NO": $91107aa294d0e39b$exports,
+    "nl-NL": $ca7a4e64db50d2a5$exports,
+    "pl-PL": $5b67223cfb013804$exports,
+    "pt-BR": $34b24f6ab11b3a53$exports,
+    "pt-PT": $e5da89c3e1b61eb4$exports,
+    "ro-RO": $54e1bea854d55a99$exports,
+    "ru-RU": $525921cc6bb2c07d$exports,
+    "sk-SK": $5844db859c817f4e$exports,
+    "sl-SI": $cbfffeb7cdbe3dff$exports,
+    "sr-SP": $2d9ef1a359230bec$exports,
+    "sv-SE": $d8ad4c5a678a9175$exports,
+    "tr-TR": $09b94e3fac869f85$exports,
+    "uk-UA": $f1804546d19a547d$exports,
+    "zh-CN": $68e45e9a239e137d$exports,
+    "zh-TW": $8a8b95d8ded2c350$exports
+};
+
+
+
+
+
+function $c675415561d15622$export$2317d149ed6f78c4(props) {
+    let { onDismiss: onDismiss  } = props;
+    let formatMessage = $P78NQ$useMessageFormatter((/*@__PURE__*/$parcel$interopDefault($02edbce599d2a482$exports)));
+    let onClick = ()=>{
+        if (onDismiss) onDismiss();
     };
-  }, [context, context.parent, options == null ? void 0 : options.isDisabled]);
-  return {
-    modalProps: {
-      'data-ismodal': !(options != null && options.isDisabled)
-    }
-  };
+    return(/*#__PURE__*/ $P78NQ$react.createElement($P78NQ$VisuallyHidden, null, /*#__PURE__*/ $P78NQ$react.createElement("button", {
+        tabIndex: -1,
+        "aria-label": formatMessage('dismiss'),
+        onClick: onClick
+    })));
 }
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/ar-AE.json
-var $e325a364098e05bf51160d06dcffdbe$exports = {};
-$e325a364098e05bf51160d06dcffdbe$exports = JSON.parse("{\"dismiss\":\"تجاهل\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/bg-BG.json
-var $ab088cc547d59c1be83369f8351a064$exports = {};
-$ab088cc547d59c1be83369f8351a064$exports = JSON.parse("{\"dismiss\":\"Отхвърляне\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/cs-CZ.json
-var $cec67ea16ca47059e10ca5e77187d8c2$exports = {};
-$cec67ea16ca47059e10ca5e77187d8c2$exports = JSON.parse("{\"dismiss\":\"Odstranit\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/da-DK.json
-var $d962fe1ed718c5ca37da1414136036f8$exports = {};
-$d962fe1ed718c5ca37da1414136036f8$exports = JSON.parse("{\"dismiss\":\"Luk\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/de-DE.json
-var $c5167dda40dde69038848f007e5$exports = {};
-$c5167dda40dde69038848f007e5$exports = JSON.parse("{\"dismiss\":\"Schließen\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/el-GR.json
-var $ecdd1ac0020e47f58a9ed51b5fb$exports = {};
-$ecdd1ac0020e47f58a9ed51b5fb$exports = JSON.parse("{\"dismiss\":\"Απόρριψη\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/en-US.json
-var $f33e30a89f4dff807f90ebe8c$exports = {};
-$f33e30a89f4dff807f90ebe8c$exports = JSON.parse("{\"dismiss\":\"Dismiss\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/es-ES.json
-var $ba353e2c61dcc5141af4537eeb3ef85c$exports = {};
-$ba353e2c61dcc5141af4537eeb3ef85c$exports = JSON.parse("{\"dismiss\":\"Descartar\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/et-EE.json
-var $dd3e8aaecbf1f2c2c0f9d51aacfd$exports = {};
-$dd3e8aaecbf1f2c2c0f9d51aacfd$exports = JSON.parse("{\"dismiss\":\"Lõpeta\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/fi-FI.json
-var $f730aaed9f4652842b2a8f94a4a$exports = {};
-$f730aaed9f4652842b2a8f94a4a$exports = JSON.parse("{\"dismiss\":\"Hylkää\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/fr-FR.json
-var $e76b22aab4e46b7806205b4af9ca3$exports = {};
-$e76b22aab4e46b7806205b4af9ca3$exports = JSON.parse("{\"dismiss\":\"Rejeter\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/he-IL.json
-var $c33ffdd5a9931bfc82c1c9b55e98de2f$exports = {};
-$c33ffdd5a9931bfc82c1c9b55e98de2f$exports = JSON.parse("{\"dismiss\":\"התעלם\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/hr-HR.json
-var $d64cb70d4ce170f599f4df5adf4e9898$exports = {};
-$d64cb70d4ce170f599f4df5adf4e9898$exports = JSON.parse("{\"dismiss\":\"Odbaci\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/hu-HU.json
-var $c05270a6513a8b6d8a6552a35a162$exports = {};
-$c05270a6513a8b6d8a6552a35a162$exports = JSON.parse("{\"dismiss\":\"Elutasítás\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/it-IT.json
-var $df915df637af1f3c14c8376c69dfd$exports = {};
-$df915df637af1f3c14c8376c69dfd$exports = JSON.parse("{\"dismiss\":\"Ignora\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/ja-JP.json
-var $e8bf1e6480d2c65d558c3537ec0d59ce$exports = {};
-$e8bf1e6480d2c65d558c3537ec0d59ce$exports = JSON.parse("{\"dismiss\":\"閉じる\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/ko-KR.json
-var $e06e93e1c9472a7e2fc5b26a87ea7$exports = {};
-$e06e93e1c9472a7e2fc5b26a87ea7$exports = JSON.parse("{\"dismiss\":\"무시\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/lt-LT.json
-var $fef82498418eab30c69349263b64e050$exports = {};
-$fef82498418eab30c69349263b64e050$exports = JSON.parse("{\"dismiss\":\"Atmesti\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/lv-LV.json
-var $c4df2502cb7b65c6578bcb8a165f6fc$exports = {};
-$c4df2502cb7b65c6578bcb8a165f6fc$exports = JSON.parse("{\"dismiss\":\"Nerādīt\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/nb-NO.json
-var $b50f4e499c19f4d55113139bba$exports = {};
-$b50f4e499c19f4d55113139bba$exports = JSON.parse("{\"dismiss\":\"Lukk\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/nl-NL.json
-var $e45d2f0079f29e4f5c6469cca7c$exports = {};
-$e45d2f0079f29e4f5c6469cca7c$exports = JSON.parse("{\"dismiss\":\"Negeren\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/pl-PL.json
-var $fcb5bfa87b2378a249bd7fb591ec22c2$exports = {};
-$fcb5bfa87b2378a249bd7fb591ec22c2$exports = JSON.parse("{\"dismiss\":\"Zignoruj\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/pt-BR.json
-var $edae5c6f18c937cf0015f2aa266d9fea$exports = {};
-$edae5c6f18c937cf0015f2aa266d9fea$exports = JSON.parse("{\"dismiss\":\"Descartar\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/pt-PT.json
-var $c016edcd88f37a017208da7518133d$exports = {};
-$c016edcd88f37a017208da7518133d$exports = JSON.parse("{\"dismiss\":\"Dispensar\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/ro-RO.json
-var $df1162b231d383d942e0fdb2bbf$exports = {};
-$df1162b231d383d942e0fdb2bbf$exports = JSON.parse("{\"dismiss\":\"Revocare\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/ru-RU.json
-var $fa17537bfd201c57fa41fd31dbd9f074$exports = {};
-$fa17537bfd201c57fa41fd31dbd9f074$exports = JSON.parse("{\"dismiss\":\"Пропустить\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/sk-SK.json
-var $c30db5bcff54a9e266ee7379a6cb8$exports = {};
-$c30db5bcff54a9e266ee7379a6cb8$exports = JSON.parse("{\"dismiss\":\"Zrušiť\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/sl-SI.json
-var $c86d8cad7c0045ad51a1fea185411a61$exports = {};
-$c86d8cad7c0045ad51a1fea185411a61$exports = JSON.parse("{\"dismiss\":\"Opusti\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/sr-SP.json
-var $c610b0b50ebc0061e6c42c420a2e1be$exports = {};
-$c610b0b50ebc0061e6c42c420a2e1be$exports = JSON.parse("{\"dismiss\":\"Odbaci\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/sv-SE.json
-var $c298c5c92c55ce8d8289d8cc18ea512$exports = {};
-$c298c5c92c55ce8d8289d8cc18ea512$exports = JSON.parse("{\"dismiss\":\"Avvisa\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/tr-TR.json
-var $f438196d9674b9d180ea6e74d7$exports = {};
-$f438196d9674b9d180ea6e74d7$exports = JSON.parse("{\"dismiss\":\"Kapat\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/uk-UA.json
-var $fa842ebaf07187d5bc74e0fa6c4679b$exports = {};
-$fa842ebaf07187d5bc74e0fa6c4679b$exports = JSON.parse("{\"dismiss\":\"Скасувати\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/zh-CN.json
-var $cdcbe39f22ae1814551e7f30dcfc8$exports = {};
-$cdcbe39f22ae1814551e7f30dcfc8$exports = JSON.parse("{\"dismiss\":\"取消\"}");
-// ASSET: /Users/govett/dev/react-spectrum-v3/packages/@react-aria/overlays/intl/zh-TW.json
-var $a8c729d90cde82a4eb34bebfb46a6$exports = {};
-$a8c729d90cde82a4eb34bebfb46a6$exports = JSON.parse("{\"dismiss\":\"關閉\"}");
 
+
+var $bf241ecdd7b50fca$exports = {};
+
+$parcel$export($bf241ecdd7b50fca$exports, "ariaHideOutside", () => $bf241ecdd7b50fca$export$1c3ebcada18427bf);
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -1054,176 +956,75 @@ $a8c729d90cde82a4eb34bebfb46a6$exports = JSON.parse("{\"dismiss\":\"關閉\"}");
  * 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 $c94f95b3263b356bb2e58a3832a84$var$intlMessages = {
-  "ar-AE": _babelRuntimeHelpersEsmInteropRequireDefault($e325a364098e05bf51160d06dcffdbe$exports).default,
-  "bg-BG": _babelRuntimeHelpersEsmInteropRequireDefault($ab088cc547d59c1be83369f8351a064$exports).default,
-  "cs-CZ": _babelRuntimeHelpersEsmInteropRequireDefault($cec67ea16ca47059e10ca5e77187d8c2$exports).default,
-  "da-DK": _babelRuntimeHelpersEsmInteropRequireDefault($d962fe1ed718c5ca37da1414136036f8$exports).default,
-  "de-DE": _babelRuntimeHelpersEsmInteropRequireDefault($c5167dda40dde69038848f007e5$exports).default,
-  "el-GR": _babelRuntimeHelpersEsmInteropRequireDefault($ecdd1ac0020e47f58a9ed51b5fb$exports).default,
-  "en-US": _babelRuntimeHelpersEsmInteropRequireDefault($f33e30a89f4dff807f90ebe8c$exports).default,
-  "es-ES": _babelRuntimeHelpersEsmInteropRequireDefault($ba353e2c61dcc5141af4537eeb3ef85c$exports).default,
-  "et-EE": _babelRuntimeHelpersEsmInteropRequireDefault($dd3e8aaecbf1f2c2c0f9d51aacfd$exports).default,
-  "fi-FI": _babelRuntimeHelpersEsmInteropRequireDefault($f730aaed9f4652842b2a8f94a4a$exports).default,
-  "fr-FR": _babelRuntimeHelpersEsmInteropRequireDefault($e76b22aab4e46b7806205b4af9ca3$exports).default,
-  "he-IL": _babelRuntimeHelpersEsmInteropRequireDefault($c33ffdd5a9931bfc82c1c9b55e98de2f$exports).default,
-  "hr-HR": _babelRuntimeHelpersEsmInteropRequireDefault($d64cb70d4ce170f599f4df5adf4e9898$exports).default,
-  "hu-HU": _babelRuntimeHelpersEsmInteropRequireDefault($c05270a6513a8b6d8a6552a35a162$exports).default,
-  "it-IT": _babelRuntimeHelpersEsmInteropRequireDefault($df915df637af1f3c14c8376c69dfd$exports).default,
-  "ja-JP": _babelRuntimeHelpersEsmInteropRequireDefault($e8bf1e6480d2c65d558c3537ec0d59ce$exports).default,
-  "ko-KR": _babelRuntimeHelpersEsmInteropRequireDefault($e06e93e1c9472a7e2fc5b26a87ea7$exports).default,
-  "lt-LT": _babelRuntimeHelpersEsmInteropRequireDefault($fef82498418eab30c69349263b64e050$exports).default,
-  "lv-LV": _babelRuntimeHelpersEsmInteropRequireDefault($c4df2502cb7b65c6578bcb8a165f6fc$exports).default,
-  "nb-NO": _babelRuntimeHelpersEsmInteropRequireDefault($b50f4e499c19f4d55113139bba$exports).default,
-  "nl-NL": _babelRuntimeHelpersEsmInteropRequireDefault($e45d2f0079f29e4f5c6469cca7c$exports).default,
-  "pl-PL": _babelRuntimeHelpersEsmInteropRequireDefault($fcb5bfa87b2378a249bd7fb591ec22c2$exports).default,
-  "pt-BR": _babelRuntimeHelpersEsmInteropRequireDefault($edae5c6f18c937cf0015f2aa266d9fea$exports).default,
-  "pt-PT": _babelRuntimeHelpersEsmInteropRequireDefault($c016edcd88f37a017208da7518133d$exports).default,
-  "ro-RO": _babelRuntimeHelpersEsmInteropRequireDefault($df1162b231d383d942e0fdb2bbf$exports).default,
-  "ru-RU": _babelRuntimeHelpersEsmInteropRequireDefault($fa17537bfd201c57fa41fd31dbd9f074$exports).default,
-  "sk-SK": _babelRuntimeHelpersEsmInteropRequireDefault($c30db5bcff54a9e266ee7379a6cb8$exports).default,
-  "sl-SI": _babelRuntimeHelpersEsmInteropRequireDefault($c86d8cad7c0045ad51a1fea185411a61$exports).default,
-  "sr-SP": _babelRuntimeHelpersEsmInteropRequireDefault($c610b0b50ebc0061e6c42c420a2e1be$exports).default,
-  "sv-SE": _babelRuntimeHelpersEsmInteropRequireDefault($c298c5c92c55ce8d8289d8cc18ea512$exports).default,
-  "tr-TR": _babelRuntimeHelpersEsmInteropRequireDefault($f438196d9674b9d180ea6e74d7$exports).default,
-  "uk-UA": _babelRuntimeHelpersEsmInteropRequireDefault($fa842ebaf07187d5bc74e0fa6c4679b$exports).default,
-  "zh-CN": _babelRuntimeHelpersEsmInteropRequireDefault($cdcbe39f22ae1814551e7f30dcfc8$exports).default,
-  "zh-TW": _babelRuntimeHelpersEsmInteropRequireDefault($a8c729d90cde82a4eb34bebfb46a6$exports).default
-};
-
-/**
- * A visually hidden button that can be used to allow screen reader
- * users to dismiss a modal or popup when there is no visual
- * affordance to do so.
- */
-export function DismissButton(props) {
-  let {
-    onDismiss
-  } = props;
-  let formatMessage = useMessageFormatter($c94f95b3263b356bb2e58a3832a84$var$intlMessages);
-
-  let onClick = () => {
-    if (onDismiss) {
-      onDismiss();
-    }
-  };
-
-  return /*#__PURE__*/_react.createElement(VisuallyHidden, null, /*#__PURE__*/_react.createElement("button", {
-    tabIndex: -1,
-    "aria-label": formatMessage('dismiss'),
-    onClick: onClick
-  }));
-}
+ */ // 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 $d006cf2ec48f5151923b9435b3d$var$refCountMap = new WeakMap();
-/**
- * Hides all elements in the DOM outside the given targets from screen readers using aria-hidden,
- * and returns a function to revert these changes. In addition, changes to the DOM are watched
- * and new elements outside the targets are automatically hidden.
- * @param targets - The elements that should remain visible.
- * @param root - Nothing will be hidden above this element.
- * @returns - A function to restore all hidden elements.
- */
-
-export function ariaHideOutside(targets, root) {
-  if (root === void 0) {
-    root = document.body;
-  }
-
-  let visibleNodes = new Set(targets);
-  let hiddenNodes = new Set();
-  let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
-    acceptNode(node) {
-      // If this node is a live announcer, add it to the set of nodes to keep visible.
-      if (node instanceof HTMLElement && node.dataset.liveAnnouncer === 'true') {
-        visibleNodes.add(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.
-
-
-      if (visibleNodes.has(node) || hiddenNodes.has(node.parentElement)) {
-        return NodeFilter.FILTER_REJECT;
-      } // VoiceOver on iOS has issues hiding elements with role="row". Hide the cells inside instead.
-      // https://bugs.webkit.org/show_bug.cgi?id=222623
-
-
-      if (node instanceof HTMLElement && node.getAttribute('role') === 'row') {
-        return NodeFilter.FILTER_SKIP;
-      } // Skip this node but continue to children if one of the targets is inside the node.
-
-
-      if (targets.some(target => node.contains(target))) {
-        return NodeFilter.FILTER_SKIP;
-      }
-
-      return NodeFilter.FILTER_ACCEPT;
-    }
-
-  });
-
-  let hide = node => {
-    var _refCountMap$get;
-
-    let refCount = (_refCountMap$get = $d006cf2ec48f5151923b9435b3d$var$refCountMap.get(node)) != null ? _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');
+let $bf241ecdd7b50fca$var$refCountMap = new WeakMap();
+function $bf241ecdd7b50fca$export$1c3ebcada18427bf(targets, root = document.body) {
+    let visibleNodes = new Set(targets);
+    let hiddenNodes = new Set();
+    let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+        acceptNode (node) {
+            // If this node is a live announcer, add it to the set of nodes to keep visible.
+            if (node instanceof HTMLElement && node.dataset.liveAnnouncer === 'true') visibleNodes.add(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.
+            if (visibleNodes.has(node) || hiddenNodes.has(node.parentElement)) return NodeFilter.FILTER_REJECT;
+            // VoiceOver on iOS has issues hiding elements with role="row". Hide the cells inside instead.
+            // https://bugs.webkit.org/show_bug.cgi?id=222623
+            if (node instanceof HTMLElement && node.getAttribute('role') === 'row') return NodeFilter.FILTER_SKIP;
+            // Skip this node but continue to children if one of the targets is inside the node.
+            if (targets.some((target)=>node.contains(target)
+            )) return NodeFilter.FILTER_SKIP;
+            return NodeFilter.FILTER_ACCEPT;
+        }
+    });
+    let hide = (node)=>{
+        let refCount = $bf241ecdd7b50fca$var$refCountMap.get(node) ?? 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);
+        $bf241ecdd7b50fca$var$refCountMap.set(node, refCount + 1);
+    };
+    let node1 = walker.nextNode();
+    while(node1 != null){
+        hide(node1);
+        node1 = walker.nextNode();
     }
+    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 node2 of change.addedNodes){
+                if (node2 instanceof HTMLElement && node2.dataset.liveAnnouncer === 'true') visibleNodes.add(node2);
+                else if (node2 instanceof Element) hide(node2);
+            }
+        }
+    });
+    observer.observe(root, {
+        childList: true,
+        subtree: true
+    });
+    return ()=>{
+        observer.disconnect();
+        for (let node of hiddenNodes){
+            let count = $bf241ecdd7b50fca$var$refCountMap.get(node);
+            if (count === 1) {
+                node.removeAttribute('aria-hidden');
+                $bf241ecdd7b50fca$var$refCountMap.delete(node);
+            } else $bf241ecdd7b50fca$var$refCountMap.set(node, count - 1);
+        }
+    };
+}
 
-    hiddenNodes.add(node);
-    $d006cf2ec48f5151923b9435b3d$var$refCountMap.set(node, refCount + 1);
-  };
-
-  let node = walker.nextNode();
-
-  while (node != null) {
-    hide(node);
-    node = walker.nextNode();
-  }
 
-  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.addedNodes) {
-          if (node instanceof HTMLElement && node.dataset.liveAnnouncer === 'true') {
-            visibleNodes.add(node);
-          } else if (node instanceof Element) {
-            hide(node);
-          }
-        }
-      }
-    }
-  });
-  observer.observe(root, {
-    childList: true,
-    subtree: true
-  });
-  return () => {
-    observer.disconnect();
-
-    for (let node of hiddenNodes) {
-      let count = $d006cf2ec48f5151923b9435b3d$var$refCountMap.get(node);
-
-      if (count === 1) {
-        node.removeAttribute('aria-hidden');
-        $d006cf2ec48f5151923b9435b3d$var$refCountMap.delete(node);
-      } else {
-        $d006cf2ec48f5151923b9435b3d$var$refCountMap.set(node, count - 1);
-      }
-    }
-  };
-}
+export {$257fdf58e89203e8$export$d39e1813b3bdd0e1 as useOverlayPosition, $3e0c6adf4453f3f2$export$ea8f71083e90600f as useOverlay, $090c2b640a9525fd$export$f9d5c8beee7d008d as useOverlayTrigger, $48168a03440bff21$export$ee0f7cc6afcd1c18 as usePreventScroll, $698c70f6640041fb$export$178405afcd8c5eb as ModalProvider, $698c70f6640041fb$export$d9aaed4c3ece1bc0 as useModalProvider, $698c70f6640041fb$export$bf688221f59024e5 as OverlayProvider, $698c70f6640041fb$export$b47c3594eab58386 as OverlayContainer, $698c70f6640041fb$export$33ffd74ebf07f060 as useModal, $c675415561d15622$export$2317d149ed6f78c4 as DismissButton, $bf241ecdd7b50fca$export$1c3ebcada18427bf as ariaHideOutside};
 //# sourceMappingURL=module.js.map