@wix/site-ui 1.30.0 → 1.32.0

package/dist/4346.js

@@ -0,0 +1,2 @@
+const ACTIVE_COMPOSITE_ITEM = 'data-composite-item-active';
+export { ACTIVE_COMPOSITE_ITEM };

package/dist/4388.js

@@ -0,0 +1,418 @@
+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";
+import { isNode, getComputedStyle, getNodeName, isShadowRoot, isHTMLElement } from "./3829.js";
+import { contains, activeElement } from "./4549.js";
+import { isElementVisible } from "./3319.js";
+import { ownerDocument } from "./9829.js";
+import { createAttribute } from "./5992.js";
+import { useRenderElement, EMPTY_OBJECT } from "./8272.js";
+import { useId } from "./6046.js";
+import { useStableCallback } from "./7541.js";
+import { mergeCleanups } from "./4495.js";
+import { addEventListener } from "./4723.js";
+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(()=>{
+        if (isSafari) setRole('button');
+    }, []);
+    const restProps = {
+        tabIndex: 0,
+        role
+    };
+    return /*#__PURE__*/ jsx("span", {
+        ...props,
+        ref: ref,
+        style: visuallyHidden,
+        "aria-hidden": role ? void 0 : true,
+        ...restProps,
+        "data-base-ui-focus-guard": ""
+    });
+});
+if ("production" !== process.env.NODE_ENV) FocusGuard_FocusGuard.displayName = "FocusGuard";
+const CANDIDATE_SELECTOR = 'a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable="false"]),audio[controls],video[controls]';
+function getParentElement(element) {
+    const assignedSlot = element.assignedSlot;
+    if (assignedSlot) return assignedSlot;
+    if (element.parentElement) return element.parentElement;
+    const rootNode = element.getRootNode();
+    return isShadowRoot(rootNode) ? rootNode.host : null;
+}
+function getDetailsSummary(details) {
+    for (const child of Array.from(details.children))if ('summary' === getNodeName(child)) return child;
+    return null;
+}
+function isWithinOpenDetailsSummary(element, details) {
+    const summary = getDetailsSummary(details);
+    return !!summary && (element === summary || contains(summary, element));
+}
+function isFocusableCandidate(element) {
+    const nodeName = element ? getNodeName(element) : '';
+    return null != element && element.matches(CANDIDATE_SELECTOR) && ('summary' !== nodeName || null != element.parentElement && 'details' === getNodeName(element.parentElement) && getDetailsSummary(element.parentElement) === element) && ('details' !== nodeName || null == getDetailsSummary(element)) && ('input' !== nodeName || 'hidden' !== element.type);
+}
+function isFocusableElement(element) {
+    if (!isFocusableCandidate(element) || !element.isConnected || element.matches(':disabled')) return false;
+    for(let current = element; current; current = getParentElement(current)){
+        const isAncestor = current !== element;
+        const isSlot = 'slot' === getNodeName(current);
+        if (current.hasAttribute('inert')) return false;
+        if (isAncestor && 'details' === getNodeName(current) && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute('hidden') || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) return false;
+    }
+    return true;
+}
+function isVisibleInTabbableTree(element, isAncestor) {
+    const styles = getComputedStyle(element);
+    if (!isAncestor) return isElementVisible(element, styles);
+    return 'none' !== styles.display;
+}
+function getTabIndex(element) {
+    const tabIndex = element.tabIndex;
+    if (tabIndex < 0) {
+        const nodeName = getNodeName(element);
+        if ('details' === nodeName || 'audio' === nodeName || 'video' === nodeName || isHTMLElement(element) && element.isContentEditable) return 0;
+    }
+    return tabIndex;
+}
+function getNamedRadioInput(element) {
+    if ('input' !== getNodeName(element)) return null;
+    const input = element;
+    return 'radio' === input.type && '' !== input.name ? input : null;
+}
+function isTabbableRadio(element, candidates) {
+    const input = getNamedRadioInput(element);
+    if (!input) return true;
+    const checkedRadio = candidates.find((candidate)=>{
+        const radio = getNamedRadioInput(candidate);
+        return radio?.name === input.name && radio.form === input.form && radio.checked;
+    });
+    if (checkedRadio) return checkedRadio === input;
+    return candidates.find((candidate)=>{
+        const radio = getNamedRadioInput(candidate);
+        return radio?.name === input.name && radio.form === input.form;
+    }) === input;
+}
+function getComposedChildren(container) {
+    if (isHTMLElement(container) && 'slot' === getNodeName(container)) {
+        const assignedElements = container.assignedElements({
+            flatten: true
+        });
+        if (assignedElements.length > 0) return assignedElements;
+    }
+    if (isHTMLElement(container) && container.shadowRoot) return Array.from(container.shadowRoot.children);
+    return Array.from(container.children);
+}
+function appendCandidates(container, list) {
+    getComposedChildren(container).forEach((child)=>{
+        if (isFocusableCandidate(child)) list.push(child);
+        appendCandidates(child, list);
+    });
+}
+function appendMatchingElements(container, selector, list) {
+    getComposedChildren(container).forEach((child)=>{
+        if (isHTMLElement(child) && child.matches(selector)) list.push(child);
+        appendMatchingElements(child, selector, list);
+    });
+}
+function isTabbable(element) {
+    return isFocusableElement(element) && getTabIndex(element) >= 0;
+}
+function focusable(container) {
+    const candidates = [];
+    appendCandidates(container, candidates);
+    return candidates.filter(isFocusableElement);
+}
+function tabbable(container) {
+    const candidates = focusable(container);
+    return candidates.filter((element)=>getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
+}
+function getTabbableIn(container, dir) {
+    const list = tabbable(container);
+    const len = list.length;
+    if (0 === len) return;
+    const active = activeElement(ownerDocument(container));
+    const index = list.indexOf(active);
+    const nextIndex = -1 === index ? 1 === dir ? 0 : len - 1 : index + dir;
+    return list[nextIndex];
+}
+function getNextTabbable(referenceElement) {
+    return getTabbableIn(ownerDocument(referenceElement).body, 1) || referenceElement;
+}
+function getPreviousTabbable(referenceElement) {
+    return getTabbableIn(ownerDocument(referenceElement).body, -1) || referenceElement;
+}
+function getTabbableNearElement(referenceElement, dir) {
+    if (!referenceElement) return null;
+    const list = tabbable(ownerDocument(referenceElement).body);
+    const elementCount = list.length;
+    if (0 === elementCount) return null;
+    const index = list.indexOf(referenceElement);
+    if (-1 === index) return null;
+    const nextIndex = (index + dir + elementCount) % elementCount;
+    return list[nextIndex];
+}
+function getTabbableAfterElement(referenceElement) {
+    return getTabbableNearElement(referenceElement, 1);
+}
+function getTabbableBeforeElement(referenceElement) {
+    return getTabbableNearElement(referenceElement, -1);
+}
+function isOutsideEvent(event, container) {
+    const containerElement = container || event.currentTarget;
+    const relatedTarget = event.relatedTarget;
+    return !relatedTarget || !contains(containerElement, relatedTarget);
+}
+function disableFocusInside(container) {
+    const tabbableElements = tabbable(container);
+    tabbableElements.forEach((element)=>{
+        element.dataset.tabindex = element.getAttribute('tabindex') || '';
+        element.setAttribute('tabindex', '-1');
+    });
+}
+function enableFocusInside(container) {
+    const elements = [];
+    appendMatchingElements(container, '[data-tabindex]', elements);
+    elements.forEach((element)=>{
+        const tabindex = element.dataset.tabindex;
+        delete element.dataset.tabindex;
+        if (tabindex) element.setAttribute('tabindex', tabindex);
+        else element.removeAttribute('tabindex');
+    });
+}
+const DISABLED_TRANSITIONS_STYLE = {
+    style: {
+        transition: 'none'
+    }
+};
+const CLICK_TRIGGER_IDENTIFIER = 'data-base-ui-click-trigger';
+const BASE_UI_SWIPE_IGNORE_ATTRIBUTE = 'data-base-ui-swipe-ignore';
+const BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
+const DROPDOWN_COLLISION_AVOIDANCE = {
+    fallbackAxisSide: 'none'
+};
+const POPUP_COLLISION_AVOIDANCE = {
+    fallbackAxisSide: 'end'
+};
+const ownerVisuallyHidden = {
+    clipPath: 'inset(50%)',
+    position: 'fixed',
+    top: 0,
+    left: 0
+};
+const PortalContext = /*#__PURE__*/ __rspack_external_react.createContext(null);
+if ("production" !== process.env.NODE_ENV) PortalContext.displayName = "PortalContext";
+const usePortalContext = ()=>__rspack_external_react.useContext(PortalContext);
+const attr = createAttribute('portal');
+function useFloatingPortalNode(props = {}) {
+    const { ref, container: containerProp, componentProps = EMPTY_OBJECT, elementProps } = props;
+    const uniqueId = useId();
+    const portalContext = usePortalContext();
+    const parentPortalNode = portalContext?.portalNode;
+    const [containerElement, setContainerElement] = __rspack_external_react.useState(null);
+    const [portalNode, setPortalNode] = __rspack_external_react.useState(null);
+    const setPortalNodeRef = useStableCallback((node)=>{
+        if (null !== node) setPortalNode(node);
+    });
+    const containerRef = __rspack_external_react.useRef(null);
+    useIsoLayoutEffect(()=>{
+        if (null === containerProp) {
+            if (containerRef.current) {
+                containerRef.current = null;
+                setPortalNode(null);
+                setContainerElement(null);
+            }
+            return;
+        }
+        if (null == uniqueId) return;
+        const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
+        if (null == resolvedContainer) {
+            if (containerRef.current) {
+                containerRef.current = null;
+                setPortalNode(null);
+                setContainerElement(null);
+            }
+            return;
+        }
+        if (containerRef.current !== resolvedContainer) {
+            containerRef.current = resolvedContainer;
+            setPortalNode(null);
+            setContainerElement(resolvedContainer);
+        }
+    }, [
+        containerProp,
+        parentPortalNode,
+        uniqueId
+    ]);
+    const portalElement = useRenderElement('div', componentProps, {
+        ref: [
+            ref,
+            setPortalNodeRef
+        ],
+        props: [
+            {
+                id: uniqueId,
+                [attr]: ''
+            },
+            elementProps
+        ]
+    });
+    const portalSubtree = containerElement && portalElement ? /*#__PURE__*/ __rspack_external_react_dom_7136dc57.createPortal(portalElement, containerElement) : null;
+    return {
+        portalNode,
+        portalSubtree
+    };
+}
+const FloatingPortal_FloatingPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, children, container, renderGuards, ...elementProps } = componentProps;
+    const { portalNode, portalSubtree } = useFloatingPortalNode({
+        container,
+        ref: forwardedRef,
+        componentProps,
+        elementProps
+    });
+    const beforeOutsideRef = __rspack_external_react.useRef(null);
+    const afterOutsideRef = __rspack_external_react.useRef(null);
+    const beforeInsideRef = __rspack_external_react.useRef(null);
+    const afterInsideRef = __rspack_external_react.useRef(null);
+    const [focusManagerState, setFocusManagerState] = __rspack_external_react.useState(null);
+    const focusInsideDisabledRef = __rspack_external_react.useRef(false);
+    const modal = focusManagerState?.modal;
+    const open = focusManagerState?.open;
+    const shouldRenderGuards = 'boolean' == typeof renderGuards ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
+    __rspack_external_react.useEffect(()=>{
+        if (!portalNode || modal) return;
+        function onFocus(event) {
+            if (portalNode && event.relatedTarget && isOutsideEvent(event)) if ('focusin' === event.type) {
+                if (focusInsideDisabledRef.current) {
+                    enableFocusInside(portalNode);
+                    focusInsideDisabledRef.current = false;
+                }
+            } else {
+                disableFocusInside(portalNode);
+                focusInsideDisabledRef.current = true;
+            }
+        }
+        return mergeCleanups(addEventListener(portalNode, 'focusin', onFocus, true), addEventListener(portalNode, 'focusout', onFocus, true));
+    }, [
+        portalNode,
+        modal
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!portalNode || false !== open) return;
+        enableFocusInside(portalNode);
+        focusInsideDisabledRef.current = false;
+    }, [
+        open,
+        portalNode
+    ]);
+    const portalContextValue = __rspack_external_react.useMemo(()=>({
+            beforeOutsideRef,
+            afterOutsideRef,
+            beforeInsideRef,
+            afterInsideRef,
+            portalNode,
+            setFocusManagerState
+        }), [
+        portalNode
+    ]);
+    return /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            portalSubtree,
+            /*#__PURE__*/ jsxs(PortalContext.Provider, {
+                value: portalContextValue,
+                children: [
+                    shouldRenderGuards && portalNode && /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                        "data-type": "outside",
+                        ref: beforeOutsideRef,
+                        onFocus: (event)=>{
+                            if (isOutsideEvent(event, portalNode)) beforeInsideRef.current?.focus();
+                            else {
+                                const domReference = focusManagerState ? focusManagerState.domReference : null;
+                                const prevTabbable = getPreviousTabbable(domReference);
+                                prevTabbable?.focus();
+                            }
+                        }
+                    }),
+                    shouldRenderGuards && portalNode && /*#__PURE__*/ jsx("span", {
+                        "aria-owns": portalNode.id,
+                        style: ownerVisuallyHidden
+                    }),
+                    portalNode && /*#__PURE__*/ __rspack_external_react_dom_7136dc57.createPortal(children, portalNode),
+                    shouldRenderGuards && portalNode && /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                        "data-type": "outside",
+                        ref: afterOutsideRef,
+                        onFocus: (event)=>{
+                            if (isOutsideEvent(event, portalNode)) afterInsideRef.current?.focus();
+                            else {
+                                const domReference = focusManagerState ? focusManagerState.domReference : null;
+                                const nextTabbable = getNextTabbable(domReference);
+                                nextTabbable?.focus();
+                                if (focusManagerState?.closeOnFocusOut) focusManagerState?.onOpenChange(false, createChangeEventDetails(focusOut, event.nativeEvent));
+                            }
+                        }
+                    })
+                ]
+            })
+        ]
+    });
+});
+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 };

package/dist/4490.js

@@ -0,0 +1,32 @@
+import { useBaseUiId } from "./6046.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import * as __rspack_external_react from "react";
+function useAriaLabelledBy(explicitAriaLabelledBy, labelId, labelSourceRef, enableFallback = true, labelSourceId) {
+    const [fallbackAriaLabelledBy, setFallbackAriaLabelledBy] = __rspack_external_react.useState();
+    const generatedLabelId = useBaseUiId(labelSourceId ? `${labelSourceId}-label` : void 0);
+    const ariaLabelledBy = explicitAriaLabelledBy ?? labelId ?? fallbackAriaLabelledBy;
+    useIsoLayoutEffect(()=>{
+        const nextAriaLabelledBy = explicitAriaLabelledBy || labelId || !enableFallback ? void 0 : getAriaLabelledBy(labelSourceRef.current, generatedLabelId);
+        if (fallbackAriaLabelledBy !== nextAriaLabelledBy) setFallbackAriaLabelledBy(nextAriaLabelledBy);
+    });
+    return ariaLabelledBy;
+}
+function getAriaLabelledBy(labelSource, generatedLabelId) {
+    const label = findAssociatedLabel(labelSource);
+    if (!label) return;
+    if (!label.id && generatedLabelId) label.id = generatedLabelId;
+    return label.id || void 0;
+}
+function findAssociatedLabel(labelSource) {
+    if (!labelSource) return;
+    const parent = labelSource.parentElement;
+    if (parent && 'LABEL' === parent.tagName) return parent;
+    const controlId = labelSource.id;
+    if (controlId) {
+        const nextSibling = labelSource.nextElementSibling;
+        if (nextSibling && nextSibling.htmlFor === controlId) return nextSibling;
+    }
+    const labels = labelSource.labels;
+    return labels && labels[0];
+}
+export { useAriaLabelledBy };

package/dist/4495.js

@@ -0,0 +1,9 @@
+function mergeCleanups(...cleanups) {
+    return ()=>{
+        for(let i = 0; i < cleanups.length; i += 1){
+            const cleanup = cleanups[i];
+            if (cleanup) cleanup();
+        }
+    };
+}
+export { mergeCleanups };

package/dist/4549.js

@@ -0,0 +1,24 @@
+import { isShadowRoot } from "./3829.js";
+function activeElement(doc) {
+    let element = doc.activeElement;
+    while(element?.shadowRoot?.activeElement != null)element = element.shadowRoot.activeElement;
+    return element;
+}
+function contains(parent, child) {
+    if (!parent || !child) return false;
+    const rootNode = child.getRootNode?.();
+    if (parent.contains(child)) return true;
+    if (rootNode && isShadowRoot(rootNode)) {
+        let next = child;
+        while(next){
+            if (parent === next) return true;
+            next = next.parentNode || next.host;
+        }
+    }
+    return false;
+}
+function getTarget(event) {
+    if ('composedPath' in event) return event.composedPath()[0];
+    return event.target;
+}
+export { activeElement, contains, getTarget };

package/dist/4586.js

@@ -0,0 +1,41 @@
+/*! LICENSE: 4586.js.LICENSE.txt */
+import { __webpack_require__ } from "./rslib-runtime.js";
+import * as __rspack_external_react from "react";
+__webpack_require__.add({
+    "../../node_modules/use-sync-external-store/cjs/use-sync-external-store.development.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * use-sync-external-store.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.
+ */ if ("production" !== process.env.NODE_ENV) {
+            "u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+            var useSyncExternalStore$jscomp$inline_1 = __webpack_require__("react?f15c").useSyncExternalStore;
+            console.error("The main 'use-sync-external-store' entry point is not supported; all it does is re-export useSyncExternalStore from the 'react' package, so it only works with React 18+.\n\nIf you wish to support React 16 and 17, import from 'use-sync-external-store/shim' instead. It will fall back to a shimmed implementation when the native one is not available.\n\nIf you only support React 18+, you can import directly from 'react'.");
+            exports.useSyncExternalStore = useSyncExternalStore$jscomp$inline_1;
+            "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.production.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * use-sync-external-store.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 useSyncExternalStore = __webpack_require__("react?f15c").useSyncExternalStore;
+        exports.useSyncExternalStore = useSyncExternalStore;
+    },
+    "../../node_modules/use-sync-external-store/index.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.production.js");
+        else module.exports = __webpack_require__("../../node_modules/use-sync-external-store/cjs/use-sync-external-store.development.js");
+    },
+    "react?f15c" (module) {
+        module.exports = __rspack_external_react;
+    }
+});

package/dist/4586.js.LICENSE.txt

@@ -0,0 +1,19 @@
+/**
+ * @license React
+ * use-sync-external-store.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.
+ */
+
+/**
+ * @license React
+ * use-sync-external-store.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.
+ */

package/dist/4707.js

@@ -0,0 +1,19 @@
+import { useRefWithInit } from "./8272.js";
+import { useIsoLayoutEffect } from "./6499.js";
+function useValueAsRef(value) {
+    const latest = useRefWithInit(createLatestRef, value).current;
+    latest.next = value;
+    useIsoLayoutEffect(latest.effect);
+    return latest;
+}
+function createLatestRef(value) {
+    const latest = {
+        current: value,
+        next: value,
+        effect: ()=>{
+            latest.current = latest.next;
+        }
+    };
+    return latest;
+}
+export { useValueAsRef };

package/dist/4723.js

@@ -0,0 +1,7 @@
+function addEventListener(target, type, listener, options) {
+    target.addEventListener(type, listener, options);
+    return ()=>{
+        target.removeEventListener(type, listener, options);
+    };
+}
+export { addEventListener };

package/dist/4745.js

@@ -0,0 +1,7 @@
+const FOCUSABLE_ATTRIBUTE = 'data-base-ui-focusable';
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+const ARROW_LEFT = 'ArrowLeft';
+const ARROW_RIGHT = 'ArrowRight';
+const ARROW_UP = 'ArrowUp';
+const ARROW_DOWN = 'ArrowDown';
+export { ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, FOCUSABLE_ATTRIBUTE, TYPEABLE_SELECTOR };

package/dist/4768.js

@@ -0,0 +1,35 @@
+import { EMPTY_OBJECT } from "./8272.js";
+function createChangeEventDetails(reason, event, trigger, customProperties) {
+    let canceled = false;
+    let allowPropagation = false;
+    const custom = customProperties ?? EMPTY_OBJECT;
+    const details = {
+        reason,
+        event: event ?? new Event('base-ui'),
+        cancel () {
+            canceled = true;
+        },
+        allowPropagation () {
+            allowPropagation = true;
+        },
+        get isCanceled () {
+            return canceled;
+        },
+        get isPropagationAllowed () {
+            return allowPropagation;
+        },
+        trigger,
+        ...custom
+    };
+    return details;
+}
+function createGenericEventDetails(reason, event, customProperties) {
+    const custom = customProperties ?? EMPTY_OBJECT;
+    const details = {
+        reason,
+        event: event ?? new Event('base-ui'),
+        ...custom
+    };
+    return details;
+}
+export { createChangeEventDetails, createGenericEventDetails };

package/dist/4922.js

@@ -0,0 +1,15 @@
+import { PopupTriggerMap, FloatingRootStore } from "./5992.js";
+function getEmptyRootContext() {
+    return new FloatingRootStore({
+        open: false,
+        transitionStatus: void 0,
+        floatingElement: null,
+        referenceElement: null,
+        triggerElements: new PopupTriggerMap(),
+        floatingId: void 0,
+        syncOnly: false,
+        nested: false,
+        onOpenChange: void 0
+    });
+}
+export { getEmptyRootContext };

package/dist/5036.js

@@ -0,0 +1,17 @@
+import * as __rspack_external_react from "react";
+const CompositeListContext = /*#__PURE__*/ __rspack_external_react.createContext({
+    register: ()=>{},
+    unregister: ()=>{},
+    subscribeMapChange: ()=>()=>{},
+    elementsRef: {
+        current: []
+    },
+    nextIndexRef: {
+        current: 0
+    }
+});
+if ("production" !== process.env.NODE_ENV) CompositeListContext.displayName = "CompositeListContext";
+function useCompositeListContext() {
+    return __rspack_external_react.useContext(CompositeListContext);
+}
+export { CompositeListContext, useCompositeListContext };