;
! 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] = "32fa5c16-2b61-91e7-3a3a-666a4f68780b")
    } catch (e) {}
}();
(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["object" == typeof document ? document.currentScript : void 0, 817703, e => {
    "use strict";
    e.s(["BROWSER", 0, !0], 817703)
}, 686518, 418956, 907855, e => {
    "use strict";
    var t = e.i(416340),
        i = e.i(817703);
    let s = String.raw,
        n = String.raw,
        r = i.BROWSER && (() => {
            try {
                document.createElement("div").animate({
                    opacity: 0
                }, {
                    easing: "linear(0, 1)"
                })
            } catch {
                return !1
            }
            return !0
        })(),
        a = i.BROWSER && "u" > typeof CSS && CSS.supports && CSS.supports("line-height", "mod(1,1)"),
        l = i.BROWSER && "u" > typeof matchMedia ? matchMedia("(prefers-reduced-motion: reduce)") : null,
        o = "--_number-flow-d-opacity",
        h = "--_number-flow-d-width",
        u = "--_number-flow-dx",
        c = "--_number-flow-d",
        p = (() => {
            try {
                return CSS.registerProperty({
                    name: o,
                    syntax: "<number>",
                    inherits: !1,
                    initialValue: "0"
                }), CSS.registerProperty({
                    name: u,
                    syntax: "<length>",
                    inherits: !0,
                    initialValue: "0px"
                }), CSS.registerProperty({
                    name: h,
                    syntax: "<number>",
                    inherits: !1,
                    initialValue: "0"
                }), CSS.registerProperty({
                    name: c,
                    syntax: "<number>",
                    inherits: !0,
                    initialValue: "0"
                }), !0
            } catch {
                return !1
            }
        })(),
        d = "round(nearest, calc(var(--number-flow-mask-height, 0.25em) / 2), 1px)",
        f = `calc(${d} * 2)`,
        m = "var(--number-flow-mask-width, 0.5em)",
        g = `calc(${m} / var(--scale-x))`,
        y = "#000 0, transparent 71%",
        v = n `:host{display:inline-block;direction:ltr;white-space:nowrap;isolation:isolate;line-height:1}.number,.number__inner{display:inline-block;transform-origin:left top}:host([data-will-change]) :is(.number,.number__inner,.section,.digit,.digit__num,.symbol){will-change:transform}.number{--scale-x:calc(1 + var(${h}) / var(--width));transform:translateX(var(${u})) scaleX(var(--scale-x));margin:0 calc(-1 * ${m});position:relative;-webkit-mask-image:linear-gradient(to right,transparent 0,#000 ${g},#000 calc(100% - ${g}),transparent ),linear-gradient(to bottom,transparent 0,#000 ${f},#000 calc(100% - ${f}),transparent 100% ),radial-gradient(at bottom right,${y}),radial-gradient(at bottom left,${y}),radial-gradient(at top left,${y}),radial-gradient(at top right,${y});-webkit-mask-size:100% calc(100% - ${f} * 2),calc(100% - ${g} * 2) 100%,${g} ${f},${g} ${f},${g} ${f},${g} ${f};-webkit-mask-position:center,center,top left,top right,bottom right,bottom left;-webkit-mask-repeat:no-repeat}.number__inner{padding:${d} ${m};transform:scaleX(calc(1 / var(--scale-x))) translateX(calc(-1 * var(${u})))}:host > :not(.number){z-index:5}.section,.symbol{display:inline-block;position:relative;isolation:isolate}.section::after{content:'\200b';display:inline-block}.section--justify-left{transform-origin:center left}.section--justify-right{transform-origin:center right}.section > [inert],.symbol > [inert]{margin:0 !important;position:absolute !important;z-index:-1}.digit{display:inline-block;position:relative;--c:var(--current) + var(${c})}.digit__num,.number .section::after{padding:${d} 0}.digit__num{display:inline-block;--offset-raw:mod(var(--length) + var(--n) - mod(var(--c),var(--length)),var(--length));--offset:calc( var(--offset-raw) - var(--length) * round(down,var(--offset-raw) / (var(--length) / 2),1) );--y:clamp(-100%,var(--offset) * 100%,100%);transform:translateY(var(--y))}.digit__num[inert]{position:absolute;top:0;left:50%;transform:translateX(-50%) translateY(var(--y))}.digit:not(.is-spinning) .digit__num[inert]{display:none}.symbol__value{display:inline-block;mix-blend-mode:plus-lighter;white-space:pre}.section--justify-left .symbol > [inert]{left:0}.section--justify-right .symbol > [inert]{right:0}.animate-presence{opacity:calc(1 + var(${o}))}`,
        b = i.BROWSER ? HTMLElement : class {},
        w = n `:host{display:inline-block;direction:ltr;white-space:nowrap;line-height:1}span{display:inline-block}:host([data-will-change]) span{will-change:transform}.number,.digit{padding:${d} 0}.symbol{white-space:pre}`,
        _ = (e, t) => `<span part="${t}">${e.reduce((e,t)=>e+`<span class="${"integer"===t.type||"fraction"===t.type?"digit":"symbol"}" part="${"integer"===t.type||"fraction"===t.type?`digit ${t.type}-digit`:`symbol ${t.type}`}">${t.value}</span>`,"")}</span>`,
        R = (e = "") => n `:where(number-flow${e}){line-height:1}number-flow${e} > span{font-kerning:none;display:inline-block;padding:${f} 0}`,
        E = (e, t, i) => {
            let s = document.createElement(e),
                [n, r] = Array.isArray(t) ? [void 0, t] : [t, i];
            return n && Object.assign(s, n), null == r || r.forEach(e => s.appendChild(e)), s
        },
        S = a && r && p;
    class $ extends b {
        constructor() {
            super(), this.created = !1, this.batched = !1;
            const {
                animated: e,
                ...t
            } = this.constructor.defaultProps;
            this._animated = this.computedAnimated = e, Object.assign(this, t)
        }
        get animated() {
            return this._animated
        }
        set animated(e) {
            var t;
            this.animated !== e && (this._animated = e, null == (t = this.shadowRoot) || t.getAnimations().forEach(e => e.finish()))
        }
        set data(e) {
            var t;
            if (null == e) return;
            let {
                pre: i,
                integer: s,
                fraction: n,
                post: r,
                value: a
            } = e;
            if (this.created) {
                let o = this._data;
                this._data = e, this.computedTrend = "function" == typeof this.trend ? this.trend(o.value, a) : this.trend, this.computedAnimated = S && this._animated && (!this.respectMotionPreference || !(null != l && l.matches)) && this.offsetWidth > 0 && this.offsetHeight > 0 && "visible" === this.ownerDocument.visibilityState, null == (t = this.plugins) || t.forEach(t => {
                    var i;
                    return null == (i = t.onUpdate) ? void 0 : i.call(t, e, o, this)
                }), this.batched || this.willUpdate(), this._pre.update(i), this._num.update({
                    integer: s,
                    fraction: n
                }), this._post.update(r), this.batched || this.didUpdate()
            } else {
                this._data = e, this.attachShadow({
                    mode: "open"
                });
                try {
                    this._internals ? ? (this._internals = this.attachInternals()), this._internals.role = "img"
                } catch {}
                let t = document.createElement("style");
                this.nonce && (t.nonce = this.nonce), t.textContent = v, this.shadowRoot.appendChild(t), this._pre = new k(this, i, {
                    justify: "right",
                    part: "left"
                }), this.shadowRoot.appendChild(this._pre.el), this._num = new C(this, s, n), this.shadowRoot.appendChild(this._num.el), this._post = new k(this, r, {
                    justify: "left",
                    part: "right"
                }), this.shadowRoot.appendChild(this._post.el), this.created = !0
            }
            try {
                this._internals.ariaLabel = e.valueAsString
            } catch {}
        }
        willUpdate() {
            this._pre.willUpdate(), this._num.willUpdate(), this._post.willUpdate()
        }
        didUpdate() {
            if (!this.computedAnimated) return;
            this._abortAnimationsFinish ? this._abortAnimationsFinish.abort() : this.dispatchEvent(new Event("animationsstart")), this._pre.didUpdate(), this._num.didUpdate(), this._post.didUpdate();
            let e = new AbortController;
            Promise.all(this.shadowRoot.getAnimations().map(e => e.finished)).then(() => {
                e.signal.aborted || (this.dispatchEvent(new Event("animationsfinish")), this._abortAnimationsFinish = void 0)
            }), this._abortAnimationsFinish = e
        }
    }
    $.defaultProps = {
        transformTiming: {
            duration: 900,
            easing: "linear(0,.005,.019,.039,.066,.096,.129,.165,.202,.24,.278,.316,.354,.39,.426,.461,.494,.526,.557,.586,.614,.64,.665,.689,.711,.731,.751,.769,.786,.802,.817,.831,.844,.856,.867,.877,.887,.896,.904,.912,.919,.925,.931,.937,.942,.947,.951,.955,.959,.962,.965,.968,.971,.973,.976,.978,.98,.981,.983,.984,.986,.987,.988,.989,.99,.991,.992,.992,.993,.994,.994,.995,.995,.996,.996,.9963,.9967,.9969,.9972,.9975,.9977,.9979,.9981,.9982,.9984,.9985,.9987,.9988,.9989,1)"
        },
        spinTiming: void 0,
        opacityTiming: {
            duration: 450,
            easing: "ease-out"
        },
        animated: !0,
        trend: (e, t) => Math.sign(t - e),
        respectMotionPreference: !0,
        plugins: void 0,
        digits: void 0
    };
    class C {
        constructor(e, t, i, {
            className: s,
            ...n
        } = {}) {
            this.flow = e, this._integer = new O(e, t, {
                justify: "right",
                part: "integer"
            }), this._fraction = new O(e, i, {
                justify: "left",
                part: "fraction"
            }), this._inner = E("span", {
                className: "number__inner"
            }, [this._integer.el, this._fraction.el]), this.el = E("span", { ...n,
                part: "number",
                className: `number ${s??""}`
            }, [this._inner])
        }
        willUpdate() {
            this._prevWidth = this.el.offsetWidth, this._prevLeft = this.el.getBoundingClientRect().left, this._integer.willUpdate(), this._fraction.willUpdate()
        }
        update({
            integer: e,
            fraction: t
        }) {
            this._integer.update(e), this._fraction.update(t)
        }
        didUpdate() {
            let e = this.el.getBoundingClientRect();
            this._integer.didUpdate(), this._fraction.didUpdate();
            let t = this._prevLeft - e.left,
                i = this.el.offsetWidth,
                s = this._prevWidth - i;
            this.el.style.setProperty("--width", String(i)), this.el.animate({
                [u]: [`${t}px`, "0px"],
                [h]: [s, 0]
            }, { ...this.flow.transformTiming,
                composite: "accumulate"
            })
        }
    }
    class x {
        constructor(e, t, {
            justify: i,
            className: s,
            ...n
        }, r) {
            this.flow = e, this.children = new Map, this.onCharRemove = e => () => {
                this.children.delete(e)
            }, this.justify = i;
            const a = t.map(e => this.addChar(e).el);
            this.el = E("span", { ...n,
                className: `section section--justify-${i} ${s??""}`
            }, r ? r(a) : a)
        }
        addChar(e, {
            startDigitsAtZero: t = !1,
            ...i
        } = {}) {
            let s = "integer" === e.type || "fraction" === e.type ? new M(this, e.type, t ? 0 : e.value, e.pos, { ...i,
                onRemove: this.onCharRemove(e.key)
            }) : new L(this, e.type, e.value, { ...i,
                onRemove: this.onCharRemove(e.key)
            });
            return this.children.set(e.key, s), s
        }
        unpop(e) {
            e.el.removeAttribute("inert"), e.el.style.top = "", e.el.style[this.justify] = ""
        }
        pop(e) {
            e.forEach(e => {
                var t, i;
                e.el.style.top = `${e.el.offsetTop}px`, e.el.style[this.justify] = `${t=e.el,"left"===this.justify?t.offsetLeft:((null==(i=t.offsetParent instanceof HTMLElement?t.offsetParent:null)?void 0:i.offsetWidth)??0)-t.offsetWidth-t.offsetLeft}px`
            }), e.forEach(e => {
                e.el.setAttribute("inert", ""), e.present = !1
            })
        }
        addNewAndUpdateExisting(e) {
            let t = new Map,
                i = new Map,
                s = "left" === this.justify,
                n = s ? "prepend" : "append";
            if (function(e, t, {
                    reverse: i = !1
                } = {}) {
                    let s = e.length;
                    for (let n = i ? s - 1 : 0; i ? n >= 0 : n < s; i ? n-- : n++) t(e[n], n)
                }(e, e => {
                    let s;
                    this.children.has(e.key) ? (s = this.children.get(e.key), i.set(e, s), this.unpop(s), s.present = !0) : (s = this.addChar(e, {
                        startDigitsAtZero: !0,
                        animateIn: !0
                    }), t.set(e, s)), this.el[n](s.el)
                }, {
                    reverse: s
                }), this.flow.computedAnimated) {
                let e = this.el.getBoundingClientRect();
                t.forEach(t => {
                    t.willUpdate(e)
                })
            }
            t.forEach((e, t) => {
                e.update(t.value)
            }), i.forEach((e, t) => {
                e.update(t.value)
            })
        }
        willUpdate() {
            let e = this.el.getBoundingClientRect();
            this._prevOffset = e[this.justify], this.children.forEach(t => t.willUpdate(e))
        }
        didUpdate() {
            let e = this.el.getBoundingClientRect();
            this.children.forEach(t => t.didUpdate(e));
            let t = e[this.justify],
                i = this._prevOffset - t;
            i && this.children.size && this.el.animate({
                transform: [`translateX(${i}px)`, "none"]
            }, { ...this.flow.transformTiming,
                composite: "accumulate"
            })
        }
    }
    class O extends x {
        update(e) {
            let t = new Map;
            this.children.forEach((i, s) => {
                e.find(e => e.key === s) || t.set(s, i), this.unpop(i)
            }), this.addNewAndUpdateExisting(e), t.forEach(e => {
                e instanceof M && e.update(0)
            }), this.pop(t)
        }
    }
    class k extends x {
        update(e) {
            let t = new Map;
            this.children.forEach((i, s) => {
                e.find(e => e.key === s) || t.set(s, i)
            }), this.pop(t), this.addNewAndUpdateExisting(e)
        }
    }
    class A {
        constructor(e, t, {
            onRemove: i,
            animateIn: s = !1
        } = {}) {
            this.flow = e, this.el = t, this._present = !0, this._remove = () => {
                var e;
                this.el.remove(), null == (e = this._onRemove) || e.call(this)
            }, this.el.classList.add("animate-presence"), this.flow.computedAnimated && s && this.el.animate({
                [o]: [-.9999, 0]
            }, { ...this.flow.opacityTiming,
                composite: "accumulate"
            }), this._onRemove = i
        }
        get present() {
            return this._present
        }
        set present(e) {
            if (this._present !== e) {
                if (this._present = e, e ? this.el.removeAttribute("inert") : this.el.setAttribute("inert", ""), !this.flow.computedAnimated) {
                    e || this._remove();
                    return
                }
                this.el.style.setProperty("--_number-flow-d-opacity", e ? "0" : "-.999"), this.el.animate({
                    [o]: e ? [-.9999, 0] : [.999, 0]
                }, { ...this.flow.opacityTiming,
                    composite: "accumulate"
                }), e ? this.flow.removeEventListener("animationsfinish", this._remove) : this.flow.addEventListener("animationsfinish", this._remove, {
                    once: !0
                })
            }
        }
    }
    class U extends A {
        constructor(e, t, i, s) {
            super(e.flow, i, s), this.section = e, this.value = t, this.el = i
        }
    }
    class M extends U {
        constructor(e, t, i, s, n) {
            var r, a;
            const l = ((null == (a = null == (r = e.flow.digits) ? void 0 : r[s]) ? void 0 : a.max) ? ? 9) + 1,
                o = Array.from({
                    length: l
                }).map((e, t) => {
                    let s = E("span", {
                        className: "digit__num"
                    }, [document.createTextNode(String(t))]);
                    return t !== i && s.setAttribute("inert", ""), s.style.setProperty("--n", String(t)), s
                }),
                h = E("span", {
                    part: `digit ${t}-digit`,
                    className: "digit"
                }, o);
            h.style.setProperty("--current", String(i)), h.style.setProperty("--length", String(l)), super(e, i, h, n), this.pos = s, this._onAnimationsFinish = () => {
                this.el.classList.remove("is-spinning")
            }, this._numbers = o, this.length = l
        }
        willUpdate(e) {
            let t = this.el.getBoundingClientRect();
            this._prevValue = this.value;
            let i = t[this.section.justify] - e[this.section.justify],
                s = t.width / 2;
            this._prevCenter = "left" === this.section.justify ? i + s : i - s
        }
        update(e) {
            this.el.style.setProperty("--current", String(e)), this._numbers.forEach((t, i) => i === e ? t.removeAttribute("inert") : t.setAttribute("inert", "")), this.value = e
        }
        didUpdate(e) {
            let t = this.el.getBoundingClientRect(),
                i = t[this.section.justify] - e[this.section.justify],
                s = t.width / 2,
                n = "left" === this.section.justify ? i + s : i - s,
                r = this._prevCenter - n;
            r && this.el.animate({
                transform: [`translateX(${r}px)`, "none"]
            }, { ...this.flow.transformTiming,
                composite: "accumulate"
            });
            let a = this.getDelta();
            a && (this.el.classList.add("is-spinning"), this.el.animate({
                [c]: [-a, 0]
            }, { ...this.flow.spinTiming ? ? this.flow.transformTiming,
                composite : "accumulate"
            }), this.flow.addEventListener("animationsfinish", this._onAnimationsFinish, {
                once: !0
            }))
        }
        getDelta() {
            var e;
            if (this.flow.plugins)
                for (let t of this.flow.plugins) {
                    let i = null == (e = t.getDelta) ? void 0 : e.call(t, this.value, this._prevValue, this);
                    if (null != i) return i
                }
            let t = this.value - this._prevValue,
                i = this.flow.computedTrend || Math.sign(t);
            return i < 0 && this.value > this._prevValue ? this.value - this.length - this._prevValue : i > 0 && this.value < this._prevValue ? this.length - this._prevValue + this.value : t
        }
    }
    class L extends U {
        constructor(e, t, i, s) {
            const n = E("span", {
                className: "symbol__value",
                textContent: i
            });
            super(e, i, E("span", {
                part: `symbol ${t}`,
                className: "symbol"
            }, [n]), s), this.type = t, this._children = new Map, this._onChildRemove = e => () => {
                this._children.delete(e)
            }, this._children.set(i, new A(this.flow, n, {
                onRemove: this._onChildRemove(i)
            }))
        }
        willUpdate(e) {
            if ("decimal" === this.type) return;
            let t = this.el.getBoundingClientRect();
            this._prevOffset = t[this.section.justify] - e[this.section.justify]
        }
        update(e) {
            if (this.value !== e) {
                let t = this._children.get(this.value);
                t && (t.present = !1);
                let i = this._children.get(e);
                if (i) i.present = !0;
                else {
                    let t = E("span", {
                        className: "symbol__value",
                        textContent: e
                    });
                    this.el.appendChild(t), this._children.set(e, new A(this.flow, t, {
                        animateIn: !0,
                        onRemove: this._onChildRemove(e)
                    }))
                }
            }
            this.value = e
        }
        didUpdate(e) {
            if ("decimal" === this.type) return;
            let t = this.el.getBoundingClientRect()[this.section.justify] - e[this.section.justify],
                i = this._prevOffset - t;
            i && this.el.animate({
                transform: [`translateX(${i}px)`, "none"]
            }, { ...this.flow.transformTiming,
                composite: "accumulate"
            })
        }
    }
    var P = t;
    let T = parseInt(P.version.match(/^(\d+)\./) ? .[1]) >= 19;
    class W extends $ {
        attributeChangedCallback(e, t, i) {
            this[e] = JSON.parse(i)
        }
    }
    W.observedAttributes = T ? [] : ["data", "digits"], i.BROWSER && !customElements.get("number-flow-react") && customElements.define("number-flow-react", W);
    let j = {},
        B = T ? function(e) {
            return e
        } : JSON.stringify;

    function H(e) {
        let {
            transformTiming: t,
            spinTiming: i,
            opacityTiming: s,
            animated: n,
            respectMotionPreference: r,
            trend: a,
            plugins: l,
            ...o
        } = e;
        return [{
            transformTiming: t,
            spinTiming: i,
            opacityTiming: s,
            animated: n,
            respectMotionPreference: r,
            trend: a,
            plugins: l
        }, o]
    }
    class N extends P.Component {
        updateProperties(e) {
            if (!this.el) return;
            this.el.batched = !this.props.isolate;
            let [t] = H(this.props);
            Object.entries(t).forEach(([e, t]) => {
                this.el[e] = t ? ? W.defaultProps[e]
            }), e ? .onAnimationsStart && this.el.removeEventListener("animationsstart", e.onAnimationsStart), this.props.onAnimationsStart && this.el.addEventListener("animationsstart", this.props.onAnimationsStart), e ? .onAnimationsFinish && this.el.removeEventListener("animationsfinish", e.onAnimationsFinish), this.props.onAnimationsFinish && this.el.addEventListener("animationsfinish", this.props.onAnimationsFinish)
        }
        componentDidMount() {
            this.updateProperties(), T && this.el && (this.el.digits = this.props.digits, this.el.data = this.props.data)
        }
        getSnapshotBeforeUpdate(e) {
            if (this.updateProperties(e), e.data !== this.props.data) {
                if (this.props.group) return this.props.group.willUpdate(), () => this.props.group ? .didUpdate();
                if (!this.props.isolate) return this.el ? .willUpdate(), () => this.el ? .didUpdate()
            }
            return null
        }
        componentDidUpdate(e, t, i) {
            i ? .()
        }
        handleRef(e) {
            this.props.innerRef && (this.props.innerRef.current = e), this.el = e
        }
        render() {
            let [e, {
                innerRef: t,
                className: n,
                data: r,
                nonce: a,
                willChange: l,
                isolate: o,
                group: h,
                digits: u,
                onAnimationsStart: c,
                onAnimationsFinish: p,
                ...d
            }] = H(this.props);
            return P.createElement("number-flow-react", {
                ref: this.handleRef,
                "data-will-change": l ? "" : void 0,
                class: n,
                nonce: a,
                ...d,
                dangerouslySetInnerHTML: {
                    __html: i.BROWSER ? "" : ((e, {
                        nonce: t,
                        elementSuffix: i
                    } = {}) => s `<template shadowroot="open" shadowrootmode="open"
			><style${t?` nonce="${t}"`:""}>${w}</style
			><span role="img" aria-label="${e.valueAsString}"
				>${_(e.pre,"left")}<span part="number" class="number"
					>${_(e.integer,"integer")}${_(e.fraction,"fraction")}</span
				>${_(e.post,"right")}</span
			></template
		><style${t?` nonce="${t}"`:""}>${R(i)}</style
		><span>${e.valueAsString}</span>`)(r, {
                        nonce: a,
                        elementSuffix: "-react"
                    })
                },
                suppressHydrationWarning: !0,
                digits: B(u),
                data: B(r)
            })
        }
        constructor(e) {
            super(e), this.handleRef = this.handleRef.bind(this)
        }
    }
    let Q = P.forwardRef(function({
            value: e,
            locales: t,
            format: i,
            prefix: s,
            suffix: n,
            ...r
        }, a) {
            P.useImperativeHandle(a, () => l.current, []);
            let l = P.useRef(),
                o = P.useContext(V);
            o ? .useRegister(l);
            let h = P.useMemo(() => t ? JSON.stringify(t) : "", [t]),
                u = P.useMemo(() => i ? JSON.stringify(i) : "", [i]),
                c = P.useMemo(() => (function(e, t, i, s) {
                    let n = t.formatToParts(e);
                    i && n.unshift({
                        type: "prefix",
                        value: i
                    }), s && n.push({
                        type: "suffix",
                        value: s
                    });
                    let r = [],
                        a = [],
                        l = [],
                        o = [],
                        h = {},
                        u = e => `${e}:${h[e]=(h[e]??-1)+1}`,
                        c = "",
                        p = !1,
                        d = !1;
                    for (let e of n) {
                        c += e.value;
                        let t = "minusSign" === e.type || "plusSign" === e.type ? "sign" : e.type;
                        "integer" === t ? (p = !0, a.push(...e.value.split("").map(e => ({
                            type: t,
                            value: parseInt(e)
                        })))) : "group" === t ? a.push({
                            type: t,
                            value: e.value
                        }) : "decimal" === t ? (d = !0, l.push({
                            type: t,
                            value: e.value,
                            key: u(t)
                        })) : "fraction" === t ? l.push(...e.value.split("").map(e => ({
                            type: t,
                            value: parseInt(e),
                            key: u(t),
                            pos: -1 - h[t]
                        }))) : (p || d ? o : r).push({
                            type: t,
                            value: e.value,
                            key: u(t)
                        })
                    }
                    let f = [];
                    for (let e = a.length - 1; e >= 0; e--) {
                        let t = a[e];
                        f.unshift("integer" === t.type ? { ...t,
                            key: u(t.type),
                            pos: h[t.type]
                        } : { ...t,
                            key: u(t.type)
                        })
                    }
                    return {
                        pre: r,
                        integer: f,
                        fraction: l,
                        post: o,
                        valueAsString: c,
                        value: "string" == typeof e ? parseFloat(e) : e
                    }
                })(e, j[`${h}:${u}`] ? ? = new Intl.NumberFormat(t, i), s, n), [e, h, u, s, n]);
            return P.createElement(N, { ...r,
                group: o,
                data: c,
                innerRef: l
            })
        }),
        V = P.createContext(void 0);
    e.s(["N", 0, Q, "b", 0, function({
        children: e
    }) {
        let t = P.useRef(new Set),
            i = P.useRef(!1),
            s = P.useRef(new WeakMap),
            n = P.useMemo(() => ({
                useRegister(e) {
                    P.useEffect(() => (t.current.add(e), () => {
                        t.current.delete(e)
                    }), [])
                },
                willUpdate() {
                    i.current || (i.current = !0, t.current.forEach(e => {
                        let t = e.current;
                        t && t.created && (t.willUpdate(), s.current.set(t, !0))
                    }))
                },
                didUpdate() {
                    t.current.forEach(e => {
                        let t = e.current;
                        t && s.current.get(t) && (t.didUpdate(), s.current.delete(t))
                    }), i.current = !1
                }
            }), []);
        return P.createElement(V.Provider, {
            value: n
        }, e)
    }], 418956), R("-react"), e.s([], 686518), e.s(["default", 0, Q], 907855)
}, 614933, e => {
    "use strict";
    var t = e.i(416340);
    e.i(284553);
    var i = e.i(289780),
        s = e.i(189106),
        n = e.i(698576),
        r = e.i(122538);

    function a(e, t) {
        let i = new Set(t);
        return e.filter(e => !i.has(e))
    }
    var l = class extends n.Subscribable {#
            e;#
            t;#
            i;#
            s;#
            n;#
            r;#
            a;#
            l;#
            o;#
            h = [];
            constructor(e, t, i) {
                super(), this.#e = e, this.#s = i, this.#i = [], this.#n = [], this.#t = [], this.setQueries(t)
            }
            onSubscribe() {
                1 === this.listeners.size && this.#n.forEach(e => {
                    e.subscribe(t => {
                        this.#u(e, t)
                    })
                })
            }
            onUnsubscribe() {
                this.listeners.size || this.destroy()
            }
            destroy() {
                this.listeners = new Set, this.#n.forEach(e => {
                    e.destroy()
                })
            }
            setQueries(e, t) {
                this.#i = e, this.#s = t, i.notifyManager.batch(() => {
                    let e = this.#n,
                        t = this.#c(this.#i);
                    t.forEach(e => e.observer.setOptions(e.defaultedQueryOptions));
                    let i = t.map(e => e.observer),
                        s = i.map(e => e.getCurrentResult()),
                        n = e.length !== i.length,
                        l = i.some((t, i) => t !== e[i]),
                        o = n || l,
                        h = !!o || s.some((e, t) => {
                            let i = this.#t[t];
                            return !i || !(0, r.shallowEqualObjects)(e, i)
                        });
                    (o || h) && (o && (this.#h = t, this.#n = i), this.#t = s, this.hasListeners() && (o && (a(e, i).forEach(e => {
                        e.destroy()
                    }), a(i, e).forEach(e => {
                        e.subscribe(t => {
                            this.#u(e, t)
                        })
                    })), this.#p()))
                })
            }
            getCurrentResult() {
                return this.#t
            }
            getQueries() {
                return this.#n.map(e => e.getCurrentQuery())
            }
            getObservers() {
                return this.#n
            }
            getOptimisticResult(e, t) {
                let i = this.#c(e),
                    s = i.map(e => e.observer.getOptimisticResult(e.defaultedQueryOptions)),
                    n = i.map(e => e.defaultedQueryOptions.queryHash);
                return [s, e => this.#d(e ? ? s, t, n), () => this.#f(s, i)]
            }#
            f(e, t) {
                return t.map((i, s) => {
                    let n = e[s];
                    return i.defaultedQueryOptions.notifyOnChangeProps ? n : i.observer.trackResult(n, e => {
                        t.forEach(t => {
                            t.observer.trackProp(e)
                        })
                    })
                })
            }#
            d(e, t, i) {
                if (t) {
                    let s = this.#o,
                        n = void 0 !== i && void 0 !== s && (s.length !== i.length || i.some((e, t) => e !== s[t]));
                    return (!this.#r || this.#t !== this.#l || n || t !== this.#a) && (this.#a = t, this.#l = this.#t, void 0 !== i && (this.#o = i), this.#r = (0, r.replaceEqualDeep)(this.#r, t(e))), this.#r
                }
                return e
            }#
            m() {
                return this.#s ? .combine !== void 0 && this.#n.some((e, t) => e.options.suspense && this.#t[t] ? .data === void 0)
            }#
            c(e) {
                let t = new Map;
                this.#n.forEach(e => {
                    let i = e.options.queryHash;
                    if (!i) return;
                    let s = t.get(i);
                    s ? s.push(e) : t.set(i, [e])
                });
                let i = [];
                return e.forEach(e => {
                    let n = this.#e.defaultQueryOptions(e),
                        r = t.get(n.queryHash) ? .shift() ? ? new s.QueryObserver(this.#e, n);
                    i.push({
                        defaultedQueryOptions: n,
                        observer: r
                    })
                }), i
            }#
            u(e, t) {
                let i = this.#n.indexOf(e);
                if (-1 !== i) {
                    var s;
                    let e;
                    this.#t = (s = this.#t, (e = s.slice(0))[i] = t, e), this.#p()
                }
            }#
            p() {
                if (this.hasListeners()) {
                    let e = this.#f(this.#t, this.#h),
                        t = this.#m(),
                        s = this.#r,
                        n = t ? s : this.#d(e, this.#s ? .combine);
                    (t || s !== n) && i.notifyManager.batch(() => {
                        this.listeners.forEach(e => {
                            e(this.#t)
                        })
                    })
                }
            }
        },
        o = e.i(318594),
        h = e.i(254938),
        u = e.i(224851),
        c = e.i(487498),
        p = e.i(787370);
    e.s(["useQueries", 0, function({
        queries: e,
        ...n
    }, a) {
        let d = (0, o.useQueryClient)(a),
            f = (0, h.useIsRestoring)(),
            m = (0, u.useQueryErrorResetBoundary)(),
            g = t.useMemo(() => e.map(e => {
                let t = d.defaultQueryOptions(e);
                return t._optimisticResults = f ? "isRestoring" : "optimistic", t
            }), [e, d, f]);
        g.forEach(e => {
            (0, p.ensureSuspenseTimers)(e);
            let t = d.getQueryCache().get(e.queryHash);
            (0, c.ensurePreventErrorBoundaryRetry)(e, m, t)
        }), (0, c.useClearResetErrorBoundary)(m);
        let [y] = t.useState(() => new l(d, g, n)), [v, b, w] = y.getOptimisticResult(g, n.combine), _ = !f && !1 !== n.subscribed;
        t.useSyncExternalStore(t.useCallback(e => _ ? y.subscribe(i.notifyManager.batchCalls(e)) : r.noop, [y, _]), () => y.getCurrentResult(), () => y.getCurrentResult()), t.useEffect(() => {
            y.setQueries(g, n)
        }, [g, n, y]);
        let R = v.some((e, t) => (0, p.shouldSuspend)(g[t], e)) ? v.flatMap((e, t) => {
            let i = g[t];
            if (i && (0, p.shouldSuspend)(i, e)) {
                let e = new s.QueryObserver(d, i);
                return (0, p.fetchOptimistic)(i, e, m)
            }
            return []
        }) : [];
        if (R.length > 0) throw Promise.all(R);
        let E = v.find((e, t) => {
            let i = g[t];
            return i && (0, c.getHasError)({
                result: e,
                errorResetBoundary: m,
                throwOnError: i.throwOnError,
                query: d.getQueryCache().get(i.queryHash),
                suspense: i.suspense
            })
        });
        if (E ? .error) throw E.error;
        return b(w())
    }], 614933)
}, 452090, e => {
    "use strict";
    var t = e.i(719131),
        i = e.i(520415),
        s = e.i(451258),
        n = e.i(416340),
        r = e.i(363831),
        a = e.i(839589);

    function l(e, t) {
        let i, s = () => {
            let {
                currentTime: s
            } = t, n = (null === s ? 0 : s.value) / 100;
            i !== n && e(n), i = n
        };
        return a.frame.preUpdate(s, !0), () => (0, a.cancelFrame)(s)
    }

    function o(e) {
        return !("u" < typeof window) && (e ? (0, t.supportsViewTimeline)() : (0, t.supportsScrollTimeline)())
    }
    var h = e.i(288048),
        u = e.i(724820),
        c = e.i(73004);
    let p = () => ({
            current: 0,
            offset: [],
            progress: 0,
            scrollLength: 0,
            targetOffset: 0,
            targetLength: 0,
            containerLength: 0,
            velocity: 0
        }),
        d = {
            x: {
                length: "Width",
                position: "Left"
            },
            y: {
                length: "Height",
                position: "Top"
            }
        };

    function f(e, t, i, s) {
        let n = i[t],
            {
                length: r,
                position: a
            } = d[t],
            l = n.current,
            o = i.time;
        n.current = Math.abs(e[`scroll${a}`]), n.scrollLength = e[`scroll${r}`] - e[`client${r}`], n.offset.length = 0, n.offset[0] = 0, n.offset[1] = n.scrollLength, n.progress = (0, u.progress)(0, n.scrollLength, n.current);
        let h = s - o;
        n.velocity = h > 50 ? 0 : (0, c.velocityPerSecond)(n.current - l, h)
    }
    e.i(284553);
    var m = e.i(529996),
        g = e.i(95456),
        y = e.i(212344),
        v = e.i(141355);
    let b = {
        start: 0,
        center: .5,
        end: 1
    };

    function w(e, t, i = 0) {
        let s = 0;
        if (e in b && (e = b[e]), "string" == typeof e) {
            let t = parseFloat(e);
            e.endsWith("px") ? s = t : e.endsWith("%") ? e = t / 100 : e.endsWith("vw") ? s = t / 100 * document.documentElement.clientWidth : e.endsWith("vh") ? s = t / 100 * document.documentElement.clientHeight : e = t
        }
        return "number" == typeof e && (s = t * e), i + s
    }
    let _ = [0, 0],
        R = [
            [0, 0],
            [1, 1]
        ],
        E = {
            x: 0,
            y: 0
        },
        S = new WeakMap,
        $ = new WeakMap,
        C = new WeakMap,
        x = new WeakMap,
        O = new WeakMap,
        k = e => e === document.scrollingElement ? window : e;

    function A(e, {
        container: t = document.scrollingElement,
        trackContentSize: i = !1,
        ...s
    } = {}) {
        if (!t) return r.noop;
        let n = C.get(t);
        n || (n = new Set, C.set(t, n));
        let l = function(e, t, i, s = {}) {
            return {
                measure: t => {
                    ! function(e, t = e, i) {
                        if (i.x.targetOffset = 0, i.y.targetOffset = 0, t !== e) {
                            let s = t;
                            for (; s && s !== e;) i.x.targetOffset += s.offsetLeft, i.y.targetOffset += s.offsetTop, s = s.offsetParent
                        }
                        i.x.targetLength = t === e ? t.scrollWidth : t.clientWidth, i.y.targetLength = t === e ? t.scrollHeight : t.clientHeight, i.x.containerLength = e.clientWidth, i.y.containerLength = e.clientHeight
                    }(e, s.target, i), f(e, "x", i, t), f(e, "y", i, t), i.time = t, (s.offset || s.target) && function(e, t, i) {
                        let {
                            offset: s = R
                        } = i, {
                            target: n = e,
                            axis: r = "y"
                        } = i, a = "y" === r ? "height" : "width", l = n !== e ? function(e, t) {
                            let i = {
                                    x: 0,
                                    y: 0
                                },
                                s = e;
                            for (; s && s !== t;)
                                if ((0, v.isHTMLElement)(s)) i.x += s.offsetLeft, i.y += s.offsetTop, s = s.offsetParent;
                                else if ("svg" === s.tagName) {
                                let e = s.getBoundingClientRect(),
                                    t = (s = s.parentElement).getBoundingClientRect();
                                i.x += e.left - t.left, i.y += e.top - t.top
                            } else if (s instanceof SVGGraphicsElement) {
                                let {
                                    x: e,
                                    y: t
                                } = s.getBBox();
                                i.x += e, i.y += t;
                                let n = null,
                                    r = s.parentNode;
                                for (; !n;) "svg" === r.tagName && (n = r), r = s.parentNode;
                                s = n
                            } else break;
                            return i
                        }(n, e) : E, o = n === e ? {
                            width: e.scrollWidth,
                            height: e.scrollHeight
                        } : "getBBox" in n && "svg" !== n.tagName ? n.getBBox() : {
                            width: n.clientWidth,
                            height: n.clientHeight
                        }, h = {
                            width: e.clientWidth,
                            height: e.clientHeight
                        };
                        t[r].offset.length = 0;
                        let u = !t[r].interpolate,
                            c = s.length;
                        for (let e = 0; e < c; e++) {
                            let i = function(e, t, i, s) {
                                let n = Array.isArray(e) ? e : _,
                                    r = 0;
                                return "number" == typeof e ? n = [e, e] : "string" == typeof e && (n = (e = e.trim()).includes(" ") ? e.split(" ") : [e, b[e] ? e : "0"]), (r = w(n[0], i, s)) - w(n[1], t)
                            }(s[e], h[a], o[a], l[r]);
                            u || i === t[r].interpolatorOffsets[e] || (u = !0), t[r].offset[e] = i
                        }
                        u && (t[r].interpolate = (0, m.interpolate)(t[r].offset, (0, g.defaultOffset)(s), {
                            clamp: !1
                        }), t[r].interpolatorOffsets = [...t[r].offset]), t[r].progress = (0, y.clamp)(0, 1, t[r].interpolate(t[r].current))
                    }(e, i, s)
                },
                notify: () => t(i)
            }
        }(t, e, {
            time: 0,
            x: p(),
            y: p()
        }, s);
        if (n.add(l), !S.has(t)) {
            let e = () => {
                    for (let e of n) e.measure(a.frameData.timestamp);
                    a.frame.preUpdate(i)
                },
                i = () => {
                    for (let e of n) e.notify()
                },
                s = () => a.frame.read(e);
            S.set(t, s);
            let r = k(t);
            window.addEventListener("resize", s), t !== document.documentElement && $.set(t, (0, h.resize)(t, s)), r.addEventListener("scroll", s), s()
        }
        if (i && !O.has(t)) {
            let e = S.get(t),
                i = {
                    width: t.scrollWidth,
                    height: t.scrollHeight
                };
            x.set(t, i);
            let s = a.frame.read(() => {
                let s = t.scrollWidth,
                    n = t.scrollHeight;
                (i.width !== s || i.height !== n) && (e(), i.width = s, i.height = n)
            }, !0);
            O.set(t, s)
        }
        let o = S.get(t);
        return a.frame.read(o, !1, !0), () => {
            (0, a.cancelFrame)(o);
            let e = C.get(t);
            if (!e || (e.delete(l), e.size)) return;
            let i = S.get(t);
            S.delete(t), i && (k(t).removeEventListener("scroll", i), $.get(t) ? .(), window.removeEventListener("resize", i));
            let s = O.get(t);
            s && ((0, a.cancelFrame)(s), O.delete(t)), x.delete(t)
        }
    }
    let U = [
            [
                [
                    [0, 1],
                    [1, 1]
                ], "entry"
            ],
            [
                [
                    [0, 0],
                    [1, 0]
                ], "exit"
            ],
            [
                [
                    [1, 0],
                    [0, 1]
                ], "cover"
            ],
            [R, "contain"]
        ],
        M = {
            start: 0,
            end: 1
        };

    function L(e) {
        if (!e) return {
            rangeStart: "contain 0%",
            rangeEnd: "contain 100%"
        };
        for (let [t, i] of U)
            if (function(e, t) {
                    let i = function(e) {
                        if (2 !== e.length) return;
                        let t = [];
                        for (let i of e)
                            if (Array.isArray(i)) t.push(i);
                            else {
                                if ("string" != typeof i) return;
                                let e = function(e) {
                                    let t = e.trim().split(/\s+/);
                                    if (2 !== t.length) return;
                                    let i = M[t[0]],
                                        s = M[t[1]];
                                    if (void 0 !== i && void 0 !== s) return [i, s]
                                }(i);
                                if (!e) return;
                                t.push(e)
                            }
                        return t
                    }(e);
                    if (!i) return !1;
                    for (let e = 0; e < 2; e++) {
                        let s = i[e],
                            n = t[e];
                        if (s[0] !== n[0] || s[1] !== n[1]) return !1
                    }
                    return !0
                }(e, t)) return {
                rangeStart: `${i} 0%`,
                rangeEnd: `${i} 100%`
            }
    }
    let P = new Map;

    function T(e) {
        let t = {
                value: 0
            },
            i = A(i => {
                t.value = 100 * i[e.axis].progress
            }, e);
        return {
            currentTime: t,
            cancel: i
        }
    }

    function W({
        source: e,
        container: t,
        ...i
    }) {
        let {
            axis: s
        } = i;
        e && (t = e);
        let n = P.get(t);
        n || (n = new Map, P.set(t, n));
        let r = i.target ? ? "self",
            a = n.get(r);
        a || (a = {}, n.set(r, a));
        let l = s + (i.offset ? ? []).join(",");
        return a[l] || (i.target && o(i.target) ? L(i.offset) ? a[l] = new ViewTimeline({
            subject: i.target,
            axis: s
        }) : a[l] = T({
            container: t,
            ...i
        }) : o() ? a[l] = new ScrollTimeline({
            source: t,
            axis: s
        }) : a[l] = T({
            container: t,
            ...i
        })), a[l]
    }

    function j(e, {
        axis: t = "y",
        container: i = document.scrollingElement,
        ...s
    } = {}) {
        var n, a;
        let h, u, c;
        if (!i) return r.noop;
        let p = {
            axis: t,
            container: i,
            ...s
        };
        return "function" == typeof e ? (n = e, a = p, 2 === n.length ? A(e => {
            n(e[a.axis].progress, e)
        }, a) : l(n, W(a))) : (h = W(p), u = p.target ? L(p.offset) : void 0, c = p.target ? o(p.target) && !!u : o(), e.attachTimeline({
            timeline: c ? h : void 0,
            ...u && c && {
                rangeStart: u.rangeStart,
                rangeEnd: u.rangeEnd
            },
            observe: e => (e.pause(), l(t => {
                e.time = e.iterationDuration * t
            }, h))
        }))
    }
    var B = e.i(583730),
        H = e.i(519825);
    let N = () => ({
            scrollX: (0, i.motionValue)(0),
            scrollY: (0, i.motionValue)(0),
            scrollXProgress: (0, i.motionValue)(0),
            scrollYProgress: (0, i.motionValue)(0)
        }),
        Q = e => !!e && !e.current;

    function V(e, t, i, s) {
        return {
            factory: n => j(n, { ...t,
                axis: e,
                container: i ? .current || void 0,
                target: s ? .current || void 0
            }),
            times: [0, 1],
            keyframes: [0, 1],
            ease: e => e,
            duration: 1
        }
    }
    e.s(["useScroll", 0, function({
        container: e,
        target: i,
        ...r
    } = {}) {
        var a;
        let l = (0, B.useConstant)(N);
        a = r.offset, !("u" < typeof window) && (i ? (0, t.supportsViewTimeline)() && !!L(a) : (0, t.supportsScrollTimeline)()) && (l.scrollXProgress.accelerate = V("x", r, e, i), l.scrollYProgress.accelerate = V("y", r, e, i));
        let o = (0, n.useRef)(null),
            h = (0, n.useRef)(!1),
            u = (0, n.useCallback)(() => (o.current = j((e, {
                x: t,
                y: i
            }) => {
                l.scrollX.set(t.current), l.scrollXProgress.set(t.progress), l.scrollY.set(i.current), l.scrollYProgress.set(i.progress)
            }, { ...r,
                container: e ? .current || void 0,
                target: i ? .current || void 0
            }), () => {
                o.current ? .()
            }), [e, i, JSON.stringify(r.offset)]);
        return (0, H.useIsomorphicLayoutEffect)(() => {
            if (h.current = !1, !(Q(e) || Q(i))) return u();
            h.current = !0
        }, [u]), (0, n.useEffect)(() => h.current ? ((0, s.invariant)(!Q(e), "Container ref is defined but not hydrated", "use-scroll-ref"), (0, s.invariant)(!Q(i), "Target ref is defined but not hydrated", "use-scroll-ref"), u()) : void 0, [u]), l
    }], 452090)
}, 112283, e => {
    "use strict";
    var t = e.i(828397),
        i = e.i(88714);
    e.s(["useMotionTemplate", 0, function(e, ...s) {
        let n = e.length;
        return (0, i.useCombineMotionValues)(s.filter(t.isMotionValue), function() {
            let i = "";
            for (let r = 0; r < n; r++) {
                i += e[r];
                let n = s[r];
                n && (i += (0, t.isMotionValue)(n) ? n.get() : n)
            }
            return i
        })
    }])
}]);

//# debugId=32fa5c16-2b61-91e7-3a3a-666a4f68780b