@trackunit/react-components 0.1.157 → 0.1.159

package/index.cjs.js

@@ -1888,7 +1888,7 @@ function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "func
  * //=> Sun Jul 02 1995 00:00:00
  */
 
-function max$2(dirtyDatesArray) {
+function max$1(dirtyDatesArray) {
   requiredArgs(1, arguments);
   var datesArray; // `dirtyDatesArray` is Array, Set or Map, or object with custom `forEach` method
 
@@ -1936,7 +1936,7 @@ function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "func
  * //=> Wed Feb 11 1987 00:00:00
  */
 
-function min$2(dirtyDatesArray) {
+function min$1(dirtyDatesArray) {
   requiredArgs(1, arguments);
   var datesArray; // `dirtyDatesArray` is Array, Set or Map, or object with custom `forEach` method
 
@@ -13948,10 +13948,10 @@ function getNextFocus(focusedDay, options) {
     };
     var newFocusedDay = moveFns[moveBy](focusedDay, direction === 'after' ? 1 : -1);
     if (direction === 'before' && fromDate) {
-        newFocusedDay = max$2([fromDate, newFocusedDay]);
+        newFocusedDay = max$1([fromDate, newFocusedDay]);
     }
     else if (direction === 'after' && toDate) {
-        newFocusedDay = min$2([toDate, newFocusedDay]);
+        newFocusedDay = min$1([toDate, newFocusedDay]);
     }
     var isFocusable = true;
     if (modifiers) {
@@ -14813,20 +14813,372 @@ const DayPicker = ({ onDaySelect, disabledDays, selectedDays, language, classNam
     return (jsxRuntime.jsx(DayPicker$1, { onDayClick: onDaySelect, selected: selectedDays, locale: locale, disabled: disabledDays, className: `custom-day-picker ${className !== null && className !== void 0 ? className : ""}`, max: max, footer: jsxRuntime.jsx("div", { "data-testid": dataTestId }) }));
 };
 
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+const oppositeAlignmentMap = {
+  start: 'end',
+  end: 'start'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
 function getAlignment(placement) {
   return placement.split('-')[1];
 }
-
-function getLengthFromAxis(axis) {
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
   return axis === 'y' ? 'height' : 'width';
 }
+function getSideAxis(placement) {
+  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(side => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  return {
+    ...rect,
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
+  };
+}
 
-function getSide(placement) {
-  return placement.split('-')[0];
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  // Browsers without `ShadowRoot` support.
+  if (typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isContainingBlock(element) {
+  const webkit = isWebKit();
+  const css = getComputedStyle$1(element);
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else {
+      currentNode = getParentNode(currentNode);
+    }
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
+}
+function isLastTraversableNode(node) {
+  return ['html', 'body', '#document'].includes(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.pageXOffset,
+    scrollTop: element.pageYOffset
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor));
+}
+
+function activeElement(doc) {
+  let activeElement = doc.activeElement;
+  while (((_activeElement = activeElement) == null ? void 0 : (_activeElement$shadow = _activeElement.shadowRoot) == null ? void 0 : _activeElement$shadow.activeElement) != null) {
+    var _activeElement, _activeElement$shadow;
+    activeElement = activeElement.shadowRoot.activeElement;
+  }
+  return activeElement;
+}
+function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  const rootNode = child.getRootNode && child.getRootNode();
+
+  // First, attempt with faster native method
+  if (parent.contains(child)) {
+    return true;
+  }
+
+  // then fallback to custom implementation with Shadow DOM support
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      // @ts-ignore
+      next = next.parentNode || next.host;
+    }
+  }
+
+  // Give up, the result is false
+  return false;
+}
+// Avoid Chrome DevTools blue warning.
+function getPlatform() {
+  const uaData = navigator.userAgentData;
+  if (uaData != null && uaData.platform) {
+    return uaData.platform;
+  }
+  return navigator.platform;
+}
+function getUserAgent() {
+  const uaData = navigator.userAgentData;
+  if (uaData && Array.isArray(uaData.brands)) {
+    return uaData.brands.map(_ref => {
+      let {
+        brand,
+        version
+      } = _ref;
+      return brand + "/" + version;
+    }).join(' ');
+  }
+  return navigator.userAgent;
+}
+
+// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts
+function isVirtualClick(event) {
+  if (event.mozInputSource === 0 && event.isTrusted) {
+    return true;
+  }
+  const androidRe = /Android/i;
+  if ((androidRe.test(getPlatform()) || androidRe.test(getUserAgent())) && event.pointerType) {
+    return event.type === 'click' && event.buttons === 1;
+  }
+  return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+  return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType !== 'mouse' ||
+  // iOS VoiceOver returns 0.333• for width/height.
+  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0;
+}
+function isSafari() {
+  // Chrome DevTools does not complain about navigator.vendor
+  return /apple/i.test(navigator.vendor);
+}
+function isMouseLikePointerType(pointerType, strict) {
+  // On some Linux machines with Chromium, mouse inputs return a `pointerType`
+  // of "pen": https://github.com/floating-ui/floating-ui/issues/2015
+  const values = ['mouse', 'pen'];
+  if (!strict) {
+    values.push('', undefined);
+  }
+  return values.includes(pointerType);
+}
+function isReactEvent(event) {
+  return 'nativeEvent' in event;
 }
+function isRootElement(element) {
+  return element.matches('html,body');
+}
+function getDocument(node) {
+  return (node == null ? void 0 : node.ownerDocument) || document;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null) {
+    return false;
+  }
+  if ('composedPath' in event) {
+    return event.composedPath().includes(node);
+  }
 
-function getMainAxisFromPlacement(placement) {
-  return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y';
+  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't
+  const e = event;
+  return e.target != null && node.contains(e.target);
+}
+function getTarget(event) {
+  if ('composedPath' in event) {
+    return event.composedPath()[0];
+  }
+
+  // TS thinks `event` is of type never as it assumes all browsers support
+  // `composedPath()`, but browsers without shadow DOM don't.
+  return event.target;
+}
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled])," + "[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function isTypeableElement(element) {
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function stopEvent(event) {
+  event.preventDefault();
+  event.stopPropagation();
 }
 
 function computeCoordsFromPlacement(_ref, placement, rtl) {
@@ -14834,13 +15186,14 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
     reference,
     floating
   } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === 'y';
   const commonX = reference.x + reference.width / 2 - floating.width / 2;
   const commonY = reference.y + reference.height / 2 - floating.height / 2;
-  const mainAxis = getMainAxisFromPlacement(placement);
-  const length = getLengthFromAxis(mainAxis);
-  const commonAlign = reference[length] / 2 - floating[length] / 2;
-  const side = getSide(placement);
-  const isVertical = mainAxis === 'x';
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
   let coords;
   switch (side) {
     case 'top':
@@ -14875,10 +15228,10 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
   }
   switch (getAlignment(placement)) {
     case 'start':
-      coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
     case 'end':
-      coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
       break;
   }
   return coords;
@@ -14900,22 +15253,6 @@ const computePosition$1 = async (reference, floating, config) => {
   } = config;
   const validMiddleware = middleware.filter(Boolean);
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
-  if (process.env.NODE_ENV !== "production") {
-    if (platform == null) {
-      console.error(['Floating UI: `platform` property was not passed to config. If you', 'want to use Floating UI on the web, install @floating-ui/dom', 'instead of the /core package. Otherwise, you can create your own', '`platform`: https://floating-ui.com/docs/platform'].join(' '));
-    }
-    if (validMiddleware.filter(_ref => {
-      let {
-        name
-      } = _ref;
-      return name === 'autoPlacement' || name === 'flip';
-    }).length > 1) {
-      throw new Error(['Floating UI: duplicate `flip` and/or `autoPlacement` middleware', 'detected. This will lead to an infinite loop. Ensure only one of', 'either has been passed to the `middleware` array.'].join(' '));
-    }
-    if (!reference || !floating) {
-      console.error(['Floating UI: The reference and/or floating element was not defined', 'when `computePosition()` was called. Ensure that both elements have', 'been created and can be measured.'].join(' '));
-    }
-  }
   let rects = await platform.getElementRects({
     reference,
     floating,
@@ -14961,11 +15298,6 @@ const computePosition$1 = async (reference, floating, config) => {
         ...data
       }
     };
-    if (process.env.NODE_ENV !== "production") {
-      if (resetCount > 50) {
-        console.warn(['Floating UI: The middleware lifecycle appears to be running in an', 'infinite loop. This is usually caused by a `reset` continually', 'being returned without a break condition.'].join(' '));
-      }
-    }
     if (reset && resetCount <= 50) {
       resetCount++;
       if (typeof reset === 'object') {
@@ -14997,35 +15329,6 @@ const computePosition$1 = async (reference, floating, config) => {
   };
 };
 
-function expandPaddingObject(padding) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
-  };
-}
-
-function getSideObjectFromPadding(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-
-function rectToClientRect(rect) {
-  return {
-    ...rect,
-    top: rect.y,
-    left: rect.x,
-    right: rect.x + rect.width,
-    bottom: rect.y + rect.height
-  };
-}
-
 /**
  * Resolves with an object of overflow side offsets that determine how much the
  * element is overflowing a given clipping boundary on each side.
@@ -15053,8 +15356,8 @@ async function detectOverflow(state, options) {
     elementContext = 'floating',
     altBoundary = false,
     padding = 0
-  } = options;
-  const paddingObject = getSideObjectFromPadding(padding);
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
   const altContext = elementContext === 'floating' ? 'reference' : 'floating';
   const element = elements[altBoundary ? altContext : elementContext];
   const clippingClientRect = rectToClientRect(await platform.getClippingRect({
@@ -15081,7 +15384,6 @@ async function detectOverflow(state, options) {
     offsetParent,
     strategy
   }) : rect);
-  if (process.env.NODE_ENV !== "production") ;
   return {
     top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
     bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
@@ -15090,82 +15392,6 @@ async function detectOverflow(state, options) {
   };
 }
 
-const min$1 = Math.min;
-const max$1 = Math.max;
-
-function within(min$1$1, value, max$1$1) {
-  return max$1(min$1$1, min$1(value, max$1$1));
-}
-
-const oppositeSideMap = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
-}
-
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const mainAxis = getMainAxisFromPlacement(placement);
-  const length = getLengthFromAxis(mainAxis);
-  let mainAlignmentSide = mainAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return {
-    main: mainAlignmentSide,
-    cross: getOppositePlacement(mainAlignmentSide)
-  };
-}
-
-const oppositeAlignmentMap = {
-  start: 'end',
-  end: 'start'
-};
-function getOppositeAlignmentPlacement(placement) {
-  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
-}
-
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-
-function getSideList(side, isStart, rtl) {
-  const lr = ['left', 'right'];
-  const rl = ['right', 'left'];
-  const tb = ['top', 'bottom'];
-  const bt = ['bottom', 'top'];
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rl : lr;
-      return isStart ? lr : rl;
-    case 'left':
-    case 'right':
-      return isStart ? tb : bt;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-
 /**
  * Optimizes the visibility of the floating element by flipping the `placement`
  * in order to keep it in view when the preferred placement(s) will overflow the
@@ -15197,7 +15423,7 @@ const flip = function (options) {
         fallbackAxisSideDirection = 'none',
         flipAlignment = true,
         ...detectOverflowOptions
-      } = options;
+      } = evaluate(options, state);
       const side = getSide(placement);
       const isBasePlacement = getSide(initialPlacement) === initialPlacement;
       const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
@@ -15213,11 +15439,8 @@ const flip = function (options) {
         overflows.push(overflow[side]);
       }
       if (checkCrossAxis) {
-        const {
-          main,
-          cross
-        } = getAlignmentSides(placement, rects, rtl);
-        overflows.push(overflow[main], overflow[cross]);
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
       }
       overflowsData = [...overflowsData, {
         placement,
@@ -15276,7 +15499,9 @@ const flip = function (options) {
   };
 };
 
-async function convertValueToCoords(state, value) {
+// For type backwards-compatibility, the `OffsetOptions` type was also
+// Derivable.
+async function convertValueToCoords(state, options) {
   const {
     placement,
     platform,
@@ -15285,10 +15510,10 @@ async function convertValueToCoords(state, value) {
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
   const side = getSide(placement);
   const alignment = getAlignment(placement);
-  const isVertical = getMainAxisFromPlacement(placement) === 'x';
+  const isVertical = getSideAxis(placement) === 'y';
   const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = typeof value === 'function' ? value(state) : value;
+  const rawValue = evaluate(options, state);
 
   // eslint-disable-next-line prefer-const
   let {
@@ -15324,19 +15549,19 @@ async function convertValueToCoords(state, value) {
  * object may be passed.
  * @see https://floating-ui.com/docs/offset
  */
-const offset = function (value) {
-  if (value === void 0) {
-    value = 0;
+const offset = function (options) {
+  if (options === void 0) {
+    options = 0;
   }
   return {
     name: 'offset',
-    options: value,
+    options,
     async fn(state) {
       const {
         x,
         y
       } = state;
-      const diffCoords = await convertValueToCoords(state, value);
+      const diffCoords = await convertValueToCoords(state, options);
       return {
         x: x + diffCoords.x,
         y: y + diffCoords.y,
@@ -15346,10 +15571,6 @@ const offset = function (value) {
   };
 };
 
-function getCrossAxis(axis) {
-  return axis === 'x' ? 'y' : 'x';
-}
-
 /**
  * Optimizes the visibility of the floating element by shifting it in order to
  * keep it in view when it will overflow the clipping boundary.
@@ -15384,14 +15605,14 @@ const shift = function (options) {
           }
         },
         ...detectOverflowOptions
-      } = options;
+      } = evaluate(options, state);
       const coords = {
         x,
         y
       };
       const overflow = await detectOverflow(state, detectOverflowOptions);
-      const mainAxis = getMainAxisFromPlacement(getSide(placement));
-      const crossAxis = getCrossAxis(mainAxis);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
       if (checkMainAxis) {
@@ -15399,14 +15620,14 @@ const shift = function (options) {
         const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
         const min = mainAxisCoord + overflow[minSide];
         const max = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = within(min, mainAxisCoord, max);
+        mainAxisCoord = clamp(min, mainAxisCoord, max);
       }
       if (checkCrossAxis) {
         const minSide = crossAxis === 'y' ? 'top' : 'left';
         const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
         const min = crossAxisCoord + overflow[minSide];
         const max = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = within(min, crossAxisCoord, max);
+        crossAxisCoord = clamp(min, crossAxisCoord, max);
       }
       const limitedCoords = limiter.fn({
         ...state,
@@ -15447,12 +15668,11 @@ const size = function (options) {
       const {
         apply = () => {},
         ...detectOverflowOptions
-      } = options;
+      } = evaluate(options, state);
       const overflow = await detectOverflow(state, detectOverflowOptions);
       const side = getSide(placement);
       const alignment = getAlignment(placement);
-      const axis = getMainAxisFromPlacement(placement);
-      const isXAxis = axis === 'x';
+      const isYAxis = getSideAxis(placement) === 'y';
       const {
         width,
         height
@@ -15468,26 +15688,25 @@ const size = function (options) {
       }
       const overflowAvailableHeight = height - overflow[heightSide];
       const overflowAvailableWidth = width - overflow[widthSide];
+      const noShift = !state.middlewareData.shift;
       let availableHeight = overflowAvailableHeight;
       let availableWidth = overflowAvailableWidth;
-      if (isXAxis) {
-        availableWidth = min$1(
-        // Maximum clipping viewport width
-        width - overflow.right - overflow.left, overflowAvailableWidth);
+      if (isYAxis) {
+        const maximumClippingWidth = width - overflow.left - overflow.right;
+        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
       } else {
-        availableHeight = min$1(
-        // Maximum clipping viewport height
-        height - overflow.bottom - overflow.top, overflowAvailableHeight);
-      }
-      if (!state.middlewareData.shift && !alignment) {
-        const xMin = max$1(overflow.left, 0);
-        const xMax = max$1(overflow.right, 0);
-        const yMin = max$1(overflow.top, 0);
-        const yMax = max$1(overflow.bottom, 0);
-        if (isXAxis) {
-          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$1(overflow.left, overflow.right));
+        const maximumClippingHeight = height - overflow.top - overflow.bottom;
+        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
+      }
+      if (noShift && !alignment) {
+        const xMin = max(overflow.left, 0);
+        const xMax = max(overflow.right, 0);
+        const yMin = max(overflow.top, 0);
+        const yMax = max(overflow.bottom, 0);
+        if (isYAxis) {
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
         } else {
-          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$1(overflow.top, overflow.bottom));
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
         }
       }
       await apply({
@@ -15508,106 +15727,13 @@ const size = function (options) {
   };
 };
 
-function getWindow$1(node) {
-  var _node$ownerDocument;
-  return ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-
-function getComputedStyle$1(element) {
-  return getWindow$1(element).getComputedStyle(element);
-}
-
-function isNode(value) {
-  return value instanceof getWindow$1(value).Node;
-}
-function getNodeName(node) {
-  return isNode(node) ? (node.nodeName || '').toLowerCase() : '';
-}
-
-let uaString;
-function getUAString() {
-  if (uaString) {
-    return uaString;
-  }
-  const uaData = navigator.userAgentData;
-  if (uaData && Array.isArray(uaData.brands)) {
-    uaString = uaData.brands.map(item => item.brand + "/" + item.version).join(' ');
-    return uaString;
-  }
-  return navigator.userAgent;
-}
-
-function isHTMLElement$1(value) {
-  return value instanceof getWindow$1(value).HTMLElement;
-}
-function isElement$1(value) {
-  return value instanceof getWindow$1(value).Element;
-}
-function isShadowRoot$1(node) {
-  // Browsers without `ShadowRoot` support.
-  if (typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  const OwnElement = getWindow$1(node).ShadowRoot;
-  return node instanceof OwnElement || node instanceof ShadowRoot;
-}
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
-}
-function isTableElement(element) {
-  return ['table', 'td', 'th'].includes(getNodeName(element));
-}
-function isContainingBlock(element) {
-  // TODO: Try to use feature detection here instead.
-  const isFirefox = /firefox/i.test(getUAString());
-  const css = getComputedStyle$1(element);
-  const backdropFilter = css.backdropFilter || css.WebkitBackdropFilter;
-
-  // This is non-exhaustive but covers the most common CSS properties that
-  // create a containing block.
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  return css.transform !== 'none' || css.perspective !== 'none' || (backdropFilter ? backdropFilter !== 'none' : false) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective'].some(value => css.willChange.includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => {
-    // Add type check for old browsers.
-    const contain = css.contain;
-    return contain != null ? contain.includes(value) : false;
-  });
-}
-
-/**
- * Determines whether or not `.getBoundingClientRect()` is affected by visual
- * viewport offsets. In Safari, the `x`/`y` offsets are values relative to the
- * visual viewport, while in other engines, they are values relative to the
- * layout viewport.
- */
-function isClientRectVisualViewportBased() {
-  // TODO: Try to use feature detection here instead. Feature detection for
-  // this can fail in various ways, making the userAgent check the most
-  // reliable:
-  // • Always-visible scrollbar or not
-  // • Width of <html>
-
-  // Is Safari.
-  return /^((?!chrome|android).)*safari/i.test(getUAString());
-}
-function isLastTraversableNode(node) {
-  return ['html', 'body', '#document'].includes(getNodeName(node));
-}
-
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-
 function getCssDimensions(element) {
   const css = getComputedStyle$1(element);
-  let width = parseFloat(css.width);
-  let height = parseFloat(css.height);
-  const hasOffset = isHTMLElement$1(element);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
   const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
@@ -15618,31 +15744,27 @@ function getCssDimensions(element) {
   return {
     width,
     height,
-    fallback: shouldFallback
+    $: shouldFallback
   };
 }
 
 function unwrapElement(element) {
-  return !isElement$1(element) ? element.contextElement : element;
+  return !isElement(element) ? element.contextElement : element;
 }
 
-const FALLBACK_SCALE = {
-  x: 1,
-  y: 1
-};
 function getScale(element) {
   const domElement = unwrapElement(element);
-  if (!isHTMLElement$1(domElement)) {
-    return FALLBACK_SCALE;
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
   }
   const rect = domElement.getBoundingClientRect();
   const {
     width,
     height,
-    fallback
+    $
   } = getCssDimensions(domElement);
-  let x = (fallback ? round(rect.width) : rect.width) / width;
-  let y = (fallback ? round(rect.height) : rect.height) / height;
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
 
   // 0, NaN, or Infinity should always fallback to 1.
 
@@ -15658,8 +15780,28 @@ function getScale(element) {
   };
 }
 
+const noOffsets = /*#__PURE__*/createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+
 function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
-  var _win$visualViewport, _win$visualViewport2;
   if (includeScale === void 0) {
     includeScale = false;
   }
@@ -15668,39 +15810,38 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   }
   const clientRect = element.getBoundingClientRect();
   const domElement = unwrapElement(element);
-  let scale = FALLBACK_SCALE;
+  let scale = createCoords(1);
   if (includeScale) {
     if (offsetParent) {
-      if (isElement$1(offsetParent)) {
+      if (isElement(offsetParent)) {
         scale = getScale(offsetParent);
       }
     } else {
       scale = getScale(element);
     }
   }
-  const win = domElement ? getWindow$1(domElement) : window;
-  const addVisualOffsets = isClientRectVisualViewportBased() && isFixedStrategy;
-  let x = (clientRect.left + (addVisualOffsets ? ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0 : 0)) / scale.x;
-  let y = (clientRect.top + (addVisualOffsets ? ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0 : 0)) / scale.y;
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
   let width = clientRect.width / scale.x;
   let height = clientRect.height / scale.y;
   if (domElement) {
-    const win = getWindow$1(domElement);
-    const offsetWin = offsetParent && isElement$1(offsetParent) ? getWindow$1(offsetParent) : offsetParent;
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
     let currentIFrame = win.frameElement;
     while (currentIFrame && offsetParent && offsetWin !== win) {
       const iframeScale = getScale(currentIFrame);
       const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = getComputedStyle(currentIFrame);
-      iframeRect.x += (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
-      iframeRect.y += (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      const css = getComputedStyle$1(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
       x *= iframeScale.x;
       y *= iframeScale.y;
       width *= iframeScale.x;
       height *= iframeScale.y;
-      x += iframeRect.x;
-      y += iframeRect.y;
-      currentIFrame = getWindow$1(currentIFrame).frameElement;
+      x += left;
+      y += top;
+      currentIFrame = getWindow(currentIFrame).frameElement;
     }
   }
   return rectToClientRect({
@@ -15711,30 +15852,13 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   });
 }
 
-function getDocumentElement(node) {
-  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
-}
-
-function getNodeScroll(element) {
-  if (isElement$1(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.pageXOffset,
-    scrollTop: element.pageYOffset
-  };
-}
-
 function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   let {
     rect,
     offsetParent,
     strategy
   } = _ref;
-  const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
   const documentElement = getDocumentElement(offsetParent);
   if (offsetParent === documentElement) {
     return rect;
@@ -15743,19 +15867,13 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  let scale = {
-    x: 1,
-    y: 1
-  };
-  const offsets = {
-    x: 0,
-    y: 0
-  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
   if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
     if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
       scroll = getNodeScroll(offsetParent);
     }
-    if (isHTMLElement$1(offsetParent)) {
+    if (isHTMLElement(offsetParent)) {
       const offsetRect = getBoundingClientRect(offsetParent);
       scale = getScale(offsetParent);
       offsets.x = offsetRect.x + offsetParent.clientLeft;
@@ -15770,6 +15888,10 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   };
 }
 
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+
 function getWindowScrollBarX(element) {
   // If <html> has a CSS width greater than the viewport, then this will be
   // incorrect for RTL.
@@ -15797,51 +15919,8 @@ function getDocumentRect(element) {
   };
 }
 
-function getParentNode(node) {
-  if (getNodeName(node) === 'html') {
-    return node;
-  }
-  const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot$1(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-  return isShadowRoot$1(result) ? result.host : result;
-}
-
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    // `getParentNode` will never return a `Document` due to the fallback
-    // check, so it's either the <html> or <body> element.
-    return parentNode.ownerDocument.body;
-  }
-  if (isHTMLElement$1(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-
-function getOverflowAncestors(node, list) {
-  var _node$ownerDocument;
-  if (list === void 0) {
-    list = [];
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
-  const win = getWindow$1(scrollableAncestor);
-  if (isBody) {
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []);
-  }
-  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor));
-}
-
 function getViewportRect(element, strategy) {
-  const win = getWindow$1(element);
+  const win = getWindow(element);
   const html = getDocumentElement(element);
   const visualViewport = win.visualViewport;
   let width = html.clientWidth;
@@ -15851,7 +15930,7 @@ function getViewportRect(element, strategy) {
   if (visualViewport) {
     width = visualViewport.width;
     height = visualViewport.height;
-    const visualViewportBased = isClientRectVisualViewportBased();
+    const visualViewportBased = isWebKit();
     if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
       x = visualViewport.offsetLeft;
       y = visualViewport.offsetTop;
@@ -15870,10 +15949,7 @@ function getInnerBoundingClientRect(element, strategy) {
   const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
   const top = clientRect.top + element.clientTop;
   const left = clientRect.left + element.clientLeft;
-  const scale = isHTMLElement$1(element) ? getScale(element) : {
-    x: 1,
-    y: 1
-  };
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
   const width = element.clientWidth * scale.x;
   const height = element.clientHeight * scale.y;
   const x = left * scale.x;
@@ -15891,22 +15967,25 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
     rect = getViewportRect(element, strategy);
   } else if (clippingAncestor === 'document') {
     rect = getDocumentRect(getDocumentElement(element));
-  } else if (isElement$1(clippingAncestor)) {
+  } else if (isElement(clippingAncestor)) {
     rect = getInnerBoundingClientRect(clippingAncestor, strategy);
   } else {
-    const mutableRect = {
-      ...clippingAncestor
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      ...clippingAncestor,
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y
     };
-    if (isClientRectVisualViewportBased()) {
-      var _win$visualViewport, _win$visualViewport2;
-      const win = getWindow$1(element);
-      mutableRect.x -= ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0;
-      mutableRect.y -= ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0;
-    }
-    rect = mutableRect;
   }
   return rectToClientRect(rect);
 }
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle$1(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+}
 
 // A "clipping ancestor" is an `overflow` element with the characteristic of
 // clipping (or hiding) child elements. This returns all clipping ancestors
@@ -15916,27 +15995,25 @@ function getClippingElementAncestors(element, cache) {
   if (cachedResult) {
     return cachedResult;
   }
-  let result = getOverflowAncestors(element).filter(el => isElement$1(el) && getNodeName(el) !== 'body');
+  let result = getOverflowAncestors(element).filter(el => isElement(el) && getNodeName(el) !== 'body');
   let currentContainingBlockComputedStyle = null;
   const elementIsFixed = getComputedStyle$1(element).position === 'fixed';
   let currentNode = elementIsFixed ? getParentNode(element) : element;
 
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  while (isElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
     const computedStyle = getComputedStyle$1(currentNode);
-    const containingBlock = isContainingBlock(currentNode);
-    const shouldIgnoreCurrentNode = computedStyle.position === 'fixed';
-    if (shouldIgnoreCurrentNode) {
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
       currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      // Drop non-containing blocks.
+      result = result.filter(ancestor => ancestor !== currentNode);
     } else {
-      const shouldDropCurrentNode = elementIsFixed ? !containingBlock && !currentContainingBlockComputedStyle : !containingBlock && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position);
-      if (shouldDropCurrentNode) {
-        // Drop non-containing blocks.
-        result = result.filter(ancestor => ancestor !== currentNode);
-      } else {
-        // Record last containing block for next iteration.
-        currentContainingBlockComputedStyle = computedStyle;
-      }
+      // Record last containing block for next iteration.
+      currentContainingBlockComputedStyle = computedStyle;
     }
     currentNode = getParentNode(currentNode);
   }
@@ -15976,8 +16053,38 @@ function getDimensions(element) {
   return getCssDimensions(element);
 }
 
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === 'fixed';
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  return {
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
 function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement$1(element) || getComputedStyle$1(element).position === 'fixed') {
+  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
     return null;
   }
   if (polyfill) {
@@ -15985,23 +16092,12 @@ function getTrueOffsetParent(element, polyfill) {
   }
   return element.offsetParent;
 }
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else {
-      currentNode = getParentNode(currentNode);
-    }
-  }
-  return null;
-}
 
 // Gets the closest ancestor positioned element. Handles some edge cases,
 // such as table ancestors and cross browser bugs.
 function getOffsetParent(element, polyfill) {
-  const window = getWindow$1(element);
-  if (!isHTMLElement$1(element)) {
+  const window = getWindow(element);
+  if (!isHTMLElement(element)) {
     return window;
   }
   let offsetParent = getTrueOffsetParent(element, polyfill);
@@ -16014,67 +16110,115 @@ function getOffsetParent(element, polyfill) {
   return offsetParent || getContainingBlock(element) || window;
 }
 
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  const rect = getBoundingClientRect(element, true, strategy === 'fixed', offsetParent);
-  let scroll = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  const offsets = {
-    x: 0,
-    y: 0
-  };
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
-    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
-    }
-    if (isHTMLElement$1(offsetParent)) {
-      const offsetRect = getBoundingClientRect(offsetParent, true);
-      offsets.x = offsetRect.x + offsetParent.clientLeft;
-      offsets.y = offsetRect.y + offsetParent.clientTop;
-    } else if (documentElement) {
-      offsets.x = getWindowScrollBarX(documentElement);
-    }
-  }
+const getElementRects = async function (_ref) {
+  let {
+    reference,
+    floating,
+    strategy
+  } = _ref;
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
   return {
-    x: rect.left + scroll.scrollLeft - offsets.x,
-    y: rect.top + scroll.scrollTop - offsets.y,
-    width: rect.width,
-    height: rect.height
+    reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      ...(await getDimensionsFn(floating))
+    }
   };
+};
+
+function isRTL(element) {
+  return getComputedStyle$1(element).direction === 'rtl';
 }
 
 const platform = {
-  getClippingRect,
   convertOffsetParentRelativeRectToViewportRelativeRect,
-  isElement: isElement$1,
-  getDimensions,
-  getOffsetParent,
   getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
   getScale,
-  async getElementRects(_ref) {
-    let {
-      reference,
-      floating,
-      strategy
-    } = _ref;
-    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
-    const getDimensionsFn = this.getDimensions;
-    return {
-      reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
-      floating: {
-        x: 0,
-        y: 0,
-        ...(await getDimensionsFn(floating))
-      }
-    };
-  },
-  getClientRects: element => Array.from(element.getClientRects()),
-  isRTL: element => getComputedStyle$1(element).direction === 'rtl'
+  isElement,
+  isRTL
 };
 
+// https://samthor.au/2021/observing-dom/
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    clearTimeout(timeoutId);
+    io && io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = element.getBoundingClientRect();
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 100);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      isFirstUpdate = false;
+    }
+
+    // Older browsers don't support a `document` as the root and will throw an
+    // error.
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+
 /**
  * Automatically updates the position of the floating element when necessary.
  * Should only be called when the floating element is mounted on the DOM or
@@ -16088,29 +16232,41 @@ function autoUpdate(reference, floating, update, options) {
     options = {};
   }
   const {
-    ancestorScroll: _ancestorScroll = true,
+    ancestorScroll = true,
     ancestorResize = true,
-    elementResize = true,
+    elementResize = typeof ResizeObserver === 'function',
+    layoutShift = typeof IntersectionObserver === 'function',
     animationFrame = false
   } = options;
-  const ancestorScroll = _ancestorScroll && !animationFrame;
-  const ancestors = ancestorScroll || ancestorResize ? [...(isElement$1(reference) ? getOverflowAncestors(reference) : reference.contextElement ? getOverflowAncestors(reference.contextElement) : []), ...getOverflowAncestors(floating)] : [];
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
   ancestors.forEach(ancestor => {
     ancestorScroll && ancestor.addEventListener('scroll', update, {
       passive: true
     });
     ancestorResize && ancestor.addEventListener('resize', update);
   });
-  let observer = null;
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
   if (elementResize) {
-    observer = new ResizeObserver(() => {
+    resizeObserver = new ResizeObserver(_ref => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        // Prevent update loops when using the `size` middleware.
+        // https://github.com/floating-ui/floating-ui/issues/1740
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          resizeObserver && resizeObserver.observe(floating);
+        });
+      }
       update();
     });
-    isElement$1(reference) && !animationFrame && observer.observe(reference);
-    if (!isElement$1(reference) && reference.contextElement && !animationFrame) {
-      observer.observe(reference.contextElement);
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
     }
-    observer.observe(floating);
+    resizeObserver.observe(floating);
   }
   let frameId;
   let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
@@ -16127,13 +16283,13 @@ function autoUpdate(reference, floating, update, options) {
   }
   update();
   return () => {
-    var _observer;
     ancestors.forEach(ancestor => {
       ancestorScroll && ancestor.removeEventListener('scroll', update);
       ancestorResize && ancestor.removeEventListener('resize', update);
     });
-    (_observer = observer) == null ? void 0 : _observer.disconnect();
-    observer = null;
+    cleanupIo && cleanupIo();
+    resizeObserver && resizeObserver.disconnect();
+    resizeObserver = null;
     if (animationFrame) {
       cancelAnimationFrame(frameId);
     }
@@ -16196,7 +16352,7 @@ function deepEqual(a, b) {
       return false;
     }
     for (i = length; i-- !== 0;) {
-      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
+      if (!{}.hasOwnProperty.call(b, keys[i])) {
         return false;
       }
     }
@@ -16214,6 +16370,19 @@ function deepEqual(a, b) {
   return a !== a && b !== b;
 }
 
+function getDPR(element) {
+  if (typeof window === 'undefined') {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+
 function useLatestRef$1(value) {
   const ref = React__namespace.useRef(value);
   index$1(() => {
@@ -16235,12 +16404,17 @@ function useFloating$1(options) {
     strategy = 'absolute',
     middleware = [],
     platform,
+    elements: {
+      reference: externalReference,
+      floating: externalFloating
+    } = {},
+    transform = true,
     whileElementsMounted,
     open
   } = options;
   const [data, setData] = React__namespace.useState({
-    x: null,
-    y: null,
+    x: 0,
+    y: 0,
     strategy,
     placement,
     middlewareData: {},
@@ -16250,25 +16424,27 @@ function useFloating$1(options) {
   if (!deepEqual(latestMiddleware, middleware)) {
     setLatestMiddleware(middleware);
   }
-  const referenceRef = React__namespace.useRef(null);
-  const floatingRef = React__namespace.useRef(null);
-  const dataRef = React__namespace.useRef(data);
-  const whileElementsMountedRef = useLatestRef$1(whileElementsMounted);
-  const platformRef = useLatestRef$1(platform);
-  const [reference, _setReference] = React__namespace.useState(null);
-  const [floating, _setFloating] = React__namespace.useState(null);
+  const [_reference, _setReference] = React__namespace.useState(null);
+  const [_floating, _setFloating] = React__namespace.useState(null);
   const setReference = React__namespace.useCallback(node => {
-    if (referenceRef.current !== node) {
+    if (node != referenceRef.current) {
       referenceRef.current = node;
       _setReference(node);
     }
-  }, []);
+  }, [_setReference]);
   const setFloating = React__namespace.useCallback(node => {
-    if (floatingRef.current !== node) {
+    if (node !== floatingRef.current) {
       floatingRef.current = node;
       _setFloating(node);
     }
-  }, []);
+  }, [_setFloating]);
+  const referenceEl = externalReference || _reference;
+  const floatingEl = externalFloating || _floating;
+  const referenceRef = React__namespace.useRef(null);
+  const floatingRef = React__namespace.useRef(null);
+  const dataRef = React__namespace.useRef(data);
+  const whileElementsMountedRef = useLatestRef$1(whileElementsMounted);
+  const platformRef = useLatestRef$1(platform);
   const update = React__namespace.useCallback(() => {
     if (!referenceRef.current || !floatingRef.current) {
       return;
@@ -16311,14 +16487,16 @@ function useFloating$1(options) {
     };
   }, []);
   index$1(() => {
-    if (reference && floating) {
+    if (referenceEl) referenceRef.current = referenceEl;
+    if (floatingEl) floatingRef.current = floatingEl;
+    if (referenceEl && floatingEl) {
       if (whileElementsMountedRef.current) {
-        return whileElementsMountedRef.current(reference, floating, update);
+        return whileElementsMountedRef.current(referenceEl, floatingEl, update);
       } else {
         update();
       }
     }
-  }, [reference, floating, update, whileElementsMountedRef]);
+  }, [referenceEl, floatingEl, update, whileElementsMountedRef]);
   const refs = React__namespace.useMemo(() => ({
     reference: referenceRef,
     floating: floatingRef,
@@ -16326,147 +16504,44 @@ function useFloating$1(options) {
     setFloating
   }), [setReference, setFloating]);
   const elements = React__namespace.useMemo(() => ({
-    reference,
-    floating
-  }), [reference, floating]);
+    reference: referenceEl,
+    floating: floatingEl
+  }), [referenceEl, floatingEl]);
+  const floatingStyles = React__namespace.useMemo(() => {
+    const initialStyles = {
+      position: strategy,
+      left: 0,
+      top: 0
+    };
+    if (!elements.floating) {
+      return initialStyles;
+    }
+    const x = roundByDPR(elements.floating, data.x);
+    const y = roundByDPR(elements.floating, data.y);
+    if (transform) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + x + "px, " + y + "px)",
+        ...(getDPR(elements.floating) >= 1.5 && {
+          willChange: 'transform'
+        })
+      };
+    }
+    return {
+      position: strategy,
+      left: x,
+      top: y
+    };
+  }, [strategy, transform, elements.floating, data.x, data.y]);
   return React__namespace.useMemo(() => ({
     ...data,
     update,
     refs,
     elements,
-    reference: setReference,
-    floating: setFloating
-  }), [data, update, refs, elements, setReference, setFloating]);
+    floatingStyles
+  }), [data, update, refs, elements, floatingStyles]);
 }
 
-var getDefaultParent = function (originalTarget) {
-    if (typeof document === 'undefined') {
-        return null;
-    }
-    var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
-    return sampleTarget.ownerDocument.body;
-};
-var counterMap = new WeakMap();
-var uncontrolledNodes = new WeakMap();
-var markerMap = {};
-var lockCount = 0;
-var unwrapHost = function (node) {
-    return node && (node.host || unwrapHost(node.parentNode));
-};
-var correctTargets = function (parent, targets) {
-    return targets.map(function (target) {
-        if (parent.contains(target)) {
-            return target;
-        }
-        var correctedTarget = unwrapHost(target);
-        if (correctedTarget && parent.contains(correctedTarget)) {
-            return correctedTarget;
-        }
-        console.error('aria-hidden', target, 'in not contained inside', parent, '. Doing nothing');
-        return null;
-    }).filter(function (x) { return Boolean(x); });
-};
-/**
- * Marks everything except given node(or nodes) as aria-hidden
- * @param {Element | Element[]} originalTarget - elements to keep on the page
- * @param [parentNode] - top element, defaults to document.body
- * @param {String} [markerName] - a special attribute to mark every node
- * @param {String} [controlAttribute] - html Attribute to control
- * @return {Undo} undo command
- */
-var applyAttributeToOthers = function (originalTarget, parentNode, markerName, controlAttribute) {
-    var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
-    if (!markerMap[markerName]) {
-        markerMap[markerName] = new WeakMap();
-    }
-    var markerCounter = markerMap[markerName];
-    var hiddenNodes = [];
-    var elementsToKeep = new Set();
-    var elementsToStop = new Set(targets);
-    var keep = function (el) {
-        if (!el || elementsToKeep.has(el)) {
-            return;
-        }
-        elementsToKeep.add(el);
-        keep(el.parentNode);
-    };
-    targets.forEach(keep);
-    var deep = function (parent) {
-        if (!parent || elementsToStop.has(parent)) {
-            return;
-        }
-        Array.prototype.forEach.call(parent.children, function (node) {
-            if (elementsToKeep.has(node)) {
-                deep(node);
-            }
-            else {
-                var attr = node.getAttribute(controlAttribute);
-                var alreadyHidden = attr !== null && attr !== 'false';
-                var counterValue = (counterMap.get(node) || 0) + 1;
-                var markerValue = (markerCounter.get(node) || 0) + 1;
-                counterMap.set(node, counterValue);
-                markerCounter.set(node, markerValue);
-                hiddenNodes.push(node);
-                if (counterValue === 1 && alreadyHidden) {
-                    uncontrolledNodes.set(node, true);
-                }
-                if (markerValue === 1) {
-                    node.setAttribute(markerName, 'true');
-                }
-                if (!alreadyHidden) {
-                    node.setAttribute(controlAttribute, 'true');
-                }
-            }
-        });
-    };
-    deep(parentNode);
-    elementsToKeep.clear();
-    lockCount++;
-    return function () {
-        hiddenNodes.forEach(function (node) {
-            var counterValue = counterMap.get(node) - 1;
-            var markerValue = markerCounter.get(node) - 1;
-            counterMap.set(node, counterValue);
-            markerCounter.set(node, markerValue);
-            if (!counterValue) {
-                if (!uncontrolledNodes.has(node)) {
-                    node.removeAttribute(controlAttribute);
-                }
-                uncontrolledNodes.delete(node);
-            }
-            if (!markerValue) {
-                node.removeAttribute(markerName);
-            }
-        });
-        lockCount--;
-        if (!lockCount) {
-            // clear
-            counterMap = new WeakMap();
-            counterMap = new WeakMap();
-            uncontrolledNodes = new WeakMap();
-            markerMap = {};
-        }
-    };
-};
-/**
- * Marks everything except given node(or nodes) as aria-hidden
- * @param {Element | Element[]} originalTarget - elements to keep on the page
- * @param [parentNode] - top element, defaults to document.body
- * @param {String} [markerName] - a special attribute to mark every node
- * @return {Undo} undo command
- */
-var hideOthers = function (originalTarget, parentNode, markerName) {
-    if (markerName === void 0) { markerName = 'data-aria-hidden'; }
-    var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
-    var activeParentNode = parentNode || getDefaultParent(originalTarget);
-    if (!activeParentNode) {
-        return function () { return null; };
-    }
-    // we should not hide ariaLive elements - https://github.com/theKashey/aria-hidden/issues/10
-    targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll('[aria-live]')));
-    return applyAttributeToOthers(targets, activeParentNode, markerName, 'aria-hidden');
-};
-
 /*!
 * tabbable 6.0.1
 * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
@@ -16889,8 +16964,53 @@ var tabbable = function tabbable(el, options) {
   return sortByOrder(candidates);
 };
 
+/**
+ * Merges an array of refs into a single memoized callback ref or `null`.
+ * @see https://floating-ui.com/docs/useMergeRefs
+ */
+function useMergeRefs(refs) {
+  return React__namespace.useMemo(() => {
+    if (refs.every(ref => ref == null)) {
+      return null;
+    }
+    return value => {
+      refs.forEach(ref => {
+        if (typeof ref === 'function') {
+          ref(value);
+        } else if (ref != null) {
+          ref.current = value;
+        }
+      });
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, refs);
+}
+
+let rafId = 0;
+function enqueueFocus(el, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    preventScroll = false,
+    cancelPrevious = true,
+    sync = false
+  } = options;
+  cancelPrevious && cancelAnimationFrame(rafId);
+  const exec = () => el == null ? void 0 : el.focus({
+    preventScroll
+  });
+  if (sync) {
+    exec();
+  } else {
+    rafId = requestAnimationFrame(exec);
+  }
+}
+
+var index = typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+
 function _extends() {
-  _extends = Object.assign || function (target) {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
       for (var key in source) {
@@ -16904,8 +17024,6 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-var index = typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect;
-
 let serverHandoffComplete = false;
 let count = 0;
 const genId = () => "floating-ui-" + count++;
@@ -16961,105 +17079,8 @@ const useFloatingParentNodeId = () => {
 };
 const useFloatingTree = () => React__namespace.useContext(FloatingTreeContext);
 
-function getDocument(node) {
-  return (node == null ? void 0 : node.ownerDocument) || document;
-}
-
-// Avoid Chrome DevTools blue warning.
-function getPlatform() {
-  const uaData = navigator.userAgentData;
-  if (uaData != null && uaData.platform) {
-    return uaData.platform;
-  }
-  return navigator.platform;
-}
-function getUserAgent() {
-  const uaData = navigator.userAgentData;
-  if (uaData && Array.isArray(uaData.brands)) {
-    return uaData.brands.map(_ref => {
-      let {
-        brand,
-        version
-      } = _ref;
-      return brand + "/" + version;
-    }).join(' ');
-  }
-  return navigator.userAgent;
-}
-
-function getWindow(value) {
-  return getDocument(value).defaultView || window;
-}
-function isElement(value) {
-  return value ? value instanceof getWindow(value).Element : false;
-}
-function isHTMLElement(value) {
-  return value ? value instanceof getWindow(value).HTMLElement : false;
-}
-function isShadowRoot(node) {
-  // Browsers without `ShadowRoot` support
-  if (typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  const OwnElement = getWindow(node).ShadowRoot;
-  return node instanceof OwnElement || node instanceof ShadowRoot;
-}
-
-// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts
-function isVirtualClick(event) {
-  if (event.mozInputSource === 0 && event.isTrusted) {
-    return true;
-  }
-  const androidRe = /Android/i;
-  if ((androidRe.test(getPlatform()) || androidRe.test(getUserAgent())) && event.pointerType) {
-    return event.type === 'click' && event.buttons === 1;
-  }
-  return event.detail === 0 && !event.pointerType;
-}
-function isVirtualPointerEvent(event) {
-  return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType !== 'mouse' ||
-  // iOS VoiceOver returns 0.333• for width/height.
-  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0;
-}
-function isSafari() {
-  // Chrome DevTools does not complain about navigator.vendor
-  return /apple/i.test(navigator.vendor);
-}
-function isMouseLikePointerType(pointerType, strict) {
-  // On some Linux machines with Chromium, mouse inputs return a `pointerType`
-  // of "pen": https://github.com/floating-ui/floating-ui/issues/2015
-  const values = ['mouse', 'pen'];
-  if (!strict) {
-    values.push('', undefined);
-  }
-  return values.includes(pointerType);
-}
-
-function contains(parent, child) {
-  if (!parent || !child) {
-    return false;
-  }
-  const rootNode = child.getRootNode && child.getRootNode();
-
-  // First, attempt with faster native method
-  if (parent.contains(child)) {
-    return true;
-  }
-
-  // then fallback to custom implementation with Shadow DOM support
-  if (rootNode && isShadowRoot(rootNode)) {
-    let next = child;
-    while (next) {
-      if (parent === next) {
-        return true;
-      }
-      // @ts-ignore
-      next = next.parentNode || next.host;
-    }
-  }
-
-  // Give up, the result is false
-  return false;
+function createAttribute(name) {
+  return "data-floating-ui-" + name;
 }
 
 function useLatestRef(value) {
@@ -17070,7 +17091,7 @@ function useLatestRef(value) {
   return ref;
 }
 
-const safePolygonIdentifier = 'data-floating-ui-safe-polygon';
+const safePolygonIdentifier = /*#__PURE__*/createAttribute('safe-polygon');
 function getDelay(value, prop, pointerType) {
   if (pointerType && !isMouseLikePointerType(pointerType)) {
     return 0;
@@ -17085,7 +17106,7 @@ function getDelay(value, prop, pointerType) {
  * CSS `:hover`.
  * @see https://floating-ui.com/docs/useHover
  */
-const useHover$1 = function (context, props) {
+function useHover$1(context, props) {
   if (props === void 0) {
     props = {};
   }
@@ -17145,9 +17166,9 @@ const useHover$1 = function (context, props) {
     if (!enabled || !handleCloseRef.current || !open) {
       return;
     }
-    function onLeave() {
+    function onLeave(event) {
       if (isHoverOpen()) {
-        onOpenChange(false);
+        onOpenChange(false, event);
       }
     }
     const html = getDocument(floating).documentElement;
@@ -17156,17 +17177,17 @@ const useHover$1 = function (context, props) {
       html.removeEventListener('mouseleave', onLeave);
     };
   }, [floating, open, onOpenChange, enabled, handleCloseRef, dataRef, isHoverOpen]);
-  const closeWithDelay = React__namespace.useCallback(function (runElseBranch) {
+  const closeWithDelay = React__namespace.useCallback(function (event, runElseBranch) {
     if (runElseBranch === void 0) {
       runElseBranch = true;
     }
     const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);
     if (closeDelay && !handlerRef.current) {
       clearTimeout(timeoutRef.current);
-      timeoutRef.current = setTimeout(() => onOpenChange(false), closeDelay);
+      timeoutRef.current = setTimeout(() => onOpenChange(false, event), closeDelay);
     } else if (runElseBranch) {
       clearTimeout(timeoutRef.current);
-      onOpenChange(false);
+      onOpenChange(false, event);
     }
   }, [delayRef, onOpenChange]);
   const cleanupMouseMoveHandler = React__namespace.useCallback(() => {
@@ -17198,14 +17219,13 @@ const useHover$1 = function (context, props) {
       if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && getDelay(delayRef.current, 'open') === 0) {
         return;
       }
-      dataRef.current.openEvent = event;
       const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);
       if (openDelay) {
         timeoutRef.current = setTimeout(() => {
-          onOpenChange(true);
+          onOpenChange(true, event);
         }, openDelay);
       } else {
-        onOpenChange(true);
+        onOpenChange(true, event);
       }
     }
     function onMouseLeave(event) {
@@ -17228,7 +17248,8 @@ const useHover$1 = function (context, props) {
           onClose() {
             clearPointerEvents();
             cleanupMouseMoveHandler();
-            closeWithDelay();
+            // Should the event expose that it was closed by `safePolygon`?
+            closeWithDelay(event);
           }
         });
         const handler = handlerRef.current;
@@ -17244,7 +17265,7 @@ const useHover$1 = function (context, props) {
       // consistently.
       const shouldClose = pointerTypeRef.current === 'touch' ? !contains(floating, event.relatedTarget) : true;
       if (shouldClose) {
-        closeWithDelay();
+        closeWithDelay(event);
       }
     }
 
@@ -17263,7 +17284,7 @@ const useHover$1 = function (context, props) {
         onClose() {
           clearPointerEvents();
           cleanupMouseMoveHandler();
-          closeWithDelay();
+          closeWithDelay(event);
         }
       })(event);
     }
@@ -17330,7 +17351,7 @@ const useHover$1 = function (context, props) {
       clearTimeout(restTimeoutRef.current);
       clearPointerEvents();
     };
-  }, [enabled, cleanupMouseMoveHandler, clearPointerEvents]);
+  }, [enabled, domReference, cleanupMouseMoveHandler, clearPointerEvents]);
   return React__namespace.useMemo(() => {
     if (!enabled) {
       return {};
@@ -17342,14 +17363,14 @@ const useHover$1 = function (context, props) {
       reference: {
         onPointerDown: setPointerRef,
         onPointerEnter: setPointerRef,
-        onMouseMove() {
+        onMouseMove(event) {
           if (open || restMs === 0) {
             return;
           }
           clearTimeout(restTimeoutRef.current);
           restTimeoutRef.current = setTimeout(() => {
             if (!blockMouseMoveRef.current) {
-              onOpenChange(true);
+              onOpenChange(true, event.nativeEvent);
             }
           }, restMs);
         }
@@ -17358,51 +17379,18 @@ const useHover$1 = function (context, props) {
         onMouseEnter() {
           clearTimeout(timeoutRef.current);
         },
-        onMouseLeave() {
+        onMouseLeave(event) {
           events.emit('dismiss', {
             type: 'mouseLeave',
             data: {
               returnFocus: false
             }
           });
-          closeWithDelay(false);
+          closeWithDelay(event.nativeEvent, false);
         }
       }
     };
   }, [events, enabled, restMs, open, onOpenChange, closeWithDelay]);
-};
-
-/**
- * Find the real active element. Traverses into shadowRoots.
- */
-function activeElement(doc) {
-  let activeElement = doc.activeElement;
-  while (((_activeElement = activeElement) == null ? void 0 : (_activeElement$shadow = _activeElement.shadowRoot) == null ? void 0 : _activeElement$shadow.activeElement) != null) {
-    var _activeElement, _activeElement$shadow;
-    activeElement = activeElement.shadowRoot.activeElement;
-  }
-  return activeElement;
-}
-
-let rafId = 0;
-function enqueueFocus(el, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    preventScroll = false,
-    cancelPrevious = true,
-    sync = false
-  } = options;
-  cancelPrevious && cancelAnimationFrame(rafId);
-  const exec = () => el == null ? void 0 : el.focus({
-    preventScroll
-  });
-  if (sync) {
-    exec();
-  } else {
-    rafId = requestAnimationFrame(exec);
-  }
 }
 
 function getAncestors(nodes, id) {
@@ -17438,24 +17426,107 @@ function getChildren(nodes, id) {
   return allChildren;
 }
 
-function getTarget(event) {
-  if ('composedPath' in event) {
-    return event.composedPath()[0];
+// Modified to add conditional `aria-hidden` support:
+// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts
+let counterMap = /*#__PURE__*/new WeakMap();
+let uncontrolledElementsSet = /*#__PURE__*/new WeakSet();
+let markerMap = {};
+let lockCount = 0;
+const supportsInert = () => typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;
+const unwrapHost = node => node && (node.host || unwrapHost(node.parentNode));
+const correctElements = (parent, targets) => targets.map(target => {
+  if (parent.contains(target)) {
+    return target;
   }
-
-  // TS thinks `event` is of type never as it assumes all browsers support
-  // `composedPath()`, but browsers without shadow DOM don't.
-  return event.target;
-}
-
-const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled])," + "[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
-function isTypeableElement(element) {
-  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+  const correctedTarget = unwrapHost(target);
+  if (parent.contains(correctedTarget)) {
+    return correctedTarget;
+  }
+  return null;
+}).filter(x => x != null);
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {
+  const markerName = 'data-floating-ui-inert';
+  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;
+  const avoidElements = correctElements(body, uncorrectedAvoidElements);
+  const elementsToKeep = new Set();
+  const elementsToStop = new Set(avoidElements);
+  const hiddenElements = [];
+  if (!markerMap[markerName]) {
+    markerMap[markerName] = new WeakMap();
+  }
+  const markerCounter = markerMap[markerName];
+  avoidElements.forEach(keep);
+  deep(body);
+  elementsToKeep.clear();
+  function keep(el) {
+    if (!el || elementsToKeep.has(el)) {
+      return;
+    }
+    elementsToKeep.add(el);
+    el.parentNode && keep(el.parentNode);
+  }
+  function deep(parent) {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    Array.prototype.forEach.call(parent.children, node => {
+      if (elementsToKeep.has(node)) {
+        deep(node);
+      } else {
+        const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;
+        const alreadyHidden = attr !== null && attr !== 'false';
+        const counterValue = (counterMap.get(node) || 0) + 1;
+        const markerValue = (markerCounter.get(node) || 0) + 1;
+        counterMap.set(node, counterValue);
+        markerCounter.set(node, markerValue);
+        hiddenElements.push(node);
+        if (counterValue === 1 && alreadyHidden) {
+          uncontrolledElementsSet.add(node);
+        }
+        if (markerValue === 1) {
+          node.setAttribute(markerName, '');
+        }
+        if (!alreadyHidden && controlAttribute) {
+          node.setAttribute(controlAttribute, 'true');
+        }
+      }
+    });
+  }
+  lockCount++;
+  return () => {
+    hiddenElements.forEach(element => {
+      const counterValue = (counterMap.get(element) || 0) - 1;
+      const markerValue = (markerCounter.get(element) || 0) - 1;
+      counterMap.set(element, counterValue);
+      markerCounter.set(element, markerValue);
+      if (!counterValue) {
+        if (!uncontrolledElementsSet.has(element) && controlAttribute) {
+          element.removeAttribute(controlAttribute);
+        }
+        uncontrolledElementsSet.delete(element);
+      }
+      if (!markerValue) {
+        element.removeAttribute(markerName);
+      }
+    });
+    lockCount--;
+    if (!lockCount) {
+      counterMap = new WeakMap();
+      counterMap = new WeakMap();
+      uncontrolledElementsSet = new WeakSet();
+      markerMap = {};
+    }
+  };
 }
-
-function stopEvent(event) {
-  event.preventDefault();
-  event.stopPropagation();
+function markOthers(avoidElements, ariaHidden, inert) {
+  if (ariaHidden === void 0) {
+    ariaHidden = false;
+  }
+  if (inert === void 0) {
+    inert = false;
+  }
+  const body = getDocument(avoidElements[0]).body;
+  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);
 }
 
 const getTabbableOptions = () => ({
@@ -17545,20 +17616,20 @@ const FocusGuard = /*#__PURE__*/React__namespace.forwardRef(function FocusGuard(
       document.removeEventListener('keydown', setActiveElementOnTab);
     };
   }, []);
-  return /*#__PURE__*/React__namespace.createElement("span", _extends({}, props, {
-    ref: ref,
-    tabIndex: 0
+  const restProps = {
+    ref,
+    tabIndex: 0,
     // Role is only for VoiceOver
-    ,
-    role: role,
-    "aria-hidden": role ? undefined : true,
-    "data-floating-ui-focus-guard": "",
+    role,
+    'aria-hidden': role ? undefined : true,
+    [createAttribute('focus-guard')]: '',
     style: HIDDEN_STYLES
-  }));
+  };
+  return /*#__PURE__*/React__namespace.createElement("span", _extends({}, props, restProps));
 });
 
 const PortalContext = /*#__PURE__*/React__namespace.createContext(null);
-const useFloatingPortalNode = function (_temp) {
+function useFloatingPortalNode(_temp) {
   let {
     id,
     root
@@ -17566,20 +17637,39 @@ const useFloatingPortalNode = function (_temp) {
   const [portalNode, setPortalNode] = React__namespace.useState(null);
   const uniqueId = useId();
   const portalContext = usePortalContext();
+  const data = React__namespace.useMemo(() => ({
+    id,
+    root,
+    portalContext,
+    uniqueId
+  }), [id, root, portalContext, uniqueId]);
+  const dataRef = React__namespace.useRef();
+  index(() => {
+    return () => {
+      portalNode == null ? void 0 : portalNode.remove();
+    };
+  }, [portalNode, data]);
   index(() => {
+    if (dataRef.current === data) return;
+    dataRef.current = data;
+    const {
+      id,
+      root,
+      portalContext,
+      uniqueId
+    } = data;
     const existingIdRoot = id ? document.getElementById(id) : null;
-    const attr = 'data-floating-ui-portal';
+    const attr = createAttribute('portal');
     if (existingIdRoot) {
       const subRoot = document.createElement('div');
       subRoot.id = uniqueId;
       subRoot.setAttribute(attr, '');
       existingIdRoot.appendChild(subRoot);
       setPortalNode(subRoot);
-      return () => {
-        subRoot.remove();
-      };
     } else {
-      let container = (portalContext == null ? void 0 : portalContext.portalNode) || root || document.body;
+      let container = root || (portalContext == null ? void 0 : portalContext.portalNode);
+      if (container && !isElement(container)) container = container.current;
+      container = container || document.body;
       let idWrapper = null;
       if (id) {
         idWrapper = document.createElement('div');
@@ -17589,25 +17679,19 @@ const useFloatingPortalNode = function (_temp) {
       const subRoot = document.createElement('div');
       subRoot.id = uniqueId;
       subRoot.setAttribute(attr, '');
-      setPortalNode(subRoot);
       container = idWrapper || container;
       container.appendChild(subRoot);
-      return () => {
-        var _idWrapper;
-        subRoot.remove();
-        (_idWrapper = idWrapper) == null ? void 0 : _idWrapper.remove();
-      };
+      setPortalNode(subRoot);
     }
-  }, [id, root, portalContext, uniqueId]);
+  }, [data]);
   return portalNode;
-};
-
+}
 /**
  * Portals the floating element into a given container element — by default,
  * outside of the app root and into the body.
  * @see https://floating-ui.com/docs/FloatingPortal
  */
-const FloatingPortal = _ref => {
+function FloatingPortal(_ref) {
   let {
     children,
     id,
@@ -17628,7 +17712,9 @@ const FloatingPortal = _ref => {
   // rendered.
   !!focusManagerState &&
   // Guards are only for non-modal focus management.
-  !focusManagerState.modal && !!(root || portalNode) && preserveTabOrder;
+  !focusManagerState.modal &&
+  // Don't render if unmount is transitioning.
+  focusManagerState.open && preserveTabOrder && !!(root || portalNode);
 
   // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx
   React__namespace.useEffect(() => {
@@ -17690,11 +17776,11 @@ const FloatingPortal = _ref => {
       } else {
         const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);
         nextTabbable == null ? void 0 : nextTabbable.focus();
-        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false));
+        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, event.nativeEvent));
       }
     }
   }));
-};
+}
 const usePortalContext = () => React__namespace.useContext(PortalContext);
 
 const VisuallyHiddenDismiss = /*#__PURE__*/React__namespace.forwardRef(function VisuallyHiddenDismiss(props, ref) {
@@ -17709,18 +17795,19 @@ const VisuallyHiddenDismiss = /*#__PURE__*/React__namespace.forwardRef(function
  * Provides focus management for the floating element.
  * @see https://floating-ui.com/docs/FloatingFocusManager
  */
-function FloatingFocusManager(_ref) {
-  let {
+function FloatingFocusManager(props) {
+  const {
     context,
     children,
+    disabled = false,
     order = ['content'],
-    guards = true,
+    guards: _guards = true,
     initialFocus = 0,
     returnFocus = true,
     modal = true,
     visuallyHiddenDismiss = false,
     closeOnFocusOut = true
-  } = _ref;
+  } = props;
   const {
     open,
     refs,
@@ -17733,12 +17820,14 @@ function FloatingFocusManager(_ref) {
       floating
     }
   } = context;
+
+  // Force the guards to be rendered if the `inert` attribute is not supported.
+  const guards = supportsInert() ? _guards : true;
   const orderRef = useLatestRef(order);
   const initialFocusRef = useLatestRef(initialFocus);
   const returnFocusRef = useLatestRef(returnFocus);
   const tree = useFloatingTree();
   const portalContext = usePortalContext();
-  const [tabbableContentLength, setTabbableContentLength] = React__namespace.useState(null);
 
   // Controlled by `useListNavigation`.
   const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;
@@ -17754,7 +17843,7 @@ function FloatingFocusManager(_ref) {
   // aria-hidden should be applied to all nodes still. Further, the visually
   // hidden dismiss button should only appear at the end of the list, not the
   // start.
-  const isTypeableCombobox = domReference && domReference.getAttribute('role') === 'combobox' && isTypeableElement(domReference);
+  const isUntrappedTypeableCombobox = domReference && domReference.getAttribute('role') === 'combobox' && isTypeableElement(domReference) && ignoreInitialFocus;
   const getTabbableContent = React__namespace.useCallback(function (container) {
     if (container === void 0) {
       container = floating;
@@ -17774,13 +17863,11 @@ function FloatingFocusManager(_ref) {
     }).filter(Boolean).flat();
   }, [domReference, floating, orderRef, getTabbableContent]);
   React__namespace.useEffect(() => {
-    if (!modal) {
-      return;
-    }
+    if (disabled || !modal) return;
     function onKeyDown(event) {
       if (event.key === 'Tab') {
         // The focus guards have nothing to focus, so we need to stop the event.
-        if (getTabbableContent().length === 0 && !isTypeableCombobox) {
+        if (contains(floating, activeElement(getDocument(floating))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
           stopEvent(event);
         }
         const els = getTabbableElements();
@@ -17804,11 +17891,9 @@ function FloatingFocusManager(_ref) {
     return () => {
       doc.removeEventListener('keydown', onKeyDown);
     };
-  }, [domReference, floating, modal, orderRef, refs, isTypeableCombobox, getTabbableContent, getTabbableElements]);
+  }, [disabled, domReference, floating, modal, orderRef, refs, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
   React__namespace.useEffect(() => {
-    if (!closeOnFocusOut) {
-      return;
-    }
+    if (disabled || !closeOnFocusOut) return;
 
     // In Safari, buttons lose focus when pressing them.
     function handlePointerDown() {
@@ -17819,22 +17904,24 @@ function FloatingFocusManager(_ref) {
     }
     function handleFocusOutside(event) {
       const relatedTarget = event.relatedTarget;
-      const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute('data-floating-ui-focus-guard') || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {
-        var _node$context, _node$context2;
-        return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);
-      }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {
-        var _node$context3, _node$context4;
-        return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;
-      })));
-
-      // Focus did not move inside the floating tree, and there are no tabbable
-      // portal guards to handle closing.
-      if (relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&
-      // Fix React 18 Strict Mode returnFocus due to double rendering.
-      relatedTarget !== previouslyFocusedElementRef.current) {
-        preventReturnFocusRef.current = true;
-        onOpenChange(false);
-      }
+      queueMicrotask(() => {
+        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute('focus-guard')) || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {
+          var _node$context, _node$context2;
+          return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);
+        }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {
+          var _node$context3, _node$context4;
+          return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;
+        })));
+
+        // Focus did not move inside the floating tree, and there are no tabbable
+        // portal guards to handle closing.
+        if (relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&
+        // Fix React 18 Strict Mode returnFocus due to double rendering.
+        relatedTarget !== previouslyFocusedElementRef.current) {
+          preventReturnFocusRef.current = true;
+          onOpenChange(false, event);
+        }
+      });
     }
     if (floating && isHTMLElement(domReference)) {
       domReference.addEventListener('focusout', handleFocusOutside);
@@ -17846,63 +17933,46 @@ function FloatingFocusManager(_ref) {
         !modal && floating.removeEventListener('focusout', handleFocusOutside);
       };
     }
-  }, [domReference, floating, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut]);
+  }, [disabled, domReference, floating, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut]);
   React__namespace.useEffect(() => {
     var _portalContext$portal;
+    if (disabled) return;
+
     // Don't hide portals nested within the parent portal.
-    const portalNodes = Array.from((portalContext == null ? void 0 : (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll('[data-floating-ui-portal]')) || []);
-    function getDismissButtons() {
-      return [startDismissButtonRef.current, endDismissButtonRef.current].filter(Boolean);
-    }
-    if (floating && modal) {
-      const insideNodes = [floating, ...portalNodes, ...getDismissButtons()];
-      const cleanup = hideOthers(orderRef.current.includes('reference') || isTypeableCombobox ? insideNodes.concat(domReference || []) : insideNodes);
+    const portalNodes = Array.from((portalContext == null ? void 0 : (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll("[" + createAttribute('portal') + "]")) || []);
+    if (floating) {
+      const insideElements = [floating, ...portalNodes, startDismissButtonRef.current, endDismissButtonRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);
+      const cleanup = modal ? markOthers(insideElements, guards, !guards) : markOthers(insideElements);
       return () => {
         cleanup();
       };
     }
-  }, [domReference, floating, modal, orderRef, portalContext, isTypeableCombobox]);
-  React__namespace.useEffect(() => {
-    if (modal && !guards && floating) {
-      const tabIndexValues = [];
-      const options = getTabbableOptions();
-      const allTabbable = tabbable(getDocument(floating).body, options);
-      const floatingTabbable = getTabbableElements();
-
-      // Exclude all tabbable elements that are part of the order
-      const elements = allTabbable.filter(el => !floatingTabbable.includes(el));
-      elements.forEach((el, i) => {
-        tabIndexValues[i] = el.getAttribute('tabindex');
-        el.setAttribute('tabindex', '-1');
-      });
-      return () => {
-        elements.forEach((el, i) => {
-          const value = tabIndexValues[i];
-          if (value == null) {
-            el.removeAttribute('tabindex');
-          } else {
-            el.setAttribute('tabindex', value);
-          }
-        });
-      };
-    }
-  }, [floating, modal, guards, getTabbableElements]);
+  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards]);
   index(() => {
-    if (!floating) return;
+    if (disabled || !floating) return;
     const doc = getDocument(floating);
+    const previouslyFocusedElement = activeElement(doc);
+
+    // Wait for any layout effect state setters to execute to set `tabIndex`.
+    queueMicrotask(() => {
+      const focusableElements = getTabbableElements(floating);
+      const initialFocusValue = initialFocusRef.current;
+      const elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floating;
+      const focusAlreadyInsideFloatingEl = contains(floating, previouslyFocusedElement);
+      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {
+        enqueueFocus(elToFocus, {
+          preventScroll: elToFocus === floating
+        });
+      }
+    });
+  }, [disabled, open, floating, ignoreInitialFocus, getTabbableElements, initialFocusRef]);
+  index(() => {
+    if (disabled || !floating) return;
     let preventReturnFocusScroll = false;
+    const doc = getDocument(floating);
     const previouslyFocusedElement = activeElement(doc);
     const contextData = dataRef.current;
-    const initialFocusValue = initialFocusRef.current;
     previouslyFocusedElementRef.current = previouslyFocusedElement;
-    const focusableElements = getTabbableElements(floating);
-    const elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floating;
-
-    // If the `useListNavigation` hook is active, always ignore `initialFocus`
-    // because it has its own handling of the initial focus.
-    !ignoreInitialFocus && open && enqueueFocus(elToFocus, {
-      preventScroll: elToFocus === floating
-    });
 
     // Dismissing via outside press should always ignore `returnFocus` to
     // prevent unwanted scrolling.
@@ -17935,8 +18005,6 @@ function FloatingFocusManager(_ref) {
       if (
       // eslint-disable-next-line react-hooks/exhaustive-deps
       returnFocusRef.current && isHTMLElement(previouslyFocusedElementRef.current) && !preventReturnFocusRef.current) {
-        // `isPointerDownRef.current` to avoid the focus ring from appearing on
-        // the reference element when click-toggling it.
         enqueueFocus(previouslyFocusedElementRef.current, {
           // When dismissing nested floating elements, by the time the rAF has
           // executed, the menus will all have been unmounted. When they try
@@ -17947,49 +18015,58 @@ function FloatingFocusManager(_ref) {
         });
       }
     };
-  }, [open, floating, getTabbableElements, returnFocusRef, initialFocusRef, dataRef, refs, events, ignoreInitialFocus, tree, nodeId]);
+  }, [disabled, floating, returnFocusRef, dataRef, refs, events, tree, nodeId]);
 
   // Synchronize the `context` & `modal` value to the FloatingPortal context.
   // It will decide whether or not it needs to render its own guards.
   index(() => {
-    if (!portalContext) return;
+    if (disabled || !portalContext) return;
     portalContext.setFocusManagerState({
-      ...context,
       modal,
-      closeOnFocusOut
-      // Not concerned about the <RT> generic type.
+      closeOnFocusOut,
+      open,
+      onOpenChange,
+      refs
     });
-
     return () => {
       portalContext.setFocusManagerState(null);
     };
-  }, [portalContext, modal, closeOnFocusOut, context]);
+  }, [disabled, portalContext, modal, open, onOpenChange, refs, closeOnFocusOut]);
   index(() => {
-    if (ignoreInitialFocus || !floating) return;
-    function setState() {
-      if (activeElement(getDocument(floating)) !== refs.domReference.current) {
-        setTabbableContentLength(getTabbableContent().length);
-      }
-    }
-    setState();
-    if (typeof MutationObserver === 'function') {
-      const observer = new MutationObserver(setState);
+    if (disabled) return;
+    if (floating && typeof MutationObserver === 'function' && !ignoreInitialFocus) {
+      const handleMutation = () => {
+        const tabIndex = floating.getAttribute('tabindex');
+        if (orderRef.current.includes('floating') || activeElement(getDocument(floating)) !== refs.domReference.current && getTabbableContent().length === 0) {
+          if (tabIndex !== '0') {
+            floating.setAttribute('tabindex', '0');
+          }
+        } else if (tabIndex !== '-1') {
+          floating.setAttribute('tabindex', '-1');
+        }
+      };
+      handleMutation();
+      const observer = new MutationObserver(handleMutation);
       observer.observe(floating, {
         childList: true,
-        subtree: true
+        subtree: true,
+        attributes: true
       });
       return () => {
         observer.disconnect();
       };
     }
-  }, [floating, getTabbableContent, ignoreInitialFocus, refs]);
-  const shouldRenderGuards = guards && (isInsidePortal || modal) && !isTypeableCombobox;
+  }, [disabled, floating, refs, orderRef, getTabbableContent, ignoreInitialFocus]);
   function renderDismissButton(location) {
-    return visuallyHiddenDismiss && modal ? /*#__PURE__*/React__namespace.createElement(VisuallyHiddenDismiss, {
+    if (disabled || !visuallyHiddenDismiss || !modal) {
+      return null;
+    }
+    return /*#__PURE__*/React__namespace.createElement(VisuallyHiddenDismiss, {
       ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,
-      onClick: () => onOpenChange(false)
-    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss') : null;
+      onClick: event => onOpenChange(false, event.nativeEvent)
+    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss');
   }
+  const shouldRenderGuards = !disabled && guards && !isUntrappedTypeableCombobox && (isInsidePortal || modal);
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, shouldRenderGuards && /*#__PURE__*/React__namespace.createElement(FocusGuard, {
     "data-type": "inside",
     ref: portalContext == null ? void 0 : portalContext.beforeInsideRef,
@@ -18008,9 +18085,7 @@ function FloatingFocusManager(_ref) {
         }
       }
     }
-  }), isTypeableCombobox ? null : renderDismissButton('start'), /*#__PURE__*/React__namespace.cloneElement(children, tabbableContentLength === 0 || order.includes('floating') ? {
-    tabIndex: 0
-  } : {}), renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/React__namespace.createElement(FocusGuard, {
+  }), !isUntrappedTypeableCombobox && renderDismissButton('start'), children, renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/React__namespace.createElement(FocusGuard, {
     "data-type": "inside",
     ref: portalContext == null ? void 0 : portalContext.afterInsideRef,
     onFocus: event => {
@@ -18042,7 +18117,7 @@ function isSpaceIgnored(element) {
  * Opens or closes the floating element when clicking the reference element.
  * @see https://floating-ui.com/docs/useClick
  */
-const useClick = function (context, props) {
+function useClick(context, props) {
   if (props === void 0) {
     props = {};
   }
@@ -18062,10 +18137,9 @@ const useClick = function (context, props) {
     keyboardHandlers = true
   } = props;
   const pointerTypeRef = React__namespace.useRef();
+  const didKeyDownRef = React__namespace.useRef(false);
   return React__namespace.useMemo(() => {
-    if (!enabled) {
-      return {};
-    }
+    if (!enabled) return {};
     return {
       reference: {
         onPointerDown(event) {
@@ -18083,16 +18157,13 @@ const useClick = function (context, props) {
           if (eventOption === 'click') {
             return;
           }
-          if (open) {
-            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'mousedown' : true)) {
-              onOpenChange(false);
-            }
+          if (open && toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'mousedown' : true)) {
+            onOpenChange(false, event.nativeEvent);
           } else {
             // Prevent stealing focus from the floating element
             event.preventDefault();
-            onOpenChange(true);
+            onOpenChange(true, event.nativeEvent);
           }
-          dataRef.current.openEvent = event.nativeEvent;
         },
         onClick(event) {
           if (eventOption === 'mousedown' && pointerTypeRef.current) {
@@ -18102,63 +18173,52 @@ const useClick = function (context, props) {
           if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {
             return;
           }
-          if (open) {
-            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'click' : true)) {
-              onOpenChange(false);
-            }
+          if (open && toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'click' : true)) {
+            onOpenChange(false, event.nativeEvent);
           } else {
-            onOpenChange(true);
+            onOpenChange(true, event.nativeEvent);
           }
-          dataRef.current.openEvent = event.nativeEvent;
         },
         onKeyDown(event) {
           pointerTypeRef.current = undefined;
-          if (!keyboardHandlers) {
-            return;
-          }
-          if (isButtonTarget(event)) {
+          if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) {
             return;
           }
           if (event.key === ' ' && !isSpaceIgnored(domReference)) {
             // Prevent scrolling
             event.preventDefault();
+            didKeyDownRef.current = true;
           }
           if (event.key === 'Enter') {
-            if (open) {
-              if (toggle) {
-                onOpenChange(false);
-              }
+            if (open && toggle) {
+              onOpenChange(false, event.nativeEvent);
             } else {
-              onOpenChange(true);
+              onOpenChange(true, event.nativeEvent);
             }
           }
         },
         onKeyUp(event) {
-          if (!keyboardHandlers) {
-            return;
-          }
-          if (isButtonTarget(event) || isSpaceIgnored(domReference)) {
+          if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) {
             return;
           }
-          if (event.key === ' ') {
-            if (open) {
-              if (toggle) {
-                onOpenChange(false);
-              }
+          if (event.key === ' ' && didKeyDownRef.current) {
+            didKeyDownRef.current = false;
+            if (open && toggle) {
+              onOpenChange(false, event.nativeEvent);
             } else {
-              onOpenChange(true);
+              onOpenChange(true, event.nativeEvent);
             }
           }
         }
       }
     };
   }, [enabled, dataRef, eventOption, ignoreMouse, keyboardHandlers, domReference, toggle, open, onOpenChange]);
-};
+}
 
 // `toString()` prevents bundlers from trying to `import { useInsertionEffect } from 'react'`
 const useInsertionEffect = React__namespace[/*#__PURE__*/'useInsertionEffect'.toString()];
 const useSafeInsertionEffect = useInsertionEffect || (fn => fn());
-function useEvent(callback) {
+function useEffectEvent(callback) {
   const ref = React__namespace.useRef(() => {
     if (process.env.NODE_ENV !== "production") {
       throw new Error('Cannot call an event handler while rendering.');
@@ -18175,26 +18235,6 @@ function useEvent(callback) {
   }, []);
 }
 
-/**
- * Check whether the event.target is within the provided node. Uses event.composedPath if available for custom element support.
- *
- * @param event The event whose target/composedPath to check
- * @param node The node to check against
- * @returns Whether the event.target/composedPath is within the node.
- */
-function isEventTargetWithin(event, node) {
-  if (node == null) {
-    return false;
-  }
-  if ('composedPath' in event) {
-    return event.composedPath().includes(node);
-  }
-
-  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't
-  const e = event;
-  return e.target != null && node.contains(e.target);
-}
-
 const bubbleHandlerKeys = {
   pointerdown: 'onPointerDown',
   mousedown: 'onMouseDown',
@@ -18217,7 +18257,7 @@ const normalizeBubblesProp = bubbles => {
  * the user presses the `escape` key or outside of the floating element.
  * @see https://floating-ui.com/docs/useDismiss
  */
-const useDismiss = function (context, props) {
+function useDismiss(context, props) {
   if (props === void 0) {
     props = {};
   }
@@ -18245,14 +18285,14 @@ const useDismiss = function (context, props) {
   } = props;
   const tree = useFloatingTree();
   const nested = useFloatingParentNodeId() != null;
-  const outsidePressFn = useEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);
+  const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);
   const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;
   const insideReactTreeRef = React__namespace.useRef(false);
   const {
     escapeKeyBubbles,
     outsidePressBubbles
   } = normalizeBubblesProp(bubbles);
-  const closeOnEscapeKeyDown = useEvent(event => {
+  const closeOnEscapeKeyDown = useEffectEvent(event => {
     if (!open || !enabled || !escapeKey || event.key !== 'Escape') {
       return;
     }
@@ -18281,9 +18321,9 @@ const useDismiss = function (context, props) {
         }
       }
     });
-    onOpenChange(false);
+    onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event);
   });
-  const closeOnPressOutside = useEvent(event => {
+  const closeOnPressOutside = useEffectEvent(event => {
     // Given developers can stop the propagation of the synthetic event,
     // we can only be confident with a positive value.
     const insideReactTree = insideReactTreeRef.current;
@@ -18295,6 +18335,28 @@ const useDismiss = function (context, props) {
       return;
     }
     const target = getTarget(event);
+    const inertSelector = "[" + createAttribute('inert') + "]";
+    const markers = getDocument(floating).querySelectorAll(inertSelector);
+    let targetRootAncestor = isElement(target) ? target : null;
+    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
+      const nextParent = getParentNode(targetRootAncestor);
+      if (nextParent === getDocument(floating).body || !isElement(nextParent)) {
+        break;
+      } else {
+        targetRootAncestor = nextParent;
+      }
+    }
+
+    // Check if the click occurred on a third-party element injected after the
+    // floating element rendered.
+    if (markers.length && isElement(target) && !isRootElement(target) &&
+    // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !contains(target, floating) &&
+    // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(markers).every(marker => !contains(targetRootAncestor, marker))) {
+      return;
+    }
 
     // Check if the click occurred on the scrollbar
     if (isHTMLElement(target) && floating) {
@@ -18309,7 +18371,7 @@ const useDismiss = function (context, props) {
       // check for. Plus, for modal dialogs with backdrops, it is more
       // important that the backdrop is checked but not so much the window.
       if (canScrollY) {
-        const isRTL = getWindow(floating).getComputedStyle(target).direction === 'rtl';
+        const isRTL = getComputedStyle$1(target).direction === 'rtl';
         if (isRTL) {
           xCond = event.offsetX <= target.offsetWidth - target.clientWidth;
         }
@@ -18347,7 +18409,7 @@ const useDismiss = function (context, props) {
         } : isVirtualClick(event) || isVirtualPointerEvent(event)
       }
     });
-    onOpenChange(false);
+    onOpenChange(false, event);
   });
   React__namespace.useEffect(() => {
     if (!open || !enabled) {
@@ -18355,8 +18417,8 @@ const useDismiss = function (context, props) {
     }
     dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
     dataRef.current.__outsidePressBubbles = outsidePressBubbles;
-    function onScroll() {
-      onOpenChange(false);
+    function onScroll(event) {
+      onOpenChange(false, event);
     }
     const doc = getDocument(floating);
     escapeKey && doc.addEventListener('keydown', closeOnEscapeKeyDown);
@@ -18402,7 +18464,7 @@ const useDismiss = function (context, props) {
     return {
       reference: {
         onKeyDown: closeOnEscapeKeyDown,
-        [bubbleHandlerKeys[referencePressEvent]]: () => {
+        [bubbleHandlerKeys[referencePressEvent]]: event => {
           if (referencePress) {
             events.emit('dismiss', {
               type: 'referencePress',
@@ -18410,7 +18472,7 @@ const useDismiss = function (context, props) {
                 returnFocus: false
               }
             });
-            onOpenChange(false);
+            onOpenChange(false, event.nativeEvent);
           }
         }
       },
@@ -18422,91 +18484,19 @@ const useDismiss = function (context, props) {
       }
     };
   }, [enabled, events, referencePress, outsidePressEvent, referencePressEvent, onOpenChange, closeOnEscapeKeyDown]);
-};
-
-/**
- * Merges an array of refs into a single memoized callback ref or `null`.
- * @see https://floating-ui.com/docs/useMergeRefs
- */
-function useMergeRefs(refs) {
-  return React__namespace.useMemo(() => {
-    if (refs.every(ref => ref == null)) {
-      return null;
-    }
-    return value => {
-      refs.forEach(ref => {
-        if (typeof ref === 'function') {
-          ref(value);
-        } else if (ref != null) {
-          ref.current = value;
-        }
-      });
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, refs);
 }
 
-/**
- * Adds base screen reader props to the reference and floating elements for a
- * given floating element `role`.
- * @see https://floating-ui.com/docs/useRole
- */
-const useRole = function (context, props) {
-  if (props === void 0) {
-    props = {};
-  }
-  const {
-    open,
-    floatingId
-  } = context;
-  const {
-    enabled = true,
-    role = 'dialog'
-  } = props;
-  const referenceId = useId();
-  return React__namespace.useMemo(() => {
-    const floatingProps = {
-      id: floatingId,
-      role
-    };
-    if (!enabled) {
-      return {};
-    }
-    if (role === 'tooltip') {
-      return {
-        reference: {
-          'aria-describedby': open ? floatingId : undefined
-        },
-        floating: floatingProps
-      };
-    }
-    return {
-      reference: {
-        'aria-expanded': open ? 'true' : 'false',
-        'aria-haspopup': role === 'alertdialog' ? 'dialog' : role,
-        'aria-controls': open ? floatingId : undefined,
-        ...(role === 'listbox' && {
-          role: 'combobox'
-        }),
-        ...(role === 'menu' && {
-          id: referenceId
-        })
-      },
-      floating: {
-        ...floatingProps,
-        ...(role === 'menu' && {
-          'aria-labelledby': referenceId
-        })
-      }
-    };
-  }, [enabled, role, open, floatingId, referenceId]);
-};
+let devMessageSet;
+if (process.env.NODE_ENV !== "production") {
+  devMessageSet = /*#__PURE__*/new Set();
+}
 
 /**
  * Provides data to position a floating element and context to add interactions.
  * @see https://floating-ui.com/docs/react
  */
 function useFloating(options) {
+  var _options$elements2;
   if (options === void 0) {
     options = {};
   }
@@ -18515,13 +18505,32 @@ function useFloating(options) {
     onOpenChange: unstable_onOpenChange,
     nodeId
   } = options;
+  if (process.env.NODE_ENV !== "production") {
+    var _options$elements;
+    const err = 'Floating UI: Cannot pass a virtual element to the ' + '`elements.reference` option, as it must be a real DOM element. ' + 'Use `refs.setPositionReference` instead.';
+    if ((_options$elements = options.elements) != null && _options$elements.reference && !isElement(options.elements.reference)) {
+      var _devMessageSet;
+      if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(err))) {
+        var _devMessageSet2;
+        (_devMessageSet2 = devMessageSet) == null ? void 0 : _devMessageSet2.add(err);
+        console.error(err);
+      }
+    }
+  }
+  const [_domReference, setDomReference] = React__namespace.useState(null);
+  const domReference = ((_options$elements2 = options.elements) == null ? void 0 : _options$elements2.reference) || _domReference;
   const position = useFloating$1(options);
   const tree = useFloatingTree();
+  const onOpenChange = useEffectEvent((open, event) => {
+    if (open) {
+      dataRef.current.openEvent = event;
+    }
+    unstable_onOpenChange == null ? void 0 : unstable_onOpenChange(open, event);
+  });
   const domReferenceRef = React__namespace.useRef(null);
   const dataRef = React__namespace.useRef({});
   const events = React__namespace.useState(() => createPubSub())[0];
   const floatingId = useId();
-  const [domReference, setDomReference] = React__namespace.useState(null);
   const setPositionReference = React__namespace.useCallback(node => {
     const positionReference = isElement(node) ? {
       getBoundingClientRect: () => node.getBoundingClientRect(),
@@ -18555,7 +18564,6 @@ function useFloating(options) {
     ...position.elements,
     domReference: domReference
   }), [position.elements, domReference]);
-  const onOpenChange = useEvent(unstable_onOpenChange);
   const context = React__namespace.useMemo(() => ({
     ...position,
     refs,
@@ -18577,10 +18585,8 @@ function useFloating(options) {
     ...position,
     context,
     refs,
-    elements,
-    reference: setReference,
-    positionReference: setPositionReference
-  }), [position, refs, elements, context, setReference, setPositionReference]);
+    elements
+  }), [position, refs, elements, context]);
 }
 
 function mergeProps(userProps, propsList, elementKey) {
@@ -18619,7 +18625,14 @@ function mergeProps(userProps, propsList, elementKey) {
     }, {})
   };
 }
-const useInteractions = function (propsList) {
+
+/**
+ * Merges an array of interaction hooks' props into prop getters, allowing
+ * event handler functions to be composed together without overwriting one
+ * another.
+ * @see https://floating-ui.com/docs/react#interaction-hooks
+ */
+function useInteractions(propsList) {
   if (propsList === void 0) {
     propsList = [];
   }
@@ -18644,7 +18657,63 @@ const useInteractions = function (propsList) {
     getFloatingProps,
     getItemProps
   }), [getReferenceProps, getFloatingProps, getItemProps]);
-};
+}
+
+/**
+ * Adds base screen reader props to the reference and floating elements for a
+ * given floating element `role`.
+ * @see https://floating-ui.com/docs/useRole
+ */
+function useRole(context, props) {
+  if (props === void 0) {
+    props = {};
+  }
+  const {
+    open,
+    floatingId
+  } = context;
+  const {
+    enabled = true,
+    role = 'dialog'
+  } = props;
+  const referenceId = useId();
+  return React__namespace.useMemo(() => {
+    const floatingProps = {
+      id: floatingId,
+      role
+    };
+    if (!enabled) {
+      return {};
+    }
+    if (role === 'tooltip') {
+      return {
+        reference: {
+          'aria-describedby': open ? floatingId : undefined
+        },
+        floating: floatingProps
+      };
+    }
+    return {
+      reference: {
+        'aria-expanded': open ? 'true' : 'false',
+        'aria-haspopup': role === 'alertdialog' ? 'dialog' : role,
+        'aria-controls': open ? floatingId : undefined,
+        ...(role === 'listbox' && {
+          role: 'combobox'
+        }),
+        ...(role === 'menu' && {
+          id: referenceId
+        })
+      },
+      floating: {
+        ...floatingProps,
+        ...(role === 'menu' && {
+          'aria-labelledby': referenceId
+        })
+      }
+    };
+  }, [enabled, role, open, floatingId, referenceId]);
+}
 
 /**
  * The hook that powers the Popover component.
@@ -36767,6 +36836,24 @@ const useIsFirstRender = () => {
     return renderRef.current;
 };
 
+/**
+ * Check if text is cut off.
+ *
+ * @param {HTMLElement| null} element The element to check.
+ * @returns {boolean} True if the text is cut off.
+ */
+const useIsTextCutOff = (element) => {
+    const [isTextCutOff, setIsTextCutOff] = React.useState(false);
+    React.useEffect(() => {
+        if (!element) {
+            setIsTextCutOff(false);
+            return;
+        }
+        setIsTextCutOff(element.offsetWidth < element.scrollWidth);
+    }, [element]);
+    return isTextCutOff;
+};
+
 /**
  * Custom hook to handle window resize events and provide the current window size.
  *
@@ -39164,6 +39251,7 @@ exports.useDebounce = useDebounce;
 exports.useDevicePixelRatio = useDevicePixelRatio;
 exports.useHover = useHover;
 exports.useIsFirstRender = useIsFirstRender;
+exports.useIsTextCutOff = useIsTextCutOff;
 exports.useLocalStorage = useLocalStorage;
 exports.useLocalStorageReducer = useLocalStorageReducer;
 exports.useModal = useModal;