@jobber/components 9.6.1 → 9.6.2

package/dist/useScrollLock-cjs.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var React = require('react');
+var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var useRenderElement = require('./useRenderElement-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
 var ReactDOM = require('react-dom');
@@ -103,6 +104,14 @@ function serializeToDevModeString(input) {
 const noop = () => {};
 const useIsoLayoutEffect = typeof document !== 'undefined' ? React__namespace.useLayoutEffect : noop;
 
+function useOnFirstRender(fn) {
+  const ref = React__namespace.useRef(true);
+  if (ref.current) {
+    ref.current = false;
+    fn();
+  }
+}
+
 /**
  * A clone of the React namespace for reading APIs that may be missing in older
  * supported React versions. Bundlers can rewrite direct `React.someNewApi`
@@ -201,6 +210,87 @@ const visuallyHiddenInput = {
   position: 'absolute'
 };
 
+/**
+ * The NoOptionalParams type is a utility type that checks if a function has optional or default parameters.
+ * If the function has optional or default parameters, it returns a string literal type with an error message.
+ * Otherwise, it returns the original function type.
+ *
+ * This is used to enforce that the combiner function passed to createSelector does not have optional or default parameters,
+ * as memoization relies on the Function.length property, which does not account for optional or default parameters.
+ */
+
+/**
+ * Creates a selector function that can be used to derive values from the store's state.
+ *
+ * The combiner function can have up to three additional parameters, but it **cannot have optional or default parameters**.
+ *
+ * This function accepts up to six functions and combines them into a single selector function.
+ * The resulting selector will take the state from the combined selectors and any additional parameters required by the combiner.
+ *
+ * The return type of the resulting selector is determined by the return type of the combiner function.
+ *
+ * @example
+ * const selector = createSelector(
+ *  (state) => state.disabled
+ * );
+ *
+ * @example
+ * const selector = createSelector(
+ *   (state) => state.disabled,
+ *   (state) => state.open,
+ *   (disabled, open) => ({ disabled, open })
+ * );
+ */
+/* eslint-disable id-denylist */
+const createSelector = (a, b, c, d, e, f, ...other) => {
+  if (other.length > 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'Unsupported number of selectors' : useRenderElement.formatErrorMessage(1));
+  }
+  let selector;
+  if (a && b && c && d && e && f) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      const ve = e(state, a1, a2, a3);
+      return f(va, vb, vc, vd, ve, a1, a2, a3);
+    };
+  } else if (a && b && c && d && e) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      return e(va, vb, vc, vd, a1, a2, a3);
+    };
+  } else if (a && b && c && d) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      return d(va, vb, vc, a1, a2, a3);
+    };
+  } else if (a && b && c) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      return c(va, vb, a1, a2, a3);
+    };
+  } else if (a && b) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      return b(va, a1, a2, a3);
+    };
+  } else if (a) {
+    selector = a;
+  } else {
+    throw /* minify-error-disabled */new Error('Missing arguments');
+  }
+  return selector;
+};
+/* eslint-enable id-denylist */
+
 var shim = {exports: {}};
 
 var useSyncExternalStoreShim_production = {};
@@ -608,41 +698,6 @@ function getInstance() {
 function register(hook) {
   hooks.push(hook);
 }
-
-/**
- * Wraps a component function to enable performance optimizations for internal hooks.
- *
- * **Performance Optimization:**
- * Components wrapped with `fastComponent` have access to a shared "instance" context that enables
- * specialized hook implementations to batch operations and reduce overhead. The wrapper creates a
- * stable instance object that persists across renders, sets it as the current context, calls
- * registered hooks before and after rendering, then clears the context. The primary benefit is
- * with `useStore`, where multiple store subscriptions within the same component are collapsed into
- * a single `useSyncExternalStore` subscription per store, significantly reducing re-render overhead.
- * This optimization is only active on React 19+; on earlier versions `useStore` falls back to a
- * separate subscription per call.
- *
- * **Requirements:**
- * - The component function should follow standard React component patterns
- * - `useStore` calls must keep a stable order and count across renders, as batched hooks are
- *   matched by call index
- * - Do not rely on the instance context outside of specialized hooks
- *
- * @param fn - The component function to wrap
- * @returns A wrapped component with the same signature as the input function
- *
- * @example
- * ```tsx
- * // Wrapping a component to enable optimized useStore batching
- * export const TooltipRoot = fastComponent(function TooltipRoot(props) {
- *   // These useStore calls share a single subscription
- *   const open = useStore(store, (state) => state.open);
- *   const disabled = useStore(store, (state) => state.disabled);
- *   const value = useStore(store, (state) => state.value);
- *   // ...
- * });
- * ```
- */
 function fastComponent(fn) {
   const FastComponent = (props, forwardedRef) => {
     const instance = useRenderElement.useRefWithInit(createInstance).current;
@@ -665,31 +720,6 @@ function fastComponent(fn) {
   FastComponent.displayName = fn.displayName || fn.name;
   return FastComponent;
 }
-
-/**
- * Wraps a component function with ref forwarding to enable performance optimizations for internal hooks.
- *
- * This is a convenience wrapper that combines `fastComponent` with `React.forwardRef`, enabling
- * both performance optimizations and proper ref forwarding. See `fastComponent` for details on
- * the performance benefits.
- *
- * @param fn - The component function that accepts props and a forwarded ref
- * @returns A wrapped component with ref forwarding enabled
- *
- * @example
- * ```tsx
- * // Wrapping a component with ref forwarding and optimized hooks
- * export const TooltipTrigger = fastComponentRef(function TooltipTrigger(
- *   props,
- *   forwardedRef
- * ) {
- *   const store = useContext(TooltipContext);
- *   const open = useStore(store, (state) => state.open);
- *   // ... component logic with ref
- *   return <button ref={forwardedRef} {...props} />;
- * });
- * ```
- */
 function fastComponentRef(fn) {
   return /*#__PURE__*/React__namespace.forwardRef(fastComponent(fn));
 }
@@ -1105,170 +1135,6 @@ class ReactStore extends Store {
   }
 }
 
-function hasWindow() {
-  return typeof window !== 'undefined';
-}
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || '').toLowerCase();
-  }
-  // Mocked nodes in testing environments may not be instances of Node. By
-  // returning `#document` an infinite loop won't occur.
-  // https://github.com/floating-ui/floating-ui/issues/2317
-  return '#document';
-}
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== 'inline' && display !== 'contents';
-}
-function isTableElement(element) {
-  return /^(table|td|th)$/.test(getNodeName(element));
-}
-function isTopLayer(element) {
-  try {
-    if (element.matches(':popover-open')) {
-      return true;
-    }
-  } catch (_e) {
-    // no-op
-  }
-  try {
-    return element.matches(':modal');
-  } catch (_e) {
-    return false;
-  }
-}
-const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
-const containRe = /paint|layout|strict|content/;
-const isNotNone = value => !!value && value !== 'none';
-let isWebKitValue;
-function isContainingBlock(elementOrCss) {
-  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
-
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else if (isTopLayer(currentNode)) {
-      return null;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (isWebKitValue == null) {
-    isWebKitValue = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');
-  }
-  return isWebKitValue;
-}
-function isLastTraversableNode(node) {
-  return /^(html|body|#document)$/.test(getNodeName(node));
-}
-function getComputedStyle(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === 'html') {
-    return node;
-  }
-  const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-  return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    return (node.ownerDocument || node).body;
-  }
-  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-  var _node$ownerDocument2;
-  if (list === void 0) {
-    list = [];
-  }
-  if (traverseIframes === void 0) {
-    traverseIframes = true;
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    const frameElement = getFrameElement(win);
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-  } else {
-    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-  }
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
-}
-
 /**
  * Combines multiple cleanup functions into a single cleanup function.
  */
@@ -1298,13 +1164,15 @@ function addEventListener(target, type, listener, options) {
   };
 }
 
+const EMPTY$2 = [];
+
 /**
  * A React.useEffect equivalent that runs once, when the component is mounted.
  */
 function useOnMount(fn) {
   // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- no need to put `fn` in the dependency array
   /* eslint-disable react-hooks/exhaustive-deps */
-  React__namespace.useEffect(fn, useRenderElement.EMPTY_ARRAY);
+  React__namespace.useEffect(fn, EMPTY$2);
   /* eslint-enable react-hooks/exhaustive-deps */
 }
 
@@ -1368,7 +1236,7 @@ class Scheduler {
     this.callbacksCount -= 1;
   }
 }
-let scheduler = new Scheduler();
+const scheduler = new Scheduler();
 class AnimationFrame {
   static create() {
     return new AnimationFrame();
@@ -1615,7 +1483,7 @@ function contains(parent, child) {
   }
 
   // Then fall back to traversing out of shadow roots when needed.
-  if (rootNode && isShadowRoot(rootNode)) {
+  if (rootNode && floatingUi_utils.isShadowRoot(rootNode)) {
     let next = child;
     while (next) {
       if (parent === next) {
@@ -1637,7 +1505,7 @@ function getTarget(event) {
 }
 
 function isTargetInsideEnabledTrigger(target, triggerElements) {
-  if (!isElement(target)) {
+  if (!floatingUi_utils.isElement(target)) {
     return false;
   }
   const targetElement = target;
@@ -1667,7 +1535,7 @@ function isRootElement(element) {
   return element.matches('html,body');
 }
 function isTypeableElement(element) {
-  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+  return floatingUi_utils.isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
 }
 function isInteractiveElement(element) {
   return element?.closest(`button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),${TYPEABLE_SELECTOR}`) != null;
@@ -1808,138 +1676,6 @@ const FocusGuard = /*#__PURE__*/React__namespace.forwardRef(function FocusGuard(
 });
 if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
 
-/**
- * Custom positioning reference element.
- * @see https://floating-ui.com/docs/virtual-elements
- */
-
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = v => ({
-  x: v,
-  y: v
-});
-const oppositeSideMap = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
-}
-function evaluate(value, param) {
-  return typeof value === 'function' ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split('-')[0];
-}
-function getAlignment(placement) {
-  return placement.split('-')[1];
-}
-function getOppositeAxis(axis) {
-  return axis === 'x' ? 'y' : 'x';
-}
-function getAxisLength(axis) {
-  return axis === 'y' ? 'height' : 'width';
-}
-function getSideAxis(placement) {
-  const firstChar = placement[0];
-  return firstChar === 't' || firstChar === 'b' ? 'y' : 'x';
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');
-}
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case 'left':
-    case 'right':
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-function getOppositePlacement(placement) {
-  const side = getSide(placement);
-  return oppositeSideMap[side] + placement.slice(side.length);
-}
-function expandPaddingObject(padding) {
-  var _padding$top, _padding$right, _padding$bottom, _padding$left;
-  return {
-    top: (_padding$top = padding.top) != null ? _padding$top : 0,
-    right: (_padding$right = padding.right) != null ? _padding$right : 0,
-    bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
-    left: (_padding$left = padding.left) != null ? _padding$left : 0
-  };
-}
-function getPaddingObject(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-function rectToClientRect(rect) {
-  const {
-    x,
-    y,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y,
-    left: x,
-    right: x + width,
-    bottom: y + height,
-    x,
-    y
-  };
-}
-
 function isDifferentGridRow(index, cols, prevRow) {
   return Math.floor(index / cols) !== prevRow;
 }
@@ -2075,7 +1811,7 @@ function getGridNavigatedIndex(list, {
       const colInRow = prevIndex % verticalCols;
       const rowStep = direction === 'up' ? -verticalCols : verticalCols;
       const lastRowStart = maxIndex - maxIndex % verticalCols;
-      const rowCount = floor(maxIndex / verticalCols) + 1;
+      const rowCount = floatingUi_utils.floor(maxIndex / verticalCols) + 1;
       for (let rowStart = prevIndex - colInRow + rowStep, i = 0; i < rowCount; i += 1, rowStart += rowStep) {
         if (rowStart < 0 || rowStart > maxIndex) {
           if (!loopFocus) {
@@ -2140,7 +1876,7 @@ function getGridNavigatedIndex(list, {
 
   // Remains on the same row/column.
   if (orientation === 'both') {
-    const prevRow = floor(prevIndex / cols);
+    const prevRow = floatingUi_utils.floor(prevIndex / cols);
     if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
       if (stop) {
         stopEvent(event);
@@ -2206,7 +1942,7 @@ function getGridNavigatedIndex(list, {
         nextIndex = prevIndex;
       }
     }
-    const lastRow = floor(maxIndex / cols) === prevRow;
+    const lastRow = floatingUi_utils.floor(maxIndex / cols) === prevRow;
     if (isIndexOutOfListBounds(list, nextIndex)) {
       if (loopFocus && lastRow) {
         nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(list, {
@@ -2235,19 +1971,12 @@ function isListIndexDisabled(list, index, disabledIndices) {
   if (!isElementVisible(element)) {
     return true;
   }
-
-  // A natively disabled element can never receive focus, so it must always be
-  // skipped, even when `disabledIndices` marks it as enabled. Only
-  // `aria-disabled` items can be focusable-while-disabled.
-  if (element.matches(':disabled')) {
-    return true;
-  }
   return !disabledIndices && (element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true');
 }
 function isHiddenByStyles(styles) {
   return styles.visibility === 'hidden' || styles.visibility === 'collapse';
 }
-function isElementVisible(element, styles = element ? getComputedStyle(element) : null) {
+function isElementVisible(element, styles = element ? floatingUi_utils.getComputedStyle(element) : null) {
   if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
     return false;
   }
@@ -2267,11 +1996,11 @@ function getParentElement(element) {
     return element.parentElement;
   }
   const rootNode = element.getRootNode();
-  return isShadowRoot(rootNode) ? rootNode.host : null;
+  return floatingUi_utils.isShadowRoot(rootNode) ? rootNode.host : null;
 }
 function getDetailsSummary(details) {
   for (const child of Array.from(details.children)) {
-    if (getNodeName(child) === 'summary') {
+    if (floatingUi_utils.getNodeName(child) === 'summary') {
       return child;
     }
   }
@@ -2282,8 +2011,8 @@ function isWithinOpenDetailsSummary(element, details) {
   return !!summary && (element === summary || contains(summary, element));
 }
 function isFocusableCandidate(element) {
-  const nodeName = element ? getNodeName(element) : '';
-  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== 'summary' || element.parentElement != null && getNodeName(element.parentElement) === 'details' && getDetailsSummary(element.parentElement) === element) && (nodeName !== 'details' || getDetailsSummary(element) == null) && (nodeName !== 'input' || element.type !== 'hidden');
+  const nodeName = element ? floatingUi_utils.getNodeName(element) : '';
+  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== 'summary' || element.parentElement != null && floatingUi_utils.getNodeName(element.parentElement) === 'details' && getDetailsSummary(element.parentElement) === element) && (nodeName !== 'details' || getDetailsSummary(element) == null) && (nodeName !== 'input' || element.type !== 'hidden');
 }
 function isFocusableElement(element) {
   if (!isFocusableCandidate(element) || !element.isConnected || element.matches(':disabled')) {
@@ -2291,18 +2020,18 @@ function isFocusableElement(element) {
   }
   for (let current = element; current; current = getParentElement(current)) {
     const isAncestor = current !== element;
-    const isSlot = getNodeName(current) === 'slot';
+    const isSlot = floatingUi_utils.getNodeName(current) === 'slot';
     if (current.hasAttribute('inert')) {
       return false;
     }
-    if (isAncestor && getNodeName(current) === 'details' && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute('hidden') || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) {
+    if (isAncestor && floatingUi_utils.getNodeName(current) === 'details' && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute('hidden') || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) {
       return false;
     }
   }
   return true;
 }
 function isVisibleInTabbableTree(element, isAncestor) {
-  const styles = getComputedStyle(element);
+  const styles = floatingUi_utils.getComputedStyle(element);
   if (!isAncestor) {
     return isElementVisible(element, styles);
   }
@@ -2311,15 +2040,15 @@ function isVisibleInTabbableTree(element, isAncestor) {
 function getTabIndex(element) {
   const tabIndex = element.tabIndex;
   if (tabIndex < 0) {
-    const nodeName = getNodeName(element);
-    if (nodeName === 'details' || nodeName === 'audio' || nodeName === 'video' || isHTMLElement(element) && element.isContentEditable) {
+    const nodeName = floatingUi_utils.getNodeName(element);
+    if (nodeName === 'details' || nodeName === 'audio' || nodeName === 'video' || floatingUi_utils.isHTMLElement(element) && element.isContentEditable) {
       return 0;
     }
   }
   return tabIndex;
 }
 function getNamedRadioInput(element) {
-  if (getNodeName(element) !== 'input') {
+  if (floatingUi_utils.getNodeName(element) !== 'input') {
     return null;
   }
   const input = element;
@@ -2343,7 +2072,7 @@ function isTabbableRadio(element, candidates) {
   }) === input;
 }
 function getComposedChildren(container) {
-  if (isHTMLElement(container) && getNodeName(container) === 'slot') {
+  if (floatingUi_utils.isHTMLElement(container) && floatingUi_utils.getNodeName(container) === 'slot') {
     const assignedElements = container.assignedElements({
       flatten: true
     });
@@ -2351,7 +2080,7 @@ function getComposedChildren(container) {
       return assignedElements;
     }
   }
-  if (isHTMLElement(container) && container.shadowRoot) {
+  if (floatingUi_utils.isHTMLElement(container) && container.shadowRoot) {
     return Array.from(container.shadowRoot.children);
   }
   return Array.from(container.children);
@@ -2366,7 +2095,7 @@ function appendCandidates(container, list) {
 }
 function appendMatchingElements(container, selector, list) {
   getComposedChildren(container).forEach(child => {
-    if (isHTMLElement(child) && child.matches(selector)) {
+    if (floatingUi_utils.isHTMLElement(child) && child.matches(selector)) {
       list.push(child);
     }
     appendMatchingElements(child, selector, list);
@@ -2523,7 +2252,7 @@ function unwrapHost(node) {
   if (!node) {
     return null;
   }
-  return isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
+  return floatingUi_utils.isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
 }
 const correctElements = (parent, targets) => targets.map(target => {
   if (parent.contains(target)) {
@@ -2553,7 +2282,7 @@ const collectOutsideElements = (root, keepElements, stopElements) => {
       return;
     }
     Array.from(parent.children).forEach(node => {
-      if (getNodeName(node) === 'script') {
+      if (floatingUi_utils.getNodeName(node) === 'script') {
         return;
       }
       if (keepElements.has(node)) {
@@ -2772,7 +2501,12 @@ function useFloatingPortalNode(props = {}) {
       }
       return;
     }
-    const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
+
+    // React 17 does not use React.useId().
+    if (uniqueId == null) {
+      return;
+    }
+    const resolvedContainer = (containerProp && (floatingUi_utils.isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
     if (resolvedContainer == null) {
       if (containerRef.current) {
         containerRef.current = null;
@@ -2786,7 +2520,7 @@ function useFloatingPortalNode(props = {}) {
       setPortalNode(null);
       setContainerElement(resolvedContainer);
     }
-  }, [containerProp, parentPortalNode]);
+  }, [containerProp, parentPortalNode, uniqueId]);
   const portalElement = useRenderElement.useRenderElement('div', componentProps, {
     ref: [ref, setPortalNodeRef],
     props: [{
@@ -2799,11 +2533,8 @@ function useFloatingPortalNode(props = {}) {
   // Another call inside `FloatingPortal`/`FloatingPortalLite` then injects the children into `portalElement`.
   const portalSubtree = containerElement && portalElement ? /*#__PURE__*/ReactDOM__namespace.createPortal(portalElement, containerElement) : null;
   return {
-    node: portalNode,
-    // `id` and `render` props can override or remove the generated ID. Use the exact
-    // rendered value so `aria-owns` never points at an ID absent from the DOM.
-    nodeId: /*#__PURE__*/React__namespace.isValidElement(portalElement) ? portalElement.props.id : undefined,
-    subtree: portalSubtree
+    portalNode,
+    portalSubtree
   };
 }
 
@@ -2823,12 +2554,12 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
     style,
     children,
     container,
+    renderGuards,
     ...elementProps
   } = componentProps;
   const {
-    node: portalNode,
-    nodeId: portalNodeId,
-    subtree: portalSubtree
+    portalNode,
+    portalSubtree
   } = useFloatingPortalNode({
     container,
     ref: forwardedRef,
@@ -2843,7 +2574,7 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
   const focusInsideDisabledRef = React__namespace.useRef(false);
   const modal = focusManagerState?.modal;
   const open = focusManagerState?.open;
-  const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
+  const shouldRenderGuards = typeof renderGuards === 'boolean' ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
 
   // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx
   React__namespace.useEffect(() => {
@@ -2905,7 +2636,7 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
           }
         }
       }), shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx("span", {
-        "aria-owns": portalNodeId,
+        "aria-owns": portalNode.id,
         style: ownerVisuallyHidden
       }), portalNode && /*#__PURE__*/ReactDOM__namespace.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
         "data-type": "outside",
@@ -3062,7 +2793,7 @@ function resolveRef(maybeRef) {
 }
 
 function getEventType(event, lastInteractionType) {
-  const win = getWindow(getTarget(event));
+  const win = floatingUi_utils.getWindow(getTarget(event));
   if (event instanceof win.KeyboardEvent) {
     return 'keyboard';
   }
@@ -3092,7 +2823,7 @@ function clearDisconnectedPreviouslyFocusedElements() {
 }
 function addPreviouslyFocusedElement(element) {
   clearDisconnectedPreviouslyFocusedElements();
-  if (element && getNodeName(element) !== 'body') {
+  if (element && floatingUi_utils.getNodeName(element) !== 'body') {
     previouslyFocusedElements.push(new WeakRef(element));
     if (previouslyFocusedElements.length > LIST_LIMIT) {
       previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
@@ -3169,10 +2900,11 @@ function FloatingFocusManager(props) {
   } = store.context;
   const getNodeId = useStableCallback(() => dataRef.current.floatingContext?.nodeId);
   const ignoreInitialFocus = initialFocus === false;
-  // A typeable combobox reference (e.g. input/textarea) with `initialFocus={false}`
-  // has different focus semantics: focus is not trapped inside the floating element,
-  // so in the modal case the guards are not rendered, but `aria-hidden` is still
-  // applied to the outside nodes.
+  // If the reference is a combobox and is typeable (e.g. input/textarea),
+  // there are different focus semantics. The guards should not be rendered, but
+  // aria-hidden should be applied to all nodes still. Further, the visually
+  // hidden dismiss button should only appear at the end of the list, not the
+  // start.
   const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
   const initialFocusRef = useValueAsRef(initialFocus);
   const returnFocusRef = useValueAsRef(returnFocus);
@@ -3286,25 +3018,25 @@ function FloatingFocusManager(props) {
         const triggers = store.context.triggerElements;
         const insideElements = getResolvedInsideElements();
         const isRelatedFocusGuard = relatedTarget?.hasAttribute(createAttribute('focus-guard')) && [beforeGuardRef.current, afterGuardRef.current, portalContext?.beforeInsideRef.current, portalContext?.afterInsideRef.current, portalContext?.beforeOutsideRef.current, portalContext?.afterOutsideRef.current, resolveRef(previousFocusableElement), resolveRef(nextFocusableElement)].includes(relatedTarget);
-        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || contains(element, relatedTarget)) || triggers.hasMatchingElement(trigger => contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
+        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || contains(element, relatedTarget)) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement(trigger => contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
         if (currentTarget === domReference && floatingFocusElement) {
           handleTabIndex(floatingFocusElement);
         }
 
-        // Restore focus to the previously focused tabbable element to prevent
+        // Restore focus to the previous tabbable element index to prevent
         // focus from being lost outside the floating tree.
         if (restoreFocus && currentTarget !== domReference && !isElementVisible(target) && activeElement(doc) === doc.body) {
           // Let `FloatingPortal` effect knows that focus is still inside the
           // floating tree.
-          if (isHTMLElement(floatingFocusElement)) {
+          if (floatingUi_utils.isHTMLElement(floatingFocusElement)) {
             floatingFocusElement.focus();
             // If explicitly requested to restore focus to the popup container, do not search
             // for the next/previous tabbable element.
             if (restoreFocus === 'popup') {
-              // If the focused element is removed on pointerdown, the browser
-              // tries to move focus to it right after the `.focus()` call above,
-              // but because it's removed in the same tick, focus is lost instead.
-              // Re-focusing asynchronously (next frame) wins that race.
+              // If the element is removed on pointerdown, focus tries to move it,
+              // but since it's removed at the same time, focus gets lost as it
+              // happens after the .focus() call above.
+              // In this case, focus needs to be moved asynchronously.
               restoreFocusFrame.request(() => {
                 floatingFocusElement.focus();
               });
@@ -3314,7 +3046,7 @@ function FloatingFocusManager(props) {
           const tabbableContent = getTabbableContent();
           const prevTabbable = lastFocusedTabbableRef.current;
           const nodeToFocus = (prevTabbable && tabbableContent.includes(prevTabbable) ? prevTabbable : null) || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
-          if (isHTMLElement(nodeToFocus)) {
+          if (floatingUi_utils.isHTMLElement(nodeToFocus)) {
             nodeToFocus.focus();
           }
         }
@@ -3350,7 +3082,7 @@ function FloatingFocusManager(props) {
         dataRef.current.insideReactTree = false;
       });
     }
-    const domReferenceElement = isHTMLElement(domReference) ? domReference : null;
+    const domReferenceElement = floatingUi_utils.isHTMLElement(domReference) ? domReference : null;
     if (!floating && !domReferenceElement) {
       return undefined;
     }
@@ -3383,11 +3115,9 @@ function FloatingFocusManager(props) {
 
   // Focus the initial element when the floating element opens.
   useIsoLayoutEffect(() => {
-    if (!open || disabled || !isHTMLElement(floatingFocusElement)) {
+    if (!open || disabled || !floatingUi_utils.isHTMLElement(floatingFocusElement)) {
       return;
     }
-    closeTypeRef.current = '';
-    lastInteractionTypeRef.current = '';
     const doc = ownerDocument(floatingFocusElement);
     const previouslyFocusedElement = activeElement(doc);
 
@@ -3419,9 +3149,7 @@ function FloatingFocusManager(props) {
       }
       elToFocus = elToFocus || getDefaultFocusElement();
       const hadFocusInside = contains(floatingFocusElement, activeElement(doc));
-
-      // enqueueFocus returns a rAF-cancel function; we intentionally don't cancel this focus.
-      void enqueueFocus(elToFocus, {
+      enqueueFocus(elToFocus, {
         preventScroll: elToFocus === floatingFocusElement,
         shouldFocus() {
           // This focus is queued on the next animation frame. If the floating element has closed
@@ -3448,11 +3176,13 @@ function FloatingFocusManager(props) {
     }
     const doc = ownerDocument(floatingFocusElement);
     const elementFocusedBeforeOpen = activeElement(doc);
-    // Only an explicit `null` interaction type represents a programmatic open.
-    // `undefined` is normalized to `''` by the prop default, so it never reaches
-    // here as nullish and is intentionally not treated as programmatic.
+    // Only nullish interaction types represent programmatic opens. The empty
+    // string default is intentionally not treated as programmatic.
     const preferPreviousFocus = openInteractionTypeRef.current == null;
     addPreviouslyFocusedElement(elementFocusedBeforeOpen);
+
+    // Dismissing via outside press should always ignore `returnFocus` to
+    // prevent unwanted scrolling.
     function onOpenChangeLocal(details) {
       if (!details.open) {
         closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
@@ -3468,11 +3198,6 @@ function FloatingFocusManager(props) {
       } else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) {
         preventReturnFocusRef.current = false;
       } else {
-        // On outside press, only return focus to the reference when the browser supports the
-        // `focus({ preventScroll })` option; without it, restoring focus scrolls the page.
-        // Chrome on Android and Samsung Internet still don't support `preventScroll`
-        // (https://issues.chromium.org/issues/41453122), so the runtime check keeps return
-        // focus disabled there to avoid the scroll jump.
         let isPreventScrollSupported = false;
         ownerDocument(floatingFocusElement).createElement('div').focus({
           get preventScroll() {
@@ -3488,9 +3213,9 @@ function FloatingFocusManager(props) {
       }
     }
     events.on('openchange', onOpenChangeLocal);
-    function getReturnElement(closeType) {
+    function getReturnElement() {
       const returnFocusValueOrFn = returnFocusRef.current;
-      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeType) : returnFocusValueOrFn;
+      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
 
       // `null` should fallback to default behavior in case of an empty ref.
       if (resolvedReturnFocusValue === undefined || resolvedReturnFocusValue === false) {
@@ -3500,7 +3225,7 @@ function FloatingFocusManager(props) {
         resolvedReturnFocusValue = true;
       }
       const referenceReturnElement = domReference?.isConnected ? domReference : null;
-      const previousReturnElement = elementFocusedBeforeOpen?.isConnected && getNodeName(elementFocusedBeforeOpen) !== 'body' ? elementFocusedBeforeOpen : null;
+      const previousReturnElement = elementFocusedBeforeOpen?.isConnected && floatingUi_utils.getNodeName(elementFocusedBeforeOpen) !== 'body' ? elementFocusedBeforeOpen : null;
       let defaultReturnElement = preferPreviousFocus ? previousReturnElement || referenceReturnElement : referenceReturnElement || previousReturnElement;
       if (!defaultReturnElement) {
         defaultReturnElement = getPreviouslyFocusedElement() || null;
@@ -3518,25 +3243,19 @@ function FloatingFocusManager(props) {
 
       // eslint-disable-next-line react-hooks/exhaustive-deps
       const returnFocusValueOrFn = returnFocusRef.current;
-      const closeType = closeTypeRef.current;
-      const returnElement = getReturnElement(closeType);
+      const returnElement = getReturnElement();
       queueMicrotask(() => {
-        // `returnElement` if it is tabbable, otherwise its first tabbable child,
-        // otherwise `returnElement` itself (which may not be tabbable at all).
+        // This is `returnElement`, if it's tabbable, or its first tabbable child.
         const tabbableReturnElement = getFirstTabbableElement(returnElement);
         const hasExplicitReturnFocus = typeof returnFocusValueOrFn !== 'boolean';
-        if (returnFocusValueOrFn && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (
+        if (returnFocusValueOrFn && !preventReturnFocusRef.current && floatingUi_utils.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)) {
-          const focusOptions = {
+          tabbableReturnElement.focus({
             preventScroll: true
-          };
-          if (closeType === 'keyboard') {
-            focusOptions.focusVisible = true;
-          }
-          tabbableReturnElement.focus(focusOptions);
+          });
         }
         preventReturnFocusRef.current = false;
       });
@@ -3551,7 +3270,7 @@ function FloatingFocusManager(props) {
       return;
     }
     const activeEl = activeElement(ownerDocument(floating));
-    if (!isHTMLElement(activeEl) || !isTypeableElement(activeEl)) {
+    if (!floatingUi_utils.isHTMLElement(activeEl) || !isTypeableElement(activeEl)) {
       return;
     }
     if (contains(floating, activeEl)) {
@@ -3559,8 +3278,8 @@ function FloatingFocusManager(props) {
     }
   }, [open, floating]);
 
-  // Synchronize the focus manager state (modal, closeOnFocusOut, open, etc.) to the
-  // FloatingPortal context, which uses it to decide whether to render its own guards.
+  // Synchronize the `context` & `modal` value to the FloatingPortal context.
+  // It will decide whether or not it needs to render its own guards.
   useIsoLayoutEffect(() => {
     if (disabled || !portalContext) {
       return undefined;
@@ -3595,8 +3314,7 @@ function FloatingFocusManager(props) {
       onFocus: event => {
         if (modal) {
           const els = getTabbableContent();
-          // enqueueFocus returns a rAF-cancel function we don't need here.
-          void enqueueFocus(els[els.length - 1]);
+          enqueueFocus(els[els.length - 1]);
         } else if (portalContext?.portalNode) {
           preventReturnFocusRef.current = false;
           if (isOutsideEvent(event, portalContext.portalNode)) {
@@ -3612,8 +3330,7 @@ function FloatingFocusManager(props) {
       ref: mergedAfterGuardRef,
       onFocus: event => {
         if (modal) {
-          // enqueueFocus returns a rAF-cancel function we don't need here.
-          void enqueueFocus(getTabbableContent()[0]);
+          enqueueFocus(getTabbableContent()[0]);
         } else if (portalContext?.portalNode) {
           if (closeOnFocusOut) {
             preventReturnFocusRef.current = true;
@@ -3685,11 +3402,7 @@ function useClick(context, props = {}) {
     }
     return {
       onPointerDown(event) {
-        // Screen reader activations (Android TalkBack, desktop screen readers) report a
-        // mouse-like `pointerType`, but `ignoreMouse` must not drop them: hover logic cannot
-        // open for a virtual press since there is no real pointer movement to wait for.
-        // Virtual `touch` presses (iOS VoiceOver) keep their type so `touchOpenDelay` applies.
-        pointerTypeRef.current = isMouseLikePointerType(event.pointerType, true) && isVirtualPointerEvent(event.nativeEvent) ? 'virtual' : event.pointerType;
+        pointerTypeRef.current = event.pointerType;
       },
       onMouseDown(event) {
         const pointerType = pointerTypeRef.current;
@@ -3869,7 +3582,7 @@ function useDismiss(context, props = {}) {
   });
   React__namespace.useEffect(() => {
     if (!open || !enabled) {
-      return clearInsideReactTree;
+      return undefined;
     }
     dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
     dataRef.current.__outsidePressBubbles = outsidePressBubbles;
@@ -3938,18 +3651,18 @@ function useDismiss(context, props = {}) {
       }
       const target = getTarget(event);
       const inertSelector = `[${createAttribute('inert')}]`;
-      const targetRoot = isElement(target) ? target.getRootNode() : null;
-      const markers = Array.from((isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select('floatingElement'))).querySelectorAll(inertSelector));
+      const targetRoot = floatingUi_utils.isElement(target) ? target.getRootNode() : null;
+      const markers = Array.from((floatingUi_utils.isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select('floatingElement'))).querySelectorAll(inertSelector));
       const triggers = store.context.triggerElements;
 
       // If another trigger is clicked, don't close the floating element.
       if (target && (triggers.hasElement(target) || triggers.hasMatchingElement(trigger => contains(trigger, target)))) {
         return;
       }
-      let targetRootAncestor = isElement(target) ? target : null;
-      while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
-        const nextParent = getParentNode(targetRootAncestor);
-        if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
+      let targetRootAncestor = floatingUi_utils.isElement(target) ? target : null;
+      while (targetRootAncestor && !floatingUi_utils.isLastTraversableNode(targetRootAncestor)) {
+        const nextParent = floatingUi_utils.getParentNode(targetRootAncestor);
+        if (floatingUi_utils.isLastTraversableNode(nextParent) || !floatingUi_utils.isElement(nextParent)) {
           break;
         }
         targetRootAncestor = nextParent;
@@ -3957,7 +3670,7 @@ function useDismiss(context, props = {}) {
 
       // Check if the click occurred on a third-party element injected after the
       // floating element rendered.
-      if (markers.length && isElement(target) && !isRootElement(target) &&
+      if (markers.length && floatingUi_utils.isElement(target) && !isRootElement(target) &&
       // Clicked on a direct ancestor (e.g. FloatingOverlay).
       !contains(target, store.select('floatingElement')) &&
       // If the target root element contains none of the markers, then the
@@ -3968,9 +3681,9 @@ function useDismiss(context, props = {}) {
 
       // Check if the click occurred on the scrollbar
       // Skip for touch events: scrollbars don't receive touch events on most platforms
-      if (isHTMLElement(target) && !('touches' in event)) {
-        const lastTraversableNode = isLastTraversableNode(target);
-        const style = getComputedStyle(target);
+      if (floatingUi_utils.isHTMLElement(target) && !('touches' in event)) {
+        const lastTraversableNode = floatingUi_utils.isLastTraversableNode(target);
+        const style = floatingUi_utils.getComputedStyle(target);
         const scrollRe = /auto|scroll/;
         const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
         const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
@@ -4147,9 +3860,9 @@ function useDismiss(context, props = {}) {
       preventedPressSuppressionTimeout.clear();
       resetPressStartState();
       suppressNextOutsideClickRef.current = false;
-      clearInsideReactTree();
     };
   }, [dataRef, floatingElement, escapeKey$1, outsidePressEnabled, outsidePress$1, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store, cancelDismissOnEndTimeout]);
+  React__namespace.useEffect(clearInsideReactTree, [outsidePress$1, clearInsideReactTree]);
   const reference = React__namespace.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
     onPointerDown: closeOnReferencePress,
@@ -4183,12 +3896,12 @@ function useDismiss(context, props = {}) {
 }
 
 const selectors = {
-  open: state => state.open,
-  transitionStatus: state => state.transitionStatus,
-  domReferenceElement: state => state.domReferenceElement,
-  referenceElement: state => state.positionReference ?? state.referenceElement,
-  floatingElement: state => state.floatingElement,
-  floatingId: state => state.floatingId
+  open: createSelector(state => state.open),
+  transitionStatus: createSelector(state => state.transitionStatus),
+  domReferenceElement: createSelector(state => state.domReferenceElement),
+  referenceElement: createSelector(state => state.positionReference ?? state.referenceElement),
+  floatingElement: createSelector(state => state.floatingElement),
+  floatingId: createSelector(state => state.floatingId)
 };
 class FloatingRootStore extends ReactStore {
   constructor(options) {
@@ -4299,7 +4012,7 @@ function useSyncedFloatingRootContext(options) {
       referenceElement,
       floatingElement
     };
-    if (isElement(referenceElement)) {
+    if (floatingUi_utils.isElement(referenceElement)) {
       valuesToSync.domReferenceElement = referenceElement;
     }
     if (store.state.positionReference === store.state.referenceElement) {
@@ -4377,14 +4090,44 @@ function useTransitionStatus(open, enableIdleState = false, deferEndingState = f
   };
 }
 
+let TransitionStatusDataAttributes = /*#__PURE__*/function (TransitionStatusDataAttributes) {
+  /**
+   * Present when the component is animating in.
+   */
+  TransitionStatusDataAttributes["startingStyle"] = "data-starting-style";
+  /**
+   * Present when the component is animating out.
+   */
+  TransitionStatusDataAttributes["endingStyle"] = "data-ending-style";
+  return TransitionStatusDataAttributes;
+}({});
+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;
+  }
+};
+
 /**
  * Executes a function once all animations have finished on the provided element.
- * If an animation is canceled, waits for any replacement animations before executing.
  * @param elementOrRef - The element to watch for animations.
  * @param waitForStartingStyleRemoved - Whether to wait for [data-starting-style] to be removed before checking for animations.
+ * @param treatAbortedAsFinished - Whether to treat aborted animations as finished. If `false`, and there are aborted animations,
+ *   the function will check again if any new animations have started and wait for them to finish.
  * @returns A function that takes a callback to execute once all animations have finished, and an optional AbortSignal to abort the callback
  */
-function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false) {
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false, treatAbortedAsFinished = true) {
   const frame = useAnimationFrame();
   return useStableCallback((fnToExecute,
   /**
@@ -4413,22 +4156,23 @@ function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false
         if (!signal?.aborted) {
           done();
         }
-      }, () => {
-        if (signal?.aborted) {
+      }).catch(() => {
+        if (treatAbortedAsFinished) {
+          if (!signal?.aborted) {
+            done();
+          }
           return;
         }
         const currentAnimations = resolvedElement.getAnimations();
-        if (currentAnimations.some(animation => animation.pending || animation.playState !== 'finished')) {
+        if (!signal?.aborted && currentAnimations.length > 0 && currentAnimations.some(animation => animation.pending || animation.playState !== 'finished')) {
           // Sometimes animations can be aborted because a property they depend on changes while the animation plays.
           // In such cases, we need to re-check if any new animations have started.
           exec();
-          return;
         }
-        done();
       });
     }
     if (waitForStartingStyleRemoved) {
-      const startingStyleAttribute = 'data-starting-style';
+      const startingStyleAttribute = TransitionStatusDataAttributes.startingStyle;
 
       // If `[data-starting-style]` isn't present, fall back to waiting one more frame
       // to give "open" animations a chance to be registered.
@@ -4468,7 +4212,7 @@ function useOpenChangeComplete(parameters) {
     onComplete: onCompleteParam
   } = parameters;
   const onComplete = useStableCallback(onCompleteParam);
-  const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
+  const runOnceAnimationsFinish = useAnimationsFinished(ref, open, false);
   React__namespace.useEffect(() => {
     if (!enabled) {
       return undefined;
@@ -4494,26 +4238,14 @@ const FOCUSABLE_POPUP_PROPS = {
 function createDefaultInitialFocus(popupRef) {
   return interactionType => interactionType === 'touch' ? popupRef.current : true;
 }
-
-/**
- * The subset of a popup handle that a Root needs to bind its store to. Both the real handle classes
- * and any test double satisfy it.
- */
-
-/**
- * Creates and owns a popup store on behalf of a Root part. The store is created exactly once, with
- * controlled props and root state synced separately after creation. Sets up the synced floating
- * root context and returns the store.
- *
- * @param createStore Factory that builds the store. Called exactly once, receiving the floating id
- * and whether the popup is nested inside another floating element, both resolved on the first render.
- * @param treatPopupAsFloatingElement Whether the popup element is passed to Floating UI as the
- * floating element instead of the default positioner.
- */
-function usePopupRootStore(createStore, treatPopupAsFloatingElement = false) {
+function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement = false) {
   const floatingId = useId();
   const nested = useFloatingParentNodeId() != null;
-  const store = useRenderElement.useRefWithInit(() => createStore(floatingId, nested)).current;
+  const internalStoreRef = React__namespace.useRef(null);
+  if (externalStore === undefined && internalStoreRef.current === null) {
+    internalStoreRef.current = createStore(floatingId, nested);
+  }
+  const store = externalStore ?? internalStoreRef.current;
   useSyncedFloatingRootContext({
     popupStore: store,
     treatPopupAsFloatingElement,
@@ -4522,27 +4254,10 @@ function usePopupRootStore(createStore, treatPopupAsFloatingElement = false) {
     nested,
     onOpenChange: store.setOpen
   });
-  return store;
-}
-
-/**
- * Attaches a Root's store to a handle for this component's committed lifetime. Popup Roots render
- * it before their interactions and user children so its layout effect runs before descendant layout
- * effects. This lets descendants call the handle during the Root's initial commit without attaching
- * during render, which would leak suspended or abandoned stores. Store subscribers are notified by
- * `attachStore` in this ordinary layout phase, where React permits synchronous updates.
- *
- * Popup Roots must render this component only when a handle is present so handle-less Roots avoid
- * mounting an extra fiber and layout effect.
- */
-function PopupHandleAttachment({
-  handle,
-  store
-}) {
-  useIsoLayoutEffect(() => {
-    return handle.attachStore(store);
-  }, [handle, store]);
-  return null;
+  return {
+    store,
+    internalStore: internalStoreRef.current
+  };
 }
 
 /**
@@ -4607,6 +4322,19 @@ function attachPreventUnmountOnClose(eventDetails) {
   };
   return () => preventUnmountOnClose;
 }
+function useInitialOpenSync(store, openProp, defaultOpen, defaultTriggerId) {
+  useOnFirstRender(() => {
+    if (openProp === undefined && store.state.open === false && defaultOpen) {
+      // Avoid notifying detached trigger subscribers while the Root is rendering.
+      store.state = {
+        ...store.state,
+        open: true,
+        activeTriggerId: defaultTriggerId,
+        preventUnmountingOnClose: false
+      };
+    }
+  });
+}
 
 /**
  * Sets up trigger data forwarding to the store.
@@ -4619,11 +4347,11 @@ function attachPreventUnmountOnClose(eventDetails) {
 function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates) {
   const isMountedByThisTrigger = store.useState('isMountedByTrigger', triggerId);
   const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
-
-  // Applies trigger-owned state (active-trigger ownership and payload) when the trigger registers.
-  // Stable so payload/`stateUpdates` changes do not change the ref identity (which would needlessly
-  // churn registration); it reads the latest closure values when invoked.
-  const applyTriggerData = useStableCallback(element => {
+  const registerTrigger = useStableCallback(element => {
+    baseRegisterTrigger(element);
+    if (!element) {
+      return;
+    }
     const open = store.select('open');
     const activeTriggerId = store.select('activeTriggerId');
     if (activeTriggerId === triggerId) {
@@ -4644,18 +4372,6 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
       });
     }
   });
-
-  // Intentionally NOT stable. Its identity is derived from `baseRegisterTrigger`, which is keyed on
-  // `[store, id]`, so when a handle-backed trigger's store pointer swaps the merged ref re-fires —
-  // unregistering from the previous store and registering into the new one. This lets a detached
-  // trigger follow its handle's currently-attached store across attach/detach/remount. (A stable
-  // callback would keep its identity and never re-fire on a store swap.)
-  const registerTrigger = React__namespace.useCallback(element => {
-    baseRegisterTrigger(element);
-    if (element) {
-      applyTriggerData(element);
-    }
-  }, [baseRegisterTrigger, applyTriggerData]);
   useIsoLayoutEffect(() => {
     if (isMountedByThisTrigger) {
       store.update({
@@ -4675,17 +4391,12 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
  *
  * When a popup opens without an explicit trigger id and exactly one trigger is registered, that
  * trigger is claimed as the active trigger. When the active trigger id is still registered but its
- * element changed, the active element is refreshed. When the active trigger id is missing from the
- * registry but the same element is still registered under a different id (e.g. the rendered trigger
- * carries its own DOM `id` that differs from Base UI's internal trigger id), the active id is
- * reassociated to the registered id instead of being treated as lost. When the active trigger
- * unregisters, the default path preserves existing ownership so non-closing popup families do not
- * silently claim a different trigger while staying open.
+ * element changed, the active element is refreshed. When the active trigger unregisters, the
+ * default path preserves existing ownership so non-closing popup families do not silently claim a
+ * different trigger while staying open.
  *
- * If `closeOnActiveTriggerUnmount` is enabled, unregistering a previously resolved active trigger
- * requests a close after a microtask so a same-tick replacement trigger with the same id can
- * register first. An active trigger id that has not matched a registered trigger yet is treated as
- * pending and does not request a close.
+ * If `closeOnActiveTriggerUnmount` is enabled, unregistering the active trigger requests a close
+ * after a microtask so a same-tick replacement trigger with the same id can register first.
  *
  * This should be called on the Root part.
  *
@@ -4696,22 +4407,10 @@ function useImplicitActiveTrigger(store, options = {}) {
   const {
     closeOnActiveTriggerUnmount = false
   } = options;
-  // Distinguishes a trigger that unmounted from a new active trigger that has not hydrated yet.
-  const resolvedActiveTriggerIdRef = React__namespace.useRef(null);
   const open = store.useState('open');
   const reactiveTriggerCount = store.useState('triggerCount');
-  // Subscribe to the active trigger id so the reconciliation below reruns when ownership moves to
-  // another trigger while the popup stays open (e.g. a focus/hover handoff between triggers).
-  const activeTriggerId = store.useState('activeTriggerId');
-  // Subscribe to the active trigger element so the reconciliation reruns when a pending active
-  // trigger registers in a commit where the trigger count nets out unchanged (registration
-  // forwards the element to the store when the registering trigger matches the active id).
-  // Without this, the id would never be marked resolved and a later genuine unmount would be
-  // misclassified as pending, disabling `closeOnActiveTriggerUnmount`.
-  const reactiveActiveTriggerElement = store.useState('activeTriggerElement');
   useIsoLayoutEffect(() => {
     if (!open) {
-      resolvedActiveTriggerIdRef.current = null;
       if (store.state.triggerCount !== 0) {
         store.set('triggerCount', 0);
       }
@@ -4722,42 +4421,22 @@ function useImplicitActiveTrigger(store, options = {}) {
     if (store.state.triggerCount !== triggerCount) {
       stateUpdates.triggerCount = triggerCount;
     }
-    const currentActiveTriggerId = store.select('activeTriggerId');
+    const activeTriggerId = store.select('activeTriggerId');
     let lostActiveTriggerId = null;
-    if (currentActiveTriggerId) {
-      const activeTriggerElement = store.context.triggerElements.getById(currentActiveTriggerId);
+    if (activeTriggerId) {
+      const activeTriggerElement = store.context.triggerElements.getById(activeTriggerId);
       if (!activeTriggerElement) {
-        for (const [triggerId, triggerElement] of store.context.triggerElements.entries()) {
-          if (triggerElement === store.state.activeTriggerElement) {
-            stateUpdates.activeTriggerId = triggerId;
-            stateUpdates.activeTriggerElement = triggerElement;
-            resolvedActiveTriggerIdRef.current = triggerId;
-            break;
-          }
-        }
-        if (stateUpdates.activeTriggerId === undefined) {
-          if (resolvedActiveTriggerIdRef.current === currentActiveTriggerId) {
-            lostActiveTriggerId = currentActiveTriggerId;
-          } else {
-            resolvedActiveTriggerIdRef.current = null;
-          }
-        }
-      } else {
-        resolvedActiveTriggerIdRef.current = currentActiveTriggerId;
-        if (activeTriggerElement !== store.state.activeTriggerElement) {
-          stateUpdates.activeTriggerElement = activeTriggerElement;
-        }
+        lostActiveTriggerId = activeTriggerId;
+      } else if (activeTriggerElement !== store.state.activeTriggerElement) {
+        stateUpdates.activeTriggerElement = activeTriggerElement;
       }
-    } else {
-      resolvedActiveTriggerIdRef.current = null;
     }
-    if (!lostActiveTriggerId && !currentActiveTriggerId && triggerCount === 1) {
+    if (!lostActiveTriggerId && !activeTriggerId && triggerCount === 1) {
       const iteratorResult = store.context.triggerElements.entries().next();
       if (!iteratorResult.done) {
         const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
         stateUpdates.activeTriggerId = implicitTriggerId;
         stateUpdates.activeTriggerElement = implicitTriggerElement;
-        resolvedActiveTriggerIdRef.current = implicitTriggerId;
       }
     }
     if (stateUpdates.triggerCount !== undefined || stateUpdates.activeTriggerId !== undefined || stateUpdates.activeTriggerElement !== undefined) {
@@ -4782,7 +4461,7 @@ function useImplicitActiveTrigger(store, options = {}) {
         });
       }
     }
-  }, [open, store, reactiveTriggerCount, activeTriggerId, reactiveActiveTriggerElement, closeOnActiveTriggerUnmount]);
+  }, [open, store, reactiveTriggerCount, closeOnActiveTriggerUnmount]);
 }
 
 /**
@@ -4860,33 +4539,13 @@ function usePopupRootSync(store, open) {
   }, [store]);
 }
 
-/**
- * Development-only reverse index of element to registered id, keyed by the owning map.
- *
- * Registration would otherwise have to scan every entry to detect an element claimed by two ids,
- * making the mount of many triggers sharing one handle quadratic. Kept module-scoped, lazily
- * initialized, and read only from `process.env.NODE_ENV` guards so production builds drop it along
- * with the checks.
- */
-let devElementIdsByMap;
-function getDevElementIds(map) {
-  devElementIdsByMap ??= new WeakMap();
-  let elementIds = devElementIdsByMap.get(map);
-  if (!elementIds) {
-    elementIds = new WeakMap();
-    devElementIdsByMap.set(map, elementIds);
-  }
-  return elementIds;
-}
-
 /**
  * Data structure to keep track of popup trigger elements by their IDs.
- *
- * Element lookups iterate the id map rather than maintaining a parallel Set. Registration is O(1),
- * while `hasElement` and `hasMatchingElement` are linear in the number of triggers.
+ * Uses both a set of Elements and a map of IDs to Elements for efficient lookups.
  */
 class PopupTriggerMap {
   constructor() {
+    this.elementsSet = new Set();
     this.idMap = new Map();
   }
 
@@ -4896,56 +4555,49 @@ class PopupTriggerMap {
    * Note: The provided element is assumed to not be registered under multiple IDs.
    */
   add(id, element) {
+    const existingElement = this.idMap.get(id);
+    if (existingElement === element) {
+      return;
+    }
+    if (existingElement !== undefined) {
+      // We assume that the same element won't be registered under multiple ids.
+      // This is safe considering how useTriggerRegistration is implemented.
+      this.elementsSet.delete(existingElement);
+    }
+    this.elementsSet.add(element);
+    this.idMap.set(id, element);
     if (process.env.NODE_ENV !== 'production') {
-      const elementIds = getDevElementIds(this);
-      const existingId = elementIds.get(element);
-      if (existingId !== undefined && existingId !== id) {
+      if (this.elementsSet.size !== this.idMap.size) {
         // TODO: fix mui/no-guarded-throw
         // eslint-disable-next-line mui/no-guarded-throw
         throw new Error('Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.');
       }
-
-      // Reusing an id for a different element evicts the previous one, so it must lose its claim
-      // on the id or a later registration under a different id would be reported as a duplicate.
-      const previousElement = this.idMap.get(id);
-      if (previousElement !== undefined && previousElement !== element) {
-        elementIds.delete(previousElement);
-      }
-      elementIds.set(element, id);
     }
-    this.idMap.set(id, element);
   }
 
   /**
    * Removes the trigger element with the given ID.
    */
   delete(id) {
-    if (process.env.NODE_ENV !== 'production') {
-      const element = this.idMap.get(id);
-      if (element !== undefined) {
-        devElementIdsByMap?.get(this)?.delete(element);
-      }
+    const element = this.idMap.get(id);
+    if (element) {
+      this.elementsSet.delete(element);
+      this.idMap.delete(id);
     }
-    this.idMap.delete(id);
   }
 
   /**
    * Whether the given element is registered as a trigger.
    */
   hasElement(element) {
-    for (const registered of this.idMap.values()) {
-      if (registered === element) {
-        return true;
-      }
-    }
-    return false;
+    return this.elementsSet.has(element);
   }
 
   /**
    * Whether there is a registered trigger element matching the given predicate.
    */
   hasMatchingElement(predicate) {
-    for (const element of this.idMap.values()) {
+    for (const element of this.elementsSet) {
       if (predicate(element)) {
         return true;
       }
@@ -4971,7 +4623,7 @@ class PopupTriggerMap {
    * Returns an iterable of all registered trigger elements.
    */
   elements() {
-    return this.idMap.values();
+    return this.elementsSet.values();
   }
 
   /**
@@ -5031,11 +4683,14 @@ function useValueChanged(value, onChange) {
   const valueRef = React__namespace.useRef(value);
   const onChangeCallback = useStableCallback(onChange);
   useIsoLayoutEffect(() => {
-    if (valueRef.current !== value) {
-      onChangeCallback(valueRef.current);
+    if (valueRef.current === value) {
+      return;
     }
-    valueRef.current = value;
+    onChangeCallback(valueRef.current);
   }, [value, onChangeCallback]);
+  useIsoLayoutEffect(() => {
+    valueRef.current = value;
+  }, [value]);
 }
 
 function useOpenMethodTriggerProps(open, setOpenMethod) {
@@ -5078,6 +4733,9 @@ function useOpenInteractionType(open) {
   }), [openMethod, triggerProps]);
 }
 
+/**
+ * @internal
+ */
 const DirectionContext = /*#__PURE__*/React__namespace.createContext(undefined);
 if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
 function useDirection() {
@@ -5136,30 +4794,6 @@ function useFocusableWhenDisabled(parameters) {
   };
 }
 
-/**
- * Dispatches a constructed click on the target so it carries the source event's
- * modifier state, which `click()` always reports as unpressed. Like `click()`,
- * the untrusted click still runs native activation behavior (form submission,
- * link navigation).
- * `detail` defaults to 0 (the native convention for keyboard-generated clicks);
- * pass `detail: 1` when the click represents a mouse gesture so consumers keying
- * off `detail === 0` don't classify it as a keyboard activation.
- */
-function dispatchClickWithModifiers(target, sourceEvent, {
-  detail = 0
-} = {}) {
-  target.dispatchEvent(new (getWindow(target).PointerEvent)('click', {
-    bubbles: true,
-    cancelable: true,
-    composed: true,
-    detail,
-    shiftKey: sourceEvent.shiftKey,
-    ctrlKey: sourceEvent.ctrlKey,
-    altKey: sourceEvent.altKey,
-    metaKey: sourceEvent.metaKey
-  }));
-}
-
 function useButton(parameters = {}) {
   const {
     disabled = false,
@@ -5260,34 +4894,24 @@ function useButton(parameters = {}) {
             return;
           }
           event.preventDefault();
-
-          // Only a native-mode item that isn't a real <button> is excluded.
-          if (!isNativeButton || isButton) {
+          if (isLink || isNativeButton && isButton) {
+            currentTarget.click();
+            event.preventBaseUIHandler();
+          } else if (shouldClick) {
+            externalOnClick?.(event);
             event.preventBaseUIHandler();
-            dispatchClickWithModifiers(currentTarget, event);
           }
           return;
         }
 
         // Keyboard accessibility for native and non-native elements.
-        if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
-          // Space activates links on keyup (`role="button"` semantics, matching the
-          // composite path); prevent the page scroll Space would otherwise trigger.
-          // Enter is left to the browser's native link activation.
-          if (isCurrentTarget && isLink && isSpaceKey) {
+        if (shouldClick) {
+          if (!isNativeButton && (isSpaceKey || isEnterKey)) {
             event.preventDefault();
           }
-          return;
-        }
-
-        // Match native buttons: preventing the keydown's default cancels activation.
-        if (event.defaultPrevented) {
-          return;
-        }
-        event.preventDefault();
-        if (isEnterKey) {
-          event.preventBaseUIHandler();
-          dispatchClickWithModifiers(currentTarget, event);
+          if (!isNativeButton && isEnterKey) {
+            externalOnClick?.(event);
+          }
         }
       },
       onKeyUp(event) {
@@ -5307,14 +4931,9 @@ function useButton(parameters = {}) {
           return;
         }
 
-        // Keyboard accessibility for non interactive elements.
-        // Match native buttons: preventing the keyup's default cancels Space activation.
-        // Limitation: unlike a native <button>, a prevented *keydown* cannot cancel the
-        // activation — no state is kept between keydown and keyup, so we can't tell
-        // whether the keydown was prevented or even happened on this element.
-        if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === ' ') {
-          event.preventBaseUIHandler();
-          dispatchClickWithModifiers(event.currentTarget, event);
+        // Keyboard accessibility for non interactive elements
+        if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && event.key === ' ') {
+          externalOnClick?.(event);
         }
       },
       onPointerDown(event) {
@@ -5340,41 +4959,12 @@ function useButton(parameters = {}) {
   };
 }
 function isButtonElement(elem) {
-  return isHTMLElement(elem) && elem.tagName === 'BUTTON';
+  return floatingUi_utils.isHTMLElement(elem) && elem.tagName === 'BUTTON';
 }
 function isValidLinkElement(elem) {
-  return isHTMLElement(elem) && elem.tagName === 'A' && Boolean(elem.href);
+  return Boolean(elem?.tagName === 'A' && elem?.href);
 }
 
-let TransitionStatusDataAttributes = /*#__PURE__*/function (TransitionStatusDataAttributes) {
-  /**
-   * Present when the component begins animating in.
-   */
-  TransitionStatusDataAttributes["startingStyle"] = "data-starting-style";
-  /**
-   * Present when the component is animating out.
-   */
-  TransitionStatusDataAttributes["endingStyle"] = "data-ending-style";
-  return TransitionStatusDataAttributes;
-}({});
-const STARTING_HOOK = {
-  'data-starting-style': ''
-};
-const ENDING_HOOK = {
-  'data-ending-style': ''
-};
-const transitionStatusMapping = {
-  transitionStatus(value) {
-    if (value === 'starting') {
-      return STARTING_HOOK;
-    }
-    if (value === 'ending') {
-      return ENDING_HOOK;
-    }
-    return null;
-  }
-};
-
 let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
   /**
    * Present when the popup is open.
@@ -5385,7 +4975,7 @@ let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
    */
   CommonPopupDataAttributes["closed"] = "data-closed";
   /**
-   * Present when the popup begins animating in.
+   * Present when the popup is animating in.
    */
   CommonPopupDataAttributes[CommonPopupDataAttributes["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
   /**
@@ -5408,24 +4998,32 @@ let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
   CommonPopupDataAttributes["align"] = "data-align";
   return CommonPopupDataAttributes;
 }({});
-
-// Literal keys (instead of enum member references) keep the docs-only enums above
-// tree-shakeable: a runtime reference would retain the whole enum IIFE in every bundle.
+let CommonTriggerDataAttributes = /*#__PURE__*/function (CommonTriggerDataAttributes) {
+  /**
+   * Present when the popup is open.
+   */
+  CommonTriggerDataAttributes["popupOpen"] = "data-popup-open";
+  /**
+   * Present when a pressable trigger is pressed.
+   */
+  CommonTriggerDataAttributes["pressed"] = "data-pressed";
+  return CommonTriggerDataAttributes;
+}({});
 const TRIGGER_HOOK = {
-  'data-popup-open': ''
+  [CommonTriggerDataAttributes.popupOpen]: ''
 };
 const PRESSABLE_TRIGGER_HOOK = {
-  'data-popup-open': '',
-  'data-pressed': ''
+  [CommonTriggerDataAttributes.popupOpen]: '',
+  [CommonTriggerDataAttributes.pressed]: ''
 };
 const POPUP_OPEN_HOOK = {
-  'data-open': ''
+  [CommonPopupDataAttributes.open]: ''
 };
 const POPUP_CLOSED_HOOK = {
-  'data-closed': ''
+  [CommonPopupDataAttributes.closed]: ''
 };
 const ANCHOR_HIDDEN_HOOK = {
-  'data-anchor-hidden': ''
+  [CommonPopupDataAttributes.anchorHidden]: ''
 };
 const triggerOpenStateMapping = {
   open(value) {
@@ -5457,10 +5055,6 @@ const popupStateMapping = {
     return null;
   }
 };
-const popupTransitionStateMapping = {
-  ...popupStateMapping,
-  ...transitionStatusMapping
-};
 
 function inertValue(value) {
   if (useRenderElement.isReactVersionAtLeast(19)) {
@@ -5502,21 +5096,12 @@ if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "Inter
 let originalHtmlStyles = {};
 let originalBodyStyles = {};
 let originalHtmlScrollBehavior = '';
-
-// The viewport's overflow comes from <html> when it establishes its own scroll container, and
-// propagates from <body> otherwise. An `overflow` style on the other element doesn't lock the page.
-function getViewportScroller(html, body) {
-  return isOverflowElement(html) ? html : body;
-}
-function isPageScrollLocked(win, html, body) {
-  return /hidden|clip/.test(win.getComputedStyle(getViewportScroller(html, body)).overflowY);
-}
 function hasInsetScrollbars(referenceElement) {
   if (typeof document === 'undefined') {
     return false;
   }
   const doc = ownerDocument(referenceElement);
-  const win = getWindow(doc);
+  const win = floatingUi_utils.getWindow(doc);
   return win.innerWidth - doc.documentElement.clientWidth > 0;
 }
 function supportsStableScrollbarGutter(referenceElement) {
@@ -5527,7 +5112,7 @@ function supportsStableScrollbarGutter(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const scrollContainer = getViewportScroller(html, body);
+  const scrollContainer = floatingUi_utils.isOverflowElement(html) ? html : body;
   const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
   const originalHtmlStyleGutter = html.style.scrollbarGutter;
   html.style.scrollbarGutter = 'stable';
@@ -5548,7 +5133,7 @@ function preventScrollOverlayScrollbars(referenceElement) {
   // won't have any effect.
   // But if <body> has an `overflow` style (like `overflow-x: hidden`), we need to lock it
   // instead, as sticky elements shift otherwise.
-  const elementToLock = getViewportScroller(html, body);
+  const elementToLock = floatingUi_utils.isOverflowElement(html) ? html : body;
   const originalElementToLockStyles = {
     overflowY: elementToLock.style.overflowY,
     overflowX: elementToLock.style.overflowX
@@ -5565,7 +5150,7 @@ function preventScrollInsetScrollbars(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const win = getWindow(html);
+  const win = floatingUi_utils.getWindow(html);
   let scrollTop = 0;
   let scrollLeft = 0;
   let updateGutterOnly = false;
@@ -5613,7 +5198,7 @@ function preventScrollInsetScrollbars(referenceElement) {
     // with whitespace. Warn if <body> has margins?
     const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
     const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
-    const elementToLock = getViewportScroller(html, body);
+    const elementToLock = floatingUi_utils.isOverflowElement(html) ? html : body;
     updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
 
     /*
@@ -5643,9 +5228,7 @@ function preventScrollInsetScrollbars(referenceElement) {
       height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',
       width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',
       boxSizing: 'border-box',
-      // Assign the longhands that `cleanup` restores, so nothing is left behind.
-      overflowY: 'hidden',
-      overflowX: 'hidden',
+      overflow: 'hidden',
       scrollBehavior: 'unset'
     });
     body.scrollTop = scrollTop;
@@ -5710,30 +5293,11 @@ class ScrollLocker {
     }
     const doc = ownerDocument(referenceElement);
     const html = doc.documentElement;
-    const body = doc.body;
-    const win = getWindow(html);
-
-    // The page is already locked, either by the site author or by a non-Base UI overlay that
-    // hasn't cleaned up yet. Leave it alone and wait for the lock to clear before taking over,
-    // otherwise we'd snapshot the locked state and restore it after our own lock is released.
-    if (isPageScrollLocked(win, html, body)) {
-      const observer = new win.MutationObserver(() => {
-        if (isPageScrollLocked(win, html, body)) {
-          return;
-        }
-        observer.disconnect();
-        this.restore = null;
-        this.lock(referenceElement);
-      });
+    const htmlOverflowY = floatingUi_utils.getWindow(html).getComputedStyle(html).overflowY;
 
-      // Watch every attribute: locks are applied through inline styles, classes, or attributes
-      // paired with a stylesheet (`data-scroll-locked` in react-remove-scroll, for example).
-      const options = {
-        attributes: true
-      };
-      observer.observe(html, options);
-      observer.observe(body, options);
-      this.restore = () => observer.disconnect();
+    // If the site author already hid overflow on <html>, respect it and bail out.
+    if (htmlOverflowY === 'hidden' || htmlOverflowY === 'clip') {
+      this.restore = useRenderElement.NOOP;
       return;
     }
     const hasOverlayScrollbars = ios || !hasInsetScrollbars(referenceElement);
@@ -5768,7 +5332,6 @@ exports.ARROW_DOWN = ARROW_DOWN;
 exports.ARROW_LEFT = ARROW_LEFT;
 exports.ARROW_RIGHT = ARROW_RIGHT;
 exports.ARROW_UP = ARROW_UP;
-exports.AnimationFrame = AnimationFrame;
 exports.BASE_UI_SWIPE_IGNORE_SELECTOR = BASE_UI_SWIPE_IGNORE_SELECTOR;
 exports.CLICK_TRIGGER_IDENTIFIER = CLICK_TRIGGER_IDENTIFIER;
 exports.CommonPopupDataAttributes = CommonPopupDataAttributes;
@@ -5785,7 +5348,6 @@ exports.FocusGuard = FocusGuard;
 exports.InternalBackdrop = InternalBackdrop;
 exports.PATIENT_CLICK_THRESHOLD = PATIENT_CLICK_THRESHOLD;
 exports.POPUP_COLLISION_AVOIDANCE = POPUP_COLLISION_AVOIDANCE;
-exports.PopupHandleAttachment = PopupHandleAttachment;
 exports.PopupTriggerMap = PopupTriggerMap;
 exports.ReactStore = ReactStore;
 exports.SafeReact = SafeReact;
@@ -5799,57 +5361,33 @@ exports.android = android;
 exports.attachPreventUnmountOnClose = attachPreventUnmountOnClose;
 exports.cancelOpen = cancelOpen;
 exports.chipRemovePress = chipRemovePress;
-exports.clamp = clamp;
 exports.clearPress = clearPress;
 exports.closePress = closePress;
 exports.closeWatcher = closeWatcher;
 exports.contains = contains;
 exports.createAttribute = createAttribute;
 exports.createChangeEventDetails = createChangeEventDetails;
-exports.createCoords = createCoords;
 exports.createDefaultInitialFocus = createDefaultInitialFocus;
 exports.createGenericEventDetails = createGenericEventDetails;
+exports.createSelector = createSelector;
 exports.decrementPress = decrementPress;
-exports.dispatchClickWithModifiers = dispatchClickWithModifiers;
 exports.enqueueFocus = enqueueFocus;
 exports.error = error;
 exports.escapeKey = escapeKey;
-exports.evaluate = evaluate;
 exports.fastComponent = fastComponent;
 exports.fastComponentRef = fastComponentRef;
 exports.findNonDisabledListIndex = findNonDisabledListIndex;
-exports.floor = floor;
 exports.focusOut = focusOut;
 exports.gecko = gecko;
-exports.getAlignment = getAlignment;
-exports.getAlignmentAxis = getAlignmentAxis;
-exports.getAlignmentSides = getAlignmentSides;
-exports.getAxisLength = getAxisLength;
-exports.getComputedStyle = getComputedStyle;
-exports.getContainingBlock = getContainingBlock;
-exports.getDocumentElement = getDocumentElement;
-exports.getExpandedPlacements = getExpandedPlacements;
 exports.getFloatingFocusElement = getFloatingFocusElement;
-exports.getFrameElement = getFrameElement;
 exports.getGridNavigatedIndex = getGridNavigatedIndex;
 exports.getMaxListIndex = getMaxListIndex;
 exports.getMinListIndex = getMinListIndex;
 exports.getNextTabbable = getNextTabbable;
 exports.getNodeChildren = getNodeChildren;
-exports.getNodeName = getNodeName;
-exports.getNodeScroll = getNodeScroll;
-exports.getOppositeAxis = getOppositeAxis;
-exports.getOppositeAxisPlacements = getOppositeAxisPlacements;
-exports.getOppositePlacement = getOppositePlacement;
-exports.getOverflowAncestors = getOverflowAncestors;
-exports.getPaddingObject = getPaddingObject;
-exports.getParentNode = getParentNode;
-exports.getSide = getSide;
-exports.getSideAxis = getSideAxis;
 exports.getTabbableAfterElement = getTabbableAfterElement;
 exports.getTabbableBeforeElement = getTabbableBeforeElement;
 exports.getTarget = getTarget;
-exports.getWindow = getWindow;
 exports.imperativeAction = imperativeAction;
 exports.incrementPress = incrementPress;
 exports.inertValue = inertValue;
@@ -5859,46 +5397,32 @@ exports.inputClear = inputClear;
 exports.inputPaste = inputPaste;
 exports.inputPress = inputPress;
 exports.ios = ios;
-exports.isContainingBlock = isContainingBlock;
-exports.isElement = isElement;
 exports.isElementVisible = isElementVisible;
-exports.isHTMLElement = isHTMLElement;
 exports.isIndexOutOfListBounds = isIndexOutOfListBounds;
 exports.isInteractiveElement = isInteractiveElement;
-exports.isLastTraversableNode = isLastTraversableNode;
 exports.isListIndexDisabled = isListIndexDisabled;
 exports.isMouseLikePointerType = isMouseLikePointerType;
 exports.isOutsideEvent = isOutsideEvent;
-exports.isOverflowElement = isOverflowElement;
-exports.isTableElement = isTableElement;
 exports.isTargetInsideEnabledTrigger = isTargetInsideEnabledTrigger;
-exports.isTopLayer = isTopLayer;
 exports.isTypeableCombobox = isTypeableCombobox;
 exports.isTypeableElement = isTypeableElement;
 exports.isVirtualClick = isVirtualClick;
 exports.isVirtualPointerEvent = isVirtualPointerEvent;
-exports.isWebKit = isWebKit;
 exports.itemPress = itemPress;
 exports.jsdom = jsdom;
 exports.keyboard = keyboard;
 exports.listNavigation = listNavigation;
 exports.mac = mac;
 exports.matchesFocusVisible = matchesFocusVisible;
-exports.max = max;
 exports.mergeCleanups = mergeCleanups;
-exports.min = min;
 exports.none = none;
 exports.outsidePress = outsidePress;
 exports.ownerDocument = ownerDocument;
 exports.pointer = pointer;
 exports.popupStateMapping = popupStateMapping;
-exports.popupTransitionStateMapping = popupTransitionStateMapping;
 exports.pressableTriggerOpenStateMapping = pressableTriggerOpenStateMapping;
-exports.rectToClientRect = rectToClientRect;
-exports.round = round;
 exports.scrub = scrub;
 exports.setPopupOpenState = setPopupOpenState;
-exports.shimExports = shimExports;
 exports.siblingOpen = siblingOpen;
 exports.stopEvent = stopEvent;
 exports.swipe = swipe;
@@ -5921,15 +5445,17 @@ exports.useFloatingParentNodeId = useFloatingParentNodeId;
 exports.useFloatingTree = useFloatingTree;
 exports.useId = useId;
 exports.useImplicitActiveTrigger = useImplicitActiveTrigger;
+exports.useInitialOpenSync = useInitialOpenSync;
 exports.useIsoLayoutEffect = useIsoLayoutEffect;
+exports.useOnFirstRender = useOnFirstRender;
 exports.useOnMount = useOnMount;
 exports.useOpenChangeComplete = useOpenChangeComplete;
 exports.useOpenInteractionType = useOpenInteractionType;
 exports.useOpenMethodTriggerProps = useOpenMethodTriggerProps;
 exports.useOpenStateTransitions = useOpenStateTransitions;
 exports.usePopupInteractionProps = usePopupInteractionProps;
-exports.usePopupRootStore = usePopupRootStore;
 exports.usePopupRootSync = usePopupRootSync;
+exports.usePopupStore = usePopupStore;
 exports.useScrollLock = useScrollLock;
 exports.useStableCallback = useStableCallback;
 exports.useStore = useStore;
@@ -5942,7 +5468,6 @@ exports.useValueAsRef = useValueAsRef;
 exports.useValueChanged = useValueChanged;
 exports.visuallyHidden = visuallyHidden;
 exports.visuallyHiddenInput = visuallyHiddenInput;
-exports.voiceOver = voiceOver;
 exports.webkit = webkit;
 exports.wheel = wheel;
 exports.windowResize = windowResize;