@preply/ds-web-lib 11.0.0 → 11.1.0

package/dist/useOpenInteractionType-Cj41-8Yk.js

@@ -1,2880 +0,0 @@
-"use client";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import * as React from "react";
-import * as ReactDOM from "react-dom";
-import { u as useEventCallback, a as useIsoLayoutEffect, b as isShadowRoot, i as isHTMLElement, g as getNodeName, c as createChangeEventDetails, d as isNode, e as getWindow, f as isElement, h as isLastTraversableNode, j as getParentNode, k as getComputedStyle$1, l as getOverflowAncestors, m as isWebKit$1 } from "./floating-ui.utils.dom-3OgjGonN.js";
-import { b as useRefWithInit, i as isReactVersionAtLeast, c as useMergedRefs, E as EMPTY_OBJECT, N as NOOP } from "./useRenderElement-DtYPTE_y.js";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { u as useId } from "./useId-BhIOp2JG.js";
-const TYPEAHEAD_RESET_MS = 500;
-const PATIENT_CLICK_THRESHOLD = 500;
-const DISABLED_TRANSITIONS_STYLE = {
-  style: {
-    transition: "none"
-  }
-};
-const CLICK_TRIGGER_IDENTIFIER = "data-base-ui-click-trigger";
-const DROPDOWN_COLLISION_AVOIDANCE = {
-  fallbackAxisSide: "none"
-};
-const EMPTY$2 = [];
-function useOnMount(fn) {
-  React.useEffect(fn, EMPTY$2);
-}
-const EMPTY$1 = null;
-let LAST_RAF = globalThis.requestAnimationFrame;
-class Scheduler {
-  constructor() {
-    /* This implementation uses an array as a backing data-structure for frame callbacks.
-     * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
-     * never calls the native `cancelAnimationFrame` if there are no frames left. This can
-     * be much more efficient if there is a call pattern that alterns as
-     * "request-cancel-request-cancel-…".
-     * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
-     * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
-    __publicField(this, "callbacks", /* @__PURE__ */ (() => [])());
-    __publicField(this, "callbacksCount", 0);
-    __publicField(this, "nextId", 1);
-    __publicField(this, "startId", 1);
-    __publicField(this, "isScheduled", false);
-    __publicField(this, "tick", (timestamp) => {
-      var _a;
-      this.isScheduled = false;
-      const currentCallbacks = this.callbacks;
-      const currentCallbacksCount = this.callbacksCount;
-      this.callbacks = [];
-      this.callbacksCount = 0;
-      this.startId = this.nextId;
-      if (currentCallbacksCount > 0) {
-        for (let i = 0; i < currentCallbacks.length; i += 1) {
-          (_a = currentCallbacks[i]) == null ? void 0 : _a.call(currentCallbacks, timestamp);
-        }
-      }
-    });
-  }
-  request(fn) {
-    const id = this.nextId;
-    this.nextId += 1;
-    this.callbacks.push(fn);
-    this.callbacksCount += 1;
-    const didRAFChange = process.env.NODE_ENV === "test" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
-    if (!this.isScheduled || didRAFChange) {
-      requestAnimationFrame(this.tick);
-      this.isScheduled = true;
-    }
-    return id;
-  }
-  cancel(id) {
-    const index = id - this.startId;
-    if (index < 0 || index >= this.callbacks.length) {
-      return;
-    }
-    this.callbacks[index] = null;
-    this.callbacksCount -= 1;
-  }
-}
-const scheduler = new Scheduler();
-class AnimationFrame {
-  constructor() {
-    __publicField(this, "currentId", /* @__PURE__ */ (() => EMPTY$1)());
-    __publicField(this, "cancel", () => {
-      if (this.currentId !== EMPTY$1) {
-        scheduler.cancel(this.currentId);
-        this.currentId = EMPTY$1;
-      }
-    });
-    __publicField(this, "disposeEffect", () => {
-      return this.cancel;
-    });
-  }
-  static create() {
-    return new AnimationFrame();
-  }
-  static request(fn) {
-    return scheduler.request(fn);
-  }
-  static cancel(id) {
-    return scheduler.cancel(id);
-  }
-  /**
-   * Executes `fn` after `delay`, clearing any previously scheduled call.
-   */
-  request(fn) {
-    this.cancel();
-    this.currentId = scheduler.request(() => {
-      this.currentId = EMPTY$1;
-      fn();
-    });
-  }
-}
-function useAnimationFrame() {
-  const timeout = useRefWithInit(AnimationFrame.create).current;
-  useOnMount(timeout.disposeEffect);
-  return timeout;
-}
-function useAnimationsFinished(elementOrRef, waitForNextTick = false) {
-  const frame = useAnimationFrame();
-  return useEventCallback((fnToExecute, signal = null) => {
-    frame.cancel();
-    if (elementOrRef == null) {
-      return;
-    }
-    let element;
-    if ("current" in elementOrRef) {
-      if (elementOrRef.current == null) {
-        return;
-      }
-      element = elementOrRef.current;
-    } else {
-      element = elementOrRef;
-    }
-    if (typeof element.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
-      fnToExecute();
-    } else {
-      frame.request(() => {
-        function exec() {
-          if (!element) {
-            return;
-          }
-          Promise.allSettled(element.getAnimations().map((anim) => anim.finished)).then(() => {
-            if (signal != null && signal.aborted) {
-              return;
-            }
-            ReactDOM.flushSync(fnToExecute);
-          });
-        }
-        if (waitForNextTick) {
-          frame.request(exec);
-        } else {
-          exec();
-        }
-      });
-    }
-  });
-}
-function useTransitionStatus(open, enableIdleState = false, deferEndingState = false) {
-  const [transitionStatus, setTransitionStatus] = React.useState(open && enableIdleState ? "idle" : void 0);
-  const [mounted, setMounted] = React.useState(open);
-  if (open && !mounted) {
-    setMounted(true);
-    setTransitionStatus("starting");
-  }
-  if (!open && mounted && transitionStatus !== "ending" && !deferEndingState) {
-    setTransitionStatus("ending");
-  }
-  if (!open && !mounted && transitionStatus === "ending") {
-    setTransitionStatus(void 0);
-  }
-  useIsoLayoutEffect(() => {
-    if (!open && mounted && transitionStatus !== "ending" && deferEndingState) {
-      const frame = AnimationFrame.request(() => {
-        setTransitionStatus("ending");
-      });
-      return () => {
-        AnimationFrame.cancel(frame);
-      };
-    }
-    return void 0;
-  }, [open, mounted, transitionStatus, deferEndingState]);
-  useIsoLayoutEffect(() => {
-    if (!open || enableIdleState) {
-      return void 0;
-    }
-    const frame = AnimationFrame.request(() => {
-      ReactDOM.flushSync(() => {
-        setTransitionStatus(void 0);
-      });
-    });
-    return () => {
-      AnimationFrame.cancel(frame);
-    };
-  }, [enableIdleState, open]);
-  useIsoLayoutEffect(() => {
-    if (!open || !enableIdleState) {
-      return void 0;
-    }
-    if (open && mounted && transitionStatus !== "idle") {
-      setTransitionStatus("starting");
-    }
-    const frame = AnimationFrame.request(() => {
-      setTransitionStatus("idle");
-    });
-    return () => {
-      AnimationFrame.cancel(frame);
-    };
-  }, [enableIdleState, open, mounted, setTransitionStatus, transitionStatus]);
-  return React.useMemo(() => ({
-    mounted,
-    setMounted,
-    transitionStatus
-  }), [mounted, transitionStatus]);
-}
-let TransitionStatusDataAttributes = /* @__PURE__ */ (function(TransitionStatusDataAttributes2) {
-  TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
-  TransitionStatusDataAttributes2["endingStyle"] = "data-ending-style";
-  return TransitionStatusDataAttributes2;
-})({});
-const STARTING_HOOK = {
-  [TransitionStatusDataAttributes.startingStyle]: ""
-};
-const ENDING_HOOK = {
-  [TransitionStatusDataAttributes.endingStyle]: ""
-};
-const transitionStatusMapping = {
-  transitionStatus(value) {
-    if (value === "starting") {
-      return STARTING_HOOK;
-    }
-    if (value === "ending") {
-      return ENDING_HOOK;
-    }
-    return null;
-  }
-};
-const hasNavigator = typeof navigator !== "undefined";
-const nav = getNavigatorData();
-const platform = getPlatform();
-const userAgent = getUserAgent();
-const isWebKit = typeof CSS === "undefined" || !CSS.supports ? false : CSS.supports("-webkit-backdrop-filter:none");
-const isIOS = (
-  // iPads can claim to be MacIntel
-  nav.platform === "MacIntel" && nav.maxTouchPoints > 1 ? true : /iP(hone|ad|od)|iOS/.test(nav.platform)
-);
-const isSafari = hasNavigator && /apple/i.test(navigator.vendor);
-const isAndroid = hasNavigator && /android/i.test(platform) || /android/i.test(userAgent);
-const isMac = hasNavigator && platform.toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
-const isJSDOM = userAgent.includes("jsdom/");
-function getNavigatorData() {
-  var _a, _b;
-  if (!hasNavigator) {
-    return {
-      platform: "",
-      maxTouchPoints: -1
-    };
-  }
-  const uaData = navigator.userAgentData;
-  if (uaData == null ? void 0 : uaData.platform) {
-    return {
-      platform: uaData.platform,
-      maxTouchPoints: navigator.maxTouchPoints
-    };
-  }
-  return {
-    platform: (_a = navigator.platform) != null ? _a : "",
-    maxTouchPoints: (_b = navigator.maxTouchPoints) != null ? _b : -1
-  };
-}
-function getUserAgent() {
-  if (!hasNavigator) {
-    return "";
-  }
-  const uaData = navigator.userAgentData;
-  if (uaData && Array.isArray(uaData.brands)) {
-    return uaData.brands.map(({
-      brand,
-      version
-    }) => `${brand}/${version}`).join(" ");
-  }
-  return navigator.userAgent;
-}
-function getPlatform() {
-  var _a;
-  if (!hasNavigator) {
-    return "";
-  }
-  const uaData = navigator.userAgentData;
-  if (uaData == null ? void 0 : uaData.platform) {
-    return uaData.platform;
-  }
-  return (_a = navigator.platform) != null ? _a : "";
-}
-const FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
-const ACTIVE_KEY = "active";
-const SELECTED_KEY = "selected";
-const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
-const ARROW_LEFT$1 = "ArrowLeft";
-const ARROW_RIGHT$1 = "ArrowRight";
-const ARROW_UP$1 = "ArrowUp";
-const ARROW_DOWN$1 = "ArrowDown";
-function activeElement(doc) {
-  var _a;
-  let element = doc.activeElement;
-  while (((_a = element == null ? void 0 : element.shadowRoot) == null ? void 0 : _a.activeElement) != null) {
-    element = element.shadowRoot.activeElement;
-  }
-  return element;
-}
-function contains(parent, child) {
-  var _a;
-  if (!parent || !child) {
-    return false;
-  }
-  const rootNode = (_a = child.getRootNode) == null ? void 0 : _a.call(child);
-  if (parent.contains(child)) {
-    return true;
-  }
-  if (rootNode && isShadowRoot(rootNode)) {
-    let next = child;
-    while (next) {
-      if (parent === next) {
-        return true;
-      }
-      next = next.parentNode || next.host;
-    }
-  }
-  return false;
-}
-function getTarget(event) {
-  if ("composedPath" in event) {
-    return event.composedPath()[0];
-  }
-  return event.target;
-}
-function isEventTargetWithin(event, node) {
-  if (node == null) {
-    return false;
-  }
-  if ("composedPath" in event) {
-    return event.composedPath().includes(node);
-  }
-  const eventAgain = event;
-  return eventAgain.target != null && node.contains(eventAgain.target);
-}
-function isRootElement(element) {
-  return element.matches("html,body");
-}
-function getDocument(node) {
-  return (node == null ? void 0 : node.ownerDocument) || document;
-}
-function isTypeableElement(element) {
-  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
-}
-function isTypeableCombobox(element) {
-  if (!element) {
-    return false;
-  }
-  return element.getAttribute("role") === "combobox" && isTypeableElement(element);
-}
-function matchesFocusVisible(element) {
-  if (!element || isJSDOM) {
-    return true;
-  }
-  try {
-    return element.matches(":focus-visible");
-  } catch (_e) {
-    return true;
-  }
-}
-function getFloatingFocusElement(floatingElement) {
-  if (!floatingElement) {
-    return null;
-  }
-  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`) || floatingElement;
-}
-function getNodeChildren(nodes, id, onlyOpenChildren = true) {
-  const directChildren = nodes.filter((node) => {
-    var _a;
-    return node.parentId === id && (!onlyOpenChildren || ((_a = node.context) == null ? void 0 : _a.open));
-  });
-  return directChildren.flatMap((child) => [child, ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
-}
-function getNodeAncestors(nodes, id) {
-  var _a;
-  let allAncestors = [];
-  let currentParentId = (_a = nodes.find((node) => node.id === id)) == null ? void 0 : _a.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 stopEvent(event) {
-  event.preventDefault();
-  event.stopPropagation();
-}
-function isReactEvent(event) {
-  return "nativeEvent" in event;
-}
-function isVirtualClick(event) {
-  if (event.mozInputSource === 0 && event.isTrusted) {
-    return true;
-  }
-  if (isAndroid && event.pointerType) {
-    return event.type === "click" && event.buttons === 1;
-  }
-  return event.detail === 0 && !event.pointerType;
-}
-function isVirtualPointerEvent(event) {
-  if (isJSDOM) {
-    return false;
-  }
-  return !isAndroid && event.width === 0 && event.height === 0 || isAndroid && 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 && event.pointerType === "touch";
-}
-function isMouseLikePointerType(pointerType, strict) {
-  const values = ["mouse", "pen"];
-  if (!strict) {
-    values.push("", void 0);
-  }
-  return values.includes(pointerType);
-}
-/*!
-* tabbable 6.2.0
-* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
-*/
-var candidateSelectors = ["input:not([inert])", "select:not([inert])", "textarea:not([inert])", "a[href]:not([inert])", "button:not([inert])", "[tabindex]:not(slot):not([inert])", "audio[controls]:not([inert])", "video[controls]:not([inert])", '[contenteditable]:not([contenteditable="false"]):not([inert])', "details>summary:first-of-type:not([inert])", "details:not([inert])"];
-var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
-var NoElement = typeof Element === "undefined";
-var matches = NoElement ? function() {
-} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
-var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
-  var _element$getRootNode;
-  return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
-} : function(element) {
-  return element === null || element === void 0 ? void 0 : element.ownerDocument;
-};
-var isInert = function isInert2(node, lookUp) {
-  var _node$getAttribute;
-  if (lookUp === void 0) {
-    lookUp = true;
-  }
-  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
-  var inert = inertAtt === "" || inertAtt === "true";
-  var result = inert || lookUp && node && isInert2(node.parentNode);
-  return result;
-};
-var isContentEditable = function isContentEditable2(node) {
-  var _node$getAttribute2;
-  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
-  return attValue === "" || attValue === "true";
-};
-var getCandidates = function getCandidates2(el, includeContainer, filter) {
-  if (isInert(el)) {
-    return [];
-  }
-  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
-  if (includeContainer && matches.call(el, candidateSelector)) {
-    candidates.unshift(el);
-  }
-  candidates = candidates.filter(filter);
-  return candidates;
-};
-var getCandidatesIteratively = function getCandidatesIteratively2(elements, includeContainer, options) {
-  var candidates = [];
-  var elementsToCheck = Array.from(elements);
-  while (elementsToCheck.length) {
-    var element = elementsToCheck.shift();
-    if (isInert(element, false)) {
-      continue;
-    }
-    if (element.tagName === "SLOT") {
-      var assigned = element.assignedElements();
-      var content = assigned.length ? assigned : element.children;
-      var nestedCandidates = getCandidatesIteratively2(content, true, options);
-      if (options.flatten) {
-        candidates.push.apply(candidates, nestedCandidates);
-      } else {
-        candidates.push({
-          scopeParent: element,
-          candidates: nestedCandidates
-        });
-      }
-    } else {
-      var validCandidate = matches.call(element, candidateSelector);
-      if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {
-        candidates.push(element);
-      }
-      var shadowRoot = element.shadowRoot || // check for an undisclosed shadow
-      typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
-      var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
-      if (shadowRoot && validShadowRoot) {
-        var _nestedCandidates = getCandidatesIteratively2(shadowRoot === true ? element.children : shadowRoot.children, true, options);
-        if (options.flatten) {
-          candidates.push.apply(candidates, _nestedCandidates);
-        } else {
-          candidates.push({
-            scopeParent: element,
-            candidates: _nestedCandidates
-          });
-        }
-      } else {
-        elementsToCheck.unshift.apply(elementsToCheck, element.children);
-      }
-    }
-  }
-  return candidates;
-};
-var hasTabIndex = function hasTabIndex2(node) {
-  return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
-};
-var getTabIndex = function getTabIndex2(node) {
-  if (!node) {
-    throw new Error("No node provided");
-  }
-  if (node.tabIndex < 0) {
-    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {
-      return 0;
-    }
-  }
-  return node.tabIndex;
-};
-var getSortOrderTabIndex = function getSortOrderTabIndex2(node, isScope) {
-  var tabIndex = getTabIndex(node);
-  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {
-    return 0;
-  }
-  return tabIndex;
-};
-var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
-  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
-};
-var isInput = function isInput2(node) {
-  return node.tagName === "INPUT";
-};
-var isHiddenInput = function isHiddenInput2(node) {
-  return isInput(node) && node.type === "hidden";
-};
-var isDetailsWithSummary = function isDetailsWithSummary2(node) {
-  var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
-    return child.tagName === "SUMMARY";
-  });
-  return r;
-};
-var getCheckedRadio = function getCheckedRadio2(nodes, form) {
-  for (var i = 0; i < nodes.length; i++) {
-    if (nodes[i].checked && nodes[i].form === form) {
-      return nodes[i];
-    }
-  }
-};
-var isTabbableRadio = function isTabbableRadio2(node) {
-  if (!node.name) {
-    return true;
-  }
-  var radioScope = node.form || getRootNode(node);
-  var queryRadios = function queryRadios2(name) {
-    return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
-  };
-  var radioSet;
-  if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
-    radioSet = queryRadios(window.CSS.escape(node.name));
-  } else {
-    try {
-      radioSet = queryRadios(node.name);
-    } catch (err) {
-      console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
-      return false;
-    }
-  }
-  var checked = getCheckedRadio(radioSet, node.form);
-  return !checked || checked === node;
-};
-var isRadio = function isRadio2(node) {
-  return isInput(node) && node.type === "radio";
-};
-var isNonTabbableRadio = function isNonTabbableRadio2(node) {
-  return isRadio(node) && !isTabbableRadio(node);
-};
-var isNodeAttached = function isNodeAttached2(node) {
-  var _nodeRoot;
-  var nodeRoot = node && getRootNode(node);
-  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
-  var attached = false;
-  if (nodeRoot && nodeRoot !== node) {
-    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
-    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
-    while (!attached && nodeRootHost) {
-      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
-      nodeRoot = getRootNode(nodeRootHost);
-      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
-      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
-    }
-  }
-  return attached;
-};
-var isZeroArea = function isZeroArea2(node) {
-  var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
-  return width === 0 && height === 0;
-};
-var isHidden = function isHidden2(node, _ref) {
-  var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
-  if (getComputedStyle(node).visibility === "hidden") {
-    return true;
-  }
-  var isDirectSummary = matches.call(node, "details>summary:first-of-type");
-  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
-  if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
-    return true;
-  }
-  if (!displayCheck || displayCheck === "full" || displayCheck === "legacy-full") {
-    if (typeof getShadowRoot === "function") {
-      var originalNode = node;
-      while (node) {
-        var parentElement = node.parentElement;
-        var rootNode = getRootNode(node);
-        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) {
-          return isZeroArea(node);
-        } else if (node.assignedSlot) {
-          node = node.assignedSlot;
-        } else if (!parentElement && rootNode !== node.ownerDocument) {
-          node = rootNode.host;
-        } else {
-          node = parentElement;
-        }
-      }
-      node = originalNode;
-    }
-    if (isNodeAttached(node)) {
-      return !node.getClientRects().length;
-    }
-    if (displayCheck !== "legacy-full") {
-      return true;
-    }
-  } else if (displayCheck === "non-zero-area") {
-    return isZeroArea(node);
-  }
-  return false;
-};
-var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
-  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
-    var parentNode = node.parentElement;
-    while (parentNode) {
-      if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
-        for (var i = 0; i < parentNode.children.length; i++) {
-          var child = parentNode.children.item(i);
-          if (child.tagName === "LEGEND") {
-            return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
-          }
-        }
-        return true;
-      }
-      parentNode = parentNode.parentElement;
-    }
-  }
-  return false;
-};
-var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
-  if (node.disabled || // we must do an inert look up to filter out any elements inside an inert ancestor
-  //  because we're limited in the type of selectors we can use in JSDom (see related
-  //  note related to `candidateSelectors`)
-  isInert(node) || isHiddenInput(node) || isHidden(node, options) || // For a details element with a summary, the summary element gets the focus
-  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
-    return false;
-  }
-  return true;
-};
-var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
-  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
-    return false;
-  }
-  return true;
-};
-var isValidShadowRootTabbable = function isValidShadowRootTabbable2(shadowHostNode) {
-  var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
-  if (isNaN(tabIndex) || tabIndex >= 0) {
-    return true;
-  }
-  return false;
-};
-var sortByOrder = function sortByOrder2(candidates) {
-  var regularTabbables = [];
-  var orderedTabbables = [];
-  candidates.forEach(function(item, i) {
-    var isScope = !!item.scopeParent;
-    var element = isScope ? item.scopeParent : item;
-    var candidateTabindex = getSortOrderTabIndex(element, isScope);
-    var elements = isScope ? sortByOrder2(item.candidates) : element;
-    if (candidateTabindex === 0) {
-      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
-    } else {
-      orderedTabbables.push({
-        documentOrder: i,
-        tabIndex: candidateTabindex,
-        item,
-        isScope,
-        content: elements
-      });
-    }
-  });
-  return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
-    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
-    return acc;
-  }, []).concat(regularTabbables);
-};
-var tabbable = function tabbable2(container, options) {
-  options = options || {};
-  var candidates;
-  if (options.getShadowRoot) {
-    candidates = getCandidatesIteratively([container], options.includeContainer, {
-      filter: isNodeMatchingSelectorTabbable.bind(null, options),
-      flatten: false,
-      getShadowRoot: options.getShadowRoot,
-      shadowRootFilter: isValidShadowRootTabbable
-    });
-  } else {
-    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
-  }
-  return sortByOrder(candidates);
-};
-var focusable = function focusable2(container, options) {
-  options = options || {};
-  var candidates;
-  if (options.getShadowRoot) {
-    candidates = getCandidatesIteratively([container], options.includeContainer, {
-      filter: isNodeMatchingSelectorFocusable.bind(null, options),
-      flatten: true,
-      getShadowRoot: options.getShadowRoot
-    });
-  } else {
-    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
-  }
-  return candidates;
-};
-var isTabbable = function isTabbable2(node, options) {
-  options = options || {};
-  if (!node) {
-    throw new Error("No node provided");
-  }
-  if (matches.call(node, candidateSelector) === false) {
-    return false;
-  }
-  return isNodeMatchingSelectorTabbable(options, node);
-};
-const getTabbableOptions = () => ({
-  getShadowRoot: true,
-  displayCheck: (
-    // JSDOM does not support the `tabbable` library. To solve this we can
-    // check if `ResizeObserver` is a real function (not polyfilled), which
-    // determines if the current environment is JSDOM-like.
-    typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
-  )
-});
-function getTabbableIn(container, dir) {
-  const list = tabbable(container, getTabbableOptions());
-  const len = list.length;
-  if (len === 0) {
-    return void 0;
-  }
-  const active = activeElement(getDocument(container));
-  const index = list.indexOf(active);
-  const nextIndex = index === -1 ? dir === 1 ? 0 : len - 1 : index + dir;
-  return list[nextIndex];
-}
-function getNextTabbable(referenceElement) {
-  return getTabbableIn(getDocument(referenceElement).body, 1) || referenceElement;
-}
-function getPreviousTabbable(referenceElement) {
-  return getTabbableIn(getDocument(referenceElement).body, -1) || referenceElement;
-}
-function isOutsideEvent(event, container) {
-  const containerElement = container || event.currentTarget;
-  const relatedTarget = event.relatedTarget;
-  return !relatedTarget || !contains(containerElement, relatedTarget);
-}
-function disableFocusInside(container) {
-  const tabbableElements = tabbable(container, getTabbableOptions());
-  tabbableElements.forEach((element) => {
-    element.dataset.tabindex = element.getAttribute("tabindex") || "";
-    element.setAttribute("tabindex", "-1");
-  });
-}
-function enableFocusInside(container) {
-  const elements = container.querySelectorAll("[data-tabindex]");
-  elements.forEach((element) => {
-    const tabindex = element.dataset.tabindex;
-    delete element.dataset.tabindex;
-    if (tabindex) {
-      element.setAttribute("tabindex", tabindex);
-    } else {
-      element.removeAttribute("tabindex");
-    }
-  });
-}
-const ARROW_UP = "ArrowUp";
-const ARROW_DOWN = "ArrowDown";
-const ARROW_LEFT = "ArrowLeft";
-const ARROW_RIGHT = "ArrowRight";
-const HOME = "Home";
-const END = "End";
-const HORIZONTAL_KEYS = /* @__PURE__ */ new Set([ARROW_LEFT, ARROW_RIGHT]);
-const VERTICAL_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN]);
-const ARROW_KEYS = /* @__PURE__ */ new Set([...HORIZONTAL_KEYS, ...VERTICAL_KEYS]);
-/* @__PURE__ */ new Set([...ARROW_KEYS, HOME, END]);
-const COMPOSITE_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, HOME, END]);
-function useLatestRef(value) {
-  const latest = useRefWithInit(createLatestRef, value).current;
-  latest.next = value;
-  useIsoLayoutEffect(latest.effect);
-  return latest;
-}
-function createLatestRef(value) {
-  const latest = {
-    current: value,
-    next: value,
-    effect: () => {
-      latest.current = latest.next;
-    }
-  };
-  return latest;
-}
-function useOpenChangeComplete(parameters) {
-  const {
-    enabled = true,
-    open,
-    ref,
-    onComplete: onCompleteParam
-  } = parameters;
-  const openRef = useLatestRef(open);
-  const onComplete = useEventCallback(onCompleteParam);
-  const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
-  React.useEffect(() => {
-    if (!enabled) {
-      return;
-    }
-    runOnceAnimationsFinish(() => {
-      if (open === openRef.current) {
-        onComplete();
-      }
-    });
-  }, [enabled, open, onComplete, runOnceAnimationsFinish, openRef]);
-}
-let CommonPopupDataAttributes = (function(CommonPopupDataAttributes2) {
-  CommonPopupDataAttributes2["open"] = "data-open";
-  CommonPopupDataAttributes2["closed"] = "data-closed";
-  CommonPopupDataAttributes2[CommonPopupDataAttributes2["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
-  CommonPopupDataAttributes2[CommonPopupDataAttributes2["endingStyle"] = TransitionStatusDataAttributes.endingStyle] = "endingStyle";
-  CommonPopupDataAttributes2["anchorHidden"] = "data-anchor-hidden";
-  return CommonPopupDataAttributes2;
-})({});
-let CommonTriggerDataAttributes = /* @__PURE__ */ (function(CommonTriggerDataAttributes2) {
-  CommonTriggerDataAttributes2["popupOpen"] = "data-popup-open";
-  CommonTriggerDataAttributes2["pressed"] = "data-pressed";
-  return CommonTriggerDataAttributes2;
-})({});
-const TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: ""
-};
-const PRESSABLE_TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: "",
-  [CommonTriggerDataAttributes.pressed]: ""
-};
-const POPUP_OPEN_HOOK = {
-  [CommonPopupDataAttributes.open]: ""
-};
-const POPUP_CLOSED_HOOK = {
-  [CommonPopupDataAttributes.closed]: ""
-};
-const ANCHOR_HIDDEN_HOOK = {
-  [CommonPopupDataAttributes.anchorHidden]: ""
-};
-const triggerOpenStateMapping = {
-  open(value) {
-    if (value) {
-      return TRIGGER_HOOK;
-    }
-    return null;
-  }
-};
-const pressableTriggerOpenStateMapping = {
-  open(value) {
-    if (value) {
-      return PRESSABLE_TRIGGER_HOOK;
-    }
-    return null;
-  }
-};
-const popupStateMapping = {
-  open(value) {
-    if (value) {
-      return POPUP_OPEN_HOOK;
-    }
-    return POPUP_CLOSED_HOOK;
-  },
-  anchorHidden(value) {
-    if (value) {
-      return ANCHOR_HIDDEN_HOOK;
-    }
-    return null;
-  }
-};
-function inertValue(value) {
-  if (isReactVersionAtLeast(19)) {
-    return value;
-  }
-  return value ? "true" : void 0;
-}
-const EMPTY = 0;
-class Timeout {
-  constructor() {
-    __publicField(this, "currentId", /* @__PURE__ */ (() => EMPTY)());
-    __publicField(this, "clear", () => {
-      if (this.currentId !== EMPTY) {
-        clearTimeout(this.currentId);
-        this.currentId = EMPTY;
-      }
-    });
-    __publicField(this, "disposeEffect", () => {
-      return this.clear;
-    });
-  }
-  static create() {
-    return new Timeout();
-  }
-  /**
-   * Executes `fn` after `delay`, clearing any previously scheduled call.
-   */
-  start(delay, fn) {
-    this.clear();
-    this.currentId = setTimeout(() => {
-      this.currentId = EMPTY;
-      fn();
-    }, delay);
-  }
-  isStarted() {
-    return this.currentId !== EMPTY;
-  }
-}
-function useTimeout() {
-  const timeout = useRefWithInit(Timeout.create).current;
-  useOnMount(timeout.disposeEffect);
-  return timeout;
-}
-function createEventEmitter() {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    emit(event, data) {
-      var _a;
-      (_a = map.get(event)) == null ? void 0 : _a.forEach((listener) => listener(data));
-    },
-    on(event, listener) {
-      if (!map.has(event)) {
-        map.set(event, /* @__PURE__ */ new Set());
-      }
-      map.get(event).add(listener);
-    },
-    off(event, listener) {
-      var _a;
-      (_a = map.get(event)) == null ? void 0 : _a.delete(listener);
-    }
-  };
-}
-const FloatingNodeContext = /* @__PURE__ */ React.createContext(null);
-if (process.env.NODE_ENV !== "production") FloatingNodeContext.displayName = "FloatingNodeContext";
-const FloatingTreeContext = /* @__PURE__ */ React.createContext(null);
-if (process.env.NODE_ENV !== "production") FloatingTreeContext.displayName = "FloatingTreeContext";
-const useFloatingParentNodeId = () => {
-  var _a;
-  return ((_a = React.useContext(FloatingNodeContext)) == null ? void 0 : _a.id) || null;
-};
-const useFloatingTree = () => React.useContext(FloatingTreeContext);
-function useFloatingNodeId(customParentId) {
-  const id = useId();
-  const tree = useFloatingTree();
-  const reactParentId = useFloatingParentNodeId();
-  const parentId = reactParentId;
-  useIsoLayoutEffect(() => {
-    if (!id) {
-      return void 0;
-    }
-    const node = {
-      id,
-      parentId
-    };
-    tree == null ? void 0 : tree.addNode(node);
-    return () => {
-      tree == null ? void 0 : tree.removeNode(node);
-    };
-  }, [tree, id, parentId]);
-  return id;
-}
-function FloatingNode(props) {
-  const {
-    children,
-    id
-  } = props;
-  const parentId = useFloatingParentNodeId();
-  return /* @__PURE__ */ jsx(FloatingNodeContext.Provider, {
-    value: React.useMemo(() => ({
-      id,
-      parentId
-    }), [id, parentId]),
-    children
-  });
-}
-function FloatingTree(props) {
-  const {
-    children
-  } = props;
-  const nodesRef = React.useRef([]);
-  const addNode = React.useCallback((node) => {
-    nodesRef.current = [...nodesRef.current, node];
-  }, []);
-  const removeNode = React.useCallback((node) => {
-    nodesRef.current = nodesRef.current.filter((n) => n !== node);
-  }, []);
-  const [events] = React.useState(() => createEventEmitter());
-  return /* @__PURE__ */ jsx(FloatingTreeContext.Provider, {
-    value: React.useMemo(() => ({
-      nodesRef,
-      addNode,
-      removeNode,
-      events
-    }), [addNode, removeNode, events]),
-    children
-  });
-}
-function createAttribute(name) {
-  return `data-base-ui-${name}`;
-}
-const visuallyHidden = {
-  clip: "rect(0 0 0 0)",
-  overflow: "hidden",
-  whiteSpace: "nowrap",
-  position: "fixed",
-  top: 0,
-  left: 0,
-  border: 0,
-  padding: 0,
-  width: 1,
-  height: 1,
-  margin: -1
-};
-function ownerDocument(node) {
-  return (node == null ? void 0 : node.ownerDocument) || document;
-}
-const FocusGuard = /* @__PURE__ */ React.forwardRef(function FocusGuard2(props, ref) {
-  const [role, setRole] = React.useState();
-  useIsoLayoutEffect(() => {
-    if (isSafari) {
-      setRole("button");
-    }
-  }, []);
-  const restProps = {
-    tabIndex: 0,
-    // Role is only for VoiceOver
-    role
-  };
-  return /* @__PURE__ */ jsx("span", {
-    ...props,
-    ref,
-    style: visuallyHidden,
-    "aria-hidden": role ? void 0 : true,
-    ...restProps,
-    "data-base-ui-focus-guard": ""
-  });
-});
-if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
-let rafId = 0;
-function enqueueFocus(el, options = {}) {
-  const {
-    preventScroll = false,
-    cancelPrevious = true,
-    sync = false
-  } = options;
-  if (cancelPrevious) {
-    cancelAnimationFrame(rafId);
-  }
-  const exec = () => el == null ? void 0 : el.focus({
-    preventScroll
-  });
-  if (sync) {
-    exec();
-  } else {
-    rafId = requestAnimationFrame(exec);
-  }
-}
-const counters = {
-  inert: /* @__PURE__ */ new WeakMap(),
-  "aria-hidden": /* @__PURE__ */ new WeakMap(),
-  none: /* @__PURE__ */ new WeakMap()
-};
-function getCounterMap(control) {
-  if (control === "inert") {
-    return counters.inert;
-  }
-  if (control === "aria-hidden") {
-    return counters["aria-hidden"];
-  }
-  return counters.none;
-}
-let uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
-let markerMap = {};
-let lockCount = 0;
-const unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
-const correctElements = (parent, targets) => targets.map((target) => {
-  if (parent.contains(target)) {
-    return target;
-  }
-  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-base-ui-inert";
-  const controlAttribute = inert ? "inert" : ariaHidden ? "aria-hidden" : null;
-  const avoidElements = correctElements(body, uncorrectedAvoidElements);
-  const elementsToKeep = /* @__PURE__ */ new Set();
-  const elementsToStop = new Set(avoidElements);
-  const hiddenElements = [];
-  if (!markerMap[markerName]) {
-    markerMap[markerName] = /* @__PURE__ */ 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);
-    if (el.parentNode) {
-      keep(el.parentNode);
-    }
-  }
-  function deep(parent) {
-    if (!parent || elementsToStop.has(parent)) {
-      return;
-    }
-    [].forEach.call(parent.children, (node) => {
-      if (getNodeName(node) === "script") {
-        return;
-      }
-      if (elementsToKeep.has(node)) {
-        deep(node);
-      } else {
-        const attr2 = controlAttribute ? node.getAttribute(controlAttribute) : null;
-        const alreadyHidden = attr2 !== null && attr2 !== "false";
-        const counterMap = getCounterMap(controlAttribute);
-        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, controlAttribute === "inert" ? "" : "true");
-        }
-      }
-    });
-  }
-  lockCount += 1;
-  return () => {
-    hiddenElements.forEach((element) => {
-      const counterMap = getCounterMap(controlAttribute);
-      const currentCounterValue = counterMap.get(element) || 0;
-      const counterValue = currentCounterValue - 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 -= 1;
-    if (!lockCount) {
-      counters.inert = /* @__PURE__ */ new WeakMap();
-      counters["aria-hidden"] = /* @__PURE__ */ new WeakMap();
-      counters.none = /* @__PURE__ */ new WeakMap();
-      uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
-      markerMap = {};
-    }
-  };
-}
-function markOthers(avoidElements, ariaHidden = false, inert = false) {
-  const body = getDocument(avoidElements[0]).body;
-  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll("[aria-live]"))), body, ariaHidden, inert);
-}
-const PortalContext = /* @__PURE__ */ React.createContext(null);
-if (process.env.NODE_ENV !== "production") PortalContext.displayName = "PortalContext";
-const usePortalContext = () => React.useContext(PortalContext);
-const attr = createAttribute("portal");
-function useFloatingPortalNode(props = {}) {
-  const {
-    id,
-    root
-  } = props;
-  const uniqueId = useId();
-  const portalContext = usePortalContext();
-  const [portalNode, setPortalNode] = React.useState(null);
-  const portalNodeRef = React.useRef(null);
-  useIsoLayoutEffect(() => {
-    return () => {
-      portalNode == null ? void 0 : portalNode.remove();
-      queueMicrotask(() => {
-        portalNodeRef.current = null;
-      });
-    };
-  }, [portalNode]);
-  useIsoLayoutEffect(() => {
-    if (!uniqueId) {
-      return;
-    }
-    if (portalNodeRef.current) {
-      return;
-    }
-    const existingIdRoot = id ? document.getElementById(id) : null;
-    if (!existingIdRoot) {
-      return;
-    }
-    const subRoot = document.createElement("div");
-    subRoot.id = uniqueId;
-    subRoot.setAttribute(attr, "");
-    existingIdRoot.appendChild(subRoot);
-    portalNodeRef.current = subRoot;
-    setPortalNode(subRoot);
-  }, [id, uniqueId]);
-  useIsoLayoutEffect(() => {
-    if (root === null) {
-      return;
-    }
-    if (!uniqueId) {
-      return;
-    }
-    if (portalNodeRef.current) {
-      return;
-    }
-    let container = root || (portalContext == null ? void 0 : portalContext.portalNode);
-    if (container && !isNode(container)) {
-      container = container.current;
-    }
-    container = container || document.body;
-    let idWrapper = null;
-    if (id) {
-      idWrapper = document.createElement("div");
-      idWrapper.id = id;
-      container.appendChild(idWrapper);
-    }
-    const subRoot = document.createElement("div");
-    subRoot.id = uniqueId;
-    subRoot.setAttribute(attr, "");
-    container = idWrapper || container;
-    container.appendChild(subRoot);
-    portalNodeRef.current = subRoot;
-    setPortalNode(subRoot);
-  }, [id, root, uniqueId, portalContext]);
-  return portalNode;
-}
-function FloatingPortal(props) {
-  const {
-    children,
-    id,
-    root,
-    preserveTabOrder = true
-  } = props;
-  const portalNode = useFloatingPortalNode({
-    id,
-    root
-  });
-  const [focusManagerState, setFocusManagerState] = React.useState(null);
-  const beforeOutsideRef = React.useRef(null);
-  const afterOutsideRef = React.useRef(null);
-  const beforeInsideRef = React.useRef(null);
-  const afterInsideRef = React.useRef(null);
-  const modal = focusManagerState == null ? void 0 : focusManagerState.modal;
-  const open = focusManagerState == null ? void 0 : focusManagerState.open;
-  const shouldRenderGuards = (
-    // The FocusManager and therefore floating element are currently open/
-    // rendered.
-    !!focusManagerState && // Guards are only for non-modal focus management.
-    !focusManagerState.modal && // Don't render if unmount is transitioning.
-    focusManagerState.open && preserveTabOrder && !!(root || portalNode)
-  );
-  React.useEffect(() => {
-    if (!portalNode || !preserveTabOrder || modal) {
-      return void 0;
-    }
-    function onFocus(event) {
-      if (portalNode && isOutsideEvent(event)) {
-        const focusing = event.type === "focusin";
-        const manageFocus = focusing ? enableFocusInside : disableFocusInside;
-        manageFocus(portalNode);
-      }
-    }
-    portalNode.addEventListener("focusin", onFocus, true);
-    portalNode.addEventListener("focusout", onFocus, true);
-    return () => {
-      portalNode.removeEventListener("focusin", onFocus, true);
-      portalNode.removeEventListener("focusout", onFocus, true);
-    };
-  }, [portalNode, preserveTabOrder, modal]);
-  React.useEffect(() => {
-    if (!portalNode) {
-      return;
-    }
-    if (open) {
-      return;
-    }
-    enableFocusInside(portalNode);
-  }, [open, portalNode]);
-  return /* @__PURE__ */ jsxs(PortalContext.Provider, {
-    value: React.useMemo(() => ({
-      preserveTabOrder,
-      beforeOutsideRef,
-      afterOutsideRef,
-      beforeInsideRef,
-      afterInsideRef,
-      portalNode,
-      setFocusManagerState
-    }), [preserveTabOrder, portalNode]),
-    children: [shouldRenderGuards && portalNode && /* @__PURE__ */ jsx(FocusGuard, {
-      "data-type": "outside",
-      ref: beforeOutsideRef,
-      onFocus: (event) => {
-        var _a;
-        if (isOutsideEvent(event, portalNode)) {
-          (_a = beforeInsideRef.current) == null ? void 0 : _a.focus();
-        } else {
-          const domReference = focusManagerState ? focusManagerState.domReference : null;
-          const prevTabbable = getPreviousTabbable(domReference);
-          prevTabbable == null ? void 0 : prevTabbable.focus();
-        }
-      }
-    }), shouldRenderGuards && portalNode && /* @__PURE__ */ jsx("span", {
-      "aria-owns": portalNode.id,
-      style: visuallyHidden
-    }), portalNode && /* @__PURE__ */ ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /* @__PURE__ */ jsx(FocusGuard, {
-      "data-type": "outside",
-      ref: afterOutsideRef,
-      onFocus: (event) => {
-        var _a;
-        if (isOutsideEvent(event, portalNode)) {
-          (_a = afterInsideRef.current) == null ? void 0 : _a.focus();
-        } else {
-          const domReference = focusManagerState ? focusManagerState.domReference : null;
-          const nextTabbable = getNextTabbable(domReference);
-          nextTabbable == null ? void 0 : nextTabbable.focus();
-          if (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) {
-            focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, createChangeEventDetails("focus-out", event.nativeEvent));
-          }
-        }
-      }
-    })]
-  });
-}
-function getEventType(event, lastInteractionType) {
-  const win = getWindow(event.target);
-  if (event instanceof win.KeyboardEvent) {
-    return "keyboard";
-  }
-  if (event instanceof win.FocusEvent) {
-    return lastInteractionType || "keyboard";
-  }
-  if ("pointerType" in event) {
-    return event.pointerType || "keyboard";
-  }
-  if ("touches" in event) {
-    return "touch";
-  }
-  if (event instanceof win.MouseEvent) {
-    return lastInteractionType || (event.detail === 0 ? "keyboard" : "mouse");
-  }
-  return "";
-}
-const LIST_LIMIT = 20;
-let previouslyFocusedElements = [];
-function clearDisconnectedPreviouslyFocusedElements() {
-  previouslyFocusedElements = previouslyFocusedElements.filter((el) => el.isConnected);
-}
-function addPreviouslyFocusedElement(element) {
-  clearDisconnectedPreviouslyFocusedElements();
-  if (element && getNodeName(element) !== "body") {
-    previouslyFocusedElements.push(element);
-    if (previouslyFocusedElements.length > LIST_LIMIT) {
-      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
-    }
-  }
-}
-function getPreviouslyFocusedElement() {
-  clearDisconnectedPreviouslyFocusedElements();
-  return previouslyFocusedElements[previouslyFocusedElements.length - 1];
-}
-function getFirstTabbableElement(container) {
-  if (!container) {
-    return null;
-  }
-  const tabbableOptions = getTabbableOptions();
-  if (isTabbable(container, tabbableOptions)) {
-    return container;
-  }
-  return tabbable(container, tabbableOptions)[0] || container;
-}
-function handleTabIndex(floatingFocusElement, orderRef) {
-  var _a;
-  if (!orderRef.current.includes("floating") && !((_a = floatingFocusElement.getAttribute("role")) == null ? void 0 : _a.includes("dialog"))) {
-    return;
-  }
-  const options = getTabbableOptions();
-  const focusableElements = focusable(floatingFocusElement, options);
-  const tabbableContent = focusableElements.filter((element) => {
-    const dataTabIndex = element.getAttribute("data-tabindex") || "";
-    return isTabbable(element, options) || element.hasAttribute("data-tabindex") && !dataTabIndex.startsWith("-");
-  });
-  const tabIndex = floatingFocusElement.getAttribute("tabindex");
-  if (orderRef.current.includes("floating") || tabbableContent.length === 0) {
-    if (tabIndex !== "0") {
-      floatingFocusElement.setAttribute("tabindex", "0");
-    }
-  } else if (tabIndex !== "-1" || floatingFocusElement.hasAttribute("data-tabindex") && floatingFocusElement.getAttribute("data-tabindex") !== "-1") {
-    floatingFocusElement.setAttribute("tabindex", "-1");
-    floatingFocusElement.setAttribute("data-tabindex", "-1");
-  }
-}
-function FloatingFocusManager(props) {
-  const {
-    context,
-    children,
-    disabled = false,
-    order = ["content"],
-    initialFocus = true,
-    returnFocus = true,
-    restoreFocus = false,
-    modal = true,
-    closeOnFocusOut = true,
-    openInteractionType = "",
-    getInsideElements: getInsideElementsProp = () => []
-  } = props;
-  const {
-    open,
-    onOpenChange,
-    events,
-    dataRef,
-    elements: {
-      domReference,
-      floating
-    }
-  } = context;
-  const getNodeId = useEventCallback(() => {
-    var _a;
-    return (_a = dataRef.current.floatingContext) == null ? void 0 : _a.nodeId;
-  });
-  const getInsideElements = useEventCallback(getInsideElementsProp);
-  const ignoreInitialFocus = initialFocus === false;
-  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
-  const orderRef = useLatestRef(order);
-  const initialFocusRef = useLatestRef(initialFocus);
-  const returnFocusRef = useLatestRef(returnFocus);
-  const openInteractionTypeRef = useLatestRef(openInteractionType);
-  const tree = useFloatingTree();
-  const portalContext = usePortalContext();
-  const startDismissButtonRef = React.useRef(null);
-  const endDismissButtonRef = React.useRef(null);
-  const preventReturnFocusRef = React.useRef(false);
-  const isPointerDownRef = React.useRef(false);
-  const tabbableIndexRef = React.useRef(-1);
-  const closeTypeRef = React.useRef("");
-  const lastInteractionTypeRef = React.useRef("");
-  const blurTimeout = useTimeout();
-  const pointerDownTimeout = useTimeout();
-  const restoreFocusFrame = useAnimationFrame();
-  const isInsidePortal = portalContext != null;
-  const floatingFocusElement = getFloatingFocusElement(floating);
-  const getTabbableContent = useEventCallback((container = floatingFocusElement) => {
-    return container ? tabbable(container, getTabbableOptions()) : [];
-  });
-  const getTabbableElements = useEventCallback((container) => {
-    const content = getTabbableContent(container);
-    return orderRef.current.map(() => content).filter(Boolean).flat();
-  });
-  React.useEffect(() => {
-    if (disabled) {
-      return void 0;
-    }
-    if (!modal) {
-      return void 0;
-    }
-    function onKeyDown(event) {
-      if (event.key === "Tab") {
-        if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
-          stopEvent(event);
-        }
-      }
-    }
-    const doc = getDocument(floatingFocusElement);
-    doc.addEventListener("keydown", onKeyDown);
-    return () => {
-      doc.removeEventListener("keydown", onKeyDown);
-    };
-  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
-  React.useEffect(() => {
-    if (disabled) {
-      return void 0;
-    }
-    if (!floating) {
-      return void 0;
-    }
-    function handleFocusIn(event) {
-      const target = getTarget(event);
-      const tabbableContent = getTabbableContent();
-      const tabbableIndex = tabbableContent.indexOf(target);
-      if (tabbableIndex !== -1) {
-        tabbableIndexRef.current = tabbableIndex;
-      }
-    }
-    floating.addEventListener("focusin", handleFocusIn);
-    return () => {
-      floating.removeEventListener("focusin", handleFocusIn);
-    };
-  }, [disabled, floating, getTabbableContent]);
-  React.useEffect(() => {
-    if (disabled || !open) {
-      return void 0;
-    }
-    const doc = getDocument(floatingFocusElement);
-    function onPointerDown(event) {
-      lastInteractionTypeRef.current = event.pointerType || "keyboard";
-    }
-    function onKeyDown() {
-      lastInteractionTypeRef.current = "keyboard";
-    }
-    doc.addEventListener("pointerdown", onPointerDown, true);
-    doc.addEventListener("keydown", onKeyDown, true);
-    return () => {
-      doc.removeEventListener("pointerdown", onPointerDown, true);
-      doc.removeEventListener("keydown", onKeyDown, true);
-    };
-  }, [disabled, floating, domReference, floatingFocusElement, open]);
-  React.useEffect(() => {
-    if (disabled) {
-      return void 0;
-    }
-    if (!closeOnFocusOut) {
-      return void 0;
-    }
-    function handlePointerDown() {
-      isPointerDownRef.current = true;
-      pointerDownTimeout.start(0, () => {
-        isPointerDownRef.current = false;
-      });
-    }
-    function handleFocusOutside(event) {
-      const relatedTarget = event.relatedTarget;
-      const currentTarget = event.currentTarget;
-      const target = getTarget(event);
-      queueMicrotask(() => {
-        const nodeId = getNodeId();
-        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || (relatedTarget == null ? void 0 : relatedTarget.hasAttribute(createAttribute("focus-guard"))) || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find((node) => {
-          var _a, _b;
-          return contains((_a = node.context) == null ? void 0 : _a.elements.floating, relatedTarget) || contains((_b = node.context) == null ? void 0 : _b.elements.domReference, relatedTarget);
-        }) || getNodeAncestors(tree.nodesRef.current, nodeId).find((node) => {
-          var _a, _b, _c;
-          return [(_a = node.context) == null ? void 0 : _a.elements.floating, getFloatingFocusElement((_b = node.context) == null ? void 0 : _b.elements.floating)].includes(relatedTarget) || ((_c = node.context) == null ? void 0 : _c.elements.domReference) === relatedTarget;
-        })));
-        if (currentTarget === domReference && floatingFocusElement) {
-          handleTabIndex(floatingFocusElement, orderRef);
-        }
-        if (restoreFocus && currentTarget !== domReference && !(target == null ? void 0 : target.isConnected) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {
-          if (isHTMLElement(floatingFocusElement)) {
-            floatingFocusElement.focus();
-            if (restoreFocus === "popup") {
-              restoreFocusFrame.request(() => {
-                floatingFocusElement.focus();
-              });
-              return;
-            }
-          }
-          const prevTabbableIndex = tabbableIndexRef.current;
-          const tabbableContent = getTabbableContent();
-          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
-          if (isHTMLElement(nodeToFocus)) {
-            nodeToFocus.focus();
-          }
-        }
-        if (dataRef.current.insideReactTree) {
-          dataRef.current.insideReactTree = false;
-          return;
-        }
-        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && // Fix React 18 Strict Mode returnFocus due to double rendering.
-        // For an "untrapped" typeable combobox (input role=combobox with
-        // initialFocus=false), re-opening the popup and tabbing out should still close it even
-        // when the previously focused element (e.g. the next tabbable outside the popup) is
-        // focused again. Otherwise, the popup remains open on the second Tab sequence:
-        // click input -> Tab (closes) -> click input -> Tab.
-        // Allow closing when `isUntrappedTypeableCombobox` regardless of the previously focused element.
-        (isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {
-          preventReturnFocusRef.current = true;
-          onOpenChange(false, createChangeEventDetails("focus-out", event));
-        }
-      });
-    }
-    function markInsideReactTree() {
-      dataRef.current.insideReactTree = true;
-      blurTimeout.start(0, () => {
-        dataRef.current.insideReactTree = false;
-      });
-    }
-    if (floating && isHTMLElement(domReference)) {
-      domReference.addEventListener("focusout", handleFocusOutside);
-      domReference.addEventListener("pointerdown", handlePointerDown);
-      floating.addEventListener("focusout", handleFocusOutside);
-      if (portalContext) {
-        floating.addEventListener("focusout", markInsideReactTree, true);
-      }
-      return () => {
-        domReference.removeEventListener("focusout", handleFocusOutside);
-        domReference.removeEventListener("pointerdown", handlePointerDown);
-        floating.removeEventListener("focusout", handleFocusOutside);
-        if (portalContext) {
-          floating.removeEventListener("focusout", markInsideReactTree, true);
-        }
-      };
-    }
-    return void 0;
-  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId, orderRef, dataRef, blurTimeout, pointerDownTimeout, restoreFocusFrame]);
-  const beforeGuardRef = React.useRef(null);
-  const afterGuardRef = React.useRef(null);
-  const mergedBeforeGuardRef = useMergedRefs(beforeGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef);
-  const mergedAfterGuardRef = useMergedRefs(afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef);
-  React.useEffect(() => {
-    var _a, _b, _c;
-    if (disabled || !floating || !open) {
-      return void 0;
-    }
-    const portalNodes = Array.from(((_a = portalContext == null ? void 0 : portalContext.portalNode) == null ? void 0 : _a.querySelectorAll(`[${createAttribute("portal")}]`)) || []);
-    const ancestors = tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : [];
-    const rootAncestorComboboxDomReference = (_c = (_b = ancestors.find((node) => {
-      var _a2;
-      return isTypeableCombobox(((_a2 = node.context) == null ? void 0 : _a2.elements.domReference) || null);
-    })) == null ? void 0 : _b.context) == null ? void 0 : _c.elements.domReference;
-    const insideElements = [floating, rootAncestorComboboxDomReference, ...portalNodes, ...getInsideElements(), startDismissButtonRef.current, endDismissButtonRef.current, beforeGuardRef.current, afterGuardRef.current, portalContext == null ? void 0 : portalContext.beforeOutsideRef.current, portalContext == null ? void 0 : portalContext.afterOutsideRef.current, isUntrappedTypeableCombobox ? domReference : null].filter((x) => x != null);
-    const cleanup = markOthers(insideElements, modal || isUntrappedTypeableCombobox);
-    return () => {
-      cleanup();
-    };
-  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, getInsideElements]);
-  useIsoLayoutEffect(() => {
-    if (disabled || !isHTMLElement(floatingFocusElement)) {
-      return;
-    }
-    const doc = getDocument(floatingFocusElement);
-    const previouslyFocusedElement = activeElement(doc);
-    queueMicrotask(() => {
-      const focusableElements = getTabbableElements(floatingFocusElement);
-      const initialFocusValueOrFn = initialFocusRef.current;
-      const resolvedInitialFocus = typeof initialFocusValueOrFn === "function" ? initialFocusValueOrFn(openInteractionTypeRef.current || "") : initialFocusValueOrFn;
-      if (resolvedInitialFocus === void 0 || resolvedInitialFocus === false) {
-        return;
-      }
-      let elToFocus;
-      if (resolvedInitialFocus === true || resolvedInitialFocus === null) {
-        elToFocus = focusableElements[0] || floatingFocusElement;
-      } else if ("current" in resolvedInitialFocus) {
-        elToFocus = resolvedInitialFocus.current;
-      } else {
-        elToFocus = resolvedInitialFocus;
-      }
-      elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;
-      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);
-      if (!focusAlreadyInsideFloatingEl && open) {
-        enqueueFocus(elToFocus, {
-          preventScroll: elToFocus === floatingFocusElement
-        });
-      }
-    });
-  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef, openInteractionTypeRef]);
-  useIsoLayoutEffect(() => {
-    if (disabled || !floatingFocusElement) {
-      return void 0;
-    }
-    const doc = getDocument(floatingFocusElement);
-    const previouslyFocusedElement = activeElement(doc);
-    addPreviouslyFocusedElement(previouslyFocusedElement);
-    function onOpenChangeLocal(details) {
-      if (!details.open) {
-        closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
-      }
-      if (details.reason === "trigger-hover" && details.nativeEvent.type === "mouseleave") {
-        preventReturnFocusRef.current = true;
-      }
-      if (details.reason !== "outside-press") {
-        return;
-      }
-      if (details.nested) {
-        preventReturnFocusRef.current = false;
-      } else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) {
-        preventReturnFocusRef.current = false;
-      } else {
-        let isPreventScrollSupported = false;
-        document.createElement("div").focus({
-          get preventScroll() {
-            isPreventScrollSupported = true;
-            return false;
-          }
-        });
-        if (isPreventScrollSupported) {
-          preventReturnFocusRef.current = false;
-        } else {
-          preventReturnFocusRef.current = true;
-        }
-      }
-    }
-    events.on("openchange", onOpenChangeLocal);
-    const fallbackEl = doc.createElement("span");
-    fallbackEl.setAttribute("tabindex", "-1");
-    fallbackEl.setAttribute("aria-hidden", "true");
-    Object.assign(fallbackEl.style, visuallyHidden);
-    if (isInsidePortal && domReference) {
-      domReference.insertAdjacentElement("afterend", fallbackEl);
-    }
-    function getReturnElement() {
-      const returnFocusValueOrFn = returnFocusRef.current;
-      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === "function" ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
-      if (resolvedReturnFocusValue === void 0 || resolvedReturnFocusValue === false) {
-        return null;
-      }
-      if (resolvedReturnFocusValue === null) {
-        resolvedReturnFocusValue = true;
-      }
-      if (typeof resolvedReturnFocusValue === "boolean") {
-        const el = domReference || getPreviouslyFocusedElement();
-        return el && el.isConnected ? el : fallbackEl;
-      }
-      const fallback = domReference || getPreviouslyFocusedElement() || fallbackEl;
-      if ("current" in resolvedReturnFocusValue) {
-        return resolvedReturnFocusValue.current || fallback;
-      }
-      return resolvedReturnFocusValue || fallback;
-    }
-    return () => {
-      events.off("openchange", onOpenChangeLocal);
-      const activeEl = activeElement(doc);
-      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node) => {
-        var _a;
-        return contains((_a = node.context) == null ? void 0 : _a.elements.floating, activeEl);
-      });
-      const returnElement = getReturnElement();
-      queueMicrotask(() => {
-        const tabbableReturnElement = getFirstTabbableElement(returnElement);
-        const hasExplicitReturnFocus = typeof returnFocusRef.current !== "boolean";
-        if (
-          // eslint-disable-next-line react-hooks/exhaustive-deps
-          returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && // If the focus moved somewhere else after mount, avoid returning focus
-          // since it likely entered a different element which should be
-          // respected: https://github.com/floating-ui/floating-ui/issues/2607
-          (!hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)
-        ) {
-          tabbableReturnElement.focus({
-            preventScroll: true
-          });
-        }
-        fallbackEl.remove();
-      });
-    };
-  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, isInsidePortal, domReference, getNodeId]);
-  React.useEffect(() => {
-    queueMicrotask(() => {
-      preventReturnFocusRef.current = false;
-    });
-  }, [disabled]);
-  React.useEffect(() => {
-    if (disabled || !open) {
-      return void 0;
-    }
-    function handlePointerDown(event) {
-      const target = getTarget(event);
-      if (target == null ? void 0 : target.closest(`[${CLICK_TRIGGER_IDENTIFIER}]`)) {
-        isPointerDownRef.current = true;
-      }
-    }
-    const doc = getDocument(floatingFocusElement);
-    doc.addEventListener("pointerdown", handlePointerDown, true);
-    return () => {
-      doc.removeEventListener("pointerdown", handlePointerDown, true);
-    };
-  }, [disabled, open, floatingFocusElement]);
-  useIsoLayoutEffect(() => {
-    if (disabled) {
-      return void 0;
-    }
-    if (!portalContext) {
-      return void 0;
-    }
-    portalContext.setFocusManagerState({
-      modal,
-      closeOnFocusOut,
-      open,
-      onOpenChange,
-      domReference
-    });
-    return () => {
-      portalContext.setFocusManagerState(null);
-    };
-  }, [disabled, portalContext, modal, open, onOpenChange, closeOnFocusOut, domReference]);
-  useIsoLayoutEffect(() => {
-    if (disabled || !floatingFocusElement) {
-      return void 0;
-    }
-    handleTabIndex(floatingFocusElement, orderRef);
-    return () => {
-      queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
-    };
-  }, [disabled, floatingFocusElement, orderRef]);
-  const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
-  return /* @__PURE__ */ jsxs(React.Fragment, {
-    children: [shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
-      "data-type": "inside",
-      ref: mergedBeforeGuardRef,
-      onFocus: (event) => {
-        var _a;
-        if (modal) {
-          const els = getTabbableElements();
-          enqueueFocus(els[els.length - 1]);
-        } else if ((portalContext == null ? void 0 : portalContext.preserveTabOrder) && portalContext.portalNode) {
-          preventReturnFocusRef.current = false;
-          if (isOutsideEvent(event, portalContext.portalNode)) {
-            const nextTabbable = getNextTabbable(domReference);
-            nextTabbable == null ? void 0 : nextTabbable.focus();
-          } else {
-            (_a = portalContext.beforeOutsideRef.current) == null ? void 0 : _a.focus();
-          }
-        }
-      }
-    }), children, shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
-      "data-type": "inside",
-      ref: mergedAfterGuardRef,
-      onFocus: (event) => {
-        var _a;
-        if (modal) {
-          enqueueFocus(getTabbableElements()[0]);
-        } else if ((portalContext == null ? void 0 : portalContext.preserveTabOrder) && portalContext.portalNode) {
-          if (closeOnFocusOut) {
-            preventReturnFocusRef.current = true;
-          }
-          if (isOutsideEvent(event, portalContext.portalNode)) {
-            const prevTabbable = getPreviousTabbable(domReference);
-            prevTabbable == null ? void 0 : prevTabbable.focus();
-          } else {
-            (_a = portalContext.afterOutsideRef.current) == null ? void 0 : _a.focus();
-          }
-        }
-      }
-    })]
-  });
-}
-function useClick(context, props = {}) {
-  const {
-    open,
-    onOpenChange,
-    dataRef
-  } = context;
-  const {
-    enabled = true,
-    event: eventOption = "click",
-    toggle = true,
-    ignoreMouse = false,
-    stickIfOpen = true,
-    touchOpenDelay = 0
-  } = props;
-  const pointerTypeRef = React.useRef(void 0);
-  const frame = useAnimationFrame();
-  const touchOpenTimeout = useTimeout();
-  const reference = React.useMemo(() => ({
-    onPointerDown(event) {
-      pointerTypeRef.current = event.pointerType;
-    },
-    onMouseDown(event) {
-      const pointerType = pointerTypeRef.current;
-      const nativeEvent = event.nativeEvent;
-      if (event.button !== 0 || eventOption === "click" || isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
-      }
-      const openEvent = dataRef.current.openEvent;
-      const openEventType = openEvent == null ? void 0 : openEvent.type;
-      const nextOpen = !(open && toggle && (openEvent && stickIfOpen ? openEventType === "click" || openEventType === "mousedown" : true));
-      if (isTypeableElement(nativeEvent.target)) {
-        const details = createChangeEventDetails("trigger-press", nativeEvent);
-        if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            onOpenChange(true, details);
-          });
-        } else {
-          onOpenChange(nextOpen, details);
-        }
-        return;
-      }
-      frame.request(() => {
-        const details = createChangeEventDetails("trigger-press", nativeEvent);
-        if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            onOpenChange(true, details);
-          });
-        } else {
-          onOpenChange(nextOpen, details);
-        }
-      });
-    },
-    onClick(event) {
-      if (eventOption === "mousedown-only") {
-        return;
-      }
-      const pointerType = pointerTypeRef.current;
-      if (eventOption === "mousedown" && pointerType) {
-        pointerTypeRef.current = void 0;
-        return;
-      }
-      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
-      }
-      const openEvent = dataRef.current.openEvent;
-      const openEventType = openEvent == null ? void 0 : openEvent.type;
-      const nextOpen = !(open && toggle && (openEvent && stickIfOpen ? openEventType === "click" || openEventType === "mousedown" || openEventType === "keydown" || openEventType === "keyup" : true));
-      const details = createChangeEventDetails("trigger-press", event.nativeEvent);
-      if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) {
-        touchOpenTimeout.start(touchOpenDelay, () => {
-          onOpenChange(true, details);
-        });
-      } else {
-        onOpenChange(nextOpen, details);
-      }
-    },
-    onKeyDown() {
-      pointerTypeRef.current = void 0;
-    }
-  }), [dataRef, eventOption, ignoreMouse, onOpenChange, open, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay]);
-  return React.useMemo(() => enabled ? {
-    reference
-  } : EMPTY_OBJECT, [enabled, reference]);
-}
-const bubbleHandlerKeys = {
-  intentional: "onClick",
-  sloppy: "onPointerDown"
-};
-function normalizeProp(normalizable) {
-  var _a, _b;
-  return {
-    escapeKey: typeof normalizable === "boolean" ? normalizable : (_a = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _a : false,
-    outsidePress: typeof normalizable === "boolean" ? normalizable : (_b = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _b : true
-  };
-}
-function useDismiss(context, props = {}) {
-  const {
-    open,
-    onOpenChange,
-    elements,
-    dataRef
-  } = context;
-  const {
-    enabled = true,
-    escapeKey = true,
-    outsidePress: outsidePressProp = true,
-    outsidePressEvent = "sloppy",
-    referencePress = false,
-    referencePressEvent = "sloppy",
-    ancestorScroll = false,
-    bubbles,
-    capture
-  } = props;
-  const tree = useFloatingTree();
-  const outsidePressFn = useEventCallback(typeof outsidePressProp === "function" ? outsidePressProp : () => false);
-  const outsidePress = typeof outsidePressProp === "function" ? outsidePressFn : outsidePressProp;
-  const endedOrStartedInsideRef = React.useRef(false);
-  const {
-    escapeKey: escapeKeyBubbles,
-    outsidePress: outsidePressBubbles
-  } = normalizeProp(bubbles);
-  const {
-    escapeKey: escapeKeyCapture,
-    outsidePress: outsidePressCapture
-  } = normalizeProp(capture);
-  const touchStateRef = React.useRef(null);
-  const cancelDismissOnEndTimeout = useTimeout();
-  const insideReactTreeTimeout = useTimeout();
-  const isComposingRef = React.useRef(false);
-  const currentPointerTypeRef = React.useRef("");
-  const trackPointerType = useEventCallback((event) => {
-    currentPointerTypeRef.current = event.pointerType;
-  });
-  const getOutsidePressEvent = useEventCallback(() => {
-    const type = currentPointerTypeRef.current;
-    const computedType = type === "pen" || !type ? "mouse" : type;
-    const resolved = typeof outsidePressEvent === "function" ? outsidePressEvent() : outsidePressEvent;
-    if (typeof resolved === "string") {
-      return resolved;
-    }
-    return resolved[computedType];
-  });
-  const closeOnEscapeKeyDown = useEventCallback((event) => {
-    var _a;
-    if (!open || !enabled || !escapeKey || event.key !== "Escape") {
-      return;
-    }
-    if (isComposingRef.current) {
-      return;
-    }
-    const nodeId = (_a = dataRef.current.floatingContext) == null ? void 0 : _a.nodeId;
-    const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
-    if (!escapeKeyBubbles) {
-      if (children.length > 0) {
-        let shouldDismiss = true;
-        children.forEach((child) => {
-          var _a2;
-          if (((_a2 = child.context) == null ? void 0 : _a2.open) && !child.context.dataRef.current.__escapeKeyBubbles) {
-            shouldDismiss = false;
-          }
-        });
-        if (!shouldDismiss) {
-          return;
-        }
-      }
-    }
-    const native = isReactEvent(event) ? event.nativeEvent : event;
-    const eventDetails = createChangeEventDetails("escape-key", native);
-    onOpenChange(false, eventDetails);
-    if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) {
-      event.stopPropagation();
-    }
-  });
-  const shouldIgnoreEvent = useEventCallback((event) => {
-    const computedOutsidePressEvent = getOutsidePressEvent();
-    return computedOutsidePressEvent === "intentional" && event.type !== "click" || computedOutsidePressEvent === "sloppy" && event.type === "click";
-  });
-  const closeOnEscapeKeyDownCapture = useEventCallback((event) => {
-    var _a;
-    const callback = () => {
-      var _a2;
-      closeOnEscapeKeyDown(event);
-      (_a2 = getTarget(event)) == null ? void 0 : _a2.removeEventListener("keydown", callback);
-    };
-    (_a = getTarget(event)) == null ? void 0 : _a.addEventListener("keydown", callback);
-  });
-  const closeOnPressOutside = useEventCallback((event, endedOrStartedInside = false) => {
-    var _a;
-    if (shouldIgnoreEvent(event)) {
-      return;
-    }
-    const insideReactTree = dataRef.current.insideReactTree;
-    dataRef.current.insideReactTree = false;
-    if (getOutsidePressEvent() === "intentional" && endedOrStartedInside) {
-      return;
-    }
-    if (insideReactTree) {
-      return;
-    }
-    if (typeof outsidePress === "function" && !outsidePress(event)) {
-      return;
-    }
-    const target = getTarget(event);
-    const inertSelector = `[${createAttribute("inert")}]`;
-    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);
-    let targetRootAncestor = isElement(target) ? target : null;
-    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
-      const nextParent = getParentNode(targetRootAncestor);
-      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
-        break;
-      }
-      targetRootAncestor = nextParent;
-    }
-    if (markers.length && isElement(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
-    !contains(target, elements.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;
-    }
-    if (isHTMLElement(target)) {
-      const lastTraversableNode = isLastTraversableNode(target);
-      const style = getComputedStyle$1(target);
-      const scrollRe = /auto|scroll/;
-      const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
-      const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
-      const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
-      const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
-      const isRTL = style.direction === "rtl";
-      const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
-      const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
-      if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {
-        return;
-      }
-    }
-    const nodeId = (_a = dataRef.current.floatingContext) == null ? void 0 : _a.nodeId;
-    const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node) => {
-      var _a2;
-      return isEventTargetWithin(event, (_a2 = node.context) == null ? void 0 : _a2.elements.floating);
-    });
-    if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) {
-      return;
-    }
-    const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
-    if (children.length > 0) {
-      let shouldDismiss = true;
-      children.forEach((child) => {
-        var _a2;
-        if (((_a2 = child.context) == null ? void 0 : _a2.open) && !child.context.dataRef.current.__outsidePressBubbles) {
-          shouldDismiss = false;
-        }
-      });
-      if (!shouldDismiss) {
-        return;
-      }
-    }
-    onOpenChange(false, createChangeEventDetails("outside-press", event));
-  });
-  const handlePointerDown = useEventCallback((event) => {
-    if (getOutsidePressEvent() !== "sloppy" || !open || !enabled || isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference)) {
-      return;
-    }
-    if (event.pointerType === "touch") {
-      touchStateRef.current = {
-        startTime: Date.now(),
-        startX: event.clientX,
-        startY: event.clientY,
-        dismissOnPointerUp: false,
-        dismissOnMouseDown: true
-      };
-      cancelDismissOnEndTimeout.start(1e3, () => {
-        if (touchStateRef.current) {
-          touchStateRef.current.dismissOnPointerUp = false;
-          touchStateRef.current.dismissOnMouseDown = false;
-        }
-      });
-      return;
-    }
-    closeOnPressOutside(event);
-  });
-  const closeOnPressOutsideCapture = useEventCallback((event) => {
-    var _a;
-    const endedOrStartedInside = endedOrStartedInsideRef.current;
-    endedOrStartedInsideRef.current = false;
-    if (shouldIgnoreEvent(event)) {
-      return;
-    }
-    cancelDismissOnEndTimeout.clear();
-    if (event.type === "mousedown" && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
-      return;
-    }
-    const callback = () => {
-      var _a2;
-      if (event.type === "pointerdown") {
-        handlePointerDown(event);
-      } else {
-        closeOnPressOutside(event, endedOrStartedInside);
-      }
-      (_a2 = getTarget(event)) == null ? void 0 : _a2.removeEventListener(event.type, callback);
-    };
-    (_a = getTarget(event)) == null ? void 0 : _a.addEventListener(event.type, callback);
-  });
-  const handlePointerMove = useEventCallback((event) => {
-    if (getOutsidePressEvent() !== "sloppy" || event.pointerType !== "touch" || !touchStateRef.current || isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference)) {
-      return;
-    }
-    const deltaX = Math.abs(event.clientX - touchStateRef.current.startX);
-    const deltaY = Math.abs(event.clientY - touchStateRef.current.startY);
-    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-    if (distance > 5) {
-      touchStateRef.current.dismissOnPointerUp = true;
-    }
-    if (distance > 10) {
-      closeOnPressOutside(event);
-      cancelDismissOnEndTimeout.clear();
-      touchStateRef.current = null;
-    }
-  });
-  const handlePointerUp = useEventCallback((event) => {
-    if (getOutsidePressEvent() !== "sloppy" || event.pointerType !== "touch" || !touchStateRef.current || isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference)) {
-      return;
-    }
-    if (touchStateRef.current.dismissOnPointerUp) {
-      closeOnPressOutside(event);
-    }
-    cancelDismissOnEndTimeout.clear();
-    touchStateRef.current = null;
-  });
-  React.useEffect(() => {
-    if (!open || !enabled) {
-      return void 0;
-    }
-    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
-    dataRef.current.__outsidePressBubbles = outsidePressBubbles;
-    const compositionTimeout = new Timeout();
-    function onScroll(event) {
-      onOpenChange(false, createChangeEventDetails("none", event));
-    }
-    function handleCompositionStart() {
-      compositionTimeout.clear();
-      isComposingRef.current = true;
-    }
-    function handleCompositionEnd() {
-      compositionTimeout.start(
-        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
-        // Only apply to WebKit for the test to remain 0ms.
-        isWebKit$1() ? 5 : 0,
-        () => {
-          isComposingRef.current = false;
-        }
-      );
-    }
-    const doc = getDocument(elements.floating);
-    doc.addEventListener("pointerdown", trackPointerType, true);
-    if (escapeKey) {
-      doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
-      doc.addEventListener("compositionstart", handleCompositionStart);
-      doc.addEventListener("compositionend", handleCompositionEnd);
-    }
-    if (outsidePress) {
-      doc.addEventListener("click", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
-      doc.addEventListener("pointerdown", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
-      doc.addEventListener("pointermove", handlePointerMove, outsidePressCapture);
-      doc.addEventListener("pointerup", handlePointerUp, outsidePressCapture);
-      doc.addEventListener("mousedown", closeOnPressOutsideCapture, outsidePressCapture);
-    }
-    let ancestors = [];
-    if (ancestorScroll) {
-      if (isElement(elements.domReference)) {
-        ancestors = getOverflowAncestors(elements.domReference);
-      }
-      if (isElement(elements.floating)) {
-        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));
-      }
-      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {
-        ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));
-      }
-    }
-    ancestors = ancestors.filter((ancestor) => {
-      var _a;
-      return ancestor !== ((_a = doc.defaultView) == null ? void 0 : _a.visualViewport);
-    });
-    ancestors.forEach((ancestor) => {
-      ancestor.addEventListener("scroll", onScroll, {
-        passive: true
-      });
-    });
-    return () => {
-      doc.removeEventListener("pointerdown", trackPointerType, true);
-      if (escapeKey) {
-        doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
-        doc.removeEventListener("compositionstart", handleCompositionStart);
-        doc.removeEventListener("compositionend", handleCompositionEnd);
-      }
-      if (outsidePress) {
-        doc.removeEventListener("click", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
-        doc.removeEventListener("pointerdown", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
-        doc.removeEventListener("pointermove", handlePointerMove, outsidePressCapture);
-        doc.removeEventListener("pointerup", handlePointerUp, outsidePressCapture);
-        doc.removeEventListener("mousedown", closeOnPressOutsideCapture, outsidePressCapture);
-      }
-      ancestors.forEach((ancestor) => {
-        ancestor.removeEventListener("scroll", onScroll);
-      });
-      compositionTimeout.clear();
-    };
-  }, [dataRef, elements, escapeKey, outsidePress, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture, handlePointerDown, handlePointerMove, handlePointerUp, trackPointerType]);
-  React.useEffect(() => {
-    dataRef.current.insideReactTree = false;
-  }, [dataRef, outsidePress]);
-  const reference = React.useMemo(() => ({
-    onKeyDown: closeOnEscapeKeyDown,
-    ...referencePress && {
-      [bubbleHandlerKeys[referencePressEvent]]: (event) => {
-        onOpenChange(false, createChangeEventDetails("trigger-press", event.nativeEvent));
-      },
-      ...referencePressEvent !== "intentional" && {
-        onClick(event) {
-          onOpenChange(false, createChangeEventDetails("trigger-press", event.nativeEvent));
-        }
-      }
-    }
-  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);
-  const handlePressedInside = useEventCallback((event) => {
-    const target = getTarget(event.nativeEvent);
-    if (!contains(elements.floating, target) || event.button !== 0) {
-      return;
-    }
-    endedOrStartedInsideRef.current = true;
-  });
-  const handleCaptureInside = useEventCallback(() => {
-    dataRef.current.insideReactTree = true;
-    insideReactTreeTimeout.start(0, () => {
-      dataRef.current.insideReactTree = false;
-    });
-  });
-  const floating = React.useMemo(() => ({
-    onKeyDown: closeOnEscapeKeyDown,
-    onMouseDown: handlePressedInside,
-    onMouseUp: handlePressedInside,
-    onPointerDownCapture: handleCaptureInside,
-    onMouseDownCapture: handleCaptureInside,
-    onClickCapture: handleCaptureInside,
-    onMouseUpCapture: handleCaptureInside
-  }), [closeOnEscapeKeyDown, handlePressedInside, handleCaptureInside]);
-  return React.useMemo(() => enabled ? {
-    reference,
-    floating
-  } : {}, [enabled, reference, floating]);
-}
-function useFloatingRootContext(options) {
-  const {
-    open = false,
-    onOpenChange: onOpenChangeProp,
-    elements: elementsProp
-  } = options;
-  const floatingId = useId();
-  const dataRef = React.useRef({});
-  const [events] = React.useState(() => createEventEmitter());
-  const nested = useFloatingParentNodeId() != null;
-  if (process.env.NODE_ENV !== "production") {
-    const optionDomReference = elementsProp.reference;
-    if (optionDomReference && !isElement(optionDomReference)) {
-      console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
-    }
-  }
-  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);
-  const onOpenChange = useEventCallback((newOpen, eventDetails) => {
-    dataRef.current.openEvent = newOpen ? eventDetails.event : void 0;
-    if (!options.noEmit) {
-      const details = {
-        open: newOpen,
-        reason: eventDetails.reason,
-        nativeEvent: eventDetails.event,
-        nested
-      };
-      events.emit("openchange", details);
-    }
-    onOpenChangeProp == null ? void 0 : onOpenChangeProp(newOpen, eventDetails);
-  });
-  const refs = React.useMemo(() => ({
-    setPositionReference
-  }), []);
-  const elements = React.useMemo(() => ({
-    reference: positionReference || elementsProp.reference || null,
-    floating: elementsProp.floating || null,
-    domReference: elementsProp.reference
-  }), [positionReference, elementsProp.reference, elementsProp.floating]);
-  return React.useMemo(() => ({
-    dataRef,
-    open,
-    onOpenChange,
-    elements,
-    events,
-    floatingId,
-    refs
-  }), [open, onOpenChange, elements, events, floatingId, refs]);
-}
-function getEmptyContext() {
-  return {
-    open: false,
-    onOpenChange: () => {
-    },
-    dataRef: {
-      current: {}
-    },
-    elements: {
-      floating: null,
-      reference: null,
-      domReference: null
-    },
-    events: {
-      on: () => {
-      },
-      off: () => {
-      },
-      emit: () => {
-      }
-    },
-    floatingId: "",
-    refs: {
-      setPositionReference: () => {
-      }
-    }
-  };
-}
-function useInteractions(propsList = []) {
-  const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
-  const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
-  const itemDeps = propsList.map((key) => key == null ? void 0 : key.item);
-  const getReferenceProps = React.useCallback(
-    (userProps) => mergeProps(userProps, propsList, "reference"),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    referenceDeps
-  );
-  const getFloatingProps = React.useCallback(
-    (userProps) => mergeProps(userProps, propsList, "floating"),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    floatingDeps
-  );
-  const getItemProps = React.useCallback(
-    (userProps) => mergeProps(userProps, propsList, "item"),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    itemDeps
-  );
-  return React.useMemo(() => ({
-    getReferenceProps,
-    getFloatingProps,
-    getItemProps
-  }), [getReferenceProps, getFloatingProps, getItemProps]);
-}
-function mergeProps(userProps, propsList, elementKey) {
-  var _a;
-  const eventHandlers = /* @__PURE__ */ new Map();
-  const isItem = elementKey === "item";
-  const outputProps = {};
-  if (elementKey === "floating") {
-    outputProps.tabIndex = -1;
-    outputProps[FOCUSABLE_ATTRIBUTE] = "";
-  }
-  for (const key in userProps) {
-    if (isItem && userProps) {
-      if (key === ACTIVE_KEY || key === SELECTED_KEY) {
-        continue;
-      }
-    }
-    outputProps[key] = userProps[key];
-  }
-  for (let i = 0; i < propsList.length; i += 1) {
-    let props;
-    const propsOrGetProps = (_a = propsList[i]) == null ? void 0 : _a[elementKey];
-    if (typeof propsOrGetProps === "function") {
-      props = userProps ? propsOrGetProps(userProps) : null;
-    } else {
-      props = propsOrGetProps;
-    }
-    if (!props) {
-      continue;
-    }
-    mutablyMergeProps(outputProps, props, isItem, eventHandlers);
-  }
-  mutablyMergeProps(outputProps, userProps, isItem, eventHandlers);
-  return outputProps;
-}
-function mutablyMergeProps(outputProps, props, isItem, eventHandlers) {
-  var _a;
-  for (const key in props) {
-    const value = props[key];
-    if (isItem && (key === ACTIVE_KEY || key === SELECTED_KEY)) {
-      continue;
-    }
-    if (!key.startsWith("on")) {
-      outputProps[key] = value;
-    } else {
-      if (!eventHandlers.has(key)) {
-        eventHandlers.set(key, []);
-      }
-      if (typeof value === "function") {
-        (_a = eventHandlers.get(key)) == null ? void 0 : _a.push(value);
-        outputProps[key] = (...args) => {
-          var _a2;
-          return (_a2 = eventHandlers.get(key)) == null ? void 0 : _a2.map((fn) => fn(...args)).find((val) => val !== void 0);
-        };
-      }
-    }
-  }
-}
-const componentRoleToAriaRoleMap = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", false]]);
-function useRole(context, props = {}) {
-  var _a, _b;
-  const {
-    open,
-    elements,
-    floatingId: defaultFloatingId
-  } = context;
-  const {
-    enabled = true,
-    role = "dialog"
-  } = props;
-  const defaultReferenceId = useId();
-  const referenceId = ((_a = elements.domReference) == null ? void 0 : _a.id) || defaultReferenceId;
-  const floatingId = React.useMemo(() => {
-    var _a2;
-    return ((_a2 = getFloatingFocusElement(elements.floating)) == null ? void 0 : _a2.id) || defaultFloatingId;
-  }, [elements.floating, defaultFloatingId]);
-  const ariaRole = (_b = componentRoleToAriaRoleMap.get(role)) != null ? _b : role;
-  const parentId = useFloatingParentNodeId();
-  const isNested = parentId != null;
-  const reference = React.useMemo(() => {
-    if (ariaRole === "tooltip" || role === "label") {
-      return {
-        [`aria-${role === "label" ? "labelledby" : "describedby"}`]: open ? floatingId : void 0
-      };
-    }
-    return {
-      "aria-expanded": open ? "true" : "false",
-      "aria-haspopup": ariaRole === "alertdialog" ? "dialog" : ariaRole,
-      "aria-controls": open ? floatingId : void 0,
-      ...ariaRole === "listbox" && {
-        role: "combobox"
-      },
-      ...ariaRole === "menu" && {
-        id: referenceId
-      },
-      ...ariaRole === "menu" && isNested && {
-        role: "menuitem"
-      },
-      ...role === "select" && {
-        "aria-autocomplete": "none"
-      },
-      ...role === "combobox" && {
-        "aria-autocomplete": "list"
-      }
-    };
-  }, [ariaRole, floatingId, isNested, open, referenceId, role]);
-  const floating = React.useMemo(() => {
-    const floatingProps = {
-      id: floatingId,
-      ...ariaRole && {
-        role: ariaRole
-      }
-    };
-    if (ariaRole === "tooltip" || role === "label") {
-      return floatingProps;
-    }
-    return {
-      ...floatingProps,
-      ...ariaRole === "menu" && {
-        "aria-labelledby": referenceId
-      }
-    };
-  }, [ariaRole, floatingId, referenceId, role]);
-  const item = React.useCallback(({
-    active,
-    selected
-  }) => {
-    const commonProps = {
-      role: "option",
-      ...active && {
-        id: `${floatingId}-fui-option`
-      }
-    };
-    switch (role) {
-      case "select":
-      case "combobox":
-        return {
-          ...commonProps,
-          "aria-selected": selected
-        };
-    }
-    return {};
-  }, [floatingId, role]);
-  return React.useMemo(() => enabled ? {
-    reference,
-    floating,
-    item
-  } : {}, [enabled, reference, floating, item]);
-}
-const InternalBackdrop = /* @__PURE__ */ React.forwardRef(function InternalBackdrop2(props, ref) {
-  const {
-    cutout,
-    ...otherProps
-  } = props;
-  let clipPath;
-  if (cutout) {
-    const rect = cutout == null ? void 0 : cutout.getBoundingClientRect();
-    clipPath = `polygon(
-      0% 0%,
-      100% 0%,
-      100% 100%,
-      0% 100%,
-      0% 0%,
-      ${rect.left}px ${rect.top}px,
-      ${rect.left}px ${rect.bottom}px,
-      ${rect.right}px ${rect.bottom}px,
-      ${rect.right}px ${rect.top}px,
-      ${rect.left}px ${rect.top}px
-    )`;
-  }
-  return /* @__PURE__ */ jsx("div", {
-    ref,
-    role: "presentation",
-    "data-base-ui-inert": "",
-    ...otherProps,
-    style: {
-      position: "fixed",
-      inset: 0,
-      userSelect: "none",
-      WebkitUserSelect: "none",
-      clipPath
-    }
-  });
-});
-if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";
-let originalHtmlStyles = {};
-let originalBodyStyles = {};
-let originalHtmlScrollBehavior = "";
-function hasInsetScrollbars(referenceElement) {
-  if (typeof document === "undefined") {
-    return false;
-  }
-  const doc = ownerDocument(referenceElement);
-  const win = getWindow(doc);
-  return win.innerWidth - doc.documentElement.clientWidth > 0;
-}
-function preventScrollBasic(referenceElement) {
-  const doc = ownerDocument(referenceElement);
-  const html = doc.documentElement;
-  const originalOverflow = html.style.overflow;
-  html.style.overflow = "hidden";
-  return () => {
-    html.style.overflow = originalOverflow;
-  };
-}
-function preventScrollStandard(referenceElement) {
-  var _a, _b;
-  const doc = ownerDocument(referenceElement);
-  const html = doc.documentElement;
-  const body = doc.body;
-  const win = getWindow(html);
-  let scrollTop = 0;
-  let scrollLeft = 0;
-  const resizeFrame = AnimationFrame.create();
-  if (isWebKit && ((_b = (_a = win.visualViewport) == null ? void 0 : _a.scale) != null ? _b : 1) !== 1) {
-    return () => {
-    };
-  }
-  function lockScroll() {
-    var _a2;
-    const htmlStyles = win.getComputedStyle(html);
-    const bodyStyles = win.getComputedStyle(body);
-    scrollTop = html.scrollTop;
-    scrollLeft = html.scrollLeft;
-    originalHtmlStyles = {
-      scrollbarGutter: html.style.scrollbarGutter,
-      overflowY: html.style.overflowY,
-      overflowX: html.style.overflowX
-    };
-    originalHtmlScrollBehavior = html.style.scrollBehavior;
-    originalBodyStyles = {
-      position: body.style.position,
-      height: body.style.height,
-      width: body.style.width,
-      boxSizing: body.style.boxSizing,
-      overflowY: body.style.overflowY,
-      overflowX: body.style.overflowX,
-      scrollBehavior: body.style.scrollBehavior
-    };
-    const supportsStableScrollbarGutter = typeof CSS !== "undefined" && ((_a2 = CSS.supports) == null ? void 0 : _a2.call(CSS, "scrollbar-gutter", "stable"));
-    const isScrollableY = html.scrollHeight > html.clientHeight;
-    const isScrollableX = html.scrollWidth > html.clientWidth;
-    const hasConstantOverflowY = htmlStyles.overflowY === "scroll" || bodyStyles.overflowY === "scroll";
-    const hasConstantOverflowX = htmlStyles.overflowX === "scroll" || bodyStyles.overflowX === "scroll";
-    const scrollbarWidth = Math.max(0, win.innerWidth - html.clientWidth);
-    const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);
-    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
-    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
-    Object.assign(html.style, {
-      scrollbarGutter: "stable",
-      overflowY: !supportsStableScrollbarGutter && (isScrollableY || hasConstantOverflowY) ? "scroll" : "hidden",
-      overflowX: !supportsStableScrollbarGutter && (isScrollableX || hasConstantOverflowX) ? "scroll" : "hidden"
-    });
-    Object.assign(body.style, {
-      position: "relative",
-      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : "100dvh",
-      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : "100vw",
-      boxSizing: "border-box",
-      overflow: "hidden",
-      scrollBehavior: "unset"
-    });
-    body.scrollTop = scrollTop;
-    body.scrollLeft = scrollLeft;
-    html.setAttribute("data-base-ui-scroll-locked", "");
-    html.style.scrollBehavior = "unset";
-  }
-  function cleanup() {
-    Object.assign(html.style, originalHtmlStyles);
-    Object.assign(body.style, originalBodyStyles);
-    html.scrollTop = scrollTop;
-    html.scrollLeft = scrollLeft;
-    html.removeAttribute("data-base-ui-scroll-locked");
-    html.style.scrollBehavior = originalHtmlScrollBehavior;
-  }
-  function handleResize() {
-    cleanup();
-    resizeFrame.request(lockScroll);
-  }
-  lockScroll();
-  win.addEventListener("resize", handleResize);
-  return () => {
-    resizeFrame.cancel();
-    cleanup();
-    win.removeEventListener("resize", handleResize);
-  };
-}
-class ScrollLocker {
-  constructor() {
-    __publicField(this, "lockCount", 0);
-    __publicField(this, "restore", /* @__PURE__ */ (() => null)());
-    __publicField(this, "timeoutLock", (() => Timeout.create())());
-    __publicField(this, "timeoutUnlock", (() => Timeout.create())());
-    __publicField(this, "release", () => {
-      this.lockCount -= 1;
-      if (this.lockCount === 0 && this.restore) {
-        this.timeoutUnlock.start(0, this.unlock);
-      }
-    });
-    __publicField(this, "unlock", () => {
-      var _a;
-      if (this.lockCount === 0 && this.restore) {
-        (_a = this.restore) == null ? void 0 : _a.call(this);
-        this.restore = null;
-      }
-    });
-  }
-  acquire(referenceElement) {
-    this.lockCount += 1;
-    if (this.lockCount === 1 && this.restore === null) {
-      this.timeoutLock.start(0, () => this.lock(referenceElement));
-    }
-    return this.release;
-  }
-  lock(referenceElement) {
-    if (this.lockCount === 0 || this.restore !== null) {
-      return;
-    }
-    const doc = ownerDocument(referenceElement);
-    const html = doc.documentElement;
-    const htmlOverflowY = getWindow(html).getComputedStyle(html).overflowY;
-    if (htmlOverflowY === "hidden" || htmlOverflowY === "clip") {
-      this.restore = NOOP;
-      return;
-    }
-    const isOverflowHiddenLock = isIOS || !hasInsetScrollbars(referenceElement);
-    this.restore = isOverflowHiddenLock ? preventScrollBasic(referenceElement) : preventScrollStandard(referenceElement);
-  }
-}
-const SCROLL_LOCKER = new ScrollLocker();
-function useScrollLock(params) {
-  const {
-    enabled = true,
-    mounted,
-    open,
-    referenceElement = null
-  } = params;
-  useIsoLayoutEffect(() => {
-    if (enabled && isWebKit && mounted && !open) {
-      const doc = ownerDocument(referenceElement);
-      const originalUserSelect = doc.body.style.userSelect;
-      const originalWebkitUserSelect = doc.body.style.webkitUserSelect;
-      doc.body.style.userSelect = "none";
-      doc.body.style.webkitUserSelect = "none";
-      return () => {
-        doc.body.style.userSelect = originalUserSelect;
-        doc.body.style.webkitUserSelect = originalWebkitUserSelect;
-      };
-    }
-    return void 0;
-  }, [enabled, mounted, open, referenceElement]);
-  useIsoLayoutEffect(() => {
-    if (!enabled) {
-      return void 0;
-    }
-    return SCROLL_LOCKER.acquire(referenceElement);
-  }, [enabled, referenceElement]);
-}
-function useEnhancedClickHandler(handler) {
-  const lastClickInteractionTypeRef = React.useRef("");
-  const handlePointerDown = React.useCallback((event) => {
-    if (event.defaultPrevented) {
-      return;
-    }
-    lastClickInteractionTypeRef.current = event.pointerType;
-    handler(event, event.pointerType);
-  }, [handler]);
-  const handleClick = React.useCallback((event) => {
-    if (event.detail === 0) {
-      handler(event, "keyboard");
-      return;
-    }
-    if ("pointerType" in event) {
-      handler(event, event.pointerType);
-    }
-    handler(event, lastClickInteractionTypeRef.current);
-    lastClickInteractionTypeRef.current = "";
-  }, [handler]);
-  return {
-    onClick: handleClick,
-    onPointerDown: handlePointerDown
-  };
-}
-function useOpenInteractionType(open) {
-  const [openMethod, setOpenMethod] = React.useState(null);
-  const handleTriggerClick = useEventCallback((_, interactionType) => {
-    if (!open) {
-      setOpenMethod(interactionType);
-    }
-  });
-  const reset = useEventCallback(() => {
-    setOpenMethod(null);
-  });
-  const {
-    onClick,
-    onPointerDown
-  } = useEnhancedClickHandler(handleTriggerClick);
-  return React.useMemo(() => ({
-    openMethod,
-    reset,
-    triggerProps: {
-      onClick,
-      onPointerDown
-    }
-  }), [openMethod, reset, onClick, onPointerDown]);
-}
-export {
-  pressableTriggerOpenStateMapping as $,
-  ARROW_UP$1 as A,
-  createAttribute as B,
-  CommonPopupDataAttributes as C,
-  isMouseLikePointerType as D,
-  contains as E,
-  FloatingFocusManager as F,
-  activeElement as G,
-  isTypeableElement as H,
-  InternalBackdrop as I,
-  matchesFocusVisible as J,
-  isMac as K,
-  isSafari as L,
-  getFloatingFocusElement as M,
-  isTypeableCombobox as N,
-  enqueueFocus as O,
-  isVirtualClick as P,
-  isVirtualPointerEvent as Q,
-  getNodeChildren as R,
-  ownerDocument as S,
-  Timeout as T,
-  DISABLED_TRANSITIONS_STYLE as U,
-  DROPDOWN_COLLISION_AVOIDANCE as V,
-  useFloatingNodeId as W,
-  FloatingNode as X,
-  PATIENT_CLICK_THRESHOLD as Y,
-  FloatingTree as Z,
-  TYPEAHEAD_RESET_MS as _,
-  COMPOSITE_KEYS as a,
-  FloatingPortal as b,
-  triggerOpenStateMapping as c,
-  useTransitionStatus as d,
-  useOpenInteractionType as e,
-  useFloatingRootContext as f,
-  getEmptyContext as g,
-  useRole as h,
-  inertValue as i,
-  useClick as j,
-  useDismiss as k,
-  useScrollLock as l,
-  useInteractions as m,
-  getTarget as n,
-  ARROW_DOWN$1 as o,
-  popupStateMapping as p,
-  ARROW_LEFT$1 as q,
-  ARROW_RIGHT$1 as r,
-  stopEvent as s,
-  transitionStatusMapping as t,
-  useOpenChangeComplete as u,
-  useFloatingTree as v,
-  useFloatingParentNodeId as w,
-  useLatestRef as x,
-  useTimeout as y,
-  getDocument as z
-};