;
! 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] = "9bdca6b4-5015-17b0-bbc8-9451f7325ed1")
    } catch (e) {}
}();
(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["object" == typeof document ? document.currentScript : void 0, 864006, e => {
    "use strict";
    var t, r, i, n, s, o, h = e.i(416340);

    function a(e, t) {
        let r = t && t.cache ? t.cache : f,
            i = t && t.serializer ? t.serializer : c;
        return (t && t.strategy ? t.strategy : function(e, t) {
            var r, i;
            let n = 1 === e.length ? l : u;
            return r = t.cache.create(), i = t.serializer, n.bind(this, e, r, i)
        })(e, {
            cache: r,
            serializer: i
        })
    }

    function l(e, t, r, i) {
        let n = null == i || "number" == typeof i || "boolean" == typeof i ? i : r(i),
            s = t.get(n);
        return void 0 === s && (s = e.call(this, i), t.set(n, s)), s
    }

    function u(e, t, r) {
        let i = Array.prototype.slice.call(arguments, 3),
            n = r(i),
            s = t.get(n);
        return void 0 === s && (s = e.apply(this, i), t.set(n, s)), s
    }
    let c = function() {
        return JSON.stringify(arguments)
    };
    class m {
        cache;
        constructor() {
            this.cache = Object.create(null)
        }
        get(e) {
            return this.cache[e]
        }
        set(e, t) {
            this.cache[e] = t
        }
    }
    let f = {
            create: function() {
                return new m
            }
        },
        E = {
            variadic: function(e, t) {
                var r, i;
                return r = t.cache.create(), i = t.serializer, u.bind(this, e, r, i)
            },
            monadic: function(e, t) {
                var r, i;
                return r = t.cache.create(), i = t.serializer, l.bind(this, e, r, i)
            }
        };
    class p extends Error {
        constructor(e, t) {
            let r = e;
            t && (r += ": " + t), super(r), this.code = e, t && (this.originalMessage = t)
        }
    }
    var g = ((t = g || {}).MISSING_MESSAGE = "MISSING_MESSAGE", t.MISSING_FORMAT = "MISSING_FORMAT", t.ENVIRONMENT_FALLBACK = "ENVIRONMENT_FALLBACK", t.INSUFFICIENT_PATH = "INSUFFICIENT_PATH", t.INVALID_MESSAGE = "INVALID_MESSAGE", t.INVALID_KEY = "INVALID_KEY", t.FORMATTING_ERROR = "FORMATTING_ERROR", t);

    function b() {
        return {
            dateTime: {},
            number: {},
            message: {},
            relativeTime: {},
            pluralRules: {},
            list: {},
            displayNames: {}
        }
    }

    function T(e, t) {
        return a(e, {
            cache: {
                create: () => ({
                    get: e => t[e],
                    set(e, r) {
                        t[e] = r
                    }
                })
            },
            strategy: E.variadic
        })
    }

    function H(e, t) {
        return T((...t) => new e(...t), t)
    }

    function d(e) {
        return {
            getDateTimeFormat: H(Intl.DateTimeFormat, e.dateTime),
            getNumberFormat: H(Intl.NumberFormat, e.number),
            getPluralRules: H(Intl.PluralRules, e.pluralRules),
            getRelativeTimeFormat: H(Intl.RelativeTimeFormat, e.relativeTime),
            getListFormat: H(Intl.ListFormat, e.list),
            getDisplayNames: H(Intl.DisplayNames, e.displayNames)
        }
    }
    let B = ((r = {})[r.EXPECT_ARGUMENT_CLOSING_BRACE = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE", r[r.EMPTY_ARGUMENT = 2] = "EMPTY_ARGUMENT", r[r.MALFORMED_ARGUMENT = 3] = "MALFORMED_ARGUMENT", r[r.EXPECT_ARGUMENT_TYPE = 4] = "EXPECT_ARGUMENT_TYPE", r[r.INVALID_ARGUMENT_TYPE = 5] = "INVALID_ARGUMENT_TYPE", r[r.EXPECT_ARGUMENT_STYLE = 6] = "EXPECT_ARGUMENT_STYLE", r[r.INVALID_NUMBER_SKELETON = 7] = "INVALID_NUMBER_SKELETON", r[r.INVALID_DATE_TIME_SKELETON = 8] = "INVALID_DATE_TIME_SKELETON", r[r.EXPECT_NUMBER_SKELETON = 9] = "EXPECT_NUMBER_SKELETON", r[r.EXPECT_DATE_TIME_SKELETON = 10] = "EXPECT_DATE_TIME_SKELETON", r[r.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE", r[r.EXPECT_SELECT_ARGUMENT_OPTIONS = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS", r[r.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE", r[r.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE", r[r.EXPECT_SELECT_ARGUMENT_SELECTOR = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR", r[r.EXPECT_PLURAL_ARGUMENT_SELECTOR = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR", r[r.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT", r[r.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT", r[r.INVALID_PLURAL_ARGUMENT_SELECTOR = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR", r[r.DUPLICATE_PLURAL_ARGUMENT_SELECTOR = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR", r[r.DUPLICATE_SELECT_ARGUMENT_SELECTOR = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR", r[r.MISSING_OTHER_CLAUSE = 22] = "MISSING_OTHER_CLAUSE", r[r.INVALID_TAG = 23] = "INVALID_TAG", r[r.INVALID_TAG_NAME = 25] = "INVALID_TAG_NAME", r[r.UNMATCHED_CLOSING_TAG = 26] = "UNMATCHED_CLOSING_TAG", r[r.UNCLOSED_TAG = 27] = "UNCLOSED_TAG", r),
        A = ((i = {})[i.literal = 0] = "literal", i[i.argument = 1] = "argument", i[i.number = 2] = "number", i[i.date = 3] = "date", i[i.time = 4] = "time", i[i.select = 5] = "select", i[i.plural = 6] = "plural", i[i.pound = 7] = "pound", i[i.tag = 8] = "tag", i),
        y = ((n = {})[n.number = 0] = "number", n[n.dateTime = 1] = "dateTime", n);

    function _(e) {
        return e.type === A.literal
    }

    function N(e) {
        return e.type === A.number
    }

    function S(e) {
        return e.type === A.date
    }

    function I(e) {
        return e.type === A.time
    }

    function L(e) {
        return e.type === A.select
    }

    function M(e) {
        return e.type === A.plural
    }

    function P(e) {
        return e.type === A.tag
    }

    function R(e) {
        return !!(e && "object" == typeof e && e.type === y.number)
    }

    function C(e) {
        return !!(e && "object" == typeof e && e.type === y.dateTime)
    }
    let O = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/,
        G = /[\t-\r \x85\u200E\u200F\u2028\u2029]/i,
        U = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g,
        v = /^(@+)?(\+|#+)?[rs]?$/g,
        F = /(\*)(0+)|(#+)(0+)|(0+)/g,
        w = /^(0+)$/;

    function D(e) {
        let t = {};
        return "r" === e[e.length - 1] ? t.roundingPriority = "morePrecision" : "s" === e[e.length - 1] && (t.roundingPriority = "lessPrecision"), e.replace(v, function(e, r, i) {
            return "string" != typeof i ? (t.minimumSignificantDigits = r.length, t.maximumSignificantDigits = r.length) : "+" === i ? t.minimumSignificantDigits = r.length : "#" === r[0] ? t.maximumSignificantDigits = r.length : (t.minimumSignificantDigits = r.length, t.maximumSignificantDigits = r.length + ("string" == typeof i ? i.length : 0)), ""
        }), t
    }

    function k(e) {
        switch (e) {
            case "sign-auto":
                return {
                    signDisplay: "auto"
                };
            case "sign-accounting":
            case "()":
                return {
                    currencySign: "accounting"
                };
            case "sign-always":
            case "+!":
                return {
                    signDisplay: "always"
                };
            case "sign-accounting-always":
            case "()!":
                return {
                    signDisplay: "always",
                    currencySign: "accounting"
                };
            case "sign-except-zero":
            case "+?":
                return {
                    signDisplay: "exceptZero"
                };
            case "sign-accounting-except-zero":
            case "()?":
                return {
                    signDisplay: "exceptZero",
                    currencySign: "accounting"
                };
            case "sign-never":
            case "+_":
                return {
                    signDisplay: "never"
                }
        }
    }

    function V(e) {
        let t = k(e);
        return t || {}
    }
    let K = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g,
        X = {
            "001": ["H", "h"],
            419: ["h", "H", "hB", "hb"],
            AC: ["H", "h", "hb", "hB"],
            AD: ["H", "hB"],
            AE: ["h", "hB", "hb", "H"],
            AF: ["H", "hb", "hB", "h"],
            AG: ["h", "hb", "H", "hB"],
            AI: ["H", "h", "hb", "hB"],
            AL: ["h", "H", "hB"],
            AM: ["H", "hB"],
            AO: ["H", "hB"],
            AR: ["h", "H", "hB", "hb"],
            AS: ["h", "H"],
            AT: ["H", "hB"],
            AU: ["h", "hb", "H", "hB"],
            AW: ["H", "hB"],
            AX: ["H"],
            AZ: ["H", "hB", "h"],
            BA: ["H", "hB", "h"],
            BB: ["h", "hb", "H", "hB"],
            BD: ["h", "hB", "H"],
            BE: ["H", "hB"],
            BF: ["H", "hB"],
            BG: ["H", "hB", "h"],
            BH: ["h", "hB", "hb", "H"],
            BI: ["H", "h"],
            BJ: ["H", "hB"],
            BL: ["H", "hB"],
            BM: ["h", "hb", "H", "hB"],
            BN: ["hb", "hB", "h", "H"],
            BO: ["h", "H", "hB", "hb"],
            BQ: ["H"],
            BR: ["H", "hB"],
            BS: ["h", "hb", "H", "hB"],
            BT: ["h", "H"],
            BW: ["H", "h", "hb", "hB"],
            BY: ["H", "h"],
            BZ: ["H", "h", "hb", "hB"],
            CA: ["h", "hb", "H", "hB"],
            CC: ["H", "h", "hb", "hB"],
            CD: ["hB", "H"],
            CF: ["H", "h", "hB"],
            CG: ["H", "hB"],
            CH: ["H", "hB", "h"],
            CI: ["H", "hB"],
            CK: ["H", "h", "hb", "hB"],
            CL: ["h", "H", "hB", "hb"],
            CM: ["H", "h", "hB"],
            CN: ["H", "hB", "hb", "h"],
            CO: ["h", "H", "hB", "hb"],
            CP: ["H"],
            CR: ["h", "H", "hB", "hb"],
            CU: ["h", "H", "hB", "hb"],
            CV: ["H", "hB"],
            CW: ["H", "hB"],
            CX: ["H", "h", "hb", "hB"],
            CY: ["h", "H", "hb", "hB"],
            CZ: ["H"],
            DE: ["H", "hB"],
            DG: ["H", "h", "hb", "hB"],
            DJ: ["h", "H"],
            DK: ["H"],
            DM: ["h", "hb", "H", "hB"],
            DO: ["h", "H", "hB", "hb"],
            DZ: ["h", "hB", "hb", "H"],
            EA: ["H", "h", "hB", "hb"],
            EC: ["h", "H", "hB", "hb"],
            EE: ["H", "hB"],
            EG: ["h", "hB", "hb", "H"],
            EH: ["h", "hB", "hb", "H"],
            ER: ["h", "H"],
            ES: ["H", "hB", "h", "hb"],
            ET: ["hB", "hb", "h", "H"],
            FI: ["H"],
            FJ: ["h", "hb", "H", "hB"],
            FK: ["H", "h", "hb", "hB"],
            FM: ["h", "hb", "H", "hB"],
            FO: ["H", "h"],
            FR: ["H", "hB"],
            GA: ["H", "hB"],
            GB: ["H", "h", "hb", "hB"],
            GD: ["h", "hb", "H", "hB"],
            GE: ["H", "hB", "h"],
            GF: ["H", "hB"],
            GG: ["H", "h", "hb", "hB"],
            GH: ["h", "H"],
            GI: ["H", "h", "hb", "hB"],
            GL: ["H", "h"],
            GM: ["h", "hb", "H", "hB"],
            GN: ["H", "hB"],
            GP: ["H", "hB"],
            GQ: ["H", "hB", "h", "hb"],
            GR: ["h", "H", "hb", "hB"],
            GS: ["H", "h", "hb", "hB"],
            GT: ["h", "H", "hB", "hb"],
            GU: ["h", "hb", "H", "hB"],
            GW: ["H", "hB"],
            GY: ["h", "hb", "H", "hB"],
            HK: ["h", "hB", "hb", "H"],
            HN: ["h", "H", "hB", "hb"],
            HR: ["H", "hB"],
            HU: ["H", "h"],
            IC: ["H", "h", "hB", "hb"],
            ID: ["H"],
            IE: ["H", "h", "hb", "hB"],
            IL: ["H", "hB"],
            IM: ["H", "h", "hb", "hB"],
            IN: ["h", "H"],
            IO: ["H", "h", "hb", "hB"],
            IQ: ["h", "hB", "hb", "H"],
            IR: ["hB", "H"],
            IS: ["H"],
            IT: ["H", "hB"],
            JE: ["H", "h", "hb", "hB"],
            JM: ["h", "hb", "H", "hB"],
            JO: ["h", "hB", "hb", "H"],
            JP: ["H", "K", "h"],
            KE: ["hB", "hb", "H", "h"],
            KG: ["H", "h", "hB", "hb"],
            KH: ["hB", "h", "H", "hb"],
            KI: ["h", "hb", "H", "hB"],
            KM: ["H", "h", "hB", "hb"],
            KN: ["h", "hb", "H", "hB"],
            KP: ["h", "H", "hB", "hb"],
            KR: ["h", "H", "hB", "hb"],
            KW: ["h", "hB", "hb", "H"],
            KY: ["h", "hb", "H", "hB"],
            KZ: ["H", "hB"],
            LA: ["H", "hb", "hB", "h"],
            LB: ["h", "hB", "hb", "H"],
            LC: ["h", "hb", "H", "hB"],
            LI: ["H", "hB", "h"],
            LK: ["H", "h", "hB", "hb"],
            LR: ["h", "hb", "H", "hB"],
            LS: ["h", "H"],
            LT: ["H", "h", "hb", "hB"],
            LU: ["H", "h", "hB"],
            LV: ["H", "hB", "hb", "h"],
            LY: ["h", "hB", "hb", "H"],
            MA: ["H", "h", "hB", "hb"],
            MC: ["H", "hB"],
            MD: ["H", "hB"],
            ME: ["H", "hB", "h"],
            MF: ["H", "hB"],
            MG: ["H", "h"],
            MH: ["h", "hb", "H", "hB"],
            MK: ["H", "h", "hb", "hB"],
            ML: ["H"],
            MM: ["hB", "hb", "H", "h"],
            MN: ["H", "h", "hb", "hB"],
            MO: ["h", "hB", "hb", "H"],
            MP: ["h", "hb", "H", "hB"],
            MQ: ["H", "hB"],
            MR: ["h", "hB", "hb", "H"],
            MS: ["H", "h", "hb", "hB"],
            MT: ["H", "h"],
            MU: ["H", "h"],
            MV: ["H", "h"],
            MW: ["h", "hb", "H", "hB"],
            MX: ["h", "H", "hB", "hb"],
            MY: ["hb", "hB", "h", "H"],
            MZ: ["H", "hB"],
            NA: ["h", "H", "hB", "hb"],
            NC: ["H", "hB"],
            NE: ["H"],
            NF: ["H", "h", "hb", "hB"],
            NG: ["H", "h", "hb", "hB"],
            NI: ["h", "H", "hB", "hb"],
            NL: ["H", "hB"],
            NO: ["H", "h"],
            NP: ["H", "h", "hB"],
            NR: ["H", "h", "hb", "hB"],
            NU: ["H", "h", "hb", "hB"],
            NZ: ["h", "hb", "H", "hB"],
            OM: ["h", "hB", "hb", "H"],
            PA: ["h", "H", "hB", "hb"],
            PE: ["h", "H", "hB", "hb"],
            PF: ["H", "h", "hB"],
            PG: ["h", "H"],
            PH: ["h", "hB", "hb", "H"],
            PK: ["h", "hB", "H"],
            PL: ["H", "h"],
            PM: ["H", "hB"],
            PN: ["H", "h", "hb", "hB"],
            PR: ["h", "H", "hB", "hb"],
            PS: ["h", "hB", "hb", "H"],
            PT: ["H", "hB"],
            PW: ["h", "H"],
            PY: ["h", "H", "hB", "hb"],
            QA: ["h", "hB", "hb", "H"],
            RE: ["H", "hB"],
            RO: ["H", "hB"],
            RS: ["H", "hB", "h"],
            RU: ["H"],
            RW: ["H", "h"],
            SA: ["h", "hB", "hb", "H"],
            SB: ["h", "hb", "H", "hB"],
            SC: ["H", "h", "hB"],
            SD: ["h", "hB", "hb", "H"],
            SE: ["H"],
            SG: ["h", "hb", "H", "hB"],
            SH: ["H", "h", "hb", "hB"],
            SI: ["H", "hB"],
            SJ: ["H"],
            SK: ["H"],
            SL: ["h", "hb", "H", "hB"],
            SM: ["H", "h", "hB"],
            SN: ["H", "h", "hB"],
            SO: ["h", "H"],
            SR: ["H", "hB"],
            SS: ["h", "hb", "H", "hB"],
            ST: ["H", "hB"],
            SV: ["h", "H", "hB", "hb"],
            SX: ["H", "h", "hb", "hB"],
            SY: ["h", "hB", "hb", "H"],
            SZ: ["h", "hb", "H", "hB"],
            TA: ["H", "h", "hb", "hB"],
            TC: ["h", "hb", "H", "hB"],
            TD: ["h", "H", "hB"],
            TF: ["H", "h", "hB"],
            TG: ["H", "hB"],
            TH: ["H", "h"],
            TJ: ["H", "h"],
            TL: ["H", "hB", "hb", "h"],
            TM: ["H", "h"],
            TN: ["h", "hB", "hb", "H"],
            TO: ["h", "H"],
            TR: ["H", "hB"],
            TT: ["h", "hb", "H", "hB"],
            TW: ["hB", "hb", "h", "H"],
            TZ: ["hB", "hb", "H", "h"],
            UA: ["H", "hB", "h"],
            UG: ["hB", "hb", "H", "h"],
            UM: ["h", "hb", "H", "hB"],
            US: ["h", "hb", "H", "hB"],
            UY: ["h", "H", "hB", "hb"],
            UZ: ["H", "hB", "h"],
            VA: ["H", "h", "hB"],
            VC: ["h", "hb", "H", "hB"],
            VE: ["h", "H", "hB", "hb"],
            VG: ["h", "hb", "H", "hB"],
            VI: ["h", "hb", "H", "hB"],
            VN: ["H", "h"],
            VU: ["h", "H"],
            WF: ["H", "hB"],
            WS: ["h", "H"],
            XK: ["H", "hB", "h"],
            YE: ["h", "hB", "hb", "H"],
            YT: ["H", "hB"],
            ZA: ["H", "h", "hb", "hB"],
            ZM: ["h", "hb", "H", "hB"],
            ZW: ["H", "h"],
            "af-ZA": ["H", "h", "hB", "hb"],
            "ar-001": ["h", "hB", "hb", "H"],
            "ca-ES": ["H", "h", "hB"],
            "en-001": ["h", "hb", "H", "hB"],
            "en-HK": ["h", "hb", "H", "hB"],
            "en-IL": ["H", "h", "hb", "hB"],
            "en-MY": ["h", "hb", "H", "hB"],
            "es-BR": ["H", "h", "hB", "hb"],
            "es-ES": ["H", "h", "hB", "hb"],
            "es-GQ": ["H", "h", "hB", "hb"],
            "fr-CA": ["H", "h", "hB"],
            "gl-ES": ["H", "h", "hB"],
            "gu-IN": ["hB", "hb", "h", "H"],
            "hi-IN": ["hB", "h", "H"],
            "it-CH": ["H", "h", "hB"],
            "it-IT": ["H", "h", "hB"],
            "kn-IN": ["hB", "h", "H"],
            "ku-SY": ["H", "hB"],
            "ml-IN": ["hB", "h", "H"],
            "mr-IN": ["hB", "hb", "h", "H"],
            "pa-IN": ["hB", "hb", "h", "H"],
            "ta-IN": ["hB", "h", "hb", "H"],
            "te-IN": ["hB", "h", "H"],
            "zu-ZA": ["H", "hB", "hb", "h"]
        },
        x = RegExp(`^${O.source}*`),
        Z = RegExp(`${O.source}*$`);

    function Y(e, t) {
        return {
            start: e,
            end: t
        }
    }
    let j = !!Object.fromEntries,
        $ = !!String.prototype.trimStart,
        W = !!String.prototype.trimEnd,
        z = j ? Object.fromEntries : function(e) {
            let t = {};
            for (let [r, i] of e) t[r] = i;
            return t
        },
        q = $ ? function(e) {
            return e.trimStart()
        } : function(e) {
            return e.replace(x, "")
        },
        Q = W ? function(e) {
            return e.trimEnd()
        } : function(e) {
            return e.replace(Z, "")
        },
        J = RegExp("([^\\p{White_Space}\\p{Pattern_Syntax}]*)", "yu");
    class ee {
        message;
        position;
        locale;
        ignoreTag;
        requiresOtherClause;
        shouldParseSkeletons;
        constructor(e, t = {}) {
            this.message = e, this.position = {
                offset: 0,
                line: 1,
                column: 1
            }, this.ignoreTag = !!t.ignoreTag, this.locale = t.locale, this.requiresOtherClause = !!t.requiresOtherClause, this.shouldParseSkeletons = !!t.shouldParseSkeletons
        }
        parse() {
            if (0 !== this.offset()) throw Error("parser can only be used once");
            return this.parseMessage(0, "", !1)
        }
        parseMessage(e, t, r) {
            let i = [];
            for (; !this.isEOF();) {
                let n = this.char();
                if (123 === n) {
                    let t = this.parseArgument(e, r);
                    if (t.err) return t;
                    i.push(t.val)
                } else if (125 === n && e > 0) break;
                else if (35 === n && ("plural" === t || "selectordinal" === t)) {
                    let e = this.clonePosition();
                    this.bump(), i.push({
                        type: A.pound,
                        location: Y(e, this.clonePosition())
                    })
                } else if (60 !== n || this.ignoreTag || 47 !== this.peek())
                    if (60 === n && !this.ignoreTag && et(this.peek() || 0)) {
                        let r = this.parseTag(e, t);
                        if (r.err) return r;
                        i.push(r.val)
                    } else {
                        let r = this.parseLiteral(e, t);
                        if (r.err) return r;
                        i.push(r.val)
                    }
                else if (!r) return this.error(B.UNMATCHED_CLOSING_TAG, Y(this.clonePosition(), this.clonePosition()));
                else break
            }
            return {
                val: i,
                err: null
            }
        }
        parseTag(e, t) {
            let r = this.clonePosition();
            this.bump();
            let i = this.parseTagName();
            if (this.bumpSpace(), this.bumpIf("/>")) return {
                val: {
                    type: A.literal,
                    value: `<${i}/>`,
                    location: Y(r, this.clonePosition())
                },
                err: null
            };
            if (!this.bumpIf(">")) return this.error(B.INVALID_TAG, Y(r, this.clonePosition())); {
                let n = this.parseMessage(e + 1, t, !0);
                if (n.err) return n;
                let s = n.val,
                    o = this.clonePosition();
                if (!this.bumpIf("</")) return this.error(B.UNCLOSED_TAG, Y(r, this.clonePosition())); {
                    if (this.isEOF() || !et(this.char())) return this.error(B.INVALID_TAG, Y(o, this.clonePosition()));
                    let e = this.clonePosition();
                    return i !== this.parseTagName() ? this.error(B.UNMATCHED_CLOSING_TAG, Y(e, this.clonePosition())) : (this.bumpSpace(), this.bumpIf(">")) ? {
                        val: {
                            type: A.tag,
                            value: i,
                            children: s,
                            location: Y(r, this.clonePosition())
                        },
                        err: null
                    } : this.error(B.INVALID_TAG, Y(o, this.clonePosition()))
                }
            }
        }
        parseTagName() {
            var e;
            let t = this.offset();
            for (this.bump(); !this.isEOF() && (45 === (e = this.char()) || 46 === e || e >= 48 && e <= 57 || 95 === e || e >= 97 && e <= 122 || e >= 65 && e <= 90 || 183 == e || e >= 192 && e <= 214 || e >= 216 && e <= 246 || e >= 248 && e <= 893 || e >= 895 && e <= 8191 || e >= 8204 && e <= 8205 || e >= 8255 && e <= 8256 || e >= 8304 && e <= 8591 || e >= 11264 && e <= 12271 || e >= 12289 && e <= 55295 || e >= 63744 && e <= 64975 || e >= 65008 && e <= 65533 || e >= 65536 && e <= 983039);) this.bump();
            return this.message.slice(t, this.offset())
        }
        parseLiteral(e, t) {
            let r = this.clonePosition(),
                i = "";
            for (;;) {
                let r = this.tryParseQuote(t);
                if (r) {
                    i += r;
                    continue
                }
                let n = this.tryParseUnquoted(e, t);
                if (n) {
                    i += n;
                    continue
                }
                let s = this.tryParseLeftAngleBracket();
                if (s) {
                    i += s;
                    continue
                }
                break
            }
            let n = Y(r, this.clonePosition());
            return {
                val: {
                    type: A.literal,
                    value: i,
                    location: n
                },
                err: null
            }
        }
        tryParseLeftAngleBracket() {
            var e;
            return this.isEOF() || 60 !== this.char() || !this.ignoreTag && (et(e = this.peek() || 0) || 47 === e) ? null : (this.bump(), "<")
        }
        tryParseQuote(e) {
            if (this.isEOF() || 39 !== this.char()) return null;
            switch (this.peek()) {
                case 39:
                    return this.bump(), this.bump(), "'";
                case 123:
                case 60:
                case 62:
                case 125:
                    break;
                case 35:
                    if ("plural" === e || "selectordinal" === e) break;
                    return null;
                default:
                    return null
            }
            this.bump();
            let t = [this.char()];
            for (this.bump(); !this.isEOF();) {
                let e = this.char();
                if (39 === e)
                    if (39 === this.peek()) t.push(39), this.bump();
                    else {
                        this.bump();
                        break
                    }
                else t.push(e);
                this.bump()
            }
            return String.fromCodePoint(...t)
        }
        tryParseUnquoted(e, t) {
            if (this.isEOF()) return null;
            let r = this.char();
            return 60 === r || 123 === r || 35 === r && ("plural" === t || "selectordinal" === t) || 125 === r && e > 0 ? null : (this.bump(), String.fromCodePoint(r))
        }
        parseArgument(e, t) {
            let r = this.clonePosition();
            if (this.bump(), this.bumpSpace(), this.isEOF()) return this.error(B.EXPECT_ARGUMENT_CLOSING_BRACE, Y(r, this.clonePosition()));
            if (125 === this.char()) return this.bump(), this.error(B.EMPTY_ARGUMENT, Y(r, this.clonePosition()));
            let i = this.parseIdentifierIfPossible().value;
            if (!i) return this.error(B.MALFORMED_ARGUMENT, Y(r, this.clonePosition()));
            if (this.bumpSpace(), this.isEOF()) return this.error(B.EXPECT_ARGUMENT_CLOSING_BRACE, Y(r, this.clonePosition()));
            switch (this.char()) {
                case 125:
                    return this.bump(), {
                        val: {
                            type: A.argument,
                            value: i,
                            location: Y(r, this.clonePosition())
                        },
                        err: null
                    };
                case 44:
                    if (this.bump(), this.bumpSpace(), this.isEOF()) return this.error(B.EXPECT_ARGUMENT_CLOSING_BRACE, Y(r, this.clonePosition()));
                    return this.parseArgumentOptions(e, t, i, r);
                default:
                    return this.error(B.MALFORMED_ARGUMENT, Y(r, this.clonePosition()))
            }
        }
        parseIdentifierIfPossible() {
            var e;
            let t = this.clonePosition(),
                r = this.offset(),
                i = (e = this.message, J.lastIndex = r, J.exec(e)[1] ? ? ""),
                n = r + i.length;
            return this.bumpTo(n), {
                value: i,
                location: Y(t, this.clonePosition())
            }
        }
        parseArgumentOptions(e, t, r, i) {
            let n = this.clonePosition(),
                s = this.parseIdentifierIfPossible().value,
                o = this.clonePosition();
            switch (s) {
                case "":
                    return this.error(B.EXPECT_ARGUMENT_TYPE, Y(n, o));
                case "number":
                case "date":
                case "time":
                    {
                        this.bumpSpace();
                        let e = null;
                        if (this.bumpIf(",")) {
                            this.bumpSpace();
                            let t = this.clonePosition(),
                                r = this.parseSimpleArgStyleIfPossible();
                            if (r.err) return r;
                            let i = Q(r.val);
                            if (0 === i.length) return this.error(B.EXPECT_ARGUMENT_STYLE, Y(this.clonePosition(), this.clonePosition()));
                            e = {
                                style: i,
                                styleLocation: Y(t, this.clonePosition())
                            }
                        }
                        let t = this.tryParseArgumentClose(i);
                        if (t.err) return t;
                        let n = Y(i, this.clonePosition());
                        if (e && e.style.startsWith("::")) {
                            let t = q(e.style.slice(2));
                            if ("number" === s) {
                                let i = this.parseNumberSkeletonFromString(t, e.styleLocation);
                                if (i.err) return i;
                                return {
                                    val: {
                                        type: A.number,
                                        value: r,
                                        location: n,
                                        style: i.val
                                    },
                                    err: null
                                }
                            } {
                                let i;
                                if (0 === t.length) return this.error(B.EXPECT_DATE_TIME_SKELETON, n);
                                let o = t;
                                this.locale && (o = function(e, t) {
                                    let r = "";
                                    for (let i = 0; i < e.length; i++) {
                                        let n = e.charAt(i);
                                        if ("j" === n) {
                                            let s = 0;
                                            for (; i + 1 < e.length && e.charAt(i + 1) === n;) s++, i++;
                                            let o = 1 + (1 & s),
                                                h = s < 2 ? 1 : 3 + (s >> 1),
                                                a = function(e) {
                                                    let t, r = e.hourCycle;
                                                    if (void 0 === r && e.hourCycles && e.hourCycles.length && (r = e.hourCycles[0]), r) switch (r) {
                                                        case "h24":
                                                            return "k";
                                                        case "h23":
                                                            return "H";
                                                        case "h12":
                                                            return "h";
                                                        case "h11":
                                                            return "K";
                                                        default:
                                                            throw Error("Invalid hourCycle")
                                                    }
                                                    let i = e.language;
                                                    return "root" !== i && (t = e.maximize().region), (X[t || ""] || X[i || ""] || X[`${i}-001`] || X["001"])[0]
                                                }(t);
                                            for (("H" == a || "k" == a) && (h = 0); h-- > 0;) r += "a";
                                            for (; o-- > 0;) r = a + r
                                        } else "J" === n ? r += "H" : r += n
                                    }
                                    return r
                                }(t, this.locale));
                                let h = {
                                    type: y.dateTime,
                                    pattern: o,
                                    location: e.styleLocation,
                                    parsedOptions: this.shouldParseSkeletons ? (i = {}, o.replace(K, e => {
                                        let t = e.length;
                                        switch (e[0]) {
                                            case "G":
                                                i.era = 4 === t ? "long" : 5 === t ? "narrow" : "short";
                                                break;
                                            case "y":
                                                i.year = 2 === t ? "2-digit" : "numeric";
                                                break;
                                            case "Y":
                                            case "u":
                                            case "U":
                                            case "r":
                                                throw RangeError("`Y/u/U/r` (year) patterns are not supported, use `y` instead");
                                            case "q":
                                            case "Q":
                                                throw RangeError("`q/Q` (quarter) patterns are not supported");
                                            case "M":
                                            case "L":
                                                i.month = ["numeric", "2-digit", "short", "long", "narrow"][t - 1];
                                                break;
                                            case "w":
                                            case "W":
                                                throw RangeError("`w/W` (week) patterns are not supported");
                                            case "d":
                                                i.day = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "D":
                                            case "F":
                                            case "g":
                                                throw RangeError("`D/F/g` (day) patterns are not supported, use `d` instead");
                                            case "E":
                                                i.weekday = 4 === t ? "long" : 5 === t ? "narrow" : "short";
                                                break;
                                            case "e":
                                                if (t < 4) throw RangeError("`e..eee` (weekday) patterns are not supported");
                                                i.weekday = ["short", "long", "narrow", "short"][t - 4];
                                                break;
                                            case "c":
                                                if (t < 4) throw RangeError("`c..ccc` (weekday) patterns are not supported");
                                                i.weekday = ["short", "long", "narrow", "short"][t - 4];
                                                break;
                                            case "a":
                                                i.hour12 = !0;
                                                break;
                                            case "b":
                                            case "B":
                                                throw RangeError("`b/B` (period) patterns are not supported, use `a` instead");
                                            case "h":
                                                i.hourCycle = "h12", i.hour = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "H":
                                                i.hourCycle = "h23", i.hour = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "K":
                                                i.hourCycle = "h11", i.hour = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "k":
                                                i.hourCycle = "h24", i.hour = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "j":
                                            case "J":
                                            case "C":
                                                throw RangeError("`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead");
                                            case "m":
                                                i.minute = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "s":
                                                i.second = ["numeric", "2-digit"][t - 1];
                                                break;
                                            case "S":
                                            case "A":
                                                throw RangeError("`S/A` (second) patterns are not supported, use `s` instead");
                                            case "z":
                                                i.timeZoneName = t < 4 ? "short" : "long";
                                                break;
                                            case "Z":
                                            case "O":
                                            case "v":
                                            case "V":
                                            case "X":
                                            case "x":
                                                throw RangeError("`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead")
                                        }
                                        return ""
                                    }), i) : {}
                                };
                                return {
                                    val: {
                                        type: "date" === s ? A.date : A.time,
                                        value: r,
                                        location: n,
                                        style: h
                                    },
                                    err: null
                                }
                            }
                        }
                        return {
                            val: {
                                type: "number" === s ? A.number : "date" === s ? A.date : A.time,
                                value: r,
                                location: n,
                                style: e ? .style ? ? null
                            },
                            err: null
                        }
                    }
                case "plural":
                case "selectordinal":
                case "select":
                    {
                        let n = this.clonePosition();
                        if (this.bumpSpace(), !this.bumpIf(",")) return this.error(B.EXPECT_SELECT_ARGUMENT_OPTIONS, Y(n, { ...n
                        }));this.bumpSpace();
                        let o = this.parseIdentifierIfPossible(),
                            h = 0;
                        if ("select" !== s && "offset" === o.value) {
                            if (!this.bumpIf(":")) return this.error(B.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, Y(this.clonePosition(), this.clonePosition()));
                            this.bumpSpace();
                            let e = this.tryParseDecimalInteger(B.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, B.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);
                            if (e.err) return e;
                            this.bumpSpace(), o = this.parseIdentifierIfPossible(), h = e.val
                        }
                        let a = this.tryParsePluralOrSelectOptions(e, s, t, o);
                        if (a.err) return a;
                        let l = this.tryParseArgumentClose(i);
                        if (l.err) return l;
                        let u = Y(i, this.clonePosition());
                        if ("select" === s) return {
                            val: {
                                type: A.select,
                                value: r,
                                options: z(a.val),
                                location: u
                            },
                            err: null
                        };
                        return {
                            val: {
                                type: A.plural,
                                value: r,
                                options: z(a.val),
                                offset: h,
                                pluralType: "plural" === s ? "cardinal" : "ordinal",
                                location: u
                            },
                            err: null
                        }
                    }
                default:
                    return this.error(B.INVALID_ARGUMENT_TYPE, Y(n, o))
            }
        }
        tryParseArgumentClose(e) {
            return this.isEOF() || 125 !== this.char() ? this.error(B.EXPECT_ARGUMENT_CLOSING_BRACE, Y(e, this.clonePosition())) : (this.bump(), {
                val: !0,
                err: null
            })
        }
        parseSimpleArgStyleIfPossible() {
            let e = 0,
                t = this.clonePosition();
            for (; !this.isEOF();) switch (this.char()) {
                case 39:
                    {
                        this.bump();
                        let e = this.clonePosition();
                        if (!this.bumpUntil("'")) return this.error(B.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, Y(e, this.clonePosition()));this.bump();
                        break
                    }
                case 123:
                    e += 1, this.bump();
                    break;
                case 125:
                    if (!(e > 0)) return {
                        val: this.message.slice(t.offset, this.offset()),
                        err: null
                    };
                    e -= 1;
                    break;
                default:
                    this.bump()
            }
            return {
                val: this.message.slice(t.offset, this.offset()),
                err: null
            }
        }
        parseNumberSkeletonFromString(e, t) {
            let r = [];
            try {
                r = function(e) {
                    if (0 === e.length) throw Error("Number skeleton cannot be empty");
                    let t = e.split(G).filter(e => e.length > 0),
                        r = [];
                    for (let e of t) {
                        let t = e.split("/");
                        if (0 === t.length) throw Error("Invalid number skeleton");
                        let [i, ...n] = t;
                        for (let e of n)
                            if (0 === e.length) throw Error("Invalid number skeleton");
                        r.push({
                            stem: i,
                            options: n
                        })
                    }
                    return r
                }(e)
            } catch {
                return this.error(B.INVALID_NUMBER_SKELETON, t)
            }
            return {
                val: {
                    type: y.number,
                    tokens: r,
                    location: t,
                    parsedOptions: this.shouldParseSkeletons ? function(e) {
                        let t = {};
                        for (let r of e) {
                            switch (r.stem) {
                                case "percent":
                                case "%":
                                    t.style = "percent";
                                    continue;
                                case "%x100":
                                    t.style = "percent", t.scale = 100;
                                    continue;
                                case "currency":
                                    t.style = "currency", t.currency = r.options[0];
                                    continue;
                                case "group-off":
                                case ",_":
                                    t.useGrouping = !1;
                                    continue;
                                case "precision-integer":
                                case ".":
                                    t.maximumFractionDigits = 0;
                                    continue;
                                case "measure-unit":
                                case "unit":
                                    t.style = "unit", t.unit = r.options[0].replace(/^(.*?)-/, "");
                                    continue;
                                case "compact-short":
                                case "K":
                                    t.notation = "compact", t.compactDisplay = "short";
                                    continue;
                                case "compact-long":
                                case "KK":
                                    t.notation = "compact", t.compactDisplay = "long";
                                    continue;
                                case "scientific":
                                    t = { ...t,
                                        notation: "scientific",
                                        ...r.options.reduce((e, t) => ({ ...e,
                                            ...V(t)
                                        }), {})
                                    };
                                    continue;
                                case "engineering":
                                    t = { ...t,
                                        notation: "engineering",
                                        ...r.options.reduce((e, t) => ({ ...e,
                                            ...V(t)
                                        }), {})
                                    };
                                    continue;
                                case "notation-simple":
                                    t.notation = "standard";
                                    continue;
                                case "unit-width-narrow":
                                    t.currencyDisplay = "narrowSymbol", t.unitDisplay = "narrow";
                                    continue;
                                case "unit-width-short":
                                    t.currencyDisplay = "code", t.unitDisplay = "short";
                                    continue;
                                case "unit-width-full-name":
                                    t.currencyDisplay = "name", t.unitDisplay = "long";
                                    continue;
                                case "unit-width-iso-code":
                                    t.currencyDisplay = "symbol";
                                    continue;
                                case "scale":
                                    t.scale = parseFloat(r.options[0]);
                                    continue;
                                case "rounding-mode-floor":
                                    t.roundingMode = "floor";
                                    continue;
                                case "rounding-mode-ceiling":
                                    t.roundingMode = "ceil";
                                    continue;
                                case "rounding-mode-down":
                                    t.roundingMode = "trunc";
                                    continue;
                                case "rounding-mode-up":
                                    t.roundingMode = "expand";
                                    continue;
                                case "rounding-mode-half-even":
                                    t.roundingMode = "halfEven";
                                    continue;
                                case "rounding-mode-half-down":
                                    t.roundingMode = "halfTrunc";
                                    continue;
                                case "rounding-mode-half-up":
                                    t.roundingMode = "halfExpand";
                                    continue;
                                case "integer-width":
                                    if (r.options.length > 1) throw RangeError("integer-width stems only accept a single optional option");
                                    r.options[0].replace(F, function(e, r, i, n, s, o) {
                                        if (r) t.minimumIntegerDigits = i.length;
                                        else if (n && s) throw Error("We currently do not support maximum integer digits");
                                        else if (o) throw Error("We currently do not support exact integer digits");
                                        return ""
                                    });
                                    continue
                            }
                            if (w.test(r.stem)) {
                                t.minimumIntegerDigits = r.stem.length;
                                continue
                            }
                            if (U.test(r.stem)) {
                                if (r.options.length > 1) throw RangeError("Fraction-precision stems only accept a single optional option");
                                r.stem.replace(U, function(e, r, i, n, s, o) {
                                    return "*" === i ? t.minimumFractionDigits = r.length : n && "#" === n[0] ? t.maximumFractionDigits = n.length : s && o ? (t.minimumFractionDigits = s.length, t.maximumFractionDigits = s.length + o.length) : (t.minimumFractionDigits = r.length, t.maximumFractionDigits = r.length), ""
                                });
                                let e = r.options[0];
                                "w" === e ? t = { ...t,
                                    trailingZeroDisplay: "stripIfInteger"
                                } : e && (t = { ...t,
                                    ...D(e)
                                });
                                continue
                            }
                            if (v.test(r.stem)) {
                                t = { ...t,
                                    ...D(r.stem)
                                };
                                continue
                            }
                            let e = k(r.stem);
                            e && (t = { ...t,
                                ...e
                            });
                            let i = function(e) {
                                let t;
                                if ("E" === e[0] && "E" === e[1] ? (t = {
                                        notation: "engineering"
                                    }, e = e.slice(2)) : "E" === e[0] && (t = {
                                        notation: "scientific"
                                    }, e = e.slice(1)), t) {
                                    let r = e.slice(0, 2);
                                    if ("+!" === r ? (t.signDisplay = "always", e = e.slice(2)) : "+?" === r && (t.signDisplay = "exceptZero", e = e.slice(2)), !w.test(e)) throw Error("Malformed concise eng/scientific notation");
                                    t.minimumIntegerDigits = e.length
                                }
                                return t
                            }(r.stem);
                            i && (t = { ...t,
                                ...i
                            })
                        }
                        return t
                    }(r) : {}
                },
                err: null
            }
        }
        tryParsePluralOrSelectOptions(e, t, r, i) {
            let n = !1,
                s = [],
                o = new Set,
                {
                    value: h,
                    location: a
                } = i;
            for (;;) {
                if (0 === h.length) {
                    let e = this.clonePosition();
                    if ("select" !== t && this.bumpIf("=")) {
                        let t = this.tryParseDecimalInteger(B.EXPECT_PLURAL_ARGUMENT_SELECTOR, B.INVALID_PLURAL_ARGUMENT_SELECTOR);
                        if (t.err) return t;
                        a = Y(e, this.clonePosition()), h = this.message.slice(e.offset, this.offset())
                    } else break
                }
                if (o.has(h)) return this.error("select" === t ? B.DUPLICATE_SELECT_ARGUMENT_SELECTOR : B.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, a);
                "other" === h && (n = !0), this.bumpSpace();
                let i = this.clonePosition();
                if (!this.bumpIf("{")) return this.error("select" === t ? B.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT : B.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, Y(this.clonePosition(), this.clonePosition()));
                let l = this.parseMessage(e + 1, t, r);
                if (l.err) return l;
                let u = this.tryParseArgumentClose(i);
                if (u.err) return u;
                s.push([h, {
                    value: l.val,
                    location: Y(i, this.clonePosition())
                }]), o.add(h), this.bumpSpace(), {
                    value: h,
                    location: a
                } = this.parseIdentifierIfPossible()
            }
            return 0 === s.length ? this.error("select" === t ? B.EXPECT_SELECT_ARGUMENT_SELECTOR : B.EXPECT_PLURAL_ARGUMENT_SELECTOR, Y(this.clonePosition(), this.clonePosition())) : this.requiresOtherClause && !n ? this.error(B.MISSING_OTHER_CLAUSE, Y(this.clonePosition(), this.clonePosition())) : {
                val: s,
                err: null
            }
        }
        tryParseDecimalInteger(e, t) {
            let r = 1,
                i = this.clonePosition();
            this.bumpIf("+") || this.bumpIf("-") && (r = -1);
            let n = !1,
                s = 0;
            for (; !this.isEOF();) {
                let e = this.char();
                if (e >= 48 && e <= 57) n = !0, s = 10 * s + (e - 48), this.bump();
                else break
            }
            let o = Y(i, this.clonePosition());
            return n ? Number.isSafeInteger(s *= r) ? {
                val: s,
                err: null
            } : this.error(t, o) : this.error(e, o)
        }
        offset() {
            return this.position.offset
        }
        isEOF() {
            return this.offset() === this.message.length
        }
        clonePosition() {
            return {
                offset: this.position.offset,
                line: this.position.line,
                column: this.position.column
            }
        }
        char() {
            let e = this.position.offset;
            if (e >= this.message.length) throw Error("out of bound");
            let t = this.message.codePointAt(e);
            if (void 0 === t) throw Error(`Offset ${e} is at invalid UTF-16 code unit boundary`);
            return t
        }
        error(e, t) {
            return {
                val: null,
                err: {
                    kind: e,
                    message: this.message,
                    location: t
                }
            }
        }
        bump() {
            if (this.isEOF()) return;
            let e = this.char();
            10 === e ? (this.position.line += 1, this.position.column = 1, this.position.offset += 1) : (this.position.column += 1, this.position.offset += e < 65536 ? 1 : 2)
        }
        bumpIf(e) {
            if (this.message.startsWith(e, this.offset())) {
                for (let t = 0; t < e.length; t++) this.bump();
                return !0
            }
            return !1
        }
        bumpUntil(e) {
            let t = this.offset(),
                r = this.message.indexOf(e, t);
            return r >= 0 ? (this.bumpTo(r), !0) : (this.bumpTo(this.message.length), !1)
        }
        bumpTo(e) {
            if (this.offset() > e) throw Error(`targetOffset ${e} must be greater than or equal to the current offset ${this.offset()}`);
            for (e = Math.min(e, this.message.length);;) {
                let t = this.offset();
                if (t === e) break;
                if (t > e) throw Error(`targetOffset ${e} is at invalid UTF-16 code unit boundary`);
                if (this.bump(), this.isEOF()) break
            }
        }
        bumpSpace() {
            for (var e; !this.isEOF() && ((e = this.char()) >= 9 && e <= 13 || 32 === e || 133 === e || e >= 8206 && e <= 8207 || 8232 === e || 8233 === e);) this.bump()
        }
        peek() {
            if (this.isEOF()) return null;
            let e = this.char(),
                t = this.offset();
            return this.message.charCodeAt(t + (e >= 65536 ? 2 : 1)) ? ? null
        }
    }

    function et(e) {
        return e >= 97 && e <= 122 || e >= 65 && e <= 90
    }

    function er(e, t = {}) {
        let r = new ee(e, t = {
            shouldParseSkeletons: !0,
            requiresOtherClause: !0,
            ...t
        }).parse();
        if (r.err) {
            let e = SyntaxError(B[r.err.kind]);
            throw e.location = r.err.location, e.originalMessage = r.err.message, e
        }
        return t ? .captureLocation || function e(t) {
            t.forEach(t => {
                if (delete t.location, L(t) || M(t))
                    for (let r in t.options) delete t.options[r].location, e(t.options[r].value);
                else N(t) && R(t.style) || (S(t) || I(t)) && C(t.style) ? delete t.style.location : P(t) && e(t.children)
            })
        }(r.val), r.val
    }
    let ei = ((s = {}).MISSING_VALUE = "MISSING_VALUE", s.INVALID_VALUE = "INVALID_VALUE", s.MISSING_INTL_API = "MISSING_INTL_API", s);
    class en extends Error {
        code;
        originalMessage;
        constructor(e, t, r) {
            super(e), this.code = t, this.originalMessage = r
        }
        toString() {
            return `[formatjs Error: ${this.code}] ${this.message}`
        }
    }
    class es extends en {
        constructor(e, t, r, i) {
            super(`Invalid values for "${e}": "${t}". Options are "${Object.keys(r).join('", "')}"`, ei.INVALID_VALUE, i)
        }
    }
    class eo extends en {
        constructor(e, t, r) {
            super(`Value for "${e}" must be of type ${t}`, ei.INVALID_VALUE, r)
        }
    }
    class eh extends en {
        constructor(e, t) {
            super(`The intl string context variable "${e}" was not provided to the string "${t}"`, ei.MISSING_VALUE, t)
        }
    }
    let ea = ((o = {})[o.literal = 0] = "literal", o[o.object = 1] = "object", o);

    function el(e) {
        return {
            create: () => ({
                get: t => e[t],
                set(t, r) {
                    e[t] = r
                }
            })
        }
    }
    class eu {
        ast;
        locales;
        resolvedLocale;
        formatters;
        formats;
        message;
        formatterCache = {
            number: {},
            dateTime: {},
            pluralRules: {}
        };
        constructor(e, t = eu.defaultLocale, r, i) {
            if (this.locales = t, this.resolvedLocale = eu.resolveLocale(t), "string" == typeof e) {
                if (this.message = e, !eu.__parse) throw TypeError("IntlMessageFormat.__parse must be set to process `message` of type `string`");
                const { ...t
                } = i || {};
                this.ast = eu.__parse(e, { ...t,
                    locale: this.resolvedLocale
                })
            } else this.ast = e;
            if (!Array.isArray(this.ast)) throw TypeError("A message must be provided as a String or AST.");
            this.formats = function(e, t) {
                return t ? Object.keys(e).reduce((r, i) => {
                    var n, s;
                    return r[i] = (n = e[i], (s = t[i]) ? { ...n,
                        ...s,
                        ...Object.keys(n).reduce((e, t) => (e[t] = { ...n[t],
                            ...s[t]
                        }, e), {})
                    } : n), r
                }, { ...e
                }) : e
            }(eu.formats, r), this.formatters = i && i.formatters || function(e = {
                number: {},
                dateTime: {},
                pluralRules: {}
            }) {
                return {
                    getNumberFormat: a((...e) => new Intl.NumberFormat(...e), {
                        cache: el(e.number),
                        strategy: E.variadic
                    }),
                    getDateTimeFormat: a((...e) => new Intl.DateTimeFormat(...e), {
                        cache: el(e.dateTime),
                        strategy: E.variadic
                    }),
                    getPluralRules: a((...e) => new Intl.PluralRules(...e), {
                        cache: el(e.pluralRules),
                        strategy: E.variadic
                    })
                }
            }(this.formatterCache)
        }
        format = e => {
            let t = this.formatToParts(e);
            if (1 === t.length) return t[0].value;
            let r = t.reduce((e, t) => (e.length && t.type === ea.literal && "string" == typeof e[e.length - 1] ? e[e.length - 1] += t.value : e.push(t.value), e), []);
            return r.length <= 1 ? r[0] || "" : r
        };
        formatToParts = e => (function e(t, r, i, n, s, o, h) {
            if (1 === t.length && _(t[0])) return [{
                type: ea.literal,
                value: t[0].value
            }];
            let a = [];
            for (let l of t) {
                if (_(l)) {
                    a.push({
                        type: ea.literal,
                        value: l.value
                    });
                    continue
                }
                if (l.type === A.pound) {
                    "number" == typeof o && a.push({
                        type: ea.literal,
                        value: i.getNumberFormat(r).format(o)
                    });
                    continue
                }
                let {
                    value: t
                } = l;
                if (!(s && t in s)) throw new eh(t, h);
                let u = s[t];
                if (l.type === A.argument) {
                    u && "string" != typeof u && "number" != typeof u && "bigint" != typeof u || (u = "string" == typeof u || "number" == typeof u || "bigint" == typeof u ? String(u) : ""), a.push({
                        type: "string" == typeof u ? ea.literal : ea.object,
                        value: u
                    });
                    continue
                }
                if (S(l)) {
                    let e = "string" == typeof l.style ? n.date[l.style] : C(l.style) ? l.style.parsedOptions : void 0;
                    a.push({
                        type: ea.literal,
                        value: i.getDateTimeFormat(r, e).format(u)
                    });
                    continue
                }
                if (I(l)) {
                    let e = "string" == typeof l.style ? n.time[l.style] : C(l.style) ? l.style.parsedOptions : n.time.medium;
                    a.push({
                        type: ea.literal,
                        value: i.getDateTimeFormat(r, e).format(u)
                    });
                    continue
                }
                if (N(l)) {
                    let e = "string" == typeof l.style ? n.number[l.style] : R(l.style) ? l.style.parsedOptions : void 0;
                    if (e && e.scale) {
                        let t = e.scale || 1;
                        if ("bigint" == typeof u) {
                            if (!Number.isInteger(t)) throw TypeError(`Cannot apply fractional scale ${t} to bigint value. Scale must be an integer when formatting bigint.`);
                            u *= BigInt(t)
                        } else u *= t
                    }
                    a.push({
                        type: ea.literal,
                        value: i.getNumberFormat(r, e).format(u)
                    });
                    continue
                }
                if (P(l)) {
                    let {
                        children: t,
                        value: u
                    } = l, c = s[u];
                    if ("function" != typeof c) throw new eo(u, "function", h);
                    let m = c(e(t, r, i, n, s, o).map(e => e.value));
                    Array.isArray(m) || (m = [m]), a.push(...m.map(e => ({
                        type: "string" == typeof e ? ea.literal : ea.object,
                        value: e
                    })))
                }
                if (L(l)) {
                    let t = u,
                        o = (Object.prototype.hasOwnProperty.call(l.options, t) ? l.options[t] : void 0) || l.options.other;
                    if (!o) throw new es(l.value, u, Object.keys(l.options), h);
                    a.push(...e(o.value, r, i, n, s));
                    continue
                }
                if (M(l)) {
                    let t = `=${u}`,
                        o = Object.prototype.hasOwnProperty.call(l.options, t) ? l.options[t] : void 0;
                    if (!o) {
                        if (!Intl.PluralRules) throw new en(`Intl.PluralRules is not available in this environment.
Try polyfilling it using "@formatjs/intl-pluralrules"
`, ei.MISSING_INTL_API, h);
                        let e = "bigint" == typeof u ? Number(u) : u,
                            t = i.getPluralRules(r, {
                                type: l.pluralType
                            }).select(e - (l.offset || 0));
                        o = (Object.prototype.hasOwnProperty.call(l.options, t) ? l.options[t] : void 0) || l.options.other
                    }
                    if (!o) throw new es(l.value, u, Object.keys(l.options), h);
                    let c = "bigint" == typeof u ? Number(u) : u;
                    a.push(...e(o.value, r, i, n, s, c - (l.offset || 0)));
                    continue
                }
            }
            return a.length < 2 ? a : a.reduce((e, t) => {
                let r = e[e.length - 1];
                return r && r.type === ea.literal && t.type === ea.literal ? r.value += t.value : e.push(t), e
            }, [])
        })(this.ast, this.locales, this.formatters, this.formats, e, void 0, this.message);
        resolvedOptions = () => ({
            locale: this.resolvedLocale ? .toString() || Intl.NumberFormat.supportedLocalesOf(this.locales)[0]
        });
        getAst = () => this.ast;
        static memoizedDefaultLocale = null;
        static get defaultLocale() {
            return eu.memoizedDefaultLocale || (eu.memoizedDefaultLocale = new Intl.NumberFormat().resolvedOptions().locale), eu.memoizedDefaultLocale
        }
        static resolveLocale = e => {
            if (void 0 === Intl.Locale) return;
            let t = Intl.NumberFormat.supportedLocalesOf(e);
            return new Intl.Locale(t.length > 0 ? t[0] : "string" == typeof e ? e : e[0])
        };
        static __parse = er;
        static formats = {
            number: {
                integer: {
                    maximumFractionDigits: 0
                },
                currency: {
                    style: "currency"
                },
                percent: {
                    style: "percent"
                }
            },
            date: {
                short: {
                    month: "numeric",
                    day: "numeric",
                    year: "2-digit"
                },
                medium: {
                    month: "short",
                    day: "numeric",
                    year: "numeric"
                },
                long: {
                    month: "long",
                    day: "numeric",
                    year: "numeric"
                },
                full: {
                    weekday: "long",
                    month: "long",
                    day: "numeric",
                    year: "numeric"
                }
            },
            time: {
                short: {
                    hour: "numeric",
                    minute: "numeric"
                },
                medium: {
                    hour: "numeric",
                    minute: "numeric",
                    second: "numeric"
                },
                long: {
                    hour: "numeric",
                    minute: "numeric",
                    second: "numeric",
                    timeZoneName: "short"
                },
                full: {
                    hour: "numeric",
                    minute: "numeric",
                    second: "numeric",
                    timeZoneName: "short"
                }
            }
        }
    }

    function ec(...[e, t, r, i]) {
        let n;
        if (Array.isArray(t)) throw new p(g.INVALID_MESSAGE, void 0);
        if ("object" == typeof t) throw new p(g.INSUFFICIENT_PATH, void 0);
        if ("string" == typeof t) {
            let e = r || /'[{}]/.test(t) ? void 0 : t;
            if (e) return e
        }
        let {
            cache: s,
            formats: o,
            formatters: a,
            globalFormats: l,
            locale: u,
            timeZone: c
        } = i;
        a.getMessageFormat || (a.getMessageFormat = T((...e) => new eu(e[0], e[1], e[2], {
            formatters: a,
            ...e[3]
        }), s.message));
        try {
            let e, r, i, s;
            n = a.getMessageFormat(t, u, (e = eu.formats.date, r = eu.formats.time, i = { ...l ? .dateTime,
                ...o ? .dateTime
            }, s = {
                date: { ...e,
                    ...i
                },
                time: { ...r,
                    ...i
                },
                number: { ...l ? .number,
                    ...o ? .number
                }
            }, c && ["date", "time"].forEach(e => {
                let t = s[e];
                for (let [e, r] of Object.entries(t)) t[e] = {
                    timeZone: c,
                    ...r
                }
            }), s), {
                formatters: { ...a,
                    getDateTimeFormat: (e, t) => a.getDateTimeFormat(e, { ...t,
                        timeZone: t ? .timeZone ? ? c
                    })
                }
            })
        } catch (e) {
            throw new p(g.INVALID_MESSAGE, void 0)
        }
        let m = n.format(r);
        return (0, h.isValidElement)(m) || Array.isArray(m) || "string" == typeof m ? m : String(m)
    }

    function em(...e) {
        return e.filter(Boolean).join(".")
    }

    function ef(e) {
        return em(e.namespace, e.key)
    }

    function eE(e) {
        console.error(e)
    }

    function ep(e, t, r, i) {
        let n = em(i, r);
        if (!t) throw Error(n);
        let s = t;
        return r.split(".").forEach(t => {
            let r = s[t];
            if (null == t || null == r) throw Error(n + ` (${e})`);
            s = r
        }), s
    }
    ec.raw = !0;
    let eg = {
        second: 1,
        seconds: 1,
        minute: 60,
        minutes: 60,
        hour: 3600,
        hours: 3600,
        day: 86400,
        days: 86400,
        week: 604800,
        weeks: 604800,
        month: 2628e3,
        months: 2628e3,
        quarter: 7884e3,
        quarters: 7884e3,
        year: 31536e3,
        years: 31536e3
    };
    var eb = e.i(221628);
    let eT = (0, h.createContext)(void 0);

    function eH() {
        let e = (0, h.useContext)(eT);
        if (!e) throw Error(void 0);
        return e
    }
    let ed = !1,
        eB = "u" < typeof window;
    e.s(["IntlProvider", 0, function({
        children: e,
        formats: t,
        getMessageFallback: r,
        locale: i,
        messages: n,
        now: s,
        onError: o,
        timeZone: a
    }) {
        let l = (0, h.useContext)(eT),
            u = (0, h.useMemo)(() => l ? .cache || b(), [i, l ? .cache]),
            c = (0, h.useMemo)(() => l ? .formatters || d(u), [u, l ? .formatters]),
            m = (0, h.useMemo)(() => ({ ... function({
                    formats: e,
                    getMessageFallback: t,
                    messages: r,
                    onError: i,
                    ...n
                }) {
                    return { ...n,
                        formats: e || void 0,
                        messages: r || void 0,
                        onError: i || eE,
                        getMessageFallback: t || ef
                    }
                }({
                    locale: i,
                    formats: void 0 === t ? l ? .formats : t,
                    getMessageFallback: r || l ? .getMessageFallback,
                    messages: void 0 === n ? l ? .messages : n,
                    now: s || l ? .now,
                    onError: o || l ? .onError,
                    timeZone: a || l ? .timeZone
                }),
                formatters: c,
                cache: u
            }), [u, t, c, r, i, n, s, o, l, a]);
        return (0, eb.jsx)(eT.Provider, {
            value: m,
            children: e
        })
    }, "useFormatter", 0, function() {
        let {
            formats: e,
            formatters: t,
            locale: r,
            now: i,
            onError: n,
            timeZone: s
        } = eH();
        return (0, h.useMemo)(() => (function(e) {
            let {
                _cache: t = b(),
                _formatters: r = d(t),
                formats: i,
                locale: n,
                onError: s = eE,
                timeZone: o
            } = e;

            function h(e) {
                return e ? .timeZone || (o ? e = { ...e,
                    timeZone: o
                } : s(new p(g.ENVIRONMENT_FALLBACK, void 0))), e
            }

            function a(e, t, r, i, n) {
                let o;
                try {
                    o = function(e, t, r) {
                        let i;
                        if ("string" == typeof t) {
                            if (!(i = e ? .[t])) {
                                let e = new p(g.MISSING_FORMAT, void 0);
                                throw s(e), e
                            }
                        } else i = t;
                        return r && (i = { ...i,
                            ...r
                        }), i
                    }(r, e, t)
                } catch {
                    return n()
                }
                try {
                    return i(o)
                } catch (e) {
                    return s(new p(g.FORMATTING_ERROR, e.message)), n()
                }
            }

            function l(e, t, s) {
                return a(t, s, i ? .dateTime, t => (t = h(t), r.getDateTimeFormat(n, t).format(e)), () => String(e))
            }

            function u() {
                return e.now ? e.now : (s(new p(g.ENVIRONMENT_FALLBACK, void 0)), new Date)
            }
            return {
                dateTime: l,
                number: function(e, t, s) {
                    return a(t, s, i ? .number, t => r.getNumberFormat(n, t).format(e), () => String(e))
                },
                relativeTime: function(e, t) {
                    try {
                        var i;
                        let s, o, h, a = {};
                        t instanceof Date || "number" == typeof t ? s = new Date(t) : t && (s = null != t.now ? new Date(t.now) : u(), o = t.unit, a.style = t.style, a.numberingSystem = t.numberingSystem), s || (s = u());
                        let l = (new Date(e).getTime() - s.getTime()) / 1e3;
                        o || (o = (h = Math.abs(l)) < 60 ? "second" : h < 3600 ? "minute" : h < 86400 ? "hour" : h < 604800 ? "day" : h < 2628e3 ? "week" : h < 31536e3 ? "month" : "year"), a.numeric = "second" === o ? "auto" : "always";
                        let c = (i = o, Math.round(l / eg[i]));
                        return r.getRelativeTimeFormat(n, a).format(c, o)
                    } catch (t) {
                        return s(new p(g.FORMATTING_ERROR, t.message)), String(e)
                    }
                },
                list: function(e, t, s) {
                    let o = [],
                        h = new Map,
                        l = 0;
                    for (let t of e) {
                        let e;
                        "object" == typeof t ? (e = String(l), h.set(e, t)) : e = String(t), o.push(e), l++
                    }
                    return a(t, s, i ? .list, e => {
                        let t = r.getListFormat(n, e).formatToParts(o).map(e => "literal" === e.type ? e.value : h.get(e.value) || e.value);
                        return h.size > 0 ? t : t.join("")
                    }, () => String(e))
                },
                dateTimeRange: function(e, t, s, o) {
                    return a(s, o, i ? .dateTime, i => (i = h(i), r.getDateTimeFormat(n, i).formatRange(e, t)), () => [l(e), l(t)].join(" – "))
                },
                displayName: function(e, t, s) {
                    return a(t, s, i ? .displayName, t => r.getDisplayNames(n, t).of(e), () => e)
                }
            }
        })({
            formats: e,
            locale: r,
            now: i,
            onError: n,
            timeZone: s,
            _formatters: t
        }), [e, t, i, r, n, s])
    }, "useLocale", 0, function() {
        return eH().locale
    }, "useMessages", 0, function() {
        let e = eH();
        if (!e.messages) throw Error(void 0);
        return e.messages
    }, "useTranslations", 0, function(e) {
        return function(e, t) {
            let {
                cache: r,
                formats: i,
                formatters: n,
                getMessageFallback: s,
                locale: o,
                onError: a,
                timeZone: l
            } = eH(), u = e["!"], c = "!" === t ? void 0 : t.slice(2);
            return l || ed || !eB || (ed = !0, a(new p(g.ENVIRONMENT_FALLBACK, void 0))), (0, h.useMemo)(() => {
                var e;
                let t;
                return t = function(e, t, r) {
                        try {
                            if (!t) throw Error(void 0);
                            let i = r ? ep(e, t, r) : t;
                            if (!i) throw Error(r);
                            return i
                        } catch (e) {
                            return new p(g.MISSING_MESSAGE, e.message)
                        }
                    }((e = {
                        cache: r,
                        formatters: n,
                        getMessageFallback: s,
                        messages: u,
                        namespace: c,
                        onError: a,
                        formats: i,
                        locale: o,
                        timeZone: l
                    }).locale, e.messages, e.namespace),
                    function({
                        cache: e,
                        formats: t,
                        formatters: r,
                        getMessageFallback: i = ef,
                        locale: n,
                        messagesOrError: s,
                        namespace: o,
                        onError: a,
                        timeZone: l
                    }) {
                        let u = s instanceof p;

                        function c(e, t, r, n) {
                            let s = new p(t, r);
                            return a(s), n ? ? i({
                                error: s,
                                key: e,
                                namespace: o
                            })
                        }

                        function m(m, f, E, b) {
                            let T;
                            if (u) {
                                if (!b) return a(s), i({
                                    error: s,
                                    key: m,
                                    namespace: o
                                });
                                T = b
                            } else try {
                                T = ep(n, s, m, o)
                            } catch (e) {
                                if (!b) return c(m, g.MISSING_MESSAGE, e.message, b);
                                T = b
                            }
                            try {
                                let i, s = em(o, m);
                                return ec(s, T, f ? (i = {}, Object.keys(f).forEach(e => {
                                    let t, r = 0,
                                        n = f[e];
                                    t = "function" == typeof n ? t => {
                                        let i = n(t);
                                        return (0, h.isValidElement)(i) ? (0, h.cloneElement)(i, {
                                            key: e + r++
                                        }) : i
                                    } : n, i[e] = t
                                }), i) : f, {
                                    cache: e,
                                    formatters: r,
                                    globalFormats: t,
                                    formats: E,
                                    locale: n,
                                    timeZone: l
                                })
                            } catch (r) {
                                let e, t;
                                return r instanceof p ? (e = r.code, t = r.originalMessage) : (e = g.FORMATTING_ERROR, t = r.message), c(m, e, t, b)
                            }
                        }

                        function f(e, t, r, i) {
                            let n = m(e, t, r, i);
                            return "string" != typeof n ? c(e, g.INVALID_MESSAGE, void 0) : n
                        }
                        return f.rich = m, f.markup = (e, t, r, i) => m(e, t, r, i), f.raw = e => {
                            if (u) return a(s), i({
                                error: s,
                                key: e,
                                namespace: o
                            });
                            try {
                                return ep(n, s, e, o)
                            } catch (t) {
                                return c(e, g.MISSING_MESSAGE, t.message)
                            }
                        }, f.has = e => {
                            if (u) return !1;
                            try {
                                return ep(n, s, e, o), !0
                            } catch {
                                return !1
                            }
                        }, f
                    }({ ...e,
                        messagesOrError: t
                    })
            }, [r, n, s, u, c, a, i, o, l])
        }({
            "!": eH().messages
        }, e ? `!.${e}` : "!")
    }], 864006)
}]);

//# debugId=9bdca6b4-5015-17b0-bbc8-9451f7325ed1