@banyan_cloud/roots 2.0.4 → 2.0.6

package/dist/esm/node_modules/@floating-ui/react-dom-interactions/dist/floating-ui.react-dom-interactions.esm.js

@@ -0,0 +1,2183 @@
+import { useFloating as useFloating$1 } from '../../react-dom/dist/floating-ui.react-dom.esm.js';
+export { arrow } from '../../react-dom/dist/floating-ui.react-dom.esm.js';
+import * as React from 'react';
+import { useLayoutEffect, useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
+import { hideOthers } from '../../../aria-hidden/dist/es2015/index.js';
+import { getOverflowAncestors } from '../../utils/dist/floating-ui.utils.dom.js';
+
+var index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;
+
+function createPubSub() {
+  const map = new Map();
+  return {
+    emit(event, data) {
+      var _map$get;
+
+      (_map$get = map.get(event)) == null ? void 0 : _map$get.forEach(handler => handler(data));
+    },
+
+    on(event, listener) {
+      map.set(event, [...(map.get(event) || []), listener]);
+    },
+
+    off(event, listener) {
+      map.set(event, (map.get(event) || []).filter(l => l !== listener));
+    }
+
+  };
+}
+
+let serverHandoffComplete = false;
+let count = 0;
+
+const genId = () => "floating-ui-" + count++;
+
+function useFloatingId() {
+  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : undefined);
+  index(() => {
+    if (id == null) {
+      setId(genId());
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, []);
+  React.useEffect(() => {
+    if (!serverHandoffComplete) {
+      serverHandoffComplete = true;
+    }
+  }, []);
+  return id;
+} // `toString()` prevents bundlers from trying to `import { useId } from 'react'`
+
+
+const useReactId = React[/*#__PURE__*/'useId'.toString()];
+/**
+ * Uses React 18's built-in `useId()` when available, or falls back to a
+ * slightly less performant (requiring a double render) implementation for
+ * earlier React versions.
+ * @see https://floating-ui.com/docs/useId
+ */
+
+const useId = useReactId != null ? useReactId : useFloatingId;
+
+const FloatingNodeContext = /*#__PURE__*/React.createContext(null);
+const FloatingTreeContext = /*#__PURE__*/React.createContext(null);
+const useFloatingParentNodeId = () => {
+  var _React$useContext$id, _React$useContext;
+
+  return (_React$useContext$id = (_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) != null ? _React$useContext$id : null;
+};
+const useFloatingTree = () => React.useContext(FloatingTreeContext);
+
+function getDocument(floating) {
+  var _floating$ownerDocume;
+
+  return (_floating$ownerDocume = floating == null ? void 0 : floating.ownerDocument) != null ? _floating$ownerDocume : document;
+}
+
+function getWindow(value) {
+  var _getDocument$defaultV;
+
+  return (_getDocument$defaultV = getDocument(value).defaultView) != null ? _getDocument$defaultV : window;
+}
+
+function isElement(value) {
+  return value ? value instanceof getWindow(value).Element : false;
+}
+function isHTMLElement(value) {
+  return value ? value instanceof getWindow(value).HTMLElement : false;
+}
+
+// `toString()` prevents bundlers from trying to `import { useInsertionEffect } from 'react'`
+const useInsertionEffect = React[/*#__PURE__*/'useInsertionEffect'.toString()];
+function useEvent(callback) {
+  const ref = React.useRef(() => {
+    if (process.env.NODE_ENV !== "production") {
+      throw new Error('Cannot call an event handler while rendering.');
+    }
+  });
+
+  if (useInsertionEffect) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useInsertionEffect(() => {
+      ref.current = callback;
+    });
+  } else {
+    ref.current = callback;
+  }
+
+  return React.useCallback(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return ref.current == null ? void 0 : ref.current(...args);
+  }, []);
+}
+
+function useFloating(_temp) {
+  let {
+    open = false,
+    onOpenChange: unstable_onOpenChange,
+    whileElementsMounted,
+    placement,
+    middleware,
+    strategy,
+    nodeId
+  } = _temp === void 0 ? {} : _temp;
+  const [domReference, setDomReference] = React.useState(null);
+  const tree = useFloatingTree();
+  const domReferenceRef = React.useRef(null);
+  const dataRef = React.useRef({});
+  const events = React.useState(() => createPubSub())[0];
+  const position = useFloating$1({
+    placement,
+    middleware,
+    strategy,
+    whileElementsMounted
+  });
+  const onOpenChange = useEvent(unstable_onOpenChange);
+  const refs = React.useMemo(() => ({ ...position.refs,
+    domReference: domReferenceRef
+  }), [position.refs]);
+  const context = React.useMemo(() => ({ ...position,
+    refs,
+    dataRef,
+    nodeId,
+    events,
+    open,
+    onOpenChange,
+    _: {
+      domReference
+    }
+  }), [position, nodeId, events, open, onOpenChange, refs, domReference]);
+  index(() => {
+    const node = tree == null ? void 0 : tree.nodesRef.current.find(node => node.id === nodeId);
+
+    if (node) {
+      node.context = context;
+    }
+  });
+  const {
+    reference
+  } = position;
+  const setReference = React.useCallback(node => {
+    if (isElement(node) || node === null) {
+      context.refs.domReference.current = node;
+      setDomReference(node);
+    }
+
+    reference(node);
+  }, [reference, context.refs]);
+  return React.useMemo(() => ({ ...position,
+    context,
+    refs,
+    reference: setReference
+  }), [position, refs, context, setReference]);
+}
+
+function mergeProps(userProps, propsList, elementKey) {
+  const map = new Map();
+  return { ...(elementKey === 'floating' && {
+      tabIndex: -1
+    }),
+    ...userProps,
+    ...propsList.map(value => value ? value[elementKey] : null).concat(userProps).reduce((acc, props) => {
+      if (!props) {
+        return acc;
+      }
+
+      Object.entries(props).forEach(_ref => {
+        let [key, value] = _ref;
+
+        if (key.indexOf('on') === 0) {
+          if (!map.has(key)) {
+            map.set(key, []);
+          }
+
+          if (typeof value === 'function') {
+            var _map$get;
+
+            (_map$get = map.get(key)) == null ? void 0 : _map$get.push(value);
+
+            acc[key] = function () {
+              var _map$get2;
+
+              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+              }
+
+              (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.forEach(fn => fn(...args));
+            };
+          }
+        } else {
+          acc[key] = value;
+        }
+      });
+      return acc;
+    }, {})
+  };
+}
+
+const useInteractions = function (propsList) {
+  if (propsList === void 0) {
+    propsList = [];
+  }
+
+  // The dependencies are a dynamic array, so we can't use the linter's
+  // suggestion to add it to the deps array.
+  const deps = propsList;
+  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'), // eslint-disable-next-line react-hooks/exhaustive-deps
+  deps);
+  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'), // eslint-disable-next-line react-hooks/exhaustive-deps
+  deps);
+  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'), // eslint-disable-next-line react-hooks/exhaustive-deps
+  deps);
+  return React.useMemo(() => ({
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps
+  }), [getReferenceProps, getFloatingProps, getItemProps]);
+};
+
+function getChildren(nodes, id) {
+  var _nodes$filter;
+
+  let allChildren = (_nodes$filter = nodes.filter(node => {
+    var _node$context;
+
+    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);
+  })) != null ? _nodes$filter : [];
+  let currentChildren = allChildren;
+
+  while (currentChildren.length) {
+    var _nodes$filter2;
+
+    currentChildren = (_nodes$filter2 = nodes.filter(node => {
+      var _currentChildren;
+
+      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(n => {
+        var _node$context2;
+
+        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);
+      });
+    })) != null ? _nodes$filter2 : [];
+    allChildren = allChildren.concat(currentChildren);
+  }
+
+  return allChildren;
+}
+
+const DEFAULT_ID = 'floating-ui-root';
+const useFloatingPortalNode = function (_temp) {
+  let {
+    id = DEFAULT_ID,
+    enabled = true
+  } = _temp === void 0 ? {} : _temp;
+  const [portalEl, setPortalEl] = React.useState(null);
+  index(() => {
+    if (!enabled) {
+      return;
+    }
+
+    const rootNode = document.getElementById(id);
+
+    if (rootNode) {
+      setPortalEl(rootNode);
+    } else {
+      const newPortalEl = document.createElement('div');
+      newPortalEl.id = id;
+      setPortalEl(newPortalEl);
+
+      if (!document.body.contains(newPortalEl)) {
+        document.body.appendChild(newPortalEl);
+      }
+    }
+  }, [id, enabled]);
+  return portalEl;
+};
+/**
+ * Portals your floating element outside of the main app node.
+ * @see https://floating-ui.com/docs/FloatingPortal
+ */
+
+const FloatingPortal = _ref => {
+  let {
+    children,
+    id = DEFAULT_ID,
+    root = null
+  } = _ref;
+  const portalNode = useFloatingPortalNode({
+    id,
+    enabled: !root
+  });
+
+  if (root) {
+    return /*#__PURE__*/createPortal(children, root);
+  }
+
+  if (portalNode) {
+    return /*#__PURE__*/createPortal(children, portalNode);
+  }
+
+  return null;
+};
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+// Avoid Chrome DevTools blue warning
+function getPlatform() {
+  const uaData = navigator.userAgentData;
+
+  if (uaData != null && uaData.platform) {
+    return uaData.platform;
+  }
+
+  return navigator.platform;
+}
+
+const identifier = 'data-floating-ui-scroll-lock';
+/**
+ * Provides base styling for a fixed overlay element to dim content or block
+ * pointer events behind a floating element.
+ * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.
+ * @see https://floating-ui.com/docs/FloatingOverlay
+ */
+
+const FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(_ref, ref) {
+  let {
+    lockScroll = false,
+    ...rest
+  } = _ref;
+  index(() => {
+    var _window$visualViewpor, _window$visualViewpor2, _window$visualViewpor3, _window$visualViewpor4;
+
+    if (!lockScroll) {
+      return;
+    }
+
+    const alreadyLocked = document.body.hasAttribute(identifier);
+
+    if (alreadyLocked) {
+      return;
+    }
+
+    document.body.setAttribute(identifier, ''); // RTL <body> scrollbar
+
+    const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;
+    const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';
+    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth; // Only iOS doesn't respect `overflow: hidden` on document.body, and this
+    // technique has fewer side effects.
+
+    if (!/iP(hone|ad|od)|iOS/.test(getPlatform())) {
+      Object.assign(document.body.style, {
+        overflow: 'hidden',
+        [paddingProp]: scrollbarWidth + "px"
+      });
+      return () => {
+        document.body.removeAttribute(identifier);
+        Object.assign(document.body.style, {
+          overflow: '',
+          [paddingProp]: ''
+        });
+      };
+    } // iOS 12 does not support `visuaViewport`.
+
+
+    const offsetLeft = (_window$visualViewpor = (_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetLeft) != null ? _window$visualViewpor : 0;
+    const offsetTop = (_window$visualViewpor3 = (_window$visualViewpor4 = window.visualViewport) == null ? void 0 : _window$visualViewpor4.offsetTop) != null ? _window$visualViewpor3 : 0;
+    const scrollX = window.pageXOffset;
+    const scrollY = window.pageYOffset;
+    Object.assign(document.body.style, {
+      position: 'fixed',
+      overflow: 'hidden',
+      top: -(scrollY - Math.floor(offsetTop)) + "px",
+      left: -(scrollX - Math.floor(offsetLeft)) + "px",
+      right: '0',
+      [paddingProp]: scrollbarWidth + "px"
+    });
+    return () => {
+      Object.assign(document.body.style, {
+        position: '',
+        overflow: '',
+        top: '',
+        left: '',
+        right: '',
+        [paddingProp]: ''
+      });
+      document.body.removeAttribute(identifier);
+      window.scrollTo(scrollX, scrollY);
+    };
+  }, [lockScroll]);
+  return /*#__PURE__*/React.createElement("div", _extends({
+    ref: ref
+  }, rest, {
+    style: {
+      position: 'fixed',
+      overflow: 'auto',
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...rest.style
+    }
+  }));
+});
+
+/**
+ * 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;
+}
+
+function getAncestors(nodes, id) {
+  var _nodes$find;
+
+  let allAncestors = [];
+  let currentParentId = (_nodes$find = nodes.find(node => node.id === id)) == null ? void 0 : _nodes$find.parentId;
+
+  while (currentParentId) {
+    const currentNode = nodes.find(node => node.id === currentParentId);
+    currentParentId = currentNode == null ? void 0 : currentNode.parentId;
+
+    if (currentNode) {
+      allAncestors = allAncestors.concat(currentNode);
+    }
+  }
+
+  return allAncestors;
+}
+
+function 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 useLatestRef(value) {
+  const ref = useRef(value);
+  index(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+
+function focus(el, preventScroll) {
+  if (preventScroll === void 0) {
+    preventScroll = false;
+  }
+
+  // `mousedown` clicks occur before `focus`, so the button will steal the
+  // focus unless we wait a frame.
+  requestAnimationFrame(() => {
+    el == null ? void 0 : el.focus({
+      preventScroll
+    });
+  });
+}
+
+const SELECTOR = 'select:not([disabled]),a[href],button:not([disabled]),[tabindex],' + 'iframe,object,embed,area[href],audio[controls],video[controls],' + TYPEABLE_SELECTOR;
+const FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {
+  return /*#__PURE__*/React.createElement("span", _extends({}, props, {
+    ref: ref,
+    tabIndex: 0,
+    style: {
+      position: 'fixed',
+      opacity: '0',
+      pointerEvents: 'none',
+      outline: '0'
+    }
+  }));
+});
+
+/**
+ * Provides focus management for the floating element.
+ * @see https://floating-ui.com/docs/FloatingFocusManager
+ */
+function FloatingFocusManager(_ref) {
+  let {
+    context: {
+      refs,
+      nodeId,
+      onOpenChange,
+      dataRef,
+      events
+    },
+    children,
+    order = ['content'],
+    endGuard = true,
+    initialFocus = 0,
+    returnFocus = true,
+    modal = true
+  } = _ref;
+  const orderRef = useLatestRef(order);
+  const tree = useFloatingTree();
+  const getTabbableElements = React.useCallback(() => {
+    return orderRef.current.map(type => {
+      if (type === 'reference') {
+        return refs.domReference.current;
+      }
+
+      if (refs.floating.current && type === 'floating') {
+        return refs.floating.current;
+      }
+
+      if (type === 'content') {
+        var _refs$floating$curren, _refs$floating$curren2;
+
+        return Array.from((_refs$floating$curren = (_refs$floating$curren2 = refs.floating.current) == null ? void 0 : _refs$floating$curren2.querySelectorAll(SELECTOR)) != null ? _refs$floating$curren : []);
+      }
+
+      return null;
+    }).flat().filter(el => {
+      if (el === refs.floating.current || el === refs.domReference.current) {
+        return true;
+      }
+
+      if (isHTMLElement(el)) {
+        var _el$getAttribute;
+
+        const tabIndex = (_el$getAttribute = el.getAttribute('tabindex')) != null ? _el$getAttribute : '0';
+        return tabIndex[0].trim() !== '-';
+      }
+    });
+  }, [orderRef, refs]);
+  React.useEffect(() => {
+    if (!modal) {
+      return;
+    } // If the floating element has no focusable elements inside it, fallback
+    // to focusing the floating element and preventing tab navigation
+
+
+    const noTabbableContentElements = getTabbableElements().filter(el => el !== refs.floating.current && el !== refs.domReference.current).length === 0;
+
+    function onKeyDown(event) {
+      if (event.key === 'Tab') {
+        if (noTabbableContentElements) {
+          stopEvent(event);
+        }
+
+        const els = getTabbableElements();
+        const target = getTarget(event);
+
+        if (orderRef.current[0] === 'reference' && target === refs.domReference.current) {
+          stopEvent(event);
+
+          if (event.shiftKey) {
+            focus(els[els.length - 1]);
+          } else {
+            focus(els[1]);
+          }
+        }
+
+        if (orderRef.current[1] === 'floating' && target === refs.floating.current && event.shiftKey) {
+          stopEvent(event);
+          focus(els[0]);
+        }
+      }
+    }
+
+    const doc = getDocument(refs.floating.current);
+    doc.addEventListener('keydown', onKeyDown);
+    return () => {
+      doc.removeEventListener('keydown', onKeyDown);
+    };
+  }, [modal, getTabbableElements, orderRef, refs]);
+  React.useEffect(() => {
+    let isPointerDown = false;
+
+    function onFocusOut(event) {
+      var _refs$floating$curren3, _getAncestors;
+
+      const relatedTarget = event.relatedTarget;
+      const focusMovedOutsideFloating = !((_refs$floating$curren3 = refs.floating.current) != null && _refs$floating$curren3.contains(relatedTarget));
+      const focusMovedOutsideReference = isElement(refs.domReference.current) && !refs.domReference.current.contains(relatedTarget);
+      const isChildOpen = tree && getChildren(tree.nodesRef.current, nodeId).length > 0;
+      const isParentRelated = tree && event.currentTarget === refs.domReference.current && ((_getAncestors = getAncestors(tree.nodesRef.current, nodeId)) == null ? void 0 : _getAncestors.some(node => {
+        var _node$context, _node$context$refs$fl;
+
+        return (_node$context = node.context) == null ? void 0 : (_node$context$refs$fl = _node$context.refs.floating.current) == null ? void 0 : _node$context$refs$fl.contains(relatedTarget);
+      }));
+
+      if (focusMovedOutsideFloating && focusMovedOutsideReference && !isChildOpen && !isParentRelated && !isPointerDown) {
+        onOpenChange(false);
+      }
+    }
+
+    function onPointerDown() {
+      // In Safari, buttons *lose* focus when pressing them. This causes the
+      // reference `focusout` to fire, which closes the floating element.
+      isPointerDown = true;
+      setTimeout(() => {
+        isPointerDown = false;
+      });
+    }
+
+    const floating = refs.floating.current;
+    const reference = refs.domReference.current;
+
+    if (floating && isHTMLElement(reference)) {
+      if (!modal) {
+        floating.addEventListener('focusout', onFocusOut);
+        reference.addEventListener('focusout', onFocusOut);
+        reference.addEventListener('pointerdown', onPointerDown);
+      }
+
+      let cleanup;
+
+      if (modal) {
+        if (orderRef.current.includes('reference')) {
+          cleanup = hideOthers([reference, floating]);
+        } else {
+          cleanup = hideOthers(floating);
+        }
+      }
+
+      return () => {
+        if (!modal) {
+          floating.removeEventListener('focusout', onFocusOut);
+          reference.removeEventListener('focusout', onFocusOut);
+          reference.removeEventListener('pointerdown', onPointerDown);
+        }
+
+        cleanup == null ? void 0 : cleanup();
+      };
+    }
+  }, [nodeId, tree, modal, onOpenChange, orderRef, dataRef, getTabbableElements, refs]);
+  React.useEffect(() => {
+    const floating = refs.floating.current;
+    const doc = getDocument(floating);
+    let returnFocusValue = returnFocus;
+    let preventReturnFocusScroll = false;
+    let previouslyFocusedElement = activeElement(doc);
+
+    if (previouslyFocusedElement === doc.body && refs.domReference.current) {
+      previouslyFocusedElement = refs.domReference.current;
+    }
+
+    if (typeof initialFocus === 'number') {
+      var _getTabbableElements$;
+
+      const el = (_getTabbableElements$ = getTabbableElements()[initialFocus]) != null ? _getTabbableElements$ : floating;
+      focus(el, el === floating);
+    } else if (isHTMLElement(initialFocus.current)) {
+      var _initialFocus$current;
+
+      const el = (_initialFocus$current = initialFocus.current) != null ? _initialFocus$current : floating;
+      focus(el, el === floating);
+    } // Dismissing via outside press should always ignore `returnFocus` to
+    // prevent unwanted scrolling.
+
+
+    function onDismiss(allowReturnFocus) {
+      if (allowReturnFocus === void 0) {
+        allowReturnFocus = false;
+      }
+
+      if (typeof allowReturnFocus === 'object') {
+        returnFocusValue = true;
+        preventReturnFocusScroll = allowReturnFocus.preventScroll;
+      } else {
+        returnFocusValue = allowReturnFocus;
+      }
+    }
+
+    events.on('dismiss', onDismiss);
+    return () => {
+      events.off('dismiss', onDismiss);
+
+      if (returnFocusValue && isHTMLElement(previouslyFocusedElement)) {
+        focus(previouslyFocusedElement, preventReturnFocusScroll);
+      }
+    };
+  }, [getTabbableElements, initialFocus, returnFocus, refs, events]);
+
+  const isTypeableCombobox = () => {
+    var _refs$domReference$cu;
+
+    return ((_refs$domReference$cu = refs.domReference.current) == null ? void 0 : _refs$domReference$cu.getAttribute('role')) === 'combobox' && isTypeableElement(refs.domReference.current);
+  };
+
+  return /*#__PURE__*/React.createElement(React.Fragment, null, modal && /*#__PURE__*/React.createElement(FocusGuard, {
+    onFocus: event => {
+      if (isTypeableCombobox()) {
+        return;
+      }
+
+      stopEvent(event);
+      const els = getTabbableElements();
+
+      if (order[0] === 'reference') {
+        focus(els[0]);
+      } else {
+        focus(els[els.length - 1]);
+      }
+    }
+  }), /*#__PURE__*/React.cloneElement(children, order.includes('floating') ? {
+    tabIndex: 0
+  } : {}), modal && endGuard && /*#__PURE__*/React.createElement(FocusGuard, {
+    onFocus: event => {
+      if (isTypeableCombobox()) {
+        return;
+      }
+
+      stopEvent(event);
+      focus(getTabbableElements()[0]);
+    }
+  }));
+}
+
+function usePrevious(value) {
+  const ref = useRef();
+  index(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+function getDelay(value, prop, pointerType) {
+  if (pointerType && pointerType !== 'mouse') {
+    return 0;
+  }
+
+  if (typeof value === 'number') {
+    return value;
+  }
+
+  return value == null ? void 0 : value[prop];
+}
+
+/**
+ * Adds hover event listeners that change the open state, like CSS :hover.
+ * @see https://floating-ui.com/docs/useHover
+ */
+const useHover = function (context, _temp) {
+  let {
+    enabled = true,
+    delay = 0,
+    handleClose = null,
+    mouseOnly = false,
+    restMs = 0,
+    move = true
+  } = _temp === void 0 ? {} : _temp;
+  const {
+    open,
+    onOpenChange,
+    dataRef,
+    events,
+    refs,
+    _
+  } = context;
+  const tree = useFloatingTree();
+  const parentId = useFloatingParentNodeId();
+  const handleCloseRef = useLatestRef(handleClose);
+  const delayRef = useLatestRef(delay);
+  const previousOpen = usePrevious(open);
+  const pointerTypeRef = React.useRef();
+  const timeoutRef = React.useRef();
+  const handlerRef = React.useRef();
+  const restTimeoutRef = React.useRef();
+  const blockMouseMoveRef = React.useRef(true);
+  const performedPointerEventsMutationRef = React.useRef(false);
+  const isHoverOpen = React.useCallback(() => {
+    var _dataRef$current$open;
+
+    const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;
+    return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';
+  }, [dataRef]);
+  React.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    function onDismiss() {
+      clearTimeout(timeoutRef.current);
+      clearTimeout(restTimeoutRef.current);
+      blockMouseMoveRef.current = true;
+    }
+
+    events.on('dismiss', onDismiss);
+    return () => {
+      events.off('dismiss', onDismiss);
+    };
+  }, [enabled, events, refs]);
+  React.useEffect(() => {
+    if (!enabled || !handleCloseRef.current) {
+      return;
+    }
+
+    function onLeave() {
+      if (isHoverOpen()) {
+        onOpenChange(false);
+      }
+    }
+
+    const html = getDocument(refs.floating.current).documentElement;
+    html.addEventListener('mouseleave', onLeave);
+    return () => {
+      html.removeEventListener('mouseleave', onLeave);
+    };
+  }, [refs, onOpenChange, enabled, handleCloseRef, dataRef, isHoverOpen]);
+  const closeWithDelay = React.useCallback(function (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);
+    } else if (runElseBranch) {
+      clearTimeout(timeoutRef.current);
+      onOpenChange(false);
+    }
+  }, [delayRef, onOpenChange]);
+  const cleanupPointerMoveHandler = React.useCallback(() => {
+    if (handlerRef.current) {
+      getDocument(refs.floating.current).removeEventListener('pointermove', handlerRef.current);
+      handlerRef.current = undefined;
+    }
+  }, [refs]);
+  const clearPointerEvents = React.useCallback(() => {
+    getDocument(refs.floating.current).body.style.pointerEvents = '';
+    performedPointerEventsMutationRef.current = false;
+  }, [refs]); // Registering the mouse events on the reference directly to bypass React's
+  // delegation system. If the cursor was on a disabled element and then entered
+  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.
+
+  React.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    function isClickLikeOpenEvent() {
+      return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;
+    }
+
+    function onMouseEnter(event) {
+      clearTimeout(timeoutRef.current);
+      blockMouseMoveRef.current = false;
+
+      if (mouseOnly && pointerTypeRef.current !== 'mouse' || 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);
+        }, openDelay);
+      } else {
+        onOpenChange(true);
+      }
+    }
+
+    function onMouseLeave(event) {
+      if (isClickLikeOpenEvent()) {
+        return;
+      }
+
+      const doc = getDocument(refs.floating.current);
+      clearTimeout(restTimeoutRef.current);
+
+      if (handleCloseRef.current) {
+        clearTimeout(timeoutRef.current);
+        handlerRef.current && doc.removeEventListener('pointermove', handlerRef.current);
+        handlerRef.current = handleCloseRef.current({ ...context,
+          tree,
+          x: event.clientX,
+          y: event.clientY,
+
+          onClose() {
+            clearPointerEvents();
+            cleanupPointerMoveHandler();
+            closeWithDelay();
+          }
+
+        });
+        doc.addEventListener('pointermove', handlerRef.current);
+        return;
+      }
+
+      closeWithDelay();
+    } // Ensure the floating element closes after scrolling even if the pointer
+    // did not move.
+    // https://github.com/floating-ui/floating-ui/discussions/1692
+
+
+    function onScrollMouseLeave(event) {
+      if (isClickLikeOpenEvent()) {
+        return;
+      }
+
+      handleCloseRef.current == null ? void 0 : handleCloseRef.current({ ...context,
+        tree,
+        x: event.clientX,
+        y: event.clientY,
+        leave: true,
+
+        onClose() {
+          clearPointerEvents();
+          cleanupPointerMoveHandler();
+          closeWithDelay();
+        }
+
+      })(event);
+    }
+
+    const floating = refs.floating.current;
+    const reference = refs.domReference.current;
+
+    if (isElement(reference)) {
+      open && reference.addEventListener('mouseleave', onScrollMouseLeave);
+      floating == null ? void 0 : floating.addEventListener('mouseleave', onScrollMouseLeave);
+      move && reference.addEventListener('mousemove', onMouseEnter, {
+        once: true
+      });
+      reference.addEventListener('mouseenter', onMouseEnter);
+      reference.addEventListener('mouseleave', onMouseLeave);
+      return () => {
+        open && reference.removeEventListener('mouseleave', onScrollMouseLeave);
+        floating == null ? void 0 : floating.removeEventListener('mouseleave', onScrollMouseLeave);
+        move && reference.removeEventListener('mousemove', onMouseEnter);
+        reference.removeEventListener('mouseenter', onMouseEnter);
+        reference.removeEventListener('mouseleave', onMouseLeave);
+      };
+    }
+  }, [// Ensure the effect is re-run when the reference changes.
+  // https://github.com/floating-ui/floating-ui/issues/1833
+  _.domReference, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupPointerMoveHandler, clearPointerEvents, onOpenChange, open, tree, refs, delayRef, handleCloseRef, dataRef]); // Block pointer-events of every element other than the reference and floating
+  // while the floating element is open and has a `handleClose` handler. Also
+  // handles nested floating elements.
+  // https://github.com/floating-ui/floating-ui/issues/1722
+
+  index(() => {
+    if (!enabled) {
+      return;
+    }
+
+    if (open && handleCloseRef.current && handleCloseRef.current.__options.blockPointerEvents && isHoverOpen()) {
+      getDocument(refs.floating.current).body.style.pointerEvents = 'none';
+      performedPointerEventsMutationRef.current = true;
+      const reference = refs.domReference.current;
+      const floating = refs.floating.current;
+
+      if (isElement(reference) && floating) {
+        var _tree$nodesRef$curren, _tree$nodesRef$curren2;
+
+        const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.refs.floating.current;
+
+        if (parentFloating) {
+          parentFloating.style.pointerEvents = '';
+        }
+
+        reference.style.pointerEvents = 'auto';
+        floating.style.pointerEvents = 'auto';
+        return () => {
+          reference.style.pointerEvents = '';
+          floating.style.pointerEvents = '';
+        };
+      }
+    }
+  }, [enabled, open, parentId, refs, tree, handleCloseRef, dataRef, isHoverOpen]);
+  index(() => {
+    if (previousOpen && !open) {
+      pointerTypeRef.current = undefined;
+      cleanupPointerMoveHandler();
+      clearPointerEvents();
+    }
+  });
+  React.useEffect(() => {
+    return () => {
+      cleanupPointerMoveHandler();
+      clearTimeout(timeoutRef.current);
+      clearTimeout(restTimeoutRef.current);
+
+      if (performedPointerEventsMutationRef.current) {
+        clearPointerEvents();
+      }
+    };
+  }, [enabled, cleanupPointerMoveHandler, clearPointerEvents]);
+  return React.useMemo(() => {
+    if (!enabled) {
+      return {};
+    }
+
+    function setPointerRef(event) {
+      pointerTypeRef.current = event.pointerType;
+    }
+
+    return {
+      reference: {
+        onPointerDown: setPointerRef,
+        onPointerEnter: setPointerRef,
+
+        onMouseMove() {
+          if (open || restMs === 0) {
+            return;
+          }
+
+          clearTimeout(restTimeoutRef.current);
+          restTimeoutRef.current = setTimeout(() => {
+            if (!blockMouseMoveRef.current) {
+              onOpenChange(true);
+            }
+          }, restMs);
+        }
+
+      },
+      floating: {
+        onMouseEnter() {
+          clearTimeout(timeoutRef.current);
+        },
+
+        onMouseLeave() {
+          closeWithDelay(false);
+        }
+
+      }
+    };
+  }, [enabled, restMs, open, onOpenChange, closeWithDelay]);
+};
+
+/**
+ * Adds relevant screen reader props for a given element `role`.
+ * @see https://floating-ui.com/docs/useRole
+ */
+const useRole = function (_ref, _temp) {
+  let {
+    open
+  } = _ref;
+  let {
+    enabled = true,
+    role = 'dialog'
+  } = _temp === void 0 ? {} : _temp;
+  const rootId = useId();
+  const referenceId = useId();
+  return React.useMemo(() => {
+    const floatingProps = {
+      id: rootId,
+      role
+    };
+
+    if (!enabled) {
+      return {};
+    }
+
+    if (role === 'tooltip') {
+      return {
+        reference: {
+          'aria-describedby': open ? rootId : undefined
+        },
+        floating: floatingProps
+      };
+    }
+
+    return {
+      reference: {
+        'aria-expanded': open ? 'true' : 'false',
+        'aria-haspopup': role === 'alertdialog' ? 'dialog' : role,
+        'aria-controls': open ? rootId : undefined,
+        ...(role === 'listbox' && {
+          role: 'combobox'
+        }),
+        ...(role === 'menu' && {
+          id: referenceId
+        })
+      },
+      floating: { ...floatingProps,
+        ...(role === 'menu' && {
+          'aria-labelledby': referenceId
+        })
+      }
+    };
+  }, [enabled, role, open, rootId, referenceId]);
+};
+
+function isButtonTarget(event) {
+  return isHTMLElement(event.target) && event.target.tagName === 'BUTTON';
+}
+
+function isSpaceIgnored(element) {
+  return isTypeableElement(element);
+}
+
+/**
+ * Adds click event listeners that change the open state.
+ * @see https://floating-ui.com/docs/useClick
+ */
+const useClick = function (_ref, _temp) {
+  let {
+    open,
+    onOpenChange,
+    dataRef,
+    refs
+  } = _ref;
+  let {
+    enabled = true,
+    event: eventOption = 'click',
+    toggle = true,
+    ignoreMouse = false,
+    keyboardHandlers = true
+  } = _temp === void 0 ? {} : _temp;
+  const pointerTypeRef = React.useRef();
+  return React.useMemo(() => {
+    if (!enabled) {
+      return {};
+    }
+
+    return {
+      reference: {
+        onPointerDown(event) {
+          pointerTypeRef.current = event.pointerType;
+        },
+
+        onMouseDown(event) {
+          // Ignore all buttons except for the "main" button.
+          // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
+          if (event.button !== 0) {
+            return;
+          }
+
+          if (pointerTypeRef.current === 'mouse' && ignoreMouse) {
+            return;
+          }
+
+          if (eventOption === 'click') {
+            return;
+          }
+
+          if (open) {
+            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'mousedown' : true)) {
+              onOpenChange(false);
+            }
+          } else {
+            onOpenChange(true);
+          }
+
+          dataRef.current.openEvent = event.nativeEvent;
+        },
+
+        onClick(event) {
+          if (eventOption === 'mousedown' && pointerTypeRef.current) {
+            pointerTypeRef.current = undefined;
+            return;
+          }
+
+          if (pointerTypeRef.current === 'mouse' && ignoreMouse) {
+            return;
+          }
+
+          if (open) {
+            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'click' : true)) {
+              onOpenChange(false);
+            }
+          } else {
+            onOpenChange(true);
+          }
+
+          dataRef.current.openEvent = event.nativeEvent;
+        },
+
+        onKeyDown(event) {
+          pointerTypeRef.current = undefined;
+
+          if (!keyboardHandlers) {
+            return;
+          }
+
+          if (isButtonTarget(event)) {
+            return;
+          }
+
+          if (event.key === ' ' && !isSpaceIgnored(refs.domReference.current)) {
+            // Prvent scrolling
+            event.preventDefault();
+          }
+
+          if (event.key === 'Enter') {
+            if (open) {
+              if (toggle) {
+                onOpenChange(false);
+              }
+            } else {
+              onOpenChange(true);
+            }
+          }
+        },
+
+        onKeyUp(event) {
+          if (!keyboardHandlers) {
+            return;
+          }
+
+          if (isButtonTarget(event) || isSpaceIgnored(refs.domReference.current)) {
+            return;
+          }
+
+          if (event.key === ' ') {
+            if (open) {
+              if (toggle) {
+                onOpenChange(false);
+              }
+            } else {
+              onOpenChange(true);
+            }
+          }
+        }
+
+      }
+    };
+  }, [enabled, dataRef, eventOption, ignoreMouse, keyboardHandlers, refs, toggle, open, onOpenChange]);
+};
+
+/**
+ * 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',
+  click: 'onClick'
+};
+const captureHandlerKeys = {
+  pointerdown: 'onPointerDownCapture',
+  mousedown: 'onMouseDownCapture',
+  click: 'onClickCapture'
+};
+
+/**
+ * Adds listeners that dismiss (close) the floating element.
+ * @see https://floating-ui.com/docs/useDismiss
+ */
+const useDismiss = function (_ref, _temp) {
+  let {
+    open,
+    onOpenChange,
+    refs,
+    events,
+    nodeId
+  } = _ref;
+  let {
+    enabled = true,
+    escapeKey = true,
+    outsidePress = true,
+    outsidePressEvent = 'pointerdown',
+    referencePress = false,
+    referencePressEvent = 'pointerdown',
+    ancestorScroll = false,
+    bubbles = true
+  } = _temp === void 0 ? {} : _temp;
+  const tree = useFloatingTree();
+  const nested = useFloatingParentNodeId() != null;
+  const insideReactTreeRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!open || !enabled) {
+      return;
+    }
+
+    function onKeyDown(event) {
+      if (event.key === 'Escape') {
+        if (!bubbles && tree && getChildren(tree.nodesRef.current, nodeId).length > 0) {
+          return;
+        }
+
+        events.emit('dismiss', {
+          preventScroll: false
+        });
+        onOpenChange(false);
+      }
+    }
+
+    function onOutsidePress(event) {
+      // Given developers can stop the propagation of the synthetic event,
+      // we can only be confident with a positive value.
+      const insideReactTree = insideReactTreeRef.current;
+      insideReactTreeRef.current = false;
+
+      if (insideReactTree) {
+        return;
+      }
+
+      const target = getTarget(event); // Check if the click occurred on the scrollbar
+
+      if (isElement(target) && refs.floating.current) {
+        var _refs$floating$curren;
+
+        const win = (_refs$floating$curren = refs.floating.current.ownerDocument.defaultView) != null ? _refs$floating$curren : window;
+        const canScrollX = target.scrollWidth > target.clientWidth;
+        const canScrollY = target.scrollHeight > target.clientHeight;
+        let xCond = canScrollY && event.offsetX > target.clientWidth; // In some browsers it is possible to change the <body> (or window)
+        // scrollbar to the left side, but is very rare and is difficult to
+        // check for. Plus, for modal dialogs with backdrops, it is more
+        // important that the backdrop is checked but not so much the window.
+
+        if (canScrollY) {
+          const isRTL = win.getComputedStyle(target).direction === 'rtl';
+
+          if (isRTL) {
+            xCond = event.offsetX <= target.offsetWidth - target.clientWidth;
+          }
+        }
+
+        if (xCond || canScrollX && event.offsetY > target.clientHeight) {
+          return;
+        }
+      }
+
+      const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(node => {
+        var _node$context;
+
+        return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.refs.floating.current);
+      });
+
+      if (isEventTargetWithin(event, refs.floating.current) || isEventTargetWithin(event, refs.domReference.current) || targetIsInsideChildren) {
+        return;
+      }
+
+      if (!bubbles && tree && getChildren(tree.nodesRef.current, nodeId).length > 0) {
+        return;
+      }
+
+      events.emit('dismiss', nested ? {
+        preventScroll: true
+      } : false);
+      onOpenChange(false);
+    }
+
+    function onScroll() {
+      onOpenChange(false);
+    }
+
+    const doc = getDocument(refs.floating.current);
+    escapeKey && doc.addEventListener('keydown', onKeyDown);
+    outsidePress && doc.addEventListener(outsidePressEvent, onOutsidePress);
+    let ancestors = [];
+
+    if (ancestorScroll) {
+      if (isElement(refs.domReference.current)) {
+        ancestors = getOverflowAncestors(refs.domReference.current);
+      }
+
+      if (isElement(refs.floating.current)) {
+        ancestors = ancestors.concat(getOverflowAncestors(refs.floating.current));
+      }
+
+      if (!isElement(refs.reference.current) && refs.reference.current && // @ts-expect-error is VirtualElement
+      refs.reference.current.contextElement) {
+        ancestors = ancestors.concat( // @ts-expect-error is VirtualElement
+        getOverflowAncestors(refs.reference.current.contextElement));
+      }
+    } // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)
+
+
+    ancestors = ancestors.filter(ancestor => {
+      var _doc$defaultView;
+
+      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);
+    });
+    ancestors.forEach(ancestor => {
+      ancestor.addEventListener('scroll', onScroll, {
+        passive: true
+      });
+    });
+    return () => {
+      escapeKey && doc.removeEventListener('keydown', onKeyDown);
+      outsidePress && doc.removeEventListener(outsidePressEvent, onOutsidePress);
+      ancestors.forEach(ancestor => {
+        ancestor.removeEventListener('scroll', onScroll);
+      });
+    };
+  }, [escapeKey, outsidePress, outsidePressEvent, events, tree, nodeId, open, onOpenChange, ancestorScroll, enabled, bubbles, refs, nested]);
+  React.useEffect(() => {
+    insideReactTreeRef.current = false;
+  }, [outsidePress, outsidePressEvent]);
+  return React.useMemo(() => {
+    if (!enabled) {
+      return {};
+    }
+
+    return {
+      reference: {
+        [bubbleHandlerKeys[referencePressEvent]]: () => {
+          if (referencePress) {
+            events.emit('dismiss');
+            onOpenChange(false);
+          }
+        }
+      },
+      floating: {
+        [captureHandlerKeys[outsidePressEvent]]: () => {
+          insideReactTreeRef.current = true;
+        }
+      }
+    };
+  }, [enabled, events, referencePress, outsidePressEvent, referencePressEvent, onOpenChange]);
+};
+
+/**
+ * Adds focus event listeners that change the open state, like CSS :focus.
+ * @see https://floating-ui.com/docs/useFocus
+ */
+const useFocus = function (_ref, _temp) {
+  let {
+    open,
+    onOpenChange,
+    dataRef,
+    refs,
+    events
+  } = _ref;
+  let {
+    enabled = true,
+    keyboardOnly = true
+  } = _temp === void 0 ? {} : _temp;
+  const pointerTypeRef = React.useRef('');
+  const blockFocusRef = React.useRef(false);
+  const timeoutRef = React.useRef();
+  React.useEffect(() => {
+    var _doc$defaultView;
+
+    if (!enabled) {
+      return;
+    }
+
+    const doc = getDocument(refs.floating.current);
+    const win = (_doc$defaultView = doc.defaultView) != null ? _doc$defaultView : window;
+
+    function onBlur() {
+      if (!open && isHTMLElement(refs.domReference.current)) {
+        refs.domReference.current.blur();
+      }
+    }
+
+    win.addEventListener('blur', onBlur);
+    return () => {
+      win.removeEventListener('blur', onBlur);
+    };
+  }, [refs, open, enabled]);
+  React.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    function onDismiss() {
+      blockFocusRef.current = true;
+    }
+
+    events.on('dismiss', onDismiss);
+    return () => {
+      events.off('dismiss', onDismiss);
+    };
+  }, [events, enabled]);
+  React.useEffect(() => {
+    return () => {
+      clearTimeout(timeoutRef.current);
+    };
+  }, []);
+  return React.useMemo(() => {
+    if (!enabled) {
+      return {};
+    }
+
+    return {
+      reference: {
+        onPointerDown(_ref2) {
+          let {
+            pointerType
+          } = _ref2;
+          pointerTypeRef.current = pointerType;
+          blockFocusRef.current = !!(pointerType && keyboardOnly);
+        },
+
+        onPointerLeave() {
+          blockFocusRef.current = false;
+        },
+
+        onFocus(event) {
+          var _dataRef$current$open, _refs$domReference$cu, _dataRef$current$open2;
+
+          if (blockFocusRef.current) {
+            return;
+          } // Dismiss with click should ignore the subsequent `focus` trigger, but
+          // only if the click originated inside the reference element.
+
+
+          if (event.type === 'focus' && ((_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type) === 'mousedown' && (_refs$domReference$cu = refs.domReference.current) != null && _refs$domReference$cu.contains((_dataRef$current$open2 = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open2.target)) {
+            return;
+          }
+
+          dataRef.current.openEvent = event.nativeEvent;
+          onOpenChange(true);
+        },
+
+        onBlur(event) {
+          const target = event.relatedTarget; // Wait for the window blur listener to fire.
+
+          timeoutRef.current = setTimeout(() => {
+            var _refs$floating$curren, _refs$domReference$cu2;
+
+            // When focusing the reference element (e.g. regular click), then
+            // clicking into the floating element, prevent it from hiding.
+            // Note: it must be focusable, e.g. `tabindex="-1"`.
+            if ((_refs$floating$curren = refs.floating.current) != null && _refs$floating$curren.contains(target) || (_refs$domReference$cu2 = refs.domReference.current) != null && _refs$domReference$cu2.contains(target)) {
+              return;
+            }
+
+            blockFocusRef.current = false;
+            onOpenChange(false);
+          });
+        }
+
+      }
+    };
+  }, [enabled, keyboardOnly, refs, dataRef, onOpenChange]);
+};
+
+const ARROW_UP = 'ArrowUp';
+const ARROW_DOWN = 'ArrowDown';
+const ARROW_LEFT = 'ArrowLeft';
+const ARROW_RIGHT = 'ArrowRight';
+
+function isDifferentRow(index, cols, prevRow) {
+  return Math.floor(index / cols) !== prevRow;
+}
+
+function isIndexOutOfBounds(listRef, index) {
+  return index < 0 || index >= listRef.current.length;
+}
+
+function findNonDisabledIndex(listRef, _temp) {
+  let {
+    startingIndex = -1,
+    decrement = false,
+    disabledIndices,
+    amount = 1
+  } = _temp === void 0 ? {} : _temp;
+  const list = listRef.current;
+  let index = startingIndex;
+
+  do {
+    var _list$index, _list$index2;
+
+    index = index + (decrement ? -amount : amount);
+  } while (index >= 0 && index <= list.length - 1 && (disabledIndices ? disabledIndices.includes(index) : list[index] == null || ((_list$index = list[index]) == null ? void 0 : _list$index.hasAttribute('disabled')) || ((_list$index2 = list[index]) == null ? void 0 : _list$index2.getAttribute('aria-disabled')) === 'true'));
+
+  return index;
+}
+
+function doSwitch(orientation, vertical, horizontal) {
+  switch (orientation) {
+    case 'vertical':
+      return vertical;
+
+    case 'horizontal':
+      return horizontal;
+
+    default:
+      return vertical || horizontal;
+  }
+}
+
+function isMainOrientationKey(key, orientation) {
+  const vertical = key === ARROW_UP || key === ARROW_DOWN;
+  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;
+  return doSwitch(orientation, vertical, horizontal);
+}
+
+function isMainOrientationToEndKey(key, orientation, rtl) {
+  const vertical = key === ARROW_DOWN;
+  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;
+  return doSwitch(orientation, vertical, horizontal) || key === 'Enter' || key == ' ' || key === '';
+}
+
+function isCrossOrientationOpenKey(key, orientation, rtl) {
+  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;
+  const horizontal = key === ARROW_DOWN;
+  return doSwitch(orientation, vertical, horizontal);
+}
+
+function isCrossOrientationCloseKey(key, orientation, rtl) {
+  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;
+  const horizontal = key === ARROW_UP;
+  return doSwitch(orientation, vertical, horizontal);
+}
+
+function getMinIndex(listRef, disabledIndices) {
+  return findNonDisabledIndex(listRef, {
+    disabledIndices
+  });
+}
+
+function getMaxIndex(listRef, disabledIndices) {
+  return findNonDisabledIndex(listRef, {
+    decrement: true,
+    startingIndex: listRef.current.length,
+    disabledIndices
+  });
+}
+
+/**
+ * Adds focus-managed indexed navigation via arrow keys to a list of items
+ * within the floating element.
+ * @see https://floating-ui.com/docs/useListNavigation
+ */
+const useListNavigation = function (_ref, _temp2) {
+  let {
+    open,
+    onOpenChange,
+    refs
+  } = _ref;
+  let {
+    listRef,
+    activeIndex,
+    onNavigate: unstable_onNavigate = () => {},
+    enabled = true,
+    selectedIndex = null,
+    allowEscape = false,
+    loop = false,
+    nested = false,
+    rtl = false,
+    virtual = false,
+    focusItemOnOpen = 'auto',
+    focusItemOnHover = true,
+    openOnArrowKeyDown = true,
+    disabledIndices = undefined,
+    orientation = 'vertical',
+    cols = 1
+  } = _temp2 === void 0 ? {
+    listRef: {
+      current: []
+    },
+    activeIndex: null,
+    onNavigate: () => {}
+  } : _temp2;
+
+  if (process.env.NODE_ENV !== "production") {
+    if (allowEscape) {
+      if (!loop) {
+        console.warn(['Floating UI: `useListNavigation` looping must be enabled to allow', 'escaping.'].join(' '));
+      }
+
+      if (!virtual) {
+        console.warn(['Floating UI: `useListNavigation` must be virtual to allow', 'escaping.'].join(' '));
+      }
+    }
+
+    if (orientation === 'vertical' && cols > 1) {
+      console.warn(['Floating UI: In grid list navigation mode (`cols` > 1), the', '`orientation` should be either "horizontal" or "both".'].join(' '));
+    }
+  }
+
+  const parentId = useFloatingParentNodeId();
+  const tree = useFloatingTree();
+  const previousOpen = usePrevious(open);
+  const onNavigate = useEvent(unstable_onNavigate);
+  const previousOnNavigate = useEvent(usePrevious(unstable_onNavigate));
+  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);
+  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);
+  const keyRef = React.useRef(null);
+  const disabledIndicesRef = useLatestRef(disabledIndices);
+  const blockPointerLeaveRef = React.useRef(false);
+  const frameRef = React.useRef(-1);
+  const [activeId, setActiveId] = React.useState();
+  const focusItem = React.useCallback((listRef, indexRef) => {
+    // `mousedown` clicks occur before `focus`, so the button will steal the
+    // focus unless we wait a frame.
+    frameRef.current = requestAnimationFrame(() => {
+      if (virtual) {
+        var _listRef$current$inde;
+
+        setActiveId((_listRef$current$inde = listRef.current[indexRef.current]) == null ? void 0 : _listRef$current$inde.id);
+      } else {
+        var _listRef$current$inde2;
+
+        (_listRef$current$inde2 = listRef.current[indexRef.current]) == null ? void 0 : _listRef$current$inde2.focus({
+          preventScroll: true
+        });
+      }
+    });
+  }, [virtual]); // Sync `selectedIndex` to be the `activeIndex` upon opening the floating
+  // element. Also, reset `activeIndex` upon closing the floating element.
+
+  index(() => {
+    if (!enabled) {
+      return;
+    }
+
+    if (!previousOpen && open && focusItemOnOpenRef.current && selectedIndex != null) {
+      onNavigate(selectedIndex);
+    } // Unset `activeIndex`. Since the user can specify `onNavigate`
+    // conditionally (onNavigate: open ? setActiveIndex : setSelectedIndex)
+    // we store and call the previous function
+
+
+    if (previousOpen && !open) {
+      cancelAnimationFrame(frameRef.current);
+      indexRef.current = -1;
+      previousOnNavigate(null);
+    }
+  }, [open, previousOpen, selectedIndex, listRef, focusItem, enabled, onNavigate, previousOnNavigate]); // Sync `activeIndex` to be the focused item while the floating element is
+  // open.
+
+  index(() => {
+    if (!enabled) {
+      return;
+    }
+
+    if (open) {
+      if (activeIndex == null) {
+        if (selectedIndex != null) {
+          return;
+        } // Reset while the floating element was open (e.g. the list changed).
+
+
+        if (previousOpen) {
+          indexRef.current = -1;
+          focusItem(listRef, indexRef);
+        } // Initial sync
+
+
+        if (!previousOpen && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {
+          indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);
+          onNavigate(indexRef.current);
+          focusItem(listRef, indexRef);
+        }
+      } else if (!isIndexOutOfBounds(listRef, activeIndex)) {
+        indexRef.current = activeIndex;
+        focusItem(listRef, indexRef);
+      }
+    }
+  }, [open, previousOpen, activeIndex, selectedIndex, nested, listRef, onNavigate, focusItem, enabled, allowEscape, orientation, rtl, virtual, disabledIndicesRef]); // Ensure the parent floating element has focus when a nested child closes
+  // to allow arrow key navigation to work after the pointer leaves the child.
+
+  index(() => {
+    if (!enabled) {
+      return;
+    }
+
+    if (!open && previousOpen) {
+      var _tree$nodesRef$curren, _tree$nodesRef$curren2;
+
+      const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.refs.floating.current;
+
+      if (parentFloating && !parentFloating.contains(activeElement(getDocument(parentFloating)))) {
+        parentFloating.focus({
+          preventScroll: true
+        });
+      }
+    }
+  }, [enabled, open, previousOpen, tree, parentId]);
+  index(() => {
+    keyRef.current = null;
+  });
+  return React.useMemo(() => {
+    if (!enabled) {
+      return {};
+    }
+
+    const disabledIndices = disabledIndicesRef.current;
+
+    function onKeyDown(event) {
+      blockPointerLeaveRef.current = true;
+
+      if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {
+        stopEvent(event);
+        onOpenChange(false);
+
+        if (isHTMLElement(refs.domReference.current)) {
+          refs.domReference.current.focus();
+        }
+
+        return;
+      }
+
+      const currentIndex = indexRef.current;
+      const minIndex = getMinIndex(listRef, disabledIndices);
+      const maxIndex = getMaxIndex(listRef, disabledIndices);
+
+      if (event.key === 'Home') {
+        indexRef.current = minIndex;
+        onNavigate(indexRef.current);
+      }
+
+      if (event.key === 'End') {
+        indexRef.current = maxIndex;
+        onNavigate(indexRef.current);
+      } // Grid navigation
+
+
+      if (cols > 1) {
+        const prevIndex = indexRef.current;
+
+        if (event.key === ARROW_UP) {
+          stopEvent(event);
+
+          if (prevIndex === -1) {
+            indexRef.current = maxIndex;
+          } else {
+            indexRef.current = findNonDisabledIndex(listRef, {
+              startingIndex: prevIndex,
+              amount: cols,
+              decrement: true,
+              disabledIndices
+            });
+
+            if (loop && (prevIndex - cols < minIndex || indexRef.current < 0)) {
+              const col = prevIndex % cols;
+              const maxCol = maxIndex % cols;
+              const offset = maxIndex - (maxCol - col);
+
+              if (maxCol === col) {
+                indexRef.current = maxIndex;
+              } else {
+                indexRef.current = maxCol > col ? offset : offset - cols;
+              }
+            }
+          }
+
+          if (isIndexOutOfBounds(listRef, indexRef.current)) {
+            indexRef.current = prevIndex;
+          }
+
+          onNavigate(indexRef.current);
+        }
+
+        if (event.key === ARROW_DOWN) {
+          stopEvent(event);
+
+          if (prevIndex === -1) {
+            indexRef.current = minIndex;
+          } else {
+            indexRef.current = findNonDisabledIndex(listRef, {
+              startingIndex: prevIndex,
+              amount: cols,
+              disabledIndices
+            });
+
+            if (loop && prevIndex + cols > maxIndex) {
+              indexRef.current = findNonDisabledIndex(listRef, {
+                startingIndex: prevIndex % cols - cols,
+                amount: cols,
+                disabledIndices
+              });
+            }
+          }
+
+          if (isIndexOutOfBounds(listRef, indexRef.current)) {
+            indexRef.current = prevIndex;
+          }
+
+          onNavigate(indexRef.current);
+        } // Remains on the same row/column
+
+
+        if (orientation === 'both') {
+          const prevRow = Math.floor(prevIndex / cols);
+
+          if (event.key === ARROW_RIGHT) {
+            stopEvent(event);
+
+            if (prevIndex % cols !== cols - 1) {
+              indexRef.current = findNonDisabledIndex(listRef, {
+                startingIndex: prevIndex,
+                disabledIndices
+              });
+
+              if (loop && isDifferentRow(indexRef.current, cols, prevRow)) {
+                indexRef.current = findNonDisabledIndex(listRef, {
+                  startingIndex: prevIndex - prevIndex % cols - 1,
+                  disabledIndices
+                });
+              }
+            } else if (loop) {
+              indexRef.current = findNonDisabledIndex(listRef, {
+                startingIndex: prevIndex - prevIndex % cols - 1,
+                disabledIndices
+              });
+            }
+
+            if (isDifferentRow(indexRef.current, cols, prevRow)) {
+              indexRef.current = prevIndex;
+            }
+          }
+
+          if (event.key === ARROW_LEFT) {
+            stopEvent(event);
+
+            if (prevIndex % cols !== 0) {
+              indexRef.current = findNonDisabledIndex(listRef, {
+                startingIndex: prevIndex,
+                disabledIndices,
+                decrement: true
+              });
+
+              if (loop && isDifferentRow(indexRef.current, cols, prevRow)) {
+                indexRef.current = findNonDisabledIndex(listRef, {
+                  startingIndex: prevIndex + (cols - prevIndex % cols),
+                  decrement: true,
+                  disabledIndices
+                });
+              }
+            } else if (loop) {
+              indexRef.current = findNonDisabledIndex(listRef, {
+                startingIndex: prevIndex + (cols - prevIndex % cols),
+                decrement: true,
+                disabledIndices
+              });
+            }
+
+            if (isDifferentRow(indexRef.current, cols, prevRow)) {
+              indexRef.current = prevIndex;
+            }
+          }
+
+          const lastRow = Math.floor(maxIndex / cols) === prevRow;
+
+          if (isIndexOutOfBounds(listRef, indexRef.current)) {
+            if (loop && lastRow) {
+              indexRef.current = event.key === ARROW_LEFT ? maxIndex : findNonDisabledIndex(listRef, {
+                startingIndex: prevIndex - prevIndex % cols - 1,
+                disabledIndices
+              });
+            } else {
+              indexRef.current = prevIndex;
+            }
+          }
+
+          onNavigate(indexRef.current);
+          return;
+        }
+      }
+
+      if (isMainOrientationKey(event.key, orientation)) {
+        stopEvent(event); // Reset the index if no item is focused.
+
+        if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {
+          indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;
+          onNavigate(indexRef.current);
+          return;
+        }
+
+        if (isMainOrientationToEndKey(event.key, orientation, rtl)) {
+          if (loop) {
+            indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {
+              startingIndex: currentIndex,
+              disabledIndices
+            });
+          } else {
+            indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {
+              startingIndex: currentIndex,
+              disabledIndices
+            }));
+          }
+        } else {
+          if (loop) {
+            indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {
+              startingIndex: currentIndex,
+              decrement: true,
+              disabledIndices
+            });
+          } else {
+            indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {
+              startingIndex: currentIndex,
+              decrement: true,
+              disabledIndices
+            }));
+          }
+        }
+
+        if (isIndexOutOfBounds(listRef, indexRef.current)) {
+          onNavigate(null);
+        } else {
+          onNavigate(indexRef.current);
+        }
+      }
+    }
+
+    return {
+      reference: { ...(virtual && open && activeIndex != null && {
+          'aria-activedescendant': activeId
+        }),
+
+        onKeyDown(event) {
+          blockPointerLeaveRef.current = true;
+
+          if (virtual && open) {
+            return onKeyDown(event);
+          }
+
+          const isNavigationKey = event.key.indexOf('Arrow') === 0 || event.key === 'Enter' || event.key === ' ' || event.key === '';
+
+          if (isNavigationKey) {
+            keyRef.current = event.key;
+          }
+
+          if (nested) {
+            if (isCrossOrientationOpenKey(event.key, orientation, rtl)) {
+              stopEvent(event);
+
+              if (open) {
+                indexRef.current = getMinIndex(listRef, disabledIndices);
+                onNavigate(indexRef.current);
+              } else {
+                onOpenChange(true);
+              }
+            }
+
+            return;
+          }
+
+          if (isMainOrientationKey(event.key, orientation)) {
+            if (selectedIndex != null) {
+              indexRef.current = selectedIndex;
+            }
+
+            stopEvent(event);
+
+            if (!open && openOnArrowKeyDown) {
+              onOpenChange(true);
+            } else {
+              onKeyDown(event);
+            }
+
+            if (open) {
+              onNavigate(indexRef.current);
+            }
+          }
+        }
+
+      },
+      floating: {
+        'aria-orientation': orientation === 'both' ? undefined : orientation,
+        ...(virtual && activeIndex != null && {
+          'aria-activedescendant': activeId
+        }),
+        onKeyDown,
+
+        onPointerMove() {
+          blockPointerLeaveRef.current = false;
+        }
+
+      },
+      item: {
+        onFocus(_ref2) {
+          let {
+            currentTarget
+          } = _ref2;
+          const index = listRef.current.indexOf(currentTarget);
+
+          if (index !== -1) {
+            onNavigate(index);
+          }
+        },
+
+        onClick: _ref3 => {
+          let {
+            currentTarget
+          } = _ref3;
+          return currentTarget.focus({
+            preventScroll: true
+          });
+        },
+        // Safari
+        ...(focusItemOnHover && {
+          onMouseMove(_ref4) {
+            let {
+              currentTarget
+            } = _ref4;
+            const target = currentTarget;
+
+            if (target) {
+              const index = listRef.current.indexOf(target);
+
+              if (index !== -1) {
+                onNavigate(index);
+              }
+            }
+          },
+
+          onPointerLeave() {
+            if (!blockPointerLeaveRef.current) {
+              indexRef.current = -1;
+              focusItem(listRef, indexRef);
+              onNavigate(null);
+
+              if (!virtual) {
+                requestAnimationFrame(() => {
+                  var _refs$floating$curren;
+
+                  (_refs$floating$curren = refs.floating.current) == null ? void 0 : _refs$floating$curren.focus({
+                    preventScroll: true
+                  });
+                });
+              }
+            }
+          }
+
+        })
+      }
+    };
+  }, [activeId, disabledIndicesRef, listRef, enabled, orientation, rtl, virtual, open, activeIndex, nested, selectedIndex, openOnArrowKeyDown, focusItemOnHover, allowEscape, cols, loop, refs, focusItem, onNavigate, onOpenChange]);
+};
+
+export { FloatingFocusManager, FloatingOverlay, FloatingPortal, getOverflowAncestors, useClick, useDismiss, useFloating, useFloatingParentNodeId, useFloatingPortalNode, useFloatingTree, useFocus, useHover, useId, useInteractions, useListNavigation, useRole };
+//# sourceMappingURL=floating-ui.react-dom-interactions.esm.js.map