@wix/site-ui 1.30.0 → 1.32.0

package/dist/353.js

@@ -0,0 +1,14 @@
+import { esm_formatErrorMessage } from "./8272.js";
+import * as __rspack_external_react from "react";
+const FieldsetRootContext = /*#__PURE__*/ __rspack_external_react.createContext({
+    legendId: void 0,
+    setLegendId: ()=>{},
+    disabled: void 0
+});
+if ("production" !== process.env.NODE_ENV) FieldsetRootContext.displayName = "FieldsetRootContext";
+function useFieldsetRootContext(optional = false) {
+    const context = __rspack_external_react.useContext(FieldsetRootContext);
+    if (!context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: FieldsetRootContext is missing. Fieldset parts must be placed within <Fieldset.Root>.' : esm_formatErrorMessage(86));
+    return context;
+}
+export { FieldsetRootContext, useFieldsetRootContext };

package/dist/3670.js

@@ -0,0 +1,418 @@
+import { useFloatingTree } from "./285.js";
+import { useHoverInteractionSharedState, clearSafePolygonPointerEventsMutation, getDelay, applySafePolygonPointerEventsMutation, getRestMs, useHoverShared_isClickLikeOpenEvent } from "./3056.js";
+import { useValueAsRef } from "./4707.js";
+import { useStableCallback } from "./7541.js";
+import { getTarget, contains } from "./4549.js";
+import { isElement } from "./3829.js";
+import { ownerDocument } from "./9829.js";
+import { triggerHover } from "./2418.js";
+import { createChangeEventDetails } from "./4768.js";
+import { isMouseLikePointerType } from "./6330.js";
+import { isTargetInsideEnabledTrigger } from "./8758.js";
+import { mergeCleanups } from "./4495.js";
+import { addEventListener } from "./4723.js";
+import { Timeout } from "./42.js";
+import { getNodeChildren } from "./5992.js";
+import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+const EMPTY_REF = {
+    current: null
+};
+function useHoverReferenceInteraction(context, props = {}) {
+    const { enabled = true, delay = 0, handleClose = null, mouseOnly = false, restMs = 0, move = true, triggerElementRef = EMPTY_REF, externalTree, isActiveTrigger = true, getHandleCloseContext, isClosing, shouldOpen: shouldOpenProp } = props;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const { dataRef, events } = store.context;
+    const tree = useFloatingTree(externalTree);
+    const instance = useHoverInteractionSharedState(store);
+    const isHoverCloseActiveRef = __rspack_external_react.useRef(false);
+    const handleCloseRef = useValueAsRef(handleClose);
+    const delayRef = useValueAsRef(delay);
+    const restMsRef = useValueAsRef(restMs);
+    const enabledRef = useValueAsRef(enabled);
+    const shouldOpenRef = useValueAsRef(shouldOpenProp);
+    const isClosingRef = useValueAsRef(isClosing);
+    const isClickLikeOpenEvent = useStableCallback(()=>useHoverShared_isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside));
+    const checkShouldOpen = useStableCallback(()=>shouldOpenRef.current?.() !== false);
+    const isOverInactiveTrigger = useStableCallback((currentDomReference, currentTarget, target)=>{
+        const allTriggers = store.context.triggerElements;
+        if (allTriggers.hasElement(currentTarget)) return !currentDomReference || !contains(currentDomReference, currentTarget);
+        if (!isElement(target)) return false;
+        const targetElement = target;
+        return allTriggers.hasMatchingElement((trigger)=>contains(trigger, targetElement)) && (!currentDomReference || !contains(currentDomReference, targetElement));
+    });
+    const cleanupMouseMoveHandler = useStableCallback(()=>{
+        if (!instance.handler) return;
+        const doc = ownerDocument(store.select('domReferenceElement'));
+        doc.removeEventListener('mousemove', instance.handler);
+        instance.handler = void 0;
+    });
+    const clearPointerEvents = useStableCallback(()=>{
+        clearSafePolygonPointerEventsMutation(instance);
+    });
+    if (isActiveTrigger) instance.handleCloseOptions = handleCloseRef.current?.__options;
+    __rspack_external_react.useEffect(()=>cleanupMouseMoveHandler, [
+        cleanupMouseMoveHandler
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!enabled) return;
+        function onOpenChangeLocal(details) {
+            if (details.open) isHoverCloseActiveRef.current = false;
+            else {
+                isHoverCloseActiveRef.current = details.reason === triggerHover;
+                cleanupMouseMoveHandler();
+                instance.openChangeTimeout.clear();
+                instance.restTimeout.clear();
+                instance.blockMouseMove = true;
+                instance.restTimeoutPending = false;
+            }
+        }
+        events.on('openchange', onOpenChangeLocal);
+        return ()=>{
+            events.off('openchange', onOpenChangeLocal);
+        };
+    }, [
+        enabled,
+        events,
+        instance,
+        cleanupMouseMoveHandler
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!enabled) return;
+        function closeWithDelay(event, runElseBranch = true) {
+            const closeDelay = getDelay(delayRef.current, 'close', instance.pointerType);
+            if (closeDelay) instance.openChangeTimeout.start(closeDelay, ()=>{
+                store.setOpen(false, createChangeEventDetails(triggerHover, event));
+                tree?.events.emit('floating.closed', event);
+            });
+            else if (runElseBranch) {
+                instance.openChangeTimeout.clear();
+                store.setOpen(false, createChangeEventDetails(triggerHover, event));
+                tree?.events.emit('floating.closed', event);
+            }
+        }
+        const trigger = triggerElementRef.current ?? (isActiveTrigger ? store.select('domReferenceElement') : null);
+        if (!isElement(trigger)) return;
+        function onMouseEnter(event) {
+            instance.openChangeTimeout.clear();
+            instance.blockMouseMove = false;
+            if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) return;
+            const restMsValue = getRestMs(restMsRef.current);
+            const openDelay = getDelay(delayRef.current, 'open', instance.pointerType);
+            const eventTarget = getTarget(event);
+            const currentTarget = event.currentTarget ?? null;
+            const currentDomReference = store.select('domReferenceElement');
+            let triggerNode = currentTarget;
+            if (isElement(eventTarget) && !store.context.triggerElements.hasElement(eventTarget)) {
+                for (const triggerElement of store.context.triggerElements.elements())if (contains(triggerElement, eventTarget)) {
+                    triggerNode = triggerElement;
+                    break;
+                }
+            }
+            if (isElement(currentTarget) && isElement(currentDomReference) && !store.context.triggerElements.hasElement(currentTarget) && contains(currentTarget, currentDomReference)) triggerNode = currentDomReference;
+            const isOverInactive = null == triggerNode ? false : isOverInactiveTrigger(currentDomReference, triggerNode, eventTarget);
+            const isOpen = store.select('open');
+            const isInClosingTransition = isClosingRef.current?.() ?? 'ending' === store.select('transitionStatus');
+            const isHoverCloseTransition = !isOpen && isInClosingTransition && isHoverCloseActiveRef.current;
+            const isReenteringSameTriggerDuringCloseTransition = !isOverInactive && isElement(triggerNode) && isElement(currentDomReference) && contains(currentDomReference, triggerNode) && isHoverCloseTransition;
+            const isRestOnlyDelay = restMsValue > 0 && !openDelay;
+            const shouldOpenImmediately = isOverInactive && (isOpen || isHoverCloseTransition) || isReenteringSameTriggerDuringCloseTransition;
+            const shouldOpen = !isOpen || isOverInactive;
+            if (shouldOpenImmediately) {
+                if (checkShouldOpen()) store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerNode));
+                return;
+            }
+            if (isRestOnlyDelay) return;
+            if (openDelay) instance.openChangeTimeout.start(openDelay, ()=>{
+                if (shouldOpen && checkShouldOpen()) store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerNode));
+            });
+            else if (shouldOpen) {
+                if (checkShouldOpen()) store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerNode));
+            }
+        }
+        function onMouseLeave(event) {
+            if (isClickLikeOpenEvent()) return void clearPointerEvents();
+            cleanupMouseMoveHandler();
+            const domReferenceElement = store.select('domReferenceElement');
+            const doc = ownerDocument(domReferenceElement);
+            instance.restTimeout.clear();
+            instance.restTimeoutPending = false;
+            const handleCloseContextBase = dataRef.current.floatingContext ?? getHandleCloseContext?.();
+            if (isTargetInsideEnabledTrigger(event.relatedTarget, store.context.triggerElements)) return;
+            if (handleCloseRef.current && handleCloseContextBase) {
+                if (!store.select('open')) instance.openChangeTimeout.clear();
+                const currentTrigger = triggerElementRef.current;
+                instance.handler = handleCloseRef.current({
+                    ...handleCloseContextBase,
+                    tree,
+                    x: event.clientX,
+                    y: event.clientY,
+                    onClose () {
+                        clearPointerEvents();
+                        cleanupMouseMoveHandler();
+                        if (enabledRef.current && !isClickLikeOpenEvent() && currentTrigger === store.select('domReferenceElement')) closeWithDelay(event, true);
+                    }
+                });
+                doc.addEventListener('mousemove', instance.handler);
+                instance.handler(event);
+                return;
+            }
+            const shouldClose = 'touch' === instance.pointerType ? !contains(store.select('floatingElement'), event.relatedTarget) : true;
+            if (shouldClose) closeWithDelay(event);
+        }
+        if (move) return mergeCleanups(addEventListener(trigger, 'mousemove', onMouseEnter, {
+            once: true
+        }), addEventListener(trigger, 'mouseenter', onMouseEnter), addEventListener(trigger, 'mouseleave', onMouseLeave));
+        return mergeCleanups(addEventListener(trigger, 'mouseenter', onMouseEnter), addEventListener(trigger, 'mouseleave', onMouseLeave));
+    }, [
+        cleanupMouseMoveHandler,
+        clearPointerEvents,
+        dataRef,
+        delayRef,
+        store,
+        enabled,
+        handleCloseRef,
+        instance,
+        isActiveTrigger,
+        isOverInactiveTrigger,
+        isClickLikeOpenEvent,
+        mouseOnly,
+        move,
+        restMsRef,
+        triggerElementRef,
+        tree,
+        enabledRef,
+        getHandleCloseContext,
+        isClosingRef,
+        checkShouldOpen
+    ]);
+    return __rspack_external_react.useMemo(()=>{
+        if (!enabled) return;
+        function setPointerRef(event) {
+            instance.pointerType = event.pointerType;
+        }
+        return {
+            onPointerDown: setPointerRef,
+            onPointerEnter: setPointerRef,
+            onMouseMove (event) {
+                const { nativeEvent } = event;
+                const trigger = event.currentTarget;
+                const currentDomReference = store.select('domReferenceElement');
+                const currentOpen = store.select('open');
+                const isOverInactive = isOverInactiveTrigger(currentDomReference, trigger, event.target);
+                if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) return;
+                if (currentOpen && isOverInactive && instance.handleCloseOptions?.blockPointerEvents) {
+                    const floatingElement = store.select('floatingElement');
+                    if (floatingElement) {
+                        const scopeElement = instance.handleCloseOptions?.getScope?.() ?? trigger.ownerDocument.body;
+                        applySafePolygonPointerEventsMutation(instance, {
+                            scopeElement,
+                            referenceElement: trigger,
+                            floatingElement
+                        });
+                    }
+                }
+                const restMsValue = getRestMs(restMsRef.current);
+                if (currentOpen && !isOverInactive || 0 === restMsValue) return;
+                if (!isOverInactive && instance.restTimeoutPending && event.movementX ** 2 + event.movementY ** 2 < 2) return;
+                instance.restTimeout.clear();
+                function handleMouseMove() {
+                    instance.restTimeoutPending = false;
+                    if (isClickLikeOpenEvent()) return;
+                    const latestOpen = store.select('open');
+                    if (!instance.blockMouseMove && (!latestOpen || isOverInactive) && checkShouldOpen()) store.setOpen(true, createChangeEventDetails(triggerHover, nativeEvent, trigger));
+                }
+                if ('touch' === instance.pointerType) __rspack_external_react_dom_7136dc57.flushSync(()=>{
+                    handleMouseMove();
+                });
+                else if (isOverInactive && currentOpen) handleMouseMove();
+                else {
+                    instance.restTimeoutPending = true;
+                    instance.restTimeout.start(restMsValue, handleMouseMove);
+                }
+            }
+        };
+    }, [
+        enabled,
+        instance,
+        isClickLikeOpenEvent,
+        isOverInactiveTrigger,
+        mouseOnly,
+        store,
+        restMsRef,
+        checkShouldOpen
+    ]);
+}
+const CURSOR_SPEED_THRESHOLD = 0.1;
+const CURSOR_SPEED_THRESHOLD_SQUARED = CURSOR_SPEED_THRESHOLD * CURSOR_SPEED_THRESHOLD;
+const POLYGON_BUFFER = 0.5;
+function hasIntersectingEdge(pointX, pointY, xi, yi, xj, yj) {
+    return yi >= pointY !== yj >= pointY && pointX <= (xj - xi) * (pointY - yi) / (yj - yi) + xi;
+}
+function isPointInQuadrilateral(pointX, pointY, x1, y1, x2, y2, x3, y3, x4, y4) {
+    let isInsideValue = false;
+    if (hasIntersectingEdge(pointX, pointY, x1, y1, x2, y2)) isInsideValue = !isInsideValue;
+    if (hasIntersectingEdge(pointX, pointY, x2, y2, x3, y3)) isInsideValue = !isInsideValue;
+    if (hasIntersectingEdge(pointX, pointY, x3, y3, x4, y4)) isInsideValue = !isInsideValue;
+    if (hasIntersectingEdge(pointX, pointY, x4, y4, x1, y1)) isInsideValue = !isInsideValue;
+    return isInsideValue;
+}
+function isInsideRect(pointX, pointY, rect) {
+    return pointX >= rect.x && pointX <= rect.x + rect.width && pointY >= rect.y && pointY <= rect.y + rect.height;
+}
+function isInsideAxisAlignedRect(pointX, pointY, x1, y1, x2, y2) {
+    const minX = Math.min(x1, x2);
+    const maxX = Math.max(x1, x2);
+    const minY = Math.min(y1, y2);
+    const maxY = Math.max(y1, y2);
+    return pointX >= minX && pointX <= maxX && pointY >= minY && pointY <= maxY;
+}
+function safePolygon(options = {}) {
+    const { blockPointerEvents = false } = options;
+    const timeout = new Timeout();
+    const fn = ({ x, y, placement, elements, onClose, nodeId, tree })=>{
+        const side = placement?.split('-')[0];
+        let hasLanded = false;
+        let lastX = null;
+        let lastY = null;
+        let lastCursorTime = "u" > typeof performance ? performance.now() : 0;
+        function isCursorMovingSlowly(nextX, nextY) {
+            const currentTime = performance.now();
+            const elapsedTime = currentTime - lastCursorTime;
+            if (null === lastX || null === lastY || 0 === elapsedTime) {
+                lastX = nextX;
+                lastY = nextY;
+                lastCursorTime = currentTime;
+                return false;
+            }
+            const deltaX = nextX - lastX;
+            const deltaY = nextY - lastY;
+            const distanceSquared = deltaX * deltaX + deltaY * deltaY;
+            const thresholdSquared = elapsedTime * elapsedTime * CURSOR_SPEED_THRESHOLD_SQUARED;
+            lastX = nextX;
+            lastY = nextY;
+            lastCursorTime = currentTime;
+            return distanceSquared < thresholdSquared;
+        }
+        function close() {
+            timeout.clear();
+            onClose();
+        }
+        return function(event) {
+            timeout.clear();
+            const domReference = elements.domReference;
+            const floating = elements.floating;
+            if (!domReference || !floating || null == side || null == x || null == y) return;
+            const { clientX, clientY } = event;
+            const target = getTarget(event);
+            const isLeave = 'mouseleave' === event.type;
+            const isOverFloatingEl = contains(floating, target);
+            const isOverReferenceEl = contains(domReference, target);
+            if (isOverFloatingEl) {
+                hasLanded = true;
+                if (!isLeave) return;
+            }
+            if (isOverReferenceEl) {
+                hasLanded = false;
+                if (!isLeave) {
+                    hasLanded = true;
+                    return;
+                }
+            }
+            if (isLeave && isElement(event.relatedTarget) && contains(floating, event.relatedTarget)) return;
+            function hasOpenChildNode() {
+                return Boolean(tree && getNodeChildren(tree.nodesRef.current, nodeId).length > 0);
+            }
+            function closeIfNoOpenChild() {
+                if (!hasOpenChildNode()) close();
+            }
+            if (hasOpenChildNode()) return;
+            const refRect = domReference.getBoundingClientRect();
+            const rect = floating.getBoundingClientRect();
+            const cursorLeaveFromRight = x > rect.right - rect.width / 2;
+            const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;
+            const isFloatingWider = rect.width > refRect.width;
+            const isFloatingTaller = rect.height > refRect.height;
+            const left = (isFloatingWider ? refRect : rect).left;
+            const right = (isFloatingWider ? refRect : rect).right;
+            const top = (isFloatingTaller ? refRect : rect).top;
+            const bottom = (isFloatingTaller ? refRect : rect).bottom;
+            if ('top' === side && y >= refRect.bottom - 1 || 'bottom' === side && y <= refRect.top + 1 || 'left' === side && x >= refRect.right - 1 || 'right' === side && x <= refRect.left + 1) return void closeIfNoOpenChild();
+            let isInsideTroughRect = false;
+            switch(side){
+                case 'top':
+                    isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, left, refRect.top + 1, right, rect.bottom - 1);
+                    break;
+                case 'bottom':
+                    isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, left, rect.top + 1, right, refRect.bottom - 1);
+                    break;
+                case 'left':
+                    isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, rect.right - 1, bottom, refRect.left + 1, top);
+                    break;
+                case 'right':
+                    isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, refRect.right - 1, bottom, rect.left + 1, top);
+                    break;
+                default:
+            }
+            if (isInsideTroughRect) return;
+            if (hasLanded && !isInsideRect(clientX, clientY, refRect)) return void closeIfNoOpenChild();
+            if (!isLeave && isCursorMovingSlowly(clientX, clientY)) return void closeIfNoOpenChild();
+            let isInsidePolygon = false;
+            switch(side){
+                case 'top':
+                    {
+                        const cursorXOffset = isFloatingWider ? POLYGON_BUFFER / 2 : 4 * POLYGON_BUFFER;
+                        const cursorPointOneX = isFloatingWider ? x + cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
+                        const cursorPointTwoX = isFloatingWider ? x - cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
+                        const cursorPointY = y + POLYGON_BUFFER + 1;
+                        const commonYLeft = cursorLeaveFromRight ? rect.bottom - POLYGON_BUFFER : isFloatingWider ? rect.bottom - POLYGON_BUFFER : rect.top;
+                        const commonYRight = cursorLeaveFromRight ? isFloatingWider ? rect.bottom - POLYGON_BUFFER : rect.top : rect.bottom - POLYGON_BUFFER;
+                        isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointOneX, cursorPointY, cursorPointTwoX, cursorPointY, rect.left, commonYLeft, rect.right, commonYRight);
+                        break;
+                    }
+                case 'bottom':
+                    {
+                        const cursorXOffset = isFloatingWider ? POLYGON_BUFFER / 2 : 4 * POLYGON_BUFFER;
+                        const cursorPointOneX = isFloatingWider ? x + cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
+                        const cursorPointTwoX = isFloatingWider ? x - cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
+                        const cursorPointY = y - POLYGON_BUFFER;
+                        const commonYLeft = cursorLeaveFromRight ? rect.top + POLYGON_BUFFER : isFloatingWider ? rect.top + POLYGON_BUFFER : rect.bottom;
+                        const commonYRight = cursorLeaveFromRight ? isFloatingWider ? rect.top + POLYGON_BUFFER : rect.bottom : rect.top + POLYGON_BUFFER;
+                        isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointOneX, cursorPointY, cursorPointTwoX, cursorPointY, rect.left, commonYLeft, rect.right, commonYRight);
+                        break;
+                    }
+                case 'left':
+                    {
+                        const cursorYOffset = isFloatingTaller ? POLYGON_BUFFER / 2 : 4 * POLYGON_BUFFER;
+                        const cursorPointOneY = isFloatingTaller ? y + cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
+                        const cursorPointTwoY = isFloatingTaller ? y - cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
+                        const cursorPointX = x + POLYGON_BUFFER + 1;
+                        const commonXTop = cursorLeaveFromBottom ? rect.right - POLYGON_BUFFER : isFloatingTaller ? rect.right - POLYGON_BUFFER : rect.left;
+                        const commonXBottom = cursorLeaveFromBottom ? isFloatingTaller ? rect.right - POLYGON_BUFFER : rect.left : rect.right - POLYGON_BUFFER;
+                        isInsidePolygon = isPointInQuadrilateral(clientX, clientY, commonXTop, rect.top, commonXBottom, rect.bottom, cursorPointX, cursorPointOneY, cursorPointX, cursorPointTwoY);
+                        break;
+                    }
+                case 'right':
+                    {
+                        const cursorYOffset = isFloatingTaller ? POLYGON_BUFFER / 2 : 4 * POLYGON_BUFFER;
+                        const cursorPointOneY = isFloatingTaller ? y + cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
+                        const cursorPointTwoY = isFloatingTaller ? y - cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
+                        const cursorPointX = x - POLYGON_BUFFER;
+                        const commonXTop = cursorLeaveFromBottom ? rect.left + POLYGON_BUFFER : isFloatingTaller ? rect.left + POLYGON_BUFFER : rect.right;
+                        const commonXBottom = cursorLeaveFromBottom ? isFloatingTaller ? rect.left + POLYGON_BUFFER : rect.right : rect.left + POLYGON_BUFFER;
+                        isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointX, cursorPointOneY, cursorPointX, cursorPointTwoY, commonXTop, rect.top, commonXBottom, rect.bottom);
+                        break;
+                    }
+                default:
+            }
+            if (isInsidePolygon) {
+                if (!hasLanded) timeout.start(40, closeIfNoOpenChild);
+            } else closeIfNoOpenChild();
+        };
+    };
+    fn.__options = {
+        ...options,
+        blockPointerEvents
+    };
+    return fn;
+}
+export { safePolygon, useHoverReferenceInteraction };

package/dist/3829.js

@@ -0,0 +1,113 @@
+function hasWindow() {
+    return "u" > typeof window;
+}
+function getNodeName(node) {
+    if (isNode(node)) return (node.nodeName || '').toLowerCase();
+    return '#document';
+}
+function getWindow(node) {
+    var _node$ownerDocument;
+    return (null == node || null == (_node$ownerDocument = node.ownerDocument) ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+    var _ref;
+    return null == (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+    if (!hasWindow()) return false;
+    return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+    if (!hasWindow()) return false;
+    return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+    if (!hasWindow()) return false;
+    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+    if (!hasWindow() || "u" < typeof ShadowRoot) return false;
+    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+    const { overflow, overflowX, overflowY, display } = getComputedStyle(element);
+    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && 'inline' !== display && 'contents' !== display;
+}
+function isTableElement(element) {
+    return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+    try {
+        if (element.matches(':popover-open')) return true;
+    } catch (_e) {}
+    try {
+        return element.matches(':modal');
+    } catch (_e) {
+        return false;
+    }
+}
+const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+const containRe = /paint|layout|strict|content/;
+const isNotNone = (value)=>!!value && 'none' !== value;
+let isWebKitValue;
+function isContainingBlock(elementOrCss) {
+    const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+    return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');
+}
+function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while(isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)){
+        if (isContainingBlock(currentNode)) return currentNode;
+        if (isTopLayer(currentNode)) break;
+        currentNode = getParentNode(currentNode);
+    }
+    return null;
+}
+function isWebKit() {
+    if (null == isWebKitValue) isWebKitValue = "u" > typeof CSS && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');
+    return isWebKitValue;
+}
+function isLastTraversableNode(node) {
+    return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+    if (isElement(element)) return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop
+    };
+    return {
+        scrollLeft: element.scrollX,
+        scrollTop: element.scrollY
+    };
+}
+function getParentNode(node) {
+    if ('html' === getNodeName(node)) return node;
+    const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+    return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode(node);
+    if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+    return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+    var _node$ownerDocument2;
+    if (void 0 === list) list = [];
+    if (void 0 === traverseIframes) traverseIframes = true;
+    const scrollableAncestor = getNearestOverflowAncestor(node);
+    const isBody = scrollableAncestor === (null == (_node$ownerDocument2 = node.ownerDocument) ? void 0 : _node$ownerDocument2.body);
+    const win = getWindow(scrollableAncestor);
+    if (!isBody) return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+    {
+        const frameElement = getFrameElement(win);
+        return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+    }
+}
+function getFrameElement(win) {
+    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };

package/dist/4026.js

@@ -0,0 +1,12 @@
+let set;
+if ('production' !== process.env.NODE_ENV) set = new Set();
+function error(...messages) {
+    if ('production' !== process.env.NODE_ENV) {
+        const messageKey = messages.join(' ');
+        if (!set.has(messageKey)) {
+            set.add(messageKey);
+            console.error(`Base UI: ${messageKey}`);
+        }
+    }
+}
+export { error };

package/dist/4143.js

@@ -0,0 +1,46 @@
+import { useLabelableContext } from "./1477.js";
+import { useStableCallback } from "./7541.js";
+import { useRegisteredLabelId } from "./6706.js";
+import { ownerDocument } from "./9829.js";
+import { isHTMLElement } from "./3829.js";
+import { getTarget } from "./4549.js";
+function useLabel(params = {}) {
+    const { id: idProp, fallbackControlId, native = false, setLabelId: setLabelIdProp, focusControl: focusControlProp } = params;
+    const { controlId: contextControlId, setLabelId: setContextLabelId } = useLabelableContext();
+    const syncLabelId = useStableCallback((nextLabelId)=>{
+        setContextLabelId(nextLabelId);
+        setLabelIdProp?.(nextLabelId);
+    });
+    const id = useRegisteredLabelId(idProp, syncLabelId);
+    const resolvedControlId = contextControlId ?? fallbackControlId;
+    function focusControl(event) {
+        if (focusControlProp) return void focusControlProp(event, resolvedControlId);
+        if (!resolvedControlId) return;
+        const controlElement = ownerDocument(event.currentTarget).getElementById(resolvedControlId);
+        if (isHTMLElement(controlElement)) focusElementWithVisible(controlElement);
+    }
+    function handleInteraction(event) {
+        const target = getTarget(event.nativeEvent);
+        if (target?.closest('button,input,select,textarea')) return;
+        if (!event.defaultPrevented && event.detail > 1) event.preventDefault();
+        if (native) return;
+        focusControl(event);
+    }
+    return native ? {
+        id,
+        htmlFor: resolvedControlId ?? void 0,
+        onMouseDown: handleInteraction
+    } : {
+        id,
+        onClick: handleInteraction,
+        onPointerDown (event) {
+            event.preventDefault();
+        }
+    };
+}
+function focusElementWithVisible(element) {
+    element.focus({
+        focusVisible: true
+    });
+}
+export { focusElementWithVisible, useLabel };

package/dist/42.js

@@ -0,0 +1,32 @@
+import { useRefWithInit } from "./8272.js";
+import { useOnMount } from "./2861.js";
+const EMPTY = 0;
+class Timeout {
+    static create() {
+        return new Timeout();
+    }
+    currentId = EMPTY;
+    start(delay, fn) {
+        this.clear();
+        this.currentId = setTimeout(()=>{
+            this.currentId = EMPTY;
+            fn();
+        }, delay);
+    }
+    isStarted() {
+        return this.currentId !== EMPTY;
+    }
+    clear = ()=>{
+        if (this.currentId !== EMPTY) {
+            clearTimeout(this.currentId);
+            this.currentId = EMPTY;
+        }
+    };
+    disposeEffect = ()=>this.clear;
+}
+function useTimeout() {
+    const timeout = useRefWithInit(Timeout.create).current;
+    useOnMount(timeout.disposeEffect);
+    return timeout;
+}
+export { Timeout, useTimeout };

package/dist/4281.js

@@ -0,0 +1,30 @@
+import { useFieldRootContext } from "./1477.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import * as __rspack_external_react from "react";
+function useRegisterFieldControl(controlRef, id, value, getFormValueOverride, enabled = true) {
+    const { registerFieldControl } = useFieldRootContext();
+    const sourceRef = __rspack_external_react.useRef(null);
+    if (!sourceRef.current) sourceRef.current = Symbol();
+    useIsoLayoutEffect(()=>{
+        const source = sourceRef.current;
+        if (!source || !enabled) return;
+        const registration = {
+            controlRef,
+            getValue: getFormValueOverride,
+            id,
+            value
+        };
+        registerFieldControl(source, registration);
+        return ()=>{
+            registerFieldControl(source, void 0);
+        };
+    }, [
+        controlRef,
+        enabled,
+        getFormValueOverride,
+        id,
+        registerFieldControl,
+        value
+    ]);
+}
+export { useRegisterFieldControl };