@wix/site-ui 1.185.0 → 1.187.0

package/dist/2205.js

@@ -0,0 +1,26 @@
+import { SafeReact } from "./6499.js";
+import * as __rspack_external_react from "react";
+let globalId = 0;
+function useGlobalId(idOverride, prefix = 'mui') {
+    const [defaultId, setDefaultId] = __rspack_external_react.useState(idOverride);
+    const id = idOverride || defaultId;
+    __rspack_external_react.useEffect(()=>{
+        if (null == defaultId) {
+            globalId += 1;
+            setDefaultId(`${prefix}-${globalId}`);
+        }
+    }, [
+        defaultId,
+        prefix
+    ]);
+    return id;
+}
+const maybeReactUseId = SafeReact.useId;
+function useId(idOverride, prefix) {
+    if (void 0 !== maybeReactUseId) {
+        const reactId = maybeReactUseId();
+        return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+    }
+    return useGlobalId(idOverride, prefix);
+}
+export { useId };

package/dist/2445.js

@@ -0,0 +1,470 @@
+/*! LICENSE: 2445.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 * 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 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);
+            }
+        });
+    }
+}
+export { ReactStore, Store, createAttribute, createSelector, fastComponent, fastComponentRef, useStore };

package/dist/285.js

@@ -1,6 +1,6 @@
 import * as __rspack_external_react from "react";
 import { jsx } from "react/jsx-runtime";
-import { useId } from "./6046.js";
+import { useId } from "./2205.js";
 import { useIsoLayoutEffect } from "./6499.js";
 import { useRefWithInit } from "./8272.js";
 function createEventEmitter() {

package/dist/3485.js

@@ -3,7 +3,7 @@ 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 { CLICK_TRIGGER_IDENTIFIER, FocusGuard_FocusGuard, focusable, getPreviousTabbable, isTabbable, isOutsideEvent, tabbable, usePortalContext, getNextTabbable } from "./487.js";
 import { useStableCallback } from "./7541.js";
 import { getFloatingFocusElement, isTypeableCombobox, isTypeableElement } from "./8758.js";
 import { useValueAsRef } from "./4707.js";
@@ -13,8 +13,9 @@ 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 { createAttribute } from "./2445.js";
+import { resolveRef } from "./9369.js";
+import { getNodeChildren, getNodeAncestors } from "./5992.js";
 import { isElementVisible } from "./3319.js";
 import { createChangeEventDetails } from "./4768.js";
 import { focusOut, triggerHover, outsidePress } from "./2418.js";

package/dist/4863.js

@@ -0,0 +1,61 @@
+import { useIsoLayoutEffect } from "./6499.js";
+import { AnimationFrame } from "./8996.js";
+import * as __rspack_external_react from "react";
+function useTransitionStatus(open, enableIdleState = false, deferEndingState = false) {
+    const [transitionStatus, setTransitionStatus] = __rspack_external_react.useState(open && enableIdleState ? 'idle' : void 0);
+    const [mounted, setMounted] = __rspack_external_react.useState(open);
+    if (open && !mounted) {
+        setMounted(true);
+        setTransitionStatus('starting');
+    }
+    if (!open && mounted && 'ending' !== transitionStatus && !deferEndingState) setTransitionStatus('ending');
+    if (!open && !mounted && 'ending' === transitionStatus) setTransitionStatus(void 0);
+    useIsoLayoutEffect(()=>{
+        if (!open && mounted && 'ending' !== transitionStatus && deferEndingState) {
+            const frame = AnimationFrame.request(()=>{
+                setTransitionStatus('ending');
+            });
+            return ()=>{
+                AnimationFrame.cancel(frame);
+            };
+        }
+    }, [
+        open,
+        mounted,
+        transitionStatus,
+        deferEndingState
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!open || enableIdleState) return;
+        const frame = AnimationFrame.request(()=>{
+            setTransitionStatus(void 0);
+        });
+        return ()=>{
+            AnimationFrame.cancel(frame);
+        };
+    }, [
+        enableIdleState,
+        open
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!open || !enableIdleState) return;
+        if (open && mounted && 'idle' !== transitionStatus) setTransitionStatus('starting');
+        const frame = AnimationFrame.request(()=>{
+            setTransitionStatus('idle');
+        });
+        return ()=>{
+            AnimationFrame.cancel(frame);
+        };
+    }, [
+        enableIdleState,
+        open,
+        mounted,
+        transitionStatus
+    ]);
+    return {
+        mounted,
+        setMounted,
+        transitionStatus
+    };
+}
+export { useTransitionStatus };

package/dist/{4388.js → 487.js}

@@ -1,5 +1,4 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { stateAttributesMapping_TransitionStatusDataAttributes } from "./880.js";
 import { useIsoLayoutEffect } from "./6499.js";
 import { isSafari } from "./8971.js";
 import { visuallyHidden } from "./8225.js";
@@ -7,9 +6,9 @@ import { isNode, getComputedStyle, getNodeName, isShadowRoot, isHTMLElement } fr
 import { contains, activeElement } from "./4549.js";
 import { isElementVisible } from "./3319.js";
 import { ownerDocument } from "./9829.js";
-import { createAttribute } from "./5992.js";
+import { createAttribute } from "./2445.js";
 import { useRenderElement, EMPTY_OBJECT } from "./8272.js";
-import { useId } from "./6046.js";
+import { useId } from "./2205.js";
 import { useStableCallback } from "./7541.js";
 import { mergeCleanups } from "./4495.js";
 import { addEventListener } from "./4723.js";
@@ -17,59 +16,6 @@ import { createChangeEventDetails } from "./4768.js";
 import { focusOut } from "./2418.js";
 import * as __rspack_external_react from "react";
 import * as __rspack_external_react_dom_7136dc57 from "react-dom";
-let popupStateMapping_CommonPopupDataAttributes = function(CommonPopupDataAttributes) {
-    CommonPopupDataAttributes["open"] = "data-open";
-    CommonPopupDataAttributes["closed"] = "data-closed";
-    CommonPopupDataAttributes[CommonPopupDataAttributes["startingStyle"] = stateAttributesMapping_TransitionStatusDataAttributes.startingStyle] = "startingStyle";
-    CommonPopupDataAttributes[CommonPopupDataAttributes["endingStyle"] = stateAttributesMapping_TransitionStatusDataAttributes.endingStyle] = "endingStyle";
-    CommonPopupDataAttributes["anchorHidden"] = "data-anchor-hidden";
-    CommonPopupDataAttributes["side"] = "data-side";
-    CommonPopupDataAttributes["align"] = "data-align";
-    return CommonPopupDataAttributes;
-}({});
-let popupStateMapping_CommonTriggerDataAttributes = /*#__PURE__*/ function(CommonTriggerDataAttributes) {
-    CommonTriggerDataAttributes["popupOpen"] = "data-popup-open";
-    CommonTriggerDataAttributes["pressed"] = "data-pressed";
-    return CommonTriggerDataAttributes;
-}({});
-const TRIGGER_HOOK = {
-    [popupStateMapping_CommonTriggerDataAttributes.popupOpen]: ''
-};
-const PRESSABLE_TRIGGER_HOOK = {
-    [popupStateMapping_CommonTriggerDataAttributes.popupOpen]: '',
-    [popupStateMapping_CommonTriggerDataAttributes.pressed]: ''
-};
-const POPUP_OPEN_HOOK = {
-    [popupStateMapping_CommonPopupDataAttributes.open]: ''
-};
-const POPUP_CLOSED_HOOK = {
-    [popupStateMapping_CommonPopupDataAttributes.closed]: ''
-};
-const ANCHOR_HIDDEN_HOOK = {
-    [popupStateMapping_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;
-    }
-};
 const FocusGuard_FocusGuard = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, ref) {
     const [role, setRole] = __rspack_external_react.useState();
     useIsoLayoutEffect(()=>{
@@ -244,7 +190,9 @@ const DISABLED_TRANSITIONS_STYLE = {
 };
 const CLICK_TRIGGER_IDENTIFIER = 'data-base-ui-click-trigger';
 const BASE_UI_SWIPE_IGNORE_ATTRIBUTE = 'data-base-ui-swipe-ignore';
+const LEGACY_SWIPE_IGNORE_ATTRIBUTE = 'data-swipe-ignore';
 const BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
+const LEGACY_SWIPE_IGNORE_SELECTOR = `[${LEGACY_SWIPE_IGNORE_ATTRIBUTE}]`;
 const DROPDOWN_COLLISION_AVOIDANCE = {
     fallbackAxisSide: 'none'
 };
@@ -415,4 +363,4 @@ const FloatingPortal_FloatingPortal = /*#__PURE__*/ __rspack_external_react.forw
     });
 });
 if ("production" !== process.env.NODE_ENV) FloatingPortal_FloatingPortal.displayName = "FloatingPortal";
-export { BASE_UI_SWIPE_IGNORE_SELECTOR, CLICK_TRIGGER_IDENTIFIER, DISABLED_TRANSITIONS_STYLE, DROPDOWN_COLLISION_AVOIDANCE, FloatingPortal_FloatingPortal, FocusGuard_FocusGuard, POPUP_COLLISION_AVOIDANCE, disableFocusInside, enableFocusInside, focusable, getNextTabbable, getPreviousTabbable, getTabbableAfterElement, getTabbableBeforeElement, isOutsideEvent, isTabbable, ownerVisuallyHidden, popupStateMapping, popupStateMapping_CommonPopupDataAttributes, popupStateMapping_CommonTriggerDataAttributes, pressableTriggerOpenStateMapping, tabbable, triggerOpenStateMapping, useFloatingPortalNode, usePortalContext };
+export { BASE_UI_SWIPE_IGNORE_SELECTOR, CLICK_TRIGGER_IDENTIFIER, DISABLED_TRANSITIONS_STYLE, DROPDOWN_COLLISION_AVOIDANCE, FloatingPortal_FloatingPortal, FocusGuard_FocusGuard, LEGACY_SWIPE_IGNORE_SELECTOR, POPUP_COLLISION_AVOIDANCE, disableFocusInside, enableFocusInside, focusable, getNextTabbable, getPreviousTabbable, getTabbableAfterElement, getTabbableBeforeElement, isOutsideEvent, isTabbable, ownerVisuallyHidden, tabbable, useFloatingPortalNode, usePortalContext };