@wix/site-ui 1.29.0 → 1.31.0

package/dist/8750.js

@@ -0,0 +1,1920 @@
+import { getOppositePlacement, round, getAxisLength as floating_ui_utils_getAxisLength, clamp as floating_ui_utils_clamp, createCoords, rectToClientRect as floating_ui_utils_rectToClientRect, getOppositeAxisPlacements, getSideAxis as floating_ui_utils_getSideAxis, sides as floating_ui_utils_sides, floor, getExpandedPlacements, getAlignmentSides as floating_ui_utils_getAlignmentSides, getAlignment as floating_ui_utils_getAlignment, getOppositeAxis, getAlignmentAxis as floating_ui_utils_getAlignmentAxis, getSide as floating_ui_utils_getSide, evaluate as floating_ui_utils_evaluate, getPaddingObject as floating_ui_utils_getPaddingObject, max as floating_ui_utils_max, min as floating_ui_utils_min } from "./3319.js";
+import { isWebKit, getNodeName, isHTMLElement, getFrameElement, getComputedStyle as floating_ui_utils_dom_getComputedStyle, isOverflowElement, isTopLayer, getContainingBlock, getNodeScroll, isTableElement, isLastTraversableNode, getOverflowAncestors, getDocumentElement, getWindow, isElement, isContainingBlock, getParentNode } from "./3829.js";
+import { useId } from "./6046.js";
+import { useFloatingParentNodeId, useFloatingTree } from "./285.js";
+import { useRefWithInit, useRenderElement, EMPTY_OBJECT } from "./8272.js";
+import { PopupTriggerMap, FloatingRootStore } from "./5992.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { ownerDocument } from "./9829.js";
+import { useStableCallback } from "./7541.js";
+import { useValueAsRef } from "./4707.js";
+import { useDirection } from "./9863.js";
+import { DISABLED_TRANSITIONS_STYLE, popupStateMapping } from "./4388.js";
+import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+    let { reference, floating } = _ref;
+    const sideAxis = floating_ui_utils_getSideAxis(placement);
+    const alignmentAxis = floating_ui_utils_getAlignmentAxis(placement);
+    const alignLength = floating_ui_utils_getAxisLength(alignmentAxis);
+    const side = floating_ui_utils_getSide(placement);
+    const isVertical = 'y' === sideAxis;
+    const commonX = reference.x + reference.width / 2 - floating.width / 2;
+    const commonY = reference.y + reference.height / 2 - floating.height / 2;
+    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+    let coords;
+    switch(side){
+        case 'top':
+            coords = {
+                x: commonX,
+                y: reference.y - floating.height
+            };
+            break;
+        case 'bottom':
+            coords = {
+                x: commonX,
+                y: reference.y + reference.height
+            };
+            break;
+        case 'right':
+            coords = {
+                x: reference.x + reference.width,
+                y: commonY
+            };
+            break;
+        case 'left':
+            coords = {
+                x: reference.x - floating.width,
+                y: commonY
+            };
+            break;
+        default:
+            coords = {
+                x: reference.x,
+                y: reference.y
+            };
+    }
+    switch(floating_ui_utils_getAlignment(placement)){
+        case 'start':
+            coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+            break;
+        case 'end':
+            coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+            break;
+    }
+    return coords;
+}
+async function detectOverflow(state, options) {
+    var _await$platform$isEle;
+    if (void 0 === options) options = {};
+    const { x, y, platform, rects, elements, strategy } = state;
+    const { boundary = 'clippingAncestors', rootBoundary = 'viewport', elementContext = 'floating', altBoundary = false, padding = 0 } = floating_ui_utils_evaluate(options, state);
+    const paddingObject = floating_ui_utils_getPaddingObject(padding);
+    const altContext = 'floating' === elementContext ? 'reference' : 'floating';
+    const element = elements[altBoundary ? altContext : elementContext];
+    const clippingClientRect = floating_ui_utils_rectToClientRect(await platform.getClippingRect({
+        element: (null != (_await$platform$isEle = await (null == platform.isElement ? void 0 : platform.isElement(element))) ? _await$platform$isEle : true) ? element : element.contextElement || await (null == platform.getDocumentElement ? void 0 : platform.getDocumentElement(elements.floating)),
+        boundary,
+        rootBoundary,
+        strategy
+    }));
+    const rect = 'floating' === elementContext ? {
+        x,
+        y,
+        width: rects.floating.width,
+        height: rects.floating.height
+    } : rects.reference;
+    const offsetParent = await (null == platform.getOffsetParent ? void 0 : platform.getOffsetParent(elements.floating));
+    const offsetScale = await (null == platform.isElement ? void 0 : platform.isElement(offsetParent)) ? await (null == platform.getScale ? void 0 : platform.getScale(offsetParent)) || {
+        x: 1,
+        y: 1
+    } : {
+        x: 1,
+        y: 1
+    };
+    const elementClientRect = floating_ui_utils_rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+        elements,
+        rect,
+        offsetParent,
+        strategy
+    }) : rect);
+    return {
+        top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+        bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+        left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+        right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+    };
+}
+const MAX_RESET_COUNT = 50;
+const computePosition = async (reference, floating, config)=>{
+    const { placement = 'bottom', strategy = 'absolute', middleware = [], platform } = config;
+    const platformWithDetectOverflow = platform.detectOverflow ? platform : {
+        ...platform,
+        detectOverflow: detectOverflow
+    };
+    const rtl = await (null == platform.isRTL ? void 0 : platform.isRTL(floating));
+    let rects = await platform.getElementRects({
+        reference,
+        floating,
+        strategy
+    });
+    let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
+    let statefulPlacement = placement;
+    let resetCount = 0;
+    const middlewareData = {};
+    for(let i = 0; i < middleware.length; i++){
+        const currentMiddleware = middleware[i];
+        if (!currentMiddleware) continue;
+        const { name, fn } = currentMiddleware;
+        const { x: nextX, y: nextY, data, reset } = await fn({
+            x,
+            y,
+            initialPlacement: placement,
+            placement: statefulPlacement,
+            strategy,
+            middlewareData,
+            rects,
+            platform: platformWithDetectOverflow,
+            elements: {
+                reference,
+                floating
+            }
+        });
+        x = null != nextX ? nextX : x;
+        y = null != nextY ? nextY : y;
+        middlewareData[name] = {
+            ...middlewareData[name],
+            ...data
+        };
+        if (reset && resetCount < MAX_RESET_COUNT) {
+            resetCount++;
+            if ('object' == typeof reset) {
+                if (reset.placement) statefulPlacement = reset.placement;
+                if (reset.rects) rects = true === reset.rects ? await platform.getElementRects({
+                    reference,
+                    floating,
+                    strategy
+                }) : reset.rects;
+                ({ x, y } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+            }
+            i = -1;
+        }
+    }
+    return {
+        x,
+        y,
+        placement: statefulPlacement,
+        strategy,
+        middlewareData
+    };
+};
+const flip = function(options) {
+    if (void 0 === options) options = {};
+    return {
+        name: 'flip',
+        options,
+        async fn (state) {
+            var _middlewareData$arrow, _middlewareData$flip;
+            const { placement, middlewareData, rects, initialPlacement, platform, elements } = state;
+            const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = 'bestFit', fallbackAxisSideDirection = 'none', flipAlignment = true, ...detectOverflowOptions } = floating_ui_utils_evaluate(options, state);
+            if (null != (_middlewareData$arrow = middlewareData.arrow) && _middlewareData$arrow.alignmentOffset) return {};
+            const side = floating_ui_utils_getSide(placement);
+            const initialSideAxis = floating_ui_utils_getSideAxis(initialPlacement);
+            const isBasePlacement = floating_ui_utils_getSide(initialPlacement) === initialPlacement;
+            const rtl = await (null == platform.isRTL ? void 0 : platform.isRTL(elements.floating));
+            const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [
+                getOppositePlacement(initialPlacement)
+            ] : getExpandedPlacements(initialPlacement));
+            const hasFallbackAxisSideDirection = 'none' !== fallbackAxisSideDirection;
+            if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+            const placements = [
+                initialPlacement,
+                ...fallbackPlacements
+            ];
+            const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+            const overflows = [];
+            let overflowsData = (null == (_middlewareData$flip = middlewareData.flip) ? void 0 : _middlewareData$flip.overflows) || [];
+            if (checkMainAxis) overflows.push(overflow[side]);
+            if (checkCrossAxis) {
+                const sides = floating_ui_utils_getAlignmentSides(placement, rects, rtl);
+                overflows.push(overflow[sides[0]], overflow[sides[1]]);
+            }
+            overflowsData = [
+                ...overflowsData,
+                {
+                    placement,
+                    overflows
+                }
+            ];
+            if (!overflows.every((side)=>side <= 0)) {
+                var _middlewareData$flip2, _overflowsData$filter;
+                const nextIndex = ((null == (_middlewareData$flip2 = middlewareData.flip) ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+                const nextPlacement = placements[nextIndex];
+                if (nextPlacement) {
+                    const ignoreCrossAxisOverflow = 'alignment' === checkCrossAxis ? initialSideAxis !== floating_ui_utils_getSideAxis(nextPlacement) : false;
+                    if (!ignoreCrossAxisOverflow || overflowsData.every((d)=>floating_ui_utils_getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) return {
+                        data: {
+                            index: nextIndex,
+                            overflows: overflowsData
+                        },
+                        reset: {
+                            placement: nextPlacement
+                        }
+                    };
+                }
+                let resetPlacement = null == (_overflowsData$filter = overflowsData.filter((d)=>d.overflows[0] <= 0).sort((a, b)=>a.overflows[1] - b.overflows[1])[0]) ? void 0 : _overflowsData$filter.placement;
+                if (!resetPlacement) switch(fallbackStrategy){
+                    case 'bestFit':
+                        {
+                            var _overflowsData$filter2;
+                            const placement = null == (_overflowsData$filter2 = overflowsData.filter((d)=>{
+                                if (hasFallbackAxisSideDirection) {
+                                    const currentSideAxis = floating_ui_utils_getSideAxis(d.placement);
+                                    return currentSideAxis === initialSideAxis || 'y' === currentSideAxis;
+                                }
+                                return true;
+                            }).map((d)=>[
+                                    d.placement,
+                                    d.overflows.filter((overflow)=>overflow > 0).reduce((acc, overflow)=>acc + overflow, 0)
+                                ]).sort((a, b)=>a[1] - b[1])[0]) ? void 0 : _overflowsData$filter2[0];
+                            if (placement) resetPlacement = placement;
+                            break;
+                        }
+                    case 'initialPlacement':
+                        resetPlacement = initialPlacement;
+                        break;
+                }
+                if (placement !== resetPlacement) return {
+                    reset: {
+                        placement: resetPlacement
+                    }
+                };
+            }
+            return {};
+        }
+    };
+};
+function getSideOffsets(overflow, rect) {
+    return {
+        top: overflow.top - rect.height,
+        right: overflow.right - rect.width,
+        bottom: overflow.bottom - rect.height,
+        left: overflow.left - rect.width
+    };
+}
+function isAnySideFullyClipped(overflow) {
+    return floating_ui_utils_sides.some((side)=>overflow[side] >= 0);
+}
+const hide = function(options) {
+    if (void 0 === options) options = {};
+    return {
+        name: 'hide',
+        options,
+        async fn (state) {
+            const { rects, platform } = state;
+            const { strategy = 'referenceHidden', ...detectOverflowOptions } = floating_ui_utils_evaluate(options, state);
+            switch(strategy){
+                case 'referenceHidden':
+                    {
+                        const overflow = await platform.detectOverflow(state, {
+                            ...detectOverflowOptions,
+                            elementContext: 'reference'
+                        });
+                        const offsets = getSideOffsets(overflow, rects.reference);
+                        return {
+                            data: {
+                                referenceHiddenOffsets: offsets,
+                                referenceHidden: isAnySideFullyClipped(offsets)
+                            }
+                        };
+                    }
+                case 'escaped':
+                    {
+                        const overflow = await platform.detectOverflow(state, {
+                            ...detectOverflowOptions,
+                            altBoundary: true
+                        });
+                        const offsets = getSideOffsets(overflow, rects.floating);
+                        return {
+                            data: {
+                                escapedOffsets: offsets,
+                                escaped: isAnySideFullyClipped(offsets)
+                            }
+                        };
+                    }
+                default:
+                    return {};
+            }
+        }
+    };
+};
+const originSides = /*#__PURE__*/ new Set([
+    'left',
+    'top'
+]);
+async function convertValueToCoords(state, options) {
+    const { placement, platform, elements } = state;
+    const rtl = await (null == platform.isRTL ? void 0 : platform.isRTL(elements.floating));
+    const side = floating_ui_utils_getSide(placement);
+    const alignment = floating_ui_utils_getAlignment(placement);
+    const isVertical = 'y' === floating_ui_utils_getSideAxis(placement);
+    const mainAxisMulti = originSides.has(side) ? -1 : 1;
+    const crossAxisMulti = rtl && isVertical ? -1 : 1;
+    const rawValue = floating_ui_utils_evaluate(options, state);
+    let { mainAxis, crossAxis, alignmentAxis } = 'number' == typeof rawValue ? {
+        mainAxis: rawValue,
+        crossAxis: 0,
+        alignmentAxis: null
+    } : {
+        mainAxis: rawValue.mainAxis || 0,
+        crossAxis: rawValue.crossAxis || 0,
+        alignmentAxis: rawValue.alignmentAxis
+    };
+    if (alignment && 'number' == typeof alignmentAxis) crossAxis = 'end' === alignment ? -1 * alignmentAxis : alignmentAxis;
+    return isVertical ? {
+        x: crossAxis * crossAxisMulti,
+        y: mainAxis * mainAxisMulti
+    } : {
+        x: mainAxis * mainAxisMulti,
+        y: crossAxis * crossAxisMulti
+    };
+}
+const floating_ui_core_offset = function(options) {
+    if (void 0 === options) options = 0;
+    return {
+        name: 'offset',
+        options,
+        async fn (state) {
+            var _middlewareData$offse, _middlewareData$arrow;
+            const { x, y, placement, middlewareData } = state;
+            const diffCoords = await convertValueToCoords(state, options);
+            if (placement === (null == (_middlewareData$offse = middlewareData.offset) ? void 0 : _middlewareData$offse.placement) && null != (_middlewareData$arrow = middlewareData.arrow) && _middlewareData$arrow.alignmentOffset) return {};
+            return {
+                x: x + diffCoords.x,
+                y: y + diffCoords.y,
+                data: {
+                    ...diffCoords,
+                    placement
+                }
+            };
+        }
+    };
+};
+const shift = function(options) {
+    if (void 0 === options) options = {};
+    return {
+        name: 'shift',
+        options,
+        async fn (state) {
+            const { x, y, placement, platform } = state;
+            const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = {
+                fn: (_ref)=>{
+                    let { x, y } = _ref;
+                    return {
+                        x,
+                        y
+                    };
+                }
+            }, ...detectOverflowOptions } = floating_ui_utils_evaluate(options, state);
+            const coords = {
+                x,
+                y
+            };
+            const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+            const crossAxis = floating_ui_utils_getSideAxis(floating_ui_utils_getSide(placement));
+            const mainAxis = getOppositeAxis(crossAxis);
+            let mainAxisCoord = coords[mainAxis];
+            let crossAxisCoord = coords[crossAxis];
+            if (checkMainAxis) {
+                const minSide = 'y' === mainAxis ? 'top' : 'left';
+                const maxSide = 'y' === mainAxis ? 'bottom' : 'right';
+                const min = mainAxisCoord + overflow[minSide];
+                const max = mainAxisCoord - overflow[maxSide];
+                mainAxisCoord = floating_ui_utils_clamp(min, mainAxisCoord, max);
+            }
+            if (checkCrossAxis) {
+                const minSide = 'y' === crossAxis ? 'top' : 'left';
+                const maxSide = 'y' === crossAxis ? 'bottom' : 'right';
+                const min = crossAxisCoord + overflow[minSide];
+                const max = crossAxisCoord - overflow[maxSide];
+                crossAxisCoord = floating_ui_utils_clamp(min, crossAxisCoord, max);
+            }
+            const limitedCoords = limiter.fn({
+                ...state,
+                [mainAxis]: mainAxisCoord,
+                [crossAxis]: crossAxisCoord
+            });
+            return {
+                ...limitedCoords,
+                data: {
+                    x: limitedCoords.x - x,
+                    y: limitedCoords.y - y,
+                    enabled: {
+                        [mainAxis]: checkMainAxis,
+                        [crossAxis]: checkCrossAxis
+                    }
+                }
+            };
+        }
+    };
+};
+const limitShift = function(options) {
+    if (void 0 === options) options = {};
+    return {
+        options,
+        fn (state) {
+            const { x, y, placement, rects, middlewareData } = state;
+            const { offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true } = floating_ui_utils_evaluate(options, state);
+            const coords = {
+                x,
+                y
+            };
+            const crossAxis = floating_ui_utils_getSideAxis(placement);
+            const mainAxis = getOppositeAxis(crossAxis);
+            let mainAxisCoord = coords[mainAxis];
+            let crossAxisCoord = coords[crossAxis];
+            const rawOffset = floating_ui_utils_evaluate(offset, state);
+            const computedOffset = 'number' == typeof rawOffset ? {
+                mainAxis: rawOffset,
+                crossAxis: 0
+            } : {
+                mainAxis: 0,
+                crossAxis: 0,
+                ...rawOffset
+            };
+            if (checkMainAxis) {
+                const len = 'y' === mainAxis ? 'height' : 'width';
+                const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+                const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+                if (mainAxisCoord < limitMin) mainAxisCoord = limitMin;
+                else if (mainAxisCoord > limitMax) mainAxisCoord = limitMax;
+            }
+            if (checkCrossAxis) {
+                var _middlewareData$offse, _middlewareData$offse2;
+                const len = 'y' === mainAxis ? 'width' : 'height';
+                const isOriginSide = originSides.has(floating_ui_utils_getSide(placement));
+                const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? (null == (_middlewareData$offse = middlewareData.offset) ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+                const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : (null == (_middlewareData$offse2 = middlewareData.offset) ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+                if (crossAxisCoord < limitMin) crossAxisCoord = limitMin;
+                else if (crossAxisCoord > limitMax) crossAxisCoord = limitMax;
+            }
+            return {
+                [mainAxis]: mainAxisCoord,
+                [crossAxis]: crossAxisCoord
+            };
+        }
+    };
+};
+const size = function(options) {
+    if (void 0 === options) options = {};
+    return {
+        name: 'size',
+        options,
+        async fn (state) {
+            var _state$middlewareData, _state$middlewareData2;
+            const { placement, rects, platform, elements } = state;
+            const { apply = ()=>{}, ...detectOverflowOptions } = floating_ui_utils_evaluate(options, state);
+            const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+            const side = floating_ui_utils_getSide(placement);
+            const alignment = floating_ui_utils_getAlignment(placement);
+            const isYAxis = 'y' === floating_ui_utils_getSideAxis(placement);
+            const { width, height } = rects.floating;
+            let heightSide;
+            let widthSide;
+            if ('top' === side || 'bottom' === side) {
+                heightSide = side;
+                widthSide = alignment === (await (null == platform.isRTL ? void 0 : platform.isRTL(elements.floating)) ? 'start' : 'end') ? 'left' : 'right';
+            } else {
+                widthSide = side;
+                heightSide = 'end' === alignment ? 'top' : 'bottom';
+            }
+            const maximumClippingHeight = height - overflow.top - overflow.bottom;
+            const maximumClippingWidth = width - overflow.left - overflow.right;
+            const overflowAvailableHeight = floating_ui_utils_min(height - overflow[heightSide], maximumClippingHeight);
+            const overflowAvailableWidth = floating_ui_utils_min(width - overflow[widthSide], maximumClippingWidth);
+            const noShift = !state.middlewareData.shift;
+            let availableHeight = overflowAvailableHeight;
+            let availableWidth = overflowAvailableWidth;
+            if (null != (_state$middlewareData = state.middlewareData.shift) && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
+            if (null != (_state$middlewareData2 = state.middlewareData.shift) && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
+            if (noShift && !alignment) {
+                const xMin = floating_ui_utils_max(overflow.left, 0);
+                const xMax = floating_ui_utils_max(overflow.right, 0);
+                const yMin = floating_ui_utils_max(overflow.top, 0);
+                const yMax = floating_ui_utils_max(overflow.bottom, 0);
+                if (isYAxis) availableWidth = width - 2 * (0 !== xMin || 0 !== xMax ? xMin + xMax : floating_ui_utils_max(overflow.left, overflow.right));
+                else availableHeight = height - 2 * (0 !== yMin || 0 !== yMax ? yMin + yMax : floating_ui_utils_max(overflow.top, overflow.bottom));
+            }
+            await apply({
+                ...state,
+                availableWidth,
+                availableHeight
+            });
+            const nextDimensions = await platform.getDimensions(elements.floating);
+            if (width !== nextDimensions.width || height !== nextDimensions.height) return {
+                reset: {
+                    rects: true
+                }
+            };
+            return {};
+        }
+    };
+};
+function getCssDimensions(element) {
+    const css = floating_ui_utils_dom_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,
+        $: shouldFallback
+    };
+}
+function unwrapElement(element) {
+    return isElement(element) ? element : element.contextElement;
+}
+function getScale(element) {
+    const domElement = unwrapElement(element);
+    if (!isHTMLElement(domElement)) return createCoords(1);
+    const rect = domElement.getBoundingClientRect();
+    const { width, height, $ } = getCssDimensions(domElement);
+    let x = ($ ? round(rect.width) : rect.width) / width;
+    let y = ($ ? round(rect.height) : rect.height) / height;
+    if (!x || !Number.isFinite(x)) x = 1;
+    if (!y || !Number.isFinite(y)) y = 1;
+    return {
+        x,
+        y
+    };
+}
+const noOffsets = /*#__PURE__*/ createCoords(0);
+function getVisualOffsets(element) {
+    const win = getWindow(element);
+    if (!isWebKit() || !win.visualViewport) return noOffsets;
+    return {
+        x: win.visualViewport.offsetLeft,
+        y: win.visualViewport.offsetTop
+    };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+    if (void 0 === isFixed) isFixed = false;
+    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
+    return isFixed;
+}
+function floating_ui_dom_getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+    if (void 0 === includeScale) includeScale = false;
+    if (void 0 === isFixedStrategy) isFixedStrategy = false;
+    const clientRect = element.getBoundingClientRect();
+    const domElement = unwrapElement(element);
+    let scale = createCoords(1);
+    if (includeScale) if (offsetParent) {
+        if (isElement(offsetParent)) scale = getScale(offsetParent);
+    } else scale = getScale(element);
+    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+    let x = (clientRect.left + visualOffsets.x) / scale.x;
+    let y = (clientRect.top + visualOffsets.y) / scale.y;
+    let width = clientRect.width / scale.x;
+    let height = clientRect.height / scale.y;
+    if (domElement) {
+        const win = getWindow(domElement);
+        const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+        let currentWin = win;
+        let currentIFrame = getFrameElement(currentWin);
+        while(currentIFrame && offsetParent && offsetWin !== currentWin){
+            const iframeScale = getScale(currentIFrame);
+            const iframeRect = currentIFrame.getBoundingClientRect();
+            const css = floating_ui_utils_dom_getComputedStyle(currentIFrame);
+            const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+            const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+            x *= iframeScale.x;
+            y *= iframeScale.y;
+            width *= iframeScale.x;
+            height *= iframeScale.y;
+            x += left;
+            y += top;
+            currentWin = getWindow(currentIFrame);
+            currentIFrame = getFrameElement(currentWin);
+        }
+    }
+    return floating_ui_utils_rectToClientRect({
+        width,
+        height,
+        x,
+        y
+    });
+}
+function getWindowScrollBarX(element, rect) {
+    const leftScroll = getNodeScroll(element).scrollLeft;
+    if (!rect) return floating_ui_dom_getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+    return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+    const htmlRect = documentElement.getBoundingClientRect();
+    const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
+    const y = htmlRect.top + scroll.scrollTop;
+    return {
+        x,
+        y
+    };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+    let { elements, rect, offsetParent, strategy } = _ref;
+    const isFixed = 'fixed' === strategy;
+    const documentElement = getDocumentElement(offsetParent);
+    const topLayer = elements ? isTopLayer(elements.floating) : false;
+    if (offsetParent === documentElement || topLayer && isFixed) return rect;
+    let scroll = {
+        scrollLeft: 0,
+        scrollTop: 0
+    };
+    let scale = createCoords(1);
+    const offsets = createCoords(0);
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+        if ('body' !== getNodeName(offsetParent) || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+        if (isOffsetParentAnElement) {
+            const offsetRect = floating_ui_dom_getBoundingClientRect(offsetParent);
+            scale = getScale(offsetParent);
+            offsets.x = offsetRect.x + offsetParent.clientLeft;
+            offsets.y = offsetRect.y + offsetParent.clientTop;
+        }
+    }
+    const htmlOffset = !documentElement || isOffsetParentAnElement || isFixed ? createCoords(0) : getHTMLOffset(documentElement, scroll);
+    return {
+        width: rect.width * scale.x,
+        height: rect.height * scale.y,
+        x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+        y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+    };
+}
+function getClientRects(element) {
+    return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+    const html = getDocumentElement(element);
+    const scroll = getNodeScroll(element);
+    const body = element.ownerDocument.body;
+    const width = floating_ui_utils_max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+    const height = floating_ui_utils_max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -scroll.scrollTop;
+    if ('rtl' === floating_ui_utils_dom_getComputedStyle(body).direction) x += floating_ui_utils_max(html.clientWidth, body.clientWidth) - width;
+    return {
+        width,
+        height,
+        x,
+        y
+    };
+}
+const SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+    const win = getWindow(element);
+    const html = getDocumentElement(element);
+    const visualViewport = win.visualViewport;
+    let width = html.clientWidth;
+    let height = html.clientHeight;
+    let x = 0;
+    let y = 0;
+    if (visualViewport) {
+        width = visualViewport.width;
+        height = visualViewport.height;
+        const visualViewportBased = isWebKit();
+        if (!visualViewportBased || visualViewportBased && 'fixed' === strategy) {
+            x = visualViewport.offsetLeft;
+            y = visualViewport.offsetTop;
+        }
+    }
+    const windowScrollbarX = getWindowScrollBarX(html);
+    if (windowScrollbarX <= 0) {
+        const doc = html.ownerDocument;
+        const body = doc.body;
+        const bodyStyles = getComputedStyle(body);
+        const bodyMarginInline = 'CSS1Compat' === doc.compatMode ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+        const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+        if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
+    } else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+    return {
+        width,
+        height,
+        x,
+        y
+    };
+}
+function getInnerBoundingClientRect(element, strategy) {
+    const clientRect = floating_ui_dom_getBoundingClientRect(element, true, 'fixed' === strategy);
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+    const width = element.clientWidth * scale.x;
+    const height = element.clientHeight * scale.y;
+    const x = left * scale.x;
+    const y = top * scale.y;
+    return {
+        width,
+        height,
+        x,
+        y
+    };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+    let rect;
+    if ('viewport' === clippingAncestor) rect = getViewportRect(element, strategy);
+    else if ('document' === clippingAncestor) rect = getDocumentRect(getDocumentElement(element));
+    else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+    else {
+        const visualOffsets = getVisualOffsets(element);
+        rect = {
+            x: clippingAncestor.x - visualOffsets.x,
+            y: clippingAncestor.y - visualOffsets.y,
+            width: clippingAncestor.width,
+            height: clippingAncestor.height
+        };
+    }
+    return floating_ui_utils_rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+    const parentNode = getParentNode(element);
+    if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
+    return 'fixed' === floating_ui_utils_dom_getComputedStyle(parentNode).position || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+    const cachedResult = cache.get(element);
+    if (cachedResult) return cachedResult;
+    let result = getOverflowAncestors(element, [], false).filter((el)=>isElement(el) && 'body' !== getNodeName(el));
+    let currentContainingBlockComputedStyle = null;
+    const elementIsFixed = 'fixed' === floating_ui_utils_dom_getComputedStyle(element).position;
+    let currentNode = elementIsFixed ? getParentNode(element) : element;
+    while(isElement(currentNode) && !isLastTraversableNode(currentNode)){
+        const computedStyle = floating_ui_utils_dom_getComputedStyle(currentNode);
+        const currentNodeIsContaining = isContainingBlock(currentNode);
+        if (!currentNodeIsContaining && 'fixed' === computedStyle.position) currentContainingBlockComputedStyle = null;
+        const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && 'static' === computedStyle.position && !!currentContainingBlockComputedStyle && ('absolute' === currentContainingBlockComputedStyle.position || 'fixed' === currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+        if (shouldDropCurrentNode) result = result.filter((ancestor)=>ancestor !== currentNode);
+        else currentContainingBlockComputedStyle = computedStyle;
+        currentNode = getParentNode(currentNode);
+    }
+    cache.set(element, result);
+    return result;
+}
+function getClippingRect(_ref) {
+    let { element, boundary, rootBoundary, strategy } = _ref;
+    const elementClippingAncestors = 'clippingAncestors' === boundary ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+    const clippingAncestors = [
+        ...elementClippingAncestors,
+        rootBoundary
+    ];
+    const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+    let top = firstRect.top;
+    let right = firstRect.right;
+    let bottom = firstRect.bottom;
+    let left = firstRect.left;
+    for(let i = 1; i < clippingAncestors.length; i++){
+        const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
+        top = floating_ui_utils_max(rect.top, top);
+        right = floating_ui_utils_min(rect.right, right);
+        bottom = floating_ui_utils_min(rect.bottom, bottom);
+        left = floating_ui_utils_max(rect.left, left);
+    }
+    return {
+        width: right - left,
+        height: bottom - top,
+        x: left,
+        y: top
+    };
+}
+function getDimensions(element) {
+    const { width, height } = getCssDimensions(element);
+    return {
+        width,
+        height
+    };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+    const isFixed = 'fixed' === strategy;
+    const rect = floating_ui_dom_getBoundingClientRect(element, true, isFixed, offsetParent);
+    let scroll = {
+        scrollLeft: 0,
+        scrollTop: 0
+    };
+    const offsets = createCoords(0);
+    function setLeftRTLScrollbarOffset() {
+        offsets.x = getWindowScrollBarX(documentElement);
+    }
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+        if ('body' !== getNodeName(offsetParent) || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+        if (isOffsetParentAnElement) {
+            const offsetRect = floating_ui_dom_getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+            offsets.x = offsetRect.x + offsetParent.clientLeft;
+            offsets.y = offsetRect.y + offsetParent.clientTop;
+        } else if (documentElement) setLeftRTLScrollbarOffset();
+    }
+    if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
+    const htmlOffset = !documentElement || isOffsetParentAnElement || isFixed ? createCoords(0) : getHTMLOffset(documentElement, scroll);
+    const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+    const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+    return {
+        x,
+        y,
+        width: rect.width,
+        height: rect.height
+    };
+}
+function isStaticPositioned(element) {
+    return 'static' === floating_ui_utils_dom_getComputedStyle(element).position;
+}
+function getTrueOffsetParent(element, polyfill) {
+    if (!isHTMLElement(element) || 'fixed' === floating_ui_utils_dom_getComputedStyle(element).position) return null;
+    if (polyfill) return polyfill(element);
+    let rawOffsetParent = element.offsetParent;
+    if (getDocumentElement(element) === rawOffsetParent) rawOffsetParent = rawOffsetParent.ownerDocument.body;
+    return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+    const win = getWindow(element);
+    if (isTopLayer(element)) return win;
+    if (!isHTMLElement(element)) {
+        let svgOffsetParent = getParentNode(element);
+        while(svgOffsetParent && !isLastTraversableNode(svgOffsetParent)){
+            if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) return svgOffsetParent;
+            svgOffsetParent = getParentNode(svgOffsetParent);
+        }
+        return win;
+    }
+    let offsetParent = getTrueOffsetParent(element, polyfill);
+    while(offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent))offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+    if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) return win;
+    return offsetParent || getContainingBlock(element) || win;
+}
+const getElementRects = async function(data) {
+    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+    const getDimensionsFn = this.getDimensions;
+    const floatingDimensions = await getDimensionsFn(data.floating);
+    return {
+        reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+        floating: {
+            x: 0,
+            y: 0,
+            width: floatingDimensions.width,
+            height: floatingDimensions.height
+        }
+    };
+};
+function isRTL(element) {
+    return 'rtl' === floating_ui_utils_dom_getComputedStyle(element).direction;
+}
+const floating_ui_dom_platform = {
+    convertOffsetParentRelativeRectToViewportRelativeRect: convertOffsetParentRelativeRectToViewportRelativeRect,
+    getDocumentElement: getDocumentElement,
+    getClippingRect: getClippingRect,
+    getOffsetParent: getOffsetParent,
+    getElementRects: getElementRects,
+    getClientRects: getClientRects,
+    getDimensions: getDimensions,
+    getScale: getScale,
+    isElement: isElement,
+    isRTL: isRTL
+};
+function rectsAreEqual(a, b) {
+    return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function observeMove(element, onMove) {
+    let io = null;
+    let timeoutId;
+    const root = getDocumentElement(element);
+    function cleanup() {
+        var _io;
+        clearTimeout(timeoutId);
+        null == (_io = io) || _io.disconnect();
+        io = null;
+    }
+    function refresh(skip, threshold) {
+        if (void 0 === skip) skip = false;
+        if (void 0 === threshold) threshold = 1;
+        cleanup();
+        const elementRectForRootMargin = element.getBoundingClientRect();
+        const { left, top, width, height } = elementRectForRootMargin;
+        if (!skip) onMove();
+        if (!width || !height) return;
+        const insetTop = floor(top);
+        const insetRight = floor(root.clientWidth - (left + width));
+        const insetBottom = floor(root.clientHeight - (top + height));
+        const insetLeft = floor(left);
+        const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+        const options = {
+            rootMargin,
+            threshold: floating_ui_utils_max(0, floating_ui_utils_min(1, threshold)) || 1
+        };
+        let isFirstUpdate = true;
+        function handleObserve(entries) {
+            const ratio = entries[0].intersectionRatio;
+            if (ratio !== threshold) {
+                if (!isFirstUpdate) return refresh();
+                if (ratio) refresh(false, ratio);
+                else timeoutId = setTimeout(()=>{
+                    refresh(false, 1e-7);
+                }, 1000);
+            }
+            if (1 === ratio && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
+            isFirstUpdate = false;
+        }
+        try {
+            io = new IntersectionObserver(handleObserve, {
+                ...options,
+                root: root.ownerDocument
+            });
+        } catch (_e) {
+            io = new IntersectionObserver(handleObserve, options);
+        }
+        io.observe(element);
+    }
+    refresh(true);
+    return cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+    if (void 0 === options) options = {};
+    const { ancestorScroll = true, ancestorResize = true, elementResize = 'function' == typeof ResizeObserver, layoutShift = 'function' == typeof IntersectionObserver, animationFrame = false } = options;
+    const referenceEl = unwrapElement(reference);
+    const ancestors = ancestorScroll || ancestorResize ? [
+        ...referenceEl ? getOverflowAncestors(referenceEl) : [],
+        ...floating ? getOverflowAncestors(floating) : []
+    ] : [];
+    ancestors.forEach((ancestor)=>{
+        ancestorScroll && ancestor.addEventListener('scroll', update, {
+            passive: true
+        });
+        ancestorResize && ancestor.addEventListener('resize', update);
+    });
+    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+    let reobserveFrame = -1;
+    let resizeObserver = null;
+    if (elementResize) {
+        resizeObserver = new ResizeObserver((_ref)=>{
+            let [firstEntry] = _ref;
+            if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
+                resizeObserver.unobserve(floating);
+                cancelAnimationFrame(reobserveFrame);
+                reobserveFrame = requestAnimationFrame(()=>{
+                    var _resizeObserver;
+                    null == (_resizeObserver = resizeObserver) || _resizeObserver.observe(floating);
+                });
+            }
+            update();
+        });
+        if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
+        if (floating) resizeObserver.observe(floating);
+    }
+    let frameId;
+    let prevRefRect = animationFrame ? floating_ui_dom_getBoundingClientRect(reference) : null;
+    if (animationFrame) frameLoop();
+    function frameLoop() {
+        const nextRefRect = floating_ui_dom_getBoundingClientRect(reference);
+        if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) update();
+        prevRefRect = nextRefRect;
+        frameId = requestAnimationFrame(frameLoop);
+    }
+    update();
+    return ()=>{
+        var _resizeObserver2;
+        ancestors.forEach((ancestor)=>{
+            ancestorScroll && ancestor.removeEventListener('scroll', update);
+            ancestorResize && ancestor.removeEventListener('resize', update);
+        });
+        null == cleanupIo || cleanupIo();
+        null == (_resizeObserver2 = resizeObserver) || _resizeObserver2.disconnect();
+        resizeObserver = null;
+        if (animationFrame) cancelAnimationFrame(frameId);
+    };
+}
+const floating_ui_dom_offset = floating_ui_core_offset;
+const floating_ui_dom_shift = shift;
+const floating_ui_dom_flip = flip;
+const floating_ui_dom_size = size;
+const floating_ui_dom_hide = hide;
+const floating_ui_dom_limitShift = limitShift;
+const floating_ui_dom_computePosition = (reference, floating, options)=>{
+    const cache = new Map();
+    const mergedOptions = {
+        platform: floating_ui_dom_platform,
+        ...options
+    };
+    const platformWithCache = {
+        ...mergedOptions.platform,
+        _c: cache
+    };
+    return computePosition(reference, floating, {
+        ...mergedOptions,
+        platform: platformWithCache
+    });
+};
+var isClient = "u" > typeof document;
+var floating_ui_react_dom_noop = function() {};
+var index = isClient ? __rspack_external_react.useLayoutEffect : floating_ui_react_dom_noop;
+function deepEqual(a, b) {
+    if (a === b) return true;
+    if (typeof a !== typeof b) return false;
+    if ('function' == typeof a && a.toString() === b.toString()) return true;
+    let length;
+    let i;
+    let keys;
+    if (a && b && 'object' == typeof a) {
+        if (Array.isArray(a)) {
+            length = a.length;
+            if (length !== b.length) return false;
+            for(i = length; 0 !== i--;)if (!deepEqual(a[i], b[i])) return false;
+            return true;
+        }
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+        for(i = length; 0 !== i--;)if (!({}).hasOwnProperty.call(b, keys[i])) return false;
+        for(i = length; 0 !== i--;){
+            const key = keys[i];
+            if ('_owner' !== key || !a.$$typeof) {
+                if (!deepEqual(a[key], b[key])) return false;
+            }
+        }
+        return true;
+    }
+    return a !== a && b !== b;
+}
+function getDPR(element) {
+    if ("u" < typeof window) return 1;
+    const win = element.ownerDocument.defaultView || window;
+    return win.devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+    const dpr = getDPR(element);
+    return Math.round(value * dpr) / dpr;
+}
+function useLatestRef(value) {
+    const ref = __rspack_external_react.useRef(value);
+    index(()=>{
+        ref.current = value;
+    });
+    return ref;
+}
+function useFloating(options) {
+    if (void 0 === options) options = {};
+    const { placement = 'bottom', strategy = 'absolute', middleware = [], platform, elements: { reference: externalReference, floating: externalFloating } = {}, transform = true, whileElementsMounted, open } = options;
+    const [data, setData] = __rspack_external_react.useState({
+        x: 0,
+        y: 0,
+        strategy,
+        placement,
+        middlewareData: {},
+        isPositioned: false
+    });
+    const [latestMiddleware, setLatestMiddleware] = __rspack_external_react.useState(middleware);
+    if (!deepEqual(latestMiddleware, middleware)) setLatestMiddleware(middleware);
+    const [_reference, _setReference] = __rspack_external_react.useState(null);
+    const [_floating, _setFloating] = __rspack_external_react.useState(null);
+    const setReference = __rspack_external_react.useCallback((node)=>{
+        if (node !== referenceRef.current) {
+            referenceRef.current = node;
+            _setReference(node);
+        }
+    }, []);
+    const setFloating = __rspack_external_react.useCallback((node)=>{
+        if (node !== floatingRef.current) {
+            floatingRef.current = node;
+            _setFloating(node);
+        }
+    }, []);
+    const referenceEl = externalReference || _reference;
+    const floatingEl = externalFloating || _floating;
+    const referenceRef = __rspack_external_react.useRef(null);
+    const floatingRef = __rspack_external_react.useRef(null);
+    const dataRef = __rspack_external_react.useRef(data);
+    const hasWhileElementsMounted = null != whileElementsMounted;
+    const whileElementsMountedRef = useLatestRef(whileElementsMounted);
+    const platformRef = useLatestRef(platform);
+    const openRef = useLatestRef(open);
+    const update = __rspack_external_react.useCallback(()=>{
+        if (!referenceRef.current || !floatingRef.current) return;
+        const config = {
+            placement,
+            strategy,
+            middleware: latestMiddleware
+        };
+        if (platformRef.current) config.platform = platformRef.current;
+        floating_ui_dom_computePosition(referenceRef.current, floatingRef.current, config).then((data)=>{
+            const fullData = {
+                ...data,
+                isPositioned: false !== openRef.current
+            };
+            if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+                dataRef.current = fullData;
+                __rspack_external_react_dom_7136dc57.flushSync(()=>{
+                    setData(fullData);
+                });
+            }
+        });
+    }, [
+        latestMiddleware,
+        placement,
+        strategy,
+        platformRef,
+        openRef
+    ]);
+    index(()=>{
+        if (false === open && dataRef.current.isPositioned) {
+            dataRef.current.isPositioned = false;
+            setData((data)=>({
+                    ...data,
+                    isPositioned: false
+                }));
+        }
+    }, [
+        open
+    ]);
+    const isMountedRef = __rspack_external_react.useRef(false);
+    index(()=>{
+        isMountedRef.current = true;
+        return ()=>{
+            isMountedRef.current = false;
+        };
+    }, []);
+    index(()=>{
+        if (referenceEl) referenceRef.current = referenceEl;
+        if (floatingEl) floatingRef.current = floatingEl;
+        if (referenceEl && floatingEl) {
+            if (whileElementsMountedRef.current) return whileElementsMountedRef.current(referenceEl, floatingEl, update);
+            update();
+        }
+    }, [
+        referenceEl,
+        floatingEl,
+        update,
+        whileElementsMountedRef,
+        hasWhileElementsMounted
+    ]);
+    const refs = __rspack_external_react.useMemo(()=>({
+            reference: referenceRef,
+            floating: floatingRef,
+            setReference,
+            setFloating
+        }), [
+        setReference,
+        setFloating
+    ]);
+    const elements = __rspack_external_react.useMemo(()=>({
+            reference: referenceEl,
+            floating: floatingEl
+        }), [
+        referenceEl,
+        floatingEl
+    ]);
+    const floatingStyles = __rspack_external_react.useMemo(()=>{
+        const initialStyles = {
+            position: strategy,
+            left: 0,
+            top: 0
+        };
+        if (!elements.floating) return initialStyles;
+        const x = roundByDPR(elements.floating, data.x);
+        const y = roundByDPR(elements.floating, data.y);
+        if (transform) return {
+            ...initialStyles,
+            transform: "translate(" + x + "px, " + y + "px)",
+            ...getDPR(elements.floating) >= 1.5 && {
+                willChange: 'transform'
+            }
+        };
+        return {
+            position: strategy,
+            left: x,
+            top: y
+        };
+    }, [
+        strategy,
+        transform,
+        elements.floating,
+        data.x,
+        data.y
+    ]);
+    return __rspack_external_react.useMemo(()=>({
+            ...data,
+            update,
+            refs,
+            elements,
+            floatingStyles
+        }), [
+        data,
+        update,
+        refs,
+        elements,
+        floatingStyles
+    ]);
+}
+const floating_ui_react_dom_offset = (options, deps)=>{
+    const result = floating_ui_dom_offset(options);
+    return {
+        name: result.name,
+        fn: result.fn,
+        options: [
+            options,
+            deps
+        ]
+    };
+};
+const floating_ui_react_dom_shift = (options, deps)=>{
+    const result = floating_ui_dom_shift(options);
+    return {
+        name: result.name,
+        fn: result.fn,
+        options: [
+            options,
+            deps
+        ]
+    };
+};
+const floating_ui_react_dom_limitShift = (options, deps)=>{
+    const result = floating_ui_dom_limitShift(options);
+    return {
+        fn: result.fn,
+        options: [
+            options,
+            deps
+        ]
+    };
+};
+const floating_ui_react_dom_flip = (options, deps)=>{
+    const result = floating_ui_dom_flip(options);
+    return {
+        name: result.name,
+        fn: result.fn,
+        options: [
+            options,
+            deps
+        ]
+    };
+};
+const floating_ui_react_dom_size = (options, deps)=>{
+    const result = floating_ui_dom_size(options);
+    return {
+        name: result.name,
+        fn: result.fn,
+        options: [
+            options,
+            deps
+        ]
+    };
+};
+const floating_ui_react_dom_hide = (options, deps)=>{
+    const result = floating_ui_dom_hide(options);
+    return {
+        name: result.name,
+        fn: result.fn,
+        options: [
+            options,
+            deps
+        ]
+    };
+};
+function useFloatingRootContext(options) {
+    const { open = false, onOpenChange, elements = {} } = options;
+    const floatingId = useId();
+    const nested = null != useFloatingParentNodeId();
+    if ('production' !== process.env.NODE_ENV) {
+        const optionDomReference = elements.reference;
+        if (optionDomReference && !isElement(optionDomReference)) console.error('Cannot pass a virtual element to the `elements.reference` option,', 'as it must be a real DOM element. Use `context.setPositionReference()`', 'instead.');
+    }
+    const store = useRefWithInit(()=>new FloatingRootStore({
+            open,
+            transitionStatus: void 0,
+            onOpenChange,
+            referenceElement: elements.reference ?? null,
+            floatingElement: elements.floating ?? null,
+            triggerElements: new PopupTriggerMap(),
+            floatingId,
+            syncOnly: false,
+            nested
+        })).current;
+    useIsoLayoutEffect(()=>{
+        const valuesToSync = {
+            open,
+            floatingId
+        };
+        if (void 0 !== elements.reference) {
+            valuesToSync.referenceElement = elements.reference;
+            valuesToSync.domReferenceElement = isElement(elements.reference) ? elements.reference : null;
+        }
+        if (void 0 !== elements.floating) valuesToSync.floatingElement = elements.floating;
+        store.update(valuesToSync);
+    }, [
+        open,
+        floatingId,
+        elements.reference,
+        elements.floating,
+        store
+    ]);
+    store.context.onOpenChange = onOpenChange;
+    store.context.nested = nested;
+    return store;
+}
+function useFloating_useFloating(options = {}) {
+    const { nodeId, externalTree } = options;
+    const internalStore = useFloatingRootContext(options);
+    const store = options.rootContext || internalStore;
+    const referenceElement = store.useState('referenceElement');
+    const floatingElement = store.useState('floatingElement');
+    const domReferenceElement = store.useState('domReferenceElement');
+    const open = store.useState('open');
+    const floatingId = store.useState('floatingId');
+    const [positionReference, setPositionReferenceRaw] = __rspack_external_react.useState(null);
+    const [localDomReference, setLocalDomReference] = __rspack_external_react.useState(void 0);
+    const [localFloatingElement, setLocalFloatingElement] = __rspack_external_react.useState(void 0);
+    const domReferenceRef = __rspack_external_react.useRef(null);
+    const tree = useFloatingTree(externalTree);
+    const storeElements = __rspack_external_react.useMemo(()=>({
+            reference: referenceElement,
+            floating: floatingElement,
+            domReference: domReferenceElement
+        }), [
+        referenceElement,
+        floatingElement,
+        domReferenceElement
+    ]);
+    const position = useFloating({
+        ...options,
+        elements: {
+            ...storeElements,
+            ...positionReference && {
+                reference: positionReference
+            }
+        }
+    });
+    const localDomReferenceElement = isElement(localDomReference) ? localDomReference : null;
+    const syncedFloatingElement = void 0 === localFloatingElement ? store.state.floatingElement : localFloatingElement;
+    store.useSyncedValue('referenceElement', localDomReference ?? null);
+    store.useSyncedValue('domReferenceElement', void 0 === localDomReference ? domReferenceElement : localDomReferenceElement);
+    store.useSyncedValue('floatingElement', syncedFloatingElement);
+    const setPositionReference = __rspack_external_react.useCallback((node)=>{
+        const computedPositionReference = isElement(node) ? {
+            getBoundingClientRect: ()=>node.getBoundingClientRect(),
+            getClientRects: ()=>node.getClientRects(),
+            contextElement: node
+        } : node;
+        setPositionReferenceRaw(computedPositionReference);
+        position.refs.setReference(computedPositionReference);
+    }, [
+        position.refs
+    ]);
+    const setReference = __rspack_external_react.useCallback((node)=>{
+        if (isElement(node) || null === node) {
+            domReferenceRef.current = node;
+            setLocalDomReference(node);
+        }
+        if (isElement(position.refs.reference.current) || null === position.refs.reference.current || null !== node && !isElement(node)) position.refs.setReference(node);
+    }, [
+        position.refs,
+        setLocalDomReference
+    ]);
+    const setFloating = __rspack_external_react.useCallback((node)=>{
+        setLocalFloatingElement(node);
+        position.refs.setFloating(node);
+    }, [
+        position.refs
+    ]);
+    const refs = __rspack_external_react.useMemo(()=>({
+            ...position.refs,
+            setReference,
+            setFloating,
+            setPositionReference,
+            domReference: domReferenceRef
+        }), [
+        position.refs,
+        setReference,
+        setFloating,
+        setPositionReference
+    ]);
+    const elements = __rspack_external_react.useMemo(()=>({
+            ...position.elements,
+            domReference: domReferenceElement
+        }), [
+        position.elements,
+        domReferenceElement
+    ]);
+    const context = __rspack_external_react.useMemo(()=>({
+            ...position,
+            dataRef: store.context.dataRef,
+            open,
+            onOpenChange: store.setOpen,
+            events: store.context.events,
+            floatingId,
+            refs,
+            elements,
+            nodeId,
+            rootStore: store
+        }), [
+        position,
+        refs,
+        elements,
+        nodeId,
+        store,
+        open,
+        floatingId
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (domReferenceElement) domReferenceRef.current = domReferenceElement;
+    }, [
+        domReferenceElement
+    ]);
+    useIsoLayoutEffect(()=>{
+        store.context.dataRef.current.floatingContext = context;
+        const node = tree?.nodesRef.current.find((n)=>n.id === nodeId);
+        if (node) node.context = context;
+    });
+    return __rspack_external_react.useMemo(()=>({
+            ...position,
+            context,
+            refs,
+            elements,
+            rootStore: store
+        }), [
+        position,
+        refs,
+        elements,
+        context,
+        store
+    ]);
+}
+const baseArrow = (options)=>({
+        name: 'arrow',
+        options,
+        async fn (state) {
+            const { x, y, placement, rects, platform, elements, middlewareData } = state;
+            const { element, padding = 0, offsetParent = 'real' } = floating_ui_utils_evaluate(options, state) || {};
+            if (null == element) return {};
+            const paddingObject = floating_ui_utils_getPaddingObject(padding);
+            const coords = {
+                x,
+                y
+            };
+            const axis = floating_ui_utils_getAlignmentAxis(placement);
+            const length = floating_ui_utils_getAxisLength(axis);
+            const arrowDimensions = await platform.getDimensions(element);
+            const isYAxis = 'y' === axis;
+            const minProp = isYAxis ? 'top' : 'left';
+            const maxProp = isYAxis ? 'bottom' : 'right';
+            const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
+            const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+            const startDiff = coords[axis] - rects.reference[axis];
+            const arrowOffsetParent = 'real' === offsetParent ? await platform.getOffsetParent?.(element) : elements.floating;
+            let clientSize = elements.floating[clientProp] || rects.floating[length];
+            if (!clientSize || !await platform.isElement?.(arrowOffsetParent)) clientSize = elements.floating[clientProp] || rects.floating[length];
+            const centerToReference = endDiff / 2 - startDiff / 2;
+            const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+            const minPadding = Math.min(paddingObject[minProp], largestPossiblePadding);
+            const maxPadding = Math.min(paddingObject[maxProp], largestPossiblePadding);
+            const min = minPadding;
+            const max = clientSize - arrowDimensions[length] - maxPadding;
+            const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+            const offset = floating_ui_utils_clamp(min, center, max);
+            const shouldAddOffset = !middlewareData.arrow && null != floating_ui_utils_getAlignment(placement) && center !== offset && rects.reference[length] / 2 - (center < min ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+            const alignmentOffset = shouldAddOffset ? center < min ? center - min : center - max : 0;
+            return {
+                [axis]: coords[axis] + alignmentOffset,
+                data: {
+                    [axis]: offset,
+                    centerOffset: center - offset - alignmentOffset,
+                    ...shouldAddOffset && {
+                        alignmentOffset
+                    }
+                },
+                reset: shouldAddOffset
+            };
+        }
+    });
+const arrow_arrow = (options, deps)=>({
+        ...baseArrow(options),
+        options: [
+            options,
+            deps
+        ]
+    });
+const hideMiddleware_hide = {
+    name: 'hide',
+    async fn (state) {
+        const { width, height, x, y } = state.rects.reference;
+        const anchorHidden = 0 === width && 0 === height && 0 === x && 0 === y;
+        const nativeHideResult = await floating_ui_react_dom_hide().fn(state);
+        return {
+            data: {
+                referenceHidden: nativeHideResult.data?.referenceHidden || anchorHidden
+            }
+        };
+    }
+};
+const DEFAULT_SIDES = {
+    sideX: 'left',
+    sideY: 'top'
+};
+const adaptiveOriginMiddleware_adaptiveOrigin = {
+    name: 'adaptiveOrigin',
+    async fn (state) {
+        const { x: rawX, y: rawY, rects: { floating: floatRect }, elements: { floating }, platform, strategy, placement } = state;
+        const win = getWindow(floating);
+        const styles = win.getComputedStyle(floating);
+        const hasTransition = '0s' !== styles.transitionDuration && '' !== styles.transitionDuration;
+        if (!hasTransition) return {
+            x: rawX,
+            y: rawY,
+            data: DEFAULT_SIDES
+        };
+        const offsetParent = await platform.getOffsetParent?.(floating);
+        let offsetDimensions = {
+            width: 0,
+            height: 0
+        };
+        if ('fixed' === strategy && win?.visualViewport) offsetDimensions = {
+            width: win.visualViewport.width,
+            height: win.visualViewport.height
+        };
+        else if (offsetParent === win) {
+            const doc = ownerDocument(floating);
+            offsetDimensions = {
+                width: doc.documentElement.clientWidth,
+                height: doc.documentElement.clientHeight
+            };
+        } else if (await platform.isElement?.(offsetParent)) offsetDimensions = await platform.getDimensions(offsetParent);
+        const currentSide = floating_ui_utils_getSide(placement);
+        let x = rawX;
+        let y = rawY;
+        if ('left' === currentSide) x = offsetDimensions.width - (rawX + floatRect.width);
+        if ('top' === currentSide) y = offsetDimensions.height - (rawY + floatRect.height);
+        const sideX = 'left' === currentSide ? 'right' : DEFAULT_SIDES.sideX;
+        const sideY = 'top' === currentSide ? 'bottom' : DEFAULT_SIDES.sideY;
+        return {
+            x,
+            y,
+            data: {
+                sideX,
+                sideY
+            }
+        };
+    }
+};
+function getLogicalSide(sideParam, renderedSide, isRtl) {
+    const isLogicalSideParam = 'inline-start' === sideParam || 'inline-end' === sideParam;
+    const logicalRight = isRtl ? 'inline-start' : 'inline-end';
+    const logicalLeft = isRtl ? 'inline-end' : 'inline-start';
+    return ({
+        top: 'top',
+        right: isLogicalSideParam ? logicalRight : 'right',
+        bottom: 'bottom',
+        left: isLogicalSideParam ? logicalLeft : 'left'
+    })[renderedSide];
+}
+function getOffsetData(state, sideParam, isRtl) {
+    const { rects, placement } = state;
+    const data = {
+        side: getLogicalSide(sideParam, floating_ui_utils_getSide(placement), isRtl),
+        align: floating_ui_utils_getAlignment(placement) || 'center',
+        anchor: {
+            width: rects.reference.width,
+            height: rects.reference.height
+        },
+        positioner: {
+            width: rects.floating.width,
+            height: rects.floating.height
+        }
+    };
+    return data;
+}
+function useAnchorPositioning(params) {
+    const { anchor, positionMethod = 'absolute', side: sideParam = 'bottom', sideOffset = 0, align = 'center', alignOffset = 0, collisionBoundary, collisionPadding: collisionPaddingParam = 5, sticky = false, arrowPadding = 5, disableAnchorTracking = false, inline: inlineMiddleware, keepMounted = false, floatingRootContext, mounted, collisionAvoidance, shiftCrossAxis = false, nodeId, adaptiveOrigin, lazyFlip = false, externalTree } = params;
+    const [mountSide, setMountSide] = __rspack_external_react.useState(null);
+    if (!mounted && null !== mountSide) setMountSide(null);
+    const collisionAvoidanceSide = collisionAvoidance.side || 'flip';
+    const collisionAvoidanceAlign = collisionAvoidance.align || 'flip';
+    const collisionAvoidanceFallbackAxisSide = collisionAvoidance.fallbackAxisSide || 'end';
+    const anchorFn = 'function' == typeof anchor ? anchor : void 0;
+    const anchorFnCallback = useStableCallback(anchorFn);
+    const anchorDep = anchorFn ? anchorFnCallback : anchor;
+    const anchorValueRef = useValueAsRef(anchor);
+    const mountedRef = useValueAsRef(mounted);
+    const direction = useDirection();
+    const isRtl = 'rtl' === direction;
+    const side = mountSide || ({
+        top: 'top',
+        right: 'right',
+        bottom: 'bottom',
+        left: 'left',
+        'inline-end': isRtl ? 'left' : 'right',
+        'inline-start': isRtl ? 'right' : 'left'
+    })[sideParam];
+    const placement = 'center' === align ? side : `${side}-${align}`;
+    let collisionPadding = collisionPaddingParam;
+    const bias = 1;
+    const biasTop = 'bottom' === sideParam ? bias : 0;
+    const biasBottom = 'top' === sideParam ? bias : 0;
+    const biasLeft = 'right' === sideParam ? bias : 0;
+    const biasRight = 'left' === sideParam ? bias : 0;
+    if ('number' == typeof collisionPadding) collisionPadding = {
+        top: collisionPadding + biasTop,
+        right: collisionPadding + biasRight,
+        bottom: collisionPadding + biasBottom,
+        left: collisionPadding + biasLeft
+    };
+    else if (collisionPadding) collisionPadding = {
+        top: (collisionPadding.top || 0) + biasTop,
+        right: (collisionPadding.right || 0) + biasRight,
+        bottom: (collisionPadding.bottom || 0) + biasBottom,
+        left: (collisionPadding.left || 0) + biasLeft
+    };
+    const commonCollisionProps = {
+        boundary: 'clipping-ancestors' === collisionBoundary ? 'clippingAncestors' : collisionBoundary,
+        padding: collisionPadding
+    };
+    const arrowRef = __rspack_external_react.useRef(null);
+    const sideOffsetRef = useValueAsRef(sideOffset);
+    const alignOffsetRef = useValueAsRef(alignOffset);
+    const sideOffsetDep = 'function' != typeof sideOffset ? sideOffset : 0;
+    const alignOffsetDep = 'function' != typeof alignOffset ? alignOffset : 0;
+    const middleware = [];
+    if (inlineMiddleware) middleware.push(inlineMiddleware);
+    middleware.push(floating_ui_react_dom_offset((state)=>{
+        const data = getOffsetData(state, sideParam, isRtl);
+        const sideAxis = 'function' == typeof sideOffsetRef.current ? sideOffsetRef.current(data) : sideOffsetRef.current;
+        const alignAxis = 'function' == typeof alignOffsetRef.current ? alignOffsetRef.current(data) : alignOffsetRef.current;
+        return {
+            mainAxis: sideAxis,
+            crossAxis: alignAxis,
+            alignmentAxis: alignAxis
+        };
+    }, [
+        sideOffsetDep,
+        alignOffsetDep,
+        isRtl,
+        sideParam
+    ]));
+    const shiftDisabled = 'none' === collisionAvoidanceAlign && 'shift' !== collisionAvoidanceSide;
+    const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || 'shift' === collisionAvoidanceSide);
+    const flipMiddleware = 'none' === collisionAvoidanceSide ? null : floating_ui_react_dom_flip({
+        ...commonCollisionProps,
+        padding: {
+            top: collisionPadding.top + bias,
+            right: collisionPadding.right + bias,
+            bottom: collisionPadding.bottom + bias,
+            left: collisionPadding.left + bias
+        },
+        mainAxis: !shiftCrossAxis && 'flip' === collisionAvoidanceSide,
+        crossAxis: 'flip' === collisionAvoidanceAlign ? 'alignment' : false,
+        fallbackAxisSideDirection: collisionAvoidanceFallbackAxisSide
+    });
+    const shiftMiddleware = shiftDisabled ? null : floating_ui_react_dom_shift((data)=>{
+        const html = ownerDocument(data.elements.floating).documentElement;
+        return {
+            ...commonCollisionProps,
+            rootBoundary: shiftCrossAxis ? {
+                x: 0,
+                y: 0,
+                width: html.clientWidth,
+                height: html.clientHeight
+            } : void 0,
+            mainAxis: 'none' !== collisionAvoidanceAlign,
+            crossAxis: crossAxisShiftEnabled,
+            limiter: sticky || shiftCrossAxis ? void 0 : floating_ui_react_dom_limitShift((limitData)=>{
+                if (!arrowRef.current) return {};
+                const { width, height } = arrowRef.current.getBoundingClientRect();
+                const sideAxis = floating_ui_utils_getSideAxis(floating_ui_utils_getSide(limitData.placement));
+                const arrowSize = 'y' === sideAxis ? width : height;
+                const offsetAmount = 'y' === sideAxis ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;
+                return {
+                    offset: arrowSize / 2 + offsetAmount / 2
+                };
+            })
+        };
+    }, [
+        commonCollisionProps,
+        sticky,
+        shiftCrossAxis,
+        collisionPadding,
+        collisionAvoidanceAlign
+    ]);
+    if ('shift' === collisionAvoidanceSide || 'shift' === collisionAvoidanceAlign || 'center' === align) middleware.push(shiftMiddleware, flipMiddleware);
+    else middleware.push(flipMiddleware, shiftMiddleware);
+    middleware.push(floating_ui_react_dom_size({
+        ...commonCollisionProps,
+        apply ({ elements: { floating }, availableWidth, availableHeight, rects }) {
+            if (!mountedRef.current) return;
+            const floatingStyle = floating.style;
+            floatingStyle.setProperty('--available-width', `${availableWidth}px`);
+            floatingStyle.setProperty('--available-height', `${availableHeight}px`);
+            const dpr = getWindow(floating).devicePixelRatio || 1;
+            const { x, y, width, height } = rects.reference;
+            const anchorWidth = (Math.round((x + width) * dpr) - Math.round(x * dpr)) / dpr;
+            const anchorHeight = (Math.round((y + height) * dpr) - Math.round(y * dpr)) / dpr;
+            floatingStyle.setProperty('--anchor-width', `${anchorWidth}px`);
+            floatingStyle.setProperty('--anchor-height', `${anchorHeight}px`);
+        }
+    }), arrow_arrow((state)=>({
+            element: arrowRef.current || ownerDocument(state.elements.floating).createElement('div'),
+            padding: arrowPadding,
+            offsetParent: 'floating'
+        }), [
+        arrowPadding
+    ]), {
+        name: 'transformOrigin',
+        fn (state) {
+            const { elements, middlewareData, placement: renderedPlacement, rects, y } = state;
+            const currentRenderedSide = floating_ui_utils_getSide(renderedPlacement);
+            const currentRenderedAxis = floating_ui_utils_getSideAxis(currentRenderedSide);
+            const arrowEl = arrowRef.current;
+            const arrowX = middlewareData.arrow?.x || 0;
+            const arrowY = middlewareData.arrow?.y || 0;
+            const arrowWidth = arrowEl?.clientWidth || 0;
+            const arrowHeight = arrowEl?.clientHeight || 0;
+            const transformX = arrowX + arrowWidth / 2;
+            const transformY = arrowY + arrowHeight / 2;
+            const shiftY = Math.abs(middlewareData.shift?.y || 0);
+            const halfAnchorHeight = rects.reference.height / 2;
+            const sideOffsetValue = 'function' == typeof sideOffset ? sideOffset(getOffsetData(state, sideParam, isRtl)) : sideOffset;
+            const isOverlappingAnchor = shiftY > sideOffsetValue;
+            const adjacentTransformOrigin = {
+                top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,
+                bottom: `${transformX}px ${-sideOffsetValue}px`,
+                left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,
+                right: `${-sideOffsetValue}px ${transformY}px`
+            }[currentRenderedSide];
+            const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y}px`;
+            elements.floating.style.setProperty('--transform-origin', crossAxisShiftEnabled && 'y' === currentRenderedAxis && isOverlappingAnchor ? overlapTransformOrigin : adjacentTransformOrigin);
+            return {};
+        }
+    }, hideMiddleware_hide, adaptiveOrigin);
+    useIsoLayoutEffect(()=>{
+        if (!mounted && floatingRootContext) floatingRootContext.update({
+            referenceElement: null,
+            floatingElement: null,
+            domReferenceElement: null,
+            positionReference: null
+        });
+    }, [
+        mounted,
+        floatingRootContext
+    ]);
+    const autoUpdateOptions = __rspack_external_react.useMemo(()=>({
+            elementResize: !disableAnchorTracking && "u" > typeof ResizeObserver,
+            layoutShift: !disableAnchorTracking && "u" > typeof IntersectionObserver
+        }), [
+        disableAnchorTracking
+    ]);
+    const { refs, elements, x, y, middlewareData, update, placement: renderedPlacement, context, isPositioned, floatingStyles: originalFloatingStyles } = useFloating_useFloating({
+        rootContext: floatingRootContext,
+        open: keepMounted ? mounted : void 0,
+        placement,
+        middleware,
+        strategy: positionMethod,
+        whileElementsMounted: keepMounted ? void 0 : (...args)=>autoUpdate(...args, autoUpdateOptions),
+        nodeId,
+        externalTree
+    });
+    const { sideX, sideY } = middlewareData.adaptiveOrigin || DEFAULT_SIDES;
+    const resolvedPosition = isPositioned ? positionMethod : 'fixed';
+    const floatingStyles = __rspack_external_react.useMemo(()=>{
+        const base = adaptiveOrigin ? {
+            position: resolvedPosition,
+            [sideX]: x,
+            [sideY]: y
+        } : {
+            position: resolvedPosition,
+            ...originalFloatingStyles
+        };
+        if (!isPositioned) base.opacity = 0;
+        return base;
+    }, [
+        adaptiveOrigin,
+        resolvedPosition,
+        sideX,
+        x,
+        sideY,
+        y,
+        originalFloatingStyles,
+        isPositioned
+    ]);
+    const registeredPositionReferenceRef = __rspack_external_react.useRef(null);
+    useIsoLayoutEffect(()=>{
+        if (!mounted) return;
+        const anchorValue = anchorValueRef.current;
+        const resolvedAnchor = 'function' == typeof anchorValue ? anchorValue() : anchorValue;
+        const unwrappedElement = (useAnchorPositioning_isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor) || null;
+        const finalAnchor = unwrappedElement || null;
+        if (finalAnchor !== registeredPositionReferenceRef.current) {
+            refs.setPositionReference(finalAnchor);
+            registeredPositionReferenceRef.current = finalAnchor;
+        }
+    }, [
+        mounted,
+        refs,
+        anchorDep,
+        anchorValueRef
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!mounted) return;
+        const anchorValue = anchorValueRef.current;
+        if ('function' == typeof anchorValue) return;
+        if (useAnchorPositioning_isRef(anchorValue) && anchorValue.current !== registeredPositionReferenceRef.current) {
+            refs.setPositionReference(anchorValue.current);
+            registeredPositionReferenceRef.current = anchorValue.current;
+        }
+    }, [
+        mounted,
+        refs,
+        anchorDep,
+        anchorValueRef
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (keepMounted && mounted && elements.domReference && elements.floating) return autoUpdate(elements.domReference, elements.floating, update, autoUpdateOptions);
+    }, [
+        keepMounted,
+        mounted,
+        elements,
+        update,
+        autoUpdateOptions
+    ]);
+    const renderedSide = floating_ui_utils_getSide(renderedPlacement);
+    const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
+    const renderedAlign = floating_ui_utils_getAlignment(renderedPlacement) || 'center';
+    const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);
+    useIsoLayoutEffect(()=>{
+        if (lazyFlip && mounted && isPositioned) setMountSide(renderedSide);
+    }, [
+        lazyFlip,
+        mounted,
+        isPositioned,
+        renderedSide
+    ]);
+    const arrowStyles = __rspack_external_react.useMemo(()=>({
+            position: 'absolute',
+            top: middlewareData.arrow?.y,
+            left: middlewareData.arrow?.x
+        }), [
+        middlewareData.arrow
+    ]);
+    const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;
+    return __rspack_external_react.useMemo(()=>({
+            positionerStyles: floatingStyles,
+            arrowStyles,
+            arrowRef,
+            arrowUncentered,
+            side: logicalRenderedSide,
+            align: renderedAlign,
+            physicalSide: renderedSide,
+            anchorHidden,
+            refs,
+            context,
+            isPositioned,
+            update
+        }), [
+        floatingStyles,
+        arrowStyles,
+        arrowRef,
+        arrowUncentered,
+        logicalRenderedSide,
+        renderedAlign,
+        renderedSide,
+        anchorHidden,
+        refs,
+        context,
+        isPositioned,
+        update
+    ]);
+}
+function useAnchorPositioning_isRef(param) {
+    return null != param && 'current' in param;
+}
+function getDisabledMountTransitionStyles(transitionStatus) {
+    return 'starting' === transitionStatus ? DISABLED_TRANSITIONS_STYLE : EMPTY_OBJECT;
+}
+function usePositioner(componentProps, state, { styles, transitionStatus, props, refs, hidden, inert = false }) {
+    const style = {
+        ...styles
+    };
+    if (inert) style.pointerEvents = 'none';
+    return useRenderElement('div', componentProps, {
+        state,
+        ref: refs,
+        props: [
+            {
+                role: 'presentation',
+                hidden,
+                style
+            },
+            getDisabledMountTransitionStyles(transitionStatus),
+            props
+        ],
+        stateAttributesMapping: popupStateMapping
+    });
+}
+export { adaptiveOriginMiddleware_adaptiveOrigin, floating_ui_dom_platform, getDisabledMountTransitionStyles, useAnchorPositioning, useFloatingRootContext, usePositioner };