@jobber/components 8.20.2 → 8.21.1

package/dist/ScrollAreaViewport-cjs.js

@@ -2,11 +2,11 @@
 
 var React = require('react');
 var useRenderElement = require('./useRenderElement-cjs.js');
+var InternalBackdrop = require('./InternalBackdrop-cjs.js');
+var useButton = require('./useButton-cjs.js');
 var clamp = require('./clamp-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
-var index_esm = require('./index.esm-cjs.js');
 var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
-var ReactDOM = require('react-dom');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -26,3566 +26,6 @@ function _interopNamespaceDefault(e) {
 }
 
 var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
-var ReactDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactDOM);
-
-function useOnFirstRender(fn) {
-  const ref = React__namespace.useRef(true);
-  if (ref.current) {
-    ref.current = false;
-    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__
-
-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.
- * 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.
- *
- * @example
- * const selector = createSelector(
- *  (state) => state.disabled
- * );
- *
- * @example
- * const selector = createSelector(
- *   (state) => state.disabled,
- *   (state) => state.open,
- *   (disabled, open) => ({ disabled, open })
- * );
- *
- */
-/* eslint-disable id-denylist */
-const createSelector = (a, b, c, d, e, f, ...other) => {
-  if (other.length > 0) {
-    throw new Error(process.env.NODE_ENV !== "production" ? 'Unsupported number of selectors' : useRenderElement.formatErrorMessage(1));
-  }
-  let selector;
-  if (a && b && c && d && e && f) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      const vc = c(state, a1, a2, a3);
-      const vd = d(state, a1, a2, a3);
-      const ve = e(state, a1, a2, a3);
-      return f(va, vb, vc, vd, ve, a1, a2, a3);
-    };
-  } else if (a && b && c && d && e) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      const vc = c(state, a1, a2, a3);
-      const vd = d(state, a1, a2, a3);
-      return e(va, vb, vc, vd, a1, a2, a3);
-    };
-  } else if (a && b && c && d) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      const vc = c(state, a1, a2, a3);
-      return d(va, vb, vc, a1, a2, a3);
-    };
-  } else if (a && b && c) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      return c(va, vb, a1, a2, a3);
-    };
-  } else if (a && b) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      return b(va, a1, a2, a3);
-    };
-  } else if (a) {
-    selector = a;
-  } else {
-    throw /* minify-error-disabled */new Error('Missing arguments');
-  }
-  return selector;
-};
-
-var shim = {exports: {}};
-
-var useSyncExternalStoreShim_production = {};
-
-/**
- * @license React
- * use-sync-external-store-shim.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasRequiredUseSyncExternalStoreShim_production;
-
-function requireUseSyncExternalStoreShim_production () {
-	if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
-	hasRequiredUseSyncExternalStoreShim_production = 1;
-	var React$1 = React;
-	function is(x, y) {
-	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
-	}
-	var objectIs = "function" === typeof Object.is ? Object.is : is,
-	  useState = React$1.useState,
-	  useEffect = React$1.useEffect,
-	  useLayoutEffect = React$1.useLayoutEffect,
-	  useDebugValue = React$1.useDebugValue;
-	function useSyncExternalStore$2(subscribe, getSnapshot) {
-	  var value = getSnapshot(),
-	    _useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),
-	    inst = _useState[0].inst,
-	    forceUpdate = _useState[1];
-	  useLayoutEffect(
-	    function () {
-	      inst.value = value;
-	      inst.getSnapshot = getSnapshot;
-	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-	    },
-	    [subscribe, value, getSnapshot]
-	  );
-	  useEffect(
-	    function () {
-	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-	      return subscribe(function () {
-	        checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-	      });
-	    },
-	    [subscribe]
-	  );
-	  useDebugValue(value);
-	  return value;
-	}
-	function checkIfSnapshotChanged(inst) {
-	  var latestGetSnapshot = inst.getSnapshot;
-	  inst = inst.value;
-	  try {
-	    var nextValue = latestGetSnapshot();
-	    return !objectIs(inst, nextValue);
-	  } catch (error) {
-	    return !0;
-	  }
-	}
-	function useSyncExternalStore$1(subscribe, getSnapshot) {
-	  return getSnapshot();
-	}
-	var shim =
-	  "undefined" === typeof window ||
-	  "undefined" === typeof window.document ||
-	  "undefined" === typeof window.document.createElement
-	    ? useSyncExternalStore$1
-	    : useSyncExternalStore$2;
-	useSyncExternalStoreShim_production.useSyncExternalStore =
-	  void 0 !== React$1.useSyncExternalStore ? React$1.useSyncExternalStore : shim;
-	return useSyncExternalStoreShim_production;
-}
-
-var useSyncExternalStoreShim_development = {};
-
-/**
- * @license React
- * use-sync-external-store-shim.development.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasRequiredUseSyncExternalStoreShim_development;
-
-function requireUseSyncExternalStoreShim_development () {
-	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
-	hasRequiredUseSyncExternalStoreShim_development = 1;
-	"production" !== process.env.NODE_ENV &&
-	  (function () {
-	    function is(x, y) {
-	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
-	    }
-	    function useSyncExternalStore$2(subscribe, getSnapshot) {
-	      didWarnOld18Alpha ||
-	        void 0 === React$1.startTransition ||
-	        ((didWarnOld18Alpha = !0),
-	        console.error(
-	          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
-	        ));
-	      var value = getSnapshot();
-	      if (!didWarnUncachedGetSnapshot) {
-	        var cachedValue = getSnapshot();
-	        objectIs(value, cachedValue) ||
-	          (console.error(
-	            "The result of getSnapshot should be cached to avoid an infinite loop"
-	          ),
-	          (didWarnUncachedGetSnapshot = !0));
-	      }
-	      cachedValue = useState({
-	        inst: { value: value, getSnapshot: getSnapshot }
-	      });
-	      var inst = cachedValue[0].inst,
-	        forceUpdate = cachedValue[1];
-	      useLayoutEffect(
-	        function () {
-	          inst.value = value;
-	          inst.getSnapshot = getSnapshot;
-	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-	        },
-	        [subscribe, value, getSnapshot]
-	      );
-	      useEffect(
-	        function () {
-	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-	          return subscribe(function () {
-	            checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-	          });
-	        },
-	        [subscribe]
-	      );
-	      useDebugValue(value);
-	      return value;
-	    }
-	    function checkIfSnapshotChanged(inst) {
-	      var latestGetSnapshot = inst.getSnapshot;
-	      inst = inst.value;
-	      try {
-	        var nextValue = latestGetSnapshot();
-	        return !objectIs(inst, nextValue);
-	      } catch (error) {
-	        return !0;
-	      }
-	    }
-	    function useSyncExternalStore$1(subscribe, getSnapshot) {
-	      return getSnapshot();
-	    }
-	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
-	      "function" ===
-	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
-	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-	    var React$1 = React,
-	      objectIs = "function" === typeof Object.is ? Object.is : is,
-	      useState = React$1.useState,
-	      useEffect = React$1.useEffect,
-	      useLayoutEffect = React$1.useLayoutEffect,
-	      useDebugValue = React$1.useDebugValue,
-	      didWarnOld18Alpha = !1,
-	      didWarnUncachedGetSnapshot = !1,
-	      shim =
-	        "undefined" === typeof window ||
-	        "undefined" === typeof window.document ||
-	        "undefined" === typeof window.document.createElement
-	          ? useSyncExternalStore$1
-	          : useSyncExternalStore$2;
-	    useSyncExternalStoreShim_development.useSyncExternalStore =
-	      void 0 !== React$1.useSyncExternalStore ? React$1.useSyncExternalStore : shim;
-	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
-	      "function" ===
-	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
-	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-	  })();
-	return useSyncExternalStoreShim_development;
-}
-
-if (process.env.NODE_ENV === 'production') {
-  shim.exports = requireUseSyncExternalStoreShim_production();
-} else {
-  shim.exports = requireUseSyncExternalStoreShim_development();
-}
-
-var shimExports = shim.exports;
-
-var withSelector = {exports: {}};
-
-var withSelector_production = {};
-
-/**
- * @license React
- * use-sync-external-store-shim/with-selector.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasRequiredWithSelector_production;
-
-function requireWithSelector_production () {
-	if (hasRequiredWithSelector_production) return withSelector_production;
-	hasRequiredWithSelector_production = 1;
-	var React$1 = React,
-	  shim = shimExports;
-	function is(x, y) {
-	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
-	}
-	var objectIs = "function" === typeof Object.is ? Object.is : is,
-	  useSyncExternalStore = shim.useSyncExternalStore,
-	  useRef = React$1.useRef,
-	  useEffect = React$1.useEffect,
-	  useMemo = React$1.useMemo,
-	  useDebugValue = React$1.useDebugValue;
-	withSelector_production.useSyncExternalStoreWithSelector = function (
-	  subscribe,
-	  getSnapshot,
-	  getServerSnapshot,
-	  selector,
-	  isEqual
-	) {
-	  var instRef = useRef(null);
-	  if (null === instRef.current) {
-	    var inst = { hasValue: !1, value: null };
-	    instRef.current = inst;
-	  } else inst = instRef.current;
-	  instRef = useMemo(
-	    function () {
-	      function memoizedSelector(nextSnapshot) {
-	        if (!hasMemo) {
-	          hasMemo = !0;
-	          memoizedSnapshot = nextSnapshot;
-	          nextSnapshot = selector(nextSnapshot);
-	          if (void 0 !== isEqual && inst.hasValue) {
-	            var currentSelection = inst.value;
-	            if (isEqual(currentSelection, nextSnapshot))
-	              return (memoizedSelection = currentSelection);
-	          }
-	          return (memoizedSelection = nextSnapshot);
-	        }
-	        currentSelection = memoizedSelection;
-	        if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
-	        var nextSelection = selector(nextSnapshot);
-	        if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
-	          return (memoizedSnapshot = nextSnapshot), currentSelection;
-	        memoizedSnapshot = nextSnapshot;
-	        return (memoizedSelection = nextSelection);
-	      }
-	      var hasMemo = !1,
-	        memoizedSnapshot,
-	        memoizedSelection,
-	        maybeGetServerSnapshot =
-	          void 0 === getServerSnapshot ? null : getServerSnapshot;
-	      return [
-	        function () {
-	          return memoizedSelector(getSnapshot());
-	        },
-	        null === maybeGetServerSnapshot
-	          ? void 0
-	          : function () {
-	              return memoizedSelector(maybeGetServerSnapshot());
-	            }
-	      ];
-	    },
-	    [getSnapshot, getServerSnapshot, selector, isEqual]
-	  );
-	  var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
-	  useEffect(
-	    function () {
-	      inst.hasValue = !0;
-	      inst.value = value;
-	    },
-	    [value]
-	  );
-	  useDebugValue(value);
-	  return value;
-	};
-	return withSelector_production;
-}
-
-var withSelector_development = {};
-
-/**
- * @license React
- * use-sync-external-store-shim/with-selector.development.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasRequiredWithSelector_development;
-
-function requireWithSelector_development () {
-	if (hasRequiredWithSelector_development) return withSelector_development;
-	hasRequiredWithSelector_development = 1;
-	"production" !== process.env.NODE_ENV &&
-	  (function () {
-	    function is(x, y) {
-	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
-	    }
-	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
-	      "function" ===
-	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
-	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-	    var React$1 = React,
-	      shim = shimExports,
-	      objectIs = "function" === typeof Object.is ? Object.is : is,
-	      useSyncExternalStore = shim.useSyncExternalStore,
-	      useRef = React$1.useRef,
-	      useEffect = React$1.useEffect,
-	      useMemo = React$1.useMemo,
-	      useDebugValue = React$1.useDebugValue;
-	    withSelector_development.useSyncExternalStoreWithSelector = function (
-	      subscribe,
-	      getSnapshot,
-	      getServerSnapshot,
-	      selector,
-	      isEqual
-	    ) {
-	      var instRef = useRef(null);
-	      if (null === instRef.current) {
-	        var inst = { hasValue: !1, value: null };
-	        instRef.current = inst;
-	      } else inst = instRef.current;
-	      instRef = useMemo(
-	        function () {
-	          function memoizedSelector(nextSnapshot) {
-	            if (!hasMemo) {
-	              hasMemo = !0;
-	              memoizedSnapshot = nextSnapshot;
-	              nextSnapshot = selector(nextSnapshot);
-	              if (void 0 !== isEqual && inst.hasValue) {
-	                var currentSelection = inst.value;
-	                if (isEqual(currentSelection, nextSnapshot))
-	                  return (memoizedSelection = currentSelection);
-	              }
-	              return (memoizedSelection = nextSnapshot);
-	            }
-	            currentSelection = memoizedSelection;
-	            if (objectIs(memoizedSnapshot, nextSnapshot))
-	              return currentSelection;
-	            var nextSelection = selector(nextSnapshot);
-	            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
-	              return (memoizedSnapshot = nextSnapshot), currentSelection;
-	            memoizedSnapshot = nextSnapshot;
-	            return (memoizedSelection = nextSelection);
-	          }
-	          var hasMemo = !1,
-	            memoizedSnapshot,
-	            memoizedSelection,
-	            maybeGetServerSnapshot =
-	              void 0 === getServerSnapshot ? null : getServerSnapshot;
-	          return [
-	            function () {
-	              return memoizedSelector(getSnapshot());
-	            },
-	            null === maybeGetServerSnapshot
-	              ? void 0
-	              : function () {
-	                  return memoizedSelector(maybeGetServerSnapshot());
-	                }
-	          ];
-	        },
-	        [getSnapshot, getServerSnapshot, selector, isEqual]
-	      );
-	      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
-	      useEffect(
-	        function () {
-	          inst.hasValue = !0;
-	          inst.value = value;
-	        },
-	        [value]
-	      );
-	      useDebugValue(value);
-	      return value;
-	    };
-	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
-	      "function" ===
-	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
-	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-	  })();
-	return withSelector_development;
-}
-
-if (process.env.NODE_ENV === 'production') {
-  withSelector.exports = requireWithSelector_production();
-} else {
-  withSelector.exports = requireWithSelector_development();
-}
-
-var withSelectorExports = withSelector.exports;
-
-const hooks = [];
-let currentInstance = undefined;
-function getInstance() {
-  return currentInstance;
-}
-function register(hook) {
-  hooks.push(hook);
-}
-function fastComponent(fn) {
-  const FastComponent = (props, forwardedRef) => {
-    const instance = useRenderElement.useRefWithInit(createInstance).current;
-    let result;
-    try {
-      currentInstance = instance;
-      for (const hook of hooks) {
-        hook.before(instance);
-      }
-      result = fn(props, forwardedRef);
-      for (const hook of hooks) {
-        hook.after(instance);
-      }
-      instance.didInitialize = true;
-    } finally {
-      currentInstance = undefined;
-    }
-    return result;
-  };
-  FastComponent.displayName = fn.displayName || fn.name;
-  return FastComponent;
-}
-function fastComponentRef(fn) {
-  return /*#__PURE__*/React__namespace.forwardRef(fastComponent(fn));
-}
-function createInstance() {
-  return {
-    didInitialize: false
-  };
-}
-
-/* Some tests fail in R18 with the raw useSyncExternalStore. It may be possible to make it work
- * but for now we only enable it for R19+. */
-const canUseRawUseSyncExternalStore = useRenderElement.isReactVersionAtLeast(19);
-const useStoreImplementation = canUseRawUseSyncExternalStore ? useStoreFast : useStoreLegacy;
-function useStore(store, selector, a1, a2, a3) {
-  return useStoreImplementation(store, selector, a1, a2, a3);
-}
-function useStoreR19(store, selector, a1, a2, a3) {
-  const getSelection = React__namespace.useCallback(() => selector(store.getSnapshot(), a1, a2, a3), [store, selector, a1, a2, a3]);
-  return shimExports.useSyncExternalStore(store.subscribe, getSelection, getSelection);
-}
-register({
-  before(instance) {
-    instance.syncIndex = 0;
-    if (!instance.didInitialize) {
-      instance.syncTick = 1;
-      instance.syncHooks = [];
-      instance.didChangeStore = true;
-      instance.getSnapshot = () => {
-        let didChange = false;
-        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)) {
-            didChange = true;
-            hook.value = value;
-            hook.didChange = false;
-          }
-        }
-        if (didChange) {
-          instance.syncTick += 1;
-        }
-        return instance.syncTick;
-      };
-    }
-  },
-  after(instance) {
-    if (instance.syncHooks.length > 0) {
-      if (instance.didChangeStore) {
-        instance.didChangeStore = false;
-        instance.subscribe = onStoreChange => {
-          const stores = new Set();
-          for (const hook of instance.syncHooks) {
-            stores.add(hook.store);
-          }
-          const unsubscribes = [];
-          for (const store of stores) {
-            unsubscribes.push(store.subscribe(onStoreChange));
-          }
-          return () => {
-            for (const unsubscribe of unsubscribes) {
-              unsubscribe();
-            }
-          };
-        };
-      }
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      shimExports.useSyncExternalStore(instance.subscribe, instance.getSnapshot, instance.getSnapshot);
-    }
-  }
-});
-function useStoreFast(store, selector, a1, a2, a3) {
-  const instance = getInstance();
-  if (!instance) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useStoreR19(store, selector, a1, a2, a3);
-  }
-  const index = instance.syncIndex;
-  instance.syncIndex += 1;
-  let hook;
-  if (!instance.didInitialize) {
-    hook = {
-      store,
-      selector,
-      a1,
-      a2,
-      a3,
-      value: selector(store.getSnapshot(), a1, a2, a3),
-      didChange: false
-    };
-    instance.syncHooks.push(hook);
-  } else {
-    hook = instance.syncHooks[index];
-    if (hook.store !== store || hook.selector !== selector || !Object.is(hook.a1, a1) || !Object.is(hook.a2, a2) || !Object.is(hook.a3, a3)) {
-      if (hook.store !== store) {
-        instance.didChangeStore = true;
-      }
-      hook.store = store;
-      hook.selector = selector;
-      hook.a1 = a1;
-      hook.a2 = a2;
-      hook.a3 = a3;
-      hook.didChange = true;
-    }
-  }
-  return hook.value;
-}
-function useStoreLegacy(store, selector, a1, a2, a3) {
-  return withSelectorExports.useSyncExternalStoreWithSelector(store.subscribe, store.getSnapshot, store.getSnapshot, state => selector(state, a1, a2, a3));
-}
-
-/**
- * A data store implementation that allows subscribing to state changes and updating the state.
- * It uses an observer pattern to notify subscribers when the state changes.
- */
-class Store {
-  /**
-   * The current state of the store.
-   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
-   * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
-   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
-   *
-   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
-   */
-
-  // Internal state to handle recursive `setState()` calls
-
-  constructor(state) {
-    this.state = state;
-    this.listeners = new Set();
-    this.updateTick = 0;
-  }
-
-  /**
-   * Registers a listener that will be called whenever the store's state changes.
-   *
-   * @param fn The listener function to be called on state changes.
-   * @returns A function to unsubscribe the listener.
-   */
-  subscribe = fn => {
-    this.listeners.add(fn);
-    return () => {
-      this.listeners.delete(fn);
-    };
-  };
-
-  /**
-   * Returns the current state of the store.
-   */
-  getSnapshot = () => {
-    return this.state;
-  };
-
-  /**
-   * Updates the entire store's state and notifies all registered listeners.
-   *
-   * @param newState The new state to set for the store.
-   */
-  setState(newState) {
-    if (this.state === newState) {
-      return;
-    }
-    this.state = newState;
-    this.updateTick += 1;
-    const currentTick = this.updateTick;
-    for (const listener of this.listeners) {
-      if (currentTick !== this.updateTick) {
-        // If the tick has changed, a recursive `setState` call has been made,
-        // and it has already notified all listeners.
-        return;
-      }
-      listener(newState);
-    }
-  }
-
-  /**
-   * Merges the provided changes into the current state and notifies listeners if there are changes.
-   *
-   * @param changes An object containing the changes to apply to the current state.
-   */
-  update(changes) {
-    for (const key in changes) {
-      if (!Object.is(this.state[key], changes[key])) {
-        this.setState({
-          ...this.state,
-          ...changes
-        });
-        return;
-      }
-    }
-  }
-
-  /**
-   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
-   *
-   * @param key The key in the store's state to update.
-   * @param value The new value to set for the specified key.
-   */
-  set(key, value) {
-    if (!Object.is(this.state[key], value)) {
-      this.setState({
-        ...this.state,
-        [key]: value
-      });
-    }
-  }
-
-  /**
-   * Gives the state a new reference and updates all registered listeners.
-   */
-  notifyAll() {
-    const newState = {
-      ...this.state
-    };
-    this.setState(newState);
-  }
-  use(selector, a1, a2, a3) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useStore(this, selector, a1, a2, a3);
-  }
-}
-
-/* False positives - ESLint thinks we're calling a hook from a class component. */
-/* eslint-disable react-hooks/rules-of-hooks */
-
-/**
- * A Store that supports controlled state keys, non-reactive values and provides utility methods for React.
- */
-class ReactStore extends Store {
-  /**
-   * Creates a new ReactStore instance.
-   *
-   * @param state Initial state of the store.
-   * @param context Non-reactive context values.
-   * @param selectors Optional selectors for use with `useState`.
-   */
-  constructor(state, context = {}, selectors) {
-    super(state);
-    this.context = context;
-    this.selectors = selectors;
-  }
-
-  /**
-   * Non-reactive values such as refs, callbacks, etc.
-   */
-
-  /**
-   * Synchronizes a single external value into the store.
-   *
-   * Note that the while the value in `state` is updated immediately, the value returned
-   * by `useState` is updated before the next render (similarly to React's `useState`).
-   */
-  useSyncedValue(key, value) {
-    React__namespace.useDebugValue(key);
-    clamp.useIsoLayoutEffect(() => {
-      if (this.state[key] !== value) {
-        this.set(key, value);
-      }
-    }, [key, value]);
-  }
-
-  /**
-   * Synchronizes a single external value into the store and
-   * cleans it up (sets to `undefined`) on unmount.
-   *
-   * Note that the while the value in `state` is updated immediately, the value returned
-   * by `useState` is updated before the next render (similarly to React's `useState`).
-   */
-  useSyncedValueWithCleanup(key, value) {
-    // eslint-disable-next-line consistent-this
-    const store = this;
-    clamp.useIsoLayoutEffect(() => {
-      if (store.state[key] !== value) {
-        store.set(key, value);
-      }
-      return () => {
-        store.set(key, undefined);
-      };
-    }, [store, key, value]);
-  }
-
-  /**
-   * Synchronizes multiple external values into the store.
-   *
-   * Note that the while the values in `state` are updated immediately, the values returned
-   * by `useState` are updated before the next render (similarly to React's `useState`).
-   */
-  useSyncedValues(statePart) {
-    // eslint-disable-next-line consistent-this
-    const store = this;
-    if (process.env.NODE_ENV !== 'production') {
-      // Check that an object with the same shape is passed on every render
-      React__namespace.useDebugValue(statePart, p => Object.keys(p));
-      const keys = React__namespace.useRef(Object.keys(statePart)).current;
-      const nextKeys = Object.keys(statePart);
-      if (keys.length !== nextKeys.length || keys.some((key, index) => key !== nextKeys[index])) {
-        console.error('ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.');
-      }
-    }
-    const dependencies = Object.values(statePart);
-    clamp.useIsoLayoutEffect(() => {
-      store.update(statePart);
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [store, ...dependencies]);
-  }
-
-  /**
-   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
-   * is non-undefined, the store's state at `key` is updated to match `controlled`.
-   */
-  useControlledProp(key, controlled) {
-    React__namespace.useDebugValue(key);
-    const isControlled = controlled !== undefined;
-    clamp.useIsoLayoutEffect(() => {
-      if (isControlled && !Object.is(this.state[key], controlled)) {
-        // Set the internal state to match the controlled value.
-        super.setState({
-          ...this.state,
-          [key]: controlled
-        });
-      }
-    }, [key, controlled, isControlled]);
-    if (process.env.NODE_ENV !== 'production') {
-      // eslint-disable-next-line
-      const cache = this.controlledValues ??= new Map();
-      if (!cache.has(key)) {
-        cache.set(key, isControlled);
-      }
-      const previouslyControlled = cache.get(key);
-      if (previouslyControlled !== undefined && previouslyControlled !== isControlled) {
-        console.error(`A component is changing the ${isControlled ? '' : 'un'}controlled state of ${key.toString()} to be ${isControlled ? 'un' : ''}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
-      }
-    }
-  }
-
-  /** Gets the current value from the store using a selector with the provided key.
-   *
-   * @param key Key of the selector to use.
-   */
-
-  select(key, a1, a2, a3) {
-    const selector = this.selectors[key];
-    return selector(this.state, a1, a2, a3);
-  }
-
-  /**
-   * Returns a value from the store's state using a selector function.
-   * Used to subscribe to specific parts of the state.
-   * This methods causes a rerender whenever the selected state changes.
-   *
-   * @param key Key of the selector to use.
-   */
-
-  useState(key, a1, a2, a3) {
-    React__namespace.useDebugValue(key);
-    return useStore(this, this.selectors[key], a1, a2, a3);
-  }
-
-  /**
-   * Wraps a function with `useStableCallback` to ensure it has a stable reference
-   * and assigns it to the context.
-   *
-   * @param key Key of the event callback. Must be a function in the context.
-   * @param fn Function to assign.
-   */
-  useContextCallback(key, fn) {
-    React__namespace.useDebugValue(key);
-    const stableFunction = clamp.useStableCallback(fn ?? useRenderElement.NOOP);
-    this.context[key] = stableFunction;
-  }
-
-  /**
-   * Returns a stable setter function for a specific key in the store's state.
-   * It's commonly used to pass as a ref callback to React elements.
-   *
-   * @param key Key of the state to set.
-   */
-  useStateSetter(key) {
-    const ref = React__namespace.useRef(undefined);
-    if (ref.current === undefined) {
-      ref.current = value => {
-        this.set(key, value);
-      };
-    }
-    return ref.current;
-  }
-
-  /**
-   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
-   *
-   * @param key Key of the selector to observe.
-   * @param listener Listener function called when the selector result changes.
-   */
-
-  observe(selector, listener) {
-    let selectFn;
-    if (typeof selector === 'function') {
-      selectFn = selector;
-    } else {
-      selectFn = this.selectors[selector];
-    }
-    let prevValue = selectFn(this.state);
-    listener(prevValue, prevValue, this);
-    return this.subscribe(nextState => {
-      const nextValue = selectFn(nextState);
-      if (!Object.is(prevValue, nextValue)) {
-        const oldValue = prevValue;
-        prevValue = nextValue;
-        listener(nextValue, oldValue, this);
-      }
-    });
-  }
-}
-
-/* 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)]);
-}
-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);
-    }
-  }
-  return allAncestors;
-}
-
-function isDifferentGridRow(index, cols, prevRow) {
-  return Math.floor(index / cols) !== prevRow;
-}
-function isIndexOutOfListBounds(listRef, index) {
-  return index < 0 || index >= listRef.current.length;
-}
-function getMinListIndex(listRef, disabledIndices) {
-  return findNonDisabledListIndex(listRef, {
-    disabledIndices
-  });
-}
-function getMaxListIndex(listRef, disabledIndices) {
-  return findNonDisabledListIndex(listRef, {
-    decrement: true,
-    startingIndex: listRef.current.length,
-    disabledIndices
-  });
-}
-function findNonDisabledListIndex(listRef, {
-  startingIndex = -1,
-  decrement = false,
-  disabledIndices,
-  amount = 1
-} = {}) {
-  let index = startingIndex;
-  do {
-    index += decrement ? -amount : amount;
-  } while (index >= 0 && index <= listRef.current.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));
-  return index;
-}
-function getGridNavigatedIndex(listRef, {
-  event,
-  orientation,
-  loopFocus,
-  rtl,
-  cols,
-  disabledIndices,
-  minIndex,
-  maxIndex,
-  prevIndex,
-  stopEvent: stop = false
-}) {
-  let nextIndex = prevIndex;
-  let verticalDirection;
-  if (event.key === clamp.ARROW_UP) {
-    verticalDirection = 'up';
-  } else if (event.key === clamp.ARROW_DOWN) {
-    verticalDirection = 'down';
-  }
-  if (verticalDirection) {
-    // -------------------------------------------------------------------------
-    // Detect row structure only when handling vertical navigation. This keeps
-    // the non-vertical key paths free from row inference work.
-    // -------------------------------------------------------------------------
-    const rows = [];
-    const rowIndexMap = [];
-    let hasRoleRow = false;
-    let visibleItemCount = 0;
-    {
-      let currentRowEl = null;
-      let currentRowIndex = -1;
-      listRef.current.forEach((el, idx) => {
-        if (el == null) {
-          return;
-        }
-        visibleItemCount += 1;
-        const rowEl = el.closest('[role="row"]');
-        if (rowEl) {
-          hasRoleRow = true;
-        }
-        if (rowEl !== currentRowEl || currentRowIndex === -1) {
-          currentRowEl = rowEl;
-          currentRowIndex += 1;
-          rows[currentRowIndex] = [];
-        }
-        rows[currentRowIndex].push(idx);
-        rowIndexMap[idx] = currentRowIndex;
-      });
-    }
-    let hasDomRows = false;
-    let inferredDomCols = 0;
-    if (hasRoleRow) {
-      for (const row of rows) {
-        const rowLength = row.length;
-        if (rowLength > inferredDomCols) {
-          inferredDomCols = rowLength;
-        }
-        if (rowLength !== cols) {
-          hasDomRows = true;
-        }
-      }
-    }
-    const hasVirtualizedGaps = hasDomRows && visibleItemCount < listRef.current.length;
-    const verticalCols = inferredDomCols || cols;
-    const navigateVertically = direction => {
-      if (!hasDomRows || prevIndex === -1) {
-        return undefined;
-      }
-      const currentRow = rowIndexMap[prevIndex];
-      if (currentRow == null) {
-        return undefined;
-      }
-      const colInRow = rows[currentRow].indexOf(prevIndex);
-      const step = direction === 'up' ? -1 : 1;
-      for (let nextRow = currentRow + step, i = 0; i < rows.length; i += 1, nextRow += step) {
-        if (nextRow < 0 || nextRow >= rows.length) {
-          if (!loopFocus || hasVirtualizedGaps) {
-            return undefined;
-          }
-          nextRow = nextRow < 0 ? rows.length - 1 : 0;
-        }
-        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)) {
-            return candidate;
-          }
-        }
-      }
-      return undefined;
-    };
-    const navigateVerticallyWithInferredRows = direction => {
-      if (!hasVirtualizedGaps || prevIndex === -1) {
-        return undefined;
-      }
-      const colInRow = prevIndex % verticalCols;
-      const rowStep = direction === 'up' ? -verticalCols : verticalCols;
-      const lastRowStart = maxIndex - maxIndex % verticalCols;
-      const rowCount = index_esm.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) {
-            return undefined;
-          }
-          rowStart = rowStart < 0 ? lastRowStart : 0;
-        }
-        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)) {
-            return candidate;
-          }
-        }
-      }
-      return undefined;
-    };
-    if (stop) {
-      clamp.stopEvent(event);
-    }
-    const verticalCandidate = navigateVertically(verticalDirection) ?? navigateVerticallyWithInferredRows(verticalDirection);
-    if (verticalCandidate !== undefined) {
-      nextIndex = verticalCandidate;
-    } else if (prevIndex === -1) {
-      nextIndex = verticalDirection === 'up' ? maxIndex : minIndex;
-    } else {
-      nextIndex = findNonDisabledListIndex(listRef, {
-        startingIndex: prevIndex,
-        amount: verticalCols,
-        decrement: verticalDirection === 'up',
-        disabledIndices
-      });
-      if (loopFocus) {
-        if (verticalDirection === 'up' && (prevIndex - verticalCols < minIndex || nextIndex < 0)) {
-          const col = prevIndex % verticalCols;
-          const maxCol = maxIndex % verticalCols;
-          const offset = maxIndex - (maxCol - col);
-          if (maxCol === col) {
-            nextIndex = maxIndex;
-          } else {
-            nextIndex = maxCol > col ? offset : offset - verticalCols;
-          }
-        }
-        if (verticalDirection === 'down' && prevIndex + verticalCols > maxIndex) {
-          nextIndex = findNonDisabledListIndex(listRef, {
-            startingIndex: prevIndex % verticalCols - verticalCols,
-            amount: verticalCols,
-            disabledIndices
-          });
-        }
-      }
-    }
-    if (isIndexOutOfListBounds(listRef, nextIndex)) {
-      nextIndex = prevIndex;
-    }
-  }
-
-  // Remains on the same row/column.
-  if (orientation === 'both') {
-    const prevRow = index_esm.floor(prevIndex / cols);
-    if (event.key === (rtl ? clamp.ARROW_LEFT : clamp.ARROW_RIGHT)) {
-      if (stop) {
-        clamp.stopEvent(event);
-      }
-      if (prevIndex % cols !== cols - 1) {
-        nextIndex = findNonDisabledListIndex(listRef, {
-          startingIndex: prevIndex,
-          disabledIndices
-        });
-        if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
-          nextIndex = findNonDisabledListIndex(listRef, {
-            startingIndex: prevIndex - prevIndex % cols - 1,
-            disabledIndices
-          });
-        }
-      } else if (loopFocus) {
-        nextIndex = findNonDisabledListIndex(listRef, {
-          startingIndex: prevIndex - prevIndex % cols - 1,
-          disabledIndices
-        });
-      }
-      if (isDifferentGridRow(nextIndex, cols, prevRow)) {
-        nextIndex = prevIndex;
-      }
-    }
-    if (event.key === (rtl ? clamp.ARROW_RIGHT : clamp.ARROW_LEFT)) {
-      if (stop) {
-        clamp.stopEvent(event);
-      }
-      if (prevIndex % cols !== 0) {
-        nextIndex = findNonDisabledListIndex(listRef, {
-          startingIndex: prevIndex,
-          decrement: true,
-          disabledIndices
-        });
-        if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
-          nextIndex = findNonDisabledListIndex(listRef, {
-            startingIndex: prevIndex + (cols - prevIndex % cols),
-            decrement: true,
-            disabledIndices
-          });
-        }
-      } else if (loopFocus) {
-        nextIndex = findNonDisabledListIndex(listRef, {
-          startingIndex: prevIndex + (cols - prevIndex % cols),
-          decrement: true,
-          disabledIndices
-        });
-      }
-      if (isDifferentGridRow(nextIndex, cols, prevRow)) {
-        nextIndex = prevIndex;
-      }
-    }
-    const lastRow = index_esm.floor(maxIndex / cols) === prevRow;
-    if (isIndexOutOfListBounds(listRef, nextIndex)) {
-      if (loopFocus && lastRow) {
-        nextIndex = event.key === (rtl ? clamp.ARROW_RIGHT : clamp.ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {
-          startingIndex: prevIndex - prevIndex % cols - 1,
-          disabledIndices
-        });
-      } else {
-        nextIndex = prevIndex;
-      }
-    }
-  }
-  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) {
-  const isExplicitlyDisabled = typeof disabledIndices === 'function' ? disabledIndices(index) : disabledIndices?.includes(index) ?? false;
-  if (isExplicitlyDisabled) {
-    return true;
-  }
-  const element = listRef.current[index];
-  if (!element) {
-    return false;
-  }
-  if (!isElementVisible(element)) {
-    return true;
-  }
-  return !disabledIndices && (element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true');
-}
-function isElementVisible(element) {
-  return floatingUi_utils_dom.getComputedStyle(element).display !== 'none';
-}
-
-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 active = clamp.activeElement(clamp.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(clamp.ownerDocument(referenceElement).body, 1) || referenceElement;
-}
-function getPreviousTabbable(referenceElement) {
-  return getTabbableIn(clamp.ownerDocument(referenceElement).body, -1) || referenceElement;
-}
-function getTabbableNearElement(referenceElement, dir) {
-  if (!referenceElement) {
-    return null;
-  }
-  const list = index_esm.tabbable(clamp.ownerDocument(referenceElement).body, getTabbableOptions());
-  const elementCount = list.length;
-  if (elementCount === 0) {
-    return null;
-  }
-  const index = list.indexOf(referenceElement);
-  if (index === -1) {
-    return null;
-  }
-  const nextIndex = (index + dir + elementCount) % elementCount;
-  return list[nextIndex];
-}
-function getTabbableAfterElement(referenceElement) {
-  return getTabbableNearElement(referenceElement, 1);
-}
-function getTabbableBeforeElement(referenceElement) {
-  return getTabbableNearElement(referenceElement, -1);
-}
-function isOutsideEvent(event, container) {
-  const containerElement = container || event.currentTarget;
-  const relatedTarget = event.relatedTarget;
-  return !relatedTarget || !clamp.contains(containerElement, relatedTarget);
-}
-function disableFocusInside(container) {
-  const tabbableElements = index_esm.tabbable(container, getTabbableOptions());
-  tabbableElements.forEach(element => {
-    element.dataset.tabindex = element.getAttribute('tabindex') || '';
-    element.setAttribute('tabindex', '-1');
-  });
-}
-function enableFocusInside(container) {
-  const elements = container.querySelectorAll('[data-tabindex]');
-  elements.forEach(element => {
-    const tabindex = element.dataset.tabindex;
-    delete element.dataset.tabindex;
-    if (tabindex) {
-      element.setAttribute('tabindex', tabindex);
-    } else {
-      element.removeAttribute('tabindex');
-    }
-  });
-}
-
-const 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 FocusGuard = /*#__PURE__*/React__namespace.forwardRef(function FocusGuard(props, ref) {
-  const [role, setRole] = React__namespace.useState();
-  clamp.useIsoLayoutEffect(() => {
-    if (clamp.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');
-    }
-  }, []);
-  const restProps = {
-    tabIndex: 0,
-    // Role is only for VoiceOver
-    role
-  };
-  return /*#__PURE__*/jsxRuntime.jsx("span", {
-    ...props,
-    ref: ref,
-    style: clamp.visuallyHidden,
-    "aria-hidden": role ? undefined : true,
-    ...restProps,
-    "data-base-ui-focus-guard": ""
-  });
-});
-if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
-
-function createAttribute(name) {
-  return `data-base-ui-${name}`;
-}
-
-let rafId = 0;
-function enqueueFocus(el, options = {}) {
-  const {
-    preventScroll = false,
-    cancelPrevious = true,
-    sync = false
-  } = options;
-  if (cancelPrevious) {
-    cancelAnimationFrame(rafId);
-  }
-  const exec = () => el?.focus({
-    preventScroll
-  });
-  if (sync) {
-    exec();
-  } else {
-    rafId = requestAnimationFrame(exec);
-  }
-}
-
-// Modified to add conditional `aria-hidden` support:
-// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts
-const counters = {
-  inert: new WeakMap(),
-  'aria-hidden': new WeakMap()
-};
-const markerName = 'data-base-ui-inert';
-const uncontrolledElementsSets = {
-  inert: new WeakSet(),
-  'aria-hidden': new WeakSet()
-};
-let markerCounterMap = new WeakMap();
-let lockCount = 0;
-function getUncontrolledElementsSet(controlAttribute) {
-  return uncontrolledElementsSets[controlAttribute];
-}
-function unwrapHost(node) {
-  if (!node) {
-    return null;
-  }
-  return floatingUi_utils_dom.isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
-}
-const correctElements = (parent, targets) => targets.map(target => {
-  if (parent.contains(target)) {
-    return target;
-  }
-  const correctedTarget = unwrapHost(target);
-  if (parent.contains(correctedTarget)) {
-    return correctedTarget;
-  }
-  return null;
-}).filter(x => x != null);
-const buildKeepSet = targets => {
-  const keep = new Set();
-  targets.forEach(target => {
-    let node = target;
-    while (node && !keep.has(node)) {
-      keep.add(node);
-      node = node.parentNode;
-    }
-  });
-  return keep;
-};
-const collectOutsideElements = (root, keepElements, stopElements) => {
-  const outside = [];
-  const walk = parent => {
-    if (!parent || stopElements.has(parent)) {
-      return;
-    }
-    Array.from(parent.children).forEach(node => {
-      if (floatingUi_utils_dom.getNodeName(node) === 'script') {
-        return;
-      }
-      if (keepElements.has(node)) {
-        walk(node);
-      } else {
-        outside.push(node);
-      }
-    });
-  };
-  walk(root);
-  return outside;
-};
-function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert, {
-  mark = true,
-  markerIgnoreElements = []
-}) {
-  // eslint-disable-next-line no-nested-ternary
-  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;
-  let counterMap = null;
-  let uncontrolledElementsSet = null;
-  const avoidElements = correctElements(body, uncorrectedAvoidElements);
-  const markerIgnoreTargets = mark ? correctElements(body, markerIgnoreElements) : [];
-  const markerIgnoreSet = new Set(markerIgnoreTargets);
-  const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)).filter(target => !markerIgnoreSet.has(target)) : [];
-  const hiddenElements = [];
-  const markedElements = [];
-  if (controlAttribute) {
-    const map = counters[controlAttribute];
-    const currentUncontrolledElementsSet = getUncontrolledElementsSet(controlAttribute);
-    uncontrolledElementsSet = currentUncontrolledElementsSet;
-    counterMap = map;
-    const ariaLiveElements = correctElements(body, Array.from(body.querySelectorAll('[aria-live]')));
-    const controlElements = avoidElements.concat(ariaLiveElements);
-    const controlTargets = collectOutsideElements(body, buildKeepSet(controlElements), new Set(controlElements));
-    controlTargets.forEach(node => {
-      const attr = node.getAttribute(controlAttribute);
-      const alreadyHidden = attr !== null && attr !== 'false';
-      const counterValue = (map.get(node) || 0) + 1;
-      map.set(node, counterValue);
-      hiddenElements.push(node);
-      if (counterValue === 1 && alreadyHidden) {
-        currentUncontrolledElementsSet.add(node);
-      }
-      if (!alreadyHidden) {
-        node.setAttribute(controlAttribute, controlAttribute === 'inert' ? '' : 'true');
-      }
-    });
-  }
-  if (mark) {
-    markerTargets.forEach(node => {
-      const markerValue = (markerCounterMap.get(node) || 0) + 1;
-      markerCounterMap.set(node, markerValue);
-      markedElements.push(node);
-      if (markerValue === 1) {
-        node.setAttribute(markerName, '');
-      }
-    });
-  }
-  lockCount += 1;
-  return () => {
-    if (counterMap) {
-      hiddenElements.forEach(element => {
-        const currentCounterValue = counterMap.get(element) || 0;
-        const counterValue = currentCounterValue - 1;
-        counterMap.set(element, counterValue);
-        if (!counterValue) {
-          if (!uncontrolledElementsSet?.has(element) && controlAttribute) {
-            element.removeAttribute(controlAttribute);
-          }
-          uncontrolledElementsSet?.delete(element);
-        }
-      });
-    }
-    if (mark) {
-      markedElements.forEach(element => {
-        const markerValue = (markerCounterMap.get(element) || 0) - 1;
-        markerCounterMap.set(element, markerValue);
-        if (!markerValue) {
-          element.removeAttribute(markerName);
-        }
-      });
-    }
-    lockCount -= 1;
-    if (!lockCount) {
-      counters.inert = new WeakMap();
-      counters['aria-hidden'] = new WeakMap();
-      uncontrolledElementsSets.inert = new WeakSet();
-      uncontrolledElementsSets['aria-hidden'] = new WeakSet();
-      markerCounterMap = new WeakMap();
-    }
-  };
-}
-function markOthers(avoidElements, options = {}) {
-  const {
-    ariaHidden = false,
-    inert = false,
-    mark = true,
-    markerIgnoreElements = []
-  } = options;
-  const body = clamp.ownerDocument(avoidElements[0]).body;
-  return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, {
-    mark,
-    markerIgnoreElements
-  });
-}
-
-const PortalContext = /*#__PURE__*/React__namespace.createContext(null);
-if (process.env.NODE_ENV !== "production") PortalContext.displayName = "PortalContext";
-const usePortalContext = () => React__namespace.useContext(PortalContext);
-const attr = createAttribute('portal');
-function useFloatingPortalNode(props = {}) {
-  const {
-    ref,
-    container: containerProp,
-    componentProps = useRenderElement.EMPTY_OBJECT,
-    elementProps
-  } = props;
-  const uniqueId = clamp.useId();
-  const portalContext = usePortalContext();
-  const parentPortalNode = portalContext?.portalNode;
-  const [containerElement, setContainerElement] = React__namespace.useState(null);
-  const [portalNode, setPortalNode] = React__namespace.useState(null);
-  const setPortalNodeRef = clamp.useStableCallback(node => {
-    if (node !== null) {
-      // the useIsoLayoutEffect below watching containerProp / parentPortalNode
-      // sets setPortalNode(null) when the container becomes null or changes.
-      // So even though the ref callback now ignores null, the portal node still gets cleared.
-      setPortalNode(node);
-    }
-  });
-  const containerRef = React__namespace.useRef(null);
-  clamp.useIsoLayoutEffect(() => {
-    // Wait for the container to be resolved if explicitly `null`.
-    if (containerProp === null) {
-      if (containerRef.current) {
-        containerRef.current = null;
-        setPortalNode(null);
-        setContainerElement(null);
-      }
-      return;
-    }
-
-    // React 17 does not use React.useId().
-    if (uniqueId == null) {
-      return;
-    }
-    const resolvedContainer = (containerProp && (floatingUi_utils_dom.isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
-    if (resolvedContainer == null) {
-      if (containerRef.current) {
-        containerRef.current = null;
-        setPortalNode(null);
-        setContainerElement(null);
-      }
-      return;
-    }
-    if (containerRef.current !== resolvedContainer) {
-      containerRef.current = resolvedContainer;
-      setPortalNode(null);
-      setContainerElement(resolvedContainer);
-    }
-  }, [containerProp, parentPortalNode, uniqueId]);
-  const portalElement = useRenderElement.useRenderElement('div', componentProps, {
-    ref: [ref, setPortalNodeRef],
-    props: [{
-      id: uniqueId,
-      [attr]: ''
-    }, elementProps]
-  });
-
-  // This `createPortal` call injects `portalElement` into the `container`.
-  // Another call inside `FloatingPortal`/`FloatingPortalLite` then injects the children into `portalElement`.
-  const portalSubtree = containerElement && portalElement ? /*#__PURE__*/ReactDOM__namespace.createPortal(portalElement, containerElement) : null;
-  return {
-    portalNode,
-    portalSubtree
-  };
-}
-
-/**
- * Portals the floating element into a given container element — by default,
- * outside of the app root and into the body.
- * This is necessary to ensure the floating element can appear outside any
- * potential parent containers that cause clipping (such as `overflow: hidden`),
- * while retaining its location in the React tree.
- * @see https://floating-ui.com/docs/FloatingPortal
- * @internal
- */
-const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function FloatingPortal(componentProps, forwardedRef) {
-  const {
-    children,
-    container,
-    className,
-    render,
-    renderGuards,
-    ...elementProps
-  } = componentProps;
-  const {
-    portalNode,
-    portalSubtree
-  } = useFloatingPortalNode({
-    container,
-    ref: forwardedRef,
-    componentProps,
-    elementProps
-  });
-  const beforeOutsideRef = React__namespace.useRef(null);
-  const afterOutsideRef = React__namespace.useRef(null);
-  const beforeInsideRef = React__namespace.useRef(null);
-  const afterInsideRef = React__namespace.useRef(null);
-  const [focusManagerState, setFocusManagerState] = React__namespace.useState(null);
-  const modal = focusManagerState?.modal;
-  const open = focusManagerState?.open;
-  const shouldRenderGuards = typeof renderGuards === 'boolean' ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
-
-  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx
-  React__namespace.useEffect(() => {
-    if (!portalNode || modal) {
-      return undefined;
-    }
-
-    // Make sure elements inside the portal element are tabbable only when the
-    // portal has already been focused, either by tabbing into a focus trap
-    // 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);
-      }
-    }
-
-    // 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);
-    };
-  }, [portalNode, modal]);
-  React__namespace.useEffect(() => {
-    if (!portalNode || open) {
-      return;
-    }
-    enableFocusInside(portalNode);
-  }, [open, portalNode]);
-  const portalContextValue = React__namespace.useMemo(() => ({
-    beforeOutsideRef,
-    afterOutsideRef,
-    beforeInsideRef,
-    afterInsideRef,
-    portalNode,
-    setFocusManagerState
-  }), [portalNode]);
-  return /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
-    children: [portalSubtree, /*#__PURE__*/jsxRuntime.jsxs(PortalContext.Provider, {
-      value: portalContextValue,
-      children: [shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
-        "data-type": "outside",
-        ref: beforeOutsideRef,
-        onFocus: event => {
-          if (isOutsideEvent(event, portalNode)) {
-            beforeInsideRef.current?.focus();
-          } else {
-            const domReference = focusManagerState ? focusManagerState.domReference : null;
-            const prevTabbable = getPreviousTabbable(domReference);
-            prevTabbable?.focus();
-          }
-        }
-      }), shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx("span", {
-        "aria-owns": portalNode.id,
-        style: ownerVisuallyHidden
-      }), portalNode && /*#__PURE__*/ReactDOM__namespace.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
-        "data-type": "outside",
-        ref: afterOutsideRef,
-        onFocus: event => {
-          if (isOutsideEvent(event, portalNode)) {
-            afterInsideRef.current?.focus();
-          } else {
-            const domReference = focusManagerState ? focusManagerState.domReference : null;
-            const nextTabbable = getNextTabbable(domReference);
-            nextTabbable?.focus();
-            if (focusManagerState?.closeOnFocusOut) {
-              focusManagerState?.onOpenChange(false, clamp.createChangeEventDetails(clamp.focusOut, event.nativeEvent));
-            }
-          }
-        }
-      })]
-    })]
-  });
-});
-if (process.env.NODE_ENV !== "production") FloatingPortal.displayName = "FloatingPortal";
-
-function createEventEmitter() {
-  const map = new Map();
-  return {
-    emit(event, data) {
-      map.get(event)?.forEach(listener => listener(data));
-    },
-    on(event, listener) {
-      if (!map.has(event)) {
-        map.set(event, new Set());
-      }
-      map.get(event).add(listener);
-    },
-    off(event, listener) {
-      map.get(event)?.delete(listener);
-    }
-  };
-}
-
-/**
- * Stores and manages floating elements in a tree structure.
- * This is a backing store for the `FloatingTree` component.
- */
-class FloatingTreeStore {
-  nodesRef = {
-    current: []
-  };
-  events = createEventEmitter();
-  addNode(node) {
-    this.nodesRef.current.push(node);
-  }
-  removeNode(node) {
-    const index = this.nodesRef.current.findIndex(n => n === node);
-    if (index !== -1) {
-      this.nodesRef.current.splice(index, 1);
-    }
-  }
-}
-
-const FloatingNodeContext = /*#__PURE__*/React__namespace.createContext(null);
-if (process.env.NODE_ENV !== "production") FloatingNodeContext.displayName = "FloatingNodeContext";
-const FloatingTreeContext = /*#__PURE__*/React__namespace.createContext(null);
-
-/**
- * Returns the parent node id for nested floating elements, if available.
- * Returns `null` for top-level floating elements.
- */
-if (process.env.NODE_ENV !== "production") FloatingTreeContext.displayName = "FloatingTreeContext";
-const useFloatingParentNodeId = () => React__namespace.useContext(FloatingNodeContext)?.id || null;
-
-/**
- * Returns the nearest floating tree context, if available.
- */
-const useFloatingTree = externalTree => {
-  const contextTree = React__namespace.useContext(FloatingTreeContext);
-  return externalTree ?? contextTree;
-};
-
-/**
- * Registers a node into the `FloatingTree`, returning its id.
- * @see https://floating-ui.com/docs/FloatingTree
- */
-function useFloatingNodeId(externalTree) {
-  const id = clamp.useId();
-  const tree = useFloatingTree(externalTree);
-  const parentId = useFloatingParentNodeId();
-  clamp.useIsoLayoutEffect(() => {
-    if (!id) {
-      return undefined;
-    }
-    const node = {
-      id,
-      parentId
-    };
-    tree?.addNode(node);
-    return () => {
-      tree?.removeNode(node);
-    };
-  }, [tree, id, parentId]);
-  return id;
-}
-/**
- * Provides parent node context for nested floating elements.
- * @see https://floating-ui.com/docs/FloatingTree
- * @internal
- */
-function FloatingNode(props) {
-  const {
-    children,
-    id
-  } = props;
-  const parentId = useFloatingParentNodeId();
-  return /*#__PURE__*/jsxRuntime.jsx(FloatingNodeContext.Provider, {
-    value: React__namespace.useMemo(() => ({
-      id,
-      parentId
-    }), [id, parentId]),
-    children: children
-  });
-}
-/**
- * Provides context for nested floating elements when they are not children of
- * each other on the DOM.
- * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:
- * - The `bubbles` option in the `useDismiss()` Hook
- * - Nested virtual list navigation
- * - Nested floating elements that each open on hover
- * - Custom communication between parent and child floating elements
- * @see https://floating-ui.com/docs/FloatingTree
- * @internal
- */
-function FloatingTree(props) {
-  const {
-    children,
-    externalTree
-  } = props;
-  const tree = useRenderElement.useRefWithInit(() => externalTree ?? new FloatingTreeStore()).current;
-  return /*#__PURE__*/jsxRuntime.jsx(FloatingTreeContext.Provider, {
-    value: tree,
-    children: children
-  });
-}
-
-function getEventType(event, lastInteractionType) {
-  const win = floatingUi_utils_dom.getWindow(event.target);
-  if (event instanceof win.KeyboardEvent) {
-    return 'keyboard';
-  }
-  if (event instanceof win.FocusEvent) {
-    // Focus events can be caused by a preceding pointer interaction (e.g., focusout on outside press).
-    // Prefer the last known pointer type if provided, else treat as keyboard.
-    return lastInteractionType || 'keyboard';
-  }
-  if ('pointerType' in event) {
-    return event.pointerType || 'keyboard';
-  }
-  if ('touches' in event) {
-    return 'touch';
-  }
-  if (event instanceof win.MouseEvent) {
-    // onClick events may not contain pointer events, and will fall through to here
-    return lastInteractionType || (event.detail === 0 ? 'keyboard' : 'mouse');
-  }
-  return '';
-}
-const LIST_LIMIT = 20;
-let previouslyFocusedElements = [];
-function clearDisconnectedPreviouslyFocusedElements() {
-  previouslyFocusedElements = previouslyFocusedElements.filter(entry => {
-    return entry.deref()?.isConnected;
-  });
-}
-function addPreviouslyFocusedElement(element) {
-  clearDisconnectedPreviouslyFocusedElements();
-  if (element && floatingUi_utils_dom.getNodeName(element) !== 'body') {
-    previouslyFocusedElements.push(new WeakRef(element));
-    if (previouslyFocusedElements.length > LIST_LIMIT) {
-      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
-    }
-  }
-}
-function getPreviouslyFocusedElement() {
-  clearDisconnectedPreviouslyFocusedElements();
-  return previouslyFocusedElements[previouslyFocusedElements.length - 1]?.deref();
-}
-function getFirstTabbableElement(container) {
-  if (!container) {
-    return null;
-  }
-  const tabbableOptions = getTabbableOptions();
-  if (index_esm.isTabbable(container, tabbableOptions)) {
-    return container;
-  }
-  return index_esm.tabbable(container, tabbableOptions)[0] || container;
-}
-function isFocusable(element) {
-  if (!element || !element.isConnected) {
-    return false;
-  }
-  if (typeof element.checkVisibility === 'function') {
-    return element.checkVisibility();
-  }
-  return isElementVisible(element);
-}
-function handleTabIndex(floatingFocusElement, orderRef) {
-  if (!orderRef.current.includes('floating') && !floatingFocusElement.getAttribute('role')?.includes('dialog')) {
-    return;
-  }
-  const options = getTabbableOptions();
-  const focusableElements = index_esm.focusable(floatingFocusElement, options);
-  const tabbableContent = focusableElements.filter(element => {
-    const dataTabIndex = element.getAttribute('data-tabindex') || '';
-    return index_esm.isTabbable(element, options) || element.hasAttribute('data-tabindex') && !dataTabIndex.startsWith('-');
-  });
-  const tabIndex = floatingFocusElement.getAttribute('tabindex');
-  if (orderRef.current.includes('floating') || tabbableContent.length === 0) {
-    if (tabIndex !== '0') {
-      floatingFocusElement.setAttribute('tabindex', '0');
-    }
-  } else if (tabIndex !== '-1' || floatingFocusElement.hasAttribute('data-tabindex') && floatingFocusElement.getAttribute('data-tabindex') !== '-1') {
-    floatingFocusElement.setAttribute('tabindex', '-1');
-    floatingFocusElement.setAttribute('data-tabindex', '-1');
-  }
-}
-/**
- * Provides focus management for the floating element.
- * @see https://floating-ui.com/docs/FloatingFocusManager
- * @internal
- */
-function FloatingFocusManager(props) {
-  const {
-    context,
-    children,
-    disabled = false,
-    initialFocus = true,
-    returnFocus = true,
-    restoreFocus = false,
-    modal = true,
-    closeOnFocusOut = true,
-    openInteractionType = '',
-    nextFocusableElement,
-    previousFocusableElement,
-    beforeContentFocusGuardRef,
-    externalTree,
-    getInsideElements
-  } = props;
-  const store = 'rootStore' in context ? context.rootStore : context;
-  const open = store.useState('open');
-  const domReference = store.useState('domReferenceElement');
-  const floating = store.useState('floatingElement');
-  const {
-    events,
-    dataRef
-  } = store.context;
-  const getNodeId = clamp.useStableCallback(() => dataRef.current.floatingContext?.nodeId);
-  const ignoreInitialFocus = initialFocus === false;
-  // If the reference is a combobox and is typeable (e.g. input/textarea),
-  // there are different focus semantics. The guards should not be rendered, but
-  // aria-hidden should be applied to all nodes still. Further, the visually
-  // hidden dismiss button should only appear at the end of the list, not the
-  // start.
-  const isUntrappedTypeableCombobox = clamp.isTypeableCombobox(domReference) && ignoreInitialFocus;
-  const orderRef = React__namespace.useRef(['content']);
-  const initialFocusRef = clamp.useValueAsRef(initialFocus);
-  const returnFocusRef = clamp.useValueAsRef(returnFocus);
-  const openInteractionTypeRef = clamp.useValueAsRef(openInteractionType);
-  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 closeTypeRef = React__namespace.useRef('');
-  const lastInteractionTypeRef = React__namespace.useRef('');
-  const beforeGuardRef = React__namespace.useRef(null);
-  const afterGuardRef = React__namespace.useRef(null);
-  const mergedBeforeGuardRef = useRenderElement.useMergedRefs(beforeGuardRef, beforeContentFocusGuardRef, portalContext?.beforeInsideRef);
-  const mergedAfterGuardRef = useRenderElement.useMergedRefs(afterGuardRef, portalContext?.afterInsideRef);
-  const blurTimeout = clamp.useTimeout();
-  const pointerDownTimeout = clamp.useTimeout();
-  const restoreFocusFrame = clamp.useAnimationFrame();
-  const isInsidePortal = portalContext != null;
-  const floatingFocusElement = clamp.getFloatingFocusElement(floating);
-  const getTabbableContent = clamp.useStableCallback((container = floatingFocusElement) => {
-    return container ? index_esm.tabbable(container, getTabbableOptions()) : [];
-  });
-  const getResolvedInsideElements = clamp.useStableCallback(() => getInsideElements?.().filter(element => element != null) ?? []);
-  const getTabbableElements = clamp.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(() => {
-    if (disabled || !modal) {
-      return undefined;
-    }
-    function onKeyDown(event) {
-      if (event.key === 'Tab') {
-        // The focus guards have nothing to focus, so we need to stop the event.
-        if (clamp.contains(floatingFocusElement, clamp.activeElement(clamp.ownerDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
-          clamp.stopEvent(event);
-        }
-      }
-    }
-    const doc = clamp.ownerDocument(floatingFocusElement);
-    doc.addEventListener('keydown', onKeyDown);
-    return () => {
-      doc.removeEventListener('keydown', onKeyDown);
-    };
-  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
-
-  // Track pointer/keyboard interactions to disambiguate focus and outside presses.
-  React__namespace.useEffect(() => {
-    if (disabled || !open) {
-      return undefined;
-    }
-    const doc = clamp.ownerDocument(floatingFocusElement);
-    function clearPointerDownOutside() {
-      pointerDownOutsideRef.current = false;
-    }
-    function onPointerDown(event) {
-      const target = clamp.getTarget(event);
-      const insideElements = getResolvedInsideElements();
-      const pointerTargetInside = clamp.contains(floating, target) || clamp.contains(domReference, target) || clamp.contains(portalContext?.portalNode, target) || insideElements.some(element => element === target || clamp.contains(element, target));
-      pointerDownOutsideRef.current = !pointerTargetInside;
-      lastInteractionTypeRef.current = event.pointerType || 'keyboard';
-      if (target?.closest(`[${CLICK_TRIGGER_IDENTIFIER}]`)) {
-        isPointerDownRef.current = true;
-      }
-    }
-    function onKeyDown() {
-      lastInteractionTypeRef.current = 'keyboard';
-    }
-    doc.addEventListener('pointerdown', onPointerDown, true);
-    doc.addEventListener('pointerup', clearPointerDownOutside, true);
-    doc.addEventListener('pointercancel', clearPointerDownOutside, true);
-    doc.addEventListener('keydown', onKeyDown, true);
-    return () => {
-      doc.removeEventListener('pointerdown', onPointerDown, true);
-      doc.removeEventListener('pointerup', clearPointerDownOutside, true);
-      doc.removeEventListener('pointercancel', clearPointerDownOutside, true);
-      doc.removeEventListener('keydown', onKeyDown, true);
-    };
-  }, [disabled, floating, domReference, floatingFocusElement, open, portalContext, getResolvedInsideElements]);
-
-  // Close on focus out and restore focus within the floating tree when needed.
-  React__namespace.useEffect(() => {
-    if (disabled || !closeOnFocusOut) {
-      return undefined;
-    }
-    const doc = clamp.ownerDocument(floatingFocusElement);
-
-    // In Safari, buttons lose focus when pressing them.
-    function handlePointerDown() {
-      isPointerDownRef.current = true;
-      pointerDownTimeout.start(0, () => {
-        isPointerDownRef.current = false;
-      });
-    }
-    function handleFocusIn(event) {
-      const target = clamp.getTarget(event);
-      const tabbableContent = getTabbableContent();
-      const tabbableIndex = tabbableContent.indexOf(target);
-      if (tabbableIndex !== -1) {
-        tabbableIndexRef.current = tabbableIndex;
-      }
-    }
-    function handleFocusOutside(event) {
-      const relatedTarget = event.relatedTarget;
-      const currentTarget = event.currentTarget;
-      const target = clamp.getTarget(event);
-      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, clamp.resolveRef(previousFocusableElement), clamp.resolveRef(nextFocusableElement)].includes(relatedTarget);
-        const movedToUnrelatedNode = !(clamp.contains(domReference, relatedTarget) || clamp.contains(floating, relatedTarget) || clamp.contains(relatedTarget, floating) || clamp.contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || clamp.contains(element, relatedTarget)) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement(trigger => clamp.contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => clamp.contains(node.context?.elements.floating, relatedTarget) || clamp.contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, clamp.getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
-        if (currentTarget === domReference && floatingFocusElement) {
-          handleTabIndex(floatingFocusElement, orderRef);
-        }
-
-        // Restore focus to the previous tabbable element index to prevent
-        // focus from being lost outside the floating tree.
-        if (restoreFocus && currentTarget !== domReference && !isFocusable(target) && clamp.activeElement(doc) === doc.body) {
-          // Let `FloatingPortal` effect knows that focus is still inside the
-          // floating tree.
-          if (floatingUi_utils_dom.isHTMLElement(floatingFocusElement)) {
-            floatingFocusElement.focus();
-            // If explicitly requested to restore focus to the popup container, do not search
-            // for the next/previous tabbable element.
-            if (restoreFocus === 'popup') {
-              // If the element is removed on pointerdown, focus tries to move it,
-              // but since it's removed at the same time, focus gets lost as it
-              // happens after the .focus() call above.
-              // In this case, focus needs to be moved asynchronously.
-              restoreFocusFrame.request(() => {
-                floatingFocusElement.focus();
-              });
-              return;
-            }
-          }
-          const prevTabbableIndex = tabbableIndexRef.current;
-          const tabbableContent = getTabbableContent();
-          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
-          if (floatingUi_utils_dom.isHTMLElement(nodeToFocus)) {
-            nodeToFocus.focus();
-          }
-        }
-
-        // https://github.com/floating-ui/floating-ui/issues/3060
-        if (dataRef.current.insideReactTree) {
-          dataRef.current.insideReactTree = false;
-          return;
-        }
-
-        // Focus did not move inside the floating tree, and there are no tabbable
-        // portal guards to handle closing.
-        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && (
-        // Fix React 18 Strict Mode returnFocus due to double rendering.
-        // For an "untrapped" typeable combobox (input role=combobox with
-        // initialFocus=false), re-opening the popup and tabbing out should still close it even
-        // when the previously focused element (e.g. the next tabbable outside the popup) is
-        // focused again. Otherwise, the popup remains open on the second Tab sequence:
-        // click input -> Tab (closes) -> click input -> Tab.
-        // Allow closing when `isUntrappedTypeableCombobox` regardless of the previously focused element.
-        isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {
-          preventReturnFocusRef.current = true;
-          store.setOpen(false, clamp.createChangeEventDetails(clamp.focusOut, event));
-        }
-      });
-    }
-    function markInsideReactTree() {
-      if (pointerDownOutsideRef.current) {
-        return;
-      }
-      dataRef.current.insideReactTree = true;
-      blurTimeout.start(0, () => {
-        dataRef.current.insideReactTree = false;
-      });
-    }
-    const domReferenceElement = floatingUi_utils_dom.isHTMLElement(domReference) ? domReference : null;
-    const cleanups = [];
-    if (!floating && !domReferenceElement) {
-      return 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]);
-
-  // Hide everything outside the floating tree from assistive tech while open.
-  React__namespace.useEffect(() => {
-    if (disabled || !floating || !open) {
-      return undefined;
-    }
-
-    // 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 => clamp.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, clamp.resolveRef(previousFocusableElement), clamp.resolveRef(nextFocusableElement), isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);
-    const ariaHiddenCleanup = markOthers(insideElements, {
-      ariaHidden: modal || isUntrappedTypeableCombobox,
-      mark: false
-    });
-    const markerInsideElements = [floating, ...portalNodes].filter(x => x != null);
-    const markerCleanup = markOthers(markerInsideElements);
-    return () => {
-      markerCleanup();
-      ariaHiddenCleanup();
-    };
-  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
-
-  // Focus the initial element when the floating element opens.
-  clamp.useIsoLayoutEffect(() => {
-    if (!open || disabled || !floatingUi_utils_dom.isHTMLElement(floatingFocusElement)) {
-      return;
-    }
-    const doc = clamp.ownerDocument(floatingFocusElement);
-    const previouslyFocusedElement = clamp.activeElement(doc);
-
-    // 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;
-
-      // `null` should fallback to default behavior in case of an empty ref.
-      if (resolvedInitialFocus === undefined || resolvedInitialFocus === false) {
-        return;
-      }
-      let elToFocus;
-      if (resolvedInitialFocus === true || resolvedInitialFocus === null) {
-        elToFocus = focusableElements[0] || floatingFocusElement;
-      } else {
-        elToFocus = clamp.resolveRef(resolvedInitialFocus);
-      }
-      elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;
-      const focusAlreadyInsideFloatingEl = clamp.contains(floatingFocusElement, previouslyFocusedElement);
-      if (focusAlreadyInsideFloatingEl) {
-        return;
-      }
-      enqueueFocus(elToFocus, {
-        preventScroll: elToFocus === floatingFocusElement
-      });
-    });
-  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef, openInteractionTypeRef]);
-
-  // Track return focus targets and restore focus on unmount/close.
-  clamp.useIsoLayoutEffect(() => {
-    if (disabled || !floatingFocusElement) {
-      return undefined;
-    }
-    const doc = clamp.ownerDocument(floatingFocusElement);
-    const previouslyFocusedElement = clamp.activeElement(doc);
-    addPreviouslyFocusedElement(previouslyFocusedElement);
-
-    // Dismissing via outside press should always ignore `returnFocus` to
-    // prevent unwanted scrolling.
-    function onOpenChangeLocal(details) {
-      if (!details.open) {
-        closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
-      }
-      if (details.reason === clamp.triggerHover && details.nativeEvent.type === 'mouseleave') {
-        preventReturnFocusRef.current = true;
-      }
-      if (details.reason !== clamp.outsidePress) {
-        return;
-      }
-      if (details.nested) {
-        preventReturnFocusRef.current = false;
-      } else if (clamp.isVirtualClick(details.nativeEvent) || clamp.isVirtualPointerEvent(details.nativeEvent)) {
-        preventReturnFocusRef.current = false;
-      } else {
-        let isPreventScrollSupported = false;
-        document.createElement('div').focus({
-          get preventScroll() {
-            isPreventScrollSupported = true;
-            return false;
-          }
-        });
-        if (isPreventScrollSupported) {
-          preventReturnFocusRef.current = false;
-        } else {
-          preventReturnFocusRef.current = true;
-        }
-      }
-    }
-    events.on('openchange', onOpenChangeLocal);
-    function getReturnElement() {
-      const returnFocusValueOrFn = returnFocusRef.current;
-      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
-
-      // `null` should fallback to default behavior in case of an empty ref.
-      if (resolvedReturnFocusValue === undefined || resolvedReturnFocusValue === false) {
-        return null;
-      }
-      if (resolvedReturnFocusValue === null) {
-        resolvedReturnFocusValue = true;
-      }
-      if (typeof resolvedReturnFocusValue === 'boolean') {
-        const el = domReference || getPreviouslyFocusedElement();
-        return el && el.isConnected ? el : null;
-      }
-      const fallback = domReference || getPreviouslyFocusedElement();
-      return clamp.resolveRef(resolvedReturnFocusValue) || fallback || null;
-    }
-    return () => {
-      events.off('openchange', onOpenChangeLocal);
-      const activeEl = clamp.activeElement(doc);
-      const insideElements = getResolvedInsideElements();
-      const isFocusInsideFloatingTree = clamp.contains(floating, activeEl) || insideElements.some(element => element === activeEl || clamp.contains(element, activeEl)) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some(node => clamp.contains(node.context?.elements.floating, activeEl));
-      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) && (
-        // If the focus moved somewhere else after mount, avoid returning focus
-        // since it likely entered a different element which should be
-        // respected: https://github.com/floating-ui/floating-ui/issues/2607
-        !hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {
-          tabbableReturnElement.focus({
-            preventScroll: true
-          });
-        }
-        preventReturnFocusRef.current = false;
-      });
-    };
-  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, domReference, getNodeId, getResolvedInsideElements]);
-
-  // 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.
-  clamp.useIsoLayoutEffect(() => {
-    if (!clamp.isWebKit || open || !floating) {
-      return;
-    }
-    const activeEl = clamp.activeElement(clamp.ownerDocument(floating));
-    if (!floatingUi_utils_dom.isHTMLElement(activeEl) || !clamp.isTypeableElement(activeEl)) {
-      return;
-    }
-    if (clamp.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.
-  clamp.useIsoLayoutEffect(() => {
-    if (disabled || !portalContext) {
-      return undefined;
-    }
-    portalContext.setFocusManagerState({
-      modal,
-      closeOnFocusOut,
-      open,
-      onOpenChange: store.setOpen,
-      domReference
-    });
-    return () => {
-      portalContext.setFocusManagerState(null);
-    };
-  }, [disabled, portalContext, modal, open, store, closeOnFocusOut, domReference]);
-
-  // Keep the floating element tabIndex in sync and clear stale focus records.
-  clamp.useIsoLayoutEffect(() => {
-    if (disabled || !floatingFocusElement) {
-      return undefined;
-    }
-    handleTabIndex(floatingFocusElement, orderRef);
-    return () => {
-      queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
-    };
-  }, [disabled, floatingFocusElement, orderRef]);
-  const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
-  return /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
-    children: [shouldRenderGuards && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
-      "data-type": "inside",
-      ref: mergedBeforeGuardRef,
-      onFocus: event => {
-        if (modal) {
-          const els = getTabbableElements();
-          enqueueFocus(els[els.length - 1]);
-        } else if (portalContext?.portalNode) {
-          preventReturnFocusRef.current = false;
-          if (isOutsideEvent(event, portalContext.portalNode)) {
-            const nextTabbable = getNextTabbable(domReference);
-            nextTabbable?.focus();
-          } else {
-            clamp.resolveRef(previousFocusableElement ?? portalContext.beforeOutsideRef)?.focus();
-          }
-        }
-      }
-    }), children, shouldRenderGuards && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
-      "data-type": "inside",
-      ref: mergedAfterGuardRef,
-      onFocus: event => {
-        if (modal) {
-          enqueueFocus(getTabbableElements()[0]);
-        } else if (portalContext?.portalNode) {
-          if (closeOnFocusOut) {
-            preventReturnFocusRef.current = true;
-          }
-          if (isOutsideEvent(event, portalContext.portalNode)) {
-            const prevTabbable = getPreviousTabbable(domReference);
-            prevTabbable?.focus();
-          } else {
-            clamp.resolveRef(nextFocusableElement ?? portalContext.afterOutsideRef)?.focus();
-          }
-        }
-      }
-    })]
-  });
-}
-
-/**
- * Opens or closes the floating element when clicking the reference element.
- * @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',
-    toggle = true,
-    ignoreMouse = false,
-    stickIfOpen = true,
-    touchOpenDelay = 0,
-    reason = clamp.triggerPress
-  } = props;
-  const pointerTypeRef = React__namespace.useRef(undefined);
-  const frame = clamp.useAnimationFrame();
-  const touchOpenTimeout = clamp.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' || clamp.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
-      }
-      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 (clamp.isTypeableElement(nativeEvent.target)) {
-        const details = clamp.createChangeEventDetails(reason, nativeEvent, nativeEvent.target);
-        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            store.setOpen(true, details);
-          });
-        } else {
-          store.setOpen(nextOpen, details);
-        }
-        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(() => {
-        const details = clamp.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;
-      }
-      const pointerType = pointerTypeRef.current;
-      if (eventOption === 'mousedown' && pointerType) {
-        pointerTypeRef.current = undefined;
-        return;
-      }
-      if (clamp.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
-      }
-      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 ? clamp.isClickLikeEvent(openEvent) : true));
-      const details = clamp.createChangeEventDetails(reason, event.nativeEvent, event.currentTarget);
-      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-        touchOpenTimeout.start(touchOpenDelay, () => {
-          store.setOpen(true, details);
-        });
-      } else {
-        store.setOpen(nextOpen, details);
-      }
-    },
-    onKeyDown() {
-      pointerTypeRef.current = undefined;
-    }
-  }), [dataRef, eventOption, ignoreMouse, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay, reason]);
-  return React__namespace.useMemo(() => enabled ? {
-    reference
-  } : useRenderElement.EMPTY_OBJECT, [enabled, reference]);
-}
-
-const bubbleHandlerKeys = {
-  intentional: 'onClick',
-  sloppy: 'onPointerDown'
-};
-function alwaysFalse() {
-  return false;
-}
-function normalizeProp(normalizable) {
-  return {
-    escapeKey: typeof normalizable === 'boolean' ? normalizable : normalizable?.escapeKey ?? false,
-    outsidePress: typeof normalizable === 'boolean' ? normalizable : normalizable?.outsidePress ?? true
-  };
-}
-/**
- * Closes the floating element when a dismissal is requested — by default, when
- * the user presses the `escape` key or outside of the floating element.
- * @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 tree = useFloatingTree(externalTree);
-  const outsidePressFn = clamp.useStableCallback(typeof outsidePressProp === 'function' ? outsidePressProp : () => false);
-  const outsidePress = typeof outsidePressProp === 'function' ? outsidePressFn : outsidePressProp;
-  const outsidePressEnabled = outsidePress !== false;
-  const getOutsidePressEventProp = clamp.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 touchStateRef = React__namespace.useRef(null);
-  const cancelDismissOnEndTimeout = clamp.useTimeout();
-  const clearInsideReactTreeTimeout = clamp.useTimeout();
-  const clearInsideReactTree = clamp.useStableCallback(() => {
-    clearInsideReactTreeTimeout.clear();
-    dataRef.current.insideReactTree = false;
-  });
-  const isComposingRef = React__namespace.useRef(false);
-  const currentPointerTypeRef = React__namespace.useRef('');
-  const isReferencePressEnabled = clamp.useStableCallback(referencePress);
-  const closeOnEscapeKeyDown = clamp.useStableCallback(event => {
-    if (!open || !enabled || !escapeKey || event.key !== 'Escape') {
-      return;
-    }
-
-    // Wait until IME is settled. Pressing `Escape` while composing should
-    // close the compose menu, but not the floating element.
-    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;
-        }
-      }
-    }
-    const native = clamp.isReactEvent(event) ? event.nativeEvent : event;
-    const eventDetails = clamp.createChangeEventDetails(clamp.escapeKey, native);
-    store.setOpen(false, eventDetails);
-    if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) {
-      event.stopPropagation();
-    }
-  });
-  const markInsideReactTree = clamp.useStableCallback(() => {
-    dataRef.current.insideReactTree = true;
-    clearInsideReactTreeTimeout.start(0, clearInsideReactTree);
-  });
-  React__namespace.useEffect(() => {
-    if (!open || !enabled) {
-      return undefined;
-    }
-    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
-    dataRef.current.__outsidePressBubbles = outsidePressBubbles;
-    const compositionTimeout = new clamp.Timeout();
-    const preventedPressSuppressionTimeout = new clamp.Timeout();
-    function handleCompositionStart() {
-      compositionTimeout.clear();
-      isComposingRef.current = true;
-    }
-    function handleCompositionEnd() {
-      // Safari fires `compositionend` before `keydown`, so we need to wait
-      // until the next tick to set `isComposing` to `false`.
-      // https://bugs.webkit.org/show_bug.cgi?id=165004
-      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, () => {
-        isComposingRef.current = false;
-      });
-    }
-    function suppressImmediateOutsideClickAfterPreventedStart() {
-      suppressNextOutsideClickRef.current = true;
-      // Firefox can emit the synthetic outside click in a later task after
-      // pointer lock exit, so microtask clearing is too early here.
-      preventedPressSuppressionTimeout.start(0, () => {
-        suppressNextOutsideClickRef.current = false;
-      });
-    }
-    function resetPressStartState() {
-      pressStartedInsideRef.current = false;
-      pressStartPreventedRef.current = false;
-    }
-    function getOutsidePressEvent() {
-      const type = currentPointerTypeRef.current;
-      const computedType = type === 'pen' || !type ? 'mouse' : type;
-      const outsidePressEventValue = getOutsidePressEventProp();
-      const resolved = typeof outsidePressEventValue === 'function' ? outsidePressEventValue() : outsidePressEventValue;
-      if (typeof resolved === 'string') {
-        return resolved;
-      }
-      return resolved[computedType];
-    }
-    function shouldIgnoreEvent(event) {
-      const computedOutsidePressEvent = getOutsidePressEvent();
-      return computedOutsidePressEvent === 'intentional' && event.type !== 'click' || computedOutsidePressEvent === 'sloppy' && event.type === 'click';
-    }
-    function isEventWithinFloatingTree(event) {
-      const nodeId = dataRef.current.floatingContext?.nodeId;
-      const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some(node => clamp.isEventTargetWithin(event, node.context?.elements.floating));
-      return clamp.isEventTargetWithin(event, store.select('floatingElement')) || clamp.isEventTargetWithin(event, store.select('domReferenceElement')) || targetIsInsideChildren;
-    }
-    function closeOnPressOutside(event) {
-      if (shouldIgnoreEvent(event)) {
-        clearInsideReactTree();
-        return;
-      }
-      if (dataRef.current.insideReactTree) {
-        clearInsideReactTree();
-        return;
-      }
-      const target = clamp.getTarget(event);
-      const inertSelector = `[${createAttribute('inert')}]`;
-      let markers = Array.from(clamp.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 triggers = store.context.triggerElements;
-
-      // If another trigger is clicked, don't close the floating element.
-      if (target && (triggers.hasElement(target) || triggers.hasMatchingElement(trigger => clamp.contains(trigger, target)))) {
-        return;
-      }
-      let targetRootAncestor = floatingUi_utils_dom.isElement(target) ? target : null;
-      while (targetRootAncestor && !floatingUi_utils_dom.isLastTraversableNode(targetRootAncestor)) {
-        const nextParent = floatingUi_utils_dom.getParentNode(targetRootAncestor);
-        if (floatingUi_utils_dom.isLastTraversableNode(nextParent) || !floatingUi_utils_dom.isElement(nextParent)) {
-          break;
-        }
-        targetRootAncestor = nextParent;
-      }
-
-      // Check if the click occurred on a third-party element injected after the
-      // floating element rendered.
-      if (markers.length && floatingUi_utils_dom.isElement(target) && !clamp.isRootElement(target) &&
-      // Clicked on a direct ancestor (e.g. FloatingOverlay).
-      !clamp.contains(target, store.select('floatingElement')) &&
-      // If the target root element contains none of the markers, then the
-      // element was injected after the floating element rendered.
-      markers.every(marker => !clamp.contains(targetRootAncestor, marker))) {
-        return;
-      }
-
-      // Check if the click occurred on the scrollbar
-      // Skip for touch events: scrollbars don't receive touch events on most platforms
-      if (floatingUi_utils_dom.isHTMLElement(target) && !('touches' in event)) {
-        const lastTraversableNode = floatingUi_utils_dom.isLastTraversableNode(target);
-        const style = floatingUi_utils_dom.getComputedStyle(target);
-        const scrollRe = /auto|scroll/;
-        const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
-        const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
-        const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
-        const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
-        const isRTL = style.direction === 'rtl';
-
-        // Check click position relative to scrollbar.
-        // In some browsers it is possible to change the <body> (or window)
-        // scrollbar to the left side, but is very rare and is difficult to
-        // check for. Plus, for modal dialogs with backdrops, it is more
-        // important that the backdrop is checked but not so much the window.
-        const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
-        const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
-        if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {
-          return;
-        }
-      }
-      if (isEventWithinFloatingTree(event)) {
-        return;
-      }
-
-      // In intentional mode, a press that starts inside and ends outside gets
-      // one suppressed outside click. Run this after inside-target checks so
-      // inside clicks don't consume the one-shot suppression.
-      if (getOutsidePressEvent() === 'intentional' && suppressNextOutsideClickRef.current) {
-        preventedPressSuppressionTimeout.clear();
-        suppressNextOutsideClickRef.current = false;
-        return;
-      }
-      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;
-        }
-      }
-      store.setOpen(false, clamp.createChangeEventDetails(clamp.outsidePress, event));
-      clearInsideReactTree();
-    }
-    function handlePointerDown(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || event.pointerType === 'touch' || !store.select('open') || !enabled || clamp.isEventTargetWithin(event, store.select('floatingElement')) || clamp.isEventTargetWithin(event, store.select('domReferenceElement'))) {
-        return;
-      }
-      closeOnPressOutside(event);
-    }
-    function handleTouchStart(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || !store.select('open') || !enabled || clamp.isEventTargetWithin(event, store.select('floatingElement')) || clamp.isEventTargetWithin(event, store.select('domReferenceElement'))) {
-        return;
-      }
-      const touch = event.touches[0];
-      if (touch) {
-        touchStateRef.current = {
-          startTime: Date.now(),
-          startX: touch.clientX,
-          startY: touch.clientY,
-          dismissOnTouchEnd: false,
-          dismissOnMouseDown: true
-        };
-        cancelDismissOnEndTimeout.start(1000, () => {
-          if (touchStateRef.current) {
-            touchStateRef.current.dismissOnTouchEnd = false;
-            touchStateRef.current.dismissOnMouseDown = false;
-          }
-        });
-      }
-    }
-    function handleTouchStartCapture(event) {
-      currentPointerTypeRef.current = 'touch';
-      const target = clamp.getTarget(event);
-      function callback() {
-        handleTouchStart(event);
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
-    }
-    function closeOnPressOutsideCapture(event) {
-      cancelDismissOnEndTimeout.clear();
-      if (event.type === 'pointerdown') {
-        currentPointerTypeRef.current = event.pointerType;
-      }
-      if (event.type === 'mousedown' && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
-        return;
-      }
-      const target = clamp.getTarget(event);
-      function callback() {
-        if (event.type === 'pointerdown') {
-          handlePointerDown(event);
-        } else {
-          closeOnPressOutside(event);
-        }
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
-    }
-    function handlePressEndCapture(event) {
-      if (!pressStartedInsideRef.current) {
-        return;
-      }
-      const pressStartedInsideDefaultPrevented = pressStartPreventedRef.current;
-      resetPressStartState();
-      if (getOutsidePressEvent() !== 'intentional') {
-        return;
-      }
-      if (event.type === 'pointercancel') {
-        if (pressStartedInsideDefaultPrevented) {
-          suppressImmediateOutsideClickAfterPreventedStart();
-        }
-        return;
-      }
-      if (isEventWithinFloatingTree(event)) {
-        return;
-      }
-
-      // If pointerdown was prevented, no click may be generated for that
-      // interaction. However, Firefox may still emit an immediate click after
-      // pointerup (e.g. NumberField scrub with pointer lock), so suppress for
-      // one tick to absorb that synthetic click only.
-      if (pressStartedInsideDefaultPrevented) {
-        suppressImmediateOutsideClickAfterPreventedStart();
-        return;
-      }
-
-      // Avoid suppressing when outsidePress explicitly ignores this target.
-      if (typeof outsidePress === 'function' && !outsidePress(event)) {
-        return;
-      }
-      preventedPressSuppressionTimeout.clear();
-      suppressNextOutsideClickRef.current = true;
-      clearInsideReactTree();
-    }
-    function handleTouchMove(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || !touchStateRef.current || clamp.isEventTargetWithin(event, store.select('floatingElement')) || clamp.isEventTargetWithin(event, store.select('domReferenceElement'))) {
-        return;
-      }
-      const touch = event.touches[0];
-      if (!touch) {
-        return;
-      }
-      const deltaX = Math.abs(touch.clientX - touchStateRef.current.startX);
-      const deltaY = Math.abs(touch.clientY - touchStateRef.current.startY);
-      const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-      if (distance > 5) {
-        touchStateRef.current.dismissOnTouchEnd = true;
-      }
-      if (distance > 10) {
-        closeOnPressOutside(event);
-        cancelDismissOnEndTimeout.clear();
-        touchStateRef.current = null;
-      }
-    }
-    function handleTouchMoveCapture(event) {
-      const target = clamp.getTarget(event);
-      function callback() {
-        handleTouchMove(event);
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
-    }
-    function handleTouchEnd(event) {
-      if (getOutsidePressEvent() !== 'sloppy' || !touchStateRef.current || clamp.isEventTargetWithin(event, store.select('floatingElement')) || clamp.isEventTargetWithin(event, store.select('domReferenceElement'))) {
-        return;
-      }
-      if (touchStateRef.current.dismissOnTouchEnd) {
-        closeOnPressOutside(event);
-      }
-      cancelDismissOnEndTimeout.clear();
-      touchStateRef.current = null;
-    }
-    function handleTouchEndCapture(event) {
-      const target = clamp.getTarget(event);
-      function callback() {
-        handleTouchEnd(event);
-        target?.removeEventListener(event.type, callback);
-      }
-      target?.addEventListener(event.type, callback);
-    }
-    const doc = clamp.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);
-    }
-    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);
-      }
-      compositionTimeout.clear();
-      preventedPressSuppressionTimeout.clear();
-      resetPressStartState();
-      suppressNextOutsideClickRef.current = false;
-    };
-  }, [dataRef, floatingElement, escapeKey, outsidePressEnabled, outsidePress, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, 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, clamp.createChangeEventDetails(clamp.triggerPress, event.nativeEvent));
-    },
-    ...(referencePressEvent !== 'intentional' && {
-      onClick(event) {
-        if (!isReferencePressEnabled()) {
-          return;
-        }
-        store.setOpen(false, clamp.createChangeEventDetails(clamp.triggerPress, event.nativeEvent));
-      }
-    })
-  }), [closeOnEscapeKeyDown, store, referencePressEvent, isReferencePressEnabled]);
-  const markPressStartedInsideReactTree = clamp.useStableCallback(event => {
-    if (!open || !enabled || event.button !== 0) {
-      return;
-    }
-    const target = clamp.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 (!clamp.contains(store.select('floatingElement'), target)) {
-      return;
-    }
-    if (!pressStartedInsideRef.current) {
-      pressStartedInsideRef.current = true;
-      pressStartPreventedRef.current = false;
-    }
-  });
-  const markInsidePressStartPrevented = clamp.useStableCallback(event => {
-    if (!open || !enabled) {
-      return;
-    }
-    if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) {
-      return;
-    }
-    if (pressStartedInsideRef.current) {
-      pressStartPreventedRef.current = true;
-    }
-  });
-  const floating = React__namespace.useMemo(() => ({
-    onKeyDown: closeOnEscapeKeyDown,
-    // `onMouseDown` may be blocked if `event.preventDefault()` is called in
-    // `onPointerDown`, such as with <NumberField.ScrubArea>.
-    // See https://github.com/mui/base-ui/pull/3379
-    onPointerDown: markInsidePressStartPrevented,
-    onMouseDown: markInsidePressStartPrevented,
-    onClickCapture: markInsideReactTree,
-    onMouseDownCapture(event) {
-      markInsideReactTree();
-      markPressStartedInsideReactTree(event);
-    },
-    onPointerDownCapture(event) {
-      markInsideReactTree();
-      markPressStartedInsideReactTree(event);
-    },
-    onMouseUpCapture: markInsideReactTree,
-    onTouchEndCapture: markInsideReactTree,
-    onTouchMoveCapture: markInsideReactTree
-  }), [closeOnEscapeKeyDown, markInsideReactTree, markPressStartedInsideReactTree, markInsidePressStartPrevented]);
-  return React__namespace.useMemo(() => enabled ? {
-    reference,
-    floating,
-    trigger: reference
-  } : {}, [enabled, reference, floating]);
-}
-
-const selectors$1 = {
-  open: createSelector(state => state.open),
-  domReferenceElement: createSelector(state => state.domReferenceElement),
-  referenceElement: createSelector(state => state.positionReference ?? state.referenceElement),
-  floatingElement: createSelector(state => state.floatingElement),
-  floatingId: createSelector(state => state.floatingId)
-};
-class FloatingRootStore extends ReactStore {
-  constructor(options) {
-    const {
-      nested,
-      noEmit,
-      onOpenChange,
-      triggerElements,
-      ...initialState
-    } = options;
-    super({
-      ...initialState,
-      positionReference: initialState.referenceElement,
-      domReferenceElement: initialState.referenceElement
-    }, {
-      onOpenChange,
-      dataRef: {
-        current: {}
-      },
-      events: createEventEmitter(),
-      nested,
-      noEmit,
-      triggerElements
-    }, selectors$1);
-  }
-
-  /**
-   * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
-   *
-   * @param newOpen The new open state.
-   * @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.
-    clamp.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);
-    }
-    this.context.onOpenChange?.(newOpen, eventDetails);
-  };
-}
 
 /**
  * Returns a callback ref that registers/unregisters the trigger element in the store.
@@ -3629,7 +69,7 @@ function useTriggerRegistration(id, store) {
 function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates) {
   const isMountedByThisTrigger = store.useState('isMountedByTrigger', triggerId);
   const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
-  const registerTrigger = clamp.useStableCallback(element => {
+  const registerTrigger = useButton.useStableCallback(element => {
     baseRegisterTrigger(element);
     if (!element || !store.select('open')) {
       return;
@@ -3654,7 +94,7 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
       });
     }
   });
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     if (isMountedByThisTrigger) {
       store.update({
         activeTriggerElement: triggerElementRef.current,
@@ -3680,7 +120,7 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
  */
 function useImplicitActiveTrigger(store) {
   const open = store.useState('open');
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     if (open && !store.select('activeTriggerId') && store.context.triggerElements.size === 1) {
       const iteratorResult = store.context.triggerElements.entries().next();
       if (!iteratorResult.done) {
@@ -3710,12 +150,12 @@ function useOpenStateTransitions(open, store, onUnmount) {
     mounted,
     setMounted,
     transitionStatus
-  } = clamp.useTransitionStatus(open);
+  } = useButton.useTransitionStatus(open);
   store.useSyncedValues({
     mounted,
     transitionStatus
   });
-  const forceUnmount = clamp.useStableCallback(() => {
+  const forceUnmount = useButton.useStableCallback(() => {
     setMounted(false);
     store.update({
       activeTriggerId: null,
@@ -3726,7 +166,7 @@ function useOpenStateTransitions(open, store, onUnmount) {
     store.context.onOpenChangeComplete?.(false);
   });
   const preventUnmountingOnClose = store.useState('preventUnmountingOnClose');
-  clamp.useOpenChangeComplete({
+  useButton.useOpenChangeComplete({
     enabled: !preventUnmountingOnClose,
     open,
     ref: store.context.popupRef,
@@ -3742,105 +182,12 @@ function useOpenStateTransitions(open, store, onUnmount) {
   };
 }
 
-/**
- * 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.
- */
-class PopupTriggerMap {
-  constructor() {
-    this.elementsSet = new Set();
-    this.idMap = new Map();
-  }
-
-  /**
-   * Adds a trigger element with the given ID.
-   *
-   * Note: The provided element is assumed to not be registered under multiple IDs.
-   */
-  add(id, element) {
-    const existingElement = this.idMap.get(id);
-    if (existingElement === element) {
-      return;
-    }
-    if (existingElement !== undefined) {
-      // We assume that the same element won't be registered under multiple ids.
-      // This is safe considering how useTriggerRegistration is implemented.
-      this.elementsSet.delete(existingElement);
-    }
-    this.elementsSet.add(element);
-    this.idMap.set(id, element);
-    if (process.env.NODE_ENV !== 'production') {
-      if (this.elementsSet.size !== this.idMap.size) {
-        throw new Error('Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.');
-      }
-    }
-  }
-
-  /**
-   * Removes the trigger element with the given ID.
-   */
-  delete(id) {
-    const element = this.idMap.get(id);
-    if (element) {
-      this.elementsSet.delete(element);
-      this.idMap.delete(id);
-    }
-  }
-
-  /**
-   * Whether the given element is registered as a trigger.
-   */
-  hasElement(element) {
-    return this.elementsSet.has(element);
-  }
-
-  /**
-   * Whether there is a registered trigger element matching the given predicate.
-   */
-  hasMatchingElement(predicate) {
-    for (const element of this.elementsSet) {
-      if (predicate(element)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Returns the trigger element associated with the given ID, or undefined if no such element exists.
-   */
-  getById(id) {
-    return this.idMap.get(id);
-  }
-
-  /**
-   * Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
-   */
-  entries() {
-    return this.idMap.entries();
-  }
-
-  /**
-   * Returns an iterable of all registered trigger elements.
-   */
-  elements() {
-    return this.elementsSet.values();
-  }
-
-  /**
-   * Returns the number of registered trigger elements.
-   */
-  get size() {
-    return this.idMap.size;
-  }
-}
-
 function getEmptyRootContext() {
-  return new FloatingRootStore({
+  return new InternalBackdrop.FloatingRootStore({
     open: false,
     floatingElement: null,
     referenceElement: null,
-    triggerElements: new PopupTriggerMap(),
+    triggerElements: new InternalBackdrop.PopupTriggerMap(),
     floatingId: '',
     nested: false,
     noEmit: false,
@@ -3871,32 +218,32 @@ function createInitialPopupStoreState() {
     popupProps: useRenderElement.EMPTY_OBJECT
   };
 }
-const activeTriggerIdSelector = createSelector(state => state.triggerIdProp ?? state.activeTriggerId);
+const activeTriggerIdSelector = InternalBackdrop.createSelector(state => state.triggerIdProp ?? state.activeTriggerId);
 const popupStoreSelectors = {
-  open: createSelector(state => state.openProp ?? state.open),
-  mounted: createSelector(state => state.mounted),
-  transitionStatus: createSelector(state => state.transitionStatus),
-  floatingRootContext: createSelector(state => state.floatingRootContext),
-  preventUnmountingOnClose: createSelector(state => state.preventUnmountingOnClose),
-  payload: createSelector(state => state.payload),
+  open: InternalBackdrop.createSelector(state => state.openProp ?? state.open),
+  mounted: InternalBackdrop.createSelector(state => state.mounted),
+  transitionStatus: InternalBackdrop.createSelector(state => state.transitionStatus),
+  floatingRootContext: InternalBackdrop.createSelector(state => state.floatingRootContext),
+  preventUnmountingOnClose: InternalBackdrop.createSelector(state => state.preventUnmountingOnClose),
+  payload: InternalBackdrop.createSelector(state => state.payload),
   activeTriggerId: activeTriggerIdSelector,
-  activeTriggerElement: createSelector(state => state.mounted ? state.activeTriggerElement : null),
+  activeTriggerElement: InternalBackdrop.createSelector(state => state.mounted ? state.activeTriggerElement : null),
   /**
    * Whether the trigger with the given ID was used to open the popup.
    */
-  isTriggerActive: createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId),
+  isTriggerActive: InternalBackdrop.createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId),
   /**
    * Whether the popup is open and was activated by a trigger with the given ID.
    */
-  isOpenedByTrigger: createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.open),
+  isOpenedByTrigger: InternalBackdrop.createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.open),
   /**
    * Whether the popup is mounted and was activated by a trigger with the given ID.
    */
-  isMountedByTrigger: createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.mounted),
-  triggerProps: createSelector((state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps),
-  popupProps: createSelector(state => state.popupProps),
-  popupElement: createSelector(state => state.popupElement),
-  positionerElement: createSelector(state => state.positionerElement)
+  isMountedByTrigger: InternalBackdrop.createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.mounted),
+  triggerProps: InternalBackdrop.createSelector((state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps),
+  popupProps: InternalBackdrop.createSelector(state => state.popupProps),
+  popupElement: InternalBackdrop.createSelector(state => state.popupElement),
+  positionerElement: InternalBackdrop.createSelector(state => state.positionerElement)
 };
 
 /**
@@ -3910,13 +257,13 @@ function useSyncedFloatingRootContext(options) {
     treatPopupAsFloatingElement = false,
     onOpenChange
   } = options;
-  const floatingId = clamp.useId();
-  const nested = useFloatingParentNodeId() != null;
+  const floatingId = useButton.useId();
+  const nested = InternalBackdrop.useFloatingParentNodeId() != null;
   const open = popupStore.useState('open');
   const referenceElement = popupStore.useState('activeTriggerElement');
   const floatingElement = popupStore.useState(treatPopupAsFloatingElement ? 'popupElement' : 'positionerElement');
   const triggerElements = popupStore.context.triggerElements;
-  const store = useRenderElement.useRefWithInit(() => new FloatingRootStore({
+  const store = useRenderElement.useRefWithInit(() => new InternalBackdrop.FloatingRootStore({
     open,
     referenceElement,
     floatingElement,
@@ -3926,7 +273,7 @@ function useSyncedFloatingRootContext(options) {
     nested,
     noEmit
   })).current;
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     const valuesToSync = {
       open,
       floatingId,
@@ -3949,93 +296,6 @@ function useSyncedFloatingRootContext(options) {
   return store;
 }
 
-/**
- * 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[clamp.FOCUSABLE_ATTRIBUTE] = '';
-  }
-  for (const key in userProps) {
-    if (isItem && userProps) {
-      if (key === clamp.ACTIVE_KEY || key === clamp.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 === clamp.ACTIVE_KEY || key === clamp.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);
-        };
-      }
-    }
-  }
-}
-
 const componentRoleToAriaRoleMap = new Map([['select', 'listbox'], ['combobox', 'listbox'], ['label', false]]);
 
 /**
@@ -4052,11 +312,11 @@ function useRole(context, props = {}) {
   const {
     role = 'dialog'
   } = props;
-  const defaultReferenceId = clamp.useId();
+  const defaultReferenceId = useButton.useId();
   const referenceId = domReference?.id || defaultReferenceId;
-  const floatingId = React__namespace.useMemo(() => clamp.getFloatingFocusElement(floatingElement)?.id || defaultFloatingId, [floatingElement, defaultFloatingId]);
+  const floatingId = React__namespace.useMemo(() => useButton.getFloatingFocusElement(floatingElement)?.id || defaultFloatingId, [floatingElement, defaultFloatingId]);
   const ariaRole = componentRoleToAriaRoleMap.get(role) ?? role;
-  const parentId = useFloatingParentNodeId();
+  const parentId = InternalBackdrop.useFloatingParentNodeId();
   const isNested = parentId != null;
   const trigger = React__namespace.useMemo(() => {
     if (ariaRole === 'tooltip' || role === 'label') {
@@ -4144,461 +404,6 @@ function useRole(context, props = {}) {
   }), [reference, floating, trigger, item]);
 }
 
-/**
- * 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.
- * Additionally, this implementation detects if the click was triggered by the keyboard.
- *
- * @param handler The function to be called when the button is clicked. The first parameter is the original event and the second parameter is the pointer type.
- */
-function useEnhancedClickHandler(handler) {
-  const lastClickInteractionTypeRef = React__namespace.useRef('');
-  const handlePointerDown = React__namespace.useCallback(event => {
-    if (event.defaultPrevented) {
-      return;
-    }
-    lastClickInteractionTypeRef.current = event.pointerType;
-    handler(event, event.pointerType);
-  }, [handler]);
-  const handleClick = React__namespace.useCallback(event => {
-    // event.detail has the number of clicks performed on the element. 0 means it was triggered by the keyboard.
-    if (event.detail === 0) {
-      handler(event, 'keyboard');
-      return;
-    }
-    if ('pointerType' in event) {
-      // Chrome and Edge correctly use PointerEvent
-      handler(event, event.pointerType);
-    } else {
-      handler(event, lastClickInteractionTypeRef.current);
-    }
-    lastClickInteractionTypeRef.current = '';
-  }, [handler]);
-  return {
-    onClick: handleClick,
-    onPointerDown: handlePointerDown
-  };
-}
-
-/**
- * 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 handleTriggerClick = clamp.useStableCallback((_, interactionType) => {
-    if (!open) {
-      setOpenMethod(interactionType || (
-      // On iOS Safari, the hitslop around touch targets means tapping outside an element's
-      // bounds does not fire `pointerdown` but does fire `mousedown`. The `interactionType`
-      // will be "" in that case.
-      clamp.isIOS ? 'touch' : ''));
-    }
-  });
-  clamp.useValueChanged(open, previousOpen => {
-    if (previousOpen && !open) {
-      setOpenMethod(null);
-    }
-  });
-  const {
-    onClick,
-    onPointerDown
-  } = useEnhancedClickHandler(handleTriggerClick);
-  return React__namespace.useMemo(() => ({
-    openMethod,
-    triggerProps: {
-      onClick,
-      onPointerDown
-    }
-  }), [openMethod, onClick, onPointerDown]);
-}
-
-let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
-  /**
-   * Present when the popup is open.
-   */
-  CommonPopupDataAttributes["open"] = "data-open";
-  /**
-   * Present when the popup is closed.
-   */
-  CommonPopupDataAttributes["closed"] = "data-closed";
-  /**
-   * Present when the popup is animating in.
-   */
-  CommonPopupDataAttributes[CommonPopupDataAttributes["startingStyle"] = clamp.TransitionStatusDataAttributes.startingStyle] = "startingStyle";
-  /**
-   * Present when the popup is animating out.
-   */
-  CommonPopupDataAttributes[CommonPopupDataAttributes["endingStyle"] = clamp.TransitionStatusDataAttributes.endingStyle] = "endingStyle";
-  /**
-   * Present when the anchor is hidden.
-   */
-  CommonPopupDataAttributes["anchorHidden"] = "data-anchor-hidden";
-  /**
-   * Indicates which side the popup is positioned relative to the trigger.
-   * @type { 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start'}
-   */
-  CommonPopupDataAttributes["side"] = "data-side";
-  /**
-   * Indicates how the popup is aligned relative to specified side.
-   * @type {'start' | 'center' | 'end'}
-   */
-  CommonPopupDataAttributes["align"] = "data-align";
-  return CommonPopupDataAttributes;
-}({});
-let CommonTriggerDataAttributes = /*#__PURE__*/function (CommonTriggerDataAttributes) {
-  /**
-   * Present when the popup is open.
-   */
-  CommonTriggerDataAttributes["popupOpen"] = "data-popup-open";
-  /**
-   * Present when a pressable trigger is pressed.
-   */
-  CommonTriggerDataAttributes["pressed"] = "data-pressed";
-  return CommonTriggerDataAttributes;
-}({});
-const TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: ''
-};
-const PRESSABLE_TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: '',
-  [CommonTriggerDataAttributes.pressed]: ''
-};
-const POPUP_OPEN_HOOK = {
-  [CommonPopupDataAttributes.open]: ''
-};
-const POPUP_CLOSED_HOOK = {
-  [CommonPopupDataAttributes.closed]: ''
-};
-const ANCHOR_HIDDEN_HOOK = {
-  [CommonPopupDataAttributes.anchorHidden]: ''
-};
-const triggerOpenStateMapping = {
-  open(value) {
-    if (value) {
-      return TRIGGER_HOOK;
-    }
-    return null;
-  }
-};
-const pressableTriggerOpenStateMapping = {
-  open(value) {
-    if (value) {
-      return PRESSABLE_TRIGGER_HOOK;
-    }
-    return null;
-  }
-};
-const popupStateMapping = {
-  open(value) {
-    if (value) {
-      return POPUP_OPEN_HOOK;
-    }
-    return POPUP_CLOSED_HOOK;
-  },
-  anchorHidden(value) {
-    if (value) {
-      return ANCHOR_HIDDEN_HOOK;
-    }
-    return null;
-  }
-};
-
-/**
- * @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;
-  }
-  // compatibility with React < 19
-  return value ? 'true' : undefined;
-}
-
-let originalHtmlStyles = {};
-let originalBodyStyles = {};
-let originalHtmlScrollBehavior = '';
-function hasInsetScrollbars(referenceElement) {
-  if (typeof document === 'undefined') {
-    return false;
-  }
-  const doc = clamp.ownerDocument(referenceElement);
-  const win = floatingUi_utils_dom.getWindow(doc);
-  return win.innerWidth - doc.documentElement.clientWidth > 0;
-}
-function supportsStableScrollbarGutter(referenceElement) {
-  const supported = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('scrollbar-gutter', 'stable');
-  if (!supported || typeof document === 'undefined') {
-    return false;
-  }
-  const doc = clamp.ownerDocument(referenceElement);
-  const html = doc.documentElement;
-  const body = doc.body;
-  const scrollContainer = floatingUi_utils_dom.isOverflowElement(html) ? html : body;
-  const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
-  const originalHtmlStyleGutter = html.style.scrollbarGutter;
-  html.style.scrollbarGutter = 'stable';
-  scrollContainer.style.overflowY = 'scroll';
-  const before = scrollContainer.offsetWidth;
-  scrollContainer.style.overflowY = 'hidden';
-  const after = scrollContainer.offsetWidth;
-  scrollContainer.style.overflowY = originalScrollContainerOverflowY;
-  html.style.scrollbarGutter = originalHtmlStyleGutter;
-  return before === after;
-}
-function preventScrollOverlayScrollbars(referenceElement) {
-  const doc = clamp.ownerDocument(referenceElement);
-  const html = doc.documentElement;
-  const body = doc.body;
-
-  // If an `overflow` style is present on <html>, we need to lock it, because a lock on <body>
-  // won't have any effect.
-  // But if <body> has an `overflow` style (like `overflow-x: hidden`), we need to lock it
-  // instead, as sticky elements shift otherwise.
-  const elementToLock = floatingUi_utils_dom.isOverflowElement(html) ? html : body;
-  const originalElementToLockStyles = {
-    overflowY: elementToLock.style.overflowY,
-    overflowX: elementToLock.style.overflowX
-  };
-  Object.assign(elementToLock.style, {
-    overflowY: 'hidden',
-    overflowX: 'hidden'
-  });
-  return () => {
-    Object.assign(elementToLock.style, originalElementToLockStyles);
-  };
-}
-function preventScrollInsetScrollbars(referenceElement) {
-  const doc = clamp.ownerDocument(referenceElement);
-  const html = doc.documentElement;
-  const body = doc.body;
-  const win = floatingUi_utils_dom.getWindow(html);
-  let scrollTop = 0;
-  let scrollLeft = 0;
-  let updateGutterOnly = false;
-  const resizeFrame = clamp.AnimationFrame.create();
-
-  // Pinch-zoom in Safari causes a shift. Just don't lock scroll if there's any pinch-zoom.
-  if (clamp.isWebKit && (win.visualViewport?.scale ?? 1) !== 1) {
-    return () => {};
-  }
-  function lockScroll() {
-    /* DOM reads: */
-
-    const htmlStyles = win.getComputedStyle(html);
-    const bodyStyles = win.getComputedStyle(body);
-    const htmlScrollbarGutterValue = htmlStyles.scrollbarGutter || '';
-    const hasBothEdges = htmlScrollbarGutterValue.includes('both-edges');
-    const scrollbarGutterValue = hasBothEdges ? 'stable both-edges' : 'stable';
-    scrollTop = html.scrollTop;
-    scrollLeft = html.scrollLeft;
-    originalHtmlStyles = {
-      scrollbarGutter: html.style.scrollbarGutter,
-      overflowY: html.style.overflowY,
-      overflowX: html.style.overflowX
-    };
-    originalHtmlScrollBehavior = html.style.scrollBehavior;
-    originalBodyStyles = {
-      position: body.style.position,
-      height: body.style.height,
-      width: body.style.width,
-      boxSizing: body.style.boxSizing,
-      overflowY: body.style.overflowY,
-      overflowX: body.style.overflowX,
-      scrollBehavior: body.style.scrollBehavior
-    };
-    const isScrollableY = html.scrollHeight > html.clientHeight;
-    const isScrollableX = html.scrollWidth > html.clientWidth;
-    const hasConstantOverflowY = htmlStyles.overflowY === 'scroll' || bodyStyles.overflowY === 'scroll';
-    const hasConstantOverflowX = htmlStyles.overflowX === 'scroll' || bodyStyles.overflowX === 'scroll';
-
-    // Values can be negative in Firefox
-    const scrollbarWidth = Math.max(0, win.innerWidth - body.clientWidth);
-    const scrollbarHeight = Math.max(0, win.innerHeight - body.clientHeight);
-
-    // Avoid shift due to the default <body> margin. This does cause elements to be clipped
-    // with whitespace. Warn if <body> has margins?
-    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
-    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
-    const elementToLock = floatingUi_utils_dom.isOverflowElement(html) ? html : body;
-    updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
-
-    /*
-     * DOM writes:
-     * Do not read the DOM past this point!
-     */
-
-    if (updateGutterOnly) {
-      html.style.scrollbarGutter = scrollbarGutterValue;
-      elementToLock.style.overflowY = 'hidden';
-      elementToLock.style.overflowX = 'hidden';
-      return;
-    }
-    Object.assign(html.style, {
-      scrollbarGutter: scrollbarGutterValue,
-      overflowY: 'hidden',
-      overflowX: 'hidden'
-    });
-    if (isScrollableY || hasConstantOverflowY) {
-      html.style.overflowY = 'scroll';
-    }
-    if (isScrollableX || hasConstantOverflowX) {
-      html.style.overflowX = 'scroll';
-    }
-    Object.assign(body.style, {
-      position: 'relative',
-      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',
-      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',
-      boxSizing: 'border-box',
-      overflow: 'hidden',
-      scrollBehavior: 'unset'
-    });
-    body.scrollTop = scrollTop;
-    body.scrollLeft = scrollLeft;
-    html.setAttribute('data-base-ui-scroll-locked', '');
-    html.style.scrollBehavior = 'unset';
-  }
-  function cleanup() {
-    Object.assign(html.style, originalHtmlStyles);
-    Object.assign(body.style, originalBodyStyles);
-    if (!updateGutterOnly) {
-      html.scrollTop = scrollTop;
-      html.scrollLeft = scrollLeft;
-      html.removeAttribute('data-base-ui-scroll-locked');
-      html.style.scrollBehavior = originalHtmlScrollBehavior;
-    }
-  }
-  function handleResize() {
-    cleanup();
-    resizeFrame.request(lockScroll);
-  }
-  lockScroll();
-  win.addEventListener('resize', handleResize);
-  return () => {
-    resizeFrame.cancel();
-    cleanup();
-    // 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.
-    if (typeof win.removeEventListener === 'function') {
-      win.removeEventListener('resize', handleResize);
-    }
-  };
-}
-class ScrollLocker {
-  lockCount = 0;
-  restore = null;
-  timeoutLock = clamp.Timeout.create();
-  timeoutUnlock = clamp.Timeout.create();
-  acquire(referenceElement) {
-    this.lockCount += 1;
-    if (this.lockCount === 1 && this.restore === null) {
-      this.timeoutLock.start(0, () => this.lock(referenceElement));
-    }
-    return this.release;
-  }
-  release = () => {
-    this.lockCount -= 1;
-    if (this.lockCount === 0 && this.restore) {
-      this.timeoutUnlock.start(0, this.unlock);
-    }
-  };
-  unlock = () => {
-    if (this.lockCount === 0 && this.restore) {
-      this.restore?.();
-      this.restore = null;
-    }
-  };
-  lock(referenceElement) {
-    if (this.lockCount === 0 || this.restore !== null) {
-      return;
-    }
-    const doc = clamp.ownerDocument(referenceElement);
-    const html = doc.documentElement;
-    const htmlOverflowY = floatingUi_utils_dom.getWindow(html).getComputedStyle(html).overflowY;
-
-    // If the site author already hid overflow on <html>, respect it and bail out.
-    if (htmlOverflowY === 'hidden' || htmlOverflowY === 'clip') {
-      this.restore = useRenderElement.NOOP;
-      return;
-    }
-    const hasOverlayScrollbars = clamp.isIOS || !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
-    // being enabled to ensure it doesn't cause the following issues:
-    // - Textboxes must scroll into view when focused, nor cause a glitchy scroll animation.
-    // - The navbar must not force itself into view and cause layout shift.
-    // - Scroll containers must not flicker upon closing a popup when it has an exit animation.
-    this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);
-  }
-}
-const SCROLL_LOCKER = new ScrollLocker();
-
-/**
- * Locks the scroll of the document when enabled.
- *
- * @param enabled - Whether to enable the scroll lock.
- * @param referenceElement - Element to use as a reference for lock calculations.
- */
-function useScrollLock(enabled = true, referenceElement = null) {
-  clamp.useIsoLayoutEffect(() => {
-    if (!enabled) {
-      return undefined;
-    }
-    return SCROLL_LOCKER.acquire(referenceElement);
-  }, [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";
-
 const DialogRootContext = /*#__PURE__*/React__namespace.createContext(undefined);
 if (process.env.NODE_ENV !== "production") DialogRootContext.displayName = "DialogRootContext";
 function useDialogRootContext(optional) {
@@ -4658,8 +463,8 @@ let DrawerBackdropCssVars = /*#__PURE__*/function (DrawerBackdropCssVars) {
 }({});
 
 const stateAttributesMapping$1 = {
-  ...popupStateMapping,
-  ...clamp.transitionStatusMapping
+  ...InternalBackdrop.popupStateMapping,
+  ...useButton.transitionStatusMapping
 };
 
 /**
@@ -4741,19 +546,19 @@ let DrawerPopupDataAttributes = function (DrawerPopupDataAttributes) {
   /**
    * Present when the drawer is open.
    */
-  DrawerPopupDataAttributes[DrawerPopupDataAttributes["open"] = CommonPopupDataAttributes.open] = "open";
+  DrawerPopupDataAttributes[DrawerPopupDataAttributes["open"] = InternalBackdrop.CommonPopupDataAttributes.open] = "open";
   /**
    * Present when the drawer is closed.
    */
-  DrawerPopupDataAttributes[DrawerPopupDataAttributes["closed"] = CommonPopupDataAttributes.closed] = "closed";
+  DrawerPopupDataAttributes[DrawerPopupDataAttributes["closed"] = InternalBackdrop.CommonPopupDataAttributes.closed] = "closed";
   /**
    * Present when the drawer is animating in.
    */
-  DrawerPopupDataAttributes[DrawerPopupDataAttributes["startingStyle"] = CommonPopupDataAttributes.startingStyle] = "startingStyle";
+  DrawerPopupDataAttributes[DrawerPopupDataAttributes["startingStyle"] = InternalBackdrop.CommonPopupDataAttributes.startingStyle] = "startingStyle";
   /**
    * Present when the drawer is animating out.
    */
-  DrawerPopupDataAttributes[DrawerPopupDataAttributes["endingStyle"] = CommonPopupDataAttributes.endingStyle] = "endingStyle";
+  DrawerPopupDataAttributes[DrawerPopupDataAttributes["endingStyle"] = InternalBackdrop.CommonPopupDataAttributes.endingStyle] = "endingStyle";
   /**
    * Present when the drawer is at the expanded (full-height) snap point.
    */
@@ -4863,8 +668,8 @@ function useDrawerSnapPoints() {
   const viewportElement = store.useState('viewportElement');
   const [viewportHeight, setViewportHeight] = React__namespace.useState(0);
   const [rootFontSize, setRootFontSize] = React__namespace.useState(16);
-  const measureViewportHeight = clamp.useStableCallback(() => {
-    const doc = clamp.ownerDocument(viewportElement);
+  const measureViewportHeight = useButton.useStableCallback(() => {
+    const doc = useButton.ownerDocument(viewportElement);
     const html = doc.documentElement;
     if (viewportElement) {
       setViewportHeight(viewportElement.offsetHeight);
@@ -4877,7 +682,7 @@ function useDrawerSnapPoints() {
       setRootFontSize(fontSize);
     }
   });
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     measureViewportHeight();
     if (!viewportElement || typeof ResizeObserver !== 'function') {
       return undefined;
@@ -5018,8 +823,8 @@ function removeCSSVariableInheritance$1() {
   drawerSwipeVarsRegistered = true;
 }
 const stateAttributesMapping = {
-  ...popupStateMapping,
-  ...clamp.transitionStatusMapping,
+  ...InternalBackdrop.popupStateMapping,
+  ...useButton.transitionStatusMapping,
   expanded(value) {
     return value ? {
       [DrawerPopupDataAttributes.expanded]: ''
@@ -5099,7 +904,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
   useDialogPortalContext();
   const [popupHeight, setPopupHeight] = React__namespace.useState(0);
   const popupHeightRef = React__namespace.useRef(0);
-  const measureHeight = clamp.useStableCallback(() => {
+  const measureHeight = useButton.useStableCallback(() => {
     const popupElement = store.context.popupRef.current;
     if (!popupElement) {
       return;
@@ -5125,7 +930,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
     setPopupHeight(nextHeight);
     onPopupHeightChange(nextHeight);
   });
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     if (!mounted) {
       popupHeightRef.current = 0;
       setPopupHeight(0);
@@ -5147,7 +952,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       resizeObserver.disconnect();
     };
   }, [measureHeight, mounted, nestedDrawerOpen, onPopupHeightChange, store.context.popupRef]);
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     const popupRef = store.context.popupRef;
     const syncNestedSwipeProgress = () => {
       const popupElement = popupRef.current;
@@ -5190,7 +995,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       notifyParentHasNestedDrawer(false);
     };
   }, [notifyParentHasNestedDrawer, open, transitionStatus]);
-  clamp.useOpenChangeComplete({
+  useButton.useOpenChangeComplete({
     open,
     ref: store.context.popupRef,
     onComplete() {
@@ -5268,7 +1073,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
     ref: [forwardedRef, store.context.popupRef, store.useStateSetter('popupElement')],
     stateAttributesMapping
   });
-  return /*#__PURE__*/jsxRuntime.jsx(FloatingFocusManager, {
+  return /*#__PURE__*/jsxRuntime.jsx(InternalBackdrop.FloatingFocusManager, {
     context: floatingRootContext,
     openInteractionType: openMethod,
     disabled: !mounted,
@@ -5299,12 +1104,12 @@ const DialogPortal = /*#__PURE__*/React__namespace.forwardRef(function DialogPor
   }
   return /*#__PURE__*/jsxRuntime.jsx(DialogPortalContext.Provider, {
     value: keepMounted,
-    children: /*#__PURE__*/jsxRuntime.jsxs(FloatingPortal, {
+    children: /*#__PURE__*/jsxRuntime.jsxs(InternalBackdrop.FloatingPortal, {
       ref: forwardedRef,
       ...portalProps,
-      children: [mounted && modal === true && /*#__PURE__*/jsxRuntime.jsx(InternalBackdrop, {
+      children: [mounted && modal === true && /*#__PURE__*/jsxRuntime.jsx(InternalBackdrop.InternalBackdrop, {
         ref: store.context.internalBackdropRef,
-        inert: inertValue(!open)
+        inert: InternalBackdrop.inertValue(!open)
       }), props.children]
     })
   });
@@ -5333,20 +1138,20 @@ function useDialogRoot(params) {
   const {
     openMethod,
     triggerProps
-  } = useOpenInteractionType(open);
+  } = InternalBackdrop.useOpenInteractionType(open);
   useImplicitActiveTrigger(store);
   const {
     forceUnmount
   } = useOpenStateTransitions(open, store);
-  const createDialogEventDetails = clamp.useStableCallback(reason => {
-    const details = clamp.createChangeEventDetails(reason);
+  const createDialogEventDetails = useButton.useStableCallback(reason => {
+    const details = useButton.createChangeEventDetails(reason);
     details.preventUnmountOnClose = () => {
       store.set('preventUnmountingOnClose', true);
     };
     return details;
   });
   const handleImperativeClose = React__namespace.useCallback(() => {
-    store.setOpen(false, createDialogEventDetails(clamp.imperativeAction));
+    store.setOpen(false, createDialogEventDetails(useButton.imperativeAction));
   }, [store, createDialogEventDetails]);
   React__namespace.useImperativeHandle(actionsRef, () => ({
     unmount: forceUnmount,
@@ -5361,7 +1166,7 @@ function useDialogRoot(params) {
   const [ownNestedOpenDialogs, setOwnNestedOpenDialogs] = React__namespace.useState(0);
   const isTopmost = ownNestedOpenDialogs === 0;
   const role = useRole(floatingRootContext);
-  const dismiss = useDismiss(floatingRootContext, {
+  const dismiss = InternalBackdrop.useDismiss(floatingRootContext, {
     outsidePressEvent() {
       if (store.context.internalBackdropRef.current || store.context.backdropRef.current) {
         return 'intentional';
@@ -5386,14 +1191,14 @@ function useDialogRoot(params) {
       if ('touches' in event && event.touches.length !== 1) {
         return false;
       }
-      const target = clamp.getTarget(event);
+      const target = useButton.getTarget(event);
       if (isTopmost && !disablePointerDismissal) {
         const eventTarget = target;
         // Only close if the click occurred on the dialog's owning backdrop.
         // This supports multiple modal dialogs that aren't nested in the React tree:
         // https://github.com/mui/base-ui/issues/1320
         if (modal) {
-          return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === eventTarget || store.context.backdropRef.current === eventTarget || clamp.contains(eventTarget, popupElement) && !eventTarget?.hasAttribute('data-base-ui-portal') : true;
+          return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === eventTarget || store.context.backdropRef.current === eventTarget || useButton.contains(eventTarget, popupElement) && !eventTarget?.hasAttribute('data-base-ui-portal') : true;
         }
         return true;
       }
@@ -5401,12 +1206,12 @@ function useDialogRoot(params) {
     },
     escapeKey: isTopmost
   });
-  useScrollLock(open && modal === true, popupElement);
+  InternalBackdrop.useScrollLock(open && modal === true, popupElement);
   const {
     getReferenceProps,
     getFloatingProps,
     getTriggerProps
-  } = useInteractions([role, dismiss]);
+  } = InternalBackdrop.useInteractions([role, dismiss]);
 
   // Listen for nested open/close events on this store to maintain the count
   store.useContextCallback('onNestedDialogOpen', ownChildrenCount => {
@@ -5445,17 +1250,17 @@ function useDialogRoot(params) {
 
 const selectors = {
   ...popupStoreSelectors,
-  modal: createSelector(state => state.modal),
-  nested: createSelector(state => state.nested),
-  nestedOpenDialogCount: createSelector(state => state.nestedOpenDialogCount),
-  disablePointerDismissal: createSelector(state => state.disablePointerDismissal),
-  openMethod: createSelector(state => state.openMethod),
-  descriptionElementId: createSelector(state => state.descriptionElementId),
-  titleElementId: createSelector(state => state.titleElementId),
-  viewportElement: createSelector(state => state.viewportElement),
-  role: createSelector(state => state.role)
+  modal: InternalBackdrop.createSelector(state => state.modal),
+  nested: InternalBackdrop.createSelector(state => state.nested),
+  nestedOpenDialogCount: InternalBackdrop.createSelector(state => state.nestedOpenDialogCount),
+  disablePointerDismissal: InternalBackdrop.createSelector(state => state.disablePointerDismissal),
+  openMethod: InternalBackdrop.createSelector(state => state.openMethod),
+  descriptionElementId: InternalBackdrop.createSelector(state => state.descriptionElementId),
+  titleElementId: InternalBackdrop.createSelector(state => state.titleElementId),
+  viewportElement: InternalBackdrop.createSelector(state => state.viewportElement),
+  role: InternalBackdrop.createSelector(state => state.role)
 };
-class DialogStore extends ReactStore {
+class DialogStore extends InternalBackdrop.ReactStore {
   constructor(initialState) {
     super(createInitialState(initialState), {
       popupRef: /*#__PURE__*/React__namespace.createRef(),
@@ -5464,7 +1269,7 @@ class DialogStore extends ReactStore {
       outsidePressEnabledRef: {
         current: true
       },
-      triggerElements: new PopupTriggerMap(),
+      triggerElements: new InternalBackdrop.PopupTriggerMap(),
       onOpenChange: undefined,
       onOpenChangeComplete: undefined
     }, selectors);
@@ -5555,7 +1360,7 @@ function DialogRoot(props) {
   }).current;
 
   // Support initially open state when uncontrolled
-  useOnFirstRender(() => {
+  InternalBackdrop.useOnFirstRender(() => {
     if (openProp === undefined && store.state.open === false && defaultOpen === true) {
       store.update({
         open: true,
@@ -5613,7 +1418,7 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
   if (!store) {
     throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: <Dialog.Trigger> must be used within <Dialog.Root> or provided with a handle.' : useRenderElement.formatErrorMessage(79));
   }
-  const thisTriggerId = clamp.useBaseUiId(idProp);
+  const thisTriggerId = useButton.useBaseUiId(idProp);
   const floatingContext = store.useState('floatingRootContext');
   const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);
   const triggerElementRef = React__namespace.useRef(null);
@@ -5626,14 +1431,14 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
   const {
     getButtonProps,
     buttonRef
-  } = clamp.useButton({
+  } = useButton.useButton({
     disabled,
     native: nativeButton
   });
-  const click = useClick(floatingContext, {
+  const click = InternalBackdrop.useClick(floatingContext, {
     enabled: floatingContext != null
   });
-  const localInteractionProps = useInteractions([click]);
+  const localInteractionProps = InternalBackdrop.useInteractions([click]);
   const state = {
     disabled,
     open: isOpenedByThisTrigger
@@ -5643,10 +1448,10 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
     state,
     ref: [buttonRef, forwardedRef, registerTrigger, triggerElementRef],
     props: [localInteractionProps.getReferenceProps(), rootTriggerProps, {
-      [CLICK_TRIGGER_IDENTIFIER]: '',
+      [InternalBackdrop.CLICK_TRIGGER_IDENTIFIER]: '',
       id: thisTriggerId
     }, elementProps, getButtonProps],
-    stateAttributesMapping: triggerOpenStateMapping
+    stateAttributesMapping: InternalBackdrop.triggerOpenStateMapping
   });
 });
 if (process.env.NODE_ENV !== "production") DialogTrigger.displayName = "DialogTrigger";
@@ -5678,7 +1483,7 @@ function DrawerRoot(props) {
     defaultSnapPoint,
     onSnapPointChange: onSnapPointChangeProp
   } = props;
-  const onSnapPointChange = clamp.useStableCallback(onSnapPointChangeProp);
+  const onSnapPointChange = useButton.useStableCallback(onSnapPointChangeProp);
   const parentDrawerRootContext = useDrawerRootContext(true);
   const notifyParentSwipeProgressChange = parentDrawerRootContext?.onNestedSwipeProgressChange;
   const notifyParentFrontmostHeight = parentDrawerRootContext?.onNestedFrontmostHeightChange;
@@ -5691,15 +1496,15 @@ function DrawerRoot(props) {
   const [nestedSwipeProgressStore] = React__namespace.useState(createNestedSwipeProgressStore);
   const resolvedDefaultSnapPoint = defaultSnapPoint !== undefined ? defaultSnapPoint : snapPoints?.[0] ?? null;
   const isSnapPointControlled = snapPointProp !== undefined;
-  const [activeSnapPoint, setActiveSnapPointUnwrapped] = clamp.useControlled({
+  const [activeSnapPoint, setActiveSnapPointUnwrapped] = useButton.useControlled({
     controlled: snapPointProp,
     default: resolvedDefaultSnapPoint,
     name: 'Drawer',
     state: 'snapPoint'
   });
   const isNestedDrawerOpenRef = React__namespace.useRef(false);
-  const setActiveSnapPoint = clamp.useStableCallback((nextSnapPoint, eventDetails) => {
-    const resolvedEventDetails = eventDetails ?? clamp.createChangeEventDetails(clamp.none);
+  const setActiveSnapPoint = useButton.useStableCallback((nextSnapPoint, eventDetails) => {
+    const resolvedEventDetails = eventDetails ?? useButton.createChangeEventDetails(useButton.none);
     onSnapPointChange?.(nextSnapPoint, resolvedEventDetails);
     if (resolvedEventDetails.isCanceled) {
       return;
@@ -5718,13 +1523,13 @@ function DrawerRoot(props) {
     }
     return activeSnapPoint;
   }, [activeSnapPoint, isSnapPointControlled, resolvedDefaultSnapPoint, snapPoints]);
-  const onPopupHeightChange = clamp.useStableCallback(height => {
+  const onPopupHeightChange = useButton.useStableCallback(height => {
     setPopupHeight(height);
     if (!isNestedDrawerOpenRef.current && height > 0) {
       setFrontmostHeight(height);
     }
   });
-  const onNestedFrontmostHeightChange = clamp.useStableCallback(height => {
+  const onNestedFrontmostHeightChange = useButton.useStableCallback(height => {
     if (height > 0) {
       isNestedDrawerOpenRef.current = true;
       setFrontmostHeight(height);
@@ -5735,24 +1540,24 @@ function DrawerRoot(props) {
       setFrontmostHeight(popupHeight);
     }
   });
-  const onNestedDrawerPresenceChange = clamp.useStableCallback(present => {
+  const onNestedDrawerPresenceChange = useButton.useStableCallback(present => {
     setHasNestedDrawer(present);
   });
-  const onNestedSwipeProgressChange = clamp.useStableCallback(progress => {
+  const onNestedSwipeProgressChange = useButton.useStableCallback(progress => {
     nestedSwipeProgressStore.set(progress);
     notifyParentSwipeProgressChange?.(progress);
   });
-  const onNestedSwipingChange = clamp.useStableCallback(swiping => {
+  const onNestedSwipingChange = useButton.useStableCallback(swiping => {
     setNestedSwiping(swiping);
     notifyParentSwipingChange?.(swiping);
   });
-  const handleOpenChange = clamp.useStableCallback((nextOpen, eventDetails) => {
+  const handleOpenChange = useButton.useStableCallback((nextOpen, eventDetails) => {
     onOpenChange?.(nextOpen, eventDetails);
     if (eventDetails.isCanceled) {
       return;
     }
     if (!nextOpen && snapPoints && snapPoints.length > 0) {
-      setActiveSnapPoint(resolvedDefaultSnapPoint, clamp.createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
+      setActiveSnapPoint(resolvedDefaultSnapPoint, useButton.createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
     }
   });
   const contextValue = React__namespace.useMemo(() => ({
@@ -5822,7 +1627,7 @@ function createNestedSwipeProgressStore() {
   };
 }
 function DrawerProviderReporter() {
-  const drawerId = clamp.useId();
+  const drawerId = useButton.useId();
   const providerContext = useDrawerProviderContext();
   const dialogRootContext = useDialogRootContext(false);
   const open = dialogRootContext.store.useState('open');
@@ -5846,7 +1651,7 @@ function DrawerProviderReporter() {
   React__namespace.useEffect(() => {
     // CloseWatcher enables the Android back gesture (Chromium-only).
     // Keep this Android-only for now to avoid interfering with Escape/nesting semantics on desktop due to `useDismiss`.
-    if (!open || !isTopmost || !clamp.isAndroid) {
+    if (!open || !isTopmost || !useButton.isAndroid) {
       return undefined;
     }
     const win = floatingUi_utils_dom.getWindow(popupElement);
@@ -5858,7 +1663,7 @@ function DrawerProviderReporter() {
       if (!dialogRootContext.store.select('open')) {
         return;
       }
-      dialogRootContext.store.setOpen(false, clamp.createChangeEventDetails(clamp.closeWatcher, event));
+      dialogRootContext.store.setOpen(false, useButton.createChangeEventDetails(useButton.closeWatcher, event));
     }
     const closeWatcher = new CloseWatcherCtor();
     closeWatcher.addEventListener('close', handleCloseWatcher);
@@ -6078,9 +1883,9 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
     ...elementProps
   } = componentProps;
   const overflowEdgeThreshold = normalizeOverflowEdgeThreshold(overflowEdgeThresholdProp);
-  const rootId = clamp.useBaseUiId();
-  const scrollYTimeout = clamp.useTimeout();
-  const scrollXTimeout = clamp.useTimeout();
+  const rootId = useButton.useBaseUiId();
+  const scrollYTimeout = useButton.useTimeout();
+  const scrollXTimeout = useButton.useTimeout();
   const {
     nonce,
     disableStyleElements
@@ -6108,7 +1913,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
   const startScrollLeftRef = React__namespace.useRef(0);
   const currentOrientationRef = React__namespace.useRef('vertical');
   const scrollPositionRef = React__namespace.useRef(DEFAULT_COORDS);
-  const handleScroll = clamp.useStableCallback(scrollPosition => {
+  const handleScroll = useButton.useStableCallback(scrollPosition => {
     const offsetX = scrollPosition.x - scrollPositionRef.current.x;
     const offsetY = scrollPosition.y - scrollPositionRef.current.y;
     scrollPositionRef.current = scrollPosition;
@@ -6125,7 +1930,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       });
     }
   });
-  const handlePointerDown = clamp.useStableCallback(event => {
+  const handlePointerDown = useButton.useStableCallback(event => {
     if (event.button !== 0) {
       return;
     }
@@ -6144,7 +1949,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       thumbXRef.current.setPointerCapture(event.pointerId);
     }
   });
-  const handlePointerMove = clamp.useStableCallback(event => {
+  const handlePointerMove = useButton.useStableCallback(event => {
     if (!thumbDraggingRef.current) {
       return;
     }
@@ -6183,7 +1988,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       }
     }
   });
-  const handlePointerUp = clamp.useStableCallback(event => {
+  const handlePointerUp = useButton.useStableCallback(event => {
     thumbDraggingRef.current = false;
     if (thumbYRef.current && currentOrientationRef.current === 'vertical') {
       thumbYRef.current.releasePointerCapture(event.pointerId);
@@ -6198,7 +2003,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
   function handlePointerEnterOrMove(event) {
     handleTouchModalityChange(event);
     if (event.pointerType !== 'touch') {
-      const isTargetRootChild = clamp.contains(rootRef.current, event.target);
+      const isTargetRootChild = useButton.contains(rootRef.current, event.target);
       setHovering(isTargetRootChild);
     }
   }
@@ -6381,7 +2186,7 @@ function removeCSSVariableInheritance() {
   if (scrollAreaOverflowVarsRegistered ||
   // When `inherits: false`, specifying `inherit` on child elements doesn't work
   // in Safari. To let CSS features work correctly, this optimization must be skipped.
-  clamp.isWebKit) {
+  useButton.isWebKit) {
     return;
   }
   if (typeof CSS !== 'undefined' && 'registerProperty' in CSS) {
@@ -6435,12 +2240,12 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
     scrollingX,
     scrollingY
   } = useScrollAreaRootContext();
-  const direction = useDirection();
+  const direction = InternalBackdrop.useDirection();
   const programmaticScrollRef = React__namespace.useRef(true);
   const lastMeasuredViewportMetricsRef = React__namespace.useRef([NaN, NaN, NaN, NaN]);
-  const scrollEndTimeout = clamp.useTimeout();
-  const waitForAnimationsTimeout = clamp.useTimeout();
-  const computeThumbPosition = clamp.useStableCallback(() => {
+  const scrollEndTimeout = useButton.useTimeout();
+  const waitForAnimationsTimeout = useButton.useTimeout();
+  const computeThumbPosition = useButton.useStableCallback(() => {
     const viewportEl = viewportRef.current;
     const scrollbarYEl = scrollbarYRef.current;
     const scrollbarXEl = scrollbarXRef.current;
@@ -6578,7 +2383,7 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
       return nextOverflowEdges;
     });
   });
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     if (!viewportRef.current) {
       return undefined;
     }
@@ -6590,11 +2395,11 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
       computeThumbPosition();
     });
   }, [computeThumbPosition, viewportRef]);
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     // Wait for scrollbar and thumb refs after hidden-state toggles, and refresh math on direction flips.
     queueMicrotask(computeThumbPosition);
   }, [computeThumbPosition, hiddenState, direction]);
-  clamp.useIsoLayoutEffect(() => {
+  useButton.useIsoLayoutEffect(() => {
     // `onMouseEnter` doesn't fire upon load, so we need to check if the viewport is already
     // being hovered.
     if (viewportRef.current?.matches(':hover')) {
@@ -6727,12 +2532,8 @@ function mergeHiddenState(prevState, nextState) {
   return nextState;
 }
 
-exports.BASE_UI_SWIPE_IGNORE_SELECTOR = BASE_UI_SWIPE_IGNORE_SELECTOR;
 exports.COMPOSITE_KEYS = COMPOSITE_KEYS;
-exports.CommonPopupDataAttributes = CommonPopupDataAttributes;
-exports.DISABLED_TRANSITIONS_STYLE = DISABLED_TRANSITIONS_STYLE;
 exports.DRAWER_CONTENT_ATTRIBUTE = DRAWER_CONTENT_ATTRIBUTE;
-exports.DROPDOWN_COLLISION_AVOIDANCE = DROPDOWN_COLLISION_AVOIDANCE;
 exports.DialogStore = DialogStore;
 exports.DrawerBackdrop = DrawerBackdrop;
 exports.DrawerBackdropCssVars = DrawerBackdropCssVars;
@@ -6745,72 +2546,23 @@ exports.DrawerProviderContext = DrawerProviderContext;
 exports.DrawerRoot = DrawerRoot;
 exports.DrawerTrigger = DrawerTrigger;
 exports.DrawerViewportContext = DrawerViewportContext;
-exports.FloatingFocusManager = FloatingFocusManager;
-exports.FloatingNode = FloatingNode;
-exports.FloatingPortal = FloatingPortal;
-exports.FloatingRootStore = FloatingRootStore;
-exports.FloatingTree = FloatingTree;
-exports.FloatingTreeStore = FloatingTreeStore;
-exports.FocusGuard = FocusGuard;
-exports.InternalBackdrop = InternalBackdrop;
-exports.PATIENT_CLICK_THRESHOLD = PATIENT_CLICK_THRESHOLD;
-exports.POPUP_COLLISION_AVOIDANCE = POPUP_COLLISION_AVOIDANCE;
-exports.PopupTriggerMap = PopupTriggerMap;
-exports.ReactStore = ReactStore;
 exports.ScrollAreaRoot = ScrollAreaRoot;
 exports.ScrollAreaRootCssVars = ScrollAreaRootCssVars;
 exports.ScrollAreaViewport = ScrollAreaViewport;
-exports.Store = Store;
-exports.TYPEAHEAD_RESET_MS = TYPEAHEAD_RESET_MS;
-exports.createAttribute = createAttribute;
-exports.createGridCellMap = createGridCellMap;
 exports.createInitialPopupStoreState = createInitialPopupStoreState;
-exports.createSelector = createSelector;
-exports.enqueueFocus = enqueueFocus;
-exports.fastComponent = fastComponent;
-exports.fastComponentRef = fastComponentRef;
-exports.findNonDisabledListIndex = findNonDisabledListIndex;
-exports.getGridCellIndexOfCorner = getGridCellIndexOfCorner;
-exports.getGridCellIndices = getGridCellIndices;
-exports.getGridNavigatedIndex = getGridNavigatedIndex;
-exports.getMaxListIndex = getMaxListIndex;
-exports.getMinListIndex = getMinListIndex;
-exports.getNextTabbable = getNextTabbable;
-exports.getNodeChildren = getNodeChildren;
 exports.getOffset = getOffset;
-exports.getTabbableAfterElement = getTabbableAfterElement;
-exports.getTabbableBeforeElement = getTabbableBeforeElement;
-exports.inertValue = inertValue;
-exports.isElementVisible = isElementVisible;
-exports.isIndexOutOfListBounds = isIndexOutOfListBounds;
-exports.isListIndexDisabled = isListIndexDisabled;
-exports.isOutsideEvent = isOutsideEvent;
-exports.popupStateMapping = popupStateMapping;
 exports.popupStoreSelectors = popupStoreSelectors;
-exports.pressableTriggerOpenStateMapping = pressableTriggerOpenStateMapping;
 exports.scrollAreaStateAttributesMapping = scrollAreaStateAttributesMapping;
-exports.triggerOpenStateMapping = triggerOpenStateMapping;
-exports.useClick = useClick;
 exports.useDialogPortalContext = useDialogPortalContext;
 exports.useDialogRootContext = useDialogRootContext;
-exports.useDirection = useDirection;
-exports.useDismiss = useDismiss;
 exports.useDrawerProviderContext = useDrawerProviderContext;
 exports.useDrawerRootContext = useDrawerRootContext;
 exports.useDrawerSnapPoints = useDrawerSnapPoints;
-exports.useFloatingNodeId = useFloatingNodeId;
-exports.useFloatingParentNodeId = useFloatingParentNodeId;
-exports.useFloatingTree = useFloatingTree;
 exports.useImplicitActiveTrigger = useImplicitActiveTrigger;
-exports.useInteractions = useInteractions;
-exports.useOnFirstRender = useOnFirstRender;
-exports.useOpenInteractionType = useOpenInteractionType;
 exports.useOpenStateTransitions = useOpenStateTransitions;
 exports.useRole = useRole;
 exports.useScrollAreaRootContext = useScrollAreaRootContext;
 exports.useScrollAreaViewportContext = useScrollAreaViewportContext;
-exports.useScrollLock = useScrollLock;
-exports.useStore = useStore;
 exports.useSyncedFloatingRootContext = useSyncedFloatingRootContext;
 exports.useTriggerDataForwarding = useTriggerDataForwarding;
 exports.useTriggerRegistration = useTriggerRegistration;