@wix/site-ui 1.30.0 → 1.31.0

package/dist/5992.js

@@ -0,0 +1,913 @@
+/*! LICENSE: 5992.js.LICENSE.txt */
+import { __webpack_require__ } from "./rslib-runtime.js";
+import "./4586.js";
+import { NOOP, useRefWithInit, isReactVersionAtLeast, esm_formatErrorMessage } from "./8272.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { useStableCallback } from "./7541.js";
+import { createEventEmitter, useFloatingTree } from "./285.js";
+import { isReactEvent, isClickLikeEvent } from "./6330.js";
+import { Timeout, useTimeout } from "./42.js";
+import { isEventTargetWithin, isRootElement } from "./8758.js";
+import { createChangeEventDetails } from "./4768.js";
+import { triggerPress, outsidePress as reason_parts_outsidePress, escapeKey as reason_parts_escapeKey } from "./2418.js";
+import { getTarget, contains } from "./4549.js";
+import { isHTMLElement, getComputedStyle, isWebKit, isElement, isLastTraversableNode, isShadowRoot, getParentNode } from "./3829.js";
+import { ownerDocument } from "./9829.js";
+import { addEventListener } from "./4723.js";
+import { mergeCleanups } from "./4495.js";
+import * as __rspack_external_react from "react";
+__webpack_require__.add({
+    "../../node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * use-sync-external-store-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.
+ */ "production" !== process.env.NODE_ENV && function() {
+            function is(x, y) {
+                return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+            }
+            "u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+            var React = __webpack_require__("react?1096"), objectIs = "function" == typeof Object.is ? Object.is : is, useSyncExternalStore = React.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+            exports.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;
+            };
+            "u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+        }();
+    },
+    "../../node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * use-sync-external-store-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 React = __webpack_require__("react?1096");
+        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 = React.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+        exports.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;
+        };
+    },
+    "../../node_modules/use-sync-external-store/with-selector.js" (module, __unused_rspack_exports, __webpack_require__) {
+        if ('production' === process.env.NODE_ENV) module.exports = __webpack_require__("../../node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.js");
+        else module.exports = __webpack_require__("../../node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js");
+    },
+    "react?1096" (module) {
+        module.exports = __rspack_external_react;
+    }
+});
+function getNodeChildren(nodes, id, onlyOpenChildren = true) {
+    const directChildren = nodes.filter((node)=>node.parentId === id);
+    return directChildren.flatMap((child)=>[
+            ...!onlyOpenChildren || child.context?.open ? [
+                child
+            ] : [],
+            ...getNodeChildren(nodes, child.id, onlyOpenChildren)
+        ]);
+}
+function getNodeAncestors(nodes, id) {
+    let allAncestors = [];
+    let currentParentId = nodes.find((node)=>node.id === id)?.parentId;
+    while(currentParentId){
+        const currentNode = nodes.find((node)=>node.id === currentParentId);
+        currentParentId = currentNode?.parentId;
+        if (currentNode) allAncestors = allAncestors.concat(currentNode);
+    }
+    return allAncestors;
+}
+function createAttribute(name) {
+    return `data-base-ui-${name}`;
+}
+const createSelector = (a, b, c, d, e, f, ...other)=>{
+    if (other.length > 0) throw new Error("production" !== process.env.NODE_ENV ? 'Unsupported number of selectors' : esm_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 new Error('Missing arguments');
+    return selector;
+};
+const hooks = [];
+let currentInstance;
+function getInstance() {
+    return currentInstance;
+}
+function register(hook) {
+    hooks.push(hook);
+}
+function fastComponent(fn) {
+    const FastComponent = (props, forwardedRef)=>{
+        const instance = 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 = void 0;
+        }
+        return result;
+    };
+    FastComponent.displayName = fn.displayName || fn.name;
+    return FastComponent;
+}
+function fastComponentRef(fn) {
+    return /*#__PURE__*/ __rspack_external_react.forwardRef(fastComponent(fn));
+}
+function createInstance() {
+    return {
+        didInitialize: false
+    };
+}
+const use_sync_external_store = __webpack_require__("../../node_modules/use-sync-external-store/index.js");
+const with_selector = __webpack_require__("../../node_modules/use-sync-external-store/with-selector.js");
+const canUseRawUseSyncExternalStore = 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 = __rspack_external_react.useCallback(()=>selector(store.getSnapshot(), a1, a2, a3), [
+        store,
+        selector,
+        a1,
+        a2,
+        a3
+    ]);
+    return (0, use_sync_external_store.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();
+                    };
+                };
+            }
+            (0, use_sync_external_store.useSyncExternalStore)(instance.subscribe, instance.getSnapshot, instance.getSnapshot);
+        }
+    }
+});
+function useStoreFast(store, selector, a1, a2, a3) {
+    const instance = getInstance();
+    if (!instance) return useStoreR19(store, selector, a1, a2, a3);
+    const index = instance.syncIndex;
+    instance.syncIndex += 1;
+    let hook;
+    if (instance.didInitialize) {
+        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;
+        }
+    } else {
+        hook = {
+            store,
+            selector,
+            a1,
+            a2,
+            a3,
+            value: selector(store.getSnapshot(), a1, a2, a3),
+            didChange: false
+        };
+        instance.syncHooks.push(hook);
+    }
+    return hook.value;
+}
+function useStoreLegacy(store, selector, a1, a2, a3) {
+    return (0, with_selector.useSyncExternalStoreWithSelector)(store.subscribe, store.getSnapshot, store.getSnapshot, (state)=>selector(state, a1, a2, a3));
+}
+class Store {
+    constructor(state){
+        this.state = state;
+        this.listeners = new Set();
+        this.updateTick = 0;
+    }
+    subscribe = (fn)=>{
+        this.listeners.add(fn);
+        return ()=>{
+            this.listeners.delete(fn);
+        };
+    };
+    getSnapshot = ()=>this.state;
+    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) return;
+            listener(newState);
+        }
+    }
+    update(changes) {
+        for(const key in changes)if (!Object.is(this.state[key], changes[key])) return void this.setState({
+            ...this.state,
+            ...changes
+        });
+    }
+    set(key, value) {
+        if (!Object.is(this.state[key], value)) this.setState({
+            ...this.state,
+            [key]: value
+        });
+    }
+    notifyAll() {
+        const newState = {
+            ...this.state
+        };
+        this.setState(newState);
+    }
+    use(selector, a1, a2, a3) {
+        return useStore(this, selector, a1, a2, a3);
+    }
+}
+class ReactStore extends Store {
+    constructor(state, context = {}, selectors){
+        super(state);
+        this.context = context;
+        this.selectors = selectors;
+    }
+    useSyncedValue(key, value) {
+        __rspack_external_react.useDebugValue(key);
+        const store = this;
+        useIsoLayoutEffect(()=>{
+            if (store.state[key] !== value) store.set(key, value);
+        }, [
+            store,
+            key,
+            value
+        ]);
+    }
+    useSyncedValueWithCleanup(key, value) {
+        const store = this;
+        useIsoLayoutEffect(()=>{
+            if (store.state[key] !== value) store.set(key, value);
+            return ()=>{
+                store.set(key, void 0);
+            };
+        }, [
+            store,
+            key,
+            value
+        ]);
+    }
+    useSyncedValues(statePart) {
+        const store = this;
+        if ('production' !== process.env.NODE_ENV) {
+            __rspack_external_react.useDebugValue(statePart, (p)=>Object.keys(p));
+            const keys = __rspack_external_react.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);
+        useIsoLayoutEffect(()=>{
+            store.update(statePart);
+        }, [
+            store,
+            ...dependencies
+        ]);
+    }
+    useControlledProp(key, controlled) {
+        __rspack_external_react.useDebugValue(key);
+        const store = this;
+        const isControlled = void 0 !== controlled;
+        useIsoLayoutEffect(()=>{
+            if (isControlled && !Object.is(store.state[key], controlled)) store.setState({
+                ...store.state,
+                [key]: controlled
+            });
+        }, [
+            store,
+            key,
+            controlled,
+            isControlled
+        ]);
+        if ('production' !== process.env.NODE_ENV) {
+            const cache = this.controlledValues ??= new Map();
+            if (!cache.has(key)) cache.set(key, isControlled);
+            const previouslyControlled = cache.get(key);
+            if (void 0 !== previouslyControlled && 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).`);
+        }
+    }
+    select(key, a1, a2, a3) {
+        const selector = this.selectors[key];
+        return selector(this.state, a1, a2, a3);
+    }
+    useState(key, a1, a2, a3) {
+        __rspack_external_react.useDebugValue(key);
+        return useStore(this, this.selectors[key], a1, a2, a3);
+    }
+    useContextCallback(key, fn) {
+        __rspack_external_react.useDebugValue(key);
+        const stableFunction = useStableCallback(fn ?? NOOP);
+        this.context[key] = stableFunction;
+    }
+    useStateSetter(key) {
+        const ref = __rspack_external_react.useRef(void 0);
+        if (void 0 === ref.current) ref.current = (value)=>{
+            this.set(key, value);
+        };
+        return ref.current;
+    }
+    observe(selector, listener) {
+        let selectFn;
+        selectFn = 'function' == typeof selector ? selector : 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);
+            }
+        });
+    }
+}
+const FloatingRootStore_selectors = {
+    open: createSelector((state)=>state.open),
+    transitionStatus: createSelector((state)=>state.transitionStatus),
+    domReferenceElement: createSelector((state)=>state.domReferenceElement),
+    referenceElement: createSelector((state)=>state.positionReference ?? state.referenceElement),
+    floatingElement: createSelector((state)=>state.floatingElement),
+    floatingId: createSelector((state)=>state.floatingId)
+};
+class FloatingRootStore extends ReactStore {
+    constructor(options){
+        const { syncOnly, nested, onOpenChange, triggerElements, ...initialState } = options;
+        super({
+            ...initialState,
+            positionReference: initialState.referenceElement,
+            domReferenceElement: initialState.referenceElement
+        }, {
+            onOpenChange,
+            dataRef: {
+                current: {}
+            },
+            events: createEventEmitter(),
+            nested,
+            triggerElements
+        }, FloatingRootStore_selectors);
+        this.syncOnly = syncOnly;
+    }
+    syncOpenEvent = (newOpen, event)=>{
+        if (!newOpen || !this.state.open || null != event && isClickLikeEvent(event)) this.context.dataRef.current.openEvent = newOpen ? event : void 0;
+    };
+    dispatchOpenChange = (newOpen, eventDetails)=>{
+        this.syncOpenEvent(newOpen, eventDetails.event);
+        const details = {
+            open: newOpen,
+            reason: eventDetails.reason,
+            nativeEvent: eventDetails.event,
+            nested: this.context.nested,
+            triggerElement: eventDetails.trigger
+        };
+        this.context.events.emit('openchange', details);
+    };
+    setOpen = (newOpen, eventDetails)=>{
+        if (this.syncOnly) return void this.context.onOpenChange?.(newOpen, eventDetails);
+        this.dispatchOpenChange(newOpen, eventDetails);
+        this.context.onOpenChange?.(newOpen, eventDetails);
+    };
+}
+const bubbleHandlerKeys = {
+    intentional: 'onClick',
+    sloppy: 'onPointerDown'
+};
+function alwaysFalse() {
+    return false;
+}
+function normalizeProp(normalizable) {
+    return {
+        escapeKey: 'boolean' == typeof normalizable ? normalizable : normalizable?.escapeKey ?? false,
+        outsidePress: 'boolean' == typeof normalizable ? normalizable : normalizable?.outsidePress ?? true
+    };
+}
+function useDismiss(context, props = {}) {
+    const { enabled = true, escapeKey = true, outsidePress: outsidePressProp = true, outsidePressEvent = 'sloppy', referencePress = alwaysFalse, referencePressEvent = 'sloppy', bubbles, externalTree } = props;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const open = store.useState('open');
+    const floatingElement = store.useState('floatingElement');
+    const { dataRef } = store.context;
+    const tree = useFloatingTree(externalTree);
+    const outsidePressFn = useStableCallback('function' == typeof outsidePressProp ? outsidePressProp : ()=>false);
+    const outsidePress = 'function' == typeof outsidePressProp ? outsidePressFn : outsidePressProp;
+    const outsidePressEnabled = false !== outsidePress;
+    const getOutsidePressEventProp = useStableCallback(()=>outsidePressEvent);
+    const { escapeKey: escapeKeyBubbles, outsidePress: outsidePressBubbles } = normalizeProp(bubbles);
+    const pressStartedInsideRef = __rspack_external_react.useRef(false);
+    const pressStartPreventedRef = __rspack_external_react.useRef(false);
+    const suppressNextOutsideClickRef = __rspack_external_react.useRef(false);
+    const isComposingRef = __rspack_external_react.useRef(false);
+    const currentPointerTypeRef = __rspack_external_react.useRef('');
+    const touchStateRef = __rspack_external_react.useRef(null);
+    const cancelDismissOnEndTimeout = useTimeout();
+    const clearInsideReactTreeTimeout = useTimeout();
+    const clearInsideReactTree = useStableCallback(()=>{
+        clearInsideReactTreeTimeout.clear();
+        dataRef.current.insideReactTree = false;
+    });
+    const hasBlockingChild = useStableCallback((bubbleKey)=>{
+        const nodeId = dataRef.current.floatingContext?.nodeId;
+        const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+        return children.some((child)=>child.context?.open && !child.context.dataRef.current[bubbleKey]);
+    });
+    const isEventWithinOwnElements = useStableCallback((event)=>isEventTargetWithin(event, store.select('floatingElement')) || isEventTargetWithin(event, store.select('domReferenceElement')));
+    const closeOnReferencePress = useStableCallback((event)=>{
+        if (!referencePress()) return;
+        store.setOpen(false, createChangeEventDetails(triggerPress, event.nativeEvent));
+    });
+    const closeOnEscapeKeyDown = useStableCallback((event)=>{
+        if (!open || !enabled || !escapeKey || 'Escape' !== event.key) return;
+        if (isComposingRef.current) return;
+        if (!escapeKeyBubbles && hasBlockingChild('__escapeKeyBubbles')) return;
+        const native = isReactEvent(event) ? event.nativeEvent : event;
+        const eventDetails = createChangeEventDetails(reason_parts_escapeKey, native);
+        store.setOpen(false, eventDetails);
+        if (!eventDetails.isCanceled) event.preventDefault();
+        if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) event.stopPropagation();
+    });
+    const markInsideReactTree = useStableCallback(()=>{
+        dataRef.current.insideReactTree = true;
+        clearInsideReactTreeTimeout.start(0, clearInsideReactTree);
+    });
+    const markPressStartedInsideReactTree = useStableCallback((event)=>{
+        if (!open || !enabled || 0 !== event.button) return;
+        const target = getTarget(event.nativeEvent);
+        if (!contains(store.select('floatingElement'), target)) return;
+        if (!pressStartedInsideRef.current) {
+            pressStartedInsideRef.current = true;
+            pressStartPreventedRef.current = false;
+        }
+    });
+    const markInsidePressStartPrevented = useStableCallback((event)=>{
+        if (!open || !enabled) return;
+        if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) return;
+        if (pressStartedInsideRef.current) pressStartPreventedRef.current = true;
+    });
+    __rspack_external_react.useEffect(()=>{
+        if (!open || !enabled) return;
+        dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
+        dataRef.current.__outsidePressBubbles = outsidePressBubbles;
+        const compositionTimeout = new Timeout();
+        const preventedPressSuppressionTimeout = new Timeout();
+        function handleCompositionStart() {
+            compositionTimeout.clear();
+            isComposingRef.current = true;
+        }
+        function handleCompositionEnd() {
+            compositionTimeout.start(isWebKit() ? 5 : 0, ()=>{
+                isComposingRef.current = false;
+            });
+        }
+        function suppressImmediateOutsideClickAfterPreventedStart() {
+            suppressNextOutsideClickRef.current = true;
+            preventedPressSuppressionTimeout.start(0, ()=>{
+                suppressNextOutsideClickRef.current = false;
+            });
+        }
+        function resetPressStartState() {
+            pressStartedInsideRef.current = false;
+            pressStartPreventedRef.current = false;
+        }
+        function getOutsidePressEvent() {
+            const type = currentPointerTypeRef.current;
+            const computedType = 'pen' !== type && type ? type : 'mouse';
+            const outsidePressEventValue = getOutsidePressEventProp();
+            const resolved = 'function' == typeof outsidePressEventValue ? outsidePressEventValue() : outsidePressEventValue;
+            if ('string' == typeof resolved) return resolved;
+            return resolved[computedType];
+        }
+        function shouldIgnoreEvent(event) {
+            const computedOutsidePressEvent = getOutsidePressEvent();
+            return 'intentional' === computedOutsidePressEvent && 'click' !== event.type || 'sloppy' === computedOutsidePressEvent && 'click' === event.type;
+        }
+        function isEventWithinFloatingTree(event) {
+            const nodeId = dataRef.current.floatingContext?.nodeId;
+            const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node)=>isEventTargetWithin(event, node.context?.elements.floating));
+            return isEventWithinOwnElements(event) || targetIsInsideChildren;
+        }
+        function closeOnPressOutside(event) {
+            if (shouldIgnoreEvent(event)) {
+                if ('click' !== event.type && !isEventWithinOwnElements(event)) {
+                    preventedPressSuppressionTimeout.clear();
+                    suppressNextOutsideClickRef.current = false;
+                }
+                clearInsideReactTree();
+                return;
+            }
+            if (dataRef.current.insideReactTree) return void clearInsideReactTree();
+            const target = getTarget(event);
+            const inertSelector = `[${createAttribute('inert')}]`;
+            const targetRoot = isElement(target) ? target.getRootNode() : null;
+            const markers = Array.from((isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select('floatingElement'))).querySelectorAll(inertSelector));
+            const triggers = store.context.triggerElements;
+            if (target && (triggers.hasElement(target) || triggers.hasMatchingElement((trigger)=>contains(trigger, target)))) return;
+            let targetRootAncestor = isElement(target) ? target : null;
+            while(targetRootAncestor && !isLastTraversableNode(targetRootAncestor)){
+                const nextParent = getParentNode(targetRootAncestor);
+                if (isLastTraversableNode(nextParent) || !isElement(nextParent)) break;
+                targetRootAncestor = nextParent;
+            }
+            if (markers.length && isElement(target) && !isRootElement(target) && !contains(target, store.select('floatingElement')) && markers.every((marker)=>!contains(targetRootAncestor, marker))) return;
+            if (isHTMLElement(target) && !('touches' in event)) {
+                const lastTraversableNode = isLastTraversableNode(target);
+                const style = 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 = 'rtl' === style.direction;
+                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;
+            if ('intentional' === getOutsidePressEvent() && suppressNextOutsideClickRef.current) {
+                preventedPressSuppressionTimeout.clear();
+                suppressNextOutsideClickRef.current = false;
+                return;
+            }
+            if ('function' == typeof outsidePress && !outsidePress(event)) return;
+            if (hasBlockingChild('__outsidePressBubbles')) return;
+            store.setOpen(false, createChangeEventDetails(reason_parts_outsidePress, event));
+            clearInsideReactTree();
+        }
+        function handlePointerDown(event) {
+            if ('sloppy' !== getOutsidePressEvent() || 'touch' === event.pointerType || !store.select('open') || !enabled || isEventWithinOwnElements(event)) return;
+            closeOnPressOutside(event);
+        }
+        function handleTouchStart(event) {
+            if ('sloppy' !== getOutsidePressEvent() || !store.select('open') || !enabled || isEventWithinOwnElements(event)) 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 addTargetEventListenerOnce(event, listener) {
+            const target = getTarget(event);
+            if (!target) return;
+            const unsubscribe = addEventListener(target, event.type, ()=>{
+                listener(event);
+                unsubscribe();
+            });
+        }
+        function handleTouchStartCapture(event) {
+            currentPointerTypeRef.current = 'touch';
+            addTargetEventListenerOnce(event, handleTouchStart);
+        }
+        function closeOnPressOutsideCapture(event) {
+            cancelDismissOnEndTimeout.clear();
+            if ('pointerdown' === event.type) currentPointerTypeRef.current = event.pointerType;
+            if ('mousedown' === event.type && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) return;
+            addTargetEventListenerOnce(event, (targetEvent)=>{
+                if ('pointerdown' === targetEvent.type) handlePointerDown(targetEvent);
+                else closeOnPressOutside(targetEvent);
+            });
+        }
+        function handlePressEndCapture(event) {
+            if (!pressStartedInsideRef.current) return;
+            const pressStartedInsideDefaultPrevented = pressStartPreventedRef.current;
+            resetPressStartState();
+            if ('intentional' !== getOutsidePressEvent()) return;
+            if ('pointercancel' === event.type) {
+                if (pressStartedInsideDefaultPrevented) suppressImmediateOutsideClickAfterPreventedStart();
+                return;
+            }
+            if (isEventWithinFloatingTree(event)) return;
+            if (pressStartedInsideDefaultPrevented) return void suppressImmediateOutsideClickAfterPreventedStart();
+            if ('function' == typeof outsidePress && !outsidePress(event)) return;
+            preventedPressSuppressionTimeout.clear();
+            suppressNextOutsideClickRef.current = true;
+            clearInsideReactTree();
+        }
+        function handleTouchMove(event) {
+            if ('sloppy' !== getOutsidePressEvent() || !touchStateRef.current || isEventWithinOwnElements(event)) 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) {
+            addTargetEventListenerOnce(event, handleTouchMove);
+        }
+        function handleTouchEnd(event) {
+            if ('sloppy' !== getOutsidePressEvent() || !touchStateRef.current || isEventWithinOwnElements(event)) return;
+            if (touchStateRef.current.dismissOnTouchEnd) closeOnPressOutside(event);
+            cancelDismissOnEndTimeout.clear();
+            touchStateRef.current = null;
+        }
+        function handleTouchEndCapture(event) {
+            addTargetEventListenerOnce(event, handleTouchEnd);
+        }
+        const doc = ownerDocument(floatingElement);
+        const unsubscribe = mergeCleanups(escapeKey && mergeCleanups(addEventListener(doc, 'keydown', closeOnEscapeKeyDown), addEventListener(doc, 'compositionstart', handleCompositionStart), addEventListener(doc, 'compositionend', handleCompositionEnd)), outsidePressEnabled && mergeCleanups(addEventListener(doc, 'click', closeOnPressOutsideCapture, true), addEventListener(doc, 'pointerdown', closeOnPressOutsideCapture, true), addEventListener(doc, 'pointerup', handlePressEndCapture, true), addEventListener(doc, 'pointercancel', handlePressEndCapture, true), addEventListener(doc, 'mousedown', closeOnPressOutsideCapture, true), addEventListener(doc, 'mouseup', handlePressEndCapture, true), addEventListener(doc, 'touchstart', handleTouchStartCapture, true), addEventListener(doc, 'touchmove', handleTouchMoveCapture, true), addEventListener(doc, 'touchend', handleTouchEndCapture, true)));
+        return ()=>{
+            unsubscribe();
+            compositionTimeout.clear();
+            preventedPressSuppressionTimeout.clear();
+            resetPressStartState();
+            suppressNextOutsideClickRef.current = false;
+        };
+    }, [
+        dataRef,
+        floatingElement,
+        escapeKey,
+        outsidePressEnabled,
+        outsidePress,
+        open,
+        enabled,
+        escapeKeyBubbles,
+        outsidePressBubbles,
+        closeOnEscapeKeyDown,
+        clearInsideReactTree,
+        getOutsidePressEventProp,
+        hasBlockingChild,
+        isEventWithinOwnElements,
+        tree,
+        store,
+        cancelDismissOnEndTimeout
+    ]);
+    __rspack_external_react.useEffect(clearInsideReactTree, [
+        outsidePress,
+        clearInsideReactTree
+    ]);
+    const reference = __rspack_external_react.useMemo(()=>({
+            onKeyDown: closeOnEscapeKeyDown,
+            [bubbleHandlerKeys[referencePressEvent]]: closeOnReferencePress,
+            ...'intentional' !== referencePressEvent && {
+                onClick: closeOnReferencePress
+            }
+        }), [
+        closeOnEscapeKeyDown,
+        closeOnReferencePress,
+        referencePressEvent
+    ]);
+    const floating = __rspack_external_react.useMemo(()=>({
+            onKeyDown: closeOnEscapeKeyDown,
+            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 __rspack_external_react.useMemo(()=>enabled ? {
+            reference,
+            floating,
+            trigger: reference
+        } : {}, [
+        enabled,
+        reference,
+        floating
+    ]);
+}
+class PopupTriggerMap {
+    constructor(){
+        this.elementsSet = new Set();
+        this.idMap = new Map();
+    }
+    add(id, element) {
+        const existingElement = this.idMap.get(id);
+        if (existingElement === element) return;
+        if (void 0 !== existingElement) this.elementsSet.delete(existingElement);
+        this.elementsSet.add(element);
+        this.idMap.set(id, element);
+        if ('production' !== process.env.NODE_ENV) {
+            if (this.elementsSet.size !== this.idMap.size) throw new Error('Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.');
+        }
+    }
+    delete(id) {
+        const element = this.idMap.get(id);
+        if (element) {
+            this.elementsSet.delete(element);
+            this.idMap.delete(id);
+        }
+    }
+    hasElement(element) {
+        return this.elementsSet.has(element);
+    }
+    hasMatchingElement(predicate) {
+        for (const element of this.elementsSet)if (predicate(element)) return true;
+        return false;
+    }
+    getById(id) {
+        return this.idMap.get(id);
+    }
+    entries() {
+        return this.idMap.entries();
+    }
+    elements() {
+        return this.elementsSet.values();
+    }
+    get size() {
+        return this.idMap.size;
+    }
+}
+export { FloatingRootStore, PopupTriggerMap, ReactStore, Store, createAttribute, createSelector, fastComponent, fastComponentRef, getNodeAncestors, getNodeChildren, useDismiss, useStore };