@wix/site-ui 1.29.0 → 1.31.0

package/dist/6914.js

@@ -0,0 +1,30 @@
+const cache = new Map();
+function getFormatter(locale, options) {
+    const optionsString = JSON.stringify({
+        locale,
+        options
+    });
+    const cachedFormatter = cache.get(optionsString);
+    if (cachedFormatter) return cachedFormatter;
+    const formatter = new Intl.NumberFormat(locale, options);
+    cache.set(optionsString, formatter);
+    return formatter;
+}
+function formatNumber(value, locale, options) {
+    if (null == value) return '';
+    return getFormatter(locale, options).format(value);
+}
+function formatNumberMaxPrecision(value, locale, options) {
+    return formatNumber(value, locale, {
+        ...options,
+        maximumFractionDigits: 20
+    });
+}
+function formatNumberValue(value, locale, format) {
+    if (null == value) return '';
+    if (!format) return formatNumber(value / 100, locale, {
+        style: 'percent'
+    });
+    return formatNumber(value, locale, format);
+}
+export { formatNumber, formatNumberMaxPrecision, formatNumberValue, getFormatter };

package/dist/7021.js

@@ -0,0 +1,13 @@
+import * as __rspack_external_react from "react";
+function usePreviousValue(value) {
+    const [state, setState] = __rspack_external_react.useState({
+        current: value,
+        previous: null
+    });
+    if (value !== state.current) setState({
+        current: value,
+        previous: state.current
+    });
+    return state.previous;
+}
+export { usePreviousValue };

package/dist/7366.js

@@ -0,0 +1,83 @@
+import { jsx } from "react/jsx-runtime";
+import { serializeValue } from "./5778.js";
+import * as __rspack_external_react from "react";
+const defaultItemEquality = (itemValue, selectedValue)=>Object.is(itemValue, selectedValue);
+function compareItemEquality(itemValue, selectedValue, comparer) {
+    if (null == itemValue || null == selectedValue) return Object.is(itemValue, selectedValue);
+    return comparer(itemValue, selectedValue);
+}
+function selectedValueIncludes(selectedValues, itemValue, comparer) {
+    if (!selectedValues || 0 === selectedValues.length) return false;
+    return selectedValues.some((selectedValue)=>{
+        if (void 0 === selectedValue) return false;
+        return compareItemEquality(itemValue, selectedValue, comparer);
+    });
+}
+function findItemIndex(itemValues, selectedValue, comparer) {
+    if (!itemValues || 0 === itemValues.length) return -1;
+    return itemValues.findIndex((itemValue)=>{
+        if (void 0 === itemValue) return false;
+        return compareItemEquality(itemValue, selectedValue, comparer);
+    });
+}
+function removeItem(selectedValues, itemValue, comparer) {
+    return selectedValues.filter((selectedValue)=>!compareItemEquality(itemValue, selectedValue, comparer));
+}
+function isGroupedItems(items) {
+    return null != items && items.length > 0 && 'object' == typeof items[0] && null != items[0] && 'items' in items[0];
+}
+function hasNullItemLabel(items) {
+    if (!Array.isArray(items)) return null != items && 'null' in items;
+    const arrayItems = items;
+    if (isGroupedItems(arrayItems)) {
+        for (const group of arrayItems)for (const item of group.items)if (item && null == item.value && null != item.label) return true;
+        return false;
+    }
+    for (const item of arrayItems)if (item && null == item.value && null != item.label) return true;
+    return false;
+}
+function stringifyAsLabel(item, itemToStringLabel) {
+    if (itemToStringLabel && null != item) return itemToStringLabel(item) ?? '';
+    if (item && 'object' == typeof item) {
+        if ('label' in item && null != item.label) return String(item.label);
+        if ('value' in item) return String(item.value);
+    }
+    return serializeValue(item);
+}
+function stringifyAsValue(item, itemToStringValue) {
+    if (itemToStringValue && null != item) return itemToStringValue(item) ?? '';
+    if (item && 'object' == typeof item && 'value' in item && 'label' in item) return serializeValue(item.value);
+    return serializeValue(item);
+}
+function resolveSelectedLabel(value, items, itemToStringLabel) {
+    function fallback() {
+        return stringifyAsLabel(value, itemToStringLabel);
+    }
+    if (itemToStringLabel && null != value) return itemToStringLabel(value);
+    if (value && 'object' == typeof value && 'label' in value && null != value.label) return value.label;
+    if (items && !Array.isArray(items)) return items[value] ?? fallback();
+    if (Array.isArray(items)) {
+        const arrayItems = items;
+        const flatItems = isGroupedItems(arrayItems) ? arrayItems.flatMap((group)=>group.items) : arrayItems;
+        if (null == value || 'object' != typeof value) {
+            const match = flatItems.find((item)=>item.value === value);
+            if (match && null != match.label) return match.label;
+            return fallback();
+        }
+        if ('value' in value) {
+            const match = flatItems.find((item)=>item && item.value === value.value);
+            if (match && null != match.label) return match.label;
+        }
+    }
+    return fallback();
+}
+function resolveMultipleLabels(values, items, itemToStringLabel) {
+    return values.reduce((acc, value, index)=>{
+        if (index > 0) acc.push(', ');
+        acc.push(/*#__PURE__*/ jsx(__rspack_external_react.Fragment, {
+            children: resolveSelectedLabel(value, items, itemToStringLabel)
+        }, index));
+        return acc;
+    }, []);
+}
+export { compareItemEquality, defaultItemEquality, findItemIndex, hasNullItemLabel, isGroupedItems, removeItem, resolveMultipleLabels, resolveSelectedLabel, selectedValueIncludes, stringifyAsLabel, stringifyAsValue };

package/dist/7373.js

@@ -0,0 +1,25 @@
+import { getWindow } from "./3829.js";
+function getPseudoElementBounds(element) {
+    const elementRect = element.getBoundingClientRect();
+    if ('production' !== process.env.NODE_ENV) return elementRect;
+    const win = getWindow(element);
+    const beforeStyles = win.getComputedStyle(element, '::before');
+    const afterStyles = win.getComputedStyle(element, '::after');
+    const hasPseudoElements = 'none' !== beforeStyles.content || 'none' !== afterStyles.content;
+    if (!hasPseudoElements) return elementRect;
+    const beforeWidth = parseFloat(beforeStyles.width) || 0;
+    const beforeHeight = parseFloat(beforeStyles.height) || 0;
+    const afterWidth = parseFloat(afterStyles.width) || 0;
+    const afterHeight = parseFloat(afterStyles.height) || 0;
+    const totalWidth = Math.max(elementRect.width, beforeWidth, afterWidth);
+    const totalHeight = Math.max(elementRect.height, beforeHeight, afterHeight);
+    const widthDiff = totalWidth - elementRect.width;
+    const heightDiff = totalHeight - elementRect.height;
+    return {
+        left: elementRect.left - widthDiff / 2,
+        right: elementRect.right + widthDiff / 2,
+        top: elementRect.top - heightDiff / 2,
+        bottom: elementRect.bottom + heightDiff / 2
+    };
+}
+export { getPseudoElementBounds };

package/dist/7541.js

@@ -0,0 +1,25 @@
+import { SafeReact } from "./6499.js";
+import { useRefWithInit } from "./8272.js";
+const useInsertionEffect = SafeReact.useInsertionEffect;
+const useSafeInsertionEffect = useInsertionEffect && useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : (fn)=>fn();
+function useStableCallback(callback) {
+    const stable = useRefWithInit(createStableCallback).current;
+    stable.next = callback;
+    useSafeInsertionEffect(stable.effect);
+    return stable.trampoline;
+}
+function createStableCallback() {
+    const stable = {
+        next: void 0,
+        callback: assertNotCalled,
+        trampoline: (...args)=>stable.callback?.(...args),
+        effect: ()=>{
+            stable.callback = stable.next;
+        }
+    };
+    return stable;
+}
+function assertNotCalled() {
+    if ('production' !== process.env.NODE_ENV) throw new Error('Base UI: Cannot call an event handler while rendering.');
+}
+export { useStableCallback };

package/dist/7564.js

@@ -0,0 +1,10 @@
+import { esm_formatErrorMessage } from "./8272.js";
+import * as __rspack_external_react from "react";
+const MenubarContext = /*#__PURE__*/ __rspack_external_react.createContext(null);
+if ("production" !== process.env.NODE_ENV) MenubarContext.displayName = "MenubarContext";
+function useMenubarContext(optional) {
+    const context = __rspack_external_react.useContext(MenubarContext);
+    if (null === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenubarContext is missing. Menubar parts must be placed within <Menubar>.' : esm_formatErrorMessage(5));
+    return context;
+}
+export { MenubarContext, useMenubarContext };

package/dist/7642.js

@@ -0,0 +1,20 @@
+import { getComputedStyle, isHTMLElement } from "./3829.js";
+import { round } from "./3319.js";
+function getCssDimensions(element) {
+    const css = getComputedStyle(element);
+    let width = parseFloat(css.width) || 0;
+    let height = parseFloat(css.height) || 0;
+    const hasOffset = isHTMLElement(element);
+    const offsetWidth = hasOffset ? element.offsetWidth : width;
+    const offsetHeight = hasOffset ? element.offsetHeight : height;
+    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+    if (shouldFallback) {
+        width = offsetWidth;
+        height = offsetHeight;
+    }
+    return {
+        width,
+        height
+    };
+}
+export { getCssDimensions };

package/dist/7725.js

@@ -0,0 +1,10 @@
+import { esm_formatErrorMessage } from "./8272.js";
+import * as __rspack_external_react from "react";
+const ToggleGroupContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ToggleGroupContext.displayName = "ToggleGroupContext";
+function useToggleGroupContext(optional = true) {
+    const context = __rspack_external_react.useContext(ToggleGroupContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ToggleGroupContext is missing. ToggleGroup parts must be placed within <ToggleGroup>.' : esm_formatErrorMessage(7));
+    return context;
+}
+export { ToggleGroupContext, useToggleGroupContext };

package/dist/7871.js

@@ -0,0 +1,38 @@
+import { createChangeEventDetails } from "./4768.js";
+import { focusOut } from "./2418.js";
+import { getTabbableBeforeElement, isOutsideEvent, getNextTabbable, getTabbableAfterElement } from "./4388.js";
+import { contains } from "./4549.js";
+import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+function useTriggerFocusGuards(store, triggerElementRef) {
+    const preFocusGuardRef = __rspack_external_react.useRef(null);
+    function handlePreFocusGuardFocus(event) {
+        __rspack_external_react_dom_7136dc57.flushSync(()=>{
+            store.setOpen(false, createChangeEventDetails(focusOut, event.nativeEvent, event.currentTarget));
+        });
+        const previousTabbable = getTabbableBeforeElement(preFocusGuardRef.current);
+        previousTabbable?.focus();
+    }
+    function handleFocusTargetFocus(event) {
+        const positionerElement = store.select('positionerElement');
+        if (positionerElement && isOutsideEvent(event, positionerElement)) store.context.beforeContentFocusGuardRef.current?.focus();
+        else {
+            __rspack_external_react_dom_7136dc57.flushSync(()=>{
+                store.setOpen(false, createChangeEventDetails(focusOut, event.nativeEvent, event.currentTarget));
+            });
+            let nextTabbable = getTabbableAfterElement(store.context.triggerFocusTargetRef.current || triggerElementRef.current);
+            while(null !== nextTabbable && contains(positionerElement, nextTabbable)){
+                const prevTabbable = nextTabbable;
+                nextTabbable = getNextTabbable(nextTabbable);
+                if (nextTabbable === prevTabbable) break;
+            }
+            nextTabbable?.focus();
+        }
+    }
+    return {
+        preFocusGuardRef,
+        handlePreFocusGuardFocus,
+        handleFocusTargetFocus
+    };
+}
+export { useTriggerFocusGuards };

package/dist/8052.js

@@ -0,0 +1,352 @@
+import { useControlled } from "./8527.js";
+import { useAnimationsFinished, stateAttributesMapping_TransitionStatusDataAttributes, useTransitionStatus, useOpenChangeComplete } from "./880.js";
+import { useBaseUiId } from "./6046.js";
+import { useStableCallback } from "./7541.js";
+import { createChangeEventDetails } from "./4768.js";
+import { triggerPress } from "./2418.js";
+import { useMergedRefs, warn, esm_formatErrorMessage } from "./8272.js";
+import { useValueAsRef } from "./4707.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { AnimationFrame } from "./8996.js";
+import { addEventListener } from "./4723.js";
+import { getWindow } from "./3829.js";
+import * as __rspack_external_react from "react";
+function useCollapsibleRoot(parameters) {
+    const { open: openParam, defaultOpen, onOpenChange, disabled } = parameters;
+    const [open, setOpen] = useControlled({
+        controlled: openParam,
+        default: defaultOpen,
+        name: 'Collapsible',
+        state: 'open'
+    });
+    const { mounted, setMounted, transitionStatus } = useTransitionStatus(open, true, true);
+    const defaultPanelId = useBaseUiId();
+    const [panelIdState, setPanelIdState] = __rspack_external_react.useState();
+    const panelId = panelIdState ?? defaultPanelId;
+    const handleTrigger = useStableCallback((event)=>{
+        const nextOpen = !open;
+        const eventDetails = createChangeEventDetails(triggerPress, event.nativeEvent);
+        onOpenChange(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        setOpen(nextOpen);
+    });
+    return __rspack_external_react.useMemo(()=>({
+            disabled,
+            handleTrigger,
+            mounted,
+            open,
+            panelId,
+            setMounted,
+            setOpen,
+            setPanelIdState,
+            transitionStatus
+        }), [
+        disabled,
+        handleTrigger,
+        mounted,
+        open,
+        panelId,
+        setMounted,
+        setOpen,
+        setPanelIdState,
+        transitionStatus
+    ]);
+}
+const CollapsibleRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) CollapsibleRootContext.displayName = "CollapsibleRootContext";
+function useCollapsibleRootContext() {
+    const context = __rspack_external_react.useContext(CollapsibleRootContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: CollapsibleRootContext is missing. Collapsible parts must be placed within <Collapsible.Root>.' : esm_formatErrorMessage(15));
+    return context;
+}
+let CollapsiblePanelDataAttributes_CollapsiblePanelDataAttributes = function(CollapsiblePanelDataAttributes) {
+    CollapsiblePanelDataAttributes["open"] = "data-open";
+    CollapsiblePanelDataAttributes["closed"] = "data-closed";
+    CollapsiblePanelDataAttributes[CollapsiblePanelDataAttributes["startingStyle"] = stateAttributesMapping_TransitionStatusDataAttributes.startingStyle] = "startingStyle";
+    CollapsiblePanelDataAttributes[CollapsiblePanelDataAttributes["endingStyle"] = stateAttributesMapping_TransitionStatusDataAttributes.endingStyle] = "endingStyle";
+    return CollapsiblePanelDataAttributes;
+}({});
+let CollapsibleTriggerDataAttributes_CollapsibleTriggerDataAttributes = /*#__PURE__*/ function(CollapsibleTriggerDataAttributes) {
+    CollapsibleTriggerDataAttributes["panelOpen"] = "data-panel-open";
+    return CollapsibleTriggerDataAttributes;
+}({});
+const PANEL_OPEN_HOOK = {
+    [CollapsiblePanelDataAttributes_CollapsiblePanelDataAttributes.open]: ''
+};
+const PANEL_CLOSED_HOOK = {
+    [CollapsiblePanelDataAttributes_CollapsiblePanelDataAttributes.closed]: ''
+};
+const triggerOpenStateMapping = {
+    open (value) {
+        if (value) return {
+            [CollapsibleTriggerDataAttributes_CollapsibleTriggerDataAttributes.panelOpen]: ''
+        };
+        return null;
+    }
+};
+const collapsibleOpenStateMapping = {
+    open (value) {
+        if (value) return PANEL_OPEN_HOOK;
+        return PANEL_CLOSED_HOOK;
+    }
+};
+const EMPTY_DIMENSIONS = {
+    height: void 0,
+    width: void 0
+};
+function useCollapsiblePanel(parameters) {
+    const { externalRef, hiddenUntilFound, id: idParam, keepMounted, mounted, onOpenChange, open, setMounted, setOpen, transitionStatus } = parameters;
+    const panelRef = __rspack_external_react.useRef(null);
+    const animationTypeRef = __rspack_external_react.useRef(null);
+    const [dimensions, setDimensionsUnwrapped] = __rspack_external_react.useState(EMPTY_DIMENSIONS);
+    const lastMeasuredDimensionsRef = __rspack_external_react.useRef(EMPTY_DIMENSIONS);
+    const shouldSkipNextOpenRef = __rspack_external_react.useRef(false);
+    const shouldPreventMountAnimationRef = __rspack_external_react.useRef(open);
+    const shouldPreventActivityResumeAnimationRef = __rspack_external_react.useRef(false);
+    const [forcePanelIdle, setForcePanelIdle] = __rspack_external_react.useState(false);
+    const pendingTemporaryStyleRestoreRef = __rspack_external_react.useRef(null);
+    const mergedPanelRef = useMergedRefs(externalRef, panelRef);
+    const latestStateRef = useValueAsRef({
+        mounted,
+        open
+    });
+    const runOnceCloseAnimationsFinish = useAnimationsFinished(panelRef, false, false);
+    const hidden = !open && !mounted;
+    const panelTransitionStatus = forcePanelIdle ? 'idle' : transitionStatus;
+    const shouldPreventOpenAnimation = open && (shouldPreventMountAnimationRef.current || shouldPreventActivityResumeAnimationRef.current);
+    const renderedDimensions = !open && mounted && 'css-animation' === animationTypeRef.current && void 0 === dimensions.height && void 0 === dimensions.width ? lastMeasuredDimensionsRef.current : dimensions;
+    const shouldPersistHiddenTransitionStyles = hiddenUntilFound && hidden && 'css-animation' !== animationTypeRef.current;
+    const setDimensions = useStableCallback((nextDimensions, shouldCacheMeasurement = true)=>{
+        if (shouldCacheMeasurement) lastMeasuredDimensionsRef.current = nextDimensions;
+        setDimensionsUnwrapped(nextDimensions);
+    });
+    const restorePendingTemporaryStyle = useStableCallback(()=>{
+        pendingTemporaryStyleRestoreRef.current?.();
+        pendingTemporaryStyleRestoreRef.current = null;
+    });
+    const setPendingTemporaryStyleRestore = useStableCallback((restore)=>{
+        restorePendingTemporaryStyle();
+        pendingTemporaryStyleRestoreRef.current = ()=>{
+            pendingTemporaryStyleRestoreRef.current = null;
+            restore();
+        };
+    });
+    const markActivityResumeAnimationSuppressed = useStableCallback(()=>{
+        if (open && mounted && 'css-animation' === animationTypeRef.current) shouldPreventActivityResumeAnimationRef.current = true;
+    });
+    useIsoLayoutEffect(()=>{
+        if (!forcePanelIdle || 'starting' === transitionStatus) return;
+        setForcePanelIdle(false);
+    }, [
+        forcePanelIdle,
+        transitionStatus
+    ]);
+    __rspack_external_react.useEffect(()=>()=>{
+            markActivityResumeAnimationSuppressed();
+            restorePendingTemporaryStyle();
+        }, [
+        markActivityResumeAnimationSuppressed,
+        restorePendingTemporaryStyle
+    ]);
+    useIsoLayoutEffect(()=>{
+        const panel = panelRef.current;
+        if (!panel) return;
+        if (!open && pendingTemporaryStyleRestoreRef.current) restorePendingTemporaryStyle();
+        const animationType = getAnimationType(panel, shouldPreventOpenAnimation);
+        animationTypeRef.current = animationType;
+        if (open && 'idle' === transitionStatus && shouldPreventMountAnimationRef.current && 'css-animation' === animationType) {
+            lastMeasuredDimensionsRef.current = getDimensions(panel);
+            return;
+        }
+        if (open && 'starting' === transitionStatus) {
+            const skipNextOpen = shouldSkipNextOpenRef.current;
+            shouldSkipNextOpenRef.current = false;
+            if ('none' === animationType) {
+                setDimensions(getDimensions(panel));
+                setForcePanelIdle(true);
+                return;
+            }
+            if ('css-transition' === animationType) {
+                const restoreLayoutStyles = resetLayoutStyles(panel);
+                setDimensions(getDimensions(panel));
+                if (!skipNextOpen) return restoreLayoutStyles;
+                const restoreTransitionDuration = setTemporaryStyle(panel, 'transition-duration', '0s');
+                setPendingTemporaryStyleRestore(restoreTransitionDuration);
+                setForcePanelIdle(true);
+                return restoreLayoutStyles;
+            }
+            if ('css-animation' === animationType) {
+                setDimensions(getDimensions(panel));
+                if (!skipNextOpen) {
+                    const restoreAnimationName = setTemporaryStyle(panel, 'animation-name', 'none');
+                    restoreAnimationName();
+                    return;
+                }
+                const restoreAnimationName = setTemporaryStyle(panel, 'animation-name', 'none');
+                const restoreAnimationDuration = setTemporaryStyle(panel, 'animation-duration', '0s');
+                restoreAnimationName();
+                setPendingTemporaryStyleRestore(restoreAnimationDuration);
+                setForcePanelIdle(true);
+                return;
+            }
+        }
+        if (!open && mounted && ('idle' === transitionStatus || 'starting' === transitionStatus)) {
+            if ('none' === animationType) {
+                setDimensions(EMPTY_DIMENSIONS, false);
+                setMounted(false);
+                return;
+            }
+            if ('css-animation' === animationType) {
+                shouldPreventMountAnimationRef.current = false;
+                shouldPreventActivityResumeAnimationRef.current = false;
+            }
+            setDimensions(getDimensions(panel));
+            return;
+        }
+        if ('ending' !== transitionStatus) return;
+        if ('none' === animationType) return void setMounted(false);
+        const nextDimensions = getDimensions(panel);
+        const hasMeasuredSize = (nextDimensions.height ?? 0) > 0 || (nextDimensions.width ?? 0) > 0;
+        if (!hasMeasuredSize) return void setMounted(false);
+        setDimensions(nextDimensions);
+        if ('css-animation' === animationType) {
+            const restoreAnimationName = setTemporaryStyle(panel, 'animation-name', 'none');
+            restoreAnimationName();
+        }
+    }, [
+        mounted,
+        open,
+        restorePendingTemporaryStyle,
+        setDimensions,
+        setMounted,
+        setPendingTemporaryStyleRestore,
+        shouldPreventOpenAnimation,
+        transitionStatus
+    ]);
+    useOpenChangeComplete({
+        enabled: open && mounted && 'idle' === panelTransitionStatus,
+        open: true,
+        ref: panelRef,
+        onComplete () {
+            if (!open) return;
+            setDimensions(EMPTY_DIMENSIONS, false);
+        }
+    });
+    __rspack_external_react.useEffect(()=>{
+        if (open || !mounted || 'ending' !== panelTransitionStatus) return;
+        const panel = panelRef.current;
+        if (!panel) return;
+        const abortController = new AbortController();
+        let endingStyleFrame = -1;
+        function handleComplete() {
+            if (latestStateRef.current.open) return;
+            setMounted(false);
+            setDimensions(EMPTY_DIMENSIONS, false);
+        }
+        endingStyleFrame = AnimationFrame.request(()=>{
+            if (!abortController.signal.aborted) runOnceCloseAnimationsFinish(handleComplete, abortController.signal);
+        });
+        return ()=>{
+            AnimationFrame.cancel(endingStyleFrame);
+            abortController.abort();
+        };
+    }, [
+        latestStateRef,
+        mounted,
+        open,
+        panelTransitionStatus,
+        runOnceCloseAnimationsFinish,
+        setDimensions,
+        setMounted
+    ]);
+    useIsoLayoutEffect(()=>{
+        const panel = panelRef.current;
+        if (!panel || !hiddenUntilFound || !hidden) return;
+        panel.setAttribute('hidden', 'until-found');
+    }, [
+        hidden,
+        hiddenUntilFound
+    ]);
+    __rspack_external_react.useEffect(function() {
+        const panel = panelRef.current;
+        if (!panel) return;
+        function handleBeforeMatch(event) {
+            shouldSkipNextOpenRef.current = true;
+            setOpen(true);
+            onOpenChange(true, createChangeEventDetails("none", event));
+        }
+        return addEventListener(panel, 'beforematch', handleBeforeMatch);
+    }, [
+        onOpenChange,
+        setOpen
+    ]);
+    const shouldRender = keepMounted || hiddenUntilFound || mounted || open;
+    return {
+        height: renderedDimensions.height,
+        props: {
+            ...shouldPersistHiddenTransitionStyles ? {
+                [CollapsiblePanelDataAttributes_CollapsiblePanelDataAttributes.startingStyle]: ''
+            } : void 0,
+            hidden,
+            id: idParam
+        },
+        ref: mergedPanelRef,
+        shouldPreventOpenAnimation,
+        shouldRender,
+        transitionStatus: panelTransitionStatus,
+        width: renderedDimensions.width
+    };
+}
+function getDimensions(element) {
+    return {
+        height: element.scrollHeight,
+        width: element.scrollWidth
+    };
+}
+function getAnimationType(element, hasSuppressedMountAnimation = false) {
+    const panelStyles = getWindow(element).getComputedStyle(element);
+    const hasAnimation = (panelStyles.animationName.split(',').map((name)=>name.trim()).some((name)=>'' !== name && 'none' !== name) || hasSuppressedMountAnimation) && hasNonZeroDuration(panelStyles.animationDuration);
+    const hasTransition = hasNonZeroDuration(panelStyles.transitionDuration);
+    if (hasAnimation && hasTransition) {
+        if ('production' !== process.env.NODE_ENV) warn('CSS transitions and CSS animations both detected on Collapsible or Accordion panel.', 'Only one of either animation type should be used.');
+        return 'css-transition';
+    }
+    if (hasTransition) return 'css-transition';
+    if (hasAnimation) return 'css-animation';
+    return 'none';
+}
+function hasNonZeroDuration(value) {
+    return value.split(',').map((part)=>part.trim()).some((part)=>'' !== part && Number.parseFloat(part) > 0);
+}
+function setTemporaryStyle(element, property, value) {
+    const previousValue = element.style.getPropertyValue(property);
+    const previousPriority = element.style.getPropertyPriority(property);
+    element.style.setProperty(property, value);
+    return ()=>{
+        if ('' === previousValue) return void element.style.removeProperty(property);
+        element.style.setProperty(property, previousValue, previousPriority);
+    };
+}
+function resetLayoutStyles(element) {
+    const originalLayoutStyles = {
+        'justify-content': element.style.justifyContent,
+        'align-items': element.style.alignItems,
+        'align-content': element.style.alignContent,
+        'justify-items': element.style.justifyItems
+    };
+    Object.keys(originalLayoutStyles).forEach((key)=>{
+        element.style.setProperty(key, 'initial', 'important');
+    });
+    function restoreLayoutStyles() {
+        Object.entries(originalLayoutStyles).forEach(([key, value])=>{
+            if ('' === value) return void element.style.removeProperty(key);
+            element.style.setProperty(key, value);
+        });
+    }
+    const frame = AnimationFrame.request(restoreLayoutStyles);
+    return ()=>{
+        AnimationFrame.cancel(frame);
+        restoreLayoutStyles();
+    };
+}
+export { CollapsibleRootContext, collapsibleOpenStateMapping, triggerOpenStateMapping, useCollapsiblePanel, useCollapsibleRoot, useCollapsibleRootContext };