@jobber/components 9.5.3 → 9.6.0

package/dist/useScrollLock-es.js

@@ -1,7 +1,6 @@
 import * as React from 'react';
 import React__default from 'react';
-import { a as isShadowRoot, i as isHTMLElement, b as isElement, h as getComputedStyle, f as floor, g as getNodeName, c as isNode, K as getWindow, d as isLastTraversableNode, e as getParentNode, I as isOverflowElement } from './floating-ui.utils-es.js';
-import { a as useRefWithInit, f as formatErrorMessage, i as isReactVersionAtLeast, N as NOOP, E as EMPTY_OBJECT, u as useRenderElement, b as useMergedRefs, m as mergeProps, d as makeEventPreventable } from './useRenderElement-es.js';
+import { a as useRefWithInit, i as isReactVersionAtLeast, N as NOOP, c as EMPTY_ARRAY, E as EMPTY_OBJECT, u as useRenderElement, b as useMergedRefs, f as formatErrorMessage, m as mergeProps, d as makeEventPreventable } from './useRenderElement-es.js';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import * as ReactDOM from 'react-dom';
 
@@ -83,14 +82,6 @@ function serializeToDevModeString(input) {
 const noop = () => {};
 const useIsoLayoutEffect = typeof document !== 'undefined' ? React.useLayoutEffect : noop;
 
-function useOnFirstRender(fn) {
-  const ref = React.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`
@@ -189,87 +180,6 @@ 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' : 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 = {};
@@ -677,6 +587,41 @@ 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 = useRefWithInit(createInstance).current;
@@ -699,6 +644,31 @@ 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.forwardRef(fastComponent(fn));
 }
@@ -1114,6 +1084,170 @@ 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.
  */
@@ -1143,15 +1277,13 @@ 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.useEffect(fn, EMPTY$2);
+  React.useEffect(fn, EMPTY_ARRAY);
   /* eslint-enable react-hooks/exhaustive-deps */
 }
 
@@ -1215,7 +1347,7 @@ class Scheduler {
     this.callbacksCount -= 1;
   }
 }
-const scheduler = new Scheduler();
+let scheduler = new Scheduler();
 class AnimationFrame {
   static create() {
     return new AnimationFrame();
@@ -1655,6 +1787,138 @@ const FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref)
 });
 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;
 }
@@ -1950,6 +2214,13 @@ 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) {
@@ -2480,11 +2751,6 @@ function useFloatingPortalNode(props = {}) {
       }
       return;
     }
-
-    // React 17 does not use React.useId().
-    if (uniqueId == null) {
-      return;
-    }
     const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
     if (resolvedContainer == null) {
       if (containerRef.current) {
@@ -2499,7 +2765,7 @@ function useFloatingPortalNode(props = {}) {
       setPortalNode(null);
       setContainerElement(resolvedContainer);
     }
-  }, [containerProp, parentPortalNode, uniqueId]);
+  }, [containerProp, parentPortalNode]);
   const portalElement = useRenderElement('div', componentProps, {
     ref: [ref, setPortalNodeRef],
     props: [{
@@ -2512,8 +2778,11 @@ function useFloatingPortalNode(props = {}) {
   // Another call inside `FloatingPortal`/`FloatingPortalLite` then injects the children into `portalElement`.
   const portalSubtree = containerElement && portalElement ? /*#__PURE__*/ReactDOM.createPortal(portalElement, containerElement) : null;
   return {
-    portalNode,
-    portalSubtree
+    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.isValidElement(portalElement) ? portalElement.props.id : undefined,
+    subtree: portalSubtree
   };
 }
 
@@ -2533,12 +2802,12 @@ const FloatingPortal = /*#__PURE__*/React.forwardRef(function FloatingPortal(com
     style,
     children,
     container,
-    renderGuards,
     ...elementProps
   } = componentProps;
   const {
-    portalNode,
-    portalSubtree
+    node: portalNode,
+    nodeId: portalNodeId,
+    subtree: portalSubtree
   } = useFloatingPortalNode({
     container,
     ref: forwardedRef,
@@ -2553,7 +2822,7 @@ const FloatingPortal = /*#__PURE__*/React.forwardRef(function FloatingPortal(com
   const focusInsideDisabledRef = React.useRef(false);
   const modal = focusManagerState?.modal;
   const open = focusManagerState?.open;
-  const shouldRenderGuards = typeof renderGuards === 'boolean' ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
+  const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
 
   // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx
   React.useEffect(() => {
@@ -2615,7 +2884,7 @@ const FloatingPortal = /*#__PURE__*/React.forwardRef(function FloatingPortal(com
           }
         }
       }), shouldRenderGuards && portalNode && /*#__PURE__*/jsx("span", {
-        "aria-owns": portalNode.id,
+        "aria-owns": portalNodeId,
         style: ownerVisuallyHidden
       }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/jsx(FocusGuard, {
         "data-type": "outside",
@@ -2879,11 +3148,10 @@ function FloatingFocusManager(props) {
   } = store.context;
   const getNodeId = useStableCallback(() => dataRef.current.floatingContext?.nodeId);
   const ignoreInitialFocus = initialFocus === false;
-  // 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.
+  // 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.
   const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
   const initialFocusRef = useValueAsRef(initialFocus);
   const returnFocusRef = useValueAsRef(returnFocus);
@@ -2997,12 +3265,12 @@ 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)) || 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)));
+        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)));
         if (currentTarget === domReference && floatingFocusElement) {
           handleTabIndex(floatingFocusElement);
         }
 
-        // Restore focus to the previous tabbable element index to prevent
+        // Restore focus to the previously focused tabbable element 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
@@ -3012,10 +3280,10 @@ function FloatingFocusManager(props) {
             // If explicitly requested to restore focus to the popup container, do not search
             // for the next/previous tabbable element.
             if (restoreFocus === 'popup') {
-              // 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.
+              // 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.
               restoreFocusFrame.request(() => {
                 floatingFocusElement.focus();
               });
@@ -3097,6 +3365,8 @@ function FloatingFocusManager(props) {
     if (!open || disabled || !isHTMLElement(floatingFocusElement)) {
       return;
     }
+    closeTypeRef.current = '';
+    lastInteractionTypeRef.current = '';
     const doc = ownerDocument(floatingFocusElement);
     const previouslyFocusedElement = activeElement(doc);
 
@@ -3128,7 +3398,9 @@ function FloatingFocusManager(props) {
       }
       elToFocus = elToFocus || getDefaultFocusElement();
       const hadFocusInside = contains(floatingFocusElement, activeElement(doc));
-      enqueueFocus(elToFocus, {
+
+      // enqueueFocus returns a rAF-cancel function; we intentionally don't cancel this focus.
+      void enqueueFocus(elToFocus, {
         preventScroll: elToFocus === floatingFocusElement,
         shouldFocus() {
           // This focus is queued on the next animation frame. If the floating element has closed
@@ -3155,13 +3427,11 @@ function FloatingFocusManager(props) {
     }
     const doc = ownerDocument(floatingFocusElement);
     const elementFocusedBeforeOpen = activeElement(doc);
-    // Only nullish interaction types represent programmatic opens. The empty
-    // string default is intentionally not treated as programmatic.
+    // 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.
     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);
@@ -3177,6 +3447,11 @@ 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() {
@@ -3192,9 +3467,9 @@ function FloatingFocusManager(props) {
       }
     }
     events.on('openchange', onOpenChangeLocal);
-    function getReturnElement() {
+    function getReturnElement(closeType) {
       const returnFocusValueOrFn = returnFocusRef.current;
-      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
+      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeType) : returnFocusValueOrFn;
 
       // `null` should fallback to default behavior in case of an empty ref.
       if (resolvedReturnFocusValue === undefined || resolvedReturnFocusValue === false) {
@@ -3222,9 +3497,11 @@ function FloatingFocusManager(props) {
 
       // eslint-disable-next-line react-hooks/exhaustive-deps
       const returnFocusValueOrFn = returnFocusRef.current;
-      const returnElement = getReturnElement();
+      const closeType = closeTypeRef.current;
+      const returnElement = getReturnElement(closeType);
       queueMicrotask(() => {
-        // This is `returnElement`, if it's tabbable, or its first tabbable child.
+        // `returnElement` if it is tabbable, otherwise its first tabbable child,
+        // otherwise `returnElement` itself (which may not be tabbable at all).
         const tabbableReturnElement = getFirstTabbableElement(returnElement);
         const hasExplicitReturnFocus = typeof returnFocusValueOrFn !== 'boolean';
         if (returnFocusValueOrFn && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (
@@ -3232,9 +3509,13 @@ function FloatingFocusManager(props) {
         // 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({
+          const focusOptions = {
             preventScroll: true
-          });
+          };
+          if (closeType === 'keyboard') {
+            focusOptions.focusVisible = true;
+          }
+          tabbableReturnElement.focus(focusOptions);
         }
         preventReturnFocusRef.current = false;
       });
@@ -3257,8 +3538,8 @@ function FloatingFocusManager(props) {
     }
   }, [open, floating]);
 
-  // Synchronize the `context` & `modal` value to the FloatingPortal context.
-  // It will decide whether or not it needs to render its own guards.
+  // Synchronize the focus manager state (modal, closeOnFocusOut, open, etc.) to the
+  // FloatingPortal context, which uses it to decide whether to render its own guards.
   useIsoLayoutEffect(() => {
     if (disabled || !portalContext) {
       return undefined;
@@ -3293,7 +3574,8 @@ function FloatingFocusManager(props) {
       onFocus: event => {
         if (modal) {
           const els = getTabbableContent();
-          enqueueFocus(els[els.length - 1]);
+          // enqueueFocus returns a rAF-cancel function we don't need here.
+          void enqueueFocus(els[els.length - 1]);
         } else if (portalContext?.portalNode) {
           preventReturnFocusRef.current = false;
           if (isOutsideEvent(event, portalContext.portalNode)) {
@@ -3309,7 +3591,8 @@ function FloatingFocusManager(props) {
       ref: mergedAfterGuardRef,
       onFocus: event => {
         if (modal) {
-          enqueueFocus(getTabbableContent()[0]);
+          // enqueueFocus returns a rAF-cancel function we don't need here.
+          void enqueueFocus(getTabbableContent()[0]);
         } else if (portalContext?.portalNode) {
           if (closeOnFocusOut) {
             preventReturnFocusRef.current = true;
@@ -3381,7 +3664,11 @@ function useClick(context, props = {}) {
     }
     return {
       onPointerDown(event) {
-        pointerTypeRef.current = event.pointerType;
+        // 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;
       },
       onMouseDown(event) {
         const pointerType = pointerTypeRef.current;
@@ -3561,7 +3848,7 @@ function useDismiss(context, props = {}) {
   });
   React.useEffect(() => {
     if (!open || !enabled) {
-      return undefined;
+      return clearInsideReactTree;
     }
     dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
     dataRef.current.__outsidePressBubbles = outsidePressBubbles;
@@ -3839,9 +4126,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.useEffect(clearInsideReactTree, [outsidePress$1, clearInsideReactTree]);
   const reference = React.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
     onPointerDown: closeOnReferencePress,
@@ -3875,12 +4162,12 @@ function useDismiss(context, props = {}) {
 }
 
 const selectors = {
-  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)
+  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
 };
 class FloatingRootStore extends ReactStore {
   constructor(options) {
@@ -4069,44 +4356,14 @@ 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, treatAbortedAsFinished = true) {
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false) {
   const frame = useAnimationFrame();
   return useStableCallback((fnToExecute,
   /**
@@ -4135,23 +4392,22 @@ function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false
         if (!signal?.aborted) {
           done();
         }
-      }).catch(() => {
-        if (treatAbortedAsFinished) {
-          if (!signal?.aborted) {
-            done();
-          }
+      }, () => {
+        if (signal?.aborted) {
           return;
         }
         const currentAnimations = resolvedElement.getAnimations();
-        if (!signal?.aborted && currentAnimations.length > 0 && currentAnimations.some(animation => animation.pending || animation.playState !== 'finished')) {
+        if (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 = TransitionStatusDataAttributes.startingStyle;
+      const startingStyleAttribute = 'data-starting-style';
 
       // If `[data-starting-style]` isn't present, fall back to waiting one more frame
       // to give "open" animations a chance to be registered.
@@ -4191,7 +4447,7 @@ function useOpenChangeComplete(parameters) {
     onComplete: onCompleteParam
   } = parameters;
   const onComplete = useStableCallback(onCompleteParam);
-  const runOnceAnimationsFinish = useAnimationsFinished(ref, open, false);
+  const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
   React.useEffect(() => {
     if (!enabled) {
       return undefined;
@@ -4217,14 +4473,26 @@ const FOCUSABLE_POPUP_PROPS = {
 function createDefaultInitialFocus(popupRef) {
   return interactionType => interactionType === 'touch' ? popupRef.current : true;
 }
-function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement = false) {
+
+/**
+ * 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) {
   const floatingId = useId();
   const nested = useFloatingParentNodeId() != null;
-  const internalStoreRef = React.useRef(null);
-  if (externalStore === undefined && internalStoreRef.current === null) {
-    internalStoreRef.current = createStore(floatingId, nested);
-  }
-  const store = externalStore ?? internalStoreRef.current;
+  const store = useRefWithInit(() => createStore(floatingId, nested)).current;
   useSyncedFloatingRootContext({
     popupStore: store,
     treatPopupAsFloatingElement,
@@ -4233,10 +4501,27 @@ function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement =
     nested,
     onOpenChange: store.setOpen
   });
-  return {
-    store,
-    internalStore: internalStoreRef.current
-  };
+  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;
 }
 
 /**
@@ -4301,19 +4586,6 @@ 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.
@@ -4326,11 +4598,11 @@ function useInitialOpenSync(store, openProp, defaultOpen, defaultTriggerId) {
 function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates) {
   const isMountedByThisTrigger = store.useState('isMountedByTrigger', triggerId);
   const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
-  const registerTrigger = useStableCallback(element => {
-    baseRegisterTrigger(element);
-    if (!element) {
-      return;
-    }
+
+  // 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 open = store.select('open');
     const activeTriggerId = store.select('activeTriggerId');
     if (activeTriggerId === triggerId) {
@@ -4351,6 +4623,18 @@ 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.useCallback(element => {
+    baseRegisterTrigger(element);
+    if (element) {
+      applyTriggerData(element);
+    }
+  }, [baseRegisterTrigger, applyTriggerData]);
   useIsoLayoutEffect(() => {
     if (isMountedByThisTrigger) {
       store.update({
@@ -4370,12 +4654,17 @@ 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 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 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.
  *
- * 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.
+ * 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.
  *
  * This should be called on the Root part.
  *
@@ -4386,10 +4675,22 @@ 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.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);
       }
@@ -4400,22 +4701,42 @@ function useImplicitActiveTrigger(store, options = {}) {
     if (store.state.triggerCount !== triggerCount) {
       stateUpdates.triggerCount = triggerCount;
     }
-    const activeTriggerId = store.select('activeTriggerId');
+    const currentActiveTriggerId = store.select('activeTriggerId');
     let lostActiveTriggerId = null;
-    if (activeTriggerId) {
-      const activeTriggerElement = store.context.triggerElements.getById(activeTriggerId);
+    if (currentActiveTriggerId) {
+      const activeTriggerElement = store.context.triggerElements.getById(currentActiveTriggerId);
       if (!activeTriggerElement) {
-        lostActiveTriggerId = activeTriggerId;
-      } else if (activeTriggerElement !== store.state.activeTriggerElement) {
-        stateUpdates.activeTriggerElement = 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;
+        }
       }
+    } else {
+      resolvedActiveTriggerIdRef.current = null;
     }
-    if (!lostActiveTriggerId && !activeTriggerId && triggerCount === 1) {
+    if (!lostActiveTriggerId && !currentActiveTriggerId && 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) {
@@ -4440,7 +4761,7 @@ function useImplicitActiveTrigger(store, options = {}) {
         });
       }
     }
-  }, [open, store, reactiveTriggerCount, closeOnActiveTriggerUnmount]);
+  }, [open, store, reactiveTriggerCount, activeTriggerId, reactiveActiveTriggerElement, closeOnActiveTriggerUnmount]);
 }
 
 /**
@@ -4518,13 +4839,33 @@ 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.
- * Uses both a set of Elements and a map of IDs to Elements for efficient lookups.
+ *
+ * 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.
  */
 class PopupTriggerMap {
   constructor() {
-    this.elementsSet = new Set();
     this.idMap = new Map();
   }
 
@@ -4534,49 +4875,56 @@ 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') {
-      if (this.elementsSet.size !== this.idMap.size) {
+      const elementIds = getDevElementIds(this);
+      const existingId = elementIds.get(element);
+      if (existingId !== undefined && existingId !== id) {
         // 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) {
-    const element = this.idMap.get(id);
-    if (element) {
-      this.elementsSet.delete(element);
-      this.idMap.delete(id);
+    if (process.env.NODE_ENV !== 'production') {
+      const element = this.idMap.get(id);
+      if (element !== undefined) {
+        devElementIdsByMap?.get(this)?.delete(element);
+      }
     }
+    this.idMap.delete(id);
   }
 
   /**
    * Whether the given element is registered as a trigger.
    */
   hasElement(element) {
-    return this.elementsSet.has(element);
+    for (const registered of this.idMap.values()) {
+      if (registered === element) {
+        return true;
+      }
+    }
+    return false;
   }
 
   /**
    * Whether there is a registered trigger element matching the given predicate.
    */
   hasMatchingElement(predicate) {
-    for (const element of this.elementsSet) {
+    for (const element of this.idMap.values()) {
       if (predicate(element)) {
         return true;
       }
@@ -4602,7 +4950,7 @@ class PopupTriggerMap {
    * Returns an iterable of all registered trigger elements.
    */
   elements() {
-    return this.elementsSet.values();
+    return this.idMap.values();
   }
 
   /**
@@ -4662,14 +5010,11 @@ function useValueChanged(value, onChange) {
   const valueRef = React.useRef(value);
   const onChangeCallback = useStableCallback(onChange);
   useIsoLayoutEffect(() => {
-    if (valueRef.current === value) {
-      return;
+    if (valueRef.current !== value) {
+      onChangeCallback(valueRef.current);
     }
-    onChangeCallback(valueRef.current);
-  }, [value, onChangeCallback]);
-  useIsoLayoutEffect(() => {
     valueRef.current = value;
-  }, [value]);
+  }, [value, onChangeCallback]);
 }
 
 function useOpenMethodTriggerProps(open, setOpenMethod) {
@@ -4712,9 +5057,6 @@ function useOpenInteractionType(open) {
   }), [openMethod, triggerProps]);
 }
 
-/**
- * @internal
- */
 const DirectionContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
 function useDirection() {
@@ -4773,6 +5115,30 @@ 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,
@@ -4873,24 +5239,34 @@ function useButton(parameters = {}) {
             return;
           }
           event.preventDefault();
-          if (isLink || isNativeButton && isButton) {
-            currentTarget.click();
-            event.preventBaseUIHandler();
-          } else if (shouldClick) {
-            externalOnClick?.(event);
+
+          // Only a native-mode item that isn't a real <button> is excluded.
+          if (!isNativeButton || isButton) {
             event.preventBaseUIHandler();
+            dispatchClickWithModifiers(currentTarget, event);
           }
           return;
         }
 
         // Keyboard accessibility for native and non-native elements.
-        if (shouldClick) {
-          if (!isNativeButton && (isSpaceKey || isEnterKey)) {
+        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) {
             event.preventDefault();
           }
-          if (!isNativeButton && isEnterKey) {
-            externalOnClick?.(event);
-          }
+          return;
+        }
+
+        // Match native buttons: preventing the keydown's default cancels activation.
+        if (event.defaultPrevented) {
+          return;
+        }
+        event.preventDefault();
+        if (isEnterKey) {
+          event.preventBaseUIHandler();
+          dispatchClickWithModifiers(currentTarget, event);
         }
       },
       onKeyUp(event) {
@@ -4910,9 +5286,14 @@ function useButton(parameters = {}) {
           return;
         }
 
-        // Keyboard accessibility for non interactive elements
-        if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && event.key === ' ') {
-          externalOnClick?.(event);
+        // 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);
         }
       },
       onPointerDown(event) {
@@ -4941,9 +5322,38 @@ function isButtonElement(elem) {
   return isHTMLElement(elem) && elem.tagName === 'BUTTON';
 }
 function isValidLinkElement(elem) {
-  return Boolean(elem?.tagName === 'A' && elem?.href);
+  return isHTMLElement(elem) && elem.tagName === 'A' && Boolean(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.
@@ -4954,7 +5364,7 @@ let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
    */
   CommonPopupDataAttributes["closed"] = "data-closed";
   /**
-   * Present when the popup is animating in.
+   * Present when the popup begins animating in.
    */
   CommonPopupDataAttributes[CommonPopupDataAttributes["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
   /**
@@ -4977,32 +5387,24 @@ let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
   CommonPopupDataAttributes["align"] = "data-align";
   return CommonPopupDataAttributes;
 }({});
-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;
-}({});
+
+// 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.
 const TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: ''
+  'data-popup-open': ''
 };
 const PRESSABLE_TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: '',
-  [CommonTriggerDataAttributes.pressed]: ''
+  'data-popup-open': '',
+  'data-pressed': ''
 };
 const POPUP_OPEN_HOOK = {
-  [CommonPopupDataAttributes.open]: ''
+  'data-open': ''
 };
 const POPUP_CLOSED_HOOK = {
-  [CommonPopupDataAttributes.closed]: ''
+  'data-closed': ''
 };
 const ANCHOR_HIDDEN_HOOK = {
-  [CommonPopupDataAttributes.anchorHidden]: ''
+  'data-anchor-hidden': ''
 };
 const triggerOpenStateMapping = {
   open(value) {
@@ -5034,6 +5436,10 @@ const popupStateMapping = {
     return null;
   }
 };
+const popupTransitionStateMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
 
 function inertValue(value) {
   if (isReactVersionAtLeast(19)) {
@@ -5075,6 +5481,15 @@ 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;
@@ -5091,7 +5506,7 @@ function supportsStableScrollbarGutter(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const scrollContainer = isOverflowElement(html) ? html : body;
+  const scrollContainer = getViewportScroller(html, body);
   const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
   const originalHtmlStyleGutter = html.style.scrollbarGutter;
   html.style.scrollbarGutter = 'stable';
@@ -5112,7 +5527,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 = isOverflowElement(html) ? html : body;
+  const elementToLock = getViewportScroller(html, body);
   const originalElementToLockStyles = {
     overflowY: elementToLock.style.overflowY,
     overflowX: elementToLock.style.overflowX
@@ -5177,7 +5592,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 = isOverflowElement(html) ? html : body;
+    const elementToLock = getViewportScroller(html, body);
     updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
 
     /*
@@ -5207,7 +5622,9 @@ function preventScrollInsetScrollbars(referenceElement) {
       height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',
       width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',
       boxSizing: 'border-box',
-      overflow: 'hidden',
+      // Assign the longhands that `cleanup` restores, so nothing is left behind.
+      overflowY: 'hidden',
+      overflowX: 'hidden',
       scrollBehavior: 'unset'
     });
     body.scrollTop = scrollTop;
@@ -5272,11 +5689,30 @@ class ScrollLocker {
     }
     const doc = ownerDocument(referenceElement);
     const html = doc.documentElement;
-    const htmlOverflowY = getWindow(html).getComputedStyle(html).overflowY;
+    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);
+      });
 
-    // If the site author already hid overflow on <html>, respect it and bail out.
-    if (htmlOverflowY === 'hidden' || htmlOverflowY === 'clip') {
-      this.restore = NOOP;
+      // 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();
       return;
     }
     const hasOverlayScrollbars = ios || !hasInsetScrollbars(referenceElement);
@@ -5307,4 +5743,4 @@ function useScrollLock(enabled = true, referenceElement = null) {
   }, [enabled, referenceElement]);
 }
 
-export { cancelOpen as $, inputBlur as A, inputPaste as B, CommonPopupDataAttributes as C, activeElement as D, createGenericEventDetails as E, FOCUSABLE_POPUP_PROPS as F, wheel as G, useOnMount as H, incrementPress as I, decrementPress as J, useValueChanged as K, stopEvent as L, keyboard as M, createSelector as N, useOpenInteractionType as O, useStore as P, useClick as Q, useDismiss as R, SafeReact as S, Timeout as T, useOnFirstRender as U, Store as V, focusOut as W, outsidePress as X, pressableTriggerOpenStateMapping as Y, getFloatingFocusElement as Z, contains as _, useIsoLayoutEffect as a, getTabbableBeforeElement as a$, FloatingPortal as a0, InternalBackdrop as a1, inertValue as a2, DROPDOWN_COLLISION_AVOIDANCE as a3, useDirection as a4, useAnimationFrame as a5, webkit as a6, windowResize as a7, isVirtualClick as a8, itemPress as a9, isTargetInsideEnabledTrigger as aA, triggerFocus as aB, createAttribute as aC, mac as aD, triggerPress as aE, escapeKey as aF, isInteractiveElement as aG, getNodeChildren as aH, triggerHover as aI, useAnimationsFinished as aJ, POPUP_COLLISION_AVOIDANCE as aK, FloatingNode as aL, siblingOpen as aM, ReactStore as aN, FloatingTreeStore as aO, fastComponent as aP, useInitialOpenSync as aQ, useFloatingNodeId as aR, useImplicitActiveTrigger as aS, useOpenStateTransitions as aT, attachPreventUnmountOnClose as aU, setPopupOpenState as aV, useSyncedFloatingRootContext as aW, TYPEAHEAD_RESET_MS as aX, usePopupInteractionProps as aY, FloatingTree as aZ, useCompositeRootContext as a_, useId as aa, useFloatingParentNodeId as ab, FloatingRootStore as ac, PopupTriggerMap as ad, useFloatingTree as ae, isTypeableCombobox as af, isIndexOutOfListBounds as ag, getMinListIndex as ah, getMaxListIndex as ai, listNavigation as aj, findNonDisabledListIndex as ak, enqueueFocus as al, isVirtualPointerEvent as am, ARROW_UP as an, ARROW_DOWN as ao, ARROW_LEFT as ap, ARROW_RIGHT as aq, isListIndexDisabled as ar, isElementVisible as as, jsdom as at, DISABLED_TRANSITIONS_STYLE as au, useScrollLock as av, isMouseLikePointerType as aw, mergeCleanups as ax, isTypeableElement as ay, matchesFocusVisible as az, useStableCallback as b, isOutsideEvent as b0, getTabbableAfterElement as b1, getNextTabbable as b2, fastComponentRef as b3, useTriggerDataForwarding as b4, FocusGuard as b5, PATIENT_CLICK_THRESHOLD as b6, useTriggerRegistration as b7, triggerOpenStateMapping as b8, usePopupRootSync as b9, usePopupStore as ba, useOpenMethodTriggerProps as bb, CLICK_TRIGGER_IDENTIFIER as bc, android as bd, closeWatcher as be, BASE_UI_SWIPE_IGNORE_SELECTOR as bf, TransitionStatusDataAttributes as bg, swipe as bh, getGridNavigatedIndex as bi, inputPress as bj, gecko as bk, clearPress as bl, chipRemovePress as bm, pointer as bn, scrub as bo, useButton as c, createChangeEventDetails as d, closePress as e, useOpenChangeComplete as f, getTarget as g, createDefaultInitialFocus as h, FloatingFocusManager as i, imperativeAction as j, useTimeout as k, error as l, useTransitionStatus as m, useControlled as n, ownerDocument as o, popupStateMapping as p, useValueAsRef as q, ios as r, addEventListener as s, transitionStatusMapping as t, useBaseUiId as u, none as v, visuallyHiddenInput as w, visuallyHidden as x, inputChange as y, inputClear as z };
+export { getFloatingFocusElement as $, AnimationFrame as A, visuallyHiddenInput as B, visuallyHidden as C, activeElement as D, wheel as E, FOCUSABLE_POPUP_PROPS as F, createGenericEventDetails as G, useOnMount as H, getWindow as I, incrementPress as J, decrementPress as K, useValueChanged as L, inputClear as M, inputBlur as N, inputChange as O, keyboard as P, inputPaste as Q, useOpenInteractionType as R, SafeReact as S, Timeout as T, useStore as U, useClick as V, useDismiss as W, ReactStore as X, focusOut as Y, outsidePress as Z, pressableTriggerOpenStateMapping as _, isLastTraversableNode as a, isListIndexDisabled as a$, contains as a0, cancelOpen as a1, FloatingPortal as a2, InternalBackdrop as a3, inertValue as a4, DROPDOWN_COLLISION_AVOIDANCE as a5, popupStateMapping as a6, useDirection as a7, useAnimationFrame as a8, webkit as a9, getNodeScroll as aA, isTableElement as aB, isContainingBlock as aC, getContainingBlock as aD, getOverflowAncestors as aE, getFrameElement as aF, isWebKit as aG, floor as aH, useId as aI, useFloatingParentNodeId as aJ, FloatingRootStore as aK, PopupTriggerMap as aL, useFloatingTree as aM, isTypeableCombobox as aN, isIndexOutOfListBounds as aO, getMinListIndex as aP, getMaxListIndex as aQ, stopEvent as aR, listNavigation as aS, findNonDisabledListIndex as aT, enqueueFocus as aU, isVirtualPointerEvent as aV, ARROW_UP as aW, ARROW_DOWN as aX, ARROW_LEFT as aY, ARROW_RIGHT as aZ, isElementVisible as a_, rectToClientRect as aa, windowResize as ab, isVirtualClick as ac, itemPress as ad, evaluate as ae, getSide as af, getSideAxis as ag, getOppositePlacement as ah, getExpandedPlacements as ai, getOppositeAxisPlacements as aj, getAlignmentSides as ak, getAlignment as al, min as am, max as an, getAlignmentAxis as ao, getPaddingObject as ap, getOppositeAxis as aq, clamp as ar, getAxisLength as as, getDocumentElement as at, isElement as au, createCoords as av, round as aw, isTopLayer as ax, getNodeName as ay, isOverflowElement as az, getParentNode as b, scrub as b$, jsdom as b0, DISABLED_TRANSITIONS_STYLE as b1, useScrollLock as b2, shimExports as b3, usePopupInteractionProps as b4, setPopupOpenState as b5, usePopupRootStore as b6, usePopupRootSync as b7, useImplicitActiveTrigger as b8, useOpenStateTransitions as b9, POPUP_COLLISION_AVOIDANCE as bA, FloatingNode as bB, siblingOpen as bC, FloatingTreeStore as bD, fastComponent as bE, useFloatingNodeId as bF, attachPreventUnmountOnClose as bG, useSyncedFloatingRootContext as bH, TYPEAHEAD_RESET_MS as bI, FloatingTree as bJ, useCompositeRootContext as bK, getTabbableBeforeElement as bL, isOutsideEvent as bM, getTabbableAfterElement as bN, getNextTabbable as bO, fastComponentRef as bP, FocusGuard as bQ, PATIENT_CLICK_THRESHOLD as bR, useTriggerRegistration as bS, voiceOver as bT, getGridNavigatedIndex as bU, Store as bV, inputPress as bW, pointer as bX, gecko as bY, clearPress as bZ, chipRemovePress as b_, PopupHandleAttachment as ba, useTriggerDataForwarding as bb, useOpenMethodTriggerProps as bc, CLICK_TRIGGER_IDENTIFIER as bd, triggerOpenStateMapping as be, CommonPopupDataAttributes as bf, android as bg, closeWatcher as bh, TransitionStatusDataAttributes as bi, swipe as bj, BASE_UI_SWIPE_IGNORE_SELECTOR as bk, isMouseLikePointerType as bl, mergeCleanups as bm, isTypeableElement as bn, matchesFocusVisible as bo, isTargetInsideEnabledTrigger as bp, triggerFocus as bq, createAttribute as br, mac as bs, triggerPress as bt, escapeKey as bu, isInteractiveElement as bv, getNodeChildren as bw, triggerHover as bx, dispatchClickWithModifiers as by, useAnimationsFinished as bz, useIsoLayoutEffect as c, useStableCallback as d, getTarget as e, useButton as f, getComputedStyle as g, createChangeEventDetails as h, isHTMLElement as i, closePress as j, imperativeAction as k, useOpenChangeComplete as l, createDefaultInitialFocus as m, FloatingFocusManager as n, ownerDocument as o, popupTransitionStateMapping as p, useTimeout as q, error as r, useTransitionStatus as s, transitionStatusMapping as t, useBaseUiId as u, useControlled as v, useValueAsRef as w, ios as x, addEventListener as y, none as z };