@jobber/components 8.23.0 → 8.23.1

package/dist/{InternalBackdrop-cjs.js → useScrollLock-cjs.js}

@@ -1,11 +1,11 @@
 'use strict';
 
 var React = require('react');
-var index_esm = require('./index.esm-cjs.js');
 var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
-var useRenderElement = require('./useRenderElement-cjs.js');
 var useButton = require('./useButton-cjs.js');
+var useRenderElement = require('./useRenderElement-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
+var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var ReactDOM = require('react-dom');
 
 function _interopNamespaceDefault(e) {
@@ -36,449 +36,24 @@ function useOnFirstRender(fn) {
   }
 }
 
-// src/devModeChecks/identityFunctionCheck.ts
-var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
-  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
-    let isInputSameAsOutput = false;
-    try {
-      const emptyObject = {};
-      if (resultFunc(emptyObject) === emptyObject)
-        isInputSameAsOutput = true;
-    } catch {
-    }
-    if (isInputSameAsOutput) {
-      let stack = void 0;
-      try {
-        throw new Error();
-      } catch (e) {
-        ({ stack } = e);
-      }
-      console.warn(
-        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
-        { stack }
-      );
-    }
-  }
-};
-
-// src/devModeChecks/inputStabilityCheck.ts
-var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
-  const { memoize, memoizeOptions } = options;
-  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
-  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);
-  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
-  if (!areInputSelectorResultsEqual) {
-    let stack = void 0;
-    try {
-      throw new Error();
-    } catch (e) {
-      ({ stack } = e);
-    }
-    console.warn(
-      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
-      {
-        arguments: inputSelectorArgs,
-        firstInputs: inputSelectorResults,
-        secondInputs: inputSelectorResultsCopy,
-        stack
-      }
-    );
-  }
-};
-
-// src/devModeChecks/setGlobalDevModeChecks.ts
-var globalDevModeChecks = {
-  inputStabilityCheck: "once",
-  identityFunctionCheck: "once"
-};
-
-// src/utils.ts
-var NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
-function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
-  if (typeof func !== "function") {
-    throw new TypeError(errorMessage);
-  }
-}
-function assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {
-  if (typeof object !== "object") {
-    throw new TypeError(errorMessage);
-  }
-}
-function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
-  if (!array.every((item) => typeof item === "function")) {
-    const itemTypes = array.map(
-      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
-    ).join(", ");
-    throw new TypeError(`${errorMessage}[${itemTypes}]`);
-  }
-}
-var ensureIsArray = (item) => {
-  return Array.isArray(item) ? item : [item];
-};
-function getDependencies(createSelectorArgs) {
-  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
-  assertIsArrayOfFunctions(
-    dependencies,
-    `createSelector expects all input-selectors to be functions, but received the following types: `
-  );
-  return dependencies;
-}
-function collectInputSelectorResults(dependencies, inputSelectorArgs) {
-  const inputSelectorResults = [];
-  const { length } = dependencies;
-  for (let i = 0; i < length; i++) {
-    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
-  }
-  return inputSelectorResults;
-}
-var getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {
-  const { identityFunctionCheck, inputStabilityCheck } = {
-    ...globalDevModeChecks,
-    ...devModeChecks
-  };
-  return {
-    identityFunctionCheck: {
-      shouldRun: identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun,
-      run: runIdentityFunctionCheck
-    },
-    inputStabilityCheck: {
-      shouldRun: inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun,
-      run: runInputStabilityCheck
-    }
-  };
-};
-
-// src/lruMemoize.ts
-function createSingletonCache(equals) {
-  let entry;
-  return {
-    get(key) {
-      if (entry && equals(entry.key, key)) {
-        return entry.value;
-      }
-      return NOT_FOUND;
-    },
-    put(key, value) {
-      entry = { key, value };
-    },
-    getEntries() {
-      return entry ? [entry] : [];
-    },
-    clear() {
-      entry = void 0;
-    }
-  };
-}
-function createLruCache(maxSize, equals) {
-  let entries = [];
-  function get(key) {
-    const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));
-    if (cacheIndex > -1) {
-      const entry = entries[cacheIndex];
-      if (cacheIndex > 0) {
-        entries.splice(cacheIndex, 1);
-        entries.unshift(entry);
-      }
-      return entry.value;
-    }
-    return NOT_FOUND;
-  }
-  function put(key, value) {
-    if (get(key) === NOT_FOUND) {
-      entries.unshift({ key, value });
-      if (entries.length > maxSize) {
-        entries.pop();
-      }
-    }
-  }
-  function getEntries() {
-    return entries;
-  }
-  function clear() {
-    entries = [];
-  }
-  return { get, put, getEntries, clear };
-}
-var referenceEqualityCheck = (a, b) => a === b;
-function createCacheKeyComparator(equalityCheck) {
-  return function areArgumentsShallowlyEqual(prev, next) {
-    if (prev === null || next === null || prev.length !== next.length) {
-      return false;
-    }
-    const { length } = prev;
-    for (let i = 0; i < length; i++) {
-      if (!equalityCheck(prev[i], next[i])) {
-        return false;
-      }
-    }
-    return true;
-  };
-}
-function lruMemoize(func, equalityCheckOrOptions) {
-  const providedOptions = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };
-  const {
-    equalityCheck = referenceEqualityCheck,
-    maxSize = 1,
-    resultEqualityCheck
-  } = providedOptions;
-  const comparator = createCacheKeyComparator(equalityCheck);
-  let resultsCount = 0;
-  const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);
-  function memoized() {
-    let value = cache.get(arguments);
-    if (value === NOT_FOUND) {
-      value = func.apply(null, arguments);
-      resultsCount++;
-      if (resultEqualityCheck) {
-        const entries = cache.getEntries();
-        const matchingEntry = entries.find(
-          (entry) => resultEqualityCheck(entry.value, value)
-        );
-        if (matchingEntry) {
-          value = matchingEntry.value;
-          resultsCount !== 0 && resultsCount--;
-        }
-      }
-      cache.put(arguments, value);
-    }
-    return value;
-  }
-  memoized.clearCache = () => {
-    cache.clear();
-    memoized.resetResultsCount();
-  };
-  memoized.resultsCount = () => resultsCount;
-  memoized.resetResultsCount = () => {
-    resultsCount = 0;
-  };
-  return memoized;
-}
-
-// src/weakMapMemoize.ts
-var StrongRef = class {
-  constructor(value) {
-    this.value = value;
-  }
-  deref() {
-    return this.value;
-  }
-};
-var Ref = typeof WeakRef !== "undefined" ? WeakRef : StrongRef;
-var UNTERMINATED = 0;
-var TERMINATED = 1;
-function createCacheNode() {
-  return {
-    s: UNTERMINATED,
-    v: void 0,
-    o: null,
-    p: null
-  };
-}
-function weakMapMemoize(func, options = {}) {
-  let fnNode = createCacheNode();
-  const { resultEqualityCheck } = options;
-  let lastResult;
-  let resultsCount = 0;
-  function memoized() {
-    let cacheNode = fnNode;
-    const { length } = arguments;
-    for (let i = 0, l = length; i < l; i++) {
-      const arg = arguments[i];
-      if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
-        let objectCache = cacheNode.o;
-        if (objectCache === null) {
-          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();
-        }
-        const objectNode = objectCache.get(arg);
-        if (objectNode === void 0) {
-          cacheNode = createCacheNode();
-          objectCache.set(arg, cacheNode);
-        } else {
-          cacheNode = objectNode;
-        }
-      } else {
-        let primitiveCache = cacheNode.p;
-        if (primitiveCache === null) {
-          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();
-        }
-        const primitiveNode = primitiveCache.get(arg);
-        if (primitiveNode === void 0) {
-          cacheNode = createCacheNode();
-          primitiveCache.set(arg, cacheNode);
-        } else {
-          cacheNode = primitiveNode;
-        }
-      }
-    }
-    const terminatedNode = cacheNode;
-    let result;
-    if (cacheNode.s === TERMINATED) {
-      result = cacheNode.v;
-    } else {
-      result = func.apply(null, arguments);
-      resultsCount++;
-      if (resultEqualityCheck) {
-        const lastResultValue = lastResult?.deref?.() ?? lastResult;
-        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
-          result = lastResultValue;
-          resultsCount !== 0 && resultsCount--;
-        }
-        const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
-        lastResult = needsWeakRef ? new Ref(result) : result;
-      }
-    }
-    terminatedNode.s = TERMINATED;
-    terminatedNode.v = result;
-    return result;
-  }
-  memoized.clearCache = () => {
-    fnNode = createCacheNode();
-    memoized.resetResultsCount();
-  };
-  memoized.resultsCount = () => resultsCount;
-  memoized.resetResultsCount = () => {
-    resultsCount = 0;
-  };
-  return memoized;
-}
-
-// src/createSelectorCreator.ts
-function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
-  const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
-    memoize: memoizeOrOptions,
-    memoizeOptions: memoizeOptionsFromArgs
-  } : memoizeOrOptions;
-  const createSelector2 = (...createSelectorArgs) => {
-    let recomputations = 0;
-    let dependencyRecomputations = 0;
-    let lastResult;
-    let directlyPassedOptions = {};
-    let resultFunc = createSelectorArgs.pop();
-    if (typeof resultFunc === "object") {
-      directlyPassedOptions = resultFunc;
-      resultFunc = createSelectorArgs.pop();
-    }
-    assertIsFunction(
-      resultFunc,
-      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`
-    );
-    const combinedOptions = {
-      ...createSelectorCreatorOptions,
-      ...directlyPassedOptions
-    };
-    const {
-      memoize,
-      memoizeOptions = [],
-      argsMemoize = weakMapMemoize,
-      argsMemoizeOptions = [],
-      devModeChecks = {}
-    } = combinedOptions;
-    const finalMemoizeOptions = ensureIsArray(memoizeOptions);
-    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);
-    const dependencies = getDependencies(createSelectorArgs);
-    const memoizedResultFunc = memoize(function recomputationWrapper() {
-      recomputations++;
-      return resultFunc.apply(
-        null,
-        arguments
-      );
-    }, ...finalMemoizeOptions);
-    let firstRun = true;
-    const selector = argsMemoize(function dependenciesChecker() {
-      dependencyRecomputations++;
-      const inputSelectorResults = collectInputSelectorResults(
-        dependencies,
-        arguments
-      );
-      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
-      if (process.env.NODE_ENV !== "production") {
-        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);
-        if (identityFunctionCheck.shouldRun) {
-          identityFunctionCheck.run(
-            resultFunc,
-            inputSelectorResults,
-            lastResult
-          );
-        }
-        if (inputStabilityCheck.shouldRun) {
-          const inputSelectorResultsCopy = collectInputSelectorResults(
-            dependencies,
-            arguments
-          );
-          inputStabilityCheck.run(
-            { inputSelectorResults, inputSelectorResultsCopy },
-            { memoize, memoizeOptions: finalMemoizeOptions },
-            arguments
-          );
-        }
-        if (firstRun)
-          firstRun = false;
-      }
-      return lastResult;
-    }, ...finalArgsMemoizeOptions);
-    return Object.assign(selector, {
-      resultFunc,
-      memoizedResultFunc,
-      dependencies,
-      dependencyRecomputations: () => dependencyRecomputations,
-      resetDependencyRecomputations: () => {
-        dependencyRecomputations = 0;
-      },
-      lastResult: () => lastResult,
-      recomputations: () => recomputations,
-      resetRecomputations: () => {
-        recomputations = 0;
-      },
-      memoize,
-      argsMemoize
-    });
-  };
-  Object.assign(createSelector2, {
-    withTypes: () => createSelector2
-  });
-  return createSelector2;
-}
-var createSelector$1 = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);
-
-// src/createStructuredSelector.ts
-var createStructuredSelector = Object.assign(
-  (inputSelectorsObject, selectorCreator = createSelector$1) => {
-    assertIsObject(
-      inputSelectorsObject,
-      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`
-    );
-    const inputSelectorKeys = Object.keys(inputSelectorsObject);
-    const dependencies = inputSelectorKeys.map(
-      (key) => inputSelectorsObject[key]
-    );
-    const structuredSelector = selectorCreator(
-      dependencies,
-      (...inputSelectorResults) => {
-        return inputSelectorResults.reduce((composition, value, index) => {
-          composition[inputSelectorKeys[index]] = value;
-          return composition;
-        }, {});
-      }
-    );
-    return structuredSelector;
-  },
-  { withTypes: () => createStructuredSelector }
-);
-
-/* eslint-disable no-underscore-dangle */ // __cacheKey__
+/**
+ * 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.
+ */
 
-createSelectorCreator({
-  memoize: lruMemoize,
-  memoizeOptions: {
-    maxSize: 1,
-    equalityCheck: Object.is
-  }
-});
 /**
  * Creates a selector function that can be used to derive values from the store's state.
- * The selector can take up to three additional arguments that can be used in the selector logic.
+ *
+ * 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 last parameter is the combiner function that combines the results of the previous selectors.
+ * 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(
@@ -491,7 +66,6 @@ createSelectorCreator({
  *   (state) => state.open,
  *   (disabled, open) => ({ disabled, open })
  * );
- *
  */
 /* eslint-disable id-denylist */
 const createSelector = (a, b, c, d, e, f, ...other) => {
@@ -541,6 +115,7 @@ const createSelector = (a, b, c, d, e, f, ...other) => {
   }
   return selector;
 };
+/* eslint-enable id-denylist */
 
 var shim = {exports: {}};
 
@@ -1003,10 +578,9 @@ register({
         for (let i = 0; i < instance.syncHooks.length; i += 1) {
           const hook = instance.syncHooks[i];
           const value = hook.selector(hook.store.state, hook.a1, hook.a2, hook.a3);
-          if (hook.didChange || !Object.is(hook.value, value)) {
+          if (!Object.is(hook.value, value)) {
             didChange = true;
             hook.value = value;
-            hook.didChange = false;
           }
         }
         if (didChange) {
@@ -1057,8 +631,7 @@ function useStoreFast(store, selector, a1, a2, a3) {
       a1,
       a2,
       a3,
-      value: selector(store.getSnapshot(), a1, a2, a3),
-      didChange: false
+      value: selector(store.getSnapshot(), a1, a2, a3)
     };
     instance.syncHooks.push(hook);
   } else {
@@ -1072,7 +645,7 @@ function useStoreFast(store, selector, a1, a2, a3) {
       hook.a1 = a1;
       hook.a2 = a2;
       hook.a3 = a3;
-      hook.didChange = true;
+      hook.value = selector(store.getSnapshot(), a1, a2, a3);
     }
   }
   return hook.value;
@@ -1224,11 +797,13 @@ class ReactStore extends Store {
    */
   useSyncedValue(key, value) {
     React__namespace.useDebugValue(key);
+    // eslint-disable-next-line consistent-this
+    const store = this;
     useButton.useIsoLayoutEffect(() => {
-      if (this.state[key] !== value) {
-        this.set(key, value);
+      if (store.state[key] !== value) {
+        store.set(key, value);
       }
-    }, [key, value]);
+    }, [store, key, value]);
   }
 
   /**
@@ -1282,16 +857,18 @@ class ReactStore extends Store {
    */
   useControlledProp(key, controlled) {
     React__namespace.useDebugValue(key);
+    // eslint-disable-next-line consistent-this
+    const store = this;
     const isControlled = controlled !== undefined;
     useButton.useIsoLayoutEffect(() => {
-      if (isControlled && !Object.is(this.state[key], controlled)) {
+      if (isControlled && !Object.is(store.state[key], controlled)) {
         // Set the internal state to match the controlled value.
-        super.setState({
-          ...this.state,
+        store.setState({
+          ...store.state,
           [key]: controlled
         });
       }
-    }, [key, controlled, isControlled]);
+    }, [store, key, controlled, isControlled]);
     if (process.env.NODE_ENV !== 'production') {
       // eslint-disable-next-line
       const cache = this.controlledValues ??= new Map();
@@ -1384,44 +961,169 @@ class ReactStore extends Store {
   }
 }
 
-/* eslint-disable @typescript-eslint/no-loop-func */
-
-function getNodeChildren(nodes, id, onlyOpenChildren = true) {
-  const directChildren = nodes.filter(node => node.parentId === id && (!onlyOpenChildren || node.context?.open));
-  return directChildren.flatMap(child => [child, ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+/**
+ * Combines multiple cleanup functions into a single cleanup function.
+ */
+function mergeCleanups(...cleanups) {
+  return () => {
+    for (let i = 0; i < cleanups.length; i += 1) {
+      const cleanup = cleanups[i];
+      if (cleanup) {
+        cleanup();
+      }
+    }
+  };
 }
-function getNodeAncestors(nodes, id) {
-  let allAncestors = [];
-  let currentParentId = nodes.find(node => node.id === id)?.parentId;
-  while (currentParentId) {
-    const currentNode = nodes.find(node => node.id === currentParentId);
-    currentParentId = currentNode?.parentId;
-    if (currentNode) {
-      allAncestors = allAncestors.concat(currentNode);
+
+// WebKit (Safari, all iOS browsers, GNOME Web). Distinguished from Blink by
+// the legacy `-webkit-backdrop-filter` name — Blink forked from WebKit in 2013
+// and only ships the unprefixed `backdrop-filter`.
+/** WebKit: Safari, all iOS browsers, GNOME Web. Excludes Blink. */
+const webkit = typeof CSS !== 'undefined' && !!CSS.supports?.('-webkit-backdrop-filter:none');
+
+// Anchored to `!webkit` so engines are mutually exclusive by construction.
+// Firefox-on-iOS uses WebKit (its UA marker is `FxiOS/`, not `Firefox/`); the
+// `!webkit` prefix also defends against future iOS-browser UA changes that
+// might inject `Firefox` into a WebKit-based UA.
+/** Gecko: Firefox. */
+const gecko = !webkit && useButton.lowerUserAgent.includes('firefox');
+
+// All Chromium-based browsers ship `Chrome/` or `Chromium/` in their UA — both
+// share the `chrom` prefix, so a single substring check covers Chrome, Edge,
+// Opera, Brave, etc. Chrome-on-iOS uses `CriOS/` and stays WebKit. The positive
+// UA check also makes this SSR-safe — an empty UA matches nothing.
+/** Blink: Chrome, Edge, Opera, Brave, and other Chromium-based browsers. */
+!webkit && useButton.lowerUserAgent.includes('chrom');
+
+// Whether a screen reader is *actually* running cannot be detected. These flags
+// identify platforms where a specific screen reader could be active. VoiceOver
+// is the system screen reader on Apple platforms and works with every browser
+// there, so the flag is purely an OS check; engine-specific quirks (e.g. the
+// NSAccessibility virtual-cursor focus path) should be gated at the call site.
+/**
+ * The user *may* be using VoiceOver — actual activation is not detectable.
+ * True on any Apple platform (macOS, iOS, iPadOS).
+ */
+const voiceOver = useButton.apple;
+
+const FOCUSABLE_ATTRIBUTE = 'data-base-ui-focusable';
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled])," + "[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+const ARROW_LEFT = 'ArrowLeft';
+const ARROW_RIGHT = 'ArrowRight';
+const ARROW_UP = 'ArrowUp';
+const ARROW_DOWN = 'ArrowDown';
+
+function isTargetInsideEnabledTrigger(target, triggerElements) {
+  if (!floatingUi_utils_dom.isElement(target)) {
+    return false;
+  }
+  const targetElement = target;
+  if (triggerElements.hasElement(targetElement)) {
+    return !targetElement.hasAttribute('data-trigger-disabled');
+  }
+  for (const [, trigger] of triggerElements.entries()) {
+    if (useButton.contains(trigger, targetElement)) {
+      return !trigger.hasAttribute('data-trigger-disabled');
     }
   }
-  return allAncestors;
+  return false;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null) {
+    return false;
+  }
+  if ('composedPath' in event) {
+    return event.composedPath().includes(node);
+  }
+
+  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't
+  const eventAgain = event;
+  return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+  return element.matches('html,body');
+}
+function isTypeableElement(element) {
+  return floatingUi_utils_dom.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;
 }
+function isTypeableCombobox(element) {
+  if (!element) {
+    return false;
+  }
+  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);
+}
+function matchesFocusVisible(element) {
+  // We don't want to block focus from working with `visibleOnly`
+  // (JSDOM doesn't match `:focus-visible` when the element has `:focus`)
+  if (!element || useButton.jsdom) {
+    return true;
+  }
+  try {
+    return element.matches(':focus-visible');
+  } catch (_e) {
+    return true;
+  }
+}
+function getFloatingFocusElement(floatingElement) {
+  if (!floatingElement) {
+    return null;
+  }
+  // Try to find the element that has `{...getFloatingProps()}` spread on it.
+  // This indicates the floating element is acting as a positioning wrapper, and
+  // so focus should be managed on the child element with the event handlers and
+  // aria props.
+  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`) || floatingElement;
+}
+
+const FocusGuard = /*#__PURE__*/React__namespace.forwardRef(function FocusGuard(props, ref) {
+  const [role, setRole] = React__namespace.useState();
+  useButton.useIsoLayoutEffect(() => {
+    // Unlike NVDA and JAWS, VoiceOver's virtual cursor triggers `onFocus` as
+    // it moves — but only on focusable/role-button elements through WebKit's
+    // NSAccessibility path. Setting `role="button"` lets the focus trap catch
+    // the cursor.
+    if (voiceOver && webkit) {
+      setRole('button');
+    }
+  }, []);
+  const restProps = {
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role
+  };
+  return /*#__PURE__*/jsxRuntime.jsx("span", {
+    ...props,
+    ref: ref,
+    style: useButton.visuallyHidden,
+    "aria-hidden": role ? undefined : true,
+    ...restProps,
+    "data-base-ui-focus-guard": ""
+  });
+});
+if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
 
 function isDifferentGridRow(index, cols, prevRow) {
   return Math.floor(index / cols) !== prevRow;
 }
-function isIndexOutOfListBounds(listRef, index) {
-  return index < 0 || index >= listRef.current.length;
+function isIndexOutOfListBounds(list, index) {
+  return index < 0 || index >= list.length;
 }
 function getMinListIndex(listRef, disabledIndices) {
-  return findNonDisabledListIndex(listRef, {
+  return findNonDisabledListIndex(listRef.current, {
     disabledIndices
   });
 }
 function getMaxListIndex(listRef, disabledIndices) {
-  return findNonDisabledListIndex(listRef, {
+  return findNonDisabledListIndex(listRef.current, {
     decrement: true,
     startingIndex: listRef.current.length,
     disabledIndices
   });
 }
-function findNonDisabledListIndex(listRef, {
+function findNonDisabledListIndex(list, {
   startingIndex = -1,
   decrement = false,
   disabledIndices,
@@ -1430,13 +1132,14 @@ function findNonDisabledListIndex(listRef, {
   let index = startingIndex;
   do {
     index += decrement ? -amount : amount;
-  } while (index >= 0 && index <= listRef.current.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));
+  } while (index >= 0 && index <= list.length - 1 && isListIndexDisabled(list, index, disabledIndices));
   return index;
 }
-function getGridNavigatedIndex(listRef, {
+function getGridNavigatedIndex(list, {
   event,
   orientation,
   loopFocus,
+  onLoop,
   rtl,
   cols,
   disabledIndices,
@@ -1447,9 +1150,9 @@ function getGridNavigatedIndex(listRef, {
 }) {
   let nextIndex = prevIndex;
   let verticalDirection;
-  if (event.key === useButton.ARROW_UP) {
+  if (event.key === ARROW_UP) {
     verticalDirection = 'up';
-  } else if (event.key === useButton.ARROW_DOWN) {
+  } else if (event.key === ARROW_DOWN) {
     verticalDirection = 'down';
   }
   if (verticalDirection) {
@@ -1464,7 +1167,7 @@ function getGridNavigatedIndex(listRef, {
     {
       let currentRowEl = null;
       let currentRowIndex = -1;
-      listRef.current.forEach((el, idx) => {
+      list.forEach((el, idx) => {
         if (el == null) {
           return;
         }
@@ -1495,7 +1198,7 @@ function getGridNavigatedIndex(listRef, {
         }
       }
     }
-    const hasVirtualizedGaps = hasDomRows && visibleItemCount < listRef.current.length;
+    const hasVirtualizedGaps = hasDomRows && visibleItemCount < list.length;
     const verticalCols = inferredDomCols || cols;
     const navigateVertically = direction => {
       if (!hasDomRows || prevIndex === -1) {
@@ -1513,11 +1216,17 @@ function getGridNavigatedIndex(listRef, {
             return undefined;
           }
           nextRow = nextRow < 0 ? rows.length - 1 : 0;
+          if (onLoop) {
+            const clampedCol = Math.min(colInRow, rows[nextRow].length - 1);
+            const targetItemIndex = rows[nextRow][clampedCol] ?? rows[nextRow][0];
+            const returnedItemIndex = onLoop(event, prevIndex, targetItemIndex);
+            nextRow = rowIndexMap[returnedItemIndex] ?? nextRow;
+          }
         }
         const targetRow = rows[nextRow];
         for (let col = Math.min(colInRow, targetRow.length - 1); col >= 0; col -= 1) {
           const candidate = targetRow[col];
-          if (!isListIndexDisabled(listRef, candidate, disabledIndices)) {
+          if (!isListIndexDisabled(list, candidate, disabledIndices)) {
             return candidate;
           }
         }
@@ -1531,7 +1240,7 @@ function getGridNavigatedIndex(listRef, {
       const colInRow = prevIndex % verticalCols;
       const rowStep = direction === 'up' ? -verticalCols : verticalCols;
       const lastRowStart = maxIndex - maxIndex % verticalCols;
-      const rowCount = index_esm.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) {
@@ -1541,7 +1250,7 @@ function getGridNavigatedIndex(listRef, {
         }
         const rowEnd = Math.min(rowStart + verticalCols - 1, maxIndex);
         for (let candidate = Math.min(rowStart + colInRow, rowEnd); candidate >= rowStart; candidate -= 1) {
-          if (!isListIndexDisabled(listRef, candidate, disabledIndices)) {
+          if (!isListIndexDisabled(list, candidate, disabledIndices)) {
             return candidate;
           }
         }
@@ -1557,7 +1266,7 @@ function getGridNavigatedIndex(listRef, {
     } else if (prevIndex === -1) {
       nextIndex = verticalDirection === 'up' ? maxIndex : minIndex;
     } else {
-      nextIndex = findNonDisabledListIndex(listRef, {
+      nextIndex = findNonDisabledListIndex(list, {
         startingIndex: prevIndex,
         amount: verticalCols,
         decrement: verticalDirection === 'up',
@@ -1573,84 +1282,105 @@ function getGridNavigatedIndex(listRef, {
           } else {
             nextIndex = maxCol > col ? offset : offset - verticalCols;
           }
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
         if (verticalDirection === 'down' && prevIndex + verticalCols > maxIndex) {
-          nextIndex = findNonDisabledListIndex(listRef, {
+          nextIndex = findNonDisabledListIndex(list, {
             startingIndex: prevIndex % verticalCols - verticalCols,
             amount: verticalCols,
             disabledIndices
           });
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
       }
     }
-    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+    if (isIndexOutOfListBounds(list, nextIndex)) {
       nextIndex = prevIndex;
     }
   }
 
   // Remains on the same row/column.
   if (orientation === 'both') {
-    const prevRow = index_esm.floor(prevIndex / cols);
-    if (event.key === (rtl ? useButton.ARROW_LEFT : useButton.ARROW_RIGHT)) {
+    const prevRow = floatingUi_utils.floor(prevIndex / cols);
+    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
       if (stop) {
         useButton.stopEvent(event);
       }
       if (prevIndex % cols !== cols - 1) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex,
           disabledIndices
         });
         if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
-          nextIndex = findNonDisabledListIndex(listRef, {
+          nextIndex = findNonDisabledListIndex(list, {
             startingIndex: prevIndex - prevIndex % cols - 1,
             disabledIndices
           });
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
       } else if (loopFocus) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex - prevIndex % cols - 1,
           disabledIndices
         });
+        if (onLoop) {
+          nextIndex = onLoop(event, prevIndex, nextIndex);
+        }
       }
       if (isDifferentGridRow(nextIndex, cols, prevRow)) {
         nextIndex = prevIndex;
       }
     }
-    if (event.key === (rtl ? useButton.ARROW_RIGHT : useButton.ARROW_LEFT)) {
+    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {
       if (stop) {
         useButton.stopEvent(event);
       }
       if (prevIndex % cols !== 0) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex,
           decrement: true,
           disabledIndices
         });
         if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
-          nextIndex = findNonDisabledListIndex(listRef, {
+          nextIndex = findNonDisabledListIndex(list, {
             startingIndex: prevIndex + (cols - prevIndex % cols),
             decrement: true,
             disabledIndices
           });
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
       } else if (loopFocus) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex + (cols - prevIndex % cols),
           decrement: true,
           disabledIndices
         });
+        if (onLoop) {
+          nextIndex = onLoop(event, prevIndex, nextIndex);
+        }
       }
       if (isDifferentGridRow(nextIndex, cols, prevRow)) {
         nextIndex = prevIndex;
       }
     }
-    const lastRow = index_esm.floor(maxIndex / cols) === prevRow;
-    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+    const lastRow = floatingUi_utils.floor(maxIndex / cols) === prevRow;
+    if (isIndexOutOfListBounds(list, nextIndex)) {
       if (loopFocus && lastRow) {
-        nextIndex = event.key === (rtl ? useButton.ARROW_RIGHT : useButton.ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {
+        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(list, {
           startingIndex: prevIndex - prevIndex % cols - 1,
           disabledIndices
         });
+        if (onLoop) {
+          nextIndex = onLoop(event, prevIndex, nextIndex);
+        }
       } else {
         nextIndex = prevIndex;
       }
@@ -1658,80 +1388,12 @@ function getGridNavigatedIndex(listRef, {
   }
   return nextIndex;
 }
-
-/** For each cell index, gets the item index that occupies that cell */
-function createGridCellMap(sizes, cols, dense) {
-  const cellMap = [];
-  let startIndex = 0;
-  sizes.forEach(({
-    width,
-    height
-  }, index) => {
-    if (width > cols) {
-      if (process.env.NODE_ENV !== 'production') {
-        throw new Error(`[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns`);
-      }
-    }
-    let itemPlaced = false;
-    while (!itemPlaced) {
-      const targetCells = [];
-      for (let i = 0; i < width; i += 1) {
-        for (let j = 0; j < height; j += 1) {
-          targetCells.push(startIndex + i + j * cols);
-        }
-      }
-      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {
-        targetCells.forEach(cell => {
-          cellMap[cell] = index;
-        });
-        itemPlaced = true;
-      } else {
-        startIndex += 1;
-      }
-    }
-  });
-
-  // convert into a non-sparse array
-  return [...cellMap];
-}
-
-/** Gets cell index of an item's corner or -1 when index is -1. */
-function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
-  if (index === -1) {
-    return -1;
-  }
-  const firstCellIndex = cellMap.indexOf(index);
-  const sizeItem = sizes[index];
-  switch (corner) {
-    case 'tl':
-      return firstCellIndex;
-    case 'tr':
-      if (!sizeItem) {
-        return firstCellIndex;
-      }
-      return firstCellIndex + sizeItem.width - 1;
-    case 'bl':
-      if (!sizeItem) {
-        return firstCellIndex;
-      }
-      return firstCellIndex + (sizeItem.height - 1) * cols;
-    case 'br':
-      return cellMap.lastIndexOf(index);
-    default:
-      return -1;
-  }
-}
-
-/** Gets all cell indices that correspond to the specified indices */
-function getGridCellIndices(indices, cellMap) {
-  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);
-}
-function isListIndexDisabled(listRef, index, disabledIndices) {
+function isListIndexDisabled(list, index, disabledIndices) {
   const isExplicitlyDisabled = typeof disabledIndices === 'function' ? disabledIndices(index) : disabledIndices?.includes(index) ?? false;
   if (isExplicitlyDisabled) {
     return true;
   }
-  const element = listRef.current[index];
+  const element = list[index];
   if (!element) {
     return false;
   }
@@ -1740,44 +1402,172 @@ function isListIndexDisabled(listRef, index, disabledIndices) {
   }
   return !disabledIndices && (element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true');
 }
-function isElementVisible(element) {
-  return floatingUi_utils_dom.getComputedStyle(element).display !== 'none';
+function isHiddenByStyles(styles) {
+  return styles.visibility === 'hidden' || styles.visibility === 'collapse';
+}
+function isElementVisible(element, styles = element ? floatingUi_utils_dom.getComputedStyle(element) : null) {
+  if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
+    return false;
+  }
+  if (typeof element.checkVisibility === 'function') {
+    return element.checkVisibility();
+  }
+  return styles.display !== 'none' && styles.display !== 'contents';
 }
 
-const getTabbableOptions = () => ({
-  getShadowRoot: true,
-  displayCheck:
-  // JSDOM does not support the `tabbable` library. To solve this we can
-  // check if `ResizeObserver` is a real function (not polyfilled), which
-  // determines if the current environment is JSDOM-like.
-  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'
-});
-function getTabbableIn(container, dir) {
-  const list = index_esm.tabbable(container, getTabbableOptions());
-  const len = list.length;
-  if (len === 0) {
-    return undefined;
+const CANDIDATE_SELECTOR = 'a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable="false"]),audio[controls],video[controls]';
+function getParentElement(element) {
+  const assignedSlot = element.assignedSlot;
+  if (assignedSlot) {
+    return assignedSlot;
   }
-  const active = useButton.activeElement(useButton.ownerDocument(container));
-  const index = list.indexOf(active);
-  // eslint-disable-next-line no-nested-ternary
-  const nextIndex = index === -1 ? dir === 1 ? 0 : len - 1 : index + dir;
-  return list[nextIndex];
+  if (element.parentElement) {
+    return element.parentElement;
+  }
+  const rootNode = element.getRootNode();
+  return floatingUi_utils_dom.isShadowRoot(rootNode) ? rootNode.host : null;
 }
-function getNextTabbable(referenceElement) {
-  return getTabbableIn(useButton.ownerDocument(referenceElement).body, 1) || referenceElement;
+function getDetailsSummary(details) {
+  for (const child of Array.from(details.children)) {
+    if (floatingUi_utils_dom.getNodeName(child) === 'summary') {
+      return child;
+    }
+  }
+  return null;
 }
-function getPreviousTabbable(referenceElement) {
-  return getTabbableIn(useButton.ownerDocument(referenceElement).body, -1) || referenceElement;
+function isWithinOpenDetailsSummary(element, details) {
+  const summary = getDetailsSummary(details);
+  return !!summary && (element === summary || useButton.contains(summary, element));
 }
-function getTabbableNearElement(referenceElement, dir) {
-  if (!referenceElement) {
-    return null;
-  }
-  const list = index_esm.tabbable(useButton.ownerDocument(referenceElement).body, getTabbableOptions());
-  const elementCount = list.length;
-  if (elementCount === 0) {
-    return null;
+function isFocusableCandidate(element) {
+  const nodeName = element ? floatingUi_utils_dom.getNodeName(element) : '';
+  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== 'summary' || element.parentElement != null && floatingUi_utils_dom.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')) {
+    return false;
+  }
+  for (let current = element; current; current = getParentElement(current)) {
+    const isAncestor = current !== element;
+    const isSlot = floatingUi_utils_dom.getNodeName(current) === 'slot';
+    if (current.hasAttribute('inert')) {
+      return false;
+    }
+    if (isAncestor && floatingUi_utils_dom.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 = floatingUi_utils_dom.getComputedStyle(element);
+  if (!isAncestor) {
+    return isElementVisible(element, styles);
+  }
+  return styles.display !== 'none';
+}
+function getTabIndex(element) {
+  const tabIndex = element.tabIndex;
+  if (tabIndex < 0) {
+    const nodeName = floatingUi_utils_dom.getNodeName(element);
+    if (nodeName === 'details' || nodeName === 'audio' || nodeName === 'video' || floatingUi_utils_dom.isHTMLElement(element) && element.isContentEditable) {
+      return 0;
+    }
+  }
+  return tabIndex;
+}
+function getNamedRadioInput(element) {
+  if (floatingUi_utils_dom.getNodeName(element) !== 'input') {
+    return null;
+  }
+  const input = element;
+  return input.type === 'radio' && input.name !== '' ? input : null;
+}
+function isTabbableRadio(element, candidates) {
+  const input = getNamedRadioInput(element);
+  if (!input) {
+    return true;
+  }
+  const checkedRadio = candidates.find(candidate => {
+    const radio = getNamedRadioInput(candidate);
+    return radio?.name === input.name && radio.form === input.form && radio.checked;
+  });
+  if (checkedRadio) {
+    return checkedRadio === input;
+  }
+  return candidates.find(candidate => {
+    const radio = getNamedRadioInput(candidate);
+    return radio?.name === input.name && radio.form === input.form;
+  }) === input;
+}
+function getComposedChildren(container) {
+  if (floatingUi_utils_dom.isHTMLElement(container) && floatingUi_utils_dom.getNodeName(container) === 'slot') {
+    const assignedElements = container.assignedElements({
+      flatten: true
+    });
+    if (assignedElements.length > 0) {
+      return assignedElements;
+    }
+  }
+  if (floatingUi_utils_dom.isHTMLElement(container) && container.shadowRoot) {
+    return Array.from(container.shadowRoot.children);
+  }
+  return Array.from(container.children);
+}
+function appendCandidates(container, list) {
+  getComposedChildren(container).forEach(child => {
+    if (isFocusableCandidate(child)) {
+      list.push(child);
+    }
+    appendCandidates(child, list);
+  });
+}
+function appendMatchingElements(container, selector, list) {
+  getComposedChildren(container).forEach(child => {
+    if (floatingUi_utils_dom.isHTMLElement(child) && child.matches(selector)) {
+      list.push(child);
+    }
+    appendMatchingElements(child, selector, list);
+  });
+}
+function isTabbable(element) {
+  return isFocusableElement(element) && getTabIndex(element) >= 0;
+}
+function focusable(container) {
+  const candidates = [];
+  appendCandidates(container, candidates);
+  return candidates.filter(isFocusableElement);
+}
+function tabbable(container) {
+  const candidates = focusable(container);
+  return candidates.filter(element => getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
+}
+function getTabbableIn(container, dir) {
+  const list = tabbable(container);
+  const len = list.length;
+  if (len === 0) {
+    return undefined;
+  }
+  const active = useButton.activeElement(useButton.ownerDocument(container));
+  const index = list.indexOf(active);
+  // eslint-disable-next-line no-nested-ternary
+  const nextIndex = index === -1 ? dir === 1 ? 0 : len - 1 : index + dir;
+  return list[nextIndex];
+}
+function getNextTabbable(referenceElement) {
+  return getTabbableIn(useButton.ownerDocument(referenceElement).body, 1) || referenceElement;
+}
+function getPreviousTabbable(referenceElement) {
+  return getTabbableIn(useButton.ownerDocument(referenceElement).body, -1) || referenceElement;
+}
+function getTabbableNearElement(referenceElement, dir) {
+  if (!referenceElement) {
+    return null;
+  }
+  const list = tabbable(useButton.ownerDocument(referenceElement).body);
+  const elementCount = list.length;
+  if (elementCount === 0) {
+    return null;
   }
   const index = list.indexOf(referenceElement);
   if (index === -1) {
@@ -1798,14 +1588,15 @@ function isOutsideEvent(event, container) {
   return !relatedTarget || !useButton.contains(containerElement, relatedTarget);
 }
 function disableFocusInside(container) {
-  const tabbableElements = index_esm.tabbable(container, getTabbableOptions());
+  const tabbableElements = tabbable(container);
   tabbableElements.forEach(element => {
     element.dataset.tabindex = element.getAttribute('tabindex') || '';
     element.setAttribute('tabindex', '-1');
   });
 }
 function enableFocusInside(container) {
-  const elements = container.querySelectorAll('[data-tabindex]');
+  const elements = [];
+  appendMatchingElements(container, '[data-tabindex]', elements);
   elements.forEach(element => {
     const tabindex = element.dataset.tabindex;
     delete element.dataset.tabindex;
@@ -1817,71 +1608,24 @@ function enableFocusInside(container) {
   });
 }
 
-const TYPEAHEAD_RESET_MS = 500;
-const PATIENT_CLICK_THRESHOLD = 500;
-const DISABLED_TRANSITIONS_STYLE = {
-  style: {
-    transition: 'none'
-  }
-};
-const CLICK_TRIGGER_IDENTIFIER = 'data-base-ui-click-trigger';
-const BASE_UI_SWIPE_IGNORE_ATTRIBUTE = 'data-base-ui-swipe-ignore';
-const BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
-
-/**
- * Used for dropdowns that usually strictly prefer top/bottom placements and
- * use `var(--available-height)` to limit their height.
- */
-const DROPDOWN_COLLISION_AVOIDANCE = {
-  fallbackAxisSide: 'none'
-};
-
-/**
- * Used by regular popups that usually aren't scrollable and are allowed to
- * freely flip to any axis of placement.
- */
-const POPUP_COLLISION_AVOIDANCE = {
-  fallbackAxisSide: 'end'
-};
-
-/**
- * Special visually hidden styles for the aria-owns owner element to ensure owned element
- * accessibility in iOS/Safari/VoiceControl.
- * The owner element is an empty span, so most of the common visually hidden styles are not needed.
- * @see https://github.com/floating-ui/floating-ui/issues/3403
- */
-const ownerVisuallyHidden = {
-  clipPath: 'inset(50%)',
-  position: 'fixed',
-  top: 0,
-  left: 0
-};
+/* eslint-disable @typescript-eslint/no-loop-func */
 
-const FocusGuard = /*#__PURE__*/React__namespace.forwardRef(function FocusGuard(props, ref) {
-  const [role, setRole] = React__namespace.useState();
-  useButton.useIsoLayoutEffect(() => {
-    if (useButton.isSafari) {
-      // Unlike other screen readers such as NVDA and JAWS, the virtual cursor
-      // on VoiceOver does trigger the onFocus event, so we can use the focus
-      // trap element. On Safari, only buttons trigger the onFocus event.
-      setRole('button');
+function getNodeChildren(nodes, id, onlyOpenChildren = true) {
+  const directChildren = nodes.filter(node => node.parentId === id);
+  return directChildren.flatMap(child => [...(!onlyOpenChildren || child.context?.open ? [child] : []), ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+}
+function getNodeAncestors(nodes, id) {
+  let allAncestors = [];
+  let currentParentId = nodes.find(node => node.id === id)?.parentId;
+  while (currentParentId) {
+    const currentNode = nodes.find(node => node.id === currentParentId);
+    currentParentId = currentNode?.parentId;
+    if (currentNode) {
+      allAncestors = allAncestors.concat(currentNode);
     }
-  }, []);
-  const restProps = {
-    tabIndex: 0,
-    // Role is only for VoiceOver
-    role
-  };
-  return /*#__PURE__*/jsxRuntime.jsx("span", {
-    ...props,
-    ref: ref,
-    style: useButton.visuallyHidden,
-    "aria-hidden": role ? undefined : true,
-    ...restProps,
-    "data-base-ui-focus-guard": ""
-  });
-});
-if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
+  }
+  return allAncestors;
+}
 
 function createAttribute(name) {
   return `data-base-ui-${name}`;
@@ -1891,20 +1635,30 @@ let rafId = 0;
 function enqueueFocus(el, options = {}) {
   const {
     preventScroll = false,
-    cancelPrevious = true,
-    sync = false
+    sync = false,
+    shouldFocus
   } = options;
-  if (cancelPrevious) {
-    cancelAnimationFrame(rafId);
+  cancelAnimationFrame(rafId);
+  function exec() {
+    if (shouldFocus && !shouldFocus()) {
+      return;
+    }
+    el?.focus({
+      preventScroll
+    });
   }
-  const exec = () => el?.focus({
-    preventScroll
-  });
   if (sync) {
     exec();
-  } else {
-    rafId = requestAnimationFrame(exec);
+    return useRenderElement.NOOP;
   }
+  const currentRafId = requestAnimationFrame(exec);
+  rafId = currentRafId;
+  return () => {
+    if (rafId === currentRafId) {
+      cancelAnimationFrame(currentRafId);
+      rafId = 0;
+    }
+  };
 }
 
 // Modified to add conditional `aria-hidden` support:
@@ -1971,17 +1725,18 @@ const collectOutsideElements = (root, keepElements, stopElements) => {
   return outside;
 };
 function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert, {
-  mark = true,
-  markerIgnoreElements = []
+  mark = true
 }) {
-  // eslint-disable-next-line no-nested-ternary
-  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;
+  let controlAttribute = null;
+  if (inert) {
+    controlAttribute = 'inert';
+  } else if (ariaHidden) {
+    controlAttribute = 'aria-hidden';
+  }
   let counterMap = null;
   let uncontrolledElementsSet = null;
   const avoidElements = correctElements(body, uncorrectedAvoidElements);
-  const markerIgnoreTargets = mark ? correctElements(body, markerIgnoreElements) : [];
-  const markerIgnoreSet = new Set(markerIgnoreTargets);
-  const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)).filter(target => !markerIgnoreSet.has(target)) : [];
+  const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)) : [];
   const hiddenElements = [];
   const markedElements = [];
   if (controlAttribute) {
@@ -2054,16 +1809,54 @@ function markOthers(avoidElements, options = {}) {
   const {
     ariaHidden = false,
     inert = false,
-    mark = true,
-    markerIgnoreElements = []
+    mark = true
   } = options;
   const body = useButton.ownerDocument(avoidElements[0]).body;
   return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, {
-    mark,
-    markerIgnoreElements
+    mark
   });
 }
 
+const TYPEAHEAD_RESET_MS = 500;
+const PATIENT_CLICK_THRESHOLD = 500;
+const DISABLED_TRANSITIONS_STYLE = {
+  style: {
+    transition: 'none'
+  }
+};
+const CLICK_TRIGGER_IDENTIFIER = 'data-base-ui-click-trigger';
+const BASE_UI_SWIPE_IGNORE_ATTRIBUTE = 'data-base-ui-swipe-ignore';
+const BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
+
+/**
+ * Used for dropdowns that usually strictly prefer top/bottom placements and
+ * use `var(--available-height)` to limit their height.
+ */
+const DROPDOWN_COLLISION_AVOIDANCE = {
+  fallbackAxisSide: 'none'
+};
+
+/**
+ * Used by regular popups that usually aren't scrollable and are allowed to
+ * freely flip to any axis of placement.
+ */
+const POPUP_COLLISION_AVOIDANCE = {
+  fallbackAxisSide: 'end'
+};
+
+/**
+ * Special visually hidden styles for the aria-owns owner element to ensure owned element
+ * accessibility in iOS/Safari/VoiceControl.
+ * The owner element is an empty span, so most of the common visually hidden styles are not needed.
+ * @see https://github.com/floating-ui/floating-ui/issues/3403
+ */
+const ownerVisuallyHidden = {
+  clipPath: 'inset(50%)',
+  position: 'fixed',
+  top: 0,
+  left: 0
+};
+
 const PortalContext = /*#__PURE__*/React__namespace.createContext(null);
 if (process.env.NODE_ENV !== "production") PortalContext.displayName = "PortalContext";
 const usePortalContext = () => React__namespace.useContext(PortalContext);
@@ -2147,10 +1940,11 @@ function useFloatingPortalNode(props = {}) {
  */
 const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function FloatingPortal(componentProps, forwardedRef) {
   const {
+    render,
+    className,
+    style,
     children,
     container,
-    className,
-    render,
     renderGuards,
     ...elementProps
   } = componentProps;
@@ -2168,6 +1962,7 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
   const beforeInsideRef = React__namespace.useRef(null);
   const afterInsideRef = React__namespace.useRef(null);
   const [focusManagerState, setFocusManagerState] = React__namespace.useState(null);
+  const focusInsideDisabledRef = React__namespace.useRef(false);
   const modal = focusManagerState?.modal;
   const open = focusManagerState?.open;
   const shouldRenderGuards = typeof renderGuards === 'boolean' ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
@@ -2183,26 +1978,30 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
     // element outside or using the mouse.
     function onFocus(event) {
       if (portalNode && event.relatedTarget && isOutsideEvent(event)) {
-        const focusing = event.type === 'focusin';
-        const manageFocus = focusing ? enableFocusInside : disableFocusInside;
-        manageFocus(portalNode);
+        if (event.type === 'focusin') {
+          if (focusInsideDisabledRef.current) {
+            enableFocusInside(portalNode);
+            focusInsideDisabledRef.current = false;
+          }
+        } else {
+          disableFocusInside(portalNode);
+          focusInsideDisabledRef.current = true;
+        }
       }
     }
 
     // Listen to the event on the capture phase so they run before the focus
     // trap elements onFocus prop is called.
-    portalNode.addEventListener('focusin', onFocus, true);
-    portalNode.addEventListener('focusout', onFocus, true);
-    return () => {
-      portalNode.removeEventListener('focusin', onFocus, true);
-      portalNode.removeEventListener('focusout', onFocus, true);
-    };
+    return mergeCleanups(useButton.addEventListener(portalNode, 'focusin', onFocus, true), useButton.addEventListener(portalNode, 'focusout', onFocus, true));
   }, [portalNode, modal]);
-  React__namespace.useEffect(() => {
-    if (!portalNode || open) {
+  useButton.useIsoLayoutEffect(() => {
+    if (!portalNode || open !== true || !focusInsideDisabledRef.current) {
       return;
     }
+
+    // Restore tabbability before the focus manager's queued focus-on-open step runs.
     enableFocusInside(portalNode);
+    focusInsideDisabledRef.current = false;
   }, [open, portalNode]);
   const portalContextValue = React__namespace.useMemo(() => ({
     beforeOutsideRef,
@@ -2374,7 +2173,7 @@ function FloatingTree(props) {
 }
 
 function getEventType(event, lastInteractionType) {
-  const win = floatingUi_utils_dom.getWindow(event.target);
+  const win = floatingUi_utils_dom.getWindow(useButton.getTarget(event));
   if (event instanceof win.KeyboardEvent) {
     return 'keyboard';
   }
@@ -2419,35 +2218,30 @@ function getFirstTabbableElement(container) {
   if (!container) {
     return null;
   }
-  const tabbableOptions = getTabbableOptions();
-  if (index_esm.isTabbable(container, tabbableOptions)) {
+  if (isTabbable(container)) {
     return container;
   }
-  return index_esm.tabbable(container, tabbableOptions)[0] || container;
+  return tabbable(container)[0] || container;
 }
-function isFocusable(element) {
-  if (!element || !element.isConnected) {
-    return false;
-  }
-  if (typeof element.checkVisibility === 'function') {
-    return element.checkVisibility();
+function handleTabIndex(floatingFocusElement) {
+  if (floatingFocusElement.hasAttribute('tabindex') && !floatingFocusElement.hasAttribute('data-tabindex')) {
+    return;
   }
-  return isElementVisible(element);
-}
-function handleTabIndex(floatingFocusElement, orderRef) {
-  if (!orderRef.current.includes('floating') && !floatingFocusElement.getAttribute('role')?.includes('dialog')) {
+  if (!floatingFocusElement.getAttribute('role')?.includes('dialog')) {
     return;
   }
-  const options = getTabbableOptions();
-  const focusableElements = index_esm.focusable(floatingFocusElement, options);
+  const focusableElements = focusable(floatingFocusElement);
   const tabbableContent = focusableElements.filter(element => {
     const dataTabIndex = element.getAttribute('data-tabindex') || '';
-    return index_esm.isTabbable(element, options) || element.hasAttribute('data-tabindex') && !dataTabIndex.startsWith('-');
+    return isTabbable(element) || element.hasAttribute('data-tabindex') && !dataTabIndex.startsWith('-');
   });
   const tabIndex = floatingFocusElement.getAttribute('tabindex');
-  if (orderRef.current.includes('floating') || tabbableContent.length === 0) {
+  if (tabbableContent.length === 0) {
     if (tabIndex !== '0') {
       floatingFocusElement.setAttribute('tabindex', '0');
+      // Mark our own write so the externally-managed early-return above doesn't
+      // mistake it for a user-authored `tabindex` and freeze management.
+      floatingFocusElement.setAttribute('data-tabindex', '0');
     }
   } else if (tabIndex !== '-1' || floatingFocusElement.hasAttribute('data-tabindex') && floatingFocusElement.getAttribute('data-tabindex') !== '-1') {
     floatingFocusElement.setAttribute('tabindex', '-1');
@@ -2491,17 +2285,17 @@ function FloatingFocusManager(props) {
   // 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 = useButton.isTypeableCombobox(domReference) && ignoreInitialFocus;
-  const orderRef = React__namespace.useRef(['content']);
+  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
   const initialFocusRef = useButton.useValueAsRef(initialFocus);
   const returnFocusRef = useButton.useValueAsRef(returnFocus);
   const openInteractionTypeRef = useButton.useValueAsRef(openInteractionType);
+  const openRef = useButton.useValueAsRef(open);
   const tree = useFloatingTree(externalTree);
   const portalContext = usePortalContext();
   const preventReturnFocusRef = React__namespace.useRef(false);
   const isPointerDownRef = React__namespace.useRef(false);
   const pointerDownOutsideRef = React__namespace.useRef(false);
-  const tabbableIndexRef = React__namespace.useRef(-1);
+  const lastFocusedTabbableRef = React__namespace.useRef(null);
   const closeTypeRef = React__namespace.useRef('');
   const lastInteractionTypeRef = React__namespace.useRef('');
   const beforeGuardRef = React__namespace.useRef(null);
@@ -2512,15 +2306,11 @@ function FloatingFocusManager(props) {
   const pointerDownTimeout = useButton.useTimeout();
   const restoreFocusFrame = useButton.useAnimationFrame();
   const isInsidePortal = portalContext != null;
-  const floatingFocusElement = useButton.getFloatingFocusElement(floating);
+  const floatingFocusElement = getFloatingFocusElement(floating);
   const getTabbableContent = useButton.useStableCallback((container = floatingFocusElement) => {
-    return container ? index_esm.tabbable(container, getTabbableOptions()) : [];
+    return container ? tabbable(container) : [];
   });
   const getResolvedInsideElements = useButton.useStableCallback(() => getInsideElements?.().filter(element => element != null) ?? []);
-  const getTabbableElements = useButton.useStableCallback(container => {
-    const content = getTabbableContent(container);
-    return orderRef.current.map(() => content).filter(Boolean).flat();
-  });
 
   // Prevent Tab from escaping the modal when there are no tabbable elements.
   React__namespace.useEffect(() => {
@@ -2536,11 +2326,8 @@ function FloatingFocusManager(props) {
       }
     }
     const doc = useButton.ownerDocument(floatingFocusElement);
-    doc.addEventListener('keydown', onKeyDown);
-    return () => {
-      doc.removeEventListener('keydown', onKeyDown);
-    };
-  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
+    return useButton.addEventListener(doc, 'keydown', onKeyDown);
+  }, [disabled, floatingFocusElement, modal, isUntrappedTypeableCombobox, getTabbableContent]);
 
   // Track pointer/keyboard interactions to disambiguate focus and outside presses.
   React__namespace.useEffect(() => {
@@ -2559,22 +2346,21 @@ function FloatingFocusManager(props) {
       lastInteractionTypeRef.current = event.pointerType || 'keyboard';
       if (target?.closest(`[${CLICK_TRIGGER_IDENTIFIER}]`)) {
         isPointerDownRef.current = true;
+        // Reset on the next tick so a single click on a click-trigger doesn't
+        // permanently suppress focus-out closing for the lifetime of the instance.
+        pointerDownTimeout.start(0, () => {
+          isPointerDownRef.current = false;
+        });
       }
     }
     function onKeyDown() {
       lastInteractionTypeRef.current = 'keyboard';
     }
-    doc.addEventListener('pointerdown', onPointerDown, true);
-    doc.addEventListener('pointerup', clearPointerDownOutside, true);
-    doc.addEventListener('pointercancel', clearPointerDownOutside, true);
-    doc.addEventListener('keydown', onKeyDown, true);
-    return () => {
-      doc.removeEventListener('pointerdown', onPointerDown, true);
-      doc.removeEventListener('pointerup', clearPointerDownOutside, true);
-      doc.removeEventListener('pointercancel', clearPointerDownOutside, true);
-      doc.removeEventListener('keydown', onKeyDown, true);
-    };
-  }, [disabled, floating, domReference, floatingFocusElement, open, portalContext, getResolvedInsideElements]);
+    return mergeCleanups(useButton.addEventListener(doc, 'pointerdown', onPointerDown, true), useButton.addEventListener(doc, 'pointerup', clearPointerDownOutside, true), useButton.addEventListener(doc, 'pointercancel', clearPointerDownOutside, true), useButton.addEventListener(doc, 'keydown', onKeyDown, true),
+    // Avoid a stale `true` leaking into the next open (e.g. keep-mounted popups)
+    // if the popup dismissed between pointerdown and pointerup.
+    clearPointerDownOutside);
+  }, [disabled, floating, domReference, floatingFocusElement, open, portalContext, pointerDownTimeout, getResolvedInsideElements]);
 
   // Close on focus out and restore focus within the floating tree when needed.
   React__namespace.useEffect(() => {
@@ -2592,29 +2378,34 @@ function FloatingFocusManager(props) {
     }
     function handleFocusIn(event) {
       const target = useButton.getTarget(event);
-      const tabbableContent = getTabbableContent();
-      const tabbableIndex = tabbableContent.indexOf(target);
-      if (tabbableIndex !== -1) {
-        tabbableIndexRef.current = tabbableIndex;
+      if (isTabbable(target)) {
+        lastFocusedTabbableRef.current = target;
       }
     }
     function handleFocusOutside(event) {
       const relatedTarget = event.relatedTarget;
       const currentTarget = event.currentTarget;
       const target = useButton.getTarget(event);
+
+      // When focus is lost to the body (e.g. on a backdrop press), record the element that
+      // had focus so a confirmation dialog opened while the body is focused can return focus
+      // to it. Scoped to `modal` to avoid non-modal popups polluting the shared stack.
+      if (modal && relatedTarget == null && target != null && useButton.contains(floating, target)) {
+        addPreviouslyFocusedElement(target);
+      }
       queueMicrotask(() => {
         const nodeId = getNodeId();
         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, useButton.resolveRef(previousFocusableElement), useButton.resolveRef(nextFocusableElement)].includes(relatedTarget);
-        const movedToUnrelatedNode = !(useButton.contains(domReference, relatedTarget) || useButton.contains(floating, relatedTarget) || useButton.contains(relatedTarget, floating) || useButton.contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || useButton.contains(element, relatedTarget)) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement(trigger => useButton.contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => useButton.contains(node.context?.elements.floating, relatedTarget) || useButton.contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, useButton.getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
+        const movedToUnrelatedNode = !(useButton.contains(domReference, relatedTarget) || useButton.contains(floating, relatedTarget) || useButton.contains(relatedTarget, floating) || useButton.contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || useButton.contains(element, relatedTarget)) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement(trigger => useButton.contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => useButton.contains(node.context?.elements.floating, relatedTarget) || useButton.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, orderRef);
+          handleTabIndex(floatingFocusElement);
         }
 
         // Restore focus to the previous tabbable element index to prevent
         // focus from being lost outside the floating tree.
-        if (restoreFocus && currentTarget !== domReference && !isFocusable(target) && useButton.activeElement(doc) === doc.body) {
+        if (restoreFocus && currentTarget !== domReference && !isElementVisible(target) && useButton.activeElement(doc) === doc.body) {
           // Let `FloatingPortal` effect knows that focus is still inside the
           // floating tree.
           if (floatingUi_utils_dom.isHTMLElement(floatingFocusElement)) {
@@ -2632,9 +2423,9 @@ function FloatingFocusManager(props) {
               return;
             }
           }
-          const prevTabbableIndex = tabbableIndexRef.current;
           const tabbableContent = getTabbableContent();
-          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
+          const prevTabbable = lastFocusedTabbableRef.current;
+          const nodeToFocus = (prevTabbable && tabbableContent.includes(prevTabbable) ? prevTabbable : null) || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
           if (floatingUi_utils_dom.isHTMLElement(nodeToFocus)) {
             nodeToFocus.focus();
           }
@@ -2672,38 +2463,11 @@ function FloatingFocusManager(props) {
       });
     }
     const domReferenceElement = floatingUi_utils_dom.isHTMLElement(domReference) ? domReference : null;
-    const cleanups = [];
     if (!floating && !domReferenceElement) {
       return undefined;
     }
-    if (domReferenceElement) {
-      domReferenceElement.addEventListener('focusout', handleFocusOutside);
-      domReferenceElement.addEventListener('pointerdown', handlePointerDown);
-      cleanups.push(() => {
-        domReferenceElement.removeEventListener('focusout', handleFocusOutside);
-        domReferenceElement.removeEventListener('pointerdown', handlePointerDown);
-      });
-    }
-    if (floating) {
-      floating.addEventListener('focusin', handleFocusIn);
-      floating.addEventListener('focusout', handleFocusOutside);
-      if (portalContext) {
-        floating.addEventListener('focusout', markInsideReactTree, true);
-        cleanups.push(() => {
-          floating.removeEventListener('focusout', markInsideReactTree, true);
-        });
-      }
-      cleanups.push(() => {
-        floating.removeEventListener('focusin', handleFocusIn);
-        floating.removeEventListener('focusout', handleFocusOutside);
-      });
-    }
-    return () => {
-      cleanups.forEach(cleanup => {
-        cleanup();
-      });
-    };
-  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, store, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId, orderRef, dataRef, blurTimeout, pointerDownTimeout, restoreFocusFrame, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
+    return mergeCleanups(domReferenceElement && useButton.addEventListener(domReferenceElement, 'focusout', handleFocusOutside), domReferenceElement && useButton.addEventListener(domReferenceElement, 'pointerdown', handlePointerDown), floating && useButton.addEventListener(floating, 'focusin', handleFocusIn), floating && useButton.addEventListener(floating, 'focusout', handleFocusOutside), floating && portalContext && useButton.addEventListener(floating, 'focusout', markInsideReactTree, true));
+  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, store, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId, dataRef, blurTimeout, pointerDownTimeout, restoreFocusFrame, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
 
   // Hide everything outside the floating tree from assistive tech while open.
   React__namespace.useEffect(() => {
@@ -2714,7 +2478,7 @@ function FloatingFocusManager(props) {
     // Don't hide portals nested within the parent portal.
     const portalNodes = Array.from(portalContext?.portalNode?.querySelectorAll(`[${createAttribute('portal')}]`) || []);
     const ancestors = tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : [];
-    const rootAncestorComboboxDomReference = ancestors.find(node => useButton.isTypeableCombobox(node.context?.elements.domReference || null))?.context?.elements.domReference;
+    const rootAncestorComboboxDomReference = ancestors.find(node => isTypeableCombobox(node.context?.elements.domReference || null))?.context?.elements.domReference;
     const controlInsideElements = [floating, ...portalNodes, beforeGuardRef.current, afterGuardRef.current, portalContext?.beforeOutsideRef.current, portalContext?.afterOutsideRef.current, ...getResolvedInsideElements()];
     const insideElements = [...controlInsideElements, rootAncestorComboboxDomReference, useButton.resolveRef(previousFocusableElement), useButton.resolveRef(nextFocusableElement), isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);
     const ariaHiddenCleanup = markOthers(insideElements, {
@@ -2727,7 +2491,7 @@ function FloatingFocusManager(props) {
       markerCleanup();
       ariaHiddenCleanup();
     };
-  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
+  }, [open, disabled, domReference, floating, modal, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
 
   // Focus the initial element when the floating element opens.
   useButton.useIsoLayoutEffect(() => {
@@ -2739,7 +2503,6 @@ function FloatingFocusManager(props) {
 
     // Wait for any layout effect state setters to execute to set `tabIndex`.
     queueMicrotask(() => {
-      const focusableElements = getTabbableElements(floatingFocusElement);
       const initialFocusValueOrFn = initialFocusRef.current;
       const resolvedInitialFocus = typeof initialFocusValueOrFn === 'function' ? initialFocusValueOrFn(openInteractionTypeRef.current || '') : initialFocusValueOrFn;
 
@@ -2747,22 +2510,44 @@ function FloatingFocusManager(props) {
       if (resolvedInitialFocus === undefined || resolvedInitialFocus === false) {
         return;
       }
+      const focusAlreadyInsideFloatingEl = useButton.contains(floatingFocusElement, previouslyFocusedElement);
+      if (focusAlreadyInsideFloatingEl) {
+        return;
+      }
+      let focusableElements = null;
+      const getDefaultFocusElement = () => {
+        if (focusableElements == null) {
+          focusableElements = getTabbableContent(floatingFocusElement);
+        }
+        return focusableElements[0] || floatingFocusElement;
+      };
       let elToFocus;
       if (resolvedInitialFocus === true || resolvedInitialFocus === null) {
-        elToFocus = focusableElements[0] || floatingFocusElement;
+        elToFocus = getDefaultFocusElement();
       } else {
         elToFocus = useButton.resolveRef(resolvedInitialFocus);
       }
-      elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;
-      const focusAlreadyInsideFloatingEl = useButton.contains(floatingFocusElement, previouslyFocusedElement);
-      if (focusAlreadyInsideFloatingEl) {
-        return;
-      }
+      elToFocus = elToFocus || getDefaultFocusElement();
+      const hadFocusInside = useButton.contains(floatingFocusElement, useButton.activeElement(doc));
       enqueueFocus(elToFocus, {
-        preventScroll: elToFocus === floatingFocusElement
+        preventScroll: elToFocus === floatingFocusElement,
+        shouldFocus() {
+          // This focus is queued on the next animation frame. If the floating element has closed
+          // before it runs — e.g. tabbing out of a kept-mounted popup — don't pull focus back
+          // onto the initial element after it has legitimately moved elsewhere.
+          if (!openRef.current) {
+            return false;
+          }
+          if (hadFocusInside) {
+            return true;
+          }
+          const currentActiveElement = useButton.activeElement(doc);
+          const focusMovedInside = currentActiveElement !== elToFocus && useButton.contains(floatingFocusElement, currentActiveElement);
+          return !focusMovedInside;
+        }
       });
     });
-  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef, openInteractionTypeRef]);
+  }, [disabled, open, floatingFocusElement, getTabbableContent, initialFocusRef, openInteractionTypeRef, openRef]);
 
   // Track return focus targets and restore focus on unmount/close.
   useButton.useIsoLayoutEffect(() => {
@@ -2770,8 +2555,11 @@ function FloatingFocusManager(props) {
       return undefined;
     }
     const doc = useButton.ownerDocument(floatingFocusElement);
-    const previouslyFocusedElement = useButton.activeElement(doc);
-    addPreviouslyFocusedElement(previouslyFocusedElement);
+    const elementFocusedBeforeOpen = useButton.activeElement(doc);
+    // 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.
@@ -2791,7 +2579,7 @@ function FloatingFocusManager(props) {
         preventReturnFocusRef.current = false;
       } else {
         let isPreventScrollSupported = false;
-        document.createElement('div').focus({
+        useButton.ownerDocument(floatingFocusElement).createElement('div').focus({
           get preventScroll() {
             isPreventScrollSupported = true;
             return false;
@@ -2816,26 +2604,31 @@ function FloatingFocusManager(props) {
       if (resolvedReturnFocusValue === null) {
         resolvedReturnFocusValue = true;
       }
+      const referenceReturnElement = domReference?.isConnected ? domReference : null;
+      const previousReturnElement = elementFocusedBeforeOpen?.isConnected && floatingUi_utils_dom.getNodeName(elementFocusedBeforeOpen) !== 'body' ? elementFocusedBeforeOpen : null;
+      let defaultReturnElement = preferPreviousFocus ? previousReturnElement || referenceReturnElement : referenceReturnElement || previousReturnElement;
+      if (!defaultReturnElement) {
+        defaultReturnElement = getPreviouslyFocusedElement() || null;
+      }
       if (typeof resolvedReturnFocusValue === 'boolean') {
-        const el = domReference || getPreviouslyFocusedElement();
-        return el && el.isConnected ? el : null;
+        return defaultReturnElement;
       }
-      const fallback = domReference || getPreviouslyFocusedElement();
-      return useButton.resolveRef(resolvedReturnFocusValue) || fallback || null;
+      return useButton.resolveRef(resolvedReturnFocusValue) || defaultReturnElement || null;
     }
     return () => {
       events.off('openchange', onOpenChangeLocal);
       const activeEl = useButton.activeElement(doc);
       const insideElements = getResolvedInsideElements();
       const isFocusInsideFloatingTree = useButton.contains(floating, activeEl) || insideElements.some(element => element === activeEl || useButton.contains(element, activeEl)) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some(node => useButton.contains(node.context?.elements.floating, activeEl));
+
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      const returnFocusValueOrFn = returnFocusRef.current;
       const returnElement = getReturnElement();
       queueMicrotask(() => {
         // This is `returnElement`, if it's tabbable, or its first tabbable child.
         const tabbableReturnElement = getFirstTabbableElement(returnElement);
-        const hasExplicitReturnFocus = typeof returnFocusRef.current !== 'boolean';
-        if (
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        returnFocusRef.current && !preventReturnFocusRef.current && floatingUi_utils_dom.isHTMLElement(tabbableReturnElement) && (
+        const hasExplicitReturnFocus = typeof returnFocusValueOrFn !== 'boolean';
+        if (returnFocusValueOrFn && !preventReturnFocusRef.current && floatingUi_utils_dom.isHTMLElement(tabbableReturnElement) && (
         // If the focus moved somewhere else after mount, avoid returning focus
         // since it likely entered a different element which should be
         // respected: https://github.com/floating-ui/floating-ui/issues/2607
@@ -2847,23 +2640,24 @@ function FloatingFocusManager(props) {
         preventReturnFocusRef.current = false;
       });
     };
-  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, domReference, getNodeId, getResolvedInsideElements]);
+  }, [disabled, floating, floatingFocusElement, returnFocusRef, openInteractionTypeRef, events, tree, domReference, getNodeId, getResolvedInsideElements]);
 
   // Safari may randomly scroll to the bottom of the page if an input inside a popup has focus
   // when the popup unmounts from the DOM.
   // By blurring it before the popup unmounts, we can prevent this behavior.
   useButton.useIsoLayoutEffect(() => {
-    if (!useButton.isWebKit || open || !floating) {
+    if (!webkit || open || !floating) {
       return;
     }
     const activeEl = useButton.activeElement(useButton.ownerDocument(floating));
-    if (!floatingUi_utils_dom.isHTMLElement(activeEl) || !useButton.isTypeableElement(activeEl)) {
+    if (!floatingUi_utils_dom.isHTMLElement(activeEl) || !isTypeableElement(activeEl)) {
       return;
     }
     if (useButton.contains(floating, activeEl)) {
       activeEl.blur();
     }
   }, [open, floating]);
+
   // Synchronize the `context` & `modal` value to the FloatingPortal context.
   // It will decide whether or not it needs to render its own guards.
   useButton.useIsoLayoutEffect(() => {
@@ -2887,11 +2681,11 @@ function FloatingFocusManager(props) {
     if (disabled || !floatingFocusElement) {
       return undefined;
     }
-    handleTabIndex(floatingFocusElement, orderRef);
+    handleTabIndex(floatingFocusElement);
     return () => {
       queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
     };
-  }, [disabled, floatingFocusElement, orderRef]);
+  }, [disabled, floatingFocusElement]);
   const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
   return /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
     children: [shouldRenderGuards && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
@@ -2899,7 +2693,7 @@ function FloatingFocusManager(props) {
       ref: mergedBeforeGuardRef,
       onFocus: event => {
         if (modal) {
-          const els = getTabbableElements();
+          const els = getTabbableContent();
           enqueueFocus(els[els.length - 1]);
         } else if (portalContext?.portalNode) {
           preventReturnFocusRef.current = false;
@@ -2916,7 +2710,7 @@ function FloatingFocusManager(props) {
       ref: mergedAfterGuardRef,
       onFocus: event => {
         if (modal) {
-          enqueueFocus(getTabbableElements()[0]);
+          enqueueFocus(getTabbableContent()[0]);
         } else if (portalContext?.portalNode) {
           if (closeOnFocusOut) {
             preventReturnFocusRef.current = true;
@@ -2938,8 +2732,6 @@ function FloatingFocusManager(props) {
  * @see https://floating-ui.com/docs/useClick
  */
 function useClick(context, props = {}) {
-  const store = 'rootStore' in context ? context.rootStore : context;
-  const dataRef = store.context.dataRef;
   const {
     enabled = true,
     event: eventOption = 'click',
@@ -2949,97 +2741,105 @@ function useClick(context, props = {}) {
     touchOpenDelay = 0,
     reason = useButton.triggerPress
   } = props;
+  const store = 'rootStore' in context ? context.rootStore : context;
+  const dataRef = store.context.dataRef;
   const pointerTypeRef = React__namespace.useRef(undefined);
   const frame = useButton.useAnimationFrame();
   const touchOpenTimeout = useButton.useTimeout();
-  const reference = React__namespace.useMemo(() => ({
-    onPointerDown(event) {
-      pointerTypeRef.current = event.pointerType;
-    },
-    onMouseDown(event) {
-      const pointerType = pointerTypeRef.current;
-      const nativeEvent = event.nativeEvent;
-      const open = store.select('open');
-
-      // Ignore all buttons except for the "main" button.
-      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
-      if (event.button !== 0 || eventOption === 'click' || useButton.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
+  const reference = React__namespace.useMemo(() => {
+    function setOpenWithTouchDelay(nextOpen, nativeEvent, target, pointerType) {
+      const details = useButton.createChangeEventDetails(reason, nativeEvent, target);
+      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
+        touchOpenTimeout.start(touchOpenDelay, () => {
+          store.setOpen(true, details);
+        });
+      } else {
+        store.setOpen(nextOpen, details);
       }
+    }
+    function getNextOpen(open, currentTarget, isClickLikeOpenEvent) {
       const openEvent = dataRef.current.openEvent;
-      const openEventType = openEvent?.type;
-      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;
-      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? openEventType === 'click' || openEventType === 'mousedown' : true));
-
-      // Animations sometimes won't run on a typeable element if using a rAF.
-      // Focus is always set on these elements. For touch, we may delay opening.
-      if (useButton.isTypeableElement(nativeEvent.target)) {
-        const details = useButton.createChangeEventDetails(reason, nativeEvent, nativeEvent.target);
-        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            store.setOpen(true, details);
-          });
-        } else {
-          store.setOpen(nextOpen, details);
-        }
-        return;
+      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== currentTarget;
+      if (open && hasClickedOnInactiveTrigger) {
+        // Moving between triggers should always open the newly active one.
+        return true;
       }
-
-      // Capture the currentTarget before the rAF.
-      // as React sets it to null after the event handler completes.
-      const eventCurrentTarget = event.currentTarget;
-
-      // Wait until focus is set on the element. This is an alternative to
-      // `event.preventDefault()` to avoid :focus-visible from appearing when using a pointer.
-      frame.request(() => {
-        const details = useButton.createChangeEventDetails(reason, nativeEvent, eventCurrentTarget);
-        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            store.setOpen(true, details);
-          });
-        } else {
-          store.setOpen(nextOpen, details);
-        }
-      });
-    },
-    onClick(event) {
-      if (eventOption === 'mousedown-only') {
-        return;
+      if (!open) {
+        // A closed popup should open on the next press.
+        return true;
       }
-      const pointerType = pointerTypeRef.current;
-      if (eventOption === 'mousedown' && pointerType) {
-        pointerTypeRef.current = undefined;
-        return;
+      if (!toggle) {
+        // Non-toggle mode never closes on a repeated trigger press.
+        return true;
       }
-      if (useButton.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
+      if (openEvent && stickIfOpen) {
+        // Preserve hover/focus-opened popups until the matching click-like event closes them.
+        return !isClickLikeOpenEvent(openEvent.type);
       }
-      const open = store.select('open');
-      const openEvent = dataRef.current.openEvent;
-      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;
-      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? useButton.isClickLikeEvent(openEvent) : true));
-      const details = useButton.createChangeEventDetails(reason, event.nativeEvent, event.currentTarget);
-      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-        touchOpenTimeout.start(touchOpenDelay, () => {
-          store.setOpen(true, details);
+
+      // Otherwise, a repeated click toggles the popup closed.
+      return false;
+    }
+    return {
+      onPointerDown(event) {
+        pointerTypeRef.current = event.pointerType;
+      },
+      onMouseDown(event) {
+        const pointerType = pointerTypeRef.current;
+        const nativeEvent = event.nativeEvent;
+        const open = store.select('open');
+
+        // Ignore all buttons except for the "main" button.
+        // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
+        if (event.button !== 0 || eventOption === 'click' || useButton.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+          return;
+        }
+        const nextOpen = getNextOpen(open, event.currentTarget, openEventType => openEventType === 'click' || openEventType === 'mousedown');
+
+        // Animations sometimes won't run on a typeable element if using a rAF.
+        // Focus is always set on these elements. For touch, we may delay opening.
+        const target = useButton.getTarget(nativeEvent);
+        if (isTypeableElement(target)) {
+          setOpenWithTouchDelay(nextOpen, nativeEvent, target, pointerType);
+          return;
+        }
+
+        // Capture the currentTarget before the rAF.
+        // as React sets it to null after the event handler completes.
+        const eventCurrentTarget = event.currentTarget;
+
+        // Wait until focus is set on the element. This is an alternative to
+        // `event.preventDefault()` to avoid :focus-visible from appearing when using a pointer.
+        frame.request(() => {
+          setOpenWithTouchDelay(nextOpen, nativeEvent, eventCurrentTarget, pointerType);
         });
-      } else {
-        store.setOpen(nextOpen, details);
+      },
+      onClick(event) {
+        if (eventOption === 'mousedown-only') {
+          return;
+        }
+        const pointerType = pointerTypeRef.current;
+        if (eventOption === 'mousedown' && pointerType) {
+          pointerTypeRef.current = undefined;
+          return;
+        }
+        if (useButton.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+          return;
+        }
+        const open = store.select('open');
+        const nextOpen = getNextOpen(open, event.currentTarget, openEventType => openEventType === 'click' || openEventType === 'mousedown' || openEventType === 'keydown' || openEventType === 'keyup');
+        setOpenWithTouchDelay(nextOpen, event.nativeEvent, event.currentTarget, pointerType);
+      },
+      onKeyDown() {
+        pointerTypeRef.current = undefined;
       }
-    },
-    onKeyDown() {
-      pointerTypeRef.current = undefined;
-    }
-  }), [dataRef, eventOption, ignoreMouse, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay, reason]);
+    };
+  }, [dataRef, eventOption, ignoreMouse, reason, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay]);
   return React__namespace.useMemo(() => enabled ? {
     reference
   } : useRenderElement.EMPTY_OBJECT, [enabled, reference]);
 }
 
-const bubbleHandlerKeys = {
-  intentional: 'onClick',
-  sloppy: 'onPointerDown'
-};
 function alwaysFalse() {
   return false;
 }
@@ -3055,35 +2855,36 @@ function normalizeProp(normalizable) {
  * @see https://floating-ui.com/docs/useDismiss
  */
 function useDismiss(context, props = {}) {
-  const store = 'rootStore' in context ? context.rootStore : context;
-  const open = store.useState('open');
-  const floatingElement = store.useState('floatingElement');
-  const {
-    dataRef
-  } = store.context;
   const {
     enabled = true,
     escapeKey = true,
     outsidePress: outsidePressProp = true,
     outsidePressEvent = 'sloppy',
     referencePress = alwaysFalse,
-    referencePressEvent = 'sloppy',
     bubbles,
     externalTree
   } = props;
+  const store = 'rootStore' in context ? context.rootStore : context;
+  const open = store.useState('open');
+  const floatingElement = store.useState('floatingElement');
+  const {
+    dataRef
+  } = store.context;
   const tree = useFloatingTree(externalTree);
   const outsidePressFn = useButton.useStableCallback(typeof outsidePressProp === 'function' ? outsidePressProp : () => false);
   const outsidePress = typeof outsidePressProp === 'function' ? outsidePressFn : outsidePressProp;
   const outsidePressEnabled = outsidePress !== false;
   const getOutsidePressEventProp = useButton.useStableCallback(() => outsidePressEvent);
-  const pressStartedInsideRef = React__namespace.useRef(false);
-  const pressStartPreventedRef = React__namespace.useRef(false);
-  // Ignore only the very next outside click after dragging from inside to outside.
-  const suppressNextOutsideClickRef = React__namespace.useRef(false);
   const {
     escapeKey: escapeKeyBubbles,
     outsidePress: outsidePressBubbles
   } = normalizeProp(bubbles);
+  const pressStartedInsideRef = React__namespace.useRef(false);
+  const pressStartPreventedRef = React__namespace.useRef(false);
+  // Ignore only the very next outside click after dragging from inside to outside.
+  const suppressNextOutsideClickRef = React__namespace.useRef(false);
+  const isComposingRef = React__namespace.useRef(false);
+  const currentPointerTypeRef = React__namespace.useRef('');
   const touchStateRef = React__namespace.useRef(null);
   const cancelDismissOnEndTimeout = useButton.useTimeout();
   const clearInsideReactTreeTimeout = useButton.useTimeout();
@@ -3091,9 +2892,20 @@ function useDismiss(context, props = {}) {
     clearInsideReactTreeTimeout.clear();
     dataRef.current.insideReactTree = false;
   });
-  const isComposingRef = React__namespace.useRef(false);
-  const currentPointerTypeRef = React__namespace.useRef('');
-  const isReferencePressEnabled = useButton.useStableCallback(referencePress);
+  const hasBlockingChild = useButton.useStableCallback(bubbleKey => {
+    const nodeId = dataRef.current.floatingContext?.nodeId;
+    const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+    return children.some(child => child.context?.open && !child.context.dataRef.current[bubbleKey]);
+  });
+  const isEventWithinOwnElements = useButton.useStableCallback(event => {
+    return isEventTargetWithin(event, store.select('floatingElement')) || isEventTargetWithin(event, store.select('domReferenceElement'));
+  });
+  const closeOnReferencePress = useButton.useStableCallback(event => {
+    if (!referencePress()) {
+      return;
+    }
+    store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerPress, event.nativeEvent));
+  });
   const closeOnEscapeKeyDown = useButton.useStableCallback(event => {
     if (!open || !enabled || !escapeKey || event.key !== 'Escape') {
       return;
@@ -3104,24 +2916,15 @@ function useDismiss(context, props = {}) {
     if (isComposingRef.current) {
       return;
     }
-    const nodeId = dataRef.current.floatingContext?.nodeId;
-    const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
-    if (!escapeKeyBubbles) {
-      if (children.length > 0) {
-        let shouldDismiss = true;
-        children.forEach(child => {
-          if (child.context?.open && !child.context.dataRef.current.__escapeKeyBubbles) {
-            shouldDismiss = false;
-          }
-        });
-        if (!shouldDismiss) {
-          return;
-        }
-      }
+    if (!escapeKeyBubbles && hasBlockingChild('__escapeKeyBubbles')) {
+      return;
     }
     const native = useButton.isReactEvent(event) ? event.nativeEvent : event;
     const eventDetails = useButton.createChangeEventDetails(useButton.escapeKey, native);
     store.setOpen(false, eventDetails);
+    if (!eventDetails.isCanceled) {
+      event.preventDefault();
+    }
     if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) {
       event.stopPropagation();
     }
@@ -3130,6 +2933,33 @@ function useDismiss(context, props = {}) {
     dataRef.current.insideReactTree = true;
     clearInsideReactTreeTimeout.start(0, clearInsideReactTree);
   });
+  const markPressStartedInsideReactTree = useButton.useStableCallback(event => {
+    if (!open || !enabled || event.button !== 0) {
+      return;
+    }
+    const target = useButton.getTarget(event.nativeEvent);
+
+    // Only treat presses that start within the floating DOM subtree as inside.
+    // This avoids suppressing parent dismissal when interacting with nested portals.
+    if (!useButton.contains(store.select('floatingElement'), target)) {
+      return;
+    }
+    if (!pressStartedInsideRef.current) {
+      pressStartedInsideRef.current = true;
+      pressStartPreventedRef.current = false;
+    }
+  });
+  const markInsidePressStartPrevented = useButton.useStableCallback(event => {
+    if (!open || !enabled) {
+      return;
+    }
+    if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) {
+      return;
+    }
+    if (pressStartedInsideRef.current) {
+      pressStartPreventedRef.current = true;
+    }
+  });
   React__namespace.useEffect(() => {
     if (!open || !enabled) {
       return undefined;
@@ -3149,7 +2979,7 @@ function useDismiss(context, props = {}) {
       compositionTimeout.start(
       // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
       // Only apply to WebKit for the test to remain 0ms.
-      floatingUi_utils_dom.isWebKit() ? 5 : 0, () => {
+      webkit ? 5 : 0, () => {
         isComposingRef.current = false;
       });
     }
@@ -3181,11 +3011,17 @@ function useDismiss(context, props = {}) {
     }
     function isEventWithinFloatingTree(event) {
       const nodeId = dataRef.current.floatingContext?.nodeId;
-      const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some(node => useButton.isEventTargetWithin(event, node.context?.elements.floating));
-      return useButton.isEventTargetWithin(event, store.select('floatingElement')) || useButton.isEventTargetWithin(event, store.select('domReferenceElement')) || targetIsInsideChildren;
+      const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some(node => isEventTargetWithin(event, node.context?.elements.floating));
+      return isEventWithinOwnElements(event) || targetIsInsideChildren;
     }
     function closeOnPressOutside(event) {
       if (shouldIgnoreEvent(event)) {
+        // A new press began outside the floating element and its trigger. Clear any
+        // leftover drag-out suppression so this press's eventual click can dismiss.
+        if (event.type !== 'click' && !isEventWithinOwnElements(event)) {
+          preventedPressSuppressionTimeout.clear();
+          suppressNextOutsideClickRef.current = false;
+        }
         clearInsideReactTree();
         return;
       }
@@ -3195,11 +3031,8 @@ function useDismiss(context, props = {}) {
       }
       const target = useButton.getTarget(event);
       const inertSelector = `[${createAttribute('inert')}]`;
-      let markers = Array.from(useButton.ownerDocument(store.select('floatingElement')).querySelectorAll(inertSelector));
       const targetRoot = floatingUi_utils_dom.isElement(target) ? target.getRootNode() : null;
-      if (floatingUi_utils_dom.isShadowRoot(targetRoot)) {
-        markers = markers.concat(Array.from(targetRoot.querySelectorAll(inertSelector)));
-      }
+      const markers = Array.from((floatingUi_utils_dom.isShadowRoot(targetRoot) ? targetRoot : useButton.ownerDocument(store.select('floatingElement'))).querySelectorAll(inertSelector));
       const triggers = store.context.triggerElements;
 
       // If another trigger is clicked, don't close the floating element.
@@ -3217,7 +3050,7 @@ function useDismiss(context, props = {}) {
 
       // Check if the click occurred on a third-party element injected after the
       // floating element rendered.
-      if (markers.length && floatingUi_utils_dom.isElement(target) && !useButton.isRootElement(target) &&
+      if (markers.length && floatingUi_utils_dom.isElement(target) && !isRootElement(target) &&
       // Clicked on a direct ancestor (e.g. FloatingOverlay).
       !useButton.contains(target, store.select('floatingElement')) &&
       // If the target root element contains none of the markers, then the
@@ -3264,30 +3097,20 @@ function useDismiss(context, props = {}) {
       if (typeof outsidePress === 'function' && !outsidePress(event)) {
         return;
       }
-      const nodeId = dataRef.current.floatingContext?.nodeId;
-      const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
-      if (children.length > 0) {
-        let shouldDismiss = true;
-        children.forEach(child => {
-          if (child.context?.open && !child.context.dataRef.current.__outsidePressBubbles) {
-            shouldDismiss = false;
-          }
-        });
-        if (!shouldDismiss) {
-          return;
-        }
+      if (hasBlockingChild('__outsidePressBubbles')) {
+        return;
       }
       store.setOpen(false, useButton.createChangeEventDetails(useButton.outsidePress, event));
       clearInsideReactTree();
     }
     function handlePointerDown(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || event.pointerType === 'touch' || !store.select('open') || !enabled || useButton.isEventTargetWithin(event, store.select('floatingElement')) || useButton.isEventTargetWithin(event, store.select('domReferenceElement'))) {
+      if (getOutsidePressEvent() !== 'sloppy' || event.pointerType === 'touch' || !store.select('open') || !enabled || isEventWithinOwnElements(event)) {
         return;
       }
       closeOnPressOutside(event);
     }
     function handleTouchStart(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || !store.select('open') || !enabled || useButton.isEventTargetWithin(event, store.select('floatingElement')) || useButton.isEventTargetWithin(event, store.select('domReferenceElement'))) {
+      if (getOutsidePressEvent() !== 'sloppy' || !store.select('open') || !enabled || isEventWithinOwnElements(event)) {
         return;
       }
       const touch = event.touches[0];
@@ -3307,14 +3130,19 @@ function useDismiss(context, props = {}) {
         });
       }
     }
-    function handleTouchStartCapture(event) {
-      currentPointerTypeRef.current = 'touch';
+    function addTargetEventListenerOnce(event, listener) {
       const target = useButton.getTarget(event);
-      function callback() {
-        handleTouchStart(event);
-        target?.removeEventListener(event.type, callback);
+      if (!target) {
+        return;
       }
-      target?.addEventListener(event.type, callback);
+      const unsubscribe = useButton.addEventListener(target, event.type, () => {
+        listener(event);
+        unsubscribe();
+      });
+    }
+    function handleTouchStartCapture(event) {
+      currentPointerTypeRef.current = 'touch';
+      addTargetEventListenerOnce(event, handleTouchStart);
     }
     function closeOnPressOutsideCapture(event) {
       cancelDismissOnEndTimeout.clear();
@@ -3324,16 +3152,13 @@ function useDismiss(context, props = {}) {
       if (event.type === 'mousedown' && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
         return;
       }
-      const target = useButton.getTarget(event);
-      function callback() {
-        if (event.type === 'pointerdown') {
-          handlePointerDown(event);
+      addTargetEventListenerOnce(event, targetEvent => {
+        if (targetEvent.type === 'pointerdown') {
+          handlePointerDown(targetEvent);
         } else {
-          closeOnPressOutside(event);
+          closeOnPressOutside(targetEvent);
         }
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
+      });
     }
     function handlePressEndCapture(event) {
       if (!pressStartedInsideRef.current) {
@@ -3372,7 +3197,7 @@ function useDismiss(context, props = {}) {
       clearInsideReactTree();
     }
     function handleTouchMove(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || !touchStateRef.current || useButton.isEventTargetWithin(event, store.select('floatingElement')) || useButton.isEventTargetWithin(event, store.select('domReferenceElement'))) {
+      if (getOutsidePressEvent() !== 'sloppy' || !touchStateRef.current || isEventWithinOwnElements(event)) {
         return;
       }
       const touch = event.touches[0];
@@ -3392,15 +3217,10 @@ function useDismiss(context, props = {}) {
       }
     }
     function handleTouchMoveCapture(event) {
-      const target = useButton.getTarget(event);
-      function callback() {
-        handleTouchMove(event);
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
+      addTargetEventListenerOnce(event, handleTouchMove);
     }
     function handleTouchEnd(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || !touchStateRef.current || useButton.isEventTargetWithin(event, store.select('floatingElement')) || useButton.isEventTargetWithin(event, store.select('domReferenceElement'))) {
+      if (getOutsidePressEvent() !== 'sloppy' || !touchStateRef.current || isEventWithinOwnElements(event)) {
         return;
       }
       if (touchStateRef.current.dismissOnTouchEnd) {
@@ -3410,97 +3230,24 @@ function useDismiss(context, props = {}) {
       touchStateRef.current = null;
     }
     function handleTouchEndCapture(event) {
-      const target = useButton.getTarget(event);
-      function callback() {
-        handleTouchEnd(event);
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
+      addTargetEventListenerOnce(event, handleTouchEnd);
     }
     const doc = useButton.ownerDocument(floatingElement);
-    if (escapeKey) {
-      doc.addEventListener('keydown', closeOnEscapeKeyDown);
-      doc.addEventListener('compositionstart', handleCompositionStart);
-      doc.addEventListener('compositionend', handleCompositionEnd);
-    }
-    if (outsidePressEnabled) {
-      doc.addEventListener('click', closeOnPressOutsideCapture, true);
-      doc.addEventListener('pointerdown', closeOnPressOutsideCapture, true);
-      doc.addEventListener('pointerup', handlePressEndCapture, true);
-      doc.addEventListener('pointercancel', handlePressEndCapture, true);
-      doc.addEventListener('mousedown', closeOnPressOutsideCapture, true);
-      doc.addEventListener('mouseup', handlePressEndCapture, true);
-      doc.addEventListener('touchstart', handleTouchStartCapture, true);
-      doc.addEventListener('touchmove', handleTouchMoveCapture, true);
-      doc.addEventListener('touchend', handleTouchEndCapture, true);
-    }
+    const unsubscribe = mergeCleanups(escapeKey && mergeCleanups(useButton.addEventListener(doc, 'keydown', closeOnEscapeKeyDown), useButton.addEventListener(doc, 'compositionstart', handleCompositionStart), useButton.addEventListener(doc, 'compositionend', handleCompositionEnd)), outsidePressEnabled && mergeCleanups(useButton.addEventListener(doc, 'click', closeOnPressOutsideCapture, true), useButton.addEventListener(doc, 'pointerdown', closeOnPressOutsideCapture, true), useButton.addEventListener(doc, 'pointerup', handlePressEndCapture, true), useButton.addEventListener(doc, 'pointercancel', handlePressEndCapture, true), useButton.addEventListener(doc, 'mousedown', closeOnPressOutsideCapture, true), useButton.addEventListener(doc, 'mouseup', handlePressEndCapture, true), useButton.addEventListener(doc, 'touchstart', handleTouchStartCapture, true), useButton.addEventListener(doc, 'touchmove', handleTouchMoveCapture, true), useButton.addEventListener(doc, 'touchend', handleTouchEndCapture, true)));
     return () => {
-      if (escapeKey) {
-        doc.removeEventListener('keydown', closeOnEscapeKeyDown);
-        doc.removeEventListener('compositionstart', handleCompositionStart);
-        doc.removeEventListener('compositionend', handleCompositionEnd);
-      }
-      if (outsidePressEnabled) {
-        doc.removeEventListener('click', closeOnPressOutsideCapture, true);
-        doc.removeEventListener('pointerdown', closeOnPressOutsideCapture, true);
-        doc.removeEventListener('pointerup', handlePressEndCapture, true);
-        doc.removeEventListener('pointercancel', handlePressEndCapture, true);
-        doc.removeEventListener('mousedown', closeOnPressOutsideCapture, true);
-        doc.removeEventListener('mouseup', handlePressEndCapture, true);
-        doc.removeEventListener('touchstart', handleTouchStartCapture, true);
-        doc.removeEventListener('touchmove', handleTouchMoveCapture, true);
-        doc.removeEventListener('touchend', handleTouchEndCapture, true);
-      }
+      unsubscribe();
       compositionTimeout.clear();
       preventedPressSuppressionTimeout.clear();
       resetPressStartState();
       suppressNextOutsideClickRef.current = false;
     };
-  }, [dataRef, floatingElement, escapeKey, outsidePressEnabled, outsidePress, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, tree, store, cancelDismissOnEndTimeout]);
+  }, [dataRef, floatingElement, escapeKey, outsidePressEnabled, outsidePress, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store, cancelDismissOnEndTimeout]);
   React__namespace.useEffect(clearInsideReactTree, [outsidePress, clearInsideReactTree]);
   const reference = React__namespace.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
-    [bubbleHandlerKeys[referencePressEvent]]: event => {
-      if (!isReferencePressEnabled()) {
-        return;
-      }
-      store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerPress, event.nativeEvent));
-    },
-    ...(referencePressEvent !== 'intentional' && {
-      onClick(event) {
-        if (!isReferencePressEnabled()) {
-          return;
-        }
-        store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerPress, event.nativeEvent));
-      }
-    })
-  }), [closeOnEscapeKeyDown, store, referencePressEvent, isReferencePressEnabled]);
-  const markPressStartedInsideReactTree = useButton.useStableCallback(event => {
-    if (!open || !enabled || event.button !== 0) {
-      return;
-    }
-    const target = useButton.getTarget(event.nativeEvent);
-    // Only treat presses that start within the floating DOM subtree as inside.
-    // This avoids suppressing parent dismissal when interacting with nested portals.
-    if (!useButton.contains(store.select('floatingElement'), target)) {
-      return;
-    }
-    if (!pressStartedInsideRef.current) {
-      pressStartedInsideRef.current = true;
-      pressStartPreventedRef.current = false;
-    }
-  });
-  const markInsidePressStartPrevented = useButton.useStableCallback(event => {
-    if (!open || !enabled) {
-      return;
-    }
-    if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) {
-      return;
-    }
-    if (pressStartedInsideRef.current) {
-      pressStartPreventedRef.current = true;
-    }
-  });
+    onPointerDown: closeOnReferencePress,
+    onClick: closeOnReferencePress
+  }), [closeOnEscapeKeyDown, closeOnReferencePress]);
   const floating = React__namespace.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
     // `onMouseDown` may be blocked if `event.preventDefault()` is called in
@@ -3530,6 +3277,7 @@ 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),
@@ -3538,8 +3286,8 @@ const selectors = {
 class FloatingRootStore extends ReactStore {
   constructor(options) {
     const {
+      syncOnly,
       nested,
-      noEmit,
       onOpenChange,
       triggerElements,
       ...initialState
@@ -3555,11 +3303,38 @@ class FloatingRootStore extends ReactStore {
       },
       events: createEventEmitter(),
       nested,
-      noEmit,
       triggerElements
     }, selectors);
+    this.syncOnly = syncOnly;
   }
 
+  /**
+   * Syncs the event used by hover logic to distinguish hover-open from click-like interaction.
+   */
+  syncOpenEvent = (newOpen, event) => {
+    if (!newOpen || !this.state.open ||
+    // Prevent a pending hover-open from overwriting a click-open event, while allowing
+    // click events to upgrade a hover-open.
+    event != null && useButton.isClickLikeEvent(event)) {
+      this.context.dataRef.current.openEvent = newOpen ? event : undefined;
+    }
+  };
+
+  /**
+   * Runs the root-owned side effects for an open state change.
+   */
+  dispatchOpenChange = (newOpen, eventDetails) => {
+    this.syncOpenEvent(newOpen, eventDetails.event);
+    const details = {
+      open: newOpen,
+      reason: eventDetails.reason,
+      nativeEvent: eventDetails.event,
+      nested: this.context.nested,
+      triggerElement: eventDetails.trigger
+    };
+    this.context.events.emit('openchange', details);
+  };
+
   /**
    * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
    *
@@ -3567,26 +3342,385 @@ class FloatingRootStore extends ReactStore {
    * @param eventDetails Details about the event that triggered the open state change.
    */
   setOpen = (newOpen, eventDetails) => {
-    if (!newOpen || !this.state.open ||
-    // Prevent a pending hover-open from overwriting a click-open event, while allowing
-    // click events to upgrade a hover-open.
-    useButton.isClickLikeEvent(eventDetails.event)) {
-      this.context.dataRef.current.openEvent = newOpen ? eventDetails.event : undefined;
-    }
-    if (!this.context.noEmit) {
-      const details = {
-        open: newOpen,
-        reason: eventDetails.reason,
-        nativeEvent: eventDetails.event,
-        nested: this.context.nested,
-        triggerElement: eventDetails.trigger
-      };
-      this.context.events.emit('openchange', details);
+    if (this.syncOnly) {
+      this.context.onOpenChange?.(newOpen, eventDetails);
+      return;
     }
+    this.dispatchOpenChange(newOpen, eventDetails);
     this.context.onOpenChange?.(newOpen, eventDetails);
   };
 }
 
+/**
+ * Keeps a FloatingRootStore in sync with the provided PopupStore.
+ * Uses the provided FloatingRootStore when one exists, otherwise creates one once and updates it on every render.
+ */
+function useSyncedFloatingRootContext(options) {
+  const {
+    popupStore,
+    treatPopupAsFloatingElement = false,
+    floatingRootContext: floatingRootContextProp,
+    floatingId,
+    nested,
+    onOpenChange
+  } = options;
+  const open = popupStore.useState('open');
+  const referenceElement = popupStore.useState('activeTriggerElement');
+  const floatingElement = popupStore.useState(treatPopupAsFloatingElement ? 'popupElement' : 'positionerElement');
+  const triggerElements = popupStore.context.triggerElements;
+  const handleOpenChange = onOpenChange;
+  const internalStoreRef = React__namespace.useRef(null);
+  if (floatingRootContextProp === undefined && internalStoreRef.current === null) {
+    internalStoreRef.current = new FloatingRootStore({
+      open,
+      transitionStatus: undefined,
+      referenceElement,
+      floatingElement,
+      triggerElements,
+      onOpenChange: handleOpenChange,
+      floatingId,
+      syncOnly: true,
+      nested
+    });
+  }
+  const store = floatingRootContextProp ?? internalStoreRef.current;
+  popupStore.useSyncedValue('floatingId', floatingId);
+  useButton.useIsoLayoutEffect(() => {
+    const valuesToSync = {
+      open,
+      floatingId,
+      referenceElement,
+      floatingElement
+    };
+    if (floatingUi_utils_dom.isElement(referenceElement)) {
+      valuesToSync.domReferenceElement = referenceElement;
+    }
+    if (store.state.positionReference === store.state.referenceElement) {
+      valuesToSync.positionReference = referenceElement;
+    }
+    store.update(valuesToSync);
+  }, [open, floatingId, referenceElement, floatingElement, store]);
+
+  // Keep non-reactive context values fresh for interactions that call `store.setOpen`.
+  store.context.onOpenChange = handleOpenChange;
+  store.context.nested = nested;
+  return store;
+}
+
+const FOCUSABLE_POPUP_PROPS = {
+  tabIndex: -1,
+  [FOCUSABLE_ATTRIBUTE]: ''
+};
+
+/**
+ * Returns the default `initialFocus` resolver for a popup. When opened by touch it focuses the
+ * popup element itself to prevent the virtual keyboard from opening (required for Android
+ * specifically; iOS handles this automatically). Otherwise it falls back to the default behavior.
+ */
+function createDefaultInitialFocus(popupRef) {
+  return interactionType => interactionType === 'touch' ? popupRef.current : true;
+}
+function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement = false) {
+  const floatingId = useButton.useId();
+  const nested = useFloatingParentNodeId() != null;
+  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,
+    floatingRootContext: store.state.floatingRootContext,
+    floatingId,
+    nested,
+    onOpenChange: store.setOpen
+  });
+  return {
+    store,
+    internalStore: internalStoreRef.current
+  };
+}
+
+/**
+ * Returns a callback ref that registers/unregisters the trigger element in the store.
+ *
+ * @param store The Store instance where the trigger should be registered.
+ */
+function useTriggerRegistration(id, store) {
+  // Keep track of the currently registered element to unregister it on unmount or id change.
+  const registeredElementIdRef = React__namespace.useRef(null);
+  const registeredElementRef = React__namespace.useRef(null);
+  return React__namespace.useCallback(element => {
+    if (id === undefined) {
+      return;
+    }
+    let shouldSyncTriggerCount = false;
+    if (registeredElementIdRef.current !== null) {
+      const registeredId = registeredElementIdRef.current;
+      const registeredElement = registeredElementRef.current;
+      const currentElement = store.context.triggerElements.getById(registeredId);
+      if (registeredElement && currentElement === registeredElement) {
+        store.context.triggerElements.delete(registeredId);
+        shouldSyncTriggerCount = true;
+      }
+      registeredElementIdRef.current = null;
+      registeredElementRef.current = null;
+    }
+    if (element !== null) {
+      registeredElementIdRef.current = id;
+      registeredElementRef.current = element;
+      store.context.triggerElements.add(id, element);
+      shouldSyncTriggerCount = true;
+    }
+    if (shouldSyncTriggerCount) {
+      const triggerCount = store.context.triggerElements.size;
+      if (store.select('open') && store.state.triggerCount !== triggerCount) {
+        store.set('triggerCount', triggerCount);
+      }
+    }
+  }, [store, id]);
+}
+function setPopupOpenState(state, open, trigger, preventUnmountOnClose = false) {
+  if (open) {
+    // Opening starts a new close cycle, so clear any previous request to keep the popup mounted.
+    state.preventUnmountingOnClose = false;
+  } else if (preventUnmountOnClose) {
+    state.preventUnmountingOnClose = true;
+  }
+  const triggerId = trigger?.id ?? null;
+
+  // If a popup is closing, the `trigger` may be undefined.
+  // We want to keep the previous value so that exit animations are played and focus is returned correctly.
+  if (triggerId || open) {
+    state.activeTriggerId = triggerId;
+    state.activeTriggerElement = trigger ?? null;
+  }
+}
+function attachPreventUnmountOnClose(eventDetails) {
+  let preventUnmountOnClose = false;
+  eventDetails.preventUnmountOnClose = () => {
+    preventUnmountOnClose = true;
+  };
+  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.
+ *
+ * @param triggerId Id of the trigger.
+ * @param triggerElementRef Ref for the trigger DOM element.
+ * @param store The Store instance managing the popup state.
+ * @param stateUpdates An object with state updates to apply when the trigger is active.
+ */
+function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates) {
+  const isMountedByThisTrigger = store.useState('isMountedByTrigger', triggerId);
+  const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
+  const registerTrigger = useButton.useStableCallback(element => {
+    baseRegisterTrigger(element);
+    if (!element) {
+      return;
+    }
+    const open = store.select('open');
+    const activeTriggerId = store.select('activeTriggerId');
+    if (activeTriggerId === triggerId) {
+      store.update({
+        activeTriggerElement: element,
+        ...(open ? stateUpdates : null)
+      });
+      return;
+    }
+    if (activeTriggerId == null && open) {
+      // If a popup is already open, a detached trigger can mount before any active trigger
+      // has been established. Claim the first registered trigger so trigger-owned focus
+      // management and ARIA relationships work.
+      store.update({
+        activeTriggerId: triggerId,
+        activeTriggerElement: element,
+        ...stateUpdates
+      });
+    }
+  });
+  useButton.useIsoLayoutEffect(() => {
+    if (isMountedByThisTrigger) {
+      store.update({
+        activeTriggerElement: triggerElementRef.current,
+        ...stateUpdates
+      });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isMountedByThisTrigger, store, triggerElementRef, ...Object.values(stateUpdates)]);
+  return {
+    registerTrigger,
+    isMountedByThisTrigger
+  };
+}
+/**
+ * Keeps trigger registration state synchronized while the popup is open.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * @param store The Store instance managing the popup state.
+ * @param options Options for active trigger unmount behavior.
+ */
+function useImplicitActiveTrigger(store, options = {}) {
+  const {
+    closeOnActiveTriggerUnmount = false
+  } = options;
+  const open = store.useState('open');
+  const reactiveTriggerCount = store.useState('triggerCount');
+  useButton.useIsoLayoutEffect(() => {
+    if (!open) {
+      if (store.state.triggerCount !== 0) {
+        store.set('triggerCount', 0);
+      }
+      return;
+    }
+    const triggerCount = store.context.triggerElements.size;
+    const stateUpdates = {};
+    if (store.state.triggerCount !== triggerCount) {
+      stateUpdates.triggerCount = triggerCount;
+    }
+    const activeTriggerId = store.select('activeTriggerId');
+    let lostActiveTriggerId = null;
+    if (activeTriggerId) {
+      const activeTriggerElement = store.context.triggerElements.getById(activeTriggerId);
+      if (!activeTriggerElement) {
+        lostActiveTriggerId = activeTriggerId;
+      } else if (activeTriggerElement !== store.state.activeTriggerElement) {
+        stateUpdates.activeTriggerElement = activeTriggerElement;
+      }
+    }
+    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;
+      }
+    }
+    if (stateUpdates.triggerCount !== undefined || stateUpdates.activeTriggerId !== undefined || stateUpdates.activeTriggerElement !== undefined) {
+      store.update(stateUpdates);
+    }
+    if (lostActiveTriggerId) {
+      if (closeOnActiveTriggerUnmount) {
+        // Defer so a same-tick replacement trigger with the same id can register first.
+        queueMicrotask(() => {
+          if (store.select('open') && store.select('activeTriggerId') === lostActiveTriggerId && !store.context.triggerElements.getById(lostActiveTriggerId)) {
+            const eventDetails = useButton.createChangeEventDetails(useButton.none);
+            store.setOpen(false, eventDetails);
+            // If closing is canceled, keep the previous active trigger ownership for the
+            // still-open popup instead of claiming another trigger implicitly.
+            if (!eventDetails.isCanceled) {
+              store.update({
+                activeTriggerId: null,
+                activeTriggerElement: null
+              });
+            }
+          }
+        });
+      }
+    }
+  }, [open, store, reactiveTriggerCount, closeOnActiveTriggerUnmount]);
+}
+
+/**
+ * Manages the mounted state of the popup.
+ * Sets up the transition status listeners and handles unmounting when needed.
+ * Updates the `mounted`, `transitionStatus`, and `preventUnmountingOnClose` states in the store.
+ *
+ * @param open Whether the popup is open.
+ * @param store The Store instance managing the popup state.
+ * @param onUnmount Optional callback to be called when the popup is unmounted.
+ *
+ * @returns A function to forcibly unmount the popup.
+ */
+function useOpenStateTransitions(open, store, onUnmount) {
+  const {
+    mounted,
+    setMounted,
+    transitionStatus
+  } = useButton.useTransitionStatus(open);
+  const preventUnmountingOnClose = store.useState('preventUnmountingOnClose');
+  // Opening starts a new close cycle. Clear during render so the close-completion hook below
+  // reads the synchronized value on the same pass.
+  const syncedPreventUnmountingOnClose = open ? false : preventUnmountingOnClose;
+  store.useSyncedValues({
+    mounted,
+    transitionStatus,
+    preventUnmountingOnClose: syncedPreventUnmountingOnClose
+  });
+  const forceUnmount = useButton.useStableCallback(() => {
+    setMounted(false);
+    store.update({
+      activeTriggerId: null,
+      activeTriggerElement: null,
+      mounted: false,
+      preventUnmountingOnClose: false
+    });
+    onUnmount?.();
+    store.context.onOpenChangeComplete?.(false);
+  });
+  useButton.useOpenChangeComplete({
+    enabled: mounted && !open && !syncedPreventUnmountingOnClose,
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      if (!open) {
+        forceUnmount();
+      }
+    }
+  });
+  return {
+    forceUnmount,
+    transitionStatus
+  };
+}
+function usePopupInteractionProps(store, statePart) {
+  store.useSyncedValues(statePart);
+  useButton.useIsoLayoutEffect(() => () => {
+    store.update({
+      activeTriggerProps: useRenderElement.EMPTY_OBJECT,
+      inactiveTriggerProps: useRenderElement.EMPTY_OBJECT,
+      popupProps: useRenderElement.EMPTY_OBJECT
+    });
+  }, [store]);
+}
+function usePopupRootSync(store, open) {
+  useButton.useIsoLayoutEffect(() => {
+    if (!open && store.state.openMethod !== null) {
+      store.set('openMethod', null);
+    }
+  }, [open, store]);
+  useButton.useIsoLayoutEffect(() => () => {
+    if (store.state.openMethod !== null) {
+      store.set('openMethod', null);
+    }
+  }, [store]);
+}
+
 /**
  * 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.
@@ -3616,6 +3750,8 @@ class PopupTriggerMap {
     this.idMap.set(id, element);
     if (process.env.NODE_ENV !== 'production') {
       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.');
       }
     }
@@ -3680,93 +3816,6 @@ class PopupTriggerMap {
   }
 }
 
-/**
- * Merges an array of interaction hooks' props into prop getters, allowing
- * event handler functions to be composed together without overwriting one
- * another.
- * @see https://floating-ui.com/docs/useInteractions
- */
-function useInteractions(propsList = []) {
-  const referenceDeps = propsList.map(key => key?.reference);
-  const floatingDeps = propsList.map(key => key?.floating);
-  const itemDeps = propsList.map(key => key?.item);
-  const triggerDeps = propsList.map(key => key?.trigger);
-  const getReferenceProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  referenceDeps);
-  const getFloatingProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  floatingDeps);
-  const getItemProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'item'),
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  itemDeps);
-  const getTriggerProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'trigger'),
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  triggerDeps);
-  return React__namespace.useMemo(() => ({
-    getReferenceProps,
-    getFloatingProps,
-    getItemProps,
-    getTriggerProps
-  }), [getReferenceProps, getFloatingProps, getItemProps, getTriggerProps]);
-}
-
-/* eslint-disable guard-for-in */
-
-function mergeProps(userProps, propsList, elementKey) {
-  const eventHandlers = new Map();
-  const isItem = elementKey === 'item';
-  const outputProps = {};
-  if (elementKey === 'floating') {
-    outputProps.tabIndex = -1;
-    outputProps[useButton.FOCUSABLE_ATTRIBUTE] = '';
-  }
-  for (const key in userProps) {
-    if (isItem && userProps) {
-      if (key === useButton.ACTIVE_KEY || key === useButton.SELECTED_KEY) {
-        continue;
-      }
-    }
-    outputProps[key] = userProps[key];
-  }
-  for (let i = 0; i < propsList.length; i += 1) {
-    let props;
-    const propsOrGetProps = propsList[i]?.[elementKey];
-    if (typeof propsOrGetProps === 'function') {
-      props = userProps ? propsOrGetProps(userProps) : null;
-    } else {
-      props = propsOrGetProps;
-    }
-    if (!props) {
-      continue;
-    }
-    mutablyMergeProps(outputProps, props, isItem, eventHandlers);
-  }
-  mutablyMergeProps(outputProps, userProps, isItem, eventHandlers);
-  return outputProps;
-}
-function mutablyMergeProps(outputProps, props, isItem, eventHandlers) {
-  for (const key in props) {
-    const value = props[key];
-    if (isItem && (key === useButton.ACTIVE_KEY || key === useButton.SELECTED_KEY)) {
-      continue;
-    }
-    if (!key.startsWith('on')) {
-      outputProps[key] = value;
-    } else {
-      if (!eventHandlers.has(key)) {
-        eventHandlers.set(key, []);
-      }
-      if (typeof value === 'function') {
-        eventHandlers.get(key)?.push(value);
-        outputProps[key] = (...args) => {
-          return eventHandlers.get(key)?.map(fn => fn(...args)).find(val => val !== undefined);
-        };
-      }
-    }
-  }
-}
-
 /**
  * Provides a cross-browser way to determine the type of the pointer used to click.
  * Safari and Firefox do not provide the PointerEvent to the click handler (they use MouseEvent) yet.
@@ -3803,38 +3852,54 @@ function useEnhancedClickHandler(handler) {
   };
 }
 
-/**
- * Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.
- *
- * @param open The open state of the component.
- */
-function useOpenInteractionType(open) {
-  const [openMethod, setOpenMethod] = React__namespace.useState(null);
+function useOpenMethodTriggerProps(open, setOpenMethod) {
   const handleTriggerClick = useButton.useStableCallback((_, interactionType) => {
-    if (!open) {
+    const isOpen = typeof open === 'function' ? open() : open;
+    if (!isOpen) {
       setOpenMethod(interactionType || (
       // On iOS Safari, the hitslop around touch targets means tapping outside an element's
       // bounds does not fire `pointerdown` but does fire `mousedown`. The `interactionType`
       // will be "" in that case.
-      useButton.isIOS ? 'touch' : ''));
+      useButton.ios ? 'touch' : ''));
     }
   });
+  const {
+    onClick,
+    onPointerDown
+  } = useEnhancedClickHandler(handleTriggerClick);
+  return React__namespace.useMemo(() => ({
+    onClick,
+    onPointerDown
+  }), [onClick, onPointerDown]);
+}
+
+/**
+ * Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.
+ *
+ * @param open The open state of the component.
+ */
+function useOpenInteractionType(open) {
+  const [openMethod, setOpenMethod] = React__namespace.useState(null);
+  const triggerProps = useOpenMethodTriggerProps(open, setOpenMethod);
   useButton.useValueChanged(open, previousOpen => {
     if (previousOpen && !open) {
       setOpenMethod(null);
     }
   });
-  const {
-    onClick,
-    onPointerDown
-  } = useEnhancedClickHandler(handleTriggerClick);
   return React__namespace.useMemo(() => ({
     openMethod,
-    triggerProps: {
-      onClick,
-      onPointerDown
-    }
-  }), [openMethod, onClick, onPointerDown]);
+    triggerProps
+  }), [openMethod, triggerProps]);
+}
+
+/**
+ * @internal
+ */
+const DirectionContext = /*#__PURE__*/React__namespace.createContext(undefined);
+if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
+function useDirection() {
+  const context = React__namespace.useContext(DirectionContext);
+  return context?.direction ?? 'ltr';
 }
 
 let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
@@ -3928,16 +3993,6 @@ const popupStateMapping = {
   }
 };
 
-/**
- * @internal
- */
-const DirectionContext = /*#__PURE__*/React__namespace.createContext(undefined);
-if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
-function useDirection() {
-  const context = React__namespace.useContext(DirectionContext);
-  return context?.direction ?? 'ltr';
-}
-
 function inertValue(value) {
   if (useRenderElement.isReactVersionAtLeast(19)) {
     return value;
@@ -3946,6 +4001,35 @@ function inertValue(value) {
   return value ? 'true' : undefined;
 }
 
+const InternalBackdrop = /*#__PURE__*/React__namespace.forwardRef(function InternalBackdrop(props, ref) {
+  const {
+    cutout,
+    ...otherProps
+  } = props;
+  let clipPath;
+  if (cutout) {
+    const rect = cutout.getBoundingClientRect();
+    clipPath = `polygon(0% 0%,100% 0%,100% 100%,0% 100%,0% 0%,${rect.left}px ${rect.top}px,${rect.left}px ${rect.bottom}px,${rect.right}px ${rect.bottom}px,${rect.right}px ${rect.top}px,${rect.left}px ${rect.top}px)`;
+  }
+  return /*#__PURE__*/jsxRuntime.jsx("div", {
+    ref: ref,
+    role: "presentation"
+    // Ensures Floating UI's outside press detection runs, as it considers
+    // it an element that existed when the popup rendered.
+    ,
+    "data-base-ui-inert": "",
+    ...otherProps,
+    style: {
+      position: 'fixed',
+      inset: 0,
+      userSelect: 'none',
+      WebkitUserSelect: 'none',
+      clipPath
+    }
+  });
+});
+if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";
+
 let originalHtmlStyles = {};
 let originalBodyStyles = {};
 let originalHtmlScrollBehavior = '';
@@ -4010,7 +4094,7 @@ function preventScrollInsetScrollbars(referenceElement) {
   const resizeFrame = useButton.AnimationFrame.create();
 
   // Pinch-zoom in Safari causes a shift. Just don't lock scroll if there's any pinch-zoom.
-  if (useButton.isWebKit && (win.visualViewport?.scale ?? 1) !== 1) {
+  if (webkit && (win.visualViewport?.scale ?? 1) !== 1) {
     return () => {};
   }
   function lockScroll() {
@@ -4104,16 +4188,15 @@ function preventScrollInsetScrollbars(referenceElement) {
     resizeFrame.request(lockScroll);
   }
   lockScroll();
-  win.addEventListener('resize', handleResize);
+  const unsubscribeResize = useButton.addEventListener(win, 'resize', handleResize);
   return () => {
     resizeFrame.cancel();
     cleanup();
-    // Sometimes this cleanup can be run after test teardown
-    // because it is called in a `setTimeout(fn, 0)`,
-    // in which case `removeEventListener` wouldn't be available,
-    // so we check for it to avoid test failures.
+    // Sometimes this cleanup can run after test teardown because it is called
+    // in a `setTimeout(fn, 0)`. Guard the returned cleanup to avoid calling
+    // `removeEventListener` when it is no longer available in tests.
     if (typeof win.removeEventListener === 'function') {
-      win.removeEventListener('resize', handleResize);
+      unsubscribeResize();
     }
   };
 }
@@ -4154,7 +4237,7 @@ class ScrollLocker {
       this.restore = useRenderElement.NOOP;
       return;
     }
-    const hasOverlayScrollbars = useButton.isIOS || !hasInsetScrollbars(referenceElement);
+    const hasOverlayScrollbars = useButton.ios || !hasInsetScrollbars(referenceElement);
 
     // On iOS, scroll locking does not work if the navbar is collapsed. Due to numerous
     // side effects and bugs that arise on iOS, it must be researched extensively before
@@ -4182,51 +4265,16 @@ function useScrollLock(enabled = true, referenceElement = null) {
   }, [enabled, referenceElement]);
 }
 
-const InternalBackdrop = /*#__PURE__*/React__namespace.forwardRef(function InternalBackdrop(props, ref) {
-  const {
-    cutout,
-    ...otherProps
-  } = props;
-  let clipPath;
-  if (cutout) {
-    const rect = cutout?.getBoundingClientRect();
-    clipPath = `polygon(
-      0% 0%,
-      100% 0%,
-      100% 100%,
-      0% 100%,
-      0% 0%,
-      ${rect.left}px ${rect.top}px,
-      ${rect.left}px ${rect.bottom}px,
-      ${rect.right}px ${rect.bottom}px,
-      ${rect.right}px ${rect.top}px,
-      ${rect.left}px ${rect.top}px
-    )`;
-  }
-  return /*#__PURE__*/jsxRuntime.jsx("div", {
-    ref: ref,
-    role: "presentation"
-    // Ensures Floating UI's outside press detection runs, as it considers
-    // it an element that existed when the popup rendered.
-    ,
-    "data-base-ui-inert": "",
-    ...otherProps,
-    style: {
-      position: 'fixed',
-      inset: 0,
-      userSelect: 'none',
-      WebkitUserSelect: 'none',
-      clipPath
-    }
-  });
-});
-if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";
-
+exports.ARROW_DOWN = ARROW_DOWN;
+exports.ARROW_LEFT = ARROW_LEFT;
+exports.ARROW_RIGHT = ARROW_RIGHT;
+exports.ARROW_UP = ARROW_UP;
 exports.BASE_UI_SWIPE_IGNORE_SELECTOR = BASE_UI_SWIPE_IGNORE_SELECTOR;
 exports.CLICK_TRIGGER_IDENTIFIER = CLICK_TRIGGER_IDENTIFIER;
 exports.CommonPopupDataAttributes = CommonPopupDataAttributes;
 exports.DISABLED_TRANSITIONS_STYLE = DISABLED_TRANSITIONS_STYLE;
 exports.DROPDOWN_COLLISION_AVOIDANCE = DROPDOWN_COLLISION_AVOIDANCE;
+exports.FOCUSABLE_POPUP_PROPS = FOCUSABLE_POPUP_PROPS;
 exports.FloatingFocusManager = FloatingFocusManager;
 exports.FloatingNode = FloatingNode;
 exports.FloatingPortal = FloatingPortal;
@@ -4241,15 +4289,16 @@ exports.PopupTriggerMap = PopupTriggerMap;
 exports.ReactStore = ReactStore;
 exports.Store = Store;
 exports.TYPEAHEAD_RESET_MS = TYPEAHEAD_RESET_MS;
+exports.attachPreventUnmountOnClose = attachPreventUnmountOnClose;
 exports.createAttribute = createAttribute;
-exports.createGridCellMap = createGridCellMap;
+exports.createDefaultInitialFocus = createDefaultInitialFocus;
 exports.createSelector = createSelector;
 exports.enqueueFocus = enqueueFocus;
 exports.fastComponent = fastComponent;
 exports.fastComponentRef = fastComponentRef;
 exports.findNonDisabledListIndex = findNonDisabledListIndex;
-exports.getGridCellIndexOfCorner = getGridCellIndexOfCorner;
-exports.getGridCellIndices = getGridCellIndices;
+exports.gecko = gecko;
+exports.getFloatingFocusElement = getFloatingFocusElement;
 exports.getGridNavigatedIndex = getGridNavigatedIndex;
 exports.getMaxListIndex = getMaxListIndex;
 exports.getMinListIndex = getMinListIndex;
@@ -4260,10 +4309,17 @@ exports.getTabbableBeforeElement = getTabbableBeforeElement;
 exports.inertValue = inertValue;
 exports.isElementVisible = isElementVisible;
 exports.isIndexOutOfListBounds = isIndexOutOfListBounds;
+exports.isInteractiveElement = isInteractiveElement;
 exports.isListIndexDisabled = isListIndexDisabled;
 exports.isOutsideEvent = isOutsideEvent;
+exports.isTargetInsideEnabledTrigger = isTargetInsideEnabledTrigger;
+exports.isTypeableCombobox = isTypeableCombobox;
+exports.isTypeableElement = isTypeableElement;
+exports.matchesFocusVisible = matchesFocusVisible;
+exports.mergeCleanups = mergeCleanups;
 exports.popupStateMapping = popupStateMapping;
 exports.pressableTriggerOpenStateMapping = pressableTriggerOpenStateMapping;
+exports.setPopupOpenState = setPopupOpenState;
 exports.triggerOpenStateMapping = triggerOpenStateMapping;
 exports.useClick = useClick;
 exports.useDirection = useDirection;
@@ -4271,8 +4327,18 @@ exports.useDismiss = useDismiss;
 exports.useFloatingNodeId = useFloatingNodeId;
 exports.useFloatingParentNodeId = useFloatingParentNodeId;
 exports.useFloatingTree = useFloatingTree;
-exports.useInteractions = useInteractions;
+exports.useImplicitActiveTrigger = useImplicitActiveTrigger;
+exports.useInitialOpenSync = useInitialOpenSync;
 exports.useOnFirstRender = useOnFirstRender;
 exports.useOpenInteractionType = useOpenInteractionType;
+exports.useOpenMethodTriggerProps = useOpenMethodTriggerProps;
+exports.useOpenStateTransitions = useOpenStateTransitions;
+exports.usePopupInteractionProps = usePopupInteractionProps;
+exports.usePopupRootSync = usePopupRootSync;
+exports.usePopupStore = usePopupStore;
 exports.useScrollLock = useScrollLock;
 exports.useStore = useStore;
+exports.useSyncedFloatingRootContext = useSyncedFloatingRootContext;
+exports.useTriggerDataForwarding = useTriggerDataForwarding;
+exports.useTriggerRegistration = useTriggerRegistration;
+exports.webkit = webkit;