@1771technologies/lytenyte-pro 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/components/external/floating-ui.js

@@ -0,0 +1,1802 @@
+/* eslint-disable */
+//#region node_modules/.pnpm/@floating-ui+utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+const sides = ["top", "right", "bottom", "left"];
+const alignments = ["start", "end"];
+const placements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+    x: v,
+    y: v,
+});
+const oppositeSideMap = {
+    left: "right",
+    right: "left",
+    bottom: "top",
+    top: "bottom",
+};
+const oppositeAlignmentMap = {
+    start: "end",
+    end: "start",
+};
+function clamp(start, value, end) {
+    return max(start, min(value, end));
+}
+function evaluate(value, param) {
+    return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+    return placement.split("-")[0];
+}
+function getAlignment(placement) {
+    return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+    return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+    return axis === "y" ? "height" : "width";
+}
+const yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+    return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+    return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+    if (rtl === void 0)
+        rtl = false;
+    const alignment = getAlignment(placement);
+    const alignmentAxis = getAlignmentAxis(placement);
+    const length = getAxisLength(alignmentAxis);
+    let mainAlignmentSide = alignmentAxis === "x"
+        ? alignment === (rtl ? "end" : "start")
+            ? "right"
+            : "left"
+        : alignment === "start"
+            ? "bottom"
+            : "top";
+    if (rects.reference[length] > rects.floating[length])
+        mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+    return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+    const oppositePlacement = getOppositePlacement(placement);
+    return [
+        getOppositeAlignmentPlacement(placement),
+        oppositePlacement,
+        getOppositeAlignmentPlacement(oppositePlacement),
+    ];
+}
+function getOppositeAlignmentPlacement(placement) {
+    return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+const lrPlacement = ["left", "right"];
+const rlPlacement = ["right", "left"];
+const tbPlacement = ["top", "bottom"];
+const btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+    switch (side) {
+        case "top":
+        case "bottom":
+            if (rtl)
+                return isStart ? rlPlacement : lrPlacement;
+            return isStart ? lrPlacement : rlPlacement;
+        case "left":
+        case "right":
+            return isStart ? tbPlacement : btPlacement;
+        default:
+            return [];
+    }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+    const alignment = getAlignment(placement);
+    let list = getSideList(getSide(placement), direction === "start", rtl);
+    if (alignment) {
+        list = list.map((side) => side + "-" + alignment);
+        if (flipAlignment)
+            list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+    return list;
+}
+function getOppositePlacement(placement) {
+    return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+    return {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0,
+        ...padding,
+    };
+}
+function getPaddingObject(padding) {
+    return typeof padding !== "number"
+        ? expandPaddingObject(padding)
+        : {
+            top: padding,
+            right: padding,
+            bottom: padding,
+            left: padding,
+        };
+}
+function rectToClientRect(rect) {
+    const { x, y, width, height } = rect;
+    return {
+        width,
+        height,
+        top: y,
+        left: x,
+        right: x + width,
+        bottom: y + height,
+        x,
+        y,
+    };
+}
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+core@1.7.3/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+    let { reference, floating } = _ref;
+    const sideAxis = getSideAxis(placement);
+    const alignmentAxis = getAlignmentAxis(placement);
+    const alignLength = getAxisLength(alignmentAxis);
+    const side = getSide(placement);
+    const isVertical = sideAxis === "y";
+    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 (getAlignment(placement)) {
+        case "start":
+            coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+            break;
+        case "end":
+            coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+            break;
+    }
+    return coords;
+}
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+const computePosition$1 = async (reference, floating, config) => {
+    const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1 } = config;
+    const validMiddleware = middleware.filter(Boolean);
+    const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(floating));
+    let rects = await platform$1.getElementRects({
+        reference,
+        floating,
+        strategy,
+    });
+    let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
+    let statefulPlacement = placement;
+    let middlewareData = {};
+    let resetCount = 0;
+    for (let i = 0; i < validMiddleware.length; i++) {
+        const { name, fn } = validMiddleware[i];
+        const { x: nextX, y: nextY, data, reset, } = await fn({
+            x,
+            y,
+            initialPlacement: placement,
+            placement: statefulPlacement,
+            strategy,
+            middlewareData,
+            rects,
+            platform: platform$1,
+            elements: {
+                reference,
+                floating,
+            },
+        });
+        x = nextX != null ? nextX : x;
+        y = nextY != null ? nextY : y;
+        middlewareData = {
+            ...middlewareData,
+            [name]: {
+                ...middlewareData[name],
+                ...data,
+            },
+        };
+        if (reset && resetCount <= 50) {
+            resetCount++;
+            if (typeof reset === "object") {
+                if (reset.placement)
+                    statefulPlacement = reset.placement;
+                if (reset.rects)
+                    rects =
+                        reset.rects === true
+                            ? await platform$1.getElementRects({
+                                reference,
+                                floating,
+                                strategy,
+                            })
+                            : reset.rects;
+                ({ x, y } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+            }
+            i = -1;
+        }
+    }
+    return {
+        x,
+        y,
+        placement: statefulPlacement,
+        strategy,
+        middlewareData,
+    };
+};
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+async function detectOverflow$1(state, options) {
+    var _await$platform$isEle;
+    if (options === void 0)
+        options = {};
+    const { x, y, platform: platform$1, rects, elements, strategy } = state;
+    const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0, } = evaluate(options, state);
+    const paddingObject = getPaddingObject(padding);
+    const element = elements[altBoundary ? (elementContext === "floating" ? "reference" : "floating") : elementContext];
+    const clippingClientRect = rectToClientRect(await platform$1.getClippingRect({
+        element: ((_await$platform$isEle = await (platform$1.isElement == null
+            ? void 0
+            : platform$1.isElement(element))) != null
+            ? _await$platform$isEle
+            : true)
+            ? element
+            : element.contextElement ||
+                (await (platform$1.getDocumentElement == null
+                    ? void 0
+                    : platform$1.getDocumentElement(elements.floating))),
+        boundary,
+        rootBoundary,
+        strategy,
+    }));
+    const rect = elementContext === "floating"
+        ? {
+            x,
+            y,
+            width: rects.floating.width,
+            height: rects.floating.height,
+        }
+        : rects.reference;
+    const offsetParent = await (platform$1.getOffsetParent == null
+        ? void 0
+        : platform$1.getOffsetParent(elements.floating));
+    const offsetScale = (await (platform$1.isElement == null ? void 0 : platform$1.isElement(offsetParent)))
+        ? (await (platform$1.getScale == null ? void 0 : platform$1.getScale(offsetParent))) || {
+            x: 1,
+            y: 1,
+        }
+        : {
+            x: 1,
+            y: 1,
+        };
+    const elementClientRect = rectToClientRect(platform$1.convertOffsetParentRelativeRectToViewportRelativeRect
+        ? await platform$1.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,
+    };
+}
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow$1 = (options) => ({
+    name: "arrow",
+    options,
+    async fn(state) {
+        const { x, y, placement, rects, platform: platform$1, elements, middlewareData } = state;
+        const { element, padding = 0 } = evaluate(options, state) || {};
+        if (element == null)
+            return {};
+        const paddingObject = getPaddingObject(padding);
+        const coords = {
+            x,
+            y,
+        };
+        const axis = getAlignmentAxis(placement);
+        const length = getAxisLength(axis);
+        const arrowDimensions = await platform$1.getDimensions(element);
+        const isYAxis = axis === "y";
+        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 = await (platform$1.getOffsetParent == null
+            ? void 0
+            : platform$1.getOffsetParent(element));
+        let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+        if (!clientSize ||
+            !(await (platform$1.isElement == null ? void 0 : platform$1.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 = min(paddingObject[minProp], largestPossiblePadding);
+        const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+        const min$1 = minPadding;
+        const max$1 = clientSize - arrowDimensions[length] - maxPadding;
+        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+        const offset$2 = clamp(min$1, center, max$1);
+        const shouldAddOffset = !middlewareData.arrow &&
+            getAlignment(placement) != null &&
+            center !== offset$2 &&
+            rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 <
+                0;
+        const alignmentOffset = shouldAddOffset ? (center < min$1 ? center - min$1 : center - max$1) : 0;
+        return {
+            [axis]: coords[axis] + alignmentOffset,
+            data: {
+                [axis]: offset$2,
+                centerOffset: center - offset$2 - alignmentOffset,
+                ...(shouldAddOffset && { alignmentOffset }),
+            },
+            reset: shouldAddOffset,
+        };
+    },
+});
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+    return (alignment
+        ? [
+            ...allowedPlacements.filter((placement) => getAlignment(placement) === alignment),
+            ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment),
+        ]
+        : allowedPlacements.filter((placement) => getSide(placement) === placement)).filter((placement) => {
+        if (alignment)
+            return (getAlignment(placement) === alignment ||
+                (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false));
+        return true;
+    });
+}
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        name: "autoPlacement",
+        options,
+        async fn(state) {
+            var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+            const { rects, middlewareData, placement, platform: platform$1, elements } = state;
+            const { crossAxis = false, alignment, allowedPlacements = placements, autoAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
+            const placements$1 = alignment !== void 0 || allowedPlacements === placements
+                ? getPlacementList(alignment || null, autoAlignment, allowedPlacements)
+                : allowedPlacements;
+            const overflow = await detectOverflow$1(state, detectOverflowOptions);
+            const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null
+                ? void 0
+                : _middlewareData$autoP.index) || 0;
+            const currentPlacement = placements$1[currentIndex];
+            if (currentPlacement == null)
+                return {};
+            const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(elements.floating)));
+            if (placement !== currentPlacement)
+                return { reset: { placement: placements$1[0] } };
+            const currentOverflows = [
+                overflow[getSide(currentPlacement)],
+                overflow[alignmentSides[0]],
+                overflow[alignmentSides[1]],
+            ];
+            const allOverflows = [
+                ...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null
+                    ? void 0
+                    : _middlewareData$autoP2.overflows) || []),
+                {
+                    placement: currentPlacement,
+                    overflows: currentOverflows,
+                },
+            ];
+            const nextPlacement = placements$1[currentIndex + 1];
+            if (nextPlacement)
+                return {
+                    data: {
+                        index: currentIndex + 1,
+                        overflows: allOverflows,
+                    },
+                    reset: { placement: nextPlacement },
+                };
+            const placementsSortedByMostSpace = allOverflows
+                .map((d) => {
+                const alignment$1 = getAlignment(d.placement);
+                return [
+                    d.placement,
+                    alignment$1 && crossAxis
+                        ? d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0)
+                        : d.overflows[0],
+                    d.overflows,
+                ];
+            })
+                .sort((a, b) => a[1] - b[1]);
+            const resetPlacement = ((_placementsThatFitOnE = placementsSortedByMostSpace.filter((d) => d[2].slice(0, getAlignment(d[0]) ? 2 : 3).every((v) => v <= 0))[0]) == null
+                ? void 0
+                : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+            if (resetPlacement !== placement)
+                return {
+                    data: {
+                        index: currentIndex + 1,
+                        overflows: allOverflows,
+                    },
+                    reset: { placement: resetPlacement },
+                };
+            return {};
+        },
+    };
+};
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        name: "flip",
+        options,
+        async fn(state) {
+            var _middlewareData$arrow, _middlewareData$flip;
+            const { placement, middlewareData, rects, initialPlacement, platform: platform$1, elements } = state;
+            const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = "bestFit", fallbackAxisSideDirection = "none", flipAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
+            if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset)
+                return {};
+            const side = getSide(placement);
+            const initialSideAxis = getSideAxis(initialPlacement);
+            const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+            const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(elements.floating));
+            const fallbackPlacements = specifiedFallbackPlacements ||
+                (isBasePlacement || !flipAlignment
+                    ? [getOppositePlacement(initialPlacement)]
+                    : getExpandedPlacements(initialPlacement));
+            const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+            if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection)
+                fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+            const placements$1 = [initialPlacement, ...fallbackPlacements];
+            const overflow = await detectOverflow$1(state, detectOverflowOptions);
+            const overflows = [];
+            let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) ||
+                [];
+            if (checkMainAxis)
+                overflows.push(overflow[side]);
+            if (checkCrossAxis) {
+                const sides$1 = getAlignmentSides(placement, rects, rtl);
+                overflows.push(overflow[sides$1[0]], overflow[sides$1[1]]);
+            }
+            overflowsData = [
+                ...overflowsData,
+                {
+                    placement,
+                    overflows,
+                },
+            ];
+            if (!overflows.every((side$1) => side$1 <= 0)) {
+                var _middlewareData$flip2, _overflowsData$filter;
+                const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) ||
+                    0) + 1;
+                const nextPlacement = placements$1[nextIndex];
+                if (nextPlacement) {
+                    if (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false) ||
+                        overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true))
+                        return {
+                            data: {
+                                index: nextIndex,
+                                overflows: overflowsData,
+                            },
+                            reset: { placement: nextPlacement },
+                        };
+                }
+                let resetPlacement = (_overflowsData$filter = overflowsData
+                    .filter((d) => d.overflows[0] <= 0)
+                    .sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null
+                    ? void 0
+                    : _overflowsData$filter.placement;
+                if (!resetPlacement)
+                    switch (fallbackStrategy) {
+                        case "bestFit": {
+                            var _overflowsData$filter2;
+                            const placement$1 = (_overflowsData$filter2 = overflowsData
+                                .filter((d) => {
+                                if (hasFallbackAxisSideDirection) {
+                                    const currentSideAxis = getSideAxis(d.placement);
+                                    return currentSideAxis === initialSideAxis || currentSideAxis === "y";
+                                }
+                                return true;
+                            })
+                                .map((d) => [
+                                d.placement,
+                                d.overflows
+                                    .filter((overflow$1) => overflow$1 > 0)
+                                    .reduce((acc, overflow$1) => acc + overflow$1, 0),
+                            ])
+                                .sort((a, b) => a[1] - b[1])[0]) == null
+                                ? void 0
+                                : _overflowsData$filter2[0];
+                            if (placement$1)
+                                resetPlacement = placement$1;
+                            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 sides.some((side) => overflow[side] >= 0);
+}
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        name: "hide",
+        options,
+        async fn(state) {
+            const { rects } = state;
+            const { strategy = "referenceHidden", ...detectOverflowOptions } = evaluate(options, state);
+            switch (strategy) {
+                case "referenceHidden": {
+                    const offsets = getSideOffsets(await detectOverflow$1(state, {
+                        ...detectOverflowOptions,
+                        elementContext: "reference",
+                    }), rects.reference);
+                    return {
+                        data: {
+                            referenceHiddenOffsets: offsets,
+                            referenceHidden: isAnySideFullyClipped(offsets),
+                        },
+                    };
+                }
+                case "escaped": {
+                    const offsets = getSideOffsets(await detectOverflow$1(state, {
+                        ...detectOverflowOptions,
+                        altBoundary: true,
+                    }), rects.floating);
+                    return {
+                        data: {
+                            escapedOffsets: offsets,
+                            escaped: isAnySideFullyClipped(offsets),
+                        },
+                    };
+                }
+                default:
+                    return {};
+            }
+        },
+    };
+};
+function getBoundingRect(rects) {
+    const minX = min(...rects.map((rect) => rect.left));
+    const minY = min(...rects.map((rect) => rect.top));
+    const maxX = max(...rects.map((rect) => rect.right));
+    const maxY = max(...rects.map((rect) => rect.bottom));
+    return {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY,
+    };
+}
+function getRectsByLine(rects) {
+    const sortedRects = rects.slice().sort((a, b) => a.y - b.y);
+    const groups = [];
+    let prevRect = null;
+    for (let i = 0; i < sortedRects.length; i++) {
+        const rect = sortedRects[i];
+        if (!prevRect || rect.y - prevRect.y > prevRect.height / 2)
+            groups.push([rect]);
+        else
+            groups[groups.length - 1].push(rect);
+        prevRect = rect;
+    }
+    return groups.map((rect) => rectToClientRect(getBoundingRect(rect)));
+}
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        name: "inline",
+        options,
+        async fn(state) {
+            const { placement, elements, rects, platform: platform$1, strategy } = state;
+            const { padding = 2, x, y } = evaluate(options, state);
+            const nativeClientRects = Array.from((await (platform$1.getClientRects == null
+                ? void 0
+                : platform$1.getClientRects(elements.reference))) || []);
+            const clientRects = getRectsByLine(nativeClientRects);
+            const fallback = rectToClientRect(getBoundingRect(nativeClientRects));
+            const paddingObject = getPaddingObject(padding);
+            function getBoundingClientRect$1() {
+                if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null)
+                    return (clientRects.find((rect) => x > rect.left - paddingObject.left &&
+                        x < rect.right + paddingObject.right &&
+                        y > rect.top - paddingObject.top &&
+                        y < rect.bottom + paddingObject.bottom) || fallback);
+                if (clientRects.length >= 2) {
+                    if (getSideAxis(placement) === "y") {
+                        const firstRect = clientRects[0];
+                        const lastRect = clientRects[clientRects.length - 1];
+                        const isTop = getSide(placement) === "top";
+                        const top$1 = firstRect.top;
+                        const bottom$1 = lastRect.bottom;
+                        const left$1 = isTop ? firstRect.left : lastRect.left;
+                        const right$1 = isTop ? firstRect.right : lastRect.right;
+                        return {
+                            top: top$1,
+                            bottom: bottom$1,
+                            left: left$1,
+                            right: right$1,
+                            width: right$1 - left$1,
+                            height: bottom$1 - top$1,
+                            x: left$1,
+                            y: top$1,
+                        };
+                    }
+                    const isLeftSide = getSide(placement) === "left";
+                    const maxRight = max(...clientRects.map((rect) => rect.right));
+                    const minLeft = min(...clientRects.map((rect) => rect.left));
+                    const measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
+                    const top = measureRects[0].top;
+                    const bottom = measureRects[measureRects.length - 1].bottom;
+                    const left = minLeft;
+                    const right = maxRight;
+                    return {
+                        top,
+                        bottom,
+                        left,
+                        right,
+                        width: right - left,
+                        height: bottom - top,
+                        x: left,
+                        y: top,
+                    };
+                }
+                return fallback;
+            }
+            const resetRects = await platform$1.getElementRects({
+                reference: { getBoundingClientRect: getBoundingClientRect$1 },
+                floating: elements.floating,
+                strategy,
+            });
+            if (rects.reference.x !== resetRects.reference.x ||
+                rects.reference.y !== resetRects.reference.y ||
+                rects.reference.width !== resetRects.reference.width ||
+                rects.reference.height !== resetRects.reference.height)
+                return { reset: { rects: resetRects } };
+            return {};
+        },
+    };
+};
+const originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+    const { placement, platform: platform$1, elements } = state;
+    const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(elements.floating));
+    const side = getSide(placement);
+    const alignment = getAlignment(placement);
+    const isVertical = getSideAxis(placement) === "y";
+    const mainAxisMulti = originSides.has(side) ? -1 : 1;
+    const crossAxisMulti = rtl && isVertical ? -1 : 1;
+    const rawValue = evaluate(options, state);
+    let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === "number"
+        ? {
+            mainAxis: rawValue,
+            crossAxis: 0,
+            alignmentAxis: null,
+        }
+        : {
+            mainAxis: rawValue.mainAxis || 0,
+            crossAxis: rawValue.crossAxis || 0,
+            alignmentAxis: rawValue.alignmentAxis,
+        };
+    if (alignment && typeof alignmentAxis === "number")
+        crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+    return isVertical
+        ? {
+            x: crossAxis * crossAxisMulti,
+            y: mainAxis * mainAxisMulti,
+        }
+        : {
+            x: mainAxis * mainAxisMulti,
+            y: crossAxis * crossAxisMulti,
+        };
+}
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset$1 = function (options) {
+    if (options === void 0)
+        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 ===
+                ((_middlewareData$offse = middlewareData.offset) == null
+                    ? void 0
+                    : _middlewareData$offse.placement) &&
+                (_middlewareData$arrow = middlewareData.arrow) != null &&
+                _middlewareData$arrow.alignmentOffset)
+                return {};
+            return {
+                x: x + diffCoords.x,
+                y: y + diffCoords.y,
+                data: {
+                    ...diffCoords,
+                    placement,
+                },
+            };
+        },
+    };
+};
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        name: "shift",
+        options,
+        async fn(state) {
+            const { x, y, placement } = state;
+            const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = {
+                fn: (_ref) => {
+                    let { x: x$1, y: y$1 } = _ref;
+                    return {
+                        x: x$1,
+                        y: y$1,
+                    };
+                },
+            }, ...detectOverflowOptions } = evaluate(options, state);
+            const coords = {
+                x,
+                y,
+            };
+            const overflow = await detectOverflow$1(state, detectOverflowOptions);
+            const crossAxis = getSideAxis(getSide(placement));
+            const mainAxis = getOppositeAxis(crossAxis);
+            let mainAxisCoord = coords[mainAxis];
+            let crossAxisCoord = coords[crossAxis];
+            if (checkMainAxis) {
+                const minSide = mainAxis === "y" ? "top" : "left";
+                const maxSide = mainAxis === "y" ? "bottom" : "right";
+                const min$1 = mainAxisCoord + overflow[minSide];
+                const max$1 = mainAxisCoord - overflow[maxSide];
+                mainAxisCoord = clamp(min$1, mainAxisCoord, max$1);
+            }
+            if (checkCrossAxis) {
+                const minSide = crossAxis === "y" ? "top" : "left";
+                const maxSide = crossAxis === "y" ? "bottom" : "right";
+                const min$1 = crossAxisCoord + overflow[minSide];
+                const max$1 = crossAxisCoord - overflow[maxSide];
+                crossAxisCoord = clamp(min$1, crossAxisCoord, max$1);
+            }
+            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,
+                    },
+                },
+            };
+        },
+    };
+};
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        options,
+        fn(state) {
+            const { x, y, placement, rects, middlewareData } = state;
+            const { offset: offset$2 = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, } = evaluate(options, state);
+            const coords = {
+                x,
+                y,
+            };
+            const crossAxis = getSideAxis(placement);
+            const mainAxis = getOppositeAxis(crossAxis);
+            let mainAxisCoord = coords[mainAxis];
+            let crossAxisCoord = coords[crossAxis];
+            const rawOffset = evaluate(offset$2, state);
+            const computedOffset = typeof rawOffset === "number"
+                ? {
+                    mainAxis: rawOffset,
+                    crossAxis: 0,
+                }
+                : {
+                    mainAxis: 0,
+                    crossAxis: 0,
+                    ...rawOffset,
+                };
+            if (checkMainAxis) {
+                const len = mainAxis === "y" ? "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 = mainAxis === "y" ? "width" : "height";
+                const isOriginSide = originSides.has(getSide(placement));
+                const limitMin = rects.reference[crossAxis] -
+                    rects.floating[len] +
+                    (isOriginSide
+                        ? ((_middlewareData$offse = middlewareData.offset) == null
+                            ? void 0
+                            : _middlewareData$offse[crossAxis]) || 0
+                        : 0) +
+                    (isOriginSide ? 0 : computedOffset.crossAxis);
+                const limitMax = rects.reference[crossAxis] +
+                    rects.reference[len] +
+                    (isOriginSide
+                        ? 0
+                        : ((_middlewareData$offse2 = middlewareData.offset) == null
+                            ? 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,
+            };
+        },
+    };
+};
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size$1 = function (options) {
+    if (options === void 0)
+        options = {};
+    return {
+        name: "size",
+        options,
+        async fn(state) {
+            var _state$middlewareData, _state$middlewareData2;
+            const { placement, rects, platform: platform$1, elements } = state;
+            const { apply = () => { }, ...detectOverflowOptions } = evaluate(options, state);
+            const overflow = await detectOverflow$1(state, detectOverflowOptions);
+            const side = getSide(placement);
+            const alignment = getAlignment(placement);
+            const isYAxis = getSideAxis(placement) === "y";
+            const { width, height } = rects.floating;
+            let heightSide;
+            let widthSide;
+            if (side === "top" || side === "bottom") {
+                heightSide = side;
+                widthSide =
+                    alignment ===
+                        ((await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(elements.floating)))
+                            ? "start"
+                            : "end")
+                        ? "left"
+                        : "right";
+            }
+            else {
+                widthSide = side;
+                heightSide = alignment === "end" ? "top" : "bottom";
+            }
+            const maximumClippingHeight = height - overflow.top - overflow.bottom;
+            const maximumClippingWidth = width - overflow.left - overflow.right;
+            const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+            const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+            const noShift = !state.middlewareData.shift;
+            let availableHeight = overflowAvailableHeight;
+            let availableWidth = overflowAvailableWidth;
+            if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x)
+                availableWidth = maximumClippingWidth;
+            if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y)
+                availableHeight = maximumClippingHeight;
+            if (noShift && !alignment) {
+                const xMin = max(overflow.left, 0);
+                const xMax = max(overflow.right, 0);
+                const yMin = max(overflow.top, 0);
+                const yMax = max(overflow.bottom, 0);
+                if (isYAxis)
+                    availableWidth =
+                        width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+                else
+                    availableHeight =
+                        height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+            }
+            await apply({
+                ...state,
+                availableWidth,
+                availableHeight,
+            });
+            const nextDimensions = await platform$1.getDimensions(elements.floating);
+            if (width !== nextDimensions.width || height !== nextDimensions.height)
+                return { reset: { rects: true } };
+            return {};
+        },
+    };
+};
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function hasWindow() {
+    return typeof window !== "undefined";
+}
+function getNodeName(node) {
+    if (isNode(node))
+        return (node.nodeName || "").toLowerCase();
+    return "#document";
+}
+function getWindow(node) {
+    var _node$ownerDocument;
+    return ((node == null || (_node$ownerDocument = node.ownerDocument) == null
+        ? void 0
+        : _node$ownerDocument.defaultView) || window);
+}
+function getDocumentElement(node) {
+    var _ref;
+    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null
+        ? void 0
+        : _ref.documentElement;
+}
+function isNode(value) {
+    if (!hasWindow())
+        return false;
+    return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+    if (!hasWindow())
+        return false;
+    return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+    if (!hasWindow())
+        return false;
+    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+    if (!hasWindow() || typeof ShadowRoot === "undefined")
+        return false;
+    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+const invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(element) {
+    const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
+    return (/auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) &&
+        !invalidOverflowDisplayValues.has(display));
+}
+const tableElements = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function isTableElement(element) {
+    return tableElements.has(getNodeName(element));
+}
+const topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(element) {
+    return topLayerSelectors.some((selector) => {
+        try {
+            return element.matches(selector);
+        }
+        catch (_e) {
+            return false;
+        }
+    });
+}
+const transformProperties = ["transform", "translate", "scale", "rotate", "perspective"];
+const willChangeValues = ["transform", "translate", "scale", "rotate", "perspective", "filter"];
+const containValues = ["paint", "layout", "strict", "content"];
+function isContainingBlock(elementOrCss) {
+    const webkit = isWebKit();
+    const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+    return (transformProperties.some((value) => (css[value] ? css[value] !== "none" : false)) ||
+        (css.containerType ? css.containerType !== "normal" : false) ||
+        (!webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false)) ||
+        (!webkit && (css.filter ? css.filter !== "none" : false)) ||
+        willChangeValues.some((value) => (css.willChange || "").includes(value)) ||
+        containValues.some((value) => (css.contain || "").includes(value)));
+}
+function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+        if (isContainingBlock(currentNode))
+            return currentNode;
+        else if (isTopLayer(currentNode))
+            return null;
+        currentNode = getParentNode(currentNode);
+    }
+    return null;
+}
+function isWebKit() {
+    if (typeof CSS === "undefined" || !CSS.supports)
+        return false;
+    return CSS.supports("-webkit-backdrop-filter", "none");
+}
+const lastTraversableNodeNames = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function isLastTraversableNode(node) {
+    return lastTraversableNodeNames.has(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+    return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+    if (isElement(element))
+        return {
+            scrollLeft: element.scrollLeft,
+            scrollTop: element.scrollTop,
+        };
+    return {
+        scrollLeft: element.scrollX,
+        scrollTop: element.scrollY,
+    };
+}
+function getParentNode(node) {
+    if (getNodeName(node) === "html")
+        return node;
+    const result = node.assignedSlot || node.parentNode || (isShadowRoot(node) && node.host) || getDocumentElement(node);
+    return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode(node);
+    if (isLastTraversableNode(parentNode))
+        return node.ownerDocument ? node.ownerDocument.body : node.body;
+    if (isHTMLElement(parentNode) && isOverflowElement(parentNode))
+        return parentNode;
+    return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+    var _node$ownerDocument2;
+    if (list === void 0)
+        list = [];
+    if (traverseIframes === void 0)
+        traverseIframes = true;
+    const scrollableAncestor = getNearestOverflowAncestor(node);
+    const isBody = scrollableAncestor ===
+        ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+    const win = getWindow(scrollableAncestor);
+    if (isBody) {
+        const frameElement = getFrameElement(win);
+        return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+    }
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+dom@1.7.4/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function getCssDimensions(element) {
+    const css = getComputedStyle$1(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.contextElement : element;
+}
+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 (isFixed === void 0)
+        isFixed = false;
+    if (!floatingOffsetParent || (isFixed && floatingOffsetParent !== getWindow(element)))
+        return false;
+    return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+    if (includeScale === void 0)
+        includeScale = false;
+    if (isFixedStrategy === void 0)
+        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 = getComputedStyle$1(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 rectToClientRect({
+        width,
+        height,
+        x,
+        y,
+    });
+}
+function getWindowScrollBarX(element, rect) {
+    const leftScroll = getNodeScroll(element).scrollLeft;
+    if (!rect)
+        return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+    return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+    const htmlRect = documentElement.getBoundingClientRect();
+    return {
+        x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
+        y: htmlRect.top + scroll.scrollTop,
+    };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+    let { elements, rect, offsetParent, strategy } = _ref;
+    const isFixed = strategy === "fixed";
+    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 (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement))
+            scroll = getNodeScroll(offsetParent);
+        if (isHTMLElement(offsetParent)) {
+            const offsetRect = getBoundingClientRect(offsetParent);
+            scale = getScale(offsetParent);
+            offsets.x = offsetRect.x + offsetParent.clientLeft;
+            offsets.y = offsetRect.y + offsetParent.clientTop;
+        }
+    }
+    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed
+        ? getHTMLOffset(documentElement, scroll)
+        : createCoords(0);
+    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 = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+    const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -scroll.scrollTop;
+    if (getComputedStyle$1(body).direction === "rtl")
+        x += 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 && strategy === "fixed")) {
+            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 = doc.compatMode === "CSS1Compat"
+            ? 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,
+    };
+}
+const absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function getInnerBoundingClientRect(element, strategy) {
+    const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+    return {
+        width: element.clientWidth * scale.x,
+        height: element.clientHeight * scale.y,
+        x: left * scale.x,
+        y: top * scale.y,
+    };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+    let rect;
+    if (clippingAncestor === "viewport")
+        rect = getViewportRect(element, strategy);
+    else if (clippingAncestor === "document")
+        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 rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+    const parentNode = getParentNode(element);
+    if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode))
+        return false;
+    return (getComputedStyle$1(parentNode).position === "fixed" || 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) && getNodeName(el) !== "body");
+    let currentContainingBlockComputedStyle = null;
+    const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+    let currentNode = elementIsFixed ? getParentNode(element) : element;
+    while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+        const computedStyle = getComputedStyle$1(currentNode);
+        const currentNodeIsContaining = isContainingBlock(currentNode);
+        if (!currentNodeIsContaining && computedStyle.position === "fixed")
+            currentContainingBlockComputedStyle = null;
+        if (elementIsFixed
+            ? !currentNodeIsContaining && !currentContainingBlockComputedStyle
+            : (!currentNodeIsContaining &&
+                computedStyle.position === "static" &&
+                !!currentContainingBlockComputedStyle &&
+                absoluteOrFixed.has(currentContainingBlockComputedStyle.position)) ||
+                (isOverflowElement(currentNode) &&
+                    !currentNodeIsContaining &&
+                    hasFixedPositionAncestor(element, currentNode)))
+            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 clippingAncestors = [
+        ...(boundary === "clippingAncestors"
+            ? isTopLayer(element)
+                ? []
+                : getClippingElementAncestors(element, this._c)
+            : [].concat(boundary)),
+        rootBoundary,
+    ];
+    const firstClippingAncestor = clippingAncestors[0];
+    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+        const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+        accRect.top = max(rect.top, accRect.top);
+        accRect.right = min(rect.right, accRect.right);
+        accRect.bottom = min(rect.bottom, accRect.bottom);
+        accRect.left = max(rect.left, accRect.left);
+        return accRect;
+    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+    return {
+        width: clippingRect.right - clippingRect.left,
+        height: clippingRect.bottom - clippingRect.top,
+        x: clippingRect.left,
+        y: clippingRect.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 = strategy === "fixed";
+    const rect = 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 (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement))
+            scroll = getNodeScroll(offsetParent);
+        if (isOffsetParentAnElement) {
+            const offsetRect = 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
+        ? getHTMLOffset(documentElement, scroll)
+        : createCoords(0);
+    return {
+        x: rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x,
+        y: rect.top + scroll.scrollTop - offsets.y - htmlOffset.y,
+        width: rect.width,
+        height: rect.height,
+    };
+}
+function isStaticPositioned(element) {
+    return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+    if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed")
+        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 getComputedStyle$1(element).direction === "rtl";
+}
+const platform = {
+    convertOffsetParentRelativeRectToViewportRelativeRect,
+    getDocumentElement,
+    getClippingRect,
+    getOffsetParent,
+    getElementRects,
+    getClientRects,
+    getDimensions,
+    getScale,
+    isElement,
+    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);
+        (_io = io) == null || _io.disconnect();
+        io = null;
+    }
+    function refresh(skip, threshold) {
+        if (skip === void 0)
+            skip = false;
+        if (threshold === void 0)
+            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 options = {
+            rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
+            threshold: max(0, min(1, threshold)) || 1,
+        };
+        let isFirstUpdate = true;
+        function handleObserve(entries) {
+            const ratio = entries[0].intersectionRatio;
+            if (ratio !== threshold) {
+                if (!isFirstUpdate)
+                    return refresh();
+                if (!ratio)
+                    timeoutId = setTimeout(() => {
+                        refresh(false, 1e-7);
+                    }, 1e3);
+                else
+                    refresh(false, ratio);
+            }
+            if (ratio === 1 && !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;
+}
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+function autoUpdate(reference, floating, update, options) {
+    if (options === void 0)
+        options = {};
+    const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false, } = options;
+    const referenceEl = unwrapElement(reference);
+    const ancestors = ancestorScroll || ancestorResize
+        ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...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) {
+                resizeObserver.unobserve(floating);
+                cancelAnimationFrame(reobserveFrame);
+                reobserveFrame = requestAnimationFrame(() => {
+                    var _resizeObserver;
+                    (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+                });
+            }
+            update();
+        });
+        if (referenceEl && !animationFrame)
+            resizeObserver.observe(referenceEl);
+        resizeObserver.observe(floating);
+    }
+    let frameId;
+    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+    if (animationFrame)
+        frameLoop();
+    function frameLoop() {
+        const nextRefRect = 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);
+        });
+        cleanupIo?.();
+        (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+        resizeObserver = null;
+        if (animationFrame)
+            cancelAnimationFrame(frameId);
+    };
+}
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+const detectOverflow = detectOverflow$1;
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset = offset$1;
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement = autoPlacement$1;
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = shift$1;
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = flip$1;
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size = size$1;
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide = hide$1;
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = arrow$1;
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline = inline$1;
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift = limitShift$1;
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+const computePosition = (reference, floating, options) => {
+    const cache = /* @__PURE__ */ new Map();
+    const mergedOptions = {
+        platform,
+        ...options,
+    };
+    const platformWithCache = {
+        ...mergedOptions.platform,
+        _c: cache,
+    };
+    return computePosition$1(reference, floating, {
+        ...mergedOptions,
+        platform: platformWithCache,
+    });
+};
+//#endregion
+export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size, };