;
! 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] = "d20101f7-e758-30a1-aeaa-bff3fb8b273e")
    } catch (e) {}
}();
(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["object" == typeof document ? document.currentScript : void 0, 262504, t => {
    "use strict";
    let e = (0, t.i(416340).createContext)({});
    t.s(["LayoutGroupContext", 0, e])
}, 583730, t => {
    "use strict";
    var e = t.i(416340);
    t.s(["useConstant", 0, function(t) {
        let i = (0, e.useRef)(null);
        return null === i.current && (i.current = t()), i.current
    }])
}, 519825, t => {
    "use strict";
    var e = t.i(416340);
    let i = "u" > typeof window ? e.useLayoutEffect : e.useEffect;
    t.s(["useIsomorphicLayoutEffect", 0, i], 519825)
}, 62682, t => {
    "use strict";
    let e = (0, t.i(416340).createContext)(null);
    t.s(["PresenceContext", 0, e])
}, 562914, t => {
    "use strict";
    t.s(["isObject", 0, function(t) {
        return "object" == typeof t && null !== t
    }])
}, 141355, t => {
    "use strict";
    var e = t.i(562914);
    t.s(["isHTMLElement", 0, function(t) {
        return (0, e.isObject)(t) && "offsetHeight" in t && !("ownerSVGElement" in t)
    }])
}, 20655, t => {
    "use strict";
    let e = (0, t.i(416340).createContext)({
        transformPagePoint: t => t,
        isStatic: !1,
        reducedMotion: "never"
    });
    t.s(["MotionConfigContext", 0, e])
}, 312151, t => {
    "use strict";
    var e = t.i(416340),
        i = t.i(62682);
    t.s(["usePresence", 0, function(t = !0) {
        let s = (0, e.useContext)(i.PresenceContext);
        if (null === s) return [!0, null];
        let {
            isPresent: n,
            onExitComplete: r,
            register: a
        } = s, o = (0, e.useId)();
        (0, e.useEffect)(() => {
            if (t) return a(o)
        }, [t]);
        let l = (0, e.useCallback)(() => t && r && r(o), [o, r, t]);
        return !n && r ? [!1, l] : [!0]
    }])
}, 870691, t => {
    "use strict";
    let e = ["transformPerspective", "x", "y", "z", "translateX", "translateY", "translateZ", "scale", "scaleX", "scaleY", "rotate", "rotateX", "rotateY", "rotateZ", "skew", "skewX", "skewY"],
        i = new Set(e);
    t.s(["transformPropOrder", 0, e, "transformProps", 0, i])
}, 212344, t => {
    "use strict";
    t.s(["clamp", 0, (t, e, i) => i > e ? e : i < t ? t : i])
}, 23642, 383119, 884188, 144454, 336868, 960847, 866031, 401828, t => {
    "use strict";
    var e = t.i(212344);
    let i = {
            test: t => "number" == typeof t,
            parse: parseFloat,
            transform: t => t
        },
        s = { ...i,
            transform: t => (0, e.clamp)(0, 1, t)
        },
        n = { ...i,
            default: 1
        };
    t.s(["alpha", 0, s, "number", 0, i, "scale", 0, n], 383119);
    let r = t => Math.round(1e5 * t) / 1e5,
        a = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
    t.s(["floatRegex", 0, a], 884188);
    let o = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu,
        l = (t, e) => i => !!("string" == typeof i && o.test(i) && i.startsWith(t) || e && null != i && Object.prototype.hasOwnProperty.call(i, e)),
        u = (t, e, i) => s => {
            if ("string" != typeof s) return s;
            let [n, r, o, l] = s.match(a);
            return {
                [t]: parseFloat(n),
                [e]: parseFloat(r),
                [i]: parseFloat(o),
                alpha: void 0 !== l ? parseFloat(l) : 1
            }
        },
        h = { ...i,
            transform: t => Math.round((0, e.clamp)(0, 255, t))
        },
        c = {
            test: l("rgb", "red"),
            parse: u("red", "green", "blue"),
            transform: ({
                red: t,
                green: e,
                blue: i,
                alpha: n = 1
            }) => "rgba(" + h.transform(t) + ", " + h.transform(e) + ", " + h.transform(i) + ", " + r(s.transform(n)) + ")"
        };
    t.s(["rgba", 0, c], 144454);
    let d = {
        test: l("#"),
        parse: function(t) {
            let e = "",
                i = "",
                s = "",
                n = "";
            return t.length > 5 ? (e = t.substring(1, 3), i = t.substring(3, 5), s = t.substring(5, 7), n = t.substring(7, 9)) : (e = t.substring(1, 2), i = t.substring(2, 3), s = t.substring(3, 4), n = t.substring(4, 5), e += e, i += i, s += s, n += n), {
                red: parseInt(e, 16),
                green: parseInt(i, 16),
                blue: parseInt(s, 16),
                alpha: n ? parseInt(n, 16) / 255 : 1
            }
        },
        transform: c.transform
    };
    t.s(["hex", 0, d], 336868);
    let m = t => ({
            test: e => "string" == typeof e && e.endsWith(t) && 1 === e.split(" ").length,
            parse: parseFloat,
            transform: e => `${e}${t}`
        }),
        p = m("deg"),
        f = m("%"),
        v = m("px"),
        g = m("vh"),
        y = m("vw"),
        x = { ...f,
            parse: t => f.parse(t) / 100,
            transform: t => f.transform(100 * t)
        };
    t.s(["degrees", 0, p, "percent", 0, f, "progressPercentage", 0, x, "px", 0, v, "vh", 0, g, "vw", 0, y], 960847);
    let T = {
        test: l("hsl", "hue"),
        parse: u("hue", "saturation", "lightness"),
        transform: ({
            hue: t,
            saturation: e,
            lightness: i,
            alpha: n = 1
        }) => "hsla(" + Math.round(t) + ", " + f.transform(r(e)) + ", " + f.transform(r(i)) + ", " + r(s.transform(n)) + ")"
    };
    t.s(["hsla", 0, T], 866031);
    let b = {
        test: t => c.test(t) || d.test(t) || T.test(t),
        parse: t => c.test(t) ? c.parse(t) : T.test(t) ? T.parse(t) : d.parse(t),
        transform: t => "string" == typeof t ? t : t.hasOwnProperty("red") ? c.transform(t) : T.transform(t),
        getAnimatableNone: t => {
            let e = b.parse(t);
            return e.alpha = 0, b.transform(e)
        }
    };
    t.s(["color", 0, b], 23642);
    let S = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu,
        w = "number",
        P = "color",
        V = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;

    function M(t) {
        let e = t.toString(),
            i = [],
            s = {
                color: [],
                number: [],
                var: []
            },
            n = [],
            r = 0,
            a = e.replace(V, t => (b.test(t) ? (s.color.push(r), n.push(P), i.push(b.parse(t))) : t.startsWith("var(") ? (s.var.push(r), n.push("var"), i.push(t)) : (s.number.push(r), n.push(w), i.push(parseFloat(t))), ++r, "${}")).split("${}");
        return {
            values: i,
            split: a,
            indexes: s,
            types: n
        }
    }

    function A({
        split: t,
        types: e
    }) {
        let i = t.length;
        return s => {
            let n = "";
            for (let a = 0; a < i; a++)
                if (n += t[a], void 0 !== s[a]) {
                    let t = e[a];
                    t === w ? n += r(s[a]) : t === P ? n += b.transform(s[a]) : n += s[a]
                }
            return n
        }
    }
    t.s(["analyseComplexValue", 0, M, "complex", 0, {
        test: function(t) {
            return isNaN(t) && "string" == typeof t && (t.match(a) ? .length || 0) + (t.match(S) ? .length || 0) > 0
        },
        parse: function(t) {
            return M(t).values
        },
        createTransformer: function(t) {
            return A(M(t))
        },
        getAnimatableNone: function(t) {
            let e = M(t);
            return A(e)(e.values.map((t, i) => ((t, e) => "number" == typeof t ? e ? .trim().endsWith("/") ? t : 0 : "number" == typeof t ? 0 : b.test(t) ? b.getAnimatableNone(t) : t)(t, e.split[i])))
        }
    }], 401828)
}, 446094, 55698, 514010, 568774, 107952, t => {
    "use strict";
    var e = t.i(23642),
        i = t.i(401828),
        s = t.i(884188);
    let n = new Set(["brightness", "contrast", "saturate", "opacity"]);

    function r(t) {
        let [e, i] = t.slice(0, -1).split("(");
        if ("drop-shadow" === e) return t;
        let [r] = i.match(s.floatRegex) || [];
        if (!r) return t;
        let a = i.replace(r, ""),
            o = +!!n.has(e);
        return r !== i && (o *= 100), e + "(" + o + a + ")"
    }
    let a = /\b([a-z-]*)\(.*?\)/gu,
        o = { ...i.complex,
            getAnimatableNone: t => {
                let e = t.match(a);
                return e ? e.map(r).join(" ") : t
            }
        };
    t.s(["filter", 0, o], 55698);
    let l = { ...i.complex,
        getAnimatableNone: t => {
            let e = i.complex.parse(t);
            return i.complex.createTransformer(t)(e.map(t => "number" == typeof t ? 0 : "object" == typeof t ? { ...t,
                alpha: 1
            } : t))
        }
    };
    t.s(["mask", 0, l], 514010);
    var u = t.i(383119);
    let h = { ...u.number,
        transform: Math.round
    };
    var c = t.i(960847);
    let d = {
            rotate: c.degrees,
            rotateX: c.degrees,
            rotateY: c.degrees,
            rotateZ: c.degrees,
            scale: u.scale,
            scaleX: u.scale,
            scaleY: u.scale,
            scaleZ: u.scale,
            skew: c.degrees,
            skewX: c.degrees,
            skewY: c.degrees,
            distance: c.px,
            translateX: c.px,
            translateY: c.px,
            translateZ: c.px,
            x: c.px,
            y: c.px,
            z: c.px,
            perspective: c.px,
            transformPerspective: c.px,
            opacity: u.alpha,
            originX: c.progressPercentage,
            originY: c.progressPercentage,
            originZ: c.px
        },
        m = {
            borderWidth: c.px,
            borderTopWidth: c.px,
            borderRightWidth: c.px,
            borderBottomWidth: c.px,
            borderLeftWidth: c.px,
            borderRadius: c.px,
            borderTopLeftRadius: c.px,
            borderTopRightRadius: c.px,
            borderBottomRightRadius: c.px,
            borderBottomLeftRadius: c.px,
            width: c.px,
            maxWidth: c.px,
            height: c.px,
            maxHeight: c.px,
            top: c.px,
            right: c.px,
            bottom: c.px,
            left: c.px,
            inset: c.px,
            insetBlock: c.px,
            insetBlockStart: c.px,
            insetBlockEnd: c.px,
            insetInline: c.px,
            insetInlineStart: c.px,
            insetInlineEnd: c.px,
            padding: c.px,
            paddingTop: c.px,
            paddingRight: c.px,
            paddingBottom: c.px,
            paddingLeft: c.px,
            paddingBlock: c.px,
            paddingBlockStart: c.px,
            paddingBlockEnd: c.px,
            paddingInline: c.px,
            paddingInlineStart: c.px,
            paddingInlineEnd: c.px,
            margin: c.px,
            marginTop: c.px,
            marginRight: c.px,
            marginBottom: c.px,
            marginLeft: c.px,
            marginBlock: c.px,
            marginBlockStart: c.px,
            marginBlockEnd: c.px,
            marginInline: c.px,
            marginInlineStart: c.px,
            marginInlineEnd: c.px,
            fontSize: c.px,
            backgroundPositionX: c.px,
            backgroundPositionY: c.px,
            ...d,
            zIndex: h,
            fillOpacity: u.alpha,
            strokeOpacity: u.alpha,
            numOctaves: h
        };
    t.s(["numberValueTypes", 0, m], 568774);
    let p = { ...m,
        color: e.color,
        backgroundColor: e.color,
        outlineColor: e.color,
        fill: e.color,
        stroke: e.color,
        borderColor: e.color,
        borderTopColor: e.color,
        borderRightColor: e.color,
        borderBottomColor: e.color,
        borderLeftColor: e.color,
        filter: o,
        WebkitFilter: o,
        mask: l,
        WebkitMask: l
    };
    t.s(["getDefaultValueType", 0, t => p[t]], 446094);
    let f = () => ({
            translate: 0,
            scale: 1,
            origin: 0,
            originPoint: 0
        }),
        v = () => ({
            min: 0,
            max: 0
        });
    t.s(["createBox", 0, () => ({
        x: v(),
        y: v()
    }), "createDelta", 0, () => ({
        x: f(),
        y: f()
    })], 107952)
}, 828397, t => {
    "use strict";
    t.s(["isMotionValue", 0, t => !!(t && t.getVelocity)])
}, 152983, t => {
    "use strict";
    let e = new Set(["width", "height", "top", "left", "right", "bottom", ...t.i(870691).transformPropOrder]);
    t.s(["positionalKeys", 0, e])
}, 854260, 950158, t => {
    "use strict";
    var e = t.i(383119),
        i = t.i(960847);
    let s = t => e => e.test(t);
    t.s(["testValueType", 0, s], 950158);
    let n = [e.number, i.px, i.percent, i.degrees, i.vw, i.vh, {
        test: t => "auto" === t,
        parse: t => t
    }];
    t.s(["dimensionValueTypes", 0, n, "findDimensionValueType", 0, t => n.find(s(t))], 854260)
}, 451258, t => {
    "use strict";
    t.i(284553).default, t.s(["invariant", 0, () => {}, "warning", 0, () => {}], 451258)
}, 667148, t => {
    "use strict";
    t.s(["isNumericalString", 0, t => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t)])
}, 426882, t => {
    "use strict";
    let e = t => e => "string" == typeof e && e.startsWith(t),
        i = e("--"),
        s = e("var(--"),
        n = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
    t.s(["containsCSSVariable", 0, function(t) {
        return "string" == typeof t && t.split("/*")[0].includes("var(--")
    }, "isCSSVariableName", 0, i, "isCSSVariableToken", 0, t => !!s(t) && n.test(t.split("/*")[0].trim())])
}, 441743, t => {
    "use strict";
    var e = t.i(451258),
        i = t.i(667148),
        s = t.i(426882);
    let n = /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u;
    t.s(["getVariableValue", 0, function t(r, a, o = 1) {
        (0, e.invariant)(o <= 4, `Max CSS variable fallback depth detected in property "${r}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
        let [l, u] = function(t) {
            let e = n.exec(t);
            if (!e) return [, ];
            let [, i, s, r] = e;
            return [`--${i??s}`, r]
        }(r);
        if (!l) return;
        let h = window.getComputedStyle(a).getPropertyValue(l);
        if (h) {
            let t = h.trim();
            return (0, i.isNumericalString)(t) ? parseFloat(t) : t
        }
        return (0, s.isCSSVariableToken)(u) ? t(u, a, o + 1) : u
    }])
}, 882777, 166833, t => {
    "use strict";
    t.s(["fillWildcards", 0, function(t) {
        for (let e = 1; e < t.length; e++) t[e] ? ? (t[e] = t[e - 1])
    }], 882777);
    let e = t => 180 * t / Math.PI,
        i = t => n(e(Math.atan2(t[1], t[0]))),
        s = {
            x: 4,
            y: 5,
            translateX: 4,
            translateY: 5,
            scaleX: 0,
            scaleY: 3,
            scale: t => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
            rotate: i,
            rotateZ: i,
            skewX: t => e(Math.atan(t[1])),
            skewY: t => e(Math.atan(t[2])),
            skew: t => (Math.abs(t[1]) + Math.abs(t[2])) / 2
        },
        n = t => ((t %= 360) < 0 && (t += 360), t),
        r = t => Math.sqrt(t[0] * t[0] + t[1] * t[1]),
        a = t => Math.sqrt(t[4] * t[4] + t[5] * t[5]),
        o = {
            x: 12,
            y: 13,
            z: 14,
            translateX: 12,
            translateY: 13,
            translateZ: 14,
            scaleX: r,
            scaleY: a,
            scale: t => (r(t) + a(t)) / 2,
            rotateX: t => n(e(Math.atan2(t[6], t[5]))),
            rotateY: t => n(e(Math.atan2(-t[2], t[0]))),
            rotateZ: i,
            rotate: i,
            skewX: t => e(Math.atan(t[4])),
            skewY: t => e(Math.atan(t[1])),
            skew: t => (Math.abs(t[1]) + Math.abs(t[4])) / 2
        };

    function l(t) {
        return +!!t.includes("scale")
    }

    function u(t, e) {
        let i, n;
        if (!t || "none" === t) return l(e);
        let r = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
        if (r) i = o, n = r;
        else {
            let e = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
            i = s, n = e
        }
        if (!n) return l(e);
        let a = i[e],
            u = n[1].split(",").map(h);
        return "function" == typeof a ? a(u) : u[a]
    }

    function h(t) {
        return parseFloat(t.trim())
    }
    t.s(["defaultTransformValue", 0, l, "parseValueFromTransform", 0, u, "readTransformValue", 0, (t, e) => {
        let {
            transform: i = "none"
        } = getComputedStyle(t);
        return u(i, e)
    }], 166833)
}, 88012, t => {
    "use strict";
    var e = t.i(166833),
        i = t.i(870691),
        s = t.i(383119),
        n = t.i(960847);
    let r = new Set(["x", "y", "z"]),
        a = i.transformPropOrder.filter(t => !r.has(t)),
        o = {
            width: ({
                x: t
            }, {
                paddingLeft: e = "0",
                paddingRight: i = "0",
                boxSizing: s
            }) => {
                let n = t.max - t.min;
                return "border-box" === s ? n : n - parseFloat(e) - parseFloat(i)
            },
            height: ({
                y: t
            }, {
                paddingTop: e = "0",
                paddingBottom: i = "0",
                boxSizing: s
            }) => {
                let n = t.max - t.min;
                return "border-box" === s ? n : n - parseFloat(e) - parseFloat(i)
            },
            top: (t, {
                top: e
            }) => parseFloat(e),
            left: (t, {
                left: e
            }) => parseFloat(e),
            bottom: ({
                y: t
            }, {
                top: e
            }) => parseFloat(e) + (t.max - t.min),
            right: ({
                x: t
            }, {
                left: e
            }) => parseFloat(e) + (t.max - t.min),
            x: (t, {
                transform: i
            }) => (0, e.parseValueFromTransform)(i, "x"),
            y: (t, {
                transform: i
            }) => (0, e.parseValueFromTransform)(i, "y")
        };
    o.translateX = o.x, o.translateY = o.y, t.s(["isNumOrPxType", 0, t => t === s.number || t === n.px, "positionalValues", 0, o, "removeNonTranslationalTransform", 0, function(t) {
        let e = [];
        return a.forEach(i => {
            let s = t.getValue(i);
            void 0 !== s && (e.push([i, s.get()]), s.set(+!!i.startsWith("scale")))
        }), e
    }])
}, 363831, t => {
    "use strict";
    t.s(["noop", 0, t => t])
}, 628346, t => {
    "use strict";
    t.s(["MotionGlobalConfig", 0, {}])
}, 839589, 968909, 398638, t => {
    "use strict";
    var e = t.i(363831),
        i = t.i(628346);
    let s = ["setup", "read", "resolveKeyframes", "preUpdate", "update", "preRender", "render", "postRender"],
        n = {
            value: null,
            addProjectionMetrics: null
        };

    function r(t, e) {
        let r = !1,
            a = !0,
            o = {
                delta: 0,
                timestamp: 0,
                isProcessing: !1
            },
            l = () => r = !0,
            u = s.reduce((t, i) => (t[i] = function(t, e) {
                let i = new Set,
                    s = new Set,
                    r = !1,
                    a = !1,
                    o = new WeakSet,
                    l = {
                        delta: 0,
                        timestamp: 0,
                        isProcessing: !1
                    },
                    u = 0;

                function h(e) {
                    o.has(e) && (c.schedule(e), t()), u++, e(l)
                }
                let c = {
                    schedule: (t, e = !1, n = !1) => {
                        let a = n && r ? i : s;
                        return e && o.add(t), a.add(t), t
                    },
                    cancel: t => {
                        s.delete(t), o.delete(t)
                    },
                    process: t => {
                        if (l = t, r) {
                            a = !0;
                            return
                        }
                        r = !0;
                        let o = i;
                        i = s, s = o, i.forEach(h), e && n.value && n.value.frameloop[e].push(u), u = 0, i.clear(), r = !1, a && (a = !1, c.process(t))
                    }
                };
                return c
            }(l, e ? i : void 0), t), {}),
            {
                setup: h,
                read: c,
                resolveKeyframes: d,
                preUpdate: m,
                update: p,
                preRender: f,
                render: v,
                postRender: g
            } = u,
            y = () => {
                let s = i.MotionGlobalConfig.useManualTiming,
                    n = s ? o.timestamp : performance.now();
                r = !1, s || (o.delta = a ? 1e3 / 60 : Math.max(Math.min(n - o.timestamp, 40), 1)), o.timestamp = n, o.isProcessing = !0, h.process(o), c.process(o), d.process(o), m.process(o), p.process(o), f.process(o), v.process(o), g.process(o), o.isProcessing = !1, r && e && (a = !1, t(y))
            };
        return {
            schedule: s.reduce((e, i) => {
                let s = u[i];
                return e[i] = (e, i = !1, n = !1) => (!r && (r = !0, a = !0, o.isProcessing || t(y)), s.schedule(e, i, n)), e
            }, {}),
            cancel: t => {
                for (let e = 0; e < s.length; e++) u[s[e]].cancel(t)
            },
            state: o,
            steps: u
        }
    }
    t.s(["statsBuffer", 0, n], 968909), t.s(["createRenderBatcher", 0, r], 398638);
    let {
        schedule: a,
        cancel: o,
        state: l,
        steps: u
    } = r("u" > typeof requestAnimationFrame ? requestAnimationFrame : e.noop, !0);
    t.s(["cancelFrame", 0, o, "frame", 0, a, "frameData", 0, l, "frameSteps", 0, u], 839589)
}, 592018, t => {
    "use strict";
    var e = t.i(882777),
        i = t.i(88012),
        s = t.i(839589);
    let n = new Set,
        r = !1,
        a = !1,
        o = !1;

    function l() {
        if (a) {
            let t = Array.from(n).filter(t => t.needsMeasurement),
                e = new Set(t.map(t => t.element)),
                s = new Map;
            e.forEach(t => {
                let e = (0, i.removeNonTranslationalTransform)(t);
                e.length && (s.set(t, e), t.render())
            }), t.forEach(t => t.measureInitialState()), e.forEach(t => {
                t.render();
                let e = s.get(t);
                e && e.forEach(([e, i]) => {
                    t.getValue(e) ? .set(i)
                })
            }), t.forEach(t => t.measureEndState()), t.forEach(t => {
                void 0 !== t.suspendedScrollY && window.scrollTo(0, t.suspendedScrollY)
            })
        }
        a = !1, r = !1, n.forEach(t => t.complete(o)), n.clear()
    }

    function u() {
        n.forEach(t => {
            t.readKeyframes(), t.needsMeasurement && (a = !0)
        })
    }
    t.s(["KeyframeResolver", 0, class {
        constructor(t, e, i, s, n, r = !1) {
            this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...t], this.onComplete = e, this.name = i, this.motionValue = s, this.element = n, this.isAsync = r
        }
        scheduleResolve() {
            this.state = "scheduled", this.isAsync ? (n.add(this), r || (r = !0, s.frame.read(u), s.frame.resolveKeyframes(l))) : (this.readKeyframes(), this.complete())
        }
        readKeyframes() {
            let {
                unresolvedKeyframes: t,
                name: i,
                element: s,
                motionValue: n
            } = this;
            if (null === t[0]) {
                let e = n ? .get(),
                    r = t[t.length - 1];
                if (void 0 !== e) t[0] = e;
                else if (s && i) {
                    let e = s.readValue(i, r);
                    null != e && (t[0] = e)
                }
                void 0 === t[0] && (t[0] = r), n && void 0 === e && n.set(t[0])
            }(0, e.fillWildcards)(t)
        }
        setFinalKeyframe() {}
        measureInitialState() {}
        renderEndStyles() {}
        measureEndState() {}
        complete(t = !1) {
            this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, t), n.delete(this)
        }
        cancel() {
            "scheduled" === this.state && (n.delete(this), this.state = "pending")
        }
        resume() {
            "pending" === this.state && this.scheduleResolve()
        }
    }, "flushKeyframeResolvers", 0, function() {
        o = !0, u(), l(), o = !1
    }])
}, 67775, 343945, 15259, t => {
    "use strict";
    var e = t.i(152983),
        i = t.i(854260),
        s = t.i(441743),
        n = t.i(426882),
        r = t.i(592018);
    let a = t => /^0[^.\s]+$/u.test(t);
    t.s(["isZeroValueString", 0, a], 343945);
    var o = t.i(401828),
        l = t.i(55698),
        u = t.i(514010),
        h = t.i(446094);
    let c = new Set([l.filter, u.mask]);

    function d(t, e) {
        let i = (0, h.getDefaultValueType)(t);
        return c.has(i) || (i = o.complex), i.getAnimatableNone ? i.getAnimatableNone(e) : void 0
    }
    t.s(["getAnimatableNone", 0, d], 15259);
    let m = new Set(["auto", "none", "0"]);
    var p = t.i(88012);
    class f extends r.KeyframeResolver {
        constructor(t, e, i, s, n) {
            super(t, e, i, s, n, !0)
        }
        readKeyframes() {
            let {
                unresolvedKeyframes: t,
                element: r,
                name: a
            } = this;
            if (!r || !r.current) return;
            super.readKeyframes();
            for (let e = 0; e < t.length; e++) {
                let i = t[e];
                if ("string" == typeof i && (i = i.trim(), (0, n.isCSSVariableToken)(i))) {
                    let n = (0, s.getVariableValue)(i, r.current);
                    void 0 !== n && (t[e] = n), e === t.length - 1 && (this.finalKeyframe = i)
                }
            }
            if (this.resolveNoneKeyframes(), !e.positionalKeys.has(a) || 2 !== t.length) return;
            let [o, l] = t, u = (0, i.findDimensionValueType)(o), h = (0, i.findDimensionValueType)(l);
            if ((0, n.containsCSSVariable)(o) !== (0, n.containsCSSVariable)(l) && p.positionalValues[a]) {
                this.needsMeasurement = !0;
                return
            }
            if (u !== h)
                if ((0, p.isNumOrPxType)(u) && (0, p.isNumOrPxType)(h))
                    for (let e = 0; e < t.length; e++) {
                        let i = t[e];
                        "string" == typeof i && (t[e] = parseFloat(i))
                    } else p.positionalValues[a] && (this.needsMeasurement = !0)
        }
        resolveNoneKeyframes() {
            let {
                unresolvedKeyframes: t,
                name: e
            } = this, i = [];
            for (let e = 0; e < t.length; e++) {
                var s;
                (null === t[e] || ("number" == typeof(s = t[e]) ? 0 === s : null === s || "none" === s || "0" === s || a(s))) && i.push(e)
            }
            i.length && function(t, e, i) {
                let s, n = 0;
                for (; n < t.length && !s;) {
                    let e = t[n];
                    "string" == typeof e && !m.has(e) && (0, o.analyseComplexValue)(e).values.length && (s = t[n]), n++
                }
                if (s && i)
                    for (let n of e) t[n] = d(i, s)
            }(t, i, e)
        }
        measureInitialState() {
            let {
                element: t,
                unresolvedKeyframes: e,
                name: i
            } = this;
            if (!t || !t.current) return;
            "height" === i && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = p.positionalValues[i](t.measureViewportBox(), window.getComputedStyle(t.current)), e[0] = this.measuredOrigin;
            let s = e[e.length - 1];
            void 0 !== s && t.getValue(i, s).jump(s, !1)
        }
        measureEndState() {
            let {
                element: t,
                name: e,
                unresolvedKeyframes: i
            } = this;
            if (!t || !t.current) return;
            let s = t.getValue(e);
            s && s.jump(this.measuredOrigin, !1);
            let n = i.length - 1,
                r = i[n];
            i[n] = p.positionalValues[e](t.measureViewportBox(), window.getComputedStyle(t.current)), null !== r && void 0 === this.finalKeyframe && (this.finalKeyframe = r), this.removedTransforms ? .length && this.removedTransforms.forEach(([e, i]) => {
                t.getValue(e).set(i)
            }), this.resolveNoneKeyframes()
        }
    }
    t.s(["DOMKeyframesResolver", 0, f], 67775)
}, 648400, t => {
    "use strict";
    t.s(["millisecondsToSeconds", 0, t => t / 1e3, "secondsToMilliseconds", 0, t => 1e3 * t])
}, 906097, 522120, t => {
    "use strict";

    function e(t, e) {
        -1 === t.indexOf(e) && t.push(e)
    }

    function i(t, e) {
        let i = t.indexOf(e);
        i > -1 && t.splice(i, 1)
    }
    t.s(["addUniqueItem", 0, e, "removeItem", 0, i], 522120), t.s(["SubscriptionManager", 0, class {
        constructor() {
            this.subscriptions = []
        }
        add(t) {
            return e(this.subscriptions, t), () => i(this.subscriptions, t)
        }
        notify(t, e, i) {
            let s = this.subscriptions.length;
            if (s)
                if (1 === s) this.subscriptions[0](t, e, i);
                else
                    for (let n = 0; n < s; n++) {
                        let s = this.subscriptions[n];
                        s && s(t, e, i)
                    }
        }
        getSize() {
            return this.subscriptions.length
        }
        clear() {
            this.subscriptions.length = 0
        }
    }], 906097)
}, 961708, 443203, 979519, 719131, t => {
    "use strict";

    function e(t) {
        let e;
        return () => (void 0 === e && (e = t()), e)
    }
    t.s(["setStyle", 0, function(t, e, i) {
        e.startsWith("--") ? t.style.setProperty(e, i) : t.style[e] = i
    }], 961708), t.s(["memo", 0, e], 443203);
    let i = {};

    function s(t, s) {
        let n = e(t);
        return () => i[s] ? ? n()
    }
    t.s(["memoSupports", 0, s], 979519);
    let n = s(() => void 0 !== window.ScrollTimeline, "scrollTimeline"),
        r = s(() => void 0 !== window.ViewTimeline, "viewTimeline");
    t.s(["supportsScrollTimeline", 0, n, "supportsViewTimeline", 0, r], 719131)
}, 525745, t => {
    "use strict";
    let e = t => null !== t;
    t.s(["getFinalKeyframe", 0, function(t, {
        repeat: i,
        repeatType: s = "loop"
    }, n, r = 1) {
        let a = t.filter(e),
            o = r < 0 || i && "loop" !== s && i % 2 == 1 ? 0 : a.length - 1;
        return o && void 0 !== n ? n : a[o]
    }])
}, 41967, t => {
    "use strict";
    t.s(["WithPromise", 0, class {
        constructor() {
            this.updateFinished()
        }
        get finished() {
            return this._finished
        }
        updateFinished() {
            this._finished = new Promise(t => {
                this.resolve = t
            })
        }
        notifyFinished() {
            this.resolve()
        }
        then(t, e) {
            return this.finished.then(t, e)
        }
    }])
}, 859798, t => {
    "use strict";
    t.s(["activeAnimations", 0, {
        layout: 0,
        mainThread: 0,
        waapi: 0
    }])
}, 9372, t => {
    "use strict";
    t.s(["isBezierDefinition", 0, t => Array.isArray(t) && "number" == typeof t[0]])
}, 195609, t => {
    "use strict";
    let e = (0, t.i(979519).memoSupports)(() => {
        try {
            document.createElement("div").animate({
                opacity: 0
            }, {
                easing: "linear(0, 1)"
            })
        } catch (t) {
            return !1
        }
        return !0
    }, "linearEasing");
    t.s(["supportsLinearEasing", 0, e])
}, 33522, t => {
    "use strict";
    t.s(["generateLinearEasing", 0, (t, e, i = 10) => {
        let s = "",
            n = Math.max(Math.round(e / i), 2);
        for (let e = 0; e < n; e++) s += Math.round(1e4 * t(e / (n - 1))) / 1e4 + ", ";
        return `linear(${s.substring(0,s.length-2)})`
    }])
}, 966549, t => {
    "use strict";
    var e = t.i(859798),
        i = t.i(968909),
        s = t.i(9372),
        n = t.i(195609),
        r = t.i(33522);
    let a = ([t, e, i, s]) => `cubic-bezier(${t}, ${e}, ${i}, ${s})`,
        o = {
            linear: "linear",
            ease: "ease",
            easeIn: "ease-in",
            easeOut: "ease-out",
            easeInOut: "ease-in-out",
            circIn: a([0, .65, .55, 1]),
            circOut: a([.55, 0, 1, .45]),
            backIn: a([.31, .01, .66, -.59]),
            backOut: a([.33, 1.53, .69, .99])
        };
    t.s(["startWaapiAnimation", 0, function(t, l, u, {
        delay: h = 0,
        duration: c = 300,
        repeat: d = 0,
        repeatType: m = "loop",
        ease: p = "easeOut",
        times: f
    } = {}, v) {
        let g = {
            [l]: u
        };
        f && (g.offset = f);
        let y = function t(e, i) {
            if (e) return "function" == typeof e ? (0, n.supportsLinearEasing)() ? (0, r.generateLinearEasing)(e, i) : "ease-out" : (0, s.isBezierDefinition)(e) ? a(e) : Array.isArray(e) ? e.map(e => t(e, i) || o.easeOut) : o[e]
        }(p, c);
        Array.isArray(y) && (g.easing = y), i.statsBuffer.value && e.activeAnimations.waapi++;
        let x = {
            delay: h,
            duration: c,
            easing: Array.isArray(y) ? "linear" : y,
            fill: "both",
            iterations: d + 1,
            direction: "reverse" === m ? "alternate" : "normal"
        };
        v && (x.pseudoElement = v);
        let T = t.animate(g, x);
        return i.statsBuffer.value && T.finished.finally(() => {
            e.activeAnimations.waapi--
        }), T
    }], 966549)
}, 94855, t => {
    "use strict";
    t.s(["isGenerator", 0, function(t) {
        return "function" == typeof t && "applyToOptions" in t
    }])
}, 569047, t => {
    "use strict";
    var e = t.i(451258),
        i = t.i(648400),
        s = t.i(363831),
        n = t.i(961708),
        r = t.i(719131),
        a = t.i(525745),
        o = t.i(41967),
        l = t.i(966549),
        u = t.i(195609),
        h = t.i(94855);
    class c extends o.WithPromise {
        constructor(t) {
            if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !t) return;
            const {
                element: i,
                name: s,
                keyframes: r,
                pseudoElement: o,
                allowFlatten: c = !1,
                finalKeyframe: d,
                onComplete: m
            } = t;
            this.isPseudoElement = !!o, this.allowFlatten = c, this.options = t, (0, e.invariant)("string" != typeof t.type, 'Mini animate() doesn\'t support "type" as a string.', "mini-spring");
            const p = function({
                type: t,
                ...e
            }) {
                return (0, h.isGenerator)(t) && (0, u.supportsLinearEasing)() ? t.applyToOptions(e) : (e.duration ? ? (e.duration = 300), e.ease ? ? (e.ease = "easeOut"), e)
            }(t);
            this.animation = (0, l.startWaapiAnimation)(i, s, r, p, o), !1 === p.autoplay && this.animation.pause(), this.animation.onfinish = () => {
                if (this.finishedTime = this.time, !o) {
                    let t = (0, a.getFinalKeyframe)(r, this.options, d, this.speed);
                    this.updateMotionValue && this.updateMotionValue(t), (0, n.setStyle)(i, s, t), this.animation.cancel()
                }
                m ? .(), this.notifyFinished()
            }
        }
        play() {
            this.isStopped || (this.manualStartTime = null, this.animation.play(), "finished" === this.state && this.updateFinished())
        }
        pause() {
            this.animation.pause()
        }
        complete() {
            this.animation.finish ? .()
        }
        cancel() {
            try {
                this.animation.cancel()
            } catch (t) {}
        }
        stop() {
            if (this.isStopped) return;
            this.isStopped = !0;
            let {
                state: t
            } = this;
            "idle" !== t && "finished" !== t && (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel())
        }
        commitStyles() {
            let t = this.options ? .element;
            !this.isPseudoElement && t ? .isConnected && this.animation.commitStyles ? .()
        }
        get duration() {
            let t = this.animation.effect ? .getComputedTiming ? .().duration || 0;
            return (0, i.millisecondsToSeconds)(Number(t))
        }
        get iterationDuration() {
            let {
                delay: t = 0
            } = this.options || {};
            return this.duration + (0, i.millisecondsToSeconds)(t)
        }
        get time() {
            return (0, i.millisecondsToSeconds)(Number(this.animation.currentTime) || 0)
        }
        set time(t) {
            let e = null !== this.finishedTime;
            this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = (0, i.secondsToMilliseconds)(t), e && this.animation.pause()
        }
        get speed() {
            return this.animation.playbackRate
        }
        set speed(t) {
            t < 0 && (this.finishedTime = null), this.animation.playbackRate = t
        }
        get state() {
            return null !== this.finishedTime ? "finished" : this.animation.playState
        }
        get startTime() {
            return this.manualStartTime ? ? Number(this.animation.startTime)
        }
        set startTime(t) {
            this.manualStartTime = this.animation.startTime = t
        }
        attachTimeline({
            timeline: t,
            rangeStart: e,
            rangeEnd: i,
            observe: n
        }) {
            return (this.allowFlatten && this.animation.effect ? .updateTiming({
                easing: "linear"
            }), this.animation.onfinish = null, t && (0, r.supportsScrollTimeline)()) ? (this.animation.timeline = t, e && (this.animation.rangeStart = e), i && (this.animation.rangeEnd = i), s.noop) : n(this)
        }
    }
    t.s(["NativeAnimation", 0, c], 569047)
}, 902514, t => {
    "use strict";
    let e = new Set(["opacity", "clipPath", "filter", "transform"]);
    t.s(["acceleratedValues", 0, e])
}, 705647, t => {
    "use strict";
    let {
        schedule: e
    } = (0, t.i(398638).createRenderBatcher)(queueMicrotask, !1);
    t.s(["microtask", 0, e])
}, 569659, t => {
    "use strict";
    let e;
    var i = t.i(628346),
        s = t.i(839589);

    function n() {
        e = void 0
    }
    let r = {
        now: () => (void 0 === e && r.set(s.frameData.isProcessing || i.MotionGlobalConfig.useManualTiming ? s.frameData.timestamp : performance.now()), e),
        set: t => {
            e = t, queueMicrotask(n)
        }
    };
    t.s(["time", 0, r])
}, 73004, t => {
    "use strict";
    t.s(["velocityPerSecond", 0, function(t, e) {
        return e ? 1e3 / e * t : 0
    }])
}, 520415, t => {
    "use strict";
    var e = t.i(906097),
        i = t.i(73004),
        s = t.i(569659),
        n = t.i(839589);
    let r = {
        current: void 0
    };
    class a {
        constructor(t, e = {}) {
            this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = t => {
                let e = s.time.now();
                if (this.updatedAt !== e && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(t), this.current !== this.prev && (this.events.change ? .notify(this.current), this.dependents))
                    for (let t of this.dependents) t.dirty()
            }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner
        }
        setCurrent(t) {
            this.current = t, this.updatedAt = s.time.now(), null === this.canTrackVelocity && void 0 !== t && (this.canTrackVelocity = !isNaN(parseFloat(this.current)))
        }
        setPrevFrameValue(t = this.current) {
            this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt
        }
        onChange(t) {
            return this.on("change", t)
        }
        on(t, i) {
            this.events[t] || (this.events[t] = new e.SubscriptionManager);
            let s = this.events[t].add(i);
            return "change" === t ? () => {
                s(), n.frame.read(() => {
                    this.events.change.getSize() || this.stop()
                })
            } : s
        }
        clearListeners() {
            for (let t in this.events) this.events[t].clear()
        }
        attach(t, e) {
            this.passiveEffect = t, this.stopPassiveEffect = e
        }
        set(t) {
            this.passiveEffect ? this.passiveEffect(t, this.updateAndNotify) : this.updateAndNotify(t)
        }
        setWithVelocity(t, e, i) {
            this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - i
        }
        jump(t, e = !0) {
            this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, e && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect()
        }
        dirty() {
            this.events.change ? .notify(this.current)
        }
        addDependent(t) {
            this.dependents || (this.dependents = new Set), this.dependents.add(t)
        }
        removeDependent(t) {
            this.dependents && this.dependents.delete(t)
        }
        get() {
            return r.current && r.current.push(this), this.current
        }
        getPrevious() {
            return this.prev
        }
        getVelocity() {
            let t = s.time.now();
            if (!this.canTrackVelocity || void 0 === this.prevFrameValue || t - this.updatedAt > 30) return 0;
            let e = Math.min(this.updatedAt - this.prevUpdatedAt, 30);
            return (0, i.velocityPerSecond)(parseFloat(this.current) - parseFloat(this.prevFrameValue), e)
        }
        start(t) {
            return this.stop(), new Promise(e => {
                this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify()
            }).then(() => {
                this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation()
            })
        }
        stop() {
            this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation()
        }
        isAnimating() {
            return !!this.animation
        }
        clearAnimation() {
            delete this.animation
        }
        destroy() {
            this.dependents ? .clear(), this.events.destroy ? .notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect()
        }
    }
    t.s(["collectMotionValues", 0, r, "motionValue", 0, function(t, e) {
        return new a(t, e)
    }])
}, 753728, t => {
    "use strict";
    var e = t.i(23642),
        i = t.i(401828),
        s = t.i(854260),
        n = t.i(950158);
    let r = [...s.dimensionValueTypes, e.color, i.complex];
    t.s(["findValueType", 0, t => r.find((0, n.testValueType)(t))])
}, 874013, t => {
    "use strict";
    let e = new WeakMap;
    t.s(["visualElementStore", 0, e])
}, 633223, 956705, 320636, 52435, 164032, t => {
    "use strict";

    function e(t) {
        return null !== t && "object" == typeof t && "function" == typeof t.start
    }

    function i(t) {
        return "string" == typeof t || Array.isArray(t)
    }
    t.s(["isAnimationControls", 0, e], 956705), t.s(["isVariantLabel", 0, i], 320636);
    let s = ["animate", "whileInView", "whileFocus", "whileHover", "whileTap", "whileDrag", "exit"],
        n = ["initial", ...s];

    function r(t) {
        return e(t.animate) || n.some(e => i(t[e]))
    }
    t.s(["variantPriorityOrder", 0, s, "variantProps", 0, n], 52435), t.s(["isControllingVariants", 0, r, "isVariantNode", 0, function(t) {
        return !!(r(t) || t.variants)
    }], 633223);
    var a = t.i(520415),
        o = t.i(828397);
    t.s(["updateMotionValuesFromProps", 0, function(t, e, i) {
        for (let s in e) {
            let n = e[s],
                r = i[s];
            if ((0, o.isMotionValue)(n)) t.addValue(s, n);
            else if ((0, o.isMotionValue)(r)) t.addValue(s, (0, a.motionValue)(n, {
                owner: t
            }));
            else if (r !== n)
                if (t.hasValue(s)) {
                    let e = t.getValue(s);
                    !0 === e.liveStyle ? e.jump(n) : e.hasAnimated || e.set(n)
                } else {
                    let e = t.getStaticValue(s);
                    t.addValue(s, (0, a.motionValue)(void 0 !== e ? e : n, {
                        owner: t
                    }))
                }
        }
        for (let s in i) void 0 === e[s] && t.removeValue(s);
        return e
    }], 164032)
}, 710918, 644362, t => {
    "use strict";
    let e = {
            current: null
        },
        i = {
            current: !1
        };
    t.s(["hasReducedMotionListener", 0, i, "prefersReducedMotion", 0, e], 644362);
    let s = "u" > typeof window;
    t.s(["initPrefersReducedMotion", 0, function() {
        if (i.current = !0, s)
            if (window.matchMedia) {
                let t = window.matchMedia("(prefers-reduced-motion)"),
                    i = () => e.current = t.matches;
                t.addEventListener("change", i), i()
            } else e.current = !1
    }], 710918)
}, 301833, t => {
    "use strict";

    function e(t) {
        let e = [{}, {}];
        return t ? .values.forEach((t, i) => {
            e[0][i] = t.get(), e[1][i] = t.getVelocity()
        }), e
    }
    t.s(["resolveVariantFromProps", 0, function(t, i, s, n) {
        if ("function" == typeof i) {
            let [r, a] = e(n);
            i = i(void 0 !== s ? s : t.custom, r, a)
        }
        if ("string" == typeof i && (i = t.variants && t.variants[i]), "function" == typeof i) {
            let [r, a] = e(n);
            i = i(void 0 !== s ? s : t.custom, r, a)
        }
        return i
    }])
}, 236792, 742397, t => {
    "use strict";
    var e = t.i(828397),
        i = t.i(67775);
    t.i(284553);
    var s = t.i(648400),
        n = t.i(667148),
        r = t.i(343945),
        a = t.i(906097),
        o = t.i(592018),
        l = t.i(569047),
        u = t.i(902514),
        h = t.i(705647),
        c = t.i(569659),
        d = t.i(107952),
        m = t.i(520415),
        p = t.i(401828),
        f = t.i(15259),
        v = t.i(753728),
        g = t.i(874013),
        y = t.i(633223),
        x = t.i(870691),
        T = t.i(164032),
        b = t.i(710918),
        S = t.i(301833),
        w = t.i(644362),
        P = t.i(839589);
    let V = ["AnimationStart", "AnimationComplete", "Update", "BeforeLayoutMeasure", "LayoutMeasure", "LayoutAnimationStart", "LayoutAnimationComplete"],
        M = {};
    class A {
        scrapeMotionValuesFromProps(t, e, i) {
            return {}
        }
        constructor({
            parent: t,
            props: i,
            presenceContext: s,
            reducedMotionConfig: n,
            skipAnimations: r,
            blockInitialAnimation: a,
            visualState: l
        }, u = {}) {
            this.current = null, this.children = new Set, this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.shouldSkipAnimations = !1, this.values = new Map, this.KeyframeResolver = o.KeyframeResolver, this.features = {}, this.valueSubscriptions = new Map, this.prevMotionValues = {}, this.hasBeenMounted = !1, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
                this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection))
            }, this.renderScheduledAt = 0, this.scheduleRender = () => {
                let t = c.time.now();
                this.renderScheduledAt < t && (this.renderScheduledAt = t, P.frame.render(this.render, !1, !0))
            };
            const {
                latestValues: h,
                renderState: d
            } = l;
            this.latestValues = h, this.baseTarget = { ...h
            }, this.initialValues = i.initial ? { ...h
            } : {}, this.renderState = d, this.parent = t, this.props = i, this.presenceContext = s, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = n, this.skipAnimationsConfig = r, this.options = u, this.blockInitialAnimation = !!a, this.isControllingVariants = (0, y.isControllingVariants)(i), this.isVariantNode = (0, y.isVariantNode)(i), this.isVariantNode && (this.variantChildren = new Set), this.manuallyAnimateOnMount = !!(t && t.current);
            const {
                willChange: m,
                ...p
            } = this.scrapeMotionValuesFromProps(i, {}, this);
            for (const t in p) {
                const i = p[t];
                void 0 !== h[t] && (0, e.isMotionValue)(i) && i.set(h[t])
            }
        }
        mount(t) {
            if (this.hasBeenMounted)
                for (let t in this.initialValues) this.values.get(t) ? .jump(this.initialValues[t]), this.latestValues[t] = this.initialValues[t];
            this.current = t, g.visualElementStore.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((t, e) => this.bindToMotionValue(e, t)), "never" === this.reducedMotionConfig ? this.shouldReduceMotion = !1 : "always" === this.reducedMotionConfig ? this.shouldReduceMotion = !0 : (w.hasReducedMotionListener.current || (0, b.initPrefersReducedMotion)(), this.shouldReduceMotion = w.prefersReducedMotion.current), this.shouldSkipAnimations = this.skipAnimationsConfig ? ? !1, this.parent ? .addChild(this), this.update(this.props, this.presenceContext), this.hasBeenMounted = !0
        }
        unmount() {
            for (let t in this.projection && this.projection.unmount(), (0, P.cancelFrame)(this.notifyUpdate), (0, P.cancelFrame)(this.render), this.valueSubscriptions.forEach(t => t()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent ? .removeChild(this), this.events) this.events[t].clear();
            for (let t in this.features) {
                let e = this.features[t];
                e && (e.unmount(), e.isMounted = !1)
            }
            this.current = null
        }
        addChild(t) {
            this.children.add(t), this.enteringChildren ? ? (this.enteringChildren = new Set), this.enteringChildren.add(t)
        }
        removeChild(t) {
            this.children.delete(t), this.enteringChildren && this.enteringChildren.delete(t)
        }
        bindToMotionValue(t, e) {
            let i;
            if (this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)(), e.accelerate && u.acceleratedValues.has(t) && this.current instanceof HTMLElement) {
                let {
                    factory: i,
                    keyframes: n,
                    times: r,
                    ease: a,
                    duration: o
                } = e.accelerate, u = new l.NativeAnimation({
                    element: this.current,
                    name: t,
                    keyframes: n,
                    times: r,
                    ease: a,
                    duration: (0, s.secondsToMilliseconds)(o)
                }), h = i(u);
                this.valueSubscriptions.set(t, () => {
                    h(), u.cancel()
                });
                return
            }
            let n = x.transformProps.has(t);
            n && this.onBindTransform && this.onBindTransform();
            let r = e.on("change", e => {
                this.latestValues[t] = e, this.props.onUpdate && P.frame.preRender(this.notifyUpdate), n && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender()
            });
            "u" > typeof window && window.MotionCheckAppearSync && (i = window.MotionCheckAppearSync(this, t, e)), this.valueSubscriptions.set(t, () => {
                r(), i && i(), e.owner && e.stop()
            })
        }
        sortNodePosition(t) {
            return this.current && this.sortInstanceNodePosition && this.type === t.type ? this.sortInstanceNodePosition(this.current, t.current) : 0
        }
        updateFeatures() {
            let t = "animation";
            for (t in M) {
                let e = M[t];
                if (!e) continue;
                let {
                    isEnabled: i,
                    Feature: s
                } = e;
                if (!this.features[t] && s && i(this.props) && (this.features[t] = new s(this)), this.features[t]) {
                    let e = this.features[t];
                    e.isMounted ? e.update() : (e.mount(), e.isMounted = !0)
                }
            }
        }
        triggerBuild() {
            this.build(this.renderState, this.latestValues, this.props)
        }
        measureViewportBox() {
            return this.current ? this.measureInstanceViewportBox(this.current, this.props) : (0, d.createBox)()
        }
        getStaticValue(t) {
            return this.latestValues[t]
        }
        setStaticValue(t, e) {
            this.latestValues[t] = e
        }
        update(t, e) {
            (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = e;
            for (let e = 0; e < V.length; e++) {
                let i = V[e];
                this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
                let s = t["on" + i];
                s && (this.propEventSubscriptions[i] = this.on(i, s))
            }
            this.prevMotionValues = (0, T.updateMotionValuesFromProps)(this, this.scrapeMotionValuesFromProps(t, this.prevProps || {}, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue()
        }
        getProps() {
            return this.props
        }
        getVariant(t) {
            return this.props.variants ? this.props.variants[t] : void 0
        }
        getDefaultTransition() {
            return this.props.transition
        }
        getTransformPagePoint() {
            return this.props.transformPagePoint
        }
        getClosestVariantNode() {
            return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0
        }
        addVariantChild(t) {
            let e = this.getClosestVariantNode();
            if (e) return e.variantChildren && e.variantChildren.add(t), () => e.variantChildren.delete(t)
        }
        addValue(t, e) {
            let i = this.values.get(t);
            e !== i && (i && this.removeValue(t), this.bindToMotionValue(t, e), this.values.set(t, e), this.latestValues[t] = e.get())
        }
        removeValue(t) {
            this.values.delete(t);
            let e = this.valueSubscriptions.get(t);
            e && (e(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState)
        }
        hasValue(t) {
            return this.values.has(t)
        }
        getValue(t, e) {
            if (this.props.values && this.props.values[t]) return this.props.values[t];
            let i = this.values.get(t);
            return void 0 === i && void 0 !== e && (i = (0, m.motionValue)(null === e ? void 0 : e, {
                owner: this
            }), this.addValue(t, i)), i
        }
        readValue(t, i) {
            let s = void 0 === this.latestValues[t] && this.current ? this.getBaseTargetFromProps(this.props, t) ? ? this.readValueFromInstance(this.current, t, this.options) : this.latestValues[t];
            return null != s && ("string" == typeof s && ((0, n.isNumericalString)(s) || (0, r.isZeroValueString)(s)) ? s = parseFloat(s) : !(0, v.findValueType)(s) && p.complex.test(i) && (s = (0, f.getAnimatableNone)(t, i)), this.setBaseTarget(t, (0, e.isMotionValue)(s) ? s.get() : s)), (0, e.isMotionValue)(s) ? s.get() : s
        }
        setBaseTarget(t, e) {
            this.baseTarget[t] = e
        }
        getBaseTarget(t) {
            let i, {
                initial: s
            } = this.props;
            if ("string" == typeof s || "object" == typeof s) {
                let e = (0, S.resolveVariantFromProps)(this.props, s, this.presenceContext ? .custom);
                e && (i = e[t])
            }
            if (s && void 0 !== i) return i;
            let n = this.getBaseTargetFromProps(this.props, t);
            return void 0 === n || (0, e.isMotionValue)(n) ? void 0 !== this.initialValues[t] && void 0 === i ? void 0 : this.baseTarget[t] : n
        }
        on(t, e) {
            return this.events[t] || (this.events[t] = new a.SubscriptionManager), this.events[t].add(e)
        }
        notify(t, ...e) {
            this.events[t] && this.events[t].notify(...e)
        }
        scheduleRenderMicrotask() {
            h.microtask.render(this.render)
        }
    }
    t.s(["VisualElement", 0, A, "getFeatureDefinitions", 0, function() {
        return M
    }, "setFeatureDefinitions", 0, function(t) {
        M = t
    }], 742397), t.s(["DOMVisualElement", 0, class extends A {
        constructor() {
            super(...arguments), this.KeyframeResolver = i.DOMKeyframesResolver
        }
        sortInstanceNodePosition(t, e) {
            return 2 & t.compareDocumentPosition(e) ? 1 : -1
        }
        getBaseTargetFromProps(t, e) {
            let i = t.style;
            return i ? i[e] : void 0
        }
        removeValueFromRenderState(t, {
            vars: e,
            style: i
        }) {
            delete e[t], delete i[t]
        }
        handleChildMotionValue() {
            this.childSubscription && (this.childSubscription(), delete this.childSubscription);
            let {
                children: t
            } = this.props;
            (0, e.isMotionValue)(t) && (this.childSubscription = t.on("change", t => {
                this.current && (this.current.textContent = `${t}`)
            }))
        }
    }], 236792)
}, 907050, t => {
    "use strict";
    t.s(["camelToDash", 0, function(t) {
        return t.replace(/([A-Z])/g, t => `-${t.toLowerCase()}`)
    }])
}, 445515, 156701, 124301, 745192, 216060, 521613, 839912, t => {
    "use strict";
    let e = (t, e) => e && "number" == typeof t ? e.transform(t) : t;
    var i = t.i(568774),
        s = t.i(870691),
        n = t.i(426882);
    let r = {
            x: "translateX",
            y: "translateY",
            z: "translateZ",
            transformPerspective: "perspective"
        },
        a = s.transformPropOrder.length;

    function o(t, o, l) {
        let {
            style: u,
            vars: h,
            transformOrigin: c
        } = t, d = !1, m = !1;
        for (let t in o) {
            let r = o[t];
            if (s.transformProps.has(t)) {
                d = !0;
                continue
            }
            if ((0, n.isCSSVariableName)(t)) {
                h[t] = r;
                continue
            } {
                let s = e(r, i.numberValueTypes[t]);
                t.startsWith("origin") ? (m = !0, c[t] = s) : u[t] = s
            }
        }
        if (!o.transform && (d || l ? u.transform = function(t, n, o) {
                let l = "",
                    u = !0;
                for (let h = 0; h < a; h++) {
                    let a = s.transformPropOrder[h],
                        c = t[a];
                    if (void 0 === c) continue;
                    let d = !0;
                    if ("number" == typeof c) d = c === +!!a.startsWith("scale");
                    else {
                        let t = parseFloat(c);
                        d = a.startsWith("scale") ? 1 === t : 0 === t
                    }
                    if (!d || o) {
                        let t = e(c, i.numberValueTypes[a]);
                        if (!d) {
                            u = !1;
                            let e = r[a] || a;
                            l += `${e}(${t}) `
                        }
                        o && (n[a] = t)
                    }
                }
                return l = l.trim(), o ? l = o(n, u ? "" : l) : u && (l = "none"), l
            }(o, t.transform, l) : u.transform && (u.transform = "none")), m) {
            let {
                originX: t = "50%",
                originY: e = "50%",
                originZ: i = 0
            } = c;
            u.transformOrigin = `${t} ${e} ${i}`
        }
    }
    t.s(["buildHTMLStyles", 0, o], 156701);
    let l = {
            offset: "stroke-dashoffset",
            array: "stroke-dasharray"
        },
        u = {
            offset: "strokeDashoffset",
            array: "strokeDasharray"
        },
        h = ["offsetDistance", "offsetPath", "offsetRotate", "offsetAnchor"];
    t.s(["buildSVGAttrs", 0, function(t, {
        attrX: e,
        attrY: i,
        attrScale: s,
        pathLength: n,
        pathSpacing: r = 1,
        pathOffset: a = 0,
        ...c
    }, d, m, p) {
        if (o(t, c, m), d) {
            t.style.viewBox && (t.attrs.viewBox = t.style.viewBox);
            return
        }
        t.attrs = t.style, t.style = {};
        let {
            attrs: f,
            style: v
        } = t;
        for (let t of (f.transform && (v.transform = f.transform, delete f.transform), (v.transform || f.transformOrigin) && (v.transformOrigin = f.transformOrigin ? ? "50% 50%", delete f.transformOrigin), v.transform && (v.transformBox = p ? .transformBox ? ? "fill-box", delete f.transformBox), h)) void 0 !== f[t] && (v[t] = f[t], delete f[t]);
        void 0 !== e && (f.x = e), void 0 !== i && (f.y = i), void 0 !== s && (f.scale = s), void 0 !== n && function(t, e, i = 1, s = 0, n = !0) {
            t.pathLength = 1;
            let r = n ? l : u;
            t[r.offset] = `${-s}`, t[r.array] = `${e} ${i}`
        }(f, n, r, a, !1)
    }], 445515);
    let c = new Set(["baseFrequency", "diffuseConstant", "kernelMatrix", "kernelUnitLength", "keySplines", "keyTimes", "limitingConeAngle", "markerHeight", "markerWidth", "numOctaves", "targetX", "targetY", "surfaceScale", "specularConstant", "specularExponent", "stdDeviation", "tableValues", "viewBox", "gradientTransform", "pathLength", "startOffset", "textLength", "lengthAdjust"]);
    t.s(["camelCaseAttributes", 0, c], 124301), t.s(["isSVGTag", 0, t => "string" == typeof t && "svg" === t.toLowerCase()], 745192);
    var d = t.i(907050);

    function m(t, {
        style: e,
        vars: i
    }, s, n) {
        let r, a = t.style;
        for (r in e) a[r] = e[r];
        for (r in n ? .applyProjectionStyles(a, s), i) a.setProperty(r, i[r])
    }
    t.s(["renderHTML", 0, m], 216060), t.s(["renderSVG", 0, function(t, e, i, s) {
        for (let i in m(t, e, void 0, s), e.attrs) t.setAttribute(c.has(i) ? i : (0, d.camelToDash)(i), e.attrs[i])
    }], 521613);
    var p = t.i(960847);

    function f(t, e) {
        return e.max === e.min ? 0 : t / (e.max - e.min) * 100
    }
    let v = {
        correct: (t, e) => {
            if (!e.target) return t;
            if ("string" == typeof t)
                if (!p.px.test(t)) return t;
                else t = parseFloat(t);
            let i = f(t, e.target.x),
                s = f(t, e.target.y);
            return `${i}% ${s}%`
        }
    };
    t.s(["correctBorderRadius", 0, v], 839912)
}, 509667, t => {
    "use strict";
    t.s(["mixNumber", 0, (t, e, i) => t + (e - t) * i])
}, 764667, 511572, 832671, 120069, 454745, 678611, 223138, 715426, 638822, 382983, 435099, 395466, t => {
    "use strict";
    var e = t.i(870691),
        i = t.i(446094),
        s = t.i(107952),
        n = t.i(236792),
        r = t.i(907050),
        a = t.i(445515),
        o = t.i(124301),
        l = t.i(745192),
        u = t.i(521613),
        h = t.i(828397),
        c = t.i(426882),
        d = t.i(839912),
        m = t.i(401828),
        p = t.i(509667);
    let f = {
        borderRadius: { ...d.correctBorderRadius,
            applyTo: ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius"]
        },
        borderTopLeftRadius: d.correctBorderRadius,
        borderTopRightRadius: d.correctBorderRadius,
        borderBottomLeftRadius: d.correctBorderRadius,
        borderBottomRightRadius: d.correctBorderRadius,
        boxShadow: {
            correct: (t, {
                treeScale: e,
                projectionDelta: i
            }) => {
                let s = m.complex.parse(t);
                if (s.length > 5) return t;
                let n = m.complex.createTransformer(t),
                    r = +("number" != typeof s[0]),
                    a = i.x.scale * e.x,
                    o = i.y.scale * e.y;
                s[0 + r] /= a, s[1 + r] /= o;
                let l = (0, p.mixNumber)(a, o, .5);
                return "number" == typeof s[2 + r] && (s[2 + r] /= l), "number" == typeof s[3 + r] && (s[3 + r] /= l), n(s)
            }
        }
    };

    function v(t, {
        layout: i,
        layoutId: s
    }) {
        return e.transformProps.has(t) || t.startsWith("origin") || (i || void 0 !== s) && (!!f[t] || "opacity" === t)
    }

    function g(t, e, i) {
        let s = t.style,
            n = e ? .style,
            r = {};
        if (!s) return r;
        for (let e in s)((0, h.isMotionValue)(s[e]) || n && (0, h.isMotionValue)(n[e]) || v(e, t) || i ? .getValue(e) ? .liveStyle !== void 0) && (r[e] = s[e]);
        return r
    }

    function y(t, i, s) {
        let n = g(t, i, s);
        for (let s in t)((0, h.isMotionValue)(t[s]) || (0, h.isMotionValue)(i[s])) && (n[-1 !== e.transformPropOrder.indexOf(s) ? "attr" + s.charAt(0).toUpperCase() + s.substring(1) : s] = t[s]);
        return n
    }
    t.s(["scaleCorrectors", 0, f], 511572), t.s(["isForcedMotionValue", 0, v], 832671), t.s(["scrapeMotionValuesFromProps", 0, g], 120069), t.s(["scrapeMotionValuesFromProps", 0, y], 454745);
    class x extends n.DOMVisualElement {
        constructor() {
            super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = s.createBox
        }
        getBaseTargetFromProps(t, e) {
            return t[e]
        }
        readValueFromInstance(t, s) {
            if (e.transformProps.has(s)) {
                let t = (0, i.getDefaultValueType)(s);
                return t && t.default || 0
            }
            return s = o.camelCaseAttributes.has(s) ? s : (0, r.camelToDash)(s), t.getAttribute(s)
        }
        scrapeMotionValuesFromProps(t, e, i) {
            return y(t, e, i)
        }
        build(t, e, i) {
            (0, a.buildSVGAttrs)(t, e, this.isSVGTag, i.transformTemplate, i.style)
        }
        renderInstance(t, e, i, s) {
            (0, u.renderSVG)(t, e, i, s)
        }
        mount(t) {
            this.isSVGTag = (0, l.isSVGTag)(t.tagName), super.mount(t)
        }
    }
    t.s(["SVGVisualElement", 0, x], 678611);
    var T = t.i(166833);

    function b({
        top: t,
        left: e,
        right: i,
        bottom: s
    }) {
        return {
            x: {
                min: e,
                max: i
            },
            y: {
                min: t,
                max: s
            }
        }
    }

    function S(t, e) {
        if (!e) return t;
        let i = e({
                x: t.left,
                y: t.top
            }),
            s = e({
                x: t.right,
                y: t.bottom
            });
        return {
            top: i.y,
            left: i.x,
            bottom: s.y,
            right: s.x
        }
    }

    function w(t) {
        return void 0 === t || 1 === t
    }

    function P({
        scale: t,
        scaleX: e,
        scaleY: i
    }) {
        return !w(t) || !w(e) || !w(i)
    }

    function V(t) {
        return P(t) || M(t) || t.z || t.rotate || t.rotateX || t.rotateY || t.skewX || t.skewY
    }

    function M(t) {
        var e, i;
        return (e = t.x) && "0%" !== e || (i = t.y) && "0%" !== i
    }
    t.s(["convertBoundingBoxToBox", 0, b, "convertBoxToBoundingBox", 0, function({
        x: t,
        y: e
    }) {
        return {
            top: e.min,
            right: t.max,
            bottom: e.max,
            left: t.min
        }
    }, "transformBoxPoints", 0, S], 223138);

    function A(t, e, i) {
        return i + e * (t - i)
    }

    function E(t, e, i, s, n) {
        return void 0 !== n && (t = A(t, n, s)), A(t, i, s) + e
    }

    function C(t, e = 0, i = 1, s, n) {
        t.min = E(t.min, e, i, s, n), t.max = E(t.max, e, i, s, n)
    }

    function D(t, {
        x: e,
        y: i
    }) {
        C(t.x, e.translate, e.scale, e.originPoint), C(t.y, i.translate, i.scale, i.originPoint)
    }

    function k(t, e) {
        t.min += e, t.max += e
    }

    function R(t, e, i, s, n = .5) {
        let r = (0, p.mixNumber)(t.min, t.max, n);
        C(t, e, i, r, s)
    }

    function L(t, e) {
        return "string" == typeof t ? parseFloat(t) / 100 * (e.max - e.min) : t
    }

    function B(t, e, i) {
        let s = i ? ? t;
        R(t.x, L(e.x, s.x), e.scaleX, e.scale, e.originX), R(t.y, L(e.y, s.y), e.scaleY, e.scale, e.originY)
    }

    function F(t, e) {
        return b(S(t.getBoundingClientRect(), e))
    }
    t.s(["has2DTranslate", 0, M, "hasScale", 0, P, "hasTransform", 0, V], 715426), t.s(["applyBoxDelta", 0, D, "applyTreeDeltas", 0, function(t, e, i, s = !1) {
        let n, r, a = i.length;
        if (a) {
            e.x = e.y = 1;
            for (let o = 0; o < a; o++) {
                r = (n = i[o]).projectionDelta;
                let {
                    visualElement: a
                } = n.options;
                (!a || !a.props.style || "contents" !== a.props.style.display) && (s && n.options.layoutScroll && n.scroll && n !== n.root && (k(t.x, -n.scroll.offset.x), k(t.y, -n.scroll.offset.y)), r && (e.x *= r.x.scale, e.y *= r.y.scale, D(t, r)), s && V(n.latestValues) && B(t, n.latestValues, n.layout ? .layoutBox))
            }
            e.x < 1.0000000000001 && e.x > .999999999999 && (e.x = 1), e.y < 1.0000000000001 && e.y > .999999999999 && (e.y = 1)
        }
    }, "scalePoint", 0, A, "transformBox", 0, B, "translateAxis", 0, k], 638822), t.s(["measurePageBox", 0, function(t, e, i) {
        let s = F(t, i),
            {
                scroll: n
            } = e;
        return n && (k(s.x, n.offset.x), k(s.y, n.offset.y)), s
    }, "measureViewportBox", 0, F], 382983);
    var O = n,
        j = t.i(156701),
        I = t.i(216060);
    class N extends O.DOMVisualElement {
        constructor() {
            super(...arguments), this.type = "html", this.renderInstance = I.renderHTML
        }
        readValueFromInstance(t, i) {
            if (e.transformProps.has(i)) return this.projection ? .isProjecting ? (0, T.defaultTransformValue)(i) : (0, T.readTransformValue)(t, i); {
                let e = window.getComputedStyle(t),
                    s = ((0, c.isCSSVariableName)(i) ? e.getPropertyValue(i) : e[i]) || 0;
                return "string" == typeof s ? s.trim() : s
            }
        }
        measureInstanceViewportBox(t, {
            transformPagePoint: e
        }) {
            return F(t, e)
        }
        build(t, e, i) {
            (0, j.buildHTMLStyles)(t, e, i.transformTemplate)
        }
        scrapeMotionValuesFromProps(t, e, i) {
            return g(t, e, i)
        }
    }
    t.s(["HTMLVisualElement", 0, N], 435099);
    var U = t.i(416340);
    let W = ["animate", "circle", "defs", "desc", "ellipse", "g", "image", "line", "filter", "marker", "mask", "metadata", "path", "pattern", "polygon", "polyline", "rect", "stop", "switch", "symbol", "svg", "text", "tspan", "use", "view"];

    function G(t) {
        if ("string" != typeof t || t.includes("-"));
        else if (W.indexOf(t) > -1 || /[A-Z]/u.test(t)) return !0;
        return !1
    }
    t.s(["isSVGComponent", 0, G], 395466), t.s(["createDomVisualElement", 0, (t, e) => e.isSVG ? ? G(t) ? new x(e) : new N(e, {
        allowProjection: t !== U.Fragment
    })], 764667)
}, 618941, t => {
    "use strict";
    let e = (0, t.i(416340).createContext)({
        strict: !1
    });
    t.s(["LazyContext", 0, e])
}, 313940, 118411, 198682, 634084, 175865, 152912, 98829, 327454, t => {
    "use strict";
    var e = t.i(416340);
    let i = (0, e.createContext)({});
    t.s(["MotionContext", 0, i], 313940);
    var s = t.i(633223),
        n = t.i(320636);

    function r(t) {
        return Array.isArray(t) ? t.join(" ") : t
    }
    t.s(["useCreateMotionContext", 0, function(t) {
        let {
            initial: a,
            animate: o
        } = function(t, e) {
            if ((0, s.isControllingVariants)(t)) {
                let {
                    initial: e,
                    animate: i
                } = t;
                return {
                    initial: !1 === e || (0, n.isVariantLabel)(e) ? e : void 0,
                    animate: (0, n.isVariantLabel)(i) ? i : void 0
                }
            }
            return !1 !== t.inherit ? e : {}
        }(t, (0, e.useContext)(i));
        return (0, e.useMemo)(() => ({
            initial: a,
            animate: o
        }), [r(a), r(o)])
    }], 118411);
    var a = t.i(828397),
        o = t.i(832671),
        l = t.i(156701);
    let u = () => ({
        style: {},
        transform: {},
        transformOrigin: {},
        vars: {}
    });

    function h(t, e, i) {
        for (let s in e)(0, a.isMotionValue)(e[s]) || (0, o.isForcedMotionValue)(s, i) || (t[s] = e[s])
    }
    t.s(["createHtmlRenderState", 0, u], 198682);
    var c = t.i(445515),
        d = t.i(745192);
    let m = () => ({ ...u(),
        attrs: {}
    });
    t.s(["createSvgRenderState", 0, m], 634084);
    let p = new Set(["animate", "exit", "variants", "initial", "style", "values", "variants", "transition", "transformTemplate", "custom", "inherit", "onBeforeLayoutMeasure", "onAnimationStart", "onAnimationComplete", "onUpdate", "onDragStart", "onDrag", "onDragEnd", "onMeasureDragConstraints", "onDirectionLock", "onDragTransitionEnd", "_dragX", "_dragY", "onHoverStart", "onHoverEnd", "onViewportEnter", "onViewportLeave", "globalTapTarget", "propagate", "ignoreStrict", "viewport"]);

    function f(t) {
        return t.startsWith("while") || t.startsWith("drag") && "draggable" !== t || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || p.has(t)
    }
    let v = t => !f(t);

    function g(t) {
        "function" == typeof t && (v = e => e.startsWith("on") ? !f(e) : t(e))
    }
    try {
        g((() => {
            let t = Error("Cannot find module '@emotion/is-prop-valid'");
            throw t.code = "MODULE_NOT_FOUND", t
        })().default)
    } catch {}

    function y(t, e, i) {
        let s = {};
        for (let n in t)("values" !== n || "object" != typeof t.values) && !(0, a.isMotionValue)(t[n]) && (v(n) || !0 === i && f(n) || !e && !f(n) || t.draggable && n.startsWith("onDrag")) && (s[n] = t[n]);
        return s
    }
    t.s(["filterProps", 0, y, "loadExternalIsValidProp", 0, g], 175865);
    var x = t.i(395466);
    t.s(["useRender", 0, function(t, i, s, {
        latestValues: n
    }, r, o = !1, p) {
        let f = (p ? ? (0, x.isSVGComponent)(t) ? function(t, i, s, n) {
                let r = (0, e.useMemo)(() => {
                    let e = m();
                    return (0, c.buildSVGAttrs)(e, i, (0, d.isSVGTag)(n), t.transformTemplate, t.style), { ...e.attrs,
                        style: { ...e.style
                        }
                    }
                }, [i]);
                if (t.style) {
                    let e = {};
                    h(e, t.style, t), r.style = { ...e,
                        ...r.style
                    }
                }
                return r
            } : function(t, i) {
                let s, n, r = {},
                    a = (s = t.style || {}, h(n = {}, s, t), Object.assign(n, function({
                        transformTemplate: t
                    }, i) {
                        return (0, e.useMemo)(() => {
                            let e = u();
                            return (0, l.buildHTMLStyles)(e, i, t), Object.assign({}, e.vars, e.style)
                        }, [i])
                    }(t, i)), n);
                return t.drag && !1 !== t.dragListener && (r.draggable = !1, a.userSelect = a.WebkitUserSelect = a.WebkitTouchCallout = "none", a.touchAction = !0 === t.drag ? "none" : `pan-${"x"===t.drag?"y":"x"}`), void 0 === t.tabIndex && (t.onTap || t.onTapStart || t.whileTap) && (r.tabIndex = 0), r.style = a, r
            })(i, n, r, t),
            v = y(i, "string" == typeof t, o),
            g = t !== e.Fragment ? { ...v,
                ...f,
                ref: s
            } : {},
            {
                children: T
            } = i,
            b = (0, e.useMemo)(() => (0, a.isMotionValue)(T) ? T.get() : T, [T]);
        return (0, e.createElement)(t, { ...g,
            children: b
        })
    }], 152912);
    var T = t.i(120069);
    t.s(["scrapeHTMLMotionValuesFromProps", () => T.scrapeMotionValuesFromProps], 98829), t.s(["resolveMotionValue", 0, function(t) {
        return (0, a.isMotionValue)(t) ? t.get() : t
    }], 327454)
}, 895361, 368618, 651854, 767189, 416936, 275061, t => {
    "use strict";
    var e = t.i(98829),
        i = t.i(327454),
        s = t.i(633223),
        n = t.i(956705),
        r = t.i(301833),
        a = t.i(416340),
        o = t.i(313940),
        l = t.i(62682),
        u = t.i(583730);
    let h = t => (e, h) => {
        let c = (0, a.useContext)(o.MotionContext),
            d = (0, a.useContext)(l.PresenceContext),
            m = () => (function({
                scrapeMotionValuesFromProps: t,
                createRenderState: e
            }, a, o, l) {
                return {
                    latestValues: function(t, e, a, o) {
                        let l = {},
                            u = o(t, {});
                        for (let t in u) l[t] = (0, i.resolveMotionValue)(u[t]);
                        let {
                            initial: h,
                            animate: c
                        } = t, d = (0, s.isControllingVariants)(t), m = (0, s.isVariantNode)(t);
                        e && m && !d && !1 !== t.inherit && (void 0 === h && (h = e.initial), void 0 === c && (c = e.animate));
                        let p = !!a && !1 === a.initial,
                            f = (p = p || !1 === h) ? c : h;
                        if (f && "boolean" != typeof f && !(0, n.isAnimationControls)(f)) {
                            let e = Array.isArray(f) ? f : [f];
                            for (let i = 0; i < e.length; i++) {
                                let s = (0, r.resolveVariantFromProps)(t, e[i]);
                                if (s) {
                                    let {
                                        transitionEnd: t,
                                        transition: e,
                                        ...i
                                    } = s;
                                    for (let t in i) {
                                        let e = i[t];
                                        if (Array.isArray(e)) {
                                            let t = p ? e.length - 1 : 0;
                                            e = e[t]
                                        }
                                        null !== e && (l[t] = e)
                                    }
                                    for (let e in t) l[e] = t[e]
                                }
                            }
                        }
                        return l
                    }(a, o, l, t),
                    renderState: e()
                }
            })(t, e, c, d);
        return h ? m() : (0, u.useConstant)(m)
    };
    var c = t.i(198682);
    let d = h({
        scrapeMotionValuesFromProps: e.scrapeHTMLMotionValuesFromProps,
        createRenderState: c.createHtmlRenderState
    });
    t.s(["useHTMLVisualState", 0, d], 895361);
    var m = t.i(454745),
        m = m,
        p = t.i(634084);
    let f = h({
        scrapeMotionValuesFromProps: m.scrapeMotionValuesFromProps,
        createRenderState: p.createSvgRenderState
    });
    t.s(["useSVGVisualState", 0, f], 368618);
    var v = t.i(742397);
    let g = {
            animation: ["animate", "variants", "whileHover", "whileTap", "exit", "whileInView", "whileFocus", "whileDrag"],
            exit: ["exit"],
            drag: ["drag", "dragControls"],
            focus: ["whileFocus"],
            hover: ["whileHover", "onHoverStart", "onHoverEnd"],
            tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
            pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
            inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
            layout: ["layout", "layoutId"]
        },
        y = !1;

    function x() {
        return ! function() {
            if (y) return;
            let t = {};
            for (let e in g) t[e] = {
                isEnabled: t => g[e].some(e => !!t[e])
            };
            (0, v.setFeatureDefinitions)(t), y = !0
        }(), (0, v.getFeatureDefinitions)()
    }
    t.s(["getInitializedFeatureDefinitions", 0, x], 651854), t.s(["loadFeatures", 0, function(t) {
        let e = x();
        for (let i in t) e[i] = { ...e[i],
            ...t[i]
        };
        (0, v.setFeatureDefinitions)(e)
    }], 767189);
    let T = Symbol.for("motionComponentSymbol");
    t.s(["motionComponentSymbol", 0, T], 416936), t.s(["useMotionRef", 0, function(t, e, i) {
        let s = (0, a.useRef)(i);
        (0, a.useInsertionEffect)(() => {
            s.current = i
        });
        let n = (0, a.useRef)(null);
        return (0, a.useCallback)(i => {
            i && t.onMount ? .(i);
            let r = s.current;
            if ("function" == typeof r)
                if (i) {
                    let t = r(i);
                    "function" == typeof t && (n.current = t)
                } else n.current ? (n.current(), n.current = null) : r(i);
            else r && (r.current = i);
            e && (i ? e.mount(i) : e.unmount())
        }, [e])
    }], 275061)
}, 822215, t => {
    "use strict";
    let e = "data-" + (0, t.i(907050).camelToDash)("framerAppearId");
    t.s(["optimizedAppearDataAttribute", 0, e])
}, 464140, 950196, t => {
    "use strict";
    let e = (0, t.i(416340).createContext)({});
    t.s(["SwitchLayoutGroupContext", 0, e], 464140), t.s(["isRefObject", 0, function(t) {
        return t && "object" == typeof t && Object.prototype.hasOwnProperty.call(t, "current")
    }], 950196)
}, 562862, 431424, t => {
    "use strict";
    t.i(284553);
    var e = t.i(221628),
        i = t.i(416340),
        s = t.i(262504),
        n = t.i(618941),
        r = t.i(20655),
        a = t.i(313940),
        o = t.i(118411),
        l = t.i(152912),
        u = t.i(395466),
        h = t.i(895361),
        c = t.i(368618),
        d = t.i(651854),
        m = t.i(767189),
        p = t.i(416936),
        f = t.i(275061),
        v = t.i(822215),
        g = t.i(62682),
        y = t.i(464140),
        x = t.i(950196),
        T = t.i(519825);

    function b(t, {
        forwardMotionProps: S = !1,
        type: w
    } = {}, P, V) {
        P && (0, m.loadFeatures)(P);
        let M = w ? "svg" === w : (0, u.isSVGComponent)(t),
            A = M ? c.useSVGVisualState : h.useHTMLVisualState;

        function E(u, h) {
            let c, m = { ...(0, i.useContext)(r.MotionConfigContext),
                    ...u,
                    layoutId: function({
                        layoutId: t
                    }) {
                        let e = (0, i.useContext)(s.LayoutGroupContext).id;
                        return e && void 0 !== t ? e + "-" + t : t
                    }(u)
                },
                {
                    isStatic: p
                } = m,
                b = (0, o.useCreateMotionContext)(u),
                w = A(u, p);
            if (!p && "u" > typeof window) {
                (0, i.useContext)(n.LazyContext).strict;
                let e = function(t) {
                    let {
                        drag: e,
                        layout: i
                    } = (0, d.getInitializedFeatureDefinitions)();
                    if (!e && !i) return {};
                    let s = { ...e,
                        ...i
                    };
                    return {
                        MeasureLayout: e ? .isEnabled(t) || i ? .isEnabled(t) ? s.MeasureLayout : void 0,
                        ProjectionNode: s.ProjectionNode
                    }
                }(m);
                c = e.MeasureLayout, b.visualElement = function(t, e, s, o, l, u) {
                    let {
                        visualElement: h
                    } = (0, i.useContext)(a.MotionContext), c = (0, i.useContext)(n.LazyContext), d = (0, i.useContext)(g.PresenceContext), m = (0, i.useContext)(r.MotionConfigContext), p = m.reducedMotion, f = m.skipAnimations, b = (0, i.useRef)(null), S = (0, i.useRef)(!1);
                    o = o || c.renderer, !b.current && o && (b.current = o(t, {
                        visualState: e,
                        parent: h,
                        props: s,
                        presenceContext: d,
                        blockInitialAnimation: !!d && !1 === d.initial,
                        reducedMotionConfig: p,
                        skipAnimations: f,
                        isSVG: u
                    }), S.current && b.current && (b.current.manuallyAnimateOnMount = !0));
                    let w = b.current,
                        P = (0, i.useContext)(y.SwitchLayoutGroupContext);
                    w && !w.projection && l && ("html" === w.type || "svg" === w.type) && function(t, e, i, s) {
                        let {
                            layoutId: n,
                            layout: r,
                            drag: a,
                            dragConstraints: o,
                            layoutScroll: l,
                            layoutRoot: u,
                            layoutAnchor: h,
                            layoutCrossfade: c
                        } = e;
                        t.projection = new i(t.latestValues, e["data-framer-portal-id"] ? void 0 : function t(e) {
                            if (e) return !1 !== e.options.allowProjection ? e.projection : t(e.parent)
                        }(t.parent)), t.projection.setOptions({
                            layoutId: n,
                            layout: r,
                            alwaysMeasureLayout: !!a || o && (0, x.isRefObject)(o),
                            visualElement: t,
                            animationType: "string" == typeof r ? r : "both",
                            initialPromotionConfig: s,
                            crossfade: c,
                            layoutScroll: l,
                            layoutRoot: u,
                            layoutAnchor: h
                        })
                    }(b.current, s, l, P);
                    let V = (0, i.useRef)(!1);
                    (0, i.useInsertionEffect)(() => {
                        w && V.current && w.update(s, d)
                    });
                    let M = s[v.optimizedAppearDataAttribute],
                        A = (0, i.useRef)(!!M && "u" > typeof window && !window.MotionHandoffIsComplete ? .(M) && window.MotionHasOptimisedAnimation ? .(M));
                    return (0, T.useIsomorphicLayoutEffect)(() => {
                        S.current = !0, w && (V.current = !0, window.MotionIsMounted = !0, w.updateFeatures(), w.scheduleRenderMicrotask(), A.current && w.animationState && w.animationState.animateChanges())
                    }), (0, i.useEffect)(() => {
                        w && (!A.current && w.animationState && w.animationState.animateChanges(), A.current && (queueMicrotask(() => {
                            window.MotionHandoffMarkAsComplete ? .(M)
                        }), A.current = !1), w.enteringChildren = void 0)
                    }), w
                }(t, w, m, V, e.ProjectionNode, M)
            }
            return (0, e.jsxs)(a.MotionContext.Provider, {
                value: b,
                children: [c && b.visualElement ? (0, e.jsx)(c, {
                    visualElement: b.visualElement,
                    ...m
                }) : null, (0, l.useRender)(t, u, (0, f.useMotionRef)(w, b.visualElement, h), w, p, S, M)]
            })
        }
        E.displayName = `motion.${"string"==typeof t?t:`create(${t.displayName??t.name??""})`}`;
        let C = (0, i.forwardRef)(E);
        return C[p.motionComponentSymbol] = t, C
    }
    t.s(["createMotionProxy", 0, function(t, e) {
        if ("u" < typeof Proxy) return b;
        let i = new Map,
            s = (i, s) => b(i, s, t, e);
        return new Proxy((t, e) => s(t, e), {
            get: (n, r) => "create" === r ? s : (i.has(r) || i.set(r, b(r, void 0, t, e)), i.get(r))
        })
    }], 562862), t.s(["Feature", 0, class {
        constructor(t) {
            this.isMounted = !1, this.node = t
        }
        update() {}
    }], 431424)
}, 436234, t => {
    "use strict";
    var e = t.i(301833);
    t.s(["resolveVariant", 0, function(t, i, s) {
        let n = t.getProps();
        return (0, e.resolveVariantFromProps)(n, i, void 0 !== s ? s : n.custom, t)
    }])
}, 752085, 743959, t => {
    "use strict";

    function e(t, e) {
        if (t ? .inherit && e) {
            let {
                inherit: i,
                ...s
            } = t;
            return { ...e,
                ...s
            }
        }
        return t
    }
    t.s(["resolveTransition", 0, e], 743959), t.s(["getValueTransition", 0, function(t, i) {
        let s = t ? .[i] ? ? t ? .default ? ? t;
        return s !== t ? e(s, t) : s
    }], 752085)
}, 399911, 848016, 339649, t => {
    "use strict";
    var e = t.i(520415),
        i = t.i(436234);
    let s = t => Array.isArray(t);
    t.s(["isKeyframesTarget", 0, s], 848016), t.s(["setTarget", 0, function(t, n) {
        let {
            transitionEnd: r = {},
            transition: a = {},
            ...o
        } = (0, i.resolveVariant)(t, n) || {};
        for (let i in o = { ...o,
                ...r
            }) {
            var l;
            let n = s(l = o[i]) ? l[l.length - 1] || 0 : l;
            t.hasValue(i) ? t.getValue(i).set(n) : t.addValue(i, (0, e.motionValue)(n))
        }
    }], 399911);
    var n = t.i(628346),
        r = t.i(828397);
    t.s(["addValueToWillChange", 0, function(t, e) {
        let i = t.getValue("willChange");
        if ((0, r.isMotionValue)(i) && i.add) return i.add(e);
        if (!i && n.MotionGlobalConfig.WillChange) {
            let i = new n.MotionGlobalConfig.WillChange("auto");
            t.addValue("willChange", i), i.add(e)
        }
    }], 339649)
}, 925612, t => {
    "use strict";
    var e = t.i(822215);
    t.s(["getOptimisedAppearId", 0, function(t) {
        return t.props[e.optimizedAppearDataAttribute]
    }])
}, 10968, t => {
    "use strict";
    let e = (t, e) => i => e(t(i));
    t.s(["pipe", 0, (...t) => t.reduce(e)])
}, 781028, 407297, t => {
    "use strict";
    var e = t.i(10968),
        i = t.i(451258),
        s = t.i(426882),
        n = t.i(23642),
        r = t.i(401828),
        a = t.i(336868),
        o = t.i(866031);

    function l(t, e, i) {
        return (i < 0 && (i += 1), i > 1 && (i -= 1), i < 1 / 6) ? t + (e - t) * 6 * i : i < .5 ? e : i < 2 / 3 ? t + (e - t) * (2 / 3 - i) * 6 : t
    }
    var u = t.i(144454);

    function h(t, e) {
        return i => i > 0 ? e : t
    }
    var c = t.i(509667);
    let d = (t, e, i) => {
            let s = t * t,
                n = i * (e * e - s) + s;
            return n < 0 ? 0 : Math.sqrt(n)
        },
        m = [a.hex, u.rgba, o.hsla];

    function p(t) {
        let e = m.find(e => e.test(t));
        if ((0, i.warning)(!!e, `'${t}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !e) return !1;
        let s = e.parse(t);
        return e === o.hsla && (s = function({
            hue: t,
            saturation: e,
            lightness: i,
            alpha: s
        }) {
            t /= 360, i /= 100;
            let n = 0,
                r = 0,
                a = 0;
            if (e /= 100) {
                let s = i < .5 ? i * (1 + e) : i + e - i * e,
                    o = 2 * i - s;
                n = l(o, s, t + 1 / 3), r = l(o, s, t), a = l(o, s, t - 1 / 3)
            } else n = r = a = i;
            return {
                red: Math.round(255 * n),
                green: Math.round(255 * r),
                blue: Math.round(255 * a),
                alpha: s
            }
        }(s)), s
    }
    let f = (t, e) => {
            let i = p(t),
                s = p(e);
            if (!i || !s) return h(t, e);
            let n = { ...i
            };
            return t => (n.red = d(i.red, s.red, t), n.green = d(i.green, s.green, t), n.blue = d(i.blue, s.blue, t), n.alpha = (0, c.mixNumber)(i.alpha, s.alpha, t), u.rgba.transform(n))
        },
        v = new Set(["none", "hidden"]);

    function g(t, e) {
        return i => (0, c.mixNumber)(t, e, i)
    }

    function y(t) {
        return "number" == typeof t ? g : "string" == typeof t ? (0, s.isCSSVariableToken)(t) ? h : n.color.test(t) ? f : b : Array.isArray(t) ? x : "object" == typeof t ? n.color.test(t) ? f : T : h
    }

    function x(t, e) {
        let i = [...t],
            s = i.length,
            n = t.map((t, i) => y(t)(t, e[i]));
        return t => {
            for (let e = 0; e < s; e++) i[e] = n[e](t);
            return i
        }
    }

    function T(t, e) {
        let i = { ...t,
                ...e
            },
            s = {};
        for (let n in i) void 0 !== t[n] && void 0 !== e[n] && (s[n] = y(t[n])(t[n], e[n]));
        return t => {
            for (let e in s) i[e] = s[e](t);
            return i
        }
    }
    let b = (t, s) => {
        let n = r.complex.createTransformer(s),
            a = (0, r.analyseComplexValue)(t),
            o = (0, r.analyseComplexValue)(s);
        if (!(a.indexes.var.length === o.indexes.var.length && a.indexes.color.length === o.indexes.color.length && a.indexes.number.length >= o.indexes.number.length)) return (0, i.warning)(!0, `Complex values '${t}' and '${s}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different"), h(t, s);
        if (v.has(t) && !o.values.length || v.has(s) && !a.values.length) return v.has(t) ? e => e <= 0 ? t : s : e => e >= 1 ? s : t;
        return (0, e.pipe)(x(function(t, e) {
            let i = [],
                s = {
                    color: 0,
                    var: 0,
                    number: 0
                };
            for (let n = 0; n < e.values.length; n++) {
                let r = e.types[n],
                    a = t.indexes[r][s[r]],
                    o = t.values[a] ? ? 0;
                i[n] = o, s[r]++
            }
            return i
        }(a, o), o.values), n)
    };
    t.s(["mix", 0, function(t, e, i) {
        return "number" == typeof t && "number" == typeof e && "number" == typeof i ? (0, c.mixNumber)(t, e, i) : y(t)(t, e)
    }], 781028);
    var S = t.i(569659),
        w = t.i(839589);
    t.s(["frameloopDriver", 0, t => {
        let e = ({
            timestamp: e
        }) => t(e);
        return {
            start: (t = !0) => w.frame.update(e, t),
            stop: () => (0, w.cancelFrame)(e),
            now: () => w.frameData.isProcessing ? w.frameData.timestamp : S.time.now()
        }
    }], 407297)
}, 516528, 231582, 976905, t => {
    "use strict";
    var e = t.i(648400),
        i = t.i(212344),
        s = t.i(451258),
        n = t.i(33522);

    function r(t) {
        let e = 0,
            i = t.next(e);
        for (; !i.done && e < 2e4;) e += 50, i = t.next(e);
        return e >= 2e4 ? 1 / 0 : e
    }

    function a(t, i = 100, s) {
        let n = s({ ...t,
                keyframes: [0, i]
            }),
            o = Math.min(r(n), 2e4);
        return {
            type: "keyframes",
            ease: t => n.next(o * t).value / i,
            duration: (0, e.millisecondsToSeconds)(o)
        }
    }
    t.s(["calcGeneratorDuration", 0, r, "maxGeneratorDuration", 0, 2e4], 231582), t.s(["createGeneratorEasing", 0, a], 976905);
    let o = .01,
        l = 2,
        u = .005,
        h = .5;

    function c(t, e) {
        return t * Math.sqrt(1 - e * e)
    }
    let d = ["duration", "bounce"],
        m = ["stiffness", "damping", "mass"];

    function p(t, e) {
        return e.some(e => void 0 !== t[e])
    }

    function f(t = .3, a = .3) {
        let v, g, y, x, T, b, S = "object" != typeof t ? {
                visualDuration: t,
                keyframes: [0, 1],
                bounce: a
            } : t,
            {
                restSpeed: w,
                restDelta: P
            } = S,
            V = S.keyframes[0],
            M = S.keyframes[S.keyframes.length - 1],
            A = {
                done: !1,
                value: V
            },
            {
                stiffness: E,
                damping: C,
                mass: D,
                duration: k,
                velocity: R,
                isResolvedFromDuration: L
            } = function(t) {
                let n = {
                    velocity: 0,
                    stiffness: 100,
                    damping: 10,
                    mass: 1,
                    isResolvedFromDuration: !1,
                    ...t
                };
                if (!p(t, m) && p(t, d))
                    if (n.velocity = 0, t.visualDuration) {
                        let e = 2 * Math.PI / (1.2 * t.visualDuration),
                            s = e * e,
                            r = 2 * (0, i.clamp)(.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(s);
                        n = { ...n,
                            mass: 1,
                            stiffness: s,
                            damping: r
                        }
                    } else {
                        let r = function({
                            duration: t = 800,
                            bounce: n = .3,
                            velocity: r = 0,
                            mass: a = 1
                        }) {
                            let o, l;
                            (0, s.warning)(t <= (0, e.secondsToMilliseconds)(10), "Spring duration must be 10 seconds or less", "spring-duration-limit");
                            let u = 1 - n;
                            u = (0, i.clamp)(.05, 1, u), t = (0, i.clamp)(.01, 10, (0, e.millisecondsToSeconds)(t)), u < 1 ? (o = e => {
                                let i = e * u,
                                    s = i * t;
                                return .001 - (i - r) / c(e, u) * Math.exp(-s)
                            }, l = e => {
                                let i = e * u * t,
                                    s = Math.pow(u, 2) * Math.pow(e, 2) * t,
                                    n = Math.exp(-i),
                                    a = c(Math.pow(e, 2), u);
                                return (i * r + r - s) * n * (-o(e) + .001 > 0 ? -1 : 1) / a
                            }) : (o = e => -.001 + Math.exp(-e * t) * ((e - r) * t + 1), l = e => t * t * (r - e) * Math.exp(-e * t));
                            let h = function(t, e, i) {
                                let s = i;
                                for (let i = 1; i < 12; i++) s -= t(s) / e(s);
                                return s
                            }(o, l, 5 / t);
                            if (t = (0, e.secondsToMilliseconds)(t), isNaN(h)) return {
                                stiffness: 100,
                                damping: 10,
                                duration: t
                            }; {
                                let e = Math.pow(h, 2) * a;
                                return {
                                    stiffness: e,
                                    damping: 2 * u * Math.sqrt(a * e),
                                    duration: t
                                }
                            }
                        }({ ...t,
                            velocity: 0
                        });
                        (n = { ...n,
                            ...r,
                            mass: 1
                        }).isResolvedFromDuration = !0
                    }
                return n
            }({ ...S,
                velocity: -(0, e.millisecondsToSeconds)(S.velocity || 0)
            }),
            B = R || 0,
            F = C / (2 * Math.sqrt(E * D)),
            O = M - V,
            j = (0, e.millisecondsToSeconds)(Math.sqrt(E / D)),
            I = 5 > Math.abs(O);
        if (w || (w = I ? o : l), P || (P = I ? u : h), F < 1) y = c(j, F), x = (B + F * j * O) / y, v = t => M - Math.exp(-F * j * t) * (x * Math.sin(y * t) + O * Math.cos(y * t)), T = F * j * x + O * y, b = F * j * O - x * y, g = t => Math.exp(-F * j * t) * (T * Math.sin(y * t) + b * Math.cos(y * t));
        else if (1 === F) {
            v = t => M - Math.exp(-j * t) * (O + (B + j * O) * t);
            let t = B + j * O;
            g = e => Math.exp(-j * e) * (j * t * e - B)
        } else {
            let t = j * Math.sqrt(F * F - 1);
            v = e => {
                let i = Math.exp(-F * j * e),
                    s = Math.min(t * e, 300);
                return M - i * ((B + F * j * O) * Math.sinh(s) + t * O * Math.cosh(s)) / t
            };
            let e = (B + F * j * O) / t,
                i = F * j * e - O * t,
                s = F * j * O - e * t;
            g = e => {
                let n = Math.exp(-F * j * e),
                    r = Math.min(t * e, 300);
                return n * (i * Math.sinh(r) + s * Math.cosh(r))
            }
        }
        let N = {
            calculatedDuration: L && k || null,
            velocity: t => (0, e.secondsToMilliseconds)(g(t)),
            next: t => {
                if (!L && F < 1) {
                    let i = Math.exp(-F * j * t),
                        s = Math.sin(y * t),
                        n = Math.cos(y * t),
                        r = M - i * (x * s + O * n);
                    return A.done = Math.abs((0, e.secondsToMilliseconds)(i * (T * s + b * n))) <= w && Math.abs(M - r) <= P, A.value = A.done ? M : r, A
                }
                let i = v(t);
                return L ? A.done = t >= k : A.done = Math.abs((0, e.secondsToMilliseconds)(g(t))) <= w && Math.abs(M - i) <= P, A.value = A.done ? M : i, A
            },
            toString: () => {
                let t = Math.min(r(N), 2e4),
                    e = (0, n.generateLinearEasing)(e => N.next(t * e).value, t, 30);
                return t + "ms " + e
            },
            toTransition: () => {}
        };
        return N
    }
    f.applyToOptions = t => {
        let i = a(t, 100, f);
        return t.ease = i.ease, t.duration = (0, e.secondsToMilliseconds)(i.duration), t.type = "keyframes", t
    }, t.s(["spring", 0, f], 516528)
}, 90500, 188119, 479399, 290878, t => {
    "use strict";
    var e = t.i(516528),
        i = t.i(73004);

    function s(t, e, s) {
        let n = Math.max(e - 5, 0);
        return (0, i.velocityPerSecond)(s - t(n), e - n)
    }
    t.s(["getGeneratorVelocity", 0, s], 188119), t.s(["inertia", 0, function({
        keyframes: t,
        velocity: i = 0,
        power: n = .8,
        timeConstant: r = 325,
        bounceDamping: a = 10,
        bounceStiffness: o = 500,
        modifyTarget: l,
        min: u,
        max: h,
        restDelta: c = .5,
        restSpeed: d
    }) {
        let m, p, f = t[0],
            v = {
                done: !1,
                value: f
            },
            g = n * i,
            y = f + g,
            x = void 0 === l ? y : l(y);
        x !== y && (g = x - f);
        let T = t => -g * Math.exp(-t / r),
            b = t => x + T(t),
            S = t => {
                let e = T(t),
                    i = b(t);
                v.done = Math.abs(e) <= c, v.value = v.done ? x : i
            },
            w = t => {
                let i;
                if (i = v.value, void 0 !== u && i < u || void 0 !== h && i > h) {
                    var n;
                    m = t, p = (0, e.spring)({
                        keyframes: [v.value, (n = v.value, void 0 === u ? h : void 0 === h || Math.abs(u - n) < Math.abs(h - n) ? u : h)],
                        velocity: s(b, t, v.value),
                        damping: a,
                        stiffness: o,
                        restDelta: c,
                        restSpeed: d
                    })
                }
            };
        return w(0), {
            calculatedDuration: null,
            next: t => {
                let e = !1;
                return (p || void 0 !== m || (e = !0, S(t), w(t)), void 0 !== m && t >= m) ? p.next(t - m) : (e || S(t), v)
            }
        }
    }], 90500);
    var n = t.i(363831);
    let r = (t, e, i) => (((1 - 3 * i + 3 * e) * t + (3 * i - 6 * e)) * t + 3 * e) * t;

    function a(t, e, i, s) {
        return t === e && i === s ? n.noop : n => 0 === n || 1 === n ? n : r(function(t, e, i, s, n) {
            let a, o, l = 0;
            do(a = r(o = e + (i - e) / 2, s, n) - t) > 0 ? i = o : e = o; while (Math.abs(a) > 1e-7 && ++l < 12) return o
        }(n, 0, 1, t, i), e, s)
    }
    t.s(["cubicBezier", 0, a], 479399);
    let o = a(.42, 0, 1, 1),
        l = a(0, 0, .58, 1),
        u = a(.42, 0, .58, 1);
    t.s(["easeIn", 0, o, "easeInOut", 0, u, "easeOut", 0, l], 290878)
}, 584346, t => {
    "use strict";
    t.s(["isEasingArray", 0, t => Array.isArray(t) && "number" != typeof t[0]])
}, 600754, 564113, 249767, t => {
    "use strict";
    var e = t.i(479399);
    let i = t => e => e <= .5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2,
        s = t => e => 1 - t(1 - e),
        n = (0, e.cubicBezier)(.33, 1.53, .69, .99),
        r = s(n),
        a = i(r);
    t.s(["backIn", 0, r, "backInOut", 0, a, "backOut", 0, n], 564113), t.s(["anticipate", 0, t => t >= 1 ? 1 : (t *= 2) < 1 ? .5 * r(t) : .5 * (2 - Math.pow(2, -10 * (t - 1)))], 600754);
    let o = t => 1 - Math.sin(Math.acos(t)),
        l = s(o),
        u = i(o);
    t.s(["circIn", 0, o, "circInOut", 0, u, "circOut", 0, l], 249767)
}, 516404, t => {
    "use strict";
    var e = t.i(451258),
        i = t.i(363831),
        s = t.i(600754),
        n = t.i(564113),
        r = t.i(249767),
        a = t.i(479399),
        o = t.i(290878),
        l = t.i(9372);
    let u = {
        linear: i.noop,
        easeIn: o.easeIn,
        easeInOut: o.easeInOut,
        easeOut: o.easeOut,
        circIn: r.circIn,
        circInOut: r.circInOut,
        circOut: r.circOut,
        backIn: n.backIn,
        backInOut: n.backInOut,
        backOut: n.backOut,
        anticipate: s.anticipate
    };
    t.s(["easingDefinitionToFunction", 0, t => {
        if ((0, l.isBezierDefinition)(t)) {
            (0, e.invariant)(4 === t.length, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
            let [i, s, n, r] = t;
            return (0, a.cubicBezier)(i, s, n, r)
        }
        return "string" == typeof t ? ((0, e.invariant)(void 0 !== u[t], `Invalid easing type '${t}'`, "invalid-easing-type"), u[t]) : t
    }])
}, 724820, t => {
    "use strict";
    t.s(["progress", 0, (t, e, i) => {
        let s = e - t;
        return 0 === s ? 1 : (i - t) / s
    }])
}, 529996, t => {
    "use strict";
    var e = t.i(451258),
        i = t.i(212344),
        s = t.i(628346),
        n = t.i(363831),
        r = t.i(10968),
        a = t.i(724820),
        o = t.i(781028);
    t.s(["interpolate", 0, function(t, l, {
        clamp: u = !0,
        ease: h,
        mixer: c
    } = {}) {
        let d = t.length;
        if ((0, e.invariant)(d === l.length, "Both input and output ranges must be the same length", "range-length"), 1 === d) return () => l[0];
        if (2 === d && l[0] === l[1]) return () => l[1];
        let m = t[0] === t[1];
        t[0] > t[d - 1] && (t = [...t].reverse(), l = [...l].reverse());
        let p = function(t, e, i) {
                let a = [],
                    l = i || s.MotionGlobalConfig.mix || o.mix,
                    u = t.length - 1;
                for (let i = 0; i < u; i++) {
                    let s = l(t[i], t[i + 1]);
                    if (e) {
                        let t = Array.isArray(e) ? e[i] || n.noop : e;
                        s = (0, r.pipe)(t, s)
                    }
                    a.push(s)
                }
                return a
            }(l, h, c),
            f = p.length,
            v = e => {
                if (m && e < t[0]) return l[0];
                let i = 0;
                if (f > 1)
                    for (; i < t.length - 2 && !(e < t[i + 1]); i++);
                let s = (0, a.progress)(t[i], t[i + 1], e);
                return p[i](s)
            };
        return u ? e => v((0, i.clamp)(t[0], t[d - 1], e)) : v
    }])
}, 95456, 389815, t => {
    "use strict";
    var e = t.i(724820),
        i = t.i(509667);

    function s(t, s) {
        let n = t[t.length - 1];
        for (let r = 1; r <= s; r++) {
            let a = (0, e.progress)(0, s, r);
            t.push((0, i.mixNumber)(n, 1, a))
        }
    }
    t.s(["fillOffset", 0, s], 389815), t.s(["defaultOffset", 0, function(t) {
        let e = [0];
        return s(e, t.length - 1), e
    }], 95456)
}, 579133, t => {
    "use strict";
    var e = t.i(290878),
        i = t.i(584346),
        s = t.i(516404),
        n = t.i(529996),
        r = t.i(95456);
    t.s(["keyframes", 0, function({
        duration: t = 300,
        keyframes: a,
        times: o,
        ease: l = "easeInOut"
    }) {
        var u;
        let h = (0, i.isEasingArray)(l) ? l.map(s.easingDefinitionToFunction) : (0, s.easingDefinitionToFunction)(l),
            c = {
                done: !1,
                value: a[0]
            },
            d = (u = o && o.length === a.length ? o : (0, r.defaultOffset)(a), u.map(e => e * t)),
            m = (0, n.interpolate)(d, a, {
                ease: Array.isArray(h) ? h : a.map(() => h || e.easeInOut).splice(0, a.length - 1)
            });
        return {
            calculatedDuration: t,
            next: e => (c.value = m(e), c.done = e >= t, c)
        }
    }], 579133)
}, 811432, t => {
    "use strict";
    var e = t.i(90500),
        i = t.i(579133),
        s = t.i(516528);
    let n = {
        decay: e.inertia,
        inertia: e.inertia,
        tween: i.keyframes,
        keyframes: i.keyframes,
        spring: s.spring
    };
    t.s(["replaceTransitionType", 0, function(t) {
        "string" == typeof t.type && (t.type = n[t.type])
    }])
}, 208344, t => {
    "use strict";
    var e = t.i(10968),
        i = t.i(212344),
        s = t.i(648400),
        n = t.i(569659),
        r = t.i(859798),
        a = t.i(781028),
        o = t.i(407297),
        l = t.i(90500),
        u = t.i(579133),
        h = t.i(231582),
        c = t.i(188119),
        d = t.i(525745),
        m = t.i(811432),
        p = t.i(41967);
    let f = t => t / 100;
    class v extends p.WithPromise {
        constructor(t) {
            super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
                done: !1,
                value: void 0
            }, this.stop = () => {
                let {
                    motionValue: t
                } = this.options;
                t && t.updatedAt !== n.time.now() && this.tick(n.time.now()), this.isStopped = !0, "idle" !== this.state && (this.teardown(), this.options.onStop ? .())
            }, r.activeAnimations.mainThread++, this.options = t, this.initAnimation(), this.play(), !1 === t.autoplay && this.pause()
        }
        initAnimation() {
            let {
                options: t
            } = this;
            (0, m.replaceTransitionType)(t);
            let {
                type: i = u.keyframes,
                repeat: s = 0,
                repeatDelay: n = 0,
                repeatType: r,
                velocity: o = 0
            } = t, {
                keyframes: l
            } = t, c = i || u.keyframes;
            c !== u.keyframes && "number" != typeof l[0] && (this.mixKeyframes = (0, e.pipe)(f, (0, a.mix)(l[0], l[1])), l = [0, 100]);
            let d = c({ ...t,
                keyframes: l
            });
            "mirror" === r && (this.mirroredGenerator = c({ ...t,
                keyframes: [...l].reverse(),
                velocity: -o
            })), null === d.calculatedDuration && (d.calculatedDuration = (0, h.calcGeneratorDuration)(d));
            let {
                calculatedDuration: p
            } = d;
            this.calculatedDuration = p, this.resolvedDuration = p + n, this.totalDuration = this.resolvedDuration * (s + 1) - n, this.generator = d
        }
        updateTime(t) {
            let e = Math.round(t - this.startTime) * this.playbackSpeed;
            null !== this.holdTime ? this.currentTime = this.holdTime : this.currentTime = e
        }
        tick(t, e = !1) {
            let s, {
                generator: n,
                totalDuration: r,
                mixKeyframes: a,
                mirroredGenerator: o,
                resolvedDuration: u,
                calculatedDuration: h
            } = this;
            if (null === this.startTime) return n.next(0);
            let {
                delay: c = 0,
                keyframes: m,
                repeat: p,
                repeatType: f,
                repeatDelay: v,
                type: g,
                onUpdate: y,
                finalKeyframe: x
            } = this.options;
            this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - r / this.speed, this.startTime)), e ? this.currentTime = t : this.updateTime(t);
            let T = this.currentTime - c * (this.playbackSpeed >= 0 ? 1 : -1),
                b = this.playbackSpeed >= 0 ? T < 0 : T > r;
            this.currentTime = Math.max(T, 0), "finished" === this.state && null === this.holdTime && (this.currentTime = r);
            let S = this.currentTime,
                w = n;
            if (p) {
                let t = Math.min(this.currentTime, r) / u,
                    e = Math.floor(t),
                    s = t % 1;
                !s && t >= 1 && (s = 1), 1 === s && e--, (e = Math.min(e, p + 1)) % 2 && ("reverse" === f ? (s = 1 - s, v && (s -= v / u)) : "mirror" === f && (w = o)), S = (0, i.clamp)(0, 1, s) * u
            }
            b ? (this.delayState.value = m[0], s = this.delayState) : s = w.next(S), a && !b && (s.value = a(s.value));
            let {
                done: P
            } = s;
            b || null === h || (P = this.playbackSpeed >= 0 ? this.currentTime >= r : this.currentTime <= 0);
            let V = null === this.holdTime && ("finished" === this.state || "running" === this.state && P);
            return V && g !== l.inertia && (s.value = (0, d.getFinalKeyframe)(m, this.options, x, this.speed)), y && y(s.value), V && this.finish(), s
        }
        then(t, e) {
            return this.finished.then(t, e)
        }
        get duration() {
            return (0, s.millisecondsToSeconds)(this.calculatedDuration)
        }
        get iterationDuration() {
            let {
                delay: t = 0
            } = this.options || {};
            return this.duration + (0, s.millisecondsToSeconds)(t)
        }
        get time() {
            return (0, s.millisecondsToSeconds)(this.currentTime)
        }
        set time(t) {
            t = (0, s.secondsToMilliseconds)(t), this.currentTime = t, null === this.startTime || null !== this.holdTime || 0 === this.playbackSpeed ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = t, this.tick(t))
        }
        getGeneratorVelocity() {
            let t = this.currentTime;
            if (t <= 0) return this.options.velocity || 0;
            if (this.generator.velocity) return this.generator.velocity(t);
            let e = this.generator.next(t).value;
            return (0, c.getGeneratorVelocity)(t => this.generator.next(t).value, t, e)
        }
        get speed() {
            return this.playbackSpeed
        }
        set speed(t) {
            let e = this.playbackSpeed !== t;
            e && this.driver && this.updateTime(n.time.now()), this.playbackSpeed = t, e && this.driver && (this.time = (0, s.millisecondsToSeconds)(this.currentTime))
        }
        play() {
            if (this.isStopped) return;
            let {
                driver: t = o.frameloopDriver,
                startTime: e
            } = this.options;
            this.driver || (this.driver = t(t => this.tick(t))), this.options.onPlay ? .();
            let i = this.driver.now();
            "finished" === this.state ? (this.updateFinished(), this.startTime = i) : null !== this.holdTime ? this.startTime = i - this.holdTime : this.startTime || (this.startTime = e ? ? i), "finished" === this.state && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start()
        }
        pause() {
            this.state = "paused", this.updateTime(n.time.now()), this.holdTime = this.currentTime
        }
        complete() {
            "running" !== this.state && this.play(), this.state = "finished", this.holdTime = null
        }
        finish() {
            this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete ? .()
        }
        cancel() {
            this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel ? .()
        }
        teardown() {
            this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null, r.activeAnimations.mainThread--
        }
        stopDriver() {
            this.driver && (this.driver.stop(), this.driver = void 0)
        }
        sample(t) {
            return this.startTime = 0, this.tick(t, !0)
        }
        attachTimeline(t) {
            return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver ? .stop(), t.observe(this)
        }
    }
    t.s(["JSAnimation", 0, v])
}, 506239, 890943, 632161, t => {
    "use strict";
    var e = t.i(212344),
        i = t.i(569659),
        s = t.i(961708),
        n = t.i(208344),
        r = t.i(569047),
        a = t.i(811432),
        o = t.i(249767),
        l = t.i(564113);
    let u = {
        anticipate: t.i(600754).anticipate,
        backInOut: l.backInOut,
        circInOut: o.circInOut
    };
    class h extends r.NativeAnimation {
        constructor(t) {
            ! function(t) {
                "string" == typeof t.ease && t.ease in u && (t.ease = u[t.ease])
            }(t), (0, a.replaceTransitionType)(t), super(t), void 0 !== t.startTime && !1 !== t.autoplay && (this.startTime = t.startTime), this.options = t
        }
        updateMotionValue(t) {
            let {
                motionValue: r,
                onUpdate: a,
                onComplete: o,
                element: l,
                ...u
            } = this.options;
            if (!r) return;
            if (void 0 !== t) return void r.set(t);
            let h = new n.JSAnimation({ ...u,
                    autoplay: !1
                }),
                c = Math.max(10, i.time.now() - this.startTime),
                d = (0, e.clamp)(0, 10, c - 10),
                m = h.sample(c).value,
                {
                    name: p
                } = this.options;
            l && p && (0, s.setStyle)(l, p, m), r.setWithVelocity(h.sample(Math.max(0, c - d)).value, m, d), h.stop()
        }
    }
    t.s(["NativeAnimationExtended", 0, h], 506239);
    var c = t.i(451258),
        d = t.i(94855),
        m = t.i(401828);
    let p = (t, e) => "zIndex" !== e && !!("number" == typeof t || Array.isArray(t) || "string" == typeof t && (m.complex.test(t) || "0" === t) && !t.startsWith("url("));
    t.s(["canAnimate", 0, function(t, e, i, s) {
        let n = t[0];
        if (null === n) return !1;
        if ("display" === e || "visibility" === e) return !0;
        let r = t[t.length - 1],
            a = p(n, e),
            o = p(r, e);
        return (0, c.warning)(a === o, `You are trying to animate ${e} from "${n}" to "${r}". "${a?r:n}" is not an animatable value.`, "value-not-animatable"), !!a && !!o && (function(t) {
            let e = t[0];
            if (1 === t.length) return !0;
            for (let i = 0; i < t.length; i++)
                if (t[i] !== e) return !0
        }(t) || ("spring" === i || (0, d.isGenerator)(i)) && s)
    }], 890943), t.s(["makeAnimationInstant", 0, function(t) {
        t.duration = 0, t.type = "keyframes"
    }], 632161)
}, 731312, t => {
    "use strict";
    var e = t.i(628346),
        i = t.i(363831),
        s = t.i(569659),
        n = t.i(208344),
        r = t.i(525745),
        a = t.i(592018),
        o = t.i(506239),
        l = t.i(890943),
        u = t.i(632161),
        h = t.i(41967),
        c = t.i(443203),
        d = t.i(902514);
    let m = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/,
        p = new Set(["color", "backgroundColor", "outlineColor", "fill", "stroke", "borderColor", "borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"]),
        f = (0, c.memo)(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
    class v extends h.WithPromise {
        constructor({
            autoplay: t = !0,
            delay: e = 0,
            type: i = "keyframes",
            repeat: n = 0,
            repeatDelay: r = 0,
            repeatType: o = "loop",
            keyframes: l,
            name: u,
            motionValue: h,
            element: c,
            ...d
        }) {
            super(), this.stop = () => {
                this._animation && (this._animation.stop(), this.stopTimeline ? .()), this.keyframeResolver ? .cancel()
            }, this.createdAt = s.time.now();
            const m = {
                    autoplay: t,
                    delay: e,
                    type: i,
                    repeat: n,
                    repeatDelay: r,
                    repeatType: o,
                    name: u,
                    motionValue: h,
                    element: c,
                    ...d
                },
                p = c ? .KeyframeResolver || a.KeyframeResolver;
            this.keyframeResolver = new p(l, (t, e, i) => this.onKeyframesResolved(t, e, m, !i), u, h, c), this.keyframeResolver ? .scheduleResolve()
        }
        onKeyframesResolved(t, a, h, c) {
            let v;
            this.keyframeResolver = void 0;
            let {
                name: g,
                type: y,
                velocity: x,
                delay: T,
                isHandoff: b,
                onUpdate: S
            } = h;
            this.resolvedAt = s.time.now();
            let w = !0;
            (0, l.canAnimate)(t, g, y, x) || (w = !1, (e.MotionGlobalConfig.instantAnimations || !T) && S ? .((0, r.getFinalKeyframe)(t, h, a)), t[0] = t[t.length - 1], (0, u.makeAnimationInstant)(h), h.repeat = 0);
            let P = {
                    startTime: c ? this.resolvedAt && this.resolvedAt - this.createdAt > 40 ? this.resolvedAt : this.createdAt : void 0,
                    finalKeyframe: a,
                    ...h,
                    keyframes: t
                },
                V = w && !b && function(t) {
                    let {
                        motionValue: e,
                        name: i,
                        repeatDelay: s,
                        repeatType: n,
                        damping: r,
                        type: a,
                        keyframes: o
                    } = t;
                    if (!(e ? .owner ? .current instanceof HTMLElement)) return !1;
                    let {
                        onUpdate: l,
                        transformTemplate: u
                    } = e.owner.getProps();
                    return f() && i && (d.acceleratedValues.has(i) || p.has(i) && function(t) {
                        for (let e = 0; e < t.length; e++)
                            if ("string" == typeof t[e] && m.test(t[e])) return !0;
                        return !1
                    }(o)) && ("transform" !== i || !u) && !l && !s && "mirror" !== n && 0 !== r && "inertia" !== a
                }(P),
                M = P.motionValue ? .owner ? .current;
            if (V) try {
                v = new o.NativeAnimationExtended({ ...P,
                    element: M
                })
            } catch {
                v = new n.JSAnimation(P)
            } else v = new n.JSAnimation(P);
            v.finished.then(() => {
                this.notifyFinished()
            }).catch(i.noop), this.pendingTimeline && (this.stopTimeline = v.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = v
        }
        get finished() {
            return this._animation ? this.animation.finished : this._finished
        }
        then(t, e) {
            return this.finished.finally(t).then(() => {})
        }
        get animation() {
            return this._animation || (this.keyframeResolver ? .resume(), (0, a.flushKeyframeResolvers)()), this._animation
        }
        get duration() {
            return this.animation.duration
        }
        get iterationDuration() {
            return this.animation.iterationDuration
        }
        get time() {
            return this.animation.time
        }
        set time(t) {
            this.animation.time = t
        }
        get speed() {
            return this.animation.speed
        }
        get state() {
            return this.animation.state
        }
        set speed(t) {
            this.animation.speed = t
        }
        get startTime() {
            return this.animation.startTime
        }
        attachTimeline(t) {
            return this._animation ? this.stopTimeline = this.animation.attachTimeline(t) : this.pendingTimeline = t, () => this.stop()
        }
        play() {
            this.animation.play()
        }
        pause() {
            this.animation.pause()
        }
        complete() {
            this.animation.complete()
        }
        cancel() {
            this._animation && this.animation.cancel(), this.keyframeResolver ? .cancel()
        }
    }
    t.s(["AsyncMotionValueAnimation", 0, v], 731312)
}, 401865, t => {
    "use strict";
    var e = t.i(648400),
        i = t.i(628346),
        s = t.i(731312),
        n = t.i(208344),
        r = t.i(752085),
        a = t.i(632161),
        o = t.i(870691);
    let l = {
            type: "spring",
            stiffness: 500,
            damping: 25,
            restSpeed: 10
        },
        u = {
            type: "keyframes",
            duration: .8
        },
        h = {
            type: "keyframes",
            ease: [.25, .1, .35, 1],
            duration: .3
        };
    var c = t.i(525745);
    let d = new Set(["when", "delay", "delayChildren", "staggerChildren", "staggerDirection", "repeat", "repeatType", "repeatDelay", "from", "elapsed"]);
    var m = t.i(839589);
    t.s(["animateMotionValue", 0, (t, p, f, v = {}, g, y) => x => {
        let T = (0, r.getValueTransition)(v, t) || {},
            b = T.delay || v.delay || 0,
            {
                elapsed: S = 0
            } = v;
        S -= (0, e.secondsToMilliseconds)(b);
        let w = {
            keyframes: Array.isArray(f) ? f : [null, f],
            ease: "easeOut",
            velocity: p.getVelocity(),
            ...T,
            delay: -S,
            onUpdate: t => {
                p.set(t), T.onUpdate && T.onUpdate(t)
            },
            onComplete: () => {
                x(), T.onComplete && T.onComplete()
            },
            name: t,
            motionValue: p,
            element: y ? void 0 : g
        };
        ! function(t) {
            for (let e in t)
                if (!d.has(e)) return !0;
            return !1
        }(T) && Object.assign(w, ((t, {
            keyframes: e
        }) => e.length > 2 ? u : o.transformProps.has(t) ? t.startsWith("scale") ? {
            type: "spring",
            stiffness: 550,
            damping: 0 === e[1] ? 2 * Math.sqrt(550) : 30,
            restSpeed: 10
        } : l : h)(t, w)), w.duration && (w.duration = (0, e.secondsToMilliseconds)(w.duration)), w.repeatDelay && (w.repeatDelay = (0, e.secondsToMilliseconds)(w.repeatDelay)), void 0 !== w.from && (w.keyframes[0] = w.from);
        let P = !1;
        if (!1 !== w.type && (0 !== w.duration || w.repeatDelay) || ((0, a.makeAnimationInstant)(w), 0 === w.delay && (P = !0)), (i.MotionGlobalConfig.instantAnimations || i.MotionGlobalConfig.skipAnimations || g ? .shouldSkipAnimations) && (P = !0, (0, a.makeAnimationInstant)(w), w.delay = 0), w.allowFlatten = !T.type && !T.ease, P && !y && void 0 !== p.get()) {
            let t = (0, c.getFinalKeyframe)(w.keyframes, T);
            if (void 0 !== t) return void m.frame.update(() => {
                w.onUpdate(t), w.onComplete()
            })
        }
        return T.isSync ? new n.JSAnimation(w) : new s.AsyncMotionValueAnimation(w)
    }], 401865)
}, 897296, t => {
    "use strict";
    var e = t.i(752085),
        i = t.i(743959),
        s = t.i(152983),
        n = t.i(399911),
        r = t.i(339649),
        a = t.i(925612),
        o = t.i(401865),
        l = t.i(839589);
    t.s(["animateTarget", 0, function(t, u, {
        delay: h = 0,
        transitionOverride: c,
        type: d
    } = {}) {
        let {
            transition: m,
            transitionEnd: p,
            ...f
        } = u, v = t.getDefaultTransition();
        m = m ? (0, i.resolveTransition)(m, v) : v;
        let g = m ? .reduceMotion;
        c && (m = c);
        let y = [],
            x = d && t.animationState && t.animationState.getState()[d];
        for (let i in f) {
            let n = t.getValue(i, t.latestValues[i] ? ? null),
                u = f[i];
            if (void 0 === u || x && function({
                    protectedKeys: t,
                    needsAnimating: e
                }, i) {
                    let s = t.hasOwnProperty(i) && !0 !== e[i];
                    return e[i] = !1, s
                }(x, i)) continue;
            let c = {
                    delay: h,
                    ...(0, e.getValueTransition)(m || {}, i)
                },
                d = n.get();
            if (void 0 !== d && !n.isAnimating() && !Array.isArray(u) && u === d && !c.velocity) {
                l.frame.update(() => n.set(u));
                continue
            }
            let p = !1;
            if (window.MotionHandoffAnimation) {
                let e = (0, a.getOptimisedAppearId)(t);
                if (e) {
                    let t = window.MotionHandoffAnimation(e, i, l.frame);
                    null !== t && (c.startTime = t, p = !0)
                }
            }(0, r.addValueToWillChange)(t, i);
            let v = g ? ? t.shouldReduceMotion;
            n.start((0, o.animateMotionValue)(i, n, u, v && s.positionalKeys.has(i) ? {
                type: !1
            } : c, t, p));
            let T = n.animation;
            T && y.push(T)
        }
        if (p) {
            let e = () => l.frame.update(() => {
                p && (0, n.setTarget)(t, p)
            });
            y.length ? Promise.all(y).then(e) : e()
        }
        return y
    }])
}, 700330, 433440, 489535, 319106, 355722, 206134, 102781, t => {
    "use strict";
    var e = t.i(431424),
        i = t.i(436234),
        s = t.i(897296);

    function n(t, e, i, s = 0, r = 1) {
        let a = Array.from(t).sort((t, e) => t.sortNodePosition(e)).indexOf(e),
            o = t.size,
            l = (o - 1) * s;
        return "function" == typeof i ? i(a, o) : 1 === r ? a * s : l - a * s
    }

    function r(t, e, a = {}) {
        let o = (0, i.resolveVariant)(t, e, "exit" === a.type ? t.presenceContext ? .custom : void 0),
            {
                transition: l = t.getDefaultTransition() || {}
            } = o || {};
        a.transitionOverride && (l = a.transitionOverride);
        let u = o ? () => Promise.all((0, s.animateTarget)(t, o, a)) : () => Promise.resolve(),
            h = t.variantChildren && t.variantChildren.size ? (i = 0) => {
                let {
                    delayChildren: s = 0,
                    staggerChildren: o,
                    staggerDirection: u
                } = l;
                return function(t, e, i = 0, s = 0, a = 0, o = 1, l) {
                    let u = [];
                    for (let h of t.variantChildren) h.notify("AnimationStart", e), u.push(r(h, e, { ...l,
                        delay: i + ("function" == typeof s ? 0 : s) + n(t.variantChildren, h, s, a, o)
                    }).then(() => h.notify("AnimationComplete", e)));
                    return Promise.all(u)
                }(t, e, i, s, o, u, a)
            } : () => Promise.resolve(),
            {
                when: c
            } = l;
        if (!c) return Promise.all([u(), h(a.delay)]); {
            let [t, e] = "beforeChildren" === c ? [u, h] : [h, u];
            return t().then(() => e())
        }
    }

    function a(t, e, n = {}) {
        let o;
        if (t.notify("AnimationStart", e), Array.isArray(e)) o = Promise.all(e.map(e => r(t, e, n)));
        else if ("string" == typeof e) o = r(t, e, n);
        else {
            let r = "function" == typeof e ? (0, i.resolveVariant)(t, e, n.custom) : e;
            o = Promise.all((0, s.animateTarget)(t, r, n))
        }
        return o.then(() => {
            t.notify("AnimationComplete", e)
        })
    }
    t.s(["animateVisualElement", 0, a], 433440);
    var o = t.i(320636),
        l = t.i(52435);
    let u = l.variantProps.length;
    var h = t.i(956705),
        c = t.i(848016);

    function d(t, e) {
        if (!Array.isArray(e)) return !1;
        let i = e.length;
        if (i !== t.length) return !1;
        for (let s = 0; s < i; s++)
            if (e[s] !== t[s]) return !1;
        return !0
    }
    let m = [...l.variantPriorityOrder].reverse(),
        p = l.variantPriorityOrder.length;

    function f(t = !1) {
        return {
            isActive: t,
            protectedKeys: {},
            needsAnimating: {},
            prevResolvedValues: {}
        }
    }

    function v() {
        return {
            animate: f(!0),
            whileInView: f(),
            whileHover: f(),
            whileTap: f(),
            whileDrag: f(),
            whileFocus: f(),
            exit: f()
        }
    }
    class g extends e.Feature {
        constructor(t) {
            super(t), t.animationState || (t.animationState = function(t) {
                let e = e => Promise.all(e.map(({
                        animation: e,
                        options: i
                    }) => a(t, e, i))),
                    s = v(),
                    r = !0,
                    f = !1,
                    g = e => (s, n) => {
                        let r = (0, i.resolveVariant)(t, n, "exit" === e ? t.presenceContext ? .custom : void 0);
                        if (r) {
                            let {
                                transition: t,
                                transitionEnd: e,
                                ...i
                            } = r;
                            s = { ...s,
                                ...i,
                                ...e
                            }
                        }
                        return s
                    };

                function y(a) {
                    let {
                        props: v
                    } = t, y = function t(e) {
                        if (!e) return;
                        if (!e.isControllingVariants) {
                            let i = e.parent && t(e.parent) || {};
                            return void 0 !== e.props.initial && (i.initial = e.props.initial), i
                        }
                        let i = {};
                        for (let t = 0; t < u; t++) {
                            let s = l.variantProps[t],
                                n = e.props[s];
                            ((0, o.isVariantLabel)(n) || !1 === n) && (i[s] = n)
                        }
                        return i
                    }(t.parent) || {}, x = [], T = new Set, b = {}, S = 1 / 0;
                    for (let e = 0; e < p; e++) {
                        var w, P;
                        let l = m[e],
                            u = s[l],
                            p = void 0 !== v[l] ? v[l] : y[l],
                            V = (0, o.isVariantLabel)(p),
                            M = l === a ? u.isActive : null;
                        !1 === M && (S = e);
                        let A = p === y[l] && p !== v[l] && V;
                        if (A && (r || f) && t.manuallyAnimateOnMount && (A = !1), u.protectedKeys = { ...b
                            }, !u.isActive && null === M || !p && !u.prevProp || (0, h.isAnimationControls)(p) || "boolean" == typeof p) continue;
                        if ("exit" === l && u.isActive && !0 !== M) {
                            u.prevResolvedValues && (b = { ...b,
                                ...u.prevResolvedValues
                            });
                            continue
                        }
                        let E = (w = u.prevProp, "string" == typeof(P = p) ? P !== w : !!Array.isArray(P) && !d(P, w)),
                            C = E || l === a && u.isActive && !A && V || e > S && V,
                            D = !1,
                            k = Array.isArray(p) ? p : [p],
                            R = k.reduce(g(l), {});
                        !1 === M && (R = {});
                        let {
                            prevResolvedValues: L = {}
                        } = u, B = { ...L,
                            ...R
                        }, F = e => {
                            C = !0, T.has(e) && (D = !0, T.delete(e)), u.needsAnimating[e] = !0;
                            let i = t.getValue(e);
                            i && (i.liveStyle = !1)
                        };
                        for (let t in B) {
                            let e = R[t],
                                i = L[t];
                            if (!b.hasOwnProperty(t))((0, c.isKeyframesTarget)(e) && (0, c.isKeyframesTarget)(i) ? d(e, i) : e === i) ? void 0 !== e && T.has(t) ? F(t) : u.protectedKeys[t] = !0 : null != e ? F(t) : T.add(t)
                        }
                        u.prevProp = p, u.prevResolvedValues = R, u.isActive && (b = { ...b,
                            ...R
                        }), (r || f) && t.blockInitialAnimation && (C = !1);
                        let O = A && E,
                            j = !O || D;
                        C && j && x.push(...k.map(e => {
                            let s = {
                                type: l
                            };
                            if ("string" == typeof e && (r || f) && !O && t.manuallyAnimateOnMount && t.parent) {
                                let {
                                    parent: r
                                } = t, a = (0, i.resolveVariant)(r, e);
                                if (r.enteringChildren && a) {
                                    let {
                                        delayChildren: e
                                    } = a.transition || {};
                                    s.delay = n(r.enteringChildren, t, e)
                                }
                            }
                            return {
                                animation: e,
                                options: s
                            }
                        }))
                    }
                    if (T.size) {
                        let e = {};
                        if ("boolean" != typeof v.initial) {
                            let s = (0, i.resolveVariant)(t, Array.isArray(v.initial) ? v.initial[0] : v.initial);
                            s && s.transition && (e.transition = s.transition)
                        }
                        T.forEach(i => {
                            let s = t.getBaseTarget(i),
                                n = t.getValue(i);
                            n && (n.liveStyle = !0), e[i] = s ? ? null
                        }), x.push({
                            animation: e
                        })
                    }
                    let V = !!x.length;
                    return r && (!1 === v.initial || v.initial === v.animate) && !t.manuallyAnimateOnMount && (V = !1), r = !1, f = !1, V ? e(x) : Promise.resolve()
                }
                return {
                    animateChanges: y,
                    setActive: function(e, i) {
                        if (s[e].isActive === i) return Promise.resolve();
                        t.variantChildren ? .forEach(t => t.animationState ? .setActive(e, i)), s[e].isActive = i;
                        let n = y(e);
                        for (let t in s) s[t].protectedKeys = {};
                        return n
                    },
                    setAnimateFunction: function(i) {
                        e = i(t)
                    },
                    getState: () => s,
                    reset: () => {
                        s = v(), f = !0
                    }
                }
            }(t))
        }
        updateAnimationControlsSubscription() {
            let {
                animate: t
            } = this.node.getProps();
            (0, h.isAnimationControls)(t) && (this.unmountControls = t.subscribe(this.node))
        }
        mount() {
            this.updateAnimationControlsSubscription()
        }
        update() {
            let {
                animate: t
            } = this.node.getProps(), {
                animate: e
            } = this.node.prevProps || {};
            t !== e && this.updateAnimationControlsSubscription()
        }
        unmount() {
            this.node.animationState.reset(), this.unmountControls ? .()
        }
    }
    var y = e;
    let x = 0;
    class T extends y.Feature {
        constructor() {
            super(...arguments), this.id = x++, this.isExitComplete = !1
        }
        update() {
            if (!this.node.presenceContext) return;
            let {
                isPresent: t,
                onExitComplete: e
            } = this.node.presenceContext, {
                isPresent: s
            } = this.node.prevPresenceContext || {};
            if (!this.node.animationState || t === s) return;
            if (t && !1 === s) {
                if (this.isExitComplete) {
                    let {
                        initial: t,
                        custom: e
                    } = this.node.getProps();
                    if ("string" == typeof t) {
                        let s = (0, i.resolveVariant)(this.node, t, e);
                        if (s) {
                            let {
                                transition: t,
                                transitionEnd: e,
                                ...i
                            } = s;
                            for (let t in i) this.node.getValue(t) ? .jump(i[t])
                        }
                    }
                    this.node.animationState.reset(), this.node.animationState.animateChanges()
                } else this.node.animationState.setActive("exit", !1);
                this.isExitComplete = !1;
                return
            }
            let n = this.node.animationState.setActive("exit", !t);
            e && !t && n.then(() => {
                this.isExitComplete = !0, e(this.id)
            })
        }
        mount() {
            let {
                register: t,
                onExitComplete: e
            } = this.node.presenceContext || {};
            e && e(this.id), t && (this.unmount = t(this.id))
        }
        unmount() {}
    }
    t.s(["animations", 0, {
        animation: {
            Feature: g
        },
        exit: {
            Feature: T
        }
    }], 700330), t.s(["eachAxis", 0, function(t) {
        return [t("x"), t("y")]
    }], 489535), t.s(["addDomEvent", 0, function(t, e, i, s = {
        passive: !0
    }) {
        return t.addEventListener(e, i, s), () => t.removeEventListener(e, i)
    }], 319106);
    let b = {
        x: !1,
        y: !1
    };
    t.s(["isDragActive", 0, function() {
        return b.x || b.y
    }, "isDragging", 0, b], 355722), t.s(["setDragLock", 0, function(t) {
        if ("x" === t || "y" === t)
            if (b[t]) return null;
            else return b[t] = !0, () => {
                b[t] = !1
            };
        return b.x || b.y ? null : (b.x = b.y = !0, () => {
            b.x = b.y = !1
        })
    }], 206134);
    var S = t.i(509667);

    function w(t) {
        return t.max - t.min
    }

    function P(t, e, i, s = .5) {
        t.origin = s, t.originPoint = (0, S.mixNumber)(e.min, e.max, t.origin), t.scale = w(i) / w(e), t.translate = (0, S.mixNumber)(i.min, i.max, t.origin) - t.originPoint, (t.scale >= .9999 && t.scale <= 1.0001 || isNaN(t.scale)) && (t.scale = 1), (t.translate >= -.01 && t.translate <= .01 || isNaN(t.translate)) && (t.translate = 0)
    }

    function V(t, e, i, s = 0) {
        t.min = (s ? (0, S.mixNumber)(i.min, i.max, s) : i.min) + e.min, t.max = t.min + w(e)
    }

    function M(t, e, i, s = 0) {
        let n = s ? (0, S.mixNumber)(i.min, i.max, s) : i.min;
        t.min = e.min - n, t.max = t.min + w(e)
    }
    t.s(["calcBoxDelta", 0, function(t, e, i, s) {
        P(t.x, e.x, i.x, s ? s.originX : void 0), P(t.y, e.y, i.y, s ? s.originY : void 0)
    }, "calcLength", 0, w, "calcRelativeBox", 0, function(t, e, i, s) {
        V(t.x, e.x, i.x, s ? .x), V(t.y, e.y, i.y, s ? .y)
    }, "calcRelativePosition", 0, function(t, e, i, s) {
        M(t.x, e.x, i.x, s ? .x), M(t.y, e.y, i.y, s ? .y)
    }, "isNear", 0, function(t, e, i) {
        return Math.abs(t - e) <= i
    }], 102781)
}, 874833, t => {
    "use strict";
    var e = t.i(562914);
    t.s(["isSVGElement", 0, function(t) {
        return (0, e.isObject)(t) && "ownerSVGElement" in t
    }])
}, 279393, t => {
    "use strict";
    t.s(["resolveElements", 0, function(t, e, i) {
        if (null == t) return [];
        if (t instanceof EventTarget) return [t];
        if ("string" == typeof t) {
            let s = document;
            e && (s = e.current);
            let n = i ? .[t] ? ? s.querySelectorAll(t);
            return n ? Array.from(n) : []
        }
        return Array.from(t).filter(t => null != t)
    }])
}, 506773, 288048, 919661, 771178, 200280, 853273, 261028, t => {
    "use strict";
    let e, i;
    var s = t.i(431424),
        n = t.i(363831),
        r = t.i(107952),
        a = t.i(839589),
        o = t.i(489535),
        l = t.i(382983),
        u = t.i(223138),
        h = t.i(339649),
        c = t.i(401865),
        d = t.i(509667),
        m = t.i(319106),
        p = t.i(206134),
        f = t.i(960847),
        v = t.i(102781),
        g = t.i(874833),
        y = t.i(279393);
    let x = new WeakMap,
        T = (t, e, i) => (s, n) => n && n[0] ? n[0][t + "Size"] : (0, g.isSVGElement)(s) && "getBBox" in s ? s.getBBox()[e] : s[i],
        b = T("inline", "width", "offsetWidth"),
        S = T("block", "height", "offsetHeight");

    function w({
        target: t,
        borderBoxSize: e
    }) {
        x.get(t) ? .forEach(i => {
            i(t, {
                get width() {
                    return b(t, e)
                },
                get height() {
                    return S(t, e)
                }
            })
        })
    }

    function P(t) {
        t.forEach(w)
    }
    let V = new Set;

    function M(t, s) {
        let n;
        return "function" == typeof t ? (V.add(t), i || (i = () => {
            let t = {
                get width() {
                    return window.innerWidth
                },
                get height() {
                    return window.innerHeight
                }
            };
            V.forEach(e => e(t))
        }, window.addEventListener("resize", i)), () => {
            V.delete(t), V.size || "function" != typeof i || (window.removeEventListener("resize", i), i = void 0)
        }) : (!e && "u" > typeof ResizeObserver && (e = new ResizeObserver(P)), (n = (0, y.resolveElements)(t)).forEach(t => {
            let i = x.get(t);
            i || (i = new Set, x.set(t, i)), i.add(s), e ? .observe(t)
        }), () => {
            n.forEach(t => {
                let i = x.get(t);
                i ? .delete(s), i ? .size || e ? .unobserve(t)
            })
        })
    }
    t.s(["resize", 0, M], 288048);
    let A = new Set(["BUTTON", "INPUT", "SELECT", "TEXTAREA", "A"]),
        E = new Set(["INPUT", "SELECT", "TEXTAREA"]);

    function C(t) {
        return E.has(t.tagName) || !0 === t.isContentEditable
    }
    t.s(["isElementKeyboardAccessible", 0, function(t) {
        return A.has(t.tagName) || !0 === t.isContentEditable
    }, "isElementTextInput", 0, C], 919661);
    var D = t.i(451258);
    let k = t => "mouse" === t.pointerType ? "number" != typeof t.button || t.button <= 0 : !1 !== t.isPrimary;

    function R(t) {
        return {
            point: {
                x: t.pageX,
                y: t.pageY
            }
        }
    }
    t.s(["isPrimaryPointer", 0, k], 771178);
    let L = t => e => k(e) && t(e, R(e));

    function B(t, e, i, s) {
        return (0, m.addDomEvent)(t, e, L(i), s)
    }
    t.s(["addPointerInfo", 0, L, "extractEventInfo", 0, R], 200280);
    let F = ({
        current: t
    }) => t ? t.ownerDocument.defaultView : null;
    var O = t.i(950196),
        j = t.i(10968),
        I = t.i(648400);
    let N = (t, e) => Math.abs(t - e),
        U = new Set(["auto", "scroll"]);
    class W {
        constructor(t, e, {
            transformPagePoint: i,
            contextWindow: s = window,
            dragSnapToOrigin: n = !1,
            distanceThreshold: r = 3,
            element: o
        } = {}) {
            if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.lastRawMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = new Map, this.removeScrollListeners = null, this.onElementScroll = t => {
                    this.handleScroll(t.target)
                }, this.onWindowScroll = () => {
                    this.handleScroll(window)
                }, this.updatePoint = () => {
                    var t, e;
                    if (!(this.lastMoveEvent && this.lastMoveEventInfo)) return;
                    this.lastRawMoveEventInfo && (this.lastMoveEventInfo = G(this.lastRawMoveEventInfo, this.transformPagePoint));
                    let i = $(this.lastMoveEventInfo, this.history),
                        s = null !== this.startEvent,
                        n = (t = i.offset, e = {
                            x: 0,
                            y: 0
                        }, Math.sqrt(N(t.x, e.x) ** 2 + N(t.y, e.y) ** 2) >= this.distanceThreshold);
                    if (!s && !n) return;
                    let {
                        point: r
                    } = i, {
                        timestamp: o
                    } = a.frameData;
                    this.history.push({ ...r,
                        timestamp: o
                    });
                    let {
                        onStart: l,
                        onMove: u
                    } = this.handlers;
                    s || (l && l(this.lastMoveEvent, i), this.startEvent = this.lastMoveEvent), u && u(this.lastMoveEvent, i)
                }, this.handlePointerMove = (t, e) => {
                    this.lastMoveEvent = t, this.lastRawMoveEventInfo = e, this.lastMoveEventInfo = G(e, this.transformPagePoint), a.frame.update(this.updatePoint, !0)
                }, this.handlePointerUp = (t, e) => {
                    this.end();
                    let {
                        onEnd: i,
                        onSessionEnd: s,
                        resumeAnimation: n
                    } = this.handlers;
                    if ((this.dragSnapToOrigin || !this.startEvent) && n && n(), !(this.lastMoveEvent && this.lastMoveEventInfo)) return;
                    let r = $("pointercancel" === t.type ? this.lastMoveEventInfo : G(e, this.transformPagePoint), this.history);
                    this.startEvent && i && i(t, r), s && s(t, r)
                }, !k(t)) return;
            this.dragSnapToOrigin = n, this.handlers = e, this.transformPagePoint = i, this.distanceThreshold = r, this.contextWindow = s || window;
            const l = G(R(t), this.transformPagePoint),
                {
                    point: u
                } = l,
                {
                    timestamp: h
                } = a.frameData;
            this.history = [{ ...u,
                timestamp: h
            }];
            const {
                onSessionStart: c
            } = e;
            c && c(t, $(l, this.history)), this.removeListeners = (0, j.pipe)(B(this.contextWindow, "pointermove", this.handlePointerMove), B(this.contextWindow, "pointerup", this.handlePointerUp), B(this.contextWindow, "pointercancel", this.handlePointerUp)), o && this.startScrollTracking(o)
        }
        startScrollTracking(t) {
            let e = t.parentElement;
            for (; e;) {
                let t = getComputedStyle(e);
                (U.has(t.overflowX) || U.has(t.overflowY)) && this.scrollPositions.set(e, {
                    x: e.scrollLeft,
                    y: e.scrollTop
                }), e = e.parentElement
            }
            this.scrollPositions.set(window, {
                x: window.scrollX,
                y: window.scrollY
            }), window.addEventListener("scroll", this.onElementScroll, {
                capture: !0
            }), window.addEventListener("scroll", this.onWindowScroll), this.removeScrollListeners = () => {
                window.removeEventListener("scroll", this.onElementScroll, {
                    capture: !0
                }), window.removeEventListener("scroll", this.onWindowScroll)
            }
        }
        handleScroll(t) {
            let e = this.scrollPositions.get(t);
            if (!e) return;
            let i = t === window,
                s = i ? {
                    x: window.scrollX,
                    y: window.scrollY
                } : {
                    x: t.scrollLeft,
                    y: t.scrollTop
                },
                n = {
                    x: s.x - e.x,
                    y: s.y - e.y
                };
            (0 !== n.x || 0 !== n.y) && (i ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += n.x, this.lastMoveEventInfo.point.y += n.y) : this.history.length > 0 && (this.history[0].x -= n.x, this.history[0].y -= n.y), this.scrollPositions.set(t, s), a.frame.update(this.updatePoint, !0))
        }
        updateHandlers(t) {
            this.handlers = t
        }
        end() {
            this.removeListeners && this.removeListeners(), this.removeScrollListeners && this.removeScrollListeners(), this.scrollPositions.clear(), (0, a.cancelFrame)(this.updatePoint)
        }
    }

    function G(t, e) {
        return e ? {
            point: e(t.point)
        } : t
    }

    function z(t, e) {
        return {
            x: t.x - e.x,
            y: t.y - e.y
        }
    }

    function $({
        point: t
    }, e) {
        return {
            point: t,
            delta: z(t, H(e)),
            offset: z(t, e[0]),
            velocity: function(t) {
                if (t.length < 2) return {
                    x: 0,
                    y: 0
                };
                let e = t.length - 1,
                    i = null,
                    s = H(t);
                for (; e >= 0 && (i = t[e], !(s.timestamp - i.timestamp > (0, I.secondsToMilliseconds)(.1)));) e--;
                if (!i) return {
                    x: 0,
                    y: 0
                };
                i === t[0] && t.length > 2 && s.timestamp - i.timestamp > 2 * (0, I.secondsToMilliseconds)(.1) && (i = t[1]);
                let n = (0, I.millisecondsToSeconds)(s.timestamp - i.timestamp);
                if (0 === n) return {
                    x: 0,
                    y: 0
                };
                let r = {
                    x: (s.x - i.x) / n,
                    y: (s.y - i.y) / n
                };
                return r.x === 1 / 0 && (r.x = 0), r.y === 1 / 0 && (r.y = 0), r
            }(e)
        }
    }

    function H(t) {
        return t[t.length - 1]
    }
    var K = t.i(724820),
        Y = t.i(212344);

    function X(t, e, i) {
        return {
            min: void 0 !== e ? t.min + e : void 0,
            max: void 0 !== i ? t.max + i - (t.max - t.min) : void 0
        }
    }

    function q(t, e) {
        let i = e.min - t.min,
            s = e.max - t.max;
        return e.max - e.min < t.max - t.min && ([i, s] = [s, i]), {
            min: i,
            max: s
        }
    }

    function Z(t, e, i) {
        return {
            min: _(t, e),
            max: _(t, i)
        }
    }

    function _(t, e) {
        return "number" == typeof t ? t : t[e] || 0
    }
    let J = new WeakMap;
    class Q {
        constructor(t) {
            this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = {
                x: 0,
                y: 0
            }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = (0, r.createBox)(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = t
        }
        start(t, {
            snapToCursor: e = !1,
            distanceThreshold: i
        } = {}) {
            let {
                presenceContext: s
            } = this.visualElement;
            if (s && !1 === s.isPresent) return;
            let n = t => {
                    e && this.snapToCursor(R(t).point), this.stopAnimation()
                },
                r = (t, e) => {
                    let {
                        drag: i,
                        dragPropagation: s,
                        onDragStart: n
                    } = this.getProps();
                    if (i && !s && (this.openDragLock && this.openDragLock(), this.openDragLock = (0, p.setDragLock)(i), !this.openDragLock)) return;
                    this.latestPointerEvent = t, this.latestPanInfo = e, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), (0, o.eachAxis)(t => {
                        let e = this.getAxisMotionValue(t).get() || 0;
                        if (f.percent.test(e)) {
                            let {
                                projection: i
                            } = this.visualElement;
                            if (i && i.layout) {
                                let s = i.layout.layoutBox[t];
                                s && (e = (0, v.calcLength)(s) * (parseFloat(e) / 100))
                            }
                        }
                        this.originPoint[t] = e
                    }), n && a.frame.update(() => n(t, e), !1, !0), (0, h.addValueToWillChange)(this.visualElement, "transform");
                    let {
                        animationState: r
                    } = this.visualElement;
                    r && r.setActive("whileDrag", !0)
                },
                l = (t, e) => {
                    this.latestPointerEvent = t, this.latestPanInfo = e;
                    let {
                        dragPropagation: i,
                        dragDirectionLock: s,
                        onDirectionLock: n,
                        onDrag: r
                    } = this.getProps();
                    if (!i && !this.openDragLock) return;
                    let {
                        offset: o
                    } = e;
                    if (s && null === this.currentDirection) {
                        this.currentDirection = function(t, e = 10) {
                            let i = null;
                            return Math.abs(t.y) > e ? i = "y" : Math.abs(t.x) > e && (i = "x"), i
                        }(o), null !== this.currentDirection && n && n(this.currentDirection);
                        return
                    }
                    this.updateAxis("x", e.point, o), this.updateAxis("y", e.point, o), this.visualElement.render(), r && a.frame.update(() => r(t, e), !1, !0)
                },
                u = (t, e) => {
                    this.latestPointerEvent = t, this.latestPanInfo = e, this.stop(t, e), this.latestPointerEvent = null, this.latestPanInfo = null
                },
                c = () => {
                    let {
                        dragSnapToOrigin: t
                    } = this.getProps();
                    (t || this.constraints) && this.startAnimation({
                        x: 0,
                        y: 0
                    })
                },
                {
                    dragSnapToOrigin: d
                } = this.getProps();
            this.panSession = new W(t, {
                onSessionStart: n,
                onStart: r,
                onMove: l,
                onSessionEnd: u,
                resumeAnimation: c
            }, {
                transformPagePoint: this.visualElement.getTransformPagePoint(),
                dragSnapToOrigin: d,
                distanceThreshold: i,
                contextWindow: F(this.visualElement),
                element: this.visualElement.current
            })
        }
        stop(t, e) {
            let i = t || this.latestPointerEvent,
                s = e || this.latestPanInfo,
                n = this.isDragging;
            if (this.cancel(), !n || !s || !i) return;
            let {
                velocity: r
            } = s;
            this.startAnimation(r);
            let {
                onDragEnd: o
            } = this.getProps();
            o && a.frame.postRender(() => o(i, s))
        }
        cancel() {
            this.isDragging = !1;
            let {
                projection: t,
                animationState: e
            } = this.visualElement;
            t && (t.isAnimationBlocked = !1), this.endPanSession();
            let {
                dragPropagation: i
            } = this.getProps();
            !i && this.openDragLock && (this.openDragLock(), this.openDragLock = null), e && e.setActive("whileDrag", !1)
        }
        endPanSession() {
            this.panSession && this.panSession.end(), this.panSession = void 0
        }
        updateAxis(t, e, i) {
            let {
                drag: s
            } = this.getProps();
            if (!i || !te(t, s, this.currentDirection)) return;
            let n = this.getAxisMotionValue(t),
                r = this.originPoint[t] + i[t];
            this.constraints && this.constraints[t] && (r = function(t, {
                min: e,
                max: i
            }, s) {
                return void 0 !== e && t < e ? t = s ? (0, d.mixNumber)(e, t, s.min) : Math.max(t, e) : void 0 !== i && t > i && (t = s ? (0, d.mixNumber)(i, t, s.max) : Math.min(t, i)), t
            }(r, this.constraints[t], this.elastic[t])), n.set(r)
        }
        resolveConstraints() {
            let {
                dragConstraints: t,
                dragElastic: e
            } = this.getProps(), i = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection ? .layout, s = this.constraints;
            t && (0, O.isRefObject)(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && i ? this.constraints = function(t, {
                top: e,
                left: i,
                bottom: s,
                right: n
            }) {
                return {
                    x: X(t.x, i, n),
                    y: X(t.y, e, s)
                }
            }(i.layoutBox, t) : this.constraints = !1, this.elastic = function(t = .35) {
                return !1 === t ? t = 0 : !0 === t && (t = .35), {
                    x: Z(t, "left", "right"),
                    y: Z(t, "top", "bottom")
                }
            }(e), s !== this.constraints && !(0, O.isRefObject)(t) && i && this.constraints && !this.hasMutatedConstraints && (0, o.eachAxis)(t => {
                var e, s;
                let n;
                !1 !== this.constraints && this.getAxisMotionValue(t) && (this.constraints[t] = (e = i.layoutBox[t], s = this.constraints[t], n = {}, void 0 !== s.min && (n.min = s.min - e.min), void 0 !== s.max && (n.max = s.max - e.min), n))
            })
        }
        resolveRefConstraints() {
            var t;
            let {
                dragConstraints: e,
                onMeasureDragConstraints: i
            } = this.getProps();
            if (!e || !(0, O.isRefObject)(e)) return !1;
            let s = e.current;
            (0, D.invariant)(null !== s, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
            let {
                projection: n
            } = this.visualElement;
            if (!n || !n.layout) return !1;
            let r = (0, l.measurePageBox)(s, n.root, this.visualElement.getTransformPagePoint()),
                a = (t = n.layout.layoutBox, {
                    x: q(t.x, r.x),
                    y: q(t.y, r.y)
                });
            if (i) {
                let t = i((0, u.convertBoxToBoundingBox)(a));
                this.hasMutatedConstraints = !!t, t && (a = (0, u.convertBoundingBoxToBox)(t))
            }
            return a
        }
        startAnimation(t) {
            let {
                drag: e,
                dragMomentum: i,
                dragElastic: s,
                dragTransition: n,
                dragSnapToOrigin: r,
                onDragTransitionEnd: a
            } = this.getProps(), l = this.constraints || {};
            return Promise.all((0, o.eachAxis)(a => {
                if (!te(a, e, this.currentDirection)) return;
                let o = l && l[a] || {};
                (!0 === r || r === a) && (o = {
                    min: 0,
                    max: 0
                });
                let u = {
                    type: "inertia",
                    velocity: i ? t[a] : 0,
                    bounceStiffness: s ? 200 : 1e6,
                    bounceDamping: s ? 40 : 1e7,
                    timeConstant: 750,
                    restDelta: 1,
                    restSpeed: 10,
                    ...n,
                    ...o
                };
                return this.startAxisValueAnimation(a, u)
            })).then(a)
        }
        startAxisValueAnimation(t, e) {
            let i = this.getAxisMotionValue(t);
            return (0, h.addValueToWillChange)(this.visualElement, t), i.start((0, c.animateMotionValue)(t, i, 0, e, this.visualElement, !1))
        }
        stopAnimation() {
            (0, o.eachAxis)(t => this.getAxisMotionValue(t).stop())
        }
        getAxisMotionValue(t) {
            let e = `_drag${t.toUpperCase()}`,
                i = this.visualElement.getProps();
            return i[e] || this.visualElement.getValue(t, (i.initial ? i.initial[t] : void 0) || 0)
        }
        snapToCursor(t) {
            (0, o.eachAxis)(e => {
                let {
                    drag: i
                } = this.getProps();
                if (!te(e, i, this.currentDirection)) return;
                let {
                    projection: s
                } = this.visualElement, n = this.getAxisMotionValue(e);
                if (s && s.layout) {
                    let {
                        min: i,
                        max: r
                    } = s.layout.layoutBox[e], a = n.get() || 0;
                    n.set(t[e] - (0, d.mixNumber)(i, r, .5) + a)
                }
            })
        }
        scalePositionWithinConstraints() {
            if (!this.visualElement.current) return;
            let {
                drag: t,
                dragConstraints: e
            } = this.getProps(), {
                projection: i
            } = this.visualElement;
            if (!(0, O.isRefObject)(e) || !i || !this.constraints) return;
            this.stopAnimation();
            let s = {
                x: 0,
                y: 0
            };
            (0, o.eachAxis)(t => {
                let e = this.getAxisMotionValue(t);
                if (e && !1 !== this.constraints) {
                    var i, n;
                    let r, a, o, l = e.get();
                    s[t] = (i = {
                        min: l,
                        max: l
                    }, n = this.constraints[t], r = .5, a = (0, v.calcLength)(i), (o = (0, v.calcLength)(n)) > a ? r = (0, K.progress)(n.min, n.max - a, i.min) : a > o && (r = (0, K.progress)(i.min, i.max - o, n.min)), (0, Y.clamp)(0, 1, r))
                }
            });
            let {
                transformTemplate: n
            } = this.visualElement.getProps();
            this.visualElement.current.style.transform = n ? n({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.constraints = !1, this.resolveConstraints(), (0, o.eachAxis)(e => {
                if (!te(e, t, null)) return;
                let i = this.getAxisMotionValue(e),
                    {
                        min: n,
                        max: r
                    } = this.constraints[e];
                i.set((0, d.mixNumber)(n, r, s[e]))
            }), this.visualElement.render()
        }
        addListeners() {
            let t;
            if (!this.visualElement.current) return;
            J.set(this.visualElement, this);
            let e = this.visualElement.current,
                i = B(e, "pointerdown", t => {
                    let {
                        drag: i,
                        dragListener: s = !0
                    } = this.getProps(), n = t.target, r = n !== e && C(n);
                    i && s && !r && this.start(t)
                }),
                s = () => {
                    var i, s, n;
                    let r, a, {
                        dragConstraints: o
                    } = this.getProps();
                    (0, O.isRefObject)(o) && o.current && (this.constraints = this.resolveRefConstraints(), t || (i = e, s = o.current, r = M(i, tt(n = () => this.scalePositionWithinConstraints())), a = M(s, tt(n)), t = () => {
                        r(), a()
                    }))
                },
                {
                    projection: n
                } = this.visualElement,
                r = n.addEventListener("measure", s);
            n && !n.layout && (n.root && n.root.updateScroll(), n.updateLayout()), a.frame.read(s);
            let l = (0, m.addDomEvent)(window, "resize", () => this.scalePositionWithinConstraints()),
                u = n.addEventListener("didUpdate", ({
                    delta: t,
                    hasLayoutChanged: e
                }) => {
                    this.isDragging && e && ((0, o.eachAxis)(e => {
                        let i = this.getAxisMotionValue(e);
                        i && (this.originPoint[e] += t[e].translate, i.set(i.get() + t[e].translate))
                    }), this.visualElement.render())
                });
            return () => {
                l(), i(), r(), u && u(), t && t()
            }
        }
        getProps() {
            let t = this.visualElement.getProps(),
                {
                    drag: e = !1,
                    dragDirectionLock: i = !1,
                    dragPropagation: s = !1,
                    dragConstraints: n = !1,
                    dragElastic: r = .35,
                    dragMomentum: a = !0
                } = t;
            return { ...t,
                drag: e,
                dragDirectionLock: i,
                dragPropagation: s,
                dragConstraints: n,
                dragElastic: r,
                dragMomentum: a
            }
        }
    }

    function tt(t) {
        let e = !0;
        return () => {
            if (e) {
                e = !1;
                return
            }
            t()
        }
    }

    function te(t, e, i) {
        return (!0 === e || e === t) && (null === i || i === t)
    }
    class ti extends s.Feature {
        constructor(t) {
            super(t), this.removeGroupControls = n.noop, this.removeListeners = n.noop, this.controls = new Q(t)
        }
        mount() {
            let {
                dragControls: t
            } = this.node.getProps();
            t && (this.removeGroupControls = t.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || n.noop
        }
        update() {
            let {
                dragControls: t
            } = this.node.getProps(), {
                dragControls: e
            } = this.node.prevProps || {};
            t !== e && (this.removeGroupControls(), t && (this.removeGroupControls = t.subscribe(this.controls)))
        }
        unmount() {
            this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession()
        }
    }
    t.s(["DragGesture", 0, ti], 506773);
    var ts = s;
    let tn = t => (e, i) => {
        t && a.frame.update(() => t(e, i), !1, !0)
    };
    class tr extends ts.Feature {
        constructor() {
            super(...arguments), this.removePointerDownListener = n.noop
        }
        onPointerDown(t) {
            this.session = new W(t, this.createPanHandlers(), {
                transformPagePoint: this.node.getTransformPagePoint(),
                contextWindow: F(this.node)
            })
        }
        createPanHandlers() {
            let {
                onPanSessionStart: t,
                onPanStart: e,
                onPan: i,
                onPanEnd: s
            } = this.node.getProps();
            return {
                onSessionStart: tn(t),
                onStart: tn(e),
                onMove: tn(i),
                onEnd: (t, e) => {
                    delete this.session, s && a.frame.postRender(() => s(t, e))
                }
            }
        }
        mount() {
            this.removePointerDownListener = B(this.node.current, "pointerdown", t => this.onPointerDown(t))
        }
        update() {
            this.session && this.session.updateHandlers(this.createPanHandlers())
        }
        unmount() {
            this.removePointerDownListener(), this.session && this.session.end()
        }
    }
    t.s(["PanGesture", 0, tr], 853273), t.s(["globalProjectionState", 0, {
        hasAnimatedSinceResize: !0,
        hasEverUpdated: !1
    }], 261028)
}, 38240, t => {
    "use strict";
    var e = t.i(221628),
        i = t.i(261028),
        s = t.i(839589),
        n = t.i(705647),
        r = t.i(416340),
        a = t.i(312151),
        o = t.i(262504),
        l = t.i(464140);
    let u = !1;
    class h extends r.Component {
        componentDidMount() {
            let {
                visualElement: t,
                layoutGroup: e,
                switchLayoutGroup: s,
                layoutId: n
            } = this.props, {
                projection: r
            } = t;
            r && (e.group && e.group.add(r), s && s.register && n && s.register(r), u && r.root.didUpdate(), r.addEventListener("animationComplete", () => {
                this.safeToRemove()
            }), r.setOptions({ ...r.options,
                layoutDependency: this.props.layoutDependency,
                onExitComplete: () => this.safeToRemove()
            })), i.globalProjectionState.hasEverUpdated = !0
        }
        getSnapshotBeforeUpdate(t) {
            let {
                layoutDependency: e,
                visualElement: i,
                drag: n,
                isPresent: r
            } = this.props, {
                projection: a
            } = i;
            return a && (a.isPresent = r, t.layoutDependency !== e && a.setOptions({ ...a.options,
                layoutDependency: e
            }), u = !0, n || t.layoutDependency !== e || void 0 === e || t.isPresent !== r ? a.willUpdate() : this.safeToRemove(), t.isPresent !== r && (r ? a.promote() : a.relegate() || s.frame.postRender(() => {
                let t = a.getStack();
                t && t.members.length || this.safeToRemove()
            }))), null
        }
        componentDidUpdate() {
            let {
                visualElement: t,
                layoutAnchor: e
            } = this.props, {
                projection: i
            } = t;
            i && (i.options.layoutAnchor = e, i.root.didUpdate(), n.microtask.postRender(() => {
                !i.currentAnimation && i.isLead() && this.safeToRemove()
            }))
        }
        componentWillUnmount() {
            let {
                visualElement: t,
                layoutGroup: e,
                switchLayoutGroup: i
            } = this.props, {
                projection: s
            } = t;
            u = !0, s && (s.scheduleCheckAfterUnmount(), e && e.group && e.group.remove(s), i && i.deregister && i.deregister(s))
        }
        safeToRemove() {
            let {
                safeToRemove: t
            } = this.props;
            t && t()
        }
        render() {
            return null
        }
    }
    t.s(["MeasureLayout", 0, function(t) {
        let [i, s] = (0, a.usePresence)(), n = (0, r.useContext)(o.LayoutGroupContext);
        return (0, e.jsx)(h, { ...t,
            layoutGroup: n,
            switchLayoutGroup: (0, r.useContext)(l.SwitchLayoutGroupContext),
            isPresent: i,
            safeToRemove: s
        })
    }])
}, 754710, t => {
    "use strict";
    var e = t.i(401865),
        i = t.i(520415),
        s = t.i(828397);
    t.s(["animateSingleValue", 0, function(t, n, r) {
        let a = (0, s.isMotionValue)(t) ? t : (0, i.motionValue)(t);
        return a.start((0, e.animateMotionValue)("", a, n, r)), a.animation
    }])
}, 127386, t => {
    "use strict";
    var e = t.i(569659);
    t.i(648400);
    var i = t.i(839589);
    t.s(["delay", 0, function(t, s) {
        let n = e.time.now(),
            r = ({
                timestamp: e
            }) => {
                let a = e - n;
                a >= s && ((0, i.cancelFrame)(r), t(a - s))
            };
        return i.frame.setup(r, !0), () => (0, i.cancelFrame)(r)
    }])
}, 220719, t => {
    "use strict";
    var e = t.i(874833);
    t.s(["isSVGSVGElement", 0, function(t) {
        return (0, e.isSVGElement)(t) && "svg" === t.tagName
    }])
}, 905959, 466142, 328189, 393002, 973534, t => {
    "use strict";
    var e = t.i(506773),
        i = t.i(853273),
        s = t.i(38240),
        n = t.i(906097),
        r = t.i(212344),
        a = t.i(363831),
        o = t.i(754710),
        l = t.i(925612),
        u = t.i(752085),
        h = t.i(705647),
        c = t.i(569659),
        d = t.i(511572),
        m = t.i(859798),
        p = t.i(968909),
        f = t.i(127386),
        v = t.i(874833),
        g = t.i(220719),
        y = t.i(509667),
        x = t.i(520415),
        T = t.i(327454),
        b = t.i(960847),
        S = t.i(724820),
        w = t.i(249767);
    let P = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius"],
        V = P.length,
        M = t => "string" == typeof t ? parseFloat(t) : t,
        A = t => "number" == typeof t || b.px.test(t);

    function E(t, e) {
        return void 0 !== t[e] ? t[e] : t.borderRadius
    }
    let C = k(0, .5, w.circOut),
        D = k(.5, .95, a.noop);

    function k(t, e, i) {
        return s => s < t ? 0 : s > e ? 1 : i((0, S.progress)(t, e, s))
    }

    function R(t, e) {
        t.min = e.min, t.max = e.max
    }

    function L(t, e) {
        R(t.x, e.x), R(t.y, e.y)
    }

    function B(t, e) {
        t.translate = e.translate, t.scale = e.scale, t.originPoint = e.originPoint, t.origin = e.origin
    }
    var F = t.i(638822),
        O = t.i(102781);

    function j(t, e, i, s, n) {
        return t -= e, t = (0, F.scalePoint)(t, 1 / i, s), void 0 !== n && (t = (0, F.scalePoint)(t, 1 / n, s)), t
    }

    function I(t, e, [i, s, n], r, a) {
        ! function(t, e = 0, i = 1, s = .5, n, r = t, a = t) {
            if (b.percent.test(e) && (e = parseFloat(e), e = (0, y.mixNumber)(a.min, a.max, e / 100) - a.min), "number" != typeof e) return;
            let o = (0, y.mixNumber)(r.min, r.max, s);
            t === r && (o -= e), t.min = j(t.min, e, i, o, n), t.max = j(t.max, e, i, o, n)
        }(t, e[i], e[s], e[n], e.scale, r, a)
    }
    let N = ["x", "scaleX", "originX"],
        U = ["y", "scaleY", "originY"];

    function W(t, e, i, s) {
        I(t.x, e, N, i ? i.x : void 0, s ? s.x : void 0), I(t.y, e, U, i ? i.y : void 0, s ? s.y : void 0)
    }
    var G = t.i(107952);

    function z(t) {
        return 0 === t.translate && 1 === t.scale
    }

    function $(t) {
        return z(t.x) && z(t.y)
    }

    function H(t, e) {
        return t.min === e.min && t.max === e.max
    }

    function K(t, e) {
        return Math.round(t.min) === Math.round(e.min) && Math.round(t.max) === Math.round(e.max)
    }

    function Y(t, e) {
        return K(t.x, e.x) && K(t.y, e.y)
    }

    function X(t) {
        return (0, O.calcLength)(t.x) / (0, O.calcLength)(t.y)
    }

    function q(t, e) {
        return t.translate === e.translate && t.scale === e.scale && t.originPoint === e.originPoint
    }
    var Z = t.i(522120);
    class _ {
        constructor() {
            this.members = []
        }
        add(t) {
            (0, Z.addUniqueItem)(this.members, t);
            for (let e = this.members.length - 1; e >= 0; e--) {
                let i = this.members[e];
                if (i === t || i === this.lead || i === this.prevLead) continue;
                let s = i.instance;
                s && !1 !== s.isConnected || i.snapshot || ((0, Z.removeItem)(this.members, i), i.unmount())
            }
            t.scheduleRender()
        }
        remove(t) {
            if ((0, Z.removeItem)(this.members, t), t === this.prevLead && (this.prevLead = void 0), t === this.lead) {
                let t = this.members[this.members.length - 1];
                t && this.promote(t)
            }
        }
        relegate(t) {
            for (let e = this.members.indexOf(t) - 1; e >= 0; e--) {
                let t = this.members[e];
                if (!1 !== t.isPresent && t.instance ? .isConnected !== !1) return this.promote(t), !0
            }
            return !1
        }
        promote(t, e) {
            let i = this.lead;
            if (t !== i && (this.prevLead = i, this.lead = t, t.show(), i)) {
                i.updateSnapshot(), t.scheduleRender();
                let {
                    layoutDependency: s
                } = i.options, {
                    layoutDependency: n
                } = t.options;
                (void 0 === s || s !== n) && (t.resumeFrom = i, e && (i.preserveOpacity = !0), i.snapshot && (t.snapshot = i.snapshot, t.snapshot.latestValues = i.animationValues || i.latestValues), t.root ? .isUpdating && (t.isLayoutDirty = !0)), !1 === t.options.crossfade && i.hide()
            }
        }
        exitAnimationComplete() {
            this.members.forEach(t => {
                t.options.onExitComplete ? .(), t.resumingFrom ? .options.onExitComplete ? .()
            })
        }
        scheduleRender() {
            this.members.forEach(t => t.instance && t.scheduleRender(!1))
        }
        removeLeadSnapshot() {
            this.lead ? .snapshot && (this.lead.snapshot = void 0)
        }
    }
    var J = t.i(489535);
    let Q = (t, e) => t.depth - e.depth;
    class tt {
        constructor() {
            this.children = [], this.isDirty = !1
        }
        add(t) {
            (0, Z.addUniqueItem)(this.children, t), this.isDirty = !0
        }
        remove(t) {
            (0, Z.removeItem)(this.children, t), this.isDirty = !0
        }
        forEach(t) {
            this.isDirty && this.children.sort(Q), this.isDirty = !1, this.children.forEach(t)
        }
    }
    var te = t.i(715426),
        ti = t.i(261028),
        ts = t.i(839589);
    let tn = {
            nodes: 0,
            calculatedTargetDeltas: 0,
            calculatedProjections: 0
        },
        tr = ["", "X", "Y", "Z"],
        ta = 0;

    function to(t, e, i, s) {
        let {
            latestValues: n
        } = e;
        n[t] && (i[t] = n[t], e.setStaticValue(t, 0), s && (s[t] = 0))
    }

    function tl({
        attachResizeListener: t,
        defaultParent: e,
        measureScroll: i,
        checkIsScrollRoot: s,
        resetTransform: a
    }) {
        return class {
            constructor(t = {}, i = e ? .()) {
                this.id = ta++, this.animationId = 0, this.animationCommitId = 0, this.children = new Set, this.options = {}, this.isTreeAnimating = !1, this.isAnimationBlocked = !1, this.isLayoutDirty = !1, this.isProjectionDirty = !1, this.isSharedProjectionDirty = !1, this.isTransformDirty = !1, this.updateManuallyBlocked = !1, this.updateBlockedByResize = !1, this.isUpdating = !1, this.isSVG = !1, this.needsReset = !1, this.shouldResetTransform = !1, this.hasCheckedOptimisedAppear = !1, this.treeScale = {
                    x: 1,
                    y: 1
                }, this.eventHandlers = new Map, this.hasTreeAnimated = !1, this.layoutVersion = 0, this.updateScheduled = !1, this.scheduleUpdate = () => this.update(), this.projectionUpdateScheduled = !1, this.checkUpdateFailed = () => {
                    this.isUpdating && (this.isUpdating = !1, this.clearAllSnapshots())
                }, this.updateProjection = () => {
                    this.projectionUpdateScheduled = !1, p.statsBuffer.value && (tn.nodes = tn.calculatedTargetDeltas = tn.calculatedProjections = 0), this.nodes.forEach(tc), this.nodes.forEach(tT), this.nodes.forEach(tb), this.nodes.forEach(td), p.statsBuffer.addProjectionMetrics && p.statsBuffer.addProjectionMetrics(tn)
                }, this.resolvedRelativeTargetAt = 0, this.linkedParentVersion = 0, this.hasProjected = !1, this.isVisible = !0, this.animationProgress = 0, this.sharedNodes = new Map, this.latestValues = t, this.root = i ? i.root || i : this, this.path = i ? [...i.path, i] : [], this.parent = i, this.depth = i ? i.depth + 1 : 0;
                for (let t = 0; t < this.path.length; t++) this.path[t].shouldResetTransform = !0;
                this.root === this && (this.nodes = new tt)
            }
            addEventListener(t, e) {
                return this.eventHandlers.has(t) || this.eventHandlers.set(t, new n.SubscriptionManager), this.eventHandlers.get(t).add(e)
            }
            notifyListeners(t, ...e) {
                let i = this.eventHandlers.get(t);
                i && i.notify(...e)
            }
            hasListeners(t) {
                return this.eventHandlers.has(t)
            }
            mount(e) {
                if (this.instance) return;
                this.isSVG = (0, v.isSVGElement)(e) && !(0, g.isSVGSVGElement)(e), this.instance = e;
                let {
                    layoutId: i,
                    layout: s,
                    visualElement: n
                } = this.options;
                if (n && !n.current && n.mount(e), this.root.nodes.add(this), this.parent && this.parent.children.add(this), this.root.hasTreeAnimated && (s || i) && (this.isLayoutDirty = !0), t) {
                    let i, s = 0,
                        n = () => this.root.updateBlockedByResize = !1;
                    ts.frame.read(() => {
                        s = window.innerWidth
                    }), t(e, () => {
                        let t = window.innerWidth;
                        t !== s && (s = t, this.root.updateBlockedByResize = !0, i && i(), i = (0, f.delay)(n, 250), ti.globalProjectionState.hasAnimatedSinceResize && (ti.globalProjectionState.hasAnimatedSinceResize = !1, this.nodes.forEach(tx)))
                    })
                }
                i && this.root.registerSharedNode(i, this), !1 !== this.options.animate && n && (i || s) && this.addEventListener("didUpdate", ({
                    delta: t,
                    hasLayoutChanged: e,
                    hasRelativeLayoutChanged: i,
                    layout: s
                }) => {
                    if (this.isTreeAnimationBlocked()) {
                        this.target = void 0, this.relativeTarget = void 0;
                        return
                    }
                    let r = this.options.transition || n.getDefaultTransition() || tA,
                        {
                            onLayoutAnimationStart: a,
                            onLayoutAnimationComplete: o
                        } = n.getProps(),
                        l = !this.targetLayout || !Y(this.targetLayout, s),
                        h = !e && i;
                    if (this.options.layoutRoot || this.resumeFrom || h || e && (l || !this.currentAnimation)) {
                        this.resumeFrom && (this.resumingFrom = this.resumeFrom, this.resumingFrom.resumingFrom = void 0);
                        let e = { ...(0, u.getValueTransition)(r, "layout"),
                            onPlay: a,
                            onComplete: o
                        };
                        (n.shouldReduceMotion || this.options.layoutRoot) && (e.delay = 0, e.type = !1), this.startAnimation(e), this.setAnimationOrigin(t, h)
                    } else e || tx(this), this.isLead() && this.options.onExitComplete && this.options.onExitComplete();
                    this.targetLayout = s
                })
            }
            unmount() {
                this.options.layoutId && this.willUpdate(), this.root.nodes.remove(this);
                let t = this.getStack();
                t && t.remove(this), this.parent && this.parent.children.delete(this), this.instance = void 0, this.eventHandlers.clear(), (0, ts.cancelFrame)(this.updateProjection)
            }
            blockUpdate() {
                this.updateManuallyBlocked = !0
            }
            unblockUpdate() {
                this.updateManuallyBlocked = !1
            }
            isUpdateBlocked() {
                return this.updateManuallyBlocked || this.updateBlockedByResize
            }
            isTreeAnimationBlocked() {
                return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || !1
            }
            startUpdate() {
                !this.isUpdateBlocked() && (this.isUpdating = !0, this.nodes && this.nodes.forEach(tS), this.animationId++)
            }
            getTransformTemplate() {
                let {
                    visualElement: t
                } = this.options;
                return t && t.getProps().transformTemplate
            }
            willUpdate(t = !0) {
                if (this.root.hasTreeAnimated = !0, this.root.isUpdateBlocked()) {
                    this.options.onExitComplete && this.options.onExitComplete();
                    return
                }
                if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear && function t(e) {
                        if (e.hasCheckedOptimisedAppear = !0, e.root === e) return;
                        let {
                            visualElement: i
                        } = e.options;
                        if (!i) return;
                        let s = (0, l.getOptimisedAppearId)(i);
                        if (window.MotionHasOptimisedAnimation(s, "transform")) {
                            let {
                                layout: t,
                                layoutId: i
                            } = e.options;
                            window.MotionCancelOptimisedAnimation(s, "transform", ts.frame, !(t || i))
                        }
                        let {
                            parent: n
                        } = e;
                        n && !n.hasCheckedOptimisedAppear && t(n)
                    }(this), this.root.isUpdating || this.root.startUpdate(), this.isLayoutDirty) return;
                this.isLayoutDirty = !0;
                for (let t = 0; t < this.path.length; t++) {
                    let e = this.path[t];
                    e.shouldResetTransform = !0, ("string" == typeof e.latestValues.x || "string" == typeof e.latestValues.y) && (e.isLayoutDirty = !0), e.updateScroll("snapshot"), e.options.layoutRoot && e.willUpdate(!1)
                }
                let {
                    layoutId: e,
                    layout: i
                } = this.options;
                if (void 0 === e && !i) return;
                let s = this.getTransformTemplate();
                this.prevTransformTemplateValue = s ? s(this.latestValues, "") : void 0, this.updateSnapshot(), t && this.notifyListeners("willUpdate")
            }
            update() {
                if (this.updateScheduled = !1, this.isUpdateBlocked()) {
                    let t = this.updateBlockedByResize;
                    this.unblockUpdate(), this.updateBlockedByResize = !1, this.clearAllSnapshots(), t && this.nodes.forEach(tf), this.nodes.forEach(tp);
                    return
                }
                if (this.animationId <= this.animationCommitId) return void this.nodes.forEach(tv);
                this.animationCommitId = this.animationId, this.isUpdating ? (this.isUpdating = !1, this.nodes.forEach(tg), this.nodes.forEach(ty), this.nodes.forEach(tu), this.nodes.forEach(th)) : this.nodes.forEach(tv), this.clearAllSnapshots();
                let t = c.time.now();
                ts.frameData.delta = (0, r.clamp)(0, 1e3 / 60, t - ts.frameData.timestamp), ts.frameData.timestamp = t, ts.frameData.isProcessing = !0, ts.frameSteps.update.process(ts.frameData), ts.frameSteps.preRender.process(ts.frameData), ts.frameSteps.render.process(ts.frameData), ts.frameData.isProcessing = !1
            }
            didUpdate() {
                this.updateScheduled || (this.updateScheduled = !0, h.microtask.read(this.scheduleUpdate))
            }
            clearAllSnapshots() {
                this.nodes.forEach(tm), this.sharedNodes.forEach(tw)
            }
            scheduleUpdateProjection() {
                this.projectionUpdateScheduled || (this.projectionUpdateScheduled = !0, ts.frame.preRender(this.updateProjection, !1, !0))
            }
            scheduleCheckAfterUnmount() {
                ts.frame.postRender(() => {
                    this.isLayoutDirty ? this.root.didUpdate() : this.root.checkUpdateFailed()
                })
            }
            updateSnapshot() {
                !this.snapshot && this.instance && (this.snapshot = this.measure(), !this.snapshot || (0, O.calcLength)(this.snapshot.measuredBox.x) || (0, O.calcLength)(this.snapshot.measuredBox.y) || (this.snapshot = void 0))
            }
            updateLayout() {
                if (!this.instance || (this.updateScroll(), !(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty)) return;
                if (this.resumeFrom && !this.resumeFrom.instance)
                    for (let t = 0; t < this.path.length; t++) this.path[t].updateScroll();
                let t = this.layout;
                this.layout = this.measure(!1), this.layoutVersion++, this.layoutCorrected || (this.layoutCorrected = (0, G.createBox)()), this.isLayoutDirty = !1, this.projectionDelta = void 0, this.notifyListeners("measure", this.layout.layoutBox);
                let {
                    visualElement: e
                } = this.options;
                e && e.notify("LayoutMeasure", this.layout.layoutBox, t ? t.layoutBox : void 0)
            }
            updateScroll(t = "measure") {
                let e = !!(this.options.layoutScroll && this.instance);
                if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === t && (e = !1), e && this.instance) {
                    let e = s(this.instance);
                    this.scroll = {
                        animationId: this.root.animationId,
                        phase: t,
                        isRoot: e,
                        offset: i(this.instance),
                        wasRoot: this.scroll ? this.scroll.isRoot : e
                    }
                }
            }
            resetTransform() {
                if (!a) return;
                let t = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout,
                    e = this.projectionDelta && !$(this.projectionDelta),
                    i = this.getTransformTemplate(),
                    s = i ? i(this.latestValues, "") : void 0,
                    n = s !== this.prevTransformTemplateValue;
                t && this.instance && (e || (0, te.hasTransform)(this.latestValues) || n) && (a(this.instance, s), this.shouldResetTransform = !1, this.scheduleRender())
            }
            measure(t = !0) {
                var e;
                let i = this.measurePageBox(),
                    s = this.removeElementScroll(i);
                return t && (s = this.removeTransform(s)), tD((e = s).x), tD(e.y), {
                    animationId: this.root.animationId,
                    measuredBox: i,
                    layoutBox: s,
                    latestValues: {},
                    source: this.id
                }
            }
            measurePageBox() {
                let {
                    visualElement: t
                } = this.options;
                if (!t) return (0, G.createBox)();
                let e = t.measureViewportBox();
                if (!(this.scroll ? .wasRoot || this.path.some(tR))) {
                    let {
                        scroll: t
                    } = this.root;
                    t && ((0, F.translateAxis)(e.x, t.offset.x), (0, F.translateAxis)(e.y, t.offset.y))
                }
                return e
            }
            removeElementScroll(t) {
                let e = (0, G.createBox)();
                if (L(e, t), this.scroll ? .wasRoot) return e;
                for (let i = 0; i < this.path.length; i++) {
                    let s = this.path[i],
                        {
                            scroll: n,
                            options: r
                        } = s;
                    s !== this.root && n && r.layoutScroll && (n.wasRoot && L(e, t), (0, F.translateAxis)(e.x, n.offset.x), (0, F.translateAxis)(e.y, n.offset.y))
                }
                return e
            }
            applyTransform(t, e = !1, i) {
                let s = i || (0, G.createBox)();
                L(s, t);
                for (let t = 0; t < this.path.length; t++) {
                    let i = this.path[t];
                    !e && i.options.layoutScroll && i.scroll && i !== i.root && ((0, F.translateAxis)(s.x, -i.scroll.offset.x), (0, F.translateAxis)(s.y, -i.scroll.offset.y)), (0, te.hasTransform)(i.latestValues) && (0, F.transformBox)(s, i.latestValues, i.layout ? .layoutBox)
                }
                return (0, te.hasTransform)(this.latestValues) && (0, F.transformBox)(s, this.latestValues, this.layout ? .layoutBox), s
            }
            removeTransform(t) {
                let e = (0, G.createBox)();
                L(e, t);
                for (let t = 0; t < this.path.length; t++) {
                    let i, s = this.path[t];
                    (0, te.hasTransform)(s.latestValues) && (s.instance && ((0, te.hasScale)(s.latestValues) && s.updateSnapshot(), L(i = (0, G.createBox)(), s.measurePageBox())), W(e, s.latestValues, s.snapshot ? .layoutBox, i))
                }
                return (0, te.hasTransform)(this.latestValues) && W(e, this.latestValues), e
            }
            setTargetDelta(t) {
                this.targetDelta = t, this.root.scheduleUpdateProjection(), this.isProjectionDirty = !0
            }
            setOptions(t) {
                this.options = { ...this.options,
                    ...t,
                    crossfade: void 0 === t.crossfade || t.crossfade
                }
            }
            clearMeasurements() {
                this.scroll = void 0, this.layout = void 0, this.snapshot = void 0, this.prevTransformTemplateValue = void 0, this.targetDelta = void 0, this.target = void 0, this.isLayoutDirty = !1
            }
            forceRelativeParentToResolveTarget() {
                this.relativeParent && this.relativeParent.resolvedRelativeTargetAt !== ts.frameData.timestamp && this.relativeParent.resolveTargetDelta(!0)
            }
            resolveTargetDelta(t = !1) {
                let e = this.getLead();
                this.isProjectionDirty || (this.isProjectionDirty = e.isProjectionDirty), this.isTransformDirty || (this.isTransformDirty = e.isTransformDirty), this.isSharedProjectionDirty || (this.isSharedProjectionDirty = e.isSharedProjectionDirty);
                let i = !!this.resumingFrom || this !== e;
                if (!(t || i && this.isSharedProjectionDirty || this.isProjectionDirty || this.parent ? .isProjectionDirty || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize)) return;
                let {
                    layout: s,
                    layoutId: n
                } = this.options;
                if (!this.layout || !(s || n)) return;
                this.resolvedRelativeTargetAt = ts.frameData.timestamp;
                let r = this.getClosestProjectingParent();
                r && this.linkedParentVersion !== r.layoutVersion && !r.options.layoutRoot && this.removeRelativeTarget(), this.targetDelta || this.relativeTarget || (!1 !== this.options.layoutAnchor && r && r.layout ? this.createRelativeTarget(r, this.layout.layoutBox, r.layout.layoutBox) : this.removeRelativeTarget()), (this.relativeTarget || this.targetDelta) && (this.target || (this.target = (0, G.createBox)(), this.targetWithTransforms = (0, G.createBox)()), this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target ? (this.forceRelativeParentToResolveTarget(), (0, O.calcRelativeBox)(this.target, this.relativeTarget, this.relativeParent.target, this.options.layoutAnchor || void 0)) : this.targetDelta ? (this.resumingFrom ? this.applyTransform(this.layout.layoutBox, !1, this.target) : L(this.target, this.layout.layoutBox), (0, F.applyBoxDelta)(this.target, this.targetDelta)) : L(this.target, this.layout.layoutBox), this.attemptToResolveRelativeTarget && (this.attemptToResolveRelativeTarget = !1, !1 !== this.options.layoutAnchor && r && !!r.resumingFrom == !!this.resumingFrom && !r.options.layoutScroll && r.target && 1 !== this.animationProgress ? this.createRelativeTarget(r, this.target, r.target) : this.relativeParent = this.relativeTarget = void 0), p.statsBuffer.value && tn.calculatedTargetDeltas++)
            }
            getClosestProjectingParent() {
                if (!(!this.parent || (0, te.hasScale)(this.parent.latestValues) || (0, te.has2DTranslate)(this.parent.latestValues)))
                    if (this.parent.isProjecting()) return this.parent;
                    else return this.parent.getClosestProjectingParent()
            }
            isProjecting() {
                return !!((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout)
            }
            createRelativeTarget(t, e, i) {
                this.relativeParent = t, this.linkedParentVersion = t.layoutVersion, this.forceRelativeParentToResolveTarget(), this.relativeTarget = (0, G.createBox)(), this.relativeTargetOrigin = (0, G.createBox)(), (0, O.calcRelativePosition)(this.relativeTargetOrigin, e, i, this.options.layoutAnchor || void 0), L(this.relativeTarget, this.relativeTargetOrigin)
            }
            removeRelativeTarget() {
                this.relativeParent = this.relativeTarget = void 0
            }
            calcProjection() {
                let t = this.getLead(),
                    e = !!this.resumingFrom || this !== t,
                    i = !0;
                if ((this.isProjectionDirty || this.parent ? .isProjectionDirty) && (i = !1), e && (this.isSharedProjectionDirty || this.isTransformDirty) && (i = !1), this.resolvedRelativeTargetAt === ts.frameData.timestamp && (i = !1), i) return;
                let {
                    layout: s,
                    layoutId: n
                } = this.options;
                if (this.isTreeAnimating = !!(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation), this.isTreeAnimating || (this.targetDelta = this.relativeTarget = void 0), !this.layout || !(s || n)) return;
                L(this.layoutCorrected, this.layout.layoutBox);
                let r = this.treeScale.x,
                    a = this.treeScale.y;
                (0, F.applyTreeDeltas)(this.layoutCorrected, this.treeScale, this.path, e), t.layout && !t.target && (1 !== this.treeScale.x || 1 !== this.treeScale.y) && (t.target = t.layout.layoutBox, t.targetWithTransforms = (0, G.createBox)());
                let {
                    target: o
                } = t;
                if (!o) {
                    this.prevProjectionDelta && (this.createProjectionDeltas(), this.scheduleRender());
                    return
                }
                this.projectionDelta && this.prevProjectionDelta ? (B(this.prevProjectionDelta.x, this.projectionDelta.x), B(this.prevProjectionDelta.y, this.projectionDelta.y)) : this.createProjectionDeltas(), (0, O.calcBoxDelta)(this.projectionDelta, this.layoutCorrected, o, this.latestValues), this.treeScale.x === r && this.treeScale.y === a && q(this.projectionDelta.x, this.prevProjectionDelta.x) && q(this.projectionDelta.y, this.prevProjectionDelta.y) || (this.hasProjected = !0, this.scheduleRender(), this.notifyListeners("projectionUpdate", o)), p.statsBuffer.value && tn.calculatedProjections++
            }
            hide() {
                this.isVisible = !1
            }
            show() {
                this.isVisible = !0
            }
            scheduleRender(t = !0) {
                if (this.options.visualElement ? .scheduleRender(), t) {
                    let t = this.getStack();
                    t && t.scheduleRender()
                }
                this.resumingFrom && !this.resumingFrom.instance && (this.resumingFrom = void 0)
            }
            createProjectionDeltas() {
                this.prevProjectionDelta = (0, G.createDelta)(), this.projectionDelta = (0, G.createDelta)(), this.projectionDeltaWithTransform = (0, G.createDelta)()
            }
            setAnimationOrigin(t, e = !1) {
                let i, s = this.snapshot,
                    n = s ? s.latestValues : {},
                    r = { ...this.latestValues
                    },
                    a = (0, G.createDelta)();
                this.relativeParent && this.relativeParent.options.layoutRoot || (this.relativeTarget = this.relativeTargetOrigin = void 0), this.attemptToResolveRelativeTarget = !e;
                let o = (0, G.createBox)(),
                    l = (s ? s.source : void 0) !== (this.layout ? this.layout.source : void 0),
                    u = this.getStack(),
                    h = !u || u.members.length <= 1,
                    c = !!(l && !h && !0 === this.options.crossfade && !this.path.some(tM));
                this.animationProgress = 0, this.mixTargetDelta = e => {
                    let s = e / 1e3;
                    if (tP(a.x, t.x, s), tP(a.y, t.y, s), this.setTargetDelta(a), this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout) {
                        var u, d, m, p, f, v;
                        (0, O.calcRelativePosition)(o, this.layout.layoutBox, this.relativeParent.layout.layoutBox, this.options.layoutAnchor || void 0), m = this.relativeTarget, p = this.relativeTargetOrigin, f = o, v = s, tV(m.x, p.x, f.x, v), tV(m.y, p.y, f.y, v), i && (u = this.relativeTarget, d = i, H(u.x, d.x) && H(u.y, d.y)) && (this.isProjectionDirty = !1), i || (i = (0, G.createBox)()), L(i, this.relativeTarget)
                    }
                    l && (this.animationValues = r, function(t, e, i, s, n, r) {
                        n ? (t.opacity = (0, y.mixNumber)(0, i.opacity ? ? 1, C(s)), t.opacityExit = (0, y.mixNumber)(e.opacity ? ? 1, 0, D(s))) : r && (t.opacity = (0, y.mixNumber)(e.opacity ? ? 1, i.opacity ? ? 1, s));
                        for (let n = 0; n < V; n++) {
                            let r = P[n],
                                a = E(e, r),
                                o = E(i, r);
                            (void 0 !== a || void 0 !== o) && (a || (a = 0), o || (o = 0), 0 === a || 0 === o || A(a) === A(o) ? (t[r] = Math.max((0, y.mixNumber)(M(a), M(o), s), 0), (b.percent.test(o) || b.percent.test(a)) && (t[r] += "%")) : t[r] = o)
                        }(e.rotate || i.rotate) && (t.rotate = (0, y.mixNumber)(e.rotate || 0, i.rotate || 0, s))
                    }(r, n, this.latestValues, s, c, h)), this.root.scheduleUpdateProjection(), this.scheduleRender(), this.animationProgress = s
                }, this.mixTargetDelta(1e3 * !!this.options.layoutRoot)
            }
            startAnimation(t) {
                this.notifyListeners("animationStart"), this.currentAnimation ? .stop(), this.resumingFrom ? .currentAnimation ? .stop(), this.pendingAnimation && ((0, ts.cancelFrame)(this.pendingAnimation), this.pendingAnimation = void 0), this.pendingAnimation = ts.frame.update(() => {
                    ti.globalProjectionState.hasAnimatedSinceResize = !0, m.activeAnimations.layout++, this.motionValue || (this.motionValue = (0, x.motionValue)(0)), this.motionValue.jump(0, !1), this.currentAnimation = (0, o.animateSingleValue)(this.motionValue, [0, 1e3], { ...t,
                        velocity: 0,
                        isSync: !0,
                        onUpdate: e => {
                            this.mixTargetDelta(e), t.onUpdate && t.onUpdate(e)
                        },
                        onStop: () => {
                            m.activeAnimations.layout--
                        },
                        onComplete: () => {
                            m.activeAnimations.layout--, t.onComplete && t.onComplete(), this.completeAnimation()
                        }
                    }), this.resumingFrom && (this.resumingFrom.currentAnimation = this.currentAnimation), this.pendingAnimation = void 0
                })
            }
            completeAnimation() {
                this.resumingFrom && (this.resumingFrom.currentAnimation = void 0, this.resumingFrom.preserveOpacity = void 0);
                let t = this.getStack();
                t && t.exitAnimationComplete(), this.resumingFrom = this.currentAnimation = this.animationValues = void 0, this.notifyListeners("animationComplete")
            }
            finishAnimation() {
                this.currentAnimation && (this.mixTargetDelta && this.mixTargetDelta(1e3), this.currentAnimation.stop()), this.completeAnimation()
            }
            applyTransformsToTarget() {
                let t = this.getLead(),
                    {
                        targetWithTransforms: e,
                        target: i,
                        layout: s,
                        latestValues: n
                    } = t;
                if (e && i && s) {
                    if (this !== t && this.layout && s && tk(this.options.animationType, this.layout.layoutBox, s.layoutBox)) {
                        i = this.target || (0, G.createBox)();
                        let e = (0, O.calcLength)(this.layout.layoutBox.x);
                        i.x.min = t.target.x.min, i.x.max = i.x.min + e;
                        let s = (0, O.calcLength)(this.layout.layoutBox.y);
                        i.y.min = t.target.y.min, i.y.max = i.y.min + s
                    }
                    L(e, i), (0, F.transformBox)(e, n), (0, O.calcBoxDelta)(this.projectionDeltaWithTransform, this.layoutCorrected, e, n)
                }
            }
            registerSharedNode(t, e) {
                this.sharedNodes.has(t) || this.sharedNodes.set(t, new _), this.sharedNodes.get(t).add(e);
                let i = e.options.initialPromotionConfig;
                e.promote({
                    transition: i ? i.transition : void 0,
                    preserveFollowOpacity: i && i.shouldPreserveFollowOpacity ? i.shouldPreserveFollowOpacity(e) : void 0
                })
            }
            isLead() {
                let t = this.getStack();
                return !t || t.lead === this
            }
            getLead() {
                let {
                    layoutId: t
                } = this.options;
                return t && this.getStack() ? .lead || this
            }
            getPrevLead() {
                let {
                    layoutId: t
                } = this.options;
                return t ? this.getStack() ? .prevLead : void 0
            }
            getStack() {
                let {
                    layoutId: t
                } = this.options;
                if (t) return this.root.sharedNodes.get(t)
            }
            promote({
                needsReset: t,
                transition: e,
                preserveFollowOpacity: i
            } = {}) {
                let s = this.getStack();
                s && s.promote(this, i), t && (this.projectionDelta = void 0, this.needsReset = !0), e && this.setOptions({
                    transition: e
                })
            }
            relegate() {
                let t = this.getStack();
                return !!t && t.relegate(this)
            }
            resetSkewAndRotation() {
                let {
                    visualElement: t
                } = this.options;
                if (!t) return;
                let e = !1,
                    {
                        latestValues: i
                    } = t;
                if ((i.z || i.rotate || i.rotateX || i.rotateY || i.rotateZ || i.skewX || i.skewY) && (e = !0), !e) return;
                let s = {};
                i.z && to("z", t, s, this.animationValues);
                for (let e = 0; e < tr.length; e++) to(`rotate${tr[e]}`, t, s, this.animationValues), to(`skew${tr[e]}`, t, s, this.animationValues);
                for (let e in t.render(), s) t.setStaticValue(e, s[e]), this.animationValues && (this.animationValues[e] = s[e]);
                t.scheduleRender()
            }
            applyProjectionStyles(t, e) {
                if (!this.instance || this.isSVG) return;
                if (!this.isVisible) {
                    t.visibility = "hidden";
                    return
                }
                let i = this.getTransformTemplate();
                if (this.needsReset) {
                    this.needsReset = !1, t.visibility = "", t.opacity = "", t.pointerEvents = (0, T.resolveMotionValue)(e ? .pointerEvents) || "", t.transform = i ? i(this.latestValues, "") : "none";
                    return
                }
                let s = this.getLead();
                if (!this.projectionDelta || !this.layout || !s.target) {
                    this.options.layoutId && (t.opacity = void 0 !== this.latestValues.opacity ? this.latestValues.opacity : 1, t.pointerEvents = (0, T.resolveMotionValue)(e ? .pointerEvents) || ""), this.hasProjected && !(0, te.hasTransform)(this.latestValues) && (t.transform = i ? i({}, "") : "none", this.hasProjected = !1);
                    return
                }
                t.visibility = "";
                let n = s.animationValues || s.latestValues;
                this.applyTransformsToTarget();
                let r = function(t, e, i) {
                    let s = "",
                        n = t.x.translate / e.x,
                        r = t.y.translate / e.y,
                        a = i ? .z || 0;
                    if ((n || r || a) && (s = `translate3d(${n}px, ${r}px, ${a}px) `), (1 !== e.x || 1 !== e.y) && (s += `scale(${1/e.x}, ${1/e.y}) `), i) {
                        let {
                            transformPerspective: t,
                            rotate: e,
                            rotateX: n,
                            rotateY: r,
                            skewX: a,
                            skewY: o
                        } = i;
                        t && (s = `perspective(${t}px) ${s}`), e && (s += `rotate(${e}deg) `), n && (s += `rotateX(${n}deg) `), r && (s += `rotateY(${r}deg) `), a && (s += `skewX(${a}deg) `), o && (s += `skewY(${o}deg) `)
                    }
                    let o = t.x.scale * e.x,
                        l = t.y.scale * e.y;
                    return (1 !== o || 1 !== l) && (s += `scale(${o}, ${l})`), s || "none"
                }(this.projectionDeltaWithTransform, this.treeScale, n);
                i && (r = i(n, r)), t.transform = r;
                let {
                    x: a,
                    y: o
                } = this.projectionDelta;
                for (let e in t.transformOrigin = `${100*a.origin}% ${100*o.origin}% 0`, s.animationValues ? t.opacity = s === this ? n.opacity ? ? this.latestValues.opacity ? ? 1 : this.preserveOpacity ? this.latestValues.opacity : n.opacityExit : t.opacity = s === this ? void 0 !== n.opacity ? n.opacity : "" : void 0 !== n.opacityExit ? n.opacityExit : 0, d.scaleCorrectors) {
                    if (void 0 === n[e]) continue;
                    let {
                        correct: i,
                        applyTo: a,
                        isCSSVariable: o
                    } = d.scaleCorrectors[e], l = "none" === r ? n[e] : i(n[e], s);
                    if (a) {
                        let e = a.length;
                        for (let i = 0; i < e; i++) t[a[i]] = l
                    } else o ? this.options.visualElement.renderState.vars[e] = l : t[e] = l
                }
                this.options.layoutId && (t.pointerEvents = s === this ? (0, T.resolveMotionValue)(e ? .pointerEvents) || "" : "none")
            }
            clearSnapshot() {
                this.resumeFrom = this.snapshot = void 0
            }
            resetTree() {
                this.root.nodes.forEach(t => t.currentAnimation ? .stop()), this.root.nodes.forEach(tp), this.root.sharedNodes.clear()
            }
        }
    }

    function tu(t) {
        t.updateLayout()
    }

    function th(t) {
        let e = t.resumeFrom ? .snapshot || t.snapshot;
        if (t.isLead() && t.layout && e && t.hasListeners("didUpdate")) {
            let {
                layoutBox: i,
                measuredBox: s
            } = t.layout, {
                animationType: n
            } = t.options, r = e.source !== t.layout.source;
            if ("size" === n)(0, J.eachAxis)(t => {
                let s = r ? e.measuredBox[t] : e.layoutBox[t],
                    n = (0, O.calcLength)(s);
                s.min = i[t].min, s.max = s.min + n
            });
            else if ("x" === n || "y" === n) {
                let t = "x" === n ? "y" : "x";
                R(r ? e.measuredBox[t] : e.layoutBox[t], i[t])
            } else tk(n, e.layoutBox, i) && (0, J.eachAxis)(s => {
                let n = r ? e.measuredBox[s] : e.layoutBox[s],
                    a = (0, O.calcLength)(i[s]);
                n.max = n.min + a, t.relativeTarget && !t.currentAnimation && (t.isProjectionDirty = !0, t.relativeTarget[s].max = t.relativeTarget[s].min + a)
            });
            let a = (0, G.createDelta)();
            (0, O.calcBoxDelta)(a, i, e.layoutBox);
            let o = (0, G.createDelta)();
            r ? (0, O.calcBoxDelta)(o, t.applyTransform(s, !0), e.measuredBox) : (0, O.calcBoxDelta)(o, i, e.layoutBox);
            let l = !$(a),
                u = !1;
            if (!t.resumeFrom) {
                let s = t.getClosestProjectingParent();
                if (s && !s.resumeFrom) {
                    let {
                        snapshot: n,
                        layout: r
                    } = s;
                    if (n && r) {
                        let a = t.options.layoutAnchor || void 0,
                            o = (0, G.createBox)();
                        (0, O.calcRelativePosition)(o, e.layoutBox, n.layoutBox, a);
                        let l = (0, G.createBox)();
                        (0, O.calcRelativePosition)(l, i, r.layoutBox, a), Y(o, l) || (u = !0), s.options.layoutRoot && (t.relativeTarget = l, t.relativeTargetOrigin = o, t.relativeParent = s)
                    }
                }
            }
            t.notifyListeners("didUpdate", {
                layout: i,
                snapshot: e,
                delta: o,
                layoutDelta: a,
                hasLayoutChanged: l,
                hasRelativeLayoutChanged: u
            })
        } else if (t.isLead()) {
            let {
                onExitComplete: e
            } = t.options;
            e && e()
        }
        t.options.transition = void 0
    }

    function tc(t) {
        p.statsBuffer.value && tn.nodes++, t.parent && (t.isProjecting() || (t.isProjectionDirty = t.parent.isProjectionDirty), t.isSharedProjectionDirty || (t.isSharedProjectionDirty = !!(t.isProjectionDirty || t.parent.isProjectionDirty || t.parent.isSharedProjectionDirty)), t.isTransformDirty || (t.isTransformDirty = t.parent.isTransformDirty))
    }

    function td(t) {
        t.isProjectionDirty = t.isSharedProjectionDirty = t.isTransformDirty = !1
    }

    function tm(t) {
        t.clearSnapshot()
    }

    function tp(t) {
        t.clearMeasurements()
    }

    function tf(t) {
        t.isLayoutDirty = !0, t.updateLayout()
    }

    function tv(t) {
        t.isLayoutDirty = !1
    }

    function tg(t) {
        t.isAnimationBlocked && t.layout && !t.isLayoutDirty && (t.snapshot = t.layout, t.isLayoutDirty = !0)
    }

    function ty(t) {
        let {
            visualElement: e
        } = t.options;
        e && e.getProps().onBeforeLayoutMeasure && e.notify("BeforeLayoutMeasure"), t.resetTransform()
    }

    function tx(t) {
        t.finishAnimation(), t.targetDelta = t.relativeTarget = t.target = void 0, t.isProjectionDirty = !0
    }

    function tT(t) {
        t.resolveTargetDelta()
    }

    function tb(t) {
        t.calcProjection()
    }

    function tS(t) {
        t.resetSkewAndRotation()
    }

    function tw(t) {
        t.removeLeadSnapshot()
    }

    function tP(t, e, i) {
        t.translate = (0, y.mixNumber)(e.translate, 0, i), t.scale = (0, y.mixNumber)(e.scale, 1, i), t.origin = e.origin, t.originPoint = e.originPoint
    }

    function tV(t, e, i, s) {
        t.min = (0, y.mixNumber)(e.min, i.min, s), t.max = (0, y.mixNumber)(e.max, i.max, s)
    }

    function tM(t) {
        return t.animationValues && void 0 !== t.animationValues.opacityExit
    }
    let tA = {
            duration: .45,
            ease: [.4, 0, .1, 1]
        },
        tE = t => "u" > typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().includes(t),
        tC = tE("applewebkit/") && !tE("chrome/") ? Math.round : a.noop;

    function tD(t) {
        t.min = tC(t.min), t.max = tC(t.max)
    }

    function tk(t, e, i) {
        return "position" === t || "preserve-aspect" === t && !(0, O.isNear)(X(e), X(i), .2)
    }

    function tR(t) {
        return t !== t.root && t.scroll ? .wasRoot
    }
    var tL = t.i(319106);
    let tB = tl({
            attachResizeListener: (t, e) => (0, tL.addDomEvent)(t, "resize", e),
            measureScroll: () => ({
                x: document.documentElement.scrollLeft || document.body ? .scrollLeft || 0,
                y: document.documentElement.scrollTop || document.body ? .scrollTop || 0
            }),
            checkIsScrollRoot: () => !0
        }),
        tF = {
            current: void 0
        },
        tO = tl({
            measureScroll: t => ({
                x: t.scrollLeft,
                y: t.scrollTop
            }),
            defaultParent: () => {
                if (!tF.current) {
                    let t = new tB({});
                    t.mount(window), t.setOptions({
                        layoutScroll: !0
                    }), tF.current = t
                }
                return tF.current
            },
            resetTransform: (t, e) => {
                t.style.transform = void 0 !== e ? e : "none"
            },
            checkIsScrollRoot: t => "fixed" === window.getComputedStyle(t).position
        });
    t.s(["HTMLProjectionNode", 0, tO], 466142);
    let tj = {
        pan: {
            Feature: i.PanGesture
        },
        drag: {
            Feature: e.DragGesture,
            ProjectionNode: tO,
            MeasureLayout: s.MeasureLayout
        }
    };
    t.s(["drag", 0, tj], 905959);
    var tI = t.i(431424),
        tN = t.i(355722),
        tU = t.i(279393);

    function tW(t, e) {
        let i = (0, tU.resolveElements)(t),
            s = new AbortController;
        return [i, {
            passive: !0,
            ...e,
            signal: s.signal
        }, () => s.abort()]
    }
    t.s(["setupGesture", 0, tW], 328189);
    var tG = t.i(200280);

    function tz(t, e, i) {
        let {
            props: s
        } = t;
        t.animationState && s.whileHover && t.animationState.setActive("whileHover", "Start" === i);
        let n = s["onHover" + i];
        n && ts.frame.postRender(() => n(e, (0, tG.extractEventInfo)(e)))
    }
    class t$ extends tI.Feature {
        mount() {
            let {
                current: t
            } = this.node;
            t && (this.unmount = function(t, e, i = {}) {
                let [s, n, r] = tW(t, i);
                return s.forEach(t => {
                    let i, s = !1,
                        r = !1,
                        a = e => {
                            i && (i(e), i = void 0), t.removeEventListener("pointerleave", l)
                        },
                        o = t => {
                            s = !1, window.removeEventListener("pointerup", o), window.removeEventListener("pointercancel", o), r && (r = !1, a(t))
                        },
                        l = t => {
                            if ("touch" !== t.pointerType) {
                                if (s) {
                                    r = !0;
                                    return
                                }
                                a(t)
                            }
                        };
                    t.addEventListener("pointerenter", s => {
                        if ("touch" === s.pointerType || (0, tN.isDragActive)()) return;
                        r = !1;
                        let a = e(t, s);
                        "function" == typeof a && (i = a, t.addEventListener("pointerleave", l, n))
                    }, n), t.addEventListener("pointerdown", () => {
                        s = !0, window.addEventListener("pointerup", o, n), window.addEventListener("pointercancel", o, n)
                    }, n)
                }), r
            }(t, (t, e) => (tz(this.node, e, "Start"), t => tz(this.node, t, "End"))))
        }
        unmount() {}
    }
    t.s(["HoverGesture", 0, t$], 393002);
    var tH = tI,
        tK = t.i(10968);
    class tY extends tH.Feature {
        constructor() {
            super(...arguments), this.isActive = !1
        }
        onFocus() {
            let t = !1;
            try {
                t = this.node.current.matches(":focus-visible")
            } catch (e) {
                t = !0
            }
            t && this.node.animationState && (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0)
        }
        onBlur() {
            this.isActive && this.node.animationState && (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1)
        }
        mount() {
            this.unmount = (0, tK.pipe)((0, tL.addDomEvent)(this.node.current, "focus", () => this.onFocus()), (0, tL.addDomEvent)(this.node.current, "blur", () => this.onBlur()))
        }
        unmount() {}
    }
    t.s(["FocusGesture", 0, tY], 973534)
}, 215959, t => {
    "use strict";
    var e = t.i(764667),
        i = t.i(562862),
        s = t.i(700330),
        n = t.i(905959),
        r = t.i(393002),
        a = t.i(973534),
        o = t.i(431424),
        l = t.i(141355),
        u = t.i(355722);
    let h = (t, e) => !!e && (t === e || h(t, e.parentElement));
    var c = t.i(771178),
        d = t.i(328189),
        m = t.i(919661);
    let p = new WeakSet;

    function f(t) {
        return e => {
            "Enter" === e.key && t(e)
        }
    }

    function v(t, e) {
        t.dispatchEvent(new PointerEvent("pointer" + e, {
            isPrimary: !0,
            bubbles: !0
        }))
    }

    function g(t) {
        return (0, c.isPrimaryPointer)(t) && !(0, u.isDragActive)()
    }
    let y = new WeakSet;
    var x = t.i(839589),
        T = t.i(200280);

    function b(t, e, i) {
        let {
            props: s
        } = t;
        if (t.current instanceof HTMLButtonElement && t.current.disabled) return;
        t.animationState && s.whileTap && t.animationState.setActive("whileTap", "Start" === i);
        let n = s["onTap" + ("End" === i ? "" : i)];
        n && x.frame.postRender(() => n(e, (0, T.extractEventInfo)(e)))
    }
    class S extends o.Feature {
        mount() {
            let {
                current: t
            } = this.node;
            if (!t) return;
            let {
                globalTapTarget: e,
                propagate: i
            } = this.node.props;
            this.unmount = function(t, e, i = {}) {
                let [s, n, r] = (0, d.setupGesture)(t, i), a = t => {
                    let s = t.currentTarget;
                    if (!g(t) || y.has(t)) return;
                    p.add(s), i.stopPropagation && y.add(t);
                    let r = e(s, t),
                        a = (t, e) => {
                            window.removeEventListener("pointerup", o), window.removeEventListener("pointercancel", l), p.has(s) && p.delete(s), g(t) && "function" == typeof r && r(t, {
                                success: e
                            })
                        },
                        o = t => {
                            a(t, s === window || s === document || i.useGlobalTarget || h(s, t.target))
                        },
                        l = t => {
                            a(t, !1)
                        };
                    window.addEventListener("pointerup", o, n), window.addEventListener("pointercancel", l, n)
                };
                return s.forEach(t => {
                    (i.useGlobalTarget ? window : t).addEventListener("pointerdown", a, n), (0, l.isHTMLElement)(t) && (t.addEventListener("focus", t => ((t, e) => {
                        let i = t.currentTarget;
                        if (!i) return;
                        let s = f(() => {
                            if (p.has(i)) return;
                            v(i, "down");
                            let t = f(() => {
                                v(i, "up")
                            });
                            i.addEventListener("keyup", t, e), i.addEventListener("blur", () => v(i, "cancel"), e)
                        });
                        i.addEventListener("keydown", s, e), i.addEventListener("blur", () => i.removeEventListener("keydown", s), e)
                    })(t, n)), (0, m.isElementKeyboardAccessible)(t) || t.hasAttribute("tabindex") || (t.tabIndex = 0))
                }), r
            }(t, (t, e) => (b(this.node, e, "Start"), (t, {
                success: e
            }) => b(this.node, t, e ? "End" : "Cancel")), {
                useGlobalTarget: e,
                stopPropagation: i ? .tap === !1
            })
        }
        unmount() {}
    }
    var w = o;
    let P = new WeakMap,
        V = new WeakMap,
        M = t => {
            let e = P.get(t.target);
            e && e(t)
        },
        A = t => {
            t.forEach(M)
        },
        E = {
            some: 0,
            all: 1
        };
    class C extends w.Feature {
        constructor() {
            super(...arguments), this.hasEnteredView = !1, this.isInView = !1
        }
        startObserver() {
            var t;
            let e;
            this.stopObserver ? .();
            let {
                viewport: i = {}
            } = this.node.getProps(), {
                root: s,
                margin: n,
                amount: r = "some",
                once: a
            } = i, o = {
                root: s ? s.current : void 0,
                rootMargin: n,
                threshold: "number" == typeof r ? r : E[r]
            }, l = t => {
                let {
                    isIntersecting: e
                } = t;
                if (this.isInView === e || (this.isInView = e, a && !e && this.hasEnteredView)) return;
                e && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", e);
                let {
                    onViewportEnter: i,
                    onViewportLeave: s
                } = this.node.getProps(), n = e ? i : s;
                n && n(t)
            };
            this.stopObserver = (t = this.node.current, e = function({
                root: t,
                ...e
            }) {
                let i = t || document;
                V.has(i) || V.set(i, {});
                let s = V.get(i),
                    n = JSON.stringify(e);
                return s[n] || (s[n] = new IntersectionObserver(A, {
                    root: t,
                    ...e
                })), s[n]
            }(o), P.set(t, l), e.observe(t), () => {
                P.delete(t), e.unobserve(t)
            })
        }
        mount() {
            this.startObserver()
        }
        update() {
            if ("u" < typeof IntersectionObserver) return;
            let {
                props: t,
                prevProps: e
            } = this.node;
            ["amount", "margin", "root"].some(function({
                viewport: t = {}
            }, {
                viewport: e = {}
            } = {}) {
                return i => t[i] !== e[i]
            }(t, e)) && this.startObserver()
        }
        unmount() {
            this.stopObserver ? .(), this.hasEnteredView = !1, this.isInView = !1
        }
    }
    let D = {
        inView: {
            Feature: C
        },
        tap: {
            Feature: S
        },
        focus: {
            Feature: a.FocusGesture
        },
        hover: {
            Feature: r.HoverGesture
        }
    };
    var k = t.i(466142),
        R = t.i(38240);
    let L = {
            layout: {
                ProjectionNode: k.HTMLProjectionNode,
                MeasureLayout: R.MeasureLayout
            }
        },
        B = { ...s.animations,
            ...D,
            ...n.drag,
            ...L
        },
        F = (0, i.createMotionProxy)(B, e.createDomVisualElement);
    t.s(["motion", 0, F], 215959)
}, 300792, t => {
    "use strict";
    var e = t.i(416340);
    t.s(["usePrevious", 0, function(t) {
        let i = e.useRef({
            value: t,
            previous: t
        });
        return e.useMemo(() => (i.current.value !== t && (i.current.previous = i.current.value, i.current.value = t), i.current.previous), [t])
    }])
}]);

//# debugId=d20101f7-e758-30a1-aeaa-bff3fb8b273e