lynote-ui 0.0.1

package/dist/InternalBackdrop-B3WuVcuG.js

@@ -0,0 +1,1021 @@
+"use strict";
+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);
+const floatingUi_utils_dom = require("./floating-ui.utils.dom-djqmdyxg.js");
+const detectBrowser = require("./detectBrowser-j_AUpd7-.js");
+const owner = require("./owner-DohlhdQa.js");
+const useIsoLayoutEffect = require("./useIsoLayoutEffect-CYDr9Bko.js");
+const useTimeout = require("./useTimeout-CSlJ10_7.js");
+const useAnimationFrame = require("./useAnimationFrame-Bgt4Euiv.js");
+const useRenderElement = require("./useRenderElement-CtyURhhF.js");
+const React = require("react");
+const popupStateMapping = require("./popupStateMapping-DKN5mXrh.js");
+const useValueAsRef = require("./useValueAsRef-uSzmRbW_.js");
+const useStableCallback = require("./useStableCallback-CfE_knIO.js");
+const createBaseUIEventDetails = require("./createBaseUIEventDetails-D39y2D9R.js");
+const useOpenChangeComplete = require("./useOpenChangeComplete-B0xZNwMu.js");
+const jsxRuntime = require("./jsx-runtime-CPzt8Nmm.js");
+const element = require("./element-DAAyJrnp.js");
+const event = require("./event-BHxKjfyi.js");
+const composite = require("./composite-DhXBXmhV.js");
+const useValueChanged = require("./useValueChanged-CvJls2Pv.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+let originalHtmlStyles = {};
+let originalBodyStyles = {};
+let originalHtmlScrollBehavior = "";
+function hasInsetScrollbars(referenceElement) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  const doc = owner.ownerDocument(referenceElement);
+  const win = floatingUi_utils_dom.getWindow(doc);
+  return win.innerWidth - doc.documentElement.clientWidth > 0;
+}
+function supportsStableScrollbarGutter(referenceElement) {
+  const supported = typeof CSS !== "undefined" && CSS.supports && CSS.supports("scrollbar-gutter", "stable");
+  if (!supported || typeof document === "undefined") {
+    return false;
+  }
+  const doc = owner.ownerDocument(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const scrollContainer = floatingUi_utils_dom.isOverflowElement(html) ? html : body;
+  const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
+  const originalHtmlStyleGutter = html.style.scrollbarGutter;
+  html.style.scrollbarGutter = "stable";
+  scrollContainer.style.overflowY = "scroll";
+  const before = scrollContainer.offsetWidth;
+  scrollContainer.style.overflowY = "hidden";
+  const after = scrollContainer.offsetWidth;
+  scrollContainer.style.overflowY = originalScrollContainerOverflowY;
+  html.style.scrollbarGutter = originalHtmlStyleGutter;
+  return before === after;
+}
+function preventScrollOverlayScrollbars(referenceElement) {
+  const doc = owner.ownerDocument(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const elementToLock = floatingUi_utils_dom.isOverflowElement(html) ? html : body;
+  const originalElementToLockStyles = {
+    overflowY: elementToLock.style.overflowY,
+    overflowX: elementToLock.style.overflowX
+  };
+  Object.assign(elementToLock.style, {
+    overflowY: "hidden",
+    overflowX: "hidden"
+  });
+  return () => {
+    Object.assign(elementToLock.style, originalElementToLockStyles);
+  };
+}
+function preventScrollInsetScrollbars(referenceElement) {
+  var _a;
+  const doc = owner.ownerDocument(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const win = floatingUi_utils_dom.getWindow(html);
+  let scrollTop = 0;
+  let scrollLeft = 0;
+  let updateGutterOnly = false;
+  const resizeFrame = useAnimationFrame.AnimationFrame.create();
+  if (detectBrowser.isWebKit && (((_a = win.visualViewport) == null ? void 0 : _a.scale) ?? 1) !== 1) {
+    return () => {
+    };
+  }
+  function lockScroll() {
+    const htmlStyles = win.getComputedStyle(html);
+    const bodyStyles = win.getComputedStyle(body);
+    const htmlScrollbarGutterValue = htmlStyles.scrollbarGutter || "";
+    const hasBothEdges = htmlScrollbarGutterValue.includes("both-edges");
+    const scrollbarGutterValue = hasBothEdges ? "stable both-edges" : "stable";
+    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 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 - body.clientWidth);
+    const scrollbarHeight = Math.max(0, win.innerHeight - body.clientHeight);
+    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+    const elementToLock = floatingUi_utils_dom.isOverflowElement(html) ? html : body;
+    updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
+    if (updateGutterOnly) {
+      html.style.scrollbarGutter = scrollbarGutterValue;
+      elementToLock.style.overflowY = "hidden";
+      elementToLock.style.overflowX = "hidden";
+      return;
+    }
+    Object.assign(html.style, {
+      scrollbarGutter: scrollbarGutterValue,
+      overflowY: "hidden",
+      overflowX: "hidden"
+    });
+    if (isScrollableY || hasConstantOverflowY) {
+      html.style.overflowY = "scroll";
+    }
+    if (isScrollableX || hasConstantOverflowX) {
+      html.style.overflowX = "scroll";
+    }
+    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);
+    if (!updateGutterOnly) {
+      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();
+    if (typeof win.removeEventListener === "function") {
+      win.removeEventListener("resize", handleResize);
+    }
+  };
+}
+class ScrollLocker {
+  constructor() {
+    __publicField(this, "lockCount", 0);
+    __publicField(this, "restore", null);
+    __publicField(this, "timeoutLock", useTimeout.Timeout.create());
+    __publicField(this, "timeoutUnlock", useTimeout.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 = owner.ownerDocument(referenceElement);
+    const html = doc.documentElement;
+    const htmlOverflowY = floatingUi_utils_dom.getWindow(html).getComputedStyle(html).overflowY;
+    if (htmlOverflowY === "hidden" || htmlOverflowY === "clip") {
+      this.restore = useRenderElement.NOOP;
+      return;
+    }
+    const hasOverlayScrollbars = detectBrowser.isIOS || !hasInsetScrollbars(referenceElement);
+    this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);
+  }
+}
+const SCROLL_LOCKER = new ScrollLocker();
+function useScrollLock(enabled = true, referenceElement = null) {
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    return SCROLL_LOCKER.acquire(referenceElement);
+  }, [enabled, referenceElement]);
+}
+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()
+};
+const markerName = "data-base-ui-inert";
+const uncontrolledElementsSets = {
+  inert: /* @__PURE__ */ new WeakSet(),
+  "aria-hidden": /* @__PURE__ */ new WeakSet()
+};
+let markerCounterMap = /* @__PURE__ */ new WeakMap();
+let lockCount = 0;
+function getUncontrolledElementsSet(controlAttribute) {
+  return uncontrolledElementsSets[controlAttribute];
+}
+function unwrapHost(node) {
+  if (!node) {
+    return null;
+  }
+  return floatingUi_utils_dom.isShadowRoot(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);
+const buildKeepSet = (targets) => {
+  const keep = /* @__PURE__ */ new Set();
+  targets.forEach((target) => {
+    let node = target;
+    while (node && !keep.has(node)) {
+      keep.add(node);
+      node = node.parentNode;
+    }
+  });
+  return keep;
+};
+const collectOutsideElements = (root, keepElements, stopElements) => {
+  const outside = [];
+  const walk = (parent) => {
+    if (!parent || stopElements.has(parent)) {
+      return;
+    }
+    Array.from(parent.children).forEach((node) => {
+      if (floatingUi_utils_dom.getNodeName(node) === "script") {
+        return;
+      }
+      if (keepElements.has(node)) {
+        walk(node);
+      } else {
+        outside.push(node);
+      }
+    });
+  };
+  walk(root);
+  return outside;
+};
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert, {
+  mark = true,
+  markerIgnoreElements = []
+}) {
+  const controlAttribute = inert ? "inert" : ariaHidden ? "aria-hidden" : null;
+  let counterMap = null;
+  let uncontrolledElementsSet = null;
+  const avoidElements = correctElements(body, uncorrectedAvoidElements);
+  const markerIgnoreTargets = mark ? correctElements(body, markerIgnoreElements) : [];
+  const markerIgnoreSet = new Set(markerIgnoreTargets);
+  const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)).filter((target) => !markerIgnoreSet.has(target)) : [];
+  const hiddenElements = [];
+  const markedElements = [];
+  if (controlAttribute) {
+    const map = counters[controlAttribute];
+    const currentUncontrolledElementsSet = getUncontrolledElementsSet(controlAttribute);
+    uncontrolledElementsSet = currentUncontrolledElementsSet;
+    counterMap = map;
+    const ariaLiveElements = correctElements(body, Array.from(body.querySelectorAll("[aria-live]")));
+    const controlElements = avoidElements.concat(ariaLiveElements);
+    const controlTargets = collectOutsideElements(body, buildKeepSet(controlElements), new Set(controlElements));
+    controlTargets.forEach((node) => {
+      const attr = node.getAttribute(controlAttribute);
+      const alreadyHidden = attr !== null && attr !== "false";
+      const counterValue = (map.get(node) || 0) + 1;
+      map.set(node, counterValue);
+      hiddenElements.push(node);
+      if (counterValue === 1 && alreadyHidden) {
+        currentUncontrolledElementsSet.add(node);
+      }
+      if (!alreadyHidden) {
+        node.setAttribute(controlAttribute, controlAttribute === "inert" ? "" : "true");
+      }
+    });
+  }
+  if (mark) {
+    markerTargets.forEach((node) => {
+      const markerValue = (markerCounterMap.get(node) || 0) + 1;
+      markerCounterMap.set(node, markerValue);
+      markedElements.push(node);
+      if (markerValue === 1) {
+        node.setAttribute(markerName, "");
+      }
+    });
+  }
+  lockCount += 1;
+  return () => {
+    if (counterMap) {
+      hiddenElements.forEach((element2) => {
+        const currentCounterValue = counterMap.get(element2) || 0;
+        const counterValue = currentCounterValue - 1;
+        counterMap.set(element2, counterValue);
+        if (!counterValue) {
+          if (!(uncontrolledElementsSet == null ? void 0 : uncontrolledElementsSet.has(element2)) && controlAttribute) {
+            element2.removeAttribute(controlAttribute);
+          }
+          uncontrolledElementsSet == null ? void 0 : uncontrolledElementsSet.delete(element2);
+        }
+      });
+    }
+    if (mark) {
+      markedElements.forEach((element2) => {
+        const markerValue = (markerCounterMap.get(element2) || 0) - 1;
+        markerCounterMap.set(element2, markerValue);
+        if (!markerValue) {
+          element2.removeAttribute(markerName);
+        }
+      });
+    }
+    lockCount -= 1;
+    if (!lockCount) {
+      counters.inert = /* @__PURE__ */ new WeakMap();
+      counters["aria-hidden"] = /* @__PURE__ */ new WeakMap();
+      uncontrolledElementsSets.inert = /* @__PURE__ */ new WeakSet();
+      uncontrolledElementsSets["aria-hidden"] = /* @__PURE__ */ new WeakSet();
+      markerCounterMap = /* @__PURE__ */ new WeakMap();
+    }
+  };
+}
+function markOthers(avoidElements, options = {}) {
+  const {
+    ariaHidden = false,
+    inert = false,
+    mark = true,
+    markerIgnoreElements = []
+  } = options;
+  const body = owner.ownerDocument(avoidElements[0]).body;
+  return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, {
+    mark,
+    markerIgnoreElements
+  });
+}
+function getEventType(event2, lastInteractionType) {
+  const win = floatingUi_utils_dom.getWindow(event2.target);
+  if (event2 instanceof win.KeyboardEvent) {
+    return "keyboard";
+  }
+  if (event2 instanceof win.FocusEvent) {
+    return lastInteractionType || "keyboard";
+  }
+  if ("pointerType" in event2) {
+    return event2.pointerType || "keyboard";
+  }
+  if ("touches" in event2) {
+    return "touch";
+  }
+  if (event2 instanceof win.MouseEvent) {
+    return lastInteractionType || (event2.detail === 0 ? "keyboard" : "mouse");
+  }
+  return "";
+}
+const LIST_LIMIT = 20;
+let previouslyFocusedElements = [];
+function clearDisconnectedPreviouslyFocusedElements() {
+  previouslyFocusedElements = previouslyFocusedElements.filter((entry) => {
+    var _a;
+    return (_a = entry.deref()) == null ? void 0 : _a.isConnected;
+  });
+}
+function addPreviouslyFocusedElement(element2) {
+  clearDisconnectedPreviouslyFocusedElements();
+  if (element2 && floatingUi_utils_dom.getNodeName(element2) !== "body") {
+    previouslyFocusedElements.push(new WeakRef(element2));
+    if (previouslyFocusedElements.length > LIST_LIMIT) {
+      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
+    }
+  }
+}
+function getPreviouslyFocusedElement() {
+  var _a;
+  clearDisconnectedPreviouslyFocusedElements();
+  return (_a = previouslyFocusedElements[previouslyFocusedElements.length - 1]) == null ? void 0 : _a.deref();
+}
+function getFirstTabbableElement(container) {
+  if (!container) {
+    return null;
+  }
+  const tabbableOptions = popupStateMapping.getTabbableOptions();
+  if (popupStateMapping.isTabbable(container, tabbableOptions)) {
+    return container;
+  }
+  return popupStateMapping.tabbable(container, tabbableOptions)[0] || container;
+}
+function isFocusable(element2) {
+  if (!element2 || !element2.isConnected) {
+    return false;
+  }
+  if (typeof element2.checkVisibility === "function") {
+    return element2.checkVisibility();
+  }
+  return composite.isElementVisible(element2);
+}
+function handleTabIndex(floatingFocusElement, orderRef) {
+  var _a;
+  if (!orderRef.current.includes("floating") && !((_a = floatingFocusElement.getAttribute("role")) == null ? void 0 : _a.includes("dialog"))) {
+    return;
+  }
+  const options = popupStateMapping.getTabbableOptions();
+  const focusableElements = popupStateMapping.focusable(floatingFocusElement, options);
+  const tabbableContent = focusableElements.filter((element2) => {
+    const dataTabIndex = element2.getAttribute("data-tabindex") || "";
+    return popupStateMapping.isTabbable(element2, options) || element2.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,
+    initialFocus = true,
+    returnFocus = true,
+    restoreFocus = false,
+    modal = true,
+    closeOnFocusOut = true,
+    openInteractionType = "",
+    nextFocusableElement,
+    previousFocusableElement,
+    beforeContentFocusGuardRef,
+    externalTree,
+    getInsideElements
+  } = props;
+  const store = "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open");
+  const domReference = store.useState("domReferenceElement");
+  const floating = store.useState("floatingElement");
+  const {
+    events,
+    dataRef
+  } = store.context;
+  const getNodeId = useStableCallback.useStableCallback(() => {
+    var _a;
+    return (_a = dataRef.current.floatingContext) == null ? void 0 : _a.nodeId;
+  });
+  const ignoreInitialFocus = initialFocus === false;
+  const isUntrappedTypeableCombobox = element.isTypeableCombobox(domReference) && ignoreInitialFocus;
+  const orderRef = React__namespace.useRef(["content"]);
+  const initialFocusRef = useValueAsRef.useValueAsRef(initialFocus);
+  const returnFocusRef = useValueAsRef.useValueAsRef(returnFocus);
+  const openInteractionTypeRef = useValueAsRef.useValueAsRef(openInteractionType);
+  const tree = popupStateMapping.useFloatingTree(externalTree);
+  const portalContext = popupStateMapping.usePortalContext();
+  const preventReturnFocusRef = React__namespace.useRef(false);
+  const isPointerDownRef = React__namespace.useRef(false);
+  const pointerDownOutsideRef = React__namespace.useRef(false);
+  const tabbableIndexRef = React__namespace.useRef(-1);
+  const closeTypeRef = React__namespace.useRef("");
+  const lastInteractionTypeRef = React__namespace.useRef("");
+  const beforeGuardRef = React__namespace.useRef(null);
+  const afterGuardRef = React__namespace.useRef(null);
+  const mergedBeforeGuardRef = useRenderElement.useMergedRefs(beforeGuardRef, beforeContentFocusGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef);
+  const mergedAfterGuardRef = useRenderElement.useMergedRefs(afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef);
+  const blurTimeout = useTimeout.useTimeout();
+  const pointerDownTimeout = useTimeout.useTimeout();
+  const restoreFocusFrame = useAnimationFrame.useAnimationFrame();
+  const isInsidePortal = portalContext != null;
+  const floatingFocusElement = element.getFloatingFocusElement(floating);
+  const getTabbableContent = useStableCallback.useStableCallback((container = floatingFocusElement) => {
+    return container ? popupStateMapping.tabbable(container, popupStateMapping.getTabbableOptions()) : [];
+  });
+  const getResolvedInsideElements = useStableCallback.useStableCallback(() => (getInsideElements == null ? void 0 : getInsideElements().filter((element2) => element2 != null)) ?? []);
+  const getTabbableElements = useStableCallback.useStableCallback((container) => {
+    const content = getTabbableContent(container);
+    return orderRef.current.map(() => content).filter(Boolean).flat();
+  });
+  React__namespace.useEffect(() => {
+    if (disabled || !modal) {
+      return void 0;
+    }
+    function onKeyDown(event$1) {
+      if (event$1.key === "Tab") {
+        if (element.contains(floatingFocusElement, element.activeElement(owner.ownerDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
+          event.stopEvent(event$1);
+        }
+      }
+    }
+    const doc = owner.ownerDocument(floatingFocusElement);
+    doc.addEventListener("keydown", onKeyDown);
+    return () => {
+      doc.removeEventListener("keydown", onKeyDown);
+    };
+  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
+  React__namespace.useEffect(() => {
+    if (disabled || !open) {
+      return void 0;
+    }
+    const doc = owner.ownerDocument(floatingFocusElement);
+    function clearPointerDownOutside() {
+      pointerDownOutsideRef.current = false;
+    }
+    function onPointerDown(event2) {
+      const target = element.getTarget(event2);
+      const insideElements = getResolvedInsideElements();
+      const pointerTargetInside = element.contains(floating, target) || element.contains(domReference, target) || element.contains(portalContext == null ? void 0 : portalContext.portalNode, target) || insideElements.some((element$1) => element$1 === target || element.contains(element$1, target));
+      pointerDownOutsideRef.current = !pointerTargetInside;
+      lastInteractionTypeRef.current = event2.pointerType || "keyboard";
+      if (target == null ? void 0 : target.closest(`[${popupStateMapping.CLICK_TRIGGER_IDENTIFIER}]`)) {
+        isPointerDownRef.current = true;
+      }
+    }
+    function onKeyDown() {
+      lastInteractionTypeRef.current = "keyboard";
+    }
+    doc.addEventListener("pointerdown", onPointerDown, true);
+    doc.addEventListener("pointerup", clearPointerDownOutside, true);
+    doc.addEventListener("pointercancel", clearPointerDownOutside, true);
+    doc.addEventListener("keydown", onKeyDown, true);
+    return () => {
+      doc.removeEventListener("pointerdown", onPointerDown, true);
+      doc.removeEventListener("pointerup", clearPointerDownOutside, true);
+      doc.removeEventListener("pointercancel", clearPointerDownOutside, true);
+      doc.removeEventListener("keydown", onKeyDown, true);
+    };
+  }, [disabled, floating, domReference, floatingFocusElement, open, portalContext, getResolvedInsideElements]);
+  React__namespace.useEffect(() => {
+    if (disabled || !closeOnFocusOut) {
+      return void 0;
+    }
+    const doc = owner.ownerDocument(floatingFocusElement);
+    function handlePointerDown() {
+      isPointerDownRef.current = true;
+      pointerDownTimeout.start(0, () => {
+        isPointerDownRef.current = false;
+      });
+    }
+    function handleFocusIn(event2) {
+      const target = element.getTarget(event2);
+      const tabbableContent = getTabbableContent();
+      const tabbableIndex = tabbableContent.indexOf(target);
+      if (tabbableIndex !== -1) {
+        tabbableIndexRef.current = tabbableIndex;
+      }
+    }
+    function handleFocusOutside(event2) {
+      const relatedTarget = event2.relatedTarget;
+      const currentTarget = event2.currentTarget;
+      const target = element.getTarget(event2);
+      queueMicrotask(() => {
+        const nodeId = getNodeId();
+        const triggers = store.context.triggerElements;
+        const insideElements = getResolvedInsideElements();
+        const isRelatedFocusGuard = (relatedTarget == null ? void 0 : relatedTarget.hasAttribute(popupStateMapping.createAttribute("focus-guard"))) && [beforeGuardRef.current, afterGuardRef.current, portalContext == null ? void 0 : portalContext.beforeInsideRef.current, portalContext == null ? void 0 : portalContext.afterInsideRef.current, portalContext == null ? void 0 : portalContext.beforeOutsideRef.current, portalContext == null ? void 0 : portalContext.afterOutsideRef.current, useOpenChangeComplete.resolveRef(previousFocusableElement), useOpenChangeComplete.resolveRef(nextFocusableElement)].includes(relatedTarget);
+        const movedToUnrelatedNode = !(element.contains(domReference, relatedTarget) || element.contains(floating, relatedTarget) || element.contains(relatedTarget, floating) || element.contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || insideElements.some((element$1) => element$1 === relatedTarget || element.contains(element$1, relatedTarget)) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement((trigger) => element.contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (popupStateMapping.getNodeChildren(tree.nodesRef.current, nodeId).find((node) => {
+          var _a, _b;
+          return element.contains((_a = node.context) == null ? void 0 : _a.elements.floating, relatedTarget) || element.contains((_b = node.context) == null ? void 0 : _b.elements.domReference, relatedTarget);
+        }) || popupStateMapping.getNodeAncestors(tree.nodesRef.current, nodeId).find((node) => {
+          var _a, _b, _c;
+          return [(_a = node.context) == null ? void 0 : _a.elements.floating, element.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 && !isFocusable(target) && element.activeElement(doc) === doc.body) {
+          if (floatingUi_utils_dom.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 (floatingUi_utils_dom.isHTMLElement(nodeToFocus)) {
+            nodeToFocus.focus();
+          }
+        }
+        if (dataRef.current.insideReactTree) {
+          dataRef.current.insideReactTree = false;
+          return;
+        }
+        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && // 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;
+          store.setOpen(false, createBaseUIEventDetails.createChangeEventDetails(createBaseUIEventDetails.focusOut, event2));
+        }
+      });
+    }
+    function markInsideReactTree() {
+      if (pointerDownOutsideRef.current) {
+        return;
+      }
+      dataRef.current.insideReactTree = true;
+      blurTimeout.start(0, () => {
+        dataRef.current.insideReactTree = false;
+      });
+    }
+    const domReferenceElement = floatingUi_utils_dom.isHTMLElement(domReference) ? domReference : null;
+    const cleanups = [];
+    if (!floating && !domReferenceElement) {
+      return void 0;
+    }
+    if (domReferenceElement) {
+      domReferenceElement.addEventListener("focusout", handleFocusOutside);
+      domReferenceElement.addEventListener("pointerdown", handlePointerDown);
+      cleanups.push(() => {
+        domReferenceElement.removeEventListener("focusout", handleFocusOutside);
+        domReferenceElement.removeEventListener("pointerdown", handlePointerDown);
+      });
+    }
+    if (floating) {
+      floating.addEventListener("focusin", handleFocusIn);
+      floating.addEventListener("focusout", handleFocusOutside);
+      if (portalContext) {
+        floating.addEventListener("focusout", markInsideReactTree, true);
+        cleanups.push(() => {
+          floating.removeEventListener("focusout", markInsideReactTree, true);
+        });
+      }
+      cleanups.push(() => {
+        floating.removeEventListener("focusin", handleFocusIn);
+        floating.removeEventListener("focusout", handleFocusOutside);
+      });
+    }
+    return () => {
+      cleanups.forEach((cleanup) => {
+        cleanup();
+      });
+    };
+  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, store, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId, orderRef, dataRef, blurTimeout, pointerDownTimeout, restoreFocusFrame, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
+  React__namespace.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(`[${popupStateMapping.createAttribute("portal")}]`)) || []);
+    const ancestors = tree ? popupStateMapping.getNodeAncestors(tree.nodesRef.current, getNodeId()) : [];
+    const rootAncestorComboboxDomReference = (_c = (_b = ancestors.find((node) => {
+      var _a2;
+      return element.isTypeableCombobox(((_a2 = node.context) == null ? void 0 : _a2.elements.domReference) || null);
+    })) == null ? void 0 : _b.context) == null ? void 0 : _c.elements.domReference;
+    const controlInsideElements = [floating, ...portalNodes, beforeGuardRef.current, afterGuardRef.current, portalContext == null ? void 0 : portalContext.beforeOutsideRef.current, portalContext == null ? void 0 : portalContext.afterOutsideRef.current, ...getResolvedInsideElements()];
+    const insideElements = [...controlInsideElements, rootAncestorComboboxDomReference, useOpenChangeComplete.resolveRef(previousFocusableElement), useOpenChangeComplete.resolveRef(nextFocusableElement), isUntrappedTypeableCombobox ? domReference : null].filter((x) => x != null);
+    const ariaHiddenCleanup = markOthers(insideElements, {
+      ariaHidden: modal || isUntrappedTypeableCombobox,
+      mark: false
+    });
+    const markerInsideElements = [floating, ...portalNodes].filter((x) => x != null);
+    const markerCleanup = markOthers(markerInsideElements);
+    return () => {
+      markerCleanup();
+      ariaHiddenCleanup();
+    };
+  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (!open || disabled || !floatingUi_utils_dom.isHTMLElement(floatingFocusElement)) {
+      return;
+    }
+    const doc = owner.ownerDocument(floatingFocusElement);
+    const previouslyFocusedElement = element.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 {
+        elToFocus = useOpenChangeComplete.resolveRef(resolvedInitialFocus);
+      }
+      elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;
+      const focusAlreadyInsideFloatingEl = element.contains(floatingFocusElement, previouslyFocusedElement);
+      if (focusAlreadyInsideFloatingEl) {
+        return;
+      }
+      enqueueFocus(elToFocus, {
+        preventScroll: elToFocus === floatingFocusElement
+      });
+    });
+  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef, openInteractionTypeRef]);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (disabled || !floatingFocusElement) {
+      return void 0;
+    }
+    const doc = owner.ownerDocument(floatingFocusElement);
+    const previouslyFocusedElement = element.activeElement(doc);
+    addPreviouslyFocusedElement(previouslyFocusedElement);
+    function onOpenChangeLocal(details) {
+      if (!details.open) {
+        closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
+      }
+      if (details.reason === createBaseUIEventDetails.triggerHover && details.nativeEvent.type === "mouseleave") {
+        preventReturnFocusRef.current = true;
+      }
+      if (details.reason !== createBaseUIEventDetails.outsidePress) {
+        return;
+      }
+      if (details.nested) {
+        preventReturnFocusRef.current = false;
+      } else if (event.isVirtualClick(details.nativeEvent) || event.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);
+    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 : null;
+      }
+      const fallback = domReference || getPreviouslyFocusedElement();
+      return useOpenChangeComplete.resolveRef(resolvedReturnFocusValue) || fallback || null;
+    }
+    return () => {
+      events.off("openchange", onOpenChangeLocal);
+      const activeEl = element.activeElement(doc);
+      const insideElements = getResolvedInsideElements();
+      const isFocusInsideFloatingTree = element.contains(floating, activeEl) || insideElements.some((element$1) => element$1 === activeEl || element.contains(element$1, activeEl)) || tree && popupStateMapping.getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node) => {
+        var _a;
+        return element.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 && floatingUi_utils_dom.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
+          });
+        }
+        preventReturnFocusRef.current = false;
+      });
+    };
+  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, domReference, getNodeId, getResolvedInsideElements]);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (!detectBrowser.isWebKit || open || !floating) {
+      return;
+    }
+    const activeEl = element.activeElement(owner.ownerDocument(floating));
+    if (!floatingUi_utils_dom.isHTMLElement(activeEl) || !element.isTypeableElement(activeEl)) {
+      return;
+    }
+    if (element.contains(floating, activeEl)) {
+      activeEl.blur();
+    }
+  }, [open, floating]);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (disabled || !portalContext) {
+      return void 0;
+    }
+    portalContext.setFocusManagerState({
+      modal,
+      closeOnFocusOut,
+      open,
+      onOpenChange: store.setOpen,
+      domReference
+    });
+    return () => {
+      portalContext.setFocusManagerState(null);
+    };
+  }, [disabled, portalContext, modal, open, store, closeOnFocusOut, domReference]);
+  useIsoLayoutEffect.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__ */ jsxRuntime.jsxRuntimeExports.jsxs(React__namespace.Fragment, {
+    children: [shouldRenderGuards && /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(popupStateMapping.FocusGuard, {
+      "data-type": "inside",
+      ref: mergedBeforeGuardRef,
+      onFocus: (event2) => {
+        var _a;
+        if (modal) {
+          const els = getTabbableElements();
+          enqueueFocus(els[els.length - 1]);
+        } else if (portalContext == null ? void 0 : portalContext.portalNode) {
+          preventReturnFocusRef.current = false;
+          if (popupStateMapping.isOutsideEvent(event2, portalContext.portalNode)) {
+            const nextTabbable = popupStateMapping.getNextTabbable(domReference);
+            nextTabbable == null ? void 0 : nextTabbable.focus();
+          } else {
+            (_a = useOpenChangeComplete.resolveRef(previousFocusableElement ?? portalContext.beforeOutsideRef)) == null ? void 0 : _a.focus();
+          }
+        }
+      }
+    }), children, shouldRenderGuards && /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(popupStateMapping.FocusGuard, {
+      "data-type": "inside",
+      ref: mergedAfterGuardRef,
+      onFocus: (event2) => {
+        var _a;
+        if (modal) {
+          enqueueFocus(getTabbableElements()[0]);
+        } else if (portalContext == null ? void 0 : portalContext.portalNode) {
+          if (closeOnFocusOut) {
+            preventReturnFocusRef.current = true;
+          }
+          if (popupStateMapping.isOutsideEvent(event2, portalContext.portalNode)) {
+            const prevTabbable = popupStateMapping.getPreviousTabbable(domReference);
+            prevTabbable == null ? void 0 : prevTabbable.focus();
+          } else {
+            (_a = useOpenChangeComplete.resolveRef(nextFocusableElement ?? portalContext.afterOutsideRef)) == null ? void 0 : _a.focus();
+          }
+        }
+      }
+    })]
+  });
+}
+function useEnhancedClickHandler(handler) {
+  const lastClickInteractionTypeRef = React__namespace.useRef("");
+  const handlePointerDown = React__namespace.useCallback((event2) => {
+    if (event2.defaultPrevented) {
+      return;
+    }
+    lastClickInteractionTypeRef.current = event2.pointerType;
+    handler(event2, event2.pointerType);
+  }, [handler]);
+  const handleClick = React__namespace.useCallback((event2) => {
+    if (event2.detail === 0) {
+      handler(event2, "keyboard");
+      return;
+    }
+    if ("pointerType" in event2) {
+      handler(event2, event2.pointerType);
+    } else {
+      handler(event2, lastClickInteractionTypeRef.current);
+    }
+    lastClickInteractionTypeRef.current = "";
+  }, [handler]);
+  return {
+    onClick: handleClick,
+    onPointerDown: handlePointerDown
+  };
+}
+function useOpenInteractionType(open) {
+  const [openMethod, setOpenMethod] = React__namespace.useState(null);
+  const handleTriggerClick = useStableCallback.useStableCallback((_, interactionType) => {
+    if (!open) {
+      setOpenMethod(interactionType || // On iOS Safari, the hitslop around touch targets means tapping outside an element's
+      // bounds does not fire `pointerdown` but does fire `mousedown`. The `interactionType`
+      // will be "" in that case.
+      (detectBrowser.isIOS ? "touch" : ""));
+    }
+  });
+  useValueChanged.useValueChanged(open, (previousOpen) => {
+    if (previousOpen && !open) {
+      setOpenMethod(null);
+    }
+  });
+  const {
+    onClick,
+    onPointerDown
+  } = useEnhancedClickHandler(handleTriggerClick);
+  return React__namespace.useMemo(() => ({
+    openMethod,
+    triggerProps: {
+      onClick,
+      onPointerDown
+    }
+  }), [openMethod, onClick, onPointerDown]);
+}
+const InternalBackdrop = /* @__PURE__ */ React__namespace.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__ */ jsxRuntime.jsxRuntimeExports.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";
+exports.FloatingFocusManager = FloatingFocusManager;
+exports.InternalBackdrop = InternalBackdrop;
+exports.enqueueFocus = enqueueFocus;
+exports.useOpenInteractionType = useOpenInteractionType;
+exports.useScrollLock = useScrollLock;
+//# sourceMappingURL=InternalBackdrop-B3WuVcuG.js.map