@wix/site-ui 1.30.0 → 1.32.0

package/dist/3485.js

@@ -0,0 +1,854 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMergedRefs, NOOP } from "./8272.js";
+import { getWindow, isOverflowElement, getNodeName, isShadowRoot, isHTMLElement } from "./3829.js";
+import { ownerDocument } from "./9829.js";
+import { getTarget, contains, activeElement } from "./4549.js";
+import { CLICK_TRIGGER_IDENTIFIER, FocusGuard_FocusGuard, focusable, getPreviousTabbable, isTabbable, isOutsideEvent, tabbable, usePortalContext, getNextTabbable } from "./4388.js";
+import { useStableCallback } from "./7541.js";
+import { getFloatingFocusElement, isTypeableCombobox, isTypeableElement } from "./8758.js";
+import { useValueAsRef } from "./4707.js";
+import { useFloatingTree } from "./285.js";
+import { Timeout, useTimeout } from "./42.js";
+import { useAnimationFrame, AnimationFrame } from "./8996.js";
+import { stopEvent, isVirtualPointerEvent, isVirtualClick } from "./6330.js";
+import { addEventListener } from "./4723.js";
+import { mergeCleanups } from "./4495.js";
+import { getNodeAncestors, getNodeChildren, createAttribute } from "./5992.js";
+import { resolveRef } from "./880.js";
+import { isElementVisible } from "./3319.js";
+import { createChangeEventDetails } from "./4768.js";
+import { focusOut, triggerHover, outsidePress } from "./2418.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { isIOS, isWebKit } from "./8971.js";
+import { useValueChanged } from "./2801.js";
+import * as __rspack_external_react from "react";
+let rafId = 0;
+function enqueueFocus(el, options = {}) {
+    const { preventScroll = false, sync = false, shouldFocus } = options;
+    cancelAnimationFrame(rafId);
+    function exec() {
+        if (shouldFocus && !shouldFocus()) return;
+        el?.focus({
+            preventScroll
+        });
+    }
+    if (sync) {
+        exec();
+        return NOOP;
+    }
+    const currentRafId = requestAnimationFrame(exec);
+    rafId = currentRafId;
+    return ()=>{
+        if (rafId === currentRafId) {
+            cancelAnimationFrame(currentRafId);
+            rafId = 0;
+        }
+    };
+}
+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 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)=>null != x);
+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 ("script" === getNodeName(node)) return;
+            if (keepElements.has(node)) walk(node);
+            else outside.push(node);
+        });
+    };
+    walk(root);
+    return outside;
+};
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert, { mark = true, markerIgnoreElements = [] }) {
+    const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;
+    let counterMap = null;
+    let uncontrolledElementsSet = null;
+    const avoidElements = correctElements(body, uncorrectedAvoidElements);
+    const markerIgnoreTargets = mark ? correctElements(body, markerIgnoreElements) : [];
+    const markerIgnoreSet = new Set(markerIgnoreTargets);
+    const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)).filter((target)=>!markerIgnoreSet.has(target)) : [];
+    const hiddenElements = [];
+    const markedElements = [];
+    if (controlAttribute) {
+        const map = counters[controlAttribute];
+        const currentUncontrolledElementsSet = getUncontrolledElementsSet(controlAttribute);
+        uncontrolledElementsSet = currentUncontrolledElementsSet;
+        counterMap = map;
+        const ariaLiveElements = correctElements(body, Array.from(body.querySelectorAll('[aria-live]')));
+        const controlElements = avoidElements.concat(ariaLiveElements);
+        const controlTargets = collectOutsideElements(body, buildKeepSet(controlElements), new Set(controlElements));
+        controlTargets.forEach((node)=>{
+            const attr = node.getAttribute(controlAttribute);
+            const alreadyHidden = null !== attr && 'false' !== attr;
+            const counterValue = (map.get(node) || 0) + 1;
+            map.set(node, counterValue);
+            hiddenElements.push(node);
+            if (1 === counterValue && alreadyHidden) currentUncontrolledElementsSet.add(node);
+            if (!alreadyHidden) node.setAttribute(controlAttribute, 'inert' === controlAttribute ? '' : 'true');
+        });
+    }
+    if (mark) markerTargets.forEach((node)=>{
+        const markerValue = (markerCounterMap.get(node) || 0) + 1;
+        markerCounterMap.set(node, markerValue);
+        markedElements.push(node);
+        if (1 === markerValue) 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 = ownerDocument(avoidElements[0]).body;
+    return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, {
+        mark,
+        markerIgnoreElements
+    });
+}
+function getEventType(event, lastInteractionType) {
+    const win = getWindow(getTarget(event));
+    if (event instanceof win.KeyboardEvent) return 'keyboard';
+    if (event instanceof win.FocusEvent) return lastInteractionType || 'keyboard';
+    if ('pointerType' in event) return event.pointerType || 'keyboard';
+    if ('touches' in event) return 'touch';
+    if (event instanceof win.MouseEvent) return lastInteractionType || (0 === event.detail ? 'keyboard' : 'mouse');
+    return '';
+}
+const LIST_LIMIT = 20;
+let previouslyFocusedElements = [];
+function clearDisconnectedPreviouslyFocusedElements() {
+    previouslyFocusedElements = previouslyFocusedElements.filter((entry)=>entry.deref()?.isConnected);
+}
+function addPreviouslyFocusedElement(element) {
+    clearDisconnectedPreviouslyFocusedElements();
+    if (element && 'body' !== getNodeName(element)) {
+        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;
+    if (isTabbable(container)) return container;
+    return tabbable(container)[0] || container;
+}
+function handleTabIndex(floatingFocusElement, orderRef) {
+    if (floatingFocusElement.hasAttribute('tabindex') && !floatingFocusElement.hasAttribute('data-tabindex')) return;
+    if (!orderRef.current.includes('floating') && !floatingFocusElement.getAttribute('role')?.includes('dialog')) return;
+    const focusableElements = focusable(floatingFocusElement);
+    const tabbableContent = focusableElements.filter((element)=>{
+        const dataTabIndex = element.getAttribute('data-tabindex') || '';
+        return isTabbable(element) || element.hasAttribute('data-tabindex') && !dataTabIndex.startsWith('-');
+    });
+    const tabIndex = floatingFocusElement.getAttribute('tabindex');
+    if (orderRef.current.includes('floating') || 0 === tabbableContent.length) {
+        if ('0' !== tabIndex) floatingFocusElement.setAttribute('tabindex', '0');
+    } else if ('-1' !== tabIndex || floatingFocusElement.hasAttribute('data-tabindex') && '-1' !== floatingFocusElement.getAttribute('data-tabindex')) {
+        floatingFocusElement.setAttribute('tabindex', '-1');
+        floatingFocusElement.setAttribute('data-tabindex', '-1');
+    }
+}
+function FloatingFocusManager(props) {
+    const { context, children, disabled = false, initialFocus = true, returnFocus = true, restoreFocus = false, modal = true, closeOnFocusOut = true, openInteractionType = '', nextFocusableElement, previousFocusableElement, beforeContentFocusGuardRef, externalTree, getInsideElements } = props;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const open = store.useState('open');
+    const domReference = store.useState('domReferenceElement');
+    const floating = store.useState('floatingElement');
+    const { events, dataRef } = store.context;
+    const getNodeId = useStableCallback(()=>dataRef.current.floatingContext?.nodeId);
+    const ignoreInitialFocus = false === initialFocus;
+    const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
+    const orderRef = __rspack_external_react.useRef([
+        'content'
+    ]);
+    const initialFocusRef = useValueAsRef(initialFocus);
+    const returnFocusRef = useValueAsRef(returnFocus);
+    const openInteractionTypeRef = useValueAsRef(openInteractionType);
+    const tree = useFloatingTree(externalTree);
+    const portalContext = usePortalContext();
+    const preventReturnFocusRef = __rspack_external_react.useRef(false);
+    const isPointerDownRef = __rspack_external_react.useRef(false);
+    const pointerDownOutsideRef = __rspack_external_react.useRef(false);
+    const lastFocusedTabbableRef = __rspack_external_react.useRef(null);
+    const closeTypeRef = __rspack_external_react.useRef('');
+    const lastInteractionTypeRef = __rspack_external_react.useRef('');
+    const beforeGuardRef = __rspack_external_react.useRef(null);
+    const afterGuardRef = __rspack_external_react.useRef(null);
+    const mergedBeforeGuardRef = useMergedRefs(beforeGuardRef, beforeContentFocusGuardRef, portalContext?.beforeInsideRef);
+    const mergedAfterGuardRef = useMergedRefs(afterGuardRef, portalContext?.afterInsideRef);
+    const blurTimeout = useTimeout();
+    const pointerDownTimeout = useTimeout();
+    const restoreFocusFrame = useAnimationFrame();
+    const isInsidePortal = null != portalContext;
+    const floatingFocusElement = getFloatingFocusElement(floating);
+    const getTabbableContent = useStableCallback((container = floatingFocusElement)=>container ? tabbable(container) : []);
+    const getResolvedInsideElements = useStableCallback(()=>getInsideElements?.().filter((element)=>null != element) ?? []);
+    __rspack_external_react.useEffect(()=>{
+        if (disabled || !modal) return;
+        function onKeyDown(event) {
+            if ('Tab' === event.key) {
+                if (contains(floatingFocusElement, activeElement(ownerDocument(floatingFocusElement))) && 0 === getTabbableContent().length && !isUntrappedTypeableCombobox) stopEvent(event);
+            }
+        }
+        const doc = ownerDocument(floatingFocusElement);
+        return addEventListener(doc, 'keydown', onKeyDown);
+    }, [
+        disabled,
+        floatingFocusElement,
+        modal,
+        isUntrappedTypeableCombobox,
+        getTabbableContent
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (disabled || !open) return;
+        const doc = ownerDocument(floatingFocusElement);
+        function clearPointerDownOutside() {
+            pointerDownOutsideRef.current = false;
+        }
+        function onPointerDown(event) {
+            const target = getTarget(event);
+            const insideElements = getResolvedInsideElements();
+            const pointerTargetInside = contains(floating, target) || contains(domReference, target) || contains(portalContext?.portalNode, target) || insideElements.some((element)=>element === target || 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';
+        }
+        return mergeCleanups(addEventListener(doc, 'pointerdown', onPointerDown, true), addEventListener(doc, 'pointerup', clearPointerDownOutside, true), addEventListener(doc, 'pointercancel', clearPointerDownOutside, true), addEventListener(doc, 'keydown', onKeyDown, true));
+    }, [
+        disabled,
+        floating,
+        domReference,
+        floatingFocusElement,
+        open,
+        portalContext,
+        getResolvedInsideElements
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (disabled || !closeOnFocusOut) return;
+        const doc = ownerDocument(floatingFocusElement);
+        function handlePointerDown() {
+            isPointerDownRef.current = true;
+            pointerDownTimeout.start(0, ()=>{
+                isPointerDownRef.current = false;
+            });
+        }
+        function handleFocusIn(event) {
+            const target = getTarget(event);
+            if (isTabbable(target)) lastFocusedTabbableRef.current = target;
+        }
+        function handleFocusOutside(event) {
+            const relatedTarget = event.relatedTarget;
+            const currentTarget = event.currentTarget;
+            const target = 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,
+                    resolveRef(previousFocusableElement),
+                    resolveRef(nextFocusableElement)
+                ].includes(relatedTarget);
+                const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || insideElements.some((element)=>element === relatedTarget || contains(element, relatedTarget)) || null != relatedTarget && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement((trigger)=>contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find((node)=>contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find((node)=>[
+                        node.context?.elements.floating,
+                        getFloatingFocusElement(node.context?.elements.floating)
+                    ].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
+                if (currentTarget === domReference && floatingFocusElement) handleTabIndex(floatingFocusElement, orderRef);
+                if (restoreFocus && currentTarget !== domReference && !isElementVisible(target) && activeElement(doc) === doc.body) {
+                    if (isHTMLElement(floatingFocusElement)) {
+                        floatingFocusElement.focus();
+                        if ('popup' === restoreFocus) return void restoreFocusFrame.request(()=>{
+                            floatingFocusElement.focus();
+                        });
+                    }
+                    const tabbableContent = getTabbableContent();
+                    const prevTabbable = lastFocusedTabbableRef.current;
+                    const nodeToFocus = (prevTabbable && tabbableContent.includes(prevTabbable) ? prevTabbable : null) || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
+                    if (isHTMLElement(nodeToFocus)) nodeToFocus.focus();
+                }
+                if (dataRef.current.insideReactTree) {
+                    dataRef.current.insideReactTree = false;
+                    return;
+                }
+                if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && (isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {
+                    preventReturnFocusRef.current = true;
+                    store.setOpen(false, createChangeEventDetails(focusOut, event));
+                }
+            });
+        }
+        function markInsideReactTree() {
+            if (pointerDownOutsideRef.current) return;
+            dataRef.current.insideReactTree = true;
+            blurTimeout.start(0, ()=>{
+                dataRef.current.insideReactTree = false;
+            });
+        }
+        const domReferenceElement = isHTMLElement(domReference) ? domReference : null;
+        if (!floating && !domReferenceElement) return;
+        return mergeCleanups(domReferenceElement && addEventListener(domReferenceElement, 'focusout', handleFocusOutside), domReferenceElement && addEventListener(domReferenceElement, 'pointerdown', handlePointerDown), floating && addEventListener(floating, 'focusin', handleFocusIn), floating && addEventListener(floating, 'focusout', handleFocusOutside), floating && portalContext && addEventListener(floating, 'focusout', markInsideReactTree, true));
+    }, [
+        disabled,
+        domReference,
+        floating,
+        floatingFocusElement,
+        modal,
+        tree,
+        portalContext,
+        store,
+        closeOnFocusOut,
+        restoreFocus,
+        getTabbableContent,
+        isUntrappedTypeableCombobox,
+        getNodeId,
+        orderRef,
+        dataRef,
+        blurTimeout,
+        pointerDownTimeout,
+        restoreFocusFrame,
+        nextFocusableElement,
+        previousFocusableElement,
+        getResolvedInsideElements
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (disabled || !floating || !open) return;
+        const portalNodes = Array.from(portalContext?.portalNode?.querySelectorAll(`[${createAttribute('portal')}]`) || []);
+        const ancestors = tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : [];
+        const rootAncestorComboboxDomReference = ancestors.find((node)=>isTypeableCombobox(node.context?.elements.domReference || null))?.context?.elements.domReference;
+        const controlInsideElements = [
+            floating,
+            ...portalNodes,
+            beforeGuardRef.current,
+            afterGuardRef.current,
+            portalContext?.beforeOutsideRef.current,
+            portalContext?.afterOutsideRef.current,
+            ...getResolvedInsideElements()
+        ];
+        const insideElements = [
+            ...controlInsideElements,
+            rootAncestorComboboxDomReference,
+            resolveRef(previousFocusableElement),
+            resolveRef(nextFocusableElement),
+            isUntrappedTypeableCombobox ? domReference : null
+        ].filter((x)=>null != x);
+        const ariaHiddenCleanup = markOthers(insideElements, {
+            ariaHidden: modal || isUntrappedTypeableCombobox,
+            mark: false
+        });
+        const markerInsideElements = [
+            floating,
+            ...portalNodes
+        ].filter((x)=>null != x);
+        const markerCleanup = markOthers(markerInsideElements);
+        return ()=>{
+            markerCleanup();
+            ariaHiddenCleanup();
+        };
+    }, [
+        open,
+        disabled,
+        domReference,
+        floating,
+        modal,
+        portalContext,
+        isUntrappedTypeableCombobox,
+        tree,
+        getNodeId,
+        nextFocusableElement,
+        previousFocusableElement,
+        getResolvedInsideElements
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!open || disabled || !isHTMLElement(floatingFocusElement)) return;
+        const doc = ownerDocument(floatingFocusElement);
+        const previouslyFocusedElement = activeElement(doc);
+        queueMicrotask(()=>{
+            const initialFocusValueOrFn = initialFocusRef.current;
+            const resolvedInitialFocus = 'function' == typeof initialFocusValueOrFn ? initialFocusValueOrFn(openInteractionTypeRef.current || '') : initialFocusValueOrFn;
+            if (void 0 === resolvedInitialFocus || false === resolvedInitialFocus) return;
+            const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);
+            if (focusAlreadyInsideFloatingEl) return;
+            let focusableElements = null;
+            const getDefaultFocusElement = ()=>{
+                if (null == focusableElements) focusableElements = getTabbableContent(floatingFocusElement);
+                return focusableElements[0] || floatingFocusElement;
+            };
+            let elToFocus;
+            elToFocus = true === resolvedInitialFocus || null === resolvedInitialFocus ? getDefaultFocusElement() : resolveRef(resolvedInitialFocus);
+            elToFocus = elToFocus || getDefaultFocusElement();
+            const hadFocusInside = contains(floatingFocusElement, activeElement(doc));
+            enqueueFocus(elToFocus, {
+                preventScroll: elToFocus === floatingFocusElement,
+                shouldFocus () {
+                    if (hadFocusInside) return true;
+                    const currentActiveElement = activeElement(doc);
+                    const focusMovedInside = currentActiveElement !== elToFocus && contains(floatingFocusElement, currentActiveElement);
+                    return !focusMovedInside;
+                }
+            });
+        });
+    }, [
+        disabled,
+        open,
+        floatingFocusElement,
+        getTabbableContent,
+        initialFocusRef,
+        openInteractionTypeRef
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (disabled || !floatingFocusElement) return;
+        const doc = ownerDocument(floatingFocusElement);
+        const previouslyFocusedElement = activeElement(doc);
+        addPreviouslyFocusedElement(previouslyFocusedElement);
+        function onOpenChangeLocal(details) {
+            if (!details.open) closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
+            if (details.reason === triggerHover && 'mouseleave' === details.nativeEvent.type) preventReturnFocusRef.current = true;
+            if (details.reason !== outsidePress) return;
+            if (details.nested) preventReturnFocusRef.current = false;
+            else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) preventReturnFocusRef.current = false;
+            else {
+                let isPreventScrollSupported = false;
+                ownerDocument(floatingFocusElement).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 = 'function' == typeof returnFocusValueOrFn ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
+            if (void 0 === resolvedReturnFocusValue || false === resolvedReturnFocusValue) return null;
+            if (null === resolvedReturnFocusValue) resolvedReturnFocusValue = true;
+            if ('boolean' == typeof resolvedReturnFocusValue) {
+                if (domReference?.isConnected) return domReference;
+                return getPreviouslyFocusedElement() || null;
+            }
+            const fallback = domReference?.isConnected ? domReference : getPreviouslyFocusedElement();
+            return resolveRef(resolvedReturnFocusValue) || fallback || null;
+        }
+        return ()=>{
+            events.off('openchange', onOpenChangeLocal);
+            const activeEl = activeElement(doc);
+            const insideElements = getResolvedInsideElements();
+            const isFocusInsideFloatingTree = contains(floating, activeEl) || insideElements.some((element)=>element === activeEl || contains(element, activeEl)) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node)=>contains(node.context?.elements.floating, activeEl));
+            const returnFocusValueOrFn = returnFocusRef.current;
+            const returnElement = getReturnElement();
+            queueMicrotask(()=>{
+                const tabbableReturnElement = getFirstTabbableElement(returnElement);
+                const hasExplicitReturnFocus = 'boolean' != typeof returnFocusValueOrFn;
+                if (returnFocusValueOrFn && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (hasExplicitReturnFocus || tabbableReturnElement === activeEl || activeEl === doc.body ? true : isFocusInsideFloatingTree)) tabbableReturnElement.focus({
+                    preventScroll: true
+                });
+                preventReturnFocusRef.current = false;
+            });
+        };
+    }, [
+        disabled,
+        floating,
+        floatingFocusElement,
+        returnFocusRef,
+        events,
+        tree,
+        domReference,
+        getNodeId,
+        getResolvedInsideElements
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!isWebKit || open || !floating) return;
+        const activeEl = activeElement(ownerDocument(floating));
+        if (!isHTMLElement(activeEl) || !isTypeableElement(activeEl)) return;
+        if (contains(floating, activeEl)) activeEl.blur();
+    }, [
+        open,
+        floating
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (disabled || !portalContext) return;
+        portalContext.setFocusManagerState({
+            modal,
+            closeOnFocusOut,
+            open,
+            onOpenChange: store.setOpen,
+            domReference
+        });
+        return ()=>{
+            portalContext.setFocusManagerState(null);
+        };
+    }, [
+        disabled,
+        portalContext,
+        modal,
+        open,
+        store,
+        closeOnFocusOut,
+        domReference
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (disabled || !floatingFocusElement) return;
+        handleTabIndex(floatingFocusElement, orderRef);
+        return ()=>{
+            queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
+        };
+    }, [
+        disabled,
+        floatingFocusElement,
+        orderRef
+    ]);
+    const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+    return /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            shouldRenderGuards && /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                "data-type": "inside",
+                ref: mergedBeforeGuardRef,
+                onFocus: (event)=>{
+                    if (modal) {
+                        const els = getTabbableContent();
+                        enqueueFocus(els[els.length - 1]);
+                    } else if (portalContext?.portalNode) {
+                        preventReturnFocusRef.current = false;
+                        if (isOutsideEvent(event, portalContext.portalNode)) {
+                            const nextTabbable = getNextTabbable(domReference);
+                            nextTabbable?.focus();
+                        } else resolveRef(previousFocusableElement ?? portalContext.beforeOutsideRef)?.focus();
+                    }
+                }
+            }),
+            children,
+            shouldRenderGuards && /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                "data-type": "inside",
+                ref: mergedAfterGuardRef,
+                onFocus: (event)=>{
+                    if (modal) enqueueFocus(getTabbableContent()[0]);
+                    else if (portalContext?.portalNode) {
+                        if (closeOnFocusOut) preventReturnFocusRef.current = true;
+                        if (isOutsideEvent(event, portalContext.portalNode)) {
+                            const prevTabbable = getPreviousTabbable(domReference);
+                            prevTabbable?.focus();
+                        } else resolveRef(nextFocusableElement ?? portalContext.afterOutsideRef)?.focus();
+                    }
+                }
+            })
+        ]
+    });
+}
+function useEnhancedClickHandler(handler) {
+    const lastClickInteractionTypeRef = __rspack_external_react.useRef('');
+    const handlePointerDown = __rspack_external_react.useCallback((event)=>{
+        if (event.defaultPrevented) return;
+        lastClickInteractionTypeRef.current = event.pointerType;
+        handler(event, event.pointerType);
+    }, [
+        handler
+    ]);
+    const handleClick = __rspack_external_react.useCallback((event)=>{
+        if (0 === event.detail) return void handler(event, 'keyboard');
+        'pointerType' in event ? handler(event, event.pointerType) : handler(event, lastClickInteractionTypeRef.current);
+        lastClickInteractionTypeRef.current = '';
+    }, [
+        handler
+    ]);
+    return {
+        onClick: handleClick,
+        onPointerDown: handlePointerDown
+    };
+}
+function useOpenMethodTriggerProps(open, setOpenMethod) {
+    const handleTriggerClick = useStableCallback((_, interactionType)=>{
+        const isOpen = 'function' == typeof open ? open() : open;
+        if (!isOpen) setOpenMethod(interactionType || (isIOS ? 'touch' : ''));
+    });
+    const { onClick, onPointerDown } = useEnhancedClickHandler(handleTriggerClick);
+    return __rspack_external_react.useMemo(()=>({
+            onClick,
+            onPointerDown
+        }), [
+        onClick,
+        onPointerDown
+    ]);
+}
+function useOpenInteractionType(open) {
+    const [openMethod, setOpenMethod] = __rspack_external_react.useState(null);
+    const triggerProps = useOpenMethodTriggerProps(open, setOpenMethod);
+    useValueChanged(open, (previousOpen)=>{
+        if (previousOpen && !open) setOpenMethod(null);
+    });
+    return __rspack_external_react.useMemo(()=>({
+            openMethod,
+            triggerProps
+        }), [
+        openMethod,
+        triggerProps
+    ]);
+}
+let originalHtmlStyles = {};
+let originalBodyStyles = {};
+let originalHtmlScrollBehavior = '';
+function hasInsetScrollbars(referenceElement) {
+    if ("u" < typeof document) return false;
+    const doc = ownerDocument(referenceElement);
+    const win = getWindow(doc);
+    return win.innerWidth - doc.documentElement.clientWidth > 0;
+}
+function supportsStableScrollbarGutter(referenceElement) {
+    const supported = "u" > typeof CSS && CSS.supports && CSS.supports('scrollbar-gutter', 'stable');
+    if (!supported || "u" < typeof document) return false;
+    const doc = ownerDocument(referenceElement);
+    const html = doc.documentElement;
+    const body = doc.body;
+    const scrollContainer = 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 = ownerDocument(referenceElement);
+    const html = doc.documentElement;
+    const body = doc.body;
+    const elementToLock = 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 = ownerDocument(referenceElement);
+    const html = doc.documentElement;
+    const body = doc.body;
+    const win = getWindow(html);
+    let scrollTop = 0;
+    let scrollLeft = 0;
+    let updateGutterOnly = false;
+    const resizeFrame = AnimationFrame.create();
+    if (isWebKit && (win.visualViewport?.scale ?? 1) !== 1) return ()=>{};
+    function lockScroll() {
+        const htmlStyles = win.getComputedStyle(html);
+        const bodyStyles = win.getComputedStyle(body);
+        const htmlScrollbarGutterValue = htmlStyles.scrollbarGutter || '';
+        const hasBothEdges = htmlScrollbarGutterValue.includes('both-edges');
+        const scrollbarGutterValue = hasBothEdges ? 'stable both-edges' : 'stable';
+        scrollTop = html.scrollTop;
+        scrollLeft = html.scrollLeft;
+        originalHtmlStyles = {
+            scrollbarGutter: html.style.scrollbarGutter,
+            overflowY: html.style.overflowY,
+            overflowX: html.style.overflowX
+        };
+        originalHtmlScrollBehavior = html.style.scrollBehavior;
+        originalBodyStyles = {
+            position: body.style.position,
+            height: body.style.height,
+            width: body.style.width,
+            boxSizing: body.style.boxSizing,
+            overflowY: body.style.overflowY,
+            overflowX: body.style.overflowX,
+            scrollBehavior: body.style.scrollBehavior
+        };
+        const isScrollableY = html.scrollHeight > html.clientHeight;
+        const isScrollableX = html.scrollWidth > html.clientWidth;
+        const hasConstantOverflowY = 'scroll' === htmlStyles.overflowY || 'scroll' === bodyStyles.overflowY;
+        const hasConstantOverflowX = 'scroll' === htmlStyles.overflowX || 'scroll' === bodyStyles.overflowX;
+        const scrollbarWidth = Math.max(0, win.innerWidth - body.clientWidth);
+        const scrollbarHeight = Math.max(0, win.innerHeight - body.clientHeight);
+        const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+        const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+        const elementToLock = isOverflowElement(html) ? html : body;
+        updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
+        if (updateGutterOnly) {
+            html.style.scrollbarGutter = scrollbarGutterValue;
+            elementToLock.style.overflowY = 'hidden';
+            elementToLock.style.overflowX = 'hidden';
+            return;
+        }
+        Object.assign(html.style, {
+            scrollbarGutter: scrollbarGutterValue,
+            overflowY: 'hidden',
+            overflowX: 'hidden'
+        });
+        if (isScrollableY || hasConstantOverflowY) html.style.overflowY = 'scroll';
+        if (isScrollableX || hasConstantOverflowX) html.style.overflowX = 'scroll';
+        Object.assign(body.style, {
+            position: 'relative',
+            height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',
+            width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',
+            boxSizing: 'border-box',
+            overflow: 'hidden',
+            scrollBehavior: 'unset'
+        });
+        body.scrollTop = scrollTop;
+        body.scrollLeft = scrollLeft;
+        html.setAttribute('data-base-ui-scroll-locked', '');
+        html.style.scrollBehavior = 'unset';
+    }
+    function cleanup() {
+        Object.assign(html.style, originalHtmlStyles);
+        Object.assign(body.style, originalBodyStyles);
+        if (!updateGutterOnly) {
+            html.scrollTop = scrollTop;
+            html.scrollLeft = scrollLeft;
+            html.removeAttribute('data-base-ui-scroll-locked');
+            html.style.scrollBehavior = originalHtmlScrollBehavior;
+        }
+    }
+    function handleResize() {
+        cleanup();
+        resizeFrame.request(lockScroll);
+    }
+    lockScroll();
+    const unsubscribeResize = addEventListener(win, 'resize', handleResize);
+    return ()=>{
+        resizeFrame.cancel();
+        cleanup();
+        if ('function' == typeof win.removeEventListener) unsubscribeResize();
+    };
+}
+class ScrollLocker {
+    lockCount = 0;
+    restore = null;
+    timeoutLock = Timeout.create();
+    timeoutUnlock = Timeout.create();
+    acquire(referenceElement) {
+        this.lockCount += 1;
+        if (1 === this.lockCount && null === this.restore) this.timeoutLock.start(0, ()=>this.lock(referenceElement));
+        return this.release;
+    }
+    release = ()=>{
+        this.lockCount -= 1;
+        if (0 === this.lockCount && this.restore) this.timeoutUnlock.start(0, this.unlock);
+    };
+    unlock = ()=>{
+        if (0 === this.lockCount && this.restore) {
+            this.restore?.();
+            this.restore = null;
+        }
+    };
+    lock(referenceElement) {
+        if (0 === this.lockCount || null !== this.restore) return;
+        const doc = ownerDocument(referenceElement);
+        const html = doc.documentElement;
+        const htmlOverflowY = getWindow(html).getComputedStyle(html).overflowY;
+        if ('hidden' === htmlOverflowY || 'clip' === htmlOverflowY) {
+            this.restore = NOOP;
+            return;
+        }
+        const hasOverlayScrollbars = isIOS || !hasInsetScrollbars(referenceElement);
+        this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);
+    }
+}
+const SCROLL_LOCKER = new ScrollLocker();
+function useScrollLock(enabled = true, referenceElement = null) {
+    useIsoLayoutEffect(()=>{
+        if (!enabled) return;
+        return SCROLL_LOCKER.acquire(referenceElement);
+    }, [
+        enabled,
+        referenceElement
+    ]);
+}
+const InternalBackdrop_InternalBackdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(function(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__*/ jsx("div", {
+        ref: ref,
+        role: "presentation",
+        "data-base-ui-inert": "",
+        ...otherProps,
+        style: {
+            position: 'fixed',
+            inset: 0,
+            userSelect: 'none',
+            WebkitUserSelect: 'none',
+            clipPath
+        }
+    });
+});
+if ("production" !== process.env.NODE_ENV) InternalBackdrop_InternalBackdrop.displayName = "InternalBackdrop";
+export { FloatingFocusManager, InternalBackdrop_InternalBackdrop, enqueueFocus, useOpenInteractionType, useOpenMethodTriggerProps, useScrollLock };