;
! function() {
    try {
        var e = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof global ? global : "undefined" != typeof window ? window : "undefined" != typeof self ? self : {},
            n = (new e.Error).stack;
        n && ((e._debugIds || (e._debugIds = {}))[n] = "4d8bbe56-a7f9-427f-b638-35eb79413967")
    } catch (e) {}
}();
(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["object" == typeof document ? document.currentScript : void 0, 127200, t => {
    "use strict";
    let e;
    var n = t.i(416340);
    let r = ["top", "right", "bottom", "left"],
        i = Math.min,
        o = Math.max,
        l = Math.round,
        a = Math.floor,
        f = t => ({
            x: t,
            y: t
        }),
        s = {
            left: "right",
            right: "left",
            bottom: "top",
            top: "bottom"
        };

    function c(t, e) {
        return "function" == typeof t ? t(e) : t
    }

    function u(t) {
        return t.split("-")[0]
    }

    function d(t) {
        return t.split("-")[1]
    }

    function p(t) {
        return "x" === t ? "y" : "x"
    }

    function h(t) {
        return "y" === t ? "height" : "width"
    }

    function m(t) {
        let e = t[0];
        return "t" === e || "b" === e ? "y" : "x"
    }

    function g(t) {
        return t.includes("start") ? t.replace("start", "end") : t.replace("end", "start")
    }
    let y = ["left", "right"],
        w = ["right", "left"],
        x = ["top", "bottom"],
        v = ["bottom", "top"];

    function b(t) {
        let e = u(t);
        return s[e] + t.slice(e.length)
    }

    function R(t) {
        return "number" != typeof t ? {
            top: 0,
            right: 0,
            bottom: 0,
            left: 0,
            ...t
        } : {
            top: t,
            right: t,
            bottom: t,
            left: t
        }
    }

    function A(t) {
        let {
            x: e,
            y: n,
            width: r,
            height: i
        } = t;
        return {
            width: r,
            height: i,
            top: n,
            left: e,
            right: e + r,
            bottom: n + i,
            x: e,
            y: n
        }
    }

    function C(t, e, n) {
        let r, {
                reference: i,
                floating: o
            } = t,
            l = m(e),
            a = p(m(e)),
            f = h(a),
            s = u(e),
            c = "y" === l,
            g = i.x + i.width / 2 - o.width / 2,
            y = i.y + i.height / 2 - o.height / 2,
            w = i[f] / 2 - o[f] / 2;
        switch (s) {
            case "top":
                r = {
                    x: g,
                    y: i.y - o.height
                };
                break;
            case "bottom":
                r = {
                    x: g,
                    y: i.y + i.height
                };
                break;
            case "right":
                r = {
                    x: i.x + i.width,
                    y: y
                };
                break;
            case "left":
                r = {
                    x: i.x - o.width,
                    y: y
                };
                break;
            default:
                r = {
                    x: i.x,
                    y: i.y
                }
        }
        switch (d(e)) {
            case "start":
                r[a] -= w * (n && c ? -1 : 1);
                break;
            case "end":
                r[a] += w * (n && c ? -1 : 1)
        }
        return r
    }
    async function O(t, e) {
        var n;
        void 0 === e && (e = {});
        let {
            x: r,
            y: i,
            platform: o,
            rects: l,
            elements: a,
            strategy: f
        } = t, {
            boundary: s = "clippingAncestors",
            rootBoundary: u = "viewport",
            elementContext: d = "floating",
            altBoundary: p = !1,
            padding: h = 0
        } = c(e, t), m = R(h), g = a[p ? "floating" === d ? "reference" : "floating" : d], y = A(await o.getClippingRect({
            element: null == (n = await (null == o.isElement ? void 0 : o.isElement(g))) || n ? g : g.contextElement || await (null == o.getDocumentElement ? void 0 : o.getDocumentElement(a.floating)),
            boundary: s,
            rootBoundary: u,
            strategy: f
        })), w = "floating" === d ? {
            x: r,
            y: i,
            width: l.floating.width,
            height: l.floating.height
        } : l.reference, x = await (null == o.getOffsetParent ? void 0 : o.getOffsetParent(a.floating)), v = await (null == o.isElement ? void 0 : o.isElement(x)) && await (null == o.getScale ? void 0 : o.getScale(x)) || {
            x: 1,
            y: 1
        }, b = A(o.convertOffsetParentRelativeRectToViewportRelativeRect ? await o.convertOffsetParentRelativeRectToViewportRelativeRect({
            elements: a,
            rect: w,
            offsetParent: x,
            strategy: f
        }) : w);
        return {
            top: (y.top - b.top + m.top) / v.y,
            bottom: (b.bottom - y.bottom + m.bottom) / v.y,
            left: (y.left - b.left + m.left) / v.x,
            right: (b.right - y.right + m.right) / v.x
        }
    }
    let L = async (t, e, n) => {
        let {
            placement: r = "bottom",
            strategy: i = "absolute",
            middleware: o = [],
            platform: l
        } = n, a = l.detectOverflow ? l : { ...l,
            detectOverflow: O
        }, f = await (null == l.isRTL ? void 0 : l.isRTL(e)), s = await l.getElementRects({
            reference: t,
            floating: e,
            strategy: i
        }), {
            x: c,
            y: u
        } = C(s, r, f), d = r, p = 0, h = {};
        for (let n = 0; n < o.length; n++) {
            let m = o[n];
            if (!m) continue;
            let {
                name: g,
                fn: y
            } = m, {
                x: w,
                y: x,
                data: v,
                reset: b
            } = await y({
                x: c,
                y: u,
                initialPlacement: r,
                placement: d,
                strategy: i,
                middlewareData: h,
                rects: s,
                platform: a,
                elements: {
                    reference: t,
                    floating: e
                }
            });
            c = null != w ? w : c, u = null != x ? x : u, h[g] = { ...h[g],
                ...v
            }, b && p < 50 && (p++, "object" == typeof b && (b.placement && (d = b.placement), b.rects && (s = !0 === b.rects ? await l.getElementRects({
                reference: t,
                floating: e,
                strategy: i
            }) : b.rects), {
                x: c,
                y: u
            } = C(s, d, f)), n = -1)
        }
        return {
            x: c,
            y: u,
            placement: d,
            strategy: i,
            middlewareData: h
        }
    };

    function P(t, e) {
        return {
            top: t.top - e.height,
            right: t.right - e.width,
            bottom: t.bottom - e.height,
            left: t.left - e.width
        }
    }

    function S(t) {
        return r.some(e => t[e] >= 0)
    }
    let T = new Set(["left", "top"]);
    async function E(t, e) {
        let {
            placement: n,
            platform: r,
            elements: i
        } = t, o = await (null == r.isRTL ? void 0 : r.isRTL(i.floating)), l = u(n), a = d(n), f = "y" === m(n), s = T.has(l) ? -1 : 1, p = o && f ? -1 : 1, h = c(e, t), {
            mainAxis: g,
            crossAxis: y,
            alignmentAxis: w
        } = "number" == typeof h ? {
            mainAxis: h,
            crossAxis: 0,
            alignmentAxis: null
        } : {
            mainAxis: h.mainAxis || 0,
            crossAxis: h.crossAxis || 0,
            alignmentAxis: h.alignmentAxis
        };
        return a && "number" == typeof w && (y = "end" === a ? -1 * w : w), f ? {
            x: y * p,
            y: g * s
        } : {
            x: g * s,
            y: y * p
        }
    }

    function D() {
        return "u" > typeof window
    }

    function H(t) {
        return $(t) ? (t.nodeName || "").toLowerCase() : "#document"
    }

    function k(t) {
        var e;
        return (null == t || null == (e = t.ownerDocument) ? void 0 : e.defaultView) || window
    }

    function F(t) {
        var e;
        return null == (e = ($(t) ? t.ownerDocument : t.document) || window.document) ? void 0 : e.documentElement
    }

    function $(t) {
        return !!D() && (t instanceof Node || t instanceof k(t).Node)
    }

    function j(t) {
        return !!D() && (t instanceof Element || t instanceof k(t).Element)
    }

    function M(t) {
        return !!D() && (t instanceof HTMLElement || t instanceof k(t).HTMLElement)
    }

    function W(t) {
        return !(!D() || "u" < typeof ShadowRoot) && (t instanceof ShadowRoot || t instanceof k(t).ShadowRoot)
    }

    function B(t) {
        let {
            overflow: e,
            overflowX: n,
            overflowY: r,
            display: i
        } = q(t);
        return /auto|scroll|overlay|hidden|clip/.test(e + r + n) && "inline" !== i && "contents" !== i
    }

    function N(t) {
        try {
            if (t.matches(":popover-open")) return !0
        } catch (t) {}
        try {
            return t.matches(":modal")
        } catch (t) {
            return !1
        }
    }
    let V = /transform|translate|scale|rotate|perspective|filter/,
        z = /paint|layout|strict|content/,
        _ = t => !!t && "none" !== t;

    function I(t) {
        let e = j(t) ? q(t) : t;
        return _(e.transform) || _(e.translate) || _(e.scale) || _(e.rotate) || _(e.perspective) || !Y() && (_(e.backdropFilter) || _(e.filter)) || V.test(e.willChange || "") || z.test(e.contain || "")
    }

    function Y() {
        return null == e && (e = "u" > typeof CSS && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), e
    }

    function X(t) {
        return /^(html|body|#document)$/.test(H(t))
    }

    function q(t) {
        return k(t).getComputedStyle(t)
    }

    function K(t) {
        return j(t) ? {
            scrollLeft: t.scrollLeft,
            scrollTop: t.scrollTop
        } : {
            scrollLeft: t.scrollX,
            scrollTop: t.scrollY
        }
    }

    function U(t) {
        if ("html" === H(t)) return t;
        let e = t.assignedSlot || t.parentNode || W(t) && t.host || F(t);
        return W(e) ? e.host : e
    }

    function G(t, e, n) {
        var r;
        void 0 === e && (e = []), void 0 === n && (n = !0);
        let i = function t(e) {
                let n = U(e);
                return X(n) ? e.ownerDocument ? e.ownerDocument.body : e.body : M(n) && B(n) ? n : t(n)
            }(t),
            o = i === (null == (r = t.ownerDocument) ? void 0 : r.body),
            l = k(i);
        if (!o) return e.concat(i, G(i, [], n)); {
            let t = J(l);
            return e.concat(l, l.visualViewport || [], B(i) ? i : [], t && n ? G(t) : [])
        }
    }

    function J(t) {
        return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null
    }

    function Q(t) {
        let e = q(t),
            n = parseFloat(e.width) || 0,
            r = parseFloat(e.height) || 0,
            i = M(t),
            o = i ? t.offsetWidth : n,
            a = i ? t.offsetHeight : r,
            f = l(n) !== o || l(r) !== a;
        return f && (n = o, r = a), {
            width: n,
            height: r,
            $: f
        }
    }

    function Z(t) {
        return j(t) ? t : t.contextElement
    }

    function tt(t) {
        let e = Z(t);
        if (!M(e)) return f(1);
        let n = e.getBoundingClientRect(),
            {
                width: r,
                height: i,
                $: o
            } = Q(e),
            a = (o ? l(n.width) : n.width) / r,
            s = (o ? l(n.height) : n.height) / i;
        return a && Number.isFinite(a) || (a = 1), s && Number.isFinite(s) || (s = 1), {
            x: a,
            y: s
        }
    }
    let te = f(0);

    function tn(t) {
        let e = k(t);
        return Y() && e.visualViewport ? {
            x: e.visualViewport.offsetLeft,
            y: e.visualViewport.offsetTop
        } : te
    }

    function tr(t, e, n, r) {
        var i;
        void 0 === e && (e = !1), void 0 === n && (n = !1);
        let o = t.getBoundingClientRect(),
            l = Z(t),
            a = f(1);
        e && (r ? j(r) && (a = tt(r)) : a = tt(t));
        let s = (void 0 === (i = n) && (i = !1), r && (!i || r === k(l)) && i) ? tn(l) : f(0),
            c = (o.left + s.x) / a.x,
            u = (o.top + s.y) / a.y,
            d = o.width / a.x,
            p = o.height / a.y;
        if (l) {
            let t = k(l),
                e = r && j(r) ? k(r) : r,
                n = t,
                i = J(n);
            for (; i && r && e !== n;) {
                let t = tt(i),
                    e = i.getBoundingClientRect(),
                    r = q(i),
                    o = e.left + (i.clientLeft + parseFloat(r.paddingLeft)) * t.x,
                    l = e.top + (i.clientTop + parseFloat(r.paddingTop)) * t.y;
                c *= t.x, u *= t.y, d *= t.x, p *= t.y, c += o, u += l, i = J(n = k(i))
            }
        }
        return A({
            width: d,
            height: p,
            x: c,
            y: u
        })
    }

    function ti(t, e) {
        let n = K(t).scrollLeft;
        return e ? e.left + n : tr(F(t)).left + n
    }

    function to(t, e) {
        let n = t.getBoundingClientRect();
        return {
            x: n.left + e.scrollLeft - ti(t, n),
            y: n.top + e.scrollTop
        }
    }

    function tl(t, e, n) {
        var r;
        let i;
        if ("viewport" === e) i = function(t, e) {
            let n = k(t),
                r = F(t),
                i = n.visualViewport,
                o = r.clientWidth,
                l = r.clientHeight,
                a = 0,
                f = 0;
            if (i) {
                o = i.width, l = i.height;
                let t = Y();
                (!t || t && "fixed" === e) && (a = i.offsetLeft, f = i.offsetTop)
            }
            let s = ti(r);
            if (s <= 0) {
                let t = r.ownerDocument,
                    e = t.body,
                    n = getComputedStyle(e),
                    i = "CSS1Compat" === t.compatMode && parseFloat(n.marginLeft) + parseFloat(n.marginRight) || 0,
                    l = Math.abs(r.clientWidth - e.clientWidth - i);
                l <= 25 && (o -= l)
            } else s <= 25 && (o += s);
            return {
                width: o,
                height: l,
                x: a,
                y: f
            }
        }(t, n);
        else if ("document" === e) {
            let e, n, l, a, f, s, c;
            r = F(t), e = F(r), n = K(r), l = r.ownerDocument.body, a = o(e.scrollWidth, e.clientWidth, l.scrollWidth, l.clientWidth), f = o(e.scrollHeight, e.clientHeight, l.scrollHeight, l.clientHeight), s = -n.scrollLeft + ti(r), c = -n.scrollTop, "rtl" === q(l).direction && (s += o(e.clientWidth, l.clientWidth) - a), i = {
                width: a,
                height: f,
                x: s,
                y: c
            }
        } else if (j(e)) {
            let t, r, o, l, a, s;
            r = (t = tr(e, !0, "fixed" === n)).top + e.clientTop, o = t.left + e.clientLeft, l = M(e) ? tt(e) : f(1), a = e.clientWidth * l.x, s = e.clientHeight * l.y, i = {
                width: a,
                height: s,
                x: o * l.x,
                y: r * l.y
            }
        } else {
            let n = tn(t);
            i = {
                x: e.x - n.x,
                y: e.y - n.y,
                width: e.width,
                height: e.height
            }
        }
        return A(i)
    }

    function ta(t) {
        return "static" === q(t).position
    }

    function tf(t, e) {
        if (!M(t) || "fixed" === q(t).position) return null;
        if (e) return e(t);
        let n = t.offsetParent;
        return F(t) === n && (n = n.ownerDocument.body), n
    }

    function ts(t, e) {
        var n;
        let r = k(t);
        if (N(t)) return r;
        if (!M(t)) {
            let e = U(t);
            for (; e && !X(e);) {
                if (j(e) && !ta(e)) return e;
                e = U(e)
            }
            return r
        }
        let i = tf(t, e);
        for (; i && (n = i, /^(table|td|th)$/.test(H(n))) && ta(i);) i = tf(i, e);
        return i && X(i) && ta(i) && !I(i) ? r : i || function(t) {
            let e = U(t);
            for (; M(e) && !X(e);) {
                if (I(e)) return e;
                if (N(e)) break;
                e = U(e)
            }
            return null
        }(t) || r
    }
    let tc = async function(t) {
            let e = this.getOffsetParent || ts,
                n = this.getDimensions,
                r = await n(t.floating);
            return {
                reference: function(t, e, n) {
                    let r = M(e),
                        i = F(e),
                        o = "fixed" === n,
                        l = tr(t, !0, o, e),
                        a = {
                            scrollLeft: 0,
                            scrollTop: 0
                        },
                        s = f(0);
                    if (r || !r && !o)
                        if (("body" !== H(e) || B(i)) && (a = K(e)), r) {
                            let t = tr(e, !0, o, e);
                            s.x = t.x + e.clientLeft, s.y = t.y + e.clientTop
                        } else i && (s.x = ti(i));
                    o && !r && i && (s.x = ti(i));
                    let c = !i || r || o ? f(0) : to(i, a);
                    return {
                        x: l.left + a.scrollLeft - s.x - c.x,
                        y: l.top + a.scrollTop - s.y - c.y,
                        width: l.width,
                        height: l.height
                    }
                }(t.reference, await e(t.floating), t.strategy),
                floating: {
                    x: 0,
                    y: 0,
                    width: r.width,
                    height: r.height
                }
            }
        },
        tu = {
            convertOffsetParentRelativeRectToViewportRelativeRect: function(t) {
                let {
                    elements: e,
                    rect: n,
                    offsetParent: r,
                    strategy: i
                } = t, o = "fixed" === i, l = F(r), a = !!e && N(e.floating);
                if (r === l || a && o) return n;
                let s = {
                        scrollLeft: 0,
                        scrollTop: 0
                    },
                    c = f(1),
                    u = f(0),
                    d = M(r);
                if ((d || !d && !o) && (("body" !== H(r) || B(l)) && (s = K(r)), d)) {
                    let t = tr(r);
                    c = tt(r), u.x = t.x + r.clientLeft, u.y = t.y + r.clientTop
                }
                let p = !l || d || o ? f(0) : to(l, s);
                return {
                    width: n.width * c.x,
                    height: n.height * c.y,
                    x: n.x * c.x - s.scrollLeft * c.x + u.x + p.x,
                    y: n.y * c.y - s.scrollTop * c.y + u.y + p.y
                }
            },
            getDocumentElement: F,
            getClippingRect: function(t) {
                let {
                    element: e,
                    boundary: n,
                    rootBoundary: r,
                    strategy: l
                } = t, a = [..."clippingAncestors" === n ? N(e) ? [] : function(t, e) {
                    let n = e.get(t);
                    if (n) return n;
                    let r = G(t, [], !1).filter(t => j(t) && "body" !== H(t)),
                        i = null,
                        o = "fixed" === q(t).position,
                        l = o ? U(t) : t;
                    for (; j(l) && !X(l);) {
                        let e = q(l),
                            n = I(l);
                        n || "fixed" !== e.position || (i = null), (o ? n || i : !(!n && "static" === e.position && i && ("absolute" === i.position || "fixed" === i.position) || B(l) && !n && function t(e, n) {
                            let r = U(e);
                            return !(r === n || !j(r) || X(r)) && ("fixed" === q(r).position || t(r, n))
                        }(t, l))) ? i = e : r = r.filter(t => t !== l), l = U(l)
                    }
                    return e.set(t, r), r
                }(e, this._c) : [].concat(n), r], f = tl(e, a[0], l), s = f.top, c = f.right, u = f.bottom, d = f.left;
                for (let t = 1; t < a.length; t++) {
                    let n = tl(e, a[t], l);
                    s = o(n.top, s), c = i(n.right, c), u = i(n.bottom, u), d = o(n.left, d)
                }
                return {
                    width: c - d,
                    height: u - s,
                    x: d,
                    y: s
                }
            },
            getOffsetParent: ts,
            getElementRects: tc,
            getClientRects: function(t) {
                return Array.from(t.getClientRects())
            },
            getDimensions: function(t) {
                let {
                    width: e,
                    height: n
                } = Q(t);
                return {
                    width: e,
                    height: n
                }
            },
            getScale: tt,
            isElement: j,
            isRTL: function(t) {
                return "rtl" === q(t).direction
            }
        };

    function td(t, e) {
        return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height
    }
    let tp = t => ({
        name: "arrow",
        options: t,
        async fn(e) {
            let {
                x: n,
                y: r,
                placement: l,
                rects: a,
                platform: f,
                elements: s,
                middlewareData: u
            } = e, {
                element: g,
                padding: y = 0
            } = c(t, e) || {};
            if (null == g) return {};
            let w = R(y),
                x = {
                    x: n,
                    y: r
                },
                v = p(m(l)),
                b = h(v),
                A = await f.getDimensions(g),
                C = "y" === v,
                O = C ? "clientHeight" : "clientWidth",
                L = a.reference[b] + a.reference[v] - x[v] - a.floating[b],
                P = x[v] - a.reference[v],
                S = await (null == f.getOffsetParent ? void 0 : f.getOffsetParent(g)),
                T = S ? S[O] : 0;
            T && await (null == f.isElement ? void 0 : f.isElement(S)) || (T = s.floating[O] || a.floating[b]);
            let E = T / 2 - A[b] / 2 - 1,
                D = i(w[C ? "top" : "left"], E),
                H = i(w[C ? "bottom" : "right"], E),
                k = T - A[b] - H,
                F = T / 2 - A[b] / 2 + (L / 2 - P / 2),
                $ = o(D, i(F, k)),
                j = !u.arrow && null != d(l) && F !== $ && a.reference[b] / 2 - (F < D ? D : H) - A[b] / 2 < 0,
                M = j ? F < D ? F - D : F - k : 0;
            return {
                [v]: x[v] + M,
                data: {
                    [v]: $,
                    centerOffset: F - $ - M,
                    ...j && {
                        alignmentOffset: M
                    }
                },
                reset: j
            }
        }
    });
    var th = t.i(149285),
        tm = "u" > typeof document ? n.useLayoutEffect : function() {};

    function tg(t, e) {
        let n, r, i;
        if (t === e) return !0;
        if (typeof t != typeof e) return !1;
        if ("function" == typeof t && t.toString() === e.toString()) return !0;
        if (t && e && "object" == typeof t) {
            if (Array.isArray(t)) {
                if ((n = t.length) !== e.length) return !1;
                for (r = n; 0 != r--;)
                    if (!tg(t[r], e[r])) return !1;
                return !0
            }
            if ((n = (i = Object.keys(t)).length) !== Object.keys(e).length) return !1;
            for (r = n; 0 != r--;)
                if (!({}).hasOwnProperty.call(e, i[r])) return !1;
            for (r = n; 0 != r--;) {
                let n = i[r];
                if (("_owner" !== n || !t.$$typeof) && !tg(t[n], e[n])) return !1
            }
            return !0
        }
        return t != t && e != e
    }

    function ty(t) {
        return "u" < typeof window ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1
    }

    function tw(t, e) {
        let n = ty(t);
        return Math.round(e * n) / n
    }

    function tx(t) {
        let e = n.useRef(t);
        return tm(() => {
            e.current = t
        }), e
    }
    var tv = t.i(600317),
        tb = t.i(221628),
        tR = n.forwardRef((t, e) => {
            let {
                children: n,
                width: r = 10,
                height: i = 5,
                ...o
            } = t;
            return (0, tb.jsx)(tv.Primitive.svg, { ...o,
                ref: e,
                width: r,
                height: i,
                viewBox: "0 0 30 10",
                preserveAspectRatio: "none",
                children: t.asChild ? n : (0, tb.jsx)("polygon", {
                    points: "0,0 30,0 15,10"
                })
            })
        });
    tR.displayName = "Arrow";
    var tA = t.i(78892),
        tC = t.i(608652),
        tO = t.i(886449),
        tL = t.i(723570),
        tP = t.i(692166),
        tS = "Popper",
        [tT, tE] = (0, tC.createContextScope)(tS),
        [tD, tH] = tT(tS),
        tk = t => {
            let {
                __scopePopper: e,
                children: r
            } = t, [i, o] = n.useState(null);
            return (0, tb.jsx)(tD, {
                scope: e,
                anchor: i,
                onAnchorChange: o,
                children: r
            })
        };
    tk.displayName = tS;
    var tF = "PopperAnchor",
        t$ = n.forwardRef((t, e) => {
            let {
                __scopePopper: r,
                virtualRef: i,
                ...o
            } = t, l = tH(tF, r), a = n.useRef(null), f = (0, tA.useComposedRefs)(e, a), s = n.useRef(null);
            return n.useEffect(() => {
                let t = s.current;
                s.current = i ? .current || a.current, t !== s.current && l.onAnchorChange(s.current)
            }), i ? null : (0, tb.jsx)(tv.Primitive.div, { ...o,
                ref: f
            })
        });
    t$.displayName = tF;
    var tj = "PopperContent",
        [tM, tW] = tT(tj),
        tB = n.forwardRef((t, e) => {
            var r, l, f, s, R, A, C, O, D, H, k, $, j;
            let M, W, B, N, V, z, {
                    __scopePopper: _,
                    side: I = "bottom",
                    sideOffset: Y = 0,
                    align: X = "center",
                    alignOffset: q = 0,
                    arrowPadding: K = 0,
                    avoidCollisions: U = !0,
                    collisionBoundary: J = [],
                    collisionPadding: Q = 0,
                    sticky: tt = "partial",
                    hideWhenDetached: te = !1,
                    updatePositionStrategy: tn = "optimized",
                    onPlaced: ti,
                    ...to
                } = t,
                tl = tH(tj, _),
                [ta, tf] = n.useState(null),
                ts = (0, tA.useComposedRefs)(e, t => tf(t)),
                [tc, tR] = n.useState(null),
                tC = (0, tP.useSize)(tc),
                tS = tC ? .width ? ? 0,
                tT = tC ? .height ? ? 0,
                tE = "number" == typeof Q ? Q : {
                    top: 0,
                    right: 0,
                    bottom: 0,
                    left: 0,
                    ...Q
                },
                tD = Array.isArray(J) ? J : [J],
                tk = tD.length > 0,
                tF = {
                    padding: tE,
                    boundary: tD.filter(t_),
                    altBoundary: tk
                },
                {
                    refs: t$,
                    floatingStyles: tW,
                    placement: tB,
                    isPositioned: tN,
                    middlewareData: tV
                } = function(t) {
                    void 0 === t && (t = {});
                    let {
                        placement: e = "bottom",
                        strategy: r = "absolute",
                        middleware: i = [],
                        platform: o,
                        elements: {
                            reference: l,
                            floating: a
                        } = {},
                        transform: f = !0,
                        whileElementsMounted: s,
                        open: c
                    } = t, [u, d] = n.useState({
                        x: 0,
                        y: 0,
                        strategy: r,
                        placement: e,
                        middlewareData: {},
                        isPositioned: !1
                    }), [p, h] = n.useState(i);
                    tg(p, i) || h(i);
                    let [m, g] = n.useState(null), [y, w] = n.useState(null), x = n.useCallback(t => {
                        t !== A.current && (A.current = t, g(t))
                    }, []), v = n.useCallback(t => {
                        t !== C.current && (C.current = t, w(t))
                    }, []), b = l || m, R = a || y, A = n.useRef(null), C = n.useRef(null), O = n.useRef(u), P = null != s, S = tx(s), T = tx(o), E = tx(c), D = n.useCallback(() => {
                        var t, n;
                        let i, o, l;
                        if (!A.current || !C.current) return;
                        let a = {
                            placement: e,
                            strategy: r,
                            middleware: p
                        };
                        T.current && (a.platform = T.current), (t = A.current, n = C.current, i = new Map, l = { ...(o = {
                                platform: tu,
                                ...a
                            }).platform,
                            _c: i
                        }, L(t, n, { ...o,
                            platform: l
                        })).then(t => {
                            let e = { ...t,
                                isPositioned: !1 !== E.current
                            };
                            H.current && !tg(O.current, e) && (O.current = e, th.flushSync(() => {
                                d(e)
                            }))
                        })
                    }, [p, e, r, T, E]);
                    tm(() => {
                        !1 === c && O.current.isPositioned && (O.current.isPositioned = !1, d(t => ({ ...t,
                            isPositioned: !1
                        })))
                    }, [c]);
                    let H = n.useRef(!1);
                    tm(() => (H.current = !0, () => {
                        H.current = !1
                    }), []), tm(() => {
                        if (b && (A.current = b), R && (C.current = R), b && R) {
                            if (S.current) return S.current(b, R, D);
                            D()
                        }
                    }, [b, R, D, S, P]);
                    let k = n.useMemo(() => ({
                            reference: A,
                            floating: C,
                            setReference: x,
                            setFloating: v
                        }), [x, v]),
                        F = n.useMemo(() => ({
                            reference: b,
                            floating: R
                        }), [b, R]),
                        $ = n.useMemo(() => {
                            let t = {
                                position: r,
                                left: 0,
                                top: 0
                            };
                            if (!F.floating) return t;
                            let e = tw(F.floating, u.x),
                                n = tw(F.floating, u.y);
                            return f ? { ...t,
                                transform: "translate(" + e + "px, " + n + "px)",
                                ...ty(F.floating) >= 1.5 && {
                                    willChange: "transform"
                                }
                            } : {
                                position: r,
                                left: e,
                                top: n
                            }
                        }, [r, f, F.floating, u.x, u.y]);
                    return n.useMemo(() => ({ ...u,
                        update: D,
                        refs: k,
                        elements: F,
                        floatingStyles: $
                    }), [u, D, k, F, $])
                }({
                    strategy: "fixed",
                    placement: I + ("center" !== X ? "-" + X : ""),
                    whileElementsMounted: (...t) => (function(t, e, n, r) {
                        let l;
                        void 0 === r && (r = {});
                        let {
                            ancestorScroll: f = !0,
                            ancestorResize: s = !0,
                            elementResize: c = "function" == typeof ResizeObserver,
                            layoutShift: u = "function" == typeof IntersectionObserver,
                            animationFrame: d = !1
                        } = r, p = Z(t), h = f || s ? [...p ? G(p) : [], ...e ? G(e) : []] : [];
                        h.forEach(t => {
                            f && t.addEventListener("scroll", n, {
                                passive: !0
                            }), s && t.addEventListener("resize", n)
                        });
                        let m = p && u ? function(t, e) {
                                let n, r = null,
                                    l = F(t);

                                function f() {
                                    var t;
                                    clearTimeout(n), null == (t = r) || t.disconnect(), r = null
                                }
                                return ! function s(c, u) {
                                    void 0 === c && (c = !1), void 0 === u && (u = 1), f();
                                    let d = t.getBoundingClientRect(),
                                        {
                                            left: p,
                                            top: h,
                                            width: m,
                                            height: g
                                        } = d;
                                    if (c || e(), !m || !g) return;
                                    let y = {
                                            rootMargin: -a(h) + "px " + -a(l.clientWidth - (p + m)) + "px " + -a(l.clientHeight - (h + g)) + "px " + -a(p) + "px",
                                            threshold: o(0, i(1, u)) || 1
                                        },
                                        w = !0;

                                    function x(e) {
                                        let r = e[0].intersectionRatio;
                                        if (r !== u) {
                                            if (!w) return s();
                                            r ? s(!1, r) : n = setTimeout(() => {
                                                s(!1, 1e-7)
                                            }, 1e3)
                                        }
                                        1 !== r || td(d, t.getBoundingClientRect()) || s(), w = !1
                                    }
                                    try {
                                        r = new IntersectionObserver(x, { ...y,
                                            root: l.ownerDocument
                                        })
                                    } catch (t) {
                                        r = new IntersectionObserver(x, y)
                                    }
                                    r.observe(t)
                                }(!0), f
                            }(p, n) : null,
                            g = -1,
                            y = null;
                        c && (y = new ResizeObserver(t => {
                            let [r] = t;
                            r && r.target === p && y && e && (y.unobserve(e), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
                                var t;
                                null == (t = y) || t.observe(e)
                            })), n()
                        }), p && !d && y.observe(p), e && y.observe(e));
                        let w = d ? tr(t) : null;
                        return d && function e() {
                            let r = tr(t);
                            w && !td(w, r) && n(), w = r, l = requestAnimationFrame(e)
                        }(), n(), () => {
                            var t;
                            h.forEach(t => {
                                f && t.removeEventListener("scroll", n), s && t.removeEventListener("resize", n)
                            }), null == m || m(), null == (t = y) || t.disconnect(), y = null, d && cancelAnimationFrame(l)
                        }
                    })(...t, {
                        animationFrame: "always" === tn
                    }),
                    elements: {
                        reference: tl.anchor
                    },
                    middleware: [{
                        name: (M = {
                            name: "offset",
                            options: l = r = {
                                mainAxis: Y + tT,
                                alignmentAxis: q
                            },
                            async fn(t) {
                                var e, n;
                                let {
                                    x: r,
                                    y: i,
                                    placement: o,
                                    middlewareData: a
                                } = t, f = await E(t, l);
                                return o === (null == (e = a.offset) ? void 0 : e.placement) && null != (n = a.arrow) && n.alignmentOffset ? {} : {
                                    x: r + f.x,
                                    y: i + f.y,
                                    data: { ...f,
                                        placement: o
                                    }
                                }
                            }
                        }).name,
                        fn: M.fn,
                        options: [r, void 0]
                    }, U && {
                        name: (W = {
                            name: "shift",
                            options: R = s = {
                                mainAxis: !0,
                                crossAxis: !1,
                                limiter: "partial" === tt ? {
                                    fn: (f = void 0, {
                                        options: f = {},
                                        fn(t) {
                                            let {
                                                x: e,
                                                y: n,
                                                placement: r,
                                                rects: i,
                                                middlewareData: o
                                            } = t, {
                                                offset: l = 0,
                                                mainAxis: a = !0,
                                                crossAxis: s = !0
                                            } = c(f, t), d = {
                                                x: e,
                                                y: n
                                            }, h = m(r), g = p(h), y = d[g], w = d[h], x = c(l, t), v = "number" == typeof x ? {
                                                mainAxis: x,
                                                crossAxis: 0
                                            } : {
                                                mainAxis: 0,
                                                crossAxis: 0,
                                                ...x
                                            };
                                            if (a) {
                                                let t = "y" === g ? "height" : "width",
                                                    e = i.reference[g] - i.floating[t] + v.mainAxis,
                                                    n = i.reference[g] + i.reference[t] - v.mainAxis;
                                                y < e ? y = e : y > n && (y = n)
                                            }
                                            if (s) {
                                                var b, R;
                                                let t = "y" === g ? "width" : "height",
                                                    e = T.has(u(r)),
                                                    n = i.reference[h] - i.floating[t] + (e && (null == (b = o.offset) ? void 0 : b[h]) || 0) + (e ? 0 : v.crossAxis),
                                                    l = i.reference[h] + i.reference[t] + (e ? 0 : (null == (R = o.offset) ? void 0 : R[h]) || 0) - (e ? v.crossAxis : 0);
                                                w < n ? w = n : w > l && (w = l)
                                            }
                                            return {
                                                [g]: y,
                                                [h]: w
                                            }
                                        }
                                    }).fn,
                                    options: [void 0, void 0]
                                } : void 0,
                                ...tF
                            },
                            async fn(t) {
                                let {
                                    x: e,
                                    y: n,
                                    placement: r,
                                    platform: l
                                } = t, {
                                    mainAxis: a = !0,
                                    crossAxis: f = !1,
                                    limiter: s = {
                                        fn: t => {
                                            let {
                                                x: e,
                                                y: n
                                            } = t;
                                            return {
                                                x: e,
                                                y: n
                                            }
                                        }
                                    },
                                    ...d
                                } = c(R, t), h = {
                                    x: e,
                                    y: n
                                }, g = await l.detectOverflow(t, d), y = m(u(r)), w = p(y), x = h[w], v = h[y];
                                if (a) {
                                    let t = "y" === w ? "top" : "left",
                                        e = "y" === w ? "bottom" : "right",
                                        n = x + g[t],
                                        r = x - g[e];
                                    x = o(n, i(x, r))
                                }
                                if (f) {
                                    let t = "y" === y ? "top" : "left",
                                        e = "y" === y ? "bottom" : "right",
                                        n = v + g[t],
                                        r = v - g[e];
                                    v = o(n, i(v, r))
                                }
                                let b = s.fn({ ...t,
                                    [w]: x,
                                    [y]: v
                                });
                                return { ...b,
                                    data: {
                                        x: b.x - e,
                                        y: b.y - n,
                                        enabled: {
                                            [w]: a,
                                            [y]: f
                                        }
                                    }
                                }
                            }
                        }).name,
                        fn: W.fn,
                        options: [s, void 0]
                    }, U && {
                        name: (B = {
                            name: "flip",
                            options: C = A = { ...tF
                            },
                            async fn(t) {
                                var e, n, r, i, o, l, a, f;
                                let s, R, A, {
                                        placement: O,
                                        middlewareData: L,
                                        rects: P,
                                        initialPlacement: S,
                                        platform: T,
                                        elements: E
                                    } = t,
                                    {
                                        mainAxis: D = !0,
                                        crossAxis: H = !0,
                                        fallbackPlacements: k,
                                        fallbackStrategy: F = "bestFit",
                                        fallbackAxisSideDirection: $ = "none",
                                        flipAlignment: j = !0,
                                        ...M
                                    } = c(C, t);
                                if (null != (e = L.arrow) && e.alignmentOffset) return {};
                                let W = u(O),
                                    B = m(S),
                                    N = u(S) === S,
                                    V = await (null == T.isRTL ? void 0 : T.isRTL(E.floating)),
                                    z = k || (N || !j ? [b(S)] : (s = b(S), [g(S), s, g(s)])),
                                    _ = "none" !== $;
                                !k && _ && z.push(...(R = d(S), A = function(t, e, n) {
                                    switch (t) {
                                        case "top":
                                        case "bottom":
                                            if (n) return e ? w : y;
                                            return e ? y : w;
                                        case "left":
                                        case "right":
                                            return e ? x : v;
                                        default:
                                            return []
                                    }
                                }(u(S), "start" === $, V), R && (A = A.map(t => t + "-" + R), j && (A = A.concat(A.map(g)))), A));
                                let I = [S, ...z],
                                    Y = await T.detectOverflow(t, M),
                                    X = [],
                                    q = (null == (n = L.flip) ? void 0 : n.overflows) || [];
                                if (D && X.push(Y[W]), H) {
                                    let t, e, n, r, i = (l = O, a = P, void 0 === (f = V) && (f = !1), t = d(l), n = h(e = p(m(l))), r = "x" === e ? t === (f ? "end" : "start") ? "right" : "left" : "start" === t ? "bottom" : "top", a.reference[n] > a.floating[n] && (r = b(r)), [r, b(r)]);
                                    X.push(Y[i[0]], Y[i[1]])
                                }
                                if (q = [...q, {
                                        placement: O,
                                        overflows: X
                                    }], !X.every(t => t <= 0)) {
                                    let t = ((null == (r = L.flip) ? void 0 : r.index) || 0) + 1,
                                        e = I[t];
                                    if (e && ("alignment" !== H || B === m(e) || q.every(t => m(t.placement) !== B || t.overflows[0] > 0))) return {
                                        data: {
                                            index: t,
                                            overflows: q
                                        },
                                        reset: {
                                            placement: e
                                        }
                                    };
                                    let n = null == (i = q.filter(t => t.overflows[0] <= 0).sort((t, e) => t.overflows[1] - e.overflows[1])[0]) ? void 0 : i.placement;
                                    if (!n) switch (F) {
                                        case "bestFit":
                                            {
                                                let t = null == (o = q.filter(t => {
                                                    if (_) {
                                                        let e = m(t.placement);
                                                        return e === B || "y" === e
                                                    }
                                                    return !0
                                                }).map(t => [t.placement, t.overflows.filter(t => t > 0).reduce((t, e) => t + e, 0)]).sort((t, e) => t[1] - e[1])[0]) ? void 0 : o[0];t && (n = t);
                                                break
                                            }
                                        case "initialPlacement":
                                            n = S
                                    }
                                    if (O !== n) return {
                                        reset: {
                                            placement: n
                                        }
                                    }
                                }
                                return {}
                            }
                        }).name,
                        fn: B.fn,
                        options: [A, void 0]
                    }, {
                        name: (N = {
                            name: "size",
                            options: D = O = { ...tF,
                                apply: ({
                                    elements: t,
                                    rects: e,
                                    availableWidth: n,
                                    availableHeight: r
                                }) => {
                                    let {
                                        width: i,
                                        height: o
                                    } = e.reference, l = t.floating.style;
                                    l.setProperty("--radix-popper-available-width", `${n}px`), l.setProperty("--radix-popper-available-height", `${r}px`), l.setProperty("--radix-popper-anchor-width", `${i}px`), l.setProperty("--radix-popper-anchor-height", `${o}px`)
                                }
                            },
                            async fn(t) {
                                var e, n;
                                let r, l, {
                                        placement: a,
                                        rects: f,
                                        platform: s,
                                        elements: p
                                    } = t,
                                    {
                                        apply: h = () => {},
                                        ...g
                                    } = c(D, t),
                                    y = await s.detectOverflow(t, g),
                                    w = u(a),
                                    x = d(a),
                                    v = "y" === m(a),
                                    {
                                        width: b,
                                        height: R
                                    } = f.floating;
                                "top" === w || "bottom" === w ? (r = w, l = x === (await (null == s.isRTL ? void 0 : s.isRTL(p.floating)) ? "start" : "end") ? "left" : "right") : (l = w, r = "end" === x ? "top" : "bottom");
                                let A = R - y.top - y.bottom,
                                    C = b - y.left - y.right,
                                    O = i(R - y[r], A),
                                    L = i(b - y[l], C),
                                    P = !t.middlewareData.shift,
                                    S = O,
                                    T = L;
                                if (null != (e = t.middlewareData.shift) && e.enabled.x && (T = C), null != (n = t.middlewareData.shift) && n.enabled.y && (S = A), P && !x) {
                                    let t = o(y.left, 0),
                                        e = o(y.right, 0),
                                        n = o(y.top, 0),
                                        r = o(y.bottom, 0);
                                    v ? T = b - 2 * (0 !== t || 0 !== e ? t + e : o(y.left, y.right)) : S = R - 2 * (0 !== n || 0 !== r ? n + r : o(y.top, y.bottom))
                                }
                                await h({ ...t,
                                    availableWidth: T,
                                    availableHeight: S
                                });
                                let E = await s.getDimensions(p.floating);
                                return b !== E.width || R !== E.height ? {
                                    reset: {
                                        rects: !0
                                    }
                                } : {}
                            }
                        }).name,
                        fn: N.fn,
                        options: [O, void 0]
                    }, tc && {
                        name: (V = {
                            name: "arrow",
                            options: k = H = {
                                element: tc,
                                padding: K
                            },
                            fn(t) {
                                let {
                                    element: e,
                                    padding: n
                                } = "function" == typeof k ? k(t) : k;
                                return e && ({}).hasOwnProperty.call(e, "current") ? null != e.current ? tp({
                                    element: e.current,
                                    padding: n
                                }).fn(t) : {} : e ? tp({
                                    element: e,
                                    padding: n
                                }).fn(t) : {}
                            }
                        }).name,
                        fn: V.fn,
                        options: [H, void 0]
                    }, tI({
                        arrowWidth: tS,
                        arrowHeight: tT
                    }), te && {
                        name: (z = {
                            name: "hide",
                            options: j = $ = {
                                strategy: "referenceHidden",
                                ...tF
                            },
                            async fn(t) {
                                let {
                                    rects: e,
                                    platform: n
                                } = t, {
                                    strategy: r = "referenceHidden",
                                    ...i
                                } = c(j, t);
                                switch (r) {
                                    case "referenceHidden":
                                        {
                                            let r = P(await n.detectOverflow(t, { ...i,
                                                elementContext: "reference"
                                            }), e.reference);
                                            return {
                                                data: {
                                                    referenceHiddenOffsets: r,
                                                    referenceHidden: S(r)
                                                }
                                            }
                                        }
                                    case "escaped":
                                        {
                                            let r = P(await n.detectOverflow(t, { ...i,
                                                altBoundary: !0
                                            }), e.floating);
                                            return {
                                                data: {
                                                    escapedOffsets: r,
                                                    escaped: S(r)
                                                }
                                            }
                                        }
                                    default:
                                        return {}
                                }
                            }
                        }).name,
                        fn: z.fn,
                        options: [$, void 0]
                    }]
                }),
                [tz, tX] = tY(tB),
                tq = (0, tO.useCallbackRef)(ti);
            (0, tL.useLayoutEffect)(() => {
                tN && tq ? .()
            }, [tN, tq]);
            let tK = tV.arrow ? .x,
                tU = tV.arrow ? .y,
                tG = tV.arrow ? .centerOffset !== 0,
                [tJ, tQ] = n.useState();
            return (0, tL.useLayoutEffect)(() => {
                ta && tQ(window.getComputedStyle(ta).zIndex)
            }, [ta]), (0, tb.jsx)("div", {
                ref: t$.setFloating,
                "data-radix-popper-content-wrapper": "",
                style: { ...tW,
                    transform: tN ? tW.transform : "translate(0, -200%)",
                    minWidth: "max-content",
                    zIndex: tJ,
                    "--radix-popper-transform-origin": [tV.transformOrigin ? .x, tV.transformOrigin ? .y].join(" "),
                    ...tV.hide ? .referenceHidden && {
                        visibility: "hidden",
                        pointerEvents: "none"
                    }
                },
                dir: t.dir,
                children: (0, tb.jsx)(tM, {
                    scope: _,
                    placedSide: tz,
                    onArrowChange: tR,
                    arrowX: tK,
                    arrowY: tU,
                    shouldHideArrow: tG,
                    children: (0, tb.jsx)(tv.Primitive.div, {
                        "data-side": tz,
                        "data-align": tX,
                        ...to,
                        ref: ts,
                        style: { ...to.style,
                            animation: tN ? void 0 : "none"
                        }
                    })
                })
            })
        });
    tB.displayName = tj;
    var tN = "PopperArrow",
        tV = {
            top: "bottom",
            right: "left",
            bottom: "top",
            left: "right"
        },
        tz = n.forwardRef(function(t, e) {
            let {
                __scopePopper: n,
                ...r
            } = t, i = tW(tN, n), o = tV[i.placedSide];
            return (0, tb.jsx)("span", {
                ref: i.onArrowChange,
                style: {
                    position: "absolute",
                    left: i.arrowX,
                    top: i.arrowY,
                    [o]: 0,
                    transformOrigin: {
                        top: "",
                        right: "0 0",
                        bottom: "center 0",
                        left: "100% 0"
                    }[i.placedSide],
                    transform: {
                        top: "translateY(100%)",
                        right: "translateY(50%) rotate(90deg) translateX(-50%)",
                        bottom: "rotate(180deg)",
                        left: "translateY(50%) rotate(-90deg) translateX(50%)"
                    }[i.placedSide],
                    visibility: i.shouldHideArrow ? "hidden" : void 0
                },
                children: (0, tb.jsx)(tR, { ...r,
                    ref: e,
                    style: { ...r.style,
                        display: "block"
                    }
                })
            })
        });

    function t_(t) {
        return null !== t
    }
    tz.displayName = tN;
    var tI = t => ({
        name: "transformOrigin",
        options: t,
        fn(e) {
            let {
                placement: n,
                rects: r,
                middlewareData: i
            } = e, o = i.arrow ? .centerOffset !== 0, l = o ? 0 : t.arrowWidth, a = o ? 0 : t.arrowHeight, [f, s] = tY(n), c = {
                start: "0%",
                center: "50%",
                end: "100%"
            }[s], u = (i.arrow ? .x ? ? 0) + l / 2, d = (i.arrow ? .y ? ? 0) + a / 2, p = "", h = "";
            return "bottom" === f ? (p = o ? c : `${u}px`, h = `${-a}px`) : "top" === f ? (p = o ? c : `${u}px`, h = `${r.floating.height+a}px`) : "right" === f ? (p = `${-a}px`, h = o ? c : `${d}px`) : "left" === f && (p = `${r.floating.width+a}px`, h = o ? c : `${d}px`), {
                data: {
                    x: p,
                    y: h
                }
            }
        }
    });

    function tY(t) {
        let [e, n = "center"] = t.split("-");
        return [e, n]
    }
    t.s(["Anchor", 0, t$, "Arrow", 0, tz, "Content", 0, tB, "Root", 0, tk, "createPopperScope", 0, tE], 127200)
}]);

//# debugId=4d8bbe56-a7f9-427f-b638-35eb79413967